Travailler avec les messages dans un fichier PST

Ajouter des messages aux fichiers PST Outlook

Ajouter un seul message à un fichier PST

Créer un nouveau fichier PST et ajouter des sous‑dossiers montre comment créer un fichier PST et y ajouter un sous‑dossier. Avec Aspose.Email, vous pouvez également ajouter des messages aux sous‑dossiers d’un fichier PST que vous avez créé ou chargé. L’exemple de code ci‑dessous montre comment créer un nouveau fichier PST, ajouter un dossier "Inbox", puis ajouter un message à ce dossier. Le PersonalStorage et le FolderInfo les classes sont utilisées pour exécuter la tâche.

Utilisez le PersonalStorage.create méthode pour initier un nouveau fichier PST en spécifiant le chemin du fichier et la version du format du fichier en Unicode.
Créez un nouveau dossier nommé "Inbox" dans le répertoire racine du fichier PST.
Ajoutez un message au dossier "Inbox" nouvellement créé en utilisant le add_message méthode.
Chargez le message en utilisant 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()

Ajouter plusieurs messages aux fichiers PST pour de meilleures performances

Ajouter des messages individuels à un PST implique plus d’opérations d’E/S vers le disque et peut donc ralentir les performances. Pour améliorer les performances, les messages peuvent être ajoutés au PST en mode masse, réduisant ainsi les opérations d’E/S.

Charger et ajouter des messages depuis le disque

Le add_messages méthode vous permet de définir une plage de messages à ajouter à un fichier PST. L’exemple de code ci‑dessus montre comment ajouter plusieurs messages depuis le disque à un fichier PST pour améliorer les performances :

Définissez une fonction en créant add_messages_in_bulk_mode avec des paramètres pour le nom du fichier PST et le dossier contenant les messages.
Ouvrez le fichier PST spécifié en utilisant PersonalStorage.from_file().
Récupérez le sous‑dossier "myInbox" à partir du dossier racine du PST.
Ajoutez les messages du dossier spécifié en masse en utilisant folder.add_messages().
Appelez add_messages_in_bulk_mode() avec le fichier PST et le nom du dossier en tant qu’arguments.

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

Utiliser `MapiMessageEnumerator` pour les opérations en masse**

Pour simplifier le traitement en masse des messages, vous pouvez implémenter le MapiMessageEnumerator classe qui itère efficacement à travers les messages stockés dans un dossier spécifié. Le script Python suivant fournit une approche structurée pour énumérer et itérer les messages MAPI à l’aide de la bibliothèque Aspose.Email. Il définit deux classes d’aide :

MapiMessageEnumerator pour lire des messages depuis un répertoire,
et MapiMessageCollection pour les gérer lors d’opérations par lots.

Cette approche facilite le parcours et la gestion des fichiers de messages 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

Ajouter des messages depuis un autre PST

Pour importer des messages d’un PST à un autre, Aspose.Email fournit le FolderInfo.enumerate_mapi_messages() méthode. L’exemple de code suivant montre comment copier des messages d’un dossier "Inbox" d’un fichier PST vers un autre fichier PST :

Récupérer les messages depuis les fichiers PST Outlook

Dans Lire les fichiers PST Outlook, récupérer les informations des dossiers et sous‑dossiers, nous avons expliqué comment charger un fichier PST Outlook et parcourir ses dossiers afin d’obtenir les noms des dossiers et le nombre de messages qu’ils contiennent. Cet article explique comment accéder aux messages et les extraire des fichiers PST Outlook : récupérer les détails de base d’un message, compter le nombre d’éléments dans un dossier et extraire un nombre précis de messages pour le traitement ou l’analyse.

Récupérer les informations de base d’un message

L’exemple de code ci‑dessus montre comment extraire et afficher les informations clés des messages MAPI stockés dans un fichier PST à l’aide de la bibliothèque Aspose.Email. Il initialise un PersonalStorage objet extrait d’un fichier "Outlook.pst", récupère le contenu du dossier racine et itère à travers chaque message. Le script affiche des détails tels que le sujet, les informations de l’expéditeur, les adresses des destinataires, la date de livraison et le corps du message, offrant une vue d’ensemble complète de chaque e‑mail dans le fichier PST spécifié.

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)

