Invoice/InvoiceToZUGFeRD.py (78a5623) - invoice.git

InvoiceToZUGFeRD.py

# -*- coding: utf-8 -*-

import os.path
import sys
from decimal import Decimal

# Search for included submodule python-drafthorse
atoms = os.path.abspath(os.path.dirname(__file__)).split('/')
dir = ''
while atoms:
    candidate = os.path.join('/'.join(atoms), 'external/python-drafthorse')
    if os.path.exists(candidate):
        dir = candidate
        break
    atoms = atoms[:-1]
sys.path.insert(0, dir)
from drafthorse.models.document import Document
from drafthorse.models.accounting import ApplicableTradeTax
from drafthorse.models.tradelines import LineItem
from .InvoiceObjects import InvoiceTable, InvoiceText, RECHNUNG, GUTSCHRIFT, KORREKTUR, \
    VAT_REGULAR, VAT_KLEINUNTERNEHMER, VAT_INNERGEM, PAYMENT_UEBERWEISUNG, PAYMENT_LASTSCHRIFT, UNITS
from drafthorse.models.accounting import TradeAllowanceCharge
from drafthorse.models.party import TaxRegistration, URIUniversalCommunication
from drafthorse.models.payment import PaymentTerms, PaymentMeans
from drafthorse.models.note import IncludedNote
from drafthorse.models import NS_QDT
from drafthorse.pdf import attach_xml
import re

def InvoiceToXML(invoice):
    doc = Document()

doc.context.guideline_parameter.id = "urn:cen.eu:en16931:2017"
    if invoice.leitweg_id:
        doc.context.guideline_parameter.id = "urn:cen.eu:en16931:2017#compliant#urn:xeinkauf.de:kosit:xrechnung_3.0"
        # Standardwert für XRechnung 3.0.1
        doc.context.business_parameter.id = "urn:fdc:peppol.eu:2017:poacc:billing:01:1.0"
    doc.header.id = invoice.id
    # Typecodes:
    # 380: Handelsrechnungen
    # 381: Gutschrift
    # 384: Korrekturrechnung
    # 389: Eigenrechnung (vom Käufer im Namen des Lieferanten erstellt).
    # 261: Selbstverfasste Gutschrift.
    # 386: Vorauszahlungsrechnung
    # 326: Teilrechnung
    # 751: Rechnungsinformation - KEINE RECHNUNG
    if invoice.type == RECHNUNG:
        doc.header.type_code = "380"
    elif invoice.type == GUTSCHRIFT:
        doc.header.type_code = "381"
    elif invoice.type == KORREKTUR:
        doc.header.type_code = "384"
    else:
        raise TypeError("Unbekannter Rechnungstyp, kann kein XML erstellen")
    doc.header.issue_date_time = invoice.date

# Seller-Address
    if invoice.seller['trade_name']:
        doc.trade.agreement.seller.legal_organization.trade_name = invoice.seller['trade_name']
    if invoice.seller["mandatory_details"]["managers"]:
        doc.trade.agreement.seller.description = "Geschäftsführer: " + ", ".join(invoice.seller["mandatory_details"]["managers"])
    if invoice.seller["mandatory_details"]["seat"]:
        doc.trade.agreement.seller.legal_organization.trade_address.city_name = invoice.seller["mandatory_details"]["seat"]
        doc.trade.agreement.seller.legal_organization.trade_address.country_id = "DE"
    if invoice.seller["mandatory_details"]["court"]:
        doc.trade.agreement.seller.description = (
            str(doc.trade.agreement.seller.description) + "\nRegistergericht: " + invoice.seller["mandatory_details"]["court"])
    if invoice.seller["mandatory_details"]["number"]:
        doc.trade.agreement.seller.legal_organization.id = ("0102", invoice.seller["mandatory_details"]["number"])

doc.trade.agreement.seller.name = invoice.seller['name']
    doc.trade.agreement.seller.address.country_id = invoice.seller['address']['country_id']
    doc.trade.agreement.seller.address.postcode = invoice.seller['address']['postcode']
    doc.trade.agreement.seller.address.city_name = invoice.seller['address']['city_name']
    doc.trade.agreement.seller.address.line_one = invoice.seller['address']['line1']
    doc.trade.agreement.seller.address.line_two = invoice.seller['address']['line2']
    doc.trade.agreement.seller.address.line_three = invoice.seller['address']['line3']
    # Für XRECHNUNG muss das Contact-Array mindestens eine Angabe enthalten
    if invoice.seller['contactPerson']:
        doc.trade.agreement.seller.contact.person_name = invoice.seller['contactPerson']
    if invoice.seller['phone']:
        doc.trade.agreement.seller.contact.telephone.number = invoice.seller['phone']
    if invoice.seller_vat_id:
        tax_reg = TaxRegistration()
        tax_reg.id = ('VA', invoice.seller_vat_id)
        doc.trade.agreement.seller.tax_registrations.add(tax_reg)
    if invoice.seller['email']:
        doc.trade.agreement.seller.electronic_address.uri_ID = ('EM', invoice.seller['email'])
        doc.trade.agreement.seller.contact.email.address = invoice.seller['email']

