Documentation – ביצוע עבודה עם לקוח IMAP

Python-Net: התחבר לשרתים של IMAP בפייתון באמצעות Aspose.Email

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

Aspose.Email עבור פייתון דרך .NET כולל את ImapClient מחלקה, המאפשרת למפתחים להתחבר לשרתי דוא"ל באמצעות IMAP (Internet Message Access Protocol). מחלקה זו מאפשרת ניהול דוא"ל מאובטח ויעיל בתוך יישומי פייתון, כולל אחזור, קריאה, העברה, מחיקה ועדכון הודעות דוא"ל.

באמצעות לקוח ה‑IMAP, ניתן לאמת משתמשים, לנהל תיקיות בתיבת הדואר, להתחבר דרך SSL, להגדיר פיקוחות מותאמים, ולגשת לחשבונות דוא"ל דרך שרתי פרוקסי או אימות CRAM-MD5.

חיבור IMAP בסיסי

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

צור מופע של ImapClient מחלקה.
ציין את שם המארח, הפורט, שם המשתמש והסיסמה.
ציין את אפשרות האבטחה הרצויה.

דוגמת הקוד שלהלן מציגה כיצד להתחבר לשרת IMAP תכנותית:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd")

הפעלת SSL לחיבורים ל‑IMAP

כדי להתחבר לשרת IMAP עם SSL, הגדר את security_options מאפיין ל‑SSLImplicit:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd")

# Set the security mode to implicit
client.security_options = ae.clients.SecurityOptions.SSL_EXPLICIT

התחברות דרך פרוקסי SOCKS

Aspose.Email תומכת ב‑SOCKS גרסאות 4, 4a, ו‑5 לחיבורים דרך פרוקסי. השתמש בצעדים הבאים להתחברות דרך פרוקסי SOCKS:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", "username", "password")
client.security_options = ae.clients.SecurityOptions.AUTO

proxy = ae.clients.SocksProxy("192.168.203.142", 1080, ae.clients.SocksVersion.SOCKS_V5)
client.proxy = proxy

client.select_folder("Inbox")

התחברות לשרת דרך פרוקסי HTTP

Aspose.Email גם מאפשרת חיבורים ל‑IMAP דרך פרוקסי HTTP:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", "username", "password")
client.proxy = ae.clients.HttpProxy("18.222.124.59", 8080)
client.select_folder("Inbox")

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

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

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd")
client.security_options = ae.clients.SecurityOptions.SSL_EXPLICIT
client.read_only = True

שימוש באימות CRAM-MD5

לשיפור האבטחה, הגדר את הלקוח להשתמש באימות CRAM-MD5:

דוגמת הקוד שלהלן מציגה כיצד להגדיר את הלקוח לקבלת CRAM-MD5 כאחד משיטות האימות הנתמכות להתחברות לשרת IMAP:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd")
client.allowed_authentication = ae.clients.imap.ImapKnownAuthenticationType.CRAM_MD5

הגדרת פיקוח פעולה

מנע מהלקוח להמתין ללא גבול על ידי הגדרת פיקוח (במילישניות):

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

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)
#  60 seconds
client.timeout = 60000

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

שלוט במשך הזמן שהלקוח ממתין במהלך החזקה הראשונית עם שרת הדואר.

קטע הקוד הבא מראה כיצד להגביל את זמן הפיקוח של תקופת קבלת הברכה באמצעות המאפיין greeting_timeout של ה- ImapClient מחלקה:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd")

client.greeting_timeout = 4000
client.select_folder(ae.clients.imap.ImapFolderInfo.IN_BOX)

השתמש ב‑TLS עם לקוח ה‑IMAP

Aspose.Email תומכת ב‑TLS ו‑SSL לתקשורת מאובטחת. השתמש ב- supported_encryption מאפיין להגדרת גרסאות פרוטוקול קבילות.

הערה: ניתן להגדיר רק את גרסאות הפרוטוקול הנתמכות על ידי .NET Framework. אם גרסאות מסוימות של פרוטוקול אינן נתמכות בגרסה הנוכחית שלך של .NET Framework, הן יתעלמו וידולגו. זה עלול לגרום להורדת רמת האבטחה של TLS. במקרה זה, לא ייווצרו חריגות. אנא השתמש בשיטה ‘set_supported_encryption_unsafe(value)’ אם ברצונך להגדיר את הפרוטוקולים ללא בדיקות התאמה.

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

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

client.supported_encryption = ae.clients.base.EncryptionProtocols.TLS13

במקרה שבו פרוטוקול ההצפנה שצוין אינו נתמך בגרסה הנוכחית של .NET Framework, ההבדל בהתנהגות בין השיטה set_supported_encryption_unsafe(value) למאפיין supported_encryption הוא כדלקמן:

אם נעשה שימוש במאפיין supported_encryption, לקוח הדוא"ל יוריד את פרוטוקול ההצפנה לרמה נתמכת.
אם נעשה שימוש בשיטה set_supported_encryption_unsafe(value), לקוח הדוא"ל יזרוק חריגות.

אימות פרטי שרת IMAP

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

import aspose.email as ae

with ae.clients.imap.ImapClient("your imap server", 993, "your username", "your password", ae.clients.SecurityOptions.AUTO) as client:
    client.timeout = 4000

    if client.validate_credentials():
        # Further actions

הפעלת רישום פעילות IMAP

