mikrowerk-edi-invoicing 0.1.0__py3-none-any.whl

x_mapper/xml_cii_dom_parser.py

@@ -0,0 +1,203 @@
+"""
+This implements a mapper from a drafthorse parsed x-rechnung-xml to the internal XRechnung object
+"""
+from datetime import datetime
+
+from drafthorse.models.document import Document
+
+from .xml_abstract_x_rechnung_parser import XMLAbstractXRechnungParser
+from ..model.x_rechnung import (XRechnung, XRechnungCurrency, XRechnungTradeParty, XRechnungTradeAddress,
+                              XRechnungTradeContact, XRechnungPaymentMeans, XRechnungFinancialCard,
+                              XRechnungTradeLine, XRechnungAppliedTradeTax, XRechnungBankAccount)
+
+
+class XRechnungCIIXMLParser(XMLAbstractXRechnungParser):
+
+
+    @classmethod
+    def parse_and_map_x_rechnung(cls, _xml: any) -> XRechnung:
+        doc = Document.parse(_xml)
+        return cls().map_to_x_rechnung(doc)
+
+    @classmethod
+    def map_to_x_rechnung(cls, doc: any) -> XRechnung:
+        """
+        :param doc: Element, the parsed dom root element
+        :return:
+        """
+
+        return XRechnung(
+            name=f"{cls().TYPE_CODES.get(doc.header.type_code.get_string(), 'Unknown doc type ')} {doc.header.id.get_string()}",
+            doc_id=doc.header.id.get_string(),
+            doc_type_code=doc.header.type_code.get_string(),
+            issued_date_time=doc.header.issue_date_time.get_value(),
+            notes=doc.header.notes.get_string_elements("\n"),
+            languages=doc.header.languages.get_string_elements(";"),
+            buyer_reference=doc.trade.agreement.buyer_reference.get_string(),
+            currency_code=doc.trade.settlement.currency_code.get_string(),
+            line_total_amount=doc.trade.settlement.monetary_summation.line_total.get_value(),
+            charge_total_amount=doc.trade.settlement.monetary_summation.charge_total.get_value(),
+            allowance_total_amount=doc.trade.settlement.monetary_summation.allowance_total.get_value(),
+            tax_basis_total_amount=XRechnungCurrency.from_currency_tuple(
+                doc.trade.settlement.monetary_summation.tax_basis_total.get_currency()),
+            tax_total_amount=[XRechnungCurrency.from_currency_tuple(tpl) for tpl in
+                              doc.trade.settlement.monetary_summation.tax_total_other_currency.get_currencies()],
+            # list of currency
+            grand_total_amount=XRechnungCurrency.from_currency_tuple(
+                doc.trade.settlement.monetary_summation.grand_total.get_currency()),
+            total_prepaid_amount=doc.trade.settlement.monetary_summation.prepaid_total.get_value(),
+            due_payable_amount=doc.trade.settlement.monetary_summation.due_amount.get_value(),
+            delivered_date_time=datetime.now(),
+            payment_means=cls().map_payment_means(
+                doc.trade.settlement.payment_means) if doc.trade.settlement.payment_means else None,
+            payment_terms=doc.trade.settlement.terms.get_string_elements("\n"),
+            seller=cls().map_trade_party(doc.trade.agreement.seller) if hasattr(doc.trade.agreement,
+                                                                                "seller") else None,
+            invoicee=cls().map_trade_party(doc.trade.agreement.invoicee) if hasattr(doc.trade.agreement,
+                                                                                    "invoicee") else None,
+            buyer=cls().map_trade_party(doc.trade.agreement.buyer) if hasattr(doc.trade.agreement, "buyer") else None,
+            payee=cls().map_trade_party(doc.trade.agreement.payee) if hasattr(doc.trade.agreement, "payee") else None,
+            trade_line_items=cls().map_trade_line_items(doc.trade.items) if hasattr(doc.trade, "items") else None,
+            applicable_trade_taxes=cls().map_trade_taxes(doc.trade.settlement.trade_tax) if hasattr(
+                doc.trade.settlement,
+                "trade_tax") else None
+        )
+
+    @classmethod
+    def map_trade_party(cls, trade_party: any) -> XRechnungTradeParty:
+        _global_id_schema, _global_id = cls().map_first_id(trade_party.global_id)
+        return XRechnungTradeParty(
+            name=trade_party.name.get_string(),
+            description=trade_party.description.get_string(),
+            global_id=_global_id,
+            global_id_schema=_global_id_schema,
+            email=cls().map_electronic_address(trade_party.electronic_address, 'EM') if hasattr(trade_party,
+                                                                                                "electronic_address") else None,
+            vat_registration_number=cls().map_tax_registration(trade_party.tax_registrations, 'VA') if hasattr(
+                trade_party, 'tax_registrations') else None,
+            fiscal_registration_number=cls().map_tax_registration(trade_party.tax_registrations, 'FC') if hasattr(
+                trade_party, 'tax_registrations') else None,
+            postal_address=cls().map_trade_address(trade_party.address) if hasattr(trade_party, 'address') else None,
+            trade_contact=cls().map_trade_contact(trade_party.contact) if hasattr(trade_party, 'contact') else None,
+            id=trade_party.id.get_string() if hasattr(trade_party, 'id') else None,
+        )
+
+    @staticmethod
+    def map_first_id(global_id: any) -> (str, str):
+        if global_id is not None and hasattr(global_id, "children") and len(global_id.children) > 0:
+            for child in global_id.children:
+                return child
+        else:
+            return None, None
+
+    @staticmethod
+    def map_electronic_address(electronic_address: any, schema_id: str) -> str | None:
+        if electronic_address is not None and hasattr(electronic_address, "children") and len(
+                electronic_address.children) > 0:
+            for child in electronic_address.children:
+                if child.uri_ID._scheme_id == schema_id:
+                    return child.uri_ID._text
+
+        return None
+
+    @staticmethod
+    def map_tax_registration(tax_reg: any, schema_id: str) -> str | None:
+        if tax_reg is not None and hasattr(tax_reg, "children") and len(
+                tax_reg.children) > 0:
+            for child in tax_reg.children:
+                if child.id._scheme_id == schema_id and child.id._text:
+                    return "".join(child.id._text.split())
+
+        return None
+
+    @staticmethod
+    def map_trade_address(trade_address: any) -> XRechnungTradeAddress:
+        return XRechnungTradeAddress(
+            city_name=trade_address.city_name.get_string(),
+            country_id=trade_address.country_id.get_string(),
+            country_subdivision_id=trade_address.country_subdivision.get_string(),
+            address_line_1=trade_address.line_one.get_string(),
+            address_line_2=trade_address.line_two.get_string(),
+            address_line_3=trade_address.line_three.get_string(),
+            post_code=trade_address.postcode.get_string(),
+        )
+
+    @staticmethod
+    def map_trade_contact(trade_contact: any) -> XRechnungTradeContact:
+        return XRechnungTradeContact(
+            name=trade_contact.person_name.get_string(),
+            email=trade_contact.email.get_string(),
+            telephone=trade_contact.telephone.get_string(),
+            department_name=trade_contact.department_name.get_string(),
+            fax=trade_contact.fax.get_string(),
+        )
+
+    @staticmethod
+    def map_bank_account(payment_means: any) -> XRechnungBankAccount:
+        return XRechnungBankAccount(
+            iban="".join(payment_means.payee_account.iban.get_string().split()) if hasattr(payment_means,
+                                                                                           'payee_account') else None,
+            bic=payment_means.payee_institution.bic.get_string() if hasattr(payment_means,
+                                                                            'payee_institution') else None,
+        )
+
+    @staticmethod
+    def map_financial_card(financial_card: any) -> XRechnungFinancialCard:
+        return XRechnungFinancialCard(
+            id=financial_card.id.get_string(),
+            cardholder_name=financial_card.cardholder_name.get_string(),
+        )
+
+    @classmethod
+    def map_payment_means(cls, payment_means: any) -> XRechnungPaymentMeans:
+        return XRechnungPaymentMeans(
+            information=payment_means.information.get_string(),
+            type_code=payment_means.type_code.get_string(),
+            payee_account=cls().map_bank_account(payment_means) if hasattr(payment_means, 'payee_account') else None,
+            financial_card=cls().map_financial_card(payment_means.financial_card) if hasattr(payment_means,
+                                                                                             'financial_card') else None,
+        )
+
+    @staticmethod
+    def map_trade_tax(trade_tax: any) -> XRechnungAppliedTradeTax:
+        return XRechnungAppliedTradeTax(
+            type_code=trade_tax.type_code.get_string(),
+            name=f"{trade_tax.type_code.get_string()} {trade_tax.rate_applicable_percent.get_value()}",
+            category_code=trade_tax.category_code.get_string(),
+            basis_amount=trade_tax.basis_amount.get_value(),
+            calculated_amount=trade_tax.calculated_amount.get_value(),
+            applicable_percent=trade_tax.rate_applicable_percent.get_value()
+        )
+
+    @classmethod
+    def map_trade_taxes(cls, trade_taxes: any) -> [XRechnungTradeLine]:
+        res = []
+        for child in trade_taxes.children:
+            res.append(cls().map_trade_tax(child))
+        return res
+
+    @classmethod
+    def map_trade_line(cls, trade_line: any) -> XRechnungTradeLine:
+        return XRechnungTradeLine(
+            name=trade_line.product.name.get_string(),
+            description=trade_line.product.description.get_string(),
+            line_id=trade_line.document.line_id.get_string(),
+            price_unit=trade_line.agreement.net.amount.get_value(),
+            price_unit_gross=trade_line.agreement.gross.amount.get_value(),
+            quantity_billed=trade_line.delivery.billed_quantity.get_value(),
+            global_product_id=trade_line.product.global_id.get_string(),
+            total_amount_net=trade_line.settlement.monetary_summation.total_amount.get_value(),
+            total_allowance_charge=trade_line.settlement.monetary_summation.total_allowance_charge.get_value(),
+            quantity_unit_code=trade_line.delivery.billed_quantity._unit_code,
+            seller_assigned_id=trade_line.product.seller_assigned_id.get_string(),
+            buyer_assigned_id=trade_line.product.buyer_assigned_id.get_string(),
+            global_product_scheme_id=trade_line.product.global_id._scheme_id,
+            trade_tax=cls().map_trade_tax(trade_line.settlement.trade_tax)
+        )
+
+    @classmethod
+    def map_trade_line_items(cls, trade_line_items: any) -> [XRechnungTradeLine]:
+        res = []
+        for child in trade_line_items.children:
+            res.append(cls().map_trade_line(child))
+        return res

