Zugriff auf lexoffice per REST-API und VBA

2/2023, 2023, Lösungen

lexoffice ist ein Online-Buchhaltungsdienst, der es Unternehmen ermöglicht, Rechnungen, Bestellungen und Bankkonten zu verwalten und Berichte zu erstellen. Der Service bietet ein einfaches Dashboard, mit dem Benutzer Geschäftsinformationen leicht auffinden und mit wenigen Klicks auswerten können. Rechnungen lassen sich online oder über die mobile App erstellen, Umsätze auf Bank- oder Paypalkonten liest lexoffice automatisch ein und es ermöglicht die Zuordnung von Ein- und Ausgangsrechnungen zu den Umsätzen. Aber das Beste ist: lexoffice bietet eine REST-API-Schnittstelle, die wir von einer Access-Datenbank aus per VBA ansteuern können. Grund genug, diese Schnittstelle einmal genauer anzusehen!

Von Access zu lexoffice

Die besten Beiträge schreibt das Leben, und so ist auch für die Entstehung dieses Beitrags ein Schritt des Autors für das aktuelle Thema verantwortlich. Die Buchhaltung soll umgezogen werden, um den aktuellen Randparametern gerecht zu werden – zum Beispiel den Grundsätzen ordnungsgemäßer Führung und Aufbewahrung von Büchern, Aufzeichnungen und Unterlagen in elektronischer Form sowie zum Datenzugriff (GoBD). Als Werkzeug für diese Aufgaben haben wir lexoffice ausgewählt.

Damit entstehen einige Aufgaben:

  • Einige offene Rechnungen von 2022, die erst in 2023 beglichen wurden, sollen noch aufgenommen werden.
  • Diese Rechnungen müssen als PDF importiert werden und wir müssen diesen noch Daten zum Rechnungsempfänger und einige weitere Daten hinzufügen.
  • Um die Kundendaten nicht manuell eintragen zu müssen, wollen wir die relevanten Datensätze mit der API aus der Datenbank nach lexoffice übertragen.
  • Schließlich sollen neue Bestellungen direkt komplett mit lexoffice verwaltet werden. Diese kommen zum Teil aus dem Shopsystem, wozu es eine Schnittstelle gibt (die hier nicht Thema sein wird) und teilweise aus der Access-Bestellverwaltung. Bei letzteren handelt es sich um Rechnungen für die Verlängerung von Abonnements.

Vorbereitungen für den Zugriff auf die API von lexoffice

Wie bei den meisten API, auf die wir von außerhalb zugreifen wollen, benötigen wir auch hier eine Möglichkeit zur Authentifizierung.

Dazu legen wir in lexoffice zunächst einen persönlichen Schlüssel an. Um das zu erledigen, rufen wir nach dem Einloggen in unseren Account bei lexware den folgenden Link auf:

https://app.lexoffice.de/addons/public-api

Damit landen wir auf einer Seite, wo wir per Mausklick einen passenden Schlüssel erstellen können (siehe Bild 1). Anschließend stimmen wir den Nutzungsbedingungen zu und erstellen den Schlüssel.

Anfordern eines persönlichen Schlüssels für die REST-Api

Bild 1: Anfordern eines persönlichen Schlüssels für die REST-Api

Im nächsten Schritt zeigt lexoffice den Schlüssel bereits an und bietet die Möglichkeit, diesen per Schaltfläche in die Zwischenablage zu kopieren (siehe Bild 2).

Kopieren des Schlüssels in die Zwischenablage

Bild 2: Kopieren des Schlüssels in die Zwischenablage

Um diesen dauerhaft zu sichern, legen wir in einem neuen VBA-Modul eine Konstante mit diesem Schlüssel an:

Public Const cstrAPIKey As String = "xxxxxxxxxxx-xxxxxxxx-xxxx"

Anschließend schließen wir den Dialog.

Datenbank vorbereiten