תיעוד פעילות כולל רישום חיבורי שרת, פרטי העברה של הודעות שנשלחו והתקבלו, הודעות שגיאה במהלך עיבוד הדוא"ל, וכל פעולה אחרת שבוצעה על ידי הלקוח או השרת. כדי לעקוב אחר פעילות לקוח IMAP והאינטראקציות עם השרת, השתמש בדוגמת הקוד הבאה שמשתמש במאפיין log_file_name של ה- ImapClient מחלקה לרישום המידע לקובץ הלוג המוגדר:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

# Set the path to the log file using the LogFileName property.
client.log_file_name = "C:\\Aspose.Email.IMAP.log"
# Set the UseDateInLogFileName property if it is necessary.
client.use_date_in_log_file_name = False

Python-Net: מחיקת הודעות משרת IMAP בסביבת פייתון

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

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

כדי למחוק הודעה משרת IMAP, ספריית Aspose.Email מספקת את השיטה delete_message של ה- ImapClient מחלקה. היא מקבלת את מספר הרצף של ההודעה או מזהה ייחודי כפרמטר. קטע הקוד הבא מראה כיצד למחוק הודעת דוא"ל עם מזהה ההודעה 1 משרת IMAP:

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

ניתן למחוק הודעות מרובות מתיבת דואר באמצעות השיטה delete_messages של ה- ImapClient מחלקה המסופקת על ידי ה-API של Aspose.Email. שיטה זו מציעה מגוון אפשרויות למחיקת מספר הודעות מהשרת באמצעות מזהים ייחודיים, מספרי רצף או אלמנטים של ImapMessageInfoCollection. קטע הקוד הבא מראה כיצד למחוק מספר הודעות:

Python-Net: חיפוש וסינון הודעות IMAP בפייתון באמצעות Aspose.Email

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

כדי לאחזר את כל ההודעות מתיבת דואר Aspose.Email מספקת את השיטה ’list_messages’ של ה- ImapClient מחלקה. כדי לקבל רק הודעות העומדות בתנאים ספציפיים, ניתן להשתמש בשיטה העומס ’list_messages’ שמקבלת MailQuery כארגומנט. ה- MailQuery מחלקה מציעה מגוון מאפיינים כדי להגדיר תנאים אלו, כגון תאריך, נושא, שולח ונמען.

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

סנן והבא הודעות משרת IMAP

בנה שאילתת IMAP פשוטה

השתמש בקטע הקוד הבא כדי להתחבר לתיבת דואר IMAP ולקבל הודעות שהגיעו היום וכוללות את המילה "newsletter" בנושא.

התחבר לשרת IMAP באמצעות פורט 993 עם שם המשתמש והסיסמה.
בחר את תיקיית "Inbox" כדי לעבוד עם הודעות נכנסות.
צור מופע של בונה שאילתות Imap לבניית שאילתת חיפוש.
ציין קריטריוני חיפוש, לדוגמה שהנושא של ההודעות יכיל "Newsletter" וכי התאריך הפנימי יתאים לתאריך של היום.
צור את שאילתת החיפוש על ידי קבלתה מהבונה.
השתמש בשאילתה כדי לרשום הודעות העומדות בתנאים.
הדפס את סך כל ההודעות התואמות לתנאי החיפוש.

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

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

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

כדי לאחזר הודעות לפי תאריך משלוח, השתמש במאפיין ‘internal_date’ של MailQueryBuilder מחלקה כפי שמוצג בדוגמת הקוד למטה:

import aspose.email as ae
from datetime import datetime

builder = ae.tools.search.MailQueryBuilder()
builder.internal_date.on(datetime.now())

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

כדי לאחזר הודעות בטווח תאריכים, השתמש במאפיין ‘internal_date’ עם ציון הטווח כפי שמופיע בדוגמת הקוד למטה:

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

builder = ae.tools.search.MailQueryBuilder()
# Emails that arrived in last 7 days
builder.internal_date.before(datetime.now())
builder.internal_date.since(datetime.today() - timedelta(days=7))

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

כדי לקבל הודעות משולח ספציפי, השתמש במאפיין ‘from_address’ של ה- MailQueryBuilder מחלקה כפי שמוצג בדוגמת הקוד למטה:

import aspose.email as ae

builder = ae.tools.search.MailQueryBuilder()
builder.from_address.contains("saqib.razzaq@127.0.0.1")

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

כדי לאחזר הודעות מדומיין ספציפי, השתמש במאפיין ‘from_address’ כפי שמופיע בדוגמת הקוד למטה:

import aspose.email as ae

builder = ae.tools.search.MailQueryBuilder()
builder.from_address.contains("SpecificHost.com")

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

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

import aspose.email as ae

builder = ae.tools.search.MailQueryBuilder()
builder.to.contains("recipient")

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

בנה שאילתה על תנאים ספציפיים כגון "internal date" ו‑"subject contains". "internal date" מתייחסת לתאריך ולזמן שבהם הודעת דוא"ל התקבלה או נוספה לשרת הדוא"ל וניתן להגדיר אותה באמצעות המאפיין ‘internal_date’ של ה- בונה שאילתות Imap מחלקה. קוד הדוגמה למטה מדגים כיצד לאחזר הודעות ספציפיות מתיבת דואר נכנס על פי נושא ותאריך:

import aspose.email as ae
from datetime import datetime

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd")
client.select_folder("Inbox")

