Analyse, Design und Implementie-rung einer Softwarekomponenteals Schnittstelle einer Schlag-dokumentationssoftware zur Daten-übermittlung an Bio mit Gesicht

Bachelorarbeit

Analyse, Design und Implementie-rung einer Softwarekomponenteals Schnittstelle einer Schlag-dokumentationssoftware zur Daten-übermittlung an Bio mit Gesicht.

Zur Erlangung des akademischen Grades eines

Bachelor of Science

- Wirtschaftsinformatik-

Fakultät InformatikReferent: Prof. Dr. Oliver BraunKoreferent: Prof. Dr. Dietmar Beyer

eingereicht von:Alexander BoninMatr.-Nr. 280395Hans-Loch-Straße 3899099 Erfurt

Schmalkalden, den 29.09.2011

Zusammenfassung

Warenrückverfolgbarkeit bei Lebensmitteln welches mit zunehmender Komplexitätder Warenströme und den steigenden Anforderungen des Gesetzgebers immer wich-tiger wird. Im Rahmen dieser Arbeit soll eine Möglichkeit geschaffen werden Land-wirten, über eine Schlagdokumentationssoftware, die Teilnahme an einem solchenSystem zur Warenrückverfolgung zu ermöglichen.

Danksagung

An dieser Stelle möchte ich mich bei allen bedanken, die mich bei der Anfertigungdieser Bachelor-Thesis unterstützt haben.Zunächst mein Dank den beiden Korrektoren Prof. Dr. Oliver Braun und Prof. Dr.Dietmar Beyer, die dieses Thema problemlos und unkompliziert von einem anderenProfessor übernommen haben.Des weiteren möchte ich mich bei Eckehart Klingner, Andrea Möckel und MarkoEspig von der Ibykus AG bedanken welche mir diese Arbeit ermöglicht, und michüber den gesamten Zeitraum betreut und unterstützt haben.Nicht zuletzt möchte ich mich bei meinen Eltern bedanken die mir das Studiumermöglicht und mich moralisch unterstützt haben.

Inhaltsverzeichnis

1 Grundlagen 11.1 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Schlagdokumentation . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Warenrückverfolgbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . 11.4 Bio mit Gesicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5 XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.6 Webservice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.7 SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.8 AgroXML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Anforderungsdefinition der Software 62.1 funktionale Anforderungen . . . . . . . . . . . . . . . . . . . . . . . . 6

2.1.1 Technische Spezifikation . . . . . . . . . . . . . . . . . . . . . 62.1.2 Programmablauf . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2 Nicht funktionale Anforderungen . . . . . . . . . . . . . . . . . . . . 72.3 Wirtschaftlichlichkeitsbetrachtung . . . . . . . . . . . . . . . . . . . . 7

3 Entwurf 83.1 Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.2 Verwendete Werkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . 83.3 Verwendetes Framework . . . . . . . . . . . . . . . . . . . . . . . . . 83.4 Kommunikationsschnittstellen . . . . . . . . . . . . . . . . . . . . . . 10

3.4.1 Auth - Login . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.4.2 Auth - Logout . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.4.3 Daten - Synchronisierung . . . . . . . . . . . . . . . . . . . . . 113.4.4 Daten - Senden . . . . . . . . . . . . . . . . . . . . . . . . . . 113.4.5 Daten - Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.5 Struktur der Daten in Elsa-Öko . . . . . . . . . . . . . . . . . . . . . 123.6 Flussdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3.6.1 Anmeldediagramm . . . . . . . . . . . . . . . . . . . . . . . . 133.6.2 Abmeldediagramm . . . . . . . . . . . . . . . . . . . . . . . . 143.6.3 Synchronisationsdiagramm . . . . . . . . . . . . . . . . . . . . 143.6.4 Übertragungsdiagramm . . . . . . . . . . . . . . . . . . . . . . 153.6.5 Löschdiagram . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4 Implementierung 174.1 Dll Export Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.1.1 Initialize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174.1.2 GetParameter . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Alexander BoninIV

Inhaltsverzeichnis Fachhochschule Schmalkalden SS 2011

4.1.3 GetFunction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184.1.4 test_bmg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.1.5 sync_bmg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.1.6 send_bmg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.1.7 del_bmg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.1.8 sendmarked_bmg . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.2 DLL-interne Funktionen und Methoden . . . . . . . . . . . . . . . . . 294.2.1 XML Builds . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.2.2 XML Response . . . . . . . . . . . . . . . . . . . . . . . . . . 324.2.3 XML Transfer . . . . . . . . . . . . . . . . . . . . . . . . . . . 354.2.4 XML in String Umwandlung . . . . . . . . . . . . . . . . . . . 374.2.5 String in XML Umwandlung . . . . . . . . . . . . . . . . . . . 384.2.6 Netzverfügbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . 394.2.7 Mapping von Einheiten . . . . . . . . . . . . . . . . . . . . . . 394.2.8 Prüfen auf Verfügbarkeit eines Wertes . . . . . . . . . . . . . 404.2.9 Suchen der Bio mit Gesicht ID . . . . . . . . . . . . . . . . . . 41

5 Fazit 43

Literaturverzeichnis 44

A Quellcodelistings 45A.1 BMGModul.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45A.2 BMGModul.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46A.3 functions.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58A.4 functions.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60A.5 structs.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64A.6 xml_builds.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65A.7 xml_builds.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67A.8 xml_results.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81A.9 xml_results.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

B Anhang 90B.1 Telefonprotokoll Bio mit Gesicht . . . . . . . . . . . . . . . . . . . . . 90B.2 Bio-mit-Gesicht Schnittstellenbeschreibung . . . . . . . . . . . . . . . 90

Eidesstattliche Erklärung 95

Alexander BoninV

1 Grundlagen

Diese Arbeit soll den Analyse-, Design- und Entstehungsprozess eines Plugins doku-mentieren, welches eine Schlagdokumentationssoftware um eine Schnittstelle an einWarenrückverfolgbarkeitssystem erweitert.

1.1 ÜberblickIm ersten Kapitel werden die Grundbegriffe geklärt, die diese Arbeit betreffen. Dazuzählen die grundsätzlich eingesetzten Technologien, sowie die Begriffserklärungenaus dem Umfeld, in dem die Schnittstelle laufen soll.Kapitel zwei gibt einen Überblick über die funktionalen und nicht funktionalen An-forderungen, die an die Schnittstelle gestellt werden, sowie eine kurze wirtschaftlicheBetrachtung des Sachverhalts.Der Entwurf in Kapitel drei, stellt die Architektur der Schnittstelle dar, sowie allein Verbindung mit der Schnittstelle verwendeten Technologien.Das Kapitel vier beschäftigt sich ausschließlich mit der Implementierung der Schnitt-stelle. Hier werden zur Erläuterung Quellcodelistings der entworfenen Funktionender Schnittstelle herangezogen.Im Folgenden werden die Grundlagen zu dieser Arbeit geklärt.

1.2 SchlagdokumentationUnter einer Schlagdokumentation oder einer elektronischen Schlagkartei verstehtman die „Aufzeichnungen aller Maßnahmen auf einem Schlag1 (Feld- oder Wiese)und über die Ergebnisse der Bodenuntersuchungen. Damit kann der Landwirt denweiteren Anbau planen und nach der Ernte eine entsprechende Erfolgskontrolle vor-nehmen“.2

1.3 WarenrückverfolgbarkeitWarenrückverfolgbarkeit ist ein Begriff der in der Gesamten LebensmittelwirtschaftVerwendung findet. Die Rückverfolgbarkeit dieser Waren bildet allerdings meist nurden Vorgang im Unternehmen selbst ab. Ziel einer vollständigen Warenrückverfolg-barkeit ist die Abbildung der gesamten Wertschöpfungskette. Eine Abbildung vomHersteller zum Konsumenten bezeichnet man als Downstream Tracking oder auch

1Eine zusammengehörige Ackerfläche, die mit nur einer Feldfrucht bestellt ist.2http://www.agrilexikon.de/index.php?id=973

Alexander Bonin Seite 1 von 95

1. Grundlagen Fachhochschule Schmalkalden SS 2011

abwärtsgerichtete Verfolgung. Die Abbildung der Wertschöpfungskette vom Kon-sumenten bis zum Erzeuger wird als Upstream Tracking oder aufwärtsgerichteteRückverfolgung bezeichnet.Ziel dieser Abbildungen ist es jede Phase des Inverkehrbringens von Waren verfolgenzu können. Dies erleichtert zum einen die Qualitätssicherung und den Warenrückruf.Hat der Endverbraucher die Möglichkeit die Wertschöpfungskette einzusehen sostärkt dies das Vertrauen in das jeweilige Produkt.3

1.4 Bio mit Gesicht„Bio mit Gesicht“ ist eine Plattform zur Warenrückverfolgbarkeit im Bereich Lebens-mittel, und bietet als solche einen Webservice an, bei welchem Landwirte freiwilligam System der Warenrückverfolgbarkeit teilnehmen können. „Bio mit Gesicht“ sel-ber definiert sich folgendermaßen: „Bio mit Gesicht ist eine Qualitätsinitiative vonNaturland, Marktgesellschaft der Naturland Betriebe, Bioland Markt, Demeter, te-gut..., Feneberg, Ecoinform und dem Forschungsinstitut für biologischen Landbau(FiBL). Mit dem Projekt verfolgen sie gemeinsam das Ziel, den qualitätsorientiertenÖkologischen Landbau auszuweiten und erlebbar zu machen, wie er insbesondere vonden Verbänden des Ökologischen Landbaus vertreten wird.“ 4 „Bio mit Gesicht“ gibtdem Kunden die Möglichkeit, zu sehen und nachzuvollziehen wo sein erworbenesProdukt herkommt, und welche Stationen es durchlaufen hat.

1.5 XMLMit XML5 ist ein Format geschaffen worden das Informationen durch Auszeich-nungselemente kennzeichnet, und sich so hervorragend für den universellen Daten-austausch eignet.6 Diese 1998 von der W3C7, in der Version 1.0, verabschiedetenSpezifikation ist sowohl mensch- als auch maschinenlesbar.XML gibt keine Auszeichnungselemente vor. Jeder kann seine Auszeichnungselemen-te selbst definieren. Jedoch gibt XML eine klare Struktur vor, an die man sich beimDefinieren eigener Auszeichnungselemente halten muss. Dieses Vorgehen reduziertdie Komplexität des Codes und die Möglichkeit Fehler zu beheben. Im FolgendenListing 1.1 befindet sich ein Beispiel:

Listing 1.1: XML Beispiel<Nachr ich t>

< Uebe r sch r i f t >Einfaches Dokument< / Uebe rsch r i f t ><Text>Dies i s t der < u n t e r s t r i c h e n >w ich t i ge < / u n t e r s t r i c h e n

> I n h a l t . < / Text>< / Nachr ich t>

3Vgl. [Ges]4Vgl. [Bio]5EXtensible Markup Language6Vgl. [Bec09]7W3C - World Wide Web Consortium



Der Tag <Nachricht> markiert den Beginn und der Tag </Nachricht> das Endedes gesamten Dokuments. Hierbei muss darauf geachtet werden, dass jeder geöffne-te Tag auch wieder geschlossen wird. Die Tags <Ueberschrift> und <Text> sindbeide direkte Unterelemente von <Nachricht>, wobei der Tag <Text> seinerseitsein weiteres Unterelement namens <unterstrichen> enthält. Alles was zwischen demöffnenden und schließenden Tag steht, ist Inhalt dieses Tags. Auch wenn das Wort„wichtig“ mit dem Tag <unterstrichen> umgeben ist, heißt das nicht, dass es auchunterstrichen dargestellt wird. Wie der Inhalt dieses und aller weiteren Tags wieder-gegeben bzw. verarbeitet wird, obliegt allein der Interpretation der Maschine oderdes Menschen.8

1.6 Webservice„Web-Services sind selbstbeschreibende, gekapselte Software-Komponenten, die eineSchnittstelle anbieten, über die ihre Funktionen entfernt aufgerufen, und die losedurch den Austausch von Nachrichten miteinander gekoppelt werden können. ZurErreichung universeller Interoperabilität9 werden für die Kommunikation die her-kömmlichen Kanäle des Internets verwendet. Web-Services basieren auf den dreiStandards WSDL10, SOAP und UDDI:Mit WSDL wird die Schnittstelle eines Web-Services spezifiziert, via SOAP werdenProzedurfernaufrufe übermittelt und mit UDDI11, einem zentralen Verzeichnisdienstfür angebotene We- Services, können andere Web-Services aufgefunden werden.“12

1.7 SOAPIm Rahmen der zu entwickelnden Schnittstelle findet ein SOAP13 Webservice seineAnwendung. Im Listing 1.2 ist ein Beispiel eines SOAP Requests abgebildet.

Listing 1.2: XML Beispiel eines SOAP Requests<?xml version=’1.0’ encoding=’utf -8’?><SOAP−ENV:Envelope xmlns:SOAP−ENC="http://schemas.xmlsoap.

org/soap/encoding/" xmlns:SOAP−ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ax is2="http://webservice/bmg/blitz/net/" xmlns:ns0="http://data.bmg.blitz.net/xsd" xmlns:ns1="http://webservice/bmg/blitz/net/xsd" xmlns:ns2="http://entity.bmg.blitz.net/xsd"xmlns:wsaw="http://www.w3.org/2006/05/ addressing/wsdl"xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xs="

8Vgl. Seite 2 - 6 [T.R01]9Die Fähigkeit unabhängiger Systeme möglichst nahtlos zusammenzuarbeiten.

10WebService Description Language - ein platformunabhänige Beschreibungssprache fürWebSer-vices

11Universal Description, Discovery and Integration12Quelle: Seite 40 [Fin09]13SOAP- Single Object Access Protocol



http://www.w3.org/2001/XMLSchema" xmlns :xs i="http://www.w3.org/2001/XMLSchema -instance">

<SOAP−ENV:Body><ns1:sendIncomings xmlns:ns1="http://webservice/bmg/

blitz/net/xsd">< n s 1 : t i c k e t I d x s i : t y p e ="xs:string">927794510< /

n s 1 : t i c k e t I d ><ns1: incomings>

<ns1:charge>< n s 1 : a r t i c l e x s i : t y p e ="xs:string">Spargel< /

n s 1 : a r t i c l e ><ns1:bmgnumber x s i : t y p e ="xs:string">8009029< /

ns1:bmgnumber><ns1:bmgroot id x s i : t y p e ="xs:string">40328000010< /

ns1:bmgroot id><ns1 : labe ls tandardsLabe l i d x s i : t y p e ="xs:short">

103< / ns1 : labe ls tandardsLabe l i d ><ns1 :p r in tcode x s i : t y p e ="xs:string" / >< n s 1 : s e l l e r x s i : t y p e ="xs:string">1479< / n s 1 : s e l l e r

><ns1:spezies x s i : t y p e ="xs:string" / ><ns1: type x s i : t y p e ="xs:string">Auslagerung< /

ns1: type>< / ns1:charge>< n s 1 : i n f o >

<ns1:buyer x s i : t y p e ="xs:string">1500< / ns1:buyer><ns1:chargeId x s i : t y p e ="xs:string">03052011< /

ns1:chargeId>< n s 1 : q u a n t i t y U n i t i d x s i : t y p e ="xs:short">13< /

n s 1 : q u a n t i t y U n i t i d ><ns1 :quan t i t yVa lue x s i : t y p e ="xs:string">40< /

ns1 :quan t i t yVa lue>< / n s 1 : i n f o >

< / ns1: incomings>< / ns1:sendIncomings>

< /SOAP−ENV:Body>< /SOAP−ENV:Envelope>

Eine SOAP Nachricht unterteilt sich prinzipiell in drei Teile:

• Zum ersten das allumfassende SOAP-ENV:Envelope Element in dem die Na-mensräume für alle weiteren Elemente definiert werden.

• Zweitens gibt es als Unterelement von SOAP-ENV:Envelope einen SOAP-ENV:Header, der optional und auch im oben stehenden Listing nicht vor-handen ist.



• Drittens gibt es das SOAP-ENV:Body Element in welchem alle zu übertra-genden Informationen untergebracht sind

Das Soap-ENV:Body Element ist, im Gegensatz zum SOAP-ENV:Header, zwin-gend erforderlich. Die Informationen im Soap-ENV:Body sind abhängig von derFunktion, die beim Webservice angesprochen werden soll. In diesem Fall wird einElement ns1:sendIncommings definiert welches die Unterelemente ns1:ticketId undns1:incommings enthält. Das ns1:incommings Element wiederum enthält selbst nochdie Unterelemente ns1:charge und ns1:info. Diese zwei Elemente enthalten wiederumeine Reihe von Unterelementen die ihre Eigenschaften definieren.

1.8 AgroXMLAgroXML ist ein XML Standard zum Datenaustausch in der Landwirtschaft. DieserStandard ist recht komplex und bildet viele Bereiche der Landwirtschaft ab. Alle indiesem Webservice verwendeten XML Dokumente basieren auf diesem Standard.Vom Entwickler wird AgroXML wie folgt beschrieben: „agroXML erleichtert demLandwirt den Datenaustausch. Momentan bestehen zwischen dem Betriebsrechnerdes Landwirts und den Empfängern (Behörde, Handel, Bündler) eine Vielzahl indi-vidueller Schnittstellen, die für jeden Austauschprozess jeweils eine spezielle Daten-aufbereitung erfordern. Mit agroXML soll ein Softwarestandard eingeführt werden,der die Kommunikation der Programme aller Akteure untereinander ermöglicht.“14.

14[Kur]


2 Anforderungsdefinition derSoftware

Anforderungen an eine Software sind Fähigkeiten oder Bedingungen welche die Soft-ware erfüllen muss. Diese werden in die zwei Kategorien funktionale und nicht funk-tionale Anforderungen unterteilt. Funktionale Anforderungen umfassen die Funktio-nen der Software, genauer die Ausgabe, Verarbeitung, Eingabe und Bearbeitung vonDaten. Des weiteren beziehen sich funktionale Anforderungen auf die Daten selbst,im Sinne von Struktur, Verwendung, Erzeugung, Speicherung, Übertragung und Ver-änderung. Abschließend zählt auch die Behandlung von Fehlern zu den funktionalenAnforderungen.Unter nicht funktionalen Anforderung werden alle Anforderungen zusammengefasst,die nicht direkt in Verbindung mit der Grundfunktionalität der Software stehen. Die-se sind eher im Umfeld der Software angesiedelt. Hierzu zählen unter anderem Zu-griffsbeschränkungen, Sicherheit, Benutzerfreundlichkeit und Konvertierungen vonDaten.1

2.1 funktionale AnforderungenIm Folgenden werden die funktionalen Anforderungen an die Softwareschnittstellebeschrieben. Die Software soll entsprechend des Themas, dem Nutzer die Möglichkeitbieten den Webservice von „Bio mit Gesicht“ in vollem Umfang zu nutzen.

