Lavorare con i messaggi in un file PST

Aggiungi messaggi ai file PST di Outlook

Aggiungi un singolo messaggio a un file PST

Crea un nuovo file PST e aggiungi sottocartelle mostra come creare un file PST e aggiungere una sottocartella. Con Aspose.Email è anche possibile aggiungere messaggi alle sottocartelle di un file PST che hai creato o caricato. Il seguente esempio di codice dimostra come creare un nuovo file PST, aggiungere una cartella "Inbox" e poi aggiungere un messaggio a quella cartella. Il PersonalStorage e il FolderInfo classi sono usate per eseguire l’operazione.

Usa il PersonalStorage.create metodo per avviare un nuovo file PST specificando il percorso file e la versione del formato file come Unicode.
Crea una nuova cartella chiamata "Inbox" nella directory radice del file PST.
Aggiungi un messaggio alla cartella "Inbox" appena creata usando il add_message metodo.
Carica il messaggio usando 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()

Aggiungi più messaggi ai file PST per migliori prestazioni

Aggiungere messaggi individuali a un PST implica più operazioni I/O su disco e quindi può rallentare le prestazioni. Per migliorare le prestazioni, i messaggi possono essere aggiunti al PST in modalità bulk, riducendo le operazioni I/O.

Carica e aggiungi messaggi dal disco

Il add_messages metodo ti consente di definire un intervallo di messaggi da aggiungere a un file PST. Il seguente esempio di codice dimostra come aggiungere più messaggi dal disco a un file PST per migliorare le prestazioni:

Definisci una funzione creando add_messages_in_bulk_mode con parametri per il nome file PST e la cartella con i messaggi.
Apri il file PST specificato usando PersonalStorage.from_file().
Recupera la sottocartella "myInbox" dalla cartella radice del PST.
Aggiungi messaggi dalla cartella specificata in blocco usando folder.add_messages().
Chiama add_messages_in_bulk_mode() con il file PST e il nome della cartella come argomenti.

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

Usa `MapiMessageEnumerator` per Operazioni di massa

Per semplificare l’elaborazione di messaggi in blocco, è possibile implementare il MapiMessageEnumerator classe che itera efficientemente attraverso i messaggi memorizzati in una cartella specificata. Il seguente script Python fornisce un approccio strutturato per enumerare e iterare i messaggi MAPI usando la libreria Aspose.Email. Definisce due classi di supporto:

MapiMessageEnumerator per leggere i messaggi da una directory,
e MapiMessageCollection per gestirli durante operazioni batch.

Questo approccio facilita l’attraversamento e la gestione dei file di messaggi 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

Aggiungere messaggi da un altro PST

Per importare messaggi da un file PST a un altro, Aspose.Email fornisce il FolderInfo.enumerate_mapi_messages() metodo. Il seguente esempio di codice dimostra come copiare i messaggi da una cartella "Inbox" in un file PST a un altro file PST:

Recupera messaggi dai file PST di Outlook

In Leggi i file PST di Outlook, recupera informazioni su cartelle e sottocartelle, abbiamo discusso il caricamento di un file PST di Outlook e la navigazione delle sue cartelle per ottenere i nomi delle cartelle e il numero di messaggi in esse. Questo articolo spiega come accedere ed estrarre messaggi dai file PST di Outlook: recuperare dettagli di base del messaggio, contare il numero di elementi in una cartella e estrarre un numero specifico di messaggi per l’elaborazione o l’analisi.

Recupera informazioni di base del messaggio

Il seguente esempio di codice dimostra come estrarre e visualizzare le informazioni chiave dai messaggi MAPI memorizzati in un file PST usando la libreria Aspose.Email. Inizializza un PersonalStorage oggetto da un file "Outlook.pst", recupera i contenuti della cartella radice e itera attraverso ogni messaggio. Lo script stampa dettagli come l’oggetto, le informazioni del mittente, gli indirizzi dei destinatari, l’ora di consegna e il corpo del messaggio, fornendo una panoramica completa di ogni email nel file PST specificato.

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)