# Set conditions, Subject contains "Newsletter", Emails that arrived today
builder = ae.clients.imap.ImapQueryBuilder()
builder.subject.contains("Newsletter")
builder.internal_date.on(datetime.now())

# Build the query and Get list of messages
query = builder.get_query()
messages = client.list_messages(query)
for info in messages:
    print(f"Internal Date: {info.internal_date}")

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

צור שאילתה לחיפוש בתיבת דואר IMAP של הודעות המכילות דגלי מילות מפתח מותאמות, במיוחד "custom1" ו‑"custom2". כדי לבנות שאילתה, השתמש ב- בונה שאילתות Imap מחלקה המסננת הודעות בעת קבלתן משרת IMAP.

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

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


builder = ae.clients.imap.ImapQueryBuilder()
builder.has_flags(ae.clients.imap.ImapMessageFlags.keyword("custom1"))
builder.has_flags(ae.clients.imap.ImapMessageFlags.keyword("custom2"))

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

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

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

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

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

builder = ae.tools.search.MailQueryBuilder()
builder.internal_date.before(datetime.now())
builder.internal_date.since(datetime.today() - timedelta(days=7))
builder.from_address.contains("SpecificHost.com")

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

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


builder.either(builder.subject.contains("test"), builder.from_address.contains("noreply@host.com"))

החלת מסננים רגישים לרישיות

ה‑API גם מספק את היכולת לסנן אימיילים מתיבת הדואר לפי קריטריון רגיש לאותיות. המתודות הבאות של StringComparisonField מחלקה מספקת את היכולת לחפש אימיילים עם דגלים רגישים לאותיות גדולות/קטנות.

StringComparisonField.contains(value, ignore_case)
StringComparisonField.equals(value, ignore_case)
StringComparisonField.not_contains(value, ignore_case)
StringComparisonField.not_equals(value, ignore_case)

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


builder = ae.tools.search.MailQueryBuilder()
builder.from_address.contains("noreply@host.com", True)

בצע שאילתות חיפוש מותאמות

צור שאילתת חיפוש עבור תיבת דואר IMAP המסננת הודעות על פי קריטריון חיפוש מותאם של Gmail — במיוחד הודעות עם קבצים מצורפים.

התחל ביצירת אינסטנס של בונה שאילתות Imap, המשמש לבניית שאילתות חיפוש IMAP מורכבות. השתמש ב- custom_search שיטה להוספת מחרוזת חיפוש ייחודית ל‑Gmail לבונה השאילתות.

מחרוזת החיפוש X-GM-RAW "has:attachment" מנצלת את תכונת IMAP המורחבת של Gmail X-GM-RAW, מה שמאפשר להשתמש בתחביר חיפוש חזק של Gmail בתוך שאילתות IMAP. כאן, האופרטור has:attachment מחזיר את כל הודעות הדוא"ל המכילות קבצים מצורפים.

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


builder = ae.clients.imap.ImapQueryBuilder()
builder.custom_search("X-GM-RAW \"has:attachment\"")

mailQuery = builder.get_query()

שיטה זו מאפשרת סינון מתקדם ייחודי ל‑Gmail כדי לאחזר הודעות ממוקדות.

Python-Net: רישום פעילות ImapClient בפייתון

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

אפשר רישום פעילות

רישום פעילות כולל תיעוד חיבורי שרת, פרטי העברת הודעות שנשלחו והתקבלו, הודעות שגיאה במהלך עיבוד הדוא"ל, וכל פעולה אחרת שבוצעה על ידי הלקוח או השרת. כדי לעקוב אחרי פעילות לקוח IMAP והאינטראקציות עם השרת, השתמש בקוד הדוגמה הבא המשתמש במאפיין ’log_file_name’ של ה- ImapClient מחלקה לרישום המידע לקובץ הלוג המוגדר:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

# Set the path to the log file using the LogFileName property.
client.log_file_name = "C:\\Aspose.Email.IMAP.log"
# Set the UseDateInLogFileName property if it is necessary.
client.use_date_in_log_file_name = False

Python-Net: רשימת הרחבות שרת IMAP ב‑Python

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

Aspose.Email ImapClient מאפשר לכם לקבל את ההרחבות הנתמכות על ידי שרת הדוא"ל כגון IDLE, UNSELECT, QUOTA ועוד. זה מסייע לוודא זמינות של תכונות ספציפיות לפני ביצוע פעולות התלויות בהן. ה‑ get_capabilities() שיטה של ImapClient מחלקה מחזירה רשימה של סוגי הרחבות IMAP נתמכות כמחרוזות. קטע הקוד שלהלן מראה כיצד לקבל את רשימת הרחבות ה‑IMAP:

Python-Net: תכונות שימושיות ללקוח IMAP ב‑Python

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

אימות פרטי שרת הדואר

כדי להקים חיבור מאובטח לשרת IMAP לפני ביצוע פעולות נוספות, פרטי המשתמש נבדקים ומאומתים. השיטה ‘validate_credentials’ של ImapClient המחלקה מסייעת לבדוק אם שם המשתמש והסיסמה שסופקו נכונים. אם האימותים תקינים, הלקוח יכול לאמת בהצלחה עם שרת IMAP. דוגמת הקוד שלהלן מציגה כיצד ליישם שיטה זו בפרויקט שלך:

import aspose.email as ae