2.1.1 Technische SpezifikationDie Schnittstelle ist in C++ als Plugin für die Software Elsa-Öko zu implementieren,und bietet dem Nutzer aus Elsa-Öko heraus die Möglichkeit, den Webservice zubedienen.Die Schnittstelle integriert sich in die bestehenden Geschäftsprozesse vonElsa-Öko. Die Ausgaben werden in deutscher Sprache realisiert.

2.1.2 ProgrammablaufNach dem Start hat der Nutzer die Möglichkeit, seine Zugangsdaten einzugeben, undfestzulegen ob die Kommunikation automatisch stattfinden soll und ob der Nutzerjeder Kommunikation explizit gefragt werden möchte. Danach ist eine Synchronisie-rung mit „Bio mit Gesicht“ notwendig. Entsprechend den gesetzten Parametern wirdan den entsprechenden Stellen in Elsa-Öko die Kommunikation selbstständig von der

1Vgl. Seite 139-140 [Böh02]


2. Anforderungsdefinition der Software Fachhochschule Schmalkalden SS 2011

Schnittstelle realisiert. Das heißt, die Schnittstelle übernimmt selbst die Entschei-dung ob ein Datensatz übertragen werden kann und überträgt ihn dann auch. Wirdein Datensatz gelöscht, so löscht die Schnittstelle eigenständig einen möglicherweiseverbunden Eintrag beim Webservice mit.

2.2 Nicht funktionale AnforderungenDie nicht funktionalen Anforderungen sind weitere Einschränkungen an die Softwa-re, beispielsweise eine Hardwareumgebung die berücksichtigt werden muss. Weiter-hin Einschränkungen bzw Anforderungen zur Effizienz und Anforderungen an diegraphische Anbindung also die Benutzeroberfläche.Die Schnittstelle bindet sich in die Oberfläche der Software ein. Graphische Elementeder Hostsoftware werden übernommen.

2.3 WirtschaftlichlichkeitsbetrachtungEine wirtschaftliche Betrachtung ist an dieser Stelle nur hinsichtlich des Mehrwertes,welchen das Plugin für die Vermarktung von Elsa-Öko bietet, möglich. Informationenzu dieser Betrachtung stammen aus dem, im Anhang befindlichen Telefonprotokol,B.1 auf Seite 90, mit dem „Bio mit Gesicht“ Geschäftsführer Frank Wörner.Im Verlauf dieses Gespräches stellte sich neben einigen grundlegenden technischenFragen heraus, dass zwar Kontakt zu Mitbewerbern im Bereich elektronische Schlag-dokumentation hergestellt wurde, jedoch bisher niemand die Anbindung dieses Webser-vices umgesetzt hat.Dementsprechend ergibt sich, bei Elsa-Öko im Falle einer Umsetzung, ein Alleinstel-lungsmerkmal, das die Elsa-Öko Software gegen alle anderen derzeit am Markt be-findlichen elektronische Schlagdokumentationen im ökologischen Bereich abgrenzt.Dieses kann vorteilhaft zu Marketingzwecken eingesetzt werden.


3 Entwurf

Im Kapitel Entwurf erfolgt die endgültige Festlegung der Entwicklungsumgebung,des verwendeten Frameworks, der Hardwareumgebung sowie eine Beschreibung derSchnittstellen und einer Abbildung dieser als Flussdiagramm.

3.1 ArchitekturDie Anforderungen an die Umgebung, unter welcher die Schnittstelle laufen muss,entsprechen den Anforderung der Elsa-Öko Software. Diese sind wie folgt festgelegt:

Unterstützte Betriebssysteme: WindowsXP, Windows Vista, Windows 7Computer/Prozessor: Pentium ab 1GHz (oder kompatibel)Bildschirm / Grafikkarte: mind. 1024 x 768 Pixel Auflösung und 16 Bit Farbtiefe

1 Die zu implementierende Schnittstelle darf diese Angaben keinesfalls nach obenverändern.

3.2 Verwendete WerkzeugeAls Entwicklungsumgebung wird, wie unternehmensintern geregelt, MS Visual Stu-dio 2008 eingesetzt. Auswertungen und Testen des Webservices wird mit AltovaXML Spy2 realisiert.

3.3 Verwendetes FrameworkUm später problemlos weitere Webservices anbinden zu können, soll ein geeignetesFramework ausgewählt werden. Für C++ existieren einige Frameworks mit Webser-vice und XML Unterstützung. Eine Übersicht befindet sich in Tabelle 3.1.Das zu wählende Framework sollte mit möglichst geringen Kosten verbunden sein.Das Plugin soll als Update ausgeliefert werden. Daher ist von zusätzlichem Installa-tionsaufwand abzusehen. Darüber hinaus sollte das Framework in aktueller Versionvorhanden sein und nach wie vor unterstützt und weiterentwickelt werden. Die Ent-scheidung fiel auf die freie Version des Poco Frameworks3, da dieses immer nochweiter entwickelt wird. Die normale Version ist kostenfrei erhältlich, und ohne zu-sätzlichen Installationsaufwand einsetzbar ist.

1Vgl. [Iby]2http://www.altova.com/de/xmlspy.html3[App]


3. Entwurf Fachhochschule Schmalkalden SS 2011

Framework Beschreibung Lizenz Last Release.net Framework Das Microsoft .net Framework

bietet neben vielem anderen aucheine vollständige Soap / WSDLUnterstützung.

- V4

MSSOap Toolkit Vorgänger von Microsofts .netwelcher nicht mehr weiterentwi-ckelt wird

- 28.02.2005

GSoap open source C and C++ soft-ware development toolkit forSOAP/XML Web services andgeneric (non-SOAP) C/C++XML data bindings

gSOAPPublicLicense1.3

18.04.2011

AlchemySoap C++ SOAP STACK SupportingSOAP 1.1 and 1.2

LGPL 07.02.2007

Staff Ist ein Open source Web ServicesFramework für C++ und basiertauf Axis2/C

ApacheLicence2.0

16.02.2011

WSDL-Pull C++ Webservice Client Biblio-thek

LGPL 28.10.2010

CSOAP Client/Server SOAP Bibliothekin reinem C

LGPL 25.07.2006

Poco C++ Li-brary

Framework mit umfassenden Bi-bliotheken zu XML und Netzver-bindungen. Bietet in der kosten-pflichtigen Version volle WSDLUnterstützung.

BoostSoft-wareLicense

eine

Tabelle 3.1: SOAP Framework Übersicht



3.4 KommunikationsschnittstellenKommunikationsschnittstellen sind alle Übergabestellen in denen zwei interagieren-de Systeme miteinander kommunizieren.4 Grundsätzlich gibt es in diesem Fall zweiSchnittstellen, die sich durch ihre Endpunkte und ihren Funktionsumfang unterschei-den. Zum einen die Schnittstelle zur Authentifizierung, die die Funktionen Login undLogout umfasst. Zum anderen die BMG Schnittstelle zur Datenübertragung. Diesehält die Funktionen Daten synchronisieren, Daten senden und Daten löschen bereit.An dieser Stelle erfolgt eine Beschreibung der Schnittstellen hinsichtlich Ihrer End-punkte, ihrer Technik, und der Auslöser. Zu jeder Schnittstellenbeschreibung befin-det sich im Kapitel 3.6 ein Datenflussdiagramm. Alle Informationen die Schnittstellebetreffend, haben ihre Grundlage im Anhang B.2 der Schnittstellenbeschreibung von„Bio mit Gesicht“.

3.4.1 Auth - LoginIn Tabelle 3.2 befindet sich die Beschreibung zum Authentifizierungsvorgang vonElsa-Öko gegenüber „Bio mit Gesicht“. Wie im Feld Auslöser zu erkennen, ist derVorgang Login zwingend für jede Datenkommunikation erforderlich. Dieser greiftdabei auf die, in Elsa-Öko hinterlegten, Stammdaten zu und übermittelt Benutzer-name sowie Passwort an „Bio mit Gesicht“. Im Gegenzug wird von „Bio mit Gesicht“,bei erfolgreicher Authentifizierung eine Sessionid übermittelt.

3.4.2 Auth - LogoutDie Funktion Logout der Schnittstelle ist, wie die Login Funktion auch, zwingendam Ende jeder Datenübertragung erforderlich. Hiermit wird die Kommunikationzwischen Elsa-Öko und „Bio mit Gesicht“ wieder beendet. Dazu wird, wie aus Tabelle3.3 ersichtlich, die SessionID an „Bio mit Gesicht“ gesendet, und als Antwort einWahrheitswert als Indikator für den erfolgreichen Logoutvorgang zurückgesendet.

4Vgl. Seite 237 [Böh02]

Woher: Elsa-Öko Stammdaten Wohin: „Bio mit Gesicht“ LogindatenBeschreibung:Authentifizierung gegenüber Bio mit Gesicht.

Datenelemente:- „Bio mit Gesicht“ Kundennummer- Passwort - SessionIDSchnittstellentechnik: XML per HttpAuslöser(Ereignis): Vor dem Start jeder Datenkomunikation

Tabelle 3.2: Schnittstellenbeschreibung Login



Woher: Elsa-Öko SessionID Wohin: „Bio mit Gesicht“-mit-GesichtBeenden einer Session mit Bio mit Gesicht.

Datenelemente:- SessionID - WahrheitswertSchnittstellentechnik: XML per HttpAuslöser(Ereignis): Beenden einer Datenkommunikation

Tabelle 3.3: Schnittstellenbeschreibung Logout

Woher: Elsa-Öko Wohin: „Bio mit Gesicht“Daten Synchronisieren ruft die bei „Bio mit Gesicht“ hinterlegtenMasterdaten ab. Dazu Zählen die zugelassenen Käufer,Artikel, die Liste der Einheiten und die Listeder Anbaustandards.

- buyer Liste- article Liste- unit Liste

- SessionID - Standard ListeSchnittstellentechnik: XML per HttpPeriodizität: Bei Einrichtung oder Stammdatenänderung bei „Bio mit Gesicht“

Auslöser(Ereignis): nach Nutzeranforderung

Tabelle 3.4: Schnittstellenbeschreibung Synchronisieren

3.4.3 Daten - SynchronisierungDie Synchronisierung von Daten findet einmalig bei Inbetriebnahme der Schnittstel-le statt, oder nach dem Stammdaten bei Bio mit Gesicht geändert wurden. DieseFunktion, wie in Tabelle 3.4 beschrieben, überträgt alle Produkte sowie alle Markt-partner für die es dem Nutzer erlaubt ist, Datensätze bei „Bio mit Gesicht“ einzurei-chen. Des Weiteren sind die Listen der zugelassenen Einheiten und Anbauverbändein Stammdaten hinterlegt. Übergeben wird dem Webservice hierbei lediglich dieaktuelle SessionId. Auf der Basis des angemeldeten Nutzers überträgt der Webser-vice für diesen die Listen der Marktpartner, der Artikel sowie die Listen mit denzugelassenen Einheiten und Anbauverbänden.

3.4.4 Daten - SendenWird auf Basis der synchronisierten Stammdaten ein zulässiger Datensatz identifi-ziert, so überträgt die Senden-Funktion, aus Tabelle 3.5, diesen an „Bio mit Gesicht“.Dazu wird zum einen der Datenblock Info generiert, der allgemeine Informationenwie die ID des Marktpartners, die Chargenid, die Einheit der Charge und die An-zahl der Produkte beinhaltet. Danach wird ein Datenblock Charge generiert, deralle weiteren Informationen wie den Anbauverband, die Produktbezeichnung unddie Produktid, die Verkäuferbezeichnung und die Art der Buchung enthält. Diese



Woher: Elsa-Öko Wohin: „Bio mit Gesicht“Beschreibung: Übertragen von Chargendaten anBio mit Gesicht.- info Datensatz - BMGID- charge DatensatzSchnittstellentechnik: XML per HttpAuslöser(Ereignis): Buchen einer BMG gültigen Auslagerung

Tabelle 3.5: Schnittstellenbeschreibung Senden

Woher: Elsa-Öko Wohin: „Bio mit Gesicht“loBeschreibung: Stornieren übertragener Chargendatenvon Bio mit Gesicht wenn die Buchung in Elsa-Ökostorniert wird.- Charge - BMGIDSchnittstellentechnik: XML per HttpAuslöser(Ereignis): Stornieren einer übertragenen Auslagerung in Elsa-Öko.

Tabelle 3.6: Schnittstellenbeschreibung Löschen

werden an „Bio mit Gesicht“ übertragen worauf von „Bio mit Gesicht“ eine eindeu-tige ID für diese Übertragung zurückgegeben wird.

3.4.5 Daten - LöschenUm übertragene Datensätze bei „Bio mit Gesicht“ wieder zu löschen, wird die Lö-schen Funktion der Schnittstelle gerufen. Diese erwartet als Übergabeparameter,trotz der eindeutigen generierten ID wieder einen kompletten Chargendatenblockmit Produktbezeichnung, Anbauverband und allen Informationen, die beim Sendender Buchung übergeben wurden. Bei erfolgreichem Löschen gibt die Funktion dieBMGID des gelöschten Datensatzes zurück. Zu sehen ist das in Tabelle 3.6.

3.5 Struktur der Daten in Elsa-ÖkoIm Folgenden wird kurz auf die Struktur der Daten, mit dennen gearbeitet wird ,eingegangen. Eine Darstellung befindet sich in Grafik 3.1.Alle Daten, die an irgendeiner Stelle in der Software verwendet werden liegen ge-meinsam im so genannten DataRecord. Der DataRecord ist unterteilt in verschiedeneDataLists. Sie umfassen jeweils bestimmte Bereiche, in dennen zusammengehören-de Daten gesammelt sind, ähnlich einer Tabelle in einer Datenbank. Jede DataListbesteht aus mindestens einem bis n Datarecords. In Anlehnung an das Datenbank-beispiel repräsentiert also der DataRecord die Zeilen der jeweiligen Tabelle.Innerhalb des DataRecords befinden sich die einzelnen DataValues, welche die ei-gentlichen Daten beinhalten und vergleichbar mit den einzelnen Zellen der Tabellesind. Angesprochen werden diese über ihre, um beim Datenbankbeispiel zu bleiben,Spaltenbezeichner. Um auf ein bestimmtes DataValue zugreifen zu können benötigt



man also die DataList in der gesucht werden soll. Weiterhin benötigt man den Da-taRecord, also die Zeile, in der die Daten stehen. Zum Schluss braucht man nochden Bezeichner der der DataValue, analog den Spaltenbezeichnern.

Abbildung 3.1: Aufbau der Daten in Elsa-Öko

3.6 FlussdiagrammeIm Folgenden gibt es fünf Flussdiagramme. Für die Authorisierung bei „Bio mitGesicht"die Vorgänge:

• Anmeldung und

• Abmeldung,

die Voraussetzung für die drei weiteren Flussdiagramme sind.Danach die Diagramme zu den Vorfällen:

• Synchronisierung,

• Übertragung und

• Löschen.

Mit diesen Flussdiagrammen soll das System allgemein Veranschaulicht, und eineKommunikationsbasis für alle Entwicklungsprozesse geschaffen werden.5

3.6.1 AnmeldediagrammIn Abbildung 3.2 ist der Loginvorgang bei „Bio mit Gesicht“, als Flussdiagramm zusehen.Dieses veranschaulicht den Prozess der Anmeldung, angefangen vom Prüfen derNetzverfügbarkeit über das Vorhandensein von Nutzerdaten bis hin zum Senden derLoginanfrage und dem Empfangen der Antwort auf diese.

5Vgl. Seite 204 [Böh02]



Abbildung 3.2: BMG Login Flussdiagramm

3.6.2 AbmeldediagrammIn Abbildung 3.3 wird der Abmeldevorgang bei „Bio mit Gesicht“ als Flussdiagrammdargestellt.

Abbildung 3.3: BMG Logout Flussdiagramm

3.6.3 SynchronisationsdiagrammDas Synchronisationsdiagramm in Abbildung 3.4 stellt den Ablauf der Synchroni-sation von Stammdaten, die beim Webservice hinterlegt sind, dar.Wie im vorangegangenen Diagramm wird als erstes die Netzverfügbarkeit geprüft.Anschließend das Senden der XML Anfrage und das Empfangen und Auswerten derXML Antwort. Jeweils mit den zwei möglichen Endpunkten „erfolgreich“ und „nichterfolgreich“.



Abbildung 3.4: BMG Synchronisation Flussdiagramm

3.6.4 ÜbertragungsdiagrammIm Übertragungsdiagramm 3.5 wird das Vorgehen zum Einreichen von Daten amWebservice abgebildet.Es beginnt mit der Prüfung ob das Produkt und der Käufer in der BMG Listevorhanden sind und demnach übertragen werden können. Als nächstes werden alleDaten der Buchung ausgelesen und in ein XML Dokument integriert. Danach erfolgtdas Prüfen der Netzverfügbarkeit sowie das Senden und Auswerten der Antwort.Wurden alle Schritte erfolgreich abgearbeitet, erfolgt das Markieren der Buchungals gesendet.

Abbildung 3.5: BMG Übertragen Flussdiagramm

3.6.5 LöschdiagrammUm übertragene Daten auch wieder löschen zu können, wird noch das Löschdia-gramm aus Abbildung 3.6 benötigt.Es beschreibt den Löschvorgang. Dazu wird die entsprechende BMG Nummer ausden Buchungsdaten ausgelesen und im nächsten Schritt mit allen relevanten Datenein Löschdokument generiert. Hinterher erfolgt die übliche Prüfung auf Netzverfüg-



barkeit und am Ende das Absenden des Requests und die Auswertung der Antwort.

Abbildung 3.6: BMG Löschen Flussdiagramm


4 ImplementierungIm Kapitel Implementierung werden ausgewählte Funktionen betrachtet. Sie stellenjedoch nicht den gesamten Umfang aller Funktionen dar. Alle Funktionen mit einemähnlichen Ablauf, sowie die vollständigen Quellcodelistings der hier behandeltenFunktionen, befinden sich im Anhang A.

4.1 Dll Export FunktionenIn diesem Abschnitt wird der Teil der Funktionen behandelt, der per DLL Exportgegenüber Elsa-Öko bekannt gemacht wird und somit von diesem direkt aufrufbarist.

4.1.1 InitializeIn der Funktion 4.1 werden alle Punkte abgearbeitet welche beim ersten Aufrufender DLL wichtig sind. In diesem Fall ist das lediglich die Angabe der Sprachdateiwelche später in der Lage ist Mehrsprachigkeit zu unterstützen.

Listing 4.1: Initiale Aktionen beim Laden der DLLIBKBMGMODUL_EXT_API bool Initialize (){

// return CADSMessageHandler :: GetInstance ()->LoadFile(" BmgModulMessage.zip",0," BmgModul ");

return true;}

