Bijlagen beheren in Outlook‑berichten

De Outlook‑berichten (MSG) maken en opslaan het artikel legde de stappen uit die betrokken zijn bij het maken en opslaan van berichten, inclusief MSG‑bestanden met bijlagen. Dit artikel verdiept zich in het beheer van Microsoft Outlook‑bijlagen met Aspose.Email. Het zal je begeleiden bij het benaderen en opslaan van bijlagen uit een berichtbestand met behulp van de attachments eigenschap van de MapiMessage klasse. Deze eigenschap is een collectie behorende tot de MapiAttachmentCollection klasse, waardoor efficiënt omgaan met bijlagen mogelijk is.

Controleer inline versus reguliere bijlagen

"Inline" en "Regular" bijlagen verwijzen naar de manier waarop ze in een e‑mailbericht worden opgenomen. Regular bijlagen zijn bestanden die op de traditionele manier worden toegevoegd. Ze worden meestal weergegeven in een lijst in de e‑mailclient en kunnen door de ontvanger worden gedownload en lokaal worden opgeslagen. Inline bijlagen, ook wel ingesloten of inline‑afbeeldingen genoemd, worden meestal gebruikt om afbeeldingen of andere media op te nemen in de hoofdtekst van de e‑mail. Ze worden niet getoond in een aparte lijst, maar direct binnen de inhoud van de e‑mail, bijvoorbeeld in de berichttekst. Dit maakt het mogelijk om afbeeldingen of andere media op te nemen die onderdeel zijn van de berichtinhoud. De onderstaande code‑voorbeeld toont hoe je kunt bepalen of een bijlage inline of regulier is:

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

Referentie‑bijlagen identificeren in MAPI‑berichten

De Aspose.Email‑API bevat de is_reference eigenschap van de MapiAttachment klasse die ontwikkelaars in staat stelt referentie‑bijlagen in een bericht te identificeren. Probeer de onderstaande code‑voorbeeld om te zien hoe het werkt in een Python‑project:

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

Bijlagen opslaan uit MSG‑bestanden

Om bijlagen uit een MSG‑bestand op te slaan:

  1. Itereer door de MapiAttachmentCollection collectie aan en haal de individuele bijlagen op.
  2. Om de bijlagen op te slaan, roep je de MapiAttachment klasse Save() methode.

De volgende code‑snippet laat zien hoe je bijlagen opslaat op de lokale schijf:

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)

TNEF‑bijlagen afhandelen

Bijlagen laden en opslaan in TNEF‑formaat

Aspose.Email biedt methoden voor het afhandelen van TNEF‑bijlagen. Deze methoden laten het opslaan en laden van bijlagen in TNEF‑formaat toe, vaak gebruikt in Outlook‑berichten (winmail.dat).

Het volgende code‑voorbeeld toont hoe je TNEF‑formaat e‑mailbijlagen extraheert, opslaat en opnieuw toevoegt, terwijl je ze beheert via geheugen‑streams of bestanden:

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)

Geneste e‑mailbijlagen ophalen

De ingesloten OLE‑bijlagen (Object Linking and Embedding) verschijnen ook in de bijlagecollectie van de MapiMessage klasse. Het onderstaande code‑voorbeeld laat zien hoe je een berichtbestand parseert en ingesloten berichtbijlagen extraheert, waarna je ze opslaat op schijf voor verder gebruik. De MapiMessage klasse biedt een from_properties statische methode om een nieuw bericht te maken van een ingesloten bijlage. De volgende code‑snippet laat zien hoe je ingebedde e‑mailbijlagen verkrijgt:

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)

Bijlagen verwijderen

De Aspose.Email‑bibliotheek biedt de functionaliteit om bijlagen uit Microsoft Outlook‑berichten (.msg) te verwijderen. Gebruik de remove_attachments(path) methode die het pad van het berichtbestand vereist als parameter. Als een openbare statische methode kun je deze direct aanroepen zonder een object te instantieren, waardoor het proces eenvoudig en efficiënt is.

