Arbeta med meddelanden i en PST‑fil

Lägg till meddelanden i Outlook‑PST‑filer

Lägg till ett enskilt meddelande i en PST‑fil

Skapa en ny PST‑fil och lägg till undermappar visar hur du skapar en PST‑fil och lägger till en undermapp i den. Med Aspose.Email kan du också lägga till meddelanden i undermappar i en PST‑fil som du har skapat eller laddat. Kodexemplet nedan visar hur du skapar en ny PST‑fil, lägger till en "Inbox"‑mapp och sedan lägger till ett meddelande i den mappen. PersonalStorage och FolderInfo klasser används för att utföra uppgiften.

Använd PersonalStorage.create metod för att initiera en ny PST‑fil genom att ange filsökvägen och filformatversionen som Unicode.
Skapa en ny mapp med namnet "Inbox" i rotkatalogen i PST‑filen.
Lägg till ett meddelande i den nyss skapade "Inbox"‑mappen med hjälp av add_message metod.
Läs in meddelandet med hjälp av 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()

Lägg till flera meddelanden i PST‑filer för bättre prestanda

Att lägga till enskilda meddelanden i en PST innebär fler I/O‑operationer till disk och kan därför sakta ner prestandan. För att förbättra prestandan kan meddelanden läggas till i PST i bulk‑läge, vilket minskar I/O‑operationerna.

Läs in och lägg till meddelanden från disk

Den add_messages metod låter dig definiera ett intervall av meddelanden som ska läggas till i en PST‑fil. Kodexemplet nedan visar hur man lägger till flera meddelanden från disk till en PST‑fil för förbättrad prestanda:

Definiera en funktion genom att skapa add_messages_in_bulk_mode med parametrar för PST‑filnamnet och mappen med meddelanden.
Öppna den specificerade PST‑filen med PersonalStorage.from_file().
Hämta undermappen "myInbox" från PST‑rotmappen.
Lägg till meddelanden från den specificerade mappen i bulk med hjälp av folder.add_messages().
Anropa add_messages_in_bulk_mode() med PST‑filen och mappnamnet som argument.

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

Använd `MapiMessageEnumerator` för massoperationer**

För att effektivisera massbearbetning av meddelanden kan du implementera MapiMessageEnumerator klass som effektivt itererar genom meddelanden lagrade i en specificerad mapp. Följande Python‑script erbjuder ett strukturerat tillvägagångssätt för att enumerera och iterera över MAPI‑meddelanden med Aspose.Email‑biblioteket. Det definierar två hjälparklasser:

MapiMessageEnumerator för att läsa meddelanden från en katalog,
och MapiMessageCollection för att hantera dem under batch‑operationer.

Detta tillvägagångssätt underlättar traversering och hantering av MAPI‑meddelandefiler.

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

Lägg till meddelanden från en annan PST

För att importera meddelanden från en PST‑fil till en annan tillhandahåller Aspose.Email FolderInfo.enumerate_mapi_messages() metod. Följande kodexempel visar hur man kopierar meddelanden från en "Inbox"‑mapp i en PST‑fil till en annan PST‑fil:

Hämta meddelanden från Outlook‑PST‑filer

I Läs Outlook PST-filer, hämta information om mappar och undermappar, vi diskuterade att läsa in en Outlook‑PST‑fil och bläddra i dess mappar för att få mappnamnen och antalet meddelanden i dem. Denna artikel förklarar hur du får åtkomst till och extraherar meddelanden från Outlook‑PST‑filer: hämta grundläggande meddelandedetaljer, räkna antalet objekt i en mapp och extrahera ett specifikt antal meddelanden för bearbetning eller analys.

Hämta grundläggande meddelandeinformation