with ae.clients.imap.ImapClient("your imap server", 993, "your username", "your password", ae.clients.SecurityOptions.AUTO) as client:
    client.timeout = 4000

    if client.validate_credentials():
        # To do something

Python-Net: ניהול תיקיות IMAP ב‑Python עם Aspose.Email

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

רשימת תיקיות IMAP

קבלת מידע על תיקייה משרת IMAP היא פשוטה עם Aspose.Email. פעלו לפי הצעדים שלהלן כדי לקבל ולעבוד עם פרטי תיקייה:

השתמשו בשיטה list_folders() מ‑Aspose.Email ImapClient מחלקה. שיטה זו מחזירה מופע של אוסף מידע תיקייה Imap, המכיל פרטים על כל התיקיות.
לולאה על ה- אוסף מידע תיקייה Imap אובייקט לגישה למידע על תיקיות בודדות.
קבל תתי‑תיקיות (אופציונלי). השיטה list_folders() מוצעת במעמד יתר. ניתן להעביר שם תיקייה כפרמטר כדי לקבל אוסף של תתי‑תיקיות עבור התיקייה שצוין.

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

שנה שם ומחק תיקיות

Aspose.Email מספקת שיטות של ImapClient מחלקה לניהול תיקיות על שרת דוא"ל דרך IMAP:

שיטת delete_folder - מסירה באופן קבוע את התיקייה ואת כל ההודעות שבה.
שיטת rename_folder - משנה את שם התיקייה מבלי לשנות את התוכן שבתוכה.

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

# Delete a folder and Rename a folder
client.delete_folder("foldername")
client.rename_folder("foldername", "newfoldername")

צור והוסף הודעות לתיקיות ספציפיות

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

אתחלו את לקוח ה‑IMAP באמצעות ImapClient מחלקה להתחברות לשרת הדוא"ל שלכם. ספקו את כתובת השרת, הפורט, שם המשתמש והסיסמה.
בחרו בתיקייה היעד שבה ברצונכם להוסיף את ההודעה החדשה, כגון "Inbox", באמצעות השיטה select_folder.
צור דוא"ל חדש באמצעות MailMessage מחלקה. ציין את השולח, הנמען, הנושא ותוכן ההודעה.
הירשם לתיקייה באמצעות השיטה subscribe_folder עם שם התיקייה.
הוסיפו את ההודעה שנוצרה לאחרונה לתיקייה שנבחרה באמצעות השיטה append_message, שצוייה שם התיקייה והאובייקט של ההודעה.

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

Aspose.Email עבור .NET מאפשר להעביר הודעות מתיקיית תיבת דואר אחת לאחרת באמצעות ImapClient API. השיטה move_message משתמשת במזהה הייחודי של ההודעה ובשם תיקיית היעד להעברת הודעה לתיקייה הרצויה. קטע הקוד הבא מציג כיצד להעביר הודעות בין תיקיות:

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

ה‑API של Aspose.Email מאפשר להעתיק הודעות מתיקיית תיבת דואר אחת לאחרת בקלות. ניתן להעתיק הודעה בודדת או מספר הודעות באמצעות השיטות copy_message ו‑copy_messages. השיטה copy_messages מאפשרת להעביר מספר הודעות מתיקיית המקור לתיקיית היעד בתוך תיבת הדואר. למטה מופיע קטע קוד המדגים כיצד להעתיק הודעות בין תיקיות:

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

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

קטע הקוד הבא מציג כיצד לקבל מידע על תיבות דואר בעלות שימוש מיוחד מרכזיות (Inbox, Drafts, Junk, Sent, ו‑Trash) באמצעות המאפיינים של ImapMailBoxInfo מחלקה והדפיס את הפרטים:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

mailboxInfo = client.mailbox_info
print(mailboxInfo.inbox)
print(mailboxInfo.draft_messages)
print(mailboxInfo.junk_messages)
print(mailboxInfo.sent_messages)
print(mailboxInfo.trash)

גישה לתיקיות וקריאת הודעות בצורה רקורסיבית

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

import aspose.email as ae
import os

# Recursive method to get messages from folders and sub-folders
def list_messages_in_folder(folder_info, root_folder, client):
    # Create the folder on disk (same name as on the IMAP server)
    current_folder = os.path.join(root_folder, folder_info.name)
    os.makedirs(current_folder, exist_ok=True)

    # Read the messages from the current folder, if it is selectable
    if folder_info.selectable:
        # Send a status command to get folder info
        folder_info_status = client.get_folder_info(folder_info.name)
        print(
            f"{folder_info_status.name} folder selected. New messages: {folder_info_status.new_message_count}, "
            f"Total messages: {folder_info_status.total_message_count}"
        )

        # Select the current folder and list messages
        client.select_folder(folder_info.name)
        msg_info_coll = client.list_messages()
        print("Listing messages....")
        for msg_info in msg_info_coll:
            # Get subject and other properties of the message
            print("Subject:", msg_info.subject)
            print(
                f"Read: {msg_info.is_read}, Recent: {msg_info.recent}, Answered: {msg_info.answered}"
            )

            # Get rid of characters like ? and :, which should not be included in a file name
            # Save the message in MSG format
            file_name = (
                msg_info.subject.replace(":", " ").replace("?", " ")
                + "-"
                + str(msg_info.sequence_number)
                + ".msg"
            )
            msg = client.fetch_message(msg_info.sequence_number)
            msg.save(
                os.path.join(current_folder, file_name),
                ae.SaveOptions.default_msg_unicode,
            )
        print("============================\n")
    else:
        print(f"{folder_info.name} is not selectable.")

    try:
        # If this folder has sub-folders, call this method recursively to get messages
        folder_info_collection = client.list_folders(folder_info.name)
        for subfolder_info in folder_info_collection:
            list_messages_in_folder(subfolder_info, root_folder, client)
    except Exception:
        pass



