Documentation – עבודה עם לקוח Exchange EWS

Java: התחברות ל‑Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

כדי להתחבר ל‑Exchange servers 2007, 2010 ו‑2013 באמצעות Exchange Web Service, Aspose.Email מספקת את IEWSClient ממשק שמממש את EWSClient מחלקה. ה- EWSClient.getEWSClient השיטה מאתחלת ומחזירה IEWSClient אובייקט המשמש להמשך ביצוע פעולות הקשורות לתיבת דואר Exchange ותיקיות נוספות. מאמר זה מציג כיצד לאתחל אובייקטים של IEWSClient.

התחברות ל‑Exchange Server באמצעות EWS

קוד הדוגמה הבא מראה כיצד להתחבר באמצעות Exchange Web Service (EWS).

private static IEWSClient getExchangeEWSClient() {
    final String mailboxUri = "https://outlook.office365.com/ews/exchange.asmx";
    final String domain = "";
    final String username = "username@onmicrosoft.com";
    final String password = "password";
    NetworkCredential credentials = new NetworkCredential(username, password, domain);
    IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);
    return client;
}

התחברות ל‑Exchange Server באמצעות IMAP

Microsoft Exchange Server תומך בפרוטוקול IMAP לגישה לפריטים בתיבת דואר. השתמש ב‑Aspose.Email של ImapClient מחלקה להתחברות ל‑Exchange Server באמצעות פרוטוקול IMAP. למידע נוסף על ה‑ ImapClient מחלקה. ראשית, ודא ששירותי IMAP מופעלים ב‑Exchange Server שלך:

פתח את לוח הבקרה.
גש לכלי הניהול, ואז לשירותים.
בדוק את מצב שירות Microsoft Exchange IMAP4.
אם הוא עדיין אינו פועל, אפשר/הפעל אותו.

קוד הדוגמה הבא מראה כיצד להתחבר ולרשום הודעות מתיקיית ה‑Inbox של Microsoft Exchange Server באמצעות פרוטוקול IMAP.

// Connect to Exchange Server using ImapClient class
ImapClient imapClient = new ImapClient("ex07sp1", "Administrator", "Evaluation1");
imapClient.setSecurityOptions(SecurityOptions.Auto);

// Select the Inbox folder
imapClient.selectFolder(ImapFolderInfo.IN_BOX);

// Get the list of messages
ImapMessageInfoCollection msgCollection = imapClient.listMessages();
for (ImapMessageInfo msgInfo : (Iterable<ImapMessageInfo>) msgCollection) {
    System.out.println(msgInfo.getSubject());
}
// Disconnect from the server
imapClient.dispose();

קוד הדוגמה הזה מראה כיצד להשתמש ב‑SSL.

public static void run() {
    // Connect to Exchange Server using ImapClient class
    ImapClient imapClient = new ImapClient("ex07sp1", 993, "Administrator", "Evaluation1");
    imapClient.setSecurityOptions(SecurityOptions.SSLExplicit);

    // Select the Inbox folder
    imapClient.selectFolder(ImapFolderInfo.IN_BOX);

    // Get the list of messages
    ImapMessageInfoCollection msgCollection = imapClient.listMessages();
    for (ImapMessageInfo msgInfo : (Iterable<ImapMessageInfo>) msgCollection) {
        System.out.println(msgInfo.getSubject());
    }
    // Disconnect from the server
    imapClient.dispose();
}

לאחר התחברות ל‑Exchange server באמצעות IMAP וקבלת ה‑ IMapMessageInfoCollection, קטע הקוד הבא מראה כיצד להשתמש ב‑ MessageInfo מספר הרצף של האובייקט לשמירת הודעה מסוימת.

// Select the Inbox folder
imapClient.selectFolder(ImapFolderInfo.IN_BOX);
// Get the list of messages
ImapMessageInfoCollection msgCollection = imapClient.listMessages();
for (ImapMessageInfo msgInfo : (Iterable<ImapMessageInfo>) msgCollection) {
    // Fetch the message from inbox using its SequenceNumber from msgInfo
    MailMessage message = imapClient.fetchMessage(msgInfo.getSequenceNumber());

    // Save the message to disc now
    message.save(dataDir + msgInfo.getSequenceNumber() + "_out.msg", SaveOptions.getDefaultMsgUnicode());
}

Java: עבודה עם תיבת דואר Exchange והודעות - קריאת אימייל מ-Exchange Server ב-Java

Mon, 01 Jan 0001 00:00:00 +0000

קבלת מידע תיבת דואר באמצעות EWS

ה EWSClient המחלקה כוללת חברים שניתן להשתמש בהם לקבל מידע על תיבת דואר מ‑Exchange Server על ידי קריאה ל‑ IEWSClient.getMailboxInfo() מתודה. היא מחזירה מופע מסוג ExchangeMailboxInfo. קבל מידע על תיבת הדואר מתכונות כגון MailboxUri, InboxUri ו DraftsUri. מאמר זה מציג כיצד לגשת למידע תיבת דואר באמצעות Exchange Web Services.

אם ברצונך להתחבר ל‑Exchange Server באמצעות Exchange Web Services (EWS), השתמש ב‑ EWSClient class. מחלקה זו משתמשת ב‑EWS להתחבר ולנהל פריטים ב‑Exchange Server. קטע קוד Java הבא מראה כיצד לקבל מידע על תיבת הדואר באמצעות Exchange Web Services.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Get mailbox size, exchange mailbox info, Mailbox and Inbox folder URI
System.out.println("Mailbox size: " + client.getMailboxSize() + " bytes");
ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo();
System.out.println("Mailbox URI: " + mailboxInfo.getMailboxUri());
System.out.println("Inbox folder URI: " + mailboxInfo.getInboxUri());
System.out.println("Sent Items URI: " + mailboxInfo.getSentItemsUri());
System.out.println("Drafts folder URI: " + mailboxInfo.getDraftsUri());

שליחת הודעות אימייל

ניתן לשלוח הודעות אימייל באמצעות שרת Exchange בעזרת הכלים ב Aspose.Email.Exchange. המתודה IEWSClient.Send() מקבלת MailMessage מופע כפרמטר ושולח את האימייל. מאמר זה מסביר כיצד לשלוח הודעות אימייל באמצעות Exchange Web Services.

Aspose.Email מספקת את המחלקה IEWSClient לחיבור ל‑Microsoft Exchange Server באמצעות Exchange Web Services. קטע הקוד הבא מציג כיצד להשתמש ב‑EWS לשליחת אימיילים באמצעות Microsoft Exchange Server. קטע קוד Java הבא מציג כיצד לשלוח הודעות אימייל באמצעות EWS.

// Create instance of IEWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Create instance of type MailMessage
MailMessage msg = new MailMessage();
msg.setFrom(MailAddress.to_MailAddress("sender@domain.com"));
msg.setTo(MailAddressCollection.to_MailAddressCollection("recipient@ domain.com "));
msg.setSubject("Sending message from exchange server");
msg.setHtmlBody("<h3>sending message from exchange server</h3>");

// Send the message
client.send(msg);

קבלת מחלקת הודעה

ה getMessageClass() שיטה של ExchangeMessageInfo class מקבל מחרוזת המייצגת את המחלקה של ההודעה. דוגמת הקוד למטה מציגה כיצד לקבל את מחלקת ההודעה:

try (IEWSClient client = EWSClient.getEWSClient(uri, credentials))
{
    ExchangeMessageInfoCollection messageInfoCollection = client.listMessagesFromPublicFolder(publicFolder);

    for (ExchangeMessageInfo messageInfo : messageInfoCollection)
    {
        System.out.println("Message Class: " + messageInfo.getMessageClass());
    }
}

קריאת אימיילים מתיבת הדואר של משתמש אחר

חלק מהחשבונות בשרתי Exchange כוללים גישה למספר תיבות דואר, ולחלק מהמשתמשים יש כמה חשבונות אימייל באותו שרת Exchange. בשני המקרים, משתמשים יכולים לגשת לתיבות הדואר של משתמשים אחרים באמצעות Aspose.Email for Java. API זה מספק מנגנון לגישה לתיקיות ולאימיילים מתיבות דואר אחרות בעזרת IEWSClient class. פונקציונליות זו ניתנת להשגה באמצעות המומצאת getMailboxInfo() מתודה ולספק את כתובת האימייל של המשתמש כפרמטר.

קטע הקוד הבא מציג כיצד לקרוא אימיילים באמצעות IEWSClient מחלקה.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Get Exchange mailbox info of other email account
ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo("otherUser@domain.com");

רשימת הודעות

ניתן לקבל רשימת הודעות אימייל בתיבת דואר של Exchange על ידי קריאה ל‑ IEWSClient.listMessages מתודה. קבל מידע בסיסי על הודעות, כגון נושא, ממן, אל ומזהה הודעה, באמצעות listMessages שיטה.

רשימה פשוטה של הודעות

כדי לרשום את ההודעות בתיבת דואר Exchange:

צור מופע של IEWSClient מחלקה.
קרא למתודה listMessages וצור אוסף הודעות.
עבור על האוסף והצג מידע על ההודעה.

קטע קוד Java הבא מראה איך להתחבר לשרת Exchange באמצעות EWS ולרשום הודעות מתיקיית inbox.

// Create instance of ExchangeWebServiceClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "UserName", "Password");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

// Loop through the collection to display the basic information
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgCollection) {
    System.out.println("Subject: " + msgInfo.getSubject());
    System.out.println("From: " + msgInfo.getFrom().toString());
    System.out.println("To: " + msgInfo.getTo().toString());
    System.out.println("Message ID: " + msgInfo.getMessageId());
    System.out.println("Unique URI: " + msgInfo.getUniqueUri());
}

רשימת הודעות מתיקיות שונות

קטעי הקוד שלמעלה, רשום את כל ההודעות בתיקיית Inbox. אפשר גם לקבל את רשימת ההודעות מתיקיות אחרות. ה‑ IEWSClient.listMessages() מתודה מקבלת URI של תיקייה כפרמטר. כל עוד ה‑URI תקין, אפשר לקבל את רשימת ההודעות מתיקייה זו. השתמש במאפיין IEWSClient.getMailboxInfo().getXXXFolderUri כדי לקבל את ה‑URI של תיקיות שונות. שאר הקוד זהה לקבלת רשימת הודעות. קטע הקוד הבא מציג כיצד לרשום הודעות מתיקיות שונות באמצעות EWS.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Get folder URI
String strFolderURI = "";
strFolderURI = client.getMailboxInfo().getInboxUri();
strFolderURI = client.getMailboxInfo().getDeletedItemsUri();
strFolderURI = client.getMailboxInfo().getDraftsUri();
strFolderURI = client.getMailboxInfo().getSentItemsUri();

// Get list of messages from the specified folder
ExchangeMessageInfoCollection msgCollection = client.listMessages(strFolderURI);

רשימת הודעות עם תמיכת עימוד

קטע קוד Java הבא מציג כיצד לקבל רשימת הודעות עם תמיכה בעימוד.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
final IEWSClient client = EWSClient.getEWSClient("exchange.domain.com", "username", "password");
try {
    try {
        // Create some test messages to be added to server for retrieval later
        int messagesNum = 12;
        int itemsPerPage = 5;
        MailMessage message = null;
        for (int i = 0; i < messagesNum; i++) {
            message = new MailMessage("from@domain.com", "to@domain.com", "EMAILNET-35157_1 - " + UUID.randomUUID().toString(),
                    "EMAILNET-35157 Move paging parameters to separate class");
            client.appendMessage(client.getMailboxInfo().getInboxUri(), message);
        }
        // Verfiy that the messages have been added to the server
        ExchangeMessageInfoCollection totalMessageInfoCol = client.listMessages(client.getMailboxInfo().getInboxUri());
        System.out.println(totalMessageInfoCol.size());

        ////////////////// RETREIVING THE MESSAGES USING PAGING SUPPORT ////////////////////////////////////

        List<ExchangeMessagePageInfo> pages = new ArrayList<ExchangeMessagePageInfo>();
        ExchangeMessagePageInfo pageInfo = client.listMessagesByPage(client.getMailboxInfo().getInboxUri(), itemsPerPage);
        // Total Pages Count
        System.out.println(pageInfo.getTotalCount());

        pages.add(pageInfo);
        while (!pageInfo.getLastPage()) {
            pageInfo = client.listMessagesByPage(client.getMailboxInfo().getInboxUri(), itemsPerPage, pageInfo.getPageOffset() + 1);
            pages.add(pageInfo);
        }
        int retrievedItems = 0;
        // foreach to while statements conversion
        for (ExchangeMessagePageInfo pageCol : pages) {
            retrievedItems += pageCol.getItems().size();
        }
        // Verify total message count using paging
        System.out.println(retrievedItems);
    } finally {
    }
} finally {
    client.dispose();
}

קבלת מידע על סוג הודעה מ‑ExchangeMessageInfo

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);

ExchangeMessageInfoCollection list = client.listMessages(client.getMailboxInfo().getDeletedItemsUri());
System.out.println(list.get_Item(0).getMessageInfoType()); // MessageInfoType

שמירת הודעות

מאמר זה מציג כיצד לקבל הודעות מתיבת דואר של Exchange Server ולשמור אותן על הדיסק בפורמטים EML ו‑MSG:

שמור כ‑EML על הדיסק.
שמור לזרם זיכרון.
שמור כ‑MSG.

שמירת הודעות ל‑EML

כדי לקבל הודעות ולשמור בפורמט EML:

צור מופע של המחלקה IEWSClient.
ספק את mailboxUri, שם משתמש, סיסמה והדומיין.
קרא למתודה IEWSClient.listMessages() כדי לקבל מופע של האוסף ExchangeMessagesInfoCollection.
עבור על האוסף ExchangeMessagesInfoCollection כדי לקבל את ה‑URI הייחודי של כל הודעה.
קרא למתודה IEWSClient.saveMessage() והעבר את ה‑URI הייחודי כפרמטר.
ספק למתודה saveMessage() נתיב למיקום שבו ברצונך לשמור את הקובץ.

קטע הקוד הבא מציג כיצד להשתמש ב‑EWS להתחבר ל‑Exchange Server ולשמור הודעות כקבצי EML.

// Create instance of IEWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

// Loop through the collection to get Message URI
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgCollection) {
    String strMessageURI = msgInfo.getUniqueUri();

    // Now save the message in disk
    client.saveMessage(strMessageURI, dataDir + msgInfo.getMessageId() + "out.eml");
}

שמירת הודעות לזרם זיכרון

במקום לשמור קבצי EML על הדיסק, אפשר לשמור אותם לזרם זיכרון. זה שימושי כשאתה רוצה לשמור את הזרם במיקום אחסון כגון מסד נתונים. לאחר שהזרם נשמר במסד הנתונים, ניתן לטעון מחדש את קובץ ה‑EML אל MailMessage class. קטע הקוד הבא מראה איך לשמור הודעות מתיבת דואר של Exchange Server לזרם זיכרון באמצעות EWS.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

// Loop through the collection to get Message URI
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgCollection) {
    String strMessageURI = msgInfo.getUniqueUri();

    // Now save the message in memory stream
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    client.saveMessage(strMessageURI, stream);
}

שמירת הודעות בפורמט MSG

ה IEWSClient.saveMessage() מתודה יכולה לשמור ישירות את ההודעה בפורמט EML. כדי לשמור את ההודעות בפורמט MSG, ראשית קראה ל‑ IEWSClient.fetchMessage() שיטה שמחזירה מופע של MailMessage מחלקה. לאחר מכן קרא ל- MailMessage.save() מתודה לשמור את ההודעה ל‑MSG. קטע הקוד הבא מציג כיצד לקבל הודעות מתיבת דואר של Exchange Server ולשמור אותן בפורמט MSG באמצעות EWS.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

int count = 0;
// Loop through the collection to get Message URI
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgCollection) {
    String strMessageURI = msgInfo.getUniqueUri();

    // Now get the message details using FetchMessage() and Save message as Msg
    MailMessage message = client.fetchMessage(strMessageURI);
    message.save(dataDir + (count++) + "_out.msg", SaveOptions.getDefaultMsgUnicode());
}

קבלת ExchangeMessageInfo מ-Message URI

הודעת אימייל מיוצגת על ידי מזהה ייחודי, URI, והיא חלק בלתי נפרד מה ExchangeMessageInfo אובייקט. במקרה שבו רק URI של ההודעה זמין, אז ExchangeMessageInfo אובייקט ניתן גם לאחזר באמצעות המידע הזמין הזה. הגרסה המוגדלת של listMessages מקבל רשימת מזהים לשימוש ExchangeMessageInfoCollection. קטע הקוד הבא מראה איך לקבל ExchangeMessageInfo מ‑URI של ההודעה.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "user@domain.com", "pwd", "domain");

List<String> ids = new ArrayList<String>();
List<MailMessage> messages = new ArrayList<MailMessage>();

for (int i = 0; i < 5; i++) {
    MailMessage message = new MailMessage("user@domain.com", "receiver@domain.com", "EMAILNET-35033 - " + UUID.randomUUID().toString(),
            "EMAILNET-35033 Messages saved from Sent Items folder doesn't contain 'To' field");
    messages.add(message);
    String uri = client.appendMessage(message);
    ids.add(uri);
}

