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

Python-Net: יצירת ושמירת קבצי MSG

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

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

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

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

למחלקה MailMessage יש מתודה Save() שיכולה לשמור קבצי Outlook MSG לדיסק או לזרם. קטעי הקוד למטה יוצרים מופע של המחלקה MailMessage, מקצים תכונות כמו from, to, subject ו-body. המתודה Save() מקבלת את שם הקובץ כפרמטר. בנוסף, ניתן ליצור הודעות Outlook עם גוף RTF דחוס באמצעות MapiConversionOptions. כדי להתחיל, צור יישום Windows חדש והוסף הפניה ל‑dll של Aspose.Email לפרויקט.

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

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

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

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

כאשר לוחצים על הכפתור Add Attachment, מוצגת Open File Dialog שתסייע למשתמשים לעיין ולבחור את הקובץ המצורף.
כאשר קובץ נבחר, הנתיב המלא מתווסף לרשימה.
כאשר קובץ MSG נוצר, נתיבי הקבצים המצורפים נלקחים מהרשימה ומתווספים לאוסף MailMessage.Attachments.

כתוב את הקוד הבא באירוע הלחיצה של הכפתור Add Attachment.

הוסף את הקוד שמוסיף את הקבצים המצורפים למופע ה‑MailMessage. הקוד הסופי עבור הפונקציה Write Msg כתוב להלן.

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

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

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

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

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

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

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

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

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

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

נסו זאת!

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

טעינת קבצי MSG

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

from aspose.email.mapi import MapiMessage

# Create an instance of MapiMessage from file
msg = MapiMessage.from_file("message.msg")

# Get subject
print("Subject: " + msg.subject)

# Get from address
print("From: " + msg.sender_email_address)

# Get body
print("Body: " + msg.body)

# Get recipients information
recipients = ", ".join([r.email_address for r in msg.recipients])
print("Recipients: " + recipients)

# Get attachments
for att in msg.attachments:
    print(att.file_name)
    print(att.display_name)

טעינה מזרם

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

from aspose.email.mapi import MapiMessage
import io

# Read the file into a byte array
file_path = dir_path + "message.msg"
with open(file_path, "rb") as file:
    bytes_data = file.read()

# Create a memory stream from the byte array
stream = io.BytesIO(bytes_data)
stream.seek(0)

# Create an instance of MapiMessage from the stream
msg = MapiMessage.from_stream(stream)

# Get subject
print("Subject: " + msg.subject)

# Get from address
print("From: " + msg.sender_email_address)

# Get body
print("Body: " + msg.body)

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

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

from aspose.email import MailMessage, EmlLoadOptions
from aspose.email.mapi import MapiMessage, MapiConversionOptions, OutlookMessageFormat

eml_file = dir_path + "message.eml"

# Load the EML file
eml_options = EmlLoadOptions()
eml = MailMessage.load(eml_file, eml_options)

# Create MapiConversionOptions
conversion_options = MapiConversionOptions()
conversion_options.format = OutlookMessageFormat.UNICODE

# Preserve Embedded Message Format
conversion_options.preserve_embedded_message_format = True

# Convert EML to MSG with options
msg = MapiMessage.from_mail_message(eml, conversion_options)

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

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

קביעת סוג פריט MAPI בתיקיית PST

קובץ PST בדרך כלל מכיל סוגים שונים של נתונים, כגון הודעות דוא"ל, אירועי לוח שנה, אנשי קשר ועוד. ה‑ MapiItemType מחלקה של Aspose.Email מאפשרת לגשת ולסווג סוגים שונים של פריטי MAPI בקובץ PST. הקוד למטה מדגים כיצד לקבוע את סוג פריט MAPI בתיקיית PST:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("test.pst")
folder = pst.root_folder.get_sub_folder("Calendar")
for messageInfo in folder.enumerate_messages():
    msg = pst.extract_message(messageInfo)

    # Get the class type based on msg.SupportedType
    item_type = msg.supported_type

    # Non-supported type. It cannot be accessed as appropriate item type.
    if item_type == ae.mapi.MapiItemType.NONE:
        print("Item type not supported")
    # An email message.
    elif item_type == ae.mapi.MapiItemType.MESSAGE:
        # You can access to MapiMessage properties there.
        # A subject for example
        print(msg.subject)
    # A contact item. Can be accessed as MapiContact.
    elif item_type == ae.mapi.MapiItemType.CONTACT:
        contact = msg.to_mapi_message_item()
        # You can access to MapiContact properties there. 
        # A name_info.display_name for example. 
        print(contact.name_info.display_name)
    # A calendar item. Can be accessed as MapiCalendar.
    elif item_type == ae.mapi.MapiItemType.CALENDAR:
        calendar = msg.to_mapi_message_item()
        # You can access to MapiCalendar properties there. 
        # A location for example. 
        print(calendar.location)
    # A distribution list. Can be accessed as MapiDistributionList.
    elif item_type == ae.mapi.MapiItemType.DIST_LIST:
        dlist = msg.to_mapi_message_item()
        # You can access to MapiDistributionList properties there
    # A Journal entry. Can be accessed as MapiJournal.
    elif item_type == ae.mapi.MapiItemType.JOURNAL:
        journal = msg.to_mapi_message_item()
        # You can access to MapiJournal properties there
    # A StickyNote. Can be accessed as MapiNote.
    elif item_type == ae.mapi.MapiItemType.NOTE:
        note = msg.to_mapi_message_item()
        # You can access to MapiNote properties there
    # A Task item. Can be accessed as MapiTask.
    elif item_type == ae.mapi.MapiItemType.TASK:
        task = msg.to_mapi_message_item()
        # You can access to MapiTask properties there

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

