<\/p>\n
Access steuert alles fern, was nicht bei Drei auf dem nächsten Baum ist – und diesmal ist eBay dran. Zwar liefert die Handelsplattform keine VBA-Schnittstelle, aber der versierte Access-Entwickler scheut auch nicht vor dem Anzapfen eines Webservice <\/span>zurück. Der von eBay bietet alle Möglichkeiten, die auch die Benutzeroberfläche im Browser liefert – und mehr. So können Sie den Webservice beispielsweise dazu nutzen, Artikel aus der Tabelle einer Warenwirtschaft in einem Rutsch online zu stellen. In diesem Beitrag beschäftigen wir uns jedoch erstmal mit der Suche nach Artikeln.<\/b><\/p>\n Wer schon einmal mit Webservices kommuniziert hat, kennt die eine oder andere Methode, mit der man dies erledigt. Die einfachste heißt REST und liefert auf eine HTTP-Anfrage, deren Parameter die Anfragedetails enthalten, ein XML-Dokument als Antwort.<\/p>\n Ebenfalls oft verwendet wird die Variante, bei der man bereits die Anfrage in ein XML-Dokument verpackt, das der Webservice auswertet und ebenfalls mit einem XML-Dokument beantwortet. In diesem Beitrag lernen Sie beide Varianten kennen, wobei REST sich einfacher testen lässt: Sie brauchen dazu nur die URL in den Browser einzutippen und erhalten direkt die passende Antwort im XML-Format.<\/p>\n REST ist allerdings kein Allheilmittel: Wer Artikel bei eBay einstellen möchte, wird schnell feststellen, dass eine URL-Zeile schnell unhandlich wird. An dieser Stelle versendet man seine Anfrage dann doch lieber als XML-Request.<\/p>\n Nur für Developer<\/p>\n Für den Zugriff auf die Webservices von eBay brauchen Sie in der Regel einen Developer-Account. Als Ausgangspunkt für das Anlegen eines solchen Kontos dient die Webadresse http:\/\/developer.ebay.com\/<\/b>. Hier klicken Sie auf den großen Join Now!<\/b>-Link und gelangen zum Formular aus Bild 1, dem Sie Ihre Daten anvertrauen müssen, um an einen eBay-Developer-Account zu gelangen. Was Sie hier mitnehmen, ist die Developer-User-ID und Ihr Kennwort.<\/p>\n Bild 1: Anlegen eines eBay-Developer-Accounts<\/span><\/b><\/p>\n Nach dem Registrieren landen Sie auf Ihrer Account-Page, von wo aus Sie alle weiteren Schritte durchführen können, die für den Zugriff auf den eBay-Webservice nötig sind (siehe Bild 2).<\/p>\n Bild 2: Die Steuerzentrale für eBay-Developer<\/span><\/b><\/p>\n Im Bereich application keys <\/b>können Sie nun zwei Sätze von Schlüsseln erstellen. Das erste Paar dient dem Zugriff auf die Sandbox von eBay, die prinzipiell eine Kopie von eBay ist und alle dort enthaltenen Funktionen zum Testen zur Verfügung stellt. Das zweite Paar verschafft Ihnen Zutritt zur echten eBay-Welt.<\/p>\n Ein Klick auf generate sandbox keys <\/b>erstellt die drei Schlüssel DEVID<\/b>, AppID <\/b>und CertID <\/b>in Form von GUIDs und zeigt diese direkt in Ihrer Schaltzentrale an. Mit der Schaltfläche generate production keys <\/b>beschaffen Sie sich den Schlüsselsatz für den produktiven Betrieb.<\/p>\n Nun fehlen nur noch wenige Details und Sie können den ersten Zugriff starten (genaugenommen könnten Sie das schon jetzt – aber wenn wir schon einmal dabei sind …): Klicken Sie dazu auf den Link Configure Settings <\/b>(erst für die Sandbox Keys<\/b>, dann für die Production Keys<\/b>) und dann im Bereich User Tokens <\/b>auf den Link User Tokens<\/b>. Der nächste Dialog informiert Sie darüber, dass noch keine User Tokens erzeugt wurden, und bietet dementsprechend einen Link namens Generate Token <\/b>an.<\/p>\n Dieser führt Sie überraschenderweise zu einem Anmeldedialog, den Sie wahrscheinlich in deutscher Sprache schon einmal gesehen haben – mit dem Unterschied, dass dort kein Titel wie Sign in to link your eBay account to <Firmenname><\/b> steht. Der Token wird nämlich im Kontext eines existierenden Benutzers vergeben.<\/p>\n Wenn Sie gerade einen User Token für den Sandbox-Betrieb erstellen möchten (davon zeugt in diesem Fall die URL signin.sandbox.ebay.com<\/b>), müssen Sie zunächst einen Benutzer anlegen, in dessen Kontext Sie dann den User Token erstellen. Das gelingt am schnellsten über einen Mausklick auf die Schaltfläche Register <\/b>und anschließendes Eintragen der gewünschten Daten. Prinzipiell legen Sie nun einen gewöhnlichen Benutzer an – mit der Besonderheit, dass dieser nur in der Sandbox tätig werden darf.<\/p>\n Wenn Sie den User Token für die produktive Umgebung erstellen möchten, brauchen Sie ebenfalls einen eBay-Account – diesmal allerdings einen, der auch in der realen Welt kaufen und verkaufen darf.<\/p>\n Nach dem Anmelden mit dem Sandbox- oder Production-Account erscheint nicht etwa die übliche Begrüßung durch eBay, sondern ein weiterer Dialog, der nach einer Bestätigung für das Erstellen des User Tokens im Kontext der für die Anmeldung verwendeten Benutzerdaten verlangt. Der nächste Dialog liefert dann die benötigten Schlüssel und den User Token im Überblick (siehe Bild 3).<\/p>\n Optionen-Tabelle<\/b><\/p>\n Wohin nun mit den gewonnenen Informationen Immerhin werden Sie diese in den folgenden Beispielen gelegentlich benötigen und wollen sie nicht immer wieder von der Account-Webseite kopieren. Keine Frage: Als Access-Entwickler erstellen Sie natürlich auf die Schnelle eine kleine Tabelle zum Speichern von Optionen. Dies geschieht oft in der Form, dass eine Tabelle nur die beiden Felder Optionsname <\/b>und Optionswert <\/b>enthält und jeder Datensatz ein Wertepaar aufnimmt. Sie können natürlich auch eine Tabelle erstellen, in der jedes Feld eine Option aufnimmt. Da die Anzahl der Optionen in diesem Fall konstant ist, kommt diese Variante hier zum Einsatz. Die Tabelle sieht in der Entwurfsansicht so aus wie in Bild 4. Für die einfache Verwaltung dieser Informationen legen Sie ein Formular wie in Bild 5 an.<\/p>\n Bild 3: Schlüssel und User Token<\/span><\/b><\/p>\n Bild 4: Tabelle mit den für den Zugriff auf die eBay-Webservices nötigen Daten<\/span><\/b><\/p>\n Bild 5: Formular für die Verwaltung der Accountdaten<\/span><\/b><\/p>\n Für die spätere Verwendung der in der Tabelle tblOptionen<\/b> gespeicherten Werte legen Sie vier kleine Funktionen an, die in Abhängigkeit vom Wert des Felds Sandbox<\/b> entweder den Sandbox- oder den Production-Wert der gefragten Option zurückliefern. Diese Routine sieht beispielsweise so aus:<\/p>\n Ob Sie im Sandbox- oder im Production-Modus arbeiten, stellen Sie mit der entsprechenden Optionsgruppe im Formular frmOptionen <\/b>ein; die Funktionen GetAppID<\/b>, GetCertID<\/b>, GetDevID <\/b>und GetUserToken <\/b>liefern dann jeweils den dafür vorgesehenen Schlüssel beziehungsweise Token.<\/p>\n Damit ausgerüstet können wir uns nun dem eigentlichen Ziel dieses Beitrags zuwenden: Dem Fernsteuern von eBay mittels Access-Anwendung und Webservice.<\/p>\n Artikel suchen<\/b><\/p>\n Die wohl meistgenutzte Funktion ist das Suchen von Artikeln. Damit Sie nicht denken, alles sei so einfach wie nachfolgend dargestellt, weisen wir an dieser Stelle darauf hin, dass es durchaus mehrere Möglichkeiten gibt, um die eBay-Artikel nach bestimmten Merkmalen zu durchsuchen.<\/p>\n So gibt es beispielsweise zwei unabhängige APIs namens Trading-API und Shopping-API (es gibt noch mehr, aber die sind in diesem Kontext eher uninteressant). Wir konzentrieren uns auf die Shopping-API, weil sie alle Anforderungen für die nachfolgenden Beispiele erfüllt.<\/p>\n Zusammensetzen der Anfrage-URL<\/b><\/p>\n Die URL zum Übermitteln der Anfrage an den eBay-Webservice setzt sich aus der eigentlichen Webadresse sowie aus den Parametern zusammen, die jeweils aus Parameter-Wertpaaren bestehen. Parameter und Wert trennt jeweils ein Gleichheitszeichen, die einzelnen Parameter-Wertpaare hält man durch das Kaufmanns-Und auseinander.<\/p>\n Es gibt jeweils einige Pflichtparameter und solche Parameter, welche den eigentlichen API-Aufruf betreffen. Informationen über die Pflichtparameter finden Sie in Kurzform in Tab. 1 sowie in ausführlicher Fassung unter [1].<\/p>\n Parameter<\/p>\n<\/td>\n Beschreibung<\/p>\n<\/td>\n<\/tr>\n<\/thead>\n Tab. 1: Einige der Parameter beim Aufruf von Funktionen der Shopping-API<\/span><\/b><\/p>\n Die Basis-URL heißt http:\/\/open.api.ebay.com\/shopping<\/b>. Dahinter fügen Sie, getrennt durch ein Fragezeichen (), die Parameterliste ein.<\/p>\n Beginnen wir mit einem einfachen Suchauftrag nach allen Artikeln, die Access Entwicklerbuch <\/b>im Namen führen. Dafür verwenden wir die API-Funktion FindItems<\/b>, die in [2] mit allen Parametern erläutert wird.<\/p>\n Die URL sieht anschließend so aus:<\/p>\n Die URL geben Sie im Browser ein und rufen die Seite auf. Das Ergebnis finden Sie in Bild 6. Es sieht wenig erbaulich aus: Zwar enthält der Aufruf für den Parameter responseencoding <\/b>den Wert XML<\/b>, aber irgendwie sehen die Suchergebnisse der richtigen eBay-Anwendung doch besser aus.<\/p>\n Bild 6: Das Ergebnis einer Abfrage mit bestimmten Suchbegriffen<\/span><\/b><\/p>\n XML-Antwort in lesbare Form bringen<\/b><\/p>\n Nun denn: Bringen wir ein wenig Licht ins Dunkel und lesen die relevanten Informationen aus diesem XML-Dokument heraus. Dazu brauchen Sie einen Verweis auf die Bibliothek Microsoft XML, v3.0 <\/b>oder höher und ein wenig Grundkenntnisse in der Behandlung von XML-Dateien mit dem Document Object Model<\/b>. Die finden Sie in konzentrierter Form im Beitrag XML-Dokumente mit VBA erstellen und lesen <\/b>(Shortlink 522).<\/p>\n Webservice-Anfrage per VBA<\/b><\/p>\n Bevor wir uns auf den XML-Code der Antwort des Webservice stürzen, müssen wir diesen zunächst einmal in den (VBA-)Griff bekommen. Wie schicken wir die Anfrage an den Webservices, und wo speichern wir die Antwort<\/p>\n Wer schon einmal unter VBA mit XML-Dokumenten gearbeitet hat, weiß, dass diese in einem Objekt des Typs DOMDocument <\/b>gespeichert werden. Also deklarieren wir ein solches:<\/p>\n Die URL speichern wir in einer einfachen String-Variablen, die wir folgendermaßen deklarieren:<\/p>\n Für den Beginn soll die URL ganz einfach im Ganzen als Zeichenkette zugewiesen werden:<\/p>\n Mit diesen beiden Werten füttern wir die kleine Funktion aus Listing 1, und zwar mit folgender, in eine If…Then<\/b>-Abfrage verpackten Anweisung:<\/p>\n Listing 1: Ermitteln eines XML-Dokuments als Ergebnis einer Webservice-Anfrage<\/p>\n <\/p>\n Die Funktion eBayRequest <\/b>erledigt nichts anderes, als das übergebene DOMDocument<\/b>-Objekt mit einigen Eigenschaften zu versehen – unter anderem die Request-URL – und das Ergebnis einzulesen. Dieses gibt die aufrufende Routine dann über die Eigenschaft XML <\/b>des Objekts objDocument <\/b>im Direktfenster aus.<\/p>\n Suchergebnis auswerten<\/b><\/p>\n Da wir nun ein brauchbares Ergebnis im XML-Format haben, werten wir dieses gleich per VBA aus. <\/p>\n Das Root-Element des Ergebnisses heißt FindItemsResponse <\/b>und enthält neben einigen allgemeinen Informationen wie dem Timestamp <\/b>die eigentlichen Artikelinformationen, die jeweils in einem eigenen Item<\/b>-Element untergebracht sind. Um die Eigenschaften der einzelnen Elemente zu ermitteln, müssen Sie diese per VBA-Code durchlaufen und die gewünschten Informationen abfragen.<\/p>\n Dies erledigt, in einfacher Form, die Funktion PrintArticles<\/b>. Sie erwartet lediglich das XML-Dokument in Form der Objektvariablen objDocument <\/b>als Parameter und wertet einige seiner Elemente aus. Dazu deklariert sie zwei Variablen des Typs IXMLDOMNode<\/b>. Das erste soll das Root-Element des Dokuments aufnehmen, also das Element FindItemsResponse<\/b>. Einen Verweis auf das Root-Element erhält man ganz einfach über die Eigenschaft documentElement <\/b>des XML-Dokuments.<\/p>\n Listing 2: Ausgabe der ermittelten Artikel<\/p>\n Dieses Element wiederum enthält die Item<\/b>-Elemente, von denen jedes genau einen Artikel repräsentiert. Mit der Abfrage selectNodes("Item") <\/b>des Root-Elements erhalten Sie eine Referenz auf die Auflistung aller im Root-Element enthaltenen Elemente namens Item<\/b>. Die Eigenschaft length <\/b>dieser Auflistung liefert die Anzahl der Einträge.<\/p>\n Über eine For Each<\/b>-Schleife durchläuft die Routine alle Einträge und ermittelt weitere Unterelemente, nämlich ItemID <\/b>(dies entspricht der Artikelnummer bei eBay) und Title<\/b>, also den Überschriftstext, den Sie bei eBay zu jedem Artikel finden. Die Eigenschaft nodeTypedValue <\/b>fördert den Inhalt von ItemID <\/b>und Title <\/b>zu Tage, was zu einem Ergebnis wie dem folgenden führt:<\/p>\n Ihnen als Leser von Access im Unternehmen brauchen wir nicht zu erklären, wie Sie diese Informationen statt ins Direktfenster direkt in eine Tabelle der Datenbank schreiben – stattdessen widmen wir uns interessanteren API-Funktionen.<\/p>\n Erweiterte Suche<\/b><\/p>\n Die einfache Suche mit der API-Funktion FindItems <\/b>hat einen großen Nachteil: Sie können damit eine Ergebnismenge mit maximal 50 Einträgen zurückliefern, aber nicht mehr und damit in vielen Fällen nicht alle Ergebnisse. Außerdem können Sie damit die im Ergebnis enthaltenen Informationen nicht beeinflussen.<\/p>\n Beides erledigen Sie mit der API-Funktion FindItemsAdvanced<\/b>, zu der Sie unter [3] weitere Informationen erhalten. Diese Funktion liefert zwar auch nur maximal 100 Artikel je Ergebnis, aber sie akzeptiert einen Parameter namens PageNumber<\/b>, mit dem Sie FindItemAdvanced<\/b>, falls es mehr als die angegebene Anzahl Ergebnisse je Seite enthält, auch die übrigen Ergebnisseiten entlocken können.<\/p>\n Wie dies funktioniert, zeigt die Routine aus Listing 3. Sie verwendet die API-Funktion FindItemsAdvanced<\/b>, um auch über mehrere Seiten verteilte Ergebnismengen zu ermitteln.<\/p>\n Listing 3: Beispiel für das Ermitteln mehrseitiger Ergebnislisten mit FindItemsAdvanced<\/p>\n Die Funktion ist so ausgelegt, dass Sie beim Aufruf lediglich die Suchbegriffe übergeben müssen, also etwa so:<\/p>\n Sie könnten die Funktion noch flexibler gestalten, indem Sie weitere Parameter in den Aufruf verlegen, aber für Beispielzwecke reicht dieser eine Parameter aus.<\/p>\n Die Routine FindItemsAdvanced <\/b>deklariert zunächst einige Variablen und weist dann die Werte für einige bei der Suche verwendete Parameter zu:<\/p>\n Die Routine setzt nun zunächst den Request zusammen und speichert diesen in der Variablen strRequest<\/b>. Einige der verwendeten Parameter stammen aus den oben beschriebenen Variablen, andere werden mit Get…<\/b>-Funktionen aus der Tabelle tblOptionen <\/b>eingelesen (wobei hier noch einige Werte mehr zum Einsatz kommen, also in der zu Beginn beschriebenen Fassung enthalten sind).<\/p>\n Mit diesem Ausdruck und dem Objekt objDocument <\/b>im Gepäck geht es dann zur bereits weiter oben beschriebenen Funktion eBayRequest<\/b>, die bestenfalls ein gefülltes XML-Dokument zurückliefert.<\/p>\n Ist das der Fall, sieht das Ergebnis so wie in Bild 7 aus, wobei wir hier aus Gründen der Übersichtlichkeit alle Artikel-Items bis auf einen entfernt haben. Zunächst geht es hier auch mehr um die Informationen, die sich am Ende des XML-Dokuments finden, und zwar die in den Elementen PageNumber<\/b>, TotalPages <\/b>und TotalItems <\/b>enthaltenen Werte. PageNumber <\/b>liefert dabei die aktuelle Seite, die mit unserem Aufruf aus strRequest <\/b>immer 1 <\/b>ist, da kein anderer Wert übergeben wurde. TotalPages <\/b>zeigt die Anzahl der Seiten insgesamt an und TotalItems <\/b>liefert die Anzahl der darin enthaltenen Artikel. Auch der übrige Aufbau unterscheidet sich von dem des Ergebnisses eines FindItem<\/b>-Requests: Die gefundenen Items werden nicht direkt als Unterelemente des Root-Elements geführt, sondern es liegen noch die zwei Ebenen SearchResult <\/b>und ItemArray <\/b>dazwischen. All dies muss man natürlich beim Auswerten des Ergebnisses beachten.<\/p>\n Bild 7: Ergebnis einer Abfrage mit der API-Funktion FindItemsAdvanced<\/span><\/b><\/p>\n Die Funktion aus Listing 3 prüft zunächst, ob eBayRequest<\/b> möglicherweise den Wert False <\/b>zurückliefert, was auf einen Misserfolg der Anfrage hindeutet. War die Anfrage erfolgreich, kann es aber immer noch sein, dass diese zwar ein XML-Dokument zurücklieferte, dieses aber wiederum eine Fehlermeldung enthält, weil beispielsweise kein Suchbegriff angegeben wurde. Das kann dann etwa so wie in Listing 4 aussehen. Für diesen Fall haben wir die Funktion eBayRequest <\/b>ein wenig erweitert: Sie prüft nun das Element Ack<\/b>, das den Wert Failure <\/b>aufweist, wenn es ein Problem mit dem Request gab, und gibt auch in diesem Fall den Wert False <\/b>zurück.<\/p>\n Listing 4: Ergebnis eines Requests an den eBay-Webservice mit fehlerhafter Parameterliste<\/p>\n Listing 4: eBay-Request mit erweiterter Fehlerprüfung<\/p>\n Wenn der Request ein XML-Dokument mit einer Items-Liste zurückgeliefert hat, prüft die Routine noch, ob das XML-Dokument auch Ergebnisse liefert. Falls nicht, verabschiedet es sich mit einem Meldungsfenster.<\/p>\n In allen anderen Fällen kommt die Do…While<\/b>-Schleife aus Listing 3 ins Rollen. Diese läuft so lange, bis der Wert von intPageNumber<\/b>, also der Nummer der aktuell gelieferten Seite, mit intTotalPages<\/b>, also der Gesamtzahl der Seiten übereinstimmt, wobei diese Prüfung am Ende der Schleife stattfindet, denn die benötigten Werte werden erst innerhalb der Schleife zum ersten Mal ermittelt.<\/p>\n Innerhalb der Schleife findet die Zuweisung von PageNumber <\/b>und TotalNumber <\/b>zu den entsprechenden Variablen statt und außerdem schreibt die Routine den Teil des Ergebnisdokuments mit den eigentlichen Artikelinformationen in ein weiteres Objekt des Typs IXMLDOMNode<\/b>, was zur weiteren Verarbeitung an die Routine ItemVerarbeiten <\/b>gegeben wird.<\/p>\n Diese Routine schauen wir uns im Anschluss an. Zunächst aber müssen wir noch die Frage klären, wie der Webservice erfährt, welche Seite des Ergebnisses er liefern soll.<\/p>\n Diese Funktion befindet sich in dem Teil, den die Zeile If intPageNumber < intTotalPages Then <\/b>einleitet.<\/p>\n Sind wir noch nicht bei der letzten Seite angelangt, erhöht die Routine hier intPageNumber <\/b>um eins, wodurch diese Variable beim Verarbeiten der ersten Seite beispielsweise den Wert 2 <\/b>erhält.<\/p>\n Die nächste Zeile erzeugt einen neuen Request, der aus dem ursprünglichen Request aus der Variablen strRequest<\/b> und einem weiteren Parameter besteht, der in diesem Fall so lautet:<\/p>\n Damit ruft die Routine erneut eBayRequest <\/b>auf, damit es das Antwortdokument für die jeweils folgende Seite des Requests liefert.<\/p>\n Wohin damit<\/b><\/p>\n Die Ergebnisse wollen Sie in irgendeiner Weise auswerten, um diese beispielsweise in einer Liste anzuzeigen und einen der enthaltenen Artikel auszuwählen, um seine Detailbeschreibung bei eBay zu öffnen. Dazu verwenden Sie eine Tabelle, deren Entwurf zu Beispielzwecken einfach gehalten ist und wie in Bild 8 aussieht.<\/p>\n Bild 8: Entwurfsansicht einer Tabelle zum Speichern von Suchergebnissen<\/span><\/b><\/p>\n Das Formular aus Bild 9 enthält die notwendigen Bedienelemente, um eine einfache Suche auszuführen. Diese akzeptiert drei Parameter:<\/p>\n Bild 9: Formular zur Anzeige von Suchergebnissen<\/span><\/b><\/p>\n Als Suchbegriff kann der Benutzer einen oder mehrere durch Leerzeichen getrennte Begriffe eingeben.<\/p>\n Die Anzahl der ermittelten Treffer wirkt sich direkt auf die Dauer der benötigten Abfrage aus, daher sollte man diese klein halten und die interessanten Treffer durch die Wahl der richtigen Reihenfolge anvisieren.<\/p>\n Suchformular<\/b><\/p>\n Das Suchformular besteht aus einem Haupt- und einem Unterformular, wobei Letzteres lediglich die Suchergebnisse anzeigen soll. Dabei verwendet es die oben vorgestellte Tabelle tblArtikel <\/b>als Datenherkunft.<\/p>\n Die Suchen<\/b>-Schaltfläche löst die Routine aus Listing 5 aus. Während die Parameter aus den beiden Feldern txtSuchbegriffe <\/b>und txtAnzahl <\/b>reine Zeichenketten sind, wählt der Benutzer die Reihenfolge mit einem Kombinationsfeld aus. Dieses ist beispielhaft mit drei möglichen Werten in einer Wertliste gefüllt, die so aussieht:<\/p>\n Listing 5: Start der Suche nach Artikeln mit bestimmten Eigenschaften über die Suchen-Schaltfläche des Formulars frmArtikel<\/p>\n Sie können hier noch weitere Werte aufnehmen. Diese finden Sie in der Referenz der Shopping-API. Wenn Sie die Suchanfrage um weitere Parameter erweitern möchten, finden Sie die möglichen Werte am einfachsten, wenn Sie von der Referenz des jeweiligen Befehls, hier FindItemsAdvanced<\/b>, starten und den benötigten Parameter suchen (hier ItemSort<\/b>).<\/p>\n Dort finden Sie einen Link zur Seite mit Details zu den entsprechenden Werten (siehe Bild 10).<\/p>\n Bild 10: Referenz zu Parametern von API-Funktionen<\/span><\/b><\/p>\n In diesem Fall wurden die Parameter und aussagekräftige Bezeichnungen in einer Wertliste zusammengefasst; wer möchte, kann hierfür natürlich auch direkt eine Tabelle mit allen möglichen Werten erstellen.<\/p>\n Nach dem Anklicken der Suchen<\/b>-Schaltfläche wird der Suchbegriff 1:1 an die weiter oben vorgestellte Funktion FindItemsAdvanced <\/b>weitergegeben, die wir allerdings für den Einsatz in diesem Formular noch ein wenig modifiziert haben: Der Funktionskopf enthält nämlich noch zwei weitere Parameter, welche dem Übermitteln der Anzahl der Treffer und der Suchreihenfolge dienen.<\/p>\n Die Routine selbst enthält ebenfalls einige zusätzliche Zeilen, von denen die meisten dazu dienen, Standardwerte für nicht übergebene Parameter zu setzen.<\/p>\n Interessant ist in diesem Zusammenhang die Verarbeitung der einzelnen Item<\/b>-Elemente der Suchergebnisse. Die For…Next<\/b>-Schleife, die in der obigen Variante der Funktion FindItemAdvanced <\/b>lediglich den Aufruf der Funktion ItemVerarbeiten <\/b>enthielt, wurde noch um eine Bedingung erweitert, die dafür sorgt, dass nur so viele Items verarbeitet werden, wie der Benutzer als maximale Trefferanzahl angegeben hat:<\/p>\n Die Funktion ItemVerarbeiten <\/b>sieht nun wie in Listing 6 aus. Sie liest den Inhalt des Elements Titel<\/b> aus, ersetzt dort Hochkommata durch doppelte Hochkommata, liest den Preis und die URL des Artikels bei eBay ein und schreibt das Ganze als Datensatz in die Tabelle tblArtikel<\/b>. Nachdem dies alles geschehen ist, sorgt die letzte Anweisung aus Listing 5 dafür, dass das Formular die aktuellen Datensätze anzeigt.<\/p>\n Listing 6: Diese Routine verarbeitet die einzelnen, in den Response-XML-Dokumenten enthaltenen Item-Elemente und speichert deren Daten in der Tabelle tblArtikel.<\/p>\n Die Schaltfläche Bei eBay anzeigen <\/b>führt schließlich die folgende Routine aus und zeigt damit den Artikel bei eBay in einer neuen Instanz des aktuellen Standardbrowsers an:<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dies war nur ein kleiner Einblick in die Welt der eBay-Webservices. Immerhin haben Sie nun schon die Grundlage für den weiteren Zugriff geschaffen, indem Sie einen Benutzer angelegt und Schlüssel für den Einsatz in der Sandbox von eBay und in der produktiven Umgebung erzeugt haben. Außerdem wissen Sie nun, wie Sie per REST auf die Shopping-API von eBay zugreifen, um beispielsweise nach Artikeln zu suchen und deren Eigenschaften auszulesen.<\/p>\n Es gibt aber noch viel mehr, was sich mit den eBay-Webservices anstellen lässt. Wenn man sich umhört, gibt es beispielsweise nicht wirklich viele Leute, denen es Spaß macht, Artikel bei eBay einzustellen.<\/p>\n In einem weiteren Beitrag zeigen wir Ihnen daher, wie Sie die hier begonnene Beispieldatenbank mit ein wenig Kreativität und der API-Referenz von eBay um weitere Funktionen ergänzen, mit der Sie Artikel einstellen können. Dazu ist eine Menge mehr nötig als für das pure Suchen nach Artikeln. Die Möglichkeiten von REST sind hier begrenzt und Sie müssen Ihre Anfragen selbst in geeigneten XML-Requests formulieren.<\/p>\n Nun denn: Wem der vorliegende Beitrag gefallen hat, der stürzt sich am besten direkt auf den folgenden, und wer mit dem Thema eBay nur wenig anfangen kann, sollte trotzdem weiterlesen, weil er dort eine ganze Reihe Techniken zum Erstellen und Auslesen von XML-Dokumenten kennenlernen kann.<\/p>\n Links<\/p>\n [1] Informationen zu URL-Parametern: http:\/\/developer.ebay.com\/devzone\/shopping\/docs\/Concepts\/ShoppingAPI_FormatOverview.html#AffiliateURLParameters<\/p>\n [2] API-Funktion FindItems: http:\/\/developer.ebay.com\/devzone\/shopping\/docs\/CallRef\/FindItems.html<\/p>\n [3] API-Funktion FindItemsAdvanced: http:\/\/developer.ebay.com\/devzone\/shopping\/docs\/CallRef\/FindItemsAdvanced.html<\/p>\n [4] Werte für den Parameter ItemSort: http:\/\/developer.ebay.com\/devzone\/shopping\/docs\/CallRef\/types\/SimpleItemSortCodeType.html<\/p>\n [5] Werte für den Parameter ItemType: http:\/\/developer.ebay.com\/devzone\/shopping\/docs\/CallRef\/types\/ItemTypeCodeType.html<\/p>\n [6] Werte für den Parameter IncludeSelector: http:\/\/developer.ebay.com\/devzone\/shopping\/docs\/CallRef\/FindItemsAdvanced.html#Request.IncludeSelector<\/p>\n Enthaltene Beispieldateien:<\/p>\n eBay.mdb<\/p>\n![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic001_opt.jpeg\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic002_opt.jpeg\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic003_opt.jpeg\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic004_opt.jpeg\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic005_opt.jpeg\")
<\/p>\nPublic Function GetAppID() As String\r\n If DLookup("Sandbox", "tblOptionen") = 1 Then\r\n GetAppID = Nz(DLookup("AppID_Sandbox", _\r\n "tblOptionen"), "")\r\n Else\r\n GetAppID = Nz(DLookup( _\r\n "AppID_Production", _\r\n "tblOptionen"), "")\r\n End If\r\nEnd Function<\/pre>\n\n\n
\n \n\n \n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n http:\/\/open.api.ebay.com\/shopping\r\ncallname=FindItems&version=535&siteid=77&\r\nappid=mossSOFT-xxxx-xxxx-xxxx-xxxxxxxxxxxx&\r\nresponseencoding=XML&\r\nQueryKeywords=Access Entwicklerbuch<\/pre>\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic006_opt.jpeg\")
<\/p>\nDim objDocument As New MSXML2.DOMDocument<\/pre>\n
Dim strRequest As String<\/pre>\n
strRequest = "http:\/\/open.api.ebay.com\/µ\r\nshoppingcallname=FindItemsµ\r\n&version=535&siteid=77µ\r\n&appid=mossSOFT-f3da-4585-a088-125f0728ec55µ\r\n&responseencoding=XMLµ\r\n&QueryKeywords=Access Entwicklerbuch"<\/pre>\n
Public Function eBayRequest(strRequest As String, objResponse As MSXML2.DOMDocument) As Boolean\r\n With objResponse\r\n .async = False\r\n .preserveWhiteSpace = False\r\n .validateOnParse = True\r\n .resolveExternals = False\r\n End With\r\n eBayRequest = objResponse.Load(strRequest)\r\nEnd Function\r\nIf eBayRequest(strRequest, objDocument) = _\r\nTrue Then\r\nDebug.Print objDocument.XML\r\nElse\r\nDebug.Print "Aufruf gescheitert."\r\nEnd If<\/pre>\n
Public Function PrintArticles(objDocument As MSXML2.DOMDocument) As Boolean\r\nDim objRoot As MSXML2.IXMLDOMNode\r\nDim objItem As MSXML2.IXMLDOMNode\r\nSet objRoot = objDocument.documentElement\r\nDebug.Print "Anzahl Items: " & objRoot.selectNodes("Item").length\r\nFor Each objItem In objRoot.selectNodes("Item")\r\nDebug.Print objItem.selectSingleNode("ItemID").nodeTypedValue, _\r\nobjItem.selectSingleNode("Title").nodeTypedValue\r\nNext objItem\r\nEnd Function<\/pre>\nAnzahl Items: 3\r\n120339177375 ANDRE MINHORST: Das Access 2003 µ\r\nEntwicklerbuch\r\n220322044300 Das Access 2003 Entwicklerbuch - µ\r\nAndre Minh(Kein Porto)\r\n390015315509 Das Access 2003 Entwicklerbuch - µ\r\nAndre Minh(Kein Porto)<\/pre>\n
Public Function FindItemsAdvanced(strKeywords As String)\r\n Dim objDocument As New MSXML2.DOMDocument\r\n Dim objXMLItems As MSXML2.IXMLDOMElement\r\n Dim strIncludeSelector As String\r\n Dim intPageNumber As Integer\r\n Dim intTotalPages As Integer\r\n Dim lngTotalItems As Long\r\n Dim i As Integer\r\n Dim strRequestPage As String\r\n Dim strRequest As String\r\n Dim strCallname As String\r\n Dim strItemSort As String\r\n Dim strItemType As String\r\n Dim intMaxEntries As Integer\r\n strCallname = "FindItemsAdvanced"\r\n strItemSort = "BestMatch"\r\n strItemType = "AllItemTypes"\r\n strIncludeSelector = "Details"\r\n intMaxEntries = 10\r\n strRequest = "http:\/\/open.api.ebay.com\/shoppingcallname=" & strCallname _\r\n & "&ItemSort=" & strItemSort & "&version=" & GetVersion & "&siteid=" & GetSiteID _\r\n & "&appid=" & GetAppID & "&responseencoding=XML&ItemType=" & strItemType _\r\n & "&IncludeSelector=" & strIncludeSelector & "&QueryKeywords=" & strKeywords _\r\n & "&MaxEntries=" & intMaxEntries\r\n If eBayRequest(strRequest, objDocument) = False Then\r\n MsgBox "Der Request ist fehlerhaft."\r\n Exit Function\r\n Else\r\n If objDocument.selectSingleNode("FindItemsAdvancedResponse\/TotalItems").nodeTypedValue = 0 Then\r\n MsgBox "Es wurden keine Artikel gefunden."\r\n Exit Function\r\n End If\r\n End If\r\n Do\r\n With objDocument\r\n intPageNumber = .selectSingleNode("FindItemsAdvancedResponse\/PageNumber").nodeTypedValue\r\n intTotalPages = .selectSingleNode("FindItemsAdvancedResponse\/TotalPages").nodeTypedValue\r\n Set objXMLItems = .selectSingleNode("FindItemsAdvancedResponse\/SearchResult\/ItemArray")\r\n For i = 0 To objXMLItems.childNodes.length - 1\r\n ItemVerarbeiten objXMLItems.childNodes(i)\r\n Next i\r\n End With\r\n If intPageNumber < intTotalPages Then\r\n intPageNumber = intPageNumber + 1\r\n strRequestPage = strRequest & "&PageNumber=" & intPageNumber\r\n eBayRequest strRequestPage, objDocument\r\n End If\r\n Loop Until intPageNumber = intTotalPages\r\nEnd Function<\/pre>\nFindItemsAdvanced "Access 2007"<\/pre>\n
\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic007_opt.jpeg\")
<\/p>\n<xml version="1.0">\r\n<FindItemsAdvancedResponse xmlns="urn:ebay:apis:eBLBaseComponents">\r\n<Timestamp>2008-12-23T22:52:00.451Z<\/Timestamp>\r\n<Ack>Failure<\/Ack>\r\n<Errors>\r\n<ShortMessage>Geben Sie eine Abfrage ein!<\/ShortMessage>\r\n<LongMessage>Geben Sie eine Abfrage ein!<\/LongMessage>\r\n<ErrorCode>10.1<\/ErrorCode>\r\n<SeverityCode>Error<\/SeverityCode>\r\n<ErrorClassification>RequestError<\/ErrorClassification>\r\n<\/Errors>\r\n<Build>e595_core_Bundled_7641482_R1<\/Build>\r\n<Version>595<\/Version>\r\n<\/FindItemsAdvancedResponse><\/pre>\n
Public Function eBayRequest(strRequest As String, objResponse As MSXML2.DOMDocument) As Boolean\r\n Dim bolSuccess As Boolean\r\n Dim objRoot As MSXML2.IXMLDOMNode\r\n Dim objAck As MSXML2.IXMLDOMNode\r\n With objResponse\r\n .async = False\r\n .preserveWhiteSpace = False\r\n .validateOnParse = True\r\n .resolveExternals = False\r\n End With\r\n bolSuccess = objResponse.Load(strRequest)\r\n If bolSuccess = True Then\r\n Set objRoot = objResponse.documentElement\r\n Set objAck = objRoot.selectSingleNode("Ack")\r\n If objAck.nodeTypedValue = "Failure" Then\r\n bolSuccess = False\r\n End If\r\n End If\r\n eBayRequest = bolSuccess\r\nEnd Function<\/pre>\n&PageNumber=2<\/pre>\n
![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic009_opt.jpeg\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic008_opt.jpeg\")
<\/p>\n\n
Private Sub cmdSuchen_Click()\r\n Dim db As DAO.Database\r\n Dim strSuchbegriffe As String\r\n Dim intAnzahl As Integer\r\n Dim strSortierung As String\r\n Set db = CurrentDb\r\n db.Execute "DELETE FROM tblArtikel"\r\n strSuchbegriffe = Nz(Me.txtSuchbegriffe)\r\n If Len(strSuchbegriffe) = 0 Then\r\n MsgBox "Bitte geben Sie einen Suchbegriff ein."\r\n Exit Sub\r\n End If\r\n FindItemsAdvanced Me.txtSuchbegriffe, Me.txtAnzahl, Nz(Me.cboSortierung, "")\r\n Me.sfmSuche.Form.Requery\r\n End Sub\r\n"BestMatch";"Beste Treffer";\r\n"CurrentBid";"Aktuelles Gebot";\r\n"EndTime";"Angebotsende"<\/pre>\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2009_01\/Ebay-web-images\/pic010_opt.jpeg\")
<\/p>\nFor i = 0 To objXMLItems.childNodes.length - 1\r\nIf (intPageNumber - 1) * intMaxEntries + i _\r\n> varCount - 1 Then\r\nExit Function\r\nEnd If\r\nItemVerarbeiten objXMLItems.childNodes(i)\r\nNext i<\/pre>\n
Public Function ItemVerarbeiten(objItem As MSXML2.IXMLDOMNode)\r\n Dim db As DAO.Database\r\n Dim strTitel As String\r\n Dim sngPreis As Single\r\n Dim strURL As String\r\n Set db = CurrentDb\r\n strTitel = objItem.selectSingleNode("Title").nodeTypedValue\r\n strTitel = Replace(strTitel, "'", "''")\r\n sngPreis = objItem.selectSingleNode("CurrentPrice").nodeTypedValue \/ 100\r\n strURL = objItem.selectSingleNode("ViewItemURLForNaturalSearch").nodeTypedValue\r\n db.Execute "INSERT INTO tblArtikel(Titel, Preis, URL) VALUES('" & strTitel & "', " _\r\n & Replace(sngPreis, ",", ".") & ", '" & strURL & "')", dbFailOnError\r\nEnd Function<\/pre>\nPrivate Sub cmdAnzeigen_Click()\r\nApplication.FollowHyperlink _\r\nMe.sfmSuche.Form!url\r\nEnd Sub<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n