Documentation – עבודה עם פריטי Outlook

Java: יצירה ושמירת קבצי MSG

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

Aspose.Email תומך ביצירת קבצי הודעת Outlook (MSG). מאמר זה מסביר כיצד:

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

יצירת ושמירת הודעות Outlook

ה MailMessage מחלקה מכילה את שמירה מתודה שיכולה לשמור קבצי Outlook MSG לכונן או ל‑stream. הקטעי קוד למטה יוצרים מופע של ה‑ MailMessage מחלקה, הגדר מאפיינים כמו from, to, subject ו‑body. ה‑ שמירה מתודה מקבלת את שם הקובץ כארגומנט. בנוסף, ניתן ליצור הודעות Outlook עם a גוף RTF דחוס באמצעות ה- MapiConversionOptions.

צור מופע חדש של ה‑ MailMessage מחלקה ומגדירה את המאפיינים From, To, Subject ו‑Body.
הפעל את MapiMessage מחלקה fromMailMessage מתודה שמקבלת את האובייקט של ה‑ MailMessage סוג. ה‑ fromMailMessage מתודה ממירה את MailMessage ל‑ MapiMessage (MSG).
הפעל את MapiMessage.save מתודה לשמירת קובץ MSG.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

// Create an instance of the MailMessage class
MailMessage mailMsg = new MailMessage();

// Set from, to, subject and body properties
mailMsg.setFrom(MailAddress.to_MailAddress("sender@domain.com"));
mailMsg.setTo(MailAddressCollection.to_MailAddressCollection("receiver@domain.com"));
mailMsg.setSubject("This is test message");
mailMsg.setBody("This is test body");

// Create an instance of the MapiMessage class and pass MailMessage as argument
MapiMessage outlookMsg = MapiMessage.fromMailMessage(mailMsg);

// Save the message (MSG) file
String strMsgFile = "CreatingAndSavingOutlookMessages_out.msg";
outlookMsg.save(dataDir + strMsgFile);

יצירת קבצי MSG עם קבצים מצורפים

בדוגמה למעלה, יצרנו קובץ MSG פשוט. Aspose.Email גם תומך בשמירת קבצי הודעות עם קבצים מצורפים. כל שעליך לעשות הוא להוסיף את הקבצים המצורפים ל‑ MailMessage מופע. הוסף קבצים מצורפים על‑ידי קריאה למתודה addItem על ה‑ MailMessage.Attachments אוסף.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

String[] files = new String[2];
files[0] = "attachment.doc";
files[1] = "attachment.png";

// Create an instance of the MailMessage class
MailMessage mailMsg = new MailMessage();

// Set from, to, subject and body properties
mailMsg.setFrom(MailAddress.to_MailAddress("sender@domain.com"));
mailMsg.setTo(MailAddressCollection.to_MailAddressCollection("receiver@domain.com"));
mailMsg.setSubject("This is test message");
mailMsg.setBody("This is test body");

// Add the attachments
for (String strFileName : files)
{
    mailMsg.getAttachments().addItem(new Attachment(strFileName));
}

// Create an instance of MapiMessage class and pass MailMessage as argument
MapiMessage outlookMsg = MapiMessage.fromMailMessage(mailMsg);
String strMsgFile = "CreateMessagesWithAttachments.msg";
outlookMsg.save(dataDir + strMsgFile);

יצירת קבצי MSG עם גוף RTF

ניתן גם ליצור קבצי Outlook Message (MSG) עם גופי טקסט עשיר (RTF) באמצעות Aspose.Email. גוף ה‑RTF תומך בעיצוב טקסט. צור אחד על‑ידי הגדרת ה‑ MailMessage.HtmlBody מאפיין. כאשר ממירים a MailMessage מופע ל‑ MapiMessage במקרה זה, גוף ה‑HTML מומר ל‑RTF. כך נשמר העיצוב של גוף האימייל.

הדוגמה הבאה יוצרת קובץ MSG עם גוף RTF. יש כותרת אחת, ועיצוב מודגש וקו תחתי מיושמים בגוף ה‑HTML. עיצוב זה נשמר כאשר ה‑HTML מומר ל‑RTF.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

// Create an instance of the MailMessage class
MailMessage mailMsg = new MailMessage();

// Set from, to, subject and body properties
mailMsg.setFrom(MailAddress.to_MailAddress("sender@domain.com"));
mailMsg.setTo(MailAddressCollection.to_MailAddressCollection("receiver@domain.com"));
mailMsg.setSubject("This is test message");
mailMsg.setHtmlBody("<h3>rtf example</h3><p>creating an <b><u>outlook message (msg)</u></b> file using Aspose.Email.</p>");

MapiMessage outlookMsg = MapiMessage.fromMailMessage(mailMsg);
outlookMsg.save(dataDir + "CreatingMSGFilesWithRTFBody_out.msg");

שמירת הודעה במצב טיוטה

הודעות אימייל נשמרות כטיוטות כאשר מישהו החל לערוך אותן אך רוצה לחזור אליהן כדי להשלים אותן מאוחר יותר. Aspose.Email תומך בשמירת הודעות אימייל במצב טיוטה על ידי הגדרת דגל הודעה. להלן קוד לדוגמה לשמירת הודעת Outlook (MSG) כטיוטה.

שימו לב שבמצב טיוטה, Outlook אינו מציג מידע שולח שמוקצה ל‑MapiMessage. אם יש צורך להציג מידע שולח, יש להגדיר דגל MSGFLAG_READ.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

// Change properties of an existing MSG file
String strExistingMsg = "message.msg";

// Load the existing file in MailMessage and Change the properties
MailMessage msg = MailMessage.load(dataDir + strExistingMsg, new MsgLoadOptions());
msg.setSubject(msg.getSubject() + " NEW SUBJECT (updated by Aspose.Email)");
msg.setHtmlBody(msg.getHtmlBody() + " NEW BODY (udpated by Aspose.Email)");

// Create an instance of type MapiMessage from MailMessage, Set message flag to un-sent (draft status) and Save it
MapiMessage mapiMsg = MapiMessage.fromMailMessage(msg);
mapiMsg.setMessageFlags(MapiMessageFlags.MSGFLAG_UNSENT);
mapiMsg.save(dataDir + "SavingMessageInDraftStatus_out.msg");

השלכות של דחיסת גוף

שיטת דחיסת גוף RTF יכולה לשמש ליצירת MSG בגודל קטן יותר. עם זאת, היא גורמת למהירות יצירה איטית יותר. כדי ליצור הודעות במהירות משופרת, הגדר את הדגל ל‑false. דגל זה, בתורו, משפיע על קבצי PST שנוצרו: קבצי MSG קטנים יותר מניבים PST קטן יותר, וקבצי MSG גדולים יותר גורמים ליצירת PST איטית יותר.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
String fileName = "outlook/test.msg";

MailMessage message = MailMessage.load(fileName);
MapiConversionOptions options = new MapiConversionOptions();
options.setUseBodyCompression(true);
MapiMessage ae_mapi = MapiMessage.fromMailMessage(message, options);

Java: טעינה, צפייה ופירוש קובץ MSG

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

נושא זה מסביר כיצד לטעון קובץ הודעת Microsoft Outlook (*.msg). ה‑ MapiMessage המחלקה משמשת לטעינת קבצי MSG ומספקת מספר פונקציות טעינה סטטיות לתרחישים שונים. הקוד שלהלן מציג כיצד לטעון קבצי MSG מקובץ או מזרם.

טעינת קבצי MSG

הקטע הקוד שלהלן מציג כיצד לטעון קבצי MSG.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = RunExamples.getDataDir_Outlook();

// Create an instance of MapiMessage from file
MapiMessage msg = MapiMessage.fromFile(dataDir + "message.msg");

// Get subject
System.out.println("Subject:" + msg.getSubject());

// Get from address
System.out.println("From:" + msg.getSenderEmailAddress());

// Get body
System.out.println("Body" + msg.getBody());

// Get recipients information
System.out.println("Recipient: " + msg.getRecipients());

// Get attachments
for (MapiAttachment att : msg.getAttachments())
{
    System.out.println("Attachment Name: " + att.getFileName());
    System.out.println("Attachment Display Name: " + att.getDisplayName());
}

דוגמת הקוד שלהלן מציגה כיצד להשתמש ב‑MailMessage לטעון הודעה בפורמט MSG.

MailMessage eml = MailMessage.load("message.msg");

יש לציין שההודעה המתקבלת מומרת לפורמט EML, כולל קבצי ההודעה המשובצים. אל תשתמש בשיטת טעינה זו אם ברצונך לשמר תכונות פורמט msg ספציפיות של ההודעה המקורית.

כדי לשמר את הפורמט המקורי של קבצי ההודעה המשובצים, השתמש ב‑ MsgLoadOptions.PreserveEmbeddedMessageFormat מאפיין.

MsgLoadOptions msgLoadOptions = new MsgLoadOptions();
msgLoadOptions.setPreserveEmbeddedMessageFormat(true);
MailMessage msg = MailMessage.load(stream, msgLoadOptions);

טעינה מזרם

הקוד שלהלן מציג כיצד לטעון קובץ מזרם.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Create an instance of MapiMessage from file
try (FileInputStream stream = new FileInputStream(dataDir + "message.msg"))
{
    // Create an instance of MapiMessage from file
    MapiMessage msg = MapiMessage.fromStream(stream);

    // Get subject
    System.out.println("Subject:" + msg.getSubject());

    // Get from address
    System.out.println("From:" + msg.getSenderEmailAddress());

    // Get body
    System.out.println("Body" + msg.getBody());

}

המרת EML ל‑MSG תוך שמירת פורמט EML משובץ

קבצי EML ניתנים לטעינה לתוך MapiMessage מחלקה על‑ידי יצירת מופע של MailMessage אובייקט ולהעבירו ל‑ MapiMessage.fromMailMessage שיטה. אם קובץ ה‑EML מכיל קבצי EML משובצים, השתמש ב‑ MapiConversionOptions.setPreserveEmbeddedMessageFormat כדי לשמור על הפורמט של קבצי EML משובצים. הקטע הקוד שלהלן מציג כיצד לטעון קבצי EML לתוך MapiMessage במקביל לשימור הפורמט של קבצי EML משובצים.

נסו זאת!

המרת אימיילים וארכיוני הודעות באופן מקוון בחינם יישום המרה של Aspose.Email.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
String dataDir = RunExamples.getDataDir_Email();

MailMessage eml = MailMessage.load(dataDir + "sample.eml", new EmlLoadOptions());

MapiConversionOptions options = MapiConversionOptions.getUnicodeFormat();

//Preserve Embedded Message Format
options.setPreserveEmbeddedMessageFormat(true);

//Convert EML to MSG with Options
MapiMessage msg = MapiMessage.fromMailMessage(eml, options);

Java: ניהול קבצי הודעות עם Aspose.Email.Outlook

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

המרת MSG להודעת MIME

ממשק ה‑API של Aspose.Email מספק אפשרות להמרת קובצי MSG להודעות MIME באמצעות ה- toMailMessage שיטה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
MapiMessage msg = new MapiMessage(
                            "sender@test.com",
                            "recipient1@test.com; recipient2@test.com",
                            "Test Subject",
                            "This is a body of message.");
MailConversionOptions options = new MailConversionOptions();
options.setConvertAsTnef(true);
MailMessage mail = msg.toMailMessage(options);

המרת MSG ל‑EML תוך שמירת גוף RTF

ה‑API מספק את השיטות הבאות לשימור גוף RTF בעת המרת MSG ל‑EML:

MsgLoadOptions.PreserveRtfContent - מקבל או מגדיר ערך המציין האם לשמור את גוף ה‑rtf ב‑MailMessage.
MailConversionOptions.PreserveRtfContent - מקבל או מגדיר ערך המציין האם לשמור את גוף ה‑rtf ב‑MailMessage.

