Werken met berichten in een PST‑bestand

Berichten toevoegen aan Outlook‑PST‑bestanden

Voeg een enkel bericht toe aan een PST‑bestand

Maak een nieuw PST‑bestand en voeg submappen toe toont hoe je een PST‑bestand maakt en er een submap aan toevoegt. Met Aspose.Email kun je ook berichten toevoegen aan submappen van een PST‑bestand dat je hebt aangemaakt of geladen. Het onderstaande codevoorbeeld toont hoe je een nieuw PST‑bestand maakt, een "Inbox"‑map toevoegt, en vervolgens een bericht aan die map toevoegt. De PersonalStorage en de FolderInfo klassen worden gebruikt om de taak uit te voeren.

Gebruik de PersonalStorage.create methode om een nieuw PST‑bestand te starten waarbij het bestandspad en de bestandsformaatversie als Unicode worden opgegeven.
Maak een nieuwe map met de naam "Inbox" in de hoofdmap van het PST‑bestand.
Voeg een bericht toe aan de nieuw aangemaakte "Inbox"‑map met behulp van de add_message methode.
Laad het bericht met behulp van 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()

Voeg meerdere berichten toe aan PST‑bestanden voor betere prestaties

Het toevoegen van individuele berichten aan een PST betekent meer I/O‑operaties naar schijf en kan daardoor de prestaties vertragen. Om de prestaties te verbeteren, kunnen berichten in bulk‑modus aan een PST worden toegevoegd, waardoor I/O‑operaties worden geminimaliseerd.

Laden en toevoegen van berichten vanaf schijf

De add_messages methode stelt je in staat een bereik van berichten te definiëren die aan een PST‑bestand moeten worden toegevoegd. Het onderstaande codevoorbeeld toont hoe je meerdere berichten vanaf schijf aan een PST‑bestand toevoegt voor betere prestaties:

Definieer een functie door te maken add_messages_in_bulk_mode met parameters voor de PST‑bestandsnaam en de map met berichten.
Open het opgegeven PST‑bestand met behulp van PersonalStorage.from_file().
Haal submap "myInbox" op uit de PST‑hoofdmappen.
Voeg berichten in bulk toe vanuit de opgegeven map met behulp van folder.add_messages().
Roep add_messages_in_bulk_mode() met het PST‑bestand en de mapnaam als argumenten.

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

Gebruik `MapiMessageEnumerator` voor Bulk‑bewerkingen

Om bulk‑berichtverwerking te stroomlijnen, kun je de MapiMessageEnumerator klasse die efficiënt door berichten itereren die zijn opgeslagen in een opgegeven map. Het onderstaande Python‑script biedt een gestructureerde aanpak voor het enumereren en itereren over MAPI‑berichten met behulp van de Aspose.Email‑bibliotheek. Het definieert twee hulpprogramma‑klassen:

MapiMessageEnumerator voor het lezen van berichten uit een map,
en MapiMessageCollection voor het beheren ervan tijdens batch‑operaties.

Deze aanpak vergemakkelijkt het doorlopen en verwerken van MAPI‑berichtbestanden.

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

Berichten toevoegen uit een andere PST

Om berichten van het ene PST‑bestand naar het andere te importeren, biedt Aspose.Email de FolderInfo.enumerate_mapi_messages() methode. Het onderstaande codevoorbeeld toont hoe je berichten van een "Inbox"‑map in het ene PST‑bestand kopieert naar een ander PST‑bestand:

Berichten ophalen uit Outlook‑PST‑bestanden

In Outlook‑PST‑bestanden lezen, mappen en submap‑informatie ophalenWe bespraken het laden van een Outlook‑PST‑bestand en het doorbladeren van de mappen om de mapnamen en het aantal berichten erin te verkrijgen. Dit artikel legt uit hoe je berichten uit Outlook‑PST‑bestanden kunt openen en extraheren: basisberichtdetails ophalen, het aantal items in een map tellen en een specifiek aantal berichten extraheren voor verwerking of analyse.

Basisberichtinformatie ophalen