Lecture récursive des dossiers imbriqués

Un fichier PST Outlook peut contenir des dossiers imbriqués. Pour obtenir les informations des messages à partir de ceux‑ci, ainsi que des dossiers de niveau supérieur, utilisez une méthode récursive pour lire tous les dossiers. Le fragment de code suivant montre comment lire un fichier PST Outlook et afficher le contenu des dossiers et des messages de façon récursive :

Récupérer le nombre total d’éléments dans un dossier PST

Pour récupérer le nombre total d’éléments (tels que e‑mails, rendez‑vous, tâches, contacts, etc.) présents dans le magasin de messages, utilisez la méthode get_total_items_count() de MessageStore classe. Elle fournit un moyen pratique d’obtenir rapidement des informations sur la taille et le volume de données dans le magasin. L’exemple de code suivant montre comment obtenir le nombre total d’éléments d’un fichier PST :

import aspose.email as ae

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

count = pst.store.get_total_items_count()

Extraire un nombre spécifique de messages

Pour extraire un nombre spécifié de messages d’un fichier PST, utilisez la méthode get_contents(start_index, count) de FolderInfo classe. Elle prend deux paramètres :

start_index - le numéro du message de départ, par exemple le 10e ;
count - nombre total de messages à récupérer.

Récupérer uniquement le sous‑ensemble nécessaire de messages à la fois peut être utile pour gérer de gros volumes de données d’e‑mail. L’exemple de code suivant montre la mise en œuvre de cette fonctionnalité :

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)

Travailler avec les pièces jointes dans les fichiers PST

Extraire les pièces jointes sans extraire les messages entiers

Aspose.Email for Python permet d’extraire les pièces jointes des messages PST sans avoir besoin d’extraire d’abord le message complet. Cela peut être fait en utilisant le extract_attachments méthode du PersonalStorage classe. Le fragment de code suivant montre comment extraire les pièces jointes tout en ignorant les fichiers .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)

Ajouter des fichiers en tant que pièces jointes aux messages PST

Microsoft Outlook est un outil puissant pour gérer les e‑mails, les calendriers, les tâches, les contacts et les entrées de journal. Au-delà de ces fonctionnalités de base, il permet également d’ajouter des fichiers aux dossiers PST, permettant aux utilisateurs de conserver un enregistrement complet des documents associés. Aspose.Email simplifie le processus d’ajout de fichiers à un dossier PST, fonctionnant de manière similaire à la gestion des messages, contacts, tâches et entrées de journal.

Le fragment de code suivant illustre comment ajouter un document à un dossier PST avec 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", "")

Rechercher et filtrer les messages dans les fichiers PST

Les fichiers de stockage personnel (PST) peuvent contenir une grande quantité de données, et il faut incorporer plusieurs filtres pour trouver les données correspondant à des critères spécifiques. Avec le PersonalStorageQueryBuilder classe, Aspose.Email vous permet de rechercher des enregistrements spécifiques dans un PST en fonction de critères de recherche définis. Vous pouvez rechercher des messages à l’aide de paramètres tels que l’expéditeur, le destinataire, le sujet, l’importance du message, la présence de pièces jointes, la taille du message et même l’ID du message. De plus, le PersonalStorageQueryBuilder peut être utilisé pour rechercher dans les sous‑dossiers. Les sections suivantes offrent un guide complet sur la recherche dans les fichiers PST Outlook.

Rechercher des messages et dossiers Outlook

L’extrait de code suivant montre comment utiliser le PersonalStorageQueryBuilder classe permettant de rechercher le contenu d’un PST en fonction de différents critères de recherche. Elle montre notamment la recherche dans un PST basée sur :

Importance du message.
Classe du message.
Présence de pièces jointes.
Taille du message.
Messages non lus.
Messages non lus avec pièces jointes, et dossiers avec un nom de sous‑dossier spécifique.

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)

Recherche avec correspondance insensible à la casse