דגימות הקוד שלהלן ממחישות כיצד לשמור את גוף ה‑rtf ב‑MailMessage:

באמצעות MsgLoadOptions.PreserveRtfContent

MsgLoadOptions options = new MsgLoadOptions();
options.setPreserveRtfContent(true);
MailMessage message = MailMessage.load("fileName", options);

באמצעות MailConversionOptions.PreserveRtfContent

MapiMessage mapi = MapiMessage.load("fileName");
MailConversionOptions options = new MailConversionOptions();
options.setPreserveRtfContent(true);
MailMessage message = mapi.toMailMessage(options);

המרת MSG ל‑MHTML תוך שמירת כותרת הקטגוריה

ממשק ה‑API של Aspose.Email מספק אפשרות להוסיף כותרת קטגוריה בעת המרת הודעה ל‑MHTML. תכונה זו מוגדרת על‑ידי MhtSaveOptions class כאפשרות נוספת בעת שמירת MailMessage לפורמט Mhtml.

דוגמת הקוד הבאה ממחישה כיצד ליצור קובץ MHT (MHTML) מאובייקט MapiMessage, להתאים את ההצגה והכותרות של קובץ ה‑MHT באמצעות MhtSaveOptions, להגדיר קטגוריות להודעת הדוא"ל ולאחר מכן לשנות את תבניות הפורמט והכותרות לפני שמירת הקובץ.

 MapiMessage msg = new MapiMessage("from@aaa.com", "to@aaa.com", "subj", "body");

msg.setCategories(new String[] { "Urgently", "Important" });

MhtSaveOptions saveOptions = new MhtSaveOptions();

saveOptions.getFormatTemplates().set_Item(MhtTemplateName.CATEGORIES,

    saveOptions.getFormatTemplates().get_Item(MhtTemplateName.CATEGORIES).replace("Categories", "Les catégories"));

saveOptions.getRenderingHeaders().add(MhtTemplateName.CATEGORIES);

msg.save("fileName.mhtml", saveOptions);

קריאה וכתיבה של קובץ תבנית Outlook (.OFT)

תבניות Outlook שימושיות מאוד כאשר ברצונך לשלוח הודעת דוא"ל דומה שוב ושוב. במקום להכין את ההודעה מאפס בכל פעם, תחילה הכין את ההודעה ב‑Outlook ושמור כ‑Outlook Template (OFT). לאחר ذلك, בכל פעם שצריך לשלוח את ההודעה, אפשר ליצור אותה מהתבנית, מה שחוסך זמן בכתיבת הטקסט זהה בגוף או בכותרת, קביעת עיצוב וכדומה. Aspose.Email MailMessage class ניתן להשתמש כדי לטעון ולקרוא קובץ תבנית Outlook (OFT). ברגע שתבנית Outlook נטענת במופע של MailMessage class, תוכל לעדכן את השולח, הנמען, הגוף, הנושא ונתונים נוספים. לאחר עדכון המאפיינים:

שלח את האימייל באמצעות SmtpClient class או
שמור את ההודעה כ‑MSG ובצע עדכונים/אימות נוספים באמצעות Microsoft Outlook.

במקטעי הקוד שלהלן, אנו:

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

קטע הקוד הבא מראה כיצד לטעון את קובץ ה‑OFT, לעדכן את ההודעה ולשמור אותו בפורמט MSG.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

// Load the Outlook template (OFT) file in MailMessage's instance
MailMessage message = MailMessage.load(dataDir + "sample.oft", new MsgLoadOptions());

// Set the sender and recipients information
String senderDisplayName = "John";
String senderEmailAddress = "john@abc.com";
String recipientDisplayName = "William";
String recipientEmailAddress = "william@xzy.com";

message.setSender(new MailAddress(senderEmailAddress, senderDisplayName));
message.getTo().addMailAddress(new MailAddress(recipientEmailAddress, recipientDisplayName));
message.setHtmlBody(message.getHtmlBody().replace("DisplayName", "<b>" + recipientDisplayName + "</b>"));

// Set the name, location and time in email body
String meetingLocation = "<u>" + "Hall 1, Convention Center, New York, USA" + "</u>";
String meetingTime = "<u>" + "Monday, June 28, 2010" + "</u>";
message.setHtmlBody(message.getHtmlBody().replace("MeetingPlace", meetingLocation));
message.setHtmlBody(message.getHtmlBody().replace("MeetingTime", meetingTime));

// Save the message in MSG format and open in Office Outlook
MapiMessage mapimessage = MapiMessage.fromMailMessage(message);
mapimessage.setMessageFlags(MapiMessageFlags.MSGFLAG_UNSENT);
mapimessage.save(dataDir + "ReadAndWritingOutlookTemplateFile_out.msg");

שמירת קובץ Outlook MSG כתבנית

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

try (MapiMessage mapi = new MapiMessage("test@from.to", "test@to.to", "template subject", "Template body")) {
    mapi.saveAsTemplate(dataDir + "mapiToOft.msg");
}

קביעת קטגוריית צבע לקבצי Outlook MSG

קטגוריית צבע מסמנת הודעת דוא"ל לחשיבות או לקטגוריה מסוימת. Microsoft Outlook מאפשרת למשתמשים לשייך קטגוריות צבע כדי להבדיל בין הודעות. כדי לטפל בקטגוריית הצבע, השתמש ב- FollowUpManager. הוא מכיל פונקציות כגון addCategory, removeCategory, clearCategories ו getCategories.

addCategory מקבל MapiMessage והמחרוזת של קטגוריית הצבע, לדוגמה "קטגוריית סגול" או "קטגוריית אדום" כפרמטרים.
removeCategory מקבל MapiMessage והמחרוזת של קטגוריית הצבע שתוסר מההודעה.
clearCategories משמש להסרת כל קטגוריות הצבע מההודעה.
getCategories משמש לשחזור כל קטגוריות הצבע מהודעה מסוימת.

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

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage msg = MapiMessage.fromFile(dataDir + "message.msg");

// Add Two category
FollowUpManager.addCategory(msg, "Purple Category");
FollowUpManager.addCategory(msg, "Red Category");

// Retrieve the list of available categories
IList categories = FollowUpManager.getCategories(msg);

// Remove the specified category and then Clear all categories
FollowUpManager.removeCategory(msg, "Red Category");
FollowUpManager.clearCategories(msg);

גישה למידע המשך מקובץ MSG

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

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

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage msg = MapiMessage.fromFile(dataDir + "message.msg");
for (MapiRecipient recipient : msg.getRecipients()) {
    System.out.println("Recipient: " + recipient.getDisplayName());

    // Get the PR_RECIPIENT_TRACKSTATUS_TIME_DELIVERY property
    System.out.println("Delivery time: " + recipient.getProperties().get_Item(MapiPropertyTag.PR_RECIPIENT_TRACKSTATUS_TIME_DELIVERY).getDateTime());

    // Get the PR_RECIPIENT_TRACKSTATUS_TIME_READ property
    System.out.println("Read time" + recipient.getProperties().get_Item(MapiPropertyTag.PR_RECIPIENT_TRACKSTATUS_TIME_READ).getDateTime());
}

יצירת הודעות Forward ו‑Reply

Aspose.Email API מספקת אפשרות ליצור ולעצב הודעות Forward ו‑Reply. ה‑ ReplyMessageBuilder ו ForwardMessageBuilder מחלקות ה‑API משמשות ליצירת הודעות Reply ו‑Forward בהתאמה. ניתן לציין הודעת Reply או Forward שתיווצר באמצעות כל אחת מהשיטות של OriginalMessageAdditionMode enum. enum זה מכיל את הערכים הבאים:

OriginalMessageAdditionMode.None - ההודעה המקורית אינה נכללת בהודעת התגובה.
OriginalMessageAdditionMode.Attachment - ההודעה המקורית כלולה כקובץ מצורף בהודעת התגובה
OriginalMessageAdditionMode.Textpart - ההודעה המקורית כלולה כטקסט בגוף הודעת התגובה

יצירת הודעת Reply

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage originalMsg = MapiMessage.fromFile(dataDir + "message1.msg");
ReplyMessageBuilder builder = new ReplyMessageBuilder();

// Set ReplyMessageBuilder Properties
builder.setReplyAll(true);
builder.setAdditionMode(OriginalMessageAdditionMode.Textpart);
builder.setResponseText(
        "<p><b>Dear Friend,</b></p> I want to do is introduce my co-author and co-teacher. <p><a href=\"www.google.com\">This is a first link</a></p><p><a href=\"www.google.com\">This is a second link</a></p>");

MapiMessage replyMsg = builder.buildResponse(originalMsg);
replyMsg.save(dataDir + "reply_out.msg");

יצירת הודעת Forward

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage originalMsg = MapiMessage.fromFile(dataDir + "message1.msg");
ForwardMessageBuilder builder = new ForwardMessageBuilder();
builder.setAdditionMode(OriginalMessageAdditionMode.Textpart);
MapiMessage forwardMsg = builder.buildResponse(originalMsg);
forwardMsg.save(dataDir + "forward_out.msg");

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

MapiConversionOptions.setPreserveEmptyDates(boolean) מאפיין המציין האם יש צורך לשמור תאריכים ריקים בעת המרת הודעה. API זה מופיע ב‑Aspose.Email 21.5. קוד הדוגמה הבא מראה כיצד לשמר תאריכים ריקים.

MailMessage mailMessage = MailMessage.load("message.eml");
System.out.println(mailMessage.getDate()); // zero date
MapiConversionOptions mco = MapiConversionOptions.getUnicodeFormat();
// keep empty dates when converting a message
mco.setPreserveEmptyDates(true);
MapiMessage mapiMessage = MapiMessage.fromMailMessage(mailMessage, mco);
System.out.println(mapiMessage.getClientSubmitTime()); // zero date
// check zero date
if (mapiMessage.getClientSubmitTime().equals(JavaHelper.ZERO_DATE))
    System.out.println("ZERO DATE");

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

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

יצירת אפשרות הצבעה באמצעות MapiMessage

Microsoft Outlook מאפשר למשתמשים ליצור סקר בעת כתיבת הודעה חדשה. הוא מאפשר לכלול אפשרויות הצבעה כגון כן, לא, אולי וכו’. Aspose.Email מאפשר את אותו הדבר בעת יצירת הודעת Outlook חדשה. ה‑ FollowUpOptions class מספקת את VotingButtons תכונה שניתן להשתמש בה כדי לקבוע או לקבל את ערך אפשרויות ההצבעה. מאמר זה מספק דוגמה מפורטת ליצירת MapiMessage עם אפשרויות הצבעה ליצירת סקר.

יצירת סקר באמצעות MapiMessage

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
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);

קריאת אפשרויות הצבעה מתוך MapiMessage

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String fileName = "outlook/message.msg";

MapiMessage message = MapiMessage.fromFile(fileName);

// This method can be useful when except voting buttons it is necessary to get other parameters (ex. a category)
FollowUpOptions options = FollowUpManager.getOptions(message);

// Voting buttons will be introduced as a string with semi-column as a separator
String votingButtons = options.getVotingButtons();

קריאת רק כפתורי הצבעה

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
InputStream ms = new FileInputStream(dataDir + "MapiMsgWithPoll_out.msg");
MapiMessage testMsg = MapiMessage.fromStream(ms);

// This method can be useful when it is necessary to read only voting buttons
// Voting buttons will be introduced as a collection of string values
IList buttons = FollowUpManager.getVotingButtons(testMsg);

הוספת כפתור הצבעה להודעה קיימת

הקוד שלהלן מציג כיצד להוסיף כפתור הצבעה להודעה קיימת.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage mapi = MapiMessage.fromFile(dataDir + "message.msg");
FollowUpManager.addVotingButton(mapi, "Indeed!");
mapi.save(dataDir + "AddVotingButtonToExistingMessage_out.msg");