API של Aspose.Email מאפשרת המרת קובץ MSG להודעת MIME בעזרת המתודה ToMailMessage.

קביעת תזמון לפעולת המרה וטעינת הודעה

כדי להגביל את הזמן במילישניות של המרת ההודעה (ערך ברירת המחדל 3 שניות), המאפיין timeout של ה- MailConversionOptions class משמשת.

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

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("my.msg")
options = ae.mapi.MailConversionOptions()
options.timeout = 5000
mailMessage = msg.to_mail_message(options)

על ידי הגדרת זמן קצוב (timeout) לתהליכי המרת הודעות וטעינתן, ניתן לשלוט בזמן המרבי שמותר לתהליכים אלו לרוץ. לאחר קביעת זמן הקצוב, ניתן להמשיך בתהליכי המרת והטעינה של ההודעות.

עיבוד קבצי Outlook Template (OFT)

טעינה, שינוי ושמירת קובץ OFT

תבניות Outlook (OFT) מספקות דרך נוחה לייעל תהליך שליחת הודעות אימייל חוזרות. במקום לכתוב את אותה הודעה מאפס בכל פעם, ניתן ליצור הודעה ב‑Outlook ולשמור אותה כתבנית Outlook (OFT). לאחר מכן, כשצריך לשלוח הודעה דומה, ניתן ליצור אותה במהירות מהתבנית. גישה זו חוסכת את המאמץ של כתיבת תוכן זהה בגוף ההודעה, קביעת שורת הנושא, העיצוב ועוד.

של Aspose.Email MailMessage המחלקה מספקת כלי חזק לטעון ולתפעל קבצי תבנית Outlook (OFT). לאחר שתבנית Outlook נטענת למופע של מחלקת MailMessage, ניתן לעדכן בקלות תכונות כגון השולח, הנמען, גוף ההודעה, נושא ועוד מאפיינים אחרים.

import aspose.email as ae

# Load the OFT file
oft_file_path = "your_template.oft"
mail_message = ae.MailMessage.load(oft_file_path)

# Update properties as needed
mail_message.subject = "Updated Subject"
mail_message.body = "Updated body text."

# Save the updated message as an MSG file
msg_file_path = "updated_message.msg"
mail_message.save(msg_file_path, ae.MailMessageSaveType.outlook_message_format_unicode)

print(f"Updated message saved to {msg_file_path}")

לאחר ביצוע העדכונים הנדרשים, ניתן לשלוח את הדוא"ל באמצעות ה‑ SmtpClient מחלקה:

# Send the email
smtpClient.send(message)

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

לצורך זה, ניתן להשתמש ב‑ MailMessage מחלקה ליצירת אימייל, ולאחר מכן לשמור אותו כקובץ OFT. דוגמת הקוד שלהלן תציג כיצד לשמור אימייל כתבנית Outlook:

import aspose.email as ae

# Create a new MailMessage
message = ae.MailMessage()
message.subject = "Sample Outlook Template"
message.html_body = "<html><body>This is the body of the email.</body></html>"
message.from_address = ae.MailAddress("your.email@example.com", "Your Name")

# Save the MailMessage as an Outlook Template (OFT) file
oft_file_path = "sample_template.oft"
message.save(oft_file_path, ae.SaveOptions.default_oft)

print(f"Outlook Template saved as {oft_file_path}")

OFT או MSG: קביעת סוג של MapiMessage

קוד הדוגמה הבא מציג כיצד לקבוע אם הודעת MAPI שנטענה היא הודעת אימייל רגילה או תבנית Outlook (OFT):

msg = ae.mapi.MapiMessage.Load("message.msg");
isOft = msg.is_template # returns false

msg = ae.mapi.MapiMessage.Load("message.oft");
isOft = msg.IsTemplate; # returns true

לאחר טעינת קובץ MSG, הקוד בודק האם המאפיין is_template של ה‑ MapiMessaage המחלקה היא True או False. אם היא מחזירה false, ההודעה הטעונה היא הודעת דוא"ל סטנדרטית, ולא תבנית Outlook; אם היא מחזירה true, ההודעה אינה הודעת דוא"ל סטנדרטית, אלא תבנית Outlook.

שמירת MapiMessage או MailMessage כ‑OFT

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

import aspose.email as ae

# Save the MailMessage to OFT format
eml = ae.MailMessage.load("message.eml")

eml.save("message.oft", ae.SaveOptions.default_oft)

# or alternative way 2
save_options = ae.MsgSaveOptions(ae.MailMessageSaveType.outlook_template_format)
eml.save("message.oft", save_options)

# or alternative way 3
save_options = ae.SaveOptions.create_save_options(ae.MailMessageSaveType.outlook_template_format)
eml.save("message.oft", save_options)

# Save the MapiMessage to OFT format
msg = ae.mapi.MapiMessage.load("message.msg")

msg.save("message.oft", ae.SaveOptions.default_oft)

# or alternative way 2
save_options = ae.MsgSaveOptions(ae.MailMessageSaveType.outlook_template_format)
msg.save("message.oft", save_options)

# or alternative way 3
save_options = ae.SaveOptions.create_save_options(ae.MailMessageSaveType.outlook_template_format)
msg.save("message.oft", save_options)

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

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

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

דוגמת הקוד למטה מציגה כיצד לטעון הודעה, להמיר אותה לפורמט MSG ולשמור כ‑MSG (החתימה נשמרת כברירת מחדל):


import aspose.email as ae

