{"id":55000431,"date":"2024-06-01T00:00:00","date_gmt":"2024-08-07T10:15:40","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=431"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"To_DoAufgabe_mit_Power_Automate_und_VBA_anlegen","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/To_DoAufgabe_mit_Power_Automate_und_VBA_anlegen\/","title":{"rendered":"To Do-Aufgabe mit Power Automate und VBA anlegen"},"content":{"rendered":"
Power Automate ist ein cloudbasierter Service von Microsoft, der es Benutzern ermöglicht, Automatisierungen und Workflows zwischen verschiedenen Apps und Diensten zu erstellen. Früher bekannt als Microsoft Flow, bietet Power Automate eine benutzerfreundliche Oberfläche zum Erstellen von Automatisierungen ohne die Notwendigkeit von tiefgreifenden Programmierkenntnissen. Mit ein paar Tricks können wir Power Automate auch per VBA steuern. Ein guter Grund, trotz der anfallenden monatlichen Gebühren einmal einen Blick auf diese Technologie zu werfen. In diesem Artikel schauen wir uns an, welche Voraussetzungen es für Power Automate gibt und wie wir einen unverbindlichen Test damit durchführen können. Außerdem nutzen wir diesen Test für ein praxisnahes Beispiel: Wir wollen der Anwendung Microsoft To Do einen Termin hinzufügen, indem wir per VBA einen Power Automate-Flow triggern, der dann eine Aktion zum Anlegen der Aufgabe auslöst.<\/b><\/p>\n
Was ist Power Automate überhaupt? Hier sind einige Schlüsselmerkmale und Funktionen von Power Automate:<\/p>\n
\n
Integrationen<\/b>: Es ermöglicht die nahtlose Integration mit einer Vielzahl von Microsoft- und Drittanbieteranwendungen wie Office 365, SharePoint, Dynamics 365, Google Drive, Salesforce, Twitter und so weiter.<\/li>\n
Workflow-Erstellung: Nutzer können Workflows visuell durch Drag-and-Drop von Aktionen erstellen. Diese Aktionen können verschiedene Aufgaben wie das Senden einer E-Mail, das Erstellen eines Eintrags in einer Datenbank, das Verschieben von Dateien et cetera ausführen.<\/li>\n
Automatisierung<\/b>: Routineaufgaben können automatisiert werden, um die Produktivität zu steigern und menschliche Fehler zu reduzieren. Zum Beispiel können Genehmigungsworkflows erstellt werden, die auf bestimmte Bedingungen reagieren.<\/li>\n
Benutzerfreundlichkeit<\/b>: Die Plattform ist so konzipiert, dass sie von Benutzern mit unterschiedlichem technischem Hintergrund genutzt werden kann, von Anfängern bis zu fortgeschrittenen Benutzern.<\/li>\n
Auslöser und Bedingungen<\/b>: Automatisierungen können basierend auf Ereignissen (wie beispielsweise das Eingehen einer E-Mail, das Hinzufügen einer Datei in OneDrive) oder bestimmten Bedingungen gestartet werden.<\/li>\n
Berichterstellung und Überwachung<\/b>: Es bietet Einblicke in die Ausführung von Workflows und ermöglicht die Überwachung der Leistung sowie die Fehlerbehandlung.<\/li>\n
Sicherheit und Compliance<\/b>: Power Automate unterstützt Sicherheitsmaßnahmen wie Datenverschlüsselung und Compliance-Standards wie GDPR.<\/li>\n<\/ul>\n
Insgesamt ist Power Automate ein leistungsstarkes Werkzeug zur Automatisierung von Geschäftsprozessen, das Unternehmen hilft, effizienter zu arbeiten und die Interaktion zwischen verschiedenen Apps und Diensten zu optimieren. Auf den nächsten Seiten schauen wir uns an, wie wir es nutzen können.<\/p>\n
Beispielanwendung: Microsoft To Do<\/h2>\n
Ehrlich gesagt sind wir auf Power Automate schon länger aufmerksam geworden, aber am einfachsten fällt das Schreiben von Artikeln über bestimmte Themen doch, wenn man die vorgestellte Technik auch einmal praktisch einsetzen kann.<\/p>\n
In diesem Fall haben wir nach einer Möglichkeit gesucht, um Microsoft To Do von außen mit Daten zu füttern, um beispielsweise Aufgaben aus einer Datenbankanwendung heraus schreiben zu können.<\/p>\n
Wir haben uns natürlich auch die Rest API angesehen, die Microsoft To Do liefert. Allerdings wäre der Aufwand, die Authentifizierung zu programmieren, zu hoch gewesen. Auf der Suche nach einer Alternative sind wir über Power Automate gestoßen. Wir wollen hier eine bestimmte URL mit passenden Informationen aufrufen, um Einträge zu Microsoft To Do hinzuzufügen. Power Automate bietet eine solche Schnittstelle, sodass wir hier dieses Werkzeug nutzen wollen.<\/p>\n
Wir benötigen ein Geschäftskonto bei Microsoft, um mit Power Automate zu arbeiten. Mit einem privaten Konto funktionierte dies zum Zeitpunkt der Erstellung dieses Artikels nicht. Wir starten unter folgender URL:<\/p>\n
Hier klicken wir auf Kostenlos testen<\/b> (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Einstieg in PowerAutomate<\/span><\/b><\/p>\n
Danach landen wir auf einer Seite, auf der wir unsere Geschäfts-, Schul- oder Uni-E-Mail-Adresse eingeben können, mit der wir ein Konto bei Microsoft haben (siehe Bild 2).<\/p>\n
<\/p>\n
Bild 2: Eingeben der E-Mail-Adresse<\/span><\/b><\/p>\n
Im nächsten Schritt geben wir an, dass wir die Adresse von unserer Organisation erhalten haben.<\/p>\n
Einen Schritt weiter fragt Microsoft unsere Telefonnummer ab, um per SMS oder Anruf einen Prüfcode zu übermitteln. Diesen geben wir nach Erhalt ein und gelangen zu einer weiteren Seite, auf der wir nun die Daten zur Erstellung unseres Kontos hinterlegen.<\/p>\n
Nach dem erneuten Eintragen eines Prüfcodes, der diesmal per E-Mail versendet wird, klicken wir auf Weiter<\/b>.<\/p>\n
Nach der Registrierung können wir zu der zuerst aufgerufenen Seite zurückkehren und diese aktualisieren. Wir landen dann auf der Seite aus Bild 3.<\/p>\n
<\/p>\n
Bild 3: Zurück auf der PowerAutomate-Plattform<\/span><\/b><\/p>\n
Hier klicken wir nun auf die Schaltfläche Erstellen<\/b>.<\/p>\n
Hier sehen wir nun unter anderem die Möglichkeit, Power Automate für Desktop herunterzuladen und zu installieren. Wir wollen jedoch zunächst mit der Webversion arbeiten und schauen uns daher die verfügbaren Möglichkeiten an (siehe Bild 4).<\/p>\n
<\/p>\n
Bild 4: Erstellen eines neuen Flows<\/span><\/b><\/p>\n
Auf den ersten Blick ist man erst einmal überwältigt und weiß nicht, wo man anfangen soll. Die fünf hier vorgestellten Elemente dienen dazu sind allgemeine Vorlagen.<\/p>\n
Weiter unten finden wir einige konkrete Vorlagen. Diese sind ähnlich aufgebaut wie bei Tools wie Zapier oder Make: Es gibt immer mindestens zwei beteiligte Anwendungen, von denen die eine den Trigger stellt und die andere liefert das Ziel für die nun durchzuführende Aktion. Hier kannst Du Dir einmal einen Überblick über die grundsätzlichen Möglichkeiten verschaffen.<\/p>\n
Weiter unten findest Du die Möglichkeit, einen Connector zum Beginnen auszuwählen. Das bedeutet, dass Du die Anwendung wählst, die den Flow auslösen soll.<\/p>\n
Hier finden wir nach einem Klick auf Alle Connectors <\/b>viele Einträge, zum Beispiel auch Office 365 Outlook, SharePoint, Microsoft Teams, Outlook.com, SQL Server, Power BI, One Note (Business), Excel Online, Trello und auch Microsoft To Do. Wir können aber auch externe Anwendungen wie X, Google Drive, Slack, YouTube und viele mehr adressieren.<\/p>\n
Wir starten für unseren Anwendungsfall jedoch mit der Vorlage Sofortiger Cloud-Flow<\/b>.<\/p>\n
Im nun erscheinenden Fenster wählen wir den Eintrag Beim Empfang einer HTTP-Anforderung <\/b>aus (siehe Bild 5) und klicken auf Erstellen<\/b>.<\/p>\n
<\/p>\n
Bild 5: Hinzufügen eines Direktflows<\/span><\/b><\/p>\n
Hier klicken wir nun auf Manual<\/b> und füllen das nun erscheinende Formular wie in Bild 6 aus.<\/p>\n
<\/p>\n
Bild 6: Eintragen eines JSON-Schemas<\/span><\/b><\/p>\n
Unter Parameter <\/b>stellen wir unter Wer kann den Flow auslösen <\/b>den Wert Jeder <\/b>ein. Das ist wichtig, weil wir sonst einen Fehler 401 erhalten. Darunter fügen wir das folgende vorläufige JSON-Schema ein, das wir später noch anpassen werden:<\/p>\n
Dieses enthält die Vorgabe für die zu übergebenden Daten.<\/p>\n
Damit kehren wir zur Übersicht zurück und klicken auf das Plus-Zeichen.<\/p>\n
Es erscheint der Befehl Aktion hinzufügen<\/b>, den wir anklicken (siehe Bild 7).<\/p>\n
<\/p>\n
Bild 7: Hinzufügen der Aktion<\/span><\/b><\/p>\n
Klicken wir diesen an, erscheint der Dialog Eine Aktion hinzufügen<\/b>. Hier geben wir als Suchbegriff nicht etwa To Do <\/b>oder To-Do <\/b>ein, sondern Aufgabe<\/b>. Dies liefert die gewünschten Aktionen, wie Bild 8 zeigt.<\/p>\n
<\/p>\n
Bild 8: Auswählen der Aktion<\/span><\/b><\/p>\n
Dies erweitert unseren Flows um den Eintrag Aufgabe hinzufügen<\/b>. Links können wir nun eine Verbindung zu unserem To Do-Konto herstellen (siehe Bild 9).<\/p>\n
<\/p>\n
Bild 9: Herstellen einer Verbindung zu To Do<\/span><\/b><\/p>\n
Nun erscheint gegebenenfalls eine Warnmeldung, dass der Browser ein Popupfenster blockiert hat. Dieses müssen wir jedoch zulassen.<\/p>\n
Um dies zu erledigen, klicken wir zum Beispiel in Microsoft Edge auf das Symbol aus Bild 10 und lassen die entsprechenden Popups zu.<\/p>\n
<\/p>\n
Bild 10: Freigeben der Popups<\/span><\/b><\/p>\n
Danach klicken wir erneut auf Anmelden. Hier treten nun keine Probleme mehr auf und wir können uns im nun erscheinenden Popup mit dem Konto anmelden, unter dem wir Microsoft To Do Aufgaben hinzufügen wollen (siehe Bild 11).<\/p>\n
<\/p>\n
Bild 11: Anmelden unter dem To Do-Konto<\/span><\/b><\/p>\n
Anschließend erscheint ein Dialog, mit dem wir die Daten zum Erstellen einer neuen Ausgabe eintragen können (siehe Bild 12).<\/p>\n
<\/p>\n
Bild 12: Zuweisen der Parameter zur Aufgabe<\/span><\/b><\/p>\n
Hier finden wir alle Eigenschaften, die wir einer Aufgabe zuweisen können:<\/p>\n
\n
To-Do-Liste<\/b>: Hier können wir die Liste auswählen, der die Aufgabe hinzugefügt werden soll.<\/li>\n
Titel<\/b>: Erwartet den Titel. Wir können hier einen der mit dem JSON-Dokument definierten Werte auswählen, in diesem Fall title<\/b>.<\/li>\n
Fälligkeitsdatum<\/b>: Hier können wir ebenfalls einen Eintrag aus dem JSON-Dokument angeben, wie im Screenshot zu sehen.<\/li>\n
Datum und Uhrzeit für Erinnerung<\/b>: Legt Details für die Erinnerung fest.<\/li>\n
Relevanz<\/b>: Gibt die Relevanz an.<\/li>\n
Status<\/b>: Gibt den Status an.<\/li>\n
Textkörper-Inhalt<\/b>: Nimmt den Inhalt der Aufgabe entgegen.<\/li>\n<\/ul>\n
Bei den Text-Eigenschaften wird gleich nach dem Aktivieren rechts eine doppelte Schaltfläche eingeblendet (siehe Bild 13).<\/p>\n
<\/p>\n
Bild 13: Anzeigen der Tools zum Zuweisen von Werten oder Funktionen<\/span><\/b><\/p>\n
Der obere Befehl zeigt die Liste der über die JSON-Vorlage verfügbaren Elemente an, der untere erlaubt das Einfügen von Funktionen und dynamischen Inhalten. Diese benötigen wir jetzt allerdings noch nicht.<\/p>\n
Wir wollen erst einmal eine To-Do-Liste auswählen und Daten für Titel, Fälligkeitsdatum und Relevanz angeben.<\/p>\n
Eigenschaften der neuen Aufgabe als JSON-Dokument<\/h2>\n
Wenn wir nun zum Bereich Codeansicht<\/b> wechseln, finden wir das JSON-Dokument aus Bild 14 vor. Hier sehen wir, dass es auch für den Ordner einen bestimmten Wert gibt, den wir auslesen und für spätere Aufrufe nutzen wollen, wenn wir auch den Ordner beim Anlegen einer Aufgabe definieren wollen (folderId<\/b>).<\/p>\n
<\/p>\n
Bild 14: Der resultierende JSON-Code zum Anlegen der Aufgabe<\/span><\/b><\/p>\n
Wollen wir den Vorgang nun speichern, erhalten wir eine Meldung mit einer Vorgangswarnung. Diese besagt, dass wir für das Ausführen dieses Flows eine Premium-Lizenz besitzen müssen. Wir starten hier die 90-tägige Testversion.<\/p>\n
Klicken wir nun auf Flowprüfung, erhalten wir die Meldung, dass keine Fehler gefunden wurden. Also können wir uns nun darum kümmern, wie wir den Flow aufrufen.<\/p>\n
Nun steht einem ersten Test nichts mehr im Wege. Also klicken wir auf Test. Dies bewirkt allerdings nichts, denn wir müssen die Startaktion selbst ausführen – also den Aufruf der HTTP-Adresse.<\/p>\n
Dazu benötigen wir erst einmal die Adresse. Diese finden wir nun im Bereich des Schritts manual<\/b> (siehe Bild 15). <\/p>\n
<\/p>\n
Bild 15: Ermitteln der HTTP-URL<\/span><\/b><\/p>\n
VBA-Code zum Anlegen einer Aufgabe in To Do<\/h2>\n
Damit benötigen wir nun nur noch eine Prozedur, mit der wir die HTTP-URL aufrufen können. <\/p>\n
Bevor wir diese anlegen, fügen wir dem VBA-Projekt noch einen Verweis auf die Bibliothek Microsoft XML, v6.0 <\/b>hinzu (siehe Bild 16).<\/p>\n
<\/p>\n
Bild 16: Verweis auf die XML-Bibliothek<\/span><\/b><\/p>\n
Danach können wir die Prozedur aus Listing 1 ausprobieren.<\/p>\n
Sub <\/span>AddToDoTask()\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 Set<\/span> objXMLHTTP = New<\/span> MSXML2.XMLHTTP60\r\n strURL = \"https:\/\/prod2-20.germanywestcentral.logic.azure.com:443\/workflows\/...\"\r\n strJSON = \"{\"\"title\"\":\"\"Neue Aufgabe\"\",\"\"dueDate\"\":\"\"2024-07-15T00:00:00Z\"\",\"\"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, 202\r\n MsgBox<\/span> \"Aufgabe erfolgreich hinzugefügt!\"\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>\n
Listing 1: Aufruf zum Anlegen einer neuen Aufgabe in Microsoft To Do<\/span><\/b><\/p>\n
Die Prozedur deklariert ein XMLHTTP60<\/b>-Objekt sowie einige String<\/b>-Variablen. Nach dem Initialisieren von objXMLHTTP <\/b>weisen wir der Variablen strURL <\/b>die oben gewonnene URL hinzu.<\/p>\n
Außerdem schreiben wir eine JSON-Datei auf Basis der Vorlage, die wir weiter oben deklariert haben, in die Variable strJSON<\/b>. Hier ersetzen wir allerdings die Platzhalter durch die Werte, die wir der Aufgabe hinzufügen wollen.<\/p>\n
Wir rufen dann die Open<\/b>-Methode des XMLHTTP<\/b>-Objekts auf und übergeben dieser die Methode POST<\/b>, die URL aus strURL <\/b>und den Wert False <\/b>für einen asynchronen Aufruf. Wir stellen den RequestHeader <\/b>so ein, dass der Inhalt als JSON definiert ist.<\/p>\n
Schließlich senden wir den Inhalt der JSON-Datei mit der Send<\/b>-Methode.<\/p>\n
Danach müssen wir nur noch das Ergebnis auswerten. In diesem Fall sprechen die Status<\/b>-Werte 200 <\/b>oder 202 <\/b>für ein erfolgreiches Übersenden der Aufgabe, was eine entsprechende Meldung auslöst.<\/p>\n
In allen anderen Fällen werden der Status und die Fehlermeldung ausgegeben. Wie wir in unserer Beispielliste sehen, hat das Übertragen schließlich funktioniert (siehe Bild 17).<\/p>\n
<\/p>\n
Bild 17: Per VBA und Power Automate hinzufügte Aufgaben<\/span><\/b><\/p>\n
Damit haben wir an einem ersten Beispiel gezeigt, wie ein spezieller Fall von Power Automation funktioniert – nämlich der, bei dem wir einen HTTP-Aufruf als Trigger nutzen.<\/p>\n
Fassen wir noch einmal zusammen, was wir in diesem Artikel alles erledigt haben:<\/p>\n
\n
Erst einmal haben wir uns entschieden, von der direkten Programm der Rest API von Microsoft To Do abzusehen, weil die Authentifizierung mit VBA zu kompliziert ist.<\/li>\n
Dann haben wir unserem Geschäftskonto bei Microsoft ein Power Automate-Konto hinzugefügt und zunächst einmal den kostenlosen Test gewählt.<\/li>\n
Dann mussten wir entscheiden, welche Art von Flow wir anlegen wollen. Wir haben den Fall Beim Empfang einer HTTP-Anforderung <\/b>gewählt. Diesen können wir per VBA anstoßen.<\/li>\n
Für diesen haben wir zunächst ein Template für ein JSON-Dokument hinterlegt, das vorgibt, wie eine Anfrage aussehen kann, die wir später per VBA als Trigger an diesen Flow schicken. Dieses legt fest, dass wir titel<\/b>, dueDate <\/b>und importance <\/b>übergeben können.<\/li>\n
Dann haben wir die Aktion hinzugefügt, die ausgeführt werden soll, wenn der Trigger ausgelöst wurde. Hier haben wir die Aktion Aufgabe hinzufügen <\/b>gewählt.<\/li>\n
Um die Aktion nutzen zu können, müssen wir angeben, im Kontext wessen Accounts die Aktion ausgeführt werden soll – hier melden wir uns als der Benutzer an, dessen To Do-Aufgaben wir bearbeiten wollen.<\/li>\n
Danach haben wir den Parametern dieser Aktion die Werte aus der JSON-Vorlage zugewiesen. Hier haben wir festgestellt, dass diese längst noch nicht alle verfügbaren Werte enthält.<\/li>\n
Anschließend haben wir den neuen Flow geprüft und gespeichert. Danach konnten wir diesem die URL entnehmen, die wir nutzen müssen, um diesen per HTTP-Anfrage aufzurufen.<\/li>\n
Schließlich folgt der Schritt, in dem wir die VBA-Prozedur schreiben, die den HTTP-Aufruf durchführt. Diese stellt das JSON-Dokument zusammen und schickt es an die weiter oben ermittelte URL.<\/li>\n
Dadurch wird der Flow getriggert und schließlich die Aufgabe angelegt.<\/li>\n<\/ul>\n
Zusammenfassung und Ausblick<\/h2>\n
Damit haben wir einen ersten Flow angelegt, mit dem wir über VBA einen HTTP-Trigger auslösen können, der dann eine Aufgabe in To Do anlegt.<\/p>\n
In einem weiteren Artikel namens To Do mit VBA und Power Automate steuern <\/b>(www.vbentwickler.de\/432<\/b>) schauen wir uns an, wie wir diese Technik nutzen können, um To Do Aufgaben vollständig zu verwalten – zum Beispiel, um Aufgaben abzurufen, zu aktualisieren, hinzuzufügen, zu löschen oder auch um Listen zu erstellen, zu aktualisieren, abzurufen oder zu löschen.<\/p>\n
Sprich: Wir programmieren ein Rundum-Sorglos-Paket für den Zugriff auf unsere To Do-Listen und Aufgaben.<\/p>\n
Dabei gehen wir auch im Detail darauf ein, wie wir das JSON-Dokument und den Aufruf anpassen müssen, um die verschiedenen Aufgaben durchzuführen.<\/p>\n
![\"Einstieg](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_001.png\")
<\/p>\n![\"Eingeben](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_002.png\")
<\/p>\n![\"Zurück](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_003.png\")
<\/p>\n![\"Erstellen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_006.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_007.png\")
<\/p>\n![\"Eintragen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_008.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_009.png\")
<\/p>\n![\"Auswählen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_010.png\")
<\/p>\n![\"Herstellen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_011.png\")
<\/p>\n![\"Freigeben](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_012.png\")
<\/p>\n![\"Anmelden](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_013.png\")
<\/p>\n![\"Zuweisen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_014.png\")
<\/p>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_015.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_016.png\")
<\/p>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_017.png\")
<\/p>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_018.png\")
<\/p>\n![\"Per](\"..\/fileadmin\/_temp_\/2024_03\/pic_431_019.png\")
<\/p>\n