מחיקת כפתור הצבעה מהודעה

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

// Create New Message and set FollowUpOptions, FollowUpManager properties
MapiMessage msg = createTestMessage(false);

FollowUpOptions options = new FollowUpOptions();
options.setVotingButtons("Yes;No;Maybe;Exactly!");
FollowUpManager.setOptions(msg, options);
msg.save(dataDir + "MapiMsgWithPoll.msg");
FollowUpManager.removeVotingButton(msg, "Exactly!"); // Deleting a single button OR
FollowUpManager.clearVotingButtons(msg); // Deleting all buttons from a MapiMessage
msg.save(dataDir + "MapiMsgWithPoll.msg");

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

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage msg = MapiMessage.fromFile(dataDir + "AddVotingButtonToExistingMessage.msg");
for (MapiRecipient recipient : msg.getRecipients()) {
    System.out.println("Recipient: " + recipient.getDisplayName());

    // Get the PR_RECIPIENT_AUTORESPONSE_PROP_RESPONSE property
    System.out.println("Response: " + recipient.getProperties().get_Item(MapiPropertyTag.PR_RECIPIENT_AUTORESPONSE_PROP_RESPONSE).getString());

    // Get the PR_RECIPIENT_TRACKSTATUS_TIME property
    System.out.println("Response time: " + recipient.getProperties().get_Item(MapiPropertyTag.PR_RECIPIENT_TRACKSTATUS_TIME).getDateTime());

    System.out.println();
}

שיטות דוגמה המשמשות בדוגמאות

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static MapiMessage createTestMessage(boolean draft) {
    MapiMessage msg = new MapiMessage("from@test.com", "to@test.com", "Flagged message",
            "Make it nice and short, but descriptive. The description may appear in search engines' search results pages...");

    if (!draft) {
        msg.setMessageFlags(msg.getFlags() ^ MapiMessageFlags.MSGFLAG_UNSENT);
    }
    return msg;
}

Java: פענוח קבצי הודעות Outlook

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

באמצעות Aspose.Email עבור Java, מפתחים יכולים לא רק לטעון אלא גם לפענח תוכן מקבצי הודעות Outlook.

לטעון קבצי MSG מהדיסק, השתמש ב- MapiMessage class static Load שיטה.
כדי לפענח את תוכן קובץ MSG, ה- MapiMessage חשוף מספר שיטות.

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

Aspose.Email for Java מספקת את MapiMessage מחלקה המשמשת לפתיחה וניתוח קובץ MSG. מכיוון שיכולים להיות רבים ממקבלי ההודעה בקובץ MSG, ה- MapiMessage המחלקה מציגה את getRecipients() שיטה שמחזירה MapiRecipientCollection שמייצג אוסף של MapiRecipient אובייקטים. ה- MapiRecipient האובייקט חשוף עוד שיטות לעבודה עם תכונות הנמענים.

הסדרת הצעדים הבאים משמשת למטרה זו:

צור מופע של MapiMessage class לטעון קובץ MSG מ- Load מתודה סטטית.
הצג את שם השולח, הנושא והגוף מקובץ MSG באמצעות getSenderName(), getSubject() ו getBody() שיטות.
הפעל את getRecipients() מתודה שנחשפת על‑ידי ה‑ MapiRecipient מחלקה לקבלת הפנייה לאוסף של MapiRecipient אובייקטים הקשורים לקובץ MSG.
לולאה על ה- MapiRecipientCollection אוסף להצגת תוכן עבור כל MapiRecipient אובייקט דרך המתודות הציבוריות שלו.

// The path to the resource directory.
String dataDir = Utils.getSharedDataDir(ParsingOutlookMessageFiles.class) + "outlook/";

//Instantiate an MSG file to load an MSG file from disk
MapiMessage outlookMessageFile = MapiMessage.fromFile(dataDir + "message.msg");
//Display sender's name
System.out.println("Sender Name : " + outlookMessageFile.getSenderName());
//Display Subject
System.out.println("Subject : " + outlookMessageFile.getSubject());
//Display Body
System.out.println("Body : " + outlookMessageFile.getBody());
//Display Recipient's info
System.out.println("Recipients : \n");

//Loop through the recipients collection associated with the MapiMessage object
for (int i = 0; i < outlookMessageFile.getRecipients().size(); i++) {
	//Set a reference to the MapiRecipient object
	MapiRecipient rcp = (MapiRecipient) outlookMessageFile.getRecipients().get_Item(i);
	//Display recipient email address
	System.out.println("Email : " + rcp.getEmailAddress());
	//Display recipient name
	System.out.println("Name : " + rcp.getDisplayName());
	//Display recipient type
	System.out.println("Recipient Type : " + rcp.getRecipientType());
}

נסו זאת!

פענח קבצי דוא"ל אונליין בחינם אפליקציית Aspose.Email Parser.

קבל סוג פריט של הודעת MAPI

Aspose.Email מציע MapiItemType enum המייצג סוג פריט. ניתן להשתמש בו לצורך המרת הודעה לאובייקט של מחלקה מתאימה הנגזרת מ- IMapiMessageItem ממשק. פעולה זו מונעת מהמשתמשים לבדוק את ערך המאפיין MessageClass לפני המרת ההודעה.

דוגמת הקוד הבאה מדגימה כיצד לעבור על ההודעות בתיקייה ולהמיר כל הודעת MAPI לסוג פריט MAPI תואם, בהתאם לסוג ההודעה:

for (MessageInfo messageInfo : folder.enumerateMessages()) {
    MapiMessage msg = pst.extractMessage(messageInfo);

    switch (msg.getSupportedType()) {
        // Non-supported type. MapiMessage cannot be converted to an appropriate item type.
        // Just use in MSG format.
        case MapiItemType.None:
            break;
        // An email message. Conversion isn't required.
        case MapiItemType.Message:
            break;
        // A contact item. Can be converted to MapiContact.
        case MapiItemType.Contact:
            MapiContact contact = (MapiContact) msg.toMapiMessageItem();
            break;
        // A calendar item. Can be converted to MapiCalendar.
        case MapiItemType.Calendar:
            MapiCalendar calendar = (MapiCalendar) msg.toMapiMessageItem();
            break;
        // A distribution list. Can be converted to MapiDistributionList.
        case MapiItemType.DistList:
            MapiDistributionList dl = (MapiDistributionList) msg.toMapiMessageItem();
            break;
        // A Journal entry. Can be converted to MapiJournal.
        case MapiItemType.Journal:
            MapiJournal journal = (MapiJournal) msg.toMapiMessageItem();
            break;
        // A StickyNote. Can be converted to MapiNote.
        case MapiItemType.Note:
            MapiNote note = (MapiNote) msg.toMapiMessageItem();
            break;
        // A Task item. Can be converted to MapiTask.
        case MapiItemType.Task:
            MapiTask task = (MapiTask) msg.toMapiMessageItem();
            break;
    }
}

Java: עבודה עם תזכורת מעקב ותאריך יעד עבור קבצי Outlook MSG

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

הגדרת מעקב ותאריך יעד עבור קבצי Outlook MSG

דגל מעקב מסמן הודעת דוא"ל לפעולה מסוימת. Microsoft Outlook מאפשר למשתמשים לסמן הודעות בדגל ובתצורת הדגל ניתן לקבוע תאריך יעד למעקב. Microsoft Outlook שולח תזכורת לנמען כדי לעודד אותו לבצע מעקב אחרי האימייל. סימון הודעות דוא"ל וקביעת תאריכי יעד תכנותית מאפשר למפתחי תוכנה לאוטומט סוגים מסוימים של הודעות ולסייע לנמענים לזכור לבצע פעולה. לדוגמה, ניתן להשתמש בזה לשלוח הודעות חודשיות לצוות המכירות כדי להזכיר להם להשלים את הדוחות; או לשלוח הודעה לכל העובדים כדי להזכיר להם פגישת חברה. Aspose.Email for Java תומך בקביעת דגל מעקב ותאריך יעד עבור ה MapiMessage אובייקטים באמצעות FollowUpManager ו FollowUpOptions. יש מספר גרסאות שבהן ניתן להגדיר דגל מעקב על הודעה. הן כולן משמשות בדוגמת הקוד למטה:

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

הגדרת דגל תזכורת

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MailMessage mailMsg = new MailMessage();
mailMsg.setSender(new MailAddress("AETest12@gmail.com"));
mailMsg.getTo().addMailAddress(new MailAddress("receiver@gmail.com"));
mailMsg.setBody("This message will test if follow up options can be added to a new mapi message.");
MapiMessage mapi = MapiMessage.fromMailMessage(mailMsg);

Calendar calendar = Calendar.getInstance();
calendar.set(2013, Calendar.MAY, 23, 14, 40, 0);
Date dtStartDate = calendar.getTime();

calendar.set(2013, Calendar.MAY, 23, 16, 40, 0);
Date dtReminderDate = calendar.getTime();

calendar.add(Calendar.DATE, 1);
Date dtDueDate = calendar.getTime();

FollowUpOptions options = new FollowUpOptions("Follow Up", dtStartDate, dtDueDate, dtReminderDate);
FollowUpManager.setOptions(mapi, options);
mapi.save(dataDir + "SetFollowUpflag_out.msg");

הגדרת תזכורת למקבלים

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MailMessage mailMsg = new MailMessage();
mailMsg.setSender(new MailAddress("AETest12@gmail.com"));
mailMsg.getTo().addMailAddress(new MailAddress("receiver@gmail.com"));
mailMsg.setBody("This message will test if follow up options can be added to a new mapi message.");

MapiMessage mapi = MapiMessage.fromMailMessage(mailMsg);
mapi.setMessageFlags(MapiMessageFlags.MSGFLAG_UNSENT); // mark this message as draft

Calendar calendar = Calendar.getInstance();
calendar.set(2013, Calendar.MAY, 23, 16, 40, 0);
Date dtReminderDate = calendar.getTime();

// Add the follow up flag for recipient now
FollowUpManager.setFlagForRecipients(mapi, "Follow up", dtReminderDate);
mapi.save(dataDir + "SetFollowUpForRecipients_out.msg");

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

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage mapi = MapiMessage.fromFile(dataDir + "message.msg");
FollowUpManager.markAsCompleted(mapi);
mapi.save(dataDir + "MarkedCompleted_out.msg");

הסרת דגל תזכורת

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage mapi = MapiMessage.fromFile(dataDir + "message.msg");
FollowUpManager.clearFlag(mapi);
mapi.save(dataDir + "FollowUpFlagRemoved_out.msg");

קריאת אפשרויות דגל תזכורת עבור הודעה

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MapiMessage mapi = MapiMessage.fromFile(dataDir + "message.msg");
FollowUpOptions options = FollowUpManager.getOptions(mapi);

Java: עבודה עם מאפייני MAPI

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

הגדרה וגישה למאפייני Outlook MAPI

Aspose.Email for Java מספקת את MapiProperty מחלקה המייצגת מאפיין MAPI:

Name: שם המאפיין.
Tag: תג המאפיין.
Data: נתוני המאפיין.

נושא זה דן גם איך להגדיר ולגשת למאפייני קובץ הודעת Outlook (MSG) באמצעות Aspose.Email for Java. בנוסף, סופק קוד לדוגמה על איך להסיר מאפיינים מ‑MSG וקבצים מצורפים.

קריאת מאפיינים

לקריאת נתוני מאפייני MAPI מקובץ MSG:

צור מופע של MapiMessage מחלקה לטעינת קובץ MSG באמצעות Load() מתודה סטטית.
קבע הפנייה ל‑ MapiMessage אובייקט getProperties() מתודה לקבלת ה- MapiPropertyCollection.
קבל את MapiProperty אובייקט מה‑ MapiPropertyCollection על ידי MapiPropertyTag מפתחות.
קבל את נתוני המאפיין באמצעות השיטה המתאימה getXXX().