# Load mail message
loadOptions = ae.EmlLoadOptions()
message = ae.MailMessage.load("Message.eml", loadOptions)
# Save as MSG
message.save("ConvertEMLToMSG_out.msg", ae.SaveOptions.default_msg_unicode)

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

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

import aspose.email as ae

# Load mail message
loadOptions = ae.EmlLoadOptions()
smime_eml = ae.MailMessage.load("smime.eml", loadOptions)

conversion_options = ae.mapi.MapiConversionOptions(ae.mapi.OutlookMessageFormat.UNICODE)
msg = ae.mapi.MapiMessage.from_mail_message(smime_eml, conversion_options)
# Save File to disk
msg.save("ConvertMIMEMessagesFromMSGToEML_out.msg")

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

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


import aspose.email as ae

msg = ae.mapi.MapiMessage.load("my.msg")

# Add Two categories
ae.mapi.FollowUpManager.add_category(msg, "Purple Category")
ae.mapi.FollowUpManager.add_category(msg, "Red Category")

# Retrieve the list of available categories
categories = ae.mapi.FollowUpManager.get_categories(msg)

# Remove the specified category and then Clear all categories
ae.mapi.FollowUpManager.remove_category(msg, "Red Category")
ae.mapi.FollowUpManager.clear_categories(msg)

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

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

דוגמת הקוד למטה מציגה כיצד לחלץ מידע על נמען והמצב של המעקב שלו מקובץ הודעת Outlook (MSG):

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("received.msg")

for recipient in msg.recipients:
    print(f"Recipient: {recipient.display_name}")
    print(f"Delivery time:  {recipient.properties[ae.mapi.MapiPropertyTag.RECIPIENT_TRACKSTATUS_TIME_DELIVERY]}")
    print(f"Read time:  {recipient.properties[ae.mapi.MapiPropertyTag.RECIPIENT_TRACKSTATUS_TIME_READ]}")

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

Aspose.Email מספקת דרכים פשוטות ליצור הודעות הודעה קידום (forward) ותשובה (reply) בהתבסס על קיימות.

יצירת הודעת Forward

ניתן להשתמש ב- ForwardMessageBuilder מחלקה ליצירת הודעת העברה על‑ידי הגדרת הודעת המקור, השולח, הנמענים, הנושא והגוף. הודעות העברה יכולות לכלול את ההודעה המקורית כקובץ מצורף או כחלק מהגוף של ההודעה המועברת. יש לך גמישות להתאים תכונות נוספות כגון קבצים מצורפים, כותרות ואופציות עיצוב. דוגמת הקוד למטה מציגה כיצד ליצור הודעת העברה:


import aspose.email as ae

msg = ae.mapi.MapiMessage.load("original.msg")

builder = ae.tools.ForwardMessageBuilder()
builder.addition_mode = ae.tools.OriginalMessageAdditionMode.TEXTPART

forwardMsg = builder.build_response(msg)
forwardMsg.save("forward_out.msg")

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

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

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("original.msg")

builder = ae.tools.ReplyMessageBuilder()

# Set ReplyMessageBuilder Properties
builder.reply_all = True
builder.addition_mode = ae.tools.OriginalMessageAdditionMode.TEXTPART
builder.response_text = "<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>";

replyMsg = builder.build_response(msg)
replyMsg.save("reply_out.msg")

Python-Net: עבודה עם רשימות הפצה

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

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

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

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

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

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

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file( "your_pst_file.pst")
folder = pst.root_folder.get_sub_folder("Contacts")
for messageInfo in folder.enumerate_messages():
    msg = pst.extract_message(messageInfo)

    dlist = msg.to_mapi_message_item()
    if isinstance(dlist, ae.mapi.MapiDistributionList):
        for member in dlist.members:
            print("Member Display Name:", member.display_name)
            print("Member Email Address:", member.email_address)

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

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

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

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

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

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

import aspose.email as ae
from datetime import datetime, timedelta

# Create a new MailMessage
mail_msg = ae.MailMessage()
mail_msg.from_address = ae.MailAddress("from@domain.com")
mail_msg.to.append(ae.MailAddress("to@domain.com"))
mail_msg.body = "This message will test if follow-up options can be added to a new MAPI message."

# Convert MailMessage to MapiMessage
mapi = ae.mapi.MapiMessage.from_mail_message(mail_msg)

# Define follow-up options
dt_start_date = datetime(2013, 5, 23, 14, 40, 0)
dt_reminder_date = datetime(2013, 5, 23, 16, 40, 0)
dt_due_date = dt_reminder_date + timedelta(days=1)

options = ae.mapi.FollowUpOptions("Follow Up", dt_start_date, dt_due_date, dt_reminder_date)

# Set follow-up options for the MapiMessage
ae.mapi.FollowUpManager.set_options(mapi, options)

# Save the MapiMessage
mapi.save("SetFollowUpFlag_out.msg")

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

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

import aspose.email as ae
from datetime import datetime

# Create a new MailMessage
mail_msg = ae.MailMessage()
mail_msg.from_address = ae.MailAddress("from@domain.com")
mail_msg.to.append(ae.MailAddress("to@domain.com"))
mail_msg.body = "This message will test if follow-up options can be added to a new MAPI message."

# Convert MailMessage to MapiMessage
mapi = ae.mapi.MapiMessage.from_mail_message(mail_msg)

# Mark the message as draft
mapi.set_message_flags(ae.mapi.MapiMessageFlags.UNSENT)

dt_reminder_date = datetime(2013, 5, 23, 16, 40, 0)

# Add the follow-up flag for recipients
ae.mapi.FollowUpManager.set_flag_for_recipients(mapi, "Follow up", dt_reminder_date)

