invoice.git

@@ -50,9 +51,9 @@ class InvoiceTable(object):

         self.vatType = vatType

     def validEntry(self, entry):

-        '''bekommt einen Eintrag und liefert einen Eintrag wenn ok, wirft ansonsten ValueError.

+        """bekommt einen Eintrag und liefert einen Eintrag, wenn ok; wirft ansonsten ValueError.

         wird benutzt um z.B. die Summe auszurechnen oder ähnliches

-        '''

+        """

         k = entry.keys()

         e = entry

         if not ('count' in k and 'unit' in k and 'subject' in k and 'price' in k and 'vat' in k):

@@ -81,8 +82,8 @@ class InvoiceTable(object):

         return ret

     def addItem(self, data):

-        '''Fügt eine Zeile ein. data muss ein Dict mit passenden Keys und passenden

-        Typen sein'''

+        """Fügt eine Zeile ein. data muss ein Dict mit passenden Keys und passenden

+        Typen sein"""

         d = self.validEntry(data)

         if not d['vat'] in self.vat.keys():

             self.vat[d['vat']] = [0, chr(65+len(self.vat))]

@@ -94,8 +95,8 @@ class InvoiceTable(object):

     def addTitle(self, title):

         self.entries.append({'type': 'title', 'title': title, })

-    def addPayment(self, type, amount, date):

-        self.payments.append({"type": type, "amount": amount, "date": date})

+    def addPayment(self, payment_type, amount, date):

+        self.payments.append({"type": payment_type, "amount": amount, "date": date})

 RECHNUNG = 380

@@ -108,8 +109,9 @@ VAT_KLEINUNTERNEHMER = 'E'

 VAT_INNERGEM = 'K'

 PAYMENT_LASTSCHRIFT = "59"

-PAYMENT_UEBERWEISUNG = "30"

+PAYMENT_UEBERWEISUNG = "58"

 PAYMENT_BANKKONTO = "42"

+PAYMENT_ONLINE = "68"

 PAYMENT_BAR = "10"

 PAYMENT_KARTE = "48"

@@ -179,6 +182,6 @@ class Invoice(object):

         self.date = datetime.date.today()

     def setDate(self, date):

-        if type(date) != datetime.date:

+        if not isinstance(date, datetime.date):

             raise ValueError('date must be of type »datetime.date«')

         self.date = date

@@ -17,19 +17,16 @@

 # along with Bib2011.  If not, see <http://www.gnu.org/licenses/>.

 import os.path

-

-import reportlab

-from reportlab.lib import fonts

-

-from .InvoiceObjects import InvoiceTable, InvoiceText, InvoiceImage, GUTSCHRIFT

 import re

+from reportlab.lib.pagesizes import A4

 # reportlab imports

 from reportlab.lib.units import cm, inch

-from reportlab.lib.pagesizes import A4

-from reportlab.pdfbase.ttfonts import TTFont, TTFError

 from reportlab.pdfbase import pdfmetrics

-from reportlab.pdfgen import canvas as Canvas

+from reportlab.pdfbase.ttfonts import TTFont, TTFError

+from reportlab.pdfgen import canvas

+

+from .InvoiceObjects import InvoiceTable, InvoiceText, InvoiceImage, GUTSCHRIFT

 def _formatPrice(price, symbol='€'):

@@ -91,7 +89,7 @@ class PDF(object):

         _registerFonts()

         from io import BytesIO

         self.fd = BytesIO()

-        self.canvas = Canvas.Canvas(self.fd, pagesize=A4)

+        self.canvas = canvas.Canvas(self.fd, pagesize=A4)

         self.invoice = invoice

@@ -117,7 +114,8 @@ class PDF(object):

             while len(words) > 0:

                 mywords = [words[0], ]

                 del words[0]

-                while len(words) > 0 and self.canvas.stringWidth(' '.join(mywords) + ' ' + words[0], font, size) <= width:

+                while len(words) > 0 and self.canvas.stringWidth(' '.join(mywords) + ' ' + words[0], font,

+                                                                 size) <= width:

                     mywords.append(words[0])

                     del words[0]

                 lines.append(' '.join(mywords))

@@ -144,7 +140,7 @@ class PDF(object):

     def _partHeight(self, part):

         height = 0

-        if type(part) == InvoiceText:

+        if isinstance(part, InvoiceText):

             left, right = self.leftcontent, self.rightcontent

             if part.urgent:

                 left += 1.5 * cm

@@ -153,10 +149,12 @@ class PDF(object):

                 # Rechne eine Zeile mehr für den Rahmen

                 height += self.line_height

             if part.headline:

-                height += (len(self._splitToWidth(part.headline, right-left, self.font+'-Bold', self.default_font_size+1)) * self.line_height) + self.line_padding

+                height += (len(self._splitToWidth(part.headline, right - left, self.font + '-Bold',

+                                                  self.default_font_size + 1)) * self.line_height) + self.line_padding

             for para in part.paragraphs:

-                height += (len(self._splitToWidth(para, right-left, self.font, self.default_font_size)) * self.line_height) + self.line_padding

-        elif type(part) == InvoiceTable:

+                height += (len(self._splitToWidth(para, right - left, self.font,

+                                                  self.default_font_size)) * self.line_height) + self.line_padding

+        elif isinstance(part, InvoiceTable):

             # Eine Zeile plus 2 mal line_padding für Tabellenkopf

             height = self.line_height + 2 * self.line_padding

             # Wenn nur ein Element (plus Summen) hin passt, reicht uns das

@@ -183,12 +180,16 @@ class PDF(object):

     def _tableHead(self, part):

         self.canvas.setFont(self.font, self.font_size)

         self.canvas.drawString(self.leftcontent + (0.1 * cm), self.y - self.line_height + self.line_padding, 'Anz.')

-        self.canvas.drawString(self.leftcontent+(2.1*cm), self.y-self.line_height+self.line_padding, 'Beschreibung')

+        self.canvas.drawString(self.leftcontent + (2.1 * cm), self.y - self.line_height + self.line_padding,

+                               'Beschreibung')

         if len(part.vat) == 1:

-            self.canvas.drawRightString(self.leftcontent+(14.3*cm), self.y-self.line_height+self.line_padding, 'Einzelpreis')

+            self.canvas.drawRightString(self.leftcontent + (14.3 * cm), self.y - self.line_height + self.line_padding,

+                                        'Einzelpreis')

         else:

-            self.canvas.drawRightString(self.leftcontent+(13.3*cm), self.y-self.line_height+self.line_padding, 'Einzelpreis')

-        self.canvas.drawRightString(self.leftcontent+(16.8*cm), self.y-self.line_height+self.line_padding, 'Gesamtpreis')

+            self.canvas.drawRightString(self.leftcontent + (13.3 * cm), self.y - self.line_height + self.line_padding,

+                                        'Einzelpreis')

+        self.canvas.drawRightString(self.leftcontent + (16.8 * cm), self.y - self.line_height + self.line_padding,

+                                    'Gesamtpreis')

         self.canvas.setLineWidth(0.01 * cm)

         self.canvas.line(self.leftcontent, self.y - self.line_height, self.rightcontent, self.y - self.line_height)

         self.y -= self.line_height + 0.02 * cm

@@ -198,14 +198,15 @@ class PDF(object):

         '''Seitenumbruch'''

         self.num_pages += 1

         self.canvas.setFont(self.font, self.default_font_size - 2)

-        self.canvas.drawRightString(self.rightcontent, self.bottomcontent + self.line_padding, 'Fortsetzung auf Seite %i' % self.num_pages)

+        self.canvas.drawRightString(self.rightcontent, self.bottomcontent + self.line_padding,

+                                    'Fortsetzung auf Seite %i' % self.num_pages)

         self.canvas.showPage()

         self.basicPage()

         self.y = self.topcontent - self.font_size

         self.canvas.setFillColor((0, 0, 0))

         self.canvas.setFont(self.font, self.font_size - 2)

-        self.canvas.drawCentredString(self.leftcontent + (self.rightcontent - self.leftcontent) / 2, self.y, '- Seite %i -' % self.num_pages)

-  

+        self.canvas.drawCentredString(self.leftcontent + (self.rightcontent - self.leftcontent) / 2, self.y,

+                                      '- Seite %i -' % self.num_pages)

     def _Footer(self):

         self.canvas.setStrokeColor((0, 0, 0))

@@ -230,7 +231,8 @@ class PDF(object):

             c = 0

             for line in lines:

                 c += 10

-                self.canvas.drawString(self.leftcontent + ((self.rightcontent - self.leftcontent) // 3), self.bottomcontent - c, line)

+                self.canvas.drawString(self.leftcontent + ((self.rightcontent - self.leftcontent) // 3),

+                                       self.bottomcontent - c, line)

         if not self.invoice.debit:

             iban = self.invoice.seller_bank_data['iban']

@@ -243,7 +245,8 @@ class PDF(object):

             c = 0

             for line in lines:

                 c += 10

-                self.canvas.drawString(self.leftcontent + ((self.rightcontent - self.leftcontent) // 3) * 2, self.bottomcontent - c, line)

+                self.canvas.drawString(self.leftcontent + ((self.rightcontent - self.leftcontent) // 3) * 2,

+                                       self.bottomcontent - c, line)

     def basicPage(self):

         # Set marker to top.

@@ -276,7 +277,8 @@ class PDF(object):

             self.invoice.customer['address']['line1'] or '',

             self.invoice.customer['address']['line2'] or '',

             self.invoice.customer['address']['line3'] or '',

-            ((self.invoice.customer['address']['postcode'] or '') + ' ' + (self.invoice.customer['address']['city_name'] or '')).strip(),

+            ((self.invoice.customer['address']['postcode'] or '') + ' ' + (

+                    self.invoice.customer['address']['city_name'] or '')).strip(),

         ])

         for line in addresslines:

             self.canvas.drawString(x, self.y, line)

@@ -292,7 +293,8 @@ class PDF(object):

                               height=2 * cm, preserveAspectRatio=True, anchor='nw')

         self.y -= (2.5 * cm)

         self.canvas.setFont(self.font + "-Bold", self.font_size)

-        self.canvas.drawString(self.rightcolumn, self.y, self.invoice.seller['trade_name'] or self.invoice.seller['name'])

+        self.canvas.drawString(self.rightcolumn, self.y,

+                               self.invoice.seller['trade_name'] or self.invoice.seller['name'])

         self.y -= (self.font_size + 5)

         self.canvas.setFont(self.font, self.font_size)

         lines = [

@@ -369,7 +368,7 @@ class PDF(object):

             if self.y - self._partHeight(part) < (self.bottomcontent + (0.5 * cm)):

                 self._PageWrap()

                 self.y = self.topcontent - self.font_size - self.line_padding * 3

-            if type(part) == InvoiceTable:

+            if isinstance(part, InvoiceTable):

                 left = self.leftcontent

                 right = self.rightcontent

@@ -385,7 +384,6 @@ class PDF(object):

                         self.canvas.setFont(self.font, font_size)

                         self.y -= self.line_height + self.line_padding

                     else:

-                        subject = []

                         if len(part.vat) == 1:

                             subject = self._splitToWidth(el['subject'], 9.8 * cm, self.font, font_size)

                         else:

@@ -405,11 +403,13 @@ class PDF(object):

                                                                14.0 * cm, self.font, font_size))

                         need_lines = len(subject) + len(desc)

                         # need page wrap?

-                        if self.y - (need_lines+1 * (self.line_height + self.line_padding)) < (self.bottomcontent + 1*cm):

+                        if self.y - (need_lines + 1 * (self.line_height + self.line_padding)) < (

+                                self.bottomcontent + 1 * cm):

                             self.canvas.setFont(self.font + '-Italic', font_size)

                             # Zwischensumme

                             self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Zwischensumme:')

-                            self.canvas.drawRightString(left + 16.8*cm, self.y-self.font_height, _formatPrice(temp_sum))

+                            self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height,

+                                                        _formatPrice(temp_sum))

                             # page wrap

                             self._PageWrap()

                             self.y = self.topcontent - font_size - self.line_padding * 3

@@ -420,7 +420,8 @@ class PDF(object):

                             # übertrag

                             self.canvas.setFont(self.font + '-Italic', font_size)

                             self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Übertrag:')

-                            self.canvas.drawRightString(left + 16.8*cm, self.y-self.font_height, _formatPrice(temp_sum))

+                            self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height,

+                                                        _formatPrice(temp_sum))

                             self.y -= self.font_height + self.line_padding * 3

                             self.canvas.setFont(self.font, self.default_font_size)

@@ -433,7 +433,9 @@ class PDF(object):

                             self.canvas.setFillColorRGB(0.9, 0.9, 0.9)

                         else:

                             self.canvas.setFillColorRGB(1, 1, 1)

-                        self.canvas.rect(left, self.y - (need_lines*self.line_height)-(2*self.line_padding), height = (need_lines*self.line_height)+(2*self.line_padding), width = right-left, fill=1, stroke=0)

+                        self.canvas.rect(left, self.y - (need_lines * self.line_height) - (2 * self.line_padding),

+                                         height=(need_lines * self.line_height) + (2 * self.line_padding),

+                                         width=right - left, fill=1, stroke=0)

                         self.canvas.setFillColorRGB(0, 0, 0)

                         self.y -= self.line_padding

                         self.canvas.drawRightString(left + 1.1 * cm, self.y - self.font_height, '%.0f' % el['count'])

@@ -441,27 +443,34 @@ class PDF(object):

                             self.canvas.drawString(left + 1.2 * cm, self.y - self.font_height, el['unit'])

                         self.canvas.drawString(left + 2.2 * cm, self.y - self.font_height, subject[0])

                         if len(part.vat) == 1:

-                            self.canvas.drawRightString(left+14.3*cm, self.y-self.font_height, _formatPrice(el['price']))

+                            self.canvas.drawRightString(left + 14.3 * cm, self.y - self.font_height,

+                                                        _formatPrice(el['price']))

                         else:

-                            self.canvas.drawRightString(left+13.3*cm, self.y-self.font_height, _formatPrice(el['price']))

-                            self.canvas.drawString(left+13.7*cm, self.y-self.font_height, str(part.vat[el['vat']][1]))

+                            self.canvas.drawRightString(left + 13.3 * cm, self.y - self.font_height,

+                                                        _formatPrice(el['price']))

+                            self.canvas.drawString(left + 13.7 * cm, self.y - self.font_height,

+                                                   str(part.vat[el['vat']][1]))

                         if el['tender']:

                             self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, 'eventual')

                         else:

-                            self.canvas.drawRightString(left+16.8*cm, self.y-self.font_height, _formatPrice(el['total']))

+                            self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height,

+                                                        _formatPrice(el['total']))

                         subject = subject[1:]

                         x = 1

                         for line in subject:

-                            self.canvas.drawString(left+2.2*cm, self.y-(x * self.line_height)-self.font_height, line)

+                            self.canvas.drawString(left + 2.2 * cm, self.y - (x * self.line_height) - self.font_height,

+                                                   line)

                             x += 1

                         for line in desc:

-                            self.canvas.drawString(left+2.2*cm, self.y-(x * self.line_height)-self.font_height, line)

+                            self.canvas.drawString(left + 2.2 * cm, self.y - (x * self.line_height) - self.font_height,

+                                                   line)

                             x += 1

                         odd = not odd

                         self.y -= (need_lines * self.line_height) + self.line_padding

                 if part.summary:

                     need_lines = 5

-                    if self.y - (need_lines+1 * (self.line_height + self.line_padding)) < (self.bottomcontent + 1*cm):

+                    if self.y - (need_lines + 1 * (self.line_height + self.line_padding)) < (

+                            self.bottomcontent + 1 * cm):

                         self.canvas.setFont(self.font + '-Italic', font_size)

                         # Zwischensumme

                         self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Zwischensumme:')

@@ -498,15 +507,21 @@ class PDF(object):

                                 if len(part.vat) == 1:

                                     vat = list(part.vat.keys())[0]

                                     if self.invoice.tender:

-                                        summaries.append(('Im Gesamtbetrag sind %.1f%% MwSt enthalten:' % (vat*100), _formatPrice((part.sum/(vat+1))*vat)))

+                                        summaries.append(('Im Gesamtbetrag sind %.1f%% MwSt enthalten:' % (vat * 100),

+                                                          _formatPrice((part.sum / (vat + 1)) * vat)))

                                     else:

-                                        summaries.append(('Im Rechnungsbetrag sind %.1f%% MwSt enthalten:' % (vat*100), _formatPrice((part.sum/(vat+1))*vat)))

+                                        summaries.append((

+                                            'Im Rechnungsbetrag sind %.1f%% MwSt enthalten:' % (vat * 100),

+                                            _formatPrice((part.sum / (vat + 1)) * vat)))

                                 else:

                                     for vat, vatdata in part.vat.items():

                                         if vat > 0:

-                                            summaries.append(('%s: Im Teilbetrag von %s sind %.1f%% MwSt enthalten:' % (vatdata[1], _formatPrice(vatdata[0]), vat*100), _formatPrice((vatdata[0]/(vat+1))*vat)))

+                                            summaries.append(('%s: Im Teilbetrag von %s sind %.1f%% MwSt enthalten:' % (

+                                                vatdata[1], _formatPrice(vatdata[0]), vat * 100),

+                                                              _formatPrice((vatdata[0] / (vat + 1)) * vat)))

                                         else:

-                                            summaries.append(('%s: Durchlaufende Posten ohne Berechnung von MwSt.' % (vatdata[1]), 0.0))

+                                            summaries.append(('%s: Durchlaufende Posten ohne Berechnung von MwSt.' % (

+                                                vatdata[1]), 0.0))

                             summaries.append(('Nettobetrag:', _formatPrice(part.sum - (part.sum / (vat + 1)) * vat)))

                             summaries.sort()

                             for line in summaries:

@@ -520,7 +535,8 @@ class PDF(object):

                         self.y -= self.line_height

                         summaries = []

                         if list(part.vat.keys())[0] == 0.0:

-                            self.canvas.drawString(left, self.y-self.font_height, 'Dieser Beleg wurde ohne Ausweis von MwSt erstellt.')

+                            self.canvas.drawString(left, self.y - self.font_height,

+                                                   'Dieser Beleg wurde ohne Ausweis von MwSt erstellt.')

                             self.y -= self.line_height

                         else:

                             if len(part.vat) == 1:

@@ -528,7 +544,8 @@ class PDF(object):

                                 summaries.append(('zzgl. %.1f%% MwSt:' % (vat * 100), _formatPrice(vat * part.sum)))

                             else:

                                 for vat, vatdata in part.vat.items():

-                                    summaries.append(('zzgl. %.1f%% MwSt (%s):' % (vat*100, vatdata[1]), _formatPrice(vat*vatdata[0])))

+                                    summaries.append(('zzgl. %.1f%% MwSt (%s):' % (vat * 100, vatdata[1]),

+                                                      _formatPrice(vat * vatdata[0])))

                         summaries.sort()

                         for line in summaries:

                             self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, line[0])

@@ -560,7 +577,8 @@ class PDF(object):

                         if pay['date'] != self.invoice.date:

                             descr += ' am %s' % (pay['date'].strftime('%d. %m. %Y'))

                         self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, descr + ':')

-                        self.canvas.drawRightString(left + 16.8*cm, self.y-self.font_height, _formatPrice(pay['amount']))

+                        self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height,

+                                                    _formatPrice(pay['amount']))

                         self.y -= self.line_height

                     sum = part.sum

                     if part.vatType == 'net':

@@ -570,13 +588,14 @@ class PDF(object):

                     rest = sum - paysum

                     if part.payments and rest > 0:

                         self.canvas.setFont(self.font + '-Bold', font_size)

-                        self.canvas.drawRightString(left + 14.5*cm, self.y-self.font_height, 'Offener Rechnungsbetrag:')

+                        self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height,

+                                                    'Offener Rechnungsbetrag:')

                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, _formatPrice(rest))

                         self.canvas.setFont(self.font, font_size)

                         self.y -= self.line_height + self.line_padding

                     self.y -= self.line_padding

-            elif type(part) == InvoiceText:

+            elif isinstance(part, InvoiceText):

                 my_font_size = font_size + part.fontsize  # Relative Schriftgröße beachten

                 self.canvas.setFont(self.font, my_font_size)

                 left, right = self.leftcontent, self.rightcontent

@@ -594,7 +613,9 @@ class PDF(object):

                         if len(headlines) > 0:

                             need_height += len(headlines) * (self._lineHeight(my_font_size) + 1) + self.line_padding

                         self.canvas.setFillColorRGB(0.95, 0.95, 0.95)

-                        self.canvas.rect(left-0.5*cm, self.y - (need_height+(6*self.line_padding)), height = need_height+(6*self.line_padding), width = right-left+1*cm, fill=1, stroke=1)

+                        self.canvas.rect(left - 0.5 * cm, self.y - (need_height + (6 * self.line_padding)),

+                                         height=need_height + (6 * self.line_padding), width=right - left + 1 * cm,

+                                         fill=1, stroke=1)

                         self.canvas.setFillColorRGB(0, 0, 0)

                         self.y -= self.line_padding * 3

                     if part.headline and firsttime:

@@ -609,8 +630,7 @@ class PDF(object):

                         self.canvas.drawString(left, self.y - self.font_height, line)

                         self.y -= self._lineHeight(my_font_size)

                     self.y -= self.line_padding * 3

-                left, right = self.leftcontent, self.rightcontent

-            elif type(part) == InvoiceImage:

+            elif isinstance(part, InvoiceImage):

                 width = (part.imagedata.width / part.dpi) * inch

                 height = width * (part.imagedata.height / part.imagedata.width)

                 x = self.leftcontent

@@ -636,23 +656,3 @@ class PDF(object):

 def InvoiceToPDF(iv):

     pdf = PDF(iv)

     return pdf.renderRechnung()

-

-

-

-

-if __name__ == '__main__':

-    import datetime

-    from lib.Speicher import Speicher

-    from lib.BelegRechnung import BelegRechnung

-    s = Speicher()

-    import sys, os

-    renr = 'R2024-3149'

-    if len(sys.argv) > 1:

-        renr=sys.argv[1]

-    kb = s.getKassenbeleg(renr=renr)

-

-    filename = BelegRechnung(kb)

-    print (filename)

-

-

-

@@ -2,8 +2,8 @@

 from __future__ import division

-from .InvoiceObjects import Invoice, InvoiceTable, InvoiceText, InvoiceImage, PAYMENT_UEBERWEISUNG

 from utils import format_price, split_to_width

+from .InvoiceObjects import Invoice, InvoiceTable, InvoiceText, InvoiceImage, PAYMENT_UEBERWEISUNG

 def _breakLine(text, width=72):

@@ -21,9 +21,9 @@ def _breakLine(text, width=72):

     return lines

-def InvoiceToText(invoice : Invoice, bankdata=True):

-    ret = []

-    ret.append(u'Rechnungsempfänger:')

+def InvoiceToText(invoice: Invoice):

+    ret = [u'Rechnungsempfänger:',

+           ]

     addresslines = filter(None, [

         invoice.customer['name'].strip(),

         invoice.customer['address']['line1'] or '',

@@ -41,11 +41,11 @@ def InvoiceToText(invoice : Invoice, bankdata=True):

     ret.append('')

     for part in invoice.parts:

-        if type(part) == InvoiceTable:

+        if isinstance(part, InvoiceTable):

             ret.append(InvoiceTableToText(part))

-        elif type(part) == InvoiceText:

+        elif isinstance(part, InvoiceText):

             ret.append(InvoiceTextToText(part))

-        elif type(part) == InvoiceImage:

+        elif isinstance(part, InvoiceImage):

             # ignore images

             pass

         else:

@@ -75,14 +75,27 @@ def InvoiceTableToText(invoiceTable : InvoiceTable):

             unit = ' %s' % el['unit']

         if len(invoiceTable.vat) < 2:

             subject = _breakLine(el['subject'], width=39)

-            ret.append(u'%5.2f %-3s %-39s  %10s %10s' % (el['count'], unit, subject[0], format_price(el['price']), format_price(el['total'])))

+            ret.append(u'%5.2f %-3s %-39s  %10s %10s' % (

+                el['count'], unit, subject[0], format_price(el['price']), format_price(el['total'])))

             for i in range(1, len(subject)):

                 ret.append(u'          %s' % subject[i])

         else:

             subject = _breakLine(el['subject'], width=41)

-            ret.append(u'%5.2f %-3s %-37s  %10s %s %10s' % (el['count'], unit, subject[0], format_price(el['price']), invoiceTable.vat[el['vat']][1], format_price(el['total'])))

+            ret.append(u'%5.2f %-3s %-37s  %10s %s %10s' % (

+                el['count'], unit, subject[0], format_price(el['price']), invoiceTable.vat[el['vat']][1],

+                format_price(el['total'])))

             for i in range(1, len(subject)):

                 ret.append(u'          %s' % subject[i])

+        if 'period_start' in el and el['period_start']:

+            if 'period_end' in el and el['period_end']:

+                desc = _breakLine('(%s - %s)' %

+                                               (el['period_start'].strftime('%d.%m.%Y'),

+                                                el['period_end'].strftime('%d.%m.%Y')))

+            else:

+                desc = _breakLine('Leistungsdatum: %s' %

+                                               (el['period_start'].strftime('%d.%m.%Y')))

+            for line in desc:

+                ret.append(u'          %s' % line)

         if 'desc' in el and el['desc']:

             desc = _breakLine(el['desc'], 39)

             for line in desc:

@@ -94,10 +107,12 @@ def InvoiceTableToText(invoiceTable : InvoiceTable):

         summaries = []

         if len(invoiceTable.vat) == 1:

             vat = list(invoiceTable.vat.keys())[0]

-            summaries.append(u'      Im Rechnungsbetrag sind %.1f%% MwSt enthalten (%s)' % (vat * 100, format_price((invoiceTable.sum / (vat + 1)) * vat)))

+            summaries.append(u'      Im Rechnungsbetrag sind %.1f%% MwSt enthalten (%s)' % (

+                vat * 100, format_price((invoiceTable.sum / (vat + 1)) * vat)))

         else:

             for vat, vatdata in list(invoiceTable.vat.items()):

-                summaries.append(u'    %s: Im Teilbetrag von %s sind %.1f%% MwSt enthalten (%s)' % (vatdata[1], format_price(vatdata[0]), vat * 100, format_price((vatdata[0] / (vat + 1)) * vat)))

+                summaries.append(u'    %s: Im Teilbetrag von %s sind %.1f%% MwSt enthalten (%s)' % (

+                    vatdata[1], format_price(vatdata[0]), vat * 100, format_price((vatdata[0] / (vat + 1)) * vat)))

         summaries.sort()

         for line in summaries:

             ret.append(line)

@@ -109,14 +124,16 @@ def InvoiceTableToText(invoiceTable : InvoiceTable):

             summaries.append((u'zzgl. %.1f%% MwSt: %11s' % (vat * 100, format_price(vat * invoiceTable.sum))).rjust(72))

         elif len(invoiceTable.vat) > 1:

             for vat, vatdata in list(invoiceTable.vat.items()):

-                summaries.append((u'zzgl. %4.1f%% MwSt (%s): %11s' % (vat * 100, vatdata[1], format_price(vat * vatdata[0]))).rjust(72))

+                summaries.append(

+                    (u'zzgl. %4.1f%% MwSt (%s): %11s' % (vat * 100, vatdata[1], format_price(vat * vatdata[0]))).rjust(

+                        72))

         summaries.sort()

         for line in summaries:

             ret.append(line)

-        sum = invoiceTable.sum

+        tablesum = invoiceTable.sum

         for vat, vatdata in list(invoiceTable.vat.items()):

-            sum += vat * vatdata[0]

-        ret.append((u'Rechnungsbetrag: %11s' % format_price(sum)).rjust(72))

+            tablesum += vat * vatdata[0]

+        ret.append((u'Rechnungsbetrag: %11s' % format_price(tablesum)).rjust(72))

     ret.append('')

     return '\n'.join(ret)

@@ -18,9 +18,6 @@

 import os.path, sys

 from decimal import Decimal

-import datetime

-

-import re

 # Search for included submodule python-drafthorse

 atoms = os.path.abspath(os.path.dirname(__file__)).split('/')

@@ -35,7 +32,7 @@ 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, InvoiceImage, RECHNUNG, GUTSCHRIFT, KORREKTUR, \

+from .InvoiceObjects import InvoiceTable, InvoiceText, RECHNUNG, GUTSCHRIFT, KORREKTUR, \

     VAT_REGULAR, VAT_KLEINUNTERNEHMER, VAT_INNERGEM, PAYMENT_UEBERWEISUNG, PAYMENT_LASTSCHRIFT

 from drafthorse.models.party import TaxRegistration, URIUniversalCommunication

 from drafthorse.models.payment import PaymentTerms

@@ -104,9 +101,9 @@ def InvoiceToXML(invoice):

     line_id_count = 0

     textparts = []

     for part in invoice.parts:

-        if type(part) == InvoiceText:

+        if isinstance(part, InvoiceText):

             textparts += part.paragraphs

-        if type(part) == InvoiceTable:

+        if isinstance(part, InvoiceTable):

             for el in part.entries:

                 line_id_count += 1

                 li = LineItem()

@@ -236,19 +233,5 @@ def InvoiceToXML(invoice):

     return xml

-if __name__ == '__main__':

-    import datetime

-    from lib.Speicher import Speicher

-    from lib.BelegRechnung import BelegRechnung

-    s = Speicher()

-    import sys, os

-    renr = 'R2024-3149'

-    if len(sys.argv) > 1:

-        renr=sys.argv[1]

-    kb = s.getKassenbeleg(renr=renr)

-

-    filename = BelegRechnung(kb)

-    print(filename)

-