In einem weiteren Artikel namens “To Do-Aufgabe mit Power Automate und VBA anlegen” (www.vbentwickler.de\/431) haben wir die Grundlagen zur Steuerung von Microsoft To Do mit VBA über Power Automate beschrieben und einen ersten Anwendungsfall vorgestellt – das Anlegen einer Aufgabe für eine vorgegebene Liste. In diesem Artikel haben wir die wichtigsten Vorbereitungen getroffen, nämlich das Anlegen eines Power Automate Kontos und das Freigeben des Zugriffs auf das To Do-Konto, dessen Listen und Aufgaben wir verwalten wollen. Dabei schauen wir uns in diesem Artikel an, wie wir die Aufrufe noch genauer gestalten können, um beispielsweise die Liste einzustellen, der wir eine neue Aufgabe hinzufügen. Außerdem schauen wir uns an, wie wir Aufgaben auslesen, bearbeiten oder löschen können und wie wir Listen auslesen, anlegen, bearbeiten oder löschen können. Es gibt viel zu tun!<\/b><\/p>\n
Wir starten direkt dort, wo wir im oben genannten Artikel aufgehört haben, nämlich beim Anlegen einer Aufgabe. In dem dort verwendeten Code haben wir beispielsweise noch nicht die Liste dynamisch angegeben, in die wir die neue Aufgabe übertragen wollen. Wir konnten diese nur aus den vorhandenen Listen auswählen, was wir aber gern direkt von der VBA-Anwendung aus erledigen würden. Dazu müssen wir die Listen und ihre Eigenschaften auswählen, was wir nun erledigen.<\/p>\n
Dazu legen wir einen neuen Flow mit der Vorlage Sofortiger Cloud-Flow <\/b>(siehe Bild 1) und dem Typ Beim Empfang einer HTTP-Anforderung <\/b>an.<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_001.png\")
<\/p>\n
Bild 1: Anlegen eines sofortigen Cloud-Flows<\/span><\/b><\/p>\n Hier brauchen wir nichts weiter festzulegen – wir wollen alle Listen von To Do abfragen, dazu benötigen wir keine Requestparameter. Danach fügen wir mit einem Klick auf das Plus-Zeichen und anschließender Auswahl von Aktion hinzufügen die Aktion zum Abfragen der To Do-Listen hinzu (siehe Bild 2). Hier sehen wir bereits das Ergebnis.<\/p>\n Bild 2: Hinzufügen einer Aktion<\/span><\/b><\/p>\n Vorher wählen wir jedoch noch aus dem Bereich Eine Aktion hinzufügen <\/b>die gewünschte Aktion hinzu. Dazu geben wir als Suchbegriff Aufgabe <\/b>ein und scrollen dann nach unten, bis wir den Connector Microsoft To-Do <\/b>finden. Hier klicken wir auf Mehr anzeigen <\/b>und finden alle Aktionen für Microsoft To-Do vor (siehe Bild 3).<\/p>\n Bild 3: Alle Microsoft To-Do-Aktionen<\/span><\/b><\/p>\n Hier wählen wir den Eintrag Alle Aufgabenlisten auflisten <\/b>aus. Dessen Eigenschaften erscheinen nun auf der linken Seite. Auf der Seite Parameter erhalten wir wie bereits angedeutet den Hinweis, dass keine zusätzlichen Informationen nötig sind. Im unteren Bereich sollten wir, wenn wir bereits die Schritte aus dem eingangs erwähnten Artikel ausgeführt haben, die Information vorfinden, dass wir bereits mit Microsoft To-Do verbunden sind. Wir brauchen auch bei diesem Schritt nichts weiter zu tun (siehe Bild 4).<\/p>\n Bild 4: Einstellungen für die neue Aktion<\/span><\/b><\/p>\n Wir können den Flow nun speichern und das wird auch ohne Probleme gelingen. Damit können wir nun zur ersten Aktion beziehungsweise zum Trigger mit der Beschriftung manual <\/b>zurückkehren. Klicken wir diesen an, sehen wir nun unter HTTP-URL <\/b>die URL, die wir aufrufen müssen. Hier müssen wir außerdem noch prüfen, ob Wer kann den Flow auslösen <\/b>den Wert Jeder <\/b>aufweist (siehe Bild 5).<\/p>\n Bild 5: Prüfen des Auslösers und Abholen der URL<\/span><\/b><\/p>\n Im Gegensatz zum Beispiel aus dem eingangs erwähnten Artikel wollen wir hier eine Antwort erhalten, die über einen Status mit einer Erfolgsmeldung hinausgeht. Dazu fügen wir noch eine weitere Aktion hinzu. Diese heißt Antwort<\/b> und wir finden diese wie in Bild 6.<\/p>\n Bild 6: Anlegen der Antwort-Aktion<\/span><\/b><\/p>\n Hier müssen wir allerdings Hand anlegen. Die Parameter der Antwort<\/b>-Aktion sehen wir in Bild 7. Wichtig sind hier die Eigenschaften Status Code <\/b>und Body<\/b>. Wenn wir den Flow aufrufen, ohne diese letzte Aktion hinzuzufügen, bekommen wir immer den Status 202 <\/b>zurück – ohne einen Response<\/b>-Text. Hier legen wir nun fest, dass wir den Status 200<\/b> erhalten, wenn dieser Schritt erreicht wird, und mit der Eigenschaft Body <\/b>definieren wir, welchen Inhalt wir zurückerhalten wollen. Deshalb klicken wir auf die Schaltfläche mit dem Blitz und dem Text fx<\/b>, um die verfügbaren Elemente anzuzeigen.<\/p>\n Bild 7: Eintragen des Body-Wertes<\/span><\/b><\/p>\n Diese sehen wir nun in Bild 8. Hier sehen wir alle möglichen Ergebnisse der Aktion Alle Aufgabenlisten auflisten<\/b>. Wir wählen den Eintrag Textkörper <\/b>aus. Mit allen anderen Einträgen konnten wir den Flow nicht ohne Fehlermeldungen speichern. Nun gelingt dies jedoch, und wir können uns dem Aufruf per VBA zuwenden.<\/p>\n Bild 8: Hinzufügen des Elements Textkörper zur Eigenschaft Body der Antwort<\/span><\/b><\/p>\n Nachdem wir uns so praktisch unseren eigenen maßgeschneiderten Webservice gebaut haben, können wir diesen per VBA aufrufen. Um diese optimal verarbeiten zu können, wollen wir jedoch noch zwei Voraussetzungen schaffen. Als Erstes benötigen wir einen Verweis auf die Bibliothek Microsoft Scripting Runtime<\/b>. Außerdem fügen wir zwei Module namens mdlJSON <\/b>und mdlJSONDOM <\/b>zum VBA-Projekt hinzu. Diese enthalten wichtige Funktionen zum Auswerten der Antwort des Webservices.<\/p>\n In der Prozedur GetToDoLists<\/b> aus Listing 1 rufen wir den Webservice auf. Hier deklarieren wir einige Variablen und weisen dann der Variablen strURL <\/b>die URL zu, die wir weiter oben dem Element manual <\/b>entnommen haben. Dann rufen wir diese URL. Liefert diese den Wert 200 <\/b>als Status zurück, war der Aufruf erfolgreich. Dann können wir den Inhalt der Eigenschaft responseText<\/b> des XMLHTTP<\/b>-Objekts in die Variable strResponse<\/b> schreiben. Da es sich hierbei um ein JSON-Dokument handelt, verwenden wir die Funktion GetJSONDOM<\/b>, um die Referenzen zu den einzelnen Inhalten des Dokuments im Direktbereich auszugeben. Dieser sieht für das erste Element wie folgt aus:<\/p>\n Listing 1: Prozedur zum Ermitteln aller Aufgabenlisten von To Do<\/span><\/b><\/p>\n Uns interessieren primär der Anzeigename (displayName<\/b>) und die id<\/b>. Letztere benötigen wir, um gezielt die Aufgaben einer Liste zu bearbeiten.<\/p>\n Wir haben den Inhalt mit der Funktion ParseJSON <\/b>ausgelesen und in eine Objektstruktur geschrieben, die wir mit der Variablen objJSON <\/b>referenzieren. Über diese können wir die enthaltene Werte nun mit den von GetJSONDOM <\/b>gelieferten Referenzen ermitteln.<\/p>\n Wenn wir GetJSONDOM <\/b>nun durch die folgende Schleife ersetzen, erhalten wir alle Anzeigenamen plus ID im Direktbereich:<\/p>\n Damit können wir arbeiten – wir können die Informationen nun beispielsweise in eine Access- oder Excel-Tabelle schreiben, um weiter damit zu arbeiten.<\/p>\n Im nächsten Schritt wollen wir zu einer dieser Aufgabenlisten alle Aufgaben ausgeben. Dazu legen wir einen neuen Flow an. Das ist bereits deutlich anspruchsvoller, wie wir gleich sehen werden.<\/p>\n Grundsätzlich ist der Aufbau des Flows ähnlich: Wir verwenden wieder das manual<\/b>-Objekt zum Start, dann eines, das die Einträge liefert und am Ende die Antwort. Allerdings können wir die Einträge nicht so einfach wie zuvor als Antwort zurückschicken, sondern müssen diese zwischendurch noch prozessieren. Das erscheint gleich in der Beschreibung leicht, aber da wir im Web kein Beispiel dafür gefunden haben und alles selbst herausfinden mussten, sind dafür einige Stunden draufgegangen.<\/p>\n Der vollständige Flow wird später wie in Bild 9 aussehen. Wir starten mit dem Request-Element, dem wir mitteilen, welche Liste ausgelesen werden soll und wie viele Einträge wir maximal erhalten wollen. Dann folgt das eigentliche Auslesen durch die Aktion Aufgaben nach Ordner auflisten<\/b>. Die damit erhaltenen Informationen müssen wir allerdings noch verarbeiten. Dazu erstellen wir eine Array-Variable, die wir in der folgenden Schleife mit den Elementen der gefundenen Aufgaben füllen. Mit der Verfassen-Aktion bereiten wir die Inhalte zur Rückgabe als Response vor und geben diese schließlich mit dem Response-Element zurück.<\/p>\n Bild 9: Vollständiger Flow zum Abfragen der Aufgaben einer Aufgabenliste<\/span><\/b><\/p>\n Dies schauen wir uns nun im Detail an.<\/p>\n Wir starten mit einem neuen Flow, für den wir wieder den Typ Beim Empfang einer HTTP-Aufforderung<\/b>. Für diesen legen wir unter Wer kann den Flow auslösen <\/b>wieder Jeder <\/b>fest.<\/p>\n Für JSON-Schema des Anforderungstexts hinterlegen wir das folgende JSON-Dokument, mit dem wir diesmal nicht nur die listId <\/b>abfragen, sondern mit count <\/b>auch die maximale Anzahl der zurückzugebenden Elemente:<\/p>\n Über das Pluszeichen fügen wir nun ein neues Element hinzu. Leider ist die Suche nach Aktionen so schlecht, dass wir uns behelfen, indem wir das Suchwort Aufgaben <\/b>eingeben und etwas nach unten scrollen, bis wir die Gruppe Microsoft To-Do <\/b>finden. Diese enthält auch die Aktion Aufgaben nach Ordner auflisten<\/b>, die wir durch Anklicken hinzufügen.<\/p>\n Hier finden wir in den Eigenschaften unter Parameter die beiden Parameter To-Do-List <\/b>und Höchstzahl<\/b>. Wenn wir das Nachschlagfeld für To-Do-Liste <\/b>öffnen, sehen wir alle To-Do-Listen für das angegebene Konto und ganz unten den Eintrag Benutzerdefinierten Wert eingeben<\/b>. Dies blendet die Schaltfläche aus Bild 10 ein.<\/p>\n Bild 10: Weitere Auswahlmöglichkeiten<\/span><\/b><\/p>\n Klicken wir auf den Blitz oben, erhalten wir die aus den bisherigen Elementen verfügbaren Parameter, hier listId <\/b>und count <\/b>aus dem manual<\/b>-Element (siehe Bild 11). Hier wählen wir folglich das Element listId <\/b>für To-Do-Liste <\/b>aus und count <\/b>für Höchstanzahl<\/b> und haben so schon alle Einstellungen für diese Aktion festgelegt.<\/p>\n Bild 11: Hinzufügen der Parameter<\/span><\/b><\/p>\n Du solltest an dieser Stelle auch noch prüfen, ob du mit einem Microsoft To-Do-Konto verbunden bist und dies gegebenenfalls an der Stelle aus Bild 12 erledigst.<\/p>\n Bild 12: Prüfen der Verbindung mit Microsoft To-Do<\/span><\/b><\/p>\n Im vorherigen Beispiel konnten wir an dieser Stelle bereits die Antwort<\/b>-Aktion hinzufügen. Das ist hier noch nicht möglich, denn wir müssen die Elemente des Ergebnisses der Aufgaben nach Ordner auflisten<\/b>-Aktion noch aufbereiten.<\/p>\n Dazu geben wir als Suchbegriff Variable <\/b>an und wählen dort den Eintrag Variable initialisieren <\/b>aus (siehe Bild 13).<\/p>\n Bild 13: Hinzufügen der Aktion Variable initialisieren<\/span><\/b><\/p>\n Für dieses neue Variable-Element stellen wir nun die Parameter ein (siehe Bild 14). Hier finden wir den Parameter Name<\/b>, dem wir den Wert tasksArray <\/b>zuweisen. Der Parameter Type <\/b>erhält den Wert Array <\/b>und für Value <\/b>stellen wir mit einem eckigen Klammernpaar ein leeres Array ein.<\/p>\n Bild 14: Einstellen der Parameter<\/span><\/b><\/p>\n Nun benötigen wir eine Schleife, in der wir alle Aufgaben in die Array-Variable eintragen. Diese finden wir unter dem Namen Auf alle anwenden <\/b>im Bereich Control<\/b> (siehe Bild 15).<\/p>\n Bild 15: Hinzufügen der Aktion Auf alle anwenden<\/span><\/b><\/p>\n In den Parametern dieses neuen Elements legen wir nun fest, welchen Output eines vorherigen Elements wie verarbeiten wollen. Hier wählen wir den Eintrag Textkörper <\/b>aus Aufgaben nach Ordner auflisten aus<\/b> (siehe Bild 16).<\/p>\n Bild 16: Auswählen des Outputs, der in der Schleife verarbeitet werden soll<\/span><\/b><\/p>\n Danach müssen wir noch festlegen, was genau mit diesen Inhalten geschehen soll. Dazu klicken wir auf die Plus<\/b>-Schaltfläche innerhalb des Auf alle anwenden<\/b>-Elements (siehe Bild 17) und wählen die Aktion hinzufügen<\/b>-Anweisung aus.<\/p>\n Bild 17: Hier fügen wir noch ein Element hinzu.<\/span><\/b><\/p>\n Hier suchen wir im Suchen-Feld wieder nach dem Schlüsselwort Variable <\/b>und wählen diesmal den Eintrag An Arrayvariable anfügen <\/b>aus.<\/p>\n Hier sind nun zwei Parameter festzulegen. Für Name wählen wir den Namen der Variable aus, also tasksArray<\/b>. Einen anderen Eintrag gibt es auch nicht.<\/p>\n Für Value<\/b> klicken wir wieder auf das Blitz-Symbol und finden dann eine ganze Reihe von Elementen vor, wenn wir für Aufgaben nach Ordner auflisten <\/b>auf Mehr anzeigen (19) <\/b>klicken (siehe Bild 18).<\/p>\n Bild 18: Auswahl der Eigenschaften der Aufgabe<\/span><\/b><\/p>\n Aber können wir hier nun nur ein Element auswählen? Was ist, wenn wir beispielsweise die ID und den Titel selektieren wollen? Das ist kein Problem: Wir können beliebig viele Elemente auswählen und diese nacheinander per Mausklick zur Eigenschaft Value <\/b>hinzufügen.<\/p>\n In diesem Fall wollen wir uns jedoch mit ID und Titel begnügen, damit die Rückgabe überschaubar bleibt.<\/p>\n Das reicht allerdings noch nicht aus, denn so werden die Elemente einfach in einem JSON-Dokument aneinandergehängt. Wir bearbeiten also die beiden Elemente in der Eigenschaft Value, indem wir die Struktur eines JSON-Dokuments hinzufügen – hier in Form von geschweiften Klammern und den Namen für die Elemente, hier id <\/b>und title<\/b> (siehe Bild 19).<\/p>\n Bild 19: Strukturieren der Eigenschaften der Aufgabe in einem JSON-Dokument<\/span><\/b><\/p>\n Nach der Schleife fügen wir eine weitere Aktion hinzu. Diese finden wir über die Suche nach dem Begriff Verfassen <\/b>sehr schnell und fügen sie hinzu.<\/p>\n Für den Parameter Eingaben <\/b>wählen wir über die durch Anklicken des Blitz-Icons erscheinende Variable tasksArray <\/b>aus.<\/p>\n Schließlich benötigen wir noch das Antwort-Element selbst, das wir nach Eingabe des Suchbegriffs Antwort im Bereich Anforderung finden.<\/p>\n Hier behalten wir den Wert 200 <\/b>für den Parameter Status Code <\/b>bei und fügen für Body <\/b>den Wert Verfassen|Ausgaben <\/b>hinzu.<\/p>\n Ob wir alles korrekt angelegt haben, erfahren wir, wenn wir den Flow mit einem Klick auf die entsprechende Schaltfläche speichern. Wenn dies gelingt, können wir ihn mit der im Anschluss vorgestellten VBA-Prozedur testen.<\/p>\n Diese finden wir in Listing 2. Die Prozedur GetTaskOfAList <\/b>nimmt mit dem Parameter strListID <\/b>die ID der Liste entgegen, deren To Do-Aufgaben ermittelt werden sollen. Folglich benötigen wir noch einen Aufruf dieser Prozedur, mit der wir die ID ermitteln und übergeben. Hier haben wir die ID bereits vorab ermittelt und übergeben diese als Parameter:<\/p>\n Listing 2: Prozedur zum Ermitteln aller Aufgaben einer Liste in To Do<\/span><\/b><\/p>\n Die Prozedur verwendet eine Variable namens strURL<\/b>, der wir noch die URL zuweisen müssen, die wir für den Aufruf des Flows verwenden können. Diese wurde beim Speichern des Flows im Element manual <\/b>im Parameter HTTP-URL <\/b>hinterlegt. Dort können wir sie herauskopieren und für strUrl <\/b>einfügen. Dann rufen wir die URL mit dem objXMLHTTP<\/b>-Objekt auf und übergeben neben der Methode POST <\/b>die URL. Außerdem setzen wir den üblichen Request-Header. Für die Send<\/b>-Methode stellen wir vorab in der Variablen strRequest <\/b>ein JSON-Dokument mit der listId <\/b>und der maximalen Anzahl (count<\/b>) zusammen.<\/p>\n Danach werten wir das Ergebnis, zuerst die status<\/b>-Eigenschaft. Diese liefert optimalerweise den Wert 200<\/b>, dann hat alles funktioniert. In diesem Fall lesen wir den Inhalt der Eigenschaft responseText <\/b>in die Variable strResponse <\/b>ein. Wir verwenden die ParseJSON<\/b>-Funktion, um aus dem zurückgelieferten JSON-Dokument eine Objektstruktur zu machen, die wir nach bewährter Manier über das mit GetJSONDOM <\/b>einzusehende Objektmodell auslesen können.<\/p>\n In diesem Fall durchlaufen wir in einer Schleife von 1<\/b> bis zur Anzahl der Element von objJSON <\/b>die mit objJSON.Item(i).Item(“id”)<\/b> und objJSON.Item(i).Item(“title”) <\/b>referenzierten IDs <\/b>und Titel <\/b>der Aufgaben. Diese geben wir hier der Einfachheit halber im Direktbereich des VBA-Editors aus.<\/p>\n Sollte ein Fehler auftreten und der Flow liefert nicht den Wert 200 <\/b>zurück, geben wir den gelieferten Status plus Text in einem Meldungsfenster aus.<\/p>\n Die IDs und Titel könnten wir beispielsweise in eine Excel- oder Access-Tabelle schreiben und sie dann nutzen, um gezielt weitere Eigenschaften einer einzelnen Aufgabe auszulesen.<\/p>\n Im Artikel To Do-Aufgabe mit Power Automate und VBA anlegen <\/b>(www.vbentwickler.de\/431<\/b>) haben wir einfach nur eine To Do-Aufgabe angelegt. Den dortigen Flow wollen wir noch erweitern um die Rückgabe der ID des neu angelegten Flows.<\/p>\n Dazu fügen wir den beiden Elementen manual <\/b>und Aufgabe hinzufügen <\/b>noch das Element Antwort <\/b>hinzu (siehe Listing 3).<\/p>\n Listing 3: Prozedur zum Anlegen einer Aufgabe mit Rückgabe der ID<\/span><\/b><\/p>\n Für diese legen wir für den Parameter Body<\/b> den Wert aus Bild 20 fest.<\/p>\n Bild 20: Rückgabewert beim Anlegen einer neuen Aufgabe<\/span><\/b><\/p>\n Natürlich müssen wir auch die Prozedur anpassen, welche die neue Aufgabe anlegt. Diese legen wir gleich als Funktion an, die den Wert True <\/b>oder False <\/b>zurückgibt und die im Falle von True <\/b>mit dem Parameter strID <\/b>die ID der neuen Aufgabe liefert. Außerdem soll die Funktion den Titel und das Datum der anzulegenden Aufgabe als Parameter entgegennehmen.<\/p>\n Diese werden in das mit dem Request gesendete JSON-Dokument geschrieben. Der Request erfolgt wie in den bereits zuvor beschriebenen Prozeduren.<\/p>\n Beim Auswerten des Ergebnisses lesen wir den Wert von objJSON.Item(“id”) <\/b>in den Rückgabeparameter strID <\/b>ein.<\/p>\n Der Aufruf erfolgt mit einer Prozedur wie der folgenden:<\/p>\n Gerade beim Anlegen einer Aufgabe möchten wir vielleicht noch mehr Flexibilität und wollen noch weitere Eigenschaften von VBA aus übergeben wie zum Beispiel einen Body-Text.<\/p>\n Dazu sind folgende Schritte nötig:<\/p>\n Schauen wir uns an, wie das funktioniert – insbesondere im Hinblick darauf, dass wir gegebenenfalls übergebene Werte nur optional verwenden wollen.<\/p>\n Dazu schauen wir uns erst einmal an, welche Werte wir einer neuen Aufgabe überhaupt zuweisen können. Dies finden wir im Element Aufgabe hinzufügen <\/b>(siehe Bild 21). Alle dort angegebenen Elemente können wir mit dem Request übergeben. Diesen gestalten wir dazu wie folgt:<\/p>\n Bild 21: Leere Parameter einer neuen Aufgabe<\/span><\/b><\/p>\n Nun erweitern wir den VBA-Code für die anzulegende Aufgabe um die entsprechenden Elemente. Da das JSON-Dokument nun schon etwas umfangreicher wird, stellen wir es auf alternative Weise zusammen. Außerdem wollen wir alle Werte für die zu erstellende Aufgabe als Parameter übergeben und passen den Funktionskopf entsprechend an (Erweiterungen siehe Listing 4).<\/p>\n Listing 4: Prozedur zum Anlegen einer Aufgabe mit allen Parametern<\/span><\/b><\/p>\n Dazu deklarieren wir eine Dictionary<\/b>-Objektvariable namens dicRequest<\/b>. Dieses füllen wir mit einem neuen Dictionary<\/b>-Objekt, das wir anschließend über die Add<\/b>-Methode mit den Parametern füllen.<\/p>\n Dabei passen wir das Format für die Datumsangaben noch auf yyyy-mm-ddT00:00:00Z<\/b> an. Für den Parameter importance <\/b>können wir die Werte high<\/b>, low <\/b>oder normal <\/b>verwenden. Für den Parameter status <\/b>nutzen wir einen der Werte notStarted<\/b>, inProgress<\/b>, completed<\/b>, waitingOnOthers <\/b>oder deferred<\/b>. Das so zusammengestellte Dictionary<\/b>-Objekt wandeln wir mit der Funktion ConvertToJson <\/b>in eine Zeichenkette mit dem JSON-Dokument um. Der Rest der Funktion arbeitet wie die vorherige Version.<\/p>\n Den Aufruf können wir nun so gestalten:<\/p>\n Damit stellen wir nun sicher, dass die Parameter wie im Element manual <\/b>des Flows definiert übergeben werden.<\/p>\n Nun müssen wir diese noch entsprechend in die zu erstellende Aufgabe einarbeiten. Dazu klicken wir das Element Aufgabe hinzufügen <\/b>an und erhalten den Dialog aus Bild 22.<\/p>\n Bild 22: Parameter beim Anlegen einer neuen Aufgabe<\/span><\/b><\/p>\n Hier klicken wir jeweils auf das Element, für das wir den Parameter füllen wollen und dann auf das Blitz-Symbol. Nun sehen wir die Liste der verfügbaren Elemente, von denen wir das jeweils gewünschte anklicken und so den Parameter einfügen.<\/p>\n Nun wollen wir noch die Rückgabewerte definieren. Diese können wir so nicht nur für das Anlegen einer neuen Aufgabe nutzen, sondern auch beispielsweise dann, wenn wir den Inhalt einer speziellen Aufgabe auslesen wollen. Dazu klicken wir auf das Element Antwort<\/b>.<\/p>\n Hier ist nun wieder ein wenig Handarbeit angesagt. Wir müssen nämlich ein JSON-Dokument zusammenstellen, das die korrekten Bezeichnungen sowie die aktuellen Werte der Parameter enthält. Das Ergebnis sieht wie in Bild 23 aus. Wir schreiben hier jeweils eine neue Zeile in das JSON-Dokument und platzieren die Einfügemarke dann zwischen den beiden Anführungszeichen für den Wert eines Name-Wert-Paares.<\/p>\n Bild 23: Rückgabewert beim Anlegen einer neuen Aufgabe zusammenstellen<\/span><\/b><\/p>\n Dann klicken wir auf das Blitz-Symbol und sehen die im Flow verfügbaren Elemente. Hier erweitern wir die Anzeige von Aufgabe hinzufügen und finden nun alle Elemente, die wir benötigen, in der Liste.<\/p>\n Auf diese Weise stellen wir das JSON-Dokument mit allen relevanten Informationen zusammen.<\/p>\n Diese Antwort können wir noch anderen Stellen gebrauchen, zum Beispiel beim Ermitteln der Werte einer Aufgabe oder nach dem Ändern einer Aufgabe. Dazu kopieren wir einfach den Inhalt aus dem Feld Body<\/b> in die Zwischenablage und fügen diesen im gewünschten Flow wieder ein.<\/p>\n Wir können dies auch in einer Textdatei oder an einem anderen Ort zwischenspeichern. Hier sehen wir, dass sich hinter den Platzhaltern wiederum Ausdrücke in einer bestimmten Notation befinden, die wir hier nicht weiter untersuchen, sondern nur einmal vorstellen wollen. Anbei die gekürzte Fassung unserer Antwort:<\/p>\n In der oben beschriebenen Funktion AddToDoTask<\/b> werten wir jedoch nur die ID des neuen Elements aus, da wir die übrigen Informationen für das neue Element ja bereits kennen – wir haben sie schließlich übergeben.<\/p>\n Wenn wir Aufgaben per VBA hinzufügen, wollen wir diese gegebenenfalls auch wieder löschen.<\/p>\n Auch dafür gibt es eine Aktion. Diese heißt Aufgabe löschen <\/b>und wir fügen sie einem neuen Flow namens Aufgabe löschen <\/b>hinzu.<\/p>\n Diese Aktion erwartet die Angabe der To Do-Liste als auch die ID der zu löschenden Aufgabe als Parameter. Also fügen wir diese beiden zum Element manual unter Parameter für den Anforderungstext im JSON-Format in Form des Schemas aus Bild 24 hinzu.<\/p>\n Bild 24: Flow zum Löschen einer Aufgabe<\/span><\/b><\/p>\n Danach bearbeiten wir das Element Aufgabe löschen<\/b>.<\/p>\n Hier fügen wir für die beiden Parameter To-Do-List <\/b>und To-Do-Aufgabe <\/b>die beiden zuvor im Element ![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_002.png\")
<\/p>\n![\"Alle](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_003.png\")
<\/p>\n![\"Einstellungen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_004.png\")
<\/p>\n![\"Prüfen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_005.png\")
<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_006.png\")
<\/p>\nAntwort als Eigenschaft hinzufügen<\/h2>\n
![\"Eintragen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_008.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_007.png\")
<\/p>\nAlle Aufgabenlisten per VBA ermitteln<\/h2>\n
Sub <\/span>GetToDoLists()\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.ServerXMLHTTP60\r\n Dim <\/span>strUrl As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>objJSON As Object<\/span>\r\n Set<\/span> objXMLHTTP = New<\/span> MSXML2.ServerXMLHTTP60\r\n strUrl = \"https:\/\/prod2-25.germanywestcentral.logic.azure.com:443\/workflows\/...\"\r\n With<\/span> objXMLHTTP\r\n .Open \"POST\", strUrl, False<\/span>\r\n .setRequestHeader \"Content-Type\", \"application\/json\"\r\n .send \"{}\"\r\n End With<\/span>\r\n Select Case objXMLHTTP.status\r\n Case <\/span>200\r\n strResponse = objXMLHTTP.responseText\r\n Set<\/span> objJSON = ParseJson(strResponse)\r\n Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.statusText\r\n End Select<\/span>\r\n Set<\/span> objXMLHTTP = Nothing\r\nEnd Sub<\/span><\/pre>\nobjJSON.Item(1).Item(\"@odata.etag\"): W\/\"5kiLK5VJy0...\"\r\nobjJSON.Item(1).Item(\"displayName\"): Tasks\r\nobjJSON.Item(1).Item(\"isOwner\"): Wahr\r\nobjJSON.Item(1).Item(\"isShared\"): Falsch\r\nobjJSON.Item(1).Item(\"wellknownListName\"): defaultList\r\nobjJSON.Item(1).Item(\"id\"): AQMkADAwATNiZmYAZC05M2I2LTRiYTgtMDACLTAwCgAuAAADKTYDS538L0CXniiMkbeMfQEA5kiLK5VJy0Cml8itxoUMYQAAAgESAAAA<\/pre>\n
Dim <\/span>i As Integer<\/span>\r\nFor i = 1 To objJSON.Count\r\n Debug.Print<\/span> objJSON.Item(i).Item(\"displayName\"), _\r\n objJSON.Item(i).Item(\"id\")\r\nNext<\/span> i<\/pre>\nAufgaben einer Aufgabenliste abrufen<\/h2>\n
![\"Vollständiger](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_009.png\")
<\/p>\nTrigger für den Request hinzufügen<\/h2>\n
{\r\n \"properties\": {\r\n \"listId\": {\r\n \"type\": \"string\"\r\n },\r\n \"count\": {\r\n \"type\": \"integer\"\r\n }\r\n },\r\n \"type\": \"object\"\r\n}<\/pre>\nAktion zum Abfragen der Aufgaben hinzufügen<\/h2>\n
![\"Weitere](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_010.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_011.png\")
<\/p>\n![\"Prüfen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_012.png\")
<\/p>\nArray-Variable initialisieren<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_013.png\")
<\/p>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_014.png\")
<\/p>\nSchleife über alle Aufgaben<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_015.png\")
<\/p>\n![\"Auswählen](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_016.png\")
<\/p>\n![\"Hier](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_017.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_018.png\")
<\/p>\n![\"Strukturieren](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_019.png\")
<\/p>\nVerfassen der Antwort<\/h2>\n
Hinzufügen des Antwort-Elements<\/h2>\n
Speichern des Flows<\/h2>\n
Sub <\/span>GetTasksOfAList(strListID As String<\/span>)\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.ServerXMLHTTP60\r\n Dim <\/span>strUrl As String<\/span>\r\n Dim <\/span>strRequest As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>objJSON As Object<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> objXMLHTTP = New<\/span> MSXML2.ServerXMLHTTP60\r\n strUrl = \"https:\/\/prod2-11.germanywestcentral.logic.azure.com:443\/workflows\/2641fd9330094a83bf60f40088c...\"\r\n With<\/span> objXMLHTTP\r\n .Open \"POST\", strUrl, False<\/span>\r\n .setRequestHeader \"Content-Type\", \"application\/json\"\r\n strRequest = \"{\"\"listId\"\": \"\"\" & strListID & \"\"\", \"\"count\"\":999}\"\r\n .send strRequest\r\n End With<\/span>\r\n Select Case objXMLHTTP.status\r\n Case <\/span>200\r\n strResponse = objXMLHTTP.responseText\r\n Set<\/span> objJSON = ParseJson(strResponse)\r\n For i = 1 To objJSON.Count\r\n Debug.Print<\/span> objJSON.Item(i).Item(\"id\"), objJSON.Item(i).Item(\"title\")\r\n Next<\/span> i\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.statusText\r\n End Select<\/span>\r\n Set<\/span> objXMLHTTP = Nothing\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>Test_GetTasksOfAList()\r\n Dim <\/span>strListID As String<\/span>\r\n strListID = \"AQMkADAwATNiZmYAZC05M2I2LTRiYTgtMD...\"\r\n GetTasksOfAList strListID\r\nEnd Sub<\/span> <\/pre>\nUpdate des Flows zum Anlegen einer Aufgabe<\/h2>\n
Public Function <\/span>AddToDoTask(strTitle As String<\/span>, datDue As Date<\/span>, Optional<\/span> strID As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n Dim <\/span>strUrl As String<\/span>\r\n Dim <\/span>strJSON As String<\/span>\r\n Dim <\/span>objJSON As Object<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Set<\/span> objXMLHTTP = New<\/span> MSXML2.XMLHTTP60\r\n strUrl = \"https:\/\/prod2-20.germanywestcentral.logic.azure.com:443\/workflows\/966850d91ed3480badfcb64c1...\"\r\n strJSON = \"{\"\"title\"\":\"\"\" & strTitle & \"\"\",\"\"dueDate\"\":\"\"\" & Format(datDue, \"yyyy-mm-ddT00:00:00Z\") _\r\n & \"\"\",\"\"importance\"\":\"\"normal\"\"}\"\r\n With<\/span> objXMLHTTP\r\n .Open \"POST\", strUrl, False<\/span>\r\n .setRequestHeader \"Content-Type\", \"application\/json\"\r\n .send strJSON\r\n End With<\/span>\r\n Select Case objXMLHTTP.status\r\n Case <\/span>200\r\n strResponse = objXMLHTTP.responseText\r\n Set<\/span> objJSON = ParseJson(strResponse)\r\n AddToDoTask = True<\/span>\r\n strID = objJSON.Item(\"id\")\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.statusText\r\n End Select<\/span>\r\n Set<\/span> objXMLHTTP = Nothing\r\nEnd Function<\/span><\/pre>\n![\"Rückgabewert](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_020.png\")
<\/p>\nPublic Sub <\/span>Test_AddToDoTask()\r\n Dim <\/span>strID As String<\/span>\r\n If <\/span>AddToDoTask(\"Neue Aufgabe\", Date, strID) = True<\/span> Then<\/span>\r\n Debug.Print<\/span> \"Neue ID: \" & strID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nEingaben und Rückgabewerte erweitern<\/h2>\n
\n
![\"Leere](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_023.png\")
<\/p>\n{\r\n \"type\": \"object\",\r\n \"properties\": {\r\n \"listID\": {\r\n \"type\": \"string\"\r\n },\r\n \"title\": {\r\n \"type\": \"string\"\r\n },\r\n \"dueDateTime\": {\r\n \"type\": \"string\"\r\n },\r\n \"reminderDateTime\": {\r\n \"type\": \"string\"\r\n },\r\n \"importance\": {\r\n \"type\": \"string\"\r\n },\r\n \"status\": {\r\n \"type\": \"string\"\r\n },\r\n \"bodyContent\": {\r\n \"type\": \"string\"\r\n }\r\n }\r\n}<\/pre>\nPublic Function <\/span>AddToDoTask(strTitle As String<\/span>, Optional<\/span> strListID As String<\/span>, Optional<\/span> datDue As Date<\/span>, _\r\n Optional<\/span> datReminder As Date<\/span>, Optional<\/span> strImportance As String<\/span>, Optional<\/span> strStatus As String<\/span>, _\r\n Optional<\/span> strBody As String<\/span>, Optional<\/span> strID As String<\/span>) As Boolean<\/span>\r\n ...\r\n Dim <\/span>dicRequest As <\/span>Dictionary\r\n Set<\/span> objXMLHTTP = New<\/span> MSXML2.XMLHTTP60\r\n strUrl = \"https:\/\/prod2-20.germanywestcentral.logic.azure.com:443\/workflows\/966850d91ed3480badfcb64c1b...\"\r\n Set<\/span> dicRequest = New<\/span> Dictionary\r\n With<\/span> dicRequest\r\n .Add \"listId\", strListID\r\n .Add \"title\", strTitle\r\n .Add \"dueDate\", Format(datDue, \"yyyy-mm-ddT00:00:00Z\")\r\n .Add \"reminderDateTime\", Format(datReminder, \"yyyy-mm-ddT00:00:00Z\")\r\n .Add \"importance\", strImportance\r\n .Add \"status\", strStatus\r\n .Add \"bodyContent\", strBody\r\n End With<\/span>\r\n strJSON = ConvertToJson(dicRequest)\r\n ...\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>Test_AddToDoTask()\r\n Dim <\/span>strID As String<\/span>\r\n If AddToDoTask(\"Neue Aufgabe normal\", _\r\n \"AQMkADAwATNiZmYAZC05M...\", Date, Date, _\r\n \"normal\", \"notStarted\", \"Inhalt der Aufgabe\", _\r\n strID) = True<\/span> Then\r\n Debug.Print<\/span> \"Neue ID: \" & strID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nParameter den Eigenschaften der neuen Aufgabe zuweisen<\/h2>\n
![\"Parameter](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_022.png\")
<\/p>\nRückgabe definieren<\/h2>\n
![\"Rückgabewert](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_024.png\")
<\/p>\nTipp: Antwort für andere Flows über Zwischenablage kopieren<\/h2>\n
{ \"id\": \"@{outputs(''Aufgabe_hinzufügen'')?[''body\/id']}\", \"createdDateTime\": \"@{outputs(''Aufgabe_hinzufügen'')?[''body\/createdDateTime']}\", \"lastModifiedDateTime\": \"@{outputs(''Aufgabe_hinzufügen'')?[''body\/lastModifiedDateTime']}\",\r\n ...}<\/pre>\nEine Aufgabe löschen<\/h2>\n
![\"Flow](\"..\/fileadmin\/_temp_\/2024_03\/pic_432_025.png\")
<\/p>\n