# Save the MapiMessage
mapi.save("SetFollowUpForRecipients_out.msg")

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

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

import aspose.email as ae

# Load the MapiMessage from file
mapi_message = ae.mapi.MapiMessage.load("Message.msg")

# Mark the message as completed
ae.mapi.FollowUpManager.mark_as_completed(mapi_message)

# Save the updated MapiMessage
mapi_message.save("MarkedCompleted_out.msg")

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

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

import aspose.email as ae

# Load the MapiMessage from file
mapi_message = ae.mapi.MapiMessage.load("message.msg")

# Clear the follow-up flag
ae.mapi.FollowUpManager.clear_flag(mapi_message)

# Save the updated MapiMessage
mapi_message.save("RemoveFollowUpflag_out.msg")

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

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

import aspose.email as ae

# Load the MapiMessage from file
mapi_message = ae.mapi.MapiMessage.load("message.msg")

# Get the follow-up options
options = ae.mapi.FollowUpManager.get_options(mapi_message)

Python-Net: עבודה עם מאפייני MAPI

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

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

מחלקת MapiProperty מייצגת מאפיין MAPI, המכילה:

שם: מחרוזת המייצגת את שם התכונה.
Tag: ערך long שמייצג את תג המאפיין.
נתונים: מערך בתים המייצג את נתוני התכונה.

קבלת מאפיין MAPI באמצעות תג מאפיין MAPI

כדי לקבל מאפייני MAPI:

צור מופע של MapiMessage על‑ידי טעינה מקבצים או מזרם.
קבל את ה‑MapiProperty מ‑MapiMessage.Properties באמצעות מפתחות MapiPropertyTag.
קבל את הנתונים של MapiProperty באמצעות המתודה GetX.

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

הגדרת מאפייני MAPI

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

כאשר ההגדרה של המתודה convertDateTime היא כמתואר למטה:

קריאת תכונות MAPI בשם מקבצי Outlook MSG

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

קריאת תכונות MAPI בשם מקובץ MSG

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

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("my.msg")

# Get all named MAPI properties
properties = msg.named_properties.values
# Read all properties in foreach loop
for prop in properties:
    #  Read any specific property
    if prop.descriptor.canonical_name == "PidLidSideEffects":
        print(f"{prop.descriptor.canonical_name} = {prop}")
    if prop.descriptor.canonical_name == "PidLidInternetAccountName":
        print(f"{prop.descriptor.canonical_name} = {prop}")

קריאת מאפיין MAPI ממוספר מצורף

Aspose.Email מאפשרת לקבל את כל מאפייני MAPI בשם של קובץ מצורף. דוגמת הקוד הבאה מראה כיצד לקרוא מאפייני MAPI בשם מקבצים מצורפים:

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("my.msg")

# Get all named MAPI properties
attach_properties = msg.attachments[0].named_properties.values
# Read all properties in foreach loop
for prop in attach_properties:
    #  Read any specific property
    if prop.descriptor.name == "AttachmentOriginalUrl":
        print(f"{prop.descriptor.name} = {prop.get_string()}")
    if prop.descriptor.name == "AttachmentWasSavedToCloud":
        print(f"{prop.descriptor.name} = {prop.get_boolean()}")

הסרת מאפיינים מ‑MSGs וקבצים מצורפים

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

import aspose.email as ae

# create an MSG
msg = ae.mapi.MapiMessage("from@doamin.com", "to@domain.com", "subject", "body");
msg.set_body_content("<html><body><h1>This is the body content</h1></body></html>", ae.mapi.BodyContentType.HTML)

