Praca z wiadomościami w pliku PST

Dodaj wiadomości do plików PST Outlook

Dodaj pojedynczą wiadomość do pliku PST

Utwórz nowy plik PST i dodaj podfoldery pokazuje, jak utworzyć plik PST i dodać do niego podfolder. Z Aspose.Email możesz także dodawać wiadomości do podfolderów pliku PST, który utworzyłeś lub załadowałeś. Poniższy przykład kodu demonstruje, jak utworzyć nowy plik PST, dodać folder "Inbox", a następnie dodać wiadomość do tego folderu. PersonalStorage oraz FolderInfo klasy są używane do wykonania zadania.

Użyj PersonalStorage.create metoda inicjująca nowy plik PST, określająca ścieżkę pliku i wersję formatu pliku jako Unicode.
Utwórz nowy folder o nazwie "Inbox" w katalogu głównym pliku PST.
Dodaj wiadomość do nowo utworzonego folderu "Inbox" przy użyciu add_message metoda.
Załaduj wiadomość przy użyciu 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()

Dodaj wiele wiadomości do plików PST dla lepszej wydajności

Dodawanie pojedynczych wiadomości do PST oznacza więcej operacji I/O na dysku i może spowolnić wydajność. Aby ją poprawić, wiadomości mogą być dodawane do PST w trybie hurtowym, minimalizując operacje I/O.

Ładuj i dodawaj wiadomości z dysku

Ten add_messages metoda pozwala określić zakres wiadomości do dodania do pliku PST. Poniższy przykład kodu demonstruje, jak dodać wiele wiadomości z dysku do pliku PST w celu poprawy wydajności:

Zdefiniuj funkcję, tworząc add_messages_in_bulk_mode z parametrami określającymi nazwę pliku PST oraz folder z wiadomościami.
Otwórz określony plik PST przy użyciu PersonalStorage.from_file().
Pobierz podfolder "myInbox" z folderu głównego PST.
Dodaj wiadomości z określonego folderu hurtowo przy użyciu folder.add_messages().
Wywołaj add_messages_in_bulk_mode() z plikiem PST i nazwą folderu jako argumentami.

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

Użyj `MapiMessageEnumerator` dla operacji zbiorczych**

Aby usprawnić przetwarzanie wiadomości zbiorczych, możesz wdrożyć MapiMessageEnumerator klasa efektywnie iterująca po wiadomościach przechowywanych w określonym folderze. Poniższy skrypt Pythona zapewnia ustrukturyzowane podejście do wyliczania i iteracji nad wiadomościami MAPI przy użyciu biblioteki Aspose.Email. Definiuje dwie klasy pomocnicze:

MapiMessageEnumerator do odczytu wiadomości z katalogu,
i MapiMessageCollection do zarządzania nimi podczas operacji wsadowych.

To podejście ułatwia przeglądanie i obsługę plików komunikatów 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

Dodaj wiadomości z innego PST

Aby zaimportować wiadomości z jednego pliku PST do drugiego, Aspose.Email udostępnia FolderInfo.enumerate_mapi_messages() metoda. Poniższy przykład kodu demonstruje, jak skopiować wiadomości z folderu "Inbox" w jednym pliku PST do innego pliku PST:

Pobierz wiadomości z plików PST Outlook

W Odczyt plików Outlook PST, pobieranie informacji o folderach i podfolderach, omówiliśmy ładowanie pliku PST Outlook i przeglądanie jego folderów w celu uzyskania nazw folderów oraz liczby wiadomości w nich. Ten artykuł wyjaśnia, jak uzyskać dostęp i wyodrębnić wiadomości z plików PST Outlook: pobrać podstawowe szczegóły wiadomości, policzyć liczbę elementów w folderze i wyodrębnić określoną liczbę wiadomości do przetworzenia lub analizy.

Pobierz podstawowe informacje o wiadomości

Poniższy przykład kodu demonstruje, jak wyodrębnić i wyświetlić kluczowe informacje z wiadomości MAPI przechowywanych w pliku PST przy użyciu biblioteki Aspose.Email. Inicjalizuje on PersonalStorage obiekt z pliku "Outlook.pst", pobiera zawartość folderu głównego i iteruje po każdej wiadomości. Skrypt wyświetla szczegóły takie jak temat, informacje nadawcy, adresy odbiorców, czas doręczenia i treść wiadomości, zapewniając kompleksowy przegląd każdej wiadomości e‑mail w określonym pliku 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)