ExchangeMessageInfoCollection messageInfoCol = client.listMessages(ids);

for (ExchangeMessageInfo messageInfo : (Iterable<ExchangeMessageInfo>) messageInfoCol) {
    // Do something ...
    System.out.println(messageInfo.getUniqueUri());
}

הבאת הודעות מתיבת Exchange Server

רשימת הודעות ב-Exchange Server השתמשה ב- listMessages() מתודה לקבלת רשימת הודעות מתיבת Exchange Server. ה- listMessages() מתודה מקבלת מידע בסיסי על הודעות, לדוגמה, הנושא, מזהה ההודעה, השולח והמקבל. לקבלת פרטי ההודעה המלאים, Aspose.Email.Exchange מספקת את המתודה IEWSClient.fetchMessage(). מתודה זו מקבלת את URI של ההודעה כפרמטר ומחזירה מופע של MailMessage מחלקה. ה- MailMessage class ואז מספק פרטי הודעה כגון גוף, כותרות וקבצים מצורפים. גלה עוד על MailMessage API, או גלה כיצד לנהל אימיילים עם MailMessage class. כדי לאחזר הודעות מתיבת הדואר של Exchange Server:

צור מופע מסוג IEWSClient.
ציין את שם השרת, שם המשתמש, הסיסמה והדומיין.
קרא ל‑listMessages כדי לקבל את ExchangeMessageInfoCollection.
עבור על איסוף ExchangeMessageInfoCollection כדי לקבל ערכי ExchangeMessageInfo.UniqueURI.
קרא ל‑IEWSClient.fetchMessage() והעבר את ExchangeMessageInfo.UniqueURI כפרמטר.

קטע הקוד הבא מציג איך להתחבר לתיבת הדואר של שרת Exchange ומאחזר את כל ההודעות באמצעות EWS.

// Create instance of ExchangeWebServiceClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

// Loop through the collection to get Message URI
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgCollection) {
    String strMessageURI = msgInfo.getUniqueUri();

    // Now get the message details using FetchMessage()
    MailMessage msg = client.fetchMessage(strMessageURI);

    for (Attachment att : (Iterable<Attachment>) msg.getAttachments()) {
        System.out.println("Attachment Name: " + att.getName());
    }
}

שימוש במתודה FetchItem כדי לאחזר הודעה

הערה, ה‑ FetchItem מתודה מחזירה הודעה ללא קבצים מצורפים. כדי לאחזר הודעות עם קבצים מצורפים, השתמש ב‑ FetchItem מתודה, המתוארת בסעיף למטה.

ה FetchItem השיטה מועדפת יותר אם ברצונך להביא MapiMessage ולעבוד עם תכונות MAPI. ניתן גם להשתמש בשיטה זו כדי להביא כל פריט של Outlook, כגון איש קשר, פגישה, משימה וכו׳.

// Create instance of ExchangeWebServiceClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

// Loop through the collection to get Message URI
for (ExchangeMessageInfo msgInfo : msgCollection)
{
    // Now get the message using FetchItem()
    MapiMessage msg = client.fetchItem(msgInfo.getUniqueUri());

    // If necessary, you can cast the MapiMessage to the proper item type to simplify working with its properties.
    MapiContact contact = (MapiContact) msg.toMapiMessageItem();
}

קבלת גודל הודעה מראש

Microsoft Outlook InterOp מספקת את היכולת לקבל את גודל ההודעה לפני שליפת ההודעה המלאה מהשרת. במקרה של Aspose.Email API, מידע הסיכום שמתקבל מ‑Exchange server מיוצג על‑ידי ExchangeMessageInfo מחלקה. היא מספקת את אותה תכונה של קבלת גודל ההודעה באמצעות מאפיין Size. כדי לקבל את גודל ההודעה, נעשה הקריאה הסטנדרטית ל‑listMessages של IEWSClient שמחזירה אוסף של ExchangeMessageInfo. קטע הקוד הבא מראה כיצד להציג את גודל ההודעה באמצעות ה‑ ExchangeMessageInfo מחלקה.

// Create instance of ExchangeWebServiceClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

// Loop through the collection to display the basic information
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgCollection) {
    System.out.println("Subject: " + msgInfo.getSubject());
    System.out.println("From: " + msgInfo.getFrom().toString());
    System.out.println("To: " + msgInfo.getTo().toString());
    System.out.println("Message Size: " + msgInfo.getSize());
    System.out.println("==================================");
}

הורדת הודעות באופן רקורסיבי

ה EWSClientשל listSubFolders() שיטה שניתן להשתמש בה כדי לקבל הודעות מתיקיות ותתי‑תיקיות מתיבת דואר של Exchange Server באופן רקורסיבי. דרוש Exchange Server 2007 או יותר, משום שהיא משתמשת ב‑EWS. קטע הקוד הבא מציג כיצד להוריד את כל תיבת הדואר (תיקיות ותתי‑תיקיות) של Exchange Server. מבנה התיקיות נוצר באופן מקומי וכל ההודעות מורדות.

public static void run() {
    try {
        downloadAllMessages();
    } catch (java.lang.RuntimeException ex) {
        System.out.println(ex.getMessage());
    }
}

private static void downloadAllMessages() {
    try {
        String rootFolder = domain + "-" + username;
        new File(rootFolder).mkdirs();
        String inboxFolder = rootFolder + "\\Inbox";
        new File(inboxFolder).mkdirs();

        System.out.println("Downloading all messages from Inbox....");
        // Create instance of IEWSClient class by giving credentials
        IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", username, password, domain);

        ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo();
        System.out.println("Mailbox URI: " + mailboxInfo.getMailboxUri());
        String rootUri = client.getMailboxInfo().getRootUri();
        // List all the folders from Exchange server
        ExchangeFolderInfoCollection folderInfoCollection = client.listSubFolders(rootUri);
        for (ExchangeFolderInfo folderInfo : (Iterable<ExchangeFolderInfo>) folderInfoCollection) {
            // Call the recursive method to read messages and get sub-folders
            listMessagesInFolder(client, folderInfo, rootFolder);
        }

        System.out.println("All messages downloaded.");
    } catch (java.lang.RuntimeException ex) {
        System.out.println(ex.getMessage());
    }
}

// Recursive method to get messages from folders and sub-folders
private static void listMessagesInFolder(IEWSClient client, ExchangeFolderInfo folderInfo, String rootFolder) {
    // Create the folder in disk (same name as on IMAP server)
    String currentFolder = rootFolder + "\\" + folderInfo.getDisplayName();
    new File(currentFolder).mkdirs();

    // List messages
    ExchangeMessageInfoCollection msgInfoColl = client.listMessages(folderInfo.getUri());
    System.out.println("Listing messages....");
    int i = 0;
    for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgInfoColl) {
        // Get subject and other properties of the message
        System.out.println("Subject: " + msgInfo.getSubject());

        // Get rid of characters like ? and :, which should not be included in a file name
        String fileName = msgInfo.getSubject().replace("?", " ").replace(":", " ");

        MailMessage msg = client.fetchMessage(msgInfo.getUniqueUri());
        msg.save(dataDir + "\\" + fileName + "-" + i + ".msg");

        i++;
    }
    System.out.println("============================\n");
    try {
        // If this folder has sub-folders, call this method recursively to get messages
        ExchangeFolderInfoCollection folderInfoCollection = client.listSubFolders(folderInfo.getUri());
        for (ExchangeFolderInfo subfolderInfo : (Iterable<ExchangeFolderInfo>) folderInfoCollection) {
            listMessagesInFolder(client, subfolderInfo, currentFolder);
        }
    } catch (java.lang.RuntimeException e) {
    }
}

הורדת הודעות מתיקיות ציבוריות

Microsoft Exchange Server מאפשר למשתמשים ליצור תיקיות ציבוריות ולפרסם הודעות בהן. כדי לבצע זאת דרך היישום שלך, השתמש ב‑Aspose.Email של EWSClient מחלקה להתחברות ל‑Exchange Server ולקרוא ולהוריד הודעות ופוסטים מתיקיות ציבוריות. קטע הקוד הבא מציג כיצד לקרוא את כל התיקיות הציבוריות והתתי‑תיקיות, ולרשום ולהוריד כל הודעה שנמצאת באותן תיקיות. דוגמה זו פועלת רק עם Microsoft Exchange Server 2007 ומעלה, מכיוון שרק גרסאות אלו תומכות ב‑EWS.

public static void run() {
    try {
        readPublicFolders();
    } catch (java.lang.RuntimeException ex) {
        System.out.println(ex.getMessage());
    }
}

private static void readPublicFolders() {
    NetworkCredential credential = new NetworkCredential(username, password, domain);
    IEWSClient client = EWSClient.getEWSClient(mailboxUri, credential);

    ExchangeFolderInfoCollection folders = client.listPublicFolders();
    for (ExchangeFolderInfo publicFolder : (Iterable<ExchangeFolderInfo>) folders) {
        System.out.println("Name: " + publicFolder.getDisplayName());
        System.out.println("Subfolders count: " + publicFolder.getChildFolderCount());
        listMessagesFromSubFolder(publicFolder, client);

    }
}

private static void listMessagesFromSubFolder(ExchangeFolderInfo publicFolder, IEWSClient client) {
    System.out.println("Folder Name: " + publicFolder.getDisplayName());
    ExchangeMessageInfoCollection msgInfoCollection = client.listMessagesFromPublicFolder(publicFolder);
    for (ExchangeMessageInfo messageInfo : (Iterable<ExchangeMessageInfo>) msgInfoCollection) {
        MailMessage msg = client.fetchMessage(messageInfo.getUniqueUri());
        System.out.println(msg.getSubject());
        msg.save(dataDir + msg.getSubject() + ".msg", SaveOptions.getDefaultMsgUnicode());
    }

    // Call this method recursively for any subfolders
    if (publicFolder.getChildFolderCount() > 0) {
        ExchangeFolderInfoCollection subfolders = client.listSubFolders(publicFolder);
        for (ExchangeFolderInfo subfolder : (Iterable<ExchangeFolderInfo>) subfolders) {
            listMessagesFromSubFolder(subfolder, client);
        }
    }
}

העברת הודעות

ניתן להעביר הודעות דוא"ל מתיקייה אחת לאחרת בעזרת ה‑ IEWSClient מחלקה העברה מתודה. היא מקבלת את הפרמטרים:

ה‑URI הייחודי של ההודעה שיש להעביר.
ה‑URI הייחודי של תיקיית היעד.

העברת הודעות בין תיקיות

קטע הקוד הבא מראה כיצד להעביר הודעה בתיבת דואר מתיקיית הדואר הנכנס לתיקייה בשם Processed. בדוגמה זו, היישום:

קורא הודעות מתיקיית הדואר הנכנס.
מעבד חלק מההודעות על פי קריטריונים (במקרה זה, מחפש מילה מפתח בנושא ההודעה).
מעביר הודעות העומדות בתנאי הנתון לתיקיית המעובדות.

// Create instance of IEWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo();

// List all messages from Inbox folder
System.out.println("Listing all messages from Inbox....");
ExchangeMessageInfoCollection msgInfoColl = client.listMessages(mailboxInfo.getInboxUri());
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgInfoColl) {
    // Move message to "Processed" folder, after processing certain messages based on some criteria
    if (msgInfo.getSubject() != null && msgInfo.getSubject().toLowerCase().contains("process this message")) {
        client.moveItem(mailboxInfo.getDeletedItemsUri(), msgInfo.getUniqueUri()); // EWS
        System.out.println("Message moved...." + msgInfo.getSubject());
    } else {
        // Do something else
    }
}

מחיקת הודעות

אתה יכול למחוק הודעות דוא"ל מתיקייה בעזרת ה- IEWSClient מחלקה deleteItem שיטה. היא מקבלת את כתובת ה-URI הייחודית של ההודעה כפרמטר.

קטע הקוד הבא מציג כיצד למחוק הודעה מתיקיית Inbox. למטרת דוגמה זו, הקוד:

קורא הודעות מתיקיית הדואר הנכנס.
עבד הודעות על בסיס קריטריונים מסוימים (בדוגמה זו, אנו מחפשים מילת מפתח בנושא ההודעה).
מוחק את ההודעה.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo();

// List all messages from Inbox folder
System.out.println("Listing all messages from Inbox....");
ExchangeMessageInfoCollection msgInfoColl = client.listMessages(mailboxInfo.getInboxUri());
for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgInfoColl) {
    // Delete message based on some criteria
    if (msgInfo.getSubject() != null && msgInfo.getSubject().toLowerCase().contains("delete") == true) {
        client.deleteItem(msgInfo.getUniqueUri(), DeletionOptions.getDeletePermanently()); // EWS
        System.out.println("Message deleted...." + msgInfo.getSubject());
    } else {
        // Do something else
    }
}

העתקת הודעות

Aspose.Email API מאפשר להעתיק הודעה מתיקייה אחת לתיקייה אחרת באמצעות copyItem מתודה. גרסה העומס של מתודה זו מחזירה את ה‑URI הייחודי של ההודעה המועתקת כפי שמוצג במאמר זה.

העתקת הודעה לתיקייה אחרת

קטע הקוד הבא מציג איך להעתיק הודעה לתיקייה אחרת.

try {
    // Create instance of EWSClient class by giving credentials
    IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
    MailMessage message = new MailMessage("from@domain.com", "to@domain.com", "EMAILNET-34997 - " + UUID.randomUUID().toString(),
            "EMAILNET-34997 Exchange: Copy a message and get reference to the new Copy item");
    String messageUri = client.appendMessage(message);
    String newMessageUri = client.copyItem(messageUri, client.getMailboxInfo().getDeletedItemsUri());
} catch (java.lang.RuntimeException ex) {
    System.out.println(ex.getMessage());
}

Java: סינון הודעות מתיבת דואר Exchange

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email for Java מספקת את היכולת לסנן הודעות מתיבת דואר Exchange באמצעות ה- EWSClient ו ExchangeQueryBuilder. ניתן לסנן הודעות לפי קריטריונים שונים כגון תאריך, תחום, מזהה הודעה, וכדי הודעות משלוח דואר. מאמר זה מציג כיצד לסנן הודעות משרת Exchange באמצעות קריטריונים שונים.

סינון הודעות באמצעות EWS

ה IEWSClient class מספקת את listMessages() מתודה שמקבלת את כל ההודעות מתיבת דואר. כדי לקבל רק הודעות שתואמות תנאי מסוים, השתמש ב listMessages() מתודה שלוקחת את MailQuery מחלקה כארגומנט. ה- MailQuery המחלקה מספקת מגוון תכונות לציון תנאים, כגון תאריך, נושא, שולח ונמען. בנוסף, ה-API מאפשר גם להחיל מסננים רגישים לרישיות לקבלת אימיילים מתיבת הדואר.

סינון הודעות

כדי לקבל הודעות מסוננות מתיבת דואר:

התחבר לשרת Exchange.
צור מופע של MailQuery והגדר את המאפיינים הרצויים.
קרא למתודה IEWSClient.listMessages() והעבר את MailQuery בפרמטרים כדי לקבל רק את ההודעות המסוננות.

קטע הקוד הבא מראה כיצד להתחבר לתיבת דואר IMAP ולקבל הודעות שבהן המחרוזת "Newsletter" נמצאת בנושא ונשלחו היום.

try {
    // Connect to EWS
    final String mailboxUri = "https://outlook.office365.com/ews/exchange.asmx";
    final String username = "username";
    final String password = "password";
    final String domain = "domain";

    IEWSClient client = EWSClient.getEWSClient(mailboxUri, username, password, domain);

    // Query building by means of ExchangeQueryBuilder class
    ExchangeQueryBuilder builder = new ExchangeQueryBuilder();

    // Set Subject and Emails that arrived today
    builder.getSubject().contains("Newsletter");
    builder.getInternalDate().on(new Date());

    MailQuery query = builder.getQuery();

    // Get list of messages
    ExchangeMessageInfoCollection messages = client.listMessages(client.getMailboxInfo().getInboxUri(), query, false);
    System.out.println("EWS: " + messages.size() + " message(s) found.");

    // Disconnect from EWS
    client.dispose();
} catch (java.lang.RuntimeException ex) {
    System.out.println(ex.getMessage());
}

סינון הודעות לפי קריטריונים

קוד הדוגמאות מעלה מסנן הודעות על בסיס נושא הדוא"ל ותאריך. ניתן לסנן גם על מאפיינים אחרים. להלן כמה דוגמאות להגדרת התנאים באמצעות MailQuery.

סינון הודעות לפי תאריך היום

קטע הקוד הבא מראה כיצד לסנן את כל המיילים על בסיס תאריך היום.

// Emails that arrived today
MailQueryBuilder builder = new MailQueryBuilder();
builder.getInternalDate().on(new Date());

סינון הודעות לפי טווח תאריכים

קוד המקטע הבא מראה כיצד לסנן את כל הודעות הדוא"ל על בסיס טווח תאריכים.

