{"id":55000429,"date":"2024-08-01T00:00:00","date_gmt":"2024-09-26T16:14:35","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=429"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"DHLVersandetiketten_erstellen_per_VBA","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/DHLVersandetiketten_erstellen_per_VBA\/","title":{"rendered":"DHL-Versandetiketten erstellen per VBA"},"content":{"rendered":"

\"\"Wer Kunden und Bestellungen mit einer Access-Datenbank verwaltet oder gegebenenfalls auch mit einer Excel-Tabelle, möchte vielleicht Zeit sparen und die Etiketten für den Versand von Lieferungen an seine Kunden automatisieren. Das gelingt mit den verschiedenen Webservices von DHL. Wir haben bereits einmal eine solche Lösung vorgestellt, aber DHL hat seine Schnittstellen für die Erstellung von Versandetiketten aktualisiert. In diesem Artikel schauen wir uns an, wie die neuen Schnittstellen funktionieren: Welche Daten benötige ich? Welche URL muss für den Zugriff verwendet werden? In welcher Form übergebe ich beispielsweise die Adressdaten an den Webservice?<\/b><\/p>\n

Voraussetzung für die Verwendung der Lösung<\/h2>\n

Wenn wir die Webservices von DHL für die Erstellung von Versandetiketten nutzen wollen, sind einige Voraussetzungen zu erfüllen. Als Erstes benötigen wir ein Konto als Geschäftskunde bei DHL. Wie Du dieses anlegst, wollen wir hier nicht im Detail beschreiben. Wir wollen Dir aber zumindest den Link zum Geschäftskundenportal mit auf den Weg geben:<\/p>\n

https:\/\/www.dhl.de\/de\/geschaeftskunden.html<\/pre>\n
Nach der Anmeldung benötigen wir später Deine Zugangsdaten für Dein Kundenkonto, also Benutzername und Kennwort.<\/p>\n
Als Zweites benötigst Du ein Entwicklerkonto bei DHL. Dazu besuchst Du die folgende Adresse und erstellst einen Account:<\/p>\n
https:\/\/developer.dhl.com\/<\/pre>\n
Damit können wir bereits starten.<\/p>\n
App erstellen<\/h2>\n
Nachdem wir einen Entwickler-Account erstellt haben, benötigen wir eine App. Wozu brauchen wir diese? Weil eine App uns einen API Key und ein API Secret liefert, mit dem wir auf die API-Schnittstelle zugreifen können. Also klicken wir, nachdem wir den Developer Account erstellt haben, auf die Schaltfläche App erstellen <\/b>(siehe Bild 1).<\/p>\n
\"App<\/p>\n
Bild 1: App anlegen für weitere Daten<\/span><\/b><\/p>\n
Dies führt uns zu der Seite aus Bild 2, wo wir den Namen der App und eine Beschreibung eingeben. Außerdem wählen wir hier bereits die API aus, die wir in dieser App verwenden wollen – in diesem Fall Parcel DE Shipping (Post & Parcel Germany)<\/b>.<\/p>\n
\"Angeben<\/p>\n
Bild 2: Angeben von App-Name und Beschreibung sowie Auswahl der APIs<\/span><\/b><\/p>\n
Im nächsten Schritt wählen wir weiter unten aus, ob wir die API zunächst testen oder direkt produktiv einsetzen wollen. Wir entscheiden uns zunächst für den Testbetrieb (siehe Bild 3).<\/p>\n
\"Angabe,<\/p>\n
Bild 3: Angabe, ob die App zum Testen oder produktiv genutzt werden soll<\/span><\/b><\/p>\n
Nach diesem Schritt erstellen wir schließlich mit einem Klick auf App erstellen<\/b> die App (siehe Bild 4).<\/p>\n
\"Erstellen<\/p>\n
Bild 4: Erstellen der App<\/span><\/b><\/p>\n
Die App wird nun in der Übersicht angezeigt, wo wir mit einem Klick auf den Namen der App die Detailseite öffnen können (siehe Bild 5). Außerdem können wir die App hier löschen oder Analysedaten anzeigen.<\/p>\n
\"Ein<\/p>\n
Bild 5: Ein Klick auf den App-Namen zeigt die Details an.<\/span><\/b><\/p>\n
Diese liefert uns unter Credentials<\/b> die gesuchten Informationen – den API Key und das API Secret (siehe Bild 6). Diese können wir mit einem Klick auf den Link Show key <\/b>jeweils einblenden.<\/p>\n
\"Anzeige<\/p>\n
Bild 6: Anzeige von API Key und API Secret<\/span><\/b><\/p>\n
Bevor es weitergeht: Produktiv-Version<\/h2>\n
Wenn wir schon auf dieser Seite sind, können wir auch gleich die Produktiv-Version der API hinzufügen. Wenn wir die API Parcel DE Shipping <\/b>erneut auswählen, wird unter Environment <\/b>direkt Production <\/b>angeboten. Dieses behalten wir bei und klicken auf die Schaltfläche zum Hinzufügen (siehe Bild 7).<\/p>\n
\"API<\/p>\n
Bild 7: API produktiv machen<\/span><\/b><\/p>\n
Dies wird jedoch nicht direkt freigegeben, sondern wir erhalten die Meldung, dass sich die API im Status Pending <\/b>befindet.<\/p>\n
Als wir die produktive Version hinzugefügt haben, dauerte die Freigabe allerdings nur wenige Minuten. Es empfiehlt sich jedoch, die ersten Tests zunächst einmal mit der Sandbox-Version durchzuführen.<\/p>\n
Informationen über die API suchen<\/h2>\n
Bevor wir den Zugriff auf eine REST Api programmieren können, benötigen wir einige Informationen – zum Beispiel die URL, an die wir die Anfrage schicken, die Art der Authentifizierung und die dafür notwendigen Zugangsdaten, die verschiedenen API-Funktionen und deren Syntax.<\/p>\n
Dazu wechseln wir von der Seite https:\/\/developer.dhl.com <\/b>per Klick auf den Link Browse Shipping APIs <\/b>zu den gesuchten APIs.<\/p>\n
Hier finden wir eine Liste aller API, die wir durch Auswahl verschiedener Kriterien auf die Einträge aus Bild 8 begrenzen.<\/p>\n
\"APIs<\/p>\n
Bild 8: APIs für den Versand<\/span><\/b><\/p>\n
All diese APIs sind entweder mit der deutschen Bezeichnung Post & Paket Deutschland <\/b>oder der englischen Übersetzung Post & Parcel Germany <\/b>markiert, also gehen wir davon aus, dass wir diese über die von uns gewählte, gleichnamige API nutzen können (siehe Bild 8).<\/p>\n
Mit dieser API können wir beispielsweise die folgenden Aufgaben erledigen:<\/p>\n
    \n
  • Erstellung von Paketmarken für Privatkunden für den Inlands- und internationalen Versand (Absenderadresse in Deutschland)<\/li>\n
  • Herunterladen erstellter Versandetiketten<\/li>\n
  • Herunterladen von mobilen Paketmarken entweder als QR-Code (PNG) oder Wallet-Datei<\/li>\n
  • Die Zahlungsfunktion wird sicher über die Web-Schnittstelle von DHL während des Checkouts bereitgestellt<\/li>\n
  • Erstellung von Zoll- und Exportdokumenten<\/li>\n<\/ul>\n
    Programmierung der API<\/h2>\n
    Wir starten mit der Programmierung der API mit einem einfachen Beispiel. Dazu wollen wir zunächst die Sandbox nutzen, also einen Testserver.<\/p>\n
    Einfachste Abfrage: Version ermitteln<\/h2>\n
    Es ist immer schön, eine kleine Test-API zu haben, mit der man erstmal den grundlegenden Zugriff testen kann – bevor es dann ans Eingemachte geht und wir kompliziertere und umfangreichere Daten hin- und herschicken.<\/p>\n
    Also freuen wir uns, dass es eine API gibt, die einfach Versionsinformationen zurückliefert.<\/p>\n
    Diese rufen wir mit der folgenden einfachen Funktion auf:<\/p>\n
    Public Function <\/span>APIVersionAbfragen() As String<\/span>\r\n     Dim <\/span>strMethod As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Dim <\/span>lngStatus As Long<\/span>\r\n     strMethod = \"GET\"\r\n     lngStatus = HTTPRequest(GetURL(False<\/span>), _\r\n         strMethod, , , False, strResponse)\r\n     Select Case lngStatus\r\n         Case <\/span>200\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n     End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
    Natürlich ist das nicht alles, es hängt noch eine weitere Funktion namens HTTPRequest <\/b>dahinter, die den eigentlichen API-Zugriff durchführt.<\/p>\n
    Diese sehen wir in Listing 1. Die Funktion erwartet die folgenden Parameter:<\/p>\n
    Public Function <\/span>HTTPRequest(strURL As String<\/span>, Optional<\/span> strMethod As String<\/span> = \"POST\", _\r\n         Optional<\/span> strContentType As String<\/span> = \"application\/json\", Optional<\/span> strData As String<\/span>, _\r\n         Optional<\/span> strResponse As String<\/span>, Optional<\/span> bolProductive As Boolean<\/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         .Open strMethod, strURL, False<\/span>\r\n         .setRequestHeader \"Accept\", \"application\/json\"\r\n         .setRequestHeader \"Content-Type\", \"application\/json; charset=UTF-8\"\r\n         .setRequestHeader \"CharSet\", \"utf-8\"\r\n         .setRequestHeader \"dhl-api-key\", GetAPIKey\r\n         .setRequestHeader \"Authorization\", \"Basic \" & Base64Encode(GetUsername(bolProductive) & \":\" _\r\n             & GetPassword(bolProductive))\r\n         If <\/span>Not<\/span> Len<\/span>(strData) = 0 Then<\/span>\r\n             .setRequestHeader \"Body\", strData\r\n         End If<\/span>\r\n         .send strData\r\n         strResponse = .responseText\r\n         HTTPRequest = .status\r\n     End With<\/span>\r\nEnd Function<\/span><\/pre>\n
    Listing 1: Die Funktion HTTPRequest führt den eigentlichen API-Aufruf durch.<\/span><\/b><\/p>\n
      \n
    • strURL<\/b>: Nimmt die Basis-URL der Rest-API entgegen.<\/li>\n
    • strMethod<\/b>: Nimmt die Methode entgegen, zum Beispiel POST<\/b>, GET <\/b>oder PUT<\/b>.<\/li>\n
    • strContentType<\/b>: Nimmt die Art des Contents entgegen, hier application\/json<\/b>.<\/li>\n
    • strData<\/b>: Nimmt eine zu übermittelnde JSON-Datei entgegen.<\/li>\n
    • strResponse<\/b>: Liefert die Antwort der Rest-API.<\/li>\n
    • bolProductive<\/b>: Erwartet die Angabe, ob die Sandbox- oder die Produktions-API aufgerufen werden soll.<\/li>\n<\/ul>\n
      Um nun die Version der Rest-API zu ermitteln, starten wir mit dem Aufruf der Prozedur APIVersionAbfragen<\/b>. Diese legt die Methode mit GET <\/b>fest und übermittelt die mit GetURL(False) <\/b>geholte URL. Die Funktion GetURL <\/b>erwartet den Wert True <\/b>oder False<\/b>, je nachdem, ob die Produktiv- oder die Sandboxumgebung genutzt werden soll:<\/p>\n
      Public Function <\/span>GetURL(Optional<\/span> bolProductive As Boolean<\/span>)\r\n     If <\/span>bolProductive = True<\/span> Then<\/span>\r\n         GetURL = \"https:\/\/api-eu.dhl.com\/\" _\r\n             & \"parcel\/de\/shipping\/v2\/\"\r\n     Else<\/span>\r\n         GetURL = \"https:\/\/api-sandbox.dhl.com\/\" _\r\n             & \"parcel\/de\/shipping\/v2\/\"\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
      Außerdem übergeben wir noch den Parameter strResponse<\/b>, mit dem wir die Antwort der Rest-API entgegennehmen. Die Antwort geben wir schließlich sowohl für den Erfolgsfall als auch für den Fall eines Fehlers im Direktbereich des VBA-Editors aus – genau genommen das mit der Funktion GetJSONDOM <\/b>bearbeitete Ergebnis. Wie diese funktioniert, haben wir bereits in den Artikeln Mit JSON arbeiten <\/b>(www.vbentwickler.de\/361<\/b>) und JSON-Dokumente per Objektmodell zusammenstellen <\/b>(www.vbentwickler.de\/412<\/b>) beschrieben.<\/p>\n
      Das Ergebnis sieht schließlich wie in Bild 9 aus. Hier sehen wir die Ausdrücke, mit denen wir direkt auf die Werte des mit der Funktion ParseJSON <\/b>ermittelten Objekts zugreifen können.<\/p>\n
      \"Ergebnis<\/p>\n
      Bild 9: Ergebnis der Versionsabfrage<\/span><\/b><\/p>\n
      Erstellung von Versandmarken testen<\/h2>\n
      Nachdem der Zugriff auf die Version funktioniert hat, gehen wir einen Schritt weiter und schauen uns direkt die Hauptfunktion an. Diese wiederum testen wir mit der folgenden Prozedur, die wie folgt aussieht und gar nicht so kompliziert aussieht:<\/p>\n
      Public Sub <\/span>Test_APIOrder()\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Dim <\/span>lngStatus As Long<\/span>\r\n     Dim <\/span>strData As String<\/span>\r\n     Dim <\/span>strPathPDF As String<\/span>\r\n     strPathPDF = CurrentProject.Path & \"\\test.pdf\"\r\n     strData = JSONBeispielsendung\r\n     If APIOrder(strData, strPathPDF, strResponse, _\r\n             lngStatus, True, False<\/span>) = True<\/span> Then\r\n         MsgBox<\/span> \"Erfolgreich\"\r\n         OpenDocument strPathPDF\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Nicht erfolgreich\" & vbCrLf<\/span> & vbCrLf<\/span> _\r\n             & strResponse\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
      Das liegt daran, dass wir darin eine weitere Funktion namens JSONBeispielsendung <\/b>aufrufen, die uns das komplette JSON-Dokument mit den Daten für die Sendung zusammenstellt – inklusive Absender- und Empfängeradresse und den Details der Sendung wie die Abmessungen und das Gewicht (siehe Listing 2).<\/p>\n
      Public Function <\/span>JSONBeispielsendung() As String<\/span>\r\n     Dim <\/span>strJSON As String<\/span>\r\n     strJSON = strJSON & \"{\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"  \"\"shipments\"\": [\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"    {\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      \"\"product\"\": \"\"V01PAK\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      \"\"billingNumber\"\": \"\"33333333330102\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      \"\"refNo\"\": \"\"Order No. 1234\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      \"\"shipper\"\": {\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"name1\"\": \"\"Minhorst und Minhorst GmbH\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"addressStreet\"\": \"\"Borkhofer Str. 17\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"postalCode\"\": \"\"47137\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"city\"\": \"\"Duisburg\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"country\"\": \"\"DEU\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"email\"\": \"\"andre@minhorst.com\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"phone\"\": \"\"+ 123456789\"\"\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      },\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      \"\"consignee\"\": {\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"name1\"\": \"\"Maria Musterfrau\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"addressStreet\"\": \"\"Kurt-Schumacher-Str. 20\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"additionalAddressInformation1\"\": \"\"Apartment 107\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"postalCode\"\": \"\"53113\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"city\"\": \"\"Bonn\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"country\"\": \"\"DEU\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"email\"\": \"\"maria@musterfrau.de\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"phone\"\": \"\"+ 987654321\"\"\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      },\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      \"\"details\"\": {\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"dim\"\": {\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"          \"\"uom\"\": \"\"mm\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"          \"\"height\"\": 100,\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"          \"\"length\"\": 200,\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"          \"\"width\"\": 150\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        },\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        \"\"weight\"\": {\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"          \"\"uom\"\": \"\"g\"\",\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"          \"\"value\"\": 500\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"        }\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"      }\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"    }\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"  ]\" & vbCrLf<\/span>\r\n     strJSON = strJSON & \"}\" & vbCrLf<\/span>\r\n     JSONBeispielsendung = strJSON\r\nEnd Function<\/span><\/pre>\n
      Listing 2: Diese Funktion stellt das JSON-Dokument mit den Paketdaten zusammen.<\/span><\/b><\/p>\n
      Danach ruft die die Funktion APIOrder <\/b>auf, der sie alle notwendigen Variablen übergibt – diese beschreiben wir im Anschluss mit der Funktion APIOrder<\/b>.<\/p>\n
      Funktion zum Ausführen der API-Funktion Order<\/h2>\n
      Die Funktion APIOrder <\/b>erwartet die folgenden Parameter (siehe Listing 3):<\/p>\n
      Public Function <\/span>APIOrder(strData As String<\/span>, strPathPDF As String<\/span>, Optional<\/span> strResponse As String<\/span>, _\r\n         Optional<\/span> lngStatus As Long<\/span>, Optional<\/span> bolValidate As Boolean<\/span>, Optional<\/span> bolProductive As Boolean<\/span>) As String<\/span>\r\n     Dim <\/span>strMethod As String<\/span>\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>objJSON As Object<\/span>\r\n     Dim <\/span>strFile As String<\/span>\r\n     strURL = GetURL(bolProductive) & \"orders\"\r\n     If <\/span>bolValidate = True<\/span> Then<\/span>\r\n         strURL = strURL & \"?validate=true\"\r\n     End If<\/span>\r\n     strMethod = \"POST\"\r\n     lngStatus = HTTPRequest(strURL, strMethod, , strData, strResponse, bolProductive)\r\n     Select Case lngStatus\r\n         Case <\/span>200\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             If <\/span>bolValidate = False<\/span> Then<\/span>\r\n                 strFile = objJSON.Item(\"items\").Item(1).Item(\"label\").Item(\"b64\")\r\n                 WriteFileFromBytes strPathPDF, DecodeBase64(strFile)\r\n             End If<\/span>\r\n             APIOrder = True<\/span>\r\n         Case Else<\/span>\r\n             Debug.Print<\/span> GetJSONDOM(strResponse, True<\/span>)\r\n             APIOrder = False<\/span>\r\n     End Select<\/span>\r\n     Inzwischenablage strResponse\r\nEnd Function<\/span><\/pre>\n
      Listing 3: Die Funktion APIOrder übergibt den Request an die Funktion HTTPRequest und wertet die Antwort aus.<\/span><\/b><\/p>\n
        \n
      • strData<\/b>: JSON-Dokument mit den Daten für die DHL-Versandmarke<\/li>\n
      • strPathPDF<\/b>: Pfad, unter dem das erzeugte PDF-Dokument gespeichert werden soll<\/li>\n
      • strResponse<\/b>: Antwort des API-Aufrufs<\/li>\n
      • lngStatus<\/b>: Status des Aufrufs<\/li>\n
      • bolValidate<\/b>: Gibt an, ob der Aufruf nur der Validierung dienen soll. Der Wert False <\/b>sorgt dafür, dass der Aufruf nur getestet wird.<\/li>\n
      • bolProductive<\/b>: Gibt an, ob die Sandbox- oder die Produktiv-API genutzt werden soll.<\/li>\n<\/ul>\n
        Die Funktion legt als Methode POST <\/b>und als URL die URL fest, die der mit bolProductive <\/b>festgelegten Plattform entspricht. Wenn der Parameter bolValidate True <\/b>ist, hängt sie noch den Ausdruck ?validate=true <\/b>an die URL an, damit nur ein Test der API gefahren wird. Dann ruft sie HTTPRequest <\/b>auf und übergibt die notwendigen Parameter. Liefert diese den Status 200 <\/b>zurück, gibt sie testweise das Ergebnis im Direktbereich aus. Außerdem erstellt sie mit der Funktion ParseJson <\/b>in objJSON <\/b>ein Objekt auf Basis der zurückgelieferten Antwort. Erfolgt der Aufruf nicht zum Validieren, sondern direkt zum Abfragen der Versandmarke, greifen wir nachfolgend auf das als Zeichenkette kodierte PDF-Dokument zu. Dieses schreibt die Funktion dann mit der Funktion WriteFileFromBytes <\/b>in eine Datei mit dem Dateinamen aus strPathPDF<\/b>.<\/p>\n
        Die frisch erstellte Versandmarke ruft die Funktion OpenDocument <\/b>auf, um das Dokument wie in Bild 10 anzuzeigen.<\/p>\n
        \"Beispiel<\/p>\n
        Bild 10: Beispiel für eine frisch erstellte Versandmarke<\/span><\/b><\/p>\n
        Von der Sandbox zum Produktivbetrieb<\/h2>\n
        Damit haben wir schon einmal sichergestellt, dass der Code grundsätzlich funktioniert. Bevor wir diesen so erweitern, dass wir die Empfängeradresse und die Paketdaten aus einer Tabelle oder einem Formular entnehmen, wollen wir jedoch noch den Produktivbetrieb testen. Dazu stellen wir als Erstes den Aufruf der Funktion APIOrder <\/b>in der Prozedur Test_APIOrder <\/b>so um, dass der Produktivmodus verwendet wird. Gleichzeitig stellen wir den vorletzten Parameter auf den Wert True <\/b>ein, damit wir den Aufruf erst einmal validieren können:<\/p>\n
        If <\/span>APIOrder(strData, strPathPDF, strResponse, lngStatus, True, True<\/span>) = True<\/span> Then<\/span>\r\n...<\/pre>\n
        Dabei hagelt es erst einmal Fehler, die wir zum Beispiel im Direktbereich wie in Bild 11 einsehen können. <\/p>\n
        \"Rückmeldung<\/p>\n
        Bild 11: Rückmeldung des fehlerhaften Aufrufs<\/span><\/b><\/p>\n
        In unserem Fall liegen die Fehler daran, dass wir zwar ein DHL-Geschäftskundenkonto haben, aber keinen gültigen Vertrag, um Pakete zu Geschäftskundenkonditionen zu verschicken. DHL war auch nicht bereit, uns zu Testzwecken einen entsprechenden Vertrag bereitzustellen.<\/p>\n
        Wir haben die hier vorgestellte Lösung jedoch zusammen mit einem Kunden getestet und das Beispiel lief wie gewünscht durch.<\/p>\n
        Zusammenstellung des JSON-Dokuments optimieren<\/h2>\n
        Das JSON-Dokument hatten wir bisher zu Testzwecken einfach in vielen Anweisungen per Zeichenverkettung zeilenweise zusammengesetzt. Dies wollen wir nun optimieren, um einfacher und fehlerloser neue Elemente hinzufügen zu können. Dabei wollen wir dieses gleichzeitig in eine Klasse einarbeiten, der wir noch einige Eigenschaften hinzufügen, mit denen der Benutzer die Informationen über den Versender, den Empfänger und so weiter hinzufügen kann. Dazu verwenden wir zunächst einmal eine Prozedur, welche die in den Eigenschaften vorhandenen Informationen in einen JSON-Ausdruck umwandelt.<\/p>\n
        Dabei greifen wir auf die bewährte Technik zurück, ein aus Dictionarys und Collections bestehendes Konstrukt zu erstellen und dieses dann mit der Funktion ConvertToJSON<\/b> in das JSON-Dokument umzuwandeln.<\/p>\n
        Klasse erstellen<\/h2>\n
        Dazu erstellen wir eine Klasse namens clsShipment<\/b>. Diese enthält zunächst jeweils eine Variable für die aktuell von dieser Lösung unterstützten Informationen:<\/p>\n
        Private <\/span>m_Produkt As String<\/span>\r\nPrivate <\/span>m_BillingNumber As String<\/span>\r\nPrivate <\/span>m_RefNo As String<\/span>\r\nPrivate <\/span>m_Shipper_Name1 As String<\/span>\r\nPrivate <\/span>m_Shipper_AddressStreet As String<\/span>\r\nPrivate <\/span>m_Shipper_PostalCode As String<\/span>\r\nPrivate <\/span>m_Shipper_City As String<\/span>\r\nPrivate <\/span>m_Shipper_Country As String<\/span>\r\nPrivate <\/span>m_Shipper_Email As String<\/span>\r\nPrivate <\/span>m_Shipper_Phone As String<\/span>\r\nPrivate <\/span>m_Consignee_Name1 As String<\/span>\r\nPrivate <\/span>m_Consignee_AddressStreet As String<\/span>\r\nPrivate <\/span>m_Consignee_AdditionalAddressInformation1 As String<\/span>\r\nPrivate <\/span>m_Consignee_PostalCode As String<\/span>\r\nPrivate <\/span>m_Consignee_City As String<\/span>\r\nPrivate <\/span>m_Consignee_Country As String<\/span>\r\nPrivate <\/span>m_Consignee_Email As String<\/span>\r\nPrivate <\/span>m_Consignee_Phone As String<\/span>\r\nPrivate <\/span>m_Details_Dim_Uom As String<\/span>\r\nPrivate <\/span>m_Details_Dim_Height As Currency<\/span>\r\nPrivate <\/span>m_Details_Dim_Length As Currency<\/span>\r\nPrivate <\/span>m_Details_Dim_Width As Currency<\/span>\r\nPrivate <\/span>m_Details_Weight_Uom As String<\/span>\r\nPrivate <\/span>m_Details_Weight_Value As Currency<\/span><\/pre>\n
        Um diese Variablen zu füllen, die später wiederum zum Zusammenstellen des JSON-Dokuments genutzt werden, legen wir für jede Variable eine öffentliche Property Let<\/b>-Prozedur an – hier nur beispielhaft für einige der Variablen:<\/p>\n
        Public Property Let <\/span>Produkt(str As String<\/span>)\r\n     m_Produkt = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>BillingNumber(str As String<\/span>)\r\n     m_BillingNumber = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>RefNo(str As String<\/span>)\r\n     m_RefNo = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Shipper_Name1(str As String<\/span>)\r\n     m_Shipper_Name1 = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Shipper_AddressStreet(str As String<\/span>)\r\n     m_Shipper_AddressStreet = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Shipper_PostalCode(str As String<\/span>)\r\n     m_Shipper_PostalCode = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Shipper_City(str As String<\/span>)\r\n     m_Shipper_City = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Shipper_Country(str As String<\/span>)\r\n     m_Shipper_Country = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Shipper_Email(str As String<\/span>)\r\n     m_Shipper_Email = str\r\nEnd Property<\/span><\/pre>\n
        Diese öffentlichen Property Let<\/b>-Prozeduren erlauben es, der Klasse nach dem Initialisieren die Werte für die verschiedenen Eigenschaften hinzuzufügen.<\/p>\n
        JSON-Dokument für Shipment zusammenstellen<\/h2>\n
        Damit kommen wir zum Arbeitstier der Klasse – die Prozedur CreateJSONRequest<\/b>. Diese soll die Werte der Eigenschaften, sofern diese übergeben wurden, zu einem gültigen JSON-Dokument zusammensetzen. <\/p>\n
        Und hier wird es spannend. Während wir in dem ersten Beispiel einfach nur fiktive Informationen zusammengestellt haben, die alle vollständig waren, wollen wir nun dem Benutzer ermöglichen, auch einmal nur die notwendigsten Informationen einzutragen. Dazu müssen wir allerdings erst einmal wissen, welche Informationen das sind. DHL hat dazu ein Dokument zusammengestellt, das wir hier einsehen können:<\/p>\n
        https:\/\/developer.dhl.com\/api-reference\/parcel-de-shipping-post-parcel-germany-v2#additional-information-section<\/pre>\n
        Das Dokument liefert uns alle Elemente und ihre hierarchische Anordnung und gibt auch an, ob es sich um Pflichtelement handelt (erkennbar am roten Sternchen) und in welcher Anzahl diese vorkommen dürfen (siehe Bild 12). Die Pflichtfelder sind anscheinend nicht korrekt markiert – zum Beispiel ist die BillingNumber<\/b> nicht als Pflichtfeld gekennzeichnet, wird aber zwingend benötigt, da sonst ein Fehler auftritt.<\/p>\n
        \"Dokumentation<\/p>\n
        Bild 12: Dokumentation der Elemente des JSON-Dokuments<\/span><\/b><\/p>\n
        Anhand der Informationen, die wir durch Tests ermittelt haben, wollen wir jedoch die zwingend notwendigen Elemente und diejenigen, die nicht unbedingt angegeben werden müssen, dadurch unterscheiden, dass wir die freiwilligen Elemente gar nicht erst in das JSON-Dokument einbinden, wenn diese nicht angegeben wurden.<\/p>\n
        Das sehen wir in der Funktion CreateJSONRequest<\/b>, deren ersten Teil wir in Listing 4 abbilden. Hier bauen wir eine Struktur aus Dictionary<\/b>– und Collection<\/b>-Elementen auf. Jedes JSON-Element, das mit geschweiften Klammern eingefasst ist, wird dabei durch ein Dictionary<\/b>-Element abgebildet, jedes mit eckigen Klammern durch ein Collection<\/b>-Objekt.<\/p>\n
        Public Function <\/span>CreateJSONRequest() As String<\/span>\r\n     Dim <\/span>dicMain As <\/span>Dictionary\r\n     Dim <\/span>colShipments As <\/span>Collection\r\n     Dim <\/span>dicShipments As <\/span>Dictionary\r\n     Dim <\/span>dicShipper As <\/span>Dictionary\r\n     Dim <\/span>dicConsignee As <\/span>Dictionary\r\n     Dim <\/span>dicDetails As <\/span>Dictionary\r\n     Dim <\/span>dicDim As <\/span>Dictionary\r\n     Dim <\/span>dicWeight As <\/span>Dictionary\r\n     Set<\/span> dicMain = New<\/span> Dictionary\r\n     Set<\/span> colShipments = New<\/span> Collection\r\n     dicMain.Add \"shipments\", colShipments\r\n     Set<\/span> dicShipments = New<\/span> Dictionary\r\n     colShipments.Add dicShipments\r\n     dicShipments.Add \"product\", m_Produkt\r\n     dicShipments.Add \"billingNumber\", m_BillingNumber\r\n     dicShipments.Add \"refNo\", m_RefNo\r\n     Set<\/span> dicShipper = New<\/span> Dictionary\r\n     dicShipments.Add \"shipper\", dicShipper\r\n     dicShipper.Add \"name1\", m_Shipper_Name1\r\n     dicShipper.Add \"addressStreet\", m_Shipper_AddressStreet\r\n     dicShipper.Add \"postalCode\", m_Shipper_PostalCode\r\n     dicShipper.Add \"city\", m_Shipper_City\r\n     dicShipper.Add \"country\", m_Shipper_Country\r\n     If <\/span>Not<\/span> Len<\/span>(m_Shipper_Email) = 0 Then<\/span>\r\n         dicShipper.Add \"email\", m_Shipper_Email\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> Len<\/span>(m_Shipper_Phone) = 0 Then<\/span>\r\n         dicShipper.Add \"phone\", m_Shipper_Phone\r\n     End If<\/span>\r\n     ...<\/pre>\n
        Listing 4: Funktion zum Zusammenstellen einer Objekthierarchie mit dem JSON-Dokument (Teil 1)<\/span><\/b><\/p>\n
        Hier erstellen wir zuerst ein übergeordnetes Element namens objMain<\/b>, dessen erstes Element shipments<\/b> heißt und mehrere in eckigen Klammern eingefasste Elemente enthalten kann. Diesem ordnen wir ein Element namens colShipments <\/b>unter, das wiederum das Element dicShipments <\/b>enthält. Für dieses legen wir einige Name-Wert-Paare fest, beispielsweise für das Produkt, die Abrechnungsnummer und die Referenznummer. Danach folgt ein weiteres Unterelement namens shipper<\/b>, dem wir weitere Name-Wert-Paare mit den Adressdaten des Versenders hinzufügen.<\/p>\n
        Hier prüfen wir bei zwei Eigenschaften, ob diese überhaupt gefüllt sind – E-Mail-Adresse und die Telefonnummer -, und legen nur dann die entsprechenden Elemente an.<\/p>\n
        In Listing 5 geht es mit dem Element für den Empfänger weiter. Hier geben wir die gleichen Informationen wir für den Absender ein und noch eine zusätzliche Adressinformation. Danach folgt noch ein weiteres Unterelement namens details<\/b>. Dieses enthält unter anderem die Abmessungen des Pakets (dim<\/b>) sowie das Gewicht samt Einheiten (weight<\/b>).<\/p>\n
             ...\r\n     Set<\/span> dicConsignee = New<\/span> Dictionary\r\n     dicShipments.Add \"consignee\", dicConsignee\r\n     dicConsignee.Add \"name1\", m_Consignee_Name1\r\n     dicConsignee.Add \"addressStreet\", m_Consignee_AddressStreet\r\n     If <\/span>Not<\/span> Len<\/span>(m_Consignee_AdditionalAddressInformation1) = 0 Then<\/span>\r\n         dicConsignee.Add \"additionalAddressInformation1\", m_Consignee_AdditionalAddressInformation1\r\n     End If<\/span>\r\n     dicConsignee.Add \"postalCode\", m_Consignee_PostalCode\r\n     dicConsignee.Add \"city\", m_Consignee_City\r\n     dicConsignee.Add \"country\", m_Consignee_Country\r\n     If <\/span>Not<\/span> Len<\/span>(m_Consignee_Email) = 0 Then<\/span>\r\n         dicConsignee.Add \"email\", m_Consignee_Email\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> Len<\/span>(m_Consignee_Phone) Then<\/span>\r\n         dicConsignee.Add \"phone\", m_Consignee_Phone\r\n     End If<\/span>\r\n     Set<\/span> dicDetails = New<\/span> Dictionary\r\n     Set<\/span> dicDim = New<\/span> Dictionary\r\n     dicShipments.Add \"details\", dicDetails\r\n     dicDetails.Add \"dim\", dicDim\r\n     dicDim.Add \"uom\", m_Details_Dim_Uom\r\n     dicDim.Add \"height\", m_Details_Dim_Height\r\n     dicDim.Add \"length\", m_Details_Dim_Length\r\n     dicDim.Add \"width\", m_Details_Dim_Width\r\n     Set<\/span> dicWeight = New<\/span> Dictionary\r\n     dicDetails.Add \"weight\", dicWeight\r\n     dicWeight.Add \"uom\", m_Details_Weight_Uom\r\n     dicWeight.Add \"value\", m_Details_Weight_Value\r\n     CreateJSONRequest = ConvertToJson(dicMain)\r\nEnd Function<\/span><\/pre>\n
        Listing 5: Funktion zum Zusammenstellen einer Objekthierarchie mit dem JSON-Dokument (Teil 2)<\/span><\/b><\/p>\n
        Schließlich ruft die Routine die Funktion ConvertToJson <\/b>auf und gibt die ermittelte JSON-Anweisung an die aufrufende Prozedur zurück.<\/p>\n
        Steuerung der Labelerstellung<\/h2>\n
        Für die Steuerung der Labelerstellung ziehen wir die bereits weiter oben vorgestellte Funktion APIOrder<\/b> diesmal unter dem Namen GetShipmentLabel <\/b>ebenfalls in die Klasse hinein. Die Parameter, die wir APIOrder<\/b> noch direkt übergeben haben, legen wir ebenfalls als öffentliche Eigenschaften der Klasse an. Diese deklarieren wir wie folgt im Kopf des Klassenmoduls:<\/p>\n
        Private <\/span>m_PathPDF As String<\/span>\r\nPrivate <\/span>m_Productive As Boolean<\/span>\r\nPrivate <\/span>m_Validate As Boolean<\/span>\r\nPrivate <\/span>m_Response As String<\/span>\r\nPrivate <\/span>m_Status As Long<\/span>\r\nPrivate <\/span>m_PrintFormat As String<\/span><\/pre>\n
        Zum Einstellen legen wir ebenfalls öffentliche Property Let<\/b>-Prozeduren wie die folgende an:<\/p>\n
        Public Property Let <\/span>PrintFormat(str As String<\/span>)\r\n     m_PrintFormat = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>PrintFormat() As String<\/span>\r\n     PrintFormat = m_PrintFormat\r\nEnd Property<\/span><\/pre>\n
        Alle Eigenschaften werden mit Getter und Setter angelegt. Dazu haben wir übrigens das im Artikel Klassenprogrammierung mit COM-Add-In vereinfachen <\/b>(www.vbentwickler.de\/433<\/b>) vorgestellte COM-Add-In genutzt. Die Funktion GetShipmentLabel<\/b> selbst sieht nun wie in Listing 6 aus. Die Funktion hat, wie erwähnt, keine Parameter mehr, sondern holt sich alle notwendigen Informationen aus den Variablen wie m_PathPDF <\/b>oder m_Validate<\/b>. Ansonsten funktioniert sie genau wie die weiter oben bereits vorgestellte Funktion.<\/p>\n
        Public Function <\/span>GetShipmentLabel() As Boolean<\/span>\r\n     Dim <\/span>strMethod As String<\/span>\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>objJSON As Object<\/span>\r\n     Dim <\/span>strFile As String<\/span>\r\n     If <\/span>Len<\/span>(m_PathPDF) = 0 Then<\/span>\r\n         MsgBox<\/span> \"PathPDF nicht angegeben.\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     strURL = GetURL(m_Productive) & \"orders\"\r\n     If <\/span>m_Validate = True<\/span> Then<\/span>\r\n         strURL = strURL & \"?validate=true\"\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> Len<\/span>(m_PrintFormat) = 0 Then<\/span>\r\n         strURL = strURL & \"?printFormat=\" & m_PrintFormat\r\n     End If<\/span>\r\n     ...\r\n     strMethod = \"POST\"\r\n     m_Status = HTTPRequest(strURL, strMethod, , CreateJSONRequest, m_Response, m_Productive)\r\n     Select Case m_Status\r\n         Case <\/span>200\r\n             Set<\/span> objJSON = ParseJson(m_Response)\r\n             If <\/span>m_Validate = False<\/span> Then<\/span>\r\n                 strFile = objJSON.Item(\"items\").Item(1).Item(\"label\").Item(\"b64\")\r\n                 WriteFileFromBytes m_PathPDF, DecodeBase64(strFile)\r\n             End If<\/span>\r\n             GetShipmentLabel = True<\/span>\r\n         Case Else<\/span>\r\n             GetShipmentLabel = False<\/span>\r\n     End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
        Listing 6: Prozedur zum Holen des Versandlabels<\/span><\/b><\/p>\n
        Die Ergebnisse kann man nach dem Aufruf aus den öffentlichen Eigenschaften der Klasse auslesen.<\/p>\n
        Auch die Funktion HTTPRequest <\/b>haben wir in die Klasse integriert, diese brauchen wir aber nicht erneut abzubilden, da sie der oben vorgestellten Variante entspricht.<\/p>\n
        Erstellen eines Versandlabels über die Klasse clsShipment<\/h2>\n
        Um die Klasse nun zu nutzen, verwenden wie die Prozedur, die wir in Listing 7 dargestellt haben. Diese deklariert eine Objektvariable namens objShipment <\/b>auf Basis der Klasse clsShipment<\/b>. Dann erstellt sie ein Objekt auf Basis dieser Klasse und referenziert es mit objShipment<\/b>.<\/p>\n
        Public Function <\/span>CreateJSONRequest() As String<\/span>\r\n     Dim <\/span>objShipment As <\/span>clsShipment\r\n     Dim <\/span>bolProductive As Boolean<\/span>\r\n     Set<\/span> objShipment = New<\/span> clsShipment\r\n     bolProductive = False<\/span>\r\n     With<\/span> objShipment\r\n         .Produkt = \"V01PAK\"\r\n         .BillingNumber = GetBillingNumber(bolProductive)\r\n         .RefNo = \"Order No. 1234\"\r\n         .Shipper_Name1 = \"Minhorst und Minhorst GbR\"\r\n         .Shipper_AddressStreet = \"Borkhofer Str. 17\"\r\n         .Shipper_PostalCode = \"47137\"\r\n         .Shipper_City = \"Duisburg\"\r\n         .Shipper_Country = \"DEU\"\r\n         .Shipper_Email = \"andre@minhorst.com\"\r\n         .Shipper_Phone = \"0171-3145654\"\r\n         .Consignee_Name1 = \"Maria Musterfrau\"\r\n         .Consignee_AddressStreet = \"Kurt-Schumacher-Str. 20\"\r\n         .Consignee_AdditionalAddressInformation1 = \"Apartment 107\"\r\n         .Consignee_PostalCode = \"53113\"\r\n         .Consignee_City = \"Bonn\"\r\n         .Consignee_Country = \"DEU\"\r\n         .Consignee_Email = \"maria@musterfrau.de\"\r\n         .Consignee_Phone = \"+ 987654321\"\r\n         .Details_Dim_Uom = \"mm\"\r\n         .Details_Dim_Height = 100\r\n         .Details_Dim_Length = 200\r\n         .Details_Dim_Width = 150\r\n         .Details_Weight_Uom = \"g\"\r\n         .Details_Weight_Value = 500\r\n         .PathPDF = CurrentProject.Path & \"\\Test1.pdf\"\r\n         .PrintFormat = \"910-300-600\"\r\n         .Productive = False<\/span>\r\n         .Validate = False<\/span>\r\n         If <\/span>.GetShipmentLabel = True<\/span> Then<\/span>\r\n             MsgBox<\/span> \"Erstellung erfolgreich: \" & vbCrLf<\/span> & vbCrLf<\/span> & .Response\r\n             OpenDocument .PathPDF\r\n         Else<\/span>\r\n             MsgBox<\/span> \"Erstellung nicht erfolgreich: \" & vbCrLf<\/span> & vbCrLf<\/span> & .Response\r\n         End If<\/span>\r\n     End With<\/span>\r\nEnd Function<\/span><\/pre>\n
        Listing 7: Verwendung der Klasse clsShipment<\/span><\/b><\/p>\n
        Nun stellen wir die Eigenschaften der Klasse für das Versandlabel ein. Als Erstes geben wir die allgemeinen Informationen an, also das zu erstellende Produkt, die Abrechnungsnummer und die Referenznummer.<\/p>\n
        Dann folgen der Name des Versenders und seine übrigen Daten – Straße, PLZ, Stadt und Land. Das Land geben wir als dreistelligen Ländercode an. Die verfügbaren Codes sind im Beispielcode abgebildet. Danach fügen wir noch eine E-Mail-Adresse sowie die Telefonnummer des Absenders hinzu.<\/p>\n
        Anschließend tragen wir die Adressdaten des Empfängers des Pakets ein, deren Aufbau weitgehend denen des Absenders entspricht. Schließlich folgen noch die Abmessungen des Pakets (Höhe, Länge und Breite) sowie das Gewicht, beides jeweils mit der verwendeten Einheit.<\/p>\n
        Schließlich folgen die für das Anlegen notwendigen Daten: PathPDF <\/b>nimmt den Pfad für das zu erstellende PDF-Dokument auf und PrintFormat <\/b>eines der verfügbaren Printformate (diese sind ebenfalls im Quellcode der Klasse für die Property Let<\/b>-Prozedur angegeben).<\/p>\n
        Mit Productive <\/b>geben wir an, ob wir den Sandbox-Modus verwenden oder die Produktivplattform. Mit Validate <\/b>geben wir an, ob wir nur testen wollen, ob die Daten gültig sind.<\/p>\n
        Schließlich rufen wir die Funktion GetShipmentLabel <\/b>als Kriterium einer If…Then<\/b>-Bedingung auf. Liefert diese den Wert True <\/b>zurück, geben wir eine entsprechende Erfolgsmeldung aus und öffnen das erstellte Dokument (siehe Bild 13). Im Falle eines Misserfolgs teilen wir dies ebenfalls per Meldungsfenster mit.<\/p>\n
        \"Meldung<\/p>\n
        Bild 13: Meldung im Erfolgsfall<\/span><\/b><\/p>\n
        Erweitern der Versandinformationen<\/h2>\n
        Die hier vorgestellte Lösung enthält im Wesentlichen die mindestens erforderlichen Angaben für das Verwenden eines Pakets. Wenn Du weitere Elemente aus dem Data Schema der DHL hinzufügen möchtest, erhältst Du hier noch eine kurze Anleitung dazu.<\/p>\n
        Angenommen, Du möchtest für den Shipper auch noch das Feld name2<\/b> verwenden. Dann sind die folgenden Schritte nötig. <\/p>\n
        Du fügst dem Klassenmodul clsShipment <\/b>eine private Variable für diesen Wert hinzu:<\/p>\n
        Private <\/span>m_Shipper_Name2 As String<\/span><\/pre>\n
        Dann legst Du eine entsprechende Getter- und Setter-Prozedur an:<\/p>\n
        Public Property Let <\/span>Shipper_Name2(str As String<\/span>)\r\n     m_Shipper_Name2 = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Shipper_Name2() As String<\/span>\r\n     Shipper_Name2 = m_Shipper_Name2\r\nEnd Property<\/span><\/pre>\n
        Damit ist gewährleistet, dass die Daten in der Klasse landen. Nun wollen wir diese verarbeiten.<\/p>\n
        Dazu erweiterst Du die Funktion CreateJSONRequest<\/b> an der entsprechenden Stelle um eine If…Then<\/b>-Bedingung, die prüft, ob der Wert enthalten ist, und legst diesen dann als neues Element an:<\/p>\n
        ...\r\ndicShipper.Add \"name1\", m_Shipper_Name1\r\nIf <\/span>Not<\/span> Len<\/span>(m_Shipper_Name2) = 0 Then<\/span>\r\n     dicShipper.Add \"name2\", m_Shipper_Name2\r\nEnd If<\/span>\r\ndicShipper.Add \"addressStreet\", m_Shipper_AddressStreet\r\n...<\/pre>\n
        Im Aufruf der Funktion fügst Du nun den Wert für Name2 <\/b>hinzu:<\/p>\n
        .Shipper_Name2 = \"André Minhorst\"<\/pre>\n
        Damit haben wir alle Schritte erledigt, die nötig sind. Praktisch ist, dass wir beim Zusammenstellen des JSON-Dokuments nicht darauf achten müssen, ob wir hinten ein Komma anfügen, ob wir einfache oder doppelte Anführungszeichen setzen müssen und so weiter.<\/p>\n
        Das Zusammenstellen des JSON-Dokuments über das Objektmodell ist wesentlich einfacher.<\/p>\n
        Zusammenfassung und Ausblick<\/h2>\n
        Mit dieser Lösung kannst Du beliebigen Anwendungen die Funktion zum Erstellen von DHL-Versandetiketten hinzufügen.<\/p>\n
        Dabei haben wir eine Basisversion geschaffen, die Du nach Wunsch um weitere Eigenschaften erweitern kannst – beispielsweise um weitere Absender- und Empfängerdaten oder auch um alternative Empfängerarten. Hier stehen verschiedene zur Verfügung:<\/p>\n