4.1.2 GetParameterAuf die DLL Funktion GetParameter() soll in diesem Abschnitt näher eingegangenwerden. Sie ist dafür verantwortlich, dem Hauptprogramm alle wichtigen Informa-tionen über das Modul bekannt zu geben.Das folgende Listing 4.2 zeigt den Aufbau der GetParameter() Funktion. Daraus istersichtlich das die Informationen Name, FunctionList, Version, DemoDays, Points,ValidEnd und RegType vom Modul abgefragt werden können.

Listing 4.2: Funktion zum Bekanntmachen der ModulinformationenIBKBMGMODUL_EXT_API LPCTSTR GetParameter(LPCTSTR

pParameter){


4. Implementierung Fachhochschule Schmalkalden SS 2011

if (! strcmp(pParameter ,"Name")) return "BMG -Modul";else if(! strcmp(pParameter ,"FunctionList")) return "

test_bmg ,sync_bmg ,send_bmg ,del_bmg"; //,send_bmg ,del_bmg

else if(! strcmp(pParameter ,"Version")) return "1.0.0";// OnNewRelease

else if(! strcmp(pParameter ,"DemoDays")) return "100";else if(! strcmp(pParameter ,"Points")) return "10";else if(! strcmp(pParameter ,"ValidEnd")) return "

2012 -12 -31";else if(! strcmp(pParameter ,"RegType")) return "No";

// No ,Modul ,Bundleelse return NULL;

}

Der Parameter „Name“ liefert dem Hauptprogramm die exakte Bezeichnung desModuls. Der Parameter FunctionList gibt dem Hauptprogramm alle Funktionendes Moduls zurück die vom Hauptprogramm aus direkt aufgerufen werden können.Der Parameter DemoDays gibt die kostenlose Demo Laufzeit in Tagen zurück undabschließend gibt der Parameter RegType die Art der Registrierung des Moduls an.

4.1.3 GetFunctionDie Funktion GetFunction in Listing 4.3 gibt die genaue Funktionsbezeichnung ent-sprechend der, in Listing 4.2 angegebenen, FunctionList zurück sowie den Wert„TRUE“ für den Returncode. Sollte keine Übereinstimmung gefunden werden wirdals Returncode „FALSE“ zurückgegeben und die Funktion beendet.

Listing 4.3: Veröffentlichen von ModulinformationenIBKBMGMODUL_EXT_API bool GetFunction(LPCTSTR pType ,

CString& zFunction ,CValuePairArray& arrValues){

bool bRetcode = true;// Reference um warnung zu umgehenarrValues;zFunction;pType;

if ( !strcmp(pType ,"test_bmg")) {zFunction = "test_bmg";

} else if(! strcmp(pType ,"sync_bmg")) {zFunction = "sync_bmg";

} else if(! strcmp(pType ,"send_bmg")) {zFunction = "send_bmg";

} else if(! strcmp(pType ,"del_bmg")) {zFunction = "del_bmg";

} else {



bRetcode = false; //wenn funktion nicht gefunden}

return bRetcode;}

4.1.4 test_bmgDie Funktion testbmg aus Listing 4.4 macht nichts anderes als auf Basis der ein-gegebenen Zugangsdaten zu testen ob sich eine Verbindung zu „Bio mit Gesicht“aufbauen lässt oder nicht. Hierzu beschafft sie sich aus dem Datastore die DataListe„BMG_CONF“ um von dieser die DataValues „BMGNR“ für die Zugangsnummer,sowie „BMGPW“ für das Passwort abzurufen. Danach wird mit diesen Daten einLogin bei Bio mit Gesicht angestoßen, die zurückgelieferte TicketID in eine Variablegeschrieben und ein LogoutRequest gesendet. Wenn jetzt in der Variable ticket_idein beliebiger Wert steht war der Verbindungsversuch erfolgreich und die Funktionwird mit „TRUE“ beendet. Ist die Variable jedoch leer, so war mit den angegebenenZugangsdaten keine Verbindung möglich und die Funktion wird mit dem Rückga-bewert „FALSE“ beendet.

Listing 4.4: Funktion zum Verbindungstest mit „Bio mit Gesicht“.IBKBMGMODUL_EXT_API bool test_bmg(CADSModulPara&

recModulPara){std:: string bmg_user;std:: string bmg_pass;CADSDataList* pDataList;CADSDataRecord* pDataRecord;

pDataList = CADSDataStore :: GetDataStore ()->GetDataList("BMG_CONF",true);

pDataRecord = pDataList ->GetDataRecord (0);bmg_user=pDataRecord ->GetDataValue("BMGNR")->

GetStringValue ();bmg_pass=pDataRecord ->GetDataValue("BMGPW")->

GetStringValue ();std:: string ticket_id = login_response(transfer_bmg(

login_bmg(bmg_user ,bmg_pass),true));logout_response(transfer_bmg(logout_bmg(ticket_id),

true));if (ticket_id != ""){ return true; }else { return false; }

}



4.1.5 sync_bmgDie Funktion sync_bmg wird gerufen, wenn die Masterdaten von „Bio mit Gesicht“abgerufen werden sollen. Dazu werden, analog zur Funktion test_bmg, die Zugangs-daten von Bio mit Gesicht abgerufen. Außerdem wird ein leeres XML Dokumentangelegt.

Poco::AutoPtr <Poco::XML::Document > main_document = newPoco::XML:: Document;

Als Nächstes wird ein getMatserdata Request an „Bio mit Gesicht“ generiert undgesendet. die Anwort wird in das leere XML Dokument geschrieben. Danach istdie Komunikation mit „Bio mit Gesicht“ beendet und es wird nur noch mit demXML Dokument gearbeitet. Dieses wird nacheinander jeweils den Funktionen „get-masterdata_response_buyer“, die in Kapitel 4.2.2 beschrieben ist zum Auslesen derKäufer und „getmasterdata_response_us“ zum Auslesen der Units und Standardsübergeben. Gleichzeitig werden die entsprechenden DataListen aus dem DataRecordgeholt und mit an die Funktionen übergeben.

Listing 4.5: Funktion zum Holen der „Bio mit Gesicht“ Masterdaten.IBKBMGMODUL_EXT_API bool sync_bmg(CADSModulPara&

recModulPara){

if (! checknet("http :// demo.bio -mit -gesicht.de/services/AuthService")){

WriteMessage("Es besteht keine Netzverbindung.");return false;

}

Poco::AutoPtr <Poco::XML::Document > main_document =new Poco::XML:: Document;

// definiere Variablen zum auslesen der Elsa datenCADSDataStore* pDataStore = CADSDataStore ::

GetDataStore ();CADSDataList* pDataList;CADSDataRecord* pDataRecord;CADSDataValue* pDataValue;

// auslesen der BMG Konfigurationsdatenstd:: string bmg_user;std:: string bmg_pass;pDataList = CADSDataStore :: GetDataStore ()->

GetDataList("BMG_CONF",true);pDataRecord = pDataList ->GetDataRecord (0);bmg_user=pDataRecord ->GetDataValue("BMGNR")->

GetStringValue ();



bmg_pass=pDataRecord ->GetDataValue("BMGPW")->GetStringValue ();

std:: string ticket_id = login_response(transfer_bmg(login_bmg(bmg_user ,bmg_pass),true));

main_document = transfer_bmg(getmasterdata_bmg(ticket_id),false);

logout_response(transfer_bmg(logout_bmg(ticket_id),TRUE));

pDataList = CADSDataStore :: GetDataStore ()->GetDataList("PI",true);

getmasterdata_response_buyer(main_document ,pDataList);

pDataList = CADSDataStore :: GetDataStore ()->GetDataList("BMG",true);

getmasterdata_response_us(main_document ,pDataList);

return true;}

4.1.6 send_bmgDie Funktion send_bmg wird aufgerufen wenn im Hauptprogramm eine Lageraus-buchung initiiert wird. Send_bmg prüft dabei, ob die aktuelle Lagerausbuchungan Bio mit Gesicht zu übertragen ist und startet , wenn dies gegeben ist, die Da-tenübertragung. Nach erfolgreicher Übertragung markiert die Funktion die aktuelleBuchung als übertragen.

Listing 4.6: Funktion zum Übertragen der Bewegungsdaten.IBKBMGMODUL_EXT_API bool send_bmg(CADSModulPara&

recModulPara){


GetDataStore ();...struct charge_st charge;struct info_st info;

// auslesen der BMG KonfigurationsdatenpDataList = CADSDataStore :: GetDataStore ()->

GetDataList("BMG_CONF",true);pDataRecord = pDataList ->GetDataRecord (0);



bmg_user=pDataRecord ->GetDataValue("BMGNR")->GetStringValue ();

bmg_pass=pDataRecord ->GetDataValue("BMGPW")->GetStringValue ();

bmg_transfer=pDataRecord ->GetDataValue("BMGTRANS")->GetStringValue ();

bmg_ask=pDataRecord ->GetDataValue("BMGASKUSER")->GetStringValue ();

// bmgnummer und sellernummer - chargecharge.seller = pDataRecord ->GetDataValue("BMGMID")->

GetStringValue ();

// auslesen der AnbauverbandpDataList = CADSDataStore :: GetDataStore ()->

GetDataList("UI",true);pDataRecord = pDataList ->GetDataRecord (0);searchDataList = CADSDataStore :: GetDataStore ()->

GetDataList("BMG",true);charge.lablestandard = searchDataList ->FindDataRecord

("BMGBEZ",pDataRecord ->GetDataValue("ANBVERB")->GetStringValue ())->GetDataValue("BMGID")->GetStringValue ();

// auslagerungs informationen auslesenpDataRecord = recModulPara.pMODDataRecord;

...// Einheit der Ware -info (findunit ->

einheitenmapping)info.quantityUnitID = findid(findunit(pDataRecord ->

GetDataValue("AL_EINH",true)->GetStringValue ()),"BMG","BMGBEZ","BMGID");

//Menge -info//info.quantityValue = sprintf (( pDataRecord ->

GetDataValue (" AL_MNG",true)->GetFloatValue ());CString qValue;qValue.Format("%.2f",pDataRecord ->GetDataValue("

AL_MNG",true)->GetFloatValue ());info.quantityValue = qValue;...// prüfen der Daten auf vollständigkeitif (charge.bmgrootid == "" || charge.lablestandard ==

"" || charge.seller == ""){ return false;}if (info.buyer == "" || info.quantityUnitID == "" ||

info.quantityValue == ""){ return false ;}



if (! strcmp(bmg_ask.c_str(),"J")){if (AskUser("Aktuelle Auslagerung an Bio mit

Gesicht übertragen ?",MB_YESNO|MB_ICONQUESTION) != IDYES)

{return false;

}}

// Prüfen auf netzverfügbarkeit wenn kein netz zumübertragen vormerken

if (! checknet("http :// demo.bio -mit -gesicht.de/services/AuthService")){...

}

//login sendenstd:: string ticket_id = login_response(transfer_bmg(

login_bmg(bmg_user ,bmg_pass),true));

//bmg nummer reservierenbmgnumber = getbmgnumbers_response(transfer_bmg(

getbmgnumbers_bmg(ticket_id),false));charge.bmgnumber = bmgnumber.c_str();

// übertragung sendenstd:: string incomming_id = sendincommings_response(

transfer_bmg(sendincommings_bmg(ticket_id ,charge ,info),false));

// logout sendenlogout_response(transfer_bmg(logout_bmg(ticket_id),

TRUE));

//BMG Nummer an auslagerung schreibenif (! strcmp(bmgnumber.c_str (),incomming_id.c_str ())){

pDataRecord ->GetDataValue("BMGNR")->SetStringValue(bmgnumber.c_str());

}return true;

}

Um diese Funktionalität sicher zu stellen, werden wie in Listing 4.6 zu sehen, zu-nächst alle erforderlichen Variablen definiert. Dazu gehören auch zwei strukturierteDatentypen, welche alle die Buchung betreffenden Informationen aufnehmen. DerAufbau dieser zwei strukturierten Datentypen ist in Listing 4.7 abgebildet.



Listing 4.7: Strukturierte Datentypen der sendbmg Funktion.typedef struct info_st{

std:: string buyer;std:: string chargeid;std:: string quantityUnitID;std:: string quantityValue;

}info_st;

typedef struct charge_st{std:: string article;std:: string bmgnumber;std:: string bmgrootid;std:: string lablestandard;std:: string printcode;std:: string seller;std:: string spezies;std:: string type;

}charge_st;

Diese zwei Datentypen werden im Verlauf der Funktion mit den entsprechendenDaten aus den der Buchung zugehörigen DataRecords befüllt. Einige Daten könnennicht direkt in die Listen umgewandelt werden weil eine entsprechende von „Bio mitGesicht“ vergebene Indexnummer erwartet wird. Als Beispiel die Zeilen,// auslesen der Anbauverband

pDataList = CADSDataStore :: GetDataStore ()->GetDataList("UI",true);

pDataRecord = pDataList ->GetDataRecord (0);searchDataList = CADSDataStore :: GetDataStore ()->



in denen der Labelstandard beziehungsweise die ID des Labelstandards, oder auchdes Anbauverbandes, in das XML Dokument integriert wird. Im Einzelnen passiertan dieser Stelle Folgendes:Aus dem DataRecord der DataListe „UI“ wird der Wert des Anbauverbandes geholt.Auf der zu durchsuchenden DataListe wird die interne Funktion „FindDataRecord“gerufen, die als Parameter den Bezeichner in dem gesucht werden soll, sowie denWert der vorher vom Anbauverband ermittelt wurde, erwartet. Diese gibt den ent-sprechenden DataRecord zurück, von dem aus man mit den Funktionen „GetData-Value“ die Value auswählen kann um danach mit „GetStringValue“ den Wert derValue auszulesen. Eine weitere Besonderheit ist das Auffinden der Units, also derEinheiten der zu übermittelnden Ware. Das Problem an dieser Stelle ist, das genau



so wie beim Anbauverband zur entsprechenden Einheit eine zugehörige ID ermitteltwerden muss. Darüber hinaus stimmen aber auch die Schreibweisen der Einheitenauf „Bio mit Gesicht“ und „Elsa-Öko“ Seite nicht miteinander überein. Das Auslesenund Umsetzen dieser Problematik wird in den folgenden Zeilen realisiert.

// Einheit der Ware -info (findunit -> einheitenmapping)info.quantityUnitID = findid(findunit(pDataRecord ->

GetDataValue("AL_EINH",true)->GetStringValue ()),"BMG","BMGBEZ","BMGID");

Hier wird auf zwei Hilfsfunktionen zurückgegriffen. Zum einen die Funktion „fin-dunitäus Kapitel 4.2.7 welche die externe Bezeichnung von „Bio mit Gesicht“ zur in„Elsa-Öko“ vorliegenden internen Bezeichnung heraussucht. Zum anderen die Funk-tion „findid“ aus Kapitel 4.2.9 welche diese zurückgegebene Bezeichnung mit derStammdatentabelle abgleicht und die entsprechende ID von „Bio mit Gesicht“ zu-rück gibt. Da alle Daten unabhängig in welcher Form sie innerhalb von „Elsa-Öko“vorliegen, als String an den Webservice übergeben werden, ergibt sich noch eineHürde beim Auslesen und Übergeben der Menge, der zu übertragenden Buchung.Diese liegt als float-Wert vor und muss in einen Wert vom Typ String umgewandeltwerden. Das wird mit folgenden Zeilen realisiert wird.

CString qValue;qValue.Format("%.2f",pDataRecord ->GetDataValue("AL_MNG",

true)->GetFloatValue ());info.quantityValue = qValue;

Als erstes wird eine Variable vom Typ String bzw CString erstellt. Danach wirdauf die Format Funktion von CStrings zurückgegriffen, in der als erster Parameterder Datentyp der Eingangsdaten übergeben wird. In diesem Fall steht „%.2f“ füreinen Float Datentyp. Als zweiter Parameter werden die Daten, die in einen Stringumformatiert werden sollen, übergeben.Zuletzt werden alle Daten auf Vollständigkeit geprüft und die Netzverbindung si-chergestellt. Sollte keine Netzverbindung verfügbar sein, wird an dieser Stelle derBuchungssatz zum Übertragen vorgemerkt und die weitere Ausführung der Funkti-on abgebrochen. Ist eine Netzverbindung verfügbar, wird zunächst die Loginfunkti-on aufgerufen. Als nächstes wird eine BMG-Nummer reserviert und danach sofortden Buchungsdaten hinzugefügt. Damit sind alle Daten der Buchung komplett. An-schließend werden die Buchungsdaten übertragen, und die zur Bestätigung zurück-gemeldete BMG-Nummer wird dem Buchungsdatensatz in Elsa-Öko zur späterenVerwendung hinzugefügt. Die Funktion wird an dieser Stelle mit „return TRUE“beendet.

4.1.7 del_bmgDie Funktion del_bmg aus Listing 4.8 ist für den Löschvorgang verantwortlich.Wird diese gerufen, wird wie bei jeder Funktion zunächst die Netzverbindung geprüftund anschließend die benötigten Variablen deklariert. Aus der Konfiguration werdendie Logindaten abgerufen. Jetzt werden die Daten der Charge analog zur Funktion



send_bmg eingelesen. Mit diesen Daten wird nun ein XML Request zum Löschenformuliert und dieser abgesendet. Die Rückgabe dieses Requests ist die gelöschteBMG-Nummer, welche mit der gesendeten BMG-Nummer verglichen wird. Wenndiese übereinstimmen, wird der Funktionsaufruf mit „True“ ansonsten mit „False“beendet.

Listing 4.8: Funktion zum stornieren von Bewegungsdaten.IBKBMGMODUL_EXT_API bool del_bmg(CADSModulPara&

recModulPara){if (! checknet("http :// demo.bio -mit -gesicht.de/

services/AuthService")){WriteMessage("Es besteht keine Internetverbindung

.");return false;

}std:: string bmg_user;

...struct charge_st charge;




GetStringValue ();

charge.seller = pDataRecord ->GetDataValue("BMGMID")->GetStringValue ();

// auslesen der Anbauverband...charge.lablestandard = searchDataList ->FindDataRecord


pDataRecord = recModulPara.pMODDataRecord;charge.bmgnumber = pDataRecord ->GetDataValue("BMGNR")

->GetStringValue ();

// artikel und Auslagerungsart - chargecharge.article=pDataRecord ->GetDataValue("AL_BEZWARE"

,true)->GetStringValue ();charge.type="Auslagerung";



//suche Rootid zum Artikel aus der BMG Liste - chargecharge.bmgrootid = findid(pDataRecord ->GetDataValue("

AL_BEZWARE")->GetStringValue (),"BMG","BMGBEZ","BMGID");

std:: string temp_str;ticket_id = login_response(transfer_bmg(login_bmg(

bmg_user ,bmg_pass),true));temp_str =sendcancellations_response(transfer_bmg(

sendCancellations_bmg(ticket_id ,charge),false));logout_response(transfer_bmg(logout_bmg(ticket_id),

true));if (! strcmp(temp_str.c_str (),charge.bmgnumber.c_str()

)){return true;}else {return false;}

}