// Emails that arrived in last 7 days
Calendar cal = Calendar.getInstance();
builder.getInternalDate().before(cal.getTime());
cal.add(Calendar.DATE, -7);
builder.getInternalDate().since(cal.getTime());

סינון הודעות לפי שולח ספציפי

קוד המקטע הבא מראה כיצד לסנן את כל הודעות הדוא"ל על בסיס שולח ספציפי.

// Get emails from specific sender
builder.getFrom().contains("saqib.razzaq@127.0.0.1");

סינון הודעות לפי תחום ספציפי

קוד המקטע הבא מראה כיצד לסנן את כל הודעות הדוא"ל על בסיס תחום ספציפי.

// Get emails from specific domain
builder.getFrom().contains("SpecificHost.com");

סינון הודעות לפי נמען ספציפי

קוד המקטע הבא מראה כיצד לסנן את כל הודעות הדוא"ל על בסיס נמען ספציפי.

// Get emails sent to specific recipient
builder.getTo().contains("recipient");

סינון הודעות לפי MessageID

קוד המקטע הבא מראה כיצד לסנן את כל הודעות הדוא"ל על בסיס MessageID.

// Get email with specific MessageId
ExchangeQueryBuilder builder = new ExchangeQueryBuilder();
builder.getMessageId().equals("MessageID");

סינון הודעות לפי כל הודעות אספקת דואר

קוד המקטע הבא מראה כיצד לסנן את כל הודעות הדוא"ל על בסיס כל התראות משלוח דואר.

// Get Mail Delivery Notifications
builder = new ExchangeQueryBuilder();
builder.getContentClass().equals(ContentClassType.getMDN().toString());

סינון הודעות לפי גודל

builder = new ExchangeQueryBuilder();
builder.getItemSize().greater(80000);

סינון הודעות לפי ערך מחרוזת

קטע הקוד הבא מראה כיצד לסנן את כל המיילים על בסיס המחרוזת שצוינה בכותרות (subject, from, to, cc). ה getText() המתודה מחזירה את ערך המחרוזת יחד עם גוף ההודעה.

 ExchangeQueryBuilder builder = new ExchangeQueryBuilder();

builder.getText().equals("SomeText");

MailQuery query = builder.getQuery();

ExchangeMessageInfoCollection messages = ewsClient.listMessages("InboxUri", query, false);

סינון הודעות בסדר עולה/יורד

Aspose.Email מספקת את ComparisonField.orderBy(boolean ascending) מתודה שמגדירה את הערך שמציין שהלקוח משתמש במיון עולה או יורד על שדה החיפוש. היא מאפשרת למיין הודעות דוא"ל בסדר עולה/יורד על פי הקריטריון שמוגדר על ידי MailQueryBuilder.

קטע הקוד למטה מדגים כיצד לסנן הודעות בסדר עולה/יורד:

MailQueryBuilder builder = new MailQueryBuilder();
builder.getSubject().contains("Report");
builder.getInternalDate().since(sinceDate);
builder.getSubject().orderBy(true); // sort the subject ascending
builder.getInternalDate().orderBy(false); // sort the date descending  

ExchangeMessageInfoCollection miColl = client.listMessages(client.getMailboxInfo().getInboxUri(), builder.getQuery());

בניית שאילתות מורכבות

אם שונים MailQueryBuilder המאפיינים מוגדרים בהצהרה נפרדת, וכל התנאים מתאימים. לדוגמה, כדי לקבל הודעה בטווח תאריכים ספציפי וממאזן מסוים, כתבו שלוש הצהרות:

שילוב שאילתות עם AND

קטע הקוד הבא מציג כיצד לשלב שאילתות עם AND.

// Emails from specific host, get all emails that arrived before today and all emails that arrived since 7 days ago
builder.getFrom().contains("SpecificHost.com");
Calendar cal = Calendar.getInstance();
builder.getInternalDate().before(cal.getTime());
cal.add(Calendar.DATE, -7);
builder.getInternalDate().since(cal.getTime());

שילוב שאילתות עם OR

MailQueryBuilder מספקת את or() מתודה שלוקחת שני MailQuery האיברים ניתנים כפרמטרים. הוא מקבל הודעות שמתאימות לכל אחת משתי התנאים המוגדרים. בדוגמה למטה מסוננות הודעות שבהן או שיש את המילה "test" בנושא או שהשלוח הוא "noreply@host.com". קטע הקוד הבא מציג כיצד לשלב שאילתות עם OR.

builder.or(builder.getSubject().contains("test"), builder.getFrom().contains("noreply@host.com"));

סינון דוא"ל רגיש רישיות

ניתן לסנן אימיילים בהתחשב ברגישות למקרה על ידי ציון דגל IgnoreCase בקריטריון הסינון כפי שמוצג בקטע הקוד הבא.

// Query building by means of ExchangeQueryBuilder class
ExchangeQueryBuilder builder = new ExchangeQueryBuilder();
builder.getSubject().contains("Newsletter", true);
builder.getInternalDate().on(new Date());
MailQuery query = builder.getQuery();

סינון הודעות עם תמיכת דפדוף

int itemsPerPage = 5;
String sGuid = UUID.randomUUID().toString();
String str1 = sGuid + " - " + "Query 1";
String str2 = sGuid + " - " + "Query 2";

MailQueryBuilder queryBuilder1 = new MailQueryBuilder();
queryBuilder1.getSubject().contains(str1);
MailQuery query1 = queryBuilder1.getQuery();
List<ExchangeMessagePageInfo> pages = new ArrayList<ExchangeMessagePageInfo>();
ExchangeMessagePageInfo pageInfo = client.listMessagesByPage(client.getMailboxInfo().getInboxUri(), query1, itemsPerPage);
pages.add(pageInfo);
int str1Count = pageInfo.getItems().size();
while (!pageInfo.getLastPage()) {
    pageInfo = client.listMessagesByPage(client.getMailboxInfo().getInboxUri(), query1, itemsPerPage, pageInfo.getPageOffset() + 1);
    pages.add(pageInfo);
    str1Count += pageInfo.getItems().size();
}

Java: ניהול פריטי שיחה

Mon, 01 Jan 0001 00:00:00 +0000

ניתן להשתמש ב‑Aspose.Email ל‑Java כדי לנהל את פריטי השיחה ב‑Exchange Server עם ה‑ EWSClient מחלקה. מחלקה זו משתמשת ב‑Exchange Web Services, זמינה רק ב‑Exchange Server 2007 וגרסאות מאוחרות יותר. מאמר זה מראה כיצד חיפוש, העתקה, העברה ו מחיקה פריטי שיחה ב‑Exchange Server 2010. נדרש Microsoft Exchange Server 2010 Service Pack 1 לכל הפיצ’רים הנכללים בחלק זה.

מציאת שיחות

כדי לקבל את מידע השיחה מתיקייה ספציפית ב‑Exchange Server:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.findConversations() כדי למצוא את כל פריטי השיחה מתיקייה.
הצג את תכונות פריט השיחה כגון מזהה (ID), נושא השיחה ומצב הדגש.

קוד הדוגמה הבא מראה לך כיצד למצוא שיחות.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);
System.out.println("Connected to Exchange 2010");

// Find Conversation Items in the Inbox folder
ExchangeConversation[] conversations = client.findConversations(client.getMailboxInfo().getInboxUri());
// Show all conversations
for (ExchangeConversation conversation : conversations) {
    // Display conversation properties like Id and Topic
    System.out.println("Topic: " + conversation.getConversationTopic());
    System.out.println("Flag Status: " + conversation.getFlagStatus());
    System.out.println();
}

העתקת שיחות

כדי להעתיק שיחות מתיקייה אחת לשנייה:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.copyConversationItems() כדי להעתיק פריט שיחה מתיקייה מקור לתיקייה יעד.

קטעת הקוד הבא מראה לך כיצד להעתיק שיחות.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);
System.out.println("Connected to Exchange 2010");

// Find those Conversation Items in the Inbox folder which we want to copy
ExchangeConversation[] conversations = client.findConversations(client.getMailboxInfo().getInboxUri());
for (ExchangeConversation conversation : conversations) {
    System.out.println("Topic: " + conversation.getConversationTopic());
    // Copy the conversation item based on some condition
    if (conversation.getConversationTopic().contains("test email")) {
        client.copyConversationItems(conversation.getConversationId(), client.getMailboxInfo().getDeletedItemsUri());
        System.out.println("Copied the conversation item to another folder");
    }
}

העברת שיחות

להעברת שיחות מתיקייה אחת לשנייה:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.moveConversationItems() כדי להעביר שיחה מהתיקייה המקורית לתיקייה היעד.

קוד הדוגמה הבא מראה לך כיצד להעביר שיחות.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);
System.out.println("Connected to Exchange 2010");

// Find those Conversation Items in the Inbox folder which we want to move
ExchangeConversation[] conversations = client.findConversations(client.getMailboxInfo().getInboxUri());

for (ExchangeConversation conversation : conversations) {
    System.out.println("Topic: " + conversation.getConversationTopic());
    // Move the conversation item based on some condition
    if (conversation.getConversationTopic().contains("test email") == true) {
        client.moveConversationItems(conversation.getConversationId(), client.getMailboxInfo().getDeletedItemsUri());
        System.out.println("Moved the conversation item to another folder");
    }
}

מחיקת שיחות

כדי למחוק שיחות מתיקייה:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.deleteConversationItems() כדי למחוק את פריט השיחה מהתיקייה המקורית.

קוד הדוגמה הבא מראה לך כיצד למחוק שיחות.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);
System.out.println("Connected to Exchange 2010");

// Find those Conversation Items in the Inbox folder which we want to delete
ExchangeConversation[] conversations = client.findConversations(client.getMailboxInfo().getInboxUri());
for (ExchangeConversation conversation : conversations) {
    System.out.println("Topic: " + conversation.getConversationTopic());
    // Delete the conversation item based on some condition
    if (conversation.getConversationTopic().contains("test email") == true) {
        client.deleteConversationItems(conversation.getConversationId());
        System.out.println("Deleted the conversation item");
    }
}

Java: עבודה עם פריטי לוח שנה ב-Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

שליחת בקשות פגישה

מאמר זה מציג איך לשלוח בקשת פגישה למספר מקבלים באמצעות Exchange Web Services ו-Aspose.Email.

צור בקשת פגישה באמצעות המחלקה Appointment והגדר את המיקום, הזמן והמשתתפים.
צור מופע של המחלקה MailMessage והגדר את הפגישה באמצעות המתודה MailMessage.addAlternateView().
התחבר לשרת Exchange ושלח את בקשת הפגישה באמצעות המתודה send(MailMessage).

ה EWSClient המחלקה יכולה לשמש להתחברות לשרתי Exchange עם תמיכה ב-Exchange Web Services (EWS). כדי שזה יעבוד, השרת חייב להיות Exchange Server 2007 או גרסה מאוחרת יותר. קטע הקוד הבא מראה כיצד להשתמש ב-EWS לשליחת בקשות פגישה.

try {
    // Create instance of IEWSClient class by giving credentials
    IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

    Calendar c = Calendar.getInstance();
    c.add(Calendar.HOUR_OF_DAY, 1);
    Date startTime = c.getTime();
    c.add(Calendar.MINUTE, 90);
    Date endTime = c.getTime();

    // Create the meeting request
    Appointment app = new Appointment("meeting request", startTime, endTime, MailAddress.to_MailAddress("administrator@test.com"),
            MailAddressCollection.to_MailAddressCollection("bob@test.com"));
    app.setSummary("meeting request summary");
    app.setDescription("description");

    c = Calendar.getInstance();
    c.add(Calendar.DATE, 5);
    RecurrencePattern pattern = new DailyRecurrencePattern(c.getTime());
    app.setRecurrence(pattern);

    // Create the message and set the meeting request
    MailMessage msg = new MailMessage();
    msg.setFrom(MailAddress.to_MailAddress("administrator@test.com"));
    msg.setTo(MailAddressCollection.to_MailAddressCollection("bob@test.com"));
    msg.isBodyHtml(true);
    msg.setHtmlBody("<h3>HTML Heading</h3><p>Email Message detail</p>");
    msg.setSubject("meeting request");
    msg.addAlternateView(app.requestApointment(0));

    // send the appointment
    client.send(msg);
    System.out.println("Appointment request sent");
} catch (java.lang.RuntimeException ex) {
    System.out.println(ex.getMessage());
}

עבודה עם פריטי לוח שנה באמצעות EWS

Aspose.Email מספק אפשרות להוסיף, לעדכן ולבטל פגישות באמצעות לקוח Exchange Web Service (EWS). ה-IEWClients createAppointment, updateAppointment, ו- cancelAppointment מתודות מאפשרות טיפול בפריטי לוח שנה באמצעות EWS. מאמר זה מספק דוגמת קוד מפורטת לעבודה עם פריטי לוח שנה. דוגמת הקוד הבאה מראה כיצד:

צור פגישה.
עדכון פגישה.
מחיקת/ביטול פגישה.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "your.username", "your.Password");
Calendar c = Calendar.getInstance();
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
c.set(Calendar.MILLISECOND, 0);
Date startTime = c.getTime();
c.add(Calendar.HOUR_OF_DAY, 1);
Date endTime = c.getTime();
String timeZone = "America/New_York";

Appointment app = new Appointment("Room 112", startTime, endTime, MailAddress.to_MailAddress("organizeraspose-email.test3@domain.com"),
        MailAddressCollection.to_MailAddressCollection("attendee@gmail.com"));
app.setTimeZone(timeZone);
app.setSummary("NETWORKNET-34136" + UUID.randomUUID().toString());
app.setDescription("NETWORKNET-34136 Exchange 2007/EWS: Provide support for Add/Update/Delete calendar items");

String uid = client.createAppointment(app);
Appointment fetchedAppointment1 = client.fetchAppointment(uid);
app.setLocation("Room 115");
app.setSummary("New summary for " + app.getSummary());
app.setDescription("New Description");
client.updateAppointment(app);

Appointment[] appointments1 = client.listAppointments();
System.out.println("Total Appointments: " + appointments1.length);
Appointment fetchedAppointment2 = client.fetchAppointment(uid);
System.out.println("Summary: " + fetchedAppointment2.getSummary());
System.out.println("Location: " + fetchedAppointment2.getLocation());
System.out.println("Description: " + fetchedAppointment2.getDescription());
client.cancelAppointment(app);
Appointment[] appointments2 = client.listAppointments();
System.out.println("Total Appointments: " + appointments2.length);

החזרת פריטי לוח שנה מתמשכים בטווח תאריכים שצוין

ה-ASPose.Email EWSClient תומך בהחזרת פריטי לוח שנה מתמשכים בטווח המוגדר על ידי StartDate ו-EndDate. ה AppointmentQueryBuilder.setCalendarView(Date startDate, Date endDate, int maxEntriesReturned) מתודה, אם נבחר CalendarView, מחזירה רשימה של פריטי לוח שנה בודדים והתרחשויות של פריטי לוח שנה מתמשכים בטווח שמוגדר על ידי StartDate ו-EndDate. הפרמטר maxEntriesReturned מתאר את המספר המרבי של תוצאות. (ערך <= 0 לכל התוצאות).

ExchangeQueryBuilder builder = new ExchangeQueryBuilder();
builder.getAppointment().setCalendarView(startDate, endDate, -1);

Appointment[] appointments = client.listAppointments(builder.getQuery());

רשימת פגישות עם תמיכה בפייג’ינג

מתודת ListAppointments שנחשפת על ידי ה IEWSClient ה-API מאחזר את הרשימה המלאה של פגישות מהשרת Exchange. זה עשוי לקחת זמן אם יש כמות גדולה של פגישות על השרת. ה-API מספק מתודות עודפות של listAppointments מתודה המספקת תמיכת פייג’ינג לפעולה. ניתן להשתמש בה במגוון שילובים עם תכונת השאילתא. המתודות העודפות הבאות זמינות למיצוע פגישות מ-Exchange Server עם תמיכת Paging.

AppointmentCollection IEWSClient.listAppointments(int itemsPerPage).
AppointmentCollection IEWSClient.listAppointments(String folderUri, int itemsPerPage).
AppointmentCollection IEWSClient.listAppointments(MailQuery query, int itemsPerPage).
AppointmentCollection IEWSClient.listAppointments(String folderUri, MailQuery query, int itemsPerPage).
AppointmentCollection IEWSClient.listAppointments(int itemsPerPage, int itemOffset).
AppointmentCollection IEWSClient.listAppointments(String folderUri, int itemsPerPage, int itemOffset).
AppointmentCollection IEWSClient.listAppointments(MailQuery query, int itemsPerPage, int itemOffset).
AppointmentCollection IEWSClient.listAppointments(String folderUri, MailQuery query, int itemsPerPage, int itemOffset).

