Make.com als Schnittstelle<\/h2>\n
Also zeigen wir, wie wir mit alternativen Techniken E-Mails über Outlook.com versenden können – und dazu mit Make.com ein Tool zur Workflow-Automation nutzen.<\/p>\n
Im Artikel Automation mit VBA und Make <\/b>(www.vbentwickler.de\/463<\/b>) haben wir bereits gezeigt, wie wir Make.com von VBA aus ansteuern können. Dort haben wir uns angesehen, wie man ein Automations-Scenario anlegen, wie wir dieses von VBA aus starten und wie das Ergebnis der Automation abgefragt und ausgewertet werden kann.<\/p>\n
Auf den dort beschriebenen Techniken setzen wir nun auf und wollen darin den Versand einer E-Mail mit Outlook.com einbetten.<\/p>\n
Warum aber sollten wir dazu Make.com <\/b>nutzen und nicht über die Microsoft Graph API auf Outlook.com zugreifen? Weil auch hier die Authentifizierung relativ aufwendig zu realisieren ist und Make.com <\/b>uns dabei eine Menge Arbeit abnimmt.<\/p>\n
Wir gehen dabei in den folgenden Schritten vor:<\/p>\n
- \n
- Programmierung des Mailversands in Make.com<\/li>\n
- Aufruf des Mailversands in eine VBA-Prozedur<\/li>\n<\/ul>\n
Mails versenden in Make.com<\/h2>\n
Zunächst programmieren wir einen Mailversand in Make.com<\/b>, ohne dass wir Betreff, Inhalt, Empfänger und so weiter von VBA aus übergeben.<\/p>\n
Wie wir ein Make.com<\/b>-Konto anlegen und wie wir grundsätzlich Scenarios anlegen und damit arbeiten, haben wir im oben genannten Artikel beschrieben.<\/p>\n
Dazu legen wir in Make.com <\/b>ein neues Scenario an, indem wir auf der Seite All scenarios <\/b>auf Create a new scenario <\/b>klicken. Im neuen Scenario ändern wir den Namen gleich oben links auf Mail mit Outlook.com senden <\/b>(siehe Bild 1).<\/p>\n
![\"Scenario](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_003.png\")
<\/p>\nBild 1: Scenario umbenennen<\/span><\/b><\/p>\n
Danach fügen wir den Trigger ein. Wir wollen den Mailversand per VBA anstoßen, wozu wir ein XMLHTTP60<\/b>-Objekt nutzen werden.<\/p>\n
Dazu benötigen wir ein Webhook<\/b>-Element als Trigger, das wir nun hinzufügen. Dazu klicken wir auf das große Plus-Icon im Scenario und wählen Webhook|Custom webhook <\/b>aus. Hier klicken wir nun auf Add<\/b>, um einen neuen Hook hinzuzufügen (siehe Bild 2).<\/p>\n
![\"Trigger](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_002.png\")
<\/p>\nBild 2: Trigger hinzufügen und Hook anlegen<\/span><\/b><\/p>\n
Anschließend legen wir den Namen des Webhooks fest und speichern diesen mit Save<\/b> (siehe Bild 3).<\/p>\n
![\"Name](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_004.png\")
<\/p>\nBild 3: Name des Webhooks festlegen<\/span><\/b><\/p>\n
Die URL des Webhooks speichern wir in der Zwischenablage und fügen diese dann in einem Browser ein. Nach dem Betätigen der Eingabetaste sollte der Text Accepted <\/b>erscheinen.<\/p>\n
Das erste Element des Scenarios können wir damit speichern.<\/p>\n
Aktion zum Versenden von E-Mails hinzufügen<\/h2>\n
Nun klicken wir auf das Plus-Zeichen rechts vom Trigger-Element. Im Popup suchen wir den Eintrag Microsoft 365 Email (Outlook)<\/b> (siehe Bild 4).<\/p>\n
![\"Microsoft](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_005.png\")
<\/p>\nBild 4: Microsoft 365 E-Mail (Outlook)-Aktion hinzufügen<\/span><\/b><\/p>\n
Nach dem Anklicken erscheinen alle Aktionen, die diese App bereitstellt. Wir sehen gleich, dass wir eine ganze Menge Aktionen durchführen können, die mit E-Mails in Microsoft 365 Mail zu tun haben.<\/p>\n
Uns interessiert jedoch zunächst die Aktion Create and Send a Message <\/b>(siehe Bild 5).<\/p>\n
![\"Aktion](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_007.png\")
<\/p>\nBild 5: Aktion zum Versenden einer E-Mail auswählen<\/span><\/b><\/p>\n
Verbindung zu Microsoft 365 herstellen<\/h2>\n
Klicken wir diese an, wird diese Aktion angelegt und es erscheint ein Popup zur Auswahl oder zum Anlegen der Connection zu Microsoft 365<\/b> (siehe Bild 6).<\/p>\n
![\"Auswählen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_010.png\")
<\/p>\nBild 6: Auswählen oder Hinzufügen der Connection<\/span><\/b><\/p>\n
An dieser Stelle gehen wir davon aus, dass Du bereits ein Microsoft 365-Konto hast. Da dieser vermutlich noch nicht als Connection zu Make.com <\/b>hinzugefügt ist, klicken wir hier auf die Schaltfläche Add<\/b>.<\/p>\n
Im nun erscheinenden Popup geben wir eine Bezeichnung für die zu verwendende Connection an (siehe Bild 7). Eine Bezeichnung ist sinnvoll, weil wir gegebenenfalls mehrere Microsoft 365-Konten haben. Wenn wir diese noch in anderen Scenarios für den Versand von E-Mails nutzen wollen, finden wir die Connection schnell wieder, wenn wir einen aussagekräftigen Namen vergeben haben. Wir verwenden hier zum Beispiel Microsoft 365-Connection<\/b>.<\/p>\n
![\"Angeben](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_011.png\")
<\/p>\nBild 7: Angeben einer Bezeichnung für die Connection<\/span><\/b><\/p>\n
Danach klicken wir unten auf Save<\/b>.<\/p>\n
Es erscheint nun ein Microsoft-Dialog, wo wir nach der Authentifizierung die Berechtigungen von Make für den Zugriff auf unser Microsoft-Konto akzeptieren müssen (siehe Bild 8).<\/p>\n
![\"Akzeptieren](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_012.png\")
<\/p>\nBild 8: Akzeptieren der Berechtigungen<\/span><\/b><\/p>\n
Eigenschaften der E-Mail einstellen<\/h2>\n
Schließlich landen wir in dem Dialog Microsoft 365 Email (Outlook) <\/b>aus Bild 9, in dem die zuvor gewählte Connection bereits angezeigt wird.<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_013.png\")
<\/p>\nBild 9: Anlegen einer Beispiel-E-Mail<\/span><\/b><\/p>\n
Hier finden wir die üblichen Felder für das Verwenden einer E-Mail.<\/p>\n
Also tragen wir Werte in einige dieser Felder ein, zum Beispiel in Subject<\/b>, Body Content <\/b>und To Recipients<\/b>. Noch sind diese Werte statisch, später werden wir diese aus dem per VBA abgesetzten Aufruf entnehmen. Wir wollen allerdings erst einmal ausprobieren, ob das Versenden überhaupt funktioniert.<\/p>\n
Nach dem Eingeben der Eigenschaften klicken wir auf die Schaltfläche Save<\/b>.<\/p>\n
Antwort-Element hinzufügen?<\/h2>\n
Im Beispiel aus dem oben genannten Artikel haben wir noch ein Response<\/b>-Element angehängt, mit dem wir eine entsprechende Meldung zurückgegeben haben. Hier lohnt es sich eigentlich nicht, ein solches Element einzufügen – wenn wir die Connection korrekt aufgesetzt haben und die E-Mail-Daten korrekt gefüllt haben, sollten keine Fehler auftreten.<\/p>\n
Das kann jedoch dennoch der Fall sein, zum Beispiel wenn wir extern die Berechtigung für Make für den Zugriff auf Microsoft 365 entziehen. Dann sollte beim Versuch, im Kontext unserer Connection auf Microsoft 365 zuzugreifen, der Status 401 etc. zurückgeliefert werden.<\/p>\n
Leider können wir diesen Status aber nicht auslesen, da dieser vom Modul Create and Send a Message <\/b>nicht weitergegeben wird. <\/p>\n
Fehlerbehandlung einbauen<\/h2>\n
Allerdings gibt es auch in Make eine Fehlerbehandlung. Diese aktivieren wir, indem wir mit der rechten Maustaste auf das Modul Create and Send a Message klicken <\/b>und dort den Befehl Add error handler <\/b>aufrufen (siehe Bild 10).<\/p>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_018.png\")
<\/p>\nBild 10: Hinzufügen einer Fehlerbehandlung<\/span><\/b><\/p>\n
Es erscheint ein neues Modul mit dem Plus-Zeichen, für das wir das Element Webhooks|Webhook response <\/b>einfügen. Hier klicken wir in das Feld Body <\/b>und fügen die Elemente aus der Auswahl wie in Bild 11 hinzu. Außerdem stellen wir Status auf den Wert 410 <\/b>ein, der sonst normalerweise nicht verwendet wird.<\/p>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_019.png\")
<\/p>\nBild 11: Hinzufügen einer Error-Response<\/span><\/b><\/p>\n
Response im Erfolgsfall einbauen<\/h2>\n
Allerdings wollen wir auch noch eine Response einbauen, die beim erfolgreichen Mailversand ausgelöst wird und ein entsprechendes Ergebnis zurückliefert.<\/p>\n
Dazu klicken wir im Create and Send a Message<\/b>-Modul auf das Pluszeichen rechts. Hier fügen wir ein weiteres Element des Typs Webhooks|Webhook response <\/b>hinzu. Diesmal stellen wir Status <\/b>auf 201 <\/b>und Body <\/b>auf Erfolgreich versendet <\/b>ein.<\/p>\n
Außerdem benennen wir die beiden Response<\/b>-Elemente auch direkt um in Webhook Success <\/b>und Webhook Error<\/b>.<\/p>\n
Anschließend sieht unser Scenario wie in Bild 12 aus.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_020.png\")
<\/p>\nBild 12: Die Automation im Überblick<\/span><\/b><\/p>\n
Ausführen des Mailversands<\/h2>\n
Bevor wir die Automation per VBA aufrufen wollen, testen wir diese einmal. Dazu klicken wir unten links im Make-Fenster in der Menüleiste auf Run once<\/b> (siehe Bild 13) und dann auf Wait for new data<\/b>.<\/p>\n
![\"Run](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_017.png\")
<\/p>\nBild 13: Run once sorgt für das Lauschen auf einen Aufruf<\/span><\/b><\/p>\n
Dadurch lauscht die Automation auf einen Aufruf. Den führen wir aus, indem wir die Prozedur aus Listing 1 in unserer Access-Anwendung ausführen.<\/p>\n
Public Sub <\/span>Microsoft365_MailVersenden()\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 strWebhookURL = \"https:\/\/hook.eu2.make.com\/5yauwb5ehk63mudiohao3xf4mkc7lwe2\"\r\n strJSON = \"\"\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 MsgBox<\/span> \"Erfolgreich gesendet.\"\r\n Case <\/span>200\r\n MsgBox<\/span> \"Erfolgreich aufgerufen, aber nicht gesendet.\"\r\n Case <\/span>400\r\n MsgBox<\/span> \"JSON ungültig.\"\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Senden: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.statusText\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 1: Die Prozedur führt einen ersten Aufruf unserer Automation aus.<\/span><\/b><\/p>\n
Diese erfordert das Vorhandensein eines Verweises auf die Bibliothek Microsoft XML, v6.0<\/b>. Im gleichen Zuge fügen wir auch noch einen Verweis auf die Bibliothek Microsoft Scripting Runtime<\/b> hinzu (siehe Bild 14).<\/p>\n
![\"Verweise](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_001.png\")
<\/p>\nBild 14: Verweise für das VBA-Projekt<\/span><\/b><\/p>\n
Die Prozedur enthält für die Variable strWebhookURL <\/b>die URL, die wir im Element Webhooks|Custom Webhook <\/b>finden. Diese übergeben wir der open<\/b>-Methode des XMLHTTP60<\/b>-Objekts.<\/p>\n
Danach senden wir die Anfrage mit der send<\/b>-Methode ab. Dabei verwenden wir als Parameter die noch mit einer leeren Zeichenkette gefüllte Variable strJSON<\/b>. Später nutzen wir diese, um Informationen wie den Empfänger der E-Mail, Betreff und Inhalt zu übergeben.<\/p>\n
Danach werten wir den zurückgelieferten Status aus. Dieser kann verschiedene Werte liefern:<\/p>\n
- \n
- 200<\/b>: Wird geliefert, wenn der Aufruf an sich erfolgreich war, aber keines der beiden Response<\/b>-Element erreicht wurde. Tritt zum Beispiel auf, wenn man das Scenario nicht gestartet hat. Die Adresse ist dann gültig, aber es gibt nur die allgemeine Erfolgsmeldung.<\/li>\n
- 201<\/b>: Bedeutet, dass die E-Mail erfolgreich versendet wurde.<\/li>\n
- 410<\/b>: Der Rückgabewert für einen Fehler, den wir mit dem Response<\/b>-Element der Fehlerbehandlung definiert haben.<\/li>\n
- 400<\/b>: Gesendetes JSON-Dokument ist ungültig.<\/li>\n<\/ul>\n
Diese möglichen Werte adressieren wir in der Select Case<\/b>-Bedingung. <\/p>\n
Nächster Schritt: Dynamische E-Mail-Daten<\/h2>\n
Nun wird es interessant. Wir wollen nun mit der Variablen strJSON <\/b>die Informationen zusammentragen, die für das Versenden der E-Mail verwendet werden sollen – zunächst die E-Mail-Adresse des Empfängers, der Betreff und der Inhalt der E-Mail.<\/p>\n
Dabei können wir ein einfaches, aus Name-Wert-Paaren bestehendes JSON-Dokument nutzen.<\/p>\n
Dieses stellen wir wie folgt zusammen:<\/p>\n
strJSON = \"{\"\"to\"\":\"\"\" & strTo & \"\"\",\"\"subject\"\":\"\"\" _\r\n & strSubject & \"\"\",\"\"body\"\":\"\"\" & strBody & \"\"\"}\"<\/pre>\nDen Inhalt der Variablen wollen wir per Parameter an unsere Prozedur übergeben, daher ändern wir die erste Zeile wie folgt:<\/p>\n
Public Sub <\/span>Microsoft365_MailVersenden(strTo As String<\/span>, _\r\n strSubject As String<\/span>, strBody As String<\/span>)<\/pre>\nDen Rest der Prozedur können wir vorerst beibehalten.<\/p>\n
Nun erledigen wir zwei Dinge:<\/p>\n
- \n
- Wir starten erneut den Empfangsmodus der Automation. Diesmal dauerhaft, da wir noch weitere Aufrufe tätigen werden.<\/li>\n
- Außerdem schicken wir einmalig die Daten zu der Automation.<\/li>\n<\/ul>\n
Automation dauerhaft aktivieren<\/h2>\n
Dazu aktivieren wir die Option Immediately as data arrives <\/b>in Make (siehe Bild 15).<\/p>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_021.png\")
<\/p>\nBild 15: Aktivieren der Automation<\/span><\/b><\/p>\n
Danach erscheint die Meldung aus Bild 16, wo wir Delete old data <\/b>wählen.<\/p>\n
![\"Löschen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_022.png\")
<\/p>\nBild 16: Löschen alter Daten<\/span><\/b><\/p>\n
Schließlich wählen wir noch aus, dass das Scenario immer sofort ausgeführt werden soll, wenn ein Aufruf eingeht. Dazu stellen wir in Bild 17 den Wert Immediately <\/b>ein.<\/p>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_023.png\")
<\/p>\nBild 17: Einstellen der Schedule settings<\/span><\/b><\/p>\n
Damit ist die Automation nun jederzeit empfangsbereit und wir können zum ersten Mal unser JSON-Dokument übermitteln.<\/p>\n
Das erledigen wir mit dem Aufruf unserer Prozedur über eine weitere Routine (siehe Listing 2).<\/p>\n
Public Sub <\/span>Test_MailSenden()\r\n Dim <\/span>strTo As String<\/span>\r\n Dim <\/span>strSubject As String<\/span>\r\n Dim <\/span>strBody As String<\/span>\r\n strTo = \"andre@minhorst.com\"\r\n strSubject = \"Beispielbetreff einer Mail\"\r\n strBody = \"Lieber André,\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n strBody = strBody & \"hier kommt eine Testmail.\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n strBody = strBody & \"Viele Grüße\" & vbCrLf<\/span>\r\n strBody = strBody & \"Klaus\"\r\n Call<\/span> Microsoft365_MailVersenden(strTo, strSubject, strBody)\r\nEnd Sub<\/span><\/pre>\nListing 2: Prozedur zum Aufruf des Mailversands<\/span><\/b><\/p>\n
Wenn wir die Prozedur nun so aufrufen, erhalten wie den Fehler mit der Nummer 400.<\/p>\n
Das Problem ist, wie oben bereits angeführt, dass das JSON hier nicht korrekt formatiert ist. In diesem Fall liegt es an den enthaltenen Zeilenumbrüchen in der Variablen strBody<\/b>. JSON kann mit Zeilenumbrüchen nicht viel anfangen. Sie müssen hier durch \\n <\/b>ersetzt werden.<\/p>\n
Das erledigen wir, indem wir vor dem Zusammenstellen von strJSON <\/b>noch die Zeilenumbrüche in strBody <\/b>durch \\n <\/b>ersetzen:<\/p>\n
strBody = Replace<\/span>(strBody, vbCrLf<\/span>, \"\\n\")<\/pre>\nBeim nächsten Aufruf erhalten wir die Meldung, dass die Mail erfolgreich versendet wurde. Wir können immer wieder mal im Posteingang prüfen, ob die verschickten E-Mails auch tatsächlich angekommen sind.<\/p>\n
Allerdings enthalten die neuesten Versuche immer noch nicht die Daten, die wir nun mit dem JSON-Dokument übersendet haben. Der Grund ist einfach: Wir haben in unserem Microsoft 365 Email<\/b>-Modul immer noch die statischen Elemente.<\/p>\n
Diese wollen wir nun ersetzen. Dazu klicken wir erst auf das Microsoft 365 EMail<\/b>-Modul und dann beispielsweise auf das Feld Subject<\/b>.<\/p>\n
Und siehe da: Es erscheint ein Popup mit Vorschlägen zum Füllen dieses Feldes und dort finden wir auch die Elemente to<\/b>, subject <\/b>und body <\/b>vor (siehe Bild 18).<\/p>\n
![\"Zuweisen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_024.png\")
<\/p>\nBild 18: Zuweisen der Parameter<\/span><\/b><\/p>\n
Also ziehen wir hier das Element subject <\/b>hinein, in Body Content <\/b>fügen wir body <\/b>hinzu und in To Recipients <\/b>den Parameter to<\/b> (siehe Bild 19).<\/p>\n
![\"Zuweisen](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_025.png\")
<\/p>\nBild 19: Zuweisen weiterer Parameter<\/span><\/b><\/p>\n
Hier sehen wir allerdings, dass wir auch noch den Namen des Empfängers angeben können. Also speichern wir den Zwischenstand zunächst und erweitern dann unsere Zeile zum Zusammenstellen des JSON-Dokuments wie folgt:<\/p>\n
strJSON = \"{\"\"to\"\":\"\"\" & strTo & \"\"\", \"\"toName\"\":\"\"\" & strToName & \"\"\",\"\"subject\"\":\"\"\" & strSubject & \"\"\",\"\"body\"\":\"\"\" & strBody & \"\"\"}\"<\/pre>\nDies ist eine Lösung für nur einen Adressaten – wir könnten theoretisch auch noch mehrere angeben. Das wollen wir im Rahmen dieses Artikels allerdings nicht tun.<\/p>\n
JSON-Struktur in Make aktualisieren<\/h2>\n
Damit müssen wir die Struktur, die Make verarbeitet, allerdings einmal aktualisieren. Dazu klicken wir einmal auf das Modul Webhooks|Custom webhook <\/b>und klicken dort auf die Schaltfläche Redetermine data structure<\/b>. Das Modul zeigt seine Eigenschaften anschließend wie in Bild 20 an.<\/p>\n
![\"Aktualisieren](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_026.png\")
<\/p>\nBild 20: Aktualisieren der Datenstruktur<\/span><\/b><\/p>\n
Nun müssen wir noch einmal auf Run once <\/b>klicken und dann den VBA-Aufruf erneut starten.<\/p>\n
Öffnen wir anschließend wieder das Microsoft 365 Email<\/b>-Element, können wir hier nun auch das Element toName <\/b>einfügen (siehe Bild 21).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_027.png\")
<\/p>\nBild 21: Die fertig konfigurierte E-Mail<\/span><\/b><\/p>\n
Zeilenumbruch optimieren<\/h2>\n
Wenn wir uns eine der Beispielmails ansehen, finden wir schnell das nächste Problem: Offensichtlich werden die mit \\n <\/b>angegebenen Zeilenumbrüche nicht als Zeilenumbrüche dargestellt.<\/p>\n
Das ist kein Wunder: Das Microsoft 365 Email<\/b>-Modul versendet standardmäßig E-Mails im HTML-Format. Aber auch das ist kein Problem. Wir ändern einfach die entsprechende Zeile in unserer Funktion wie folgt:<\/p>\n
strBody = Replace<\/span>(strBody, vbCrLf<\/span>, \"<br>\")<\/pre>\nDamit gelingen nun auch die Zeilenumbrüche.<\/p>\n
Alternativ können wir auch einstellen, ob wir per HTML oder Plain Text versenden wollen. Im Microsoft 365 Email<\/b>-Modul können wir dies bereits über die Eigenschaft Body Content Type <\/b>einstellen.<\/p>\n
Um dieses per Parameter einzustellen, müssen wir hier die Option Map <\/b>aktivieren (siehe Bild 22). Auch die Eigenschaft Importance <\/b>müssen wir zunächst für das Mapping aktivieren. Mehr dazu im Anschluss.<\/p>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2025_02\/pic_464_028.png\")
<\/p>\nBild 22: Aktivieren der Einstellbarkeit von Body Content Type<\/span><\/b><\/p>\n
Weitere Einstellungen vornehmen<\/h2>\n
Schließlich wollen wir noch weitere Einstellungen vornehmen und auch noch Attachments an die E-Mails anhängen. Letzteres ist etwas aufwendiger. Also beginnen wir mit den einfacheren Aufgaben: der Priorität, den CC- und BCC-Empfängern und der Reply-Adresse.<\/p>\n
Professionelle JSON-Struktur<\/h2>\n
Was wir bisher gemacht haben, war funktional: Wir haben Parameter gefüllt, diese in einem JSON-Konstrukt untergebracht und die Elemente daraus den Eigenschaften des Microsoft 365 Email<\/b>-Moduls zugeordnet.<\/p>\n
Um wirklich richtig mit dieser Automation arbeiten zu können, wollen wir die Daten nun jedoch genau so übergeben, wie das Microsoft 365 Email<\/b>-Modul diese erwartet. Der Aufbau sieht dabei beispielsweise wie folgt aus:<\/p>\n
{\r\n \"subject\": \"Beispielbetreff einer Mail\",\r\n \"body\": {\r\n \"content\": \"Lieber Andr\\u00E9,<br><br>hier kommt eine Testmail.<br><br>Viele Gr\\u00FC\\u00DFe<br>Klaus\",\r\n \"contentType\": \"html\"\r\n },\r\n \"toRecipients\": [\r\n {\r\n \"address\": \"andre@minhorst.com\",\r\n \"name\": \"Andr\\u00E9 Minhorst\"\r\n }\r\n ],\r\n \"ccRecipients\": [\r\n {\r\n \"address\": \"andre@minhorst.com\",\r\n \"name\": \"Andr\\u00E9 Minhorst CC\"\r\n }\r\n ],\r\n \"bccRecipients\": [\r\n {\r\n \"address\": \"andre@minhorst.com\",\r\n \"name\": \"Andr\\u00E9 Minhorst CC\"\r\n }\r\n ],\r\n \"replyTo\": [\r\n {\r\n \"address\": \"andre@minhorst.com\",\r\n \"name\": \"Andr\\u00E9 Minhorst\"\r\n }\r\n ],\r\n \"attachments\": [\r\n {\r\n \"filename\": \"test.pdf\",\r\n \"data\": \"JVBERi0xLjYNJeLjz9MNCjE2IDAgb2JqDTw8L0xpbmVhcml6ZWQgMS9MIDE2NDI4L08gMTgvRSAxMTI0NC9OIDEvVCAxNjEyNC9IIFsgNDU3IDE1M2JqDXN0YXJ0eHJlZg0KMTE2DQolJUVPRg0K...\"\r\n }\r\n ],\r\n \"importance\": \"High\"\r\n}<\/pre>\nDabei wird direkt berücksichtigt, dass wir auch eine Liste von E-Mail-Empfängern übergeben können und nicht nur einen Empfänger. Für mehrere Empfänger würden wir entsprechend Elemente zum übergeordneten Element toRecipients <\/b>zuordnen.<\/p>\n
Funktion zum Zusammenstellen und Senden des JSON-Dokuments<\/h2>\n
Dies können wir nun in einer Funktion abbilden. Diese heißt Microsoft365_MailVersenden<\/b> und erwartet die bereits bekannten Informationen zur E-Mail als Parameter. Den ersten Teil sehen wir in Listing 3.<\/p>\n
Public Sub <\/span>Microsoft365_MailVersenden(strTo As String<\/span>, strToName As String<\/span>, strSubject As String<\/span>, strBody As String<\/span>, _\r\n Optional<\/span> strImportance As String<\/span>, Optional<\/span> strCC As String<\/span>, Optional<\/span> strCCName As String<\/span>, Optional<\/span> strBCC As <\/span>_\r\n String, Optional<\/span> strBCCName As String<\/span>, Optional<\/span> strReply As String<\/span>, Optional<\/span> strReplyName As String<\/span>, Optional<\/span> _\r\n strBodyFormat As String<\/span>, Optional<\/span> strAttachmentPath As String<\/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>dicJSON As <\/span>New<\/span> Dictionary\r\n Dim <\/span>dicBody As <\/span>New<\/span> Dictionary\r\n Dim <\/span>colToRecipients As <\/span>New<\/span> Collection\r\n Dim <\/span>dicToRecipients As <\/span>New<\/span> Dictionary\r\n Dim <\/span>colCCRecipients As <\/span>New<\/span> Collection\r\n Dim <\/span>dicCCRecipients As <\/span>New<\/span> Dictionary\r\n Dim <\/span>colBCCRecipients As <\/span>New<\/span> Collection\r\n Dim <\/span>dicBCCRecipients As <\/span>New<\/span> Dictionary\r\n Dim <\/span>colReplyToRecipients As <\/span>New<\/span> Collection\r\n Dim <\/span>dicReplyToRecipients As <\/span>New<\/span> Dictionary\r\n Dim <\/span>colAttachments As <\/span>New<\/span> Collection\r\n Dim <\/span>dicAttachment As <\/span>New<\/span> Dictionary\r\n Dim <\/span>arrBytes() As Byte<\/span>\r\n Dim <\/span>strBase64 As String<\/span>\r\n \r\n strWebhookURL = \"https:\/\/hook.eu2.make.com\/5yauwb5ehk63mudiohao3xf4mkc7lwe2\"\r\n strBody = Replace<\/span>(strBody, vbCrLf<\/span>, \"<br>\")\r\n \r\n dicJSON.Add \"subject\", strSubject\r\n dicJSON.Add \"body\", dicBody\r\n dicBody.Add \"content\", strBody\r\n dicBody.Add \"contentType\", strBodyFormat\r\n \r\n dicJSON.Add \"toRecipients\", colToRecipients\r\n colToRecipients.Add dicToRecipients\r\n dicToRecipients.Add \"address\", strTo\r\n dicToRecipients.Add \"name\", strToName\r\n ...<\/pre>\nListing 3: Funktion für den Mailversand, Teil 1<\/span><\/b><\/p>\n
Wir verwenden hier die Methoden aus dem Artikel JSON-Dokumente per Objektmodell zusammenstellen <\/b>(www.vbentwickler.de\/412<\/b>), um das JSON-Dokument zusammenzustellen.<\/p>\n
Hier deklarieren wir zunächst einige Dictionary<\/b>– und Collection<\/b>-Elemente.<\/p>\n
Wir instanzieren diese auch direkt, indem wir dem Typ das Schlüsselwort New <\/b>voranstellen. Für die Elemente der JSON-Datei mit den geschweiften Klammern benötigen wir Dictionary<\/b>-Elemente, für die mit den eckigen Klammern Collection<\/b>-Auflistungen.<\/p>\n
Das Hauptelement enthält direkt eine geschweifte Klammer, also verwenden wir ein Dictionary<\/b>-Objekt zur Aufnahme der enthaltenen Elemente wie subject<\/b>, body <\/b>und so weiter:<\/p>\n
{\r\n \"subject\": \"Beispielbetreff einer Mail\",\r\n \"body\": {\r\n ...<\/pre>\nDiesem weisen wir mit der Add<\/b>-Methode ein Name-Wert-Paar aus subject <\/b>und dem Inhalt des Parameters strSubject <\/b>zu. Das Gleiche erledigen wir für body<\/b>, content <\/b>und contentType<\/b>.<\/p>\n
Dann folgt die Auflistung der Empfänger, die in eckige Klammern eingeschlossen ist:<\/p>\n
\"toRecipients\": [<\/pre>\n
Also fügen wir dicJSON <\/b>nun das Collection<\/b>-Objekt colToRecipients <\/b>hinzu. Diesem fügen wir wiederum das Dictionary<\/b>-Objekt dicToRecipients <\/b>hinzu, das wiederum in den Name-Wert-Paaren address <\/b>und name <\/b>die Werte der Parameter strTo <\/b>und strToName <\/b>erhält.<\/p>\n
Danach prüft die Funktion, ob Werte für strCC <\/b>und strCCName <\/b>übergeben wurden (ab hier siehe Listing 4).<\/p>\n
...\r\n If <\/span>Not<\/span> (Len<\/span>(strCC) = 0 Or Len<\/span>(strCCName)) = 0 Then<\/span>\r\n dicJSON.Add \"ccRecipients\", colCCRecipients\r\n colCCRecipients.Add dicCCRecipients\r\n dicCCRecipients.Add \"address\", strCC\r\n dicCCRecipients.Add \"name\", strCCName\r\n End If<\/span>\r\n If <\/span>Not<\/span> (Len<\/span>(strCC) = 0 Or Len<\/span>(strCCName)) = 0 Then<\/span>\r\n dicJSON.Add \"bccRecipients\", colBCCRecipients\r\n colBCCRecipients.Add dicBCCRecipients\r\n dicBCCRecipients.Add \"address\", strCC\r\n dicBCCRecipients.Add \"name\", strCCName\r\n End If<\/span>\r\n \r\n If <\/span>Not<\/span> (Len<\/span>(strReply) = 0 Or Len<\/span>(strReplyName)) = 0 Then<\/span>\r\n dicJSON.Add \"replyTo\", colReplyToRecipients\r\n colReplyToRecipients.Add dicReplyToRecipients\r\n dicReplyToRecipients.Add \"address\", strReply\r\n dicReplyToRecipients.Add \"name\", strReplyName\r\n End If<\/span>\r\n \r\n
- 201<\/b>: Bedeutet, dass die E-Mail erfolgreich versendet wurde.<\/li>\n
- 200<\/b>: Wird geliefert, wenn der Aufruf an sich erfolgreich war, aber keines der beiden Response<\/b>-Element erreicht wurde. Tritt zum Beispiel auf, wenn man das Scenario nicht gestartet hat. Die Adresse ist dann gültig, aber es gibt nur die allgemeine Erfolgsmeldung.<\/li>\n