<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_01\/pic_1409_001.png\")
<\/p>\n
Bild 1: Tabelle in Notion<\/span><\/b><\/p>\n In weiteren Beiträgen haben wir uns angesehen, wie wir Daten aus Notion abfragen und neu anlegen können. Spannend wird es, wenn wir diese Techniken nutzen, um Daten aus anderen Anwendungen mit Notion zu synchronisieren. Im vorliegenden Beitrag wollen wir uns daher zuerst einmal ansehen, wie wir die Daten aus einer Access-Tabelle in eine Notion-Tabelle übertragen können. Dabei wollen wir die ID, unter welcher die Tabelle in Notion angelegt wurde, auslesen und in der Access-Tabelle speichern, damit wir wissen, welche Datensätze bereits nach Notion übertragen wurden. Gleichzeitig können wir Änderungen an diesen Datensätzen in der Access-Datenbank dann in die Notion-Tabelle übertragen.<\/b><\/p>\n Als Beispiel verwenden wir die Tabelle Artikeldatenbank<\/b>, die wir wie in Bild 1 angelegt haben. Wie Sie diese Tabelle anlegen, erfahren Sie im Beitrag Produktivität mit Notion steigern <\/b>(www.access-im-unternehmen.de\/1402<\/b>). Hier finden Sie auch wichtige Informationen, auf denen der vorliegende Beitrag aufbaut.<\/p>\n Bild 1: Tabelle in Notion<\/span><\/b><\/p>\n In der Access-Datenbank legen wir zwei Tabellen an. Die erste Tabelle hat den Namen tblArtikel<\/b> und enthält die Felder aus Bild 2. Das Primärschlüsselfeld ArtikelID<\/b> dient der eindeutigen Identifizierung der Datensätze in der Access-Tabelle.<\/p>\n Bild 2: Tabelle mit Artikeldaten in Access<\/span><\/b><\/p>\n Die Felder Artikelname <\/b>und Veroeffentlichungsdatum <\/b>sollen so in die Notion-Datenbank übernommen werden. Das Feld StatusID <\/b>ist ein Nachschlagefeld zur Auswahl von Datensätzen aus einer weiteren Tabelle namens tblStatus<\/b>. <\/p>\n Diese stellt die Daten aus Bild 3 zur Auswahl im Nachschlagefeld bereit.<\/p>\n Bild 3: Tabelle mit den verschiedenen Status-Werten<\/span><\/b><\/p>\n Damit wir direkt auf die Daten der Felder Artikelname<\/b>, Veroeffentlichungsdatum <\/b>und Status <\/b>der beiden Tabellen zugreifen können, erstellen wir noch eine Abfrage namens qryArtikelMitStatus<\/b>. Diese enthält die beiden Tabellen tblArtikel <\/b>und tblStatus <\/b>als Datenquelle und zeigt die Felder ArtikelID<\/b>, Artikelname<\/b>, Veroeffentlichungsdatum<\/b>, Status <\/b>und NotionID <\/b>an (siehe Bild 4).<\/p>\n Bild 4: Abfrage mit den Feldern aus den Tabellen tblArtikel und tblStatus<\/span><\/b><\/p>\n Die Daten dieser Abfrage, die wir in der nachfolgend beschriebenen Prozedur nach Notion exportieren wollen, sehen in der Datenblattansicht der Abfrage wie in Bild 5 aus.<\/p>\n Bild 5: Ergebnis der Abfrage mit den Feldern aus den Tabellen tblArtikel und tblStatus<\/span><\/b><\/p>\n Damit steigen wir gleich in die Prozedur ein, welche die Daten aus den Tabellen unserer Access-Datenbank in die Notion-Datenbank exportieren soll.<\/p>\n Zur Erinnerung nochmal die Strukturierung in Notion, wo ein Benutzer üblicherweise einen eigenen Workspace verwendet, der eine oder mehrere Datenbanken enthält. Eine Datenbank ist dabei aber eher mit einer Access-Tabelle gleichzusetzen – sie enthält verschiedene Eigenschaften, sogenannte Properties, mit denen die enthaltenen Elemente beschrieben werden. Diese nennen wir Pages. Eine Page in einer Notion-Datenbank entspricht also in etwa einem Datensatz in einer Access-Tabelle.<\/p>\n Bevor wir uns die Prozedur im Detail ansehen, wollen wir noch kurz skizzieren, was darin passieren soll: Wir wollen dort zunächst alle Datensätze der Access-Abfrage qryArtikelMitStatus <\/b>ermitteln, die im Feld NotionID <\/b>den Wert NULL <\/b>enthalten. Der Sinn dahinter ist, dass wir nach dem Hinzufügen der Daten eines Datensatzes der Access-Tabelle in die Notion-Datenbank die ID des in Notion angelegten Page<\/b>-Elements ermitteln und diese für den zugrundeliegenden Datensatz der Tabelle tblArtikel <\/b>in das Feld NotionID <\/b>einfügen wollen. So können wir später immer erkennen, ob dieser Datensatz bereits nach Notion exportiert wurde. Und wenn wir die Daten gegebenenfalls einmal in der Access-Datenbank aktualisieren, können wir diese aktualisierten Datensätze in einer weiteren Prozedur im entsprechenden Datensatz der Notion-Datenbank aktualisieren.<\/p>\n Diese Prozedur beginnt in Listing 1. Hier deklarieren wir zunächst die benötigten Variablen, zum Beispiel eine namens db <\/b>zum Speichern eines Verweises auf das aktuelle Database<\/b>-Objekt und eine namens rst <\/b>für das Recordset, in dem wir die zu übertragenden Datensätze durchlaufen wollen. Außerdem benötigen wir ein Dictionary, in das wir die Antwort der Notion-API einlesen können, um das Ergebnis auszuwerten. Außerdem benötigen wir diverse String<\/b>-Variablen.<\/p>\n Listing 1: Artikel nach Notion übertragen, Teil 1<\/span><\/b><\/p>\n [<\/p>\n Nach dem Initialisieren der Variablen db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt referenzieren wir mit der Variablen rst <\/b>alle Datensätze der Abfrage qryArtikelMitStatus<\/b>, bei denen das Feld NotionID <\/b>noch den Wert Null <\/b>enthält. Das zeigt uns, dass die entsprechenden Datensätze noch nicht nach Notion exportiert wurden.<\/p>\n Nachdem wir die ID der Notion-Datenbank, der wir die Artikeldatensätze hinzufügen wollen, aus der Tabelle tblDatabases<\/b> ermittelt haben, kann es losgehen – wie wir diese ermitteln, lesen Sie im Beitrag Mit Access auf Notion zugreifen <\/b>(www.access-im-unternehmen.de\/1401<\/b>). Also beginnen wir mit dem Durchlaufen der Datensätze des Recordsets.<\/p>\n Innerhalb der dazu definierten Do While<\/b>-Schleife stellen wir ein JSON-Dokument zusammen, das alle Informationen über das anzulegende Page<\/b>-Element enthält und das wir anschließend als Parameter der GetJSON<\/b>-Funktion an die Notion-API übergeben (siehe Listing 2). Die GetJSON<\/b>-Funktion beschreiben wir im Beitrag JSON-Daten auslesen <\/b>(www.access-im-unternehmen.de\/1403<\/b>).<\/p>\n Listing 2: Artikel nach Notion übertragen, Teil 2<\/span><\/b><\/p>\n Sie verwendet diesmal die in der Konstanten cStrCreatePage <\/b>enthaltene URL für den Aufruf:<\/p>\n Der beispielhafte Code für einen JSON-Datensatz, den wir hier zusammenstellen, ist in Listing 3 zu finden.<\/p>\n Listing 3: JSON-Code, den wir zum Anlegen eines Datensatzes an Notion schicken<\/span><\/b><\/p>\n Nachdem wir diesen zusammengestellt und per GetJSON<\/b>-Aufruf an Notion gesendet haben, ermitteln wir noch die ID der neuen Page.<\/p>\n Dazu lesen wir das in der Variablen strResponse <\/b>gespeicherte Ergebnis der Anfrage per API in die Dictionary<\/b>-Variable objJSON <\/b>ein. Dazu nutzen wir die Funktion ParseJson<\/b>, die wir ebenfalls im oben genannten Beitrag beschreiben.<\/p>\n Die als JSON-Dokument gelieferte Antwort sieht stark gekürzt wie folgt aus:<\/p>\n Hier lesen wir den Wert des Feldes id <\/b>aus und speichern das Ergebnis in der Variablen strPageID<\/b>. Die so gewonnene Notion-ID des Datensatzes schreiben wir anschließend in das Feld NotionID <\/b>des entsprechenden Datensatzes der Access-Tabelle tblArtikel<\/b>.<\/p>\n Auf die gleiche Art durchlaufen wir alle Elemente der zu übertragenden Datensätze und legen so den Inhalt der Access-Tabelle in der Notion-Datenbank an. Das Ergebnis sieht schließlich wie in Bild 6 aus.<\/p>\n Bild 6: Die neuen Artikel in der Notion-Datenbank<\/span><\/b><\/p>\n Hier stellt sich die entscheidende Frage: Wie komme ich überhaupt an die Struktur des JSON-Codes, der für das Anlegen eines Elements benötigt wird? Dazu fragen wir die Elemente der Notion-Datenbank beziehungsweise, wie wir unter Access sagen würden, Tabelle ab.<\/p>\n Die dazu notwendige Prozedur heißt PagesAbfragen <\/b>und sie schreibt schlicht den JSON-Inhalt der Seiten der mit dem Parameter übergebenen Datenbank in die Zwischenablage (siehe Listing 4 ). Der Aufruf lautet für die in diesem Beitrag verwendete Beispieldatenbank wie folgt:<\/p>\n Listing 4: Prozedur, welche den Inhalt einer Datenbank beziehungsweise Tabelle abfragt und als JSON-Code in die Zwischenablage schreibt.<\/span><\/b><\/p>\n Die Prozedur verwendet die API-Funktion https:\/\/api.notion.com\/v1\/databases\/{database_id}\/query<\/b>, für die wir {database_id} <\/b>durch die aus der Tabelle tblDatabases <\/b>ermittelte ID ersetzen. Diese ID <\/b>holt die Prozedur zuvor per DLookup <\/b>für den als Parameter angegebenen Datenbanknamen.<\/p>\n Die URL ist in der Konstanten cStrQueryDatabase <\/b>gespeichert:<\/p>\n Der folgende Aufruf der Prozedur GetJSON <\/b>spricht die API von Notion an und liefert die Elemente der angegebenen Datenbank-ID mit dem Parameter strResponse <\/b>zurück.<\/p>\n Das Ergebnis können wir aus der Zwischenablage in einen Editor kopieren, der JSON-Dokumente korrekt formatiert. In Visual Studio sieht das beispielsweise wie in Bild 7 aus. Hier sehen wir eine Liste von Elementen unterhalb des Elements results<\/b>. Während dieses Element alle Attribute des in der Datenbank gespeicherten Datensatzes enthält, brauchen wir diese zum Anlegen eines neuen Elements nicht vollständig anzugeben. So übergeben wir beispielsweise nicht die id <\/b>des neuen Elements, da diese von Notion vergeben wird. Wie oben beschreiben, lesen wir diese allerdings anschließend aus. Wie Sie den JSON-Code zum Anlegen eines neuen Elements zusammenstellen, hängt also davon ab, welche Informationen Sie übergeben wollen. Wir haben nur so wenige Informationen wie nötig übergeben. Wichtig ist noch, dass zum Beispiel für den Status genau einer der bereits vorhandenen Statuswerte übergeben wird.<\/p>\n Bild 7: Inhalt einer Datenbank im JSON-Format<\/span><\/b><\/p>\n Wenn wir davon ausgehen, dass die Daten immer nur von einer Richtung in die andere aktualisiert werden sollen, also in diesem Fall von der Access-Datenbank nach Notion, dann können wir für solche Datensätze, die bereits übertragen wurden und mit der entsprechenden Notion-ID gekennzeichnet sind, eine ähnliche Prozedur erstellen. Diese würde alle Einträge durchlaufen, die einen Wert im Feld NotionID <\/b>enthalten. Alternativ könnte man in der bereits vorhandenen Prozedur ArtikelInNotionAnlegen <\/b>eine Prüfung einbauen, die abhängig davon, ob das Feld NotionID <\/b>einen Wert enthält, entweder einen neuen Datensatz in Notion anlegt oder den vorhandenen anpasst.<\/p>\n Da aber der komplette Ablauf anders ist und auch eine andere API-Funktion aufgerufen werden muss, behandeln wir das Aktualisieren in einer eigenen Prozedur namens ArtikelInNotionAktualisieren<\/b> (siehe Listing 5).<\/p>\n Listing 5: Prozedur, welche Eigenschaften aller schon in Notion gespeicherten Datensätze aktualisiert<\/span><\/b><\/p>\n Diese ist grundsätzlich wie die zuvor beschriebene Prozedur ArtikelInNotionAnlegen <\/b>aufgebaut. Allerdings durchlaufen wir hier alle Datensätze der Abfrage qryArtikelMitStatus<\/b>, deren Feld NotionID <\/b>bereits gefüllt ist. Dabei stellen wir eine ähnliche JSON-Datei wie beim Anlegen zusammen, jedoch benötigen wir nicht mehr die Angabe der übergeordneten Datenbank – wir identifizieren den zu ändernden Datensatz allein über seine Notion-ID.<\/p>\n Das heißt, die JSON-Datei enthält lediglich die zu ändernden Properties. Da wir nicht prüfen, ob sich überhaupt ein Feld des aktuellen Datensatzes geändert hat und wenn ja, welches, übergeben wir einfach alle Properties erneut.<\/p>\n Als API-Befehl verwenden wir diesmal den in der folgenden Konstanten gespeicherten:<\/p>\n Hier ersetzen wir {page_id} <\/b>durch den Wert aus dem Feld NotionID<\/b> des Datensatzes der Tabelle. Dann rufen wir die Funktion GetJSON <\/b>mit der resultierenden URL auf und verwenden diesmal nicht den Parameter POST<\/b>, sondern PATCH<\/b>.<\/p>\n Im Gegensatz zur Prozedur zum Eintragen neuer Datensätze brauchen wir hier nicht die Notion-ID der bearbeiteten Elemente abzufragen, daher geben wir einfach per MsgBox <\/b>das jeweilige Ergebnis aus – das allerdings auch nur noch zu Debugging-Zwecken.<\/p>\n Die Herausforderung ist, herauszufinden, wie der zu übergebene JSON-Ausdruck aussehen muss. Dazu nutzen wir die oben vorgestellte Prozedur PagesAbfragen<\/b>, mit der wir die bereits in der Notion-Datenbank enthaltenen Einträge abfragen.<\/p>\n<\/p>\nDatenquelle in der Access-Datenbank<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_01\/pic_1409_002.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_01\/pic_1409_003.png\")
<\/p>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2023_01\/pic_1409_005.png\")
<\/p>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2023_01\/pic_1409_004.png\")
<\/p>\nProzedur zum Übertragen der Daten nach Notion<\/h2>\n
Die Prozedur ArtikelInNotionAnlegen<\/h2>\n
Public Sub <\/span>ArtikelInNotionAnlegen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>objJSON As <\/span>Dictionary\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strDatabaseID As String<\/span>\r\n Dim <\/span>strBody As String<\/span>\r\n Dim <\/span>strPageID As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM qryArtikelMitStatus WHERE NotionID IS NULL\", dbOpenDynaset)\r\n strDatabaseID = DLookup(\"DatabaseID\", \"tblDatabases\", \"DatabaseTitle = ''Artikeldatenbank''\")\r\n Do While<\/span> Not<\/span> rst.EOF\r\n strBody = \"{\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"object\"\": \"\"page\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"parent\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"type\"\": \"\"database_id\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"database_id\"\": \"\"\" & strDatabaseID & \"\"\"\" & vbCrLf<\/span>\r\n strBody = strBody & \" },\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"properties\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"Artikelname\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"title\"\": [\" & vbCrLf<\/span>\r\n strBody = strBody & \" {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"type\"\": \"\"text\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"text\"\": { \"\"content\"\": \"\"\" & rst!Artikelname & \"\"\" }\" & vbCrLf<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n strBody = strBody & \" ]\" & vbCrLf<\/span>\r\n strBody = strBody & \" },\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"Status\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"id\"\": \"\"adPI\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"type\"\": \"\"select\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"select\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"name\"\": \"\"\" & rst!status & \"\"\"\" & vbCrLf<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n ...<\/pre>\n...\r\n If <\/span>IsNull(rst!Veroeffentlichungsdatum) Then<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n Else<\/span>\r\n strBody = strBody & \" },\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"Veröffentlichungsdatum\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"id\"\": \"\"Eqsc\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"type\"\": \"\"date\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"date\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"start\"\": \"\"\" & Format(rst!Veroeffentlichungsdatum, \"yyyy-mm-dd\") & \"\"\",\" _\r\n & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"end\"\": null,\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"time_zone\"\": null\" & vbCrLf<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n End If<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n strBody = strBody & \"}\" & vbCrLf<\/span>\r\n Inzwischenablage strBody\r\n If <\/span>GetJSON(cStrCreatePage, \"POST\", strResponse, strBody) = True<\/span> Then<\/span>\r\n Set<\/span> objJSON = ParseJson(strResponse)\r\n strPageID = objJSON.Item(\"id\")\r\n rst.Edit\r\n rst!NotionID = strPageID\r\n rst.Update\r\n Else<\/span>\r\n Debug.Print<\/span> strResponse\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nConst cStrCreatePage As String<\/span> = \"https:\/\/api.notion.com\/v1\/pages\"<\/pre>\n{\r\n \"object\": \"page\",\r\n \"parent\": {\r\n \"type\": \"database_id\",\r\n \"database_id\": \"d303bedf-ca40-42ad-8474-86f41e1b5bc6\"\r\n },\r\n \"properties\": {\r\n \"Artikelname\": {\r\n \"title\": [\r\n {\r\n \"type\": \"text\",\r\n \"text\": { \"content\": \"Prüfen, ob Datenbank geöffnet ist\" }\r\n }\r\n ]\r\n },\r\n \"Status\": {\r\n \"id\": \"adPI\",\r\n \"type\": \"select\",\r\n \"select\": {\r\n \"name\": \"Veröffentlicht\"\r\n }\r\n },\r\n \"Veröffentlichungsdatum\": {\r\n \"id\": \"Eqsc\",\r\n \"type\": \"date\",\r\n \"date\": {\r\n \"start\": \"2022-09-01\",\r\n \"end\": null,\r\n \"time_zone\": null\r\n }\r\n }\r\n }\r\n}<\/pre>\n{\r\n \"object\": \"page\",\r\n \"id\": \"cc2f3bdd-3322-4713-9d7b-d573431f1ab6\",\r\n ...\r\n}<\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2023_01\/pic_1409_006.png\")
<\/p>\nJSON-Code zum Anlegen von Elementen ermitteln<\/h2>\n
Public Sub <\/span>PagesAbfragen(strDatabaseTitle As String<\/span>)\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strDatabaseID As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strQuerydatabase As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n strDatabaseID = DLookup(\"DatabaseID\", \"tblDatabases\", \"DatabaseTitle = ''\" & strDatabaseTitle & \"''\")\r\n strQuerydatabase = Replace<\/span>(cStrQueryDatabase, \"{database_id}\", strDatabaseID)\r\n If <\/span>GetJSON(strQuerydatabase, \"POST\", strResponse) = True<\/span> Then<\/span>\r\n Inzwischenablage strResponse\r\n Else<\/span>\r\n Debug.Print<\/span> strResponse\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPagesAbfragen \"Artikeldatenbank\"<\/pre>\n
Const cStrQueryDatabase As String<\/span> = \"https:\/\/api.notion.com\/v1\/databases\/{database_id}\/query\"<\/pre>\n![\"Inhalt](\"..\/fileadmin\/_temp_\/2023_01\/pic_1409_007.png\")
<\/p>\nAktualisieren vorhandener Einträge<\/h2>\n
Public Sub <\/span>ArtikelInNotionAktualisieren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>objJSON As <\/span>Dictionary\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strDatabaseID As String<\/span>\r\n Dim <\/span>strBody As String<\/span>\r\n Dim <\/span>strUpdatePage As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM qryArtikelMitStatus WHERE NOT NotionID IS NULL\", dbOpenDynaset)\r\n strDatabaseID = DLookup(\"DatabaseID\", \"tblDatabases\", \"DatabaseTitle = ''Artikeldatenbank''\")\r\n Do While<\/span> Not<\/span> rst.EOF\r\n strBody = \"{\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"properties\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"Artikelname\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"title\"\": [\" & vbCrLf<\/span>\r\n strBody = strBody & \" {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"type\"\": \"\"text\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"text\"\": { \"\"content\"\": \"\"\" & rst!Artikelname & \"\"\" }\" & vbCrLf<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n strBody = strBody & \" ]\" & vbCrLf<\/span>\r\n strBody = strBody & \" },\" & vbCrLf<\/span>\r\n ...\r\n strUpdatePage = Replace<\/span>(cStrUpdatePage, \"{page_id}\", rst!NotionID)\r\n If <\/span>GetJSON(strUpdatePage, \"PATCH\", strResponse, strBody) = True<\/span> Then<\/span>\r\n MsgBox<\/span> \"Artikel ''\" & rst!Artikelname & \"'' erfolgreich aktualisiert.\"\r\n Else<\/span>\r\n MsgBox<\/span> \"Artikel ''\" & rst!Artikelname & \"'' konnte nicht aktualisiert werden.\"\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nConst cStrUpdatePage As String<\/span> = \"https:\/\/api.notion.com\/ v1\/pages\/{page_id}\"<\/pre>\nHerausfinden, wie der JSON-Ausdruck aussehen muss<\/h2>\n