קטע הקוד הבא מראה כיצד לפרט פגישות עם תמיכת פייג’ינג.

        IEWSClient client = EWSClient.getEWSClient("exchange.domain.com", "username", "password");
        try {
            try {
                Appointment[] appts = client.listAppointments();
                System.out.println(appts.length);

                Calendar c = Calendar.getInstance();
                c.set(Calendar.MINUTE, 0);
                c.set(Calendar.SECOND, 0);
                c.set(Calendar.MILLISECOND, 0);

                int appNumber = 10;
                Map<String, Appointment> appointmentsDict = new HashMap<String, Appointment>();
                for (int i = 0; i < appNumber; i++) {
                    c.set(Calendar.HOUR_OF_DAY, i + 1);
                    Date startTime = c.getTime();
                    c.set(Calendar.HOUR_OF_DAY, i + 2);
                    Date endTime = c.getTime();

                    String timeZone = "America/New_York";
                    Appointment appointment = new Appointment("Room 112", startTime, endTime, MailAddress.to_MailAddress("from@domain.com"),
                            MailAddressCollection.to_MailAddressCollection("to@domain.com"));
                    appointment.setTimeZone(timeZone);
                    appointment.setSummary("NETWORKNET-35157_3 - " + UUID.randomUUID().toString());
                    appointment.setDescription("EMAILNET-35157 Move paging parameters to separate class");
                    String uid = client.createAppointment(appointment);
                    appointmentsDict.put(uid, appointment);
                }
                AppointmentCollection totalAppointmentCol = AppointmentCollection.to_AppointmentCollection(client.listAppointments());

                ///// LISTING APPOINTMENTS WITH PAGING SUPPORT ///////
                int itemsPerPage = 2;
                List<AppointmentPageInfo> pages = new ArrayList<AppointmentPageInfo>();
                AppointmentPageInfo pagedAppointmentCol = client.listAppointmentsByPage(itemsPerPage);
                System.out.println(pagedAppointmentCol.getItems().size());
                pages.add(pagedAppointmentCol);
                while (!pagedAppointmentCol.getLastPage()) {
                    pagedAppointmentCol = client.listAppointmentsByPage(itemsPerPage, pagedAppointmentCol.getPageOffset() + 1);
                    pages.add(pagedAppointmentCol);
                }
                int retrievedItems = 0;
                // foreach to while statements conversion
                for (AppointmentPageInfo folderCol : pages) {
                    retrievedItems += folderCol.getItems().size();
                }
            } finally {
            }
        } finally {
            client.dispose();
        }

הוספת אירוע לתיקיית לוח השנה המשנית ב-Exchange Server

ה-API של Aspose.Email מאפשר ליצור תיקיית לוח שנה משנית ב-Exchange Server באמצעות ה IEWSClient. ניתן להוסיף, לעדכן או לבטל פגישות מהלוח המשני באמצעות ה createAppointment, updateAppointment ו cancelAppointment מתודות. מתודות ותכונות ה-API הבאות משמשות בדוגמאות הקוד למטה כדי להציג את תכונת הפונקציונליות. שים לב שתכונה זו נתמכת ב-Aspose.Email for Java מגרסה 6.5.0 ואילך.

מתודה IEWSClient.cancelAppointment(Appointment, String).
מתודה IEWSClient.cancelAppointment(String, String).
מתודה IEWSClient.createAppointment(Appointment, String).
מתודה IEWSClient.createFolder(String, String, ExchangeFolderPermissionCollection, String).
מתודה IEWSClient.fetchAppointment(String, String).
מתודה IEWSClient.updateAppointment(Appointment, String).
מאפיין IEWSClient.CurrentCalendarFolderUri.

קטע הקוד הבא מראה כיצד להוסיף אירוע לתיקיית לוח השנה המשנית בשרת Exchange.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "your.username", "your.Password");
try {
    try {
        // Create an appointmenta that will be added to secondary calendar folder

        Calendar c = Calendar.getInstance();
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        c.set(Calendar.MILLISECOND, 0);
        Date startTime = c.getTime();
        c.add(Calendar.HOUR_OF_DAY, 1);
        Date endTime = c.getTime();

        String timeZone = "America/New_York";

        Appointment[] listAppointments;
        Appointment appointment = new Appointment("Room 121", startTime, endTime, MailAddress.to_MailAddress("from@domain.com"),
                MailAddressCollection.to_MailAddressCollection("attendee@domain.com"));
        appointment.setTimeZone(timeZone);
        appointment.setSummary("EMAILNET-35198 - " + UUID.randomUUID().toString());
        appointment.setDescription("EMAILNET-35198 Ability to add event to Secondary Calendar of Office 365");

        // Verify that the new folder has been created
        ExchangeFolderInfoCollection calendarSubFolders = client.listSubFolders(client.getMailboxInfo().getCalendarUri());

        String getfolderName;
        String setFolderName = "New Calendar";
        boolean alreadyExits = false;

        // Verify that the new folder has been created already exits or not

        for (int i = 0; i < calendarSubFolders.size(); i++) {
            getfolderName = calendarSubFolders.get_Item(i).getDisplayName();

            if (getfolderName.equals(setFolderName)) {
                alreadyExits = true;
            }
        }

        if (alreadyExits) {
            System.out.println("Folder Already Exists");
        } else {
            // Create new calendar folder
            client.createFolder(client.getMailboxInfo().getCalendarUri(), setFolderName, null, "IPF.Appointment");

            System.out.println(calendarSubFolders.size());

            // Get the created folder URI
            String newCalendarFolderUri = calendarSubFolders.get_Item(0).getUri();

            // appointment api with calendar folder uri
            // Create
            client.createAppointment(appointment, newCalendarFolderUri);
            appointment.setLocation("Room 122");
            // update
            client.updateAppointment(appointment, newCalendarFolderUri);
            // list
            listAppointments = client.listAppointments(newCalendarFolderUri);

            // list default calendar folder
            listAppointments = client.listAppointments(client.getMailboxInfo().getCalendarUri());

            // Cancel
            client.cancelAppointment(appointment, newCalendarFolderUri);
            listAppointments = client.listAppointments(newCalendarFolderUri);

            // appointment api with context current calendar folder uri
            client.setCurrentCalendarFolderUri(newCalendarFolderUri);
            // Create
            client.createAppointment(appointment);
            appointment.setLocation("Room 122");
            // update
            client.updateAppointment(appointment);
            // list
            listAppointments = client.listAppointments();

            // list default calendar folder
            listAppointments = client.listAppointments(client.getMailboxInfo().getCalendarUri());

            // Cancel
            client.cancelAppointment(appointment);
            listAppointments = client.listAppointments();

        }
    } finally {
    }
} finally {
    client.dispose();
}

שיתוף הזמנת לוח שנה

שרת Microsoft Exchange מספק אפשרות לשתף לוחות שנה על ידי שליחת הזמנות לוח שנה למשתמשים אחרים הרשומים באותו שרת Exchange. ה-API של Aspose.Email מספק את אותה אפשרות על ידי שיתוף לוח השנה באמצעות ה-API של EWS.

final IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
try {
    // delegate calendar access permission
    ExchangeDelegateUser delegateUser = new ExchangeDelegateUser("sharingfrom@domain.com", ExchangeDelegateFolderPermissionLevel.NotSpecified);
    delegateUser.getFolderPermissions().setCalendarFolderPermissionLevel(ExchangeDelegateFolderPermissionLevel.Reviewer);
    client.delegateAccess(delegateUser, "sharingfrom@domain.com");

    // Create invitation
    MapiMessage mapiMessage = client.createCalendarSharingInvitationMessage("sharingfrom@domain.com");
    MailConversionOptions options = new MailConversionOptions();
    options.setConvertAsTnef(true);
    MailMessage mail = mapiMessage.toMailMessage(options);
    client.send(mail);
} finally {
    client.dispose();
}

קבלת מידע על תכונות מורחבות מפריטי לוח שנה

IEWSClient client = EWSClient.getEWSClient("https://exchange.office365.com/Exchange.asmx", "username", "password");

java.util.List<String> uriList = java.util.Arrays.asList(client.listItems(client.getMailboxInfo().getCalendarUri()));

// Define the Extended Attribute Property Descriptor for searching purpose
// In this case, we have a K1 Long named property for Calendar item
UUID uuid = UUID.fromString("00020329-0000-0000-C000-000000000046");
PropertyDescriptor propertyDescriptor = new PidNamePropertyDescriptor("K1", PropertyDataType.Integer32, uuid);

java.util.List<PropertyDescriptor> propertyDescriptors = java.util.Arrays.asList(new PropertyDescriptor[] { propertyDescriptor });
IGenericList<MapiCalendar> mapiCalendarList = client.fetchMapiCalendar(uriList, propertyDescriptors);

for (MapiCalendar cal : mapiCalendarList) {
    for (MapiNamedProperty namedProperty : (Iterable<MapiNamedProperty>) cal.getNamedProperties().getValues()) {
        System.out.println(namedProperty.getNameId() + " = " + namedProperty.getInt32());
    }
}

Java: עבודה עם אנשי קשר ב‑Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

בחשבונות Exchange Server יש יותר מהודעות אימייל בלבד. בנוסף ל‑ אחזור, הזזה, שליחה ו מחיקת הודעות אימייל מתוך Exchange Servers, Aspose.Email מאפשרת לעבוד עם אנשי קשר. מאמר זה מסביר כיצד לאחזר מידע על איש קשר באמצעות Exchange Web Services. מאמר זה גם מציג כיצד ניתן לרשום אנשי קשר מתיקיית Contacts או לפתור אנשי קשר על‑פי שם האיש קשר.

קבלת אנשי קשר עם EWS

Aspose.Email מספקת את EWSClient מחלקה להתחברות ל‑Microsoft Exchange Server באמצעות Exchange Web Services. קטעי הקוד שמופיעים להלן משתמשים ב‑Exchange Web Services כדי לקרוא את כל אנשי הקשר. קטע הקוד הבא מראה כיצד לקבל Contacts עם EWS.

// Create instance of IEWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// List all the contacts
Contact[] contacts = client.getContacts(client.getMailboxInfo().getContactsUri());
for (Contact contact : contacts) {
    MapiContact mapiContact = Contact.to_MapiContact(contact);
    // Display name and email address
    System.out.println("Name: " + mapiContact.getNameInfo().getDisplayName() + "+ Email Address: " + mapiContact.getElectronicAddresses().getEmail1());
}

פתירת אנשי קשר באמצעות שם איש הקשר

קוד דוגמה הבא מראה כיצד להשתמש ב‑get contacts עם EWS

// Create instance of IEWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// List all the contacts
Contact[] contacts = client.resolveContacts("Changed Name", ExchangeListContactsOptions.FetchPhoto);
for (Contact c : contacts) {
    MapiContact contact = Contact.to_MapiContact(c);
    // Display name and email address
    System.out.println("Name: " + contact.getNameInfo().getDisplayName() + "+ Email Address: " + contact.getElectronicAddresses().getEmail1());
}

קביעת פורמט הערות של איש קשר

ה‑NotesFormat מציין את סוג פורמט הטקסט של ההערות של אנשי הקשר כפי שהוגדר על‑ידי המונה TextFormat.

אחזור איש קשר באמצעות מזהה

ניתן לאחזר איש קשר מסוים מהשרת באמצעות המזהה שלו, כפי שמוצג בדוגמת הקוד הבאה.

Contact fetchedContact = client.getContact(id);

הוספת אנשי קשר

ה EWSClient מחלקה createContact() שיטה יכולה לשמש להוספת מידע של Contact ל‑Exchange Server. ה‑ createContact() שיטה מקבלת Contact אובייקט כפרמטר קלט.

להוספת אנשי קשר ל‑Exchange Server:

אתחל את EWSClient עם כתובת ופרטי גישה.
אתחל את אובייקט Contact עם המאפיינים הרצויים.
הפעל את השיטה CreateContact כדי להוסיף את איש הקשר ל‑Exchange Server.

Aspose.Email מספקת את EWSClient מחלקה להתחברות ל‑Microsoft Exchange Server באמצעות Exchange Web Services. קטעי הקוד מראים כיצד להשתמש ב‑Exchange Web Services כדי להוסיף אנשי קשר ל‑Exchange Server.

// Set mailboxURI, Username, password, domain information
String mailboxUri = "https://ex2010/ews/exchange.asmx";
String username = "test.exchange";
String password = "pwd";
String domain = "ex2010.local";
NetworkCredential credentials = new NetworkCredential(username, password, domain);
IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);

// Create New Contact
Contact contact = new Contact();

// Set general info
contact.setGender(Gender.Male);
contact.setDisplayName("Frank Lin");
contact.setCompanyName("ABC Co.");
contact.setJobTitle("Executive Manager");
PhoneNumber tmp0 = new PhoneNumber();
tmp0.setNumber("123456789");
tmp0.setCategory(PhoneNumberCategory.getHome());

// Add Phone numbers
contact.getPhoneNumbers().add(tmp0);
AssociatedPerson tmp1 = new AssociatedPerson();
tmp1.setName("Catherine");
tmp1.setCategory(AssociatedPersonCategory.getSpouse());

// contact's associated persons
contact.getAssociatedPersons().add(tmp1);
AssociatedPerson tmp2 = new AssociatedPerson();
tmp2.setName("Bob");
tmp2.setCategory(AssociatedPersonCategory.getChild());
contact.getAssociatedPersons().add(tmp2);
AssociatedPerson tmp3 = new AssociatedPerson();
tmp3.setName("Merry");
tmp3.setCategory(AssociatedPersonCategory.getSister());
contact.getAssociatedPersons().add(tmp3);
Url tmp4 = new Url();
tmp4.setHref("www.blog.com");
tmp4.setCategory(UrlCategory.getBlog());

// URLs
contact.getUrls().add(tmp4);
Url tmp5 = new Url();
tmp5.setHref("www.homepage.com");
tmp5.setCategory(UrlCategory.getHomePage());
contact.getUrls().add(tmp5);
EmailAddress tmp6 = new EmailAddress();
tmp6.setAddress("Frank.Lin@Abc.com");
tmp6.setDisplayName("Frank Lin");
tmp6.setCategory(EmailAddressCategory.getEmail1());

// Set contact's Email address
contact.getEmailAddresses().add(tmp6);

try {
    client.createContact(contact);
} catch (java.lang.RuntimeException ex) {
    System.out.println(ex.getMessage());
}

עדכון אנשי קשר

ניתן לעדכן מידע של איש קשר באמצעות Microsoft Outlook. Aspose.Email יכולה גם לעדכן מידע של איש קשר ב‑Exchange Server באמצעות Exchange Web Service (EWS). ה‑ של IEWSClient updateContact() שיטה יכולה לעדכן מידע של איש קשר ב‑Exchange Server.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);

// List all the contacts and Loop through all contacts
Contact[] contacts = client.getContacts(client.getMailboxInfo().getContactsUri());
Contact contact = contacts[0];
System.out.println("Name: " + contact.getDisplayName());
contact.setDisplayName("David Ch");
client.updateContact(contact);

מחיקת אנשי קשר

ה EWSClient class מספקת את deleteItem לגישה ולמחיקת אנשי קשר מתיקיית Contacts של Exchange Server. שיטה זו מקבלת את מזהה האיש קשר כפרמטר קלט.

למחיקת אנשי קשר מ‑Exchange Server:

אתחול ExchangeWebServiceClient עם כתובת ופרטי גישה.
מחיקת איש קשר באמצעות המזהה שלו.

קטעי הקוד הבאים מציגים כיצד למחוק אנשי קשר מ‑Exchange Server באמצעות Exchange Web Service.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

String strContactToDelete = "John Teddy";
Contact[] contacts = client.getContacts(client.getMailboxInfo().getContactsUri());
for (Contact contact : contacts) {
    if (contact.getDisplayName().equals(strContactToDelete))
        client.deleteItem(contact.getId().getEWSId(), DeletionOptions.getDeletePermanently());

}
client.dispose();

Java: עבודה עם רשימות תפוצה ב‑Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

עבודה עם רשימות הפצה

Aspose.Email API מספקת את היכולת ליצור ולקרוא רשימות הפצה מהשרת Exchange. ניתן ליצור רשימות הפצה בשרת וכן להוסיף אליהן חברים באמצעות IEWSClient. מאמר זה מציג כיצד לעבוד עם רשימות הפצה בשרת Exchange.

יצירת רשימת הפצה

קטע הקוד הבא מציג כיצד ליצור רשימת הפצה.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList distributionList = new ExchangeDistributionList();
distributionList.setDisplayName("test private list");
MailAddressCollection members = new MailAddressCollection();
members.add("address1@host.com");
members.add("address2@host.com");
members.add("address3@host.com");
client.createDistributionList(distributionList, members);

אחזור רשימת הפצה פרטית

קטע הקוד הבא מציג כיצד לאחזר רשימת הפצה פרטית.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList[] distributionLists = client.listDistributionLists();
for (ExchangeDistributionList distributionList : distributionLists) {
    MailAddressCollection members = client.fetchDistributionList(distributionList);
    for (MailAddress member : (Iterable<MailAddress>) members) {
        System.out.println(member.getAddress());
    }
}

הרחבת רשימת הפצה ציבורית

קטע הקוד הבא מציג כיצד להרחיב את רשימת ההפצה הציבורית.