4.1.8 sendmarked_bmgDie Funktion sendmarked_bmg macht im Grunde das Gleiche, wie die Funktionsend_bmg. Es gibt jedoch einen Unterschied. Bei send_bmg wird immer der aktu-elle Buchungsdatensatz eingelesen und, sofern dies möglich ist, an „Bio mit Gesicht“gesendet. Sendmarked_bmg bearbeitet diese Buchungsdatensätze, die aus irgend-welchen Gründen, z.B. fehlendes Netz, nicht zugestellt werden konnten und zumSenden markiert wurden.

Listing 4.9: Funktion zum senden aller markierten Bewegungsdaten.IBKBMGMODUL_EXT_API bool sendmarked_bmg(CADSModulPara&

recModulPara){if (! checknet("http :// demo.bio -mit -gesicht.de/services/

AuthService")){WriteMessage("Es besteht keine Netzverbindung.");return false;

}// definiere Variablen zum auslesen der Elsa daten

CADSDataStore* pDataStore = CADSDataStore ::GetDataStore ();

...struct info_st info;

// auslesen der BMG KonfigurationsdatenpDataList = CADSDataStore :: GetDataStore ()->

GetDataList("BMG_CONF",true);...




GetStringValue ();

// auslesen der Anbauverband...// Record aller Auslagerungen holenpDataList = CADSDataStore :: GetDataStore ()->

GetDataList("LBU",true);for (int i = 0; pDataList ->GetDataRecordCount (); i++)

{pDataRecord = pDataList ->GetDataRecord(i);if (! strcmp(pDataRecord ->GetDataValue("BMGCANSEND

",true)->GetStringValue (),"Y")){

// empfängerinfo.buyer = findid(pDataRecord ->GetDataValue

("AL_EMPF")->GetStringValue (),"PI","NAME","BMGNR");

...

// prüfen der Daten auf Vollständigkeit...

//login sendenstd:: string ticket_id = login_response(

transfer_bmg(login_bmg(bmg_user ,bmg_pass),true));

//bmg nummer reservieren...// übertragung sendenstd:: string incomming_id =

sendincommings_response(transfer_bmg(sendincommings_bmg(ticket_id ,charge ,info),false));

// logout sendenlogout_response(transfer_bmg(logout_bmg(

ticket_id),TRUE));

//BMG Nummer an auslagerung schreibenif (! strcmp(bmgnumber.c_str (),incomming_id.

c_str())){pDataRecord ->GetDataValue("BMGNR")->

SetStringValue(bmgnumber.c_str());



pDataRecord ->GetDataValue("BMGCANSEND")->SetStringValue("");

}}

}return true;

}

Die Funktion holt sich also zuerst einmal alle Buchungsdatensätze die existieren.Dies wird mit folgenden Zeilen realisiert.

pDataList = CADSDataStore :: GetDataStore ()->GetDataList("LBU",true);

Als nächstes wird begonnen, mit Hilfe einer for-Schleife durch alle Buchungsdaten-sätze zu iterieren. Dabei wird die DataValue „BMGCANSEND“ geprüft.

for (int i = 0; pDataList ->GetDataRecordCount (); i++){pDataRecord = pDataList ->GetDataRecord(i);

if(! strcmp(pDataRecord ->GetDataValue("BMGCANSEND",

true)->GetStringValue (),"Y"))

Enthält diese denWert „Y“ wird der Buchungssatz entsprechend der Funktion send_bmgaufbereitet und gesendet. Sollte die DataValue einen anderen Wert enthalten wirdder Buchungsdatensatz ignoriert und mit dem nächsten Buchungsdatensatz weiter-gemacht.

4.2 DLL-interne Funktionen und MethodenIn diesem Abschnitt werden alle Programmteile behandelt, die innerhalb der DLL fürdie Kommunikation zwischen Elsa-Öko und „Bio mit Gesicht“ zuständig sind, abernicht gegenüber Elsa-Öko bekannt gemacht werden. Dazu gehören hauptsächlich dieFunktionen der XML Generierung, die Funktionen der XML Auswertung und dieFunktion zum Übertragen und Empfangen von XML Dokumenten.

4.2.1 XML BuildsIm Dokument XMLbuilds.cpp sind alle Funktionen zusammengefasst, die XML Do-kumente für die Übertragung an den „Bio mit Gesicht“ Webservice erstellen. Diegrundsätzliche Funktionsweise wird an der Generierung des SendIncommings-XMLDokumentes erläutert, dessen Quellcode sich im Listing 4.10 befindet.

Listing 4.10: Generieren des incommings XML-Dokumentes

Poco::AutoPtr <Poco::XML::Document > sendincommings_bmg(Poco::XML:: XMLString ticket_id ,struct charge_st charge,struct info_st info){



//neues Document AnlegenPoco::AutoPtr <Poco::XML::Document > pDoc = new Poco::

XML:: Document;Poco::AutoPtr <Poco::XML:: ProcessingInstruction >

pXMLHeader = pDoc ->createProcessingInstruction("xml", "version =’1.0’ encoding=’utf -8’");

pDoc ->appendChild(pXMLHeader);// documentenEnvelope anlegen - haengt direkt an pDoc

also direktes unterelement des DokumentsPoco::AutoPtr <Poco::XML::Element > pUri_def = pDoc ->

createElement("SOAP -ENV:Envelope");

pUri_def ->setAttribute("xmlns:SOAP -ENV","http ://schemas.xmlsoap.org/soap/envelope/");

....pUri_def ->setAttribute("xmlns:xsi","http :// www.w3.org

/2001/ XMLSchema -instance");pDoc ->appendChild(pUri_def);

Poco::AutoPtr <Poco::XML::Element > pBody = pDoc ->createElement("SOAP -ENV:Body");

pUri_def ->appendChild(pBody);

// sendIncomings Element als unterElement vom Bodyanlegen

Poco::AutoPtr <Poco::XML::Element > pfunction = pDoc ->createElement("ns1:sendIncomings");

pfunction ->setAttribute("xmlns:ns1","http ://webservice/bmg/blitz/net/xsd");

pBody ->appendChild(pfunction);

// ticket_id wird übergebenPoco::AutoPtr <Poco::XML::Element > ptid = pDoc ->

createElement("ns1:ticketId");ptid ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > ptid_text = pDoc ->

createTextNode(ticket_id);ptid ->appendChild(ptid_text);pfunction ->appendChild(ptid);

// incomings container wird übergebenPoco::AutoPtr <Poco::XML::Element > pinco = pDoc ->

createElement("ns1:incomings");pfunction ->appendChild(pinco);



// charge feld anlegenPoco::AutoPtr <Poco::XML::Element > pcharge = pDoc ->

createElement("ns1:charge");pinco ->appendChild(pcharge);

...// charge -> spezies

Poco::AutoPtr <Poco::XML::Element > pcharge7 = pDoc ->createElement("ns1:spezies");

pcharge7 ->setAttribute("xsi:type","xs:string");if (charge.spezies != "") {

Poco::AutoPtr <Poco::XML::Text > pcharge7_text =pDoc ->createTextNode(charge.spezies);

pcharge7 ->appendChild(pcharge7_text);}pcharge ->appendChild(pcharge7);...// info feld anlegenPoco::AutoPtr <Poco::XML::Element > pinfo = pDoc ->

createElement("ns1:info");pinco ->appendChild(pinfo);

//info -> buyer...//info -> quantityValue

...return pDoc;

}

Alle Funktionen, die ein XML Dokument bauen, besitzen als Rückgabewert einen au-tomatischen Zeiger auf ein XML Dokument( Poco::AutoPTR<Poco::XML::Document>).Innerhalb der Funktion wird ein neues XML Dokument generiert.Hierbei ist AutoPtr<Poco::XML::ProcessingInstruction> pXMLHeader für die Hea-derinformationen des Dokumentes verantwortlich, in diesem Fall der DokumententypXML in der Version 1 mit der Zeichenkodierung UTF-8. Danach wird der Body desXML Dokuments erstellt und ein erstes Unterelement „ns1:sendIncomings“ angehan-gen. Unter diesem wird als nächstes Unterelement die TicketID übergeben.Danach werden als weitere Unterelemente von „ns1:sendIncomings“ die Elemente„Charge“ und „Info“ mit Ihren jeweiligen Merkmalen angehangen. Die Daten, dieje nach zu übertragendem Produkt und Käufer in die XML Datei geschrieben wer-den, bekommt die Funktion in Form eines strukturierten Datentypes als Parameterübergeben. Die Definition der Datentypen erfolgt wie in Listing 4.11 abgebildet.

Listing 4.11: Strukturierte Datentypen für sendIncommingstypedef struct info_st{

std:: string buyer;std:: string chargeid;



std:: string quantityUnitID;std:: string quantityValue;

}info_st;


}charge_st;

Für die XML Blöcke, Charge und Info, wird jeweils ein strukturierter Datentyp er-stellt, der alle erforderlichen Informationen in Form von Strings aufnehmen kann. AlsBeispiel für ein Unterelement von Charge werden folgende Zeilen näher erläutern.

Poco::AutoPtr <Poco::XML::Element > pcharge7 = pDoc ->createElement("ns1:spezies");pcharge7 ->setAttribute("xsi:type","xs:string");if (charge.spezies != "") {


pcharge7 ->appendChild(pcharge7_text);}pcharge ->appendChild(pcharge7);

Zunächst wird „pcharge7“ als XML Element angelegt und ihm der Bezeichner „ns1:spezies“zugewiesen. Als nächstes wird der Elemententyp im XML Dokument bestimmt, indiesem Fall ein String. Danach kommt eine Abfrage, ob der Inhalt des Struct Ele-mentes Text enthält oder nicht. Diese Abfrage findet nur bei den Elementen statt,die im XML Dokument optional sind. Sollte also im definierten strukturierten Da-tentypen das Feld charge.spezies leer sein wird das gesamte Element „ns1:spezies“nicht ins XML Dokument eingebunden. Analog zur Einbindung von Elementen imChargeblock funktioiert auch die Einbindung des Infoblockes.Nach der erfolgreichen Generierung wird das Dokument „pDoc“ mit „Return pdoc“als Funktionsrückgabewert an den aufrufenden Programmteil zurückgegeben.

4.2.2 XML ResponseHinter XML Response verbergen sich die Funktionen, die nach einer erfolgreichenÜbertragung der generierten XML Dokumente die Antwortdokumente von „Bio mitGesicht“ entgegen nehmen und aus diesen die zurück gesendeten Informationen



auslesen. Veranschaulicht wird das im Codelisting 4.12 der Funktion getmasterda-ta_response_buyer, die die Buyerdaten aus dem Antwortdokument eines erfolgrei-chen GetMasterdata Requests ausliest.

Listing 4.12: Auslesen der Buyer Information aus dem Masterdata XMLbool getmasterdata_response_buyer(Poco::AutoPtr <Poco::XML

::Document >req ,CADSDataList* pDataList) {

int counter = pDataList ->GetDataRecordCount ();

Poco::XML:: NodeIterator it(req , Poco::XML:: NodeFilter:: SHOW_ELEMENT);

Poco::XML::Node* pNode = it.nextNode ();// starte zaehlschleife für eintraegetry {

std::vector <buyer > buyer_vec;buyer temp_buyer ;while (pNode){

//liest die buyer tabelle ausif (pNode ->nodeName ()=="ns:city" & pNode ->

parentNode ()->nodeName () == "ns:buyer") {//std::cout << "Stadt: " << pNode ->

innerText () << std::endl;temp_buyer.city=pNode ->innerText ();// pDataValue = pDataRecord ->GetDataValue

("ORT");

}...

pNode = it.nextNode ();}

// vector zu datavalues schreibenCADSDataRecord* pDataRecord;// CADSDataValue* pDataValue;CString bmg = "bmg_";

int writecount =0;for( std::vector < buyer >::size_type i = 0;i <

buyer_vec.size();i++ ) {

if (! existDataValue(pDataList ,"PNR",bmg+buyer_vec[i]. holdingnumber.c_str())){

pDataList ->AddDataRecord(counter+



writecount);pDataRecord = pDataList ->GetDataRecord(

counter+writecount);pDataRecord ->GetDataValue("PNR")->

SetStringValue(bmg+buyer_vec[i].holdingnumber.c_str());

pDataRecord ->GetDataValue("BMGNR")->SetStringValue(buyer_vec[i].holdingnumber.c_str());

pDataRecord ->GetDataValue("ORT")->SetStringValue(buyer_vec[i].city.c_str());

pDataRecord ->GetDataValue("NAME")->SetStringValue(buyer_vec[i].name.c_str());

pDataRecord ->GetDataValue("PLZ")->SetStringValue(buyer_vec[i]. postalcode.c_str());

pDataRecord ->GetDataValue("STR_NR")->SetStringValue(buyer_vec[i]. street.c_str());

pDataRecord ->GetDataValue("STELLUNG")->SetStringValue("P");

writecount ++;}

}return true;

}catch (Poco:: Exception error) {

return false;}

}

Der Übergabeparameter ist in diesem Fall ein XML Dokument. Da die ausgelesenenDaten innerhalb der Funktion direkt an die vorgesehenen Stellen geschrieben wer-den, ist der Rückgabewert lediglich ein boolscher Wert. Dieser kennzeichnet ob dieFunktion erfolgreich ausgeführt wurde oder nicht.Im Grunde wird in dieser Funktion durch alle Elemente des XML Dokumentes ite-riert und der Wert der entsprechend wichtigen Elemente in einen vorbereiteten Vec-tor geschrieben. Der in dieser Funktion verwendete Vector buyervec ist vom Typbuyer, ein vorher angelegter, strukturierter Datentyp, der folgendermaßen aussieht:

Listing 4.13: Aufbau des Vectors für Buyer Informationentypedef struct buyer{

std:: string city;std:: string countrycode;



std:: string holdingnumber;std:: string name;std:: string name2;std:: string postalcode;std:: string street;std:: string type_id;

}buyer ;

An dieser Stelle wurde ein Vector verwendet, da diesem beliebig Elemente ange-hangen werden können, ohne das der Umfang vorher bekannt sein muss. Man hättedas Ganze auch mit einem Array vom Typ „buyer“ lösen können, in dem man dieenthaltenen Elemente erst zählt und anschließend das Array zur Laufzeit mit derermittelten Größe erstellt. Nachdem nun alle Elemente des XML Dokuments durch-laufen und alle Informationen in den Vector geschrieben wurden, wird nun damitbegonnen, die Informationen aus dem Vector an das Host-Programm zu übergeben.Alternativ hätte man auch den Vector als Rückgabewert definieren können und ineiner weiteren Funktion, das Schreiben der Informationen in das Host-Programmrealisieren können.Zum Schreiben wird eine neue Schleife gestartet, welche die Durchlaufanzahl ent-sprechend der Größe des Vectors besitzt. Pro Durchlauf wird jetzt ein kompletterDatensatz in die Elsa-Öko Datenbasis geschrieben.Innerhalb der Schleife wird zunächst die entsprechende DataList aufgerufen undals erstes anhand des Eintrags „Holdingnumber“ geprüft, ob der Datensatz schonexistiert. Ist dies nicht der Fall, muss zunächst die Position an der der neue Datensatzerstellt werden soll ermittelt werden. Dazu wurde zu Beginn bereits die Anzahl derbereits vorhandenen Datensätze mit folgenden Zeilen ermittelt:


Dieser Wert zusammen mit dem Wert „writecount“, welcher die Anzahl der aktuellgeschriebenen Datensätze enthält, ergibt die Position an welche der aktuelle Daten-satz geschrieben wird. Ist die Position ermittelt, werden auf die einzelnen DataVa-lues die entsprechenden Werte aus dem buyer-Struct des aktuellen Vectorelementsgeschrieben. Dies wird solange wiederholt, bis das Ende des Vectors erreicht ist. An-schließend wird die Funktion mit „TRUE“ für alles in Ordnung oder „FALSE“ wennFehler aufgetreten sind beendet.

4.2.3 XML TransferDie für das Übertragen von XML Daten verantwortliche Funktion transfer_bmg,befindet sich im Dokument functions.cpp. Hier liegen alle Funktionen die sich wedermit dem Generieren noch mit dem Auswerten von XML Dokumenten befassen.

Listing 4.14: XML Übertragung per HTTPPoco::AutoPtr <Poco::XML::Document > transfer_bmg(Poco::

AutoPtr <Poco::XML::Document > req ,bool auth_id){



//http -client zur Datenübertragung an BMGPoco::URI uri;

//URL einlesen und in path und host zerlegenif (auth_id) uri="http :// demo.bio -mit -gesicht.de/

services/AuthService";else uri = "http :// demo.bio -mit -gesicht.de/services/

BmgService";

std:: string path(uri.getPathAndQuery ());if (path.empty()) path = "/";

try {

// httpclient verbindung aufbauenPoco::Net:: HTTPClientSession bmg_session(uri.

getHost (),uri.getPort ());

// Proxyeinstellungen wenn notwendigbmg_session.setProxy("192.168.10.10" ,8080);

// request Http_post mit zu string konvertiertemXML dokument erstellen und senden.

Poco::Net:: HTTPRequest request(Poco::Net::HTTPRequest ::HTTP_POST ,path ,Poco::Net::HTTPMessage :: HTTP_1_1);

//chunk -> falserequest.setChunkedTransferEncoding(FALSE);//länge des Inhaltes (xml -string) setzen ->

ansonsten EOF Errorrequest.setContentLength(node2str(req).length ());

//und raus damitbmg_session.sendRequest(request) << node2str(req)

;

// antwort von http Server abwarten und einlesen.Poco::Net:: HTTPResponse response;

std:: istream& rs = bmg_session.receiveResponse(response);std:: string temp_string;// antwort in einen string kopieren und

zurückgebenPoco:: StreamCopier :: copyToString(rs, temp_string)

;



return str2node(temp_string);}

catch (Poco:: Exception error){

WriteMessage(error.displayText ());Poco::AutoPtr <Poco::XML::Document > error_doc =

new Poco::XML:: Document;return error_doc;

}}

Die Funktion transfer_bmg bekommt als Übergabeparameter zum einen ein belie-biges zu sendendes XML Dokument vom Typ Document. Zum anderen wird ihr einboolscher Wert übergeben. Dieser Wert regelt, ob die Übertragung ein Login/Lo-gout Vorgang oder ein Datenübertragungsvorgang an „Bio mit Gesicht“ ist. Für denFall, das der übergeben Wert „True“ ist wird der Funktionsaufruf als Login/Lo-gout Vorgang interpretiert und die Endpunkt Adresse auf „http://demo.bio-mit-gesicht.de/services/AuthService“ gesetzt. Ist der Wert „FALSE“, so wird ein Daten-übertragungsvorgang vorbereitet, indem die Endpunktadresse auf „http://demo.bio-mit-gesicht.de/services/BmgService“ gesetzt wird.Im Folgenden try-Block findet die eigentliche Übertragung statt. Zum einen wirddie Endpunktadresse sinnvoll zerlegt, zum anderen werden einige Einstellungen wieProxySettings ContentLenght und ChunkTransferEncoding gesetzt. Der eigentlicheSendevorgang findet in der folgende Zeile statt.