Het onderstaande codevoorbeeld toont hoe je belangrijke informatie uit MAPI‑berichten die in een PST‑bestand zijn opgeslagen, kunt extraheren en weergeven met behulp van de Aspose.Email‑bibliotheek. Het initialiseert een PersonalStorage object van een "Outlook.pst"‑bestand, haalt de inhoud van de root‑map op en itereren door elk bericht. Het script print details zoals onderwerp, afzenderinformatie, ontvangeradressen, aflevertijd en berichtinhoud, waardoor een uitgebreid overzicht van elke e‑mail in het opgegeven PST‑bestand ontstaat.

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)

Recursief lezen van geneste mappen

Een Outlook‑PST‑bestand kan geneste mappen bevatten. Om berichtinformatie uit deze mappen, evenals de bovenliggende mappen, te verkrijgen, gebruik een recursieve methode om alle mappen te lezen. Het onderstaande codefragment toont hoe je een Outlook‑PST‑bestand leest en de map- en berichtinhoud recursief weergeeft:

Haal het totale aantal items op in een PST-map

Om het totale aantal items (zoals e‑mails, afspraken, taken, contacten, enz.) in de berichtopslag op te halen, gebruik je de get_total_items_count()‑methode van de MessageStore klasse. Het biedt een handige manier om snel informatie te verzamelen over de grootte en het volume van data in de opslag. Het onderstaande codefragment toont hoe je het totale aantal items uit een PST‑bestand krijgt:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Een specifiek aantal berichten extraheren

Om een bepaald aantal berichten uit een PST‑bestand te extraheren, gebruik je de get_contents(start_index, count)‑methode van de FolderInfo klasse. Het neemt twee parameters:

start_index - het nummer van het startbericht, bijvoorbeeld het 10e;
count - totaal aantal berichten om op te halen.

Het ophalen van alleen de noodzakelijke subset berichten per keer kan nuttig zijn bij het beheren van grote hoeveelheden e‑maildata. Het onderstaande codevoorbeeld toont de implementatie van deze functie:

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)

Werken met bijlagen in PST‑bestanden

Bijlagen extraheren zonder volledige berichten te extraheren

Aspose.Email voor Python maakt het mogelijk om bijlagen uit PST‑berichten te extraheren zonder eerst het volledige bericht te extraheren. Dit kan worden gedaan met behulp van de extract_attachments methode van de PersonalStorage klasse. Het onderstaande codefragment toont hoe je bijlagen kunt extraheren terwijl .msg‑bestanden worden overgeslagen:

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)

Bestanden toevoegen als bijlagen aan PST‑berichten

Microsoft Outlook is een krachtig hulpmiddel voor het beheren van e‑mails, agenda’s, taken, contacten en journaalitems. Naast deze kernfunctionaliteiten maakt het ook het toevoegen van bestanden aan PST‑mappen mogelijk, zodat gebruikers een uitgebreid overzicht van bijbehorende documenten kunnen bijhouden. Aspose.Email vereenvoudigt het proces van het toevoegen van bestanden aan een PST‑map, en werkt op dezelfde manier als bij berichten, contacten, taken en journaalitems.

Het onderstaande codefragment illustreert hoe je een document toevoegt aan een PST‑map met 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", "")

Zoeken en filteren van berichten in PST‑bestanden

Personal Storage (PST)-bestanden kunnen een grote hoeveelheid data bevatten, en het vereist het toepassen van meerdere filters om data te vinden die overeenkomt met specifieke criteria. Met de PersonalStorageQueryBuilder klasse, Aspose.Email stelt je in staat om specifieke records in een PST te zoeken op basis van gedefinieerde zoekcriteria. Je kunt berichten zoeken met parameters zoals afzender, ontvanger, onderwerp, berichtprioriteit, aanwezigheid van bijlagen, berichtgrootte en zelfs bericht‑ID. Bovendien, de PersonalStorageQueryBuilder kan worden gebruikt voor zoeken binnen submappen. De volgende secties bieden een uitgebreide gids over het zoeken in Outlook‑PST‑bestanden.

Zoek Outlook‑berichten en -mappen

De volgende codefragment laat zien hoe je de PersonalStorageQueryBuilder klasse om inhoud in een PST te zoeken op basis van verschillende zoekcriteria. Het toont specifiek het zoeken in een PST op basis van:

Berichtbelang.
Berichtklasse.
Aanwezigheid van bijlagen.
Berichtgrootte.
Ongelezen berichten.
Ongelezen berichten met bijlagen, en mappen met een specifieke submapnaam.

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)