Kodexemplet nedan visar hur man extraherar och visar nyckelinformation från MAPI‑meddelanden lagrade i en PST‑fil med Aspose.Email‑biblioteket. Det initierar en PersonalStorage objekt från en "Outlook.pst"‑fil, hämtar innehållet i rotmappen och itererar genom varje meddelande. Skriptet skriver ut detaljer som ämne, avsändarinformation, mottagaradresser, leveranstid och meddelandetext, vilket ger en omfattande översikt över varje e‑post i den specificerade PST‑filen.

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)

Rekursiv läsning av nästlade mappar

En Outlook‑PST‑fil kan innehålla nästlade mappar. För att få meddelandeinformation från dessa, samt från toppnivåmapparna, använd en rekursiv metod för att läsa alla mappar. Följande kodsnutt visar hur du läser en Outlook‑PST‑fil och visar mapp- och meddelandeinnehållet rekursivt:

Hämta det totala antalet objekt i en PST-mapp

För att hämta det totala antalet objekt (såsom e‑post, möten, uppgifter, kontakter etc.) som finns i meddelandelagret, använd get_total_items_count()‑metoden i MessageStore klass. Den ger ett bekvämt sätt att snabbt samla information om storlek och volym av data i lagret. Följande kodsnutt visar hur man får det totala antalet objekt från en PST‑fil:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Extrahera ett specifikt antal meddelanden

För att extrahera ett specificerat antal meddelanden från en PST‑fil, använd get_contents(start_index, count)‑metoden i FolderInfo klass. Den tar två parametrar:

start_index – numret på det första meddelandet, t.ex. det 10:e;
count – totalt antal meddelanden att hämta.

Att hämta endast den nödvändiga delmängden av meddelanden åt gången kan vara användbart för att hantera stora mängder e‑postdata. Följande kodexempel demonstrerar implementeringen av denna 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)

Arbeta med bilagor i PST‑filer

Extrahera bilagor utan att extrahera hela meddelanden

Aspose.Email för Python möjliggör extrahering av bilagor från PST‑meddelanden utan att först behöva extrahera hela meddelandet. Detta kan göras med hjälp av extract_attachments metod för PersonalStorage klass. Följande kodsnutt visar hur man extraherar bilagor samtidigt som .msg‑filer hoppas över:

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)

Lägg till filer som bilagor i PST‑meddelanden

Microsoft Outlook är ett kraftfullt verktyg för att hantera e‑post, kalendrar, uppgifter, kontakter och journalanteckningar. Utöver dessa grundfunktioner tillåter det också att lägga till filer i PST‑mappar, så att användare kan behålla en omfattande version av relaterade dokument. Aspose.Email förenklar processen att lägga till filer i en PST‑mapp, och fungerar på samma sätt som det hanterar meddelanden, kontakter, uppgifter och journalanteckningar.

Följande kodsnutt visar hur man lägger till ett dokument i en PST‑mapp med 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", "")

Sök och filtrera meddelanden i PST‑filer

Personal Storage (PST)-filer kan innehålla en stor mängd data, och det kräver flera filtreringssteg för att hitta data som matchar specifika kriterier. Med PersonalStorageQueryBuilder klass, Aspose.Email möjliggör att söka efter specifika poster i en PST baserat på definierade sökkriterier. Du kan söka efter meddelanden med parametrar som avsändare, mottagare, ämne, meddelandevikt, förekomst av bilagor, meddelandestorlek och till och med meddelande‑ID. Dessutom, PersonalStorageQueryBuilder kan användas för att söka i undermappar. Följande avsnitt ger en omfattande guide för att söka i Outlook‑PST‑filer.

Sök Outlook‑meddelanden och -mappar

Följande kodsnutt visar hur du använder PersonalStorageQueryBuilder klass för att söka innehåll i en PST baserat på olika sökkriterier. Den demonstrerar särskilt hur man söker i en PST baserat på:

Meddelandebetydelse.
Meddelandeklass.
Närvaro av bilagor.
Meddelandestorlek.
Olästa meddelanden.
Olästa meddelanden med bilagor och mappar med specifikt undermappnamn.

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)

Sökning utan versalkänslighet