# Buyer-Address
    doc.trade.agreement.buyer.id = str(invoice.customerno)
    doc.trade.agreement.buyer.name = invoice.customer['name']
    doc.trade.agreement.buyer.address.country_id = invoice.customer['address']['country_id']
    doc.trade.agreement.buyer.address.postcode = invoice.customer['address']['postcode']
    doc.trade.agreement.buyer.address.city_name = invoice.customer['address']['city_name']
    doc.trade.agreement.buyer.address.line_one = invoice.customer['address']['line1']
    doc.trade.agreement.buyer.address.line_two = invoice.customer['address']['line2']
    doc.trade.agreement.buyer.address.line_three = invoice.customer['address']['line3']
    # E-Mail-Adresse des Kunden auf jeden Fall in den Kontakt
    if invoice.buyer['email']:
        doc.trade.agreement.buyer.contact.email.address = invoice.buyer['email']
    if invoice.buyer['phone']:
        doc.trade.agreement.buyer.contact.telephone.number = invoice.buyer['phone']
    if invoice.buyer_vat_id:
        tax_reg = TaxRegistration()
        tax_reg.id = ('VA', invoice.buyer_vat_id)
        doc.trade.agreement.buyer.tax_registrations.add(tax_reg)
    if invoice.leitweg_id:
        doc.trade.agreement.buyer.electronic_address.uri_ID = ('0204', invoice.leitweg_id)
    # Bei ZUGFeRD 2.1 darf das Feld nur einmal vorkommen. In XRechnung 3.0 darf es mehrmals drin sein.
    # drafthorse kann aktuell noch kein XRechnung 3.0 erzeugen, daher hier als "elif".
    elif invoice.buyer['email']:
        doc.trade.agreement.buyer.electronic_address.uri_ID = ('EM', invoice.buyer['email'])

if invoice.buyer_reference:
        doc.trade.agreement.buyer_reference = invoice.buyer_reference
    elif invoice.leitweg_id:
        # "Leitweg-ID" in XRechnung
        # Wenn wir hier sind, ist die aber bereits in der electronic_address eingetragen,
        # daher hier nur noch wiederholen, wenn wir das Feld nicht für was anderes brauchen (Kunden-Referenz).
        doc.trade.agreement.buyer_reference = invoice.leitweg_id
    if invoice.order_number:
        doc.trade.agreement.buyer_order.issuer_assigned_id = invoice.order_number
    if invoice.contract_number:
        doc.trade.agreement.contract.issuer_assigned_id = invoice.contract_number

# Wenn alle Leistungsdaten aller Posten exakt ein fixes Datum sind, sollte statt dem Datumbereich der
    # einzelnen Posten doc.trade.delivery.event.occurence verwendet werden. Dazu müssen vorab alle Posten
    # aller Tabellen geprüft werden
    only_one_date = True
    deliverydate = None
    try:
        for part in invoice.parts:
            if not isinstance(part, InvoiceTable):
                continue
            for el in part.entries:
                end = None
                start = None
                if 'period_end' in el and el['period_end']:
                    end = el['period_end']
                if 'period_start' in el and el['period_start']:
                    start = el['period_start']
                if start and end and start != end:
                    deliverydate = None
                    only_one_date = False
                    raise Exception('loop abort')
                if start and not deliverydate:
                    deliverydate = el['period_start']
                    continue
                if start != deliverydate:
                    deliverydate = None
                    only_one_date = False
                    raise Exception('loop abort')
    except Exception as e:
        pass
    if only_one_date and deliverydate:
        doc.trade.delivery.event.occurrence = deliverydate

