Arbeiten mit Nachrichten in einer PST-Datei

Nachrichten zu Outlook‑PST‑Dateien hinzufügen

Eine einzelne Nachricht zu einer PST‑Datei hinzufügen

Neue PST‑Datei erstellen und Unterordner hinzufügen zeigt, wie man eine PST‑Datei erstellt und einen Unterordner hinzufügt. Mit Aspose.Email können Sie auch Nachrichten zu Unterordnern einer PST‑Datei hinzufügen, die Sie erstellt oder geladen haben. Das folgende Codebeispiel demonstriert, wie man eine neue PST‑Datei erstellt, einen "Inbox"‑Ordner hinzufügt und anschließend eine Nachricht zu diesem Ordner fügt. Das PersonalStorage und das FolderInfo Klassen werden verwendet, um die Aufgabe auszuführen.

Verwenden Sie die PersonalStorage.create Methode zum Initiieren einer neuen PST‑Datei, wobei Pfad und Formatversion als Unicode angegeben werden.
Erstellen Sie einen neuen Ordner namens "Inbox" im Stammverzeichnis der PST‑Datei.
Fügen Sie eine Nachricht zum neu erstellten "Inbox"‑Ordner hinzu, indem Sie die add_message Methode.
Laden Sie die Nachricht mit 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()

Mehrere Nachrichten zu PST‑Dateien hinzufügen für bessere Leistung

Das Hinzufügen einzelner Nachrichten zu einer PST erfordert mehr I/O‑Operationen auf die Festplatte und kann daher die Leistung beeinträchtigen. Um die Leistung zu verbessern, können Nachrichten im Bulk‑Modus zur PST hinzugefügt werden, wodurch I/O‑Operationen minimiert werden.

Laden und Hinzufügen von Nachrichten von der Festplatte

Die add_messages Methode ermöglicht das Definieren eines Nachrichtenbereichs, der zu einer PST‑Datei hinzugefügt werden soll. Das folgende Codebeispiel zeigt, wie mehrere Nachrichten von der Festplatte in eine PST‑Datei hinzugefügt werden, um die Leistung zu verbessern:

Definieren Sie eine Funktion, indem Sie add_messages_in_bulk_mode mit Parametern für den PST‑Dateinamen und den Ordner mit Nachrichten.
Öffnen Sie die angegebene PST‑Datei mit PersonalStorage.from_file().
Rufen Sie den Unterordner "myInbox" aus dem PST‑Stammordner ab.
Fügen Sie Nachrichten aus dem angegebenen Ordner in großen Mengen hinzu, indem Sie folder.add_messages().
Rufen Sie add_messages_in_bulk_mode() mit der PST‑Datei und dem Ordnernamen als Argumente.

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")

Verwenden `MapiMessageEnumerator` für Bulk‑Operationen

Um die Massenverarbeitung von Nachrichten zu vereinfachen, können Sie das MapiMessageEnumerator Klasse, die effizient durch in einem angegebenen Ordner gespeicherte Nachrichten iteriert. Das folgende Python‑Skript bietet einen strukturierten Ansatz zum Auflisten und Durchlaufen von MAPI‑Nachrichten mit der Aspose.Email‑Bibliothek. Es definiert zwei Hilfsklassen:

MapiMessageEnumerator zum Lesen von Nachrichten aus einem Verzeichnis,
und MapiMessageCollection zur Verwaltung während Batch‑Operationen.

Dieser Ansatz erleichtert das Durchlaufen und die Verarbeitung von MAPI‑Nachrichten-Dateien.

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

Nachrichten aus anderer PST hinzufügen

Um Nachrichten von einer PST‑Datei in eine andere zu importieren, bietet Aspose.Email die FolderInfo.enumerate_mapi_messages() Methode. Das folgende Codebeispiel zeigt, wie man Nachrichten aus einem "Inbox"‑Ordner einer PST‑Datei in eine andere PST‑Datei kopiert:

Nachrichten aus Outlook‑PST‑Dateien abrufen

