{"id":55000465,"date":"2025-04-01T00:00:00","date_gmt":"2025-07-02T14:49:28","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=465"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Microsoft_365_EMails_mit_Make_per_Klasse_senden","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Microsoft_365_EMails_mit_Make_per_Klasse_senden\/","title":{"rendered":"Microsoft 365 E-Mails mit Make per Klasse senden"},"content":{"rendered":"

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.<\/b><\/p>\n

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

Public Sub <\/span>MailVersenden()\r\n     Dim <\/span>objMail As <\/span>clsMail\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Set<\/span> objMail = New<\/span> clsMail\r\n     With<\/span> objMail\r\n         .Subject = \"Testmail von André\"\r\n         .ContentType = PlainText\r\n         .Body = \"Dies ist eine Test-E-Mail.\" & vbCrLf<\/span> & vbCrLf<\/span> & \"Viele Grüße - André\"\r\n         .AddToRecipient \"andre@minhorst.com\", \"André Minhorst\"\r\n         .AddAttachmentPath CurrentProject.Path & \"\\test.pdf\"\r\n         If <\/span>.Send(strResponse) = True<\/span> Then<\/span>\r\n             MsgBox<\/span> strResponse\r\n         Else<\/span>\r\n             MsgBox<\/span> strResponse\r\n         End If<\/span>\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Einfacher Versand einer E-Mail per Klasse<\/span><\/b><\/p>\n
Hier erstellen wir ein neues clsMail<\/b>-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<\/b>-Methode erledigt den Rest und die E-Mail landet im Postfach des angegebenen Empfängers.<\/p>\n
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:<\/p>\n
    \n
  • Ein Microsoft 365-Konto, über das Du auch E-Mails versenden kannst,<\/li>\n
  • ein Konto bei Make.com, um dieses Konto auf einfache Weise und ohne aufwendige Authentifizierung anzusteuern,<\/li>\n
  • eine Automation bei Make.com, die Deine zu versendenden Informationen entgegennimmt und sie an Microsoft 365 sendet und <\/li>\n
  • 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.<\/li>\n<\/ul>\n
    Wie die ersten Schritte gelingen, zeigen wir Dir in den folgenden Artikeln. Danach stellen wir Dir ausführlich die Ableitung einer Klasse daraus vor:<\/p>\n
      \n
    • Automation mit VBA und Make <\/b>(www.vbentwickler.de\/463<\/b>)<\/li>\n
    • Google Mail mit Make.com und VBA statt Outlook <\/b>(www.vbentwickler.de\/464<\/b>)<\/li>\n<\/ul>\n
      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.<\/p>\n
      Die Automation besteht aus wenigen, einfachen Schritten. Webhooks|Custom webhook <\/b>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).<\/p>\n
      \"Diese<\/p>\n
      Bild 1: Diese Automation steuern wir über die hier vorgestellten Klassen an.<\/span><\/b><\/p>\n
      Benötigtes JSON-Dokument<\/h2>\n
      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.<\/p>\n
      Dies sieht für unseren Aufruf von oben wie in Listing 2 aus.<\/p>\n
      {\r\n   \"subject\": \"Testmail von Andr\\u00E9\",\r\n   \"body\": {\r\n     \"content\": \"Dies ist eine Test-E-Mail.\\r\\n\\r\\nViele Gr\\u00FC\\u00DFe - Andr\\u00E9\",\r\n     \"contentType\": \"text\"\r\n   },\r\n   \"toRecipients\": [\r\n     {\r\n       \"address\": \"andre@minhorst.com\",\r\n       \"name\": \"Andr\\u00E9 Minhorst To\"\r\n     }\r\n   ],\r\n   \"attachments\": [\r\n     {\r\n       \"filename\": \"test.pdf\",\r\n       \"data\": \"JVBERi0xLjYNJeLjz9MNCjE2IDAgb2J...\"\r\n     }\r\n   ],\r\n   \"importance\": \"Normal\"\r\n}<\/pre>\n
      Listing 2: JSON-Dokument für das Versenden einer E-Mail<\/span><\/b><\/p>\n
      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.<\/p>\n
      Mapping der JSON-Daten im Make.com<\/h2>\n
      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.<\/p>\n
      \"Die<\/p>\n
      Bild 2: Die Informationen aus dem JSON-Dokument können hier gemappt werden.<\/span><\/b><\/p>\n
      Vorbereitungen<\/h2>\n
      Da wir hier viel mit JSON-Dokumenten arbeiten werden, holen wir uns die beiden Module mdlJSON <\/b>und mdlJSONDOM <\/b>hinzu. Diese können wir zum Zusammenstellen und Parsen von JSON-Dokumenten nutzen.<\/p>\n
      Außerdem benötigen wir zwei Verweise auf die Bibliotheken Microsoft XML, v6.0 <\/b>und Microsoft Scripting Runtime<\/b>. Letztere steuert das in mdlJSON <\/b>und mdlJSONDOM <\/b>verwendete Dictionary<\/b>-Element bei, das wir auch in der Klasse vermehrt einsetzen.<\/p>\n
      Klassenmodul erstellen<\/h2>\n
      Die Hauptklasse unseres Projekts heißt clsMail<\/b>. 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<\/b>-Elemente, mit denen wir die verschiedenen Mail-Adressen für Empfänger und Absender sammeln sowie für die Attachments:<\/p>\n
      \"Auswahl<\/p>\n
      Bild 3: Auswahl der Elemente der Klasse clsMail<\/span><\/b><\/p>\n
      Private <\/span>colFrom As <\/span>Collection\r\nPrivate <\/span>colToMailContacts As <\/span>Collection\r\nPrivate <\/span>colCCMailContacts As <\/span>Collection\r\nPrivate <\/span>colBCCMailContacts As <\/span>Collection\r\nPrivate <\/span>colReplyToMailContacts As <\/span>Collection\r\nPrivate <\/span>colAttachmentPaths As <\/span>Collection<\/pre>\n
      Außerdem gibt es einige Eigenschaften, die wir über Property Let\/Get<\/b>-Prozeduren nach außen veröffentlichen. Die damit erfassten Werte sollen in den wie folgt deklarierten privaten Variablen erfasst werden:<\/p>\n
      Private <\/span>m_ContentType As <\/span>ContentTypeEnum\r\nPrivate <\/span>m_Subject As String<\/span>\r\nPrivate <\/span>m_Body As String<\/span>\r\nPrivate <\/span>m_Importance As <\/span>ImportanceEnum<\/pre>\n
      Klasse initialisieren<\/h2>\n
      Damit die Collections mit den nachfolgend beschriebenen Add…<\/b>-Methoden gefüllt werden können, erstellen wir jeweils eine Instanz dieser Collection<\/b>-Objekte. Das erledigen wir in der Ereignisprozedur Class_Initialize<\/b>, das automatisch beim Erstellen der Klasse ausgelöst wird:<\/p>\n
      Private Sub <\/span>Class_Initialize()\r\n     Set<\/span> colFrom = New<\/span> Collection\r\n     Set<\/span> colToMailContacts = New<\/span> Collection\r\n     Set<\/span> colCCMailContacts = New<\/span> Collection\r\n     Set<\/span> colBCCMailContacts = New<\/span> Collection\r\n     Set<\/span> colReplyToMailContacts = New<\/span> Collection\r\n     Set<\/span> colAttachmentPaths = New<\/span> Collection\r\nEnd Sub<\/span><\/pre>\n
      Methoden zum Hinzufügen von Mailkontakten und Anlagen<\/h2>\n
      In Listing 3 sehen wir verschiedene Add…<\/b>-Methoden. Wir schauen uns diese am Beispiel der Methode AddToRecipient <\/b>an. Diese soll einen Absender-E-Mail-Kontakt zur Klasse hinzufügen.<\/p>\n
      Public Sub <\/span>AddToRecipient(strEMail As String<\/span>, strName As String<\/span>)\r\n     Dim <\/span>objMailContact As <\/span>New<\/span> clsMailContact\r\n     With<\/span> objMailContact\r\n         .Address = strEMail\r\n         .Name = strName\r\n     End With<\/span>\r\n     colToMailContacts.Add objMailContact\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>AddCCRecipient(strEMail As String<\/span>, strName As String<\/span>)\r\n     Dim <\/span>objMailContact As <\/span>New<\/span> clsMailContact\r\n     With<\/span> objMailContact\r\n         .Address = strEMail\r\n         .Name = strName\r\n     End With<\/span>\r\n     colCCMailContacts.Add objMailContact\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>AddBCCRecipient(strEMail As String<\/span>, strName As String<\/span>)\r\n     Dim <\/span>objMailContact As <\/span>New<\/span> clsMailContact\r\n     With<\/span> objMailContact\r\n         .Address = strEMail\r\n         .Name = strName\r\n     End With<\/span>\r\n     colBCCMailContacts.Add objMailContact\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>AddReplyToRecipient(strEMail As String<\/span>, strName As String<\/span>)\r\n     Dim <\/span>objMailContact As <\/span>New<\/span> clsMailContact\r\n     With<\/span> objMailContact\r\n         .Address = strEMail\r\n         .Name = strName\r\n     End With<\/span>\r\n     colReplyToMailContacts.Add objMailContact\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>AddFrom(strEMail As String<\/span>, strName As String<\/span>)\r\n     Dim <\/span>objMailContact As <\/span>clsMailContact\r\n     With<\/span> objMailContact\r\n         .Address = strEMail\r\n         .Name = strName\r\n     End With<\/span>\r\n     colFrom.Add objMailContact\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>AddAttachmentPath(strPath As String<\/span>)\r\n     colAttachmentPaths.Add strPath\r\nEnd Sub<\/span><\/pre>\n
      Listing 3: Prozeduren zum Hinzufügen von E-Mail-Kontakten und Attachments <\/span><\/b><\/p>\n
      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 <\/b>uns wird in Listing 4 abgebildet.<\/p>\n
      Private <\/span>m_Address As String<\/span>\r\nPrivate <\/span>m_Name As String<\/span>\r\nPublic Property Let <\/span>Address(strAddress As String<\/span>)\r\n     m_Address = strAddress\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Address() As String<\/span>\r\n     Address = m_Address\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Name(strName As String<\/span>)\r\n     m_Name = strName\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Name() As String<\/span>\r\n     Name = m_Name\r\nEnd Property<\/span><\/pre>\n
      Listing 4: Klassen für E-Mail-Adresse und Name eines Kontakts<\/span><\/b><\/p>\n
      In Prozeduren wie AddToRecipient <\/b>nehmen wir nun die E-Mail-Adresse und den Namen per Parameter entgegen, erstellen eine neue Instanz der Klasse clsMailContact <\/b>und weisen ihren Eigenschaften Address <\/b>und Name <\/b>die benötigten Daten hinzu. Danach hängen wir das neue clsMailContact<\/b>-Objekt an die jeweilige Collection an, in diesem Fall colToMailContacts<\/b>.<\/p>\n
      Da diese Collections klassenweit deklariert sind, gehen ihre Inhalte nicht verloren und wir können Schritt für Schritt weitere Elemente hinzufügen.<\/p>\n
      Anlagen hinzufügen<\/h2>\n
      Noch etwas einfacher gelingt dies bei den Anlagen. Die Prozedur AddAttachmentPath <\/b>nimmt den Pfad der Anlage entgegen und fügt diese einfach als Elements zur Collection colAttachmentPaths <\/b>hinzu.<\/p>\n
      Betreff hinzufügen<\/h2>\n
      Der Betreff wird in der String<\/b>-Variablen m_Subject <\/b>gespeichert. Damit wir diesen von außen schreiben und lesen können, legen wir jeweils eine Property Let<\/b>– und eine Property Get<\/b>-Prozedur an.<\/p>\n
      Die Property Let<\/b>-Prozedur nimmt einen neuen Betreff entgegen und speichert diesen in der Variablen m_Subject<\/b>:<\/p>\n
      Public Property Let <\/span>Subject(strSubject As String<\/span>)\r\n     m_Subject = strSubject\r\nEnd Property<\/span><\/pre>\n
      Die entsprechende Property Get<\/b>-Prozedur dient zum Auslesen des Betreffs:<\/p>\n
      Public Property Get <\/span>Subject() As String<\/span>\r\n     Subject = m_Subject\r\nEnd Property<\/span><\/pre>\n
      Inhalt hinzufügen<\/h2>\n
      Auf die gleiche Weise gehen wir mit dem Inhalt der E-Mail um, die in m_Body <\/b>geschrieben wird:<\/p>\n
      Public Property Let <\/span>Body(strBody As String<\/span>)\r\n     m_Body = strBody\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Body() As String<\/span>\r\n     Body = m_Body\r\nEnd Property<\/span><\/pre>\n
      ContentType festlegen<\/h2>\n
      Zum Festlegen des ContentTypes <\/b>haben wir im Standardmodul eine Enumeration erstellt, die das Auswählen des gewünschten Wertes per IntelliSense vereinfachen soll:<\/p>\n
      Public <\/span>Enum ContentTypeEnum\r\n     HTML = 1\r\n     PlainText = 2\r\nEnd Enum<\/pre>\n
      Mit den Property Let<\/b>– und Property Get<\/b>-Funktion können wir diesen Wert setzen und lesen:<\/p>\n
      Public Property Let <\/span>ContentType(lngContentType As <\/span>_\r\n         ContentTypeEnum)\r\n     m_ContentType = lngContentType\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>ContentType() As <\/span>ContentTypeEnum\r\n     ContentType = m_ContentType\r\nEnd Property<\/span><\/pre>\n
      Wichtigkeit einstellen<\/h2>\n
      Auch die Wichtigkeit einer E-Mail können wir vorgeben. Dazu geben wir wiederum die Werte mit einer Enumeration im Modul mdlGlobal <\/b>vor:<\/p>\n
      Public <\/span>Enum ImportanceEnum\r\n     High = 1\r\n     Normal = 0\r\n     Low = 2\r\nEnd Enum<\/pre>\n
      Die Prozeduren zum Einstellen sehen wir hier:<\/p>\n
      Public Property Let <\/span>Importance(lngImportance As <\/span>_\r\n         ImportanceEnum)\r\n     m_Importance = lngImportance\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Importance() As <\/span>ImportanceEnum\r\n     Importance = m_Importance\r\nEnd Property<\/span><\/pre>\n
      Funktion zum Senden einer E-Mail<\/h2>\n
      Damit kommen wir zum eigentlichen Arbeitstier dieser Klasse. Dabei handelt es sich um die Funktion Send<\/b>, die lediglich einen optionalen Parameter namens strResponse <\/b>erwartet (siehe Listing 5). Als Funktionswert liefert sie einen Boolean<\/b>-Wert, der angibt, ob die E-Mail erfolgreich an Microsoft 365 übergeben werden konnte.<\/p>\n
      Public Function <\/span>Send(Optional<\/span> strResponse As String<\/span>) As Boolean<\/span>\r\n     Dim <\/span>strWebhookURL As String<\/span>\r\n     Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n     Dim <\/span>strJSON As String<\/span>\r\n     Dim <\/span>strBody As String<\/span>\r\n     If <\/span>Not<\/span> Validate(strResponse) = True<\/span> Then<\/span>\r\n         Send = False<\/span>\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     \r\n     If <\/span>Not<\/span> CreateJSON(strJSON, strResponse) = True<\/span> Then<\/span>\r\n         Send = False<\/span>\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     strWebhookURL = \"https:\/\/hook.eu2.make.com\/5yauwb5ehk63mudiohao3xf4mkc7lwe2\"\r\n     \r\n     Inzwischenablage strJSON\r\n     \r\n     Set<\/span> objXMLHTTP = New<\/span> MSXML2.XMLHTTP60\r\n     objXMLHTTP.Open \"POST\", strWebhookURL, False<\/span>\r\n     objXMLHTTP.setRequestHeader \"Content-Type\", \"application\/json\"\r\n     \r\n     objXMLHTTP.Send strJSON\r\n     Select Case objXMLHTTP.status\r\n         Case <\/span>201\r\n             strResponse = \"201 - Erfolgreich gesendet.\" & objXMLHTTP.statusText\r\n             Send = True<\/span>\r\n         Case <\/span>200\r\n             strResponse = \"200 - Automation läuft nicht.\"\r\n         Case <\/span>400\r\n             strResponse = \"400 - JSON ungültig.\"\r\n         Case Else<\/span>\r\n             MsgBox<\/span> objXMLHTTP.status & \" Fehler beim Senden: \" - \" & objXMLHTTP.statusText & vbCrLf<\/span> & vbCrLf<\/span> _\r\n                 & objXMLHTTP.responseText\"\r\n     End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
      Listing 5: Funktion zum Senden der E-Mail<\/span><\/b><\/p>\n
      Sie prüft zuerst mit der Funktion Validate<\/b>, ob überhaupt alle für den Versand einer E-Mail benötigten Informationen geliefert wurden. Dabei handelt es sich um die Empfängeradresse, den Betreff und den Inhalt. Diese Funktion beschreiben wir weiter unten. Liefert Validate <\/b>den Wert False<\/b>, wird die Funktion Send <\/b>an dieser Stelle mit dem Rückgabewert False <\/b>verlassen.<\/p>\n
      Danach ruft sie die Funktion CreateJSON <\/b>auf, welche die Informationen aus den verschiedenen Variablen und Collections zu dem JSON-Dokument zusammenstellt, dass an Microsoft 365 gesendet werden soll.<\/p>\n
      Diese liefert das JSON-Dokument mit der Variablen strJSON <\/b>– plus mit strResponse <\/b>Hinweise, wenn CreateJSON <\/b>den Wert False <\/b>zurückliefern sollte. Diese Funktion, die wir weiter unten beschreiben, muss ebenfalls den Wert True <\/b>zurückgeben, damit wir fortfahren können.<\/p>\n
      Danach stellt die Prozedur die Adresse des Webhooks zusammen und ersetzt im Inhalt für die E-Mail Zeilenumbrüche durch das HTML-Zeichen <\/b>.<\/p>\n
      Danach startet der bereits im Artikel Google Mail mit Make.com und VBA statt Outlook <\/b>(www.vbentwickler.de\/464<\/b>) beschriebene Vorgang zum Senden der Anfrage und ihrer Auswertung.<\/p>\n
      Validieren der Daten für die E-Mail<\/h2>\n
      Die Funktion Validate <\/b>aus Listing 6 prüft, ob alle mindestens notwendigen Informationen vorliegen. Diese befinden sich in den Variablen m_Subject<\/b> und m_Body <\/b>sowie in der Collection colToMailContacts<\/b>.<\/p>\n
      Private Function <\/span>Validate(strResponse As String<\/span>) As Boolean<\/span>\r\n     If <\/span>Len<\/span>(m_Subject) = 0 Then<\/span>\r\n         strResponse = \"Kein Subject angegeben. Stelle ''Subject'' auf den gewünschten Betreff ein.\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     If <\/span>Len<\/span>(m_Body) = 0 Then<\/span>\r\n         strResponse = \"Kein Body angegeben. Stelle ''Body'' auf den gewünschten Inhalt ein.\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     If <\/span>m_ContentType = 0 Then<\/span>\r\n         strResponse = \"Kein ContentType angegeben. Stelle ''ContentType'' auf HTML oder Text ein.\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     If <\/span>colToMailContacts.Count = 0 Then<\/span>\r\n         strResponse = \"Kein Empfänger angegeben. Füge einen mit ''AddRecipientTo.Add'' hinzu.\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     Validate = True<\/span>\r\nEnd Function<\/span><\/pre>\n
      Listing 6: Funktion zum Validieren der übermittelten Daten<\/span><\/b><\/p>\n
      Ist eines dieser Elemente leer, liefert Validate <\/b>den Wert False <\/b>zurück und mit strResponse <\/b>die Angabe des entsprechenden Grundes.<\/p>\n
      JSON-Dokument zusammenstellen<\/h2>\n
      Ein JSON-Dokument könnte man auch einfach per Zeichenkettenoperationen zusammenstellen. Allerdings treten dabei sehr schnell Fehler auf, die immer erst beim Übergeben des JSON-Dokuments beim nächsten Aufruf des Webhooks auftauchen.<\/p>\n
      Also wählen wir eine mittlerweile in unseren Projekten bewährte Variante, bei der wir ein aus Dictionary<\/b>– und Collection<\/b>-Objekten bestehendes Objektmodell zusammenstellen und diesem die Name-Wert-Paare hinzufügen. Dieses Objektmodell können wir anschließend mit der Funktion ConvertToJSON <\/b>des Moduls mdlJSON <\/b>in ein JSON-Dokument umwandeln.<\/p>\n
      Mehr dazu erfährst Du im Artikel JSON-Dokumente per Objektmodell zusammenstellen <\/b>(www.vbentwickler.de\/412<\/b>).<\/p>\n
      Hauptfunktion CreateJSON<\/h2>\n
      Das Zusammenstellen dieses Objektmodells übernimmt die Funktion CreateJSON<\/b> (siehe Listing 7). Dieser übergeben wir die noch leere Variable strJSON <\/b>sowie eine Variable namens strResponse <\/b>für die Rückmeldung eventueller Fehler. Wenn das Zusammenstellen erfolgreich war, liefert die Funktion den Wert True<\/b> zurück. Dies ist theoretisch immer der Fall, da hier eine bewährte Abfolge von Anweisungen durchgeführt wird.<\/p>\n
      Private Function <\/span>CreateJSON(strJSON As String<\/span>, strResponse As String<\/span>) As Boolean<\/span>\r\n     Dim <\/span>dicJSON As <\/span>New<\/span> Dictionary\r\n     Dim <\/span>dicBodyJSON As <\/span>New<\/span> Dictionary\r\n     Dim <\/span>strContenttype As String<\/span>\r\n     Dim <\/span>strImportance As String<\/span>\r\n     \r\n     dicJSON.Add \"subject\", m_Subject\r\n     dicJSON.Add \"body\", dicBodyJSON\r\n     dicBodyJSON.Add \"content\", m_Body\r\n     strContenttype = GetContentType(m_ContentType)\r\n     dicBodyJSON.Add \"contentType\", strContenttype\r\n     \r\n     AddContacts \"toRecipients\", colToMailContacts, dicJSON\r\n     AddContacts \"ccRecipients\", colCCMailContacts, dicJSON\r\n     AddContacts \"bccRecipients\", colBCCMailContacts, dicJSON\r\n     AddContacts \"replyTo\", colReplyToMailContacts, dicJSON\r\n     AddAttachments colAttachmentPaths, dicJSON\r\n     \r\n     strImportance = GetImportance(m_Importance)\r\n     dicJSON.Add \"importance\", strImportance\r\n     \r\n     strJSON = ConvertToJson(dicJSON)\r\n     CreateJSON = True<\/span>\r\nEnd Function<\/span><\/pre>\n
      Listing 7: Hauptfunktion zum Zusammenstellen des JSON-Dokuments<\/span><\/b><\/p>\n
      Die kleine Regel lautet: Wenn wir eine JSON-Auflistung erstellen wollen, also mehrere in eckigen Klammern eingefasste Elemente, benötigen wir ein Collection-Element – wie zum Beispiel für die toRecipients<\/b>:<\/p>\n
        \"toRecipients\": [\r\n   {\r\n     \"address\": \"andre@minhorst.com\",\r\n     \"name\": \"Andr\\u00E9 Minhorst To\"\r\n   }\r\n]<\/pre>\n
      Für eine Auflistung von Elementen in geschweiften Klammern benötigen wir Dictionary<\/b>-Elemente. Das Hauptelement ist eines mit geschweiften Klammern, also deklarieren wir dafür das Dictionary<\/b>-Objekt dicJSON<\/b>. Darin fügen wir mit der Add<\/b>-Methode das Name-Wert-Paar für die Eigenschaft subject <\/b>ein.<\/p>\n
      Das body<\/b>-Element ist bereits eines mit zwei Unterelementen in geschweiften Klammern, also nutzen wir dazu ein weiteres Dictionary<\/b>-Element namens dicBodyJSON<\/b>. Diesem weisen wir mit der Add<\/b>-Methode die Eigenschaften content <\/b>und contentType <\/b>zu.<\/p>\n
      Um contentType <\/b>zu füllen, ermitteln wir zunächst mit der Funktion GetContentType <\/b>die entsprechende Zeichenfolge für den Zahlenwert aus m_ContentType<\/b>:<\/p>\n
      Private Function <\/span>GetContentType(lngContentType As <\/span>_\r\n         ContentTypeEnum) As String<\/span>\r\n     Dim <\/span>strContenttype As String<\/span>\r\n     Select Case lngContentType\r\n         Case <\/span>1\r\n             strContenttype = \"html\"\r\n         Case <\/span>2\r\n             strContenttype = \"text\"\r\n     End Select<\/span>\r\n     GetContentType = strContenttype\r\nEnd Function<\/span><\/pre>\n
      Dann fügen wir es mit Add <\/b>zu dicBodyJSON <\/b>hinzu.<\/p>\n
      Danach folgenden die Elemente toRecipients<\/b>, ccRecipients<\/b>, bccRecipients <\/b>und replyTo<\/b>. Diese sind ähnlich aufgebaut und unterscheiden sich nur durch wenige Details, daher haben wir dafür eine weitere Prozedur namens AddContacts <\/b>geschrieben. Diese rufen wir nacheinander für jedes Element auf und übergeben jeweils den Namen des Elements, zum Beispiel toRecipients<\/b>, die Collection, in der sich die entsprechenden Kontakte befinden, also zum Beispiel colToMailContacts<\/b>, sowie das Objekt dictJSON<\/b>, dem wir die neuen Unterelemente hinzufügen wollen.<\/p>\n
      Kontaktelemente zusammenstellen<\/h2>\n
      Ein solches Kontaktelement kann einen oder mehrere Kontakte enthalten. Für mehrere Empfänger in CC sieht dies beispielsweise wie folgt aus:<\/p>\n
      \"ccRecipients\": [\r\n   {\r\n     \"address\": \"andre@minhorst.com\",\r\n     \"name\": \"Andr\\u00E9 Minhorst CC\"\r\n   },\r\n   {\r\n     \"address\": \"info@andreminhorst.de\",\r\n     \"name\": \"Andr\\u00E9 Minhorst CC\"\r\n   }\r\n]<\/pre>\n
      Da wir hier ein oder mehrere Elemente gleichen Namens als Unterelemente des gleichen Elements hinzufügen, benötigen wir in der Funktion AddContacts <\/b>aus Listing 8 ein temporäres Collection<\/b>-Objekt namens colTemp<\/b>. In diesem sammeln wir die untergeordneten Dictionary<\/b>-Elemente.<\/p>\n
      Private Function <\/span>AddContacts(str As String<\/span>, colMailContacts As <\/span>Collection, dicJSON As <\/span>Dictionary)\r\n     Dim <\/span>colTemp As <\/span>New<\/span> Collection\r\n     Dim <\/span>col As <\/span>New<\/span> Collection\r\n     Dim <\/span>dic As <\/span>Dictionary\r\n     Dim <\/span>objMailContact As <\/span>clsMailContact\r\n     dicJSON.Add str, col\r\n     For Each objMailContact In colMailContacts\r\n         Set<\/span> dic = New<\/span> Dictionary\r\n         col.Add dic\r\n         dic.Add \"address\", objMailContact.Address\r\n         dic.Add \"name\", objMailContact.Name\r\n         colTemp.Add dic\r\n     Next<\/span> objMailContact\r\nEnd Function<\/span><\/pre>\n
      Listing 8: Funktion zum Hinzufügen von Kontakten<\/span><\/b><\/p>\n
      Insgesamt fügen wir als erstes dem Hauptelement dicJSON <\/b>ein Unterelement hinzu, dass den entsprechenden Namen enthält, zum Beispiel toRecipients <\/b>oder ccRecipients<\/b>.<\/p>\n
      Dann durchlaufen wir in einer For Each<\/b>-Schleife alle Kontakt-Elemente der Auflistung colMailContacts<\/b>, die Elemente des Typs clsMailContact <\/b>enthält.<\/p>\n
      Wir erstellen ein neues Dictionary<\/b>-Objekt namens dic<\/b> und fügen dieses col <\/b>hinzu (also in eckigen Klammern). Dann weisen wir dic <\/b>zwei Unterelemente für die Elemente address <\/b>und name <\/b>hinzu und weisen die Werte aus objMailContact.Address <\/b>und objMailContact.Name <\/b>zu.<\/p>\n
      Das so erstellte Objekt müssen wir in der Collection colTemp <\/b>speichern, da wir dic <\/b>für eventuelle weitere Kontakte dieser Kategorie oben in der Schleife neu erstellen.<\/p>\n
      Da wir hier direkt mit dem übergebenen Parameter dicJSON <\/b>arbeiten und dieses erweitern, benötigen wir keinen Rückgabeparameter.<\/p>\n
      Attachments hinzufügen<\/h2>\n
      Damit kehren wir zur Funktion CreateJSON <\/b>zurück, die nun die Funktion AddAttachments <\/b>aufruft. Diese stellt ähnliche Strukturen zusammen, wie es bei den Kontakten erforderlich war.<\/p>\n
      \"attachments\": [\r\n   {\r\n     \"filename\": \"test1.pdf\",\r\n     \"data\": \"JVBERi0xLjYNJeLjz9MNC2IDAgb2JqDTw8L0xpbm...\"\r\n   },\r\n   {\r\n     \"filename\": \"test.pdf\",\r\n     \"data\": \"JVBERi0xLjYNJeLjz9MNY3NiAwIG9iag08PC9GaW...\"\r\n   }\r\n]<\/pre>\n
      Die hier enthaltenen data<\/b>-Elemente sind jedoch wesentlich umfangreicher als hier abgebildet und entsprechenden einer Respräsentation der anzuhängenden Dateien.<\/p>\n
      Wir müssen die Dateien also erst einmal in eine derartige Zeichenkette umwandeln. Die Funktion AddAttachments <\/b>aus Listing 9 erledigt genau das. Sie nimmt die Collection mit den Dateipfaden der anzuhängenden Dateien entgegen sowie das Haupt-Dictionary mit den bisher hinzugefügten Elementen. Der Ablauf ist prinzipiell mit dem identisch, den wir beim Hinzufügen der Kontaktdaten erstellt haben. Wir prüfen hier in einer If…Then<\/b>-Bedingung, ob überhaupt Anlagen vorhanden sind. Falls ja, erstellen wir ein neues temporäres Collection<\/b>-Objekt, um die Unterelemente mit den Werten für filename <\/b>und data <\/b>aufzunehmen.<\/p>\n
      Private Function <\/span>AddAttachments(colAttachmentPaths As <\/span>Collection, dicJSON As <\/span>Dictionary)\r\n     Dim <\/span>colAttachmentsTemp As <\/span>Collection\r\n     Dim <\/span>col As <\/span>New<\/span> Collection\r\n     Dim <\/span>colTemp As <\/span>New<\/span> Collection\r\n     Dim <\/span>dic As <\/span>Dictionary\r\n     Dim <\/span>varAttachmentPath As Variant<\/span>\r\n     Dim <\/span>strFilename As String<\/span>\r\n     Dim <\/span>strBase64 As String<\/span>\r\n     If <\/span>Not<\/span> colAttachmentPaths.Count = 0 Then<\/span>\r\n         Set<\/span> colAttachmentsTemp = New<\/span> Collection\r\n         dicJSON.Add \"attachments\", col\r\n         For Each varAttachmentPath In colAttachmentPaths\r\n             Set<\/span> dic = New<\/span> Dictionary\r\n             col.Add dic\r\n             strFilename = Mid<\/span>(varAttachmentPath, InStrRev<\/span>(varAttachmentPath, \"\\\") + 1)\r\n             dic.Add \"filename\", strFilename\r\n             strBase64 = GetBase64FromPath(CStr(varAttachmentPath))\r\n             dic.Add \"data\", strBase64\r\n             colTemp.Add dic\r\n         Next<\/span> varAttachmentPath\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
      Listing 9: Funktion zum Hinzufügen von Attachments<\/span><\/b><\/p>\n
      Der Inhalt der Schleife unterscheidet sich insofern, als dass wir noch den Dateinamen ermitteln und mit der Funktion GetBase64FromPath <\/b>die Zeichenkette, welche die anzuhängende Datei repräsentiert. Nachdem diese Daten angehängt sind, wird die Funktion beendet.<\/p>\n
      Wichtigkeit hinzufügen<\/h2>\n
      Fehlt noch die Eigenschaft Importance<\/b>, die wir wieder durch einfache Zuweisung an dicJSON <\/b>anhängen.<\/p>\n
      Hier rufen wir die Funktion GetImportance<\/b> auf, die für die in m_Importance <\/b>angegebene Zahl den entsprechenden Text ermittelt (High<\/b>, Normal <\/b>oder Low)<\/b>:<\/p>\n
      Private Function <\/span>GetImportance(lngImportance As <\/span>ImportanceEnum) As String<\/span>\r\n     Dim <\/span>strImportance As String<\/span>\r\n     Select Case lngImportance\r\n         Case <\/span>1\r\n             strImportance = \"High\"\r\n         Case <\/span>0\r\n             strImportance = \"Normal\"\r\n         Case <\/span>2\r\n             strImportance = \"Low\"\r\n     End Select<\/span>\r\n     GetImportance = strImportance\r\nEnd Function<\/span><\/pre>\n
      Schließlich rufen wir die Funktion ConvertToJson <\/b>aus dem Modul mdlJSON <\/b>auf und wandeln das zuvor in dicJSON<\/b> erstellte Objektmodell in das JSON-Dokument in Textform um.<\/p>\n
      Zusammenfassung und Ausblick<\/h2>\n
      Mit der hier vorgestellten Lösung ist es genauso einfach, E-Mails über Microsoft 365 zu versenden, wie es zuvor mit der VBA-Programmierung von Outlook war. Mit dem Nachsatz, dass hier einige vorbereitende Schritte durchzuführen sind:<\/p>\n