Práce se zprávami v souboru PST

Přidat zprávy do souborů Outlook PST

Přidat jednu zprávu do souboru PST

Vytvořte nový soubor PST a přidejte podadresáře ukazuje, jak vytvořit soubor PST a přidat do něj podsložku. S Aspose.Email můžete také přidávat zprávy do podsložek souboru PST, který jste vytvořili nebo načetli. Níže uvedený ukázkový kód demonstruje, jak vytvořit nový soubor PST, přidat složku "Inbox" a poté přidat zprávu do této složky. PersonalStorage a FolderInfo třídy jsou použity k provedení úkolu.

Použijte PersonalStorage.create metoda pro zahájení nového souboru PST s určením cesty k souboru a verze formátu souboru jako Unicode.
Vytvořte novou složku pojmenovanou "Inbox" v kořenovém adresáři souboru PST.
Přidejte zprávu do nově vytvořené složky "Inbox" pomocí add_message metoda.
Nahrát zprávu pomocí 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()

Přidat více zpráv do souborů PST pro lepší výkon

Přidávání jednotlivých zpráv do PST vyžaduje více I/O operací na disk a může tak zpomalit výkon. Pro zlepšení výkonu lze zprávy přidávat do PST hromadně a minimalizovat I/O operace.

Načíst a přidat zprávy z disku

The add_messages metoda vám umožní definovat rozsah zpráv, které mají být přidány do souboru PST. Níže uvedený ukázkový kód demonstruje, jak přidat více zpráv z disku do souboru PST pro zlepšení výkonu:

Definujte funkci vytvořením add_messages_in_bulk_mode s parametry pro název souboru PST a složku se zprávami.
Otevřete specifikovaný soubor PST pomocí PersonalStorage.from_file().
Získejte podsložku "myInbox" z kořenové složky PST.
Přidejte zprávy ze specifikované složky hromadně pomocí folder.add_messages().
Zavolejte add_messages_in_bulk_mode() s souborem PST a názvem složky jako argumenty.

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

Použít `MapiMessageEnumerator` pro hromadné operace

Aby bylo zjednodušeno hromadné zpracování zpráv, můžete implementovat MapiMessageEnumerator class, který efektivně iteruje přes zprávy uložené ve specifikované složce. Následující Python skript poskytuje strukturovaný přístup k enumeraci a iteraci MAPI zpráv pomocí knihovny Aspose.Email. Definuje dvě pomocné třídy:

MapiMessageEnumerator pro čtení zpráv z adresáře,
a MapiMessageCollection pro jejich správu během hromadných operací.

Tento přístup usnadňuje procházení a zpracování souborů MAPI zpráv.

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

Přidat zprávy z jiného PST

Pro import zpráv z jednoho souboru PST do druhého poskytuje Aspose.Email FolderInfo.enumerate_mapi_messages() metoda. Následující ukázkový kód demonstruje, jak kopírovat zprávy ze složky "Inbox" v jednom souboru PST do jiného souboru PST:

Získat zprávy z Outlook PST souborů

V Čtení Outlook PST souborů, získávání informací o složkách a podadresářích, diskutovali jsme o načítání souboru Outlook PST a procházení jeho složek za účelem získání názvů složek a počtu zpráv v nich. Tento článek vysvětluje, jak přistupovat k zprávám a extrahovat je z Outlook PST souborů: získat základní podrobnosti o zprávě, spočítat počet položek ve složce a extrahovat konkrétní počet zpráv pro zpracování nebo analýzu.

Získat základní informace o zprávě

Následující ukázkový kód demonstruje, jak extrahovat a zobrazit klíčové informace z MAPI zpráv uložených v souboru PST pomocí knihovny Aspose.Email. Inicializuje PersonalStorage objekt ze souboru "Outlook.pst", získá obsah kořenové složky a iteruje přes každou zprávu. Skript vypisuje podrobnosti jako předmět, informace o odesílateli, adresy příjemců, čas doručení a tělo zprávy, což poskytuje komplexní přehled o každém e‑mailu ve specifikovaném souboru 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)

Rekurzivní čtení vnořených složek

Soubor Outlook PST může obsahovat vnořené složky. Pro získání informací o zprávách z nich i z nejvyšší úrovně složek použijte rekurzivní metodu pro přečtení všech složek. Následující úryvek kódu ukazuje, jak číst soubor Outlook PST a rekurzivně zobrazit obsah složek a zpráv:

Získat celkový počet položek ve složce PST

Aby byl získán celkový počet položek (např. e‑maily, schůzky, úkoly, kontakty atd.) v úložišti zpráv, použijte metodu get_total_items_count() objektu MessageStore třída. Poskytuje pohodlný způsob, jak rychle získat informace o velikosti a objemu dat v úložišti. Následující úryvek kódu ukazuje, jak získat celkový počet položek ze souboru PST:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Extrahovat konkrétní počet zpráv

Aby bylo možné extrahovat určený počet zpráv ze souboru PST, použijte metodu get_contents(start_index, count) objektu FolderInfo třída. Přijímá dva parametry:

start_index – číslo počáteční zprávy, například 10.
count – celkový počet zpráv k načtení.

