Möchtest Du den gesamten Artikel lesen? Und vielleicht sogar den Artikel im PDF-Format und die Beispieldateien herunterladen? Dann hole Dir den Artikel gleich hier - völlig kostenlos!
Am liebsten wäre den meisten Microsoft-Anwendern vermutlich, wenn sie einfach ihre vorhandenen VBA-Automationen auf Basis von Microsoft Outlook verwenden könnten. Allerdings zeigt Microsoft aktuell kein Zeichen, dass das klassische Outlook für Desktop mit seiner VBA-Programmierbarkeit über das Jahr 2029 hinaus unterstützt werden wird. Die neue Outlook-Version ist allerdings noch nicht so weit, dass wir damit so arbeiten können, wie es mit der klassischen Version möglich ist. Genau genommen wird das, wenn man sich die Pläne von Microsoft ansieht, auch zumindest per VBA nicht mehr möglich sein. Um zumindest das Versenden von E-Mails von VBA aus zu realisieren, benötigen wir also eine Alternative. In diesem Artikel schauen wir uns an, wie wir Outlook.com über den Automatisierungdienst Make dazu bringen, E-Mails zu versenden – mit allen Funktionen, die wir von Outlook gewohnt sind.
Microsoft Access und Microsoft Outlook in der klassischen Version sind ein großartiges Gespann. Wer von Access aus per VBA eine E-Mail versenden wollte, konnte dies mit wenigen Zeilen Code realisieren. Outlook starten (wenn auch unsichtbar), ein neues MailItem-Objekt erstellen, Betreff, Inhalt und gegebenenfalls noch Anlagen und weitere Eigenschaften einstellen und los geht es. Die so vorbereitete E-Mail können wir mit der Send-Methode direkt absenden oder mit der Display-Methode so öffnen, als ob wir die E-Mail soeben selbst erstellt hätten – und brauchen dann nur noch auf Senden zu klicken, nachdem wir den Entwurf gegebenenfalls noch angepasst haben.
In Zukunft können wir verschiedene Alternativen nutzen:
- E-Mails unter Versendung der Bibliothek CDO versenden: Das ist jedoch aufwendig, weil sich die Parameter je nach dem zu verwendenden E-Mail-Anbieter unterscheiden. Außerdem ist auch diese Bibliothek bereits abgekündigt.
- E-Mails mit der Graph-API von Microsoft versenden: Dies haben wir uns bereits in einem Artikel in Access im Unternehmen angesehen – Mails senden mit der Microsoft Graph API (www.access-im-unternehmen.de/1532). Allerdings ist es sehr aufwendig, dies zu realisieren, da sehr viel Vorbereitung notwendig ist – speziell für die Authentifizierung am entsprechenden Outlook-Konto.
- Office-JavaScript-API: Es soll auch für das neue Outlook eine API geben. Allerdings ist hier noch unklar, ob und wie man damit Mails mit VBA erstellen und verschicken kann.
Make.com als Schnittstelle
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.
Im Artikel Automation mit VBA und Make (www.vbentwickler.de/463) 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.
Auf den dort beschriebenen Techniken setzen wir nun auf und wollen darin den Versand einer E-Mail mit Outlook.com einbetten.
Warum aber sollten wir dazu Make.com 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 uns dabei eine Menge Arbeit abnimmt.
Wir gehen dabei in den folgenden Schritten vor:
- Programmierung des Mailversands in Make.com
- Aufruf des Mailversands in eine VBA-Prozedur
Mails versenden in Make.com
Zunächst programmieren wir einen Mailversand in Make.com, ohne dass wir Betreff, Inhalt, Empfänger und so weiter von VBA aus übergeben.
Wie wir ein Make.com-Konto anlegen und wie wir grundsätzlich Scenarios anlegen und damit arbeiten, haben wir im oben genannten Artikel beschrieben.
Dazu legen wir in Make.com ein neues Scenario an, indem wir auf der Seite All scenarios auf Create a new scenario klicken. Im neuen Scenario ändern wir den Namen gleich oben links auf Mail mit Outlook.com senden (siehe Bild 1).
Bild 1: Scenario umbenennen
Danach fügen wir den Trigger ein. Wir wollen den Mailversand per VBA anstoßen, wozu wir ein XMLHTTP60-Objekt nutzen werden.
Dazu benötigen wir ein Webhook-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 aus. Hier klicken wir nun auf Add, um einen neuen Hook hinzuzufügen (siehe Bild 2).
Bild 2: Trigger hinzufügen und Hook anlegen
Anschließend legen wir den Namen des Webhooks fest und speichern diesen mit Save (siehe Bild 3).
Bild 3: Name des Webhooks festlegen
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 erscheinen.
Das erste Element des Scenarios können wir damit speichern.
Aktion zum Versenden von E-Mails hinzufügen
Nun klicken wir auf das Plus-Zeichen rechts vom Trigger-Element. Im Popup suchen wir den Eintrag Microsoft 365 Email (Outlook) (siehe Bild 4).
Bild 4: Microsoft 365 E-Mail (Outlook)-Aktion hinzufügen
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.
Uns interessiert jedoch zunächst die Aktion Create and Send a Message (siehe Bild 5).
Bild 5: Aktion zum Versenden einer E-Mail auswählen
Verbindung zu Microsoft 365 herstellen
Klicken wir diese an, wird diese Aktion angelegt und es erscheint ein Popup zur Auswahl oder zum Anlegen der Connection zu Microsoft 365 (siehe Bild 6).
Bild 6: Auswählen oder Hinzufügen der Connection
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 hinzugefügt ist, klicken wir hier auf die Schaltfläche Add.
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.
Bild 7: Angeben einer Bezeichnung für die Connection
Danach klicken wir unten auf Save.
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).
Bild 8: Akzeptieren der Berechtigungen
Eigenschaften der E-Mail einstellen
Schließlich landen wir in dem Dialog Microsoft 365 Email (Outlook) aus Bild 9, in dem die zuvor gewählte Connection bereits angezeigt wird.
Bild 9: Anlegen einer Beispiel-E-Mail
Hier finden wir die üblichen Felder für das Verwenden einer E-Mail.
Also tragen wir Werte in einige dieser Felder ein, zum Beispiel in Subject, Body Content und To Recipients. 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.
Nach dem Eingeben der Eigenschaften klicken wir auf die Schaltfläche Save.
Antwort-Element hinzufügen?
Im Beispiel aus dem oben genannten Artikel haben wir noch ein Response-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.
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.
Leider können wir diesen Status aber nicht auslesen, da dieser vom Modul Create and Send a Message nicht weitergegeben wird.
Fehlerbehandlung einbauen
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 und dort den Befehl Add error handler aufrufen (siehe Bild 10).
Bild 10: Hinzufügen einer Fehlerbehandlung
Es erscheint ein neues Modul mit dem Plus-Zeichen, für das wir das Element Webhooks|Webhook response einfügen. Hier klicken wir in das Feld Body und fügen die Elemente aus der Auswahl wie in Bild 11 hinzu. Außerdem stellen wir Status auf den Wert 410 ein, der sonst normalerweise nicht verwendet wird.
Bild 11: Hinzufügen einer Error-Response
Response im Erfolgsfall einbauen
Allerdings wollen wir auch noch eine Response einbauen, die beim erfolgreichen Mailversand ausgelöst wird und ein entsprechendes Ergebnis zurückliefert.
Dazu klicken wir im Create and Send a Message-Modul auf das Pluszeichen rechts. Hier fügen wir ein weiteres Element des Typs Webhooks|Webhook response hinzu. Diesmal stellen wir Status auf 201 und Body auf Erfolgreich versendet ein.
Außerdem benennen wir die beiden Response-Elemente auch direkt um in Webhook Success und Webhook Error.
Anschließend sieht unser Scenario wie in Bild 12 aus.
Bild 12: Die Automation im Überblick
Ausführen des Mailversands
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 (siehe Bild 13) und dann auf Wait for new data.
Bild 13: Run once sorgt für das Lauschen auf einen Aufruf
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.
Public Sub Microsoft365_MailVersenden() Dim strWebhookURL As String Dim objXMLHTTP As MSXML2.XMLHTTP60 Dim strJSON As String strWebhookURL = "https://hook.eu2.make.com/5yauwb5ehk63mudiohao3xf4mkc7lwe2" strJSON = "" Set objXMLHTTP = New MSXML2.XMLHTTP60 objXMLHTTP.Open "POST", strWebhookURL, False objXMLHTTP.setRequestHeader "Content-Type", "application/json" objXMLHTTP.send strJSON Select Case objXMLHTTP.status Case 201 MsgBox "Erfolgreich gesendet." Case 200 MsgBox "Erfolgreich aufgerufen, aber nicht gesendet." Case 400 MsgBox "JSON ungültig." Case Else MsgBox "Fehler beim Senden: " & objXMLHTTP.status & " - " & objXMLHTTP.statusText End Select End Sub
Listing 1: Die Prozedur führt einen ersten Aufruf unserer Automation aus.
Diese erfordert das Vorhandensein eines Verweises auf die Bibliothek Microsoft XML, v6.0. Im gleichen Zuge fügen wir auch noch einen Verweis auf die Bibliothek Microsoft Scripting Runtime hinzu (siehe Bild 14).
Bild 14: Verweise für das VBA-Projekt
Die Prozedur enthält für die Variable strWebhookURL die URL, die wir im Element Webhooks|Custom Webhook finden. Diese übergeben wir der open-Methode des XMLHTTP60-Objekts.
Danach senden wir die Anfrage mit der send-Methode ab. Dabei verwenden wir als Parameter die noch mit einer leeren Zeichenkette gefüllte Variable strJSON. Später nutzen wir diese, um Informationen wie den Empfänger der E-Mail, Betreff und Inhalt zu übergeben.
Danach werten wir den zurückgelieferten Status aus. Dieser kann verschiedene Werte liefern:
- 200: Wird geliefert, wenn der Aufruf an sich erfolgreich war, aber keines der beiden Response-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.
- 201: Bedeutet, dass die E-Mail erfolgreich versendet wurde.
- 410: Der Rückgabewert für einen Fehler, den wir mit dem Response-Element der Fehlerbehandlung definiert haben.
- 400: Gesendetes JSON-Dokument ist ungültig.
Diese möglichen Werte adressieren wir in der Select Case-Bedingung.
Nächster Schritt: Dynamische E-Mail-Daten
Nun wird es interessant. Wir wollen nun mit der Variablen strJSON 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.
Dabei können wir ein einfaches, aus Name-Wert-Paaren bestehendes JSON-Dokument nutzen.
Dieses stellen wir wie folgt zusammen:
strJSON = "{""to"":""" & strTo & """,""subject"":""" _
& strSubject & """,""body"":""" & strBody & """}"
Den Inhalt der Variablen wollen wir per Parameter an unsere Prozedur übergeben, daher ändern wir die erste Zeile wie folgt:
Public Sub Microsoft365_MailVersenden(strTo As String, _ strSubject As String, strBody As String)
Den Rest der Prozedur können wir vorerst beibehalten.
Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...
den kompletten Artikel im PDF-Format mit Beispieldatenbank
diesen und alle anderen Artikel mit dem Jahresabo