Trabajar con mensajes en un archivo PST

Agregar mensajes a archivos PST de Outlook

Agregar un solo mensaje a un archivo PST

Crear un Nuevo Archivo PST y Agregar Subcarpetas muestra cómo crear un archivo PST y agregar una subcarpeta a él. Con Aspose.Email también puede agregar mensajes a subcarpetas de un archivo PST que haya creado o cargado. El siguiente ejemplo de código muestra cómo crear un nuevo archivo PST, agregar una carpeta "Inbox" y luego agregar un mensaje a esa carpeta. El PersonalStorage y el FolderInfo las clases se usan para realizar la tarea.

Utilice el PersonalStorage.create método para iniciar un nuevo archivo PST especificando la ruta del archivo y la versión del formato de archivo como Unicode.
Cree una nueva carpeta llamada "Inbox" en el directorio raíz del archivo PST.
Agregue un mensaje a la carpeta "Inbox" recién creada usando el add_message método.
Cargue el mensaje 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()

Agregar múltiples mensajes a archivos PST para mejor rendimiento

Agregar mensajes individuales a un PST implica más operaciones de E/S al disco y, por lo tanto, puede ralentizar el rendimiento. Para mejorar el rendimiento, los mensajes pueden agregarse al PST en modo masivo, minimizando las operaciones de E/S.

Cargar y agregar mensajes desde disco

El add_messages método le permite definir un rango de mensajes para ser agregados a un archivo PST. El siguiente ejemplo de código muestra cómo agregar múltiples mensajes del disco a un archivo PST para mejorar el rendimiento:

Defina una función creando add_messages_in_bulk_mode con parámetros para el nombre de archivo PST y la carpeta con mensajes.
Abra el archivo PST especificado usando PersonalStorage.from_file().
Recupere la subcarpeta "myInbox" de la carpeta raíz del PST.
Agregue mensajes de la carpeta especificada en bloque usando folder.add_messages().
Llame a add_messages_in_bulk_mode() con el archivo PST y el nombre de la carpeta 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 Operaciones Masivas**

Para optimizar el procesamiento masivo de mensajes, puede implementar el MapiMessageEnumerator clase que itera eficientemente a través de los mensajes almacenados en una carpeta especificada. El siguiente script de Python proporciona un enfoque estructurado para enumerar e iterar sobre mensajes MAPI usando la biblioteca Aspose.Email. Define dos clases auxiliares:

MapiMessageEnumerator para leer mensajes de un directorio,
y MapiMessageCollection para gestionarlos durante operaciones por lotes.

Este enfoque facilita el recorrido y manejo de archivos de mensajes 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

Añadir mensajes desde otro PST

Para importar mensajes de un archivo PST a otro, Aspose.Email proporciona el FolderInfo.enumerate_mapi_messages() método. El siguiente ejemplo de código demuestra cómo copiar mensajes de una carpeta "Inbox" en un archivo PST a otro archivo PST:

Recuperar mensajes de archivos PST de Outlook

En Leer archivos PST de Outlook, recuperar información de carpetas y subcarpetas, hablamos sobre cargar un archivo PST de Outlook y explorar sus carpetas para obtener los nombres de carpetas y el número de mensajes en ellas. Este artículo explica cómo acceder y extraer mensajes de archivos PST de Outlook: recuperar detalles básicos de mensajes, contar el número de elementos en una carpeta y extraer un número específico de mensajes para procesamiento o análisis.

Recuperar información básica del mensaje

El siguiente ejemplo de código muestra cómo extraer y mostrar información clave de los mensajes MAPI almacenados en un archivo PST usando la biblioteca Aspose.Email. Inicializa un PersonalStorage objeto de un archivo "Outlook.pst", recupera el contenido de la carpeta raíz y recorre cada mensaje. El script imprime detalles como el asunto, información del remitente, direcciones de los destinatarios, hora de entrega y cuerpo del mensaje, proporcionando una visión completa de cada correo electrónico en el archivo 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)

Lectura recursiva de carpetas anidadas

Un archivo PST de Outlook puede contener carpetas anidadas. Para obtener información de los mensajes de estas, así como de las carpetas de nivel superior, use un método recursivo para leer todas las carpetas. El siguiente fragmento de código muestra cómo leer un archivo PST de Outlook y mostrar recursivamente el contenido de carpetas y mensajes:

Recuperar el número total de elementos en una carpeta PST

Para obtener el número total de elementos (como correos, citas, tareas, contactos, etc.) presentes en el almacén de mensajes, use el método get_total_items_count() del MessageStore clase. Proporciona una forma práctica de recopilar rápidamente información sobre el tamaño y volumen de datos dentro del almacén. El siguiente fragmento de código muestra cómo obtener el número total de elementos de un archivo PST:

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Extraer un número específico de mensajes

Para extraer un número especificado de mensajes de un archivo PST, use el método get_contents(start_index, count) del FolderInfo clase. Toma dos parámetros:

start_index - el número del mensaje inicial, por ejemplo el décimo;
count - número total de mensajes a recuperar.