Získávání pouze potřebné podmnožiny zpráv najednou může být užitečné při správě velkého objemu e‑mailových dat. Následující ukázkový kód demonstruje implementaci této funkce:

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)

Práce s přílohami v souborech PST

Extrahovat přílohy bez extrahování celých zpráv

Aspose.Email pro Python umožňuje extrahovat přílohy z PST zpráv bez nutnosti nejprve extrahovat celou zprávu. Lze to provést pomocí extract_attachments metoda třídy PersonalStorage class. Následující úryvek kódu demonstruje, jak extrahovat přílohy při vynechání souborů .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)

Přidávat soubory jako přílohy k PST zprávám

Microsoft Outlook je výkonný nástroj pro správu e‑mailů, kalendářů, úkolů, kontaktů a deníků. Kromě těchto základních funkcí umožňuje také přidávat soubory do složek PST, což uživatelům umožňuje udržovat komplexní záznam souvisejících dokumentů. Aspose.Email zjednodušuje proces přidávání souborů do složky PST a funguje podobně jako při zpracování zpráv, kontaktů, úkolů a deníků.

Následující úryvek kódu ukazuje, jak přidat dokument do složky PST pomocí 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", "")

Vyhledávat a filtrovat zprávy v souborech PST

Soubor Personal Storage (PST) může obsahovat velké množství dat a vyžaduje využití více filtrací k nalezení dat odpovídajících konkrétním kritériím. S PersonalStorageQueryBuilder třída, Aspose.Email vám umožňuje vyhledávat konkrétní záznamy v PST na základě definovaných kritérií vyhledávání. Můžete vyhledávat zprávy pomocí parametrů jako odesílatel, příjemce, předmět, důležitost zprávy, přítomnost příloh, velikost zprávy a dokonce i ID zprávy. Navíc, PersonalStorageQueryBuilder může být použito k vyhledávání v podsložkách. Následující sekce poskytují komplexní průvodce vyhledáváním v souborech Outlook PST.

Vyhledávat zprávy a složky Outlook

Níže uvedený úryvek kódu ukazuje, jak použít PersonalStorageQueryBuilder class pro vyhledávání obsahu v PST na základě různých kritérií vyhledávání. Konkrétně demonstruje vyhledávání PST podle:

Důležitost zprávy.
Třída zprávy.
Přítomnost příloh.
Velikost zprávy.
Nepřečtené zprávy.
Nepřečtené zprávy s přílohami a složky s konkrétním názvem podsložky.

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)

Vyhledávání s nerespektováním velikosti písmen

S využitím Aspose.Email PersonalStorageQueryBuilder, můžete specifikovat podmínky vyhledávání e‑mailových zpráv s ignorováním velikosti písmen, což umožňuje flexibilnější a uživatelsky přívětivější vyhledávání. Následující ukázkový kód ukazuje, jak načíst soubor PST, přistoupit ke složce "Inbox" a použít filtr vyhledávání neberoucí v úvahu velikost písmen k nalezení e‑mailů na základě informací o odesílateli. Tato funkce je zvláště užitečná při práci s různou kapitalizací v e‑mailových datech.

Prohledávat předměty pomocí více klíčových slov

Načtěte konkrétní zprávy nebo položky z osobního úložného souboru (PST) nebo úložiště zpráv implementací either(query1, query2) metoda třídy PersonalStorageQueryBuilder třída. Přijímá dva parametry, které umožňují kombinovat dva různé dotazy, query1 a query2, a najít předmět zprávy odpovídající některému ze dvou zadaných slov. Viz ukázkový kód níže:

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

Filtrovat e‑maily v PST podle konkrétních kritérií

Načtěte pouze zprávy odpovídající konkrétnímu filtru, např. předmět, odesílatel nebo datum, pomocí MailQuery třída. Následující ukázkový kód demonstruje, jak použít knihovnu Aspose.Email k načtení souboru PST a filtrovat zprávy v konkrétní složce, v tomto případě ve složce "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)

Načíst zprávy podle typu

Aspose.Email MessageKind přetížení umožňuje získat zprávy konkrétního typu, například pouze e‑maily, schůzky nebo kontakty. Následující ukázkový kód demonstruje, jak přistupovat a filtrovat konkrétní typy zpráv z určené složky:

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)

Stránkovat načítání zpráv pro velké soubory PST

Při práci se složkami obsahujícími velké množství zpráv můžete použít stránkování k načítání zpráv po částech pomocí start_index a count parametry. Následující ukázkový kód demonstruje, jak získat a načíst konkrétní rozsah e‑mailových zpráv ze souboru PST místo načtení všech najednou:

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)

Aktualizovat a organizovat obsah Outlook PST

Přesun zpráv mezi složkami

Aspose.Email umožňuje přesunout položky ze zdrojové složky do jiné složky ve stejném souboru Personal Storage (PST). To zahrnuje:

Přesun konkrétní složky do nové nadřazené složky.
Přesunutí určených zpráv do nové složky.
Přesun obsahu do nové složky.
Přesun podadresářů do nové nadřazené složky.