In Outlook‑PST‑Dateien lesen, Ordner‑ und Unterordner‑Informationen abrufen, wir haben das Laden einer Outlook‑PST‑Datei und das Durchsuchen ihrer Ordner besprochen, um die Ordnernamen und die Anzahl der Nachrichten darin zu erhalten. Dieser Artikel erklärt, wie man auf Outlook‑PST‑Dateien zugreift und Nachrichten extrahiert: grundlegende Nachrichtendetails abrufen, die Anzahl der Elemente in einem Ordner zählen und eine bestimmte Anzahl von Nachrichten für die Verarbeitung oder Analyse extrahieren.

Grundlegende Nachrichteninformationen abrufen

Das folgende Codebeispiel demonstriert, wie man Schlüsselinformationen aus MAPI‑Nachrichten, die in einer PST‑Datei gespeichert sind, mit der Aspose.Email‑Bibliothek extrahiert und anzeigt. Es initialisiert ein PersonalStorage Objekt aus einer "Outlook.pst"‑Datei, ruft den Inhalt des Stammordners ab und iteriert durch jede Nachricht. Das Skript gibt Details wie Betreff, Absenderinformationen, Empfängeradressen, Zustellzeit und Nachrichtenkörper aus und bietet einen umfassenden Überblick über jede E‑Mail in der angegebenen PST‑Datei.

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)

Rekursives Lesen verschachtelter Ordner

Eine Outlook‑PST‑Datei kann verschachtelte Ordner enthalten. Um Nachrichteninformationen aus diesen sowie aus den obersten Ordnern zu erhalten, verwenden Sie eine rekursive Methode, um alle Ordner zu lesen. Das folgende Code‑Snippet zeigt, wie Sie eine Outlook‑PST‑Datei lesen und den Ordner- und Nachrichteninhalt rekursiv anzeigen:

Abrufen der Gesamtanzahl der Elemente in einem PST‑Ordner

Um die Gesamtzahl der Elemente (wie E‑Mails, Termine, Aufgaben, Kontakte usw.) im Nachrichtenspeicher zu ermitteln, verwenden Sie die Methode get_total_items_count() der MessageStore Klasse. Sie bietet eine bequeme Möglichkeit, schnell Informationen über Größe und Volumen der Daten im Store zu sammeln. Das folgende Code‑Snippet zeigt, wie man die Gesamtzahl der Elemente aus einer PST‑Datei erhält:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Eine bestimmte Anzahl von Nachrichten extrahieren

Um eine bestimmte Anzahl von Nachrichten aus einer PST‑Datei zu extrahieren, verwenden Sie die Methode get_contents(start_index, count) der FolderInfo Klasse. Sie nimmt zwei Parameter entgegen:

start_index – die Nummer der Startnachricht, z. B. die 10.
count – Gesamtzahl der abzurufenden Nachrichten.

Das Abrufen nur des notwendigen Teilsets von Nachrichten zu einem Zeitpunkt kann nützlich sein, um große Mengen an E‑Mail‑Daten zu verwalten. Das folgende Code‑Beispiel demonstriert die Implementierung dieser Funktion:

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)

Mit Anhängen in PST‑Dateien arbeiten

Anhänge extrahieren, ohne gesamte Nachrichten zu extrahieren

Aspose.Email für Python ermöglicht das Extrahieren von Anhängen aus PST‑Nachrichten, ohne die gesamte Nachricht zuerst extrahieren zu müssen. Dies kann mithilfe der extract_attachments Methode des PersonalStorage Klasse. Das folgende Code‑Snippet demonstriert, wie man Anhänge extrahiert und dabei .msg‑Dateien überspringt:

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)

Dateien als Anhänge zu PST‑Nachrichten hinzufügen

Microsoft Outlook ist ein leistungsstarkes Tool zum Verwalten von E‑Mails, Kalendern, Aufgaben, Kontakten und Journal‑Einträgen. Zusätzlich zu diesen Kernfunktionen erlaubt es auch das Hinzufügen von Dateien zu PST‑Ordnern, sodass Benutzer eine umfassende Dokumentation zugehöriger Dateien führen können. Aspose.Email vereinfacht das Hinzufügen von Dateien zu einem PST‑Ordner und funktioniert dabei ähnlich wie bei Nachrichten, Kontakten, Aufgaben und Journal‑Einträgen.