Für die nachfolgend vorgestellten VBA-Routinen benötigen wir im VBA-Projekt zusätzliche Verweise. Diese legen wir über den Verweise-Dialog an, den wir nach dem Aktivieren des VBA-Editors mit Extras|Verweise öffnen (siehe Bild 3).

Verweise im VBA-Projekt

Bild 3: Verweise im VBA-Projekt

Wir benötigen die folgenden zusätzlichen Verweise:

  • Microsoft XML, v6.0
  • Microsoft Scripting Runtime

Basisfunktion zum Senden von Anfragen an lexoffice

Wir verwenden eine Basisfunktion für den Zugriff auf die REST-API von lexoffice. Diese erwartet die folgenden Parameter:

  • strURL: URL für den Zugriff auf die REST-API. Beginnt immer mit https://api.lexoffice.io/v1/ und mit der Bezeichnung der abzufragenden/zu bearbeitenden Elemente, zum Beispiel contacts oder invoices. Anschließend folgen weitere Parameter wie beispielsweise die Angabe von Filterkriterien beim Abfragen von Elementen.
  • strMethod: Methode, die angibt, ob Daten beispielsweise gelesen (GET) oder geschrieben werden sollen (POST).
  • strRequest: Falls erforderlich, können mit diesem Parameter zusätzliche Informationen im JSON-Format übergeben werden. Enthält beispielsweise die Kundendaten, wenn ein neuer Kontakt angelegt werden soll.
  • strResponse: Liefert die Antwort im JSON-Format, also beispielsweise Daten über einen neu angelegten Kontakt oder abgefragte Kontaktdaten.

Die Funktion Request aus Listing 1 erstellt ein neues Objekt des Typs XMLHTTP60, mit dem wir auf die REST-API zugreifen. Dabei rufen wir als Erstes die Open-Methode auf, der wir die Werte der Parameter strMethod und strURL übergeben sowie für den dritten Parameter den Wert False. Damit geben wir an, dass der Aufruf asynchron erfolgen soll. Die folgenden Anweisungen stellen die Header für den Aufruf ein, unter anderem das Format für die hin- und herzuschickenden Daten (JSON) sowie für die Autorisierung für den Zugriff auf die Daten unseres Kontos bei lexoffice. Hier übergeben wir einen Ausdruck, der aus dem Text Bearer und dem zuvor ermittelten API-Schlüssel besteht. Die send-Methode schickt die Anfrage schließlich an die REST-API. Sie erhält noch die in strRequest angegebenen zusätzlichen Daten für die Anfrage.

Public Function Request(strRequest As String, strURL As String, strMethod As String, strResponse As String) As Boolean
     Dim objXMLHTTP As MSXML2.XMLHTTP60
     Set objXMLHTTP = New MSXML2.XMLHTTP60
     With objXMLHTTP
         .Open strMethod, strURL, False
         .setRequestHeader "Content-Type", "application/json"
         .setRequestHeader "Accept", "application/json"
         .setRequestHeader "Authorization", "Bearer " + cstrAPIKey
         .send strRequest
         Select Case .status
             Case 200
                 Request = True
                 strResponse = .responseText
             Case Else
                 MsgBox "Fehler beim Request:" & vbCrLf & .statusText & vbCrLf & .responseText
         End Select
     End With
End Function

Listing 1: Basisfunktion für den Zugriff auf die REST-API von lexware

Liefert die Anfrage mit der Eigenschaft status den Wert 200 zurück, war die Anfrage erfolgreich. Dann erhält die Request-Funktion als Rückgabewert den Wert True und wir füllen den Parameter strResponse mit der in der Eigenschaft responseText enthaltenen JSON-Antwort.

Anderenfalls gibt die Funktion die Fehlernummer und den Statustext in einem Meldungsfenster aus.

Kundendaten abfragen

Als Fingerübung fragen wir als Erstes alle Kundendaten ab. Dazu verwenden wir einen Aufruf der Funktion Request mit der folgenden URL:

https://api.lexoffice.io/v1/contacts