client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

try:
    # The root folder (which will be created on disk) consists of host and username
    root_folder = f"{client.host}-{client.username}"

    # Create the root folder and list all the folders from the IMAP server
    os.makedirs(root_folder, exist_ok=True)
    folder_info_collection = client.list_folders()
    for folder_info in folder_info_collection:
        # Call the recursive method to read messages and get sub-folders
        list_messages_in_folder(folder_info, root_folder, client)
except Exception as ex:
        print("\n", ex)

print("\nDownloaded messages recursively from IMAP server.")

השתמש ב‑MultiConnection לפעולות תיקיות באצווה

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

קטע הקוד שלהלן מציג כיצד להקים חיבורים מרובים לשרת IMAP בזמן העלאת אוסף של הודעות דוא"ל באמצעות השיטה ‘append_messages’ של ImapClient מחלקה:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

client.connections_quantity = 5
client.use_multi_connection = ae.clients.MultiConnectionMode.ENABLE
client.append_messages(messages)

Python-Net: ניהול דגלי הודעות IMAP בפייתון עם Aspose.Email

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

Aspose.Email עבור פייתון דרך .NET מאפשרת לנהל דגלי הודעות IMAP כגון Read, Answered, Deleted ומילות מפתח מותאמות ישירות מתוך יישום פייתון שלך. דגלים אלה מסמנים את המצב או הסטטוס של הודעות דוא"ל בתיבת הדואר והם שימושיים לבניית זרימות עבודה מסודרות של דוא"ל.

מאמר זה מכסה כיצד:

הגדר והסר דגלי מערכת IMAP סטנדרטיים
הקצה דגלי מילות מפתח מותאמות להודעות

המפתח מתודות בשימוש:

change_message_flags()
remove_message_flags()
add_message_flags()

דגלים נתמכים:

Answered
Deleted
Draft
Flagged
IsRead
Recent
דגלי מילות מפתח מותאמות

הגדרת דגלי הודעות IMAP

השתמש ב- change_message_flags() שיטה של ImapClient מחלקה להחלת דגלים סטנדרטיים כגון IsRead או Deleted על הודעות. שיטה זו מקבלת מזהה הודעה (מספר רצף או UID) ודגל אחד או יותר.

קוד הדוגמה הבא מראה כיצד להגדיר דגלי הודעות בשרת IMAP באמצעות Aspose.Email:

הסר דגלי הודעה

ניתן להסיר דגלים מערכתיים או מותאמים באמצעות ה- remove_message_flags() שיטה של ImapClient מחלקה. זה משמש בדרך כלל להסרת סימון הודעות כנקראות או כמחקות. קוד הדוגמה למטה מדגים כיצד להסיר את דגל ‘is_read’ עם שורת קוד אחת:

# Remove the 'is_read' flag from the message
client.remove_message_flags(1, ae.clients.imap.ImapMessageFlags.is_read)

הוספת דגלי מילות מפתח מותאמות להודעות IMAP

Aspose.Email תומכת גם בהקצאת דגלי מילות מפתח מותאמות באמצעות ה- add_message_flags() שיטה של ImapClient מחלקה. דגלים מותאמים אלה יכולים להיות מועילים לסיווג או כללי עיבוד.

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

# Create a new message
message = ae.MailMessage("user@domain1.com", "user@domain2.com", "subject", "message")

# Append the message to the Inbox
uid = client.append_message(ae.clients.imap.ImapFolderInfo.IN_BOX, message)

# Add custom keyword flags to the message
client.add_message_flags(uid, ae.clients.imap.ImapMessageFlags.keyword("custom1") | ae.clients.imap.ImapMessageFlags.keyword("custom1_0"))

# Verify the presence of the custom keyword
client.select_folder(ae.clients.imap.ImapFolderInfo.IN_BOX)
messageInfos = client.ListMessages()

for inf in messageInfos:
  flags = inf.flags.split()
  if inf.contains_keyword("custom1"):
        print("Keyword found")

Python-Net: אחזור ורשימת הודעות דוא"ל משרת IMAP בפייתון

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

רשימת הודעות מתיבת הדואר

השיטה ’list_messages’ של ה- ImapClient מחלקה המאחזרת רשימה של כל ההודעות מהתיקייה שנבחרה כרגע (במקרה זה, "Inbox"). רשימה זו מכילה אובייקטים של מטה‑דאטה של הודעות, שבדרך כלל כוללים מידע כגון מזהי הודעה, מספרי רצף, UID, ולעיתים נתוני סיכום כגון נושאים או מידע על השולח.

קטע הקוד הבא מדגים כיצד לאחזר את המטה‑דאטה של ההודעות מהתיקייה "Inbox", ולהדפיס את המספר הכולל של ההודעות שהיא מכילה:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

client.select_folder("Inbox")

messages = client.list_messages()
print(f"Total Messages: {len(messages)}")

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

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

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

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

רשימת מזהי הודעות MIME