הגדרת מאפיינים נוספים

דוגמת הקוד הבאה יכולה לשמש להגדרת מאפיינים נוספים של Outlook MapiMessage.

הסרת מאפיינים

קריאת מאפייני Mapi בעל שם מהודעות דוא"ל

Microsoft Outlook תומך בהוספת מאפייני MAPI בעל שם לקובץ MSG. מאפיינים אלו מתווספים על ידי המשתמש. מפתחים יכולים להוסיף מאפיין בעל שם, לדוגמה “MyProp”, לקובץ MSG באמצעות Aspose.Email.

מאמר זה מדגים את Aspose.Email MapiMessage getNamedProperties() אוסף לקריאת מאפייני MAPI בעל שם מקובץ MSG.

קריאת מאפיין MAPI בעל שם

קריאת מאפיין Mapi בעל שם מצרוף

Java: עבודה עם קבצים מצורפים להודעה

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

ניתוח ושמירת קבצים מצורפים

קבצי הודעת Outlook עשויים להכיל קובץ מצורף אחד או יותר. Aspose.Email מאפשר למפתחים לעבור על הקבצים המצורפים בקובץ MSG ולשמור אותם לכונן. נושא זה מתאר את התהליך. הוא גם מתאר כיצד לשבץ קובץ מצורף.

Aspose.Email MapiMessage מחלקה משמשת לטעון קובץ MSG מהכונן ומחשיפה את getAttachments() מתודה המתייחסת ל‑ MapiAttachment אוסף האובייקטים הקשור לקובץ MSG. ה‑ MapiAttachment האובייקט חושף בנוסף מתודות שמבצעות פעולות על הקובץ המצורף.

כדי לשמור קבצים מצורפים בקובץ MSG לכונן עם שם והרחבה מקוריים:

צור מופע של MapiMessage מחלקה לטעינת קובץ MSG באמצעות Load() מתודה סטטית.
הפעל את MapiRecipient מחלקה getAttachments() מתודה לקבלת הפניה לאוסף של MapiAttachment אובייקטים הקשורים לקובץ MSG.
לולאה על ה- MapiAttachmentCollection להציג תוכן לגבי כל MapiAttachment אובייקט דרך המתודות הציבוריות שלו.
הפעל את MapiAttachment מחלקה save() מתודה לשמירת קובץ מצורף לכונן.

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

הודעת Microsoft Outlook יכולה להכיל הודעות Microsoft Outlook אחרות בקבצים מצורפים, או כהודעות רגילות כמפורט למעלה, או כהודעות משובצות. ה‑ MapiAttachmentCollection מספק חברים מעודנים של מתודת add ליצירת הודעות Outlook עם שני סוגי קבצים מצורפים. קבצי Outlook MSG משובצים בקובץ MSG מכילים PR_ATTACH_METHOD בערך 5.

קריאת הודעה משובצת מקובץ מצורף

הכנסת והחלפת קבצים מצורפי MSG

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

הכנסת קובץ מצורף MSG במיקום ספציפי

Aspose.Email API מספקת אפשרות להכניס קובץ מצורף MSG להודעה אב (parent MSG) באמצעות ה‑ MapiAttachmentCollection.Insert() שיטה.

החלפת תוכן קובץ מצורף MSG משובץ

ניתן להשתמש בזה כדי להחליף את תוכן הקובץ המצורף המשובץ בתוכן החדש באמצעות ה‑ החלף מתודה. עם זאת, לא ניתן להשתמש בה להוספת קובץ מצורף עם PR_ATTACH_NUM = 4 (לדוגמה) באוסף שבו collection.Count = 2.

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

Aspose.Email API מספקת אפשרות לקבל או להגדיר ערך המציין האם הודעה חותמת (clear‑signed) תפוענח.

שינוי שם קובץ מצורף ב‑MapiMessage

Aspose.Email מאפשר לערוך את ה‑ שם תצוגה ערך המאפיין ב‑ קבצים מצורפים של MapiMessage.

קוד הדוגמה הבא מדגים כיצד לעדכן את שמות התצוגה של הקובץ הראשון והשני בתוך הודעת Mapi שהוטענה:

MapiMessage msg = MapiMessage.load(fileName);
msg.getAttachments().get_Item(0).setDisplayName("New display name 1");
msg.getAttachments().get_Item(1).setDisplayName("New display name 2");

בדיקת האם קובץ מצורף הוא מוטמע או רגיל

ההבדל בין קבצים מצורפים מוטמעים (inline) וקבצים מצורפים רגילים הוא באופן הצגתם באימייל. קבצים מצורפים מוטמעים משולבים בגוף האימייל וניתנים לצפייה ללא צורך בפתיחת קובץ נפרד או הורדה. קבצים מצורפים רגילים הם קבצים נפרדים שמצורפים למייל אך אינם מוצגים ישירות בגוף ההודעה ויש צורך להורידם ולפתוח אותם חיצונית. ה‑ MapiAttachment.IsInline מאפיין של MapiAttachment מחלקה מקבלת ערך המציין האם הקובץ המצורף הוא מוטמע או רגיל.

קוד הדוגמה הבא טוען הודעת אימייל מקובץ ולאחר מכן מקבל מידע על הקבצים המצורפים, ובמיוחד מדפיס את שם התצוגה של כל קובץ מצורף ואת המצב האם הוא מוטמע (inline) בתוך ההודעה או לא:

MapiMessage message = MapiMessage.load("fileName");

for (MapiAttachment attach : message.getAttachments()) {
    System.out.println(attach.getDisplayName() + ": " + attach.isInline());
}

Java: עבודה עם אנשי קשר של Outlook

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

יצירת איש קשר Outlook

Aspose.Email for Java תומך ביצירת אנשי קשר של Outlook (VCards) באמצעות ה‑ MapiContact מחלקה. MapiContact מכיל שיטות רבות, חלק מהן מפורטות להלן.

MapiContactElectronicAddressPropertySet מכיל קבוצת MapiContactElectronicAddress.
MapiContactEventPropertySet
MapiContactNamePropertySet
MapiContactPersonalInfoPropertySet
MapiContactPhysicalAddressPropertySet מכיל קבוצת MapiContactPhysicalAddress.
MapiContactProfessionalPropertySet
MapiContactTelephonePropertySet

מבנה איש הקשר ב‑Aspose.Email for Java

להלן ההיררכיה המיושמת עבור אנשי קשר ב‑Aspose.Email for Java. שם המחלקה הרלוונטית מצוין לצד כל תכונה. קישורים מסופקים לתיעוד המקוון לעיון נוסף.

Contact (MapiContact)
1. כתובות אלקטרוניות (MapiContactElectronicAddressPropertySet)
  1. דוא"ל 1 (MapiContactElectronicAddress)
    1. סוג כתובת
    2. שם תצוגה
    3. כתובת דוא"ל
    4. מספר פקס
  2. דוא"ל 2
  3. דוא"ל 3
  4. פקס ביתי
  5. פקס ראשי
  6. פקס עסקי
2. אירועים (MapiContactEventPropertySet) ראה להלן לדוגמה כיצד להגדיר אירועים.
  1. יום הולדת
  2. יום נישואין
3. מידע שם (MapiContactNamePropertySet)
  1. שם תצוגה
  2. קידומת שם תצוגה
  3. קבץ תחת
  4. קבץ תחת מזהה
  5. דור
  6. שם פרטי
  7. ראשי תיבות
  8. שם אמצעי
  9. כינוי
  10. שם משפחה
4. מידע אישי (MapiContactPersonalInfoPropertySet)
  1. חשבון
  2. דף בית עסקי
  3. שם רשת מחשבים
  4. מספר לקוח
  5. מיקום עסקי חופשי
  6. אתר FTP
  7. מגדר
  8. מספר תעודת זהות
  9. תחביבים
  10. HTML
  11. כתובת מסרים מיידיים
  12. שפה
  13. מיקום
  14. הערות
  15. מספר זיהוי ארגוני
  16. דף בית אישי
  17. שם המפנה
  18. שם בן/בת זוג
5. כתובת פיזית (MapiContactPhysicalAddressPropertySet)
  1. כתובת בית (MapiContactPhysicalAddress)
    1. כתובת
    2. עיר
    3. מדינה
    4. קוד המדינה
    5. מיקוד
    6. תיבת דואר
    7. מדינה או מחוז
  2. כתובת אחרת
  3. כתובת העבודה
6. מידע מקצועי
  1. עוזר
  2. שם החברה
  3. שם מחלקה
  4. שם המנהל
  5. מיקום המשרד
  6. מקצוע
  7. תואר
7. טלפונים (MapiContactTelephonePropertySet)
  1. מספר טלפון של העוזר
  2. מספר טלפון עסקי 2
  3. מספר טלפון עסקי
  4. מספר טלפון לחזרה
  5. מספר טלפון רכב
  6. מספר טלפון ראשי של החברה
  7. מספר טלפון בית 2
  8. מספר טלפון לבית
  9. מספר ISDN
  10. מספר טלפון נייד
  11. מספר טלפון אחר
  12. מספר פייג’ר
  13. מספר טלפון ראשי
  14. מספר טלפון רדיו
  15. מספר טלקס
  16. מספר טלפון TTY/TDD

הקוד הבא משתמש ב‑Aspose.Email כדי ליצור איש קשר ב‑Outlook וממלא אותו בשם, בתכונות מקצועיות, בכתובת פיזית ובדוא"ל. הוא גם מציג הוספה של MapiContactEventPropertySet אל איש הקשר.

|| | :- | |איור: איש קשר של Microsoft Outlook מקודד עם Aspose.Email|

הוספת מידע אירוע לאיש קשר MapiContact

Microsoft Outlook מאפשר למשתמשים להוסיף מידע על אירוע לאיש קשר. האירוע כולל יום הולדת ויום נישואין. Aspose.Email מספק את ה‑ MapiContactEventPropertySet מחלקה להוספת מידע זה לאיש קשר. זה מופיע במפורט בדוגמה הבאה.

יצירת, שמירה וקריאת אנשי קשר של Outlook

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

יצירה ושמירת MapiContact

ניתן להשתמש בשלבים הבאים כדי ליצור ולשמור איש קשר בדיסק:

צור מופע חדש של ה‑ MapiContact מחלקה.
הזן מידע הקשור למאפיינים שונים של איש הקשר.
הוסף נתוני תמונה לאיש קשר, אם קיימים.
שמור את האיש קשר בפורמט MSG או VCard.

שמירת איש קשר בפורמט VCF גרסה 3

כדי לשמור את איש הקשר בפורמט VCF גרסה 3, השתמש ב‑ VCardVersion אוסף להגדיר את ה‑ VCardSaveOptions.Version תכונה. קוד הדוגמה שלהלן מדגים את השימוש ב‑ VCardVersion אוסף לשמירת איש הקשר בפורמט VCF גרסה 3.

קריאת MapiContact

ה MapiContact המחלקה ניתנת לשימוש לטעינת קובצי MSG של Microsoft Outlook וכן אנשי קשר בפורמט VCard. דוגמאות הקוד שלהלן מציגות כיצד לטעון אנשי קשר של Outlook שנשמרו כ‑MSG ו‑VCF לתוך MapiContact.

טעינת איש קשר מ‑MSG

טעינת איש קשר מ‑VCard

הקוד שלהלן מציג כיצד ליצור MapiContact על‑ידי טעינת נתונים מקובץ VCard באמצעות VCardLoadOptions:

MapiContact mapiContact = MapiContact.fromVCard("contact.vcf", new VCardLoadOptions());
System.out.println(mapiContact.getNameInfo().getDisplayName());

טעינת איש קשר VCard עם קידוד מוגדר

שיטה נתמכת: MapiContact.fromVCard(String, Encoding)

המרת מידע איש הקשר ל‑MHTML

