Gestion des pièces jointes dans les messages Outlook

Le Création et enregistrement de fichiers de messages Outlook (MSG) l’article expliquait les étapes de création et d’enregistrement de messages, y compris les fichiers MSG avec pièces jointes. Cet article se penche sur la gestion des pièces jointes Microsoft Outlook à l’aide d’Aspose.Email. Il vous guidera à travers l’accès et l’enregistrement des pièces jointes d’un fichier de message en utilisant le attachments propriété du MapiMessage classe. Cette propriété est une collection appartenant au MapiAttachmentCollection classe, permettant une gestion efficace des pièces jointes.

Vérifier les pièces jointes Inline vs Regular

"Inline" et "Regular" font référence à la manière dont elles sont incluses dans un message électronique. Les pièces jointes Regular sont des fichiers attachés de façon traditionnelle. Elles sont généralement affichées dans une liste dans le client de messagerie et peuvent être téléchargées par le destinataire et enregistrées sur un stockage local. Les pièces jointes Inline, également appelées images incorporées ou inline, sont généralement utilisées pour inclure des images ou d’autres médias dans le corps du courriel. Elles ne sont pas affichées dans une liste séparée mais apparaissent directement dans le contenu du courriel, par exemple dans le corps du message. Cela vous permet d’inclure des images ou d’autres médias faisant partie du contenu du message. L’exemple de code ci‑dessus montre comment déterminer si une pièce jointe est inline ou regular :

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("message.msg")

for attachment in msg.attachments:
    print(f"{attachment.display_name}:{attachment.is_inline}")

Identifier les pièces jointes de référence dans les messages MAPI

L’API Aspose.Email comprend le is_reference propriété du MapiAttachment classe qui permet aux développeurs d’identifier les pièces jointes de référence dans un message. Essayez l’exemple de code ci‑dessus pour voir comment cela fonctionne dans un projet python :

import aspose.email as ae

# Load or create a MapiMessage
msg = ae.mapi.MapiMessage.load("Message_With_Reference_Attachment.msg")

# Iterate through the attachments
for attachment in msg.attachments:
    if attachment.is_reference:
        # Process reference attachment
        pass

Enregistrer les pièces jointes à partir de fichiers MSG

Pour enregistrer les pièces jointes d’un fichier MSG :

Itérer à travers le MapiAttachmentCollection collection et récupérez les pièces jointes individuelles.
Pour enregistrer les pièces jointes, appelez le MapiAttachment classe Save() méthode.

L’extrait de code suivant vous montre comment enregistrer les pièces jointes sur le disque local :

import aspose.email as ae

data_dir = "C://dataDir/"
file_name = "message.msg"

# Create an instance of MapiMessage from file
message = ae.mapi.MapiMessage.load(data_dir + file_name)

# Iterate through the attachments collection
for attachment in message.attachments:
    # Save the individual attachment
    attachment.save(data_dir + attachment.file_name)

Gestion des pièces jointes TNEF

Charger et enregistrer des pièces jointes au format TNEF

Aspose.Email fournit des méthodes pour gérer les pièces jointes TNEF. Ces méthodes permettent d’enregistrer et de charger des pièces jointes au format TNEF, couramment utilisé dans les messages Outlook (winmail.dat).

static MapiAttachment MapiAttachment.load_from_tnef(string fileName) – Charge une pièce jointe à partir d’un fichier TNEF.
static MapiAttachment MapiAttachment.load_from_tnef(Stream stream) – Charge une pièce jointe à partir d’un flux TNEF.
void MapiAttachment.save_to_tnef(string filename) – Enregistre une pièce jointe dans un fichier TNEF.
void MapiAttachment.save_to_tnef(Stream stream) – Enregistre une pièce jointe dans un flux TNEF.

L’exemple de code suivant montre comment extraire, enregistrer et ré‑ajouter des pièces jointes d’e‑mail au format TNEF tout en les gérant via des flux mémoire ou des fichiers :

import io
from aspose.email.mapi import MapiMessage, MapiAttachment

# Load the EML message (which contains a winmail.dat TNEF attachment)
msg = MapiMessage.load("message.eml")

# Save the first attachment as a winmail.dat file
msg.attachments[0].save_to_tnef("winmail.dat")

# Load the TNEF attachment from the file and add it back to the message
from_tnef_attachment = MapiAttachment.load_from_tnef("winmail.dat")
msg.attachments.add(from_tnef_attachment.long_file_name, from_tnef_attachment.binary_data)

