Microsoft 365 E-Mails mit Make per Klasse senden

2/2025, 2025, Interaktiv, Word programmieren

Lies diesen Artikel und viele weitere mit einem kostenlosen, einwöchigen Testzugang.

In unserem Artikel Google Mail mit Make.com und VBA statt Outlook (www.vbentwickler.de/464) haben wir detailliert gezeigt, wie man per VBA die Informationen zum Versenden einer E-Mail zusammenstellt und diese dann über den Automatisierungsdienst Make.com an Microsoft 365 E-Mail sendet. Hier sind wir allerdings nur so weit gekommen, dass wir die notwendige JSON-Datei mit den eigentlichen Daten der E-Mail Zeile für Zeile zusammengestellt und mit den nötigen Daten gefüllt haben. Für einen ersten Schritt nicht schlecht, aber wenn man diesen Weg professionell nutzen möchte, sollte man sich dazu eine ordentliche Klasse bauen. Eine, die man schnell initialisieren und mit den Daten wie Empfänger, Betreff, Inhalt, CC/BCC-Empfängern und Anlagen füllen kann und die eine einfache Send-Methode enthält. Ganz genau so, wie es auch mit VBA und Outlook geht – mit dem Unterschied, dass die hier vorgestellte Methode vermutlich wesentlich bessere Chancen hat, die nächsten fünf Jahre zu überleben.

Das Versenden von E-Mails per VBA könnte so einfach sein. Dazu benötigen wir lediglich eine Prozedur wie die aus Listing 1.

Public Sub MailVersenden()
     Dim objMail As clsMail
     Dim strResponse As String
     Set objMail = New clsMail
     With objMail
         .Subject = "Testmail von André"
         .ContentType = PlainText
         .Body = "Dies ist eine Test-E-Mail." & vbCrLf & vbCrLf & "Viele Grüße - André"
         .AddToRecipient "andre@minhorst.com", "André Minhorst"
         .AddAttachmentPath CurrentProject.Path & "\test.pdf"
         If .Send(strResponse) = True Then
             MsgBox strResponse
         Else
             MsgBox strResponse
         End If
     End With
End Sub

Listing 1: Einfacher Versand einer E-Mail per Klasse

Hier erstellen wir ein neues clsMail-Objekt und füllen es mit den für eine E-Mail benötigten Daten wie Empfänger, Betreff, Inhalt und Anlagen. Ein Aufruf der Send-Methode erledigt den Rest und die E-Mail landet im Postfach des angegebenen Empfängers.

Dazu brauchen wir allerdings noch ein wenig mehr – aber das ist nur einmal einzurichten und läuft dann, gegebenenfalls auch in all Deinen Anwendungen aufrufbar. Was wir noch benötigen:

  • Ein Microsoft 365-Konto, über das Du auch E-Mails versenden kannst,
  • ein Konto bei Make.com, um dieses Konto auf einfache Weise und ohne aufwendige Authentifizierung anzusteuern,
  • eine Automation bei Make.com, die Deine zu versendenden Informationen entgegennimmt und sie an Microsoft 365 sendet und
  • die hier vorgestellten VBA-Klassen, welche die Daten für Deine E-Mail im entsprechenden Format zusammenstellen und sie an Make.com schicken, damit dieses den Rest der Arbeit erledigt.

Wie die ersten Schritte gelingen, zeigen wir Dir in den folgenden Artikeln. Danach stellen wir Dir ausführlich die Ableitung einer Klasse daraus vor:

  • Automation mit VBA und Make (www.vbentwickler.de/463)
  • Google Mail mit Make.com und VBA statt Outlook (www.vbentwickler.de/464)

Im ersten Artikel geht es um die Grundlagen zur Steuerung von Webprodukten wie Microsoft 365 et cetera mit Make.com. Der zweite Artikel zeigt, wie wir Make.com dazu nutzen, eine E-Mail über Microsoft 365 zu versenden. Dort lernst Du, wie Du eine entsprechende Automation zusammenstellst. Auf diese Automation bauen wir im vorliegenden Artikel auf.

Die Automation besteht aus wenigen, einfachen Schritten. Webhooks|Custom webhook nimmt die Anfrage entgegen. Microsoft 365 Email liest die übermittelten Daten aus und versendet die E-Mail. Das obere Response-Element sendet eine Rückgabe, wenn die E-Mail erfolgreich versendet wurde, die untere eine Rückgabe mit Informationen bezüglich auftretender Fehler (siehe Bild 1).

Diese Automation steuern wir über die hier vorgestellten Klassen an.

Bild 1: Diese Automation steuern wir über die hier vorgestellten Klassen an.

Benötigtes JSON-Dokument

Im Folgenden werden dazu zum Beispiel das JSON-Dokument zusammensetzen, das über den Webhook an Microsoft 365 gesendet wird, damit es von dort verschickt werden kann.