Lettura ricorsiva di cartelle annidate

Un file PST di Outlook può contenere cartelle annidate. Per ottenere le informazioni dei messaggi da queste, così come dalle cartelle di livello superiore, utilizza un metodo ricorsivo per leggere tutte le cartelle. Il seguente frammento di codice mostra come leggere un file PST di Outlook e visualizzare ricorsivamente il contenuto di cartelle e messaggi:

Recuperare il numero totale di elementi in una cartella PST

Per recuperare il numero totale di elementi (come email, appuntamenti, attività, contatti, ecc.) presenti nello store dei messaggi, usa il metodo get_total_items_count() del MessageStore classe. Fornisce un modo comodo per raccogliere rapidamente informazioni sulla dimensione e il volume dei dati all’interno dello store. Il seguente frammento di codice mostra come ottenere il numero totale di elementi da un file PST:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Estrai un numero specifico di messaggi

Per estrarre un numero specificato di messaggi da un file PST, usa il metodo get_contents(start_index, count) del FolderInfo classe. Accetta due parametri:

start_index - il numero del messaggio di partenza, ad esempio il 10°;
count - numero totale di messaggi da recuperare.

Recuperare solo il sottoinsieme necessario di messaggi alla volta può essere utile per gestire grandi volumi di dati email. Il seguente esempio di codice dimostra l’implementazione di questa funzionalità:

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)

Lavora con gli allegati nei file PST

Estrai allegati senza estrarre interi messaggi

Aspose.Email per Python consente di estrarre gli allegati dai messaggi PST senza dover prima estrarre l’intero messaggio. Questo può essere fatto usando il extract_attachments metodo del PersonalStorage classe. Il seguente frammento di codice dimostra come estrarre gli allegati evitando i file .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)

Aggiungi file come allegati ai messaggi PST

Microsoft Outlook è uno strumento potente per gestire email, calendari, attività, contatti e voci di diario. Oltre a queste funzionalità di base, consente anche l’aggiunta di file alle cartelle PST, permettendo agli utenti di mantenere un registro completo dei documenti associati. Aspose.Email semplifica il processo di aggiunta di file a una cartella PST, funzionando in modo simile a come gestisce messaggi, contatti, attività e voci di diario.

Il seguente frammento di codice illustra come aggiungere un documento a una cartella PST con 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", "")

Cerca e filtra messaggi nei file PST

I file di Personal Storage (PST) possono contenere una grande quantità di dati e richiedono l’incorporazione di più filtri per trovare dati che corrispondono a criteri specifici. Con il PersonalStorageQueryBuilder classe, Aspose.Email consente di cercare record specifici in un PST basandosi su criteri di ricerca definiti. È possibile cercare messaggi usando parametri come mittente, destinatario, oggetto, importanza del messaggio, presenza di allegati, dimensione del messaggio e persino ID del messaggio. Inoltre, il PersonalStorageQueryBuilder può essere usato per la ricerca all’interno delle sottocartelle. Le sezioni seguenti forniscono una guida completa sulla ricerca nei file PST di Outlook.

Cerca messaggi e cartelle di Outlook

Il seguente frammento di codice mostra come utilizzare il PersonalStorageQueryBuilder classe per cercare contenuti in un PST basandosi su diversi criteri di ricerca. Dimostra in particolare la ricerca in un PST basata su:

Importanza del messaggio.
Classe del messaggio.
Presenza di allegati.
Dimensione del messaggio.
Messaggi non letti.
Messaggi non letti con allegati e cartelle con nome specifico della sottocartella.

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)

Ricerca con corrispondenza non case-sensitive

