Trabalhando com mensagens em um arquivo PST

Adicionar mensagens a arquivos PST do Outlook

Adicionar uma única mensagem a um arquivo PST

Criar um Novo Arquivo PST e Adicionar Subpastas mostra como criar um arquivo PST e adicionar uma subpasta a ele. Com Aspose.Email você também pode adicionar mensagens a subpastas de um PST que você criou ou carregou. O exemplo de código abaixo demonstra como criar um novo PST, adicionar uma pasta "Inbox" e então adicionar uma mensagem a essa pasta. O PersonalStorage e o FolderInfo classes são usadas para executar a tarefa.

Use o PersonalStorage.create método para iniciar um novo arquivo PST especificando o caminho do arquivo e a versão do formato como Unicode.
Crie uma nova pasta chamada "Inbox" no diretório raiz do arquivo PST.
Adicione uma mensagem à pasta "Inbox" recém‑criada usando o add_message método.
Carregue a mensagem 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()

Adicionar múltiplas mensagens a arquivos PST para melhor desempenho

Adicionar mensagens individuais a um PST implica mais operações de I/O ao disco e, portanto, pode desacelerar o desempenho. Para melhorar o desempenho, as mensagens podem ser adicionadas ao PST em modo de lote, minimizando as operações de I/O.

Carregar e adicionar mensagens do disco

O add_messages método permite definir um intervalo de mensagens a ser adicionado a um arquivo PST. O exemplo de código abaixo demonstra como adicionar múltiplas mensagens do disco a um arquivo PST para melhorar o desempenho:

Defina uma função criando add_messages_in_bulk_mode com parâmetros para o nome do arquivo PST e a pasta com mensagens.
Abra o arquivo PST especificado usando PersonalStorage.from_file().
Recupere a subpasta "myInbox" da pasta raiz do PST.
Adicione mensagens da pasta especificada em lote usando folder.add_messages().
Chame add_messages_in_bulk_mode() com o arquivo PST e o nome da pasta como argumentos.

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

Usar `MapiMessageEnumerator` para Operações em Lote

Para simplificar o processamento em lote de mensagens, você pode implementar o MapiMessageEnumerator classe que itera eficientemente através de mensagens armazenadas em uma pasta especificada. O script Python a seguir fornece uma abordagem estruturada para enumerar e iterar mensagens MAPI usando a biblioteca Aspose.Email. Ele define duas classes auxiliares:

MapiMessageEnumerator para ler mensagens de um diretório,
e MapiMessageCollection para gerenciá‑los durante operações em lote.

Esta abordagem facilita a travessia e manipulação de arquivos de mensagens 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

Adicionar Mensagens de Outro PST

Para importar mensagens de um PST para outro, Aspose.Email fornece o FolderInfo.enumerate_mapi_messages() método. O exemplo de código a seguir demonstra como copiar mensagens de uma pasta "Inbox" em um arquivo PST para outro arquivo PST:

Recuperar mensagens de arquivos PST do Outlook

Em Leia Arquivos PST do Outlook, Recupere Informações de Pastas e Subpastas, discutimos o carregamento de um arquivo PST do Outlook e a navegação em suas pastas para obter os nomes das pastas e o número de mensagens nelas. Este artigo explica como acessar e extrair mensagens de arquivos PST do Outlook: recuperar detalhes básicos da mensagem, contar o número de itens em uma pasta e extrair um número específico de mensagens para processamento ou análise.

Recuperar informações básicas da mensagem

O exemplo de código abaixo demonstra como extrair e exibir informações chave de mensagens MAPI armazenadas em um arquivo PST usando a biblioteca Aspose.Email. Ele inicializa um PersonalStorage objeto de um arquivo "Outlook.pst", recupera o conteúdo da pasta raiz e itera por cada mensagem. O script imprime detalhes como assunto, informações do remetente, endereços dos destinatários, horário de entrega e corpo da mensagem, fornecendo uma visão abrangente de cada e‑mail no arquivo PST especificado.

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)

Leitura recursiva de pastas aninhadas

Um arquivo PST do Outlook pode conter pastas aninhadas. Para obter informações de mensagem dessas pastas, bem como das pastas de nível superior, use um método recursivo para ler todas as pastas. O trecho de código a seguir mostra como ler um arquivo PST do Outlook e exibir recursivamente o conteúdo das pastas e mensagens:

Recuperar o Número Total de Itens em uma Pasta PST

Para recuperar o número total de itens (como e‑mails, compromissos, tarefas, contatos etc.) presentes no armazenamento de mensagens, use o método get_total_items_count() do MessageStore classe. Ela fornece uma forma conveniente de rapidamente obter informações sobre o tamanho e volume de dados dentro do armazenamento. O trecho de código a seguir mostra como obter o número total de itens de um arquivo PST:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Extrair um número específico de mensagens

Para extrair um número especificado de mensagens de um arquivo PST, use o método get_contents(start_index, count) do FolderInfo classe. Ela aceita dois parâmetros:

start_index - o número da mensagem inicial, por exemplo a décima;
count - número total de mensagens a serem recuperadas.