En utilisant Aspose.Email PersonalStorageQueryBuilder, vous pouvez spécifier des conditions de recherche pour les e‑mails tout en ignorant la sensibilité à la casse, offrant ainsi une expérience de recherche plus flexible et conviviale. L’exemple de code suivant montre comment charger un fichier PST, accéder au dossier "Inbox" et appliquer des filtres de recherche insensibles à la casse pour localiser les e‑mails en fonction des informations de l’expéditeur. Cette fonctionnalité est particulièrement utile lorsqu’il faut gérer des variations de capitalisation dans les données d’e‑mail.

Rechercher les lignes d’objet en utilisant plusieurs mots‑clés

Récupérer des messages ou éléments spécifiques d’un fichier de stockage personnel (PST) ou d’un magasin de messages en implémentant le either(query1, query2) méthode du PersonalStorageQueryBuilder classe. Elle prend deux paramètres vous permettant de combiner deux requêtes différentes, query1 et query2, et de trouver un sujet de message correspondant à l’un des deux mots spécifiés. Voir l’exemple de code ci‑dessous :

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

Filtrer les e‑mails dans un PST selon des critères spécifiques

Récupérer uniquement les messages qui correspondent à un filtre spécifique, tel que le sujet, l’expéditeur ou la date, en utilisant le MailQuery classe. L’exemple de code ci‑dessous montre comment utiliser la bibliothèque Aspose.Email pour charger un fichier PST et filtrer les messages dans un dossier spécifique, dans ce cas le dossier "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)

Récupérer les messages par type

Le Aspose.Email MessageKind la surcharge vous permet d’obtenir des messages d’un type spécifique, comme uniquement les e‑mails, les rendez‑vous ou les contacts. L’exemple de code ci‑dessous montre comment accéder et filtrer des types spécifiques de messages à partir d’un dossier désigné :

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)

Paginer la récupération des messages pour les gros fichiers PST

Lors du travail avec des dossiers contenant un grand nombre de messages, vous pouvez utiliser la pagination pour charger les messages par lots en utilisant le start_index et count paramètres. L’exemple de code ci‑dessous montre comment accéder à et récupérer une plage spécifique de messages électroniques à partir d’un fichier PST plutôt que de tous les récupérer en même temps :

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)

Mettre à jour et organiser le contenu PST d’Outlook

Déplacer des messages entre dossiers

Aspose.Email permet de déplacer des éléments d’un dossier source vers un autre dossier dans le même fichier de stockage personnel (PST). Cela comprend :

Déplacement d’un dossier spécifié vers un nouveau dossier parent.
Déplacement de messages spécifiés vers un nouveau dossier.
Déplacement du contenu vers un nouveau dossier.
Déplacement des sous-dossiers vers un nouveau dossier parent.

L’extrait de code suivant montre comment déplacer des éléments tels que des messages et des dossiers d’un dossier source vers un autre dossier dans le même fichier PST.

Mettre à jour les propriétés du message

Il est parfois nécessaire de modifier certaines propriétés des messages, comme changer le sujet, marquer l’importance du message, etc. La mise à jour de ces propriétés dans un fichier PST peut être réalisée en utilisant le FolderInfo.change_messages méthode fournie par Aspose.Email pour Python. Cet article présente le processus de mise à jour en masse des propriétés des messages, permettant des ajustements automatisés sur plusieurs messages d’un fichier PST. Vous trouverez ci‑dessus un extrait de code illustrant comment effectuer des mises à jour en masse sur différentes propriétés de messages.

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)

Modifier les propriétés MAPI personnalisées

Il peut parfois être nécessaire d’identifier et marquer les éléments déjà traités dans un fichier PST. L’API Aspose.Email propose une solution pour cette tâche grâce à l’utilisation de MapiProperty et MapiNamedProperty classes. Ces classes vous permettent d’étiqueter les éléments traités en leur assignant des propriétés personnalisées. Vous trouverez ci‑dessous des méthodes particulièrement utiles pour réaliser ce processus de marquage :

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - modifie tous les messages d’un dossier
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - modifie les propriétés du message

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

Supprimer des messages et dossiers des fichiers PST Outlook