MailAddressCollection members = client.expandDistributionList(new MailAddress("public.distribution.list@host.com"));
for (MailAddress member : (Iterable<MailAddress>) members) {
    System.out.println(member.getAddress());
}

הוספת חברים

הוספת חברים לרשימת הפצה פרטית

קטע הקוד הבא מציג כיצד להוסיף חברים לרשימת הפצה פרטית.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList[] distributionLists = client.listDistributionLists();
MailAddressCollection newMembers = new MailAddressCollection();
newMembers.add("address4@host.com");
newMembers.add("address5@host.com");
client.addToDistributionList(distributionLists[0], newMembers);

הוספת חברים ללא רישום

קטע הקוד הבא מציג כיצד להוסיף חברים ללא רישום.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList distributionList = new ExchangeDistributionList();
distributionList.setId("list's id");
distributionList.setChangeKey("list's change key");
MailAddressCollection newMembers = new MailAddressCollection();
newMembers.add("address6@host.com");
client.addToDistributionList(distributionList, newMembers);

שליחה לרשימת הפצה פרטית

קטע הקוד הבא מציג כיצד לשלוח הודעה לרשימת הפצה פרטית.

ExchangeDistributionList[] distributionLists = client.listDistributionLists();
MailAddress distributionListAddress = distributionLists[0].toMailAddress();
MailMessage message = new MailMessage(new MailAddress("from@host.com"), distributionListAddress);
message.setSubject("sendToPrivateDistributionList");
client.send(message);

מחיקת חברים

מחיקת חברים מרשימת הפצה פרטית

קטע הקוד הבא מציג כיצד למחוק חברים מרשימת הפצה פרטית.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList[] distributionLists = client.listDistributionLists();
MailAddressCollection members = client.fetchDistributionList(distributionLists[0]);
MailAddressCollection membersToDelete = new MailAddressCollection();
membersToDelete.addMailAddress(members.get_Item(0));
membersToDelete.addMailAddress(members.get_Item(1));
client.deleteFromDistributionList(distributionLists[0], membersToDelete);

מחיקת חברים ללא רישום

קטע הקוד הבא מציג כיצד למחוק חברים ללא רישום.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList distributionList = new ExchangeDistributionList();
distributionList.setId("list's id");
distributionList.setChangeKey("list's change key");
MailAddressCollection membersToDelete = new MailAddressCollection();
MailAddress addressToDelete = new MailAddress("address", true);
// addressToDelete.Id.EWSId = "member's id";
membersToDelete.addMailAddress(addressToDelete);
client.addToDistributionList(distributionList, membersToDelete);

מחיקת רשימת הפצה פרטית

קטע הקוד הבא מציג כיצד למחוק רשימת הפצה פרטית.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList[] distributionLists = client.listDistributionLists();
client.deleteDistributionList(distributionLists[0], true);

מחיקה ללא רישום

קוד הדוגמא הבא מראה לך כיצד למחוק ללא רישום.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
ExchangeDistributionList distributionList = new ExchangeDistributionList();
distributionList.setId("list's id");
client.deleteDistributionList(distributionList, true);

Java: עבודה עם תיקיות ב‑Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

רישום כל התיקיות מהשרת

API של Aspose.Email מספקת את היכולת להתחבר ל‑Exchange Server ולרשום את כל התיקיות ותתי‑תיקיות. ניתן גם לקבל את כל תתי‑התיקיות מכל תיקייה באופן רקורסיבי. היא גם מאפשרת רישום תיקיות עם עימוד (paging) מהלקוח של Exchange באמצעות Exchange Web Service (EWS). מאמר זה מסביר כיצד לקבל את כל תתי‑התיקיות משרת ה‑Exchange ולהשיג תיקיות עם פגינציה.

קטע הקוד הבא מציג כיצד לרשום תיקיות מ-Exchange Server.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    try {
        IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
        System.out.println("Downloading all messages from Inbox....");

        ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo();
        System.out.println("Mailbox URI: " + mailboxInfo.getMailboxUri());
        String rootUri = client.getMailboxInfo().getRootUri();
        // List all the folders from Exchange server
        ExchangeFolderInfoCollection folderInfoCollection = client.listSubFolders(rootUri);
        for (ExchangeFolderInfo folderInfo : (Iterable<ExchangeFolderInfo>) folderInfoCollection) {
            // Call the recursive method to read messages and get sub-folders
            listSubFolders(client, folderInfo);
        }

        System.out.println("All messages downloaded.");
    } catch (java.lang.RuntimeException ex) {
        System.out.println(ex.getMessage());
    }
}

private static void listSubFolders(IEWSClient client, ExchangeFolderInfo folderInfo) {
    // Create the folder in disk (same name as on IMAP server)
    System.out.println(folderInfo.getDisplayName());
    try {
        // If this folder has sub-folders, call this method recursively to get messages
        ExchangeFolderInfoCollection folderInfoCollection = client.listSubFolders(folderInfo.getUri());
        for (ExchangeFolderInfo subfolderInfo : (Iterable<ExchangeFolderInfo>) folderInfoCollection) {
            listSubFolders(client, subfolderInfo);
        }
    } catch (java.lang.RuntimeException e) {
    }
}

קבלת מידע על סוג התיקייה באמצעות EWS

ה FolderType תכונה שמסופקת על‑ידי ExchangeFolderInfo מחלקה שניתן להשתמש בה לקבלת מידע על סוג התיקייה. זה מוצג בדוגמת הקוד למטה.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);

ExchangeFolderInfoCollection folderInfoCol = client.listSubFolders(client.getMailboxInfo().getRootUri());
for (ExchangeFolderInfo folderInfo : (Iterable<ExchangeFolderInfo>) folderInfoCol) {
    switch (folderInfo.getFolderType()) {
    case ExchangeFolderType.Appointment:
        // handle Appointment
        break;
    case ExchangeFolderType.Contact:
        // handle Contact
        break;
    case ExchangeFolderType.Task:
        // handle Task
        break;
    case ExchangeFolderType.Note:
        // handle email message
        break;
    case ExchangeFolderType.StickyNote:
        // handle StickyNote
        break;
    case ExchangeFolderType.Journal:
        // handle Journal
        break;
    default:
        break;
    }
}

רשימת תיקיות עם תמיכת עמודים באמצעות EWS

קטעת הקוד הבא מראה לך כיצד להשתמש בתמיכה בעמודים (paging) באמצעות EWS.

// Create instance of ExchangeWebServiceClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "UserName", "Password");

// Call ListMessages method to list messages info from Inbox
ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());
int itemsPerPage = 5;
List<PageInfo> pages = new ArrayList<PageInfo>();
PageInfo pagedMessageInfoCol = client.listMessagesByPage(client.getMailboxInfo().getInboxUri(), itemsPerPage);
pages.add(pagedMessageInfoCol);
while (!pagedMessageInfoCol.getLastPage()) {
    pagedMessageInfoCol = client.listMessagesByPage(client.getMailboxInfo().getInboxUri(), itemsPerPage);
    pages.add(pagedMessageInfoCol);
}
pagedMessageInfoCol = client.listMessagesByPage(client.getMailboxInfo().getInboxUri(), itemsPerPage);
while (!pagedMessageInfoCol.getLastPage()) {
    client.listMessages(client.getMailboxInfo().getInboxUri());
}

גישה לתיקיות מותאמות אישית או תת‑תיקיות בתיבת הדואר

IEWSClient מאפשר למפתחים לגשת לכל תיקייה מותאמת אישית או תת‑תיקייה מתיבת הדואר. ה‑ folderExists() פונקציה של IEWSClient מחזירה את ה‑URI של תיקייה/תת‑תיקייה מותאמת אישית ספציפית, שניתן להשתמש בו לאחר מכן כדי לגשת לתיקייה היעד. בדוגמה הבאה, תיקייה מותאמת אישית בשם "TestInbox", שנוצרה תחת INBOX, נגישה וכל ההודעות מוצגות מתיקייה מותאמת זו. לביצוע משימה זו, הצעדים הבאים:

אתחל את אובייקט IEWSClient על‑ידי אספקת אישורים תקינים.
גש לתיבת הדואר ברירת המחדל.
גש לתיקיית האב, שהיא INBOX בדוגמה זו. תיקיית אב זו יכולה להיות גם תיקייה מותאמת אישית.
השתמש ב‑folderExists() כדי לחפש את תת‑התיקייה המותאמת שצוינה, למשל "TestInbox". הפונקציה תחזיר את ה‑URI של "TestInbox".
השתמש ב‑Uri זה כדי לגשת לכל ההודעות בתיקייה המותאמת הזאת.

קטעת הקוד הבא מראה לך כיצד לגשת לתיקיות מותאמות אישית או תת‑תיקיות בתיבת הדואר באמצעות EWS.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Create ExchangeMailboxInfo, ExchangeMessageInfoCollection instance
ExchangeMailboxInfo mailbox = client.getMailboxInfo();
ExchangeMessageInfoCollection messages = null;
ExchangeFolderInfo subfolderInfo = new ExchangeFolderInfo();

// Check if specified custom folder exisits and Get all the messages info from the target Uri
ExchangeFolderInfo[] referenceToSubfolderInfo = { subfolderInfo };
client.folderExists(mailbox.getInboxUri(), "TestInbox", /* out */ referenceToSubfolderInfo);
subfolderInfo = referenceToSubfolderInfo[0];

// if custom folder exists
if (subfolderInfo != null) {
    messages = client.listMessages(subfolderInfo.getUri());

    // Parse all the messages info collection
    for (ExchangeMessageInfo info : (Iterable<ExchangeMessageInfo>) messages) {
        String strMessageURI = info.getUniqueUri();
        // now get the message details using FetchMessage()
        MailMessage msg = client.fetchMessage(strMessageURI);
        System.out.println("Subject: " + msg.getSubject());
    }
} else {
    System.out.println("No folder with this name found.");
}

רישום תיקיות ציבוריות

Microsoft Exchange Server מאפשר למשתמשים ליצור תיקיות ציבוריות ולפרסם הודעות בהן. כדי לבצע זאת דרך היישום שלך, השתמש ב‑Aspose.Email של EWSClient מחלקה להתחברות ל‑Exchange Server ולקריאה והורדת הודעות ופוסטים מתיקיות ציבוריות. קטע הקוד הבא מראה לך כיצד לקרוא את כל התיקיות הציבוריות ותת‑תיקיות, ולרשום ולהוריד כל הודעה שנמצאת בתיקיות אלו. דוגמה זו פועלת רק עם Microsoft Exchange Server 2007 ומעלה מאחר שרק גרסאות אלו תומכות ב‑EWS.

public static void run() {
    try {
        readPublicFolders();
    } catch (java.lang.RuntimeException ex) {
        System.out.println(ex.getMessage());
    }
}

private static void readPublicFolders() {
    NetworkCredential credential = new NetworkCredential(username, password, domain);
    IEWSClient client = EWSClient.getEWSClient(mailboxUri, credential);

    ExchangeFolderInfoCollection folders = client.listPublicFolders();
    for (ExchangeFolderInfo publicFolder : (Iterable<ExchangeFolderInfo>) folders) {
        System.out.println("Name: " + publicFolder.getDisplayName());
        System.out.println("Subfolders count: " + publicFolder.getChildFolderCount());
        listMessagesFromSubFolder(publicFolder, client);

    }
}

private static void listMessagesFromSubFolder(ExchangeFolderInfo publicFolder, IEWSClient client) {
    System.out.println("Folder Name: " + publicFolder.getDisplayName());
    ExchangeMessageInfoCollection msgInfoCollection = client.listMessagesFromPublicFolder(publicFolder);
    for (ExchangeMessageInfo messageInfo : (Iterable<ExchangeMessageInfo>) msgInfoCollection) {
        MailMessage msg = client.fetchMessage(messageInfo.getUniqueUri());
        System.out.println(msg.getSubject());
        msg.save(dataDir + msg.getSubject() + ".msg", SaveOptions.getDefaultMsgUnicode());
    }

    // Call this method recursively for any subfolders
    if (publicFolder.getChildFolderCount() > 0) {
        ExchangeFolderInfoCollection subfolders = client.listSubFolders(publicFolder);
        for (ExchangeFolderInfo subfolder : (Iterable<ExchangeFolderInfo>) subfolders) {
            listMessagesFromSubFolder(subfolder, client);
        }
    }
}

העתקת הודעה לתיקייה אחרת

API של Aspose.Email מאפשר להעתיק הודעה מתיקייה אחת לתיקייה אחרת באמצעות ה‑ copyItem מתודה. גרסה העומס של מתודה זו מחזירה את ה‑URI הייחודי של ההודעה המועתקת כפי שמוצג במאמר זה.

try {
    // Create instance of EWSClient class by giving credentials
    IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
    MailMessage message = new MailMessage("from@domain.com", "to@domain.com", "EMAILNET-34997 - " + UUID.randomUUID().toString(),
            "EMAILNET-34997 Exchange: Copy a message and get reference to the new Copy item");
    String messageUri = client.appendMessage(message);
    String newMessageUri = client.copyItem(messageUri, client.getMailboxInfo().getDeletedItemsUri());
} catch (java.lang.RuntimeException ex) {
    System.out.println(ex.getMessage());
}

סנכרון פריטי תיקייה

API של Aspose.Email ל‑Java IEWSClient מספקת את האפשרות לסנכרן תיקיית Exchange לתוכן שלה. ה‑ syncFolder מתודה שנחשפת על‑ידי ה‑ IEWSClient מחלקה שניתן להשתמש בה לביצוע סנכרון מידע של תיקייה על תיקייה מסוימת. קטע הקוד הבא מראה לך כיצד לבצע סנכרון למידע תיקיית Exchange.

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
MailMessage message1 = new MailMessage("user@domain.com", "user@domain.com", "EMAILNET-34738 - " + UUID.randomUUID().toString(), "EMAILNET-34738 Sync Folder Items");
client.send(message1);

MailMessage message2 = new MailMessage("user@domain.com", "user@domain.com", "EMAILNET-34738 - " + UUID.randomUUID().toString(), "EMAILNET-34738 Sync Folder Items");
client.send(message2);

ExchangeMessageInfoCollection messageInfoCol = client.listMessages(client.getMailboxInfo().getInboxUri());
SyncFolderResult result = client.syncFolder(client.getMailboxInfo().getInboxUri(), null);
System.out.println(result.getNewItems().size());
System.out.println(result.getChangedItems().size());
System.out.println(result.getReadFlagChanged().size());
System.out.println(result.getDeletedItems().length);

קבלת הרשאות לתיקיות Exchange

משתמשים מקבלים הרשאות לתיקיות ציבוריות ב‑Exchange Server, אשר מגבילות/קובעות את רמת הגישה של משתמש לתיקיות אלו. ה‑ ExchangeFolderPermission מחלקה המספקת קבוצת תכונות הרשאה לתיקיות Exchange כגון PermissionLevel, האם הם יכולים canCreateItems, deleteItems, ולבצע משימות אחרות כפי שמוגדר בתכונות ההרשאה. ניתן לקבל הרשאות באמצעות ה‑ getFolderPermissions() מתודה של IEWSClient. מאמר זה מסביר כיצד לקבל את ההרשאות שהוחלו על תיקייה ציבורית עבור כל המשתמשים שיש להם גישה לתיקיות המשותפות.

כדי לבצע משימה זו:

אתחל את ה‑EWSClient.
השתמש ב‑listPublicFolders כדי לקבל רשימה של כל התיקיות הציבוריות
קבל את ההרשאות הקשורות לתיקייה באמצעות המתודה getFolderPermissions()

קטעת הקוד הבא מראה לך כיצד להשתמש ב- EWSClient מחלקה לקבלת ההרשאות שהוחלו על תיקייה.

String folderName = "DesiredFolderName";

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

ExchangeFolderInfoCollection folders = client.listPublicFolders();
ExchangeFolderPermissionCollection permissions = new ExchangeFolderPermissionCollection();

ExchangeFolderInfo publicFolder = null;
try {
    for (ExchangeFolderInfo folderInfo : (Iterable<ExchangeFolderInfo>) folders)
        if (folderInfo.getDisplayName().equals(folderName))
            publicFolder = folderInfo;

    if (publicFolder == null)
        System.out.println("public folder was not created in the root public folder");

    ExchangePermissionCollection folderPermissionCol = client.getFolderPermissions(publicFolder.getUri());
    for (ExchangeBasePermission perm : (Iterable<ExchangeBasePermission>) folderPermissionCol) {
        if (perm instanceof ExchangeFolderPermission)
            System.out.println("Permission is null.");
        else {
            ExchangeFolderPermission permission = (ExchangeFolderPermission) perm;

            System.out.println("User's primary smtp address: " + permission.getUserInfo().getPrimarySmtpAddress());
            System.out.println("User can create Items: " + permission.canCreateItems());
            System.out.println("User can delete Items: " + permission.getDeleteItems());
            System.out.println("Is Folder Visible: " + permission.isFolderVisible());
            System.out.println("Is User owner of this folder: " + permission.isFolderOwner());
            System.out.println("User can read items: " + permission.getReadItems());
        }
    }
    ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo();
    // Get the Permissions for the Contacts and Calendar Folder
    ExchangePermissionCollection contactsPermissionCol = client.getFolderPermissions(mailboxInfo.getContactsUri());
    ExchangePermissionCollection calendarPermissionCol = client.getFolderPermissions(mailboxInfo.getCalendarUri());
} finally {
    // Do the needfull
}