Das folgende Code‑Snippet zeigt, wie man ein Dokument zu einem PST‑Ordner mit Aspose.Email hinzufügt:

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", "")

Nachrichten in PST‑Dateien suchen und filtern

Personal Storage (PST)-Dateien können eine große Menge an Daten enthalten, und es erfordert mehrere Filterungen, um Daten zu finden, die bestimmten Kriterien entsprechen. Mit der PersonalStorageQueryBuilder Klasse, Aspose.Email ermöglicht es Ihnen, nach bestimmten Datensätzen in einer PST anhand definierter Suchkriterien zu suchen. Sie können Nachrichten anhand von Parametern wie Absender, Empfänger, Betreff, Nachrichtenpriorität, Vorhandensein von Anhängen, Nachrichtengröße und sogar Nachrichten‑ID durchsuchen. Zusätzlich bietet die PersonalStorageQueryBuilder kann für die Suche in Unterordnern verwendet werden. Die folgenden Abschnitte bieten eine umfassende Anleitung zur Suche in Outlook‑PST‑Dateien.

Outlook‑Nachrichten und -Ordner suchen

Das folgende Code‑Snippet zeigt, wie Sie die PersonalStorageQueryBuilder Klasse zur Suche nach Inhalten in einer PST basierend auf verschiedenen Suchkriterien. Sie demonstriert insbesondere das Durchsuchen einer PST nach:

Nachrichtenwichtigkeit.
Nachrichtenklasse.
Vorhandensein von Anhängen.
Nachrichtengröße.
Ungelesene Nachrichten.
Ungelesene Nachrichten mit Anhängen und Ordner mit einem bestimmten Unterordnernamen.

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)

Suche ohne Berücksichtigung der Groß-/Kleinschreibung

Durch die Nutzung von Aspose.Email PersonalStorageQueryBuilder, können Sie Suchbedingungen für E‑Mail‑Nachrichten festlegen, wobei die Groß‑/Kleinschreibung ignoriert wird, um eine flexiblere und benutzerfreundlichere Suche zu ermöglichen. Das folgende Codebeispiel zeigt, wie man eine PST‑Datei lädt, den "Inbox"‑Ordner öffnet und fallunabhängige Suchfilter anwendet, um E‑Mails basierend auf Absenderinformationen zu finden. Diese Funktion ist besonders hilfreich, wenn in den E‑Mail‑Daten unterschiedliche Schreibweisen vorkommen.

Betreffzeilen mit mehreren Schlüsselwörtern durchsuchen

Rufen Sie bestimmte Nachrichten oder Elemente aus einer persönlichen Speicherdatei (PST) oder einem Nachrichtenspeicher ab, indem Sie das either(query1, query2) Methode des PersonalStorageQueryBuilder Klasse. Sie nimmt zwei Parameter entgegen, mit denen Sie zwei verschiedene Abfragen, query1 und query2, kombinieren können, um einen Nachrichten‑Betreff zu finden, der eines der beiden angegebenen Wörter enthält. Siehe das Codebeispiel unten:

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}")

E‑Mails in PST nach bestimmten Kriterien filtern

Rufen Sie nur die Nachrichten ab, die einem bestimmten Filter entsprechen, z. B. Betreff, Absender oder Datum, indem Sie das MailQuery Klasse. Das folgende Codebeispiel zeigt, wie die Aspose.Email‑Bibliothek verwendet wird, um eine PST‑Datei zu laden und Nachrichten in einem bestimmten Ordner zu filtern, in diesem Fall im "Inbox"‑Ordner:

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)

Nachrichten nach Typ abrufen

Das Aspose.Email MessageKind Überladung ermöglicht das Abrufen von Nachrichten eines bestimmten Typs, z. B. nur E‑Mails, Termine oder Kontakte. Das folgende Codebeispiel zeigt, wie man auf bestimmte Nachrichtentypen in einem bestimmten Ordner zugreift und diese filtert:

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)

