עבודה עם הודעות בקובץ PST

הוספת הודעות לקובצי PST של Outlook

הוספת הודעה בודדת לקובץ PST

צור קובץ PST חדש והוסף תיקיות משנה מראה כיצד ליצור קובץ PST ולהוסיף לו תת‑תיקייה. עם Aspose.Email ניתן גם להוסיף הודעות לתתי‑תיקיות של קובץ PST שיצרת או טעית. דוגמת הקוד שלהלן מציגה כיצד ליצור קובץ PST חדש, להוסיף תיקיית "Inbox", ולאחר מכן להוסיף הודעה לאותה תיקייה. ה‑ PersonalStorage ו‑ FolderInfo מחלקות משמשות לביצוע המשימה.

השתמש ב- PersonalStorage.create מתודה לאתחול קובץ PST חדש תוך ציון נתיב הקובץ וגרסת פורמט הקובץ כ‑Unicode.
צור תיקייה חדשה בשם "Inbox" בתיקיית השורש של קובץ PST.
הוסף הודעה לתיקיית "Inbox" שנוצרה זה עתה באמצעות ה‑ add_message שיטה.
טען את ההודעה באמצעות MapiMessage.load.

pst = PersonalStorage.create(dataDir + "AddMessagesToPst_out.pst", FileFormatVersion.UNICODE)

# Add new folder "Inbox"
inboxFolder = pst.root_folder.add_sub_folder("Inbox");

# Add message to Inbox Folder
inboxFolder.add_message(MapiMessage.load(dataDir + "MapiMsgWithPoll.msg"))

pst.dispose()

הוספת הודעות מרובות לקבצי PST לביצועים טובים יותר

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

טעינה והוספת הודעות מהדיסק

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

הגדר פונקציה על‑ידי יצירת add_messages_in_bulk_mode עם פרמטרים עבור שם קובץ ה‑PST והתיקייה עם ההודעות.
פתח את קובץ PST המוגדר באמצעות PersonalStorage.from_file().
שחזר את תתי‑התיקייה "myInbox" מתיקיית השורש של PST.
הוסף הודעות מהתיקייה המוגדרת בכמות גדולה באמצעות folder.add_messages().
קרא add_messages_in_bulk_mode() עם קובץ PST ושם התיקייה כארגומנטים.

from aspose.email.storage.pst import PersonalStorage, StandardIpmFolder, FileFormatVersion

def add_messages_in_bulk_mode(file_name, msg_folder_name):
    with PersonalStorage.from_file(file_name) as personal_storage:
        folder = personal_storage.root_folder.get_sub_folder("myInbox")
        folder.add_messages(message_collection(msg_folder_name))

# Add multiple messages from the specified folder to the PST file for improved performance
add_messages_in_bulk_mode("file.pst", "folder_with_messages")

השתמש `MapiMessageEnumerator` לפעולות בכמות גדולה

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

MapiMessageEnumerator לקריאת הודעות מתיקייה,
ו MapiMessageCollection לניהולם במהלך פעולות אצווה.

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

import os
from aspose.email.mapi import MapiMessage

# Define a class to enumerate through MAPI message files in a directory
class MapiMessageEnumerator:
    def __init__(self, path):
        self.files = os.listdir(path)
        self.position = -1

    def __next__(self):
        self.position += 1
        if self.position < len(self.files):
            return MapiMessage.from_file(os.path.join(self.path, self.files[self.position]))
        else:
            raise StopIteration

    def __iter__(self):
        return self

# Define a collection class for managing MAPI messages
class MapiMessageCollection:
    def __init__(self, path):
        self.path = path

    def __iter__(self):
        return MapiMessageEnumerator(self.path)


# Iterate through MAPI messages in a specific directory
msg_folder_name = "\\Files\\msg"

# Initialize a collection with the directory containing message files
message_collection = MapiMessageCollection(msg_folder_name)
for message in message_collection:
    # Process each MAPI message object as needed
    pass

הוספת הודעות מ‑PST אחר

כדי לייבא הודעות מקובץ PST אחד לשני, Aspose.Email מספקת את ה‑ FolderInfo.enumerate_mapi_messages() מתודה. דוגמת הקוד הבאה מראה כיצד להעתיק הודעות מתיקיית "Inbox" בקובץ PST אחד לקובץ PST אחר:

שחזור הודעות מקבצי Outlook PST

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

שחזור מידע בסיסי של הודעה