bmg_session.sendRequest(request) << node2str(req);

Hier wird das in einen String umgewandelte XML Dokument (req) an den vorberei-teten Sende-Request übergeben und damit übertragen.Als Nächstes wird noch auf die Reaktion des Webservices gewartet.

std:: istream& rs = bmg_session.receiveResponse(response);

Der empfangene Stringstream wird zunächst wieder in einen String und von diesemString in ein XML Dokument umgewandelt und zurückgegeben.Sollte während einem dieser Vorgänge ein Fehler auftreten, wird automatisch derCatch-teil ausgeführt. Dieser gibt den Fehler in Form eines XML Dokuments überdie Funktionsrückgabe zurück. Gleichzeitig wird mit der Funktion WriteMessage derFehler aufbereitet und innerhalb der Wirtssoftware dargestellt, um den Nutzer überdiesen Vorgang in Kenntnis zu setzen.

4.2.4 XML in String UmwandlungUm ein XML Dokument überhaupt senden zu können ist es notwendig, dieses ineinen String umzuwandeln. Das übernimmt die Funktion „node2str“ aus Listing4.15.

Listing 4.15: Umwandlung eines XML Dokumentes in einen String



std:: string node2str(Poco::AutoPtr <Poco::XML::Document >node) {

std:: strstream sss;Poco::XML:: XMLString temp_str;Poco:: UTF8Encoding utf8encoding;Poco::XML:: DOMWriter writer;writer.setEncoding("UTF -8",utf8encoding);writer.setOptions(Poco::XML:: XMLWriter ::

PRETTY_PRINT);writer.setNewLine("\n");writer.writeNode(sss , node);sss << ’\0’;

temp_str=sss.str();Poco:: trimInPlace(temp_str);Poco::XML:: toXMLString(temp_str);

return temp_str;}

Zuerst werden einige Variablen definiert. Eine Variable vom Typ Stringstream, eineVariable für das TextEncoding und natürlich wird der eigentlich Writer angelegt.Danach wird dem Writer zunächst das Zeichenencoding, in diesem Fall „UTF-8“1,per „setEncoding“ übergeben. Später folgt das Setzen der Ausgabeoption „PRET-TY_PRINT“, die denWriter dazu bewegt das gesamte XML Dokument inklusive derXML Deklaration auszugeben. Hinterher wird der XML Writer per writenode dazuveranlasst, alle XML Daten aus dem Übergabeparameter Node in den Stringstreamsss zu schreiben. Anschließend wird das ende des Stringstreams mit „0“ markiert.Dann wird, per sss.str(), der Stringstream in eine Variable vom Typ String geschrie-ben. Mit der Funktion „trimInPlace“ werden danach alle überflüssigen Leerzeichenentfernt. Zum Schluss wird der fertige String über den Funktionsnamen zurückge-geben.

4.2.5 String in XML UmwandlungDie Funktion str2node ist das Gegenteil der soeben erläuterten node2str-Funktion.Weil das Antwortdokument des Webservices als String bzw Stringstream eingeht,wird eine Möglichkeit benötigt, diese wieder in ein XML Dokument umzuwandeln.Hierfür benötigt man als Übergabeparameter den Antwortstring. Dieser wird alserstes an einen InputStringStream übergeben. Danach wird er an die als InputSourcedefinierter Variable „src“ geschrieben. Jetzt wird nur noch der DOMParser benötigtwelcher als „parser“ definiert wird.

Listing 4.16: Umwandlung eines Strings in ein XML Dokument

1UTF-8 ist ein 8 bit Universal Character Set Transofmration Format und eine der am weitestenverbreitete Kodierung für Unicode-Zeichen.



Poco::AutoPtr <Poco::XML::Document > str2node(std:: stringresponse_string) {std:: istringstream istr(response_string);Poco::XML:: InputSource src(istr);Poco::XML:: DOMParser parser;Poco::AutoPtr <Poco::XML::Document > pDoc = parser.

parse(&src);return pDoc;

}

Die eigentliche Umwandlung übernimmt der Befehl „parser.parse(&src)“. Dieser gibtein XML Dokument zurück, das anschließend über den Funktionsnamen zurückge-geben wird.

4.2.6 NetzverfügbarkeitZum Prüfen der Netzverfügbarkeit wird auf die Funktion „InternetGetConnected-State“ aus der „Wininet.h“ zurückgegriffen. Diese liefert als Wahrheitswert „True“zurück, wenn eine Netzverbindung vorhanden ist. Wenn die Bedingung der Netz-verfügbarkeit erfüllt ist, wird als nächster Schritt der Endpunkt, der als Paramter„URL“ übergeben wird, geprüft. Dazu wird mit „InternetCheckConnection“ eine Ver-bindung zum übergebenen Endpunkt aufgebaut. Ist dies erfolgreich, so wird „True“zurückgegeben und damit die Funktion beendet, ansonsten wird die Funktion mit„False“ als Rückgabewert beendet.

Listing 4.17: Prüfen auf Netzverfügbarkeitbool checknet(LPCTSTR url){

DWORD dwFlags;if(InternetGetConnectedState (&dwFlags , 0)){

if(InternetCheckConnection(url ,FLAG_ICC_FORCE_CONNECTION ,0)){return true;}

else{return false;}}else{return false;

}return true;

}

4.2.7 Mapping von EinheitenDie Funktion im Listing 4.19 ist dafür verantwortlich, unterschiedliche Schreibkon-ventionen von Einheiten einander anzupassen. Hintergrund ist, dass an „Bio mitGesicht“ eine ID für Einheiten übergeben werden muss. Sie kann aus der Liste,



welche per GetMasterData synchronisiert wurde, entnommen werden. Diese Listebeinhaltet beispielsweise folgendes:

Listing 4.18: Beispiel für einen Unit Eintrag< n s : u n i t type="net.blitz.bmg.entity.Quantity"><ns:name>Dezitonne< / ns:name>< n s : u n i t i d >12< / n s : u n i t i d >

Das heißt:„Bio mit Gesicht“ erwartet für Chargen, die in der Einheit Dezitonne übertragenwerden als EinheitenID den Wert 12. In Elsa-Öko wird die Einheit Dezitonne abermit „dt“ bezeichnet. Aus diesem Grund ist es notwendig, den String „dt“ auf denString „Dezitonne“ zu mappen. Nur auf diese Art kann eine Verbindung zwischendem String „dt“ und der Einheitenid 12 herzustellen.

Listing 4.19: Mappen unterschiedlicher Einheitenbezeichnerstd:: string findunit(std:: string data){

std:: string einhvgl [8][2]={{"dt","Dezitonne"},{"Stk","Stück"},{"Stk.","Stück"},{"kg","Kilogramm"},{"g","Gramm"},{"l","Liter"},{"t","Tonne"},};for(int i=0;i < sizeof(einhvgl);i++){

if (! strcmp(data.c_str(),einhvgl[i][0]. c_str())){return einhvgl[i][1];

}}

return "";}

Dazu wird ein mehrdimensionales String Array „einhvgl“ angelegt, bestehend ausacht Zeilen und zwei Spalten. Pro Zeile beinhaltet es als ersten Wert den Einheiten-bezeichner in Elsa-Öko und als zweiten Wert den Einheitenbezeichner von „Bio mitGesicht“. Wird diese Funktion nun aufgerufen, durchläuft sie alle Zeilen des StringArrays und sucht in der ersten Spalte nach Übereinstimmungen mit dem Überga-beparameter der Funktion. Wenn sie eine Übereinstimmung festgestellt hat, gibtsie den Inhalt der zweiten Spalte der betreffenden Zeile über den Funktionsnamenzurück und wird beendet. Wird sie nicht fündig gibt Sie einen Leerstring zurück undbeendet sich auch.

4.2.8 Prüfen auf Verfügbarkeit eines WertesDie Funktion existDataValue aus Listing 4.20 liefert „True“ zurück wenn ein be-stimmter Datenwert in der Gesamtheit der Daten vorhanden ist. Wird dieser nicht



gefunden, wird „False“ zurückgegeben. Auf die Struktur der Datenhaltung in Elsa-Öko wurde in Kapitel 3.5 schon eingegangen. Als Übergabeparameter bekommt dieFunktion die Bezeichner der Datalist und Datavalue, sowie den Inhalt nach dem inden Datavalues zu suchen ist. Nun wird die DataList aus dem gesamten Datenbe-stand geholt und anschließend mit einer for-Schleife durch alle in dieser Liste vor-handen DataRecords iteriert. Während jedes Schleifendurchlaufes wird im aktuellenRecord der Wert, der im angegebenen DataValue hinterlegt ist mit dem Suchstringverglichen, dazu wird die Funktion strcmp benutzt.Ist der Vergleich erfolgreich wirddie Funktion sofort mit return „true“ beendet wird die Schleife komplett durchlaufenohne das der Vergleich erfolgreich war, wird die Funktoin mit return „false“ beendet.

Listing 4.20: Auffinden eines Wertes in den Gesamtdatenbool existDataValue(CADSDataList* pDataList ,CStringValue ,

CString searchstring){ CADSDataRecord* pDataRecord;CADSDataValue* pDataValue;//pDataList ->FindDataRecord(// iterator durch data recordfor (int i = 0;i < pDataList ->GetDataRecordCount ();i

++){pDataRecord = pDataList ->GetDataRecord(i);pDataValue = pDataRecord ->GetDataValue(Value);//wenn suchwert schon existiert bende funktion

mit rückgabewert trueif (! strcmp(pDataValue ->GetStringValue (),

searchstring)){return true;}}

return false;}

4.2.9 Suchen der Bio mit Gesicht IDAufbauend auf der Funktion findunit, die nur die unterschiedlichen Einheitenbe-zeichner mappt, ist die Funktion findid aus Listing 4.21 dafür verantwortlich, dieBMG IDs für alle Stammdaten von „Bio mit Gesicht“ herauszusuchen. Die Funktionerwartet als Übergabeparameter folgende Werte: in welchem alle zu übertragendenInformationen untergebracht sind

• CString data - den Wert nach dem gesucht wird,

• CString DataList - den Bezeichner der Datenliste in dem gesucht wird,

• CString searchValue - den Bezeichner des Valuefeldes in dem der Wert Gesuchtwird

• CString returnvalue - den Bezeichner des Valuefeldes, dessen Inhalt bei Über-einstimmung zurückgegeben wird.



Zuerst wird die DataList mit dem übergebenen Bezeichner geladen und die Längedieser ausgelesen. Danach wird mit einer Schleife die gesamte Datenliste durchlaufenund im übergebenen Valuefeld nach dem übergebenen Wert gesucht. Sollte diesergefunden werden, wird der Inhalt des ReturnValue Feldes zurückgegeben und dieFunktion beendet. Wenn die Suche erfolglos ist, wird ein Leerstring zurückgegebenund die Funktion ebenfalls beendet.

Listing 4.21: Auslesen der ID Werte von Bio mit GesichtCString findid(CString data ,CString DataList ,CStringsearchValue ,CString returnvalue){ CADSDataList*

searchDataList = CADSDataStore :: GetDataStore ()->GetDataList(DataList ,true);CADSDataRecord* searchDataRecord;for (int i = 0;i < searchDataList ->GetDataRecordCount

();i++){searchDataRecord = searchDataList ->GetDataRecord(i

);if (! strcmp(searchDataRecord ->GetDataValue(

searchValue)->GetStringValue (),data)){return searchDataRecord ->GetDataValue(returnvalue

)->GetStringValue ();}

}return "";}


5 Fazit

Das Ziel der vorliegenden Arbeit war es ein Plugin mit einer Schnittstelle zu entwi-ckeln. Diese Schnittstelle sollte den Webservice „Bio mit Gesicht“ an die Schlagdo-kumentationssoftware Elsa-Öko anbinden.Zu diesem Zweck wurde der Funktionsumfang des Webservices geprüft. Daraufhinmussten auf „Bio mit Gesicht“ Seite einige Änderungen vorgenommen werden, dadie Schnittstellenbeschreibung nicht dem tatsächlichen Funktionsumfang entsprach.Nach dieser Änderung konnte der Webservice als Plugin unter Elsa-Öko implemen-tiert werden. Im Laufe der Entwicklung ergab sich die Nützlichkeit einer weiteren,über welche in Zukunft nachgedacht werden sollte. Das Anbieten eines Anmeldeas-sistenten um den Kunden die Anmeldung bei „Bio mit Gesicht“ zu erleichtern. DesWeiteren würde dies Probleme mit möglicherweise unterschiedlichen Schreibweisenzwischen „Bio mit Gesicht und Elsa-Öko, verhindern.In wie weit das Plugin Zuspruch beim Kunden findet ist zu diesem Zeitpunkt nichtzu sagen. Dennoch ist diese Erweiterung ein Alleinstellungsmerkmal gegenüber allenanderen elektronischen Schlagdokumentationen, und aus diesem Grund ein nützli-ches Marketinginstrument.


Literaturverzeichnis

[App] Applied Informatics Software Engineering GmbH (Hrsg.): PocoC++ Libraries. http://pocoproject.org/, Abruf: 24.August. 2011

[Bec09] Becher, M.: XML. W3L GmbH, 2009. – ISBN 9783937137698

[Bio] Bio mit Gesicht GmbH (Hrsg.): Sehen wo’s herkommt. http://www.bio-mit-gesicht.de/6484.html, Abruf: 24.August. 2011

[Böh02] Böhm, Fuchs E. Rolf: System-Entwicklung in der Wirtschaftsinformatik.vdf Hochschulverlag AG, 2002. – ISBN 9783728127624

[Fin09] Finger, Zeppenfeld Prof. Dr. K. Patrik: Informatik im Fokus - SOA undWebServices. Springer Verlag, 2009. – ISBN 9783540769903

[Ges] Geschäftsstelle Bundesprogramm Ökologischer Land-bau und andere Formen nachaltiger Landwirtschaftin der Bundesanstalt für Landwirtschaft und Ernäh-rung (Hrsg.): Warenrückverfolgbarkeit - Einführung. http://www.oekolandbau.de/verarbeiter/qualitaet/warenrueckverfolgbarkeit/warenrueckverfolgbarkeit-einfuehrung/, Abruf: 24.August. 2011

[Iby] Ibykus AG (Hrsg.): Was wird benötigt, um ELSA-agrar R© , ELSA-wein undELSA-öko nutzen zu können? http://www.elsa-agrar.de/content/view/25/40/, Abruf: 24.August. 2011

[Kur] Kuratorium für Technik und Bauwesen in der Landwirtschafte. V. (Hrsg.): Die Landwirtschaft spricht AgroXML. http://www.agroxml.de/index.php, Abruf: 24.August. 2011

[T.R01] T.Ray, Brodacki O. Erik: Einführung in XML. O’REILLY Verlag GmbH,2001. – ISBN 9783897212862

Alexander Bonin44

http://pocoproject.org/

http://www.bio-mit-gesicht.de/6484.html

http://www.bio-mit-gesicht.de/6484.html

http://www.oekolandbau.de/verarbeiter/qualitaet/warenrueckverfolgbarkeit/warenrueckverfolgbarkeit-einfuehrung/



http://www.elsa-agrar.de/content/view/25/40/

http://www.elsa-agrar.de/content/view/25/40/

http://www.agroxml.de/index.php

http://www.agroxml.de/index.php

A Quellcodelistings

Appendix

A.1 BMGModul.h

Listing A.1: Inhalt der BMGModul Headerdatei#pragma once#ifdef _AFXDLL

#pragma message( "_AFXDLL" )#ifdef IBKBMGMODUL

#pragma message( "IBKBMGMODUL" )#define IBKBMGMODUL_EXT_DATA __declspec(dllexport

)#define IBKBMGMODUL_EXT_CLASS __declspec(dllexport

)#define IBKBMGMODUL_EXT_API extern "C"

__declspec(dllexport)#else

#pragma todo("no IBKBMGMODUL")#define IBKBMGMODUL_EXT_DATA __declspec(dllimport

)#define IBKBMGMODUL_EXT_CLASS __declspec(dllimport

)#define IBKBMGMODUL_EXT_API __declspec(dllimport

)#endif IBKBMGMODUL

#else#pragma todo("no _AFXDLL")#define IBKBMGMODUL_EXT_DATA#define IBKBMGMODUL_EXT_CLASS#define IBKBMGMODUL_EXT_API

#endif _AFXDLL

IBKBMGMODUL_EXT_API bool Initialize ();IBKBMGMODUL_EXT_API bool RegistrationFinished(

CADSModulRegistration *pModulRegistration);IBKBMGMODUL_EXT_API bool CheckModulVersion(LPCTSTR pType ,

int nStoredVersion , int& nCurrentVersion);

Alexander Bonin45

A. Quellcodelistings Fachhochschule Schmalkalden SS 2011

IBKBMGMODUL_EXT_API bool GetFunction(LPCTSTR pType ,CString& zFunction , CValuePairArray& arrValues);

IBKBMGMODUL_EXT_API LPCTSTR GetParameter(LPCTSTRpParameter);

IBKBMGMODUL_EXT_API bool test_bmg(CADSModulPara&recModulPara);

IBKBMGMODUL_EXT_API bool sync_bmg(CADSModulPara&recModulPara);

IBKBMGMODUL_EXT_API bool send_bmg(CADSModulPara&recModulPara);

IBKBMGMODUL_EXT_API bool del_bmg(CADSModulPara&recModulPara);

IBKBMGMODUL_EXT_API bool sendmarked_bmg(CADSModulPara&recModulPara);

A.2 BMGModul.cpp

Listing A.2: Inhalt der BMGModul.cpp// BmgModul.cpp : Defines the entry point for the DLL

application.//#include "stdafx.h"#include <ADSbase.h>#include <ADSdia.h>#include "v:\ source\ADSdia\MainFrm.h"#include "poco\poco.h"#include "structs.h"#include "BmgModul.h"#include "functions.h"#include "xml_builds.h"#include "xml_results.h"#include <string >

#include "..\..\ Exe\basis\ELSAAction.h"#include "..\..\ Exe\basis\ELSAProject.h"

#ifdef _DEBUG#define new DEBUG_NEW#undef THIS_FILEstatic char THIS_FILE [] = __FILE__;#endif

Alexander Bonin46


#ifdef _AFXDLL

#include <afxdllx.h>

