Gerenciando Arquivos de Mensagem com Aspose.Email.Outlook

Determinar o tipo de item MAPI em uma pasta PST

Um arquivo PST normalmente contém vários tipos de dados, como mensagens de e‑mail, eventos de calendário, contatos e mais. O MapiItemType A classe da Aspose.Email permite acessar e categorizar diferentes tipos de itens MAPI dentro de um arquivo PST. O código abaixo demonstra como determinar o tipo de um item MAPI em uma pasta 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

Convertendo MSG para mensagem MIME

A API Aspose.Email fornece a capacidade de converter um arquivo MSG em mensagem MIME usando o método ToMailMessage.

Definindo Timeout para Conversão e Carregamento de uma Mensagem

Para limitar o tempo em milissegundos da conversão de mensagem (valor padrão 3 seg), a propriedade timeout do MailConversionOptions classe é usada.

Veja como você pode definir um tempo limite para os processos de conversão e carregamento de mensagens:

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)

Ao definir um tempo limite para os processos de conversão e carregamento de mensagens, você pode controlar o tempo máximo que essas operações podem levar. Depois de definir o tempo limite, você pode prosseguir com seus processos de conversão e carregamento de mensagens.

Processamento de arquivos Outlook Template (OFT)

Carregar, modificar e salvar um arquivo OFT

Modelos Outlook (OFT) oferecem uma maneira prática de simplificar o processo de envio de mensagens de e‑mail repetitivas. Em vez de compor o mesmo e‑mail do zero toda vez, você pode criar uma mensagem no Outlook e salvá‑la como um Modelo Outlook (OFT). Depois, sempre que precisar enviar uma mensagem semelhante, pode gerá‑la rapidamente a partir do modelo. Essa abordagem poupa o esforço de reescrever o mesmo conteúdo no corpo da mensagem, especificar o assunto, a formatação etc.

da Aspose.Email MailMessage classe fornece uma ferramenta poderosa para carregar e manipular arquivos de modelo Outlook (OFT). Uma vez que um modelo Outlook é carregado em uma instância da classe MailMessage, você pode atualizar facilmente propriedades como remetente, destinatário, corpo da mensagem, assunto e vários outros atributos.

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

Após fazer as atualizações necessárias, você pode enviar o e‑mail usando o SmtpClient classe:

# Send the email
smtpClient.send(message)

Salvando arquivo Outlook MSG como modelo

Para isso, você pode usar o MailMessage classe para criar um e‑mail e, em seguida, salvá‑lo como um arquivo OFT. O exemplo de código a seguir mostrará como salvar um e‑mail como um Modelo 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: Determinar o tipo de um MapiMessage

O trecho de código a seguir ilustra como determinar se uma mensagem MAPI carregada representa uma mensagem de e‑mail padrão ou um Modelo 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

Após carregar o arquivo MSG, o código verifica se a propriedade is_template do MapiMessaage A classe é True ou False. Caso retorne false, a mensagem carregada é uma mensagem de e‑mail padrão, não um Modelo do Outlook; caso retorne true, a mensagem não é um e‑mail padrão, é um Modelo do Outlook.

Salvando MapiMessage ou MailMessage como OFT

O SaveOptions é uma classe base abstrata para classes que permitem ao usuário especificar opções adicionais ao salvar um MailMessage em um formato específico. O exemplo de código a seguir demonstra como salvar uma mensagem no formato 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)

Gerenciamento de Mensagens com Assinaturas Digitais

A biblioteca fornece o LoadOptions classe, uma classe base abstrata para classes que permitem ao usuário especificar opções adicionais ao carregar um MailMessage de um formato específico. A opção de preservação de assinatura está ativada por padrão.

Converter de EML para MSG Preservando a Assinatura

O exemplo de código abaixo demonstra como carregar uma mensagem, convertê‑la para o formato MSG e salvar como MSG (a assinatura é preservada por padrão):


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)

Converter mensagens S/MIME de MSG para EML

Aspose.Email permite converter de MSG para EML preservando uma assinatura digital, conforme mostrado no trecho de código a seguir.

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

Definir Categoria de Cor para Arquivos Outlook MSG

Às vezes você pode precisar diferenciar e-mails de importância particular e organizá-los visualmente. A biblioteca oferece uma maneira de fazer isso atribuindo uma cor específica a um item de mensagem. Quando você define uma categoria de cor para um item, isso permite identificar e localizar itens relacionados rapidamente. Use FollowUpManager classe para definir a categoria de cor de uma mensagem como no exemplo de código a seguir:


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)

Acessando Informações de Follow Up de arquivo MSG

Extrair Informações de Recebimento de Leitura e Entrega

O exemplo de código abaixo demonstra como extrair informações do destinatário e seu status de rastreamento de um arquivo de mensagem 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]}")

Criando Mensagens de Encaminhamento e Resposta

Aspose.Email oferece maneiras simples de criar mensagens encaminhadas e de resposta baseadas nas existentes.

Criando uma Mensagem Encaminhada

Você pode usar o ForwardMessageBuilder A classe para criar uma mensagem de encaminhamento definindo a mensagem de origem, remetente, destinatários, assunto e corpo. Mensagens de encaminhamento podem incluir a mensagem original como anexo ou como corpo da mensagem encaminhada. Você tem a flexibilidade de personalizar propriedades adicionais, como anexos, cabeçalhos e opções de formatação. O exemplo de código abaixo mostra como criar uma mensagem de encaminhamento:


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

Criando uma Mensagem de Resposta

O ReplyMessageBuilder A classe é usada para configurar as opções de resposta, incluindo a mensagem de origem, remetente, destinatários, modo de resposta, prefixo do assunto e o corpo da mensagem de resposta. Mensagens de resposta podem ser criadas em diferentes modos de resposta, como "Responder ao Remetente" ou "Responder a Todos", conforme sua necessidade. Você pode personalizar várias propriedades, como anexos, cabeçalhos e opções de formatação para a mensagem de resposta. O exemplo de código abaixo mostra como criar uma mensagem de encaminhamento:

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

Carregando, Visualizando e Analisando arquivo MSG Trabalhando com Listas de Distribuição