Recuperar solo el subconjunto necesario de mensajes a la vez puede ser útil para gestionar grandes volúmenes de datos de correo. El siguiente ejemplo de código muestra la implementación de esta función:

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)

Trabajar con adjuntos en archivos PST

Extraer adjuntos sin extraer mensajes completos

Aspose.Email para Python permite extraer adjuntos de mensajes PST sin necesidad de extraer primero el mensaje completo. Esto se puede hacer usando el extract_attachments método del PersonalStorage clase. El siguiente fragmento de código muestra cómo extraer adjuntos mientras se omiten los archivos .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)

Agregar archivos como adjuntos a mensajes PST

Microsoft Outlook es una herramienta poderosa para gestionar correos electrónicos, calendarios, tareas, contactos y entradas de diario. Más allá de estas funcionalidades principales, también permite agregar archivos a carpetas PST, lo que permite a los usuarios mantener un registro completo de los documentos asociados. Aspose.Email simplifica el proceso de agregar archivos a una carpeta PST, funcionando de manera similar a cómo maneja mensajes, contactos, tareas y entradas de diario.

El siguiente fragmento de código ilustra cómo agregar un documento a una carpeta 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", "")

Buscar y filtrar mensajes en archivos PST

Los archivos de almacenamiento personal (PST) pueden contener una gran cantidad de datos, y requiere incorporar múltiples filtrados para encontrar datos que coincidan con criterios específicos. Con el PersonalStorageQueryBuilder clase, Aspose.Email le permite buscar registros específicos en un PST basándose en criterios de búsqueda definidos. Puede buscar mensajes usando parámetros como remitente, destinatario, asunto, importancia del mensaje, presencia de adjuntos, tamaño del mensaje e incluso ID del mensaje. Además, el PersonalStorageQueryBuilder puede usarse para buscar dentro de subcarpetas. Las siguientes secciones proporcionan una guía completa sobre la búsqueda en archivos PST de Outlook.

Buscar mensajes y carpetas de Outlook

El siguiente fragmento de código muestra cómo usar el PersonalStorageQueryBuilder clase para buscar contenidos en un PST basándose en diferentes criterios de búsqueda. Demuestra particularmente la búsqueda en un PST basada en:

Importancia del mensaje.
Clase del mensaje.
Presencia de archivos adjuntos.
Tamaño del mensaje.
Mensajes no leídos.
Mensajes no leídos con archivos adjuntos, y carpetas con nombre de subcarpeta 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)

Búsqueda con coincidencia sin distinción de mayúsculas

Al utilizar Aspose.Email PersonalStorageQueryBuilder, puede especificar condiciones de búsqueda para mensajes de correo electrónico ignorando la sensibilidad a mayúsculas, lo que permite una experiencia de búsqueda más flexible y fácil de usar. El siguiente ejemplo de código demuestra cómo cargar un archivo PST, acceder a la carpeta "Inbox" y aplicar filtros de búsqueda sin distinción de mayúsculas para localizar correos basados en la información del remitente. Esta función es especialmente útil al tratar con variaciones de capitalización en los datos de correo.

Buscar líneas de asunto usando múltiples palabras clave

Recupera mensajes o elementos específicos de un archivo de almacenamiento personal (PST) o almacén de mensajes implementando el either(query1, query2) método del PersonalStorageQueryBuilder clase. Toma dos parámetros que permiten combinar dos consultas diferentes, query1 y query2, y encontrar un asunto de mensaje que coincida con cualquiera de las dos palabras especificadas. Ver el ejemplo de código a continuación:

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 correos electrónicos en PST según criterios específicos

Recupera solo los mensajes que coinciden con un filtro específico, como asunto, remitente o fecha, usando el MailQuery clase. El siguiente ejemplo de código muestra cómo usar la biblioteca Aspose.Email para cargar un archivo PST y filtrar mensajes dentro de una carpeta específica, en este caso, la carpeta "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 mensajes por tipo

El Aspose.Email MessageKind Sobrecarga permite obtener mensajes de un tipo específico, como solo correos electrónicos, citas o contactos. El siguiente ejemplo de código muestra cómo acceder y filtrar tipos específicos de mensajes de una carpeta 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)

Paginación de la recuperación de mensajes para archivos PST grandes

Al trabajar con carpetas que contienen una gran cantidad de mensajes, puedes usar paginación para cargar mensajes en fragmentos usando el start_index y count parámetros. El siguiente ejemplo de código muestra cómo acceder y recuperar un rango específico de mensajes de correo electrónico de un archivo PST en lugar de todos a la 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)

Actualizar y organizar el contenido PST de Outlook

Mover mensajes entre carpetas

Aspose.Email permite mover elementos desde una carpeta de origen a otra carpeta en el mismo archivo de Almacenamiento Personal (PST). Esto incluye:

Moviendo una carpeta especificada a una nueva carpeta padre.
Moviendo mensajes especificados a una nueva carpeta.
Moviendo el contenido a una nueva carpeta.
Moviendo subcarpetas a una nueva carpeta padre.

El siguiente fragmento de código le muestra cómo mover elementos como mensajes y carpetas desde una carpeta de origen a otra carpeta en el mismo archivo PST.

Actualizar propiedades de los mensajes