BOOL APIENTRY DllMain( HANDLE /* hModule */,DWORD ul_reason_for_call ,LPVOID /* lpReserved */

){

switch (ul_reason_for_call){

case DLL_PROCESS_ATTACH:case DLL_THREAD_ATTACH:case DLL_THREAD_DETACH:case DLL_PROCESS_DETACH:

break;}return TRUE;

}

#endif _AFXDLL

// aktionen modulinitialisierungIBKBMGMODUL_EXT_API bool Initialize (){

// return CADSMessageHandler :: GetInstance ()->LoadFile(" BmgModulMessage.zip",0," BmgModul ");

return true;}

IBKBMGMODUL_EXT_API bool CheckModulVersion(LPCTSTR pType ,int nStoredVersion , int& nCurrentVersion)

{//if (! pType) return false;// nCurrentVersion = 1;//if (nStoredVersion >= 0 && nStoredVersion <=

nCurrentVersion) {// return true;//} else {// return false;//}

Alexander Bonin47


return true;}

IBKBMGMODUL_EXT_API bool RegistrationFinished(CADSModulRegistration *pModulRegistration)

{// Die Funktion wird nach dem Laden aller Module und

dem Berechnen der// Registrierungen bzw. nach dem Eintrag eines neuen

Schlüssels aufgerufen

// Reference um warnung zu umgehenpModulRegistration;

bool bRetcode = true;// WriteMessage ("Modul offensichtlich geladen .");return bRetcode;

}

IBKBMGMODUL_EXT_API LPCTSTR GetParameter(LPCTSTRpParameter)

{if (! strcmp(pParameter ,"Name")) return "BMG -Modul";else if(! strcmp(pParameter ,"FunctionList")) return "

test_bmg ,sync_bmg ,send_bmg ,del_bmg ,sendmarked_bmg";//,send_bmg ,del_bmg

else if(! strcmp(pParameter ,"Version")) return "1.0.0";// OnNewRelease

else if(! strcmp(pParameter ,"DemoDays")) return "100";else if(! strcmp(pParameter ,"Points")) return "10";else if(! strcmp(pParameter ,"ValidEnd")) return "

2012 -12 -31";else if(! strcmp(pParameter ,"RegType")) return "No";

// No ,Modul ,Bundleelse return NULL;

}

IBKBMGMODUL_EXT_API bool GetFunction(LPCTSTR pType ,CString& zFunction ,CValuePairArray& arrValues)

{bool bRetcode = true;

// Reference um warnung zu umgehenarrValues;zFunction;pType;

Alexander Bonin48


if ( !strcmp(pType ,"test_bmg")) {zFunction = "test_bmg";

} else if(! strcmp(pType ,"sync_bmg")) {zFunction = "sync_bmg";

} else if(! strcmp(pType ,"send_bmg")) {zFunction = "send_bmg";

} else if(! strcmp(pType ,"del_bmg")) {zFunction = "del_bmg";

} else if(! strcmp(pType ,"sendmarked_bmg")) {zFunction = "sendmarked_bmg";

} else {bRetcode = false; //wenn funktion nicht gefunden

}

return bRetcode;}

IBKBMGMODUL_EXT_API bool test_bmg(CADSModulPara&recModulPara){if (! checknet("http :// demo.bio -mit -gesicht.de/


.");return false;

}

std:: string bmg_user;std:: string bmg_pass;CADSDataList* pDataList;CADSDataRecord* pDataRecord;




GetStringValue ();std:: string ticket_id = login_response(transfer_bmg(

login_bmg(bmg_user ,bmg_pass),true));logout_response(transfer_bmg(logout_bmg(ticket_id),

true));if (ticket_id != ""){ return true; }else { return false; }

}

Alexander Bonin49


IBKBMGMODUL_EXT_API bool sync_bmg(CADSModulPara&recModulPara){

if (! checknet("http :// demo.bio -mit -gesicht.de/services/AuthService")){WriteMessage("Es besteht keine Netzverbindung.");return false;

}//TODO recaction input output mitgeben lassen !!!!Poco::AutoPtr <Poco::XML::Document > main_document =

new Poco::XML:: Document;// definiere Variablen zum auslesen der Elsa datenCADSDataStore* pDataStore = CADSDataStore ::

GetDataStore ();CADSDataList* pDataList;CADSDataRecord* pDataRecord;// CADSDataValue* pDataValue;

// auslesen der BMG Configurationsdatenstd:: string bmg_user;std:: string bmg_pass;pDataList = CADSDataStore :: GetDataStore ()->



GetStringValue ();

std:: string ticket_id = login_response(transfer_bmg(login_bmg(bmg_user ,bmg_pass),true));

main_document = transfer_bmg(getmasterdata_bmg(ticket_id),false);

logout_response(transfer_bmg(logout_bmg(ticket_id),TRUE));

pDataList = CADSDataStore :: GetDataStore ()->GetDataList("PI",true);

getmasterdata_response_buyer(main_document ,pDataList);

pDataList = CADSDataStore :: GetDataStore ()->GetDataList("BMG",true);

Alexander Bonin50


getmasterdata_response_us(main_document ,pDataList);

return true;}

IBKBMGMODUL_EXT_API bool send_bmg(CADSModulPara&recModulPara){


GetDataStore ();CADSDataList* pDataList;CADSDataRecord* pDataRecord;CADSDataList* searchDataList;std:: string bmg_user;std:: string bmg_pass;std:: string bmg_transfer;std:: string bmg_ask;std:: string bmgnumber;CString temp;struct charge_st charge;struct info_st info;

// auslesen der BMG ConfigurationsdatenpDataList = CADSDataStore :: GetDataStore ()->



GetStringValue ();bmg_transfer=pDataRecord ->GetDataValue("BMGTRANS")->

GetStringValue ();bmg_ask=pDataRecord ->GetDataValue("BMGASKUSER")->

GetStringValue ();


GetStringValue ();


GetDataList("UI",true);pDataRecord = pDataList ->GetDataRecord (0);

Alexander Bonin51


searchDataList = CADSDataStore :: GetDataStore ()->GetDataList("BMG",true);

charge.lablestandard = searchDataList ->FindDataRecord("BMGBEZ",pDataRecord ->GetDataValue("ANBVERB")->GetStringValue ())->GetDataValue("BMGID")->GetStringValue ();

// auslagerungs informationen auslesenpDataRecord = recModulPara.pMODDataRecord;

// empfängerinfo.buyer = findid(pDataRecord ->GetDataValue("

AL_EMPF")->GetStringValue (),"PI","NAME","BMGNR");

// Einheit der Ware -info (findunit ->einheitenmapping)

info.quantityUnitID = findid(findunit(pDataRecord ->GetDataValue("AL_EINH",true)->GetStringValue ()),"BMG","BMGBEZ","BMGID");


GetDataValue (" AL_MNG",true)->GetFloatValue ());CString qValue;qValue.Format("%.2f",pDataRecord ->GetDataValue("

AL_MNG",true)->GetFloatValue ());info.quantityValue = qValue;


,true)->GetStringValue ();charge.type="Auslagerung";



// prüfen der Daten auf vollständigkeitif (charge.bmgrootid == "" || charge.lablestandard ==

"" || charge.seller == ""){ return false;}if (info.buyer == "" || info.quantityUnitID == "" ||

info.quantityValue == ""){ return false ;}

if (! strcmp(bmg_ask.c_str(),"J")){

Alexander Bonin52


if (AskUser("Aktuelle Auslagerung an Bio mitGesicht übertragen ?",MB_YESNO|MB_ICONQUESTION) != IDYES)

{return false;

}}

// Prüfen auf netzverfügbarkeit wenn kein netz zumübertragen vormerken

if (! checknet("http :// demo.bio -mit -gesicht.de/services/AuthService")){pDataRecord ->GetDataValue("BMGCANSEND")->

SetStringValue("Y");WriteMessage("Es besteht keine Netzverbindung .\

nDer Datensatz wurde zum senden vorgemerkt.");return false;

}

//login sendenstd:: string ticket_id = login_response(transfer_bmg(

login_bmg(bmg_user ,bmg_pass),true));

//bmg nummer reservierenbmgnumber = getbmgnumbers_response(transfer_bmg(

getbmgnumbers_bmg(ticket_id),false));charge.bmgnumber = bmgnumber.c_str();

// übertragung sendenstd:: string incomming_id = sendincommings_response(

transfer_bmg(sendincommings_bmg(ticket_id ,charge ,info),false));

// logout sendenlogout_response(transfer_bmg(logout_bmg(ticket_id),

TRUE));

//BMG Nummer an auslagerung schreibenif (! strcmp(bmgnumber.c_str (),incomming_id.c_str ())){

pDataRecord ->GetDataValue("BMGNR")->SetStringValue(bmgnumber.c_str());

}return true;

}

Alexander Bonin53


IBKBMGMODUL_EXT_API bool del_bmg(CADSModulPara&recModulPara){if (! checknet("http :// demo.bio -mit -gesicht.de/


.");return false;

}std:: string bmg_user;std:: string bmg_pass;std:: string ticket_id;CADSDataList* pDataList;CADSDataList* searchDataList;CADSDataRecord* pDataRecord;struct charge_st charge;




GetStringValue ();

charge.seller = pDataRecord ->GetDataValue("BMGMID")->GetStringValue ();





pDataRecord = recModulPara.pMODDataRecord;charge.bmgnumber = pDataRecord ->GetDataValue("BMGNR")

->GetStringValue ();


,true)->GetStringValue ();

Alexander Bonin54


charge.type="Auslagerung";



std:: string temp_str;ticket_id = login_response(transfer_bmg(login_bmg(

bmg_user ,bmg_pass),true));temp_str =sendcancellations_response(transfer_bmg(

sendCancellations_bmg(ticket_id ,charge),false));logout_response(transfer_bmg(logout_bmg(ticket_id),

true));if (! strcmp(temp_str.c_str (),charge.bmgnumber.c_str()

)){return true;}else {return false;}

}

IBKBMGMODUL_EXT_API bool sendmarked_bmg(CADSModulPara&recModulPara){if (! checknet("http :// demo.bio -mit -gesicht.de/


.");return false;

}// definiere Variablen zum auslesen der Elsa datenCADSDataStore* pDataStore = CADSDataStore ::

GetDataStore ();CADSDataList* pDataList;CADSDataRecord* pDataRecord;CADSDataList* searchDataList;std:: string bmg_user;std:: string bmg_pass;std:: string bmg_transfer;std:: string bmg_ask;std:: string bmgnumber;CString temp;struct charge_st charge;struct info_st info;

// auslesen der BMG Configurationsdaten

Alexander Bonin55





GetStringValue ();bmg_transfer=pDataRecord ->GetDataValue("BMGTRANS")->

GetStringValue ();bmg_ask=pDataRecord ->GetDataValue("BMGASKUSER")->

GetStringValue ();


GetStringValue ();





// auslagerungs informationen auslesenpDataList = CADSDataStore :: GetDataStore ()->

GetDataList("LBU",true);

for (int i = 0; i < pDataList ->GetDataRecordCount ();i++){pDataRecord = pDataList ->GetDataRecord(i);charge.article="";charge.bmgnumber="";info.buyer="";info.quantityUnitID="";info.quantityValue="";info.chargeid="";if (! strcmp(pDataRecord ->GetDataValue("BMGCANSEND

",true)->GetStringValue (),"Y")){

// empfänger

Alexander Bonin56


info.buyer = findid(pDataRecord ->GetDataValue("AL_EMPF")->GetStringValue (),"PI","NAME","BMGNR");


GetDataValue (" AL_MNG",true)->GetFloatValue());

CString qValue;qValue.Format("%.2f",pDataRecord ->

GetDataValue("AL_MNG",true)->GetFloatValue());

info.quantityValue = qValue;

// artikel und Auslagerungsart - chargecharge.article=pDataRecord ->GetDataValue("

AL_BEZWARE",true)->GetStringValue ();// Einheit der Ware -info (findunit ->

einheitenmapping)std:: string temp_einh = findid(charge.article

.c_str(),"LL","INH","EINH");

info.quantityUnitID = findid(findunit(temp_einh.c_str()),"BMG","BMGBEZ","BMGID");

charge.type="Auslagerung";

//suche Rootid zum Artikel aus der BMG Liste- charge

charge.bmgrootid = findid(pDataRecord ->GetDataValue("AL_BEZWARE")->GetStringValue(),"BMG","BMGBEZ","BMGID");

// prüfen der Daten auf vollständigkeitif (charge.bmgrootid == "" || charge.

lablestandard == "" || charge.seller == ""){ return false;}

if (info.buyer == "" || info.quantityUnitID== "" || info.quantityValue == ""){ returnfalse;}

//login sendenstd:: string ticket_id = login_response(

transfer_bmg(login_bmg(bmg_user ,bmg_pass),true));

Alexander Bonin57


//bmg nummer reservierenbmgnumber = getbmgnumbers_response(

transfer_bmg(getbmgnumbers_bmg(ticket_id),false));

charge.bmgnumber = bmgnumber.c_str();

// übertragung sendenstd:: string incomming_id =

sendincommings_response(transfer_bmg(sendincommings_bmg(ticket_id ,charge ,info),false));

// logout sendenlogout_response(transfer_bmg(logout_bmg(

ticket_id),TRUE));

//BMG Nummer an auslagerung schreibenpDataRecord ->GetDataValue("BMGNR")->

SetStringValue(charge.bmgnumber.c_str());pDataRecord ->GetDataValue("BMGCANSEND")->

SetStringValue("");

}}return true;

}

A.3 functions.h

Listing A.3: Inhalt der functions Headerdatei#include <ADSbase.h>

#include "Poco/DOM/DocumentType.h"#include "Poco/DOM/Document.h"#include "Poco/DOM/Element.h"#include "Poco/DOM/Text.h"//#include "Poco/DOM/AutoPtr.h"

#include "Poco/DOM/DOMWriter.h"#include "Poco/XML/XMLWriter.h"#include "Poco/DOM/DOMParser.h"#include "Poco/XML/XMLStream.h"#include "Poco/SAX/InputSource.h"

Alexander Bonin58


#include "Poco/URI.h"#include "Poco/StreamCopier.h"#include "Poco/Net/HTTPRequestHandlerFactory.h"#include "Poco/Net/HTTPServerRequest.h"#include "Poco/Net/HTTPServerResponse.h"#include "Poco/Net/HTTPClientSession.h"#include "Poco/AutoPtr.h"

#include "Poco/String.h"#include "Poco/UTF8Encoding.h"

#include "Poco/Exception.h"

// EinheitenvergleichCString findunit(CString data);

//BMG ID findenCString findid(CString data ,CString DataList ,CString

searchValue ,CString returnvalue);

// string dataValue existbool existDataValue(CADSDataList* pDataList ,CString Value

,CString searchstring);

// String 2 intint str2int(std:: string conv_string);

std:: string int2str(int number);

//XML ParserPoco::AutoPtr <Poco::XML::Document > str2node(std:: string

response_string);

// XMLDocument in String Konvertierenstd:: string node2str(Poco::AutoPtr <Poco::XML::Document >

node);

/* überträgt ein XML Document an BMG und gibt die antwortals Document zurück

auth_id sagt der funktion ob das xml Dokument an die Authschnittstelle auth_id=true

oder an die BMGService Schnittstelle gehen soll auth_id=false

*/

Alexander Bonin59


Poco::AutoPtr <Poco::XML::Document > transfer_bmg(Poco::AutoPtr <Poco::XML::Document > req ,bool auth_id);

/* Netzverbindung prüfen*/bool checknet(LPCTSTR url);

A.4 functions.cpp

Listing A.4: Inhalt der functions.cpp#include "stdafx.h"#include "functions.h"//#include <Wininet.h>#include <afxinet.h>

CString findunit(CString data){if (! strcmp(data ,"")){return "";}CString einhvgl [7][2]={{"dt","Dezitonne"},{"Stk","Stück"},{"Stk.","Stück"},{"kg","Kilogramm"},{"g","Gramm"},{"l","Liter"},{"t","Tonne"}};for(int i=0;i < sizeof(einhvgl);i++){

if (! strcmp(data ,einhvgl[i][0])){return einhvgl[i][1];

}}

return "";}CString findid(CString data ,CString DataList ,CString

searchValue ,CString returnvalue){if (! strcmp(data ,"")){return "";}CADSDataList* searchDataList = CADSDataStore ::

GetDataStore ()->GetDataList(DataList ,true);CADSDataRecord* searchDataRecord;int j = searchDataList ->GetDataRecordCount ();for (int i = 0;i < searchDataList ->GetDataRecordCount

();i++){

Alexander Bonin60


searchDataRecord = searchDataList ->GetDataRecord(i);

if (! strcmp(searchDataRecord ->GetDataValue(searchValue)->GetStringValue (),data)){return searchDataRecord ->GetDataValue(returnvalue

)->GetStringValue ();}

}return "";}

// string dataValue existbool existDataValue(CADSDataList* pDataList ,CString Value

,CString searchstring){CADSDataRecord* pDataRecord;CADSDataValue* pDataValue;//pDataList ->FindDataRecord(// iterator durch data recordfor (int i = 0;i < pDataList ->GetDataRecordCount ();i

++){pDataRecord = pDataList ->GetDataRecord(i);pDataValue = pDataRecord ->GetDataValue(Value);//wenn suchwert schon existiert bende funktion

mit rückgabewert trueif (! strcmp(pDataValue ->GetStringValue (),

searchstring)){return true;}}

return false;}

// StringtoInt konverterint str2int(std:: string conv_string) {

std:: istringstream isst;int strnumber =0;isst.str(conv_string);isst >> strnumber;return strnumber;

}

std:: string int2str(int number){

std:: stringstream ss;// create a stringstreamss << number;//add number to the streamreturn ss.str();// return a string with the contents of

the stream}

Alexander Bonin61


//XML ParserPoco::AutoPtr <Poco::XML::Document > str2node(std:: string

response_string) {std:: istringstream istr(response_string);Poco::XML:: InputSource src(istr);Poco::XML:: DOMParser parser;Poco::AutoPtr <Poco::XML::Document > pDoc = parser.

parse(&src);return pDoc;

}

// XMLDocument in String Konvertierenstd:: string node2str(Poco::AutoPtr <Poco::XML::

Document > node) {

std:: strstream sss;Poco::XML:: XMLString temp_str;Poco:: UTF8Encoding utf8encoding;Poco::XML:: DOMWriter writer;writer.setEncoding("UTF -8",utf8encoding);writer.setOptions(Poco::XML:: XMLWriter ::

PRETTY_PRINT);writer.setNewLine("\n");writer.writeNode(sss , node);sss << ’\0’;

temp_str=sss.str();Poco:: trimInPlace(temp_str);Poco::XML:: toXMLString(temp_str);

return temp_str;}

// überträgt ein XML Document an BMG und gibt die antwortals Document zurück

Poco::AutoPtr <Poco::XML::Document > transfer_bmg(Poco::AutoPtr <Poco::XML::Document > req ,bool auth_id)