Utilizzando Aspose.Email PersonalStorageQueryBuilder, è possibile specificare condizioni di ricerca per i messaggi email ignorando la differenza tra maiuscole e minuscole, consentendo un’esperienza di ricerca più flessibile e user-friendly. Il seguente esempio di codice dimostra come caricare un file PST, accedere alla cartella "Inbox" e applicare filtri di ricerca case-insensitive per trovare email in base alle informazioni del mittente. Questa funzionalità è particolarmente utile quando si affrontano variazioni di capitalizzazione nei dati email.

Cercare le righe dell’oggetto usando più parole chiave

Recuperare messaggi o elementi specifici da un file di archiviazione personale (PST) o da un archivio messaggi implementando il either(query1, query2) metodo del PersonalStorageQueryBuilder classe. Accetta due parametri che consentono di combinare due query diverse, query1 e query2, e trovare un oggetto del messaggio che corrisponda a una delle due parole specificate. Vedi l’esempio di codice sotto:

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

Filtrare le email in PST su criteri specifici

Recuperare solo i messaggi che corrispondono a un filtro specifico, come oggetto, mittente o data, utilizzando il MailQuery classe. Il seguente esempio di codice dimostra come utilizzare la libreria Aspose.Email per caricare un file PST e filtrare i messaggi all’interno di una cartella specifica, in questo caso, la cartella "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)

Recuperare i messaggi per tipo

Aspose.Email MessageKind l’overload consente di ottenere messaggi di un tipo specifico, come solo email, appuntamenti o contatti. Il seguente esempio di codice dimostra come accedere e filtrare tipi specifici di messaggi da una cartella designata:

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)

Paginare il recupero dei messaggi per file PST di grandi dimensioni

Quando si lavora con cartelle contenenti un gran numero di messaggi, è possibile utilizzare la paginazione per caricare i messaggi a blocchi usando il start_index e count parametri. Il seguente esempio di codice dimostra come accedere e recuperare un intervallo specifico di messaggi email da un file PST piuttosto che tutti in una volta:

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)

Aggiornare e organizzare il contenuto del PST di Outlook

Spostare messaggi tra cartelle

Aspose.Email consente di spostare elementi da una cartella di origine a un’altra cartella nello stesso file di archiviazione personale (PST). Questo include:

Spostamento di una cartella specificata in una nuova cartella principale.
Spostamento di messaggi specifici in una nuova cartella.
Spostamento del contenuto in una nuova cartella.
Spostamento di sottocartelle in una nuova cartella principale.

Il seguente frammento di codice mostra come spostare elementi come messaggi e cartelle da una cartella di origine a un’altra cartella nello stesso file PST.

Aggiornare le proprietà del messaggio

Talvolta è necessario modificare certe proprietà dei messaggi, come cambiare l’oggetto, contrassegnare l’importanza del messaggio e altro. L’aggiornamento di queste proprietà all’interno di un file PST può essere effettuato usando il FolderInfo.change_messages metodo fornito da Aspose.Email per Python. Questo articolo mostra il processo di aggiornamento in blocco delle proprietà dei messaggi, consentendo aggiustamenti automatizzati su più messaggi all’interno di un file PST. Di seguito è presente un frammento di codice che illustra come eseguire aggiornamenti in blocco su varie proprietà dei messaggi.

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)

Modificare le proprietà MAPI personalizzate

A volte può essere necessario identificare e contrassegnare gli elementi che sono stati elaborati all’interno di un file PST. L’API Aspose.Email offre una soluzione per questo compito attraverso l’uso di MapiProperty e MapiNamedProperty classi. Queste classi consentono di etichettare gli elementi elaborati assegnando loro proprietà personalizzate. Di seguito troverete metodi particolarmente utili per realizzare questo processo di marcatura:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - cambia tutti i messaggi in una cartella
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - cambia le proprietà del messaggio

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

Eliminare messaggi e cartelle dai file PST di Outlook