A veces es necesario modificar ciertas propiedades de los mensajes, como cambiar el asunto, marcar la importancia del mensaje y más. Actualizar estas propiedades dentro de un archivo PST se puede lograr usando el FolderInfo.change_messages método proporcionado por Aspose.Email para Python. Este artículo muestra el proceso de actualización masiva de propiedades de mensajes, permitiendo ajustes automatizados en varios mensajes dentro de un archivo PST. A continuación se muestra un fragmento de código que ilustra cómo realizar actualizaciones masivas en diversas propiedades de mensajes.

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 propiedades MAPI personalizadas

A veces puede ser necesario identificar y marcar elementos que han sido procesados dentro de un archivo PST. La API de Aspose.Email ofrece una solución para esta tarea mediante el uso de MapiProperty y MapiNamedProperty clases. Estas clases le permiten etiquetar elementos procesados asignándoles propiedades personalizadas. A continuación, encontrará métodos que son particularmente útiles para llevar a cabo este proceso de marcado:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - cambia todos los mensajes en una carpeta
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - cambia propiedades del mensaje

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

Eliminar mensajes y carpetas de archivos PST de Outlook

Administrar el contenido de los archivos PST de Outlook a menudo implica eliminar mensajes, carpetas o varios elementos a la vez. Aspose.Email para Python a través de .NET proporciona métodos eficientes para eliminar mensajes y carpetas de un archivo PST, ya sea que necesites eliminar correos electrónicos individuales, FolderInfo.delete_child_item() método, o realizar eliminaciones masivas, FolderInfo.delete_child_items() método, para una mejor gestión de archivos.

Eliminar mensajes de archivos PST

Aspose.Email proporciona el FolderInfo clase para acceder a carpetas específicas en un archivo PST. El siguiente ejemplo de código muestra cómo usar esta clase para acceder y eliminar mensajes de la subcarpeta Sent de archivos PST previamente cargados o creados. Específicamente, recupera el recuento de mensajes y elimina el primer elemento en la carpeta "Sent Items".

Se inicializa un objeto PST abriendo el archivo "Outlook.pst" ubicado en el directorio especificado usando PersonalStorage.from_file().
La carpeta Sent Items se accede usando pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Luego, el código recupera el contenido de la carpeta "Sent Items" con folder.get_contents(), los cuenta y muestra el número total de mensajes en esta carpeta.
El código accede al primer mensaje en la carpeta "Sent Items" con msgsColl[0] y lo elimina usando folder.delete_child_item(msgInfo.entry_id). Esta función usa el ID de entrada del mensaje para eliminarlo de la carpeta.

Después de la eliminación, el código vuelve a contar los mensajes en la carpeta "Sent Items" y muestra el recuento actualizado.

Eliminar elementos de archivos PST

En muchos sistemas de mensajería o clientes de correo, a cada elemento (como un correo electrónico, cita o tarea) se le asigna un identificador único llamado Entry ID. El delete_item(entry_id) método del FolderInfo clase toma este Entry ID como parámetro y elimina el elemento correspondiente del almacén de mensajes. Utiliza el siguiente código para eliminar un elemento del almacén de mensajes:

import aspose.email as ae

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

pst.delete_item(entry_id)

Eliminar elementos en bloque

La API de Aspose.Email puede usarse para eliminar elementos en bloque de un archivo PST. Esto se logra usando la delete_child_items() método que acepta una lista de elementos Entry ID que hacen referencia a los elementos a eliminar. El siguiente fragmento de código muestra cómo eliminar elementos en bloque de un archivo PST.

Eliminar carpetas de archivos PST

Los archivos PST de Outlook pueden contener carpetas que ya no son necesarias. Aspose.Email para Python a través de .NET permite eliminar estas carpetas ya sea moviéndolas a la carpeta Deleted Items (haciéndolas recuperables) o eliminándolas permanentemente. Los siguientes ejemplos demuestran ambos enfoques.

Mover una carpeta a Deleted Items (eliminación suave)

El move_item método del PersonalStorage clase permite que las carpetas se recuperen más tarde, ya que no se eliminan permanentemente sino que se mueven a la carpeta Deleted Items. El siguiente fragmento de código muestra cómo implementar este método en un proyecto 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)

La ventaja de este método es que la carpeta eliminada puede recuperarse fácilmente.

Restaurar una carpeta desde Deleted Items

El move_item método permite restaurar una carpeta, si fue eliminada por error, moviéndola de nuevo desde Deleted Items a su ubicación original.

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

Eliminar permanentemente una carpeta de Deleted Items

El delete_child_item método puede usarse para cualquier carpeta si deseas eliminar inmediata y permanentemente una subcarpeta, evitando la carpeta Deleted Items. El siguiente ejemplo de código muestra cómo eliminar la carpeta por completo de Deleted Items, haciendo imposible su recuperación:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Eliminar permanentemente una carpeta inmediatamente

Si una carpeta debe eliminarse sin moverla a Deleted Items, el delete_child_item método asegura la eliminación inmediata y permanente.

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

Trabajar con MapiTask en PST Gestión de la protección con contraseña de archivos PST