Zoeken met case‑ongevoelige overeenstemming

Door gebruik te maken van Aspose.Email PersonalStorageQueryBuilder, kun je zoekcriteria voor e‑mailberichten opgeven waarbij hoofdlettergevoeligheid wordt genegeerd, waardoor een meer flexibele en gebruiksvriendelijke zoekervaring ontstaat. Het onderstaande codevoorbeeld toont hoe je een PST‑bestand laadt, de "Inbox"‑map opent en case‑ongevoelige zoekfilters toepast om e‑mails te vinden op basis van afzenderinformatie. Deze functie is vooral handig bij variërende hoofdlettergebruik in e‑mailgegevens.

Zoek onderwerpregels met meerdere trefwoorden

Haal specifieke berichten of items op uit een persoonlijk opslagbestand (PST) of berichtopslag door de implementatie van de either(query1, query2) methode van de PersonalStorageQueryBuilder class. Het neemt twee parameters waarmee u twee verschillende queries, query1 en query2, kunt combineren, en een berichtonderwerp kunt vinden dat overeenkomt met een van de twee opgegeven woorden. Zie de codevoorbeeld hieronder:

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

Filter e-mails in PST op specifieke criteria

Haal alleen de berichten op die overeenkomen met een specifiek filter, zoals onderwerp, afzender of datum, met behulp van de MailQuery class. De volgende codevoorbeeld toont hoe u de Aspose.Email bibliotheek gebruikt om een PST-bestand te laden en berichten te filteren binnen een specifieke map, in dit geval de "Inbox" map:

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)

Haal berichten op op type

De Aspose.Email MessageKind overload stelt u in staat om berichten van een specifiek type op te halen, zoals alleen e-mails, afspraken of contacten. De volgende codevoorbeeld toont hoe u specifieke berichttypen kunt openen en filteren uit een aangewezen map:

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)

Pagineer berichtophaling voor grote PST-bestanden

Bij het werken met mappen die een groot aantal berichten bevatten, kunt u paginering gebruiken om berichten in delen te laden met behulp van de start_index en count parameters. De volgende codevoorbeeld toont hoe u een specifiek bereik van e-mailberichten uit een PST-bestand kunt openen en ophalen in plaats van alle berichten tegelijk:

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)

Werk Outlook PST-inhoud bij en organiseer deze

Berichten verplaatsen tussen mappen

Aspose.Email maakt het mogelijk om items van een bronmap naar een andere map in hetzelfde Personal Storage (PST)-bestand te verplaatsen. Dit omvat:

Een opgegeven map naar een nieuwe bovenliggende map verplaatsen.
Verplaatsen van opgegeven berichten naar een nieuwe map.
De inhoud verplaatsen naar een nieuwe map.
Submappen verplaatsen naar een nieuwe bovenliggende map.

De volgende codefragment toont hoe u items zoals berichten en mappen van een bronmap naar een andere map in hetzelfde PST‑bestand verplaatst.

Berichteigenschappen bijwerken

Soms is het nodig om bepaalde eigenschappen van berichten te wijzigen, zoals het onderwerp veranderen, de belangrijkheid markeren en meer. Het bijwerken van deze eigenschappen binnen een PST-bestand kan worden gedaan met behulp van de FolderInfo.change_messages methode geleverd door Aspose.Email voor Python. Dit artikel toont het proces van bulk-updates van berichteigenschappen, waardoor geautomatiseerde aanpassingen over meerdere berichten binnen een PST-bestand mogelijk zijn. Hieronder staat een codefragment dat illustreert hoe bulk-updates van diverse berichteigenschappen uit te voeren.

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)

Aangepaste MAPI-eigenschappen wijzigen

Soms moet u items identificeren en markeren die al zijn verwerkt binnen een PST-bestand. De Aspose.Email API biedt een oplossing voor deze taak via het gebruik van MapiProperty en MapiNamedProperty classes. Deze klassen stellen u in staat om verwerkte items te labelen door aangepaste eigenschappen toe te wijzen. Hieronder vindt u methoden die bijzonder nuttig zijn voor het uitvoeren van dit markeerproces:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - wijzigt alle berichten in een map
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - wijzigt berichteigenschappen

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