Genom att använda Aspose.Email PersonalStorageQueryBuilder, kan du ange sökvillkor för e‑postmeddelanden samtidigt som du ignorerar versalkänslighet, vilket möjliggör en mer flexibel och användarvänlig sökupplevelse. Följande kodexempel visar hur du läser in en PST‑fil, får åtkomst till "Inbox"‑mappen och tillämpar versalkänsliga sökfilter för att hitta e‑post baserat på avsändarinformation. Denna funktion är särskilt användbar när man hanterar varierande stora och små bokstäver i e‑postdata.

Sök i ämnesrader med flera nyckelord

Hämta specifika meddelanden eller objekt från en personlig lagringsfil (PST) eller meddelandelager genom att implementera either(query1, query2) metod för PersonalStorageQueryBuilder klass. Den tar två parametrar som låter dig kombinera två olika frågor, query1 och query2, och hitta ett meddelandeämne som matchar något av de två angivna orden. Se kodexemplet nedan:

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

Filtrera e‑post i PST efter specifika kriterier

Hämta endast meddelanden som matchar ett specifikt filter, såsom ämne, avsändare eller datum, med hjälp av MailQuery klass. Följande kodexempel visar hur du använder Aspose.Email‑biblioteket för att ladda en PST‑fil och filtrera meddelanden i en specifik mapp, i detta fall mappen "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)

Hämta meddelanden efter typ

Aspose.Email MessageKind överladdning tillåter dig att hämta meddelanden av en specifik typ, såsom endast e‑post, möten eller kontakter. Följande kodexempel visar hur du får åtkomst till och filtrerar specifika typer av meddelanden från en angiven mapp:

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)

Paginera meddelandehämtning för stora PST-filer

När du arbetar med mappar som innehåller ett stort antal meddelanden kan du använda paginering för att ladda meddelanden i delar med hjälp av start_index och count parametrar. Följande kodexempel visar hur man får åtkomst till och hämtar ett specifikt intervall av e‑postmeddelanden från en PST‑fil snarare än alla på en gång:

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)

Uppdatera och organisera Outlook PST-innehåll

Flytta meddelanden mellan mappar

Aspose.Email möjliggör att flytta objekt från en källmapp till en annan mapp i samma Personal Storage (PST)-fil. Detta inkluderar:

Flyttar en specificerad mapp till en ny föräldramapp.
Flyttar specificerade meddelanden till en ny mapp.
Flyttar innehållet till en ny mapp.
Flyttar undermappar till en ny föräldramapp.

Följande kodsnutt visar hur du flyttar objekt som meddelanden och mappar från en källmapp till en annan mapp i samma PST-fil.

Uppdatera meddelandeegenskaper

Ibland krävs det att ändra vissa egenskaper hos meddelanden, såsom att ändra ämnet, markera meddelandeviktighet med mera. Uppdatering av dessa egenskaper i en PST‑fil kan göras genom att använda FolderInfo.change_messages metod som tillhandahålls av Aspose.Email för Python. Denna artikel visar processen för massuppdatering av meddelandeegenskaper, vilket möjliggör automatiska justeringar över flera meddelanden i en PST‑fil. Nedan finns ett kodexempel som illustrerar hur man utför massuppdateringar på olika meddelandeegenskaper.

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)

Ändra anpassade MAPI‑egenskaper

Ibland kan du behöva identifiera och märka objekt som har bearbetats i en PST‑fil. Aspose.Email‑API:t erbjuder en lösning för detta genom att använda MapiProperty och MapiNamedProperty klasser. Dessa klasser möjliggör att du märker bearbetade objekt genom att tilldela anpassade egenskaper till dem. Nedan finner du metoder som är särskilt användbara för att utföra detta märkningsförfarande:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - ändrar alla meddelanden i en mapp
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - ändrar meddelandeegenskaper

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

Ta bort meddelanden och mappar från Outlook PST‑filer