{

//http -client zur Datenübertragung an BMGPoco::URI uri;

//URL einlesen und in path und host zerlegen

Alexander Bonin62


if (auth_id) uri="http :// demo.bio -mit -gesicht.de/services/AuthService";

else uri = "http :// demo.bio -mit -gesicht.de/services/BmgService";

std:: string path(uri.getPathAndQuery ());if (path.empty()) path = "/";

try {

// httpclient verbindung aufbauenPoco::Net:: HTTPClientSession bmg_session(uri.

getHost (),uri.getPort ());

// Proxyeinstellungen wenn notwendigbmg_session.setProxy("192.168.10.10" ,8080);

// request Http_post mit zu string konvertiertemXML dokument erstellen und senden.

Poco::Net:: HTTPRequest request(Poco::Net::HTTPRequest ::HTTP_POST ,path ,Poco::Net::HTTPMessage :: HTTP_1_1);

//keine übertragung in chunksrequest.setChunkedTransferEncoding(FALSE);//länge des Inhaltes (xml -string) setzen ->

ansonsten EOF Errorrequest.setContentLength(node2str(req).length ());

//und raus damitbmg_session.sendRequest(request) << node2str(req)

;

// antwort von http Server abwarten und einlesen.Poco::Net:: HTTPResponse response;

std:: istream& rs = bmg_session.receiveResponse(response);std:: string temp_string;// antwort in einen string kopieren und

zurückgebenPoco:: StreamCopier :: copyToString(rs, temp_string)

;return str2node(temp_string);

}catch (Poco:: Exception error)

Alexander Bonin63


{//std::cout << "( Error: " << error.displayText () <<

’)’ << std::endl;Poco::AutoPtr <Poco::XML::Document > error_doc =

new Poco::XML:: Document;return error_doc;

}

}

bool checknet(LPCTSTR url){DWORD dwFlags;if(InternetGetConnectedState (&dwFlags , 0)){

if(InternetCheckConnection(url ,FLAG_ICC_FORCE_CONNECTION ,0)){return true;}

else{return false;}}else{return false;

}return true;

}

A.5 structs.h

Listing A.5: Definition der strukturierten Datentypentypedef struct buyer{

std:: string city;std:: string countrycode;std:: string holdingnumber;std:: string name;std:: string name2;std:: string postalcode;std:: string street;std:: string type_id;

}buyer ;

typedef struct product{CString artikel;CString bmgrootid;CString tid;

Alexander Bonin64


}product;

typedef struct us_liste {CString id;CString name;CString tid;

}us_liste;

typedef struct unit {std:: string name;std:: string unitid;

}unit;

typedef struct info_st{std:: string buyer;std:: string chargeid;std:: string quantityUnitID;std:: string quantityValue;

}info_st;


}charge_st;

A.6 xml_builds.h

Listing A.6: Funktionen zum generieren von XML Dokumenten Headerdatei#include <ADSbase.h>// includes für XML generierung#include "Poco/DOM/ProcessingInstruction.h"

Alexander Bonin65


#include "Poco/DOM/Document.h"#include "Poco/DOM/Element.h"#include "Poco/DOM/Text.h"#include "Poco/DOM/AutoPtr.h"

// Ausnahmebehandlung#include "Poco/Exception.h"

//#include "Poco/DOM/DOMWriter.h"//#include "Poco/XML/XMLWriter.h"//#include "Poco/DOM/DOMParser.h"//#include "Poco/XML/XMLStream.h"

// includes zum navigieren durch XML Doumente//#include "Poco/DOM/NodeIterator.h"//#include "Poco/DOM/NodeFilter.h"

// inputsource 2 xml parser include//#include "Poco/SAX/InputSource.h"

// includes für Http verbindung/*#include "Poco/Net/DNS.h"#include "Poco/URI.h"#include "Poco/StreamCopier.h"#include "Poco/Net/HTTPRequestHandlerFactory.h"#include "Poco/Net/HTTPServerRequest.h"#include "Poco/Net/HTTPServerResponse.h"#include "Poco/Net/HTTPClientSession.h"

#include "Poco/String.h"#include "Poco/UTF8Encoding.h"*/

// generiert das logindokumentPoco::AutoPtr <Poco::XML::Document > login_bmg(Poco::XML::

XMLString bmg_uname ,Poco::XML:: XMLString bmg_passwd);

// logout Dokument generierenPoco::AutoPtr <Poco::XML::Document > logout_bmg(Poco::XML::

XMLString ticket_id);

// getMasterdata Dokument

Alexander Bonin66


Poco::AutoPtr <Poco::XML::Document > getmasterdata_bmg(Poco::XML:: XMLString ticket_id);

// sendIncommings DokumentPoco::AutoPtr <Poco::XML::Document > sendincommings_bmg(

Poco::XML:: XMLString ticket_id ,struct charge_st charge,struct info_st info);

// Dokument zum Reservieren von BMG NummernPoco::AutoPtr <Poco::XML::Document > getbmgnumbers_bmg(Poco

::XML:: XMLString ticket_id);

// Dokument zum Löschen von ChargenPoco::AutoPtr <Poco::XML::Document > sendCancellations_bmg(

Poco::XML:: XMLString ticket_id ,struct charge_st charge);

A.7 xml_builds.cpp

Listing A.7: Funktionen zum generieren von XML Dokumenten#include "stdafx.h"#include "structs.h"#include "xml_builds.h"//c++ Includes/*#include <iostream >#include <sstream >#include <fstream >#include <strstream >#include <stdio.h>#include <tchar.h>#include <string.h>

/*!!! Login Dokument !!!*/

Poco::AutoPtr <Poco::XML::Document > login_bmg(Poco::XML::XMLString bmg_uname ,Poco::XML:: XMLString bmg_passwd)

{// BMG Login XML bauen.


XML:: Document;

Alexander Bonin67


Poco::AutoPtr <Poco::XML:: ProcessingInstruction >pXMLHeader = pDoc ->createProcessingInstruction("xml", "version =’1.0’ encoding=’utf -8’");

pDoc ->appendChild(pXMLHeader);

// documentenEnvelope anlegen - haengt direkt an pDocalso direktes unterelement des Dokuments

Poco::AutoPtr <Poco::XML::Element > pUri_def = pDoc ->createElement("SOAP -ENV:Envelope");


pUri_def ->setAttribute("xmlns:SOAP -ENC","http ://schemas.xmlsoap.org/soap/encoding/");

pUri_def ->setAttribute("xmlns:axis2","http :// webservice/bmg/blitz/net/");

pUri_def ->setAttribute("xmlns:ns0","http :// webservice/bmg/blitz/net/xsd");

pUri_def ->setAttribute("xmlns:ns1","http :// org.apache.axis2/xsd");

pUri_def ->setAttribute("xmlns:wsaw","http ://www.w3.org/2006/05/ addressing/wsdl");

pUri_def ->setAttribute("xmlns:wsdl","http :// schemas.xmlsoap.org/wsdl/");

pUri_def ->setAttribute("xmlns:xs","http :// www.w3.org/2001/ XMLSchema");

pUri_def ->setAttribute("xmlns:xsi","http :// www.w3.org/2001/ XMLSchema -instance");pDoc ->appendChild(pUri_def);



//login Element als unterElement vom Body anlegenPoco::AutoPtr <Poco::XML::Element > pLogin = pDoc ->

createElement("ns1:logIn");pLogin ->setAttribute("xmlns:ns1","http :// webservice/

bmg/blitz/net/xsd");pBody ->appendChild(pLogin);

// Kommentar einfügen funtkioniert bisher nciht//AutoPtr <Comment > pComm1 = pDoc ->createComment ("

OPTIONAL ");//pComm1 ->appendChild(pLogin);

Alexander Bonin68


// Username und passwd werden als unterelemente vonLogIn angelegt

Poco::AutoPtr <Poco::XML::Element > pUsern = pDoc ->createElement("ns1:username");

pUsern ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pUsern_text = pDoc ->

createTextNode(bmg_uname);pUsern ->appendChild(pUsern_text);pLogin ->appendChild(pUsern);

Poco::AutoPtr <Poco::XML::Element > pPasswd = pDoc ->createElement("ns1:passwd");

pPasswd ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pPasswd_text = pDoc ->

createTextNode(bmg_passwd);pPasswd ->appendChild(pPasswd_text);pLogin ->appendChild(pPasswd);return pDoc;

}/*!!! Logout Dokument !!!*/

Poco::AutoPtr <Poco::XML::Document > logout_bmg(Poco::XML::XMLString ticket_id){// BMG Login XML bauen.










Alexander Bonin69



pUri_def ->setAttribute("xmlns:ns1","http :// org.apache.axis2/xsd");






pUri_def ->appendChild(pBody);// logout Element als unterElement vom Body anlegenPoco::AutoPtr <Poco::XML::Element > pLogout = pDoc ->

createElement("ns1:logOut");pLogout ->setAttribute("xmlns:ns1","http :// webservice/

bmg/blitz/net/xsd");pBody ->appendChild(pLogout);

// ticket_id werden als unterelemente von Logoutangelegt

Poco::AutoPtr <Poco::XML::Element > ptid = pDoc ->createElement("ns1:ticketId");

ptid ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > ptid_text = pDoc ->

createTextNode(ticket_id);ptid ->appendChild(ptid_text);pLogout ->appendChild(ptid);

return pDoc;}

/*!!! get master Data dokument !!!*/Poco::AutoPtr <Poco::XML::Document > getmasterdata_bmg(Poco

::XML:: XMLString ticket_id){// BMG Login XML bauen.


XML:: Document;

Alexander Bonin70









pUri_def ->setAttribute("xmlns:ns0","http :// data.bmg.blitz.net/xsd");


pUri_def ->setAttribute("xmlns:ns2","http :// entity.bmg.blitz.net/xsd");







// getMasterData Element als unterElement vom Bodyanlegen

Poco::AutoPtr <Poco::XML::Element > pfunction = pDoc ->createElement("ns1:getMasterData");



// ticket_id wird übergeben

Alexander Bonin71





return pDoc;}

/*!!! get BMG Numbers Dokument !!!*/Poco::AutoPtr <Poco::XML::Document > getbmgnumbers_bmg(Poco

::XML:: XMLString ticket_id){// BMG Login XML bauen.















Alexander Bonin72





pUri_def ->appendChild(pBody);// getMasterData Element als unterElement vom Body

anlegenPoco::AutoPtr <Poco::XML::Element > pfunction = pDoc ->

createElement("ns1:getBmgNumbers");pfunction ->setAttribute("xmlns:ns1","http ://

webservice/bmg/blitz/net/xsd");pBody ->appendChild(pfunction);


createElement("ns1:ticketId");ptid ->setAttribute("xsi:type","xs:string");

Poco::AutoPtr <Poco::XML::Text > ptid_text = pDoc ->createTextNode(ticket_id);

ptid ->appendChild(ptid_text);pfunction ->appendChild(ptid);

// quantity wird übergebenPoco::AutoPtr <Poco::XML::Element > pquan = pDoc ->

createElement("ns1:quantity");pquan ->setAttribute("xsi:type","xs:int");

Poco::AutoPtr <Poco::XML::Text > pquan_text = pDoc ->createTextNode("1");

pquan ->appendChild(pquan_text);pfunction ->appendChild(pquan);

return pDoc;}

/*!!! send Incommings Dokument !!!*/Poco::AutoPtr <Poco::XML::Document > sendincommings_bmg(

Poco::XML:: XMLString ticket_id ,struct charge_st charge,struct info_st info){

Alexander Bonin73




















// sendIncomings Element als unterElement vom Bodyanlegen

Poco::AutoPtr <Poco::XML::Element > pfunction = pDoc ->createElement("ns1:sendIncomings");



Alexander Bonin74



createElement("ns1:ticketId");ptid ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > ptid_text = pDoc ->



createElement("ns1:incomings");pfunction ->appendChild(pinco);// charge feld anlegen

Poco::AutoPtr <Poco::XML::Element > pcharge = pDoc ->createElement("ns1:charge");

pinco ->appendChild(pcharge);

// charge -> articlePoco::AutoPtr <Poco::XML::Element > pcharge1 = pDoc ->

createElement("ns1:article");pcharge1 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pcharge1_text = pDoc ->

createTextNode(charge.article);pcharge1 ->appendChild(pcharge1_text);pcharge ->appendChild(pcharge1);// charge -> bmgnumber

Poco::AutoPtr <Poco::XML::Element > pcharge2 = pDoc ->createElement("ns1:bmgnumber");

pcharge2 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pcharge2_text = pDoc ->

createTextNode(charge.bmgnumber);pcharge2 ->appendChild(pcharge2_text);pcharge ->appendChild(pcharge2);// charge -> bmgrootid

Poco::AutoPtr <Poco::XML::Element > pcharge3 = pDoc ->createElement("ns1:bmgrootid");


createTextNode(charge.bmgrootid);pcharge3 ->appendChild(pcharge3_text);pcharge ->appendChild(pcharge3);// charge -> labelstandartsLabelid

Poco::AutoPtr <Poco::XML::Element > pcharge4 = pDoc ->createElement("ns1:labelstandardsLabelid");

Alexander Bonin75


pcharge4 ->setAttribute("xsi:type","xs:short");Poco::AutoPtr <Poco::XML::Text > pcharge4_text = pDoc ->

createTextNode(charge.lablestandard);pcharge4 ->appendChild(pcharge4_text);pcharge ->appendChild(pcharge4);// charge -> printcode

Poco::AutoPtr <Poco::XML::Element > pcharge5 = pDoc ->createElement("ns1:printcode");

pcharge5 ->setAttribute("xsi:type","xs:string");if (charge.printcode != "") {

Poco::AutoPtr <Poco::XML::Text > pcharge5_text =pDoc ->createTextNode(charge.printcode);


// charge -> sellerPoco::AutoPtr <Poco::XML::Element > pcharge6 = pDoc ->

createElement("ns1:seller");pcharge6 ->setAttribute("xsi:type","xs:string");

Poco::AutoPtr <Poco::XML::Text > pcharge6_text = pDoc ->createTextNode(charge.seller);

pcharge6 ->appendChild(pcharge6_text);pcharge ->appendChild(pcharge6);// charge -> spezies





// charge -> typePoco::AutoPtr <Poco::XML::Element > pcharge8 = pDoc ->

createElement("ns1:type");pcharge8 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pcharge8_text = pDoc ->

createTextNode(charge.type);pcharge8 ->appendChild(pcharge8_text);pcharge ->appendChild(pcharge8);

// info feld anlegen

Alexander Bonin76


Poco::AutoPtr <Poco::XML::Element > pinfo = pDoc ->createElement("ns1:info");

pinco ->appendChild(pinfo);

//info -> buyerPoco::AutoPtr <Poco::XML::Element > pinfo1 = pDoc ->

createElement("ns1:buyer");pinfo1 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pinfo1_text = pDoc ->

createTextNode(info.buyer);pinfo1 ->appendChild(pinfo1_text);pinfo ->appendChild(pinfo1);

//info -> chargeIdPoco::AutoPtr <Poco::XML::Element > pinfo2 = pDoc ->

createElement("ns1:chargeId");pinfo2 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pinfo2_text = pDoc ->

createTextNode(info.chargeid);pinfo2 ->appendChild(pinfo2_text);pinfo ->appendChild(pinfo2);

//info -> quantityUnitidPoco::AutoPtr <Poco::XML::Element > pinfo3 = pDoc ->

createElement("ns1:quantityUnitid");pinfo3 ->setAttribute("xsi:type","xs:short");Poco::AutoPtr <Poco::XML::Text > pinfo3_text = pDoc ->

createTextNode(info.quantityUnitID);pinfo3 ->appendChild(pinfo3_text);pinfo ->appendChild(pinfo3);

//info -> quantityValuePoco::AutoPtr <Poco::XML::Element > pinfo4 = pDoc ->

createElement("ns1:quantityValue");pinfo4 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pinfo4_text = pDoc ->

createTextNode(info.quantityValue);pinfo4 ->appendChild(pinfo4_text);pinfo ->appendChild(pinfo4);

return pDoc;}

Poco::AutoPtr <Poco::XML::Document > sendCancellations_bmg(Poco::XML:: XMLString ticket_id ,struct charge_st charge){


XML:: Document;

Alexander Bonin77








pUri_def ->setAttribute("xmlns:axis2","http ://webservice/bmg/blitz/net/");




pUri_def ->setAttribute("xmlns:wsaw","http ://www.w3.org /2006/05/ addressing/wsdl");



pUri_def ->setAttribute("xmlns:xsi","http :// www.w3.org/2001/ XMLSchema -instance");

pDoc ->appendChild(pUri_def);



// sendCancellations Element als unterElement vom Bodyanlegen

Poco::AutoPtr <Poco::XML::Element > pfunction = pDoc ->createElement("ns1:sendCancellations");



// ticket_id wird übergeben

Alexander Bonin78






createElement("ns1:cancellations");pfunction ->appendChild(pinco);// charge feld anlegen

Poco::AutoPtr <Poco::XML::Element > pcharge = pDoc ->createElement("ns0:charge");

pinco ->appendChild(pcharge);

// charge -> articlePoco::AutoPtr <Poco::XML::Element > pcharge1 = pDoc ->

createElement("ns2:article");pcharge1 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pcharge1_text = pDoc ->

createTextNode(charge.article);pcharge1 ->appendChild(pcharge1_text);pcharge ->appendChild(pcharge1);// charge -> bmgnumber

Poco::AutoPtr <Poco::XML::Element > pcharge2 = pDoc ->createElement("ns2:bmgnumber");


createTextNode(charge.bmgnumber);pcharge2 ->appendChild(pcharge2_text);pcharge ->appendChild(pcharge2);// charge -> bmgrootid

Poco::AutoPtr <Poco::XML::Element > pcharge3 = pDoc ->createElement("ns2:bmgrootid");


createTextNode(charge.bmgrootid);pcharge3 ->appendChild(pcharge3_text);pcharge ->appendChild(pcharge3);// charge -> labelstandartsLabelid

Poco::AutoPtr <Poco::XML::Element > pcharge4 = pDoc ->createElement("ns2:labelstandardsLabelid");

pcharge4 ->setAttribute("xsi:type","xs:short");

Alexander Bonin79


Poco::AutoPtr <Poco::XML::Text > pcharge4_text = pDoc ->createTextNode(charge.lablestandard);

pcharge4 ->appendChild(pcharge4_text);pcharge ->appendChild(pcharge4);// charge -> printcode

Poco::AutoPtr <Poco::XML::Element > pcharge5 = pDoc ->createElement("ns2:printcode");

pcharge5 ->setAttribute("xsi:type","xs:string");if (charge.printcode != "") {

Poco::AutoPtr <Poco::XML::Text > pcharge5_text =pDoc ->createTextNode(charge.printcode);

pcharge5 ->appendChild(pcharge5_text);}pcharge ->appendChild(pcharge5);// charge -> sellerPoco::AutoPtr <Poco::XML::Element > pcharge6 = pDoc ->

createElement("ns2:seller");pcharge6 ->setAttribute("xsi:type","xs:string");

Poco::AutoPtr <Poco::XML::Text > pcharge6_text = pDoc ->createTextNode(charge.seller);

pcharge6 ->appendChild(pcharge6_text);pcharge ->appendChild(pcharge6);// charge -> spezies





// charge -> typePoco::AutoPtr <Poco::XML::Element > pcharge8 = pDoc ->

createElement("ns2:type");pcharge8 ->setAttribute("xsi:type","xs:string");Poco::AutoPtr <Poco::XML::Text > pcharge8_text = pDoc ->

createTextNode(charge.type);pcharge8 ->appendChild(pcharge8_text);pcharge ->appendChild(pcharge8);

return pDoc;}

Alexander Bonin80


A.8 xml_results.h

Listing A.8: Funktionen zum Auswerten der SOAP Response Headerdatei#include <ADSbase.h>#include "functions.h"#include "Poco/AutoPtr.h"

// Ausnahmebehandlung#include "Poco/Exception.h"

#include "Poco/DOM/DOMWriter.h"#include "Poco/XML/XMLWriter.h"#include "Poco/DOM/DOMParser.h"#include "Poco/XML/XMLStream.h"#include "Poco/DOM/ProcessingInstruction.h"#include "Poco/DOM/Document.h"#include "Poco/DOM/Element.h"#include "Poco/DOM/Text.h"

// includes zum navigieren durch XML Doumente#include "Poco/DOM/Node.h"#include "Poco/DOM/NodeIterator.h"#include "Poco/DOM/NodeFilter.h"

// inputsource 2 xml parser include#include "Poco/SAX/InputSource.h"

// gibt die Ticketid der Antwort auf Login zurückstd:: string login_response(Poco::AutoPtr <Poco::XML::

Document > req);

//gibt die Antwort auf logout zurückstd:: string logout_response(Poco::AutoPtr <Poco::XML::

Document > req);

//gibt die Antwort auf getMasterData zurückbool getmasterdata_response_us(Poco::AutoPtr <Poco::XML::

Document > req ,CADSDataList* pDataList);bool getmasterdata_response_buyer(Poco::AutoPtr <Poco::XML

::Document > req ,CADSDataList* pDataList);

//gibt die Antwort auf sendIncommings zurückstd:: string sendincommings_response(Poco::AutoPtr <Poco::

XML::Document > req);