יצירת תיקיות ותת‑תיקיות

ממשק ה‑API של Aspose.Email מספק אפשרות ליצור תיקיות בתיבת דואר של Exchange. ה‑ CreateFolder מתודה של IEWSClient ניתן להשתמש בזה למטרה זו. כדי ליצור תיקייה בתיבת הדואר של שרת Exchange, ניתן לבצע את הצעדים הבאים.

צור מופע של IEWSClient.
הגדר את המאפיין UseSlashAsFolderSeparator לפי הצורך. אם יוגדר ל‑true, היישום יחשיב את ה‑"Slash" כמפריד תיקיות והתיקייה המשנית תיווצר אחרי הסלאש.
השתמש בפונקציה createFolder כדי ליצור את התיקייה.

קטע הקוד הבא מראה כיצד ליצור תיקיות ותיקיות משנה.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

String inbox = client.getMailboxInfo().getInboxUri();
String folderName1 = "EMAILNET-35054";
String subFolderName0 = "2015";
String folderName2 = folderName1 + "/" + subFolderName0;
String folderName3 = folderName1 + " / 2015";
ExchangeFolderInfo rootFolderInfo = null;
ExchangeFolderInfo folderInfo = null;

try {
    client.setUseSlashAsFolderSeparator(true);
    client.createFolder(client.getMailboxInfo().getInboxUri(), folderName1);
    client.createFolder(client.getMailboxInfo().getInboxUri(), folderName2);
} finally {
    ExchangeFolderInfo[] referenceToRootFolderInfo = { rootFolderInfo };
    boolean outRefCondition0 = client.folderExists(inbox, folderName1, /* out */ referenceToRootFolderInfo);
    rootFolderInfo = referenceToRootFolderInfo[0];
    if (outRefCondition0) {
        ExchangeFolderInfo[] referenceToFolderInfo = { folderInfo };
        boolean outRefCondition1 = client.folderExists(inbox, folderName2, /* out */ referenceToFolderInfo);
        folderInfo = referenceToFolderInfo[0];
        if (outRefCondition1)
            client.deleteFolder(folderInfo.getUri(), true);
        client.deleteFolder(rootFolderInfo.getUri(), true);
    }
}

גיבוי תיקיות Exchange ל‑PST

לעיתים קרובות משתמשים רוצים לגבות את כל או חלק מתיקיות תיבת הדואר. Aspose.Email מספק אפשרות לגבות את כל תיקיות תיבת הדואר ב‑Exchange או תיקיות ספציפיות ל‑PST. מאמר זה מתאר כיצד לבצע גיבוי של תיקיות Exchange ל‑PST עם קוד לדוגמה. כדי לגבות תיקיות בשרת Exchange, ניתן לבצע את הצעדים הבאים.

הפעל את IEWSClient עם פרטי משתמש
הוסף את פרטי התיקייה הנדרשים ל‑ExchangeFolderInfoCollection
השתמש במתודת הגיבוי של הלקוח כדי לייצא את תוכן התיקייה ל‑PST

קטע הקוד הבא מראה כיצד לגבות תיקיות Exchange ל‑PST.

String dataDir = "data/";
// Create instance of IEWSClient class by providing credentials
final String mailboxUri = "https://ews.domain.com/ews/Exchange.asmx";
final String domain = "";
final String username = "username";
final String password = "password";
NetworkCredential credential = new NetworkCredential(username, password, domain);
IEWSClient client = EWSClient.getEWSClient(mailboxUri, credential);

// Get Exchange mailbox info of other email account
ExchangeMailboxInfo mailboxInfo = client.getMailboxInfo();
ExchangeFolderInfo info = client.getFolderInfo(mailboxInfo.getInboxUri());
ExchangeFolderInfoCollection fc = new ExchangeFolderInfoCollection();
fc.addItem(info);
client.backup(fc, dataDir + "Backup_out.pst", BackupOptions.None);

Java: עבודה עם כללים ב‑Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

ניהול כללים

ניתן להשתמש ב‑Aspose.Email for Java לניהול הכללים ב‑Exchange Server באמצעות EWSClient מחלקה. מחלקה זו משתמשת ב‑Exchange Web Services (EWS), הזמינות ב‑Exchange Server 2007 ובגרסאות מאוחרות יותר. כדי להציג כיצד לנהל כללים, מאמר זה מסביר כיצד:

קרא את הכללים שכבר קיימים בשרת.
צור כלל חדש.
עדכן כלל קיים.

Microsoft Exchange Server 2010 Service Pack 1 נדרש לכל הפונקציות המתוארות במאמר זה.

קריאת כללים

להשגת כל הכללים מ‑Exchange Server:

התחבר ל‑Exchange Server באמצעות המחלקה IEWSClient.
קרא לשיטה IEWSClient.getInboxRules() לקבלת כל הכללים.
במחזור foreach, עבור על כל הכללים והצג את מאפייני הכלל כגון תנאים, פעולות ושם.

קטע הקוד הבא מראה כיצד לקרוא כללים.

IEWSClient client = EWSClient.getEWSClient(mailboxURI, credential);

System.out.println("Connected to Exchange server");

// Get all Inbox Rules
InboxRule[] inboxRules = client.getInboxRules();

// Display information about each rule
for (InboxRule inboxRule : inboxRules) {
    System.out.println("Display Name: " + inboxRule.getDisplayName());

    // Check if there is a "From Address" condition
    if (inboxRule.getConditions().getFromAddresses().size() > 0) {
        for (MailAddress fromAddress : (Iterable<MailAddress>) inboxRule.getConditions().getFromAddresses()) {
            System.out.println("From: " + fromAddress.getDisplayName() + " - " + fromAddress.getAddress());
        }
    }
    // Check if there is a "Subject Contains" condition
    if (inboxRule.getConditions().containsSubjectStrings().size() > 0) {
        // foreach to while statements conversion
        for (String subject : inboxRule.getConditions().containsSubjectStrings()) {
            System.out.println("Subject contains: " + subject);
        }
    }
    // Check if there is a "Move to Folder" action
    if (inboxRule.getActions().getMoveToFolder().length() > 0) {
        System.out.println("Move message to folder: " + inboxRule.getActions().getMoveToFolder());
    }
}

יצירת כלל חדש

ליצירת כלל חדש ב‑Exchange Server, בצע את הצעדים הבאים:

התחבר ל‑Exchange Server באמצעות המחלקה IEWSClient.
צור מופע חדש של מחלקת InboxRule והגדר את המאפיינים החובה הבאים:
1. שם תצוגה
2. תנאים
3. פעולות
קרא לשיטה IEWSClient.createInboxRule() כדי ליצור את הכלל.

קטע הקוד הבא מראה כיצד ליצור כלל חדש.

IEWSClient client = EWSClient.getEWSClient(mailboxURI, credential);

System.out.println("Connected to Exchange server");

InboxRule rule = new InboxRule();
rule.setDisplayName("Message from client ABC");

// Add conditions
RulePredicates newRules = new RulePredicates();
// Set Subject contains string "ABC" and Add the conditions
newRules.containsSubjectStrings().addItem("ABC");
newRules.getFromAddresses().addMailAddress(new MailAddress("administrator@ex2010.local", true));
rule.setConditions(newRules);

// Add Actions and Move the message to a folder
RuleActions newActions = new RuleActions();
newActions.setMoveToFolder("120:AAMkADFjMjNjMmNjLWE3NzgtNGIzNC05OGIyLTAwNTgzNjRhN2EzNgAuAAAAAABbwP+Tkhs0TKx1GMf0D/cPAQD2lptUqri0QqRtJVHwOKJDAAACL5KNAAA=AQAAAA==");
rule.setActions(newActions);
client.createInboxRule(rule);

עדכון כלל

כדי לעדכן כלל ב‑Exchange Server:

התחבר ל‑Exchange Server באמצעות המחלקה IEWSClient.
קרא לשיטה IEWSClient.getInboxRules() לקבלת כל הכללים.
במחזור foreach, עבור על כל הכללים וקבל את הכלל שברצונך לשנות על‑ידי התאמת DisplayName בתנאי.
עדכן את מאפייני הכלל
קרא לשיטה IEWSClient.updateInboxRule() כדי לעדכן את הכלל.

קטע הקוד הבא מראה כיצד לעדכן כלל.

IEWSClient client = EWSClient.getEWSClient(mailboxURI, credential);

System.out.println("Connected to Exchange server");

// Get all Inbox Rules
InboxRule[] inboxRules = client.getInboxRules();

// Loop through each rule
for (InboxRule inboxRule : inboxRules) {
    System.out.println("Display Name: " + inboxRule.getDisplayName());
    if ("Message from client ABC".equals(inboxRule.getDisplayName())) {
        System.out.println("Updating the rule....");
        inboxRule.getConditions().getFromAddresses().set_Item(0, new MailAddress("administrator@ex2010.local", true));
        client.updateInboxRule(inboxRule);
    }
}

Java: עבודה עם משימות ב-Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

עבודה עם משימות

Aspose.Email תומך בעיבוד משימות ב-Exchange באמצעות ExchangeTask class. מאפיינים שונים נחשפים על ידי ExchangeTask, כמו נושא, סטטוס, תאריך יעד, ו- עדיפות, ניתן להשתמש כדי להגדיר את המשימה ב-Exchange. ה EWSClient המחלקה חושפת פונקציות כגון createTask, updateTask, ו- deleteTask הן משמשות לעיבוד משימות ב-Exchange. מאמר זה מציג כיצד:

יצירת משימה חדשה.
הגדרת אזור הזמן של המשימה.
עדכון משימה.
מחיקת משימה.
שליחת בקשת משימה
שמירת משימה לדיסק

יצירת משימה חדשה

קטע הקוד הבא מראה כיצד ליצור משימה חדשה.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Create Exchange task object
ExchangeTask task = new ExchangeTask();

// Set task subject and status to In progress
task.setSubject("New-Test");
task.setStatus(ExchangeTaskStatus.InProgress);
client.createTask(client.getMailboxInfo().getTasksUri(), task);

ציון אזור זמן

ה IEWSClient ממשק ו ExchangeTask מספקים את התכונה TimeZoneId להגדרת מידע על אזור זמן בעת יצירת משימה. קטע הקוד הבא מראה כיצד לציין Timezone.

client.setTimezoneId("Central Europe Standard Time");

עדכון משימה

קטעי הקוד הבאים מראים איך לעדכן משימה בשרת Exchange.

// Create instance of ExchangeClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Get all tasks info collection from exchange
ExchangeMessageInfoCollection tasks = client.listMessages(client.getMailboxInfo().getTasksUri());

// Parse all the tasks info in the list
for (ExchangeMessageInfo info : (Iterable<ExchangeMessageInfo>) tasks) {
    // Fetch task from exchange using current task info
    ExchangeTask task = client.fetchTask(info.getUniqueUri());

    // Update the task status to NotStarted
    task.setStatus(ExchangeTaskStatus.NotStarted);

    // Set the task due date
    SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
    task.setDueDate(sdf.parse("26/02/2013 00:00:00"));

    // Set task priority
    task.setPriority(MailPriority.Low.getValue());

    // Update task on exchange
    client.updateTask(task);
}

מחיקת משימה

קטע הקוד הבא מראה כיצד למחוק משימה בשרת Exchange.

// Create instance of ExchangeClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Get all tasks info collection from exchange
ExchangeMessageInfoCollection tasks = client.listMessages(client.getMailboxInfo().getTasksUri());

// Parse all the tasks info in the list
for (ExchangeMessageInfo info : (Iterable<ExchangeMessageInfo>) tasks) {
    // Fetch task from exchange using current task info
    ExchangeTask task = client.fetchTask(info.getUniqueUri());

    // Check if the current task fulfills the search criteria
    if (task.getSubject().equals("test")) {
        // Delete task from exchange
        client.deleteItem(task.getUniqueUri(), DeletionOptions.getDeletePermanently());
    }
}

שליחת בקשת משימה

שירות Aspose.Email Exchange מספק אפשרות לשלוח בקשות משימה בדומה ל-Outlook. קטע הקוד הבא מראה כיצד לטעון הודעת בקשת משימה מהדיסק ולשלוח אותה באמצעות ה IEWSClient.

// Create instance of ExchangeClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

MsgLoadOptions options = new MsgLoadOptions();
options.setPreserveTnefAttachments(true);

// load task from .msg file
MailMessage eml = MailMessage.load(dataDir + "task.msg", options);
eml.setFrom(MailAddress.to_MailAddress("firstname.lastname@domain.com"));
eml.getTo().clear();
eml.getTo().addMailAddress(new MailAddress("firstname.lastname@domain.com"));
client.send(eml);

שמירת משימה לדיסק

Aspose.Email גם מאפשר לשמור משימות Exchange לדיסק בפורמט Outlook MSG. קטע הקוד הבא מראה כיצד לשמור משימה לדיסק.

ExchangeTask task = new ExchangeTask();
task.setSubject("TASK-ID - " + UUID.randomUUID());
task.setStatus(ExchangeTaskStatus.InProgress);

Calendar cal = Calendar.getInstance();
task.setStartDate(cal.getTime());
cal.add(Calendar.DATE, 3);
task.setDueDate(cal.getTime());
task.save(dstEmail);

רשימת משימות מ-Exchange Server

IEWSClient מספקת את listTasks מתודה שניתן להשתמש בה לאחזור משימות מ-Exchange Web Service. יש לה מספר גרסאות עודפות שניתן להשתמש בהן כדי לקבל את רשימת המשימות מתיקייה ספציפית או בעזרת קריטריוני חיפוש. דוגמת הקוד למטה מציגה קבלת כל המשימות או משימות ספציפיות מתיקיית Tasks.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);

// Listing Tasks from Server
client.setTimezoneId("Central Europe Standard Time");
TaskCollection taskCollection = client.listTasks(client.getMailboxInfo().getTasksUri());

// print retrieved tasks' details
int iTasksCount = taskCollection.size();
for (int i = 0; i < iTasksCount; i++) {
    ExchangeTask task = (ExchangeTask) taskCollection.get_Item(i);
    System.out.println(task.getSubject());
    System.out.println(task.getStartDate());
    System.out.println(task.getDueDate());
}

// Listing Tasks from server based on Query - Completed and In-Progress
Integer[] selectedStatuses = new Integer[] { ExchangeTaskStatus.Completed, ExchangeTaskStatus.InProgress };
ExchangeQueryBuilder queryBuilder = new ExchangeQueryBuilder();
queryBuilder.getTaskStatus().in(Arrays.asList(selectedStatuses));
MailQuery query = queryBuilder.getQuery();

taskCollection = client.listTasks(client.getMailboxInfo().getTasksUri(), query);

// print retrieved tasks' details
iTasksCount = taskCollection.size();
for (int i = 0; i < iTasksCount; i++) {
    ExchangeTask task = (ExchangeTask) taskCollection.get_Item(i);
    System.out.println(task.getSubject());
    System.out.println(task.getStartDate());
    System.out.println(task.getDueDate());
}

סינון משימות מ-Exchange Server

Aspose.Email מספק אפשרות לקבל משימות ספציפיות מהשרת במקום לקבל את כל המשימות מהשרת. ה-API ניתן לשימוש לקבלת משימות לפי הסטטוס שלהן כגון Completed, Deferred, In Progress, Not started או Waiting on others. ה ExchangeQueryBuilder המחלקה יכולה לשמש לציון הקריטריון הרצוי באמצעות תכונת Status. היא גם מאפשרת לציין תנאים מרובים לקבלת משימות רצויות מ-Exchange Server. זאת מוצגת בדוגמת הקוד הבאה.

// Create instance of ExchangeClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");

// Set timezone for tasks
client.setTimezoneId("Central Europe Standard Time");

// We use these status values for specifying in queries
Integer[] values = new Integer[] { ExchangeTaskStatus.Completed, ExchangeTaskStatus.Deferred, ExchangeTaskStatus.InProgress, ExchangeTaskStatus.NotStarted,
        ExchangeTaskStatus.WaitingOnOthers };

messageInfoCol = client.listMessages(client.getMailboxInfo().getTasksUri());

// Now retrieve the tasks with specific statuses
for (int status : values) {
    queryBuilder = new ExchangeQueryBuilder();
    queryBuilder.getTaskStatus().equals(status);
    query = queryBuilder.getQuery();
    messageInfoCol = client.listMessages(client.getMailboxInfo().getTasksUri(), query);
    fetchedTask = client.fetchTask(messageInfoCol.get_Item(0).getUniqueUri());
}

// retrieve all other than specified
for (int status : values) {
    queryBuilder = new ExchangeQueryBuilder();
    queryBuilder.getTaskStatus().notEquals((int) status);
    query = queryBuilder.getQuery();
    messageInfoCol = client.listMessages(client.getMailboxInfo().getTasksUri(), query);
}