Att hantera innehållet i Outlook PST‑filer innebär ofta att man tar bort onödiga meddelanden, mappar eller flera objekt samtidigt. Aspose.Email för Python via .NET tillhandahåller effektiva metoder för att ta bort meddelanden och mappar från en PST‑fil, oavsett om du behöver ta bort enskilda e‑postmeddelanden, FolderInfo.delete_child_item() metod, eller utföra massborttagningar, FolderInfo.delete_child_items() metod, för bättre filhantering.

Ta bort meddelanden från PST‑filer

Aspose.Email tillhandahåller FolderInfo klass för att komma åt specifika mappar i en PST‑fil. Kodexemplet nedan visar hur du använder denna klass för att komma åt och ta bort meddelanden från under-mappen Sent i en tidigare inläst eller skapad PST‑fil. Specifikt hämtas antalet meddelanden och det första objektet i mappen "Sent Items" tas bort.

Ett PST‑objekt initieras genom att öppna filen "Outlook.pst" i den angivna katalogen med hjälp av PersonalStorage.from_file().
Mappen Sent Items nås med hjälp av pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Sedan hämtar koden innehållet i mappen "Sent Items" med folder.get_contents(), räknar dem och skriver ut det totala antalet meddelanden i denna mapp.
Koden får åtkomst till det första meddelandet i mappen "Sent Items" med msgsColl[0] och tar bort det med hjälp av folder.delete_child_item(msgInfo.entry_id). Denna funktion använder meddelandets Entry ID för att ta bort det från mappen.

Efter borttagning räknar koden återigen meddelandena i mappen "Sent Items" och skriver ut det uppdaterade antalet.

Radera objekt från PST-filer

I många meddelandesystem eller e‑postklienter tilldelas varje objekt (såsom ett e‑postmeddelande, möte eller uppgift) en unik identifierare som kallas Entry ID. delete_item(entry_id) metod för FolderInfo klass tar detta Entry ID som en parameter och tar bort motsvarande objekt från meddelandelagret. Använd följande kod för att ta bort ett objekt från meddelandelagret:

import aspose.email as ae

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

pst.delete_item(entry_id)

Ta bort objekt i bulk

Aspose.Email API kan användas för att radera objekt i bulk från en PST-fil. Detta uppnås med hjälp av delete_child_items() metod som accepterar en lista med Entry ID‑objekt som hänvisar till de objekt som ska tas bort. Följande kodexempel visar hur du tar bort objekt i bulk från en PST‑fil.

Ta bort mappar från PST‑filer

Outlook PST‑filer kan innehålla mappar som inte längre behövs. Aspose.Email för Python via .NET låter dig ta bort dessa mappar antingen genom att flytta dem till Deleted Items‑mappen (vilket gör dem återställningsbara) eller genom att ta bort dem permanent. Följande exempel demonstrerar båda tillvägagångssätten.

Flytta en mapp till Deleted Items (mjuk radering)

Den move_item metod för PersonalStorage klass möjliggör att mappar kan återställas senare, eftersom de inte tas bort permanent utan flyttas till Deleted Items‑mappen. Följande kodexempel visar hur du implementerar denna metod i ett Python‑projekt:

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)

Fördelen med denna metod är att den raderade mappen enkelt kan återställas.

Återställ en mapp från Deleted Items

Den move_item metod låter dig återställa en mapp, om den felaktigt har raderats, genom att flytta tillbaka den från Deleted Items till dess ursprungliga plats.

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

Ta bort en mapp permanent från Deleted Items

Den delete_child_item metod kan användas för alla mappar om du vill ta bort en undermapp omedelbart och permanent, utan att gå via Deleted Items‑mappen. Följande kodexempel visar hur du tar bort mappen helt från Deleted Items, vilket gör återställning omöjlig:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Ta bort en mapp permanent omedelbart

Om en mapp ska tas bort utan att flyttas till Deleted Items, så är delete_child_item metod säkerställer omedelbar och permanent borttagning.

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

Läsa korrupta PST/OST-filer Hantera lösenordsskydd för PST-filer