{"id":55000463,"date":"2025-04-01T00:00:00","date_gmt":"2025-07-02T14:48:58","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=463"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Automation_mit_VBA_und_Make","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Automation_mit_VBA_und_Make\/","title":{"rendered":"Automation mit VBA und Make"},"content":{"rendered":"

In vorherigen Artikeln haben wir bereits am Beispiel von Zapier gezeigt, wie wir Workflow Automation Tools nutzen können, um von VBA aus Automationen anstoßen können. Diese Automationen zielen auf Apps ab, die wir sonst über den Webbrowser steuern – GMail, CRMs, Zahlungsplattformen, Buchhaltungssoftware und viele mehr. Im vorliegenden Artikel nehmen wir einen weiteren Anbieter unter die Lupe, nämlich Make.com. Make ist grundsätzlich ähnlich zu nutzen wir Zapier, aber es bietet einen wichtigen Vorteil: Wir können damit nämlich Ergebnisse der Aufrufe der jeweiligen Anwendung sogar abfragen und diese auf unserem Client weiterverarbeiten. Wenn wir beispielsweise eine Mail über Google Mail versenden, können wir uns einen Link zu der gesendeten E-Mail zurückliefern lassen, um diese später per Mausklick im Browser zu öffnen. Oder wenn wir einen Datensatz anlegen, beispielsweise für einen neuen Kunden im CRM-Systen, können wir uns die ID des neuen Kunden zurückgeben lassen, um diesen als Referenz in der Datenbank zu speichern. In diesem Artikel zeigen wir zunächst, wie wir eine einfache Automation in Make.com anlegen und diese per VBA aufrufen und uns das Ergebnis zurückgeben lassen.<\/b><\/p>\n

Make.com-Konto erstellen<\/h2>\n

Wenn man sich noch nicht an den Gedanken gewöhnt hat: Der Trend in der IT geht dahin, dass man für die Nutzung von Software nicht mehr einmalig zahlt, sondern Abonnements abschließt, die man für die gesamte Nutzungsdauer monatlich oder jährlich (meist mit Rabatt) abschließt. Die Zeiten, in denen man sich einmalig eine Software wie ein Office-Paket gekauft hat und dieses dann genutzt hat, bis der Support des Herstellers beendet und die Software aus Sicherheitsgründen nicht mehr genutzt werden sollte, sind allmählich vorbei.<\/p>\n

Auch Workflow Automation Tools wie Zapier und Make.com bieten ihre Dienste nach dem gleichen Prinzip an: Man zahlt monatlich und erhält dafür ein entsprechendes Kontingent an Zugriffen.<\/p>\n

Zum Testen reicht im Falle von Make.com das kostenlose Paket aus, hier ist man allerdings auf einen Aufruf je 15 Minuten beschränkt. Wesentlich mehr erhält man bereits für 10,59 $ im Monat bei monatlicher Abrechnung beziehungsweise für 9,00 $ im Monat bei jährlicher Abrechnung.<\/p>\n

Mehr Infos dazu findest Du unter folgendem Link:<\/p>\n

https:\/\/www.make.com\/en\/pricing<\/pre>\n
Die Anmeldung ist schnell erledigt, nach der Angabe von Name, E-Mail und Kennwort brauchen wir nur noch den Bestätigungslink in der danach zugesendeten E-Mail zu betätigen (siehe Bild 1).<\/p>\n
\"Erstellen<\/p>\n
Bild 1: Erstellen eines Make.com-Kontos<\/span><\/b><\/p>\n
Automationen starten per Webhook<\/h2>\n
Automationen bestehen immer aus mindestens einem Trigger und einer Aktion. Der Trigger ist ein Element, das die Automation auslöst.<\/p>\n
Meistens stammt der Trigger aus einer der Web-Anwendungen, die wir automatisieren wollen. Beispiele:<\/p>\n
    \n
  • eine neue Zeile in einem Google Sheet,<\/li>\n
  • eine neue Datei in Google Drive, <\/li>\n
  • eine neue E-Mail ist in Google Mail eingetroffen oder <\/li>\n
  • eine neue Datei wurde zu einem Dropbox-Ordner hinzugefügt.<\/li>\n<\/ul>\n
    In unserem Fall wollen wir den Trigger per VBA auslösen. Dafür findet sich logischerweise kein vorbereiteter Trigger, denn wir können VBA nicht so von Make.com aus referenzieren, dass wir dort auf ein Ereignis lauschen könnten, wie wir es mit einer Ereignisprozedur innerhalb eines VBA-Klassenmoduls tun.<\/p>\n
    Stattdessen nutzen wir einen speziellen Trigger namens Webhook. Das funktioniert so:<\/p>\n
    Make.com <\/b>stellt uns eine bestimmten URL zur Verfügung, die wir per VBA aufrufen. Die URL ist einzigartig und nur uns bekannt, nachdem wir den Webhook-Trigger angelegt haben.<\/p>\n
    Diese URL rufen wir per VBA mit Unterstützung der Methoden der XMLHTTP60<\/b>-Klasse auf.<\/p>\n
    Mit dieser können wir alle notwendigen Informationen übergeben und auch das Ergebnis verarbeiten.<\/p>\n
    Ergebnis verarbeiten<\/h2>\n
    Im Gegensatz zu Zapier bietet Make.com <\/b>auch eine Aktion an, mit der wir das Ergebnis der Automationen an die Instanz zurückgeben können, die den Webhook aufgerufen hat. Neben den vielen anderen Aktionen, die wir durchführen können, finden wir also auch eine namens Webhook response<\/b>. Diese soll im folgenden grundlegenden Beispiel auch die einzige Aktion sein, die wir in unserem Basisworkflow nutzen wollen.<\/p>\n
    Ein Scenario erstellen<\/h2>\n
    Was unter Zapier Zap <\/b>genannt wird, heißt unter Make.com Scenario<\/b>. Von der Startseite können wir entweder direkt auf Create a new scenario <\/b>klicken oder wir klicken links auf Scenarios<\/b>, um die Übersicht aller bisher erstellten Automationen einzusehen (siehe Bild 2). Auch dort finden wir wieder die Schaltfläche Create a new scenario<\/b>.<\/p>\n
    \"Anlegen<\/p>\n
    Bild 2: Anlegen eines neuen Scenarios<\/span><\/b><\/p>\n
    Trigger zum Scenario hinzufügen<\/h2>\n
    Damit landen wir im Scenario-Designer. Hier sehen wir ein großes Plus-Icon und ein Menü mit der Übersicht der verfügbaren Trigger (siehe Bild 3).<\/p>\n
    \"Ein<\/p>\n
    Bild 3: Ein noch leeres neues Scenario<\/span><\/b><\/p>\n
    Es lohnt sich, einmal durch die Liste zu scrollen und sich anzuschauen, durch welche Anwendungen eine solche Automation gestartet werden kann.<\/p>\n
    Klicken wir auf einen der Einträge, erscheint eine weitere Liste mit allen Ereignissen, die durch diese Anwendungen ausgelöst werden können. Im Falle von Google Sheets<\/b> sind das beispielsweise neu hinzugefügte Zeilen oder geänderte Zeilen (siehe Bild 4).<\/p>\n
    \"Betrachten<\/p>\n
    Bild 4: Betrachten der verschiedenen Trigger einer Anwendung<\/span><\/b><\/p>\n
    Webhook als Trigger verwenden<\/h2>\n
    Wir wollen jedoch keine externe Anwendung als Trigger nutzen, sondern den Trigger per VBA von unserem VBA-Projekt aus auslösen.<\/p>\n
    Dazu kehren wir zur Hauptliste der Anwendungen zurück, die Trigger auslösen können, und klicken hier auf den Eintrag Webhook<\/b>.<\/p>\n
    Dies liefert die drei Elemente aus Bild 5, wobei die ersten beiden Trigger sind und die dritte eine Aktion. Die beiden Trigger funktionieren wie folgt:<\/p>\n
    \"Hinzufügen<\/p>\n
    Bild 5: Hinzufügen eines Triggers namens Custom webhook<\/span><\/b><\/p>\n
      \n
    • Custom mailhook<\/b>: Wenn wir einen Mailhook erstellen, erhalten wir eine E-Mail-Adresse. An diese E-Mail-Adresse können wir eine E-Mail senden. Kommt diese bei Make.com <\/b>an, löst dies die Automation aus. In den nachfolgend zu definierenden Aktionen können wir auf die Eigenschaften der E-Mail wie Betreff, Inhalt, Datum, Absender et cetera zugreifen und diese weiterverarbeiten.<\/li>\n
    • Custom webhook<\/b>: Erstellen wir einen Custom webhook<\/b>, erhalten wir hingegen eine URL. Der Trigger wird ausgelöst, wenn wir diese URL aufrufen. Im einfachsten Fall geben wir diese einfach im Webbrowser ein.<\/li>\n<\/ul>\n
      Die Aktion Webhook response <\/b>stellt die entscheidende Besonderheit von Make.com <\/b>gegenüber Zapier dar: Darin finden wir eine Möglichkeit, das Ergebnis einer durch einen Webhook aufgerufenen Automation auch wieder an die aufrufende Instanz zurückzugeben.<\/p>\n
      Trigger anlegen<\/h2>\n
      Um den Trigger anzulegen, klicken wir auf Custom webhook<\/b>.<\/p>\n
      Dies öffnet ein Popup, indem wir einen bestehenden Webhook auswählen oder einen neuen anlegen können (siehe Bild 6).<\/p>\n
      \"Anlegen<\/p>\n
      Bild 6: Anlegen und Konfigurieren des Webhooks<\/span><\/b><\/p>\n
      Wir benötigen hier einen neuen Hook und klicken auf die Schaltfläche Add<\/b>.<\/p>\n
      Nun erscheint der Dialog Create a webhook<\/b>, in dem wir den Namen für unseren Webhook eintragen – in diesem Fall Beispielwebhook<\/b> (siehe Bild 7).<\/p>\n
      \"Einstellen<\/p>\n
      Bild 7: Einstellen des Namens für den Webhook<\/span><\/b><\/p>\n
      Danach enthält der Webhook weitere Informationen, zum Beispiel eine URL (siehe Bild 8). Diese kopieren wir mit einem Klick auf Copy address to clipboard <\/b>in die Zwischenablage.<\/p>\n
      \"Details<\/p>\n
      Bild 8: Details des Webhooks<\/span><\/b><\/p>\n
      An der Schaltfläche Stop <\/b>erkennen wir, dass der Webhook bereits aktiv ist und auf Aufrufe wartet.<\/p>\n
      Erster Test des Webhooks<\/h2>\n
      Damit können wir den Webhook nun bereits testen – ohne größeren Aufwand wie beispielsweise eine VBA-Prozedur. Wir fügen die Adresse einfach in einen Browser ein und rufen diese auf. Das Ergebnis ist der Text Accepted<\/b> (siehe Bild 9). Das sieht sehr gut aus – der Aufruf funktioniert.<\/p>\n
      \"Aufruf<\/p>\n
      Bild 9: Aufruf des Webhooks über den Webbrowser<\/span><\/b><\/p>\n
      Damit wollen wir den Webhook nun speichern und klicken dazu auf die Schaltfläche Save<\/b>.<\/p>\n
      Antwort benutzerdefiniert gestalten<\/h2>\n
      Damit kommen wir zum zweiten Schritt unseres Beispiels. Hier wollen wir nun die Antwort Accepted <\/b>durch eine benutzerdefinierte Antwort ersetzen. Dazu fügen wir eine Aktion hinzu, indem wir auf die kleine Plus<\/b>-Schaltfläche rechts von unserem Trigger klicken.<\/p>\n
      Dies öffnet die gleiche Auswahl wie zuvor (siehe Bild 10). Klicken wir hier erneut auf Webhooks<\/b>, finden wir lediglich noch den Eintrag Webhook response <\/b>vor. Logisch, denn wir können an dieser Stelle keinen weiteren Trigger hinzufügen – wir benötigen eine Aktion. Also wählen wir Webhook response <\/b>aus.<\/p>\n
      \"Hinzufügen<\/p>\n
      Bild 10: Hinzufügen einer Aktion zum Workflow<\/span><\/b><\/p>\n
      Dies fügt das Element Webhook response <\/b>hinzu und zeigt gleich seine Eigenschaften an (siehe Bild 11).<\/p>\n
      \"Die<\/p>\n
      Bild 11: Die neue Aktion im Scenario<\/span><\/b><\/p>\n
      Wenn wir das Feld Body <\/b>anklicken, erscheint ein weiteres Popup.<\/p>\n
      Hier sehen wir zum Beispiel die Variable executionId<\/b>, welche eine ID für die aktuelle Ausführung der Automation enthält (siehe Bild 12).<\/p>\n
      \"Verfügbare<\/p>\n
      Bild 12: Verfügbare Elemente für die Antwort<\/span><\/b><\/p>\n
      Wir tragen testweise einfach einmal den Text Benutzerdefinierte Antwort<\/b>, gefolgt von der Variablen executeId <\/b>in das Feld Body <\/b>ein. executeId <\/b>ziehen wir dazu per Drag and Drop aus der Liste in das Feld Body<\/b>, sodass wir das Ergebnis aus Bild 13 erhalten.<\/p>\n
      \"Hinzufüge<\/p>\n
      Bild 13: Hinzufüge nder executionId<\/span><\/b><\/p>\n
      Mit einem Klick auf die Schaltfläche Save <\/b>speichern wir das neue Element.<\/p>\n
      Nun lauscht der Webhook allerdings nicht mehr auf unsere Anfragen, sodass wir im Browser zunächst diese Antwort erhalten:<\/p>\n
      There is no scenario listening for this webhook.<\/pre>\n
      Deshalb klicken wir nun auf die Schaltfläche Run once<\/b> (siehe Bild 14). Die Schaltfläche wandelt sich in eine Stop<\/b>-Schaltfläche um und die Automation lauscht wieder auf Aufrufe.<\/p>\n
      \"Starten<\/p>\n
      Bild 14: Starten der Automation<\/span><\/b><\/p>\n
      Rufen wir die URL des Webhooks nun erneut im Browser auf, erhalten wir das Ergebnis aus Bild 15. Die Rückgabe einer individuell in der Automation festgelegten Antwort funktioniert also.<\/p>\n
      \"Erfolgreicher<\/p>\n
      Bild 15: Erfolgreicher Test der Automation<\/span><\/b><\/p>\n
      Nächste Schritte<\/h2>\n
      Damit haben wir das Grundgerüst geschaffen. Wir werden uns nun ansehen, wie wir die Automation per VBA starten können. Das Ziel ist es, die Automation zu starten und das Ergebnis, dass wir nun im Browser erhalten haben, per VBA auszulesen und zu verarbeiten.<\/p>\n
      Make.com-Automation per VBA aufrufen<\/h2>\n
      Um die Automation per VBA zu starten und das Ergebnis zu erhalten, benötigen wir ein VBA-Projekt, für das wir in diesem Fall eine Microsoft Access-Datenbank nutzen. Wir könnten die nachfolgend beschriebenen Techniken jedoch auch im VBA-Projekt von Excel, Word, Outlook et cetera nutzen.<\/p>\n
      Dem VBA-Projekt fügen wir zwei Verweise hinzu (siehe Bild 16):<\/p>\n
      \"Verweise<\/p>\n
      Bild 16: Verweise für unser VBA-Projekt<\/span><\/b><\/p>\n
        \n
      • Microsoft XML, v6.0<\/b><\/li>\n
      • Microsoft Scripting Runtime<\/b><\/li>\n<\/ul>\n
        Danach fügen wir ein neues, leeres Modul hinzu und geben dort den Code aus Listing 1 ein. In dieser Prozedur tragen wir die URL des Webhooks für die Variable strWebhookURL <\/b>ein. Außerdem verwenden wir eine Variable namens strJSON <\/b>mit einer leeren Zeichenkette. Diese dient erst einmal der Vorbereitung – wir werden diese in einem weiteren Beispiel noch füllen. Danach erstellen wir ein neues Objekt des Typs MSXML2.XMLHTTP60<\/b>.<\/p>\n
        Public Sub <\/span>Make_Template()\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\/8kyskzlhvzgb9a6ltf4ccrg7fh9hxz3e\"\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     If <\/span>objXMLHTTP.status = 200 Then<\/span>\r\n         MsgBox<\/span> \"Erfolgreich gesendet: \" & vbCrLf<\/span> & vbCrLf<\/span> & objXMLHTTP.responseText\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Fehler beim Senden: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.statusText\r\n     End If   \r\nEnd Sub<\/span><\/pre>\n
        Listing 1: Testaufruf des Webhooks<\/span><\/b><\/p>\n
        Für dieses führen wir die Methode Open <\/b>aus und übergeben als Parameter die Werte GET <\/b>als Methode, die URL sowie den Wert False<\/b>, um anzugeben, dass wir auf das Ergebnis des Aufrufs warten wollen.<\/p>\n
        Anderenfalls können wir das Ergebnis nicht verarbeiten.<\/p>\n
        Außerdem übergeben wir noch einen Header, mit dem wir als Format der zu sendenden Daten als application\/json <\/b>angeben.<\/p>\n
        Schließlich führen wir den Aufruf mit der send<\/b>-Methode aus und übergeben dabei die in diesem Beispiel noch leere Zeichenkette aus strJSON<\/b>.<\/p>\n
        Liefert der Aufruf den Wert 200 <\/b>für die Eigenschaft status <\/b>zurück, war der Aufruf erfolgreich und wir geben den Wert der Eigenschaft responseText <\/b>in einer Meldung aus.<\/p>\n
        Im Fehlerfall, also wenn status <\/b>einen anderen Wert liefert, geben wir die Werte der Eigenschaften status <\/b>und statusText <\/b>aus.<\/p>\n
        Dies können wir simulieren, indem wir beispielsweise der URL ein Zeichen hinzufügen, sodass diese nicht mehr vorhanden ist und erhalten als Status den Wert 404<\/b>.<\/p>\n
        Führen wir die Prozedur nun ohne Weiteres aus, erhalten wir als Ergebnis im Meldungsfenster allerdings den Text Accepted <\/b>– also nicht den erwarteten Text.<\/p>\n
        Das liegt daran, dass wir die Automation erst wieder aktivieren müssen, indem wir erneut auf Run once <\/b>klicken und im nachfolgend erscheinenden Popup den Button Wait for new data <\/b>betätigen (siehe Bild 17).<\/p>\n
        \"Erneutes<\/p>\n
        Bild 17: Erneutes Aktivieren der Automation<\/span><\/b><\/p>\n
        Damit erhalten wir nun auch das erwartete Ergebnis (siehe Bild 18).<\/p>\n
        \"Ergebnis<\/p>\n
        Bild 18: Ergebnis des erneuten Aufrufs<\/span><\/b><\/p>\n
        Statuscode anpassen<\/h2>\n
        Dies ist eine wichtige Beobachtung: Die Automation liefert also im Erfolgsfall immer den Wert 200<\/b>, auch wenn die Automation gerade nicht läuft. Das wollen wir im Code noch differenzieren, indem wir für die echte Antwort einen anderen Statuscode definieren.<\/p>\n
        Dazu klicken wir in Make.com <\/b>erneut auf die Aktion und geben für Status <\/b>den Wert 201 <\/b>ein (siehe Bild 19).<\/p>\n
        \"Definieren<\/p>\n
        Bild 19: Definieren eines eigenen Statuswertes<\/span><\/b><\/p>\n
        Entsprechend passen wir auch die Bedingung an, mit der wir den Status untersuchen. Wir wandeln diese in ein Select Case<\/b>-Statement um und fügen sowohl für 201<\/b> als auch für 200 <\/b>eigene Case<\/b>-Zweige hinzu:<\/p>\n
        Select Case objXMLHTTP.status\r\n     Case <\/span>201\r\n         MsgBox<\/span> \"Erfolgreich gesendet: \" & vbCrLf<\/span> _\r\n             & vbCrLf<\/span> & objXMLHTTP.responseText\r\n     Case <\/span>200\r\n         MsgBox<\/span> \"Erfolgreich gesendet, aber Automation \" _\r\n             & \"nicht aktiv.\"\r\n     Case Else<\/span>\r\n         MsgBox<\/span> \"Fehler beim Senden: \" _\r\n            & objXMLHTTP.status & \" - \" _\r\n            & objXMLHTTP.statusText\r\nEnd Select<\/span><\/pre>\n
        Make.com-Automation dauerhaft aktivieren<\/h2>\n
        Um die Automation dauerhaft zu aktivieren, aktivieren wir unten die Option Immediately as data arrives<\/b>.<\/p>\n
        Dies öffnet ein Popup, in dem wir auswählen können, wie regelmäßig abgefragt werden soll, ob neue Aufrufe der URL eingegangen sind.<\/p>\n
        Welchen Wert wir wählen, hängt vom Anwendungszweck ab.<\/p>\n
        Wenn wir durch unseren Aufruf einfach nur eine Aktion triggern wollen, die irgendwann in nächster Zeit ausgeführt werden soll, können wir einen der Werte At regular intervals<\/b>, Every day<\/b>, Days of week<\/b>, Days of month <\/b>oder Specified days <\/b>einstellen.<\/p>\n
        Wenn wir jedoch einen Aufruf durchführen, der eine Aktion ausführt, von der wir Rückgabewerte erwarten, sollten wir hier Immediately <\/b>einstellen. Nur so lauscht die Automation ständig auf eingehende Aufrufe der URL (siehe Bild 20).<\/p>\n
        \"Dauerhaftes<\/p>\n
        Bild 20: Dauerhaftes Aktivieren der Automation<\/span><\/b><\/p>\n
        Aufruf erneut ausprobieren<\/h2>\n
        Danach rufen wir zwei Mal unsere VBA-Prozedur auf und erhalten jeweils die Meldung mit dem Status 201 und unterschiedlichen Werten für den Rückgabewert.<\/p>\n
        Die Automation ist also nun ständig bereits für Aufrufe.<\/p>\n
        Weitere Informationen übergeben<\/h2>\n
        Weiter oben haben wir bereits über die Variable strJSON <\/b>gesprochen, die aktuell noch mit einer leeren Zeichenkette gefüllt übergeben wird. Je nachdem, welche Aufgaben wir zwischen unseren Trigger und die Response-Aktion schieben, benötigen wir dazu weitere Daten.<\/p>\n
        Ein Beispiel dazu stellen wir im Artikel Google Mail mit Make.com und VBA statt Outlook <\/b>(www.vbentwickler.de\/464<\/b>) vor, wo wir zeigen, wie wir über VBA und Make.com <\/b>E-Mails über Google Mail verschicken können. Hier müssen wir beispielsweise Daten wie Empfänger, Betreff, Inhalt, Anlagen et cetera übergeben.<\/p>\n
        Genau zu diesem Zweck können wir die Variable strJSON <\/b>nutzen. <\/p>\n
        JSON ist ein ein strukturiertes Format wie XML, das allerdings anders formatiert wird.<\/p>\n
        Am einfachsten ist der Einsatz von Name-Wert-Paaren. Diese können wir beispielsweise wie folgt in der Variablen strJSON <\/b>festlegen und übergeben:<\/p>\n
        strJSON = \"{\"\"firstName\"\":\"\"André\"\",\"\"lastName\"\":\"\"Minhorst\"\"}\"<\/pre>\n
        Mit dieser neuen Version der Zuweisung führen wir die Prozedur nun erneut aus. Das Ergebnis sollte wie zuvor mit Status 201 <\/b>erfolgreich sein.<\/p>\n
        Einblick in die Historie der Aufrufe<\/h2>\n
        Nun wollen wir uns ansehen, ob die Daten erfolgreich übergeben wurden und was wir damit machen können.<\/p>\n
        Dazu klicken wir zunächst oben links auf den Pfeil neben Integration Webhooks <\/b>(siehe Bild 21). Integration Webhooks <\/b>ist übrigens der Name unserer Automation, den wir in diesem Zuge gleich einmal auf Beispiel Webhook <\/b>ändern. Anschließend klicken wir diesen einfach an und tragen den gewünschten Namen ein.<\/p>\n
        \"Zurück<\/p>\n
        Bild 21: Zurück zur Übersicht<\/span><\/b><\/p>\n
        Damit landen wir auf der Übersicht aus Bild 22. Nach einem Abgleich, ob die Zeit mit unserer letzten Ausführung übereinstimmt, klicken wir den entsprechenden Eintrag an.<\/p>\n
        \"Anklicken<\/p>\n
        Bild 22: Anklicken eines History-Eintrags<\/span><\/b><\/p>\n
        Dies zeigt wieder den Aufbau des Scenarios an. Wenn wir nun auf die Lupe des Triggers klicken, blendet Make.com <\/b>ein Popup ein, dass Informationen über die gelieferten Daten enthält (siehe Bild 23).<\/p>\n
        \"Hier<\/p>\n
        Bild 23: Hier sehen wir die Eingangsparameter und ihre Werte.<\/span><\/b><\/p>\n
        Eingangsparameter weiterverarbeiten<\/h2>\n
        Alle dort angezeigten Informationen können wir in den folgenden Schritten weiterverarbeiten. In diesem Fall liegt uns nur der zweite Schritt vor, der die Response für den Aufruf liefern soll.<\/p>\n
        Hier wollen wir nun die beiden übergebenen Informationen zusammenfügen und an den Aufruf zurückgeben.<\/p>\n
        Das ist zugegebenermaßen nicht besonders einfallsreich und wir könnten noch einige Schritte dazwischenschieben – beispielsweise indem wir einen neuen Kunden in einem CRM anlegen und für diesen den übergebenen Vornamen und Nachnamen eintragen. Mit dem Response<\/b>-Element könnten wir die ID des neu angelegten Kunden im CRM zurückliefern.<\/p>\n
        Dies würde jedoch hier den Rahmen sprengen, also wollen wir die einfache Lösung als Beispiel verwenden.<\/p>\n
        Um das Response<\/b>-Element anzupassen, klicken wir oben auf Diagram<\/b>, dann auf das Scenario und schließlich nochmal auf das anzupassende Element.<\/p>\n
        Dies blendet wieder die Eigenschaften des Elements ein. Hier klicken wir in das Textfeld Body<\/b> und das nun erscheinende Popup zeigt nun direkt die übergebenen Parameter aus dem Trigger-Element an (siehe Bild 24).<\/p>\n
        \"Eingangsparameter<\/p>\n
        Bild 24: Eingangsparameter nutzen<\/span><\/b><\/p>\n
        Falls nicht die erwarteten Parameter erscheinen<\/h2>\n
        In unserem Fall hatten wir zuvor einmal ein JSON mit anderen Bezeichnern gesendet, nämlich name <\/b>und project<\/b>.<\/p>\n
        Wie sich hier zeigt, merkt sich Make.com <\/b>die Bezeichner an einer bestimmten Stelle, nämlich wenn zum ersten Mal ein JSON-Dokument mitgesendet wird. <\/p>\n
        Wenn wir später ein JSON-Dokument mit anderen Elementen senden, werden dennoch die zuerst gespeicherten Parameter angezeigt.<\/p>\n
        Wir können dies jedoch zurücksetzen. Dazu klicken wir auf das erste Webhook-Element und finden im Popup nun den Button Redetermine data structure <\/b>vor (siehe Bild 25).<\/p>\n
        \"Zurücksetzen<\/p>\n
        Bild 25: Zurücksetzen der erwarteten Datenstruktur<\/span><\/b><\/p>\n
        Diesen klicken wir nun an und sehen nun die Ansicht aus Bild 26. Der Webhook wartet nun auf einen Aufruf mit der neuen Datenstruktur.<\/p>\n
        \"Der<\/p>\n
        Bild 26: Der Webhook wartet auf einen Aufruf mit der neuen Datenstruktur.<\/span><\/b><\/p>\n
        Also starten wir unsere VBA-Prozedur mit dem Aufruf mit der neuen JSON-Struktur erneut und erhalten als Ergebnis den Status 200<\/b>. Das ist korrekt, denn dieser Aufruf dient nur der Übergabe der neuen Parameterbezeichnungen. In Make.com sehen wir nun, dass die neue Datenstruktur erfolgreich erkannt wurde (siehe Bild 27).<\/p>\n
        \"Bestätigung<\/p>\n
        Bild 27: Bestätigung der neuen Datenstruktur<\/span><\/b><\/p>\n
        Mit einem Klick auf Save <\/b>speichern wir den aktuellen Zustand.<\/p>\n
        Danach sollten die alten Elemente verschwunden sein. Falls das nicht der Fall ist, können entweder damit leben oder wir erstellen das Scenario einmal komplett neu.<\/p>\n
        Das Neuerstellen ist mitunter aufwendig, wenn wir bereits mehrere Aktionen definiert haben.<\/p>\n
        Deshalb können wir folgende Technik nutzen:<\/p>\n