Gestion des fichiers de messages avec Aspose.Email.Outlook

Déterminer le type d’élément MAPI dans un dossier PST

Un fichier PST contient généralement différents types de données, comme des messages électroniques, des événements de calendrier, des contacts, etc. Le MapiItemType classe d’Aspose.Email vous permet d’accéder et de catégoriser différents types d’éléments MAPI au sein d’un fichier PST. Le code ci‑dessous montre comment déterminer le type d’un élément MAPI dans un dossier PST :

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("test.pst")
folder = pst.root_folder.get_sub_folder("Calendar")
for messageInfo in folder.enumerate_messages():
    msg = pst.extract_message(messageInfo)

    # Get the class type based on msg.SupportedType
    item_type = msg.supported_type

    # Non-supported type. It cannot be accessed as appropriate item type.
    if item_type == ae.mapi.MapiItemType.NONE:
        print("Item type not supported")
    # An email message.
    elif item_type == ae.mapi.MapiItemType.MESSAGE:
        # You can access to MapiMessage properties there.
        # A subject for example
        print(msg.subject)
    # A contact item. Can be accessed as MapiContact.
    elif item_type == ae.mapi.MapiItemType.CONTACT:
        contact = msg.to_mapi_message_item()
        # You can access to MapiContact properties there. 
        # A name_info.display_name for example. 
        print(contact.name_info.display_name)
    # A calendar item. Can be accessed as MapiCalendar.
    elif item_type == ae.mapi.MapiItemType.CALENDAR:
        calendar = msg.to_mapi_message_item()
        # You can access to MapiCalendar properties there. 
        # A location for example. 
        print(calendar.location)
    # A distribution list. Can be accessed as MapiDistributionList.
    elif item_type == ae.mapi.MapiItemType.DIST_LIST:
        dlist = msg.to_mapi_message_item()
        # You can access to MapiDistributionList properties there
    # A Journal entry. Can be accessed as MapiJournal.
    elif item_type == ae.mapi.MapiItemType.JOURNAL:
        journal = msg.to_mapi_message_item()
        # You can access to MapiJournal properties there
    # A StickyNote. Can be accessed as MapiNote.
    elif item_type == ae.mapi.MapiItemType.NOTE:
        note = msg.to_mapi_message_item()
        # You can access to MapiNote properties there
    # A Task item. Can be accessed as MapiTask.
    elif item_type == ae.mapi.MapiItemType.TASK:
        task = msg.to_mapi_message_item()
        # You can access to MapiTask properties there

Conversion de MSG en message MIME

L’API Aspose.Email offre la capacité de convertir un fichier MSG en message MIME à l’aide de la méthode ToMailMessage.

Définition du délai d’expiration pour la conversion et le chargement d’un message

Pour limiter le temps en millisecondes de la conversion du message (valeur par défaut 3 s), la propriété timeout du MailConversionOptions classe est utilisée.

Voici comment vous pouvez définir un délai d’expiration pour les processus de conversion et de chargement des messages :

import aspose.email as ae

msg = ae.mapi.MapiMessage.load("my.msg")
options = ae.mapi.MailConversionOptions()
options.timeout = 5000
mailMessage = msg.to_mail_message(options)

En définissant un délai d’expiration pour les processus de conversion et de chargement des messages, vous pouvez contrôler le temps maximum autorisé pour ces opérations. Après avoir fixé le délai, vous pouvez poursuivre vos processus de conversion et de chargement des messages.

Traitement des fichiers Outlook Template (OFT)

Charger, modifier et enregistrer un fichier OFT

Les modèles Outlook (OFT) offrent un moyen pratique de rationaliser l’envoi de messages électroniques récurrents. Au lieu de rédiger le même courriel à chaque fois, vous pouvez créer un message dans Outlook et l’enregistrer comme modèle Outlook (OFT). Plus tard, chaque fois que vous devez envoyer un message similaire, vous pouvez le générer rapidement à partir du modèle. Cette approche vous évite de réécrire le même contenu dans le corps du message, de spécifier l’objet, le formatage, etc.

Aspose.Email MailMessage classe fournit un outil puissant pour charger et manipuler les fichiers de modèle Outlook (OFT). Une fois un modèle Outlook chargé dans une instance de la classe MailMessage, vous pouvez facilement mettre à jour des propriétés telles que l’expéditeur, le destinataire, le corps du message, l’objet et divers autres attributs.

import aspose.email as ae