ה מידע הודעה Imap מחלקה מציעה דרך נוחה לגשת ל‑MIME MessageId לצורך זיהוי הודעות ללא צורך בחילוץ כל תוכן ההודעה. למטה נמצא קטע קוד המדגים כיצד לרשום MIME MessageId:

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

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

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

client.select_folder("Inbox")
client.connections_quantity = 5
client.use_multi_connection = ae.clients.MultiConnectionMode.ENABLE

message_info_col = client.list_messages(True)

שימו לב שהשימוש במצב זה אינו בהכרח מוביל לשיפור ביצועים.

אחזור הודעות לפי מספר רצף או מזהה ייחודי

ממשק ה‑API של Aspose.Email מאפשר לך ליצור שתי רשימות של הודעות, אחת המכילה את מספרי הרצף והשנייה מכילה את המזהים הייחודיים של כל ההודעות בתיבת הדואר. כדי לאחזר הודעות משרת IMAP לפי המזהים שלהם, השתמש בשיטה fetch_messages של ה- ImapClient מחלקה. קטע הקוד שלהלן מדגים כיצד לרשום הודעות לפי מזהים:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

# List messages
message_info_col = client.list_messages()
print("ListMessages Count:", message_info_col.count)

# Get sequence numbers and unique IDs
sequence_number_ar = [mi.sequence_number for mi in message_info_col]
unique_id_ar = [mi.unique_id for mi in message_info_col]

# Fetch messages by sequence number
fetched_messages_by_snum = client.fetch_messages(sequence_number_ar)
print("FetchMessages-sequenceNumberAr Count:", len(fetched_messages_by_snum))

# Fetch messages by UID
fetched_messages_by_uid = client.fetch_messages(unique_id_ar)
print("FetchMessages-uniqueIdAr Count:", len(fetched_messages_by_uid))

קבלת הודעות בסדר יורד

המשימה מתבצעת על‑ידי הגדרת הגדרות עימוד לאחזור הודעות. למטרה זו, השתמש במאפיין ascending_sorting של ה- PageSettings מחלקה שהיא חלק ממודול לקוח IMAP. הגדר את המאפיין ascending_sorting על ה- PageSettings אובייקט ל‑False. זה מצביע שהודעות אמורות להיות ממויניות בסדר יורד כברירת מחדל בעת האחזור. קטע הקוד שלהלן מראה כיצד לאחזר הודעות בסדר יורד:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

page_settings = ae.clients.imap.PageSettings
page_settings.ascending_sorting = False
page_info = client.list_messages_by_page(5, page_settings)
messages = page_info.items

for message in messages:
    print(message.subject)

אחזור הודעות מהשרת ושמירתן על דיסק

ה ImapClient מחלקה שיכולה לאחזר הודעות משרת IMAP ולשמור אותן בפורמט EML על דיסק מקומי. השלבים הבאים נדרשים כדי לשמור את ההודעות על הדיסק:

השתמש ב- ImapClient מחלקה עם הפרמטרים הדרושים (host, port, username, password) להתחברות לשרת IMAP.
בחר את התיקייה הרצויה על‑ידי קריאת השיטה select_folder (למשל, "Inbox")
אחזר הודעות על‑ידי איטרציה עליהן באמצעות השיטה list_messages.
כדי לשמור הודעות, עבור כל הודעה, השתמש בשיטה save_message וציין את הספרייה, והוסף את המזהה הייחודי לשם הקובץ לשם ייחודיות.

קטע הקוד הבא מראה לך כיצד לאחזר הודעות דוא"ל מהשרת ולשמור אותן:

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

כדי לשמור דוא"ל בפורמט MSG, קרא לשיטה fetch_message של ה- ImapClient מחלקה. היא מחזירה את ההודעה במופע של ה- MailMessage מחלקה. לאחר מכן ניתן לקרוא לשיטה MailMessage.save() כדי לשמור את ההודעה בפורמט MSG. קטע הקוד שלהלן מראה כיצד לשמור הודעות בפורמט MSG.

אחזור פרמטרים נוספים של הודעה (מידע סיכום)

קטע הקוד שלהלן מדגים כיצד לתקשר עם שרת דוא"ל באמצעות Aspose.Email ImapClient לשליחת וניהול הודעות דוא"ל. הקוד משתמש ב‑UID של ההודעה כדי לאחזר מידע סיכום עם פרמטרים נוספים ("X-GM-MSGID", "X-GM-THRID"). מידע דומה מאוחזר באמצעות מספר הרצף.

קבל כותרת List-Unsubscribe

כותרת "ListUnsubscribe" מופיעה לרוב בכותרות של הודעות דוא"ל שנשלחות על ידי רשימות תפוצה או מערכות דוא"ל אוטומטיות. היא מספקת קישור או כתובת דוא"ל שהנמענים יכולים להשתמש בהם כדי לבטל מנוי מרשימת ההתפוצה או מדוא"לים אוטומטיים. Aspose.Email מספקת את המאפיין ’list_unsubscribe’ של מידע הודעה Imap מחלקה לקבלת כותרת זו. קטע הקוד שלמטה מדגים את השימוש במאפיין וניתן להשתמש בו כחלק ממערכת לאוטומציה של תהליך הביטול מדוא"לים לא רצויים:

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

message_info_col = client.list_messages()

# Iterate through each message
for imap_message_info in message_info_col:
    print("ListUnsubscribe Header:", imap_message_info.list_unsubscribe)