Nachrichtenabruf für große PST‑Dateien paginieren

Beim Arbeiten mit Ordnern, die eine große Anzahl von Nachrichten enthalten, können Sie die Paginierung verwenden, um Nachrichten in Abschnitten zu laden, indem Sie das start_index und count Parameter. Das folgende Codebeispiel zeigt, wie man auf einen bestimmten Bereich von E‑Mail‑Nachrichten in einer PST‑Datei zugreift und diesen abruft, anstatt alle auf einmal zu holen:

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)

Outlook-PST-Inhalt aktualisieren und organisieren

Nachrichten zwischen Ordnern verschieben

Aspose.Email ermöglicht das Verschieben von Elementen von einem Quellordner zu einem anderen Ordner in derselben Personal Storage (PST)-Datei. Dies beinhaltet:

Einen bestimmten Ordner in einen neuen übergeordneten Ordner verschieben.
Verschieben bestimmter Nachrichten in einen neuen Ordner.
Den Inhalt in einen neuen Ordner verschieben.
Unterordner in einen neuen übergeordneten Ordner verschieben.

Das folgende Code‑Snippet zeigt, wie Sie Elemente wie Nachrichten und Ordner von einem Quellordner in einen anderen Ordner derselben PST‑Datei verschieben.

Nachrichteneigenschaften aktualisieren

Manchmal ist es nötig, bestimmte Eigenschaften von Nachrichten zu ändern, z. B. den Betreff, die Wichtigkeit der Nachricht und mehr. Das Aktualisieren dieser Eigenschaften in einer PST‑Datei kann mit der FolderInfo.change_messages Methode, die von Aspose.Email für Python bereitgestellt wird. Dieser Artikel zeigt den Prozess der massenhaften Aktualisierung von Nachrichteneigenschaften, wodurch automatisierte Anpassungen über mehrere Nachrichten hinweg in einer PST‑Datei ermöglicht werden. Weiter unten befindet sich ein Codeausschnitt, der zeigt, wie man massenweise Updates verschiedener Nachrichteneigenschaften durchführt.

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)

Benutzerdefinierte MAPI‑Eigenschaften ändern

Manchmal müssen Sie möglicherweise Elemente, die in einer PST‑Datei verarbeitet wurden, identifizieren und kennzeichnen. Die Aspose.Email‑API bietet hierfür eine Lösung über die Verwendung von MapiProperty und MapiNamedProperty Klassen. Diese Klassen ermöglichen es, verarbeitete Elemente zu kennzeichnen, indem benutzerdefinierte Eigenschaften zugewiesen werden. Im Folgenden finden Sie Methoden, die besonders nützlich für diesen Kennzeichnungsprozess sind:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - ändert alle Nachrichten in einem Ordner
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - ändert Nachrichteneigenschaften

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()

Nachrichten und Ordner aus Outlook‑PST‑Dateien löschen

Die Verwaltung des Inhalts von Outlook‑PST‑Dateien beinhaltet häufig das Entfernen unnötiger Nachrichten, Ordner oder mehrerer Elemente gleichzeitig. Aspose.Email für Python via .NET bietet effiziente Methoden zum Löschen von Nachrichten und Ordnern aus einer PST‑Datei, egal ob Sie einzelne E‑Mails entfernen möchten, FolderInfo.delete_child_item() Methode, oder Bulk‑Löschungen durchführen, FolderInfo.delete_child_items() Methode, für ein besseres Dateimanagement.

Nachrichten aus PST‑Dateien löschen

Aspose.Email provides the FolderInfo Klasse zum Zugriff auf bestimmte Ordner in einer PST‑Datei. Das untenstehende Codebeispiel zeigt, wie diese Klasse verwendet wird, um Nachrichten aus dem Unterordner Sent einer zuvor geladenen oder erstellten PST‑Datei zuzugreifen und zu löschen. Konkret wird die Nachrichtenanzahl abgerufen und das erste Element im Ordner "Sent Items" gelöscht.