דוגמת הקוד שלהלן מציגה כיצד לחלץ ולהציג מידע מרכזי מתוך הודעות MAPI השמורות בקובץ PST באמצעות ספריית Aspose.Email. היא מאתחלת a PersonalStorage אובייקט מקובץ "Outlook.pst" שמקבל את תוכן תיקיית השורש, ועובר על כל הודעה. הסקריפט מדפיס פרטים כגון הנושא, פרטי השולח, כתובות הנמענים, זמן ההגעה, וגוף ההודעה, ומספק תצוגה מקיפה של כל אימייל בקובץ PST שצוין.

from aspose.email.storage.pst import *
from aspose.email.mapi import MapiMessage

pst = PersonalStorage.from_file("Outlook.pst")

folderInfo = pst.root_folder

messageInfoCollection = folderInfo.get_contents()

for messageInfo in messageInfoCollection:
   mapi = pst.extract_message(messageInfo)

   print("Subject: " + mapi.subject)
   print("Sender name: " + mapi.sender_name)
   print("Sender email address: " + mapi.sender_email_address)
   print("To: ", mapi.display_to)
   print("Cc: ", mapi.display_cc)
   print("Bcc: ", mapi.display_bcc)
   print("Delivery time: ", str(mapi.delivery_time))
   print("Body: " + mapi.body)

קריאה רקורסיבית של תיקיות מקוננות

קובץ PST של Outlook עשוי להכיל תיקיות מקוננות. כדי לקבל מידע על הודעות מתיקיות אלו וגם מתיקיות רמה עליונה, השתמשו במתודה רקורסיבית לקריאת כל התיקיות. קטע הקוד הבא מראה כיצד לקרוא קובץ PST של Outlook ולהציג את תוכן התיקיות וההודעות בצורה רקורסיבית:

שחזר את המספר הכולל של פריטים בתיקיית PST

כדי לאחזר את סך כל הפריטים (כגון אימיילים, פגישות, משימות, אנשי קשר וכו’) הנמצאים באחסון ההודעות, השתמשו במתודה get_total_items_count() של ה‑ MessageStore מחלקה. היא מספקת דרך נוחה לאיסוף מהיר של מידע על גודל ונפח הנתונים באחסון. קטע קוד הבא מציג כיצד לקבל את סך כל הפריטים בקובץ PST:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

count = pst.store.get_total_items_count()

חלץ מספר ספציפי של הודעות

כדי לחלץ מספר מסוים של הודעות מקובץ PST, השתמשו במתודה get_contents(start_index, count) של ה‑ FolderInfo מחלקה. היא מקבלת שני פרמטרים:

start_index - מספר ההודעה ההתחלתית, למשל העשירית;
count - סך כל ההודעות שיש לאחזר.

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

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

folder = pst.root_folder.get_sub_folder("Inbox")

# Extracts messages starting from 10th index top and extract total 100 messages
messages = folder.get_contents(10, 100)

עבודה עם קבצים מצורפים בקבצי PST

חילוץ קבצים מצורפים ללא חילוץ כל ההודעה

Aspose.Email for Python מאפשרת לחלץ קבצים מצורפים מהודעות PST دون הצורך לחלץ קודם את כל ההודעה. ניתן לבצע זאת באמצעות ה‑ extract_attachments שיטה של PersonalStorage מחלקה. קטע הקוד הבא מציג כיצד לחלץ קבצים מצורפים תוך דילוג על קבצי .msg:

from aspose.email.storage.pst import PersonalStorage

# Open the PST file 
with PersonalStorage.from_file(data_dir + "my.pst") as personal_storage:
    # Get the "Inbox" subfolder from the root folder in the personal storage
    folder = personal_storage.root_folder.get_sub_folder("Inbox")

    # Iterate over each message entry ID in the Inbox folder
    for message_info in folder.enumerate_messages_entry_id():
        # Extract attachments for the current message
        attachments = personal_storage.extract_attachments(message_info)

        # Check if the message has any attachments
        if attachments.count > 0:
            # Iterate over each attachment in the list
            for attachment in attachments:
                # Ignore attachments that are message files (.msg)
                if attachment.long_file_name and attachment.long_file_name.endswith(".msg"):
                    continue
                # Save the attachment with its original file name
                attachment.save(data_dir + attachment.long_file_name)

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

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

קטוד קוד הבא מדגים כיצד להוסיף מסמך לתיקיית PST באמצעות Aspose.Email:

from aspose.email.storage.pst import PersonalStorage, FileFormatVersion

# Create a new PST file
personal_storage = PersonalStorage.create(data_dir + "AddFilesToPst_out.pst", FileFormatVersion.UNICODE)

# Add a new folder to store files
folder = personal_storage.root_folder.add_sub_folder("Files")

# Add a file to the PST folder
folder.add_file(data_dir + "FileToBeAddedToPST.txt", "")