De volgende code‑snippet laat zien hoe je bijlagen uit MSG‑bestanden verwijdert met Aspose.Email:

import aspose.email as ae

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

Je kunt ook de statische destroy_attachments‑methode van de MapiMessage klasse. Het werkt sneller dan remove_attachments omdat de remove_attachments‑methode het berichtbestand parses.

import aspose.email as ae

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

MSG‑bijlagen toevoegen

Een Outlook‑bericht kan andere Microsoft Outlook‑berichten als bijlagen bevatten, zowel als gewone als ingesloten bijlagen. De MapiAttachmentCollection biedt overladen leden van de toevoegen methode om Outlook‑berichten te maken met beide soorten bijlagen.

Referentie‑bijlagen toevoegen aan MAPI‑berichten

Referentie‑bijlage verwijst doorgaans naar een bijlage die een referentie of link bevat naar een externe bron in plaats van het eigenlijke bestand. Deze referenties worden vaak gebruikt in HTML‑e‑mails om te linken naar externe afbeeldingen of bronnen die op een externe server gehost worden. In plaats van het hele bestand in te sluiten, bevat een referentie‑bijlage een URL of verwijzing naar de externe inhoud.

Om een referentie‑bijlage aan een MAPI‑bericht toe te voegen, gebruik je de add methode van de MapiAttachmentCollection class en de ReferenceAttachmentOptions klasse om te specificeren:

  • De inhoud‑URL (directe link naar het bestand)

  • De provider‑URL (link naar de locatie van het bestand of UI‑weergave)

  • De naam van de bijlage‑provider (bijv. "GoogleDrive")

zoals getoond in de onderstaande code‑voorbeeld.

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

Berichten insluiten als bijlagen

De onderstaande code‑snippet toont hoe Outlook‑MSG‑bestanden als bijlagen in een ander MSG‑bestand worden ingesloten. Een ingesloten MSG‑bestand bevat een PR_ATTACH_METHOD‑eigenschap met waarde 5, wat aangeeft dat het een bijlage van het type "message" is.

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

Ingesloten berichten lezen uit bijlagen

De onderstaande code‑snippet laat zien hoe je ingesloten berichten uit bijlagen leest.

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

Bijlagen invoegen en vervangen

Aspose.Email‑API biedt de functionaliteit om bijlagen op een specifieke index binnen het hoofd‑bericht in te voegen. Daarnaast biedt het de mogelijkheid om de inhoud van een bestaande bijlage te vervangen door een andere berichtbijlage. Hieronder staan code‑snippets die laten zien hoe je bijlagen kunt invoegen en vervangen.

Bijlagen invoegen op specifieke locaties

Aspose.Email‑API maakt het mogelijk om een MSG‑bijlage in een ouder MSG in te voegen met behulp van de Insert‑methode van de MapiAttachmentCollection. Deze methode wordt gebruikt met de handtekening MapiAttachmentCollection Insert(int index, string name, MapiMessage msg). Hieronder staat een code‑snippet die laat zien hoe je een bijlage op een specifieke locatie invoegt:

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)

Inhoud van bijlage vervangen

Je kunt de replace methode om de inhoud van een ingesloten bijlage bij te werken met nieuwe gegevens. Houd er echter rekening mee dat deze methode niet kan worden gebruikt om een bijlage met PR_ATTACH_NUM = 4 in te voegen in een collectie die slechts 2 bijlagen bevat. Hieronder staat een codefragment dat laat zien hoe u de inhoud van een bijlage vervangt:

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)

Bijlagen hernoemen in MapiMessages

Met Aspose.Email kun je eenvoudig de weergavenaam van bijlagen in e‑mailberichten die uit een bestand zijn geladen aanpassen. Het onderstaande code‑voorbeeld laat zien hoe je dit kunt doen:

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"
Werken met distributielijsten Outlook‑MSG‑bestand follow‑up- en vervaldatumbeheer in Python