# load message and add it to created MSG as attachment
attachment = ae.mapi.MapiMessage.load(attach.msg")
msg.attachments.add("Outlook2 Test subject.msg", attachment)

# count of attachment properties before removal
print(f"Before removal = {msg.attachments[0].properties.count}")

# Delete anyone attachment property
msg.attachments[0].remove_property(923467779)

# count of attachment properties after removal
print(f"Before removal = {msg.attachments[0].properties.count}")

Python-Net: עבודה עם קבצים מצורפים להודעה

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

ניהול קבצים מצורפים עם Aspose Outlook

יצירה ושמירה של קבצי Outlook Message (MSG) מסבירים כיצד ליצור ולשמור הודעות, וכיצד ליצור קובצי MSG עם קבצים מצורפים. מאמר זה מסביר כיצד לנהל קבצים מצורפים של Microsoft Outlook באמצעות Aspose.Email. קבצים מצורפים מקובץ הודעה נגישים ונשמרים לדיסק באמצעות תכונת Attachments של מחלקת MapiMessage. תכונת Attachments היא אוסף מסוג MapiAttachmentCollection.

בדוק אם הקובץ המצורף הוא Inline או רגיל

‘Inline’ ו-‘Regular’ קבצים מצורפים מתייחסים לאופן שבו הם משולבים בהודעת דוא"ל. קבצים מצורפים Regular הם קבצים שמצורפים בדרך המסורתית. הם בדרך כלל מוצגים ברשימה בתוך תוכנת הדוא"ל וניתן להורידם על ידי הנמען ולשמור אותם באחסון מקומי. קבצים מצורפים Inline, הידועים גם כקבצים משובצים או תמונות inline, משמשים בדרך כלל לשילוב תמונות או מדיה אחרת בתוך גוף הדוא"ל. הם אינם מוצגים ברשימה נפרדת אלא מוצגים ישירות בתוך תוכן הדוא"ל, כגון בגוף ההודעה. זה מאפשר לכלול תמונות או מדיה אחרים כחלק מתוכן ההודעה. קוד הדוגמה למטה מראה כיצד לקבוע אם קובץ מצורף הוא inline או regular:

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("message.msg")

for attachment in msg.attachments:
    print(f"{attachment.display_name}:{attachment.is_inline}")

שמירת קבצים מצורפים מקובץ Outlook Message (MSG)

כדי לשמור קבצים מצורפים מקובץ MSG:

עבור על האוסף MapiAttachmentCollection וקבל את הקבצים המצורפים הפרטיים.
כדי לשמור את הקבצים המצורפים, קרא למתודה Save() של מחלקת MapiAttachment.

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

import aspose.email as ae

data_dir = "C://dataDir/"
file_name = "message.msg"

# Create an instance of MapiMessage from file
message = ae.mapi.MapiMessage.from_file(data_dir + file_name)

# Iterate through the attachments collection
for attachment in message.attachments:
    # Save the individual attachment
    attachment.save(data_dir + attachment.file_name)

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

קבצים מצורפים OLE משובצים מופיעים גם הם באוסף Attachment של מחלקת MapiMessage. דוגמת הקוד הבאה מפענחת קובץ הודעה לחיפוש קבצים מצורפים משובצים ושומרת אותם לדיסק. המתודה הסטטית FromProperties() של MapiMessage יכולה ליצור הודעה חדשה מקובץ מצורף משובץ. קטע הקוד הבא מראה כיצד לקבל קבצים מצורפים של הודעות דואר מקוננות.

import aspose.email as ae

eml = ae.mapi.MapiMessage.load("my.msg")

# Create a MapiMessage object from the individual attachment
get_attachment = ae.mapi.MapiMessage.from_properties(eml.attachments[0].object_data.properties)

# Create an object of type MailMessageInterpreter from the above message and save the embedded message to a file on disk
mail_message = get_attachment.to_mail_message(ae.mapi.MailConversionOptions())
mail_message.save("NestedMailMessageAttachments_out.eml", ae.SaveOptions.default_eml)

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

ספריית Aspose Outlook מספקת פונקציונליות להסרת קבצים מצורפים מקבצי Microsoft Outlook Message (.msg):

קרא למתודה RemoveAttachments(). היא מקבלת את נתיב קובץ ההודעה כפרמטר. היא ממומשת כמתודה סטטית ציבורית, ולכן אין צורך ליצור מופע של האובייקט.

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

import aspose.email as ae

ae.mapi.MapiMessage.remove_attachments("AttachmentsToRemove_out.msg")

ניתן גם לקרוא למתודה הסטטית DestoryAttachment() של מחלקת MapiMessage. היא פועלת מהר יותר מ‑RemoveAttachment(), מכיוון שהמתודה RemoveAttachment() מפענחת את קובץ ההודעה.

import aspose.email as ae

# Destroy attachments in the MapiMessage
ae.mapi.MapiMessage.destroy_attachments(data_dir + "AttachmentsToDestroy_out.msg")

הוספת קבצים מצורפים MSG

הודעת Outlook יכולה להכיל הודעות Microsoft Outlook אחרות כקבצים מצורפים, כקבצים רגילים או משובצים. ה־MapiAttachmentCollection מספקת גרסאות עומס של המתודה Add ליצירת הודעות Outlook עם שני סוגי הקבצים המצורפים.

נסו זאת!

הוסף או הסר קבצים מצורפים למייל אונליין עם ה‑ Aspose.Email Editor App.

הוסף קובץ מצורף רפרנס ל‑MapiMessage

"קובץ מצורף רפרנס" מתייחס בדרך כלל לקובץ מצורף המכיל הפניה או קישור למשאב חיצוני במקום הקובץ עצמו. הפניות אלה בשימוש נפוץ באימיילים HTML כדי לקשר לתמונות או משאבים חיצוניים הממוקמים בשרת מרוחק. במקום להטמיע את הקובץ המלא, קובץ מצורף רפרנס כולל URL או הפנייה לתוכן החיצוני.

Aspose.Email מספקת סט של כלי להצגת קבצים מצורפים מסוג רפרנס בצורה נכונה, כפי שמוצג בדוגמת הקוד הבאה:

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("message.msg")

# Add reference attachment
msg.attachments.add("Document.pdf",
    "https://drive.google.com/file/d/1HJ-M3F2qq1oRrTZ2GZhUdErJNy2CT3DF/",
    "https://drive.google.com/drive/my-drive",
    "GoogleDrive")

# Also, you can set additional attachment properties
msg.attachments[0].set_property(ae.mapi.KnownPropertyList.ATTACHMENT_PERMISSION_TYPE, int(ae.AttachmentPermissionType.ANYONE_CAN_EDIT))
msg.attachments[0].set_property(ae.mapi.KnownPropertyList.ATTACHMENT_ORIGINAL_PERMISSION_TYPE, 0)
msg.attachments[0].set_property(ae.mapi.KnownPropertyList.ATTACHMENT_IS_FOLDER, False)
msg.attachments[0].set_property(ae.mapi.KnownPropertyList.ATTACHMENT_PROVIDER_ENDPOINT_URL, "")
msg.attachments[0].set_property(ae.mapi.KnownPropertyList.ATTACHMENT_PREVIEW_URL, "")
msg.attachments[0].set_property(ae.mapi.KnownPropertyList.ATTACHMENT_THUMBNAIL_URL, "")
# Finally save the message
msg.save("msg_with_ref_attach.msg")

הטמעת הודעה כקובץ מצורף

קוד הדוגמה הבא מראה כיצד קבצי Outlook MSG משובצים בקובץ MSG מכילים PR_ATTACH_METHOD שערכו הוא 5.

import aspose.email as ae

# Create a new MapiMessage
message = ae.mapi.MapiMessage("from@test.com", "to@test.com", "Subj", "This is a message body")

# Load the attachment message
attach_msg = ae.mapi.MapiMessage.load("Message.msg")

# Add the attachment to the message
message.attachments.add("Weekly report.msg", attach_msg)

# Save the message with the embedded message attachment
message.save("WithEmbeddedMsg_out.msg")

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

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

import aspose.email as ae

file_name = "path/to/file.msg"

# Load the MapiMessage from file
message = ae.mapi.MapiMessage.from_file(file_name)

# Check if the first attachment is an Outlook message
if message.attachments[0].object_data.is_outlook_message:
    # Get the embedded message as MapiMessage
    embedded_message = message.attachments[0].object_data.to_mapi_message()
    # Perform further operations with the embedded message
    # ...

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

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

הכנסה במיקום ספציפי

API של Aspose.Email מספקת אפשרות להכניס קובץ מצורף MSG להודעה ה‑MSG האב באמצעות המתודה Insert של MapiAttachmentCollection – MapiAttachmentCollection Insert(int index, string name, MapiMessage msg). קטע הקוד הבא מראה כיצד להכניס במיקום ספציפי.

import aspose.email as ae
from io import BytesIO

file_name = "path/to/file.msg"

# Load the MapiMessage from file
message = ae.mapi.MapiMessage.load(file_name)

# Save the attachment to a memory stream
memory_stream = BytesIO()
message.attachments[2].save(memory_stream)

# Load the attachment from the memory stream
get_data = ae.mapi.MapiMessage.load(memory_stream)

# Insert the loaded attachment at index 1
message.attachments.insert(1, "new 11", get_data)

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

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

import aspose.email as ae
from io import BytesIO
file_name = "path/to/file.msg"

# Load the MapiMessage from file
message = ae.mapi.MapiMessage.load(file_name)

# Save the attachment to a memory stream
memory_stream = BytesIO()
message.attachments[2].save(memory_stream)

# Load the attachment from the memory stream
get_data = ae.mapi.MapiMessage.load(memory_stream)

# Replace the attachment at index 1 with the loaded attachment
message.attachments.replace(1, "new 1", get_data)

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

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

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("message.msg")

msg.attachments[0].display_name = "New display name 1"
msg.attachments[1].display_name = "New display name 2"

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

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

עבודה עם MapiCalendar

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

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

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

import aspose.email as ae
from datetime import datetime

data_dir = "path/to/data/directory"

# Create the appointment
calendar = ae.mapi.MapiCalendar(
    "LAKE ARGYLE WA 6743",
    "Appointment",
    "This is a very important meeting :)",
    datetime(2012, 4, 1),
    datetime(2012, 5, 1))

calendar.save(data_dir + "CalendarItem_out.ics", ae.calendar.AppointmentSaveFormat.ICS)

שמירת פריט לוח שנה כ‑MSG

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

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

ספריית Aspose.Email מאפשרת לשמור MapiCalendar (פריט לוח שנה) לקובץ ICS (iCalendar) עם אפשרויות ספציפיות. באמצעות המאפיינים ics_save_options.keep_original_date_time_stamp ו‑ics_save_options.product_identifier ניתן לשמור את חותמות התאריך והשעה המקוריות המשויכות לפריט הלוח ולהגדיר מזהה מוצר בקובץ ה‑ICS, לדוגמה ל‑"Foo Ltd". מזהה המוצר הוא שדה המזהה את התוכנה או השירות שייצר את קובץ ה‑ICS.

הנה דוגמת קוד המאפשרת לך להגדיר מזהה מוצר כאשר שומרים MapiCalendar ל‑ICS:

import aspose.email as ae

ics_save_options = ae.mapi.MapiCalendarIcsSaveOptions()
ics_save_options.keep_original_date_time_stamp = True
ics_save_options.product_identifier = "Foo Ltd"

mapiCalendar.save("my.ics", ics_save_options)

קבלת סך כל האירועים

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

import aspose.email as ae

reader = ae.calendar.CalendarReader(fileName)
print(f"Calendar contains {reader.count} events")
print(f"The Version of the calendar is {reader.version}")
print(f"The Method of the calendar is {reader.method}")
print(f"Is calendar contains contains multiple events? - {reader.is_multi_events}")
appointments = reader.load_as_multiple()

הוספת תזכורת תצוגה ללוח שנה

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

הוספת תזכורת קולית ללוח שנה

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

הוספת/קבלת קבצים מצורפים מקבצי לוח שנה

מודול Aspose.Email Calendar ("ae.calendar") מספק גם את הפונקציונליות להוספה ושליפה של מידע על קבצים מצורפים.

כדי להוסיף קובץ מצורף לפגישה, נוצר אובייקט "Attachment" עם נתיב הקובץ. קובץ מצורף זה מצורף לאחר מכן לרשימת הקבצים המצורפים של הפגישה. הפגישה נשמרת לנתיב קובץ ספציפי בפורמט iCalendar בעזרת שמירה מתודה והפורמט הקובץ המתאים.
כדי לקבל קבצים מצורפים מפגישה, היא נטענת תחילה מהקובץ השמור בעזרת טעינה במתודה, מספר הקבצים המצורפים ב‑"appointment2" מוצג, ובמעבר על הקבצים מודפסים שמותיהם.

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

import aspose.email as ae
import datetime as dt

# Add an attachment to an appointment
attendees = ae.MailAddressCollection()
attendees.append(ae.MailAddress("attendee@domain.com", "Recipient 1"))

appointment = ae.calendar.Appointment("Room 112", dt.datetime(2023, 5, 27), dt.date(2023, 5, 28),  ae.MailAddress("organizer@domain.com"), attendees)

attachment = ae.Attachment("D:\\Aspose\\Files\\Attachment.txt")
appointment.attachments.append(attachment)

appointment.save("D:\\Aspose\\Files\\appWithAttachments_out.ics", ae.calendar.AppointmentSaveFormat.ICS)

# Retrieve attachments from an appointment 
appointment2 = ae.calendar.Appointment.load("D:\\Aspose\\Files\\appWithAttachments_out.ics")
print(appointment2.attachments.length)
for att in appointment2.attachments:
    print(att.name)

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

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

המרת פגישת EML ל‑MSG תוך שמירת הגוף בפורמט HTML

Aspose.Email מאפשרת להמיר פגישת EML ל‑MSG ולשמור את גוף ההודעה ב‑HTML. המאפיין "forced_rtf_body_for_appointment" של MapiConversionOptions מחלקה משמשת להתמודדות עם סוג גוף הפגישה. כאשר מוגדר ל‑True, הגוף מומר לתבנית RTF כברירת מחדל. כדי לשמר את הגוף בפורמט HTML, יש להגדיר ל‑False. דוגמת הקוד הבאה מציגה כיצד לשמור על גוף HTML של הפגישה בעת המרה מ‑EML ל‑MSG:

import aspose.email as ae

eml = ae.MailMessage.load("appointment.eml")

conversionOptions = ae.mapi.MapiConversionOptions()
conversionOptions.format = ae.mapi.OutlookMessageFormat.UNICODE
# default value for ForcedRtfBodyForAppointment is true
conversionOptions.forced_rtf_body_for_appointment = False

msg = ae.mapi.MapiMessage.from_mail_message(eml, conversionOptions)

print(f"Body Type: {msg.body_type}")

msg.save("appointment.msg")

Python-Net: עבודה עם אנשי קשר של Outlook

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

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

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

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

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

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

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

import aspose.email as ae

data_dir = "path/to/data/directory"

contact = ae.mapi.MapiContact()
contact.name_info = ae.mapi.MapiContactNamePropertySet("Bertha", "A.", "Buell")
contact.professional_info = ae.mapi.MapiContactProfessionalPropertySet("Awthentikz", "Social work assistant")
contact.personal_info.personal_home_page = "B2BTies.com"
contact.physical_addresses.work_address.address = "Im Astenfeld 59 8580 EDELSCHROTT"
contact.electronic_addresses.email1 = ae.mapi.MapiContactElectronicAddress("Experwas", "SMTP", "BerthaABuell@armyspy.com")
contact.telephones = ae.mapi.MapiContactTelephonePropertySet("06605045265")
contact.personal_info.children = ["child1", "child2", "child3"]
contact.categories = ["category1", "category2", "category3"]
contact.mileage = "Some test mileage"
contact.billing = "Test billing information"
contact.other_fields.journal = True
contact.other_fields.private = True
contact.other_fields.reminder_topic = "Test topic"
contact.other_fields.user_field1 = "ContactUserField1"
contact.other_fields.user_field2 = "ContactUserField2"
contact.other_fields.user_field3 = "ContactUserField3"
contact.other_fields.user_field4 = "ContactUserField4"

# Add a photo
with open(data_dir + "Desert.jpg", "rb") as file:
    buffer = file.read()
    contact.photo = ae.mapi.MapiContactPhoto(buffer, ae.mapi.MapiContactPhotoImageFormat.Jpeg)

# Save the Contact in MSG format
contact.save(data_dir + "MapiContact_out.msg", ae.mapi.ContactSaveFormat.MSG)

# Save the Contact in VCF format
contact.save(data_dir + "MapiContact_out.vcf", ae.mapi.ContactSaveFormat.V_CARD)

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

כדי לשמור איש קשר בפורמט VCF גרסה 3, השתמש במאפיין version של VCardSaveOptions צור מופע חדש של המחלקה VCardSaveOptions, הגדר את המאפיין version של האובייקט VCardSaveOptions ל‑VCardVersion.V30. פעולה זו מגדירה את גרסת ה‑vCard ל‑3.0., קרא למתודה save של האובייקט MapiContact, העבר את שם הקובץ "contact.vcf" ואת האובייקט VCardSaveOptions כפרמטרים. פעולה זו שומרת את האיש קשר כקובץ vCard עם שם הקובץ והאפשרויות שצוינו. קטע הקוד הבא מראה כיצד לשמור איש קשר בפורמט VCF גרסה 3:

import aspose.email as ae

contact = ae.mapi.MapiContact()
contact.name_info = ae.mapi.MapiContactNamePropertySet("Bertha", "A.", "Buell")
options = ae.personalinfo.vcard.VCardSaveOptions()
options.version = ae.personalinfo.vcard.VCardVersion.V30
contact.save("contact.vcf", options)

קריאת MapiContact

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

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

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

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

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

טעינת איש קשר מ‑vCard עם קידוד ספציפי

קטע הקוד הבא מראה כיצד לטעון איש קשר מ‑vCard עם קידוד ספציפי.

שמירת פריטי איש קשר VCard עם קידוד ספציפי

בעת שמירת קובץ VCard, אפשר לציין את קידוד התווים שישמש, כדי לוודא תאימות לתווים שאינם ASCII. הגדר את המאפיין preferred_text_encoding של האובייקט VCardSaveOptions ל‑"utf-8". קטע הקוד הבא מראה כיצד ליישם פונקציה זו בפרויקט שלך:

import aspose.email as ae

contact = ae.mapi.MapiContact()
contact.name_info = ae.mapi.MapiContactNamePropertySet("Bertha", "A.", "Buell")
options = ae.personalinfo.vcard.VCardSaveOptions()
options.preferred_text_encoding = "utf-8"
contact.save("contact.vcf", options)

שמירת קבצי VCard עם שדות מורחבים

בעת שמירת קובץ VCard, ניתן גם לציין אפשרויות כולל שימוש בשדות מורחבים שהיא תכונות או מאפיינים נוספים שניתן להוסיף ל‑vCard מעבר למערך השדות הסטנדרטיים כפי שמוגדר במפרט ה‑vCard. המאפיין use_extensions של VCardSaveOptions המחלקה מאפשרת לך לבצע זאת. קטע הקוד הבא מראה כיצד לשמור קובץ VCard עם שדות מורחבים:

import aspose.email as ae

contact = ae.mapi.MapiContact()
contact.name_info = ae.mapi.MapiContactNamePropertySet("Bertha", "A.", "Buell")
options = ae.personalinfo.vcard.VCardSaveOptions()
options.use_extensions = True
contact.save("contact.vcf", options)

קריאת מספר אנשי קשר בפורמט VCard

תצטרך את המתודות הבאות כדי לקבל את רשימת כל אנשי הקשר מ‑VCard:

# Checks whether VCard source stream contains multiple contacts.
aspose.email.personalinfo.vcard.VCardContact.is_multi_contacts(stream)

# Loads list of all contacts from VCard file.
aspose.email.personalinfo.vcard.VCardContact.load_as_multiple(file_path, encoding)

# Loads list of all contacts from VCard stream.
aspose.email.personalinfo.vcard.VCardContact.load_as_multiple(stream, encoding)

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

import aspose.email as ae

contact = ae.mapi.MapiContact()
contact.name_info = ae.mapi.MapiContactNamePropertySet("Bertha", "A.", "Buell")
options = ae.personalinfo.vcard.VCardSaveOptions()
options.use_extensions = True
contact.save("contact.vcf", options)

if ae.personalinfo.vcard.VCardContact.is_multi_contacts("contact.vcf"):
    ae.personalinfo.vcard.VCardContact.load_as_multiple("contact.vcf")

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

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

Python-Net: עבודה עם פתקים של Outlook

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

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

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

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

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

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

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

קריאת MapiNote

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

Python-Net: עבודה עם משימות Outlook

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

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

Aspose.Email עבור .NET מאפשר לך ליצור משימות Outlook ולשמור אותן בפורמט MSG. המחלקה MapiTask מספקת מספר תכונות כגון Percentcomplete, Estimatedeffort, ActualEffort, History, LastUpdate ואחרים, כדי להתאים ולשייך מידע נדרש למשימת Outlook. מאמר זה מציג כיצד ליצור, לשמור ולקרוא MapiTask מהדיסק. כדי ליצור ולשמור משימה לדיסק:

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

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

קריאת MapiTask

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

קריאת משימת VToDo

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

import aspose.email as ae

data_dir = "path/to/data/directory"

task = ae.mapi.MapiTask.from_v_todo(data_dir + "VToDoTask.ics")
task.save(data_dir + "VToDo_out.msg", ae.TaskSaveFormat.Msg)

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

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

הוספת קבצים מצורפים ל-MapiTask

השתמש ב- הוסף שיטה של MapiAttachmentCollection מחלקה להוספת קובץ מצורף ל‑MapiTask. דוגמת הקוד הבאה תסייע לך בכך:

import aspose.email as ae
import datetime as dt

task = ae.mapi.MapiTask("Task with attacment", "Test body of task with attacment", dt.datetime.now(), dt.datetime.now());
task.attachments.add("Attachment.txt", str.encode("attachment data"))
task.save("AddAttachmentsToMapiTask_out", ae.mapi.TaskSaveFormat.MSG)

הוספת חזרה ל-MapiTask

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

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

דוגמת הקוד הבאה מדגימה כיצד להמיר משימה לפורמט MHT עם ציון אפשרויות נוספות עבור פורמט MHT כאשר יש צורך לעבד שדות ספציפיים של המשימה (RENDER_TASK_FIELDS) ולהכליל מידע כותרת (WRITE_HEADER). תכונת mht_format_options של MhtSaveOptions מחלקה משמשת להגדיר אפשרויות נוספות בעת שמירה בפורמט MHTML.

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("MapiTask.msg")

opt = ae.SaveOptions.default_mhtml
opt.mht_format_options = ae.MhtFormatOptions.RENDER_TASK_FIELDS | ae.MhtFormatOptions.WRITE_HEADER

msg.save("MapiTask_out.mht", opt)

Python-Net: עבודה עם אפשרות הצבעה באמצעות MapiMessage

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

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

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

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

דוגמת קוד זו מראה כיצד להשתמש במאפיין voting_buttons של FollowUpOptions מחלקה ליצירת סקר:

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("my.msg")

# Set FollowUpOptions Buttons
options = ae.mapi.FollowUpOptions()
options.voting_buttons = "Yes;No;Maybe;Exactly!"

msg.save("voting_btns.msg")

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

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

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

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

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

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

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

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

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

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

הגדרת דגל הודעה שלא נשלחה

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

import aspose.email as ae

msg = ae.mapi.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...")
msg.set_message_flags(msg.flags ^ ae.mapi.MapiMessageFlags.UNSENT)