חיפוש וסינון הודעות בקבצי PST

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

חיפוש הודעות ותיקיות ב‑Outlook

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

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

from aspose.email.mapi import MapiMessageFlags
from aspose.email.storage.pst import PersonalStorage, PersonalStorageQueryBuilder, MapiImportance

with PersonalStorage.from_file(data_dir + "my.pst") as personal_storage:
    folder = personal_storage.root_folder.get_sub_folder("Inbox")
    builder = PersonalStorageQueryBuilder()

    # High importance messages
    builder.importance.equals(2)
    messages = folder.get_contents(builder.get_query())
    print("Messages with High Imp:", messages.count)

    builder = PersonalStorageQueryBuilder()
    builder.message_class.equals("IPM.Note")
    messages = folder.get_contents(builder.get_query())
    print("Messages with IPM.Note:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Messages with attachments AND high importance
    builder.importance.equals(2)
    builder.has_flags(MapiMessageFlags.HASATTACH)
    messages = folder.get_contents(builder.get_query())
    print("Messages with atts:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Messages with size > 15 KB
    builder.message_size.greater(15000)
    messages = folder.get_contents(builder.get_query())
    print("Messages size > 15 KB:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Unread messages
    builder.has_no_flags(MapiMessageFlags.READ)
    messages = folder.get_contents(builder.get_query())
    print("Unread:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Unread messages with attachments
    builder.has_no_flags(MapiMessageFlags.READ)
    builder.has_flags(MapiMessageFlags.HASATTACH)
    messages = folder.get_contents(builder.get_query())
    print("Unread msgs with atts:", messages.count)

    # Folder with name 'SubInbox'
    builder = PersonalStorageQueryBuilder()
    builder.folder_name.equals("SubInbox")
    folders = folder.get_sub_folders(builder.get_query())
    print("Folder having subfolder:", folders.count)

    builder = PersonalStorageQueryBuilder()
    # Folders with subfolders
    builder.has_subfolders()
    folders = folder.get_sub_folders(builder.get_query())
    print("Folders with subfolders:", folders.count)

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

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

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

אחזר הודעות או פריטים ספציפיים מקובץ אחסון אישי (PST) או מחסן הודעות באמצעות יישום ה‑ either(query1, query2) שיטה של PersonalStorageQueryBuilder מחלקה. היא מקבלת שני פרמטרים המאפשרים לשלב שני שאילתות שונות, query1 ו‑query2, ולמצוא נושא הודעה התואם לאחת משתי המילים המוגדרות. ראו את דוגמת הקוד למטה:

import aspose.email as ae

builder1 = ae.storage.pst.PersonalStorageQueryBuilder()
builder1.subject.contains("Review") # 'Review' is key word for the search

builder2 = ae.storage.pst.PersonalStorageQueryBuilder()
builder2.subject.contains("Error") # 'Error' is also key word for the search

builder = ae.storage.pst.PersonalStorageQueryBuilder()
# message subjects must contain 'Review' or 'Error' words
builder.either(builder1.get_query(), builder2.get_query())


pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

folder = pst.root_folder.get_sub_folder("Inbox")
messages = folder.get_contents(builder.get_query())

for message in messages:
    print(f"Message: {message.subject}")

סינון אימיילים ב‑PST לפי קריטריונים ספציפיים

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

import aspose.email as ae

# Load the PST file and access a folder
pst = ae.PersonalStorage.from_file("sample.pst")
inbox = pst.root_folder.get_sub_folder("Inbox")

# Create a MailQuery to filter messages by subject
query_builder = ae.MailQueryBuilder()
query_builder.subject.contains("Invoice")

query = query_builder.get_query()

# Enumerate filtered messages
for info in inbox.enumerate_mapi_messages(query):
    print("Subject:", info.subject)

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

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

import aspose.email as ae

# Load the PST and target folder
pst = ae.PersonalStorage.from_file("sample.pst")
inbox = pst.root_folder.get_sub_folder("Inbox")

# Retrieve only email messages (not calendar items, contacts, etc.)
for info in inbox.enumerate_mapi_messages(ae.MessageKind.MAPI_MESSAGE):
    print("Email Message:", info.subject)

דפדוף של אחזור הודעות לקבצי PST גדולים

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

import aspose.email as ae

# Load the PST and access the target folder
pst = ae.PersonalStorage.from_file("sample.pst")
inbox = pst.root_folder.get_sub_folder("Inbox")

# Retrieve messages from index 0 to 9
for info in inbox.enumerate_mapi_messages(0, 10):
    print("Paged Message:", info.subject)

עדכן וארגן תוכן PST של Outlook

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

Aspose.Email מאפשר להעביר פריטים מתיקייה מקור לתיקייה אחרת באותו קובץ אחסון אישי (PST). זה כולל:

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

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

עדכון תכונות הודעה

לעיתים נדרש לשנות תכונות מסוימות של הודעות כגון שינוי הנושא, סימון חשיבות הודעה ועוד. עדכון תכונות אלו בתוך קובץ PST ניתן לבצע בעזרת FolderInfo.change_messages שיטה שמסופקת על ידי Aspose.Email for Python. מאמר זה מציג את תהליך עדכון תכונות הודעה באופן גורף, המאפשר התאמות אוטומטיות על פני הודעות מרובות בקובץ PST. למטה מופיעה קטע קוד הממחיש כיצד לבצע עדכונים גורפים על מגוון תכונות הודעה.

from aspose.email.storage.pst import PersonalStorage, PersonalStorageQueryBuilder
from aspose.email.mapi import MapiPropertyTag, MapiProperty, MapiPropertyCollection

pst_file_path = data_dir + "ya4demia04vb.pst"

# Load the Outlook PST file
with PersonalStorage.from_file(pst_file_path) as personal_storage:
    # Get the required subfolder
    inbox = personal_storage.root_folder.get_sub_folder("Inbox")

    # Find messages having From = "someuser@domain.com"
    query_builder = PersonalStorageQueryBuilder()
    query_builder.from_address.contains("someuser@domain.com")

    # Get contents from query
    messages = inbox.get_contents(query_builder.get_query())

    # Save (MessageInfo, EntryIdString) in a list
    change_list = [message_info.entry_id_string for message_info in messages]

    # Compose the new properties
    updated_properties = MapiPropertyCollection()
    updated_properties.add(
        MapiPropertyTag.SUBJECT_W,
        MapiProperty(MapiPropertyTag.SUBJECT_W, "New Subject".encode("utf-16le"))
    )
    updated_properties.add(
        MapiPropertyTag.IMPORTANCE,
        MapiProperty(MapiPropertyTag.IMPORTANCE, bytearray([0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
    )

    # Update messages having From = "someuser@domain.com" with new properties
    inbox.change_messages(change_list, updated_properties)

שינוי תכונות MAPI מותאמות

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

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - משנה את כל ההודעות בתיקייה
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - משנה תכונות הודעה

from uuid import UUID
from aspose.email.storage.pst import PersonalStorage
from aspose.email.mapi import MapiNamedProperty, MapiPropertyCollection
from aspose.email.mapi import MapiPropertyType, MapiProperty, MapiPropertyTag

def generate_named_property_tag(index, data_type):
    return (((0x8000 | index) << 16) | data_type) & 0x00000000FFFFFFFF

def run():
    # Load the Outlook file
    pst_file_path = data_dir + "my.pst"

    with PersonalStorage.from_file(pst_file_path) as personal_storage:
        test_folder = personal_storage.root_folder.get_sub_folder("Inbox")

        # Create the collection of message properties for adding or updating
        new_properties = MapiPropertyCollection()

        # Normal, Custom, and PidLidLogFlags named properties
        mapi_property = MapiProperty(
            MapiPropertyTag.ORG_EMAIL_ADDR_W,
            "test_address@org.com".encode("utf-16le")
        )
        named_property1 = MapiNamedProperty(
            generate_named_property_tag(0, MapiPropertyType.LONG),
            "ITEM_ID",
            UUID("00000000-0000-0000-0000-000000000000"),
            bytearray([0x7B, 0x00, 0x00, 0x00])
        )
        named_property2 = MapiNamedProperty(
            generate_named_property_tag(1, MapiPropertyType.LONG),
            0x0000870C,
            UUID("0006200A-0000-0000-C000-000000000046"),
            bytearray([0x00, 0x00, 0x00, 0x00])
        )
        new_properties.add(named_property1.tag, named_property1)
        new_properties.add(named_property2.tag, named_property2)
        new_properties.add(mapi_property.tag, mapi_property)
        test_folder.change_messages(test_folder.enumerate_messages_entry_id(), new_properties)

# Usage
run()

מחיקת הודעות ותיקיות מקבצי PST של Outlook

ניהול תוכן קבצי PST של Outlook לעיתים כולל הסרת הודעות, תיקיות או פריטים מרובים בבת אחת. Aspose.Email for Python via .NET מספקת שיטות יעילות למחיקת הודעות ותיקיות מקובץ PST, בין אם יש צורך להסיר אימיילים בנפרד, FolderInfo.delete_child_item() שיטה, או לבצע מחיקות במקבץ, FolderInfo.delete_child_items() שיטה, לניהול קבצים משופר.

מחיקת הודעות מקבצי PST

Aspose.Email מספקת את FolderInfo מחלקה לגישה לתיקיות ספציפיות בקובץ PST. דוגמת הקוד למטה מראה כיצד להשתמש במחלקה זו לגישה ומחיקה של הודעות מתת‑תיקיית Sent של קבצי PST שכבר נטענו או נוצרו. במיוחד, היא מקבלת את מספר ההודעות ומוחקת את הפריט הראשון בתיקיית "Sent Items".

אובייקט PST מאותחל על ידי פתיחת הקובץ "Outlook.pst" הנמצא בתיקייה המוגדרת בעזרת PersonalStorage.from_file().
התיקייה Sent Items נגישה באמצעות pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
לאחר מכן, הקוד משיג את תוכן תיקיית "Sent Items" באמצעות folder.get_contents(), סופר אותן, ומדפיס את המספר הכולל של הודעות בתיקייה זו.
הקוד ניגש להודעה הראשונה בתיקיית "Sent Items" באמצעות msgsColl[0] ומוחק אותה בעזרת folder.delete_child_item(msgInfo.entry_id). פונקציה זו משתמשת ב‑Entry ID של ההודעה כדי להסיר אותה מהתיקייה.

לאחר המחיקה, הקוד סופר שוב את ההודעות בתיקיית "Sent Items" ומדפיס את הספירה המעודכנת.

מחיקת פריטים מקבצי PST

ברבות ממערכות ההודעות או לקוחות האימייל, לכל פריט (כגון אימייל, פגישה או משימה) מוקצה מזהה ייחודי בשם Entry ID. ה‑ delete_item(entry_id) שיטה של FolderInfo מחלקה זו מקבלת את ה‑Entry ID כפרמטר ומסירה את הפריט המתאים ממחסן ההודעות. השתמשו בקוד הבא למחיקת פריט ממחסן ההודעות:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

pst.delete_item(entry_id)

מחיקת פריטים במקבץ

ניתן להשתמש ב‑Aspose.Email API למחיקת פריטים במקצה מתוך קובץ PST. זה מתבצע באמצעות ה‑ delete_child_items() שיטה שמקבלת רשימת פריטי Entry ID המתייחסים לפריטים שיוחזרו למחיקה. קטע הקוד הבא מציג כיצד למחוק פריטים במקבץ מקובץ PST.

מחיקת תיקיות מקבצי PST

קבצי Outlook PST עשויים להכיל תיקיות שאינן נדרשות יותר. Aspose.Email for Python via .NET מאפשרת למחוק תיקיות אלו או על ידי העברתם לתיקיית Deleted Items (כך שהן ניתנות לשחזור) או על ידי הסרה קבועה. הדוגמאות שלהלן מדגימות את שני הגישות.

העברת תיקייה ל‑Deleted Items (מחיקה רכה)

ה move_item שיטה של PersonalStorage מחלקה המאפשרת תיקיות להיות משוחזרות מאוחר יותר, מכיוון שהן לא מוסרות באופן קבוע אלא מועברות לתיקיית Deleted Items. קטע הקוד הבא מראה כיצד ליישם שיטה זו בפרויקט פייתון:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

deleted_items_folder = pst.get_predefined_folder(ae.storage.pst.StandardIpmFolder.DELETED_ITEMS)
empty_folder = pst.root_folder.get_sub_folder("Empty folder")
some_folder = pst.root_folder.get_sub_folder("Some folder")
pst.move_item(empty_folder, deleted_items_folder)
pst.move_item(some_folder, deleted_items_folder)

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

שחזור תיקייה מ‑Deleted Items

ה move_item שיטה המאפשרת לשחזר תיקייה, אם נמחקה בטעות, על ידי העברתה חזרה מ‑Deleted Items למיקום המקורי שלה.

some_folder = pst.root_folder.get_sub_folder("Some folder")
pst.move_item(some_folder, pst.root_folder)

מחיקת תיקייה קבועה מ‑Deleted Items

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

deleted_items_folder.delete_child_item(empty_folder.entry_id)

מחק תיקייה באופן קבוע ומיידי

אם תיקייה צריכה להימחק מבלי להעביר אותה ל-Deleted Items, ה‑ delete_child_item שיטה מבטיחה הסרה מיידית וקבועה.

some_folder = pst.root_folder.get_sub_folder("Some folder")
pst.root_folder.delete_child_item(some_folder.entry_id)

קריאת קבצי PST/OST פגומים ניהול הגנת סיסמא לקבצי PST