# Load the OFT file
oft_file_path = "your_template.oft"
mail_message = ae.MailMessage.load(oft_file_path)

# Update properties as needed
mail_message.subject = "Updated Subject"
mail_message.body = "Updated body text."

# Save the updated message as an MSG file
msg_file_path = "updated_message.msg"
mail_message.save(msg_file_path, ae.MailMessageSaveType.outlook_message_format_unicode)

print(f"Updated message saved to {msg_file_path}")

Après avoir effectué les mises à jour nécessaires, vous pouvez envoyer le courriel à l’aide du SmtpClient classe:

# Send the email
smtpClient.send(message)

Enregistrement du fichier Outlook MSG en tant que modèle

À cette fin, vous pouvez utiliser le MailMessage classe permettant de créer un courriel, puis de l’enregistrer en tant que fichier OFT. L’exemple de code suivant montre comment enregistrer un courriel comme modèle Outlook :

import aspose.email as ae

# Create a new MailMessage
message = ae.MailMessage()
message.subject = "Sample Outlook Template"
message.html_body = "<html><body>This is the body of the email.</body></html>"
message.from_address = ae.MailAddress("your.email@example.com", "Your Name")

# Save the MailMessage as an Outlook Template (OFT) file
oft_file_path = "sample_template.oft"
message.save(oft_file_path, ae.SaveOptions.default_oft)

print(f"Outlook Template saved as {oft_file_path}")

OFT ou MSG : Déterminer le type d’un MapiMessage

L’extrait de code suivant illustre comment déterminer si un message MAPI chargé représente un courriel standard ou un modèle Outlook (OFT) :

msg = ae.mapi.MapiMessage.Load("message.msg");
isOft = msg.is_template # returns false

msg = ae.mapi.MapiMessage.Load("message.oft");
isOft = msg.IsTemplate; # returns true

Après le chargement du fichier MSG, le code vérifie si la propriété is_template du MapiMessaage la classe renvoie True ou False. Si elle renvoie false, le message chargé est un courriel standard, pas un modèle Outlook ; sinon, si elle renvoie true, le message n’est pas un courriel standard, c’est un modèle Outlook.

Enregistrement de MapiMessage ou MailMessage au format OFT

Le SaveOptions est une classe de base abstraite pour les classes qui permettent à l’utilisateur de spécifier des options supplémentaires lors de l’enregistrement d’un MailMessage dans un format particulier. L’exemple de code suivant montre comment enregistrer un message au format OFT :

import aspose.email as ae

# Save the MailMessage to OFT format
eml = ae.MailMessage.load("message.eml")

eml.save("message.oft", ae.SaveOptions.default_oft)

# or alternative way 2
save_options = ae.MsgSaveOptions(ae.MailMessageSaveType.outlook_template_format)
eml.save("message.oft", save_options)

# or alternative way 3
save_options = ae.SaveOptions.create_save_options(ae.MailMessageSaveType.outlook_template_format)
eml.save("message.oft", save_options)

# Save the MapiMessage to OFT format
msg = ae.mapi.MapiMessage.load("message.msg")

msg.save("message.oft", ae.SaveOptions.default_oft)

# or alternative way 2
save_options = ae.MsgSaveOptions(ae.MailMessageSaveType.outlook_template_format)
msg.save("message.oft", save_options)

# or alternative way 3
save_options = ae.SaveOptions.create_save_options(ae.MailMessageSaveType.outlook_template_format)
msg.save("message.oft", save_options)

Gestion des messages avec signatures numériques

La bibliothèque fournit le LoadOptions classe, classe de base abstraite pour les classes qui permettent à l’utilisateur de spécifier des options supplémentaires lors du chargement d’un MailMessage depuis un format particulier. L’option de préservation de la signature est activée par défaut.

Conversion de EML vers MSG en préservant la signature

L’exemple de code ci-dessous montre comment charger un message, le convertir au format MSG et l’enregistrer en tant que MSG (la signature est conservée par défaut) :


import aspose.email as ae

# Load mail message
loadOptions = ae.EmlLoadOptions()
message = ae.MailMessage.load("Message.eml", loadOptions)
# Save as MSG
message.save("ConvertEMLToMSG_out.msg", ae.SaveOptions.default_msg_unicode)

Convertir les messages S/MIME de MSG en EML

Aspose.Email vous permet de convertir de MSG à EML en conservant une signature numérique comme le montre le fragment de code suivant.