Recuperar apenas o subconjunto necessário de mensagens de cada vez pode ser útil para gerenciar grandes volumes de dados de e‑mail. O exemplo de código a seguir demonstra a implementação desse recurso:

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)

Trabalhar com anexos em arquivos PST

Extrair anexos sem extrair mensagens inteiras

Aspose.Email for Python permite extrair anexos de mensagens PST sem a necessidade de extrair primeiro a mensagem inteira. Isso pode ser feito usando o extract_attachments método do PersonalStorage classe. O trecho de código a seguir demonstra como extrair anexos ignorando arquivos .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)

Adicionar arquivos como anexos a mensagens PST

Microsoft Outlook é uma ferramenta poderosa para gerenciar e‑mails, calendários, tarefas, contatos e entradas de diário. Além dessas funcionalidades principais, ele também permite a adição de arquivos a pastas PST, permitindo que os usuários mantenham um registro completo dos documentos associados. Aspose.Email simplifica o processo de adicionar arquivos a uma pasta PST, funcionando de forma semelhante ao tratamento de mensagens, contatos, tarefas e entradas de diário.

O trecho de código a seguir ilustra como adicionar um documento a uma pasta PST com 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", "")

Pesquisar e filtrar mensagens em arquivos PST

Arquivos de Armazenamento Pessoal (PST) podem conter grande quantidade de dados, e requer a incorporação de múltiplas filtragens para encontrar dados que correspondam a critérios específicos. Com o PersonalStorageQueryBuilder classe, Aspose.Email permite pesquisar registros específicos em um PST com base em critérios de pesquisa definidos. Você pode buscar mensagens usando parâmetros como remetente, destinatário, assunto, importância da mensagem, presença de anexos, tamanho da mensagem e até ID da mensagem. Além disso, o PersonalStorageQueryBuilder pode ser usado para pesquisar dentro de subpastas. As seções a seguir fornecem um guia abrangente sobre como pesquisar arquivos PST do Outlook.

Pesquisar mensagens e pastas do Outlook

O trecho de código a seguir mostra como usar o PersonalStorageQueryBuilder classe para pesquisar conteúdo em um PST com base em diferentes critérios de pesquisa. Ela demonstra particularmente a busca em um PST baseada em:

Importância da mensagem.
Classe da mensagem.
Presença de anexos.
Tamanho da mensagem.
Mensagens não lidas.
Mensagens não lidas com anexos e pastas com nome de subpasta específico.

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)

Pesquisar com correspondência sem distinção de maiúsculas/minúsculas

Ao utilizar o Aspose.Email PersonalStorageQueryBuilder, você pode especificar condições de pesquisa para mensagens de e‑mail ignorando a diferenciação entre maiúsculas e minúsculas, proporcionando uma experiência de pesquisa mais flexível e amigável. O exemplo de código a seguir demonstra como carregar um arquivo PST, acessar a pasta "Inbox" e aplicar filtros de pesquisa sem distinção de maiúsculas/minúsculas para localizar e‑mails com base nas informações do remetente. Esse recurso é especialmente útil ao lidar com variações de capitalização nos dados de e‑mail.

Pesquisar Linhas de Assunto Usando Múltiplas Palavras‑chave

Recupere mensagens ou itens específicos de um arquivo de armazenamento pessoal (PST) ou repositório de mensagens implementando o either(query1, query2) método do PersonalStorageQueryBuilder classe. Recebe dois parâmetros que permitem combinar duas consultas diferentes, query1 e query2, e encontrar um assunto de mensagem que corresponda a uma das duas palavras especificadas. Veja o exemplo de código abaixo:

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

Filtrar Emails em PST por Critérios Específicos

Recupere apenas as mensagens que correspondem a um filtro específico, como assunto, remetente ou data, usando o MailQuery classe. O exemplo de código a seguir demonstra como usar a biblioteca Aspose.Email para carregar um arquivo PST e filtrar mensagens dentro de uma pasta específica, neste caso, a pasta "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)

Recuperar Mensagens por Tipo

O Aspose.Email MessageKind a sobrecarga permite obter mensagens de um tipo específico, como apenas emails, compromissos ou contatos. O exemplo de código a seguir demonstra como acessar e filtrar tipos específicos de mensagens de uma pasta designada:

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)

Paginar a Recuperação de Mensagens para Arquivos PST Grandes

Ao trabalhar com pastas que contêm um grande número de mensagens, você pode usar paginação para carregar mensagens em blocos usando o start_index e count parâmetros. O exemplo de código a seguir demonstra como acessar e recuperar um intervalo específico de mensagens de email de um arquivo PST, em vez de todas de uma vez:

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)

Atualizar e Organizar o Conteúdo do Outlook PST

Mover Mensagens entre Pastas

Aspose.Email torna possível mover itens de uma pasta de origem para outra pasta no mesmo arquivo de Armazenamento Pessoal (PST). Isso inclui:

Movendo uma pasta especificada para uma nova pasta pai.
Movendo mensagens especificadas para uma nova pasta.
Movendo o conteúdo para uma nova pasta.
Movendo subpastas para uma nova pasta pai.

