![\"Datenmodell](\"..\/fileadmin\/_temp_\/2022_05\/pic_1395_001.png\")
<\/p>\nNachdem wir im ersten Teil dieser Beitragsreihe gezeigt haben, wie Sie aus Daten wie Kundeninformationen, Rechnungsdatum und Rechnungspositionen ein XML-Dokument im XRechnung-Format erstellen, wollen wir in diesem Beitrag den umgekehrten Weg gehen: Wir wollen die Daten aus einer so generierten Rechnung auslesen und zurück in das Datenmodell schreiben. Dazu sind vor allem Fähigkeiten im Auslesen von XML-Dokumenten erforderlich – und der Umgang mit Namespace-Deklarationen in diesen Dokumenten. Nach der Lektüre dieses Beitrags sind Sie in der Lage, die Daten aus einer XRechnung automatisiert in ein entsprechendes Datenmodell einzulesen.<\/b><\/p>\nAusgangssituation<\/h2>\n
Für bestimmte Empfänger müssen Rechnungen mittlerweile in einem automatisiert lesbaren Format vorliegen, zum Beispiel im Format XRechnung<\/b>. Dieses Format hat gegenüber Rechnungen im PDF-Format den Vorteil, dass alle Informationen an der entsprechenden in der vorgegebenen XML-Struktur zu finden sind und diese somit maschinell verarbeitet werden können. Im Beitrag XRechnung, Teil 1: Rechnungen generieren <\/b>(www.access-im-unternehmen.de\/1277<\/b>) haben wir die Daten aus einer Rechnungsverwaltung per Knopfdruck in ein solches Dokument geschrieben.<\/p>\n
Nun ist es zu erwarten und auch wünschenswert, dass sich solche Formate allgemein durchsetzen, damit niemand mehr Rechnungen in gedruckter Form oder als PDF entgegennehmen und diese händisch verarbeiten muss. Deshalb werden früher oder später alle Unternehmen in der Lage sein müssen, solche Rechnungen zu verarbeiten.<\/p>\n
Im vorliegenden Beitrag wollen wir die Daten aus einem solchen XRechnung-Dokument in ein vorgegebenes Datenmodell einlesen können. In einem weiteren Beitrag schauen wir uns dann an, wie wir die eingelesenen Daten in einem Bericht als herkömmliche Rechnung, lesbar für das menschliche Auge, präsentieren können.<\/p>\n
Im Vergleich zum Datenmodell des ersten Teils der Beitragsreihe haben wir die Tabelle tblRechnungen <\/b>leicht angepasst. Wir haben ein Feld namens Rechnungsnummer<\/b> zum Speichern der jeweiligen Rechnungsnummer hinzugefügt und das Feld RechnungID <\/b>mit dem Datentyp Autowert <\/b>versehen. Zuvor mussten wir die Beziehung zwischen dem Feld RechnungID <\/b>der Tabelle tblPositionen <\/b>und der Tabelle tblRechnungen <\/b>löschen und diese anschließend erneut anlegen.<\/p>\n
Außerdem haben wir der Tabelle tblPositionen <\/b>noch ein Feld namens Position <\/b>hinzugefügt, mit dem die in der XRechnung angegebenen Positionsnummern gespeichert werden können, sowie ein Feld namens Einheit<\/b>.<\/p>\nBeispielhafter Import<\/h2>\n
Der Standard der XRechnung umfasst natürlich alle denkbaren Informationen. Diese können wir im Rahmen dieses Beitrags nicht alle erfassen. Es geht hier allein darum, die grundlegenden Techniken für die Erfassung der gängigsten Informationen zu präsentieren.<\/p>\n
Wenn Sie oder Ihre Kunden es mit Daten in XRechnungen zu tun bekommen, deren Übertragung hier nicht berücksichtigt wurde, so lernen Sie dennoch die Techniken, die nötig sind, die notwendigen Ergänzungen vorzunehmen.<\/p>\n
Das Datenmodell finden Sie in Bild 1. Jede Rechnung wird grundsätzlich in der Tabelle tblRechnungen <\/b>erfasst und enthält dort einige grundlegende Daten wie das Rechnungsdatum, den Rechnungstyp, die Währung, eine Kundenreferenz sowie Verweise auf den Käufer und den Verkäufer. Käufer und Verkäufer werden in je einem Datensatz der Tabelle tblKontakte <\/b>gespeichert und über Fremdschlüsselfelder der Tabelle tblRechnungen <\/b>zugewiesen. Der Rechnungstyp wird aus einer Tabelle namens tblRechnungstypen <\/b>ausgewählt.<\/p>\n
<\/p>\n
Bild 1: Datenmodell für die Daten aus einer XRechnung<\/span><\/b><\/p>\n Die einzelnen Rechnungspositionen landen schließlich in der Tabelle tblPositionen<\/b>, die über das Fremdschlüsselfeld RechnungID <\/b>dem jeweiligen Datensatz aus der Tabelle tblRechnungen <\/b>zugewiesen werden.<\/p>\n Jede Position enthält Bezeichnung, Einzelpreis, Mehrwertsteuersatz und Menge, wobei der Mehrwertsteuersatz wiederum über ein Fremdschlüsselfeld aus der Tabelle tblMehrwertsteuersaetze <\/b>ausgewählt wird.<\/p>\n Der Anfang des XRechnung-Dokuments sieht wie in Listing 1 aus. Hier sehen wir zunächst das Root-Element ubl<\/b>, das einige Namespaces aufweist, um die wir uns später explizit kümmern werden.<\/p>\n Listing 1: Basisdaten der Rechnung im XML-Dokument<\/span><\/b><\/p>\n Als erste untergeordnete Elemente folgen nun bereits die grundlegenden Rechnungsdaten. Das Element cbc:CustomizationID <\/b>liefert das Format, in dem die Rechnung verfasst wurde, hier in der Version 1.2.<\/p>\n Das Element cbc:ID <\/b>liefert die Rechnungsnummer, cbc:IssueDate <\/b>das Rechnungsdatum. Mit dem Wert 380 <\/b>im Feld cbc:InvoiceTypeCode <\/b>erhalten wir einen Hinweis auf die Art der Rechnung. 380<\/b> steht für Commercial Invoice<\/b>.<\/p>\n Das Element cbc:DocumentCurrencyCode <\/b>liefert das Kürzel für die Währung der Rechnung. In der Regel finden wir hier die Einstellung EUR <\/b>für Euro vor. Das Feld cbc:BuyerReference <\/b>nimmt die sogenannte Leitweg-ID auf.<\/p>\n Außerdem gibt es noch einige weitere Elemente für verschiedene Referenzen wie OrderReference<\/b>, ContractDocumentReference<\/b>, ProjectReference <\/b>et cetera, die wir an dieser Stelle jedoch nicht verarbeiten wollen.<\/p>\n Wir wollen den Einlesevorgang zunächst VBA-gesteuert ausführen, daher erstellen wir zuerst eine Prozedur, mit der wir die einzulesende Datei per Dateiauswahl-Dialog ermitteln und dann die eigentliche Prozedur zum Einlesen aufrufen. Die Prozedur zum Initialisieren des Einlesevorgangs sieht wie folgt aus:<\/p>\n Die Funktion OpenFileName <\/b>finden Sie im Modul mdlFileDialog<\/b>.<\/p>\n Danach starten wir mit der Funktion XRechnungEinlesen <\/b>den eigentlichen Einlesevorgang. Dazu prüfen wir in einer If…Then<\/b>-Bedingung zunächst, ob ein Dateipfad mit strPfad <\/b>übergeben wurde und ob die Datei überhaupt vorhanden ist (siehe Listing 2).<\/p>\n Listing 2: Startprozedur zum Einlesen der XRechnung<\/span><\/b><\/p>\n Ist das der Fall, erstellt die Funktion ein neues Objekt des Typs MSXML2.DOMDocument60<\/b>. Um diese verwenden zu können, benötigen wir einen Verweis auf die Bibliothek Microsoft XML, v6.0<\/b>, die wir im Verweise<\/b>-Fenster, das wir mit dem Menübefehl Extras|Verweise <\/b>des VBA-Editors öffnen, markieren müssen (siehe Bild 2).<\/p>\n Bild 2: Hinzufügen eines Verweises auf die XML-Bibliothek<\/span><\/b><\/p>\n Nun kommt ein entscheidender Schritt, ohne den wir dieses mit einigen Namespace-Präfixen gespickte XML-Dokument nicht einlesen können: Wir stellen die Eigenschaft SelectionNamespaces <\/b>mit der Methode SetProperty <\/b>auf einen Wert ein, der die Definition der im Element ubl:Invoice <\/b>des XML-Dokuments angegebenen Namespaces enthält.<\/p>\n Danach können wir die Load<\/b>-Methode des Objekts objXML <\/b>nutzen, um die unter strPfad <\/b>angegebene XRechnung zu laden. Dann referenzieren wir das Root-Element, das wir mit objXML.childNodes.Item(0) <\/b>ermitteln, mit der Variablen objInvoice<\/b> und übergeben diese an die erste Unterfunktion RechnungsdatenEinlesen<\/b>. Dieser übergeben wir auch den zuvor mit CurrentDb <\/b>ermittelten Verweis auf das Database<\/b>-Objekt der aktuellen Datenbankdatei.<\/p>\n Die Funktion RechnungsdatenEinlesen <\/b>soll nach erfolgreichem Einlesen in die Tabelle tblRechnungen <\/b>den Primärschüsselwert des neu erstellten Datensatzes zurückliefern, den wir wiederum als Rückgabewert der aufrufenden Funktion XRechnungEinlesen <\/b>festlegen.<\/p>\n Die Funktion RechnungsdatenEinlesen <\/b>erwartet das Root-Element sowie einen Verweis auf das aktuelle Database<\/b>-Objekt als Parameter (siehe Listing 3).<\/p>\n Listing 3: Hauptprozedur zum Einlesen der Rechnungsdaten<\/span><\/b><\/p>\n Sie deklariert einige Variablen des Typs IXMLDOMNode<\/b>, um Unterelemente von objInvoice <\/b>aufzunehmen, sowie ein Element des Typs IXMLDOMNodeList <\/b>für die Rechnungspositionen in der XRechnung. Außerdem benötigen wir eine Recordset<\/b>-Variable namens rst<\/b>, der wir die Tabelle tblRechnungen <\/b>zuweisen und über die wir den neuen Rechnungsdatensatz anlegen. Daneben dienen einige weitere Variablen wie strID<\/b>, datIssueDate <\/b>et cetera dazu, die Werte aus der XRechnung nach dem Auslesen und vor dem Eintragen in den neuen Datensatz temporär aufzunehmen.<\/p>\n Die ersten Anweisungen lesen die Werte der entsprechenden Elemente aus der XRechnung ein. Dazu nutzen diese verschiedene Hilfsfunktionen, die wir am Ende des Beitrags beschreiben. Die erste heißt TextEinlesen<\/b> und sucht aus einem IXMLDomNode<\/b>-Element den Text des mit dem zweiten Parameter übergebenen Wertes aus – in der ersten Anweisung beispielsweise das Element cbc:ID<\/b>. Dieser Wert landet in der Variablen strID<\/b>. Das Gleiche geschieht mit den Elementen cbc:IssueDate<\/b>, cbc:InvoiceTypeCode<\/b>, cbc:DocumentCurrencyCode <\/b>und cbc:BuyerReference<\/b>. Damit erhalten wir die Basisdaten der Rechnung.<\/p>\n <\/p>\n Danach nutzen wir eine weitere Hilfsfunktion namens ElementEinlesen<\/b>, um das Unterelement mit dem Namen cac:AccountingCustomerParty\/cac:Party<\/b> mit der Variablen objKaeufer<\/b> zu referenzieren. Dieser Teilbereich der XRechnung sieht beispielsweise wie in Listing 4 aus.<\/p>\n Listing 4: Element mit den Daten des Rechnungsempfängers<\/span><\/b><\/p>\n Nachdem wir dieses Element aufgerufen haben, rufen wir die Funktion AdresseEinlesen <\/b>auf und übergeben dieser das IXMLDOMNode<\/b>-Element aus objKaeufer <\/b>sowie einen Verweis auf das Database<\/b>-Objekt. Der Übersicht halber beschreiben wir diese Funktion erst später. An dieser Stelle interessiert uns nur das Ergebnis dieser Funktion. Diese schreibt nämlich die Käuferdaten in die Tabelle tblKontakte <\/b>und liefert den Wert des Primärschlüssels des neu hinzugefügten Datensatzes zurück. Diesen können wir dann in der Variablen lngKaeuferID <\/b>zwischenspeichern und beim Erstellen eines neuen Rechnungsdatensatzes direkt in die Tabelle tblRechnungen <\/b>schreiben.<\/p>\n Auf die gleiche Weise lesen wir auch noch die Daten des Verkäufers ein. Diese finden wir im Element cac:AccountingSupplierParty\/cac:Party<\/b>. Auch für dieses Element rufen wir die Funktion AdresseEinlesen <\/b>auf, was dazu führt, dass auch der Verkäufer als neuer Datensatz in der Tabelle tblKontakte <\/b>landet. Den Primärschlüsselwert des neuen Datensatzes speichern wir in der Variablen lngVerkaeuferID<\/b>, um ihn später in der Tabelle tblRechnungen <\/b>zu speichern.<\/p>\n Mit der Variablen objPaymentMeans <\/b>des Typs IXMLDOMNode <\/b>referenzieren wir nun den folgenden Bereich der XRechnung, der die Zahlungsinformationen enthält:<\/p>\n Mit den hier enthaltenen Informationen und der ID des Verkäufers rufen wir dann die Prozedur ZahlungsinformationenSchreiben<\/b> auf. Diese fügt die Zahlungsinformationen wie die IBAN und den Kontoinhaber zum Datensatz des Verkäufers in der Tabelle tblKontakte <\/b>hinzu.<\/p>\n Damit haben wir alle notwendigen Informationen eingelesen und können nun zum Schreiben der Daten in die Tabelle tblRechnungen <\/b>schreiten. Das erledigen wir, indem wir ein neues Recordset auf Basis der Tabelle tblRechnungen<\/b> erstellen, dass aber keine Datensätze enthalten soll – deshalb das Kriterium 1=2<\/b>.<\/p>\n Hier fügen wir mit der AddNew<\/b>-Methode einen neuen Datensatz hinzu und füllen die Felder der Tabelle mit den zuvor ermittelten Werten – unter anderem auch die Fremdschlüsselfelder VerkaeuferID <\/b>und KaeuferID <\/b>mit den Primärschlüsselwerten der zuvor in der Tabelle tblKontakte <\/b>angelegten Datensätzen.<\/p>\n Im letzten Schritt vor dem Speichern des neuen Datensatzes mit der Update<\/b>-Methode schreiben wir noch den Primärschlüsselwert des neuen Datensatzes in die Variable lngRechnung<\/b>. Dieser Zeitpunkt ist wichtig, weil der Datensatzzeiger durch die Update<\/b>-Methode auf einen anderen Datensatz verschoben wird und der Autowert des erstellten Datensatzes nicht mehr verfügbar ist.<\/p>\n Nach dem Update folgt noch ein weiterer wichtiger Schritt: Mit der Hilfsfunktion ElementeEinlesen <\/b>(Beschreibung sieht weiter unten) lesen wir alle Elemente des Typs cac:InvoiceLine <\/b>in eine Variable des Typs IXMLDOMNodeList <\/b>ein. Diese übergeben wir dann samt der neuen Rechnungs-ID an die Prozedur PositionenEinlesen<\/b>, welche die einzelnen Rechnungspositionen aus der XRechnung in die Tabelle tblPositionen <\/b>schreibt und dabei gleich das Fremdschlüsselfeld RechnungID <\/b>mit dem Primärschlüsselfeld der soeben erstellten Rechnung füllt.<\/p>\n Zum Abschluss geben wir den Primärschüsselwert des neuen Datensatzes in der Tabelle tblRechnungen <\/b>an die aufrufende Funktion XRechnungEinlesen <\/b>zurück.<\/p>\n Den Einsatzzweck der Funktion AdresseEinlesen <\/b>haben wir bereits weiter oben vorgestellt. Die Funktion soll die Daten von Käufern und Verkäufern in der Tabelle tblKontakte <\/b>speichern und den Primärschlüsselwert des gegebenenfalls neu erstellten Datensatzes zurückliefern, damit dieser als Wert für eines der Fremdschlüsselfelder KaeuferID <\/b>oder VerkaeuferID <\/b>gespeichert werden kann (siehe Listing 5). Dazu übergeben wir der Funktion das IXMLDOMNode<\/b>-Element mit den Daten der jeweiligen Partei sowie den Verweis auf das aktuelle Database<\/b>-Objekt.<\/p>\n Listing 5: Funktion zum Anlegen eines Kontaktes in der Tabelle tblKontakte<\/span><\/b><\/p>\n Die Funktion deklariert einige Variablen zum Zwischenspeichern der ermittelten Daten. Sie liest die Elemente in der Reihenfolge ein, in der sie in der XRechnung auftauchen. Also beginnen wir mit der Straße, die wir über die Hilfsfunktion TextEinlesen <\/b>mit dem zu untersuchenden Elementnamen cac:PostalAddress\/cbc:Streetname <\/b>einlesen und in der Variablen strStreetName <\/b>speichern. Auf die gleiche Weise speichern wir den Namen der Stadt, das Kürzel für das Land, die PLZ, die Umsatzsteuer-Identifikationsnummer, den Firmennamen, den Namen des Ansprechpartners, die Telefonnummer und die E-Mail in entsprechenden Variablen.<\/p>\n Wir gehen an dieser Stelle davon aus, dass wir die Umsatzsteuer-Identifikationsnummer als eindeutiges Merkmal voraussetzen können. Das ist deswegen interessant, weil ja auch mehrere Leistungen vom gleichen Anbieter in Rechnung gestellt werden könnten. Wir wollen diesen Anbieter dann nicht immer wieder neu in der Tabelle tblKontakte <\/b>speichern, sondern der neuen Rechnung den bestehenden Eintrag verwenden. Deshalb versuchen wir, ein Recordset auf Basis der Tabelle tblKontakte <\/b>zu erstellen, das einen Datensatz mit der entsprechenden Umsatzsteuer-Identifikationsnummer enthält. Mit der anschließenden If…Then<\/b>-Bedingung prüfen wir den Wert der Eigenschaft EOF <\/b>des Recordsets. Ist dieser True<\/b>, befindet sich der Datensatzzeiger am Ende des Recordsets und somit ist kein Datensatz im Recordset rst <\/b>enthalten. Also legen wir mit AddNew <\/b>einen neuen Datensatz an. Liefert rst.EOF <\/b>hingegen den Wert False<\/b>, ist ein Datensatz vorhanden und wir können diesen mit den aktuellen Daten überschreiben. In diesem Fall schalten wir diesen Datensatz mit der Edit<\/b>-Methode in den Bearbeitungsmodus.<\/p>\n Unabhängig davon, ob wir einen neuen Datensatz angelegt haben oder ob wir einen vorhandenen Kontakt bearbeiten, schreiben wir nun mit der letzten Rechnung gelieferten Daten in die Tabelle. Für strCountry <\/b>haben wir nur das Kürzel für das Land erhalten, zum Beispiel DE<\/b>.<\/p>\n In der Tabelle tblLaender <\/b>haben wir diese Kürzel in einem eigenen Feld gespeichert, sodass wir die ID des entsprechenden Datensatzes der Tabelle tblLaender <\/b>mit der DLookup<\/b>-Funktion ermitteln und dann in das Feld LandID <\/b>schreiben können.<\/p>\n Schließlich schreiben wir auch hier vor dem Speichern der Datensatzänderungen noch den Wert des Primärschlüsselfeldes in eine Variable, in diesem Fall als Rückgabewert der Funktion AdresseEinlesen<\/b>, und speichern anschließend den neu angelegten oder bearbeiteten Datensatz.<\/p>\n Mit dieser Funktion legen wir nacheinander die Daten des in der XRechnung angegebenen Käufers und des Verkäufers an und geben die Primärschlüsselwerte jeweils an die aufrufende Prozedur RechnungsdatenEinlesen <\/b>zurück.<\/p>\n Damit kommen wir zu einem Teil, der nur für den Verkäufer beziehungsweise Anbieter interessant ist, nämlich die Bankverbindung. Diese finden wir im Element cac:PaymentMeans<\/b>, das wir bereits weiter oben vorgestellt haben. Um dieses auszulesen, verwenden wir die Prozedur ZahlungsinformationenSchreiben<\/b>. Diese erwartet einen Verweis auf das entsprechende IXMLDOMNode<\/b>-Element sowie auf das aktuelle Database<\/b>-Objekt und den Primärschlüsselwert des Anbieters aus der Tabelle tblKontakte <\/b>als Parameter (siehe Listing 6).<\/p>\n Listing 6: Funktion zum Erweitern eines der Einträge der Tabelle tblKontakte um die Zahlungsinformationen<\/span><\/b><\/p>\n Die Prozedur ermittelt die Werte der Elemente cac:PayeeFinancialAccount\/cbc:ID <\/b>und cac:PayeeFinancialAccount\/cbc:Name <\/b>und schreibt diese in entsprechende Variablen. Dann erstellt sie ein Recordset auf Basis der Tabelle tblKontakte <\/b>mit dem Datensatz des zuvor angelegten Verkäufer-Kontakts und versetzt diesen mit der Edit<\/b>-Methode in den Bearbeitungsmodus. Nachdem sie die beiden Felder Kontoinhaber <\/b>und IBAN <\/b>mit den Daten aus der XRechnung gefüllt hat, speichert sie den Datensatz wieder.<\/p>\n Damit kommen wir bereits zum letzten Teil der XRechnung, den wir einlesen wollen. Das betroffene Element kann einmal oder mehrmals in der XRechnung enthalten sein und heißt cac:InvoiceLine<\/b>. Im Beispiel aus Listing 7 sehen wir zwei solcher Elemente.<\/p>\n Listing 7: Zwei Elemente mit den Daten je einer Rechnungsposition<\/span><\/b><\/p>\n Diese lesen wir mit der Funktion PositionenEinlesen <\/b>ein (siehe Listing 8). Die Funktion erwartet das in der aufrufenden Prozedur ermittelte IXMLDOMNodeList<\/b>-Element mit den Rechnungspositionen, einen Verweis auf das Database<\/b>-Objekt sowie den Primärschlüsselwert der dort angelegten Rechnung als Parameter.<\/p>\n Listing 8: Funktion zum Einlesen von Rechnungspositionen<\/span><\/b><\/p>\n Die deklariert neben einigen andere Variablen eine Variable namens objInvoiceLine <\/b>mit dem Typ IXMLDOMNode<\/b>. Außerdem erstellt sie ein Recordset<\/b>-Objekt auf Basis der Tabelle tblPositionen<\/b>, wobei das Kriterium wieder dafür sorgt, dass wir ein leeres Recordset erhalten.<\/p>\n Mit der Variablen objInvoiceLine <\/b>durchläuft die Prozedur anschließend die Elemente aus objInvoiceLines<\/b>. Dabei liest sie die Werte der enthaltenen Elemente in entsprechende Variablen ein, zum Beispiel die Rechnungsposition aus dem Feld cbc:ID <\/b>in die Variable strID<\/b>. Dabei kommt immer wieder die Hilfsfunktion TextEinlesen <\/b>zum Einsatz. Zum Ermitteln der Einheit für die Menge einer Rechnungsposition nutzen wir einmal auch die Hilfsfunkton AttributEinlesen<\/b>.<\/p>\n Nachdem alle Eigenschaften der Rechnungsposition eingelesen wurden, schreibt die Prozedur diese in einen mit AddNew <\/b>vorbereiteten neuen Datensatz der Tabelle tblPositionen<\/b>. Hier ist lediglich die Ermittlung des Wertes für das Fremdschlüsselfeld MehrwertsteuersatzID <\/b>zu erwähnen. Da die XRechnung nur den Mehrwertsteuersatz als Prozentzahl liefert, müssen wir noch per DLookup <\/b>den entsprechenden Datensatz der Tabelle tblMehrwertsteuersaetze <\/b>ermitteln, um seinen Primärschlüsselwert für das entsprechende Fremdschlüsselfeld in der Tabelle tblPositionen <\/b>einzutragen. Nachdem die Prozedur alle Positionen der XRechnung durchlaufen hat, ist das Einlesen der von uns benötigten Informationen abgeschlossen.<\/p>\n In den vorherigen Prozeduren haben wir einige Hilfsfunktionen zum Auslesen verschiedener Informationen aus XML-Elementen verwendet. Diese sparen einige Zeilen Code, da sie immer wiederkehrende Anweisungen enthalten. Die Hilfsfunktionen stellen wir in den folgenden Abschnitten vor.<\/p>\n Die Hilfsfunktion TextEinlesen <\/b>erwartet die Angabe eines IXMLDOMNode<\/b>-Elements und den Namen des Elements, dessen Inhalt eingelesen werden soll.<\/p>\n Die Funktion referenziert mit der Funktion selectSingleNode <\/b>zunächst das mit strElement <\/b>angegebene Unterelement mit der Variablen objNode<\/b>. Ist dieses Element vorhanden, liest es seinen Wert über die Eigenschaft nodeTypedValue <\/b>aus und gibt diesen als Ergebnis der Funktion zurück:<\/p>\n Manchmal möchte man ein Unterelement des Typs IXMLDOMNode <\/b>referenzieren, um weitere Unterelemente oder Attribute auszulesen. Für diesen Fall haben wir die Funktion ElementEinlesen <\/b>verwendet, welche die gleichen Parameter wie die zuvor beschriebene Hilfsfunktion erwartet, aber statt des enthaltenen Textes ein Element des Typs IXMLDOMNode <\/b>zurückliefert:<\/p>\n Auch hier kann es vorkommen, dass das zu referenzierende Element nicht vorhanden ist – dann gibt die Funktion den Wert Nothing <\/b>zurück.<\/p>\n Für die Verarbeitung der Rechnungspositionen in der XRechnung müssen wir einige Elemente gleichen Namens durchlaufen. Auch dafür haben wir eine Hilfsfunktion programmiert, welche wieder die gleichen Parameter wie die zuvor beschriebenen verwendet. Diesmal nutzen wir allerdings nicht die Funktion selectSingleNode<\/b>, sondern selectNodes<\/b>, um das Ergebnis zu erhalten. Das Ergebnis wird dann als Element des Typs IXMLDOMNodeList <\/b>an die aufrufende Routine zurückgegeben:<\/p>\nEinlesen der Basisdaten<\/h2>\n
<ubl:Invoice xmlns:ubl=\"urn:oasis:names:specification:ubl:schema:xsd:Invoice-2\" \r\n xmlns:cac=\"urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2\" \r\n xmlns:cbc=\"urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2\" \r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\" \r\n xsi:schemaLocation=\"urn:oasis:names:specification:ubl:schema:xsd:Invoice-2 \r\n http:\/\/docs.oasis-open.org\/ubl\/os-UBL-2.1\/xsd\/maindoc\/UBL-Invoice-2.1.xsd\">\r\n <cbc:CustomizationID>urn:cen.eu:en16931:2017#compliant#urn:xoev-de:kosit:standard:xrechnung_1.2<\/cbc:CustomizationID>\r\n <cbc:ID>1234<\/cbc:ID>\r\n <cbc:IssueDate>2020-09-24<\/cbc:IssueDate>\r\n <cbc:InvoiceTypeCode>380<\/cbc:InvoiceTypeCode>\r\n <cbc:DocumentCurrencyCode>EUR<\/cbc:DocumentCurrencyCode>\r\n <cbc:BuyerReference>1234<\/cbc:BuyerReference>\r\n <cac:OrderReference>\r\n <cbc:ID\/>\r\n <\/cac:OrderReference>\r\n <cac:ContractDocumentReference>\r\n <cbc:ID\/>\r\n <\/cac:ContractDocumentReference>\r\n <cac:ProjectReference>\r\n <cbc:ID\/>\r\n <\/cac:ProjectReference>\r\n ...\r\n<\/ubl><\/pre>\n
Public Sub <\/span>Test_XRechnungEinlesen()\r\n Dim <\/span>strPfad As String<\/span>\r\n strPfad = OpenFileName(CurrentProject.Path, \"XRechnung auswählen\", \"XRechnung (*.xml)\")\r\n XRechnungEinlesen strPfad\r\nEnd Sub<\/span><\/pre>\nDie Funktion XRechnungEinlesen<\/h2>\n
Public Function <\/span>XRechnungEinlesen(strPfad As String<\/span>) As Long<\/span>\r\n Dim <\/span>objXML As <\/span>MSXML2.DOMDocument60\r\n Dim <\/span>objInvoice As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strPfad)) = 0 Then<\/span>\r\n Set<\/span> objXML = New<\/span> MSXML2.DOMDocument60\r\n objXML.SetProperty \"SelectionNamespaces\", \"xmlns:ubl=''urn:oasis:names:specification:ubl:schema:xsd:Invoice-2''\" _\r\n & \"xmlns:cac=''urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2'' \" _\r\n & \"xmlns:cbc=''urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2'' \" _\r\n & \"xmlns:xsi=''http:\/\/www.w3.org\/2001\/XMLSchema-instance''\"\r\n objXML.Load strPfad\r\n Set<\/span> objInvoice = objXML.childNodes.Item(0)\r\n XRechnungEinlesen = RechnungsdatenEinlesen(objInvoice, db)\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_05\/pic_1395_002.png\")
<\/p>\nFunktion zum Einlesen der Rechnungsdaten<\/h2>\n
Private Sub <\/span>RechnungsdatenEinlesen(objInvoice As <\/span>MSXML2.IXMLDOMElement, db As <\/span>DAO.Database) As Long<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strID As String<\/span>\r\n Dim <\/span>datIssueDate As Date<\/span>\r\n Dim <\/span>lngInvoiceTypeCode As Long<\/span>\r\n Dim <\/span>strDocumentCurrencyCode As String<\/span>\r\n Dim <\/span>strBuyerReference As String<\/span>\r\n Dim <\/span>objKaeufer As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>objVerkaeufer As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>objPaymentMeans As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>objInvoiceLines As <\/span>MSXML2.IXMLDOMNodeList\r\n Dim <\/span>lngVerkaeuferID As Long<\/span>\r\n Dim <\/span>lngKaeuferID As Long<\/span>\r\n Dim <\/span>lngRechnungID As Long<\/span>\r\n strID = TextEinlesen(objInvoice, \"cbc:ID\")\r\n datIssueDate = TextEinlesen(objInvoice, \"cbc:IssueDate\")\r\n lngInvoiceTypeCode = TextEinlesen(objInvoice, \"cbc:InvoiceTypeCode\")\r\n strDocumentCurrencyCode = TextEinlesen(objInvoice, \"cbc:DocumentCurrencyCode\")\r\n strBuyerReference = TextEinlesen(objInvoice, \"cbc:BuyerReference\")\r\n Set<\/span> objKaeufer = ElementEinlesen(objInvoice, \"\/\/cac:AccountingCustomerParty\/cac:Party\")\r\n lngKaeuferID = AdresseEinlesen(objKaeufer, db)\r\n Set<\/span> objVerkaeufer = ElementEinlesen(objInvoice, \"cac:AccountingSupplierParty\/cac:Party\")\r\n lngVerkaeuferID = AdresseEinlesen(objVerkaeufer, db)\r\n Set<\/span> objPaymentMeans = ElementEinlesen(objInvoice, \"cac:PaymentMeans\")\r\n ZahlungsinformationenSchreiben objPaymentMeans, db, lngVerkaeuferID\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblRechnungen WHERE 1=2\", dbOpenDynaset)\r\n With<\/span> rst\r\n .AddNew<\/span>\r\n !Rechnungsnummer = strID\r\n !Rechnungsdatum = datIssueDate\r\n !RechnungstypID = lngInvoiceTypeCode\r\n !Waehrung = strDocumentCurrencyCode\r\n !Kundenreferenz = strBuyerReference\r\n !VerkaeuferID = lngVerkaeuferID\r\n !KaeuferID = lngKaeuferID\r\n lngRechnungID = !RechnungID\r\n .Update\r\n End With<\/span>\r\n Set<\/span> objInvoiceLines = ElementeEinlesen(objInvoice, \"cac:InvoiceLine\")\r\n PositionenEinlesen objInvoiceLines, db, lngRechnungID\r\n RechnungsdatenEinlesen = lngRechnungID\r\nEnd Sub<\/span><\/pre>\nBasisdaten der Rechnung aus der XRechnung einlesen<\/h2>\n
<cac:AccountingCustomerParty>\r\n <cac:Party>\r\n <cac:PostalAddress>\r\n <cbc:StreetName>Teststr. 1<\/cbc:StreetName>\r\n <cbc:AdditionalStreetName\/>\r\n <cbc:CityName>Berlin<\/cbc:CityName>\r\n <cbc:PostalZone>12121<\/cbc:PostalZone>\r\n <cac:Country>\r\n <cbc:IdentificationCode>DE<\/cbc:IdentificationCode>\r\n <\/cac:Country>\r\n <\/cac:PostalAddress>\r\n <cac:PartyTaxScheme>\r\n <cbc:CompanyID>DE232323232<\/cbc:CompanyID>\r\n <cac:TaxScheme>\r\n <cbc:ID>VAT<\/cbc:ID>\r\n <\/cac:TaxScheme>\r\n <\/cac:PartyTaxScheme>\r\n <cac:PartyLegalEntity>\r\n <cbc:RegistrationName>Müller AG<\/cbc:RegistrationName>\r\n <\/cac:PartyLegalEntity>\r\n <cac:Contact>\r\n <cbc:Name>Klaus Müller<\/cbc:Name>\r\n <cbc:Telephone>0123-2121212<\/cbc:Telephone>\r\n <cbc:ElectronicMail>klaus@mueller.de<\/cbc:ElectronicMail>\r\n <\/cac:Contact>\r\n <\/cac:Party>\r\n <\/cac:AccountingCustomerParty><\/pre>\n
Zahlungsinformationen erfassen<\/h2>\n
<cac:PaymentMeans>\r\n <cbc:PaymentMeansCode>31<\/cbc:PaymentMeansCode>\r\n <cbc:PaymentID>Debit transfer<\/cbc:PaymentID>\r\n <cac:PayeeFinancialAccount>\r\n <cbc:ID>DE12121212121212121212<\/cbc:ID>\r\n <cbc:Name>Andre Minhorst<\/cbc:Name>\r\n <cac:FinancialInstitutionBranch>\r\n <cbc:ID\/>\r\n <\/cac:FinancialInstitutionBranch>\r\n <\/cac:PayeeFinancialAccount>\r\n<\/cac:PaymentMeans><\/pre>\n
Anlegen von Käufer und Verkäufer in der Tabelle tblKontakte<\/h2>\n
Private Function <\/span>AdresseEinlesen(objParty As <\/span>MSXML2.IXMLDOMNode, db As <\/span>DAO.Database) As Long<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strStreetName As String<\/span>\r\n Dim <\/span>strCityName As String<\/span>\r\n Dim <\/span>strCountry As String<\/span>\r\n Dim <\/span>strPostalZone As String<\/span>\r\n Dim <\/span>strCompanyID As String<\/span>\r\n Dim <\/span>strRegistrationName As String<\/span>\r\n Dim <\/span>strName As String<\/span>\r\n Dim <\/span>strTelephone As String<\/span>\r\n Dim <\/span>strElectronicMail As String<\/span>\r\n strStreetName = TextEinlesen(objParty, \"cac:PostalAddress\/cbc:StreetName\")\r\n strCityName = TextEinlesen(objParty, \"cac:PostalAddress\/cbc:CityName\")\r\n strCountry = TextEinlesen(objParty, \"cac:PostalAddress\/cac:Country\/cbc:IdentificationCode\")\r\n strPostalZone = TextEinlesen(objParty, \"cac:PostalAddress\/cbc:PostalZone\")\r\n strCompanyID = TextEinlesen(objParty, \"cac:PartyTaxScheme\/cbc:CompanyID\")\r\n strRegistrationName = TextEinlesen(objParty, \"cac:PartyLegalEntity\/cbc:RegistrationName\")\r\n strName = TextEinlesen(objParty, \"cac:Contact\/cbc:Name\")\r\n strTelephone = TextEinlesen(objParty, \"cac:Contact\/cbc:Telephone\")\r\n strElectronicMail = TextEinlesen(objParty, \"cac:Contact\/cbc:ElectronicMail\")\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKontakte WHERE UstIDNr = ''\" & strCompanyID & \"''\", dbOpenDynaset)\r\n With<\/span> rst\r\n If <\/span>rst.EOF Then<\/span>\r\n .AddNew<\/span>\r\n Else<\/span>\r\n .Edit\r\n End If<\/span>\r\n !Firma = strRegistrationName\r\n !Ansprechpartner = strName\r\n !Telefon = strTelephone\r\n !EMail = strElectronicMail\r\n !Strasse = strStreetName\r\n !PLZ = strPostalZone\r\n !Ort = strCityName\r\n !LandID = DLookup(\"LandID\", \"tblLaender\", \"LandKuerzel = ''\" & strCountry & \"''\")\r\n !UstIDNr = strCompanyID\r\n AdresseEinlesen = !KontaktID\r\n .Update\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\nUmsatzsteuer-Identifikationsnummer als eindeutiges Merkmal<\/h2>\n
Bankverbindung speichern<\/h2>\n
Private Sub <\/span>ZahlungsinformationenSchreiben(objPaymentMeans As <\/span>MSXML2.IXMLDOMNode, db As <\/span>DAO.Database, lngKaeuferID As Long<\/span>)\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strPayeeFinancialAccountID As String<\/span>\r\n Dim <\/span>strPayeeFinancialAccountName As String<\/span>\r\n strPayeeFinancialAccountID = TextEinlesen(objPaymentMeans, \"cac:PayeeFinancialAccount\/cbc:ID\")\r\n strPayeeFinancialAccountName = TextEinlesen(objPaymentMeans, \"cac:PayeeFinancialAccount\/cbc:Name\")\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKontakte WHERE KontaktID = \" & lngKaeuferID, dbOpenDynaset)\r\n rst.Edit\r\n rst!Kontoinhaber = strPayeeFinancialAccountName\r\n rst!IBAN = strPayeeFinancialAccountID\r\n rst.Update\r\nEnd Sub<\/span><\/pre>\nRechnungspositionen einlesen<\/h2>\n
<cac:InvoiceLine>\r\n <cbc:ID>1<\/cbc:ID>\r\n <cbc:InvoicedQuantity unitCode=\"XPP\">1<\/cbc:InvoicedQuantity>\r\n <cbc:LineExtensionAmount currencyID=\"EUR\">12<\/cbc:LineExtensionAmount>\r\n <cac:Item>\r\n <cbc:Description\/>\r\n <cbc:Name>Position 1<\/cbc:Name>\r\n <cac:ClassifiedTaxCategory>\r\n <cbc:ID>S<\/cbc:ID>\r\n <cbc:Percent>7<\/cbc:Percent>\r\n <cac:TaxScheme>\r\n <cbc:ID>VAT<\/cbc:ID>\r\n <\/cac:TaxScheme>\r\n <\/cac:ClassifiedTaxCategory>\r\n <\/cac:Item>\r\n <cac:Price>\r\n <cbc:PriceAmount currencyID=\"EUR\">12<\/cbc:PriceAmount>\r\n <\/cac:Price>\r\n <\/cac:InvoiceLine>\r\n <cac:InvoiceLine>\r\n <cbc:ID>2<\/cbc:ID>\r\n <cbc:InvoicedQuantity unitCode=\"XPP\">2<\/cbc:InvoicedQuantity>\r\n <cbc:LineExtensionAmount currencyID=\"EUR\">20<\/cbc:LineExtensionAmount>\r\n <cac:Item>\r\n <cbc:Description\/>\r\n <cbc:Name>Position 2<\/cbc:Name>\r\n <cac:ClassifiedTaxCategory>\r\n <cbc:ID>S<\/cbc:ID>\r\n <cbc:Percent>19<\/cbc:Percent>\r\n <cac:TaxScheme>\r\n <cbc:ID>VAT<\/cbc:ID>\r\n <\/cac:TaxScheme>\r\n <\/cac:ClassifiedTaxCategory>\r\n <\/cac:Item>\r\n <cac:Price>\r\n <cbc:PriceAmount currencyID=\"EUR\">10<\/cbc:PriceAmount>\r\n <\/cac:Price>\r\n <\/cac:InvoiceLine>\r\n<\/ubl:Invoice><\/pre>\n
Private Sub <\/span>PositionenEinlesen(objInvoiceLines As <\/span>MSXML2.IXMLDOMNodeList, db As <\/span>DAO.Database, lngRechnungID As Long<\/span>)\r\n Dim <\/span>objInvoiceLine As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>objInvoicedQuantity As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>strID As String<\/span>\r\n Dim <\/span>lngInvoicedQuantity As String<\/span>\r\n Dim <\/span>strUnitCode As String<\/span>\r\n Dim <\/span>strName As String<\/span>\r\n Dim <\/span>curClassifiedTaxCategoryPercent As Currency<\/span>\r\n Dim <\/span>curPrice As Currency<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblPositionen WHERE 1=2\", dbOpenDynaset)\r\n For Each objInvoiceLine In objInvoiceLines\r\n strID = TextEinlesen(objInvoiceLine, \"cbc:ID\")\r\n lngInvoicedQuantity = TextEinlesen(objInvoiceLine, \"cbc:InvoicedQuantity\")\r\n Set<\/span> objInvoicedQuantity = ElementEinlesen(objInvoiceLine, \"cbc:InvoicedQuantity\")\r\n strUnitCode = AttributEinlesen(objInvoicedQuantity, \"unitCode\")\r\n strName = TextEinlesen(objInvoiceLine, \"cac:Item\/cbc:Name\")\r\n curClassifiedTaxCategoryPercent = TextEinlesen(objInvoiceLine, \"cac:Item\/cac:ClassifiedTaxCategory\/cbc:Percent\")\r\n curPrice = TextEinlesen(objInvoiceLine, \"cac:Price\/cbc:PriceAmount\")\r\n With<\/span> rst\r\n .AddNew<\/span>\r\n !Position = strID\r\n !Einheit = strUnitCode\r\n !RechnungID = lngRechnungID\r\n !Bezeichnung = strName\r\n !Einzelpreis = curPrice\r\n !MehrwertsteuersatzID = DLookup(\"MehrwertsteuersatzID\", \"tblMehrwertsteuersaetze\", ?\r\n \"Mehrwertsteuersatz = \" & Replace<\/span>(curClassifiedTaxCategoryPercent \/ 100, \",\", \".\"))\r\n !Menge = lngInvoicedQuantity\r\n .Update\r\n End With<\/span>\r\n Next<\/span> objInvoiceLine\r\nEnd Sub<\/span><\/pre>\nHilfsfunktionen<\/h2>\n
Hilfsfunktion zum Einlesen des Elementwertes<\/h2>\n
Public Function <\/span>TextEinlesen(objParent As <\/span>IXMLDOMNode, strElement As String<\/span>) As Variant<\/span>\r\n Dim <\/span>objNode As <\/span>IXMLDOMNode\r\n Set<\/span> objNode = objParent.selectSingleNode(strElement)\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n TextEinlesen = objNode.nodeTypedValue\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nHilfsfunktion zum Einlesen eines Unterelements<\/h2>\n
Public Function <\/span>ElementEinlesen( objParent As <\/span>IXMLDOMNode, strElement As String<\/span>) As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>objNode As <\/span>IXMLDOMNode\r\n Set<\/span> objNode = objParent.selectSingleNode(strElement)\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n Set<\/span> ElementEinlesen = objNode\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nHilfsfunktion zum Einlesen einer Liste von Unterelementen<\/h2>\n
Public Function <\/span>ElementeEinlesen( objParent