{"id":55000444,"date":"2024-10-01T00:00:00","date_gmt":"2024-11-05T20:52:50","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=444"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Trello_per_RestAPI_steuern","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Trello_per_RestAPI_steuern\/","title":{"rendered":"Trello per Rest-API steuern"},"content":{"rendered":"

Trello ist eines der bekanntesten Projektmanagement-Tools. Damit lassen sich Projekte, Aufgaben und ToDos im Kanban-Style verwalten. Die Basisfunktionen sind bereits mächtig und dabei aber nicht unübersichtlich und man kann über sogenannte PowerUps viele zusätzliche Funktionen integrieren. Nicht zu reden von den Automationen – viele sind interne Automationen, die innerhalb von Trello genutzt werden köknnen und natürlich gibt es auch einige Möglichkeiten, Trello und die enthaltenen Elemente über Werkzeuge wie Zapier oder Make von anderen Tools zu steuern und umgekehrt. Aber wir wären keine VB\/VBA-Entwickler, wenn wir nicht per Code auf die in Trello angelegten Boards, Karten und Eigenschaften zugreifen wollten, um diese zu lesen oder zu schreiben. Die Weboberflächen vieler noch so guter Tools bieten letztlich nicht immer alle nötigen Funktionen, die man aber abbilden kann, wenn das Tool eine Rest-API anbietet und man sich mit der Steuerung solcher APIs unter VB\/VBA auskennt. Dann können wir beispielsweise schnell die Projekte oder Aufgaben aus einer Excel- oder Access-Tabelle in Trello anlegen oder auch auf die in Trello enthaltenen Daten zugreifen, um diese mit den Daten in unserer Datenbankwendung abzugleichen. In diesem Artikel zeigen wir, wie dies gelingt.<\/b><\/p>\n

Voraussetzungen für die Nutzung der Trello-Rest-API<\/h2>\n

Voraussetzung ist, dass wir einen Trello-Account angelegt haben.<\/p>\n

Im Gegensatz zu verschiedenen anderen Anbietern gibt es bei Trello keine grundsätzlichen Einschränkungen in Abhängigkeit vom Zahlungsplan, den man gewählt hat – die Rest-API können wir immer nutzen.<\/p>\n

Allerdings sind bestimmte Funktionen erst mit den höheren, kostenpflichtigen Plänen verfügbar. So können wir beispielsweise mit den höheren Plänen eine höhere Anzahl von Aufrufen pro Zeiteinheit absetzen oder auch erweiterte Funktonen nutzen. Benutzerdefinierte Felder beispielsweise können wir mit dem kostenlosen Plan noch nicht bearbeiten oder nutzen.<\/p>\n

Erste Schritte für die Trello-Rest-API<\/h2>\n

Wann immer wir eine Rest-API verwenden wollen, benötigen wir einen Key, mit dem wir uns bei der Rest-API für unseren Account referenzieren können.<\/p>\n

Das bedeutet, dass wir irgendwo in unserem Trello-Kundenkonto eine solche Zeichenfolge finden oder anlegen können sollten. Die grundlegenden Informationen finden wir unter dieser URL:<\/p>\n

https:\/\/developer.atlassian.com\/cloud\/trello\/guides\/rest-api\/api-introduction\/<\/pre>\n
Power-Up\/Integration anlegen<\/h2>\n
Um auf die Rest-API zugreifen zu können, müssen wir eine neue Integration erstellen. Dazu gehen wir zur folgenden URL, wobei wir für die folgenden Schritte bereits mit unserem Benutzerkonto angemeldet sein müssen:<\/p>\n
https:\/\/trello.com\/power-ups\/admin<\/pre>\n
Hier finden wir eine Schaltfläche namens Neu<\/b>, die wir gleich einmal betätigen (siehe Bild 1).<\/p>\n
\"Seite<\/p>\n
Bild 1: Seite zum Anlegen eines Power-Ups oder einer Integration<\/span><\/b><\/p>\n
Auf der anschließend erscheinenden Seite geben wir die für das Anlegen eines Power-Up beziehungsweise einer Integration benötigten Informationen an (siehe Bild 2).<\/p>\n
\"Eingabe<\/p>\n
Bild 2: Eingabe der notwendigen Informationen<\/span><\/b><\/p>\n
Die nächste Seite lädt uns nun direkt dazu ein, einen API-Schlüssel zu erstellen.<\/p>\n
Um das zu erledigen, klicken wir auf den Befehl Einen neuen API-Schlüssel generieren <\/b>(siehe Bild 3).<\/p>\n
\"Anlegen<\/p>\n
Bild 3: Anlegen des neuen Schlüssels<\/span><\/b><\/p>\n
Eine Bestätigung später sehen wir auf der gleichen Seite bereits unsere API-Schlüssel. Diesen kopieren wir in die Zwischenablage und speichern ihn an einer sicheren Stelle zwischen, zum Beispiel in einer Textdatei.<\/p>\n
Außerdem finden wir, etwas versteckt, den Link zum manuellen Erstellen eines Tokens für unsere Anwendung (in Bild 4 hervorgehoben).<\/p>\n
\"Der<\/p>\n
Bild 4: Der neue Schlüssel auf der Webseite von Trello<\/span><\/b><\/p>\n
Hier weist der Text explizit darauf hin, dass wir ein hier manuell erstelltes Token nutzen können, um eine Anwendung selbst zu erstellen oder lokal zu testen. Wir haben an dieser Stelle nicht vor, eine Anwendung zu programmieren, mit der wir auf die Boards anderer Benutzer zugreifen wollen.<\/p>\n
Wir möchten allein auf unser eigenes Board zugreifen und die dort enthaltenen Elemente einlesen und bearbeiten können.<\/p>\n
Durch das Anklicken des Links mit dem Text Token <\/b>gelangen wir zu einer weiteren Seite, die wir in Bild 5 sehen.<\/p>\n
\"Anlegen<\/p>\n
Bild 5: Anlegen eines Tokens für die Authentifizierung<\/span><\/b><\/p>\n
Dies ist der Dialog, der auch auftauchen würde, wenn wir einer Anwendung den Zugriff auf die Boards anderer Benutzer erlauben wollten. In diesem Fall wollen wir allerdings nur ein Token für den Zugriff auf unser eigenes Board erhalten. Nach einer Prüfung, ob die Benutzerdaten, mit denen wir angemeldet sind, mit den hier angezeigten Benutzerdaten übereinstimmen, können wir uns den unteren Bereich des Dialogs ansehen.<\/p>\n
Hier finden wir die Angabe der Berechtigungen, die wir mit dem zu erstellenden Token erhalten.<\/p>\n
Beispielsweise der Zugriff auf Name und Benutzername, Einfügen von Kommentaren, aber vor allem Zugriff auf alle Boards und Arbeitsbereiche und das Erstellen und Aktualisieren von Karten, Listen, Boards und Arbeitsbereichen.<\/p>\n
Hier klicken wir nun die Schaltfläche Erlauben <\/b>an. Dies liefert uns als Ergebnis eine neue Seite, mit dem Token, das uns noch für den Zugriff auf die Rest-API fehlte (siehe Bild 6).<\/p>\n
\"Das<\/p>\n
Bild 6: Das Token für den Zugriff auf unser Trello-Konto<\/span><\/b><\/p>\n
Diese Token kopieren wir ebenfalls in die Zwischenanlage und fügen es zu der Textdatei hinzu, in der wir bereits den API-Key gespeichert haben.<\/p>\n
Erste Schritte für den Trello-Zugriff in VBA<\/h2>\n
Wenn wir nun per VBA auf Trello zugreifen wollen, benötigen wir für unser VBA-Projekt einen Verweis auf die Bibliothek Microsoft XML, v6.0<\/b>. Diesen legen wir an, indem wir im VBA-Editor den Menübefehl Extras|Verweise <\/b>betätigen und hier den entsprechenden Eintrag selektieren (siehe Bild 7). Hier fügen wir gleich noch einen weiteren Eintrag hinzu, nämlich den namens Microsoft Scripting Runtime<\/b>. Diesen benötigen wir für die Verwendung der nachfolgend vorgestellten Module, die intensiven Gebrauch des Dictionary<\/b>-Objekts machen, das sich in diesem Verweis verbirgt.<\/p>\n
\"Hinzufügen<\/p>\n
Bild 7: Hinzufügen eines Verweises auf die XML-Bibliothek<\/span><\/b><\/p>\n
Diese Module sind in anderen Artikel bereits zum Einsatz gekommen und heißen mdlJSON <\/b>und mdlJSONDOM<\/b>. Mehr dazu erfährst Du in den Artikeln Mit JSON arbeiten <\/b>(www.vbentwickler.de\/361<\/b>) und JSON-Dokumente per Objektmodell zusammenstellen <\/b>(www.vbentwickler.de\/412<\/b>).<\/p>\n
Referenz der Rest-API<\/h2>\n
Bevor wir mit der Programmierung der Rest-API beginnen, hier noch der Hinweis auf die Referenz der Rest-API von Trello. Dies finden wir unter dieser URL:<\/p>\n
https:\/\/developer.atlassian.com\/cloud\/trello\/rest<\/pre>\n
Hier finden wir auf der linken Seite alle bereits bekannten Elemente wieder – beispielsweise Boards<\/b>, Cards<\/b>, Checklists<\/b>, CustomFields<\/b>, Labels<\/b>, Lists<\/b>, Members <\/b>und so weiter. Für jedes dieser Elemente finden wir alle denkbaren API-Befehle – hier wurde wirklich an alles gedacht.<\/p>\n
Vorbereiten der Zugriffsdaten<\/h2>\n
Weiter oben haben wir den API-Key sowie das Token ausgelesen und in einer Textdatei zwischengespeichert. Diese holen wir nun hervor und speichern diese in zwei öffentlich deklarierten Konstanten. Diese legen wir in einem neuen, leeren VBA-Standardmodul an:<\/p>\n
Public <\/span>Const cStrApiKey_Trello As String<\/span> = \"1c16ba94e18e2xxxxxxxxx734f08c6345\"\r\nPublic <\/span>Const cStrToken_Trello As String<\/span> = \"ATTA6467f2ee3c81c6fa0xxxxxxxxxxacbfe587dc3c15eb30f19a61db195b311e1CBC464D1\"<\/pre>\n
Außerdem platzieren wir in einer weiteren Konstanten die Basis-URL, die wir für alle Zugriffe als Grundlage verwenden:<\/p>\n
Public <\/span>Const cStrUrl_Trello As String<\/span> = \"https:\/\/api.trello.com\/1\"<\/pre>\n
Abfragen von Informationen zum aktuellen Benutzer<\/h2>\n
Weiter oben haben wir schon hervorgehoben, dass wir uns bei der in diesem Artikel beschriebenen Lösung auf den Rest-API-Zugriff auf die Daten unseres eigenen Benutzerkontos bei Trello beschränken würden. Wenn wir nun Informationen zu diesem Konto abrufen wollen, benötigen wir dementsprechend keine ID für unser Kundenkonto, die wir als Parameter übergeben, sondern lediglich das Schlüsselwort me <\/b>als Referenz. Die Ausgabe der Details zu unserem Kundenkonto nutzen wir auch als Beispiel für die Einführung der wenigen benötigten Codezeilen für den Zugriff auf die Trello-Rest-API.<\/p>\n
Die Basis für all unsere Zugriffe auf die Rest-API ist die Funktion HTTPRequestTrello<\/b> aus Listing 1.<\/p>\n
Public Function <\/span>HTTPRequestTrello(strURL As String<\/span>, Optional<\/span> strMethod As String<\/span> = \"POST\", _\r\n         Optional<\/span> strRequest As String<\/span>, 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         If <\/span>InStr<\/span>(1, strURL, \"?\") = 0 Then<\/span>\r\n             strURL = strURL & \"?key=\" & cStrApiKey_Trello & \"&token=\" & cStrToken_Trello\r\n         Else<\/span>\r\n             strURL = strURL & \"&key=\" & cStrApiKey_Trello & \"&token=\" & cStrToken_Trello\r\n         End If<\/span>\r\n         .Open strMethod, strURL, False<\/span>\r\n         .setRequestHeader \"Content-Type\", \"application\/json\"\r\n         If <\/span>Not<\/span> Len<\/span>(strRequest) = 0 Then<\/span>\r\n             .setRequestHeader \"Body\", strRequest\r\n         End If<\/span>\r\n         .send\r\n         strResponse = .responseText\r\n         HTTPRequestTrello = .status\r\n     End With<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 1: Funktion für den Zugriff auf die Rest-API von Trello<\/span><\/b><\/p>\n
Diese Funktion nimmt die URL, die Methode (POST<\/b>, GET<\/b>, PUT <\/b>oder DELETE<\/b>) sowie gegebenenfalls eine im JSON-Format gelieferte Anfrage entgegen. Ein weiterer Parameter namens strResponse <\/b>liefert ein eventuell im JSON-Format erhaltenes Ergebnis zurück. Die Funktion selbst ist als Integer <\/b>deklariert und sie soll einen Zahlenwert zurückliefern, der Auskunft über die Art des Ergebnisses liefert. Der Wert 200 <\/b>beispielsweise steht für einen erfolgreichen Aufruf.<\/p>\n
Die Funktion deklariert und erstellt ein Objekt des Typs ServerXMLHTTP60<\/b>, mit dem wir den Zugriff auf die Rest-API durchführen können. Dazu prüfen wir kurz die URL aus strURL<\/b>. Es kann sein, dass wir hier in der aufrufenden Prozedur bereits einen oder mehrere Parameter hinzugefügt haben. Der Teil der URL mit den Parametern wird immer mit dem Fragezeichen eingeleitet (?<\/b>) und die einzelnen Name-Wert-Paare für die Parameter werden durch das Kaufmanns-Und miteinander verbunden (&<\/b>).<\/p>\n
Wenn bereits ein & <\/b>vorhanden ist, hängen wir Key und Token mit einem führenden Fragezeichen an, sonst mit einem Kaufmanns-Und. Zur Überprüfung nutzen wir eine If…Then<\/b>-Bedingung und ergänzen darin die URL um die beiden Werte der Konstanten cStrApiKey_Trello <\/b>und cStrToken_Trello<\/b>, die wir für die Parameter key und token <\/b>anhängen.<\/p>\n
Dann rufen wir die Open<\/b>-Methode auf und übergeben dieser die Zugriffsart aus strMethod <\/b>sowie die URL aus strURL<\/b>.<\/p>\n
Als Request-Header geben wir nur die Art des Content-Types an (JSON). Wenn die Variable strRequest <\/b>einen Request im JSON-Format enthält, setzen wir den Inhalt dieser Variablen für einen weiteren Header namens Body<\/b>.<\/p>\n
Schließlich schicken wir die Anfrage mit der send<\/b>-Methode ab und speichern die Antwort aus der Eigenschaft responseText im Rückgabeparameter strResponse <\/b>und legen den Status als Rückgabewert der Funktion fest.<\/p>\n
Um die Benutzerinformationen für unseren eigenen Benutzer abzurufen, benötigen wir eine recht kleine Prozedur namens GetProfileTrello <\/b>zum Aufruf von HTTPRequestTrello<\/b> (siehe Listing 2). Diese schreibt die um \/members\/me <\/b>ergänzte Basis-URL in die Variable strURL<\/b>, die auch an HTTPRequestTrello <\/b>übergeben wird – nebst der Methode GET <\/b>und der Variablen strResponse <\/b>zum Holen der Antwort.<\/p>\n
Public Sub <\/span>GetProfileTrello()\r\n     Dim <\/span>intResult As Integer<\/span>\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     strURL = cStrUrl_Trello\r\n     strURL = strURL & \"\/members\/me\"\r\n     intResult = HTTPRequestTrello(strURL, \"GET\", , _\r\n         strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, _\r\n                 GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Auslesen eines Profils über die Trello-Rest-API<\/span><\/b><\/p>\n
Nach dem Ausführen der Funktion prüfen wir ihren Rückgabewert. Lautet dieser 200<\/b>, war der Aufruf erfolgreich. Dann geben wir das Ergebnis, das als JSON-Dokument kommt, mithilfe der Funktion GetJSONDOM<\/b> so strukturiert aus, dass wir per VBA leicht auf die ausgegebenen Elemente zugreifen können:<\/p>\n
In Bild 8 sehen wir, wie das Ergebnis im Direkbereich des VBA-Editors ausgegeben wird. Hier sehen wir nicht nur die eindeutige ID für unseren Benutzer, sondern auch seinen Namen und die E-Mail-Adresse. Außerdem sehen wir hier auch noch weitere wichtige Informationen wie die IDs der Boards dieses Benutzers.<\/p>\n
\"Ausgabe<\/p>\n
Bild 8: Ausgabe des Zugriffs auf den eigenen Benutzer<\/span><\/b><\/p>\n
Boards eines Benutzers ausgeben<\/h2>\n
Wir können allerdings auch noch über eine eigens dafür vorgesehene API-Funktion auf die Boards eines Benutzers zugreifen. Die benötigte Rest-API-Funktion finden wir hier beschrieben:<\/p>\n
https:\/\/developer.atlassian.com\/cloud\/trello\/rest\/api-group-members\/#api-members-id-boards-get<\/pre>\n
Dieser Aufruf liefert normalerweise einen ganzen Rutsch an Informationen zu den jeweiligen Boards zurück.<\/p>\n
Wir wollen diese Informationen eingrenzen, indem wir in der URL mit fields=id,name <\/b>auf die beiden Felder ID <\/b>und Name <\/b>eingrenzen (siehe Listing 3).<\/p>\n
Public Sub <\/span>GetBoardsAMemberBelongsTo()\r\n     Dim <\/span>intResult As Integer<\/span>\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     strURL = cStrUrl_Trello & \"\/members\/me\/boards?fields=id,name\"\r\n     intResult = HTTPRequestTrello(strURL, \"GET\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, _\r\n                 GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 3: Einlesen aller Boards eines Mitglieds<\/span><\/b><\/p>\n
Hier erhalten wir eine Antwort wie die folgende:<\/p>\n
objJSON.Item(1).Item(\"id\"): 66eb1bc1aade0c9c5f0ca455\r\nobjJSON.Item(1).Item(\"name\"): Access [basics]\r\nobjJSON.Item(2).Item(\"id\"): 6640778b978d4b578d8d71\r\nobjJSON.Item(2).Item(\"name\"): Access im Unternehmen\r\n...\r\nobjJSON.Item(7).Item(\"id\"): 66ec4501b8422b5893b1f0e4\r\nobjJSON.Item(7).Item(\"name\"): VB-Entwickler<\/pre>\n
Wir finden also mit einem Index versehene Elemente einer Auflistung vor. Wenn wir diese nacheinander verarbeiten wollen, brauchen wir nicht jeweils den Index zu setzen und die Anweisungen zu wiederholen, sondern können einfach über eine Schleife auf die Elemente zugreifen. Für den ersten Versuch reicht es jedoch, sich immer mal zunächst alle Elemente mit Debug.Print GetJSONDOM(strResponse, True) <\/b>ausgeben zu lassen. Dann kann man die Struktur der Antwort analysieren und die Anweisungen für die tatsächliche Verarbeitung hinzufügen. In diesem Fall sieht das wie folgt aus:<\/p>\n
Public Sub <\/span>GetBoardsAMemberBelongsTo()\r\n     ...\r\n     Dim <\/span>objJSON As Object<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     ...\r\n     Select Case intResult\r\n         Case <\/span>200\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\"), _\r\n                     objJSON.Item(i).Item(\"name\")\r\n             Next<\/span> i\r\n         ...\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Wir haben zwei Variablen namens objJSON <\/b>und i <\/b>hinzugefügt. Mit objJSON <\/b>referenzieren wir das Ergebnis der Funktion ParseJSON<\/b> für das mit strResponse <\/b>gelieferte JSON-Dokument.<\/p>\n
Mit objJSON.Count <\/b>ermitteln wir die Anzahl der Item<\/b>-Elemente und durchlaufen diese dann in einer For…Next<\/b>-Schleife.<\/p>\n
Damit können wir uns die ID und den Namen holen und verschiedene Dinge damit erledigen – zum Beispiel die Daten in eine Excel-Tabelle oder in eine Access-Tabelle schreiben.<\/p>\n
Zu den Boards benötigen zunächst erst einmal keine weiteren Informationen außer der ID und dem Namen.<\/p>\n
Informationen zu einem Board ermitteln<\/h2>\n
Haben wir die ID des zu untersuchenden Boards herausgefunden, können wir diese in einer weiteren Prozedur nutzen, um Details zu einem Board zu ermitteln.<\/p>\n
Die dazu verwendete Prozedur sieht wie in Listing 4 aus.<\/p>\n
Public Sub <\/span>GetABoard()\r\n     Dim <\/span>intResult As Integer<\/span>\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     Dim <\/span>strBoardID As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     strBoardID = \"66eb1bc1aade0c9c5f0ca455\"\r\n     strURL = cStrUrl_Trello & \"\/boards\/\" & strBoardID\r\n     intResult = HTTPRequestTrello(strURL, \"GET\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, _\r\n                 GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 4: Einlesen der Detailinformationen eines Boards<\/span><\/b><\/p>\n
In diesem Fall brauchen wir in der URL nicht mehr über members\/me\/ <\/b>auf den aktuellen Benutzer zuzugreifen, denn wir wollen unabhängig vom Benutzer auf dieses Board zugreifen. Das gelingt auch. Allerdings nur, wenn der Benutzer, in dessen Kontext wir auf das Board zugreifen, auch die Berechtigungen für dieses Boards hat.<\/p>\n
Karten eines Boards auslesen<\/h2>\n
Wenn wir weitere Elemente wie beispielswiese die Karten auslesen wollen, benötigen wir den API-Aufruf \/boards\/{id}\/cards<\/b>.<\/p>\n
Mit der folgenden Prozedur GetCardsOnBoard<\/b> holen wir uns wie oben bereits mit den Boards durchgeführt jeweils die ID und den Namen der jeweiligen Karte – dies erreichen wir durch die Angabe des Parameters &fields=id,name<\/b>. Anschließend geben wir die IDs und die Namen untereinander im Direktbereich des VBA-Editors aus (siehe Listing 5).<\/p>\n
Public Sub <\/span>GetCardsOnABoard()\r\n     Dim <\/span>intResult As Integer<\/span>\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     Dim <\/span>strBoardID As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     strBoardID = \"66eb1bc1aade0c9c5f0ca455\"\r\n     strURL = cStrUrl_Trello & \"\/boards\/\" & strBoardID & \"\/cards?fields=id,name\"\r\n     intResult = HTTPRequestTrello(strURL, \"GET\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\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\"), _\r\n                     objJSON.Item(i).Item(\"name\")\r\n             Next<\/span> i\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, _\r\n               GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 5: Auslesen der Karten eines Boards<\/span><\/b><\/p>\n
Listen eines Boards auslesen<\/h2>\n
Fast die gleiche Prozedur nutzen wir zum Auslesen aller Listen eines Boards (siehe Listing 6).<\/p>\n
Public Sub <\/span>GetListsOnABoard()\r\n     ...\r\n     strBoardID = \"66eb1bc1aade0c9c5f0ca455\"\r\n     strURL = cStrUrl_Trello & \"\/boards\/\" & strBoardID & \"\/lists?fields=id,name\"\r\n     intResult = HTTPRequestTrello(strURL, \"GET\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\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(\"name\")\r\n             Next<\/span> i\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 6: Auslesen der Listen eines Boards<\/span><\/b><\/p>\n
Das Ergebnis sieht in diesem Fall beispielsweise wie folgt aus:<\/p>\n
66ebc79e9b7b3c40a50aad0f    Noch offen\r\n66ebc7bcb7ce105e076bcdea    In Bearbeitung\r\n66ebc7bf9573e2a0c7d51a8a    Erledigt<\/pre>\n
Karten einer Liste auslesen<\/h2>\n
Wir haben in den vorherigen beiden Beispielen gesehen, dass wir einerseits alle Karten eines Boards auslesen können, aber auch alle Listen eines Boards. In der Benutzeroberfläche werden die Karten unterhalb der Listen angezeigt. Wie also können wir die Karten einer Liste auslesen?<\/p>\n
Hier verwenden wir die zuvor mit GetListsOnABoard <\/b>ermittelte Liste für die Variable strListID <\/b>und übergeben diese in der folgenden Form mit der URL:<\/p>\n
\/lists\/{id}\/cards<\/pre>\n
Dazu hängen wir, wie in den vorherigen Beispielen, den fields<\/b>-Parameter an und schränken die Ausgabe so auf die IDs und die Namen ein:<\/p>\n
Wenn wir alle Karten aller Listen aller Boards auslesen und in eine Tabelle schreiben wollen, können wir in die Prozedur GetBoardsAMemberBelongsTo <\/b>um einen Aufruf der Prozedur GetListsOnABoard <\/b>erweitern. Dieser würden wir dann einen Parameter hinzufügen, mit dem wir die ID des zu untersuchenden Boards übergeben. In der Schleife dieser Prozedur können wir einen Aufruf der Prozedur GetCardsInAList <\/b>hinzufügen, der wir wiederum mit einem noch anzulegenden Parameter die ID der entsprechenden Liste übergeben (siehe Listing 7).<\/p>\n
Public Sub <\/span>GetCardsInAList()\r\n     ...\r\n     Dim <\/span>strListID As String<\/span>\r\n     strListID = \"66ebc79e9b7b3c40a50aad0f\"\r\n     strURL = cStrUrl_Trello & \"\/lists\/\" & strListID & \"\/cards?fields=id,name\"\r\n     intResult = HTTPRequestTrello(strURL, \"GET\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\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(\"name\")\r\n             Next<\/span> i\r\n         Case <\/span>400\r\n             Debug.Print<\/span> strResponse\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, _\r\n                 GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 7: Auslesen der Karten einer Liste<\/span><\/b><\/p>\n
Arbeitsbereiche ermitteln<\/h2>\n
Bevor wir uns mit der Aufgabe beschäftigen, eigene Boards, Listen oder Karten zu erstellen, benötigen wir noch eine Information – nämlich die ID des Arbeitsbereichs, in dem wir diese Elemente anlegen wollen.<\/p>\n
Während die meisten anderen Elemente in der Benutzeroberfläche genauso benannt sind wie in der Rest-API, ist das bei den Arbeitsbereichen nicht der Fall – das Pendant in der Rest-API heißt dort nämlich Organization<\/b>.<\/p>\n
Daher verwenden wir die Prozedur aus Listing 8.<\/p>\n
Public Sub <\/span>GetAMembersOrganizations()\r\n     ...\r\n     strURL = cStrUrl_Trello & \"\/members\/me\/organizations\"\r\n     intResult = HTTPRequestTrello(strURL, \"GET\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\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(\"name\"), objJSON.Item(i).Item(\"displayName\")\r\n             Next<\/span> i\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 8: Auslesen der Arbeitsbereiche eines Mitglieds<\/span><\/b><\/p>\n
Mit dieser Prozedur holen wir uns die ID der bereits angelegten Arbeitsbereiche. Eigentlich hat man zunächst einmal nur einen Arbeitsbereich. Wenn wir jedoch über die Rest-API ein neues Board anlegen wollen und nicht explizit einen Arbeitsbereich angeben, wird das neue Board in einem neuen Arbeitsbereich angelegt.<\/p>\n
Um auszuschließen, dass dies geschieht, ermitteln wir also zuvor die ID des Zielarbeitsbereichs für unser neues Board.<\/p>\n
Ein neues Board anlegen<\/h2>\n
Interessant wird es, wenn wir neue Boards, Listen und Karten anlegen und diese mit Inhalten füllen. Wir starten mit dem Anlegen eines neuen Boards und dem Ermitteln der ID des neuen Boards, damit wir im Anschluss weitere Elemente hinzufügen können.<\/p>\n
Hier ist wichtig, dass wir die idOrganization <\/b>angeben, also die ID des Workspaces, dem wir das Board hinzufügen wollen. Das erledigen wir mit einem Zusatz zur URL. Außerdem geben wir den Namen des zu erstellenden Boards mit dem Parameter name an, ebenfalls in der URL. Beide Informationen übergeben wir diesmal als Parameter der Prozedur aus Listing 9.<\/p>\n
Public Sub <\/span>CreateABoard(strBoard As String<\/span>, strOrganizationID As String<\/span>)\r\n     ...\r\n     strURL = cStrUrl_Trello & \"\/boards?name=\" & strBoard\r\n     If <\/span>Not<\/span> Len<\/span>(strOrganizationID) = 0 Then<\/span>\r\n         strURL = strURL & \"&idOrganization=\" & strOrganizationID\r\n     End If<\/span>\r\n     intResult = HTTPRequestTrello(strURL, \"POST\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n             Debug.Print<\/span> objJSON.Item(\"id\"), objJSON.Item(\"name\")\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 9: Erstellen eines neuen Boards<\/span><\/b><\/p>\n
Die Prozedur hängt den Namen des zu erstellenden Boards über den Parameter name an die URL an. Außerdem fügt sie, wenn eine Organisations-ID übergeben wurde, auch diese an die URL an. Diese wird wie üblich an HTTPRequestTrello <\/b>übergeben, diesmal mit der POST<\/b>-Methode. Bei erfolgreicher Ausführung erhalten wir mit strResponse <\/b>die Antwort zurück, die wir zum Betrachten mit GetJSONDOM <\/b>einmal komplett ausgeben.<\/p>\n
Dort erfahren wir, mit welchen Ausdrücken wir die ID und den Namen des neuen Boards ermitteln und geben diese anschließend gezielt aus. Die ID des erstellten Boards benötigen wir gleich, um darin Listen und Karten anzulegen. Der Aufruf erfolgt beispielsweise mit:<\/p>\n
CreateABoard \"Neues Board\", \"6640778a14eb58b09b29ae42\"<\/pre>\n
Die Organisations-ID haben wir mit der weiter oben vorgestellten Prozedur GetAMembersOrganizations <\/b>ermittelt.<\/p>\n
Ein Board löschen<\/h2>\n
Um ein Board zu löschen, rufen wir die URL mit \/boards\/{id} <\/b>auf und übergeben als Methode DELETE<\/b>.<\/p>\n
Gegebenenfalls kann die übergebene ID nicht gefunden werden, dann liefert intResult <\/b>den Wert 404<\/b>.<\/p>\n
Wir geben direkt die Antwort aus strResponse <\/b>aus (diese enthält dann kein JSON-Dokument, das wir mit GetJSONDOM <\/b>analysieren könnten).<\/p>\n
Beim Aufruf übergeben wir die ID des zu löschenden Boards, die wir zuvor mit der Prozedur GetBoardsAMemberBelongsTo <\/b>ermittelt haben (siehe Listing 10).<\/p>\n
Public Sub <\/span>DeleteABoard(strBoardID As String<\/span>)\r\n     ...\r\n     strURL = cStrUrl_Trello & \"\/boards\/\" & strBoardID\r\n     intResult = HTTPRequestTrello(strURL, \"DELETE\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             Debug.Print<\/span> \"Gelöscht.\"\r\n         Case <\/span>404\r\n             Debug.Print<\/span> intResult, strResponse\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 10: Löschen eines Boards<\/span><\/b><\/p>\n
DeleteABoard \"66f2cabd67c80e62af15611e\"<\/pre>\n
Neue Liste anlegen<\/h2>\n
Um eine Liste anzulegen, benötigen wir die ID des Boards und den Namen der Liste. Dann können wir die Prozedur aus Listing 11 nutzen.<\/p>\n
Public Sub <\/span>CreateAList(strListenname As String<\/span>, strBoardID As String<\/span>)\r\n     ...\r\n     strURL = cStrUrl_Trello & \"\/lists?name=\" & strListenname\r\n     If <\/span>Not<\/span> Len<\/span>(strBoardID) = 0 Then<\/span>\r\n         strURL = strURL & \"&idBoard=\" & strBoardID\r\n     End If<\/span>\r\n     intResult = HTTPRequestTrello(strURL, \"POST\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n             Debug.Print<\/span> \"Neue Liste: \" & objJSON.Item(\"id\"), objJSON.Item(\"name\")\r\n         Case <\/span>401\r\n             Debug.Print<\/span> intResult, strResponse\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, _\r\n                 GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 11: Anlegen einer neuen Liste<\/span><\/b><\/p>\n
Der Aufruf sieht so aus:<\/p>\n
CreateAList \"Neue Liste 1\", \"66f2d0120230abee3c8bb90a\"<\/pre>\n
Neue Karte anlegen<\/h2>\n
Der Code für das Anlegen einer neuen Karte unterscheidet sich auch nicht sonderlich von dem zum Anlegen einer neuen Liste oder eines neuen Boards.<\/p>\n
Hier übergeben wir lediglich den Namen der Karte und die ID der Liste, der wir die Karte hinzufügen wollen (siehe Listing 12).<\/p>\n
Public Sub <\/span>CreateACard(strKartenname As String<\/span>, strListID As String<\/span>)\r\n     ...\r\n     strURL = cStrUrl_Trello & \"\/cards?name=\" & strKartenname\r\n     If <\/span>Not<\/span> Len<\/span>(strListID) = 0 Then<\/span>\r\n         strURL = strURL & \"&idList=\" & strListID\r\n     End If<\/span>\r\n     intResult = HTTPRequestTrello(strURL, \"POST\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n             Debug.Print<\/span> \"Neue Karte: \" & objJSON.Item(\"id\"), objJSON.Item(\"name\")\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, strResponse\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 12: Anlegen einer neuen Karte<\/span><\/b><\/p>\n
Für den Aufruf verwenden wir den folgenden Befehl, wobei wir die Zielliste zuvor mit der entsprechenden Funktion ermitteln:<\/p>\n
CreateACard \"Neue Karte\", \"66f2d08e80717169d6dfc1dc\"<\/pre>\n
Damit legen wir eine neue Karte in Trello an. <\/p>\n
Weitere Daten auf Karten eintragen<\/h2>\n
Normalerweise reicht es nicht aus, einfach nur eine Karte mit einem Titel anzulegen. Meist benötigt man zumindest noch eine Beschreibung und ein Fälligkeitsdatum. Um dies zu realisieren, erweitern wir die zuvor beschriebene Prozedur wie in Listing 13.<\/p>\n
Public Function <\/span>CreateACardWithDateAndDescription(strName As String<\/span>, _\r\n         Optional<\/span> strDescription As String<\/span>, _\r\n         Optional<\/span> datDue As Date<\/span>, Optional<\/span> strListID As String<\/span>) As String<\/span>\r\n     Dim <\/span>intResult As Integer<\/span>\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Dim <\/span>strDatDue As String<\/span>\r\n     Dim <\/span>objJSON As Object<\/span>\r\n     strURL = cStrUrl_Trello & \"\/cards?name=\" & strName\r\n     If <\/span>Not<\/span> Len<\/span>(strListID) = 0 Then<\/span>\r\n         strURL = strURL & \"&idList=\" & strListID\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> Len<\/span>(strDescription) = 0 Then<\/span>\r\n         strURL = strURL & \"&desc=\" & strDescription\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> datDue = 0 Then<\/span>\r\n         strDatDue = Format(datDue, \"yyyy-mm-dd\")\r\n         strURL = strURL & \"&due=\" & strDatDue\r\n     End If<\/span>\r\n     intResult = HTTPRequestTrello(strURL, \"POST\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             CreateACardWithDateAndDescription = objJSON.Item(\"id\")\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, strResponse\r\n     End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 13: Anlegen einer neuen Karte mit Datum und Beschreibung<\/span><\/b><\/p>\n
Hier fügen wir zwei Parameter für die Beschreibung  (strDescription<\/b>) und das Fälligkeitsdatum hinzu (datDue<\/b>). Der Unterschied zur vorherigen Version ist, dass wir die beiden zusätzlichen Parameter zunächst auf Vorhandensein prüfen.<\/p>\n
Hat der Parameter strDescription <\/b>eine Länge größer 0<\/b>, wird ein weiterer Parameter an die Zeichenkette aus strURL <\/b>angehängt.<\/p>\n
Das Gleiche gilt für datDue <\/b>– hier prüfen wir allerdings, ob der Parameter nicht den Wert 0 <\/b>enthält, was dem Standardwert entspricht und nur eintritt, wenn der Benutzer kein Datum übergeben hat.<\/p>\n
Wurde ein Datum übergeben, formatieren wir dieses noch in dem Format, das von der Rest-API erwartet wird, nämlich yyyy-mm-dd<\/b>.<\/p>\n
Dann schicken wir die Anfrage wie gewohnt an die Rest-API.<\/p>\n
Eine Prozedur für den Aufruf dieser Funktion sieht beispielsweise wie folgt aus:<\/p>\n
Public Sub <\/span>Test_CreateACardWithDateAndDescription()\r\n     Dim <\/span>strName As String<\/span>\r\n     Dim <\/span>strDescription As String<\/span>\r\n     Dim <\/span>datDue As Date<\/span>\r\n     Dim <\/span>strListID As String<\/span>\r\n     Dim <\/span>strCardID As String<\/span>\r\n     strName = \"Karte mit Beschreibung und Datum\"\r\n     strDescription = _\r\n         \"Dies ist die Beschreibung unserer Karte.\"\r\n     datDue = Date + 7\r\n     strListID = \"672a467a7a22b30d4d0f5fd2\"\r\n     strCardID = CreateACardWithDateAndDescription( _\r\n         strName, strDescription, datDue, strListID)\r\n     Debug.Print<\/span> \"Neue Karte: \" & strCardID\r\nEnd Sub<\/span><\/pre>\n
Sie gibt nach dem erfolgreichen Erstellen den Wert der ID der neuen Karte aus.<\/p>\n
Ändern einer Karte<\/h2>\n
Und letztlich wollen wir auch einmal die Eigenschaften einer bestehenden Karte ändern. Dazu nutzen wir die Funktion aus Listing 14.<\/p>\n
Public Function <\/span>ChangeACard(strCardID As String<\/span>, strName As String<\/span>, _\r\n         Optional<\/span> strDescription As String<\/span>, Optional<\/span> datDue As Date<\/span>) As Boolean<\/span>\r\n     Dim <\/span>intResult As Integer<\/span>\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Dim <\/span>strParameters As String<\/span>\r\n     Dim <\/span>strDatDue As String<\/span>\r\n     Dim <\/span>objJSON As Object<\/span>\r\n     strURL = cStrUrl_Trello & \"\/cards\/\" & strCardID\r\n     If <\/span>Not<\/span> Len<\/span>(strName) = 0 Then<\/span>\r\n         strParameters = strParameters & \"&name=\" & strName\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> Len<\/span>(strDescription) = 0 Then<\/span>\r\n         strParameters = strParameters & \"&desc=\" & strDescription\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> datDue = 0 Then<\/span>\r\n         strDatDue = Format(datDue, \"yyyy-mm-dd\")\r\n         strParameters = strParameters & \"&due=\" & strDatDue\r\n     End If<\/span>\r\n     If <\/span>Len<\/span>(strParameters) > 0 Then<\/span>\r\n         strURL = strURL & \"?\" & Mid<\/span>(strParameters, 2)\r\n     End If<\/span>\r\n     intResult = HTTPRequestTrello(strURL, \"PUT\", , strResponse)\r\n     Select Case intResult\r\n         Case <\/span>200\r\n             ChangeACard = True<\/span>\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             ChangeACard = objJSON.Item(\"id\")\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> intResult, strResponse\r\n     End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 14: Ändern einer neuen Karte<\/span><\/b><\/p>\n
Diese ist ähnlich aufgebaut wie die zum Erstellen einer Karte. Es gibt jedoch ein paar feine Unterschiede. Der erste ist, dass wir nicht die ID der Liste übergeben, sondern die ID der zu ändernden Karte. Diese übergeben wir in der URL auch nicht als Name-Wert-Paar, sondern hinter der Basis-URL und dem Element cards als weiteres Element zwischen zwei Schrägstrichen.<\/p>\n
Die übrigen Elemente hängen wir auch nicht einfach mit &<\/b>-Zeichen an diese URL an, denn der erste Parameter muss durch das Fragezeichen von der eigentlichen URL getrennt sein. Daher tragen wir die Parameter in der Variablen strParameters <\/b>zusammen und ersetzen dann das erste &<\/b> durch ?<\/b>.<\/p>\n
Die Funktion liefert keine ID zurück, denn wir legen ja kein neues Element an – stattdessen erhalten wir den Wert True <\/b>oder False <\/b>zurück, je nachdem, ob die Änderung erfolgreich war oder nicht.<\/p>\n
Zusammenfassung und Ausblick<\/h2>\n
Von den hier vorgestellten Beispielen lassen sich imgrunde alle Aktionen, die mit dem Anlegen, Ändern oder Löschen der verschiedenen Elemente in Trello ableiten.<\/p>\n
Dazu sucht man sich einfach den entsprechenden API-Befehl aus der Referenz heraus und passt die vorhandenen Prozeduren an.<\/p>\n","protected":false},"excerpt":{"rendered":"
Trello ist eines der bekanntesten Projektmanagement-Tools. Damit lassen sich Projekte, Aufgaben und ToDos im Kanban-Style verwalten. Die Basisfunktionen sind bereits mächtig und dabei aber nicht unübersichtlich und man kann über sogenannte PowerUps viele zusätzliche Funktionen integrieren. Nicht zu reden von den Automationen – viele sind interne Automationen, die innerhalb von Trello genutzt werden köknnen und natürlich gibt es auch einige Möglichkeiten, Trello und die enthaltenen Elemente über Werkzeuge wie Zapier oder Make von anderen Tools zu steuern und umgekehrt. Aber wir wären keine VB\/VBA-Entwickler, wenn wir nicht per Code auf die in Trello angelegten Boards, Karten und Eigenschaften zugreifen wollten, um diese zu lesen oder zu schreiben. Die Weboberflächen vieler noch so guter Tools bieten letztlich nicht immer alle nötigen Funktionen, die man aber abbilden kann, wenn das Tool eine Rest-API anbietet und man sich mit der Steuerung solcher APIs unter VB\/VBA auskennt. Dann können wir beispielsweise schnell die Projekte oder Aufgaben aus einer Excel- oder Access-Tabelle in Trello anlegen oder auch auf die in Trello enthaltenen Daten zugreifen, um diese mit den Daten in unserer Datenbankwendung abzugleichen. In diesem Artikel zeigen wir, wie dies gelingt.<\/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":[662024,66052024,44000012],"tags":[],"yst_prominent_words":[],"class_list":["post-55000444","post","type-post","status-publish","format-standard","hentry","category-662024","category-66052024","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