Rekursywne odczytywanie zagnieżdżonych folderów

Plik PST Outlook może zawierać zagnieżdżone foldery. Aby uzyskać informacje o wiadomościach z nich oraz z folderów najwyższego poziomu, użyj rekurencyjnej metody do odczytu wszystkich folderów. Poniższy fragment kodu pokazuje, jak odczytać plik PST Outlook i wyświetlić zawartość folderów i wiadomości rekurencyjnie:

Pobierz całkowitą liczbę elementów w folderze PST

Aby pobrać łączną liczbę elementów (takich jak e‑maile, spotkania, zadania, kontakty itp.) znajdujących się w magazynie wiadomości, użyj metody get_total_items_count() klasy MessageStore klasa. Zapewnia wygodny sposób szybkiego zebrania informacji o rozmiarze i objętości danych w magazynie. Poniższy fragment kodu pokazuje, jak uzyskać łączną liczbę elementów w pliku PST:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Wyodrębnij określoną liczbę wiadomości

Aby wyodrębnić określoną liczbę wiadomości z pliku PST, użyj metody get_contents(start_index, count) klasy FolderInfo klasa. Przyjmuje dwa parametry:

start_index - numer pierwszej wiadomości, np. 10‑tej;
count - łączna liczba wiadomości do pobrania.

Pobieranie w danej chwili tylko niezbędnego podzbioru wiadomości może być przydatne przy zarządzaniu dużą ilością danych e‑mailowych. Poniższy przykład kodu demonstruje implementację tej funkcji:

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)

Praca z załącznikami w plikach PST

Wyodrębnij załączniki bez wyciągania całych wiadomości

Aspose.Email for Python umożliwia wyodrębnianie załączników z wiadomości PST bez konieczności wcześniejszego wyciągania całej wiadomości. Można to zrobić przy użyciu extract_attachments metoda PersonalStorage klasa. Poniższy fragment kodu demonstruje, jak wyodrębnić załączniki pomijając pliki .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)

Dodaj pliki jako załączniki do wiadomości PST

Microsoft Outlook jest potężnym narzędziem do zarządzania e‑mailami, kalendarzami, zadaniami, kontaktami i wpisami dziennika. Poza tymi podstawowymi funkcjami, pozwala także na dodawanie plików do folderów PST, umożliwiając użytkownikom prowadzenie kompleksowego rejestru powiązanych dokumentów. Aspose.Email upraszcza proces dodawania plików do folderu PST, działając podobnie jak przy obsłudze wiadomości, kontaktów, zadań i wpisów dziennika.

Poniższy fragment kodu ilustruje, jak dodać dokument do folderu PST przy użyciu 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", "")

Wyszukiwanie i filtrowanie wiadomości w plikach PST

Pliki Personal Storage (PST) mogą zawierać dużą ilość danych i wymagają zastosowania wielokrotnego filtrowania, aby znaleźć dane spełniające określone kryteria. Z PersonalStorageQueryBuilder klasa, Aspose.Email umożliwia wyszukiwanie konkretnych rekordów w PST na podstawie określonych kryteriów. Możesz wyszukiwać wiadomości używając parametrów takich jak nadawca, odbiorca, temat, ważność wiadomości, obecność załączników, rozmiar wiadomości, a nawet jej ID. Dodatkowo, PersonalStorageQueryBuilder można używać do wyszukiwania w podfolderach. Poniższe sekcje zapewniają kompleksowy przewodnik po wyszukiwaniu w plikach PST Outlook.

Wyszukiwanie wiadomości i folderów Outlook

Poniższy fragment kodu pokazuje, jak używać PersonalStorageQueryBuilder klasa umożliwiająca wyszukiwanie zawartości w PST na podstawie różnych kryteriów wyszukiwania. Szczególnie demonstruje wyszukiwanie PST według:

Ważność wiadomości.
Klasa wiadomości.
Obecność załączników.
Rozmiar wiadomości.
Nieprzeczytane wiadomości.
Nieprzeczytane wiadomości z załącznikami oraz foldery o określonej nazwie podfolderu.

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)

Wyszukiwanie bez uwzględniania wielkości liter