# (Optional) If you also want to use a memory stream instead of the file
ms = io.BytesIO()
msg.attachments[0].save_to_tnef(ms)

# Reset the stream position to the beginning
ms.seek(0)

# Load the TNEF attachment directly from the memory stream and add it
from_tnef_attachment_from_stream = MapiAttachment.load_from_tnef(ms)
msg.attachments.add(from_tnef_attachment_from_stream.long_file_name, from_tnef_attachment_from_stream.binary_data)

Récupérer les pièces jointes de messages imbriqués

Les pièces jointes OLE (Object Linking and Embedding) intégrées apparaissent également dans la collection de pièces jointes du MapiMessage classe. L’exemple de code ci‑dessus montre comment analyser un fichier de message et extraire les pièces jointes de messages intégrés, puis les enregistrer sur le disque pour une utilisation ultérieure. Le MapiMessage classe offre un from_properties méthode statique pour créer un nouveau message à partir d’une pièce jointe intégrée. L’extrait de code suivant vous montre comment obtenir les pièces jointes de messages imbriqués :

import aspose.email as ae

eml = ae.mapi.MapiMessage.load("my.msg")

# Create a MapiMessage object from the individual attachment
get_attachment = ae.mapi.MapiMessage.from_properties(eml.attachments[0].object_data.properties)

# Create an object of type MailMessageInterpreter from the above message and save the embedded message to a file on disk
mail_message = get_attachment.to_mail_message(ae.mapi.MailConversionOptions())
mail_message.save("NestedMailMessageAttachments_out.eml", ae.SaveOptions.default_eml)

Supprimer les pièces jointes

La bibliothèque Aspose.Email fournit la fonctionnalité de supprimer des pièces jointes des fichiers Microsoft Outlook Message (.msg). Utilisez le remove_attachments(path) méthode qui nécessite le chemin du fichier de message comme paramètre. En tant que méthode publique statique, vous pouvez l’appeler directement sans avoir besoin d’instancier un objet, rendant le processus simple et efficace.

L’extrait de code suivant vous montre comment supprimer des pièces jointes de fichiers MSG en utilisant Aspose.Email :

import aspose.email as ae

ae.mapi.MapiMessage.remove_attachments("AttachmentsToRemove_out.msg")

Vous pouvez également appeler la méthode statique destroy_attachments du MapiMessage classe. Cela fonctionne plus rapidement que remove_attachments car la méthode remove_attachments analyse le fichier de message.

import aspose.email as ae

# Destroy attachments in the MapiMessage
ae.mapi.MapiMessage.destroy_attachments("AttachmentsToDestroy_out.msg")

Ajouter des pièces jointes MSG

Un message Outlook peut contenir d’autres messages Microsoft Outlook en pièces jointes, soit en tant que pièces jointes régulières, soit intégrées. Le MapiAttachmentCollection fournit des membres surchargés du ajouter méthode pour créer des messages Outlook avec les deux types de pièces jointes.

Essayez-le !

Ajoutez ou supprimez des pièces jointes d’e‑mail en ligne avec le gratuit Aspose.Email Editor App.

Ajouter des pièces jointes de référence aux messages MAPI

Pièce jointe de référence fait généralement référence à une pièce jointe qui contient une référence ou un lien vers une ressource externe plutôt que le fichier réel. Ces références sont souvent utilisées dans les e‑mails HTML pour lier des images ou des ressources externes hébergées sur un serveur distant. Au lieu d’intégrer le fichier complet, une pièce jointe de référence inclut une URL ou une référence au contenu externe.

Pour ajouter une pièce jointe de référence à un message MAPI, utilisez le add méthode du MapiAttachmentCollection classe et le ReferenceAttachmentOptions classe à spécifier :

L’URL du contenu (lien direct vers le fichier)
L’URL du fournisseur (lien vers l’emplacement du fichier ou la vue UI)
Le nom du fournisseur de pièces jointes (ex. "GoogleDrive")

comme indiqué dans l’exemple de code ci‑dessus.

import aspose.email as ae

# Load or create a MapiMessage
msg = ae.mapi.MapiMessage()
msg.subject = "Email with Reference Attachment"
msg.body = "This message contains a cloud-based reference attachment."

# Create ReferenceAttachmentOptions
options = ae.mapi.ReferenceAttachmentOptions(
    "https://drive.google.com/file/d/1HJ-M3F2qq1oRrTZ2GZhUdErJNy2CT3DF/",
    "https://drive.google.com/drive/my-drive",
    "GoogleDrive"
)