# Line Items
    summe_netto = Decimal('0.0')
    summe_brutto_rechnerisch = Decimal('0.0')
    summe_brutto = Decimal('0.0')
    summe_bezahlt = Decimal('0.0')
    summe_ust = Decimal('0.0')
    summe_rundung = Decimal('0.0')
    # Problem: Die Rechnung muss netto gestellt werden. Wenn wir die Rechnungsposten brutto erfassen, ergibt sich ein Rundungsfehler.
    # Daher konvertieren wir die Line-Items in stimmige Netto-Items und erfassen für jeden Posten einen Rundungsbetrag,
    # um den wir abgewichen sind.
    line_id_count = 0
    textparts = []
    for part in invoice.parts:
        if isinstance(part, InvoiceText):
            textparts += part.paragraphs
        if isinstance(part, InvoiceTable):
            last_title = None
            for el in part.entries:

if el['type'] == 'title':
                    # Diese Information ist im XML nicht auf diese Weise darstellbar
                    last_title = el['title']
                    continue
                line_id_count += 1
                li = LineItem()
                li.document.line_id = f"{line_id_count}"
                if last_title:
                    title = IncludedNote()
                    title.content = last_title
                    li.document.notes.add(title)
                li.product.name = el['subject']
                if 'desc' in el and el['desc'] != '':
                    li.product.description = el['desc']

if not only_one_date:
                    if 'period_start' in el and el['period_start']:
                        li.settlement.period.start = el['period_start']
                        if 'period_end' in el and el['period_end']:
                            li.settlement.period.end = el['period_end']

unit = 'C62'
                if el['unit']:
                    for key, value in UNITS.items():
                        if el['unit'] in value:
                            unit = key
                li.delivery.billed_quantity = (Decimal(f"{el['count']:.4f}"), unit)
                # C62 = ohne Einheit
                # H87 = Stück
                # MON = Month, SEC = second, MIN = minute, HUR = hour, DAY = day, WEE = week, ANN = year
                # LTR = Liter, MTQ = m³
                # GRM = gram, KGM = Kilogram, TNE = Tonne, DTN = decitonne,
                # MTR = Meter, MMT = Millimeter, KMT = Kilometer
                # MTK = m²
                # KWT = kW, MAW = MW, KWH = kWh, MWH = MWh

li.settlement.trade_tax.type_code = "VAT"
                if invoice.vat_type == VAT_REGULAR:
                    li.settlement.trade_tax.category_code = "S"
                elif invoice.vat_type == VAT_KLEINUNTERNEHMER:
                    li.settlement.trade_tax.category_code = "E"
                elif invoice.vat_type == VAT_INNERGEM:
                    li.settlement.trade_tax.category_code = "K"
                # FIXME: Typ bei uns nur global gesetzt, nicht pro Artikel
                # S = Standard VAT rate
                # Z = Zero rated goods
                # E = VAT exempt
                # AE = Reverse charge
                # K = Intra-Community supply (specific reverse charge)
                # G = Exempt VAT for Export outside EU
                # O = Outside VAT scope
                li.settlement.trade_tax.rate_applicable_percent = Decimal(f"{el['vat'] * 100:.2f}")

nettopreis = round(el['net_price'], 2)
                if nettopreis < 0:
                    li.agreement.net.amount = Decimal('0.00')
                    allowance = TradeAllowanceCharge()
                    allowance.indicator = False
                    allowance.actual_amount = round(abs(nettopreis * el['count']), 2)
                    allowance.reason_code = '104' # Code für "Standard discount"
                    li.settlement.allowance_charge.add(allowance)
                else:
                    li.agreement.net.amount = nettopreis

nettosumme = round(el['net_price'] * el['count'], 2)
                li.settlement.monetary_summation.total_amount = nettosumme

summe_netto += nettosumme
                summe_brutto += round(el['gross_price'] * el['count'], 2)
                summe_brutto_rechnerisch += nettosumme * (el['vat'] + 1)

doc.trade.items.add(li)

for pay in part.payments:
                summe_bezahlt += pay['amount']

for vat, vatdata in part.vat.items():
                trade_tax = ApplicableTradeTax()
                # Steuerbetrag dieses Steuersatzes
                amount = vatdata['vat_amount']
                trade_tax.calculated_amount = Decimal(f"{amount:.2f}")
                # Nettosumme dieses Steuersatzes
                amount = vatdata['net']
                trade_tax.basis_amount = Decimal(f"{amount:.2f}")
                trade_tax.type_code = "VAT"
                if invoice.vat_type == VAT_REGULAR:
                    trade_tax.category_code = "S"
                elif invoice.vat_type == VAT_KLEINUNTERNEHMER:
                    trade_tax.category_code = "E"
                    trade_tax.exemption_reason = 'Als Kleinunternehmer wird gemäß §19 UStG keine USt in Rechnung gestellt.'
                elif invoice.vat_type == VAT_INNERGEM:
                    trade_tax.category_code = "K"
                    trade_tax.exemption_reason_code = 'vatex-eu-ic'
                    trade_tax.exemption_reason = 'Innergemeinschaftliche Lieferung ohne Berechnung von Umsatzsteuer.'
                trade_tax.rate_applicable_percent = Decimal(f"{vat * 100:.1f}")
                summe_ust += vatdata['vat_amount']
                doc.trade.settlement.trade_tax.add(trade_tax)