Korzystając z Aspose.Email PersonalStorageQueryBuilder, możesz określić warunki wyszukiwania wiadomości e‑mail, ignorując wielkość liter, co umożliwia bardziej elastyczne i przyjazne dla użytkownika wyszukiwanie. Poniższy przykład kodu demonstruje, jak załadować plik PST, uzyskać dostęp do folderu "Inbox" i zastosować filtry wyszukiwania niewrażliwe na wielkość liter, aby znaleźć e‑maile na podstawie informacji o nadawcy. Ta funkcja jest szczególnie pomocna przy radzeniu sobie ze zróżnicowaną wielkością liter w danych e‑mail.

Wyszukaj linie tematu używając wielu słów kluczowych

Pobierz określone wiadomości lub elementy z pliku przechowywania osobistego (PST) lub magazynu wiadomości, stosując either(query1, query2) metoda PersonalStorageQueryBuilder klasa. Przyjmuje dwa parametry umożliwiające połączenie dwóch różnych zapytań, query1 i query2, i znalezienie tematu wiadomości pasującego do któregokolwiek z dwóch określonych słów. Zobacz poniższy przykład kodu:

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

Filtruj e‑maile w PST według określonych kryteriów

Pobierz tylko wiadomości spełniające określony filtr, np. temat, nadawcę lub datę, używając MailQuery klasa. Poniższy przykład kodu pokazuje, jak użyć biblioteki Aspose.Email do wczytania pliku PST i filtrowania wiadomości w określonym folderze, w tym przypadku folderze "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)

Pobierz wiadomości według typu

Aspose.Email MessageKind przeciążenie umożliwia pobranie wiadomości określonego typu, np. tylko e‑maile, spotkania lub kontakty. Poniższy przykład kodu pokazuje, jak uzyskać dostęp i filtrować określone typy wiadomości z wybranego folderu:

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)

Paginacja pobierania wiadomości w dużych plikach PST

Podczas pracy z folderami zawierającymi dużą liczbę wiadomości możesz używać paginacji, aby ładować wiadomości w partiach przy użyciu start_index i count parametry. Poniższy przykład kodu pokazuje, jak uzyskać dostęp i pobrać określony zakres wiadomości e‑mail z pliku PST, zamiast wszystkich jednocześnie:

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)

Zaktualizuj i uporządkuj zawartość Outlook PST

Przenoszenie wiadomości między folderami

Aspose.Email umożliwia przenoszenie elementów ze źródłowego folderu do innego folderu w tym samym pliku Personal Storage (PST). Obejmuje to:

Przenoszenie określonego folderu do nowego folderu nadrzędnego.
Przenoszenie określonych wiadomości do nowego folderu.
Przenoszenie zawartości do nowego folderu.
Przenoszenie podfolderów do nowego folderu nadrzędnego.

Poniższy fragment kodu pokazuje, jak przenieść elementy, takie jak wiadomości i foldery, ze źródłowego folderu do innego folderu w tym samym pliku PST.

Zaktualizuj właściwości wiadomości

Czasami konieczna jest modyfikacja niektórych właściwości wiadomości, takich jak zmiana tematu, oznaczanie ważności wiadomości i inne. Aktualizację tych właściwości w pliku PST można wykonać przy użyciu FolderInfo.change_messages metoda udostępniona przez Aspose.Email dla Pythona. Ten artykuł przedstawia proces masowej aktualizacji właściwości wiadomości, umożliwiając automatyczne zmiany w wielu wiadomościach w pliku PST. Poniżej znajduje się fragment kodu ilustrujący, jak wykonać masowe aktualizacje różnych właściwości wiadomości.

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)

Modyfikuj własne właściwości MAPI

Czasami może być konieczne zidentyfikowanie i oznaczenie elementów, które zostały przetworzone w pliku PST. API Aspose.Email oferuje rozwiązanie tego zadania przy użyciu MapiProperty i MapiNamedProperty klasy. Te klasy umożliwiają oznaczanie przetworzonych elementów poprzez przypisywanie im własnych właściwości. Poniżej znajdziesz metody szczególnie przydatne do przeprowadzenia tego procesu oznaczania:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - zmienia wszystkie wiadomości w folderze
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - zmienia własności wiadomości

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

Usuń wiadomości i foldery z plików Outlook PST