Ein PST‑Objekt wird initialisiert, indem die Datei "Outlook.pst" im angegebenen Verzeichnis mit PersonalStorage.from_file().
Auf den Ordner Sent Items wird zugegriffen über pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Anschließend ruft der Code den Inhalt des Ordners "Sent Items" mit folder.get_contents(), zählt sie und gibt die Gesamtzahl der Nachrichten in diesem Ordner aus.
Der Code greift auf die erste Nachricht im Ordner "Sent Items" mit msgsColl[0] zu und löscht sie mit folder.delete_child_item(msgInfo.entry_id). Diese Funktion verwendet die Entry‑ID der Nachricht, um sie aus dem Ordner zu entfernen.

Nach dem Löschen zählt der Code erneut die Nachrichten im Ordner "Sent Items" und gibt die aktualisierte Anzahl aus.

Elemente aus PST‑Dateien löschen

In vielen Nachrichtensystemen oder E‑Mail‑Clients wird jedem Element (wie einer E‑Mail, einem Termin oder einer Aufgabe) ein eindeutiger Bezeichner, die Entry‑ID, zugewiesen. Die delete_item(entry_id) Methode des FolderInfo Klasse nimmt diese Entry‑ID als Parameter und entfernt das entsprechende Element aus dem Nachrichtenspeicher. Verwenden Sie den folgenden Code, um ein Element aus dem Nachrichtenspeicher zu löschen:

import aspose.email as ae

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

pst.delete_item(entry_id)

Elemente in großen Mengen löschen

Die Aspose.Email‑API kann verwendet werden, um Elemente stapelweise aus einer PST‑Datei zu löschen. Dies wird erreicht mittels der delete_child_items() Methode, die eine Liste von Entry‑ID‑Elementen akzeptiert, die auf die zu löschenden Elemente verweisen. Der folgende Codeausschnitt zeigt, wie Sie Elemente in großen Mengen aus einer PST‑Datei löschen.

Ordner aus PST‑Dateien löschen

Outlook‑PST‑Dateien können Ordner enthalten, die nicht mehr benötigt werden. Aspose.Email für Python via .NET ermöglicht das Löschen dieser Ordner, entweder durch Verschieben in den Ordner Gelöschte Elemente (wodurch sie wiederherstellbar werden) oder durch permanentes Entfernen. Die folgenden Beispiele zeigen beide Ansätze.

Ordner in Gelöschte Elemente verschieben (weiches Löschen)

Die move_item Methode des PersonalStorage Klasse erlaubt es, Ordner später wiederherzustellen, da sie nicht dauerhaft entfernt, sondern in den Ordner Gelöschte Elemente verschoben werden. Der folgende Codeausschnitt zeigt, wie diese Methode in ein Python‑Projekt implementiert wird:

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)

Der Vorteil dieser Methode ist, dass der gelöschte Ordner leicht wiederhergestellt werden kann.

Ordner aus Gelöschten Elementen wiederherstellen

Die move_item Methode ermöglicht es, einen Ordner wiederherzustellen, falls er versehentlich gelöscht wurde, indem er vom Ordner Gelöschte Elemente zurück an den ursprünglichen Speicherort verschoben wird.

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

Ordner dauerhaft aus Gelöschten Elementen löschen

Die delete_child_item Methode kann für beliebige Ordner verwendet werden, wenn Sie einen Unterordner sofort und dauerhaft löschen möchten, ohne ihn in den Ordner Gelöschte Elemente zu verschieben. Das folgende Codebeispiel zeigt, wie man den Ordner vollständig aus Gelöschte Elemente entfernt, sodass eine Wiederherstellung unmöglich ist:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Ordner sofort dauerhaft löschen

Wenn ein Ordner gelöscht werden soll, ohne ihn in den Ordner Gelöschte Elemente zu verschieben, dann delete_child_item Methode sorgt für sofortige und permanente Entfernung.

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

Verwalten von Outlook‑MAPI‑Aufgaben in PST‑Dateien Verwaltung des Passwortschutzes für PST‑Dateien