Dies sieht für unseren Aufruf von oben wie in Listing 2 aus.

{
   "subject": "Testmail von Andr\u00E9",
   "body": {
     "content": "Dies ist eine Test-E-Mail.\r\n\r\nViele Gr\u00FC\u00DFe - Andr\u00E9",
     "contentType": "text"
   },
   "toRecipients": [
     {
       "address": "andre@minhorst.com",
       "name": "Andr\u00E9 Minhorst To"
     }
   ],
   "attachments": [
     {
       "filename": "test.pdf",
       "data": "JVBERi0xLjYNJeLjz9MNCjE2IDAgb2J..."
     }
   ],
   "importance": "Normal"
}

Listing 2: JSON-Dokument für das Versenden einer E-Mail

Dieses Beispiel enthält nur die wichtigsten Elemente. Wir könnten noch weitere To-Empfänger einfügen, CC- und BCC-Empfänger, Reply-Adressen oder weitere Attachments.

Mapping der JSON-Daten im Make.com

Die so gelieferten Informationen können wir in Make.com wie in Bild 2 verarbeiten. Hier klicken wir einfach nur in eines der vorhandenen Eigenschaftsfelder und wählen die im JSON-Dokument enthaltenen Informationen aus.

Die Informationen aus dem JSON-Dokument können hier gemappt werden.

Bild 2: Die Informationen aus dem JSON-Dokument können hier gemappt werden.

Vorbereitungen

Da wir hier viel mit JSON-Dokumenten arbeiten werden, holen wir uns die beiden Module mdlJSON und mdlJSONDOM hinzu. Diese können wir zum Zusammenstellen und Parsen von JSON-Dokumenten nutzen.

Außerdem benötigen wir zwei Verweise auf die Bibliotheken Microsoft XML, v6.0 und Microsoft Scripting Runtime. Letztere steuert das in mdlJSON und mdlJSONDOM verwendete Dictionary-Element bei, das wir auch in der Klasse vermehrt einsetzen.

Klassenmodul erstellen

Die Hauptklasse unseres Projekts heißt clsMail. Sie soll per IntelliSense alle benötigten Eigenschaften, Funktionen und Methoden anbieten (siehe Bild 3). Dazu definieren wir einige Elemente, die extern sichtbar sein sollen und einige interne Elemente. Die internen Elemente sind zum Beispiel die folgenden Collection-Elemente, mit denen wir die verschiedenen Mail-Adressen für Empfänger und Absender sammeln sowie für die Attachments:

Auswahl der Elemente der Klasse clsMail

Bild 3: Auswahl der Elemente der Klasse clsMail

Private colFrom As Collection
Private colToMailContacts As Collection
Private colCCMailContacts As Collection
Private colBCCMailContacts As Collection
Private colReplyToMailContacts As Collection
Private colAttachmentPaths As Collection

Außerdem gibt es einige Eigenschaften, die wir über Property Let/Get-Prozeduren nach außen veröffentlichen. Die damit erfassten Werte sollen in den wie folgt deklarierten privaten Variablen erfasst werden:

Private m_ContentType As ContentTypeEnum
Private m_Subject As String
Private m_Body As String
Private m_Importance As ImportanceEnum

Klasse initialisieren

Damit die Collections mit den nachfolgend beschriebenen Add…-Methoden gefüllt werden können, erstellen wir jeweils eine Instanz dieser Collection-Objekte. Das erledigen wir in der Ereignisprozedur Class_Initialize, das automatisch beim Erstellen der Klasse ausgelöst wird:

Private Sub Class_Initialize()
     Set colFrom = New Collection
     Set colToMailContacts = New Collection
     Set colCCMailContacts = New Collection
     Set colBCCMailContacts = New Collection
     Set colReplyToMailContacts = New Collection
     Set colAttachmentPaths = New Collection
End Sub

Methoden zum Hinzufügen von Mailkontakten und Anlagen

In Listing 3 sehen wir verschiedene Add…-Methoden. Wir schauen uns diese am Beispiel der Methode AddToRecipient an. Diese soll einen Absender-E-Mail-Kontakt zur Klasse hinzufügen.

Public Sub AddToRecipient(strEMail As String, strName As String)
     Dim objMailContact As New clsMailContact
     With objMailContact
         .Address = strEMail
         .Name = strName
     End With
     colToMailContacts.Add objMailContact
End Sub
Public Sub AddCCRecipient(strEMail As String, strName As String)
     Dim objMailContact As New clsMailContact
     With objMailContact
         .Address = strEMail
         .Name = strName
     End With
     colCCMailContacts.Add objMailContact