Gestire il contenuto dei file PST di Outlook spesso comporta la rimozione di messaggi, cartelle o più elementi contemporaneamente. Aspose.Email per Python via .NET fornisce metodi efficienti per eliminare messaggi e cartelle da un file PST, sia che sia necessario rimuovere email individuali, FolderInfo.delete_child_item() metodo, o eseguire cancellazioni in blocco, FolderInfo.delete_child_items() metodo, per una migliore gestione dei file.

Eliminare i messaggi dai file PST

Aspose.Email fornisce il FolderInfo classe per accedere a cartelle specifiche in un file PST. Il seguente esempio di codice dimostra come utilizzare questa classe per accedere ed eliminare messaggi dalla sottocartella Sent di un file PST precedentemente caricato o creato. In particolare, recupera il conteggio dei messaggi ed elimina il primo elemento nella cartella "Sent Items".

Un oggetto PST è inizializzato aprendo il file "Outlook.pst" situato nella directory specificata utilizzando PersonalStorage.from_file().
La cartella Sent Items è accessibile utilizzando pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Successivamente, il codice recupera il contenuto della cartella "Sent Items" con folder.get_contents(), li conta e stampa il numero totale di messaggi in questa cartella.
Il codice accede al primo messaggio nella cartella "Sent Items" con msgsColl[0] e lo elimina utilizzando folder.delete_child_item(msgInfo.entry_id). Questa funzione utilizza l’ID di ingresso del messaggio per rimuoverlo dalla cartella.

Dopo l’eliminazione, il codice riconta i messaggi nella cartella "Sent Items" e stampa il conteggio aggiornato.

Elimina elementi da file PST

In molti sistemi di messaggistica o client di posta elettronica, ogni elemento (come un’email, un appuntamento o un’attività) è assegnato a un identificatore unico chiamato entry ID. Il delete_item(entry_id) metodo del FolderInfo classe prende questo entry ID come parametro e rimuove l’elemento corrispondente dall’archivio messaggi. Usa il codice seguente per eliminare un elemento dall’archivio messaggi:

import aspose.email as ae

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

pst.delete_item(entry_id)

Eliminare più elementi in blocco

L’API Aspose.Email può essere usata per eliminare elementi in blocco da un file PST. Questo è ottenuto usando il delete_child_items() metodo che accetta un elenco di elementi Entry ID riferiti agli elementi da eliminare. Il seguente frammento di codice mostra come eliminare elementi in blocco da un file PST.

Eliminare cartelle dai file PST

I file PST di Outlook possono contenere cartelle non più necessarie. Aspose.Email per Python via .NET consente di eliminare queste cartelle sia spostandole nella cartella Deleted Items (rendendole recuperabili) sia rimuovendole definitivamente. I seguenti esempi mostrano entrambi gli approcci.

Spostare una cartella in Deleted Items (cancellazione soft)

Il move_item metodo del PersonalStorage classe consente di recuperare le cartelle in seguito, poiché non vengono rimosse definitivamente ma spostate nella cartella Deleted Items. Il seguente frammento di codice mostra come implementare questo metodo in un progetto 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)

Il vantaggio di questo metodo è che la cartella eliminata può essere facilmente recuperata.

Ripristinare una cartella da Deleted Items

Il move_item metodo consente di ripristinare una cartella, se è stata cancellata per errore, spostandola indietro da Deleted Items alla sua posizione originale.

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

Eliminare definitivamente una cartella da Deleted Items

Il delete_child_item metodo può essere usato per qualsiasi cartella se si desidera eliminare immediatamente e definitivamente una sottocartella, bypassando la cartella Deleted Items. Il seguente esempio di codice mostra come rimuovere completamente la cartella da Deleted Items, rendendo impossibile il recupero:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Eliminare definitivamente una cartella immediatamente

Se una cartella deve essere eliminata senza spostarla nella cartella Deleted Items, il delete_child_item metodo garantisce la rimozione immediata e permanente.

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

Lettura di file PST/OST corrotti Gestione della Protezione con Password dei File PST