O trecho de código a seguir mostra como mover itens, como mensagens e pastas, de uma pasta de origem para outra pasta no mesmo arquivo PST.

Atualizar Propriedades da Mensagem

Às vezes é necessário modificar certas propriedades das mensagens, como mudar o assunto, marcar a importância da mensagem e mais. Atualizar essas propriedades dentro de um arquivo PST pode ser feito usando o FolderInfo.change_messages método fornecido pela Aspose.Email para Python. Este artigo demonstra o processo de atualização em massa das propriedades de mensagens, permitindo ajustes automatizados em várias mensagens dentro de um arquivo PST. Abaixo há um trecho de código ilustrando como executar atualizações em massa em diversas propriedades de mensagens.

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)

Modificar Propriedades MAPI Personalizadas

Às vezes pode ser necessário identificar e marcar itens que foram processados dentro de um arquivo PST. A API Aspose.Email oferece uma solução para essa tarefa através do uso de MapiProperty e MapiNamedProperty classes. Essas classes permitem rotular itens processados atribuindo propriedades personalizadas a eles. A seguir, você encontrará métodos particularmente úteis para realizar esse processo de marcação:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - altera todas as mensagens em uma pasta
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - altera propriedades da mensagem

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

Excluir Mensagens e Pastas de Arquivos Outlook PST

Gerenciar o conteúdo de arquivos Outlook PST frequentemente envolve remover mensagens, pastas ou múltiplos itens desnecessários de uma só vez. Aspose.Email for Python via .NET fornece métodos eficientes para excluir mensagens e pastas de um arquivo PST, seja necessário remover emails individuais, FolderInfo.delete_child_item() método, ou executar exclusões em massa, FolderInfo.delete_child_items() método, para melhor gerenciamento de arquivos.

Excluir Mensagens de Arquivos PST

Aspose.Email fornece o FolderInfo classe para acessar pastas específicas em um arquivo PST. O exemplo de código abaixo demonstra como usar esta classe para acessar e excluir mensagens da subpasta Sent de um PST anteriormente carregado ou criado. Especificamente, ele recupera a contagem de mensagens e exclui o primeiro item na pasta "Sent Items".

Um objeto PST é inicializado ao abrir o arquivo "Outlook.pst" localizado no diretório especificado usando PersonalStorage.from_file().
A pasta Sent Items é acessada usando pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Em seguida, o código recupera o conteúdo da pasta "Sent Items" com folder.get_contents(), conta‑as e imprime o número total de mensagens nesta pasta.
O código acessa a primeira mensagem na pasta "Sent Items" com msgsColl[0] e a exclui usando folder.delete_child_item(msgInfo.entry_id). Esta função usa o ID de entrada da mensagem para removê‑la da pasta.

Após a exclusão, o código conta novamente as mensagens na pasta "Sent Items" e imprime a contagem atualizada.

Excluir Itens de Arquivos PST

Em muitos sistemas de mensagens ou clientes de email, cada item (como um email, compromisso ou tarefa) recebe um identificador único chamado entry ID. O delete_item(entry_id) método do FolderInfo classe aceita esse entry ID como parâmetro e remove o item correspondente do armazenamento de mensagens. Use o código a seguir para excluir um item do armazenamento de mensagens:

import aspose.email as ae

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

pst.delete_item(entry_id)

Excluir Itens em Massa

A API Aspose.Email pode ser usada para excluir itens em massa de um arquivo PST. Isso é conseguido usando o delete_child_items() método que aceita uma lista de itens Entry ID que se referem aos itens a serem excluídos. O trecho de código a seguir mostra como excluir itens em massa de um arquivo PST.

Excluir Pastas de Arquivos PST

Arquivos Outlook PST podem conter pastas que não são mais necessárias. Aspose.Email for Python via .NET permite excluir essas pastas movendo‑as para a pasta Itens Excluídos (tornando-as recuperáveis) ou removendo‑as permanentemente. Os exemplos a seguir demonstram ambas as abordagens.

Mover uma Pasta para Itens Excluídos (Exclusão Suave)

O move_item método do PersonalStorage classe permite que pastas sejam recuperadas posteriormente, pois não são removidas permanentemente, mas movidas para a pasta Itens Excluídos. O trecho de código a seguir mostra como implementar esse método em um projeto 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)

A vantagem deste método é que a pasta excluída pode ser facilmente recuperada.

Restaurar uma Pasta dos Itens Excluídos

O move_item método permite restaurar uma pasta, se ela foi excluída por engano, movendo‑a de volta dos Itens Excluídos para sua localização original.

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

Excluir Permanentemente uma Pasta dos Itens Excluídos

O delete_child_item método pode ser usado para qualquer pasta se você quiser excluir imediatamente e permanentemente uma subpasta, contornando a pasta Itens Excluídos. O exemplo de código a seguir mostra como remover a pasta completamente dos Itens Excluídos, tornando a recuperação impossível:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Excluir Permanentemente uma Pasta Imediatamente

Se uma pasta deve ser excluída sem movê‑la para Itens Excluídos, o delete_child_item método garante remoção imediata e permanente.

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

Trabalhando com MapiTask no PST Gerenciamento de Proteção por Senha de Arquivo PST