Nach dem Aufruf der Funktion Request geben wir den Inhalt von strResponse im Direktbereich des VBA-Editors aus und speichern das Ergebnis einer Funktion namens GetJSONDOM mit der Hilfsfunktion Zwischenablage aus dem Modul mdlZwischenablage in der Zwischenablage:

Public Sub FilteringContacts_All()
     Dim strRequest As String
     Dim strURL As String
     Dim strResponse As String
     strURL = "https://api.lexoffice.io/v1/contacts"
     If Request(strURL, "GET", strRequest, _
             strResponse) = True Then
         Debug.Print strResponse
         InZwischenablage GetJSONDOM(strResponse, _
             True, True)
     End If
End Sub

Mit der Response allein können wir nicht viel anfangen. Diese sieht in gekürzter Form wie folgt aus:

{"content":[{"id":"3a856a88-ee3a-421a-9850-1fce2d01c8f0","organizationId":"dd8bf92c-43e5-41bf-a57a-ba7b33eb980f","version":4,"roles":{"customer":{"number":10001}},"person":{"salutation":"Herr","firstName":"André","lastName":"Minhorst"},"addresses":{"billing":[{"supplement":"","street":"Borkhofer Str. 17","zip":"47137","city":"Duisburg","countryCode":"DE"}],"shippin
g":[{"supplement":"","street":"Borkhofer Str., 17","zip":"47137","city":"Duisburg","countryCode":"DE"}]},"emailAddresses":{"other":["andre@minhorst.com"]},"phoneNumbers":{"other":["98989898"]},"note":"24284","archived":false},...}

Die Funktion GetJSONDOM haben wir im Rahmen des Beitrags JSON-Daten auslesen (www.access-im-unternehmen.de/1403) entwickelt. Sie gibt die im JSON-Dokument enthaltenen Daten wie in Listing 2 aus.

objJson.Item("content").Item(3).Item("id"): 3a856a88-ee3a-421a-9850-1fce2d01c8f0
objJson.Item("content").Item(3).Item("organizationId"): dd8bf92c-43e5-41bf-a57a-ba7b33eb980f
objJson.Item("content").Item(3).Item("version"): 4
objJson.Item("content").Item(3).Item("roles").Item("customer").Item("number"): 10001
objJson.Item("content").Item(3).Item("person").Item("salutation"): Herr
objJson.Item("content").Item(3).Item("person").Item("firstName"): André
objJson.Item("content").Item(3).Item("person").Item("lastName"): Minhorst
objJson.Item("content").Item(3).Item("addresses").Item("billing").Item(1).Item("supplement"): 
objJson.Item("content").Item(3).Item("addresses").Item("billing").Item(1).Item("street"): Borkhofer Str. 17
objJson.Item("content").Item(3).Item("addresses").Item("billing").Item(1).Item("zip"): 47137
objJson.Item("content").Item(3).Item("addresses").Item("billing").Item(1).Item("city"): Duisburg
objJson.Item("content").Item(3).Item("addresses").Item("billing").Item(1).Item("countryCode"): DE
objJson.Item("content").Item(3).Item("addresses").Item("shipping").Item(1).Item("supplement"): 
objJson.Item("content").Item(3).Item("addresses").Item("shipping").Item(1).Item("street"): Borkhofer Str., 17
objJson.Item("content").Item(3).Item("addresses").Item("shipping").Item(1).Item("zip"): 47137
objJson.Item("content").Item(3).Item("addresses").Item("shipping").Item(1).Item("city"): Duisburg
objJson.Item("content").Item(3).Item("addresses").Item("shipping").Item(1).Item("countryCode"): DE
objJson.Item("content").Item(3).Item("emailAddresses").Item("other").Item(1): andre@minhorst.com
objJson.Item("content").Item(3).Item("phoneNumbers").Item("other").Item(1): 98989898
objJson.Item("content").Item(3).Item("note"): 24284
objJson.Item("content").Item(3).Item("archived"): Falsch

Listing 2: Ausgabe für den Zugriff auf die Daten einer JSON-Antwort

Diese Ausgabe dient als Vorlage für das systematische Durchlaufen der Daten, die zu diesem Zweck in ein Objektmodell bestehend aus Collections und Dictionaries überführt wurde – mehr dazu im oben genannten Beitrag. Um beispielsweise die E-Mail-Adressen aller Kunden im Direktbereich auszugeben, benötigen wir damit nur noch die folgenden Zeilen zur Prozedur FilteringContacts_All hinzuzufügen – und zwar als letzte Zeile innerhalb der If…Then-Bedingung:

AusgabeKontakte strResponse

Die Ausgabe der Nachnamen aller Personen würde dann wie folgt geschehen:

Public Sub AusgabeKontakte(strJSON As String)
     Dim objJSON As Object
     Dim objContact As Object
     Set objJSON = ParseJson(strJSON)
     For Each objContact In objJSON.Item("content")
         On Error Resume Next
         Debug.Print objContact.Item("person").Item("lastName")
         On Error GoTo 0
     Next objContact
End Sub

Die Prozedur speichert das Objektmodell des JSON-Dokuments als Struktur aus Dictionaries und Collections, auf die wir über die entsprechenden Auflistungen zugreifen können. Jedes content-Element enthält einen der Kontakte. Diese durchlaufen wir in einer For Each-Schleife und referenzieren das content-Element dabei mit der Variablen objContact.

Über dieses können wir dann beispielsweise mit dem Ausdruck objContact.Item(“person”).Item(“lastName”) auf den Nachnamen der Person zugreifen. Da nicht sichergestellt ist, dass diese Eigenschaft für jeden Kontakt existiert, haben wir für den Zugriff die eingebaute Fehlerbehandlung deaktiviert. Damit können wir nun alle Kontakte und die vorhandenen Eigenschaften durchlaufen und diese beispielsweise in einer Tabelle der Datenbank speichern.

Einen bestimmten Kontakt auslesen

Wenn Sie nicht alle Kontakte auslesen wollen, sondern nur einen bestimmten, können Sie verschiedene Kriterien verwenden. Eines davon ist die E-Mail-Adresse. In der Prozedur FilteringContacts_ByEMail, die Sie im Modul mdlLexOffice finden, fügen wir dazu an die URL noch einen Filterparameter an:

strURL = "https://api.lexoffice.io/v1/contacts?email=andre@minhorst.com"

Dies liefert alle Kunden mit der E-Mail-Adresse andre@minhorst.com. Wir können die folgenden Vergleichsfelder nutzen:

  • email: Filtert nach der E-Mail-Adresse.
  • name: Filtert nach dem Namen.
  • number: Filtert nach der Kundennummer, die beispielsweise in der Eigenschaft roles/customer/number enthalten ist.
  • customer: Filtert nach allen Kontakten, welche die Rolle customer haben.
  • vendor: Filtert nach allen Kontakten, welche die Rolle vendor haben.

Die Dokumentation des passenden API-Befehls finden Sie unter folgender URL:

https://developers.lexoffice.io/docs/#contacts-endpoint-filtering-contacts

Wenn wir beispielsweise nach dem Namen filtern wollen und dieser Sonderzeichen enthält wie in André, dann müssen wir diesen zuvor enkodieren. Funktionen dazu stellen wir im Beitrag URLs kodieren per VBA (www.access-im-unternehmen.de/1423) vor.

Zur Verwendung der dortigen Funktion URLEncode_UTF8 benötigen wir noch einen Verweis auf die Bibliothek Microsoft ActiveX Data Objects 6.1 Library.

Die URL stellen wir dann wie folgt zusammen:

strURL = "https://api.lexoffice.io/v1/contacts?name=" & URLEncode_UTF8("André")

Kontakt nach der ID in lexoffice ermitteln

Wir können auch nach der ID eines Kontakts filtern, der in der Eigenschaft id gespeichert ist. Diesen übergeben wir ohne Feldname, also beispielsweise wie folgt:

strURL = "https://api.lexoffice.io/v1/contacts/xxxxxxxx-ee3a-421a-9850-1fce2d01c8f0"

Hier ist jedoch zu beachten, dass keine Liste von Kontakten zurückgeliefert wird, sondern nur das Kontakt-Objekt selbst. Wir würden also nicht wie zuvor auf den Kontakt zugreifen:

objJson.Item("content").Item(3).Item("person").Item("lastName")

Stattdessen greifen wir so darauf zu:

objJSON.Item("lastName")

Das JSON-Dokument ist in diesem Fall anders strukturiert, als wenn wir auf alle Kontakte zugreifen oder gefiltert nach der E-Mail-Adresse. Um die Daten aus dem JSON-Dokument auszulesen, kann man sich die Struktur für den Zugriff mit der Funktion GetJSONDOM ansehen.

Die Dokumentation des passenden API-Befehls finden Sie unter folgender URL:

https://developers.lexoffice.io/docs/#contacts-endpoint-retrieve-a-contact

Kundendaten aus der Datenbank nach lexoffice übertragen

Damit nähern wir uns der eigentlichen Aufgabe: Wir wollen die Kundendaten aus unserer Bestellverwaltung nach lexoffice übertragen. Dazu nutzen wir wieder die gleiche URL, diesmal allerdings mit der Methode POST. Außerdem müssen wir mit dem Parameter strRequest ein JSON-Dokument übergeben, welches die Daten des anzulegenden Kontakts enthält.

Hinzu kommt, dass wir eine Verbindung zwischen dem Kundendatensatz in unserer Rechnungsverwaltung und dem Kontakt in lexoffice herstellen wollen. lexoffice erlaubt leider keine Übermittlung der Kundennummer und erstellt eine eigene Kundennummer. Also bleibt als einzige Möglichkeit, eine Verbindung zwischen dem Kontakt in lexoffice und dem Kundendatensatz in der Datenbank herzustellen, das Auslesen der ID des Kontakts beim Anlegen und das Speichern dieser ID in der Kundentabelle. Dazu hinterlegen wir in der Kundentabelle ein Feld namens LexOfficeID. Nun gibt es verschiedene Möglichkeiten, einen Kontakt anzulegen – und zwar als Person oder als Firma. Wir haben dafür jeweils eine eigene Funktion entwickelt, damit die Funktionen nicht zu aufgebläht werden.

Die erste Funktion heißt AddOrUpdateContact_Person (erster Teil in Listing 3). Sie erwartet die Daten der Person (Anrede, Vorname, Nachname), die Daten einer Zahlungs- und einer Lieferadresse (wenn identisch, geben wir einfach zwei Mal die gleichen Parameter an) sowie E-Mail, Telefon und Kundennummer aus der Datenbank. Die Funktion prüft nicht, ob leere Zeichenketten für Parameter übergeben wurden, aber die meisten Parameter sind Pflichtparameter. Wenn regelmäßig verschiedene Daten nicht vorhanden sind, sollten Sie abfragen, ob die jeweiligen Parameter leer sind und gegebenenfalls die betroffenen Elemente weglassen, wenn möglich.

Public Function AddOrUpdateContact_Person(strSalutation As String, strFirstname As String, strLastname As String, _
         strStreetBilling As String, strZipBilling As String, strCityBilling As String, strCountryCodeBilling As _
         String, strStreetShipping As String, strZipShipping As String, strCityShipping As String, _
         strCountryCodeShipping As String, strEMail As String, strPhone As String, strCustomerID As String, _
         strID As String)
     Dim strRequest As String
     Dim strURL As String
     Dim strResponse As String
     Dim strMethod As String
     Dim intVersion As Integer
     Dim objJSON As Object
     strURL = "https://api.lexoffice.io/v1/contacts"
     If Len(strID) = 0 Then
         strMethod = "POST"
     Else
         strMethod = "PUT"
         strURL = strURL & "/" & strID
     End If
     ...

[

Listing 3: Anlegen oder Aktualisieren eines Kontakts, Teil 1

Kontakt überschreiben

Die Funktion schreibt zunächst die URL in die Variable strURL und prüft dann, ob der Parameter strID einen Wert enthält oder eine leere Zeichenkette. strID soll, wenn der Kontakt bereits einmal angelegt wurde, im Feld LexOfficeID der Kundentabelle gespeichert werden.

Dieser wird dann statt einer leeren Zeichenkette für den letzten Parameter strID übergeben und bewirkt, dass in diesem Fall in lexoffice der entsprechende Kontakt mit neuen Daten überschrieben werden soll. Dafür gibt es einige Einschränkungen, die Sie der entsprechenden Stelle der Dokumentation entnehmen können:

https://developers.lexoffice.io/docs/#contacts-endpoint-create-a-contact

Ist strID nicht gefüllt, verwenden wir als Methode POST – dies legt ein neues Element an – oder PUT zum Aktualisieren des vorhandenen Elements. Ist strID vorhanden, wird es außerdem an strURL angehängt, sodass der Link beispielsweise wie folgt aussieht:

https://api.lexoffice.io/v1/contacts/7d64ec31-4ebb-4f1c-9a68-b50718f82efc

Danach beginnt, wie in Listing 4 abgebildet, das Zusammenstellen des als Body übergebenen JSON-Dokuments mit dem Request in der Variablen strRequest. Hier fügen wir zuerst die Version hinzu, die für ein neues Element auf 0 eingestellt wird. Für ein vorhandenes Element müssen wir zuvor mit einer weiteren Funktion die aktuelle Version für dieses Element ermitteln, die bei jeder Änderung um 1 erhöht wird. Die Version holen wir mit der Funktion GetContactVersion, der wir ebenfalls die ID aus strID übergeben.

     strRequest = "{" & vbCrLf
     If Len(strID) = 0 Then
         strRequest = strRequest & "  ""version"": 0," & vbCrLf
     Else
         intVersion = GetContactVersion(strID)
         strRequest = strRequest & "  ""version"": " & intVersion & "," & vbCrLf
     End If
     strRequest = strRequest & "  ""roles"": {""customer"": {}}," & vbCrLf
     strRequest = strRequest & "  ""person"": {" & vbCrLf
     strRequest = strRequest & "    ""salutation"": """ & strSalutation & """," & vbCrLf
     strRequest = strRequest & "    ""firstName"": """ & strFirstname & """," & vbCrLf
     strRequest = strRequest & "    ""lastName"": """ & strLastname & """" & vbCrLf
     strRequest = strRequest & "  }," & vbCrLf
     strRequest = strRequest & "  ""addresses"": {" & vbCrLf
     strRequest = strRequest & "     ""billing"": [{" & vbCrLf
     strRequest = strRequest & "         ""supplement"": """"," & vbCrLf
     strRequest = strRequest & "         ""street"": """ & strStreetBilling & """," & vbCrLf
     strRequest = strRequest & "         ""zip"": """ & strZipBilling & """," & vbCrLf
     strRequest = strRequest & "         ""city"": """ & strCityBilling & """," & vbCrLf
     strRequest = strRequest & "         ""countryCode"": """ & strCountryCodeBilling & """" & vbCrLf
     strRequest = strRequest & "       }]," & vbCrLf
     strRequest = strRequest & "     ""shipping"":  [{" & vbCrLf
     strRequest = strRequest & "       ""supplement"": """"," & vbCrLf
     strRequest = strRequest & "       ""street"": """ & strStreetShipping & """," & vbCrLf
     strRequest = strRequest & "       ""zip"": """ & strZipShipping & """," & vbCrLf
     strRequest = strRequest & "       ""city"": """ & strCityShipping & """," & vbCrLf
     strRequest = strRequest & "       ""countryCode"": """ & strCountryCodeShipping & """" & vbCrLf
     strRequest = strRequest & "     }]" & vbCrLf
     strRequest = strRequest & "  }," & vbCrLf
     strRequest = strRequest & "  ""emailAddresses"":{""other"":[""" & strEMail & """]}," & vbCrLf
     strRequest = strRequest & "  ""phoneNumbers"":{""other"":[""" & strPhone & """]}," & vbCrLf
     strRequest = strRequest & "  ""note"":""" & strCustomerID & """" & vbCrLf
     strRequest = strRequest & "}"
     If Request(strURL, strMethod, strRequest, strResponse) Then
         Set objJSON = mdlJSON.ParseJson(strResponse)
         AddOrUpdateContact_Person = True
         strID = objJSON.Item("id")
     End If
End Function

Listing 4: Anlegen oder Aktualisieren eines Kontakts, Teil 2

Diese Funktion sieht wie folgt aus. Sie übergibt der URL https://api.lexoffice.io/v1/contacts/ die ID und liest aus dem JSON-Dokument den Wert des Feldes version aus:

Public Function GetContactVersion(strID As String) As Integer
     Dim strRequest As String
     Dim strURL As String
     Dim strResponse As String
     Dim objJSON As Object
     strURL = "https://api.lexoffice.io/v1/contacts/" & strID
     If Request(strURL, "GET", strRequest, strResponse) Then
         Set objJSON = ParseJson(strResponse)
         GetContactVersion = objJSON.Item("version")
     End If
End Function

Haben wir die Version ermittelt, können wir mit dieser die korrekte Version des Kontaktes bei lexoffice überschreiben. Danach folgen einige ineinander verschachtelte Elemente, in die wir per Code die mit den Parametern der Funktion gelieferten Werte einarbeiten.

Wir fügen dem Kontakt neben dem person-Element mit Anrede, Vorname und Nachname dabei im Unterelement addresses zwei Adressen hinzu – jeweils eine Rechnungs- und eine Lieferadresse.

Danach folgen noch die E-Mail-Adressen und die Telefonnummern, von denen wir jeweils eine unter other hinzufügen. Bei den E-Mail-Adressen gibt es die Bereiche business, office, private und other. Für die Telefonnummern gibt es die Bereiche business, office, mobile, private, fax und other. Unter note geben wir, falls wir diese als Referenz in einer Rechnung et cetera benötigen, die Kundennummer aus der Kundentabelle an.

Danach folgt der eigentliche Aufruf der REST-API über die Funktion Request, der wir die URL, die Methode, das JSON-Dokument und eine leere Variable zum Entgegennehmen der Response übergeben.

Liefert die Funktion Request den Wert True zurück, war der Request erfolgreich, und das Ergebnis-Dokument ist im JSON-Format in der Variablen strResponse gelandet.

Dann nutzen wir die im oben genannten Beitrag zum Thema JSON vorgestellte Funktion ParseJSON, um den Inhalt von strResponse als Objektmodell verfügbar zu machen. Aus diesem lesen wir dann über objJSON.Item(“id”) die ID des neu angelegten Kontakts aus und speichern diesen im Rückgabeparameter strID.

Nun können wir die Funktion endlich aufrufen und verwenden dazu eine kleine Testprozedur, damit wir das Ergebnis aus strID auch auswerten können:

Public Sub Test_AddContact_Person()
     Dim strID As String
     If AddOrUpdateContact_Person("Herr", "Klaus", _
             "Schmitz", "Borkhofer Str. 17", "47137", _
             "Duisburg", "DE", "Borkhofer Str. 17", _
             "47137", "Duisburg", "DE", _
             "andre@minhorst.com", "+1713145654", _
             "99001234", strID) Then
         Debug.Print strID
     End If
End Sub

Das als Anfrage verschickte JSON-Dokument sieht mit diesen Daten wie folgt aus:

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

den kompletten Artikel im PDF-Format mit Beispieldatenbank

diesen und alle anderen Artikel mit dem Jahresabo

Schreibe einen Kommentar