Verwijder berichten en mappen uit Outlook PST-bestanden

Het beheren van de inhoud van Outlook PST-bestanden omvat vaak het verwijderen van onnodige berichten, mappen of meerdere items tegelijk. Aspose.Email voor Python via .NET biedt efficiënte methoden om berichten en mappen uit een PST-bestand te verwijderen, of u nu individuele e-mails moet verwijderen, FolderInfo.delete_child_item() methode, of voer bulkverwijderingen uit, FolderInfo.delete_child_items() methode, voor beter bestandsbeheer.

Verwijder berichten uit PST-bestanden

Aspose.Email biedt de FolderInfo class om specifieke mappen in een PST-bestand te openen. De onderstaande codevoorbeeld toont hoe u deze class gebruikt om berichten te openen en te verwijderen uit de map Sent van een eerder geladen of aangemaakt PST-bestand. Specifiek haalt het het aantal berichten op en verwijdert het eerste item in de "Sent Items" map.

Een PST-object wordt geïnitialiseerd door het "Outlook.pst" bestand te openen dat zich bevindt in de opgegeven directory met behulp van PersonalStorage.from_file().
De Sent Items map wordt geopend met pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Vervolgens haalt de code de inhoud van de "Sent Items" map op met folder.get_contents(), telt ze en print het totale aantal berichten in deze map.
De code opent het eerste bericht in de "Sent Items" map met msgsColl[0] en verwijdert het met behulp van folder.delete_child_item(msgInfo.entry_id). Deze functie gebruikt de entry ID van het bericht om het uit de map te verwijderen.

Na verwijdering telt de code opnieuw de berichten in de "Sent Items" map en print het bijgewerkte aantal.

Items verwijderen uit PST‑bestanden

In veel berichtensystemen of e-mailclients krijgt elk item (zoals een e-mail, afspraak of taak) een unieke identifier genaamd entry ID. De delete_item(entry_id) methode van de FolderInfo class neemt deze entry ID als parameter en verwijdert het overeenkomstige item uit de berichtopslag. Gebruik de onderstaande code om een item uit de berichtopslag te verwijderen:

import aspose.email as ae

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

pst.delete_item(entry_id)

Items in bulk verwijderen

Aspose.Email‑API kan worden gebruikt om items in bulk uit een PST‑bestand te verwijderen. Dit wordt bereikt met de delete_child_items() methode die een lijst van Entry ID items accepteert die verwijzen naar de te verwijderen items. De volgende codefragment toont hoe u items in bulk uit een PST-bestand kunt verwijderen.

Mappen uit PST-bestanden verwijderen

Outlook PST-bestanden kunnen mappen bevatten die niet langer nodig zijn. Aspose.Email voor Python via .NET laat u deze mappen verwijderen door ze naar de Deleted Items map te verplaatsen (herstelbaar) of door ze permanent te verwijderen. De volgende voorbeelden tonen beide benaderingen.

Verplaats een map naar Deleted Items (zachte verwijdering)

De move_item methode van de PersonalStorage class maakt het mogelijk om mappen later te herstellen, omdat ze niet permanent worden verwijderd maar naar de Deleted Items map worden verplaatst. De onderstaande codefragment toont hoe deze methode in een python-project te implementeren:

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)

Het voordeel van deze methode is dat de verwijderde map gemakkelijk kan worden hersteld.

Herstel een map vanuit Deleted Items

De move_item methode stelt u in staat een map te herstellen, als deze per ongeluk is verwijderd, door deze terug te verplaatsen van Deleted Items naar de oorspronkelijke locatie.

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

Map permanent uit Deleted Items verwijderen

De delete_child_item methode kan worden gebruikt voor alle mappen als u een submap onmiddellijk en permanent wilt verwijderen, waarbij de Deleted Items map wordt overgeslagen. De onderstaande codevoorbeeld toont hoe u de map volledig uit Deleted Items verwijdert, waardoor herstel onmogelijk wordt:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Map permanent en onmiddellijk verwijderen

Als een map moet worden verwijderd zonder deze naar Deleted Items te verplaatsen, de delete_child_item methode zorgt voor directe en permanente verwijdering.

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

Werken met MapiTask in PST Beheer van wachtwoordbeveiliging van PST‑bestanden