// specifying multiple criterion
Integer[] selectedStatuses = new Integer[] { ExchangeTaskStatus.Completed, ExchangeTaskStatus.InProgress };

queryBuilder = new ExchangeQueryBuilder();
queryBuilder.getTaskStatus().in(Arrays.asList(selectedStatuses));
query = queryBuilder.getQuery();
messageInfoCol = client.listMessages(client.getMailboxInfo().getTasksUri(), query);

// list all those which are not in our specified statuses
queryBuilder = new ExchangeQueryBuilder();
queryBuilder.getTaskStatus().notIn(Arrays.asList(selectedStatuses));
query = queryBuilder.getQuery();
messageInfoCol = client.listMessages(client.getMailboxInfo().getTasksUri(), query);

Java: עבודה עם תצורת משתמש בשרת

Mon, 01 Jan 0001 00:00:00 +0000

ניהול תצורת משתמש

ניתן להשתמש ב‑Aspose.Email ל‑Java כדי לנהל תצורת משתמש על Exchange Server עם ה‑ EWSClient מחלקה. מחלקה זו משתמשת ב‑Exchange Web Services, הזמינות רק ב‑Exchange Server 2007 וגרסאות מאוחרות יותר. במאמר זה נראה כיצד לקרוא, ליצור, לעדכן ולמחוק תצורות משתמש ב‑Exchange Server 2010. נדרש Microsoft Exchange Server 2010 Service Pack 1 לכל הפיצ’רים המתוארים במאמר זה. קטע הקוד הבא מראה לך כיצד להתחבר ל‑Exchange Server 2010 בכל הדוגמאות במאמר זה.

private static IEWSClient getExchangeEWSClient() {
    final String mailboxUri = "https://outlook.office365.com/ews/exchange.asmx";
    final String domain = "";
    final String username = "username@ASE305.onmicrosoft.com";
    final String password = "password";
    NetworkCredential credentials = new NetworkCredential(username, password, domain);
    IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);
    return client;
}

קריאת תצורת משתמש

כדי לקבל את מידע תצורת המשתמש של תיקייה ספציפית מה‑Exchange Server:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.getUserConfiguration() כדי לקבל את תצורת המשתמש עבור תיקייה.
הצג את תכונות תצורת המשתמש כגון מזהה (ID), שם ופריטי מילון כזוגות מפתח‑ערך.

קטעת הקוד הבא מראה לך כיצד לקרוא תצורת משתמש.

IEWSClient client = getExchangeEWSClient();
System.out.println("Connected to Exchange 2010");

// Get the User Configuration for Inbox folder
UserConfigurationName userConfigName = new UserConfigurationName("inbox.config", client.getMailboxInfo().getInboxUri());
UserConfiguration userConfig = client.getUserConfiguration(userConfigName);

System.out.println("Configuration Id: " + userConfig.getId());
System.out.println("Configuration Name: " + userConfig.getUserConfigurationName().getName());
System.out.println("Key value pairs:");
// foreach to while statements conversion
for (Object key : userConfig.getDictionary().keySet()) {
    System.out.println(key + ": " + userConfig.getDictionary().get(key).toString());
}

יצירת תצורות משתמש

כדי ליצור את תצורת המשתמש עבור תיקייה ספציפית ב‑Exchange Server:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.createUserConfiguration() כדי ליצור את תצורת המשתמש עבור תיקייה.

קוד הדוגמה הבא מראה לך כיצד ליצור תצורות משתמש.

IEWSClient client = getExchangeEWSClient();
System.out.println("Connected to Exchange 2010");

// Create the User Configuration for Inbox folder
UserConfigurationName userConfigName = new UserConfigurationName("inbox.config", client.getMailboxInfo().getInboxUri());
UserConfiguration userConfig = new UserConfiguration(userConfigName);
userConfig.getDictionary().put("key1", "value1");
userConfig.getDictionary().put("key2", "value2");
userConfig.getDictionary().put("key3", "value3");
client.createUserConfiguration(userConfig);

עדכון תצורת משתמש

כדי לעדכן את תצורת המשתמש עבור תיקייה ספציפית ב‑Exchange Server:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.updateUserConfiguration() כדי לעדכן את תצורת המשתמש עבור תיקייה.

קטעת הקוד הבא מראה לך כיצד לעדכן תצורת משתמש.

IEWSClient client = getExchangeEWSClient();
System.out.println("Connected to Exchange 2010");

// Create the User Configuration for Inbox folder
UserConfigurationName userConfigName = new UserConfigurationName("inbox.config", client.getMailboxInfo().getInboxUri());
UserConfiguration userConfig = client.getUserConfiguration(userConfigName);
userConfig.setId(null);

// Update User Configuration
userConfig.getDictionary().put("key1", "new-value1");
client.updateUserConfiguration(userConfig);

מחיקת תצורת משתמש

כדי למחוק את תצורת המשתמש עבור תיקייה ספציפית ב‑Exchange Server:

התחבר ל‑Exchange Server באמצעות מחלקת IEWSClient.
קרא למתודה IEWSClient.deleteUserConfiguration() כדי למחוק את תצורת המשתמש עבור תיקייה.

קוד הדוגמה הבא מראה לך כיצד למחוק תצורת משתמש.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);
System.out.println("Connected to Exchange 2010");

// Delete User Configuration
UserConfigurationName userConfigName = new UserConfigurationName("inbox.config", client.getMailboxInfo().getInboxUri());
client.deleteUserConfiguration(userConfigName);

Java: תכונות שימושיות

Mon, 01 Jan 0001 00:00:00 +0000

שליחת הודעה עם אפשרות הצבעה

Microsoft Outlook מאפשר למשתמשים ליצור סקר כאשר הם כותבים הודעה חדשה. זה נעשה על ידי הכללת אפשרויות הצבעה כגון כן, לא, אולי, וכד’. המחלקה FollowUpOptions שמוצעת על ידי Aspose.Email, מספקת את המאפיין VotingButtons שניתן להשתמש בו כדי להגדיר או לקבל את ערך אפשרויות ההצבעה. מאמר זה מספק דוגמה מפורטת ליצירת MapiMessage עם אפשרויות הצבעה ליצירת סקר ולאחר מכן שליחת ההודעה באמצעות Exchange Web Service (EWS) client.

יצירה ושליחת הודעה עם אפשרויות הצבעה

קטע הקוד הבא מציג כיצד ליצור הודעה חדשה ולאחר מכן לשלוח אותה עם אפשרויות הצבעה.

String address = "firstname.lastname@aspose.com";

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
MailMessage message = createTestMessage(address);

// Set FollowUpOptions Buttons
FollowUpOptions options = new FollowUpOptions();
options.setVotingButtons("Yes;No;Maybe;Exactly!");

client.send(message, options);

שיטות לדוגמה שנעשה בהן שימוש בדוגמאות

קטע הקוד הבא מציג כיצד להשתמש בשיטות שהשתמשו בדוגמה למעלה.

private static MailMessage createTestMessage(String address) {
    MailMessage eml = new MailMessage(address, address, "Flagged message",
            "Make it nice and short, but descriptive. The description may appear in search engines' search results pages...");

    return eml;
}

יצירת הודעות RE ו-FW מקבצי MSG

IEWSClient מאפשר למפתחים ליצור הודעות RE (Reply/Reply All) ו-FW (Forward) מהודעה מקורית. הודעה מקורית מזוהה על ידי בחירת ExchangeMessageInfo מתוך ExchangeMessageInfoCollection המתקבל מ-IEWSClient.listMessages(). הארגומנט השני הוא האמיתי MailMessage כדי להישלח כהודעת RE או FW. קטע הקוד הבא מציג כיצד ליצור חשבון לדוגמה המשמש לשליחת הודעה ולאחר מכן מציג את תכונות תגובה והעברה (Reply ו-Forward) על הודעה זו. לבצע זאת:

אתחל את אובייקט IEWSClient על‑ידי אספקת אישורים תקינים.
שלח כמה הודעות לדוגמה.
קרא לפונקציות IEWSClient.reply(), IEWSClient.replyAll() ו-IESWClient.forward() כדי לשלוח הודעות.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credential);

try {
    MailMessage message = new MailMessage("user@domain.com", "user@domain.com", "TestMailRefw - " + UUID.randomUUID().toString(),
            "TestMailRefw Implement ability to create RE and FW messages from source MSG file");

    client.send(message);

    ExchangeMessageInfoCollection messageInfoCol = client.listMessages(client.getMailboxInfo().getInboxUri());
    if (messageInfoCol.size() == 1)
        System.out.println("1 message in Inbox");
    else
        System.out.println("Error! No message in Inbox");

    MailMessage message1 = new MailMessage("user@domain.com", "user@domain.com", "TestMailRefw - " + UUID.randomUUID().toString(),
            "TestMailRefw Implement ability to create RE and FW messages from source MSG file");

    client.send(message1);
    messageInfoCol = client.listMessages(client.getMailboxInfo().getInboxUri());

    if (messageInfoCol.size() == 2)
        System.out.println("2 messages in Inbox");
    else
        System.out.println("Error! No new message in Inbox");

    MailMessage message2 = new MailMessage("user@domain.com", "user@domain.com", "TestMailRefw - " + UUID.randomUUID().toString(),
            "TestMailRefw Implement ability to create RE and FW messages from source MSG file");
    message2.getAttachments().addItem(Attachment.createAttachmentFromString("Test attachment 1", "Attachment Name 1"));
    message2.getAttachments().addItem(Attachment.createAttachmentFromString("Test attachment 2", "Attachment Name 2"));

    // Reply, Replay All and forward Message
    client.reply(message2, messageInfoCol.get_Item(0));
    client.replyAll(message2, messageInfoCol.get_Item(0));
    client.forward(message2, messageInfoCol.get_Item(0));
} catch (java.lang.RuntimeException ex) {
    System.out.println("Error in program" + ex.getMessage());
}

תמיכת OAuth עבור EWS עם Office 365

Aspose.Email API מספקת תמיכה ב-Exchange Web Service (EWS) עם Office 365. ה-API’s EWSClient interface מספקת מתוד overload שמספקת את OAuthNetworkCredential כקלט לגישה לחשבון Exchange באמצעות OAuth. המשתמש צריך לספק את Authority, Client Id, Client App Uri ו-Resource כדי שהפעולה תעבוד. קטע הקוד הבא מציג תמיכת OAuth ל-EWS עם Office 365.

// token provider
/*ITokenProvider provider = new ITokenProvider() {

    @Override
    public void dispose() {
    }

    @Override
    public OAuthToken getAccessToken(boolean ignoreExistingToken) {
        return null;
    }

    @Override
    public OAuthToken getAccessToken() {
        return null;
    }
};

NetworkCredential credentials = new OAuthNetworkCredential(provider);*/

// accessToken
NetworkCredential credentials = new OAuthNetworkCredential("accessToken");

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", credentials);
client.listMessages();

תמיכה בתיעוד בלקוחות Exchange

Aspose.Email API מספקת את היכולת להציע מתקן תיעוד ללקוח Exchange Web Service.

תיעוד עבור לקוח EWS

client.setLogFileName("logs/ews");
// OR
EWSClient.setCommonLogFileName("logs/ews");

הוספת כותרות בבקשות EWS

Aspose.Email API מאפשרת הוספת כותרות לבקשות Exchange. ניתן להשתמש בכך להוספת כותרות לבקשות EWS עבור כותרות שונות אשר משמשות למטרות שונות. דוגמה אחת יכולה להיות הוספת הכותרת X-AnchorMailbox המשמשת לניהול בעיות מהירות (throttling) בשרת Exchange. השיטה addHeader של IEWSClient משמשת להוספת כותרות לבקשות EWS כפי שמוצג בקטע הקוד הבא.

final IEWSClient client = EWSClient.getEWSClient("exchange.domain.com/ews/Exchange.asmx", "username", "password", "");
try {
    client.addHeader("X-AnchorMailbox", "username@domain.com");
    ExchangeMessageInfoCollection messageInfoCol = client.listMessages(client.getMailboxInfo().getInboxUri());
} finally {
    client.dispose();
}

החזרת מזהה בקשת הלקוח בכותרת

ה return-client-request-id הכותרת נשלחת בבקשה ומשמשת את השרת כדי לקבוע האם ה client-request-id הכותרת שהוגדרה על ידי הלקוח צריכה להיות מוחזרת בתשובת השרת. המתודות הבאות משמשות בפעולה זו:

getReturnClientRequestId()
setReturnClientRequestId(boolean value) - קבל או הגדר דגל שמציין האם הלקוח דורש שהשרת יחזיר את מזהה הבקשה.

try (IEWSClient client = createEWSClient())
{
    // Client will create random id and pass it to the server.
    // The server should include this id in request-id header of all responses.
    client.setReturnClientRequestId(true);
    
    client.setLogFileName("ews.log");
    client.getMailboxInfo();
}

עבודה עם הודעות מאוחדות

Aspose.Email יכולה לאחזר מידע על הודעות מאוחדות (Unified Messaging) מ-Exchange Server 2010. הודעות מאוחדות כגון קבלת מידע תצורה, יזום שיחה יוצאת, אחזור מידע על שיחה בטלפון לפי מזהה השיחה וסיום שיחה לפי מזהה נתמכת כיום. קטע הקוד הבא מציג כיצד לאחזר מידע תצורת הודעות מאוחדות מ-Microsoft Exchange Server 2010.

IEWSClient client = EWSClient.getEWSClient(mailboxUri, credential);
UnifiedMessagingConfiguration umConf = client.getUMConfiguration();

קבלת טיפים למייל

Microsoft Exchange Server הוסיף מספר תכונות חדשות ב-Exchange Server 2010 ו-2013. אחת מהן מאפשרת למשתמשים לקבל טיפים למייל בעת כתיבת הודעה. טיפים אלו מועילים מכיוון שהם מספקים מידע לפני שליחת המייל. לדוגמה, אם כתובת הדוא"ל שגויה ברשימת הנמענים, מוצג טיפ שמודיע שהכתובת אינה תקינה. טיפים למייל מאפשרים גם לראות תגובות מחוץ למשרד לפני שליחת המייל: Exchange Server (2010 ו-2013) שולח את הטיפ בזמן כתיבת המייל אם אחד או יותר מהנמענים הגדרו תגובה מחוץ למשרד. נדרש Microsoft Exchange Server 2010 Service Pack 1 לכל התכונות המוצגות במאמר זה. קטע הקוד הבא מציג כיצד להשתמש ב- EWSClient class שמשתמשת ב-Exchange Web Services, זמינה ב-Microsoft Exchange Server 2007 ומגרסאות מאוחרות יותר.

// Create instance of EWSClient class by giving credentials
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser", "pwd", "domain");
System.out.println("Connected to Exchange server...");
// Provide mail tips options
MailAddressCollection addrColl = new MailAddressCollection();
addrColl.addMailAddress(new MailAddress("test.exchange@ex2010.local", true));
addrColl.addMailAddress(new MailAddress("invalid.recipient@ex2010.local", true));
GetMailTipsOptions options = new GetMailTipsOptions(MailAddress.to_MailAddress("administrator@ex2010.local"), addrColl, MailTipsType.All);

// Get Mail Tips
MailTips[] tips = client.getMailTips(options);

// Display information about each Mail Tip
for (MailTips tip : tips) {
    // Display Out of office message, if present
    if (tip.getOutOfOffice() != null) {
        System.out.println("Out of office: " + tip.getOutOfOffice().getReplyBody().getMessage());
    }

    // Display the invalid email address in recipient, if present
    if (tip.getInvalidRecipient() == true) {
        System.out.println("The recipient address is invalid: " + tip.getRecipientAddress());
    }
}

התחזות ב-Exchange

התחזות ב-Exchange מאפשרת למישהו להעמיד פנים שהחשבון הוא של משתמש אחר ולבצע משימות ופעולות באמצעות ההרשאות של החשבון המתחזה במקום שלו. בעוד שהאצלת סמכות מאפשרת למשתמשים לפעול בשם משתמשים אחרים, התחזות מאפשרת לפעול כמשתמשים אחרים. Aspose.Email תומכת בהתחזות ב-Exchange. ה EWSClient class מספקת את השיטות ImpersonateUser ו-ResetImpersonation לצורך הקלות השימוש בתכונה זו.

כדי לבצע משימה זו:

אתחול ExchangeWebServiceClient עבור משתמש 1.
אתחול ExchangeWebServiceClient עבור משתמש 2.
הוספת הודעות בדיקה לחשבונות.
הפעלת התחזות.
איפוס התחזות.

קטעת הקוד הבא מראה לך כיצד להשתמש ב- EWSClient class למימוש תכונת ההתחזות.