איש קשר של Outlook ניתן להמרה ל‑MHTML באמצעות Aspose.Email API. דוגמה זו מציגה כיצד VCard נטען לתוך MapiContact ואז מומר ל‑MHTML בעזרת MailMessage API.

Java: עבודה עם משימות Outlook

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

יצירת, שמירה וקריאת משימות Outlook

Aspose.Email for Java מאפשר למפתחים ליצור משימות Outlook ולשמור אותן בפורמט MSG. ה‑ MapiTask המחלקה מספקת מספר מאפיינים כגון PercentComplete, EstimatedEffort, ActualEffort, History, LastUpdate, וכו’, כדי להתאים ולהגדיר מידע נדרש עבור משימת Outlook. מאמר זה מראה כיצד ליצור, לשמור ולקרוא MapiTask מהדיסק.

יצירה ושמירה של MapiTask

השלבים הבאים ניתנים לשימוש ליצירה ושמירת משימה לדיסק.

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

קריאת MapiTask

ה MapiTask אובייקט המחלקה משמש להמרת ה‑ MapiMessage אובייקט שמטען משימה מהדיסק בפורמט MSG.

קריאת משימת VToDo

ניתן לטעון משימות Google שיוצאו בפורמט iCalendar כאירועי VToDo באמצעות MapiTask מחלקה כפי שמוצג בדוגמת הקוד הבא.

הוספת מידע תזכורת ל-MapiTask

בדומה ל-Microsoft Outlook, Aspose.Email יכול להוסיף מידע תזכורת ל- MapiTask. הקטע הקוד הבא מראה כיצד להוסיף מידע תזכורת ל- MapiTask.

הוספת קובץ מצורף ל-MapiTask

הקטע הקוד הבא מראה כיצד להוסיף קבצים מצורפים ל- MapiTask.

המרת משימת Outlook ל-MHT

Aspose.Email יכול ליצור MapiMessage כמו פלט במהלך ההמרה של MapiTask ל-MHT.

Java: ניהול הודעות חתומות דיגיטלית

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

Aspose.Email מיישמת את האלגוריתם המלא של אובייקט דוא"ל S/MIME. זה נותן ל‑API יכולת מלאה להוסיף חתימות דיגיטליות להודעות דוא"ל, לשמור אותן בעת המרת הודעות בין פורמטים, להסירן וכו'.

צירוף חתימה להודעת דוא"ל

ה SecureEmailManager.attachSignature השיטה מאפשרת לצרף חתימות דיגיטליות להודעות דוא"ל. לאחר צירוף החתימה, אמת את התוצאות דרך מאפיינים כגון IsSigned, MessageClass, ופרטי הצירוף.

אתה יכול לספק MailMessage או MapiMessage, תעודה פרטית, ואפשרויות חתימה כדי להתאים אישית את תהליך צירוף החתימה עם ה- SignatureOptions class שמאפשרת למשתמשים לציין אפשרויות שונות לצירוף חתימה, כולל חתימות מנותקות ולא מנותקות.

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

String fileName = "message.msg";
String privateCertFile = "certFile.pfx";
X509Certificate2 privateCert = new X509Certificate2(privateCertFile, "password");

MapiMessage msg = MapiMessage.load(fileName);

SignatureOptions opt = new SignatureOptions();
opt.setDetached(true);
MapiMessage signedDetached = new SecureEmailManager().attachSignature(msg, privateCert, opt);

if (signedDetached.isSigned()) {
    System.out.println("Detached Signature Attached Successfully.");
}

opt.setDetached(false);
MapiMessage signedNonDetached = new SecureEmailManager().attachSignature(msg, privateCert, opt);

if (signedNonDetached.isSigned()) {
    System.out.println("Non-Detached Signature Attached Successfully.");
}

שמירת חתימה בעת המרה מ‑EML ל‑MSG

Aspose.Email שומרת על החתימה הדיגיטלית בעת המרה מ‑EML ל‑MSG. קטע הקוד הבא מראה כיצד לבצע המרה מ‑EML ל‑MSG.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

// Load mail message
MailMessage message = MailMessage.load(dataDir + "Message.eml", new EmlLoadOptions());
// Save as MSG
message.save(dataDir + "ConvertEMLToMSG_out.msg", SaveOptions.getDefaultMsgUnicode());

הסרת חתימה מקובץ הודעת Outlook

אם אתה נדרש להסיר את החתימה מהודעה בפורמט MAPI, למשל למטרות תאימות, Aspose.Email מציעה את MapiMessage.removeSignature שיטה ו- MapiMessage.isSigned מאפיין.

קטע הקוד הבא מראה כיצד לטעון הודעת MAPI מקובץ, לבדוק אם היא נחתמה דיגיטלית, ואם כן, ליצור הודעה חדשה ללא החתימה הדיגיטלית:

MapiMessage msg = MapiMessage.load(fileName);

if (msg.isSigned()) {
    MapiMessage unsignedMsg = msg.removeSignature();
}

המרת הודעות S/MIME מ‑MSG ל‑EML

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MailMessage msg = MailMessage.load(dataDir + "message.eml");
MapiMessage mapi = MapiMessage.fromMailMessage(msg, new MapiConversionOptions(OutlookMessageFormat.Unicode));
// Save File to disk
mapi.save(dataDir + "ConvertMIMEMessagesFromMSGToEML_out.msg");

פענוח קובץ MSG עם תעודה

אם ברשותך הודעות MAPI מוצפנות ואתה צריך לפענח אותן באמצעות המפתח הפרטי השמור באישור, התכונות הבאות של Aspose.Email עשויות להיות מועילות:

MapiMessage.isEncrypted - מקבל ערך המציין האם ההודעה מוצפנת.
MapiMessage.decrypt() - מפענח הודעה זו (השיטה מחפשת את חנויות My של המשתמש והמערכת עבור התעודה והמפתח הפרטי המתאימים).
MapiMessage.decrypt(X509Certificate2 certificate) - מפענח הודעה זו עם תעודה.

קטוד המקטע הבא מראה כיצד לעבוד עם הודעות MAPI מוצפנות:

X509Certificate2 privateCert = new X509Certificate2("privateCertFile", "password");
MapiMessage msg = MapiMessage.load("encrypted.msg");

if (msg.isEncrypted()) {
    MapiMessage decryptedMsg = msg.decrypt(privateCert);
    //MapiMessage decryptedMsg = msg.decrypt(/*byte[]*/rawPrivateCert, "password");
}

Java: עבודה עם פתקים של Outlook

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

יצירת, שמירה וקריאת פתקים של Outlook

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

יצירה ושמירת פתק Outlook

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

צור מופע של ה‑ MapiNote מחלקה.
קבע מגוון תכונות כרצונך.
שמור את הפתק לכונן כקובץ MSG.

קריאת MapiNote

ה MapiNote אובייקט המחלקה משמש להמרת ה‑ MapiMessage אובייקט הטוען פתק מהכונן בפורמט MSG.

Java: עבודה עם פריטי יומן של Outlook

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

עבודה עם MapiCalendar

של Aspose.Email MapiCalendar המחלקה מספקת שיטות ותכונות כדי להגדיר מגוון מאפיינים של פריט יומן. מאמר זה מספק דוגמאות קוד ל‑:

יצירה ושמירת פריטי יומן

קטע הקוד הבא מציג איך ליצור ולשמור פריט יומן בפורמט ICS.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

Calendar cal = Calendar.getInstance();
cal.set(2012, Calendar.OCTOBER, 2, 13, 0, 0);
Date startDate = cal.getTime();
cal.set(2012, Calendar.OCTOBER, 2, 14, 0, 0);
Date endDate = cal.getTime();

MapiCalendar calendar = new MapiCalendar("LAKE ARGYLE WA 6743", 
                                         "Appointment", 
                                         "This is a very important meeting :)", 
                                         startDate, 
                                         endDate);

calendar.save(dataDir + "CalendarItem_out.ics", AppointmentSaveFormat.Ics);

שמירת פריט היומן כ‑MSG

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
calendar.save(dataDir + "CalendarItemAsMSG_out.Msg", AppointmentSaveFormat.Msg);

הגדרת מזהה מוצר בעת שמירת פריט יומן ל‑ICS

ה ProductIdentifier מאפיין של MapiCalendarIcsSaveOptions המחלקה משמשת לשמירת פריט יומן MAPI לקובץ iCalendar (ICS) תוך שמירת מידע התאריך והשעה המקורי וכן מזהה מוצר מותאם. המאפיין מציין את המזהה למוצר שיצר את אובייקט iCalendar.

דוגמת הקוד הבאה מראה איך לעבוד עם נתוני iCalendar (ICS) בתוך אובייקט יומן MAPI:

MapiCalendarIcsSaveOptions icsSaveOptions = new MapiCalendarIcsSaveOptions();
icsSaveOptions.setKeepOriginalDateTimeStamp(true);
icsSaveOptions.setProductIdentifier("Foo Ltd");

mapiCalendar.save("my.ics", icsSaveOptions);

הוספת תזכורת תצוגה ליומן

קטע הקוד הבא מציג איך להוסיף תזכורת תצוגה ליומן.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";
Calendar jCalendar = Calendar.getInstance();
jCalendar.add(Calendar.HOUR, 1);
Date startDate = jCalendar.getTime();
Date endDate = jCalendar.getTime();

MailAddressCollection attendees = new MailAddressCollection();
attendees.addItem(new MailAddress("attendee@domain.com", "Attendee"));
// Create Appointment
Appointment app = new Appointment("Home", 
                                  startDate, 
                                  endDate, 
                                  new MailAddress("organizer@domain.com", "Organizer"), 
                                  attendees);
MailMessage msg = new MailMessage();
msg.addAlternateView(app.requestApointment());
MapiMessage mapi = MapiMessage.fromMailMessage(msg);
MapiCalendar calendar = (MapiCalendar) mapi.toMapiMessageItem();

// Set calendar Properties
calendar.setReminderSet(true);
calendar.setReminderDelta(5); // 45 min before start of event

String savedFile = (dataDir + "calendarWithDisplayReminder.ics");
calendar.save(savedFile, AppointmentSaveFormat.Ics);

הוספת תזכורת שמע ליומן

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";
Calendar jCalendar = Calendar.getInstance();
jCalendar.add(Calendar.HOUR, 1);
Date startDate = jCalendar.getTime();
Date endDate = jCalendar.getTime();

MailAddressCollection attendees = new MailAddressCollection();
attendees.addItem(new MailAddress("attendee@domain.com", "Attendee"));

Appointment app = new Appointment("Home", 
                                  startDate, 
                                  endDate, 
                                  new MailAddress("organizer@domain.com", "Organizer"), 
                                  attendees);

MailMessage msg = new MailMessage();
msg.addAlternateView(app.requestApointment());
MapiMessage mapi = MapiMessage.fromMailMessage(msg);
MapiCalendar cal = (MapiCalendar) mapi.toMapiMessageItem();

cal.setReminderSet(true);
cal.setReminderDelta(58); // 58 min before start of event
cal.setReminderFileParameter(dataDir + "Alarm01.wav");

String savedFile = dataDir + "calendarWithAudioReminder_out.ics";
cal.save(savedFile, AppointmentSaveFormat.Ics);

הוספה/קריאת קבצים מצורפים מקבצי יומן

קטע הקוד הבא מציג איך להוסיף/לקרוא קבצים מצורפים מקבצי יומן.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";
Calendar jCalendar = Calendar.getInstance();
jCalendar.add(Calendar.HOUR, 1);
Date startDate = jCalendar.getTime();
Date endDate = jCalendar.getTime();

String[] files = new String[3];
files[0] = "attachment_1.doc";
files[1] = "download.png";
files[2] = "Desert.jpg";

MailAddressCollection attendees = new MailAddressCollection();
attendees.addItem(new MailAddress("attendee@domain.com", "Attendee"));

