Gerenciando Anexos em Mensagens Outlook

O Criando e Salvando Arquivos de Mensagem Outlook (MSG) o artigo explicou as etapas envolvidas na criação e gravação de mensagens, incluindo arquivos MSG com anexos. Este artigo aprofunda o gerenciamento de anexos do Microsoft Outlook usando Aspose.Email. Ele orientará você a acessar e salvar anexos de um arquivo de mensagem utilizando o attachments propriedade do MapiMessage classe. Esta propriedade é uma coleção pertencente ao MapiAttachmentCollection classe, permitindo o manejo eficiente de anexos.

Verificar Anexos Inline vs Regular

"Inline" e "Regular" referem‑se ao modo como são incluídos em uma mensagem de e‑mail. Anexos Regular são arquivos anexados da forma tradicional. Normalmente são exibidos em uma lista no cliente de e‑mail e podem ser baixados pelo destinatário e salvos em um armazenamento local. Anexos Inline, também conhecidos como imagens incorporadas ou inline, são tipicamente usados para incluir imagens ou outros meios dentro do corpo do e‑mail. Eles não são exibidos em uma lista separada, mas sim mostrados diretamente no conteúdo da mensagem, como no corpo do e‑mail. Isso permite incluir imagens ou outros meios que fazem parte do conteúdo da mensagem. O exemplo de código abaixo demonstra como determinar se um anexo é 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}")

Identificar Anexos de Referência em Mensagens MAPI

A API Aspose.Email inclui o is_reference propriedade do MapiAttachment classe que permite aos desenvolvedores identificar anexos de referência em uma mensagem. Experimente o exemplo de código abaixo para ver como funciona em um projeto 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

Salvar Anexos de Arquivos MSG

Para salvar anexos de um arquivo MSG:

Itere através do MapiAttachmentCollection coleção e obtenha os anexos individuais.
Para salvar os anexos, chame o MapiAttachment classe Save() método.

O trecho de código a seguir mostra como salvar anexos no disco 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)

Manipulação de Anexos TNEF

Carregar e Salvar Anexos no Formato TNEF

Aspose.Email fornece métodos para manipular anexos TNEF. Esses métodos permitem salvar e carregar anexos no formato TNEF, comumente usado em mensagens Outlook (winmail.dat).

static MapiAttachment MapiAttachment.load_from_tnef(string fileName) – Carrega um anexo de um arquivo TNEF.
static MapiAttachment MapiAttachment.load_from_tnef(Stream stream) – Carrega um anexo de um fluxo TNEF.
void MapiAttachment.save_to_tnef(string filename) – Salva um anexo em um arquivo TNEF.
void MapiAttachment.save_to_tnef(Stream stream) – Salva um anexo em um fluxo TNEF.

O exemplo de código a seguir demonstra como extrair, salvar e re-adicionar anexos de e-mail no formato TNEF, gerenciando-os através de streams de memória ou arquivos:

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)

Recuperar Anexos de Mensagens de E-mail Aninhadas

Os anexos OLE incorporados (Object Linking and Embedding) também aparecem na coleção de anexos do MapiMessage classe. O exemplo de código abaixo demonstra como analisar um arquivo de mensagem e extrair anexos de mensagens incorporadas, salvando-os posteriormente em disco para uso futuro. O MapiMessage classe oferece um from_properties método estático para criar uma nova mensagem a partir de um anexo incorporado. O trecho de código a seguir mostra como obter anexos de mensagens de e-mail aninhadas:

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)

Remover Anexos

A biblioteca Aspose.Email fornece a funcionalidade de remover anexos de arquivos Microsoft Outlook Message (.msg). Use o remove_attachments(path) método que requer o caminho do arquivo de mensagem como parâmetro. Como um método estático público, você pode chamá-lo diretamente sem precisar instanciar um objeto, tornando o processo simples e eficiente.

O trecho de código a seguir mostra como remover anexos de arquivos MSG usando Aspose.Email:

import aspose.email as ae

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

Você também pode chamar o método estático destroy_attachments da MapiMessage classe. Ele funciona mais rápido que remove_attachments porque o método remove_attachments analisa o arquivo de mensagem.

import aspose.email as ae

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

Adicionar Anexos MSG

Uma mensagem Outlook pode conter outras mensagens Microsoft Outlook em anexos, seja como anexos regulares ou incorporados. O MapiAttachmentCollection fornece membros sobrecarregados do adicionar método para criar mensagens Outlook com ambos os tipos de anexos.

Experimente!

Adicione ou remova anexos de e‑mail online com o gratuito Aspose.Email Editor App.

Adicionar Anexos de Referência a Mensagens MAPI

Anexo de referência normalmente refere‑se a um anexo que contém uma referência ou link para um recurso externo, ao invés do arquivo real. Essas referências são frequentemente usadas em e‑mails HTML para vincular a imagens ou recursos externos hospedados em um servidor remoto. Em vez de incorporar o arquivo completo, um anexo de referência inclui uma URL ou referência ao conteúdo externo.

Para adicionar um anexo de referência a uma mensagem MAPI, use o add método do MapiAttachmentCollection classe e o ReferenceAttachmentOptions classe para especificar:

A URL do conteúdo (link direto para o arquivo)
A URL do provedor (link para a localização do arquivo ou visualização de UI)
O nome do provedor de anexo (ex.: "GoogleDrive")

conforme mostrado no exemplo de código abaixo.

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

Incorporar Mensagens como Anexos

O trecho de código a seguir demonstra como incorporar arquivos Outlook MSG como anexos dentro de outro arquivo MSG. Um arquivo MSG incorporado inclui uma propriedade PR_ATTACH_METHOD com o valor 5, indicando que é um anexo do tipo "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")

Ler Mensagens Incorporadas a partir de Anexos

O trecho de código a seguir mostra como ler mensagens incorporadas a partir de anexos.

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
    # ...

Inserir e Substituir Anexos

A API Aspose.Email oferece a funcionalidade de inserir anexos em um índice específico dentro da mensagem pai. Além disso, permite substituir o conteúdo de um anexo existente por um anexo de mensagem diferente. Abaixo estão trechos de código demonstrando como executar a inserção e substituição de anexos.

Inserir Anexos em Locais Específicos

A API Aspose.Email permite inserir um anexo MSG em um MSG pai usando o método Insert da MapiAttachmentCollection. Este método é usado com a assinatura MapiAttachmentCollection Insert(int index, string name, MapiMessage msg). Abaixo está um trecho de código ilustrando como inserir um anexo em um local específico:

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)

Substituir Conteúdo do Anexo

Você pode usar o replace método para atualizar o conteúdo de um anexo incorporado com novos dados. No entanto, observe que este método não pode ser usado para inserir um anexo com PR_ATTACH_NUM = 4 em uma coleção que contém apenas 2 anexos. Abaixo está um trecho de código demonstrando como substituir o conteúdo do anexo:

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)

Renomear Anexos em MapiMessages

Com Aspose.Email, você pode facilmente modificar os nomes de exibição dos anexos em mensagens de e‑mail carregadas de um arquivo. O exemplo de código a seguir demonstra como fazer isso:

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"

Trabalhando com Listas de Distribuição Gerenciamento de Follow‑Up e Data de Vencimento de Arquivo MSG do Outlook em Python