Níže uvedený úryvek kódu ukazuje, jak přesunout položky, jako jsou zprávy a složky, ze zdrojové složky do jiné složky ve stejném souboru PST.

Aktualizovat vlastnosti zprávy

Někdy je potřeba upravit určité vlastnosti zpráv, jako změna předmětu, označení důležitosti zprávy a další. Aktualizaci těchto vlastností v PST souboru lze provést pomocí FolderInfo.change_messages metoda poskytovaná Aspose.Email for Python. Tento článek ukazuje proces hromadné aktualizace vlastností zpráv, umožňující automatické úpravy napříč více zprávami v PST souboru. Níže je ukázkový kód ilustrující, jak provést hromadné aktualizace různých vlastností zpráv.

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)

Upravit vlastní MAPI vlastnosti

Někdy může být potřeba identifikovat a označit položky, které byly v PST souboru zpracovány. API Aspose.Email nabízí řešení tohoto úkolu pomocí MapiProperty a MapiNamedProperty třídy. Tyto třídy umožňují označit zpracované položky přiřazením vlastních vlastností. Níže najdete metody, které jsou zvláště užitečné pro provedení tohoto označovacího procesu:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - mění všechny zprávy ve složce
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - mění vlastnosti zprávy

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

Odstraňovat zprávy a složky z Outlook PST souborů

Správa obsahu Outlook PST souborů často zahrnuje odstraňování nepotřebných zpráv, složek nebo více položek najednou. Aspose.Email for Python via .NET poskytuje efektivní metody pro mazání zpráv a složek ze souboru PST, ať už potřebujete odstranit jednotlivé e‑maily, FolderInfo.delete_child_item() metoda, nebo provést hromadná mazání, FolderInfo.delete_child_items() metoda pro lepší správu souborů.

Odstraňovat zprávy ze souborů PST

Aspose.Email poskytuje FolderInfo třída pro přístup ke konkrétním složkám v souboru PST. Níže uvedený ukázkový kód demonstruje, jak použít tuto třídu k přístupu a mazání zpráv z podsložky Sent v dříve načteném nebo vytvořeném PST souboru. Konkrétně získá počet zpráv a odstraní první položku ve složce „Sent Items“.

Objekt PST je inicializován otevřením souboru "Outlook.pst" nacházejícího se ve specifikovaném adresáři pomocí PersonalStorage.from_file().
Složka Sent Items je přístupná pomocí pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Poté kód načte obsah složky „Sent Items“ pomocí folder.get_contents(), spočítá je a vypíše celkový počet zpráv v této složce.
Kód získá první zprávu ve složce „Sent Items“ pomocí msgsColl[0] a odstraní ji pomocí folder.delete_child_item(msgInfo.entry_id). Tato funkce používá Entry ID zprávy k jejímu odstranění ze složky.

Po smazání kód znovu spočítá zprávy ve složce „Sent Items“ a vypíše aktualizovaný počet.

Mazání položek ze souborů PST

V mnoha komunikačních systémech nebo e‑mailových klientech je každé položce (např. e‑mail, schůzka nebo úkol) přiřazen jedinečný identifikátor nazývaný Entry ID. delete_item(entry_id) metoda třídy FolderInfo třída přijímá tento Entry ID jako parametr a odstraňuje odpovídající položku z úložiště zpráv. Použijte následující kód k odstranění položky z úložiště zpráv:

import aspose.email as ae

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

pst.delete_item(entry_id)

Hromadně mazat položky

API Aspose.Email lze použít k hromadnému mazání položek ze souboru PST. To je realizováno pomocí delete_child_items() metoda, která přijímá seznam položek Entry ID odkazujících na položky k odstranění. Následující ukázka kódu ukazuje, jak hromadně mazat položky v PST souboru.

Smazat složky z PST souborů

Soubory Outlook PST mohou obsahovat složky, které již nejsou potřeba. Aspose.Email for Python via .NET vám umožní tyto složky smazat buď přesunutím do koše (umožňuje obnovení) nebo jejich trvalým odstraněním. Následující příklady demonstrují oba přístupy.

Přesunout složku do koše (měkké smazání)

The move_item metoda třídy PersonalStorage třída umožňuje složky později obnovit, protože nejsou trvale odstraněny, ale přesunuty do koše. Následující ukázka kódu ukazuje, jak implementovat tuto metodu do python projektu:

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)

Výhodou této metody je, že smazaná složka může být snadno obnovena.

Obnovit složku z koše

The move_item metoda umožňuje obnovit složku, pokud byla omylem smazána, přesunutím zpět z koše na její původní místo.

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

Trvale smazat složku z koše

The delete_child_item metoda může být použita pro libovolné složky, pokud chcete okamžitě a trvale odstranit podsložku, obejít koš. Následující ukázkový kód ukazuje, jak složku úplně odstranit z koše, čímž se zamezí obnově:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Okamžitě trvale smazat složku

Pokud má být složka smazána bez přesunu do koše, delete_child_item metoda zajišťuje okamžité a trvalé odstranění.

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

Správa úkolů Outlook MAPI v souborech PST Správa ochrany heslem PST souboru