Appointment app1 = new Appointment("Home", 
                                   startDate, 
                                   endDate, 
                                   new MailAddress("organizer@domain.com", "Organizer"), 
                                   attendees);
for (String file : files) {
    app1.getAttachments().addItem(new Attachment(dataDir + file));
}

app1.save(dataDir + "appWithAttachments_out.ics", AppointmentSaveFormat.Ics);

Appointment app2 = Appointment.load(dataDir + "appWithAttachments_out.ics");
System.out.println(app2.getAttachments().size());
for (Attachment att : app2.getAttachments())
    System.out.println(att.getName());

סטטוס של הנמענים מבקשת פגישה

קטע הקוד הבא מציג איך לקבל את הסטטוס של הנמענים מבקשת פגישה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
String fileName = "outlook/test.msg";

MapiMessage message = MapiMessage.fromFile(fileName);
for (MapiRecipient recipient : message.getRecipients()) {
    System.out.println(recipient.getRecipientTrackStatus());
}

הגדרת מצב פגישת היומן במפורש

Aspose.Email מאפשרת לך להגדיר את המצב של MapiCalendar אובייקט במפורש, מעקף את ההתנהגות ברירת המחדל. ה‑ setStateForced השיטה מספקת שליטה טובה יותר על מצבי אירועי היומן, במיוחד בטיפול בבקשות פגישה שהתקבלו. כברירת מחדל, כאשר נוצרה פגישה, מצבה הוא MapiCalendarState.Meeting. כאשר מתקבלת בתיבת הדואר של הנמען, היא משתנה אוטומטית ל‑ MapiCalendarState.Received, והמחלקה של ההודעה שלו מתעדכנת ל‑ IPM.Schedule.Meeting.Request. באמצעות SetStateForced מאפשר להגדיר ידנית את המצב ל‑Received, דבר שיכול להיות שימושי לשמירת מידע המארגן כאשר שומרים את היומן כקובץ MSG. עם זאת, זה עשוי למנוע העברה או שליחה מחודשת תקינה של הפגישה.

דוגמת הקוד הבאה תסייע לך ליישם תכונה זו:

Calendar c = Calendar.getInstance();
c.set(2024, Calendar.MAY, 10, 12, 30, 0);
Date startDate = c.getTime();
c.set(2024, Calendar.MAY, 10, 13, 30, 0);
Date endDate = c.getTime();
MapiCalendar appointment = new MapiCalendar(
        "LAKE ARGYLE WA 6743",
        "Appointment",
        "This is a very important meeting :)",
        startDate,
        endDate);

MapiElectronicAddress organizer = new MapiElectronicAddress();
organizer.setEmailAddress("test@aaa.com");
organizer.setDisplayName("test display Name");
appointment.setOrganizer(organizer);

appointment.setStateForced(MapiCalendarState.Meeting | MapiCalendarState.Received);

appointment.save("appointment.msg", AppointmentSaveFormat.Msg);

יצירת MapiCalendarTimeZone מאזור זמן סטנדרטי

קטע הקוד הבא מציג איך ליצור MapiCalendarTimeZone מהאזור זמן הסטנדרטי.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
MapiCalendarTimeZone timeZone = new MapiCalendarTimeZone("Eastern Standard Time");

הגדרת תזכורת עם הפגישה שנוצרה

תזכורת יכולה להתווסף כאשר נוצרה פגישה. ההתראות האלה יכולות להפעיל בהתבסס על קריטריונים שונים כגון n דקות לפני תחילת הלוז, חזרה n פעמים בביניים של n. ניתן להשתמש בתגים שונים ליצירת ההפעלות האלו בתסריט המוקף ב‑BEGIN:VALARM ו‑END:VALARM בתוך פגישה. קיימים מספר ווריאנטים שבהם ניתן להגדיר תזכורת לפגישה.

הגדרת תזכורת על ידי הוספת תגים

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = RunExamples.getDataDir_Outlook();
long MIN_MS = 60 * 1000;
long HR_MS = 60 * MIN_MS;
long DAY_MS = 24 * HR_MS;

String location = "Meeting Location: Room 5";
Date startDate = getDate(1997, 3, 18, 18, 30, 00);
Date endDate = getDate(1997, 3, 18, 19, 30, 00);
MailAddress organizer = new MailAddress("aaa@amail.com", "Organizer");
MailAddressCollection attendees = new MailAddressCollection();
attendees.addItem(new MailAddress("bbb@bmail.com", "First attendee"));

Appointment target = new Appointment(location, startDate, endDate, organizer, attendees);

// Audio alarm that will sound at a precise time and
// Repeat 4 more times at 15 minute intervals:
AppointmentReminder audioReminder = new AppointmentReminder();
audioReminder.setTrigger(new ReminderTrigger(getDate(1997, 3, 17, 13, 30, 0)));
audioReminder.setRepeat(4);
audioReminder.setDuration(new ReminderDuration(15 * MIN_MS));
audioReminder.setAction(ReminderAction.Audio);
ReminderAttachment attach = new ReminderAttachment(new URI("ftp://Host.com/pub/sounds/bell-01.aud"));
audioReminder.getAttachments().addItem(attach);
target.getReminders().addItem(audioReminder);


// Display alarm that will trigger 30 minutes before the
// Scheduled start of the event it is
// Associated with and will repeat 2 more times at 15 minute intervals:
AppointmentReminder displayReminder = new AppointmentReminder();
ReminderDuration dur = new ReminderDuration(-30 * MIN_MS);
displayReminder.setTrigger(new ReminderTrigger(dur, ReminderRelated.Start));
displayReminder.setRepeat(2);
displayReminder.setDuration(new ReminderDuration(15 * MIN_MS));
displayReminder.setAction(ReminderAction.Display);
displayReminder.setDescription("Breakfast meeting with executive team at 8:30 AM EST");
target.getReminders().addItem(displayReminder);

// Email alarm that will trigger 2 days before the
// Scheduled due date/time. It does not
// Repeat. The email has a subject, body and attachment link.
AppointmentReminder emailReminder = new AppointmentReminder();
ReminderDuration dur1 = new ReminderDuration(-2 * DAY_MS);
emailReminder.setTrigger(new ReminderTrigger(dur1, ReminderRelated.Start));
ReminderAttendee attendee = new ReminderAttendee("john_doe@host.com");
emailReminder.getAttendees().addItem(attendee);
emailReminder.setAction(ReminderAction.Email);
emailReminder.setSummary("REMINDER: SEND AGENDA FOR WEEKLY STAFF MEETING");
emailReminder.setDescription("A draft agenda needs to be sent out to the attendees to the weekly managers meeting (MGR-LIST). Attached is a pointer the document template for the agenda file.");
ReminderAttachment attach1 = new ReminderAttachment(new URI("http://Host.com/templates/agenda.doc"));
emailReminder.getAttachments().addItem(attach1);
target.getReminders().addItem(emailReminder);

// Procedural alarm that will trigger at a precise date/time
// And will repeat 23 more times at one hour intervals. The alarm will
// Invoke a procedure file.
AppointmentReminder procReminder = new AppointmentReminder();
procReminder.setTrigger(new ReminderTrigger(getDate(1998, 1, 1, 5, 0, 0)));
procReminder.setRepeat(23);
procReminder.setDuration(new ReminderDuration(1 * DAY_MS));
procReminder.setAction(ReminderAction.Procedure);
ReminderAttachment attach2 = new ReminderAttachment(new URI("ftp://Host.com/novo-procs/felizano.exe"));
procReminder.getAttachments().addItem(attach2);
target.getReminders().addItem(procReminder);
target.save(dataDir + "savedFile_out.ics");

המרת פגישת EML ל‑MSG עם גוף HTML

מאז גרסה 19.3, Aspose.Email מציעה אפשרות להמיר פגישות EML ל‑MSG תוך שמירת גוף HTML של הפגישה. Aspose.Email מספקת MapiConversionOptions.ForcedRtfBodyForAppointment מאפיין אשר ערך ברירת המחדל שלו הוא true. כאשר הערך של MapiConversionOptions.ForcedRtfBodyForAppointment כאשר מוגדר ל true, גוף הפגישה מומר לפורמט RTF. כדי לשמור על פורמט גוף הפגישה בפורמט HTML, הגדר את הערך של MapiConversionOptions.ForcedRtfBodyForAppointment ל false.

הדוגמה הבאה מדגימה את השימוש ב‑ MapiConversionOptions.ForcedRtfBodyForAppointment מאפיין לשמירת פורמט גוף הפגישה בפורמט HTML.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

MailMessage mailMessage = MailMessage.load(dataDir + "TestAppointment.eml");

MapiConversionOptions conversionOptions = new MapiConversionOptions();
conversionOptions.setFormat(OutlookMessageFormat.Unicode);

// default value for ForcedRtfBodyForAppointment is true
conversionOptions.setForcedRtfBodyForAppointment(false);

MapiMessage mapiMessage = MapiMessage.fromMailMessage(mailMessage, conversionOptions);

if (mapiMessage.getBodyType() == BodyContentType.Html) {
    System.out.println("Body Type: Html");
} else if (mapiMessage.getBodyType() == BodyContentType.Rtf) {
    System.out.println("Body Type: Rtf");
}

mapiMessage.save(dataDir + "TestAppointment_out.msg");

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

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

אפשר ליצור רשימת הפצה באמצעות Aspose.Email API שהיא אוסף של מספר אנשי קשר. ניתן לשמור רשימת הפצה לכונן בפורמט Outlook MSG ולצפות/לטפל בה על ידי פתיחתה ב‑MS Outlook.

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

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "outlook/";

String displayName1 = "Sebastian Wright";
String email1 = "SebastianWright@dayrep.com";

String displayName2 = "Wichert Kroos";
String email2 = "WichertKroos@teleworm.us";

String strEntryId1;
String strEntryId2;

// Create distribution list from contacts
try (PersonalStorage personalStorage = PersonalStorage.create(dataDir + "CreateDistributionListInPST_out.pst", FileFormatVersion.Unicode)) {
    // Add the contact folder to pst
    FolderInfo contactFolder = personalStorage.createPredefinedFolder("Contacts", StandardIpmFolder.Contacts);

    // Create contacts
    strEntryId1 = contactFolder.addMapiMessageItem(new MapiContact(displayName1, email1));
    strEntryId2 = contactFolder.addMapiMessageItem(new MapiContact(displayName2, email2));

    // Create distribution list on the base of the created contacts
    MapiDistributionListMember member1 = new MapiDistributionListMember(displayName1, email1);
    member1.setEntryIdType(MapiDistributionListEntryIdType.Contact);
    member1.setEntryId(Base64.getDecoder().decode(strEntryId1));

    MapiDistributionListMember member2 = new MapiDistributionListMember(displayName2, email2);
    member2.setEntryIdType(MapiDistributionListEntryIdType.Contact);
    member2.setEntryId(Base64.getDecoder().decode(strEntryId2));

    MapiDistributionListMemberCollection members = new MapiDistributionListMemberCollection();
    members.add(member1);
    members.add(member2);

    MapiDistributionList distributionList = new MapiDistributionList("Contact list", members);
    distributionList.setBody("Distribution List Body");
    distributionList.setSubject("Sample Distribution List using Aspose.Email");

    // Add distribution list to PST
    contactFolder.addMapiMessageItem(distributionList);
}

// Create one-off distribution list members (for which no separate contacts were created)
try (PersonalStorage personalStorage = PersonalStorage.create(dataDir + "CreateDistributionListInPST_OneOffmembers_out.pst", FileFormatVersion.Unicode)) {
    // Add the contact folder to pst
    FolderInfo contactFolder = personalStorage.createPredefinedFolder("Contacts", StandardIpmFolder.Contacts);

    MapiDistributionListMemberCollection oneOffmembers = new MapiDistributionListMemberCollection();
    oneOffmembers.add(new MapiDistributionListMember("John R. Patrick", "JohnRPatrick@armyspy.com"));
    oneOffmembers.add(new MapiDistributionListMember("Tilly Bates", "TillyBates@armyspy.com"));

    MapiDistributionList oneOffMembersList = new MapiDistributionList("Simple list", oneOffmembers);
    contactFolder.addMapiMessageItem(oneOffMembersList);
}