End Sub
Public Sub AddBCCRecipient(strEMail As String, strName As String)
     Dim objMailContact As New clsMailContact
     With objMailContact
         .Address = strEMail
         .Name = strName
     End With
     colBCCMailContacts.Add objMailContact
End Sub
Public Sub AddReplyToRecipient(strEMail As String, strName As String)
     Dim objMailContact As New clsMailContact
     With objMailContact
         .Address = strEMail
         .Name = strName
     End With
     colReplyToMailContacts.Add objMailContact
End Sub
Public Sub AddFrom(strEMail As String, strName As String)
     Dim objMailContact As clsMailContact
     With objMailContact
         .Address = strEMail
         .Name = strName
     End With
     colFrom.Add objMailContact
End Sub
Public Sub AddAttachmentPath(strPath As String)
     colAttachmentPaths.Add strPath
End Sub

Listing 3: Prozeduren zum Hinzufügen von E-Mail-Kontakten und Attachments

Ein E-Mail-Kontakt, wie wir ihn als Absender, Empfänger, CC oder BCC angeben können, erfordert aber immer die Angabe von E-Mail-Adresse und Name. Damit wir diese gemeinsam in einer Collection unterbringen können, haben wir dazu noch eine Klasse erstellt. Diese heißt clsMailContact uns wird in Listing 4 abgebildet.

Private m_Address As String
Private m_Name As String
Public Property Let Address(strAddress As String)
     m_Address = strAddress
End Property
Public Property Get Address() As String
     Address = m_Address
End Property
Public Property Let Name(strName As String)
     m_Name = strName
End Property
Public Property Get Name() As String
     Name = m_Name
End Property

Listing 4: Klassen für E-Mail-Adresse und Name eines Kontakts

In Prozeduren wie AddToRecipient nehmen wir nun die E-Mail-Adresse und den Namen per Parameter entgegen, erstellen eine neue Instanz der Klasse clsMailContact und weisen ihren Eigenschaften Address und Name die benötigten Daten hinzu. Danach hängen wir das neue clsMailContact-Objekt an die jeweilige Collection an, in diesem Fall colToMailContacts.

Da diese Collections klassenweit deklariert sind, gehen ihre Inhalte nicht verloren und wir können Schritt für Schritt weitere Elemente hinzufügen.

Anlagen hinzufügen

Noch etwas einfacher gelingt dies bei den Anlagen. Die Prozedur AddAttachmentPath nimmt den Pfad der Anlage entgegen und fügt diese einfach als Elements zur Collection colAttachmentPaths hinzu.

Betreff hinzufügen

Der Betreff wird in der String-Variablen m_Subject gespeichert. Damit wir diesen von außen schreiben und lesen können, legen wir jeweils eine Property Let– und eine Property Get-Prozedur an.

Die Property Let-Prozedur nimmt einen neuen Betreff entgegen und speichert diesen in der Variablen m_Subject:

Public Property Let Subject(strSubject As String)
     m_Subject = strSubject
End Property

Die entsprechende Property Get-Prozedur dient zum Auslesen des Betreffs:

Public Property Get Subject() As String
     Subject = m_Subject
End Property

Inhalt hinzufügen

Auf die gleiche Weise gehen wir mit dem Inhalt der E-Mail um, die in m_Body geschrieben wird:

Public Property Let Body(strBody As String)
     m_Body = strBody
End Property
Public Property Get Body() As String
     Body = m_Body
End Property

ContentType festlegen

Zum Festlegen des ContentTypes haben wir im Standardmodul eine Enumeration erstellt, die das Auswählen des gewünschten Wertes per IntelliSense vereinfachen soll:

Public Enum ContentTypeEnum
     HTML = 1
     PlainText = 2
End Enum

Mit den Property Let– und Property Get-Funktion können wir diesen Wert setzen und lesen:

Public Property Let ContentType(lngContentType As _
         ContentTypeEnum)
     m_ContentType = lngContentType
End Property
Public Property Get ContentType() As ContentTypeEnum
     ContentType = m_ContentType
End Property

Wichtigkeit einstellen

Auch die Wichtigkeit einer E-Mail können wir vorgeben. Dazu geben wir wiederum die Werte mit einer Enumeration im Modul mdlGlobal vor:

Public Enum ImportanceEnum
     High = 1
     Normal = 0
     Low = 2
End Enum

Die Prozeduren zum Einstellen sehen wir hier:

Public Property Let Importance(lngImportance As _
         ImportanceEnum)
     m_Importance = lngImportance
End Property
Public Property Get Importance() As ImportanceEnum
     Importance = m_Importance
End Property

Funktion zum Senden einer E-Mail

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

Testzugang

eine Woche kostenlosen Zugriff auf diesen und mehr als 1.000 weitere Artikel

diesen und alle anderen Artikel mit dem Jahresabo

Schreibe einen Kommentar