Zarządzanie zawartością plików Outlook PST często obejmuje usuwanie niepotrzebnych wiadomości, folderów lub wielu elementów jednocześnie. Aspose.Email for Python via .NET oferuje wydajne metody usuwania wiadomości i folderów z pliku PST, niezależnie od tego, czy musisz usunąć pojedyncze e‑maile, FolderInfo.delete_child_item() metoda, lub wykonywać masowe usunięcia, FolderInfo.delete_child_items() metoda, aby lepiej zarządzać plikami.

Usuń wiadomości z plików PST

Aspose.Email udostępnia FolderInfo klasa do uzyskiwania dostępu do konkretnych folderów w pliku PST. Poniższy przykład kodu pokazuje, jak używać tej klasy do uzyskiwania dostępu i usuwania wiadomości z podfolderu Sent wcześniej wczytanych lub utworzonych plików PST. Konkretne, pobiera liczbę wiadomości i usuwa pierwszy element w folderze "Sent Items".

Obiekt PST jest inicjalizowany poprzez otwarcie pliku "Outlook.pst" znajdującego się w określonym katalogu przy użyciu PersonalStorage.from_file().
Folder Sent Items jest dostępny przy użyciu pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Następnie kod pobiera zawartość folderu "Sent Items" przy użyciu folder.get_contents(), liczy je i wypisuje całkowitą liczbę wiadomości w tym folderze.
Kod uzyskuje dostęp do pierwszej wiadomości w folderze "Sent Items" za pomocą msgsColl[0] i usuwa ją przy użyciu folder.delete_child_item(msgInfo.entry_id). Ta funkcja używa identyfikatora wejścia (Entry ID) wiadomości, aby usunąć ją z folderu.

Po usunięciu kod ponownie liczy wiadomości w folderze "Sent Items" i wypisuje zaktualizowaną liczbę.

Usuwanie elementów z plików PST

W wielu systemach wiadomości lub klientach poczty każdy element (np. e‑mail, spotkanie lub zadanie) otrzymuje unikalny identyfikator zwany Entry ID. delete_item(entry_id) metoda FolderInfo klasa przyjmuje ten Entry ID jako parametr i usuwa odpowiadający element z magazynu wiadomości. Użyj poniższego kodu, aby usunąć element z magazynu wiadomości:

import aspose.email as ae

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

pst.delete_item(entry_id)

Usuwaj elementy masowo

API Aspose.Email może być użyte do zbiorczego usuwania elementów z pliku PST. Osiąga się to za pomocą delete_child_items() metoda, która przyjmuje listę elementów Entry ID odnoszących się do elementów do usunięcia. Poniższy fragment kodu pokazuje, jak usunąć elementy masowo z pliku PST.

Usuń foldery z plików PST

Pliki Outlook PST mogą zawierać foldery, które nie są już potrzebne. Aspose.Email for Python via .NET umożliwia usuwanie tych folderów albo poprzez przeniesienie ich do folderu Deleted Items (co umożliwia ich odzyskanie), albo poprzez trwałe usunięcie. Poniższe przykłady demonstrują oba podejścia.

Przenieś folder do Deleted Items (miękkie usunięcie)

Ten move_item metoda PersonalStorage klasa umożliwia późniejsze odzyskanie folderów, ponieważ nie są one trwale usuwane, a przenoszone do folderu Deleted Items. Poniższy fragment kodu pokazuje, jak zaimplementować tę metodę w projekcie Python:

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)

Zaletą tej metody jest to, że usunięty folder można łatwo odzyskać.

Przywróć folder z Deleted Items

Ten move_item metoda pozwala przywrócić folder, jeśli został omyłkowo usunięty, przenosząc go z powrotem z Deleted Items do pierwotnej lokalizacji.

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

Trwale usuń folder z Deleted Items

Ten delete_child_item metoda może być użyta dla dowolnych folderów, jeśli chcesz natychmiast i trwale usunąć podfolder, omijając folder Deleted Items. Poniższy przykład kodu pokazuje, jak całkowicie usunąć folder z Deleted Items, uniemożliwiając jego odzyskanie:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Trwale usuń folder natychmiast

Jeśli folder ma być usunięty bez przenoszenia go do Deleted Items, delete_child_item metoda zapewnia natychmiastowe i trwałe usunięcie.

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

Zarządzanie zadaniami MAPI Outlook w plikach PST Zarządzanie ochroną hasłem pliku PST