שמירת רשימת הפצה של Mapi לקובץ VCF מרובה אנשי קשר בודד

ה void save(String fileName, MapiDistributionListSaveOptions options) השיטה מאפשרת לשמור את רשימת ההפצה של Mapi בקובץ בשם שצוין תוך שימוש אפשרויות השמירה שסופקו. ניתן לספק את שם הקובץ ו‑instance של MapiDistributionListSaveOptions מחלקה כפרמטרים. ה MapiDistributionListSaveOptions המחלקה מכילה אפשרויות לשמירת רשימת ההפצה של Mapi. במקרה זה, ניתן לציין את פורמט השמירה כ-VCard (ContactSaveFormat.VCard) כדי לשמור את רשימת ההפצה כקובץ VCF עם מספר אנשי קשר.

הקטע הקוד הבא מדגים כיצד לשמור רשימת הפצה לקובץ VCF עם מספר אנשי קשר:

MapiDistributionList dlist = (MapiDistributionList)msg.toMapiMessageItem();
MapiDistributionListSaveOptions options = new MapiDistributionListSaveOptions(ContactSaveFormat.VCard);
dlist.save("distribution_list.vcf", options);

קריאת רשימת הפצה מקובץ PST

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String fileName = "outlook/message.msg";

MapiMessage message = MapiMessage.fromFile(fileName);
MapiDistributionList dlist = (MapiDistributionList)message.toMapiMessageItem();

Java: עבודה עם חזרות

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

עבודה עם חזרות יומיות

Aspose.Email תומכת ביצירת חזרות יומיות באמצעות MapiCalendarDailyRecurrencePattern. ניתן להשתמש בשלושה סוגי סיום שונים של חזרת לוח שנה Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. סעיף זה מציג את יצירת תבניות חזרה יומיות שונות.

חזרות יומיות: סוג סיום EndAfterNOccurrence

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

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה היומי על ידי הגדרת המאפיינים כגון PatternType, Period, WeekStartDay, EndType ו-OccurenceCount.
הגדר את המאפיין MapiTask.setRecurrence לאובייקט חזרה יומי זה.
שמור הודעה זו בדיסק.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = RunExamples.getDataDir_Outlook();

Date startDate = getDate(2015, 7, 16);
Date dueDate = getDate(2015, 7, 16);
Date endByDate = getDate(2015, 8, 1);
 
MapiTask task = new MapiTask("This is test task", "Sample Body", startDate, dueDate);
task.setState(MapiTaskState.NotAssigned);

// Set the Daily recurrence
MapiCalendarDailyRecurrencePattern rec = new MapiCalendarDailyRecurrencePattern();
rec.setPatternType(MapiCalendarRecurrencePatternType.Day);
rec.setPeriod(1);
rec.setWeekStartDay(DayOfWeek.Sunday);
rec.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
rec.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=DAILY"));

if (rec.getOccurrenceCount() == 0)
{
    rec.setOccurrenceCount(1);
}

task.setRecurrence(rec);
task.save(dataDir + "Daily_out.msg", TaskSaveFormat.Msg);

ניתן להשתמש בפונקציה הבאה לחישוב מספר האירועים בין שני התאריכים:

private static long getOccurrenceCount(Date start, Date endBy, String rrule)
{
    DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
    CalendarRecurrence pattern = new CalendarRecurrence("DTSTART:" + formatter.format(start) + "\r\nRRULE:" + rrule);
    DateCollection dates = pattern.generateOccurrences(start, endBy);
    return dates.size();
}

הגדרת ערך ספירת החזרות

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the Daily recurrence
MapiCalendarDailyRecurrencePattern record = new MapiCalendarDailyRecurrencePattern();

record.setPatternType(MapiCalendarRecurrencePatternType.Day);
record.setPeriod(1);
record.setWeekStartDay(DayOfWeek.Sunday);
record.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
record.setOccurrenceCount(5);
task.setRecurrence(record);

חזרות יומיות: סוג סיום EndAfterDate

חזרות יומיות: הגדרת ערך Every Day

הקטע הקוד הבא מראה כיצד להגדיר את ערך ה-period ל-1 ואת ערך ה-INTERVAL ל-1 במחרוזת RRULE גם כן.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the Daily recurrence
MapiCalendarDailyRecurrencePattern record = new MapiCalendarDailyRecurrencePattern();

record.setPatternType(MapiCalendarRecurrencePatternType.Day);
record.setPeriod(1);
record.setEndType(MapiCalendarRecurrenceEndType.EndAfterDate);
record.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=DAILY;INTERVAL=1"));
record.setEndDate(endByDate);

ניתן להגדיר את ערך Every Day לכל ערך מתאים כפי שמוצג בדוגמה הבאה:

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the Daily recurrence
MapiCalendarDailyRecurrencePattern record = new MapiCalendarDailyRecurrencePattern();

record.setPatternType(MapiCalendarRecurrencePatternType.Day);
record.setPeriod(2);
record.setEndType(MapiCalendarRecurrenceEndType.EndAfterDate);
record.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=DAILY;INTERVAL=2"));

חזרות יומיות: סוג סיום NeverEnd

ניתן להגדיר את סוג הסיום באמצעות MapiCalendarRecurrenceEndType.NeverEnd. ניתן להגדיר את ה-Period או INTERVAL לערך נדרש, לדוגמה 1, בדוגמה שלהלן.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the Daily recurrence
MapiCalendarDailyRecurrencePattern record = new MapiCalendarDailyRecurrencePattern();

record.setPatternType(MapiCalendarRecurrencePatternType.Day);
record.setPeriod(1);
record.setEndType(MapiCalendarRecurrenceEndType.NeverEnd);

עבודה עם חזרות שבועיות

Aspose.Email מספקת תכונות מתקדמות ליצירת חזרות שבועיות באמצעות MapiCalendarWeeklyRecurrencePattern. ניתן להשתמש בשלושה סוגי סיום שונים של חזרת לוח שנה Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. סעיף זה מציג את יצירת תבניות חזרה שבועיות שונות.

חזרות שבועיות: סוג סיום EndAfterNOccurrences

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

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה השבועי על ידי הגדרת המאפיינים כגון PatternType, Period, WeekStartDay, EndType ו-OccurenceCount.
הגדר את המאפיין MapiTask.setRecurrence לאובייקט חזרה שבועי זה.
שמור הודעה זו בדיסק.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = RunExamples.getDataDir_Outlook();

Date startDate = getDate(2015, 7, 16);
Date dueDate = getDate(2015, 7, 16);
Date endByDate = getDate(2015, 9, 1);

MapiTask task = new MapiTask("This is test task", "Sample Body", startDate, dueDate);
task.setState(MapiTaskState.NotAssigned);

// Set the weekly recurrence
MapiCalendarWeeklyRecurrencePattern rec = new MapiCalendarWeeklyRecurrencePattern();
rec.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
rec.setPatternType(MapiCalendarRecurrencePatternType.Week);
rec.setPeriod(1);
rec.setWeekStartDay(DayOfWeek.Sunday);
rec.setDayOfWeek(MapiCalendarDayOfWeek.Friday);
rec.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=WEEKLY;BYDAY=FR"));

if (rec.getOccurrenceCount() == 0)
{
    rec.setOccurrenceCount(1);
}

task.setRecurrence(rec);
task.save(dataDir + "Weekly_out.msg", TaskSaveFormat.Msg);

ניתן להשתמש בפונקציה הבאה לחישוב מספר האירועים בין שני התאריכים:

private static long getOccurrenceCount(Date start, Date endBy, String rrule)
{
    DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
    CalendarRecurrence pattern = new CalendarRecurrence("DTSTART:" + formatter.format(start) + "\r\nRRULE:" + rrule);
    DateCollection dates = pattern.generateOccurrences(start, endBy);
    return dates.size();
}

בחירת מספר ימים בשבוע

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the weekly recurrence
MapiCalendarWeeklyRecurrencePattern rec = new MapiCalendarWeeklyRecurrencePattern();

rec.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
rec.setPatternType(MapiCalendarRecurrencePatternType.Week);
rec.setPeriod(1);
rec.setWeekStartDay(DayOfWeek.Sunday);
rec.setDayOfWeek(MapiCalendarDayOfWeek.Friday | MapiCalendarDayOfWeek.Monday);
rec.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=WEEKLY;BYDAY=FR,MO"));

בחירת מספר ימים בשבוע והגדרת מרווחים

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the weekly recurrence
MapiCalendarWeeklyRecurrencePattern rec = new MapiCalendarWeeklyRecurrencePattern();
rec.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
rec.setPatternType(MapiCalendarRecurrencePatternType.Week);
rec.setPeriod(2);
rec.setWeekStartDay(DayOfWeek.Sunday);
rec.setDayOfWeek(MapiCalendarDayOfWeek.Friday | MapiCalendarDayOfWeek.Monday);
rec.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=WEEKLY;BYDAY=FR,MO;INTERVAL=2"));

חזרות שבועיות: סוג סיום EndAfterDate

חזרות שבועיות: הגדרת ערך Every Day

הקטע הקוד הבא מראה כיצד להגדיר את ערך ה-period ל-1 ואת ערך ה-INTERVAL ל-1 במחרוזת RRULE גם כן.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the weekly recurrence
MapiCalendarWeeklyRecurrencePattern rec = new MapiCalendarWeeklyRecurrencePattern();
rec.setEndType(MapiCalendarRecurrenceEndType.EndAfterDate);
rec.setPatternType(MapiCalendarRecurrencePatternType.Week);
rec.setPeriod(1);
rec.setWeekStartDay(DayOfWeek.Sunday);
rec.setDayOfWeek(MapiCalendarDayOfWeek.Friday);
rec.setEndDate(endByDate);
rec.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=WEEKLY;BYDAY=FR;INTERVAL=1"));

ניתן להגדיר את ערך Every Day לכל ערך מתאים ולבחור מספר ימות כפי שמוצג בדוגמה הבאה:

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
MapiCalendarWeeklyRecurrencePattern record = new MapiCalendarWeeklyRecurrencePattern();
record.setEndType(MapiCalendarRecurrenceEndType.EndAfterDate);
record.setPatternType(MapiCalendarRecurrencePatternType.Week);
record.setPeriod(2);
record.setWeekStartDay(DayOfWeek.Sunday);
record.setEndDate(endByDate);
record.setDayOfWeek(MapiCalendarDayOfWeek.Friday | MapiCalendarDayOfWeek.Monday);
record.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=WEEKLY;BYDAY=FR,MO;INTERVAL=2"));

חזרות שבועיות: סוג סיום NeverEnd

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the weekly recurrence
MapiCalendarWeeklyRecurrencePattern recurrence = new MapiCalendarWeeklyRecurrencePattern();
recurrence.setEndType(MapiCalendarRecurrenceEndType.NeverEnd);
recurrence.setPatternType(MapiCalendarRecurrencePatternType.Week);
recurrence.setPeriod(1);
recurrence.setWeekStartDay(DayOfWeek.Sunday);
recurrence.setDayOfWeek(MapiCalendarDayOfWeek.Friday);
recurrence.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=WEEKLY;BYDAY=FR"));

עבודה עם חזרות חודשיות

Aspose.Email תומכת ביצירת חזרות חודשיות באמצעות MapiCalendarMonthlyRecurrencePattern. ניתן להשתמש בשלושה סוגי סיום שונים של חזרת לוח שנה Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. סעיף זה מציג את יצירת תבניות חזרה חודשיות שונות.