Alexander Bonin81


//gibt die Antwort auf sendCancellations zurückstd:: string sendcancellations_response(Poco::AutoPtr <Poco

::XML::Document > req);

//gibt die Antwort auf getbmgnumbers zurückstd:: string getbmgnumbers_response(Poco::AutoPtr <Poco::

XML::Document > req);

A.9 xml_results.cpp

Listing A.9: Funktionen zum Auswerten der SOAP Response#include "stdafx.h"#include "xml_results.h"#include "structs.h"#include "functions.h"

std:: string login_response(Poco::AutoPtr <Poco::XML::Document > req) {std:: string return_string = "";


Poco::XML::Node* pNode = it.nextNode ();while (pNode){

if (pNode ->nodeName ()=="ns:return") {return_string = pNode ->innerText (); }

pNode = it.nextNode ();}return return_string;

}

std:: string logout_response(Poco::AutoPtr <Poco::XML::Document > req){std:: string return_string = "";


Poco::XML::Node* pNode = it.nextNode ();while (pNode){

if (pNode ->nodeName ()=="ns:return") {

Alexander Bonin82


return_string = pNode ->innerText ();}pNode = it.nextNode ();

}

return return_string;}

bool getmasterdata_response_us(Poco::AutoPtr <Poco::XML::Document > req ,CADSDataList* pDataList) {


Poco::XML::Node* pNode = it.nextNode ();int counter = pDataList ->GetDataRecordCount ();

std::vector <us_liste > us_vec;us_liste temp_us;

try {while (pNode){

//liest die standard Tabelle ausif ((pNode ->nodeName ()=="ns:name" || pNode ->

nodeName ()=="ns:labelid") & pNode ->parentNode ()->nodeName () == "ns:standard"){if (pNode ->nodeName ()=="ns:labelid") {

temp_us.id=pNode ->innerText ().c_str();

// pDataValue = pDataRecord ->GetDataValue (" BMGID");

}if (pNode ->nodeName ()=="ns:name") {

temp_us.name=pNode ->innerText ().c_str();

// pDataValue = pDataRecord ->GetDataValue (" BMGBEZ ");

temp_us.tid="s";// pDataValue = pDataRecord ->

GetDataValue (" BMTID");

Alexander Bonin83


us_vec.push_back(temp_us);}

}

//liest die unit Tabelle aus

if ((pNode ->nodeName ()=="ns:name" || pNode ->nodeName ()=="ns:unitid") & pNode ->parentNode ()->nodeName () == "ns:unit") {if (pNode ->nodeName ()=="ns:name") {

temp_us.name=pNode ->innerText ().c_str();

}if (pNode ->nodeName ()=="ns:unitid") {

temp_us.id=pNode ->innerText ().c_str();

temp_us.tid="u";us_vec.push_back(temp_us);}

}//liest die Artikel Tabelle ausif (pNode ->nodeName ()=="ns:artikel" & pNode ->

parentNode ()->nodeName () == "ns:product"){temp_us.name=pNode ->innerText ().c_str();}

if (pNode ->nodeName ()=="ns:bmgrootid" & pNode->parentNode ()->nodeName () == "ns:product") {temp_us.id=pNode ->innerText ().c_str();temp_us.tid="p";us_vec.push_back(temp_us);}

pNode = it.nextNode ();}// vector zu datavalues schreibenCADSDataRecord* pDataRecord;int writecount =0;for( std::vector < us_liste >:: size_type i = 0;i <

us_vec.size();i++ ) {

if (! existDataValue(pDataList ,"BMGID",us_vec[i].id)){

Alexander Bonin84


pDataList ->AddDataRecord(counter+writecount);

pDataRecord = pDataList ->GetDataRecord(counter+writecount);

pDataRecord ->GetDataValue("BMGID")->SetStringValue(us_vec[i].id);

pDataRecord ->GetDataValue("BMGBEZ")->SetStringValue(us_vec[i].name);

pDataRecord ->GetDataValue("BMGTID")->SetStringValue(us_vec[i].tid);

writecount ++;}

}return true;


return false;}

}

bool getmasterdata_response_buyer(Poco::AutoPtr <Poco::XML::Document > req ,CADSDataList* pDataList) {



Poco::XML::Node* pNode = it.nextNode ();// starte zaehlschleife für eintraegetry {

std::vector <buyer > buyer_vec;buyer temp_buyer ;while (pNode){

//liest die buyer tabelle ausif (pNode ->nodeName ()=="ns:city" & pNode ->

parentNode ()->nodeName () == "ns:buyer") {//std::cout << "Stadt: " << pNode ->

innerText () << std::endl;temp_buyer.city=pNode ->innerText ();// pDataValue = pDataRecord ->GetDataValue

("ORT");

}

Alexander Bonin85


if (pNode ->nodeName ()=="ns:countrycode" &pNode ->parentNode ()->nodeName () == "ns:buyer") {//std::cout << "Staedecode: " << pNode ->

innerText () << std::endl;temp_buyer.countrycode=pNode ->innerText ()

;}if (pNode ->nodeName ()=="ns:holdingnumber" &

pNode ->parentNode ()->nodeName () == "ns:buyer") {temp_buyer.holdingnumber=pNode ->innerText

();}if (pNode ->nodeName ()=="ns:name" & pNode ->

parentNode ()->nodeName () == "ns:buyer") {temp_buyer.name=pNode ->innerText ();

}if (pNode ->nodeName ()=="ns:name2" & pNode ->

parentNode ()->nodeName () == "ns:buyer") {temp_buyer.name2=pNode ->innerText ();}

if (pNode ->nodeName ()=="ns:postalcode" &pNode ->parentNode ()->nodeName () == "ns:buyer") {temp_buyer.postalcode=pNode ->innerText ();

}if (pNode ->nodeName ()=="ns:street" & pNode ->

parentNode ()->nodeName () == "ns:buyer") {temp_buyer.street=pNode ->innerText ();

}if (pNode ->nodeName ()=="ns:typeid" & pNode ->

parentNode ()->nodeName () == "ns:buyer") {temp_buyer.type_id=pNode ->innerText ();buyer_vec.push_back(temp_buyer);

}pNode = it.nextNode ();

}

// vector zu datavalues schreibenCADSDataRecord* pDataRecord;// CADSDataValue* pDataValue;CString bmg = "bmg_";

int writecount =0;

Alexander Bonin86


for( std::vector < buyer >::size_type i = 0;i <buyer_vec.size();i++ ) {

if (! existDataValue(pDataList ,"BMGNR",buyer_vec[i]. holdingnumber.c_str())){

pDataList ->AddDataRecord(counter+writecount);

pDataRecord = pDataList ->GetDataRecord(counter+writecount);


pDataRecord ->GetDataValue("PNR")->SetStringValue(bmg+buyer_vec[i].holdingnumber.c_str());


pDataRecord ->GetDataValue("ORT")->SetStringValue(buyer_vec[i].city.c_str());

pDataRecord ->GetDataValue("NAME")->SetStringValue(buyer_vec[i].name.c_str());

pDataRecord ->GetDataValue("PLZ")->SetStringValue(buyer_vec[i]. postalcode.c_str());

pDataRecord ->GetDataValue("STR_NR")->SetStringValue(buyer_vec[i]. street.c_str());

pDataRecord ->GetDataValue("STELLUNG")->SetStringValue("P");

writecount ++;}

}return true;


return false;}

}

Alexander Bonin87


std:: string getbmgnumbers_response(Poco::AutoPtr <Poco::XML::Document > req) {std:: string return_string="";Poco::XML:: NodeIterator it(req , Poco::XML:: NodeFilter

:: SHOW_ELEMENT);Poco::XML::Node* pNode = it.nextNode ();int counter =0;

while (pNode){

if (pNode ->nodeName ()=="return") {

return_string=pNode ->innerText ();}pNode = it.nextNode ();

}


std:: string sendincommings_response(Poco::AutoPtr <Poco::XML::Document > req){std:: string return_string="";


Poco::XML::Node* pNode = it.nextNode ();int counter =0;

while (pNode){



}


std:: string sendcancellations_response(Poco::AutoPtr <Poco::XML::Document > req) {std:: string return_string="";Poco::XML:: NodeIterator it(req , Poco::XML:: NodeFilter

:: SHOW_ELEMENT);Poco::XML::Node* pNode = it.nextNode ();

Alexander Bonin88


int counter =0;

while (pNode){



}


Alexander Bonin89

B Anhang

B.1 Telefonprotokoll Bio mit GesichtTelefonat Frank Wörner Bio mit Gesicht.Wie ist die Anmeldung bei Bio mit Gesicht gestaltet? Der Teilnehmer nimmt Kon-takt mit Bio mit Gesicht auf und übersendet einen Antrag. Dieser beinhaltet dieArtikel sowie die Marktpartner welche auf Bio mit Gesicht Seite eingestellt werden.

Wie ist die Form der Artikel und Marktpartnerlisten. Es gibt keine allgemeine Formmeist werden diese in Form von Exceltabellen eingeliefert, eine Liste als PDF oderAusdruck wäre aber auch in Ordnung.

Welche Informationen werden in den Listen benötigt. Die Artikelliste benötigt diefolgenden Informationen:

• Artikelbezeichnung intern

• Artikelbezeichnung extern

• Abrechnungseinheit

Die Marktpartnerliste benötigt lediglich den Namen und die Anschrift des Markt-partners. Der Markpartner muss nicht zwangsläufig an Bio mit Gesicht Teilnehmen.

Allgemeine Erfahrungen mit der Anbindung eSchlagKartein an Bio mit Gesicht.Bisher gibt es mit der Anbindung keine Erfahrungen es gibt Interesse von verschie-denen Seiten aber keine realisierte Lösung. Kritische Anmerkung gibt es von einigeneSchlagKartei Lösung in der Hinsicht das wohl keine Lagerausbuchung mit Mengenin der SchlagKartei realisiert ist oder diese nicht genutzt wird.

B.2 Bio-mit-Gesicht Schnittstellenbeschreibung

Alexander Bonin90

Bio mit Gesicht Schnittstelle - Webservice - Beschreibung

bmg_schnittstelle_beschreibung_V02_091124.doc Version 0.2 vom 24.11.2009 1 von 11

Inhalt 1 Änderungen 1

2 Vorbemerkung 2 2.1 Grundsätzliches zur Schnittstelle 2 2.2 Validierung der XML-Dokumente 2 2.3 Relationaler Aufbau 2 2.4 Encoding 2

3 Webservice Methoden 3 3.1 logIn 4 3.2 logOut 4 3.3 getMasterData 5 3.3.1 Supplier 5 3.3.2 Buyer 5 3.3.3 Product 6 3.3.4 Unit 6 3.3.5 Standard 7 3.3.6 Quality 7 3.4 getBmgNumbers 7 3.5 Übertragen der Bewegungsdaten 8 3.5.1 Chargenführung 8 3.5.2 sendIncomings 8 3.6 sendCancellations 11 3.7 getVersion 11

1 Änderungen

Version Datum Anmerkung 0.2 24.11.09 getMasterDat Liste „Company“ aufgespalten

in „Supplier“ und „Buyer“

Abbildungsverzeichnis

3.1 Aufbau der Daten in Elsa-Öko . . . . . . . . . . . . . . . . . . . . . . 133.2 BMG Login Flussdiagramm . . . . . . . . . . . . . . . . . . . . . . . 143.3 BMG Logout Flussdiagramm . . . . . . . . . . . . . . . . . . . . . . 143.4 BMG Synchronisation Flussdiagramm . . . . . . . . . . . . . . . . . . 153.5 BMG Übertragen Flussdiagramm . . . . . . . . . . . . . . . . . . . . 153.6 BMG Löschen Flussdiagramm . . . . . . . . . . . . . . . . . . . . . . 16

Alexander Bonin92

Tabellenverzeichnis

3.1 SOAP Framework Übersicht . . . . . . . . . . . . . . . . . . . . . . . 93.2 Schnittstellenbeschreibung Login . . . . . . . . . . . . . . . . . . . . 103.3 Schnittstellenbeschreibung Logout . . . . . . . . . . . . . . . . . . . . 113.4 Schnittstellenbeschreibung Synchronisieren . . . . . . . . . . . . . . . 113.5 Schnittstellenbeschreibung Senden . . . . . . . . . . . . . . . . . . . . 123.6 Schnittstellenbeschreibung Löschen . . . . . . . . . . . . . . . . . . . 12

Alexander Bonin93

Listings

1.1 XML Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2 XML Beispiel eines SOAP Requests . . . . . . . . . . . . . . . . . . . 3

4.1 Initiale Aktionen beim Laden der DLL . . . . . . . . . . . . . . . . . 174.2 Funktion zum Bekanntmachen der Modulinformationen . . . . . . . . 174.3 Veröffentlichen von Modulinformationen . . . . . . . . . . . . . . . . 184.4 Funktion zum Verbindungstest mit „Bio mit Gesicht“. . . . . . . . . . 194.5 Funktion zum Holen der „Bio mit Gesicht“ Masterdaten. . . . . . . . 204.6 Funktion zum Übertragen der Bewegungsdaten. . . . . . . . . . . . . 214.7 Strukturierte Datentypen der sendbmg Funktion. . . . . . . . . . . . 244.8 Funktion zum stornieren von Bewegungsdaten. . . . . . . . . . . . . . 264.9 Funktion zum senden aller markierten Bewegungsdaten. . . . . . . . . 274.10 Generieren des incommings XML-Dokumentes . . . . . . . . . . . . . 294.11 Strukturierte Datentypen für sendIncommings . . . . . . . . . . . . . 314.12 Auslesen der Buyer Information aus dem Masterdata XML . . . . . . 334.13 Aufbau des Vectors für Buyer Informationen . . . . . . . . . . . . . . 344.14 XML Übertragung per HTTP . . . . . . . . . . . . . . . . . . . . . . 354.15 Umwandlung eines XML Dokumentes in einen String . . . . . . . . . 374.16 Umwandlung eines Strings in ein XML Dokument . . . . . . . . . . . 384.17 Prüfen auf Netzverfügbarkeit . . . . . . . . . . . . . . . . . . . . . . . 394.18 Beispiel für einen Unit Eintrag . . . . . . . . . . . . . . . . . . . . . . 404.19 Mappen unterschiedlicher Einheitenbezeichner . . . . . . . . . . . . . 404.20 Auffinden eines Wertes in den Gesamtdaten . . . . . . . . . . . . . . 414.21 Auslesen der ID Werte von Bio mit Gesicht . . . . . . . . . . . . . . . 42

A.1 Inhalt der BMGModul Headerdatei . . . . . . . . . . . . . . . . . . . 45A.2 Inhalt der BMGModul.cpp . . . . . . . . . . . . . . . . . . . . . . . . 46A.3 Inhalt der functions Headerdatei . . . . . . . . . . . . . . . . . . . . . 58A.4 Inhalt der functions.cpp . . . . . . . . . . . . . . . . . . . . . . . . . 60A.5 Definition der strukturierten Datentypen . . . . . . . . . . . . . . . . 64A.6 Funktionen zum generieren von XML Dokumenten Headerdatei . . . 65A.7 Funktionen zum generieren von XML Dokumenten . . . . . . . . . . 67A.8 Funktionen zum Auswerten der SOAP Response Headerdatei . . . . . 81A.9 Funktionen zum Auswerten der SOAP Response . . . . . . . . . . . . 82

Alexander Bonin94

Eidesstattliche Erklärung

Ich versichere an Eides Statt durch meine eigenhändige Unterschrift, dass ich dievorliegende Arbeit selbstständig und ohne fremde Hilfe angefertigt habe. Alle Stel-len, die wörtlich oder dem Sinn nach auf Publikationen oder Vorträgen andererAutoren beruhen, sind als solche kenntlich gemacht. Ich versichere außerdem, dassich keine andere als die angegebene Literatur verwendet habe. Diese Versicherungbezieht sich auch auf alle in der Arbeit enthaltenen Zeichnungen, Skizzen, bildlichenDarstellungen und dergleichen.

Die Arbeit wurde bisher keiner anderen Prüfungsbehörde vorgelegt und auch nochnicht veröffentlicht.

Erfurt,den 8. Oktober 2011

Ort, Datum Alexander Bonin

Alexander Bonin95

Documents

Analyse, Design und Implementie-rung einer Softwarekomponenteals Schnittstelle einer Schlag-dokumentationssoftware zur Daten-übermittlung an Bio mit Gesicht