<\/p>\n
Bereits im Jahr 2009 haben wir gezeigt, wie Sie von Access aus Daten von ebay auslesen und selbst Angebote einstellen. über die Jahre ändern sich jedoch die Mechanismen einer solchen Online-Schnittstelle, also schauen wir uns in diesem Beitrag an, wie der aktuelle Zugriff auf ebay aussieht und wie Sie diesen von einer Access-Anwendung aus realisieren. Dazu legen wir einen neuen Benutzer- und Entwickler-Account an und erstellen dann die notwendigen Objekte, um von Access aus auf die Daten zuzugreifen.<\/b><\/p>\n
Für das Verständnis der folgenden Abhandlung ist es wichtig zu wissen, dass Sie sowohl einen normalen eBay-Account als auch einen Entwickler-Account benötigen. <\/p>\n
Falls Sie noch kein ebay-Konto haben, öffnen Sie einfach die ebay-Seite unter www.ebay.de<\/b>. Dort finden Sie ganz unten unter Kaufen|Neu anmelden bei ebay <\/b>alle notwendigen Informationen. Kurz gefasst klicken Sie dort auf Jetzt bei eBay anmelden <\/b>und landen auf der Seite signin.ebay.de<\/b>. Hier geben Sie Ihre Daten auf der Registerseite Neu anmelden <\/b>ein (s. Bild 1).<\/p>\n
![\"Neu](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_001.png\")
<\/p>\n
Bild 1: Neu registrieren bei ebay<\/span><\/b><\/p>\n Sie erhalten dann einen eindeutigen, automatisch generierten Benutzernamen wie andminhors_0<\/b>, den Sie aber auch durch einen selbst gewählten Benutzernamen überschreiben können. Damit sind die Arbeiten auf dieser Seite bereits erledigt. Die meisten allgemeinen Informationen finden Sie nun im Bereich Mein eBay<\/b>.<\/p>\n Nun öffnen Sie die Webseite developer.ebay.com <\/b>und damit das ebay-Entwicklerprogramm. Auch hier registrieren wir uns zunächst, und zwar durch einen Klick auf Sign In\/Join<\/b>. Auch dort nutzen wir ein Formular, um unsere Daten einzugeben (s. Bild 2). Damit wir die beiden Benutzer nachher unterscheiden können, habe ich dem Benutzernamen beim Developer-Programm die Zeichenfolge _api <\/b>angehängt.<\/p>\n Bild 2: Neu registrieren als Developer bei ebay<\/span><\/b><\/p>\n Im folgenden Dialog geben Sie für die Vergabe der sogenannten Application Keys<\/b>, die Sie später benötigen, den Namen der geplanten Anwendung ein – hier kurz und bündig accessBay<\/b> (s. Bild 3). Nun erscheinen unten Links zum Erstellen von Keysets für Sandbox- und Production-Modus. Sie entscheiden selbst, ob Sie zunächst in der Sandbox üben wollen oder direkt auf echte ebay-Daten zugreifen wollen.<\/p>\n Bild 3: Anwendungsname angeben<\/span><\/b><\/p>\n Nach der Auswahl des Eintrags Production fragt ebay einige weitere Daten zu Ihrer Person ab, um Sie kontaktieren zu können, falls es im Rahmen der Benutzung der Keys zu Problemen kommt (s. Bild 4).<\/p>\n Bild 4: Angabe weiterer Informationen<\/span><\/b><\/p>\n Danach erhalten Sie eine übersicht, über die Sie wahlweise auch noch ein Keyset für den Bereich erstellen können, den Sie noch nicht berücksichtigt haben – also wahlweise Sandbox <\/b>oder Production<\/b> (s. Bild 5). Gleichzeitig weist ebay im Falle des Production-KeySet darauf hin, dass Sie 5.000 Aufrufe pro Tag an die ebay-Api absetzen können. Für mehr ist eine Ansicht der Anwendung durch das ebay-Team erforderlich.<\/p>\n Bild 5: übersicht mit den Application Keys für den Sandbox- und für den Production-Modus<\/span><\/b><\/p>\n Nun benötigen Sie noch einen User Token für das Keyset, das Sie verwenden möchten. Dazu klicken Sie rechts neben App ID <\/b>auf den Link User Tokens<\/b>.<\/p>\n Der Clou des User Tokens ist, dass es sich dabei um einen Schlüssel handelt, der im Kontext eines ebay-Benutzerkontos erstellt wird und der sich auf die zu programmierende Anwendung bezieht. Da wir eine Anwendung nur für uns selbst programmieren möchten, ist dies die richtige Option für uns. Die Alternative wäre, einen Token anzufragen, der eine Anwendung ermöglicht, die beliebige ebay-Nutzer verwenden können, ohne dass jeder einzelne sich einen User Token holen muss – die Benutzer müssen sich dann lediglich selbst anmelden.<\/p>\n Den Token erhalten wir über den Dialog aus Bild 6. Hier klicken Sie auf Sign in to Production <\/b>(sofern Sie einen Token für den Production-Modus anfragen – sonst würde hier stehen Sign in to Sandbox<\/b>. Dazu müssten Sie allerdings auch noch einen neuen Sandbox-User anlegen). Die gewünschte Umgebung können Sie über die Optionen oben auf der Seite auswählen.<\/p>\n Bild 6: Erstellen eines User Tokens<\/span><\/b><\/p>\n Im folgenden Dialog fragt ebay nach weiteren Daten zu Ihrer Person, also zu der Person, die das Entwickler-Konto nutzt. In diesem Fall werden die bestehenden Daten um die Adressdaten ergänzt.<\/p>\n Anschließend erscheint der Anmeldedialog der ebay-Seite selbst, also nicht der der Entwicklerplattform. Hier melden Sie sich nun mit den Zugangsdaten des eingangs erstellten (oder bereits vorhandenen) ebay-Benutzers an, in dessen Namen die App auf ebay zugreifen soll.<\/p>\n Im folgenden Dialog klicken Sie noch auf I agree <\/b>und erhalten dann eine Seite später Zugriff auf Ihren User Token, mit dem Sie im Namen des angegebenen ebay-Benutzerkontos über Ihre App auf ebay zugreifen (s. Bild 8). Der Token ist die recht lange, kryptische Zeichenfolge, die Sie für folgende Anwendungszwecke immer komplett benötigen.<\/p>\n Bild 7: Registrierung eines Sandbox-Users<\/span><\/b><\/p>\n Damit haben Sie alle Daten zusammen, die Sie für den Zugriff von einer Access-Datenbankanwendung auf ebay benötigen. Nun erstellen wir die Access-Anwendung selbst und programmieren eine kleine Benutzeroberfläche sowie den Code für den Zugriff auf die ebay-Schnittstelle per XML.<\/p>\n Das Anlegen eines Sandbox-Users erledigen Sie ebenfalls vom obigen Dialog aus. Dort wählen Sie unter Environment <\/b>die Option Sandbox <\/b>und finden unter der Schaltfläche Sign in to Sandbox <\/b>den Link Register a new Sandbox user <\/b>vor. Der Dialog hier sieht natürlich anders aus als der zum Registrieren eines „echten“ ebay-Benutzers (s. Bild 7). Hier sind nur wenige Informationen nötig, dafür aber auch einige, die Sie bei der herkömmlichen Registrierung nicht erhalten. Wichtig für Entwickler, die gegebenenfalls eine App für den Zugriff auf andere als die deutsche ebay-Seite bauen wollen, ist die Option Registration Site<\/b>. Hier können Sie auch United States (US)<\/b>, Motors <\/b>oder andere Länder auswählen. Diese Option werden Sie später in der Tabelle tblOptionen <\/b>im Feld SiteID <\/b>vorfinden.<\/p>\n Bild 8: Dialog mit dem fertigen User Token<\/span><\/b><\/p>\n Merken Sie sich, dass der Benutzername des Sandbox-Users mit TESTUSER_ <\/b>beginnt.<\/p>\n Nun haben wir bereits einige Daten, die wir der Developer-Seite von ebay entnehmen und in unserer Anwendung speichern wollen – die DevID<\/b>, AppID<\/b>, CertID <\/b>und den Token <\/b>jeweils für einen Produktiv- und einen Sandbox-Account. Dazu legen wir eine Tabelle namens tblOptions<\/b> an, die im Entwurf wie in Bild 9 aussieht.<\/p>\n Bild 9: Tabellen zum Speichern der Optionen<\/span><\/b><\/p>\n Neben den Account-Daten nimmt die Tabelle noch einige weitere Informationen auf. Dazu gehört etwa ein Ja\/Nein<\/b>-Feld namens Sandbox<\/b>, das festlegt, ob Sie gerade den Sandbox- oder den Produktiv-Account für den Zugriff über die Anwendung nutzen wollen.<\/p>\n Weitere Felder legen allgemeine Eigenschaften für den Zugriff auf die ebay-Plattform fest, zum Beispiel um zu definieren, wie diese auf die übergabe fehlerhafter XML-Elemente in Anfragen reagieren soll, in welcher Sprache Fehlermeldungen auszugeben sind, in welcher Version die XML-Anfragen formuliert sind, auf welche ebay-Seite zugegriffen werden soll und welche URLs dazu verwendet werden – Letzteres jeweils wieder für den Sandbox- und den Production-Betrieb.<\/p>\n Und auch das Land, in dessen Kontext die Abfrage abgesetzt wird, und die Währung benötigen wir später zum Zusammenstellen der Anfragen.<\/p>\n Damit Sie die Einstellungen komfortabel bearbeiten können, legen wir ein passendes Formular namens frmOptionen <\/b>an (s. Bild 10). Es enthält die Tabelle tblOptionen<\/b> als Datenherkunft und zeigt alle Felder dieser Tabelle an – aufgeteilt in verschiedene Bereiche.<\/p>\n Bild 10: Formular für die Eingabe der Optionen<\/span><\/b><\/p>\n Mit dem Kontrollkästchen, das an das Feld Sandbox gebunden ist, legen Sie fest, ob Sie gerade mit den Sandbox- oder den Produktiv-Daten arbeiten möchten.<\/p>\n Je nach Auswahl werden zur besseren Kennzeichnung die nicht verwendeten Elemente in den Bereichen Sandbox-Account <\/b>beziehungsweise Production-Account <\/b>deaktiviert. Wenn Sie nun die Informationen von der ebay-Developer-Webseite in die entsprechenden Felder des Formulars übertragen, sind wichtige Voraussetzungen für den Zugriff schon einmal gegeben.<\/p>\n Anschließend schauen wir und die übrigen benötigten Werte an:<\/p>\n ebay bietet verschiedene Programmierschnittstellen an, die Sie mit entsprechenden XML-Anfragen aufrufen können. In diesem Artikel schauen wir uns zwei davon an: die Shopping-API, die den Zugriff auf angebotene Artikel erlaubt, sowie die Trading-API, mit der Sie selbst Artikel einstellen und alle weiteren Aufgaben erledigen können, die mit dem Handeln auf der ebay-Plattform zu tun haben.<\/p>\n Die Shopping-API erlaubt beispielsweise das Suchen nach Artikeln. Um dies zu testen, wollen wir die gefundenen Artikel in einer Tabelle speichern, die wie in Bild 11 aussieht.<\/p>\n Bild 11: Tabelle zum Speichern von Suchergebnissen<\/span><\/b><\/p>\n Das Formular zum Eingeben des Suchbegriffes und zur Ausgabe der Suchergebnisse besteht aus Haupt- und Unterformular. Das Unterformular verwendet die Tabelle tblSuchergebnisse <\/b>als Datenherkunft und zeigt die drei Felder Artikel <\/b>und Preis <\/b>an (s. Bild 12). Außerdem stellen wir die Eigenschaft Standardansicht <\/b>auf den Wert Datenblatt <\/b>ein.<\/p>\n Bild 12: Unterformular zur Anzeige der Suchergebnisse<\/span><\/b><\/p>\n Das Hauptformular enthält logischerweise das Unterformular. Außerdem soll es drei Steuerelemente zur Festlegung der Suchkriterien bieten:<\/p>\n Da die Parameter möglicherweise beim nächsten Aufruf nochmals verwendet werden sollen, wollen wir diese auch in der Tabelle tblOptionen <\/b>speichern.<\/p>\n Dazu fügen Sie dieser die drei Felder Sortierung<\/b>, AnzahlTreffer <\/b>und Suchbegriff <\/b>hinzu und binden erst das Formular frmArtikelsuche <\/b>über die Eigenschaft Datenherkunft <\/b>an die Tabelle tblOptionen <\/b>und dann die drei Steuerelemente des Formulars an die neu hinzugefügten Felder.<\/p>\n Die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>stellen Sie für das Hauptformular auf den Wert Nein<\/b>, die Eigenschaft Automatisch zentrieren <\/b>auf Ja <\/b>ein.<\/p>\n Wir fügen dem Formular außerdem drei Schaltflächen hinzu: Die erste startet die Suche und heißt cmdSuchen<\/b>, die zweite soll den aktuell markierten Eintrag im Unterformular bei ebay öffnen und heißt cmdBeiEbayAnsehen <\/b>und die dritte schließt das Formular (cmdOK<\/b>). Das Formular sieht im Entwurf wie in Bild 13 aus.<\/p>\n Bild 13: Hauptformular für die Suche nach ebay-Artikeln<\/span><\/b><\/p>\n Nun brauchen wir nur noch ein wenig VBA-Code, der uns aus den Angaben in den drei Steuerelementen eine XML-Anfrage zusammenstellt, diese an ebay schickt und das Ergebnis in die Tabelle tblSuchergebnisse <\/b>schreibt.<\/p>\n Den Start macht die Schaltfläche cmdSuche<\/b>, über die wir die Suche aufrufen. Die für das Ereignis Beim Klicken <\/b>hinterlegte Ereignisprozedur finden Sie in Listing 1.<\/p>\n <\/p>\n Listing 1: Starten der Suche über die Schaltfläche cmdSuchen<\/span><\/b><\/p>\n Diese Methode löscht zunächst alle in der Tabelle tblSuchergebnisse <\/b>gespeicherten Einträge. Dann speichert sie den Suchbegriff auf dem Textfeld txtSuchbegriff <\/b>in der Variablen strSuchbegriffe<\/b>. Ist das Feld leer beziehungsweise enthält es den Wert Null<\/b>, wird dank der Funktion Nz <\/b>eine leere Zeichenkette gespeichert.<\/p>\n Ist dies der Fall, meldet die Prozedur, dass noch kein Suchbegriff eingegeben wurde, und bricht die Prozedur ab. Anderenfalls ruft sie die Funktion FindItemsAdvanced <\/b>auf. Diese soll die Suche ausführen und die Ergebnisse in der Tabelle tblSuchergebnisse <\/b>speichern, damit der anschließende Aufruf der Requery<\/b>-Methode des Unterformulars sfmSuchergebnis.Form <\/b>diese im Unterformular anzeigt.<\/p>\n Diese Funktion ist für das Zusammenstellen einer XML-Anfrage verantwortlich, die per HTTP-Request an die ebay-API übergeben wird und ein Ergebnis in Form eines XML-Dokuments zurückliefern soll. Dieses soll die Funktion dann mit einer weiteren Hilfsprozedur auswerten und die Ergebnisse in der Tabelle tblSuchergebnisse <\/b>speichern.<\/p>\n Bei der vorherigen Version unserer Artikelabfrage von 2009 konnte man noch per einfachem REST-Aufruf, also einer einfachen URL mit ein paar Parametern, auf die Suche nach Artikeln zugreifen. Diese ist nun seit einigen Jahren veraltet und die dazu verwendeten Funktionen wurden aus der Shopping-Api in die Finding-Api übertragen.<\/p>\n Informationen über den grundlegenden Aufbau eines Requests an die Finding-API erhalten Sie unter folgender Adresse:<\/p>\n Das heißt für uns, dass wir nicht mehr mit einer einfachen URL weiterkommen, die wir an ebay schicken, sondern wir müssen ein XML-Dokument mit den erforderlichen Informationen zusammenstellen.<\/p>\n Die speziellen Informationen über den Aufruf der API-Funktion findItemsAdvanced <\/b>finden Sie hier:<\/p>\n Die Funktion finden Sie in Listing 2. Sie deklariert jeweils ein Objekt des Typs DOMDocument<\/b>: objRequest <\/b>nimmt die XML-Anfrage auf, objResponse <\/b>die XML-Antwort. strAppID <\/b>soll die AppID <\/b>für den aktuellen Einsatzzweck, also Sandbox oder Production, aufnehmen, die in der Tabelle tblOptionen <\/b>gespeichert ist. intTrefferMax<\/b> ist die über die Benutzeroberfläche festgelegte maximal gewünschte Anzahl an Suchergebnissen. intAnzahl<\/b> soll die tatsächlich für die aktuell einzulesende Seite zu ermittelnde Anzahl der Suchergebnisse aufnehmen. Wenn der Benutzer beispielsweise 150 Suchergebnisse anfordert und der Wert aus cintAnzahlSeite <\/b>lautet 100<\/b>, wird intAnzahl <\/b>beim Aufruf der ersten Seite den Wert 100 <\/b>und beim Aufruf der zweiten Seite den Wert 50 <\/b>aufnehmen. intSeite <\/b>enthält die Nummer der aktuell einzulesenden Seite und intSeitenGesamt <\/b>die maximale Anzahl der einzulesenden Seiten. Die Variable strURL <\/b>nimmt die URL des aufzurufenden Dienstes auf. Die Variable intAnzahlSeite <\/b>speichert die Anzahl der Suchergebnisse, die je Seite zurückgeliefert werden sollen. Sie wird als Erstes gefüllt, und zwar mit dem Wert des Feldes AnzahlSeite <\/b>der Tabelle tblOptionen<\/b>, die ja an das Formular gebunden ist.<\/p>\n Listing 2: Hauptfunktion zum Durchführen der Suche<\/span><\/b><\/p>\n Die erste If…Then…Else<\/b>-Bedingung prüft, ob aktuell der Sandbox-Modus aktiviert ist, und legt abhängig davon den Wert für die Variable strAppID <\/b>und den Wert für die Variable strURL <\/b>fest. Beide Werte werden aus den entsprechenden Feldern der Tabelle tblOptionen<\/b> gezogen, die an das Formular gebunden sind. intTrefferMax <\/b>füllt die Prozedur zunächst mit dem Wert aus dem Textfeld txtAnzahlTreffer<\/b>. Dann berechnet sie die Gesamtanzahl der Seiten. Dazu zieht sie von der vom Benutzer vorgegebenen Anzahl der Suchergebnisse den Wert 1 <\/b>ab, teilt das Ergebnis durch die Anzahl der Einträge je Seite aus der Konstanten cintAnzahlSeiten<\/b>, entfernt mit der Int<\/b>-Funktion die Nachkommastellen und addiert 1 <\/b>hinzu. Bei 150 <\/b>gewünschten Suchergebnissen kommt hier 2 <\/b>heraus, bei 99 <\/b>oder 100 <\/b>der Wert 1<\/b>. Wie man solch eine Formel ermittelt Man steckt einfach ein wenig Hirnschmalz hi-nein und experimentiert, bis alle denkbaren Konstellationen das richtige Ergebnis liefern.<\/p>\n Mit diesem Ergebnis können wir in das Abrufen der Ergebnisse über die Finding-API von ebay einsteigen. Dies erledigen wir entsprechend der ermittelten Werte seitenweise mit der vorgegebenen Anzahl von Einträgen je Seite, in diesem Fall jeweils 100<\/b>. Die For…Next<\/b>-Schleife durchläuft die Werte von 1 <\/b>bis intSeitenGesamt <\/b>und speichert den aktuellen Wert jeweils in der Variablen intSeite <\/b>für die aktuelle Seitenzahl.<\/p>\n Dabei ermittelt sie, wie viele Einträge beim Abruf der aktuellen Seite gelesen werden sollen. Wenn wir insgesamt 150 Einträge einlesen wollen, soll der erste Abruf 100 Einträge, der zweite aber nur noch 50 anfordern. Wenn also die Seitenzahl multipliziert mit der Anzahl der Einträge je Seite größer als die Anzahl der maximal gewünschten Treffer ist, berechnen wir die Anzahl der einzulesenden Elemente neu – und zwar, indem wir von der maximal gewünschten Gesamtzahl die Anzahl der bereits eingelesenen Seiten abziehen. Das Ergebnis landet dann in der Variablen intAnzahl<\/b>. Haben wir mit der aktuellen Seite noch nicht die maximale Anzahl der gewünschten Suchergebnisse eingelesen, füllt die Prozedur intAnzahl <\/b>mit dem Wert aus cintAnzahlSeite<\/b>.<\/p>\n Nun ruft die Prozedur die Funktion CreateFindItemsAdvancedRequest <\/b>auf und übergibt dieser einige Parameter, auf deren Basis die Funktion den Request im XML-Format zusammenstellen soll: den Suchbegriff, die AppID<\/b>, die gewünschte Anzahl für diese Abfrage sowie die aktuelle Seite (in diesem ersten Durchlauf 1<\/b>). Dies liefert einen Request zurück, der etwa so aussieht:<\/p>\n Das Root-Element heißt findItemsAdvancedRequest<\/b>. Der Suchbegriff im keywords<\/b>-Element lautet minhorst<\/b>, für die Menge der gelieferten Ergebnisse haben wir mit entriesPerPage <\/b>auf 100 <\/b>pro Seite festgelegt. Außerdem stellen wir mit pageNumber <\/b>ein, welche Seite des Ergebnisses der Request liefern soll.<\/p>\n Dieses XML-Dokument übersenden wir nun als ersten Parameter der Funktion FindingAPIRequest <\/b>an ebay – gemeinsam mit dem zweiten Parameter, der die zu verwendende API-Funktion betitelt (hier findItemsAdvanced<\/b>), und dem dritten Parameter, der mit strURL <\/b>die URL des Dienstes übermittelt. Das Ergebnis dieser Funktion speichern wir in der Variablen objResponse<\/b>. Wenn Sie das enthaltene Dokument ausgeben, sieht dieses etwa wie in Listing 3 aus.<\/p>\n Listing 3: Response-Dokument mit einem Suchergebnis<\/span><\/b><\/p>\n Hier interessiert uns zunächst das Root-Element find-Items-Ad-van-ced-Response<\/b>, das wir mit der SelectSingleNode<\/b>-Funktion des Objekts objResponse <\/b>referenzieren. Dieses benötigen wir, um es an die Funktion ProcessSearchResult <\/b>weiterzuleiten, welche die für uns interessanten Informationen aus den einzelnen item<\/b>-Elementen des Dokuments ausliest – zum Beispiel den Titel des Artikels sowie den Preis. Beide sollen in der weiter oben vorgestellten Tabelle tblSuchergebnisse <\/b>landen.<\/p>\n Außerdem ist der untere Teil des Dokuments sehr inte-ressant für uns: Hier stecken nämlich die Informationen, wie viele Seiten uns erwarten, wenn wir die angegebene Anzahl der Suchergebnisse pro Seite abrufen. Diese Information steckt im Element findItemsAdvancedResponse\/paginationOutput\/totalPages<\/b>. Wir erhalten diese ebenfalls über die SelectSingleNode<\/b>-Methode. Allerdings speichern wir diesmal nicht das komplette Element in einer IXMLDomElement<\/b>-Variablen, sondern greifen mit der Eigenschaft NodeTypedValue <\/b>direkt auf den Inhalt dieses Elements zu. Sollte für die aktuell eingelesene Seite die Anzahl der Gesamtseiten aus intSeitenGesamt <\/b>bereits größer als die maximal verfügbaren Seiten sein, bricht die Prozedur an dieser Stelle ab. Es macht ja keinen Sinn, leere Seiten abzurufen, was sonst geschehen würde.<\/p>\n Die Funktion CreateFindItemsAdvancedRequest <\/b>stellt eine einfache Suchanfrage zusammen (s. Listing 4). Dazu erwartet sie die folgenden Parameter:<\/p>\n Listing 4: Funktion zum Zusammenstellen der Suchanfrage<\/span><\/b><\/p>\n Die Funktion erstellt ein neues Objekt des Typs DOMDocument<\/b>, also ein XML-Dokument. Dieses speichert sie in der Variablen objRequest<\/b>. Die Funktion AddPI <\/b>ist eine kleine Hilfsfunktion, welche die folgende Zeile als erste Zeile des XML-Dokuments einfügt:<\/p>\n Diese Funktion sieht wie folgt aus:<\/p>\n Danach erstellt die Funktion CreateFindItemsAdvancedRequest <\/b>das Root-Element findItemsAdvancedRequest <\/b>(an dieser Stelle der Hinweis, dass Groß-\/Kleinschreibung bei Verwendung von Web-APIs mit XML-Dokumenten essentiell ist). Die Funktion CreateSubElement<\/b> nimmt uns eine Menge Arbeit ab, denn sie erzeugt IXMLDOMElement<\/b>-Elemente (s. Listing 5). Dazu übergeben wir ihr drei Parameter:<\/p>\n Listing 5: Funktion zum Erstellen eines XML-Elements<\/span><\/b><\/p>\n Die Funktion liefert ein Objekt des Typs IXMLDOMElement <\/b>zurück, das wir referenzieren und gegebenenfalls dazu nutzen können, weitere Unterelemente anzulegen. Die folgende Anweisung der Funktion CreateFindItems-AdvancedRequest <\/b>fügt dem Root-Element die Eigenschaft Neuen Entwickler-Account anlegen<\/h2>\n
![\"Neu](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_002.png\")
<\/p>\nApplication Keys holen<\/h2>\n
![\"Anwendungsname](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_003.png\")
<\/p>\n![\"Angabe](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_004.png\")
<\/p>\n![\"übersicht](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_005.png\")
<\/p>\nUser Token erstellen<\/h2>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_006.png\")
<\/p>\n![\"Registrierung](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_009.png\")
<\/p>\nSandbox-User anlegen<\/h2>\n
![\"Dialog](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_007.png\")
<\/p>\nTabelle zum Speichern der Accountdaten<\/h2>\n
![\"Tabellen](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_008.png\")
<\/p>\nFormular zum Bearbeiten der Einstellungen<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_010.png\")
<\/p>\n\n
Verschiedene APIs<\/h2>\n
Shopping-API: Artikel suchen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_011.png\")
<\/p>\n![\"Unterformular](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_012.png\")
<\/p>\n\n
![\"Hauptformular](\"..\/fileadmin\/_temp_\/2016_03\/pic_1042_013.png\")
<\/p>\nSuche programmieren<\/h2>\n
Private Sub <\/span>cmdSuchen_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strSuchbegriffe As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblSuchergebnisse\"\r\n strSuchbegriffe = Nz(Me!txtSuchbegriff)\r\n If <\/span>Len<\/span>(strSuchbegriffe) = 0 Then<\/span>\r\n MsgBox<\/span> \"Bitte geben Sie einen Suchbegriff ein.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n FindItemsAdvanced\r\n Me!sfmSuchergebnis.Form.Requery\r\nEnd Sub<\/span><\/pre>\nDie Funktion FindItemsAdvanced<\/h2>\n
<b>http:\/\/developer.ebay.com\/devzone\/finding\/Concepts\/MakingACall.html<\/b><\/pre>\n
http:\/\/developer.ebay.com\/devzone\/finding\/CallRef\/findItemsAdvanced.html<\/pre>\n
Public Function <\/span>FindItemsAdvanced()\r\n Dim <\/span>objRequest As <\/span>MSXML2.DOMDocument\r\n Dim <\/span>objResponse As <\/span>MSXML2.DOMDocument\r\n Dim <\/span>strAppID As String<\/span>\r\n Dim <\/span>intTrefferMax As Integer<\/span>\r\n Dim <\/span>intAnzahl As Integer<\/span>\r\n Dim <\/span>intSeite As Integer<\/span>\r\n Dim <\/span>intSeitenGesamt As Integer<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>intAnzahlSeite As Integer<\/span>\r\n intAnzahlSeite = Me!AnzahlSeite\r\n If <\/span>Me!Sandbox Then<\/span>\r\n strAppID = Me!AppID_Sandbox\r\n strURL = Me!RequestURLFinding_Sandbox\r\n Else<\/span>\r\n strAppID = Me!AppID_Production\r\n strURL = Me!RequestURLFinding_Production\r\n End If<\/span>\r\n intTrefferMax = Me!txtAnzahlTreffer\r\n intSeitenGesamt = Int((intTrefferMax - 1) \/ intAnzahlSeite) + 1\r\n For intSeite = 1 To intSeitenGesamt\r\n If <\/span>intSeite * intAnzahlSeite > intTrefferMax Then<\/span>\r\n intAnzahl = intTrefferMax - (intSeite - 1) * intAnzahlSeite\r\n Else<\/span>\r\n intAnzahl = intAnzahlSeite\r\n End If<\/span>\r\n Set<\/span> objRequest = CreateFindItemsAdvancedRequest(Me!txtSuchbegriff, intAnzahl, intSeite)\r\n Set<\/span> objResponse = FindingAPIRequest(objRequest, \"findItemsAdvanced\", strAppID, strURL)\r\n Debug.Print<\/span> FormatXML(objResponse.XML)\r\n ProcessSearchResult objResponse.SelectSingleNode(\"findItemsAdvancedResponse\")\r\n If intSeitenGesamt >= _\r\n objResponse.SelectSingleNode(\"findItemsAdvancedResponse\/paginationOutput\/totalPages\").nodeTypedValue Then\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> intSeite\r\nEnd Function<\/span><\/pre>\n<xml version=\"1.0\">\r\n<findItemsAdvancedRequest xmlns=\"http:\/\/www.ebay.com\/marketplace\/search \/v1\/services\">\r\n <keywords>minhorst<\/keywords>\r\n <paginationInput>\r\n <entriesPerPage>100<\/entriesPerPage>\r\n <pageNumber>1<\/pageNumber>\r\n <\/paginationInput>\r\n<\/findItemsAdvancedRequest><\/pre>\n
<xml version=\"1.0\">\r\n<findItemsAdvancedResponse xmlns=\"http:\/\/www.ebay.com\/marketplace\/search\/v1\/services\">\r\n <ack>Success<\/ack>\r\n <version>1.13.0<\/version>\r\n <timestamp>2016-04-28T08:55:38.247Z<\/timestamp>\r\n <searchResult count=\"1\">\r\n <item>\r\n <itemId>371579033519<\/itemId>\r\n <title>Microsoft Office 365 & Access 2016 9781305870611 by Mary Z. Last, Paperback, NEW<\/title>\r\n <globalId>EBAY-DE<\/globalId>\r\n <primaryCategory>\r\n <categoryId>171265<\/categoryId>\r\n <categoryName>Computer & Internet<\/categoryName>\r\n <\/primaryCategory>\r\n <galleryURL>http:\/\/thumbs4.ebaystatic.com\/m\/mQUV5CKwKUtkjzHjCF4CSnQ\/140.jpg<\/galleryURL>\r\n <viewItemURL>http:\/\/www.ebay.de\/itm\/Microsoft-Office-365-Access-2016-9781305870611-by-Mary-Z\r\n -Last-Paper back-NEW-\/371579033519<\/viewItemURL>\r\n <paymentMethod>PayPal<\/paymentMethod>\r\n <autoPay>true<\/autoPay>\r\n <postalCode>60954<\/postalCode>\r\n <location>Vereinigte Staaten von Amerika<\/location>\r\n <country>US<\/country>\r\n <shippingInfo>\r\n <shippingServiceCost currencyId=\"EUR\">0.0<\/shippingServiceCost>\r\n <shippingType>Free<\/shippingType>\r\n <shipToLocations>DE<\/shipToLocations>\r\n <\/shippingInfo>\r\n <sellingStatus>\r\n <currentPrice currencyId=\"EUR\">139.98<\/currentPrice>\r\n <convertedCurrentPrice currencyId=\"EUR\">139.98<\/convertedCurrentPrice>\r\n <sellingState>Active<\/sellingState>\r\n <timeLeft>P19DT23H43M50S<\/timeLeft>\r\n <\/sellingStatus>\r\n <listingInfo>...<\/listingInfo>\r\n <condition>\r\n <conditionId>1000<\/conditionId>\r\n <conditionDisplayName>Neu<\/conditionDisplayName>\r\n <\/condition>\r\n <isMultiVariationListing>false<\/isMultiVariationListing>\r\n <topRatedListing>true<\/topRatedListing>\r\n <\/item>\r\n <\/searchResult>\r\n <paginationOutput>\r\n <pageNumber>1<\/pageNumber>\r\n <entriesPerPage>1<\/entriesPerPage>\r\n <totalPages>5<\/totalPages>\r\n <totalEntries>5<\/totalEntries>\r\n <\/paginationOutput>\r\n <itemSearchURL>http:\/\/www.ebay.de\/sch\/i.html_nkw=Microsoft+Access+2016&_ddo=1&_ipg=1&_pgn=1<\/itemSearchURL>\r\n<\/findItemsAdvancedResponse><\/pre>\n
Erstellen der Suchanfrage<\/h2>\n
Public Function <\/span>CreateFindItemsAdvancedRequest(strSuchbegriffe As String<\/span>, intAnzahl As Integer<\/span>, _\r\n <\/span> intSeite As Integer<\/span>) As <\/span>MSXML2.DOMDocument\r\n Dim <\/span>objRequest As <\/span>MSXML2.DOMDocument\r\n Dim <\/span>objRoot As <\/span>MSXML2.IXMLDOMElement\r\n Dim <\/span>objPaginationInput As <\/span>MSXML2.IXMLDOMElement\r\n Set<\/span> objRequest = New<\/span> MSXML2.DOMDocument\r\n AddPI objRequest\r\n Set<\/span> objRoot = CreateSubElement(objRequest, \"findItemsAdvancedRequest\")\r\n CreateAttribute objRoot, \"xmlns\", \"http:\/\/www.ebay.com\/marketplace\/search\/v1\/services\"\r\n CreateSubElement objRoot, \"keywords\", strSuchbegriffe\r\n Set<\/span> objPaginationInput = CreateSubElement(objRoot, \"paginationInput\")\r\n CreateSubElement objPaginationInput, \"entriesPerPage\", CStr(intAnzahl)\r\n CreateSubElement objPaginationInput, \"pageNumber\", CStr(intSeite)\r\n Set<\/span> CreateFindItemsAdvancedRequest = objRequest\r\nEnd Function<\/span><\/pre>\n\n
<xml version=\"1.0\"><\/pre>\n
Public Sub <\/span>AddPI(objXML As <\/span>MSXML2.DOMDocument)\r\n Dim <\/span>objPI As <\/span>MSXML2.IXMLDOMProcessingInstruction\r\n Set<\/span> objPI = objXML.createProcessingInstruction(\"xml\", \"version=\"\"1.0\"\" encoding=\"\"utf-8\"\"\")\r\n objXML.appendChild objPI\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>CreateSubElement(objElement As Object<\/span>, strElementname As String<\/span>, Optional<\/span> strText As String<\/span>) _\r\n As <\/span>MSXML2.IXMLDOMElement\r\n Dim <\/span>strTypename As String<\/span>\r\n Dim <\/span>objDocument As <\/span>MSXML2.DOMDocument\r\n Dim <\/span>objXMLElement As <\/span>MSXML2.IXMLDOMElement\r\n strTypename = TypeName(objElement)\r\n Select Case strTypename\r\n Case <\/span>\"DOMDocument\"\r\n Set<\/span> objXMLElement = objElement.createElement(strElementname)\r\n objElement.appendChild objXMLElement\r\n Case <\/span>\"IXMLDOMElement\"\r\n Set<\/span> objDocument = objElement.ownerDocument\r\n Set<\/span> objXMLElement = objDocument.createElement(strElementname)\r\n objElement.appendChild objXMLElement\r\n End Select<\/span>\r\n If <\/span>Len<\/span>(strText) > 0 Then<\/span>\r\n objXMLElement.Text = strText\r\n End If<\/span>\r\n Set<\/span> CreateSubElement = objXMLElement\r\nEnd Function<\/span><\/pre>\n\n