x_mapper/xml_ubl_sax_parser.py

@@ -0,0 +1,268 @@
+"""
+implementation of an ubl xml parser based on sax
+"""
+from datetime import datetime
+import io
+from collections import deque
+import xml.sax as sax
+from decimal import Decimal
+
+from ..model.x_rechnung import (XRechnung, XRechnungTradeParty, XRechnungTradeAddress, XRechnungTradeContact,
+                              XRechnungPaymentMeans, XRechnungBankAccount, XRechnungCurrency, XRechnungTradeLine,
+                              XRechnungAppliedTradeTax)
+from .xml_abstract_x_rechnung_parser import XMLAbstractXRechnungParser
+
+
+class UblSaxHandler(sax.ContentHandler):
+    def __init__(self):
+        self.x_rechnung: XRechnung = XRechnung()
+        self.content = ""
+        self.stack = deque()
+        self.current_attributes = None
+        self.current_trade_party = XRechnungTradeParty()
+        self.current_trade_address: XRechnungTradeAddress = XRechnungTradeAddress()
+        self.current_trade_contact: XRechnungTradeContact = XRechnungTradeContact()
+        self.current_payment_means: XRechnungPaymentMeans = XRechnungPaymentMeans()
+        self.current_payment_means_list: [XRechnungPaymentMeans] = []
+        self.current_currency: XRechnungCurrency | None = None
+        self.current_trade_line: XRechnungTradeLine | None = None
+        self.trade_line_list: [XRechnungTradeLine] = []
+        self.current_trade_tax: XRechnungAppliedTradeTax | None = None
+        self.applicable_trade_taxes: [XRechnungAppliedTradeTax] = []
+
+    def startDocument(self):
+        print("------------------------------ Start ---------------------------------------------------")
+        self.x_rechnung = XRechnung()
+        self.stack = deque()
+
+    def endDocument(self):
+        self.x_rechnung.name = (
+            f"{XMLAbstractXRechnungParser.TYPE_CODES.get(self.x_rechnung.doc_type_code, 'Unknown doc type ')}"
+            f" {self.x_rechnung.doc_id}")
+        print("------------------------------- End  --------------------------------------------------")
+
+    def startElementNS(self, name, qname, attrs):
+        _ns, _tag_name = name
+        self.current_attributes = attrs
+        self.stack.append((_tag_name, attrs))
+        self.content = ""
+        match _tag_name:
+            case "Party":
+                self.current_trade_party = XRechnungTradeParty()
+            case "PostalAddress":
+                self.current_trade_address = XRechnungTradeAddress()
+            case "Contact":
+                self.current_trade_contact = XRechnungTradeContact()
+            case "PaymentMeans":
+                self.current_payment_means = XRechnungPaymentMeans()
+                self.current_payment_means.payee_account = XRechnungBankAccount()
+            case "InvoiceLine":
+                self.current_trade_line = XRechnungTradeLine()
+            case "TaxSubtotal":
+                self.current_trade_tax = XRechnungAppliedTradeTax()
+            case "ClassifiedTaxCategory":
+                self.current_trade_tax = XRechnungAppliedTradeTax()
+
+        _path = '/'.join([tag for tag, _attrs in self.stack])
+
+        print(f">>>>>>>>>>>>>>> start: {_ns} {_tag_name} >>>>>>>>>>>>>>>>")
+        print(_path)
+        for k, v in attrs.items():
+            print(f"{k}: {v}")
+
+    def endElementNS(self, name, qname):
+        _ns, _tag_name = name
+        _path = '/'.join([tag for tag, attrs in self.stack])
+        _close_name, attrs = self.stack.pop()
+        _content = self.content.strip()
+
+        # parse any matching closing tags
+        if "/Party" in _path:
+            self.handle_party(_path, _tag_name, _content, attrs)
+        if "/PaymentMeans" in _path:
+            self.handle_payment_means(_path, _tag_name, _content, attrs)
+        if "/InvoiceLine" in _path:
+            self.handle_invoice_line(_path, _tag_name, _content, attrs)
+        if "/ClassifiedTaxCategory" in _path:
+            self.handle_trade_tax(_path, _tag_name, _content, attrs)
+        if "/TaxTotal/TaxSubtotal" in _path:
+            self.handle_trade_tax(_path, _tag_name, _content, attrs)
+
+        # collect results when closing a main tag
+        match _tag_name:
+            case "PostalAddress":
+                self.current_trade_party.postal_address = self.current_trade_address
+            case "Contact":
+                self.current_trade_party.trade_contact = self.current_trade_contact
+            case "PaymentMeans":
+                self.current_payment_means_list.append(self.current_payment_means)
+            case "InvoiceLine":
+                self.current_trade_line.trade_tax = self.current_trade_tax
+                self.trade_line_list.append(self.current_trade_line)
+
+        if _path.endswith("Invoice/TaxTotal/TaxSubtotal"):
+            self.applicable_trade_taxes.append(self.current_trade_tax)
+
+        # invoice top level properties
+        self.handle_invoice(_path, _tag_name, _content, attrs)
+
+        print(f"content:'{_content}'")
+        self.content = ''
+        print(_path)
+        print(f"<<<<<<<<<<<<<<< end: {_ns} {_tag_name} <<<<<<<<<<<<<<<")
+
+    def characters(self, content):
+        if content and len(content) > 0:
+            self.content += content
+
+    def handle_invoice(self, path: str, tag, content: str, attrs=None):
+        match path:
+            case "Invoice/ID":
+                self.x_rechnung.doc_id = content
+            case "Invoice/IssueDate":
+                self.x_rechnung.issued_date_time = datetime.fromisoformat(content)
+            case "Invoice/InvoiceTypeCode":
+                self.x_rechnung.doc_type_code = content
+            case "Invoice/DocumentCurrencyCode":
+                self.x_rechnung.currency_code = content
+            case "Invoice/BuyerReference":
+                self.x_rechnung.buyer_reference = content
+            case "Invoice/OrderReference/ID":
+                self.x_rechnung.order_reference = content
+            case "Invoice/OrderReference/SalesOrderID":
+                self.x_rechnung.sales_order_reference = content
+            case "Invoice/DespatchDocumentReference/ID":
+                self.x_rechnung.dispatch_document_reference = content
+            case "Invoice/AccountingSupplierParty":
+                self.x_rechnung.seller = self.current_trade_party
+            case "Invoice/AccountingCustomerParty":
+                self.x_rechnung.buyer = self.current_trade_party
+            case "Invoice/PaymentMeans":
+                if self.current_payment_means_list and len(self.current_payment_means_list) > 0:
+                    self.x_rechnung.payment_means = self.current_payment_means_list[0]
+            case "Invoice/PaymentTerms/Note":
+                self.x_rechnung.payment_terms = content
+            case "Invoice/AllowanceCharge/Amount":
+                self.x_rechnung.allowance_total_amount = Decimal(content)
+            case "Invoice/TaxTotal/TaxAmount":
+                self.x_rechnung.tax_total_amount = [XRechnungCurrency(Decimal(content),
+                                                                      attrs.get('currencyID', 'EUR'))]
+            case "Invoice/TaxTotal/TaxSubtotal/TaxableAmount":
+                self.x_rechnung.tax_basis_total_amount = XRechnungCurrency(Decimal(content),
+                                                                           attrs.get('currencyID', 'EUR'))
+            case "Invoice/LegalMonetaryTotal/TaxInclusiveAmount":
+                self.x_rechnung.grand_total_amount = XRechnungCurrency(Decimal(content),
+                                                                       attrs.get('currencyID', 'EUR'))
+            case "Invoice/LegalMonetaryTotal/PrepaidAmount":
+                self.x_rechnung.total_prepaid_amount = Decimal(content)
+            case "Invoice/LegalMonetaryTotal/PayableAmount":
+                self.x_rechnung.due_payable_amount = Decimal(content)
+            case "Invoice/InvoiceLine":
+                self.x_rechnung.trade_line_items = self.trade_line_list
+            case "Invoice/TaxTotal":
+                self.x_rechnung.applicable_trade_taxes = self.applicable_trade_taxes
+
+    def handle_party(self, path: str, tag: str, content: str, attr=None):
+        if "/PostalAddress" in path:
+            self.handle_postal_address(path, tag, content)
+        elif "/Contact" in path:
+            self.handle_contact(path, tag, content)
+        elif path.endswith("Party/EndpointID"):
+            if attr.get((None, "schemeID"), None) == "EM":
+                self.current_trade_party.email = content
+        elif path.endswith("Party/PartyName/Name"):
+            self.current_trade_party.name = content
+        elif path.endswith("/Party/PartyTaxScheme/CompanyID"):
+            self.current_trade_party.vat_registration_number = content
+        elif path.endswith("/Party/PartyLegalEntity/CompanyID"):
+            self.current_trade_party.legal_registration_number = content
+        elif path.endswith("/Party/PartyLegalEntity/RegistrationName"):
+            self.current_trade_party.name = content
+        elif path.endswith("/Party/PartyIdentification/ID"):
+            self.current_trade_party.global_id = content
+            self.current_trade_party.global_id_schema = attr.get((None, "schemeID"), "")
+
+    def handle_postal_address(self, path: str, tag: str, content: str, attr=None):
+        if path.endswith("/Party/PostalAddress/StreetName"):
+            self.current_trade_address.address_line_1 = content
+        elif path.endswith("/Party/PostalAddress/AdditionalStreetName"):
+            self.current_trade_address.address_line_2 = content
+        elif path.endswith("/Party/PostalAddress/BuildingNumber"):
+            self.current_trade_address.address_line_3 = content
+        elif path.endswith("/Party/PostalAddress/CityName"):
+            self.current_trade_address.city_name = content
+        elif path.endswith("/Party/PostalAddress/PostalZone"):
+            self.current_trade_address.post_code = content
+        elif path.endswith("/Party/PostalAddress/Country/IdentificationCode"):
+            self.current_trade_address.country_id = content
+
+    def handle_contact(self, path: str, tag: str, content: str, attr=None):
+        if path.endswith("/Party/Contact/Name"):
+            self.current_trade_contact.name = content
+        elif path.endswith("/Party/Contact/ElectronicMail"):
+            self.current_trade_contact.email = content
+        elif path.endswith("/Party/Contact/Telephone"):
+            self.current_trade_contact.telephone = content
+
+    def handle_payment_means(self, path: str, tag: str, content: str, attr=None):
+        if path.endswith("/PaymentMeans/PaymentMeansCode"):
+            self.current_payment_means.type_code = content
+        elif path.endswith("/PaymentMeans/PaymentID"):
+            self.current_payment_means.id = content
+        elif path.endswith("/PaymentMeans/PayeeFinancialAccount/ID"):
+            self.current_payment_means.payee_account.iban = content
+        elif path.endswith("/PaymentMeans/PayeeFinancialAccount/FinancialInstitutionBranch/ID"):
+            self.current_payment_means.payee_account.bic = content
+
+    def handle_invoice_line(self, path: str, tag: str, content: str, attr=None):
+        if path.endswith("/InvoiceLine/ID"):
+            self.current_trade_line.line_id = content
+        elif path.endswith("/InvoiceLine/Note"):
+            self.current_trade_line.note = content
+        elif path.endswith("/InvoiceLine/InvoicedQuantity"):
+            self.current_trade_line.quantity_billed = float(content)
+            self.current_trade_line.quantity_unit_code = attr.get((None, 'unitCode'), None) if attr else None
+        elif path.endswith("/InvoiceLine/LineExtensionAmount"):
+            self.current_trade_line.total_amount_net = float(content)
+        elif path.endswith("/InvoiceLine/Item/Description"):
+            self.current_trade_line.description = content
+        elif path.endswith("/InvoiceLine/Item/Name"):
+            self.current_trade_line.name = content
+        elif path.endswith("/InvoiceLine/Item/SellersItemIdentification/ID"):
+            self.current_trade_line.seller_assigned_id = content
+        elif path.endswith("/InvoiceLine/Item/BuyersItemIdentification/ID"):
+            self.current_trade_line.buyer_assigned_id = content
+        elif path.endswith("/InvoiceLine/Item/ItemInstance/LotIdentification/LotNumberID"):
+            self.current_trade_line.lot_number_id = content
+        elif path.endswith("/InvoiceLine/Item/ItemInstance/LotIdentification/ExpiryDate"):
+            self.current_trade_line.expiry_date = datetime.fromisoformat(content)
+        elif path.endswith("/InvoiceLine/Price/PriceAmount"):
+            self.current_trade_line.price_unit = float(content)
+
+    def handle_trade_tax(self, path: str, tag: str, content: str, attr=None):
+        if path.endswith("/ClassifiedTaxCategory/ID") or path.endswith("/TaxCategory/ID"):
+            self.current_trade_tax.category_code = content
+        elif path.endswith("/ClassifiedTaxCategory/TaxScheme/ID") or path.endswith("/TaxCategory/TaxScheme/ID"):
+            self.current_trade_tax.type_code = content
+            self.current_trade_tax.name = content
+        elif path.endswith("/ClassifiedTaxCategory/Percent") or path.endswith("/TaxCategory/Percent"):
+            self.current_trade_tax.applicable_percent = float(content)
+        elif path.endswith("/TaxSubtotal/TaxableAmount"):
+            self.current_trade_tax.basis_amount = float(content)
+        elif path.endswith("/TaxSubtotal/TaxAmount"):
+            self.current_trade_tax.calculated_amount = float(content)
+
+
+class XRechnungUblXMLParser(XMLAbstractXRechnungParser):
+    @classmethod
+    def parse_and_map_x_rechnung(cls, _xml: bytes) -> XRechnung:
+        # create an XMLReader
+        parser = sax.make_parser()
+        # turn off namespaces
+        parser.setFeature(sax.handler.feature_namespaces, 1)
+        # override the default ContextHandler
+        handler = UblSaxHandler()
+        parser.setContentHandler(handler)
+        parser.parse(io.BytesIO(_xml))
+        x_rechnung = handler.x_rechnung
+        return x_rechnung