# Add the reference attachment to the message
msg.attachments.add("Document.pdf", options)

# Save the message to MSG format
msg.save("Message_With_Reference_Attachment.msg")

Intégrer des messages en tant que pièces jointes

L’extrait de code suivant montre comment intégrer des fichiers Outlook MSG en tant que pièces jointes dans un autre fichier MSG. Un fichier MSG intégré inclut une propriété PR_ATTACH_METHOD avec une valeur de 5, indiquant qu’il s’agit d’une pièce jointe de type « message ».

import aspose.email as ae

# Create a new MapiMessage
message = ae.mapi.MapiMessage("from@test.com", "to@test.com", "Subj", "This is a message body")

# Load the attachment message
attach_msg = ae.mapi.MapiMessage.load("Message.msg")

# Add the attachment to the message
message.attachments.add("Weekly report.msg", attach_msg)

# Save the message with the embedded message attachment
message.save("WithEmbeddedMsg_out.msg")

Lire les messages intégrés à partir des pièces jointes

L’extrait de code suivant vous montre comment lire des messages intégrés à partir de pièces jointes.

import aspose.email as ae

file_name = "path/to/file.msg"

# Load the MapiMessage from file
message = ae.mapi.MapiMessage.load(file_name)

# Check if the first attachment is an Outlook message
if message.attachments[0].object_data.is_outlook_message:
    # Get the embedded message as MapiMessage
    embedded_message = message.attachments[0].object_data.to_mapi_message()
    # Perform further operations with the embedded message
    # ...

Insérer et remplacer des pièces jointes

L’API Aspose.Email offre la fonctionnalité d’insérer des pièces jointes à un index spécifique au sein du message parent. De plus, elle permet de remplacer le contenu d’une pièce jointe existante par une pièce jointe de message différente. Vous trouverez ci‑dessous des extraits de code montrant comment effectuer l’insertion et le remplacement de pièces jointes.

Insérer des pièces jointes à des emplacements spécifiques

L’API Aspose.Email vous permet d’insérer une pièce jointe MSG dans un MSG parent en utilisant la méthode Insert du MapiAttachmentCollection. Cette méthode est utilisée avec la signature MapiAttachmentCollection Insert(int index, string name, MapiMessage msg). Ci‑dessus un extrait de code illustrant comment insérer une pièce jointe à un emplacement spécifique :

import aspose.email as ae
from io import BytesIO

file_name = "path/to/file.msg"

# Load the MapiMessage from file
message = ae.mapi.MapiMessage.load(file_name)

# Save the attachment to a memory stream
memory_stream = BytesIO()
message.attachments[2].save(memory_stream)

# Load the attachment from the memory stream
get_data = ae.mapi.MapiMessage.load(memory_stream)

# Insert the loaded attachment at index 1
message.attachments.insert(1, "new 11", get_data)

Remplacer le contenu de la pièce jointe

Vous pouvez utiliser le replace méthode pour mettre à jour le contenu d’une pièce jointe intégrée avec de nouvelles données. Cependant, notez que cette méthode ne peut pas être utilisée pour insérer une pièce jointe avec PR_ATTACH_NUM = 4 dans une collection qui ne contient que 2 pièces jointes. Voici un extrait de code démontrant comment remplacer le contenu d’une pièce jointe :

import aspose.email as ae
from io import BytesIO
file_name = "path/to/file.msg"

# Load the MapiMessage from file
message = ae.mapi.MapiMessage.load(file_name)

# Save the attachment to a memory stream
memory_stream = BytesIO()
message.attachments[2].save(memory_stream)

# Load the attachment from the memory stream
get_data = ae.mapi.MapiMessage.load(memory_stream)

# Replace the attachment at index 1 with the loaded attachment
message.attachments.replace(1, "new 1", get_data)

Renommer les pièces jointes dans les MapiMessages

Avec Aspose.Email, vous pouvez facilement modifier les noms d’affichage des pièces jointes dans les messages électroniques chargés depuis un fichier. L’exemple de code suivant montre comment y parvenir :

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("message.msg")

msg.attachments[0].display_name = "New display name 1"
msg.attachments[1].display_name = "New display name 2"

Le fragment de code suivant montre comment lire une liste de distribution à partir d'un fichier PST. Gestion du suivi et des dates d'échéance des fichiers Outlook MSG en Python