import aspose.email as ae

# Load mail message
loadOptions = ae.EmlLoadOptions()
smime_eml = ae.MailMessage.load("smime.eml", loadOptions)

conversion_options = ae.mapi.MapiConversionOptions(ae.mapi.OutlookMessageFormat.UNICODE)
msg = ae.mapi.MapiMessage.from_mail_message(smime_eml, conversion_options)
# Save File to disk
msg.save("ConvertMIMEMessagesFromMSGToEML_out.msg")

Définir la catégorie de couleur pour les fichiers Outlook MSG

Il arrive parfois que vous deviez différencier les courriels d’importance particulière et les organiser visuellement. La bibliothèque offre un moyen de le faire en attribuant une couleur spécifique à un élément de message. Lorsque vous définissez une catégorie de couleur pour un élément, cela vous permet d’identifier et de localiser facilement les éléments liés d’un seul coup d’œil. Utilisez FollowUpManager classe permettant de définir la catégorie de couleur d’un message comme dans l’exemple de code suivant :


import aspose.email as ae

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

# Add Two categories
ae.mapi.FollowUpManager.add_category(msg, "Purple Category")
ae.mapi.FollowUpManager.add_category(msg, "Red Category")

# Retrieve the list of available categories
categories = ae.mapi.FollowUpManager.get_categories(msg)

# Remove the specified category and then Clear all categories
ae.mapi.FollowUpManager.remove_category(msg, "Red Category")
ae.mapi.FollowUpManager.clear_categories(msg)

Accès aux informations de suivi depuis un fichier MSG

Extraire les informations d’accusé de lecture et de remise

L’exemple de code ci‑dessus montre comment extraire les informations des destinataires et leur statut de suivi à partir d’un message Outlook (MSG) :

import aspose.email as ae

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

for recipient in msg.recipients:
    print(f"Recipient: {recipient.display_name}")
    print(f"Delivery time:  {recipient.properties[ae.mapi.MapiPropertyTag.RECIPIENT_TRACKSTATUS_TIME_DELIVERY]}")
    print(f"Read time:  {recipient.properties[ae.mapi.MapiPropertyTag.RECIPIENT_TRACKSTATUS_TIME_READ]}")

Créer des messages de transfert et de réponse

Aspose.Email propose des méthodes simples pour créer des messages de transfert et de réponse à partir de messages existants.

Créer un message de transfert

Vous pouvez utiliser le ForwardMessageBuilder classe pour créer un message de transfert en définissant le message source, l’expéditeur, les destinataires, l’objet et le corps. Les messages de transfert peuvent inclure le message original en pièce jointe ou dans le corps du message transféré. Vous avez la flexibilité de personnaliser des propriétés supplémentaires telles que les pièces jointes, les en‑têtes et les options de formatage. L’exemple de code ci‑dessous montre comment créer un message de transfert :


import aspose.email as ae

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

builder = ae.tools.ForwardMessageBuilder()
builder.addition_mode = ae.tools.OriginalMessageAdditionMode.TEXTPART

forwardMsg = builder.build_response(msg)
forwardMsg.save("forward_out.msg")

Création d’un message de réponse

Le ReplyMessageBuilder La classe est utilisée pour configurer les paramètres de réponse, y compris le message source, l’expéditeur, les destinataires, le mode de réponse, le préfixe d’objet et le corps du message de réponse. Les messages de réponse peuvent être créés dans différents modes de réponse comme « Répondre à l’expéditeur » ou « Répondre à tous » selon vos besoins. Vous pouvez personnaliser diverses propriétés telles que les pièces jointes, les en‑têtes et les options de formatage du message de réponse. L’exemple de code ci‑dessous montre comment créer un message de transfert :

import aspose.email as ae

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

builder = ae.tools.ReplyMessageBuilder()

# Set ReplyMessageBuilder Properties
builder.reply_all = True
builder.addition_mode = ae.tools.OriginalMessageAdditionMode.TEXTPART
builder.response_text = "<p><b>Dear Friend,</b></p> I want to do is introduce my co-author and co-teacher. <p><a href=\"www.google.com\">This is a first link</a></p><p><a href=\"www.google.com\">This is a second link</a></p>";

replyMsg = builder.build_response(msg)
replyMsg.save("reply_out.msg")

Chargement, affichage et analyse du fichier MSG Le fragment de code suivant montre comment lire une liste de distribution à partir d'un fichier PST.