Hier findest Du einige Grundlagen allgemein zum Thema Automatisierung und ein erstes Beispiel für eine Automation auf Basis von Microsoft Outlook und Microsoft To Do.<\/p>\n
Automation per VBA nutzen<\/h2>\n
Wie Du in den obigen Artikeln erfährst, gibt es verschiedene Möglichkeiten, wie Du Automationen mit den verschiedenen Tools von VBA aus starten kannst. Für das Tool Zapier sind die Möglichkeiten ein klein wenig eingeschränkter, denn wir können damit keine Ergebnisse über die Erfolgsmeldung hinaus als Rückgabewert erhalten. Bei dem anderen Tool Make.com sieht dies anders aus – hier können wir explizit festlegen, welche Informationen nach dem Durchlaufen einer Automation an den aufrufenden VBA-Code zurückgeliefert werden sollen. Dies schauen wir uns in weiteren Artikeln an.<\/p>\n
Dafür liefert Zapier wieder mehr Möglichkeiten bei der Zusammenarbeit mit dem SQL Server und anderen Datenbanksystemen, denn hier können wir mit dem sogenannten Polling auch auf Änderungen im Datenbestand reagieren.<\/p>\n
VBA und Software wie Access, Excel, Outlook und Co. als Trigger für Zapier<\/h2>\n
Wie in den oben angegebenen Artikeln beschrieben, haben Automationen einen Trigger und anschließend auszuführende Aktionen. Außerdem hat jedes namhafte SaaS-Tool Schnittstellen, die man von Zapier aus nutzen kann.<\/p>\n
Wenn wir einen neuen Zap anlegen, finden wir hier die beiden mindestens notwendigen Elemente Trigger <\/b>und Action <\/b>(siehe Bild 1).<\/p>\n
![\"Diesen](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_002.png\")
<\/p>\n
Bild 1: Diesen Trigger wollen wir per VBA ansteuern.<\/span><\/b><\/p>\n Klicken wir hier auf Trigger, erscheint der Dialog zur Auswahl der verfügbaren Trigger (siehe Bild 2). Hier können wir in der Suchleiste Visual Basic<\/b>, Microsoft Access <\/b>oder andere Office-Anwendungen eingeben – wir finden keinen passenden Trigger, der uns weiterhilft. Es gibt zwar welche für Outlook, Excel oder Word, aber dies betrifft die Online-Anwendungen, nicht die gleichnamigen Desktop-Programme.<\/p>\n Bild 2: Einen Trigger für VBA oder eine der Office-Anwendungen finden wir nicht. Dafür aber einen für Webhooks.<\/span><\/b><\/p>\n Wir sehen hier jedoch einen Eintrag namens Webhooks. Das ist unser Weg zum Triggern von Zapier-Automationen per Visual Basic.<\/p>\n Webhooks sind nichts anderes als URLs, die von Zapier zur Verfügung gestellt werden und die wir von beliebigen anderen Anwendungen aus aufrufen können.<\/p>\n Diese können wir mit Visual Basic genauso aufrufen, wie wir es bereits mit verschiedenen Rest-APIs gemacht haben. Dazu sind grundsätzlich erst einmal nur wenige Zeilen Code notwendig.<\/p>\n Bevor wir uns dem Code zuwenden, führen wir aber erst einmal die notwendigen Arbeiten mit Zapier durch. Nach einem Klick auf den Eintrag Webhooks<\/b> finden wir drei verschiedene Trigger vor (siehe Bild 3). Diese können wir wie folgt verwenden:<\/p>\n Bild 3: Verschiedene Webhooks<\/span><\/b><\/p>\n Wir schauen uns zunächst die Variante mit Catch Hook <\/b>an. Damit können wir zum nächsten Schritt namens Configure weitergehen. Hier sehen wir die Option Pick off a Child Key<\/b>.<\/p>\n Damit können wir festlegen, dass nur bestimmte Elemente eines eventuell übergebenen JSON-Dokuments weiterverarbeitet werden sollen. Aktuell wollen wir dies nicht nutzen und klicken direkt auf Continue<\/b>.<\/p>\n Damit gelangen wir zum Bereich Test<\/b>, wo wir die URL vorfinden, die wir zum Auslösen des Triggers nutzen können (siehe Bild 4).<\/p>\n Bild 4: Die fertige Webhook-URL<\/span><\/b><\/p>\n Klicken wir nun auf Test trigger<\/b>, erhalten wir als Antwort No request found<\/b>. Das ist logisch, denn diese URL wurde speziell für uns definiert und wir haben sie noch nicht aufgerufen. Das können wir nun erst einmal über den Webbrowser erledigen. Dazu kopieren wir die URL in die Zwischenablage und fügen sie in die URL-Leiste des Browsers ein.<\/p>\n Die Antwort sehen wir in Bild 5. Wichtig ist das unterste Name-Wert-Paar namens status<\/b>, das den Wert success <\/b>liefert.<\/p>\n Bild 5: Aufruf mit der Antwort von Zapier<\/span><\/b><\/p>\n Wechseln wir nun zurück nach Zapier, können wir erneut testen und erhalten auch hier einen Eintrag namens request A<\/b>.<\/p>\n Auch wenn wir einfach nur eine Automation starten können, indem wir die URL des Webhooks aufrufen, wollen wir vermutlich in den meisten Fällen Daten übergeben, die in den folgenden Aktionen weiterverarbeitet werden sollen.<\/p>\n Dazu haben wir zwei Möglichkeiten:<\/p>\n Unabhängig davon, welche Variante wir nutzen, ist es wichtig, dass wir die Informationen immer in der gleichen Form übergeben und dass wir diese auch beim Einrichten der Automation so angeben.<\/p>\n Wir können in den folgenden Aktionen nur auf Daten zugreifen, die in einem der vorherigen Testaufrufe auch übergeben wurden. Wir schauen uns das an einem Beispiel an und übergeben einige Parameter, den wir an die URL anhängen – hier email<\/b>, subject <\/b>und body<\/b>. Die URL sieht nun wie folgt aus:<\/p>\n Nun können wir in Zapier auf Find new records <\/b>klicken und sehen den neuen Eintrag. Klicken wir diesen an, erscheint ein Bereich, der alle mit diesem Aufruf gelieferten Informationen anzeigt (siehe Bild 6).<\/p>\n Bild 6: Ein Aufruf mit einem Parameter<\/span><\/b><\/p>\n Dies können wir nun als Basis für eine weitere Aktion nutzen. Dazu klicken wir auf Continue with selected record <\/b>und landen in der Auswahl der App, die wir für den nächsten Schritt nutzen wollen.<\/p>\n Wie den Parametern unschwer zu entnehmen ist, wollen wir als Aktion eine E-Mail versenden.<\/p>\n Dazu wählen wir im nächsten Schritt, wo es um die App für die folgende Aktion geht, Microsoft Outlook aus (siehe Bild 7).<\/p>\n Bild 7: Auswahl von Microsoft Outlook für die Aktion<\/span><\/b><\/p>\n Nun wählen wir unter Action event <\/b>den Eintrag Send Email <\/b>aus (siehe Bild 8).<\/p>\n Bild 8: Anlegen der Aktion zum Senden einer E-Mail<\/span><\/b><\/p>\n Unter Account wählen wir nun den Outlook-Account aus, mit dem wir die E-Mails versenden wollen. Wenn Du bereits das Beispiel aus dem Artikel Automation mit Zapier in der Praxis <\/b>(www.vbentwickler.de\/4<\/b>) ausprobiert hast, findest Du hier bereits einen Account vor.<\/p>\n Anschließend weisen wir der Aktion Send Email <\/b>die Parameter zu, die wir der URL hinzugefügt haben (siehe Bild 9):<\/p>\n Bild 9: Hinzufügen der Parameter aus dem Trigger<\/span><\/b><\/p>\n Mit einem Klick auf Continue landen wir wieder im Test-Bereich. Hier können wir nun mit einem Klick auf Test Step <\/b>einen erneuten Test durchführen.<\/p>\n Wenn wir alles korrekt konfiguriert haben, erscheint kurz danach bereits die versendete E-Mail in unserem Posteingang. Damit sind die ersten Voraussetzungen erfüllt, um das Auslösen des Triggers per VBA zu realisieren<\/p>\n Wer bereits einmal die Ansteuerung einer Rest-API programmiert hat, weiß, dass es je nach Authentifizierungsmethode manchmal je nach API etwas komplizierter sein kann, die Anmeldung an der Rest-API zu programmieren.<\/p>\n Da ist es sehr erfreulich, dass dies hier nicht der Fall ist. Es gibt weder eine API-Key noch eine andere Authentifierungsmethode. Wir können den Request einfach an Zapier schicken.<\/p>\n Das ist auch logisch: Immerhin konnten wir das auch einfach über das Browser-Fenster durch Eingabe der URL erledigen.<\/p>\n Eine gewisse Sicherheit ist auch bereits dadurch gegeben, dass Zapier eine URL zusammenstellt, die nicht einfach zu erratende Elemente enthält.<\/p>\n Wenn wir diese URL nur von unserer Access-Anwendung aus aufrufen, besteht auch kaum Gefahr, dass jemand Kenntnis dieser URL erhält.<\/p>\n Wenn wir dennoch die Sicherheit erhöhen möchten, können wir noch einen Parameter hinzufügen, mit dem wir einen selbst vergebenen Schlüssel übergeben. Diesen können wir in der Automation prüfen und diese nur dann durchführen, wenn der Schlüssel korrekt ist.<\/p>\n Zunächst einmal wollen wir jedoch ohne diese zusätzliche Sicherheitsmaßnahme arbeiten.<\/p>\n Dazu erstellen wir eine neue, leere Access-Datenbank und öffnen den VBA-Editor, dem wir zunächst zwei Module zum Verarbeiten von JSON-Dokumenten hinzufügen. Diese heißen mdlJSON <\/b>und mdlJSONDOM <\/b>und wir finden diese in der Beispieldatenbank.<\/p>\n Für die in diesen Modulen verwendeten Dictionaries und die für den Zugriff auf Zapier verwendete Klasse ServerXMLHTTP60 <\/b>benötigen wir zwei Verweise, die wir wie in Bild 10 über den Verweise<\/b>-Dialog zum VBA-Projekt hinzufügen.<\/p>\n Bild 10: Hinzufügen von Verweisen<\/span><\/b><\/p>\n Die Funktion zum Ausführen der Anfrage heißt HTTPRequest <\/b>und erwartet die folgenden Parameter (siehe Listing 1):<\/p>\n Listing 1: Die Funktion zum Ausführen von Anfragen an Zapier<\/span><\/b><\/p>\n In der Prozedur deklarieren wir ein ServerXMLHTTP60<\/b>-Objekt, das wir zum Versenden nutzen. Darauf basierend erstellen wir ein neues Objekt, das wir mit der Variablen objHTTP <\/b>referenzieren. Für dieses rufen wir die Open<\/b>-Methode auf und übergeben die Methode, die URL und für den dritten Parameter varAsync <\/b>den Wert False<\/b>. Dadurch wird die Methode synchron aufgerufen und der aufrufende Code zwischenzeitlich angehalten.<\/p>\n Danach stellen wir mit setRequestHeader <\/b>den Inhaltstyp auf den Wert des Parameters strContentType <\/b>ein, der normalerweise den Wert application\/json <\/b>enthält.<\/p>\n Wenn strData <\/b>einen Wert enthält, beispielsweise ein JSON-Dokument, wird dieses für den Request-Header Body <\/b>hinterlegt.<\/p>\n Schließlich rufen wir die send<\/b>-Methode mit dem Inhalt von strData <\/b>auf und lesen den Rückgabewert aus der Eigenschaft ResponseText <\/b>in die Variable strResponse <\/b>ein.<\/p>\n Außerdem geben wir den Status der Anfrage als Funktionsergebnis zurück.<\/p>\n Damit kommen wir zum Aufruf dieser Funktion. Diesen erledigen wir mit der Prozedur aus Listing 2.<\/p>\n Listing 2: Aufruf der Funktion zum Versenden einer E-Mail<\/span><\/b><\/p>\n Diese stellt in der Variablen strURL <\/b>die URL zusammen und deklariert außerdem noch leere Variablen namens strResponse<\/b> und intStatus<\/b>.<\/p>\n Die URL und die leere Variable übergibt sie dem Aufruf der Funktion HTTPRequest <\/b>und wertet anschließend den Wert des Rückgabewertes aus, der in der Variablen intStatus <\/b>gelandet ist.<\/p>\n Im Falle des Wertes 200 <\/b>wird eine Erfolgsmeldung mit strResponse <\/b>in den Direktbereich geschrieben, anderenfalls der Status samt Antwort aus strResponse<\/b>.<\/p>\n Im Erfolgsfall sieht die Antwort beispielsweise wie folgt aus:<\/p>\n Mehr ist nicht nötig, um einen einfachen Aufruf zu starten, bei dem wir alle Parameter in die URL integrieren.<\/p>\n Allerdings kann es auch passieren, dass der Aufruf wesentlich umfangreichere Daten enthalten soll, die wir nicht problemlos in die URL integrieren können.<\/p>\n In diesem Fall benötigen wir ein entsprechendes JSON-Dokument. Dieses könnten wir einfach wie folgt zusammenstellen und in der Variablen strJSON <\/b>speichern:<\/p>\n Allerdings wollen wir direkt unsere bewährte Methode verwenden, die wir im Artikel JSON-Dokumente per Objektmodell zusammenstellen <\/b>(www.vbentwickler.de\/412<\/b>) vorstellen.<\/p>\n Der Aufbau der Prozedur Test_EMailJSON <\/b>aus Listing 3 entspricht weitgehend der aus dem vorherigen Beispiel. Allerdings verwenden wir zwei Variablen namens objJSON <\/b>und strJSON<\/b>. In der ersten Variablen objJSON<\/b>, das wir hier als Dictionary <\/b>deklariert haben, stellen wir das JSON-Dokument zusammen. Dazu fügen wir in diesem einfachen Fall einfach alle benötigten Name-Wert-Paare in der folgenden Form hinzu:<\/p>\n Listing 3: Aufruf der Funktion zum Versenden einer E-Mail mit einem JSON-Dokument<\/span><\/b><\/p>\n Danach ermitteln wir aus objJSON <\/b>mit der Funktion ConvertToJson <\/b>das JSON-Dokument als Zeichenkette und schreiben diese in die Variable strJSON<\/b>. Diese übergeben wir beim Aufruf der Funktion HTTPRequest <\/b>mit dem Parameter strData<\/b>.<\/p>\n Wenn wir die Prozedur nun aufrufen, erhalten wir zwar eine Erfolgsmeldung. Das bedeutet aber lediglich, dass der Trigger erfolgreich aufgerufen wurde.<\/p>\n Es kommt aber niemals eine E-Mail an, also schauen wir uns an, ob wir bei Zapier einen Hinweis auf einen Fehler finden können.<\/p>\n Dazu schauen wir uns bei Zapier den entsprechenden Zap an und zeigen den Bereich an, der uns alle Aufrufe liefert (siehe Bild 11).<\/p>\n Bild 11: Die Automation konnte nicht erfolgreich durchgeführt werden.<\/span><\/b><\/p>\n Hier sehen wir bereits, dass die letzten Versuche, die wir mit der neuen Version mit JSON-Dokument durchgeführt haben, gestoppt wurden.<\/p>\n Klicken wir beispielsweise den aktuellsten Eintrag an, sehen wir auch, welcher Schritt nicht ausgeführt wurde.<\/p>\n Es handelt sich um den zum Versenden der E-Mail. Hier sehen wir auch direkt den Grund: Offenbar konnten die Eigenschaften To Email(s)<\/b>, Subject <\/b>und Body <\/b>nicht gefüllt werden. Aber warum nicht?<\/p>\n Dazu schauen wir uns die beiden Bereiche Data out <\/b>des Trigger-Elements der Automation sowohl für einen der Aufrufe an, bei dem wir die Daten per URL gesendet haben, als auch für einen der neueren Aufrufe, wo wir dazu das JSON-Dokument genutzt haben.<\/p>\n Im ersten Fall sehen wir alle dort angegebenen Informatonen unterhalb des Elements querystring<\/b> und mit vorangestelltem Querystring <\/b>(siehe Bild 12).<\/p>\n Bild 12: Aufruf mit Querystring <\/span><\/b><\/p>\n Im zweiten Fall finden wir auch das querystring<\/b>-Element, aber die übergebenen Daten werden alle separat davon angezeigt (siehe Bild 13).<\/p>\n Bild 13: Aufruf mit JSON<\/span><\/b><\/p>\n Offensichtlich werden die Elemente, seit wir sie als Teil eines JSON-Dokuments geschickt haben, nicht mehr verarbeitet.<\/p>\n Wir müssen die Informationen aus dem JSON-Dokument also anders zuordnen.<\/p>\n Da wir die alte Automation beibehalten wollen, um auch Automationen per URL mit Parametern aufrufen zu können, erstellen wir eine neue Automation auf Basis der ersten. <\/p>\n Dazu gehen wir zurück zur Übersicht der Automationen und klicken die zu duplizierende Automation an. Klicken wir auf die Schaltfläche den drei vertikal angeordneten Punkten, finden wir den Befehl zum Duplizieren vor (siehe Bild 14).<\/p>\n Bild 14: Duplizieren einer Automation<\/span><\/b><\/p>\n In der nun erscheinenden Meldung klicken wir auf Duplicate and edit<\/b>. Alles sieht zunächst aus wie beim Original. Aber natürlich hat Zapier eine neue Webhook-URL angelegt. Diese kopieren wir und fügen diese in unsere Prozedur für den Aufruf der Automation mit Übergabe der Daten im JSON-Format ein.<\/p>\n Diese rufen wir nun auf, damit wir Beispieldaten zum Zuweisen der Eigenschaften zu der zu verwendenden E-Mail haben.<\/p>\n Unter Catch Hook <\/b>finden wir nun im Bereich Test <\/b>bereits den neuen Request (siehe Bild 15).<\/p>\n Bild 15: Es wurden neue Daten gefunden.<\/span><\/b><\/p>\n Den neuesten Datensatz wählen wir nun aus und klicken auf Continue with selected record<\/b>.<\/p>\n Damit gelangen wir zum Schritt Send Email<\/b>. Wechseln wir hier zum Bereich Configure<\/b>, sehen wir bereits dass die zuvor verwendeten Elemente wie Querystring Email <\/b>mit einem Ausrufezeichen versehen sind (siehe Bild 16). Das deutet daraufhin, dass diese in dem neuen gelieferten Datensatz nicht mehr verfügbar sind.<\/p>\n Bild 16: Einfügen der neuen Eigenschaften aus dem JSON-Dokument<\/span><\/b><\/p>\n Also löschen wir die vorhandenen Elemente und ersetzen sie durch die Elemente, die wir im linken Bereich vorfinden.<\/p>\n Bereits der erste Testdurchlauf zeigt, dass es nun auch mit den Daten aus dem JSON-Dokument funktioniert. Wir müssen also darauf achten, dass wir die Daten immer im gleichen Format liefern.<\/p>\n In diesem Artikel haben wir gezeigt, wie wir erstens eine Automation vorbereiten, die wir über das Aufrufen eines Links von außen initiieren können. Danach haben wir den Aufruf dieses Links zunächst über einen Webbrowser durchgeführt und festgestellt, dass dieser wie gewünscht funktioniert.<\/p>\n Damit konnten wir auch den Zugriff auf diese Automation per VBA über ein XMLHTTP-Objekt angehen. Hier haben wir zwei Varianten vorgestellt. Die erste verwendet für die Übergabe der Parameter ausschließlich die URL, der sie entsprechende Name-Wert-Paare zugeordnet hat. Im zweiten Fall haben wir die zu übergebenden Informationen in einem JSON-Dokument zusammengestellt und dieses an den Aufruf des Webhooks angehängt.<\/p>\n Damit können wir nun Zapier-Automationen relativ einfach per VBA von Access und von anderen Office-Anwendungen aus starten.<\/p>\n Das einzige Problem ist, dass wir keine zuverlässige Rückmeldung über den Erfolg des Zugriffs erhalten. Hier bietet ein anderes Tool namens Make.com bessere Möglichkeiten.<\/p>\n Wir können allerdings einen Workaround bauen, der wiederum Aufwand erfordert. Man könnte im letzten Schritt der Automation das Ergebnis beispielsweise in ein Google Spreadsheet oder in eine SQL Server-Datenbank eintragen, die man nach ein paar Sekunden abfragt und das Ergebnis auswertet. Dabei müsste man eine eindeutige ID übergeben, die dann ebenfalls abgelegt wird, damit man das Ergebnis für den richtigen Aufruf erhält.<\/p>\n","protected":false},"excerpt":{"rendered":" Zapier ist ein Tool, mit dem wir SaaS-Anwendungen für verschiedene Bereiche automatisieren können. Das geschieht nach dem Prinzip, dass eine solche Anwendung eine Automation triggert und dadurch Aktionen mit der gleichen oder auch mit anderen Anwendungen angestoßen werden. Wie zum Beispiel das Eintragen einer Aufgabe in eine Aufgabenliste, wenn eine neue E-Mail eingegangen ist. Wie haben in weiteren Artikel bereits gezeigt, wie wir solche Automationen mit Tools wie Zapier realisieren können. Aber welchen Bezug gibt es zum eigentlichen Thema dieses Magazins, nämlich dem Programmieren mit Sprachen wie VBA, VB6, twinBASIC et cetera – abgesehen davon, dass wir diese Automationen als Selbstständeriger, Freiberufler, aber auch als Angestellter für unser Unternehmen gewinnbringend einsetzen können? Genau: Wie können diese Automationen natürlich auch per Code triggern. Wie das im Falle von Zapier funktioniert, erklären wir im vorliegenden Artikel.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66012025,662025,44000012],"tags":[],"yst_prominent_words":[],"class_list":["post-55000459","post","type-post","status-publish","format-standard","hentry","category-66012025","category-662025","category-Interaktiv"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t![\"Einen](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_001.png\")
<\/p>\nDie Lösung: Webhooks<\/h2>\n
![\"Verschiedene](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_003.png\")
<\/p>\n\n
Webhook mit Catch Hook verwenden<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_004.png\")
<\/p>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_005.png\")
<\/p>\nDaten an Zapier übergeben<\/h2>\n
\n
https:\/\/hooks.zapier.com\/hooks\/catch\/21909841\/2qbfvbz\/?email=andre@minhorst.com&subject=Test&body=Dies%20ist%20ein%20Test<\/pre>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_006.png\")
<\/p>\nE-Mail per Outlook versenden<\/h2>\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_007.png\")
<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_008.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_009.png\")
<\/p>\n\n
Programmieren des Zapier-Zugriffs mit VBA<\/h2>\n
Vorbereitungen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_010.png\")
<\/p>\nFunktion zum Ausführen der Anfrage an Zapier<\/h2>\n
Public Function <\/span>HTTPRequest(strURL As String<\/span>, Optional<\/span> strMethod As String<\/span> = \"POST\", _\r\n Optional<\/span> strContentType As String<\/span> = \"application\/json\", Optional<\/span> strData As String<\/span>, _\r\n Optional<\/span> strResponse As String<\/span>) As Integer<\/span>\r\n Dim <\/span>objHTTP As <\/span>ServerXMLHTTP60\r\n Set<\/span> objHTTP = New<\/span> MSXML2.ServerXMLHTTP60\r\n With<\/span> objHTTP\r\n .Open strMethod, strURL, False<\/span>\r\n .setRequestHeader \"Content-Type\", \"application\/json\"\r\n If <\/span>Not<\/span> Len<\/span>(strData) = 0 Then<\/span>\r\n .setRequestHeader \"Body\", strData\r\n End If<\/span>\r\n .send strData\r\n strResponse = .responseText\r\n HTTPRequest = .status\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\n\n
Aufruf der Funktion HTTPRequest zum Versenden einer einfachen E-Mail<\/h2>\n
Public Sub <\/span>Test_EMailParameter()\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>intStatus As Integer<\/span>\r\n strURL = \"https:\/\/hooks.zapier.com\/hooks\/catch\/21909841\/2qbfvbz\/\"\r\n strURL = strURL & \"?email=andre@minhorst.com\"\r\n strURL = strURL & \"&subject=Test\"\r\n strURL = strURL & \"&body=Dies%20ist%20ein%20Test%201\"\r\n intStatus = HTTPRequest(strURL, \"POST\", , , strResponse)\r\n Select Case intStatus\r\n Case <\/span>200\r\n Debug.Print<\/span> \"Success: \" & strResponse\r\n Case Else<\/span>\r\n Debug.Print<\/span> intStatus, strResponse\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n{\"attempt\":\"01955cb0-4c9a-044a-f855-035eb968fd65\",\"id\":\"01955cb0-4c9a-044a-f855-035eb968fd65\",\"request_id\":\"01955cb0-4c9a-044a-f855-035eb968fd65\",\"status\":\"success\"}<\/pre>\nAufruf mit Eigenschaften im JSON-Dokument programmieren<\/h2>\n
{\"email\":\"andre@minhorst.com\",\"subject\":\"Beispielbetreff\",\"body\":\"Dies ist ein Beispielinhalt einer E-Mail\"}<\/pre>\nPublic Sub <\/span>Test_EMailJSON()\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>intStatus As Integer<\/span>\r\n Dim <\/span>objJSON As <\/span>Dictionary\r\n Dim <\/span>strJSON As String<\/span>\r\n strURL = \"https:\/\/hooks.zapier.com\/hooks\/catch\/21909841\/2qbfvbz\/\"\r\n Set<\/span> objJSON = New<\/span> Dictionary\r\n objJSON.Add \"email\", \"andre@minhorst.com\"\r\n objJSON.Add \"subject\", \"Beispielbetreff\"\r\n objJSON.Add \"body\", \"Dies ist ein Beispielinhalt einer E-Mail\"\r\n strJSON = ConvertToJson(objJSON)\r\n intStatus = HTTPRequest(strURL, \"POST\", , strJSON, strResponse)\r\n Select Case intStatus\r\n Case <\/span>200\r\n Debug.Print<\/span> \"Success: \" & strResponse\r\n Case Else<\/span>\r\n Debug.Print<\/span> intStatus, strResponse\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nobjJSON.Add \"email\", \"andre@minhorst.com\"<\/pre>\n
Automation analysieren<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_011.png\")
<\/p>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_012.png\")
<\/p>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_013.png\")
<\/p>\nNeue Automation für JSON erstellen<\/h2>\n
Automation duplizieren<\/h2>\n
![\"Duplizieren](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_014.png\")
<\/p>\n![\"Es](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_016.png\")
<\/p>\n![\"Einfügen](\"..\/fileadmin\/_temp_\/2025_01\/pic_459_015.png\")
<\/p>\nZusammenfassung und Ausblick<\/h2>\n