חזרות חודשיות: סוג סיום EndAfterNOccurrences

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

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה החודשי על ידי הגדרת המאפיינים כגון PatternType, Period, WeekStartDay, EndType ו-OccurenceCount.
הגדר את המאפיין MapiTask.setRecurrence לאובייקט חזרה חודשי זה.
שמור הודעה זו בדיסק.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
String dataDir = RunExamples.getDataDir_Outlook();

Date startDate = getDate(2015, 7, 16);
Date DueDate = getDate(2015, 7, 16);
Date endByDate = getDate(2015, 12, 31);

MapiTask task = new MapiTask("This is test task", "Sample Body", startDate, dueDate);
task.setState(MapiTaskState.NotAssigned);

// Set the Monthly recurrence
MapiCalendarMonthlyRecurrencePattern rec = new MapiCalendarMonthlyRecurrencePattern();
rec.setDay(15);
rec.setPeriod(1);
rec.setPatternType(MapiCalendarRecurrencePatternType.Month);
rec.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
rec.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=MONTHLY;BYMONTHDAY=15;INTERVAL=1"));
rec.setWeekStartDay(DayOfWeek.Monday);

if (rec.getOccurrenceCount() == 0)
{
    rec.setOccurrenceCount(1);
}

task.setRecurrence(rec);
task.save(dataDir + "Monthly_out.msg", TaskSaveFormat.Msg);

ניתן להשתמש בפונקציה הבאה לחישוב מספר האירועים בין שני תאריכים:

private static long getOccurrenceCount(Date start, Date endBy, String rrule)
{
    DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
    CalendarRecurrence pattern = new CalendarRecurrence("DTSTART:" + formatter.format(start) + "\r\nRRULE:" + rrule);
    DateCollection dates = pattern.generateOccurrences(start, endBy);
    return dates.size();
}

קביעת מספר קבוע של חזרות

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the Monthly recurrence
MapiCalendarMonthlyRecurrencePattern records = new MapiCalendarMonthlyRecurrencePattern();
records.setDay(15);
records.setPeriod(1);
records.setPatternType(MapiCalendarRecurrencePatternType.Month);
records.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
records.setOccurrenceCount(5);
records.setWeekStartDay(DayOfWeek.Monday);

חזרות חודשיות: סוג סיום EndAfterDate

"אפשרות "End By" במשימת Mapi מושגת על ידי הגדרת המאפיין OccurrenceCount המחושב על ידי הפונקציה getOccurrenceCount(). פונקציה זו מקבלת תאריך התחלה, תאריך סיום ומחרוזת RRULE. הקטע הקוד הבא מראה כיצד ליצור חזרה בתאריך ה-15 של כל חודש בין תאריכי ההתחלה והסיום.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = RunExamples.getDataDir_Outlook();

Date startDate = getDate(2015, 7, 1);
Date dueDate = getDate(2015, 7, 1);
Date endByDate = getDate(2015, 12, 31);

MapiTask task = new MapiTask("This is test task", "Sample Body", startDate, dueDate);
task.setState(MapiTaskState.NotAssigned);

// Set the Monthly recurrence
MapiCalendarMonthlyRecurrencePattern recurrence = new MapiCalendarMonthlyRecurrencePattern();
recurrence.setDay(15);
recurrence.setPeriod(1);
recurrence.setPatternType(MapiCalendarRecurrencePatternType.Month);
recurrence.setEndType(MapiCalendarRecurrenceEndType.EndAfterDate);
recurrence.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=MONTHLY;BYMONTHDAY=15;INTERVAL=1"));
recurrence.setWeekStartDay(DayOfWeek.Monday);
recurrence.setEndDate(endByDate);

task.setRecurrence(recurrence);
task.save(dataDir + "SetMonthlyEndAfterDateRecurrence_out.msg", TaskSaveFormat.Msg);

חזרות חודשיות: סוג סיום NeverEnd

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
MapiCalendarMonthlyRecurrencePattern recurrence = new MapiCalendarMonthlyRecurrencePattern();
recurrence.setDay(15);
recurrence.setPeriod(1);
recurrence.setPatternType(MapiCalendarRecurrencePatternType.Month);
recurrence.setEndType(MapiCalendarRecurrenceEndType.NeverEnd);
recurrence.setWeekStartDay(DayOfWeek.Monday);

עבודה עם חזרות שנתיות

Aspose.Email תומכת ביצירת חזרות שנתיות באמצעות MapiCalendarMonthlyRecurrencePattern. על ידי הגדרת המאפיין period ל-12, ניתן להשיג תבנית חזרה שנתית. ניתן להשתמש בשלושה סוגי סיום שונים של חזרת לוח שנה Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. סעיף זה מציג את יצירת תבניות חזרה שנתיות שונות.

חזרות שנתיות: סוג סיום EndAfterNOccurrences

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

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה החודשי על ידי הגדרת המאפיינים כגון PatternType, Period, WeekStartDay, EndType ו-OccurenceCount.
הגדר את המאפיין MapiTask.setRecurrence לאובייקט חזרה חודשי זה כדי להשיג חזרה שנתית.
שמור הודעה זו בדיסק.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
Date startDate = getDate(2015, 7, 1);
Date dueDate = getDate(2015, 7, 1);

MapiTask task = new MapiTask("This is test task", "Sample Body", startDate, dueDate);
task.setState(MapiTaskState.NotAssigned);

// Set the Yearly recurrence
MapiCalendarMonthlyRecurrencePattern recurrence = new MapiCalendarMonthlyRecurrencePattern();
recurrence.setDay(15);
recurrence.setPeriod(12);
recurrence.setPatternType(MapiCalendarRecurrencePatternType.Month);
recurrence.setEndType(MapiCalendarRecurrenceEndType.EndAfterNOccurrences);
recurrence.setOccurrenceCount(3);

task.setRecurrence(recurrence);
task.save("Yearly.msg", TaskSaveFormat.Msg);

חזרות שנתיות: סוג סיום EndAfterDate

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the Yearly recurrence
MapiCalendarMonthlyRecurrencePattern rec = new MapiCalendarMonthlyRecurrencePattern();
rec.setDay(15);
rec.setPeriod(12);
rec.setPatternType(MapiCalendarRecurrencePatternType.Month);
rec.setEndType(MapiCalendarRecurrenceEndType.EndAfterDate);
rec.setEndDate(endByDate);
rec.setOccurrenceCount(getOccurrenceCount(startDate, endByDate, "FREQ=YEARLY;BYMONTHDAY=15;BYMONTH=7;INTERVAL=1"));

חזרות שנתיות: סוג סיום NeverEnd

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// Set the Yearly recurrence
MapiCalendarMonthlyRecurrencePattern recurrence = new MapiCalendarMonthlyRecurrencePattern();
recurrence.setDay(15);
recurrence.setPeriod(12);
recurrence.setPatternType(MapiCalendarRecurrencePatternType.Month);
recurrence.setEndType(MapiCalendarRecurrenceEndType.NeverEnd);

יצירת חזרה מתוך כלל חזרה

API של Aspose.Email מספקת אפשרות ליצור תבנית חזרה מתוך כלל חזרה (RRULE). היא מפענחת את המידע מתוך ה-RRULE בהתאם למפרט RFC 5545 iCal ומייצרת את תבנית החזרה באמצעות השיטה MapiCalendarRecurrencePatternFactory.fromString. הקטע הקוד הבא מראה כיצד ליצור תבנית חזרה מתוך כלל החזרה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = RunExamples.getDataDir_Outlook();

Date startDate = getDate(2015, 7, 16);
Date endDate = getDate(2015, 8, 1);
MapiCalendar app1 = new MapiCalendar("test location", "test summary", "test description", startDate, endDate);

app1.setStartDate(startDate);
app1.setEndDate(endDate);

String pattern = "DTSTART;TZID=Europe/London:20150831T080000\r\nDTEND;TZID=Europe/London:20150831T083000\r\nRRULE:FREQ=DAILY;INTERVAL=1;COUNT=7\r\nEXDATE:20150831T070000Z,20150904T070000Z";
app1.getRecurrence().setRecurrencePattern(MapiCalendarRecurrencePatternFactory.fromString(pattern));

הוספת קובץ מצורף לאירועי לוח שנה חוזרים

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
String dataDir = RunExamples.getDataDir_Outlook();

Date startDate = addHours(getDate(2018, 7, 19), 12);
MapiCalendar calendar = new MapiCalendar("location1", "summary1", "description1", startDate, addHours(startDate, 1));

MapiCalendarEventRecurrence recurrence = new MapiCalendarEventRecurrence();
MapiCalendarRecurrencePattern pattern = new MapiCalendarDailyRecurrencePattern();
recurrence.setRecurrencePattern(pattern);
pattern.setPatternType(MapiCalendarRecurrencePatternType.Day);
pattern.setPeriod(1);
pattern.setEndType(MapiCalendarRecurrenceEndType.NeverEnd);

Date exceptionDate = addDays(startDate, 3);
MapiCalendarExceptionInfo exception = new MapiCalendarExceptionInfo();
exception.setLocation("exceptionLoc");
exception.setSubject("exceptionSubj");
exception.setBody("exceptionBody");
exception.setOriginalStartDate(exceptionDate);
exception.setStartDateTime(exceptionDate);
exception.setEndDateTime(addHours(exceptionDate, 5));
exception.setAttachments(new MapiAttachmentCollection(calendar));
exception.getAttachments().add("file.txt", "hello, world!".getBytes());

pattern.getExceptions().addItem(exception);
pattern.getModifiedInstanceDates().addItem(exceptionDate);
pattern.getDeletedInstanceDates().addItem(exceptionDate);
calendar.setRecurrence(recurrence);

try (PersonalStorage newPst = PersonalStorage.create(dataDir + "AddAttachmentToMapiExceptionInfo.pst", FileFormatVersion.Unicode))
{
    FolderInfo newFolder = newPst.createPredefinedFolder("Calendar", StandardIpmFolder.Appointments);
    newFolder.addMapiMessageItem(calendar);
}

הגדרת אזור זמן לאירוע לוח שנה

API של Aspose.Email מספקת אפשרות להגדיר אזור זמן של לוח שנה:

מידע אזור זמן לתאריך התחלה/סיום
מידע אזור זמן לפגישה חוזרת
מידע אזור זמן המתאר כיצד להמיר את תאריך ושעת הפגישה בסדרה חוזרת אל ומ-UTC

הקטע הקוד הבא מראה כיצד להגדיר מידע אזור זמן של לוח שנה:

MapiCalendar event = new MapiCalendar("location", "summary", "description", startDate, endDate);
// UTC time zone
MapiCalendarTimeZone utcTimeZone = new MapiCalendarTimeZone("UTC");
event.setStartDateTimeZone(utcTimeZone);
event.setEndDateTimeZone(utcTimeZone);

MapiCalendarDailyRecurrencePattern pattern = new MapiCalendarDailyRecurrencePattern();
pattern.setPeriod(1);
pattern.setStartDate(startDate);
pattern.setEndDate(untilDate);
pattern.setEndType(MapiCalendarRecurrenceEndType.EndAfterDate);
pattern.setPatternType(MapiCalendarRecurrencePatternType.Day);
pattern.setDayOfWeek(DayOfWeek.Monday);

MapiCalendarEventRecurrence r = new MapiCalendarEventRecurrence();
r.setRecurrencePattern(pattern);
r.setClipStart(startDate);
r.setClipEnd(pattern.getEndDate());
//https://docs.microsoft.com/en-us/office/client-developer/outlook/mapi/pidlidappointmenttimezonedefinitionrecur-canonical-property
r.setAppointmentTimeZoneDefinitionRecur(utcTimeZone); // <---
r.setTimeZoneStruct(utcTimeZone); // <---
event.setRecurrence(r);