Gérer le contenu des fichiers PST d’Outlook implique souvent de supprimer des messages, dossiers ou plusieurs éléments inutiles d’un seul coup. Aspose.Email pour Python via .NET fournit des méthodes efficaces pour supprimer des messages et dossiers d’un fichier PST, que vous ayez besoin de retirer des e‑mails individuels, FolderInfo.delete_child_item() méthode, ou effectuer des suppressions en masse, FolderInfo.delete_child_items() méthode, pour une meilleure gestion des fichiers.

Supprimer des messages des fichiers PST

Aspose.Email fournit le FolderInfo classe pour accéder à des dossiers spécifiques dans un fichier PST. L’exemple de code ci‑dessous montre comment utiliser cette classe pour accéder et supprimer des messages du sous‑dossier Sent d’un PST préalablement chargé ou créé. Plus précisément, il récupère le nombre de messages et supprime le premier élément du dossier "Sent Items".

Un objet PST est initialisé en ouvrant le fichier "Outlook.pst" situé dans le répertoire spécifié en utilisant PersonalStorage.from_file().
Le dossier Sent Items est accédé en utilisant pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
Ensuite, le code récupère le contenu du dossier "Sent Items" avec folder.get_contents(), les compte, et affiche le nombre total de messages dans ce dossier.
Le code accède au premier message du dossier "Sent Items" avec msgsColl[0] et le supprime en utilisant folder.delete_child_item(msgInfo.entry_id). Cette fonction utilise l’ID d’entrée du message pour le supprimer du dossier.

Après la suppression, le code recompte les messages du dossier "Sent Items" et affiche le nombre mis à jour.

Supprimer des éléments des fichiers PST

Dans de nombreux systèmes de messagerie ou clients de messagerie, chaque élément (comme un e‑mail, un rendez‑vous ou une tâche) se voit attribuer un identifiant unique appelé ID d’entrée. Le delete_item(entry_id) méthode du FolderInfo classe prend cet ID d’entrée comme paramètre et supprime l’élément correspondant du magasin de messages. Utilisez le code suivant pour supprimer un élément du magasin de messages :

import aspose.email as ae

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

pst.delete_item(entry_id)

Supprimer des éléments en masse

L’API Aspose.Email peut être utilisée pour supprimer des éléments en masse d’un fichier PST. Cela est réalisé en utilisant le delete_child_items() méthode qui accepte une liste d’ID d’entrée faisant référence aux éléments à supprimer. L’extrait de code ci‑dessus montre comment supprimer des éléments en masse d’un fichier PST.

Supprimer des dossiers des fichiers PST

Les fichiers PST d’Outlook peuvent contenir des dossiers dont vous n’avez plus besoin. Aspose.Email pour Python via .NET vous permet de supprimer ces dossiers soit en les déplaçant vers le dossier Éléments supprimés (les rendant récupérables), soit en les supprimant définitivement. Les exemples suivants démontrent les deux approches.

Déplacer un dossier vers les Éléments supprimés (suppression douce)

Le move_item méthode du PersonalStorage classe permet aux dossiers d’être récupérés ultérieurement, car ils ne sont pas supprimés définitivement mais déplacés vers le dossier Éléments supprimés. L’extrait de code ci‑dessus montre comment implémenter cette méthode dans un projet 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)

L’avantage de cette méthode est que le dossier supprimé peut être facilement récupéré.

Restaurer un dossier depuis les Éléments supprimés

Le move_item méthode vous permet de restaurer un dossier, s’il a été supprimé par erreur, en le déplaçant des Éléments supprimés vers son emplacement d’origine.

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

Supprimer définitivement un dossier des Éléments supprimés

Le delete_child_item méthode peut être utilisée pour n’importe quel dossier si vous souhaitez supprimer immédiatement et définitivement un sous‑dossier, en contournant le dossier Éléments supprimés. L’exemple de code ci‑dessus montre comment retirer le dossier complètement des Éléments supprimés, rendant toute récupération impossible :

deleted_items_folder.delete_child_item(empty_folder.entry_id)

Supprimer définitivement un dossier immédiatement

Si un dossier doit être supprimé sans être déplacé vers Éléments supprimés, le delete_child_item méthode garantit une suppression immédiate et permanente.

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

Travailler avec MapiTask dans le PST Gestion de la protection par mot de passe des fichiers PST