קבל מידע זיהוי הודעה

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

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

Aspose.Email.ImapMessageInfo מחלקה - מייצגת מידע זיהוי על הודעה בתיבת דואר.
Aspose.Email.ImapMessageInfo.sequence_number מאפיין - מספר הרצף של הודעה.
Aspose.Email.ImapMessageInfo.unique_id מאפיין - המזהה הייחודי של הודעה.

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

import aspose.email as ae

client = ae.clients.imap.ImapClient("imap.domain.com", 993, "user@domain.com", "pwd", ae.clients.SecurityOptions.SSL_IMPLICIT)

msg_infos = client.list_messages("INBOX")

for msg_info in msg_infos:
    # fetch by sequence number
    msg = client.fetch_message(msg_info.sequence_number)

    # fetch by unique id
    msg = client.fetch_message(msg_info.unique_id)

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

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

ImapAttachmentInfo מחלקה - מייצגת מידע על קובץ מצורף (גודל, שם, סוג מדיה).
ImapAttachmentInfoCollection מחלקה - מייצגת את האוסף של ImapAttachmentInfo.
מתודת list_attachments(sequence_number) של ה- ImapClient מחלקה - מקבלת איטרציה או אוסף של מידע על קבצים מצורפים להודעה.

דוגמת הקוד שלהלן מציגה כיצד לרשום קבצי מצורף עבור כל הודעת דוא"ל באמצעות Aspose.Email ImapClient:

# List messages
message_info_col = client.list_messages()

# Iterate through each message
for message_info in message_info_col:
    print(f"Attachments for message with sequence number {message_info.sequence_number}:")

    # List attachments for the current message
    attachment_info_col = client.list_attachments(message_info.sequence_number)

    # Iterate through each attachment
    for attachment_info in attachment_info_col:
        print(f"Attachment: {attachment_info.name} (size: {attachment_info.size})")

Python-Net: הפעל הרחבות IMAP באמצעות API של Python

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

תמיכה בהרחבות IMAP

ה‑API של Aspose.Email תומך במגוון הרחבות של פרוטוקול IMAP. הרחבות אלו מאפשרות פעולות מתקדמות כגון זיהוי יישומי לקוח וקבלת מטא‑נתוני תיבת דואר מפורטים. למרות שלא כל שרתי הדוא"ל תומכים בתכונות אלו, רבים משירותים פופולריים כמו Gmail כן תומכים.

מאמר זה מציג כיצד להשתמש בהרחבות IMAP הבאות עם ImapClient מחלקה ב‑Aspose.Email:

פקודת IMAP ID
פקודת IMAP LIST-EXTENDED

שימוש בפקודת IMAP ID

פקודה זו מספקת משוב האם השרת תומך בהרחבת IMAP ID ומחזירה פרטי זיהוי מובנים מהשרת. זה יכול להיות שימושי ללוגינג, אבחון והתאמה של התנהגות השרת.

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

import aspose.email as ae

with ae.clients.imap.ImapClient("imap.gmail.com", 993, "username", "password") as client:

    # Set security options
    client.security_options = ae.clients.SecurityOptions.AUTO

    # Check if ID command is supported
    print(client.id_supported)

    # Send identification info to the server
    server_identification_info1 = client.introduce_client()
    server_identification_info2 = client.introduce_client(ae.clients.imap.ImapIdentificationInfo.default_value)

    # Display server response
    print(server_identification_info1)
    print(server_identification_info2)
    print(server_identification_info1.name)
    print(server_identification_info1.vendor)
    print(server_identification_info1.support_url)
    print(server_identification_info1.version)

שימוש בפקודת IMAP LIST-EXTENDED

פקודת IMAP LIST-EXTENDED (הוגדרה ב‑RFC 5258) מאפשרת ללקוחות לקבל היררכיות תיקיות מפורטות ונתוני מטא, כגון האם לתיקיות יש תיקיות ילד. זה מועיל במיוחד ללקוחות המנהלים מבני תיבת דואר מורכבים.

דוגמת הקוד שלהלן מציגה כיצד למנות תיקיות ב‑Gmail באמצעות פקודת LIST המורחבת ולוודא אילו תיקיות מכילות תתי‑תיקיות:

import aspose.email as ae

with ae.clients.imap.ImapClient("imap.gmail.com", 993, "username", "password") as client:
    folder_info_col = client.list_folders("*")
    print("Extended List Supported:", client.extended_list_supported)

    for folder_info in folder_info_col:
        folder_name = folder_info.name

        if folder_name == "[Gmail]/All Mail":
            print("Has Children:", folder_info.has_children)
        elif folder_name == "[Gmail]/Bin":
            print("Bin has children?", folder_info.has_children)
        elif folder_name == "[Gmail]/Drafts":
            print("Drafts has children?", folder_info.has_children)
        elif folder_name == "[Gmail]/Important":
            print("Important has Children?", folder_info.has_children)
        elif folder_name == "[Gmail]/Sent Mail":
            print("Sent Mail has Children?", folder_info.has_children)
        elif folder_name == "[Gmail]/Spam":
            print("Spam has Children?", folder_info.has_children)
        elif folder_name == "[Gmail]/Starred":
            print("Starred has Children?", folder_info.has_children)

Python-Net: גיבוי ושחזור הודעות IMAP ב‑Python

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