// Create instance's of EWSClient class by giving credentials
IEWSClient client1 = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser1", "pwd", "domain");
IEWSClient client2 = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testUser2", "pwd", "domain");
{
    String folder = "Drafts";
    try {
        for (ExchangeMessageInfo messageInfo : (Iterable<ExchangeMessageInfo>) client1.listMessages(folder))
            client1.deleteItem(messageInfo.getUniqueUri(), DeletionOptions.getDeletePermanently());
        String subj1 = "NETWORKNET_33354 User User1";
        client1.appendMessage(folder, new MailMessage("User1@exchange.conholdate.local", "To@aspsoe.com", subj1, ""));

        for (ExchangeMessageInfo messageInfo : (Iterable<ExchangeMessageInfo>) client2.listMessages(folder))
            client2.deleteItem(messageInfo.getUniqueUri(), DeletionOptions.getDeletePermanently());
        String subj2 = "NETWORKNET_33354 User User2";
        client2.appendMessage(folder, new MailMessage("User2@exchange.conholdate.local", "To@aspose.com", subj2, ""));

        ExchangeMessageInfoCollection messInfoColl = client1.listMessages(folder);
        // Assert.AreEqual(1, messInfoColl.Count);
        // Assert.AreEqual(subj1, messInfoColl[0].Subject);

        client1.impersonateUser(ItemChoice.PrimarySmtpAddress, "User2@exchange.conholdate.local");
        ExchangeMessageInfoCollection messInfoColl1 = client1.listMessages(folder);
        // Assert.AreEqual(1, messInfoColl1.Count);
        // Assert.AreEqual(subj2, messInfoColl1[0].Subject);

        client1.resetImpersonation();
        ExchangeMessageInfoCollection messInfoColl2 = client1.listMessages(folder);
        // Assert.AreEqual(1, messInfoColl2.Count);
        // Assert.AreEqual(subj1, messInfoColl2[0].Subject);
    } finally {
        try {
            for (ExchangeMessageInfo messageInfo : (Iterable<ExchangeMessageInfo>) client1.listMessages(folder))
                client1.deleteItem(messageInfo.getUniqueUri(), DeletionOptions.getDeletePermanently());
            for (ExchangeMessageInfo messageInfo : (Iterable<ExchangeMessageInfo>) client2.listMessages(folder))
                client2.deleteItem(messageInfo.getUniqueUri(), DeletionOptions.getDeletePermanently());
        } catch (java.lang.RuntimeException e) {
        }
    }
}

תכונת גילוי אוטומטי באמצעות EWS

Aspose.Email API מאפשרת לך לגלות את ההגדרות של שרת Exchange באמצעות לקוח EWS.

AutodiscoverService svc = new AutodiscoverService();
svc.setCredentials(new NetworkCredential(email, password));

IGenericDictionary</* UserSettingName */Integer, Object> userSettings = svc.getUserSettings(email, UserSettingName.ExternalEwsUrl).getSettings();
String ewsUrl = (String) userSettings.get_Item(UserSettingName.ExternalEwsUrl);
System.out.println("Auto discovered EWS Url: " + ewsUrl);

ביטול שחזור PST לשרת Exchange

Aspose.Email API מאפשרת לשחזר קובץ PST לשרת Exchange. עם זאת, אם הפעולה נמשכת זמן רב עקב קובץ PST גדול, ייתכן שיהיה צורך לציין קריטריון להפסקת הפעולה. ניתן להשיג זאת באמצעות ה-API כפי שמוצג בקוד הדוגמה הבא.

final IEWSClient client = EWSClient.getEWSClient("https://exchange.office365.com/ews/exchange.asmx", "username", "password");
try {
    final long startTime = System.currentTimeMillis();
    final AtomicInteger processedItems = new AtomicInteger(0);
    final long S15 = 15 * 1000;

    BeforeItemCallback callback = new BeforeItemCallback() {
        public void invoke(ItemCallbackArgs item) {
            if (System.currentTimeMillis() - startTime > S15) {
                throw new AbortRestoreException();
            }

            processedItems.incrementAndGet();
        }
    };

    try {
        // create a test pst and add some test messages to it
        PersonalStorage pst = PersonalStorage.create(new ByteArrayOutputStream(), FileFormatVersion.Unicode);
        FolderInfo folder = pst.getRootFolder().addSubFolder("My test folder");
        for (int i = 0; i < 20; i++) {
            MapiMessage message = new MapiMessage("from@gmail.com", "to@gmail.com", "subj", "body");
            folder.addMessage(message);
        }
        RestoreSettings rs = new RestoreSettings();
        rs.setBeforeItemCallback(callback);

        // now restore the PST with callback
        client.restore(pst, rs);
        System.out.println("Success!");
    } catch (AbortRestoreException e) {
        System.out.println("Timeout! " + processedItems.get());
    }
} finally {
    client.dispose();
}

Java: סינון פגישות מ‑Exchange Server

Mon, 01 Jan 0001 00:00:00 +0000

סינון פגישות עם EWS

ה IEWSClient מציע אפשרות לסנן פגישות מה‑Exchange Server באמצעות ExchangeQueryBuilder. ניתן לסנן פגישות לפי:

תאריכים
חזרות

סינון פגישות לפי תאריכים

IEWSClient client = EWSClient.getEWSClient(mailboxUri, username, password, domain);

SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
Date startTime = sdf.parse("15/09/2017 00:00:00");
Date endTime = sdf.parse("10/10/2017 00:00:00");
ExchangeQueryBuilder builder = new ExchangeQueryBuilder();
builder.getAppointment().getStart().since(startTime);
builder.getAppointment().getEnd().beforeOrEqual(endTime);
MailQuery query = builder.getQuery();
Appointment[] appointments = client.listAppointments(query);

סינון פגישות לפי אירועים חוזרים

builder = new ExchangeQueryBuilder();
builder.getAppointment().isRecurring().equals(false);
query = builder.getQuery();
appointments = client.listAppointments(query);

Java: עבודה עם תכונות מורחבות של פריטי Exchange

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email API מאפשרת ליצור, לאחזר ולעדכן תכונות מורחבות של הודעות באמצעות לקוח EWS של ה‑API. דוגמת הקוד שלהלן מדגימה זאת על‑ידי יצירת תכונה מורחבת, הוספתה להודעה על השרת והחזרת ההודעה כ‑ MapiMessage מתוך Exchange server באמצעות ה‑client של הלקוח fetchItem.

// Define a PidTagBodyContentId extended property
PropertyDescriptor extendedProperty = KnownPropertyList.BODY_CONTENT_ID;

// Create a message and set an extended property value
MapiMessage msg = new MapiMessage("from@from.com", "to@to.com",
        "Test message", "This is a test message");
msg.setProperty(extendedProperty, "03454432-6230-4e4b-887f-a498ea223599");

// Append message
String uri = ewsClient.appendMessage(ewsClient.getMailboxInfo().getInboxUri(), msg, true);

// Fetch appended item. Pass the extended property descriptor as method parameter.
MapiMessage fetchedMsg = ewsClient.fetchItem(uri, Arrays.asList(new PropertyDescriptor[] { extendedProperty }));

// Print the extended property value
System.out.println(fetchedMsg.getProperties().get_Item(extendedProperty).getString());

Java: עבודה עם ארכיון במיקום (In-Place Archive)

Mon, 01 Jan 0001 00:00:00 +0000

ארכיונים במיקום ב-Office 365

ארכיונים במיקום (In-Place Archives) ב-Office 365 מספקים למשתמשים שטח אחסון נוסף. לאחר הפעלת תיבות הדואר בארכיון, משתמשים יכולים לגשת לאחסן הודעות בתיבת הארכיון שלהם באמצעות Microsoft Outlook ו-Outlook on the Web. כאשר תיבת דואר עם ארכיון במיקום פתוחה ב-Outlook, תיבת הארכיון מוצגת כתיבת דואר נפרדת.

העברת פריטים לארכיון במיקום

Aspose.Email API יכולה לשמש להעברת פריטים לתיקיית הארכיון של משתמשים באמצעות ה- IEWSClient.archiveItem שיטה. IEWSClient.archiveItem מתודה מספקת ארבע overloads שמפורטות להלן.

archiveItem(String sourceFolderUri, Appointment appointment)
archiveItem(String sourceFolderUri, ExchangeTask task)
archiveItem(String sourceFolderUri, MapiMessageItemBase item)]
archiveItem(String sourceFolderUri, String uniqueId)

דוגמת הקוד המוצגת למטה מדגימה את השימוש ב- IEWSClient.archiveItem מתודה להעברת אימייל לתיקיית ארכיון באמצעות UniqueUri.

NetworkCredential credentials = new NetworkCredential(username, password, domain);
IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);

ExchangeMessageInfoCollection msgCollection = client.listMessages(client.getMailboxInfo().getInboxUri());

for (ExchangeMessageInfo msgInfo : (Iterable<ExchangeMessageInfo>) msgCollection) {
    System.out.println("Subject:" + msgInfo.getSubject());
    client.archiveItem(client.getMailboxInfo().getInboxUri(), msgInfo.getUniqueUri());
}
client.dispose();

Java: קבל הודעות מתיבת דואר משותפת

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email תומך בגישה להודעות מתיבת הדואר המשותפת. כדי לבצע זאת, אתה מתחבר לתיבת הדואר הראשית שלך באמצעות EWSClient class. כדי לגשת להודעות מתיבת הדואר המשותפת, יש להעביר את תיבת הדואר המשותפת כפרמטר מחרוזת ל- listMessages או listItems שיטה.

דוגמת הקוד הבאה מציגה כיצד לגשת להודעות מתיבת הדואר המשותפת באמצעות listItems שיטה.

final String mailboxUri = "<HOST>";
final String domain = "";
final String username = "<EMAIL ADDRESS>";
final String password = "<PASSWORD>";
final String sharedEmail = "<SHARED EMAIL ADDRESS>";
NetworkCredential credentials = new NetworkCredential(username, password, domain);
IEWSClient client = EWSClient.getEWSClient(mailboxUri, credentials);

String[] items = client.listItems(sharedEmail, "Inbox");

for (String item : items) {
    MapiMessage msg = client.fetchItem(item);
    System.out.println("Subject:" + msg.getSubject());
}
client.dispose();

Java: תמיכה ב-TLS 1.2 וב‑AutodiscoverService

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email for Java תומך כעת ב‑TLS 1.2 באמצעות SAAJ API. ה‑ EWSClient מספק מאפיין סטטי useSAAJAPI ניתן להגדיר זאת ל‑true לשימוש ב‑TLS 1.2. Aspose.Email for Java תומך גם ב‑ AutodiscoverService ל‑TLS 1.2. דוגמות הקוד הבאות מציגות את השימוש ב‑SAAJ API ו‑ AutodiscoverService ל‑TLS 1.2.

השתמש ב‑SAAJ API

לקוח ה‑SOAP של Java EE בשימוש במצב SAAJAPI - https://docs.oracle.com/cd/E19651-01/817-2151-10/wsgjaxm.html.

דוגמת הקוד הבאה מציגה שימוש ב‑SAAJ API על‑ידי הגדרת EWSClient.useSAAJAPI מאפיין ל-true.

בקטטע הקוד הבא יוקצה כותרת אימות Basic:

EWSClient.useSAAJAPI(true);
IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", "testuser", "pw", "domain");
client.listMessages();

בקטטע הקוד הבא יוקצה כותרת אימות OAUTH2:

EWSClient.useSAAJAPI(true);
// token provider
/*ITokenProvider provider = new ITokenProvider() {

    @Override
    public void dispose() {
    }

    @Override
    public OAuthToken getAccessToken(boolean ignoreExistingToken) {
        return null;
    }

    @Override
    public OAuthToken getAccessToken() {
        return null;
    }
};

NetworkCredential credentials = new OAuthNetworkCredential(provider);*/

// accessToken
NetworkCredential credentials = new OAuthNetworkCredential("accessToken");

IEWSClient client = EWSClient.getEWSClient("https://outlook.office365.com/ews/exchange.asmx", credentials);
client.listMessages();

שים לב שבמצב זה, ה‑API אינו שולט בתהליך האימות של NTLM. נדרש Java Authenticator לאימות NTLM.

קטע קוד האימות NTLM עבור Java 8:

import java.net.Authenticator;
import java.net.PasswordAuthentication;
import java.net.URL;

static Authenticator getAuthenticator(String user, String pw, String domain) {
    final String username = domain + "\\" + user;
    final String password = pw;
    System.out.println("New Credentials " + username);
    return new Authenticator() {
        protected PasswordAuthentication getPasswordAuthentication() {
            System.out.println("Authenticate " + username);
            return new PasswordAuthentication(username, password.toCharArray());
        }
    };
}

EWSClient.useSAAJAPI(true);
System.setProperty("http.auth.preference", "NTLM");
Authenticator.setDefault(getAuthenticator("user", "pw", ""));
IEWSClient client = EWSClient.getEWSClient(new URL("https://domain.com/ews/Exchange.asmx"));

static Authenticator getAuthenticator() {

    // This block is written for suppressing a bug in sun implementation.
    // In Sun Impl client doesn't authenticate user for each connection,
    // uses cached credentials instead.
    sun.net.www.protocol.http.AuthCacheValue.setAuthCache(new sun.net.www.protocol.http.AuthCache() {
        public void remove(String pkey, sun.net.www.protocol.http.AuthCacheValue entry) {
        }
        public void put(String pkey, sun.net.www.protocol.http.AuthCacheValue value) {
        }
        public sun.net.www.protocol.http.AuthCacheValue get(String pkey, String skey) {
            return null;
        }
    });

    return new Authenticator() {
        protected PasswordAuthentication getPasswordAuthentication() {
            return getEmbeddedCredentials(getRequestingURL());
        }

        PasswordAuthentication getEmbeddedCredentials(URL url) {
            if (url == null) {
                return null;
            }
            String userInfo = url.getUserInfo();
            int colon = userInfo == null ? -1 : userInfo.indexOf(":");
            if (colon == -1) {
                return null;
            } else {
                String userName = userInfo.substring(0, colon);
                String pass;
                try {
                    pass = URLDecoder.decode(userInfo.substring(colon + 1), "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    pass = "";
                }
                System.out.println("Authenticate " + userInfo);
                return new PasswordAuthentication("\\" + userName, pass.toCharArray());
            }
        }
    };
}

static URL getURL(String url, String user, String pw, String domain) throws Exception {
    String host = new URL(url).getHost();
    URL endpoint = new URL(url.replace(host, user + ":" + URLEncoder.encode(pw, "UTF-8") + "@" + host));

    return endpoint;
}

EWSClient.useSAAJAPI(true);
Authenticator.setDefault(getAuthenticator());

System.setProperty("http.auth.preference", "NTLM");
IEWSClient client1 = EWSClient.getEWSClient(getURL("https://domain.com/ews/Exchange.asmx", "user1", "pw", "domain"));
IEWSClient client2 = EWSClient.getEWSClient(getURL("https://domain.com/ews/Exchange.asmx", "user2", "pw", "domain"));

מאז Java 9, ניתן להגדיר את ה‑Authenticator לחיבור:

static Map<String, Authenticator> authInfo = new HashMap<String, Authenticator>();
static URL getURL(String url, final String user, final String pw, final String domain) throws MalformedURLException {
    URL endpoint = new URL(new URL(url), "", new URLStreamHandler() {
        protected URLConnection openConnection(URL url) throws IOException {
            URL target = new URL(url.toString());
            HttpURLConnection connection = (HttpURLConnection) target.openConnection();
            // Cache for User@Url
            Authenticator auth = authInfo.get(user + "@" + url);
            if (auth == null) {
                auth = new Authenticator() {
                    protected PasswordAuthentication getPasswordAuthentication() {
                        System.out.println("Authenticate " + user);
                        return new PasswordAuthentication(domain + "\\" + user, pw.toCharArray());
                    }
                };
                authInfo.put(user + "@" + url, auth);
            }
            connection.setAuthenticator(auth);

            return connection;
        }
    });

    return endpoint;
}

EWSClient.useSAAJAPI(true);
System.setProperty("http.auth.preference", "NTLM");
IEWSClient client1 = EWSClient.getEWSClient(getURL("https://domain.com/ews/Exchange.asmx", "user1", "pw", "domain"));
IEWSClient client2 = EWSClient.getEWSClient(getURL("https://domain.com/ews/Exchange.asmx", "user2", "pw", "domain"));

הערה: ממשקי ה‑JAXB נחשבים לממשקי Java EE, ולכן אינם כלולים יותר בנתיב המחלקות ברירת המחדל ב‑Java SE 9.

תלויות Maven של JAXB:

<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
</dependency>
<dependency>
    <groupId>com.sun.xml.bind</groupId>
    <artifactId>jaxb-impl</artifactId>
</dependency>
<dependency>
    <groupId>com.sun.xml.bind</groupId>
    <artifactId>jaxb-core</artifactId>
</dependency>
<dependency>
    <groupId>com.sun.xml.messaging.saaj</groupId>
    <artifactId>saaj-impl</artifactId>
</dependency>

השתמש ב‑AutodiscoverService

דוגמת הקוד הבאה מציגה את השימוש ב‑ AutodiscoverService ל‑TLS 1.2

AutodiscoverService service = new AutodiscoverService();
service.setCredentials(new NetworkCredential("user", "password"));
GetUserSettingsResponse response = service.getUserSettings("userSmtpAddress", UserSettingName.ExternalEwsUrl, UserSettingName.UserDisplayName);