for paragraph in textparts:
        note = IncludedNote()
        note.content = paragraph
        doc.header.notes.add(note)

if invoice.creditor_reference_id:
        # Gläubiger-ID für SEPA
        doc.trade.settlement.creditor_reference_id = invoice.creditor_reference_id
    doc.trade.settlement.payment_reference = invoice.id
    doc.trade.settlement.currency_code = 'EUR'
    payment_means = PaymentMeans()
    if invoice.payment_type:
        payment_means.type_code = invoice.payment_type

if invoice.seller_bank_data['iban'] and invoice.payment_type == PAYMENT_UEBERWEISUNG:
        payment_means.payee_account.account_name = \
            invoice.seller_bank_data['kontoinhaber'] or invoice.seller['trade_name'] or invoice.seller['name']
        payment_means.payee_account.iban = invoice.seller_bank_data['iban']
        if invoice.seller_bank_data['bic']:
            payment_means.payee_institution.bic = invoice.seller_bank_data['bic']
    if invoice.buyer_bank_data['iban'] and invoice.payment_type == PAYMENT_LASTSCHRIFT:
        # Kunden-Bankverbindung bei Lastschrift
        payment_means.payer_account.iban = invoice.buyer_bank_data['iban']
    doc.trade.settlement.payment_means.add(payment_means)
    terms = PaymentTerms()
    if invoice.due_date and invoice.payment_type == PAYMENT_UEBERWEISUNG:
        terms.description = f"Bitte begleichen Sie den Betrag bis zum {invoice.due_date.strftime('%d.%m.%Y')} ohne Abzüge."
        terms.due = invoice.due_date
    if invoice.type in [GUTSCHRIFT, KORREKTUR]:
        terms.description = f"Wir überweisen den Betrag auf Ihr Konto."
    elif invoice.debit:
        if invoice.debit_mandate_id:
            # Mandatsreferenz für Lastschrift
            terms.debit_mandate_id = invoice.debit_mandate_id
        terms.description = 'Wir buchen von Ihrem Konto ab.'
    doc.trade.settlement.terms.add(terms)

summe_brutto = round(summe_brutto, 2)
    rest = summe_brutto - summe_bezahlt
    summe_netto = round(summe_netto, 2)
    summe_ust = round(summe_ust, 2)
    summe_rundung = summe_brutto - round(summe_brutto_rechnerisch, 2)
    doc.trade.settlement.monetary_summation.line_total = Decimal(f"{summe_netto:.2f}")
    doc.trade.settlement.monetary_summation.charge_total = Decimal("0.00")
    doc.trade.settlement.monetary_summation.allowance_total = Decimal("0.00")
    doc.trade.settlement.monetary_summation.tax_basis_total = Decimal(f"{summe_netto:.2f}")
    doc.trade.settlement.monetary_summation.tax_total = (Decimal(f"{summe_ust:.2f}"), "EUR")
    doc.trade.settlement.monetary_summation.grand_total = Decimal(f"{summe_brutto_rechnerisch:.2f}")
    doc.trade.settlement.monetary_summation.prepaid_total = Decimal(f"{summe_bezahlt:.2f}")
    doc.trade.settlement.monetary_summation.rounding_amount = summe_rundung
    doc.trade.settlement.monetary_summation.due_amount = Decimal(f"{rest:.2f}")

# Generate XML file
    xml = add_namespace(doc.serialize(schema="FACTUR-X_EXTENDED"))
    return xml

def add_namespace(xml):
    """insert xmlns:qdt if it is not in namespaces"""
    decoded = xml.decode('utf-8')
    searchstr = re.search(r'<rsm:CrossIndustryInvoice(.*)>',
                          decoded).group()
    nsmap = searchstr.split(' ')
    _QDT = 'xmlns:qdt='
    QDT = _QDT + '\"' + NS_QDT + '\"'
    if QDT not in nsmap:
        nsmap.insert(1, QDT)
        decoded = decoded.replace(searchstr, ' '.join(nsmap))

return decoded.encode('utf-8')

invoice.git

drafthorse update