Aspose.Email עבור Python מציעה שיטות של ImapClient מחלקה לניהול הודעות דוא"ל דרך פרוטוקול IMAP:

שיטת ‘backup’
שיטת ‘restore’

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

גיבוי הודעות IMAP

כדי ליצור גיבוי של הודעות דוא"ל משרת IMAP, השתמש ב‑ backup שיטה של ImapClient מחלקה. דוגמת הקוד שלהלן מציגה כיצד לגבות את תיקיית Inbox לקובץ .pst:

import aspose.email as ae

# Create an instance of the ImapClient class
imap_client = ae.clients.imap.ImapClient()

# Specify host, username, password, and set port for your client
imap_client.host = "imap.gmail.com"
imap_client.username = username
imap_client.password = password
imap_client.port = 993
imap_client.security_options = ae.clients.SecurityOptions.AUTO

# Get mailbox info
mailbox_info = imap_client.mailbox_info

# Get folder info for the Inbox folder
inbox_info = imap_client.get_folder_info(mailbox_info.inbox.name)

# Create an ImapFolderInfoCollection and add the Inbox folder info
infos = ae.clients.imap.ImapFolderInfoCollection()
infos.add(inbox_info)

# Specify the path to the directory
data_dir = "path/to/your/data/directory"

# Perform the backup operation
settings = ae.clients.imap.BackupSettings
settings.execute_recursively = True
imap_client.backup(infos, data_dir + "\\ImapBackup.pst", settings)

שחזור הודעות IMAP

כדי לשחזר הודעות מקובץ .pst בחזרה לשרת IMAP, השתמש ב‑ restore שיטה של ImapClient מחלקה:

import aspose.email as ae

# Create an instance of the ImapClient class
imap_client = ae.clients.imap.ImapClient()

# Specify host, username, password, and set port for your client
imap_client.host = "imap.gmail.com"
imap_client.username = username
imap_client.password = password
imap_client.port = 993
imap_client.security_options = ae.clients.SecurityOptions.Auto

# Create RestoreSettings with Recursive set to true
settings = ae.clients.imap.RestoreSettings()
settings.recursive = True

# Specify the path to the directory
data_dir = "path/to/your/data/directory"

# Load the PST file
pst = ae.storage.pst.PersonalStorage.from_file(data_dir + "\\ImapBackup.pst")

# Perform the restore operation
imap_client.restore(pst, settings)

שפר ביצועים עם מצב Multi-Connection

למשימות המשלבות כמות גדולה של נתונים או מספר רב של הודעות דוא"ל, Aspose.Email מציעה את המאפיין ‘use_multi_connection’ של ImapClient מחלקה למיטוב ביצועי הפעולות על‑ידי מתן אפשרות ללקוח לפתוח חיבורים מרובים לשרת הדוא"ל במקביל. כאשר MultiConnectionMode מופעל, לקוח ה‑IMAP יכול לבצע משימות שונות (כגון משיכת הודעות, סינכרון תיקיות וגיבוי נתונים) במקביל על פני חיבורים שונים. זה יכול להביא להפחתה משמעותית בזמן הכולל הדרוש להשלמת הפעולות. קטעי הקוד שלהלן מציגים כיצד להפעיל MultiConnection מצב לפעולות גיבוי ושחזור.

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

גיבוי הודעות עם MultiConnection מופעל

קטע הקוד הבא מציג כיצד לבצע פעולת גיבוי עם מצב MultiConnection מופעל:

import aspose.email as ae

# Create an instance of the ImapClient class
imap_client = ae.clients.imap.ImapClient()

# Specify host, username, password, and set port for your client
imap_client.host = "imap.gmail.com"
imap_client.username = username
imap_client.password = password
imap_client.port = 993
imap_client.security_options = ae.clients.SecurityOptions.Auto

# Enable MultiConnectionMode
imap_client.use_multi_connection = ae.clients.MultiConnectionMode.ENABLE

# Get mailbox info
mailbox_info = imap_client.mailbox_info

# Get folder info for the Inbox folder
inbox_info = imap_client.get_folder_info(mailbox_info.inbox.name)

# Create an ImapFolderInfoCollection and add the Inbox folder info
infos = ae.clients.imap.ImapFolderInfoCollection()
infos.add(inbox_info)

# Specify the path to the directory
data_dir = "path/to/your/data/directory"

# Perform the backup operation
settings = ae.clients.imap.BackupSettings
settings.execute_recursively = True
imap_client.backup(infos, data_dir + "\\ImapBackup.pst", settings)

שחזור הודעות עם MultiConnection

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

import aspose.email as ae

# Create an instance of the ImapClient class
imap_client = ae.clients.imap.ImapClient()

# Specify host, username, password, and set port for your client
imap_client.host = "imap.gmail.com"
imap_client.username = username
imap_client.password = password
imap_client.port = 993
imap_client.security_options = ae.clients.SecurityOptions.Auto

# Enable MultiConnectionMode
imap_client.use_multi_connection = ae.clients.MultiConnectionMode.ENABLE

# Create RestoreSettings with Recursive set to true
settings = ae.clients.imap.RestoreSettings()
settings.recursive = True

# Specify the path to the directory
data_dir = "path/to/your/data/directory"

# Load the PST file
pst = ae.storage.pst.PersonalStorage.from_file(data_dir + "\\Outlook.pst")

# Perform the restore operation
imap_client.restore(pst, settings)