invoice.git

1) # -*- coding: utf-8 -*-
2) 
3) import os.path
4) 

5) from reportlab.lib.pagesizes import A4

6) from reportlab.lib.units import cm, inch
7) from reportlab.pdfbase import pdfmetrics

8) from reportlab.pdfbase.ttfonts import TTFont, TTFError
9) from reportlab.pdfgen import canvas
10) 

11) from . import _formatPrice

12) from .InvoiceObjects import InvoiceTable, InvoiceText, InvoiceImage, GUTSCHRIFT
13) 

14) 
15) def find_font_file(filename):
16)     for n in range(4):
17)         candidate = os.path.abspath(os.path.join(os.path.dirname(__file__), '../' * n, 'ressource/fonts', filename))
18)         if os.path.exists(candidate):
19)             return candidate
20) 
21) 
22) def _registerFonts():
23)     fonts = [
24)         ("DejaVu", "DejaVuSans.ttf"),
25)         ("DejaVu-Bold", "DejaVuSans-Bold.ttf"),
26)         ("DejaVu-Italic", "DejaVuSans-Oblique.ttf"),
27)         ("DejaVu-BoldItalic", "DejaVuSans-BoldOblique.ttf")

28)     ]

29)     for fontname, fontfile in fonts:
30)         found = False
31)         try:
32)             pdfmetrics.registerFont(TTFont(fontname, fontfile))
33)             found = True
34)         except TTFError:
35)             pass
36)         if not found:
37)             f = find_font_file(fontfile)
38)             if f:
39)                 pdfmetrics.registerFont(TTFont(fontname, f))
40) 
41) 
42) class PDF(object):
43)     # Set default font size
44)     default_font_size = 8
45)     font = 'DejaVu'
46)     # set margins

47)     topmargin = 2 * cm
48)     bottommargin = 2.2 * cm
49)     leftmargin = 2 * cm
50)     rightmargin = 2 * cm
51)     rightcolumn = 13 * cm
52) 

53)     canvas = None
54)     num_pages = 1

55)     font_height = 0.3 * cm
56)     line_padding = 0.1 * cm
57)     line_height = font_height + 0.1 * cm
58) 

59)     invoice = None

60) 

61)     def __init__(self, invoice):
62)         _registerFonts()
63)         from io import BytesIO
64)         self.fd = BytesIO()

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

66) 
67)         self.invoice = invoice
68) 
69)         self.topcontent = -self.topmargin
70)         self.leftcontent = self.leftmargin
71)         self.rightcontent = A4[0] - self.rightmargin

72)         self.bottomcontent = -(A4[1] - self.bottommargin)

73) 
74)         self.font_size = 8
75)         self.x = 2.0 * cm
76)         self.y = -4.8 * cm - self.font_size - 1

77) 

78)         self.canvas.setFont(self.font, self.font_size)
79) 
80)     def _splitToWidth(self, text, width, font, size):
81)         '''_splitToWidth(canvas, text, width, font, size)
82)         Split a string to several lines of a given width.'''
83)         lines = []
84)         paras = text.split('\n')
85)         for para in paras:
86)             words = para.split(' ')
87)             while len(words) > 0:
88)                 mywords = [words[0], ]
89)                 del words[0]

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

92)                     mywords.append(words[0])
93)                     del words[0]
94)                 lines.append(' '.join(mywords))
95)         return lines

96) 

97)     def _PageMarkers(self):
98)         """Setzt Falzmarken"""

99)         self.canvas.setStrokeColor((0, 0, 0))
100)         self.canvas.setLineWidth(0.01 * cm)
101)         self.canvas.lines([(0.3 * cm, -10.5 * cm, 0.65 * cm, -10.5 * cm),
102)                            (0.3 * cm, -21.0 * cm, 0.65 * cm, -21.0 * cm),
103)                            (0.3 * cm, -14.85 * cm, 0.7 * cm, -14.85 * cm)])

104) 
105)     def _lineHeight(self, fontsize=None, font=None):
106)         if not fontsize:
107)             fontsize = self.default_font_size
108)         if not font:
109)             font = self.font
110)         face = pdfmetrics.getFont(font).face
111)         string_height = (face.ascent - face.descent) / 1000 * fontsize

112)         return string_height + 0.1 * cm
113) 

114)     def _partHeight(self, part):
115)         height = 0

116)         if isinstance(part, InvoiceText):

117)             left, right = self.leftcontent, self.rightcontent
118)             if part.urgent:

119)                 left += 1.5 * cm
120)                 right -= 1.5 * cm

121)                 height += len(part.paragraphs) * 3 * self.line_padding
122)                 # Rechne eine Zeile mehr für den Rahmen
123)                 height += self.line_height
124)             if part.headline:

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

127)             for para in part.paragraphs:

128)                 height += (len(self._splitToWidth(para, right - left, self.font,
129)                                                   self.default_font_size)) * self.line_height) + self.line_padding
130)         elif isinstance(part, InvoiceTable):

131)             # Eine Zeile plus 2 mal line_padding für Tabellenkopf
132)             height = self.line_height + 2 * self.line_padding
133)             # Wenn nur ein Element (plus Summen) hin passt, reicht uns das
134)             el = part.entries[0]
135)             # Die Abstände oben und unten
136)             height += 2 * self.line_padding
137)             # Die Breite ist konservativ
138)             if el['type'] == 'title':

139)                 height += self.line_height + 0.2 * cm

140)             else:

141)                 height += self.line_height * len(self._splitToWidth(el['subject'], 9.3 * cm, self.font, self.font_size))

142)             if 'desc' in el and el['desc'] != '':

143)                 height += self.line_height * len(self._splitToWidth(el['desc'], 11 * cm, self.font, self.font_size))

144)             if part.vatType == 'net':
145)                 # Eine Zeile mehr
146)                 height += self.line_height + self.line_padding
147)             # Für die MwSt-Summen
148)             height += (self.line_height + self.line_padding) * len(part.vat)
149)             # Für den Rechnungsbetrag
150)             height += self.line_height + self.line_padding
151)         return height
152) 
153)     def _tableHead(self, part):
154)         self.canvas.setFont(self.font, self.font_size)

155)         self.canvas.drawString(self.leftcontent + (0.1 * cm), self.y - self.line_height + self.line_padding, 'Anz.')
156)         self.canvas.drawString(self.leftcontent + (2.1 * cm), self.y - self.line_height + self.line_padding,
157)                                'Beschreibung')

158)         if len(part.vat) == 1:

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

161)         else:

162)             self.canvas.drawRightString(self.leftcontent + (13.3 * cm), self.y - self.line_height + self.line_padding,
163)                                         'Einzelpreis')
164)         self.canvas.drawRightString(self.leftcontent + (16.8 * cm), self.y - self.line_height + self.line_padding,
165)                                     'Gesamtpreis')
166)         self.canvas.setLineWidth(0.01 * cm)

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

168)         self.y -= self.line_height + 0.02 * cm
169) 

170)     def _PageWrap(self):
171)         '''Seitenumbruch'''
172)         self.num_pages += 1

173)         self.canvas.setFont(self.font, self.default_font_size - 2)
174)         self.canvas.drawRightString(self.rightcontent, self.bottomcontent + self.line_padding,
175)                                     'Fortsetzung auf Seite %i' % self.num_pages)

176)         self.canvas.showPage()
177)         self.basicPage()
178)         self.y = self.topcontent - self.font_size

179)         self.canvas.setFillColor((0, 0, 0))
180)         self.canvas.setFont(self.font, self.font_size - 2)
181)         self.canvas.drawCentredString(self.leftcontent + (self.rightcontent - self.leftcontent) / 2, self.y,
182)                                       '- Seite %i -' % self.num_pages)
183) 

184)     def _Footer(self):
185)         self.canvas.setStrokeColor((0, 0, 0))

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

187)         self.canvas.line(self.leftcontent, self.bottomcontent, self.rightcontent, self.bottomcontent)
188)         self.canvas.setFont(self.font, 7)
189)         lines = list(filter(None, [
190)             self.invoice.seller['trade_name'],
191)             self.invoice.seller['name'] if self.invoice.seller['trade_name'] else None,
192)             self.invoice.seller['website'],
193)             self.invoice.seller['email'],
194)         ]))
195)         c = 0
196)         for line in lines:
197)             c += 10
198)             self.canvas.drawString(self.leftcontent, self.bottomcontent - c, line)
199) 
200)         if self.invoice.seller_vat_id:
201)             lines = list(filter(None, [
202)                 "USt-ID: " + self.invoice.seller_vat_id
203)             ]))
204)             c = 0
205)             for line in lines:
206)                 c += 10

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

209) 

210)         if self.invoice.seller_bank_data['iban'] and not self.invoice.debit:

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

212)             iban = ' '.join([iban[i:i + 4] for i in range(0, len(iban), 4)])

213)             lines = [
214)                 f"IBAN: {iban}",
215)                 self.invoice.seller_bank_data['bankname'],

216)                 f"BIC: {self.invoice.seller_bank_data['bic']}" if self.invoice.seller_bank_data['bic'] else None,

217)             ]
218)             c = 0
219)             for line in lines:
220)                 c += 10

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

223) 
224)     def basicPage(self):
225)         # Set marker to top.
226)         self.canvas.translate(0, A4[1])
227) 
228)         self._PageMarkers()
229)         self._Footer()
230) 
231)     def addressBox(self):
232)         lines = [
233)             self.invoice.seller['trade_name'],
234)             self.invoice.seller['address']['line1'],
235)             self.invoice.seller['address']['line2'],
236)             self.invoice.seller['address']['line3'],
237)             self.invoice.seller['address']['postcode'] + ' ' + self.invoice.seller['address']['city_name'],
238)         ]
239)         address = ' · '.join(filter(None, lines))

240)         self.canvas.drawString(self.x, self.y + 0.1 * cm, f' {address}')

241)         self.canvas.line(self.x, self.y, self.x + (8.5 * cm), self.y)
242)         self.y = self.y - self.font_size - 3

243) 

244)         font_size = 11

245)         x = self.x + 0.5 * cm
246)         self.y -= 0.5 * cm

247)         self.canvas.setFont(self.font, font_size)
248)         addresslines = filter(None, [
249)             self.invoice.customer['name'].strip(),
250)             self.invoice.customer['address']['line1'] or '',
251)             self.invoice.customer['address']['line2'] or '',
252)             self.invoice.customer['address']['line3'] or '',

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

255)         ])
256)         for line in addresslines:
257)             self.canvas.drawString(x, self.y, line)
258)             self.y -= font_size * 0.03527 * cm * 1.2
259) 
260)     def firstPage(self):
261)         self.basicPage()
262)         self.addressBox()

263) 

264)         self.y = self.topcontent

265)         self.canvas.drawImage(self.invoice.logo_image_file, self.rightcolumn, self.topcontent - (2 * cm),
266)                               height=2 * cm, preserveAspectRatio=True, anchor='nw')
267)         self.y -= (2.5 * cm)
268)         self.canvas.setFont(self.font + "-Bold", self.font_size)
269)         self.canvas.drawString(self.rightcolumn, self.y,
270)                                self.invoice.seller['trade_name'] or self.invoice.seller['name'])

271)         self.y -= (self.font_size + 5)
272)         self.canvas.setFont(self.font, self.font_size)
273)         lines = [
274)             self.invoice.seller['name'] if self.invoice.seller['trade_name'] else None,
275)             self.invoice.seller['address']['line1'],
276)             self.invoice.seller['address']['line2'],
277)             self.invoice.seller['address']['line3'],
278)             self.invoice.seller['address']['postcode'] + ' ' + self.invoice.seller['address']['city_name'],
279)             self.invoice.seller['website'],
280)         ]
281)         address = filter(None, lines)
282)         for line in address:
283)             self.canvas.drawString(self.rightcolumn, self.y, line)
284)             self.y -= (self.font_size + 5)
285)         self.y -= 5

286)         if self.invoice.seller['phone']:
287)             self.canvas.drawString(self.rightcolumn, self.y, f"Tel: {self.invoice.seller['phone']}")
288)             self.y -= (self.font_size + 5)
289)         if self.invoice.seller['email']:
290)             self.canvas.drawString(self.rightcolumn, self.y, f"E-Mail: {self.invoice.seller['email']}")
291)             self.y -= (self.font_size + 10)

292)         self.y = -9.5 * cm

293) 
294)     def title(self, title):
295)         self.canvas.setTitle(title)
296)         self.canvas.drawString(self.leftcontent, self.y, title)
297) 
298)     def renderRechnung(self):
299)         self.firstPage()

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

301)         self.title(self.invoice.title)
302) 
303)         if self.invoice.tender:
304)             self.canvas.setFont(self.font, self.font_size)
305)             self.canvas.drawString(self.rightcolumn, self.y, "Erstellungsdatum:")
306)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.date.strftime('%d. %m. %Y'))

307)             self.y -= (self.font_size + 0.1 * cm)

308)         elif self.invoice.type:

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

310)             self.canvas.drawString(self.rightcolumn, self.y, "Bei Fragen bitte immer angeben:")

311)             self.y -= (self.font_size + 0.2 * cm)

312)             self.canvas.setFont(self.font, self.font_size)
313)             self.canvas.drawString(self.rightcolumn, self.y, "Rechnungsdatum:")
314)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.date.strftime('%d. %m. %Y'))

315)             self.y -= (self.font_size + 0.1 * cm)

316)             self.canvas.drawString(self.rightcolumn, self.y, "Rechnungsnummer:")
317)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.id)

318)             self.y -= (self.font_size + 0.1 * cm)

319)         else:
320)             self.canvas.drawString(self.rightcolumn, self.y, "Datum:")
321)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.date.strftime('%d. %m. %Y'))
322)             self.y -= (self.font_size + 0.1 * cm)

323)         if self.invoice.customerno:
324)             self.canvas.drawString(self.rightcolumn, self.y, "Kundennummer:")
325)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.customerno)

326)             self.y -= (self.font_size + 0.5 * cm)

327)         if self.invoice.leitweg_id:
328)             self.canvas.drawString(self.rightcolumn, self.y, "Leitweg-ID:")
329)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.leitweg_id)
330)             self.y -= (self.font_size + 0.1 * cm)
331)         if self.invoice.buyer_reference:
332)             self.canvas.drawString(self.rightcolumn, self.y, "Kunden-Referenz:")
333)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.buyer_reference)
334)             self.y -= (self.font_size + 0.1 * cm)
335)         if self.invoice.contract_number:
336)             self.canvas.drawString(self.rightcolumn, self.y, "Vertragsnummer:")
337)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.contract_number)
338)             self.y -= (self.font_size + 0.1 * cm)
339)         if self.invoice.order_number:
340)             self.canvas.drawString(self.rightcolumn, self.y, "Ihre Bestellnummer:")
341)             self.canvas.drawRightString(self.rightcontent, self.y, "%s" % self.invoice.order_number)
342)             self.y -= (self.font_size + 0.1 * cm)

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

344) 

345)         if self.invoice.salutation:
346)             self.canvas.drawString(self.leftcontent, self.y, self.invoice.salutation)

347)             self.y -= self.font_size + 0.2 * cm

348)             introText = 'hiermit stellen wir Ihnen die nachfolgend genannten Leistungen in Rechnung.'
349)             if self.invoice.tender:
350)                 introText = 'hiermit unterbreiten wir Ihnen folgendes Angebot.'

351)             if self.invoice.type == GUTSCHRIFT:
352)                 introText = 'nach unserer Berechnung entsteht für Sie folgende Gutschrift.'

353)             intro = self._splitToWidth(introText, self.rightcontent - self.leftcontent, self.font, self.font_size)
354)             for line in intro:
355)                 self.canvas.drawString(self.leftcontent, self.y, line)

356)                 self.y -= self.font_size + 0.1 * cm
357)             self.y -= self.font_size + 0.1 * cm
358) 

359)         font_size = self.default_font_size
360)         for part in self.invoice.parts:

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

362)                 self._PageWrap()

363)                 self.y = self.topcontent - self.font_size - self.line_padding * 3
364)             if isinstance(part, InvoiceTable):
365) 

366)                 left = self.leftcontent
367)                 right = self.rightcontent
368)                 self._tableHead(part)
369)                 temp_sum = 0.0
370)                 odd = True
371)                 for el in part.entries:
372)                     if el['type'] == 'title':

373)                         self.y -= self.line_padding + 0.2 * cm

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

375)                         self.canvas.setFont(self.font + '-Italic', font_size)
376)                         self.canvas.drawString(left, self.y - self.font_height, el['title'])

377)                         self.canvas.setFont(self.font, font_size)
378)                         self.y -= self.line_height + self.line_padding
379)                     else:
380)                         if len(part.vat) == 1:

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

382)                         else:

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

384)                         desc = []
385)                         if 'desc' in el and el['desc'] != '':

386)                             desc = self._splitToWidth(el['desc'], 14.0 * cm, self.font, font_size)

387)                         if 'period_start' in el and el['period_start']:
388)                             if 'period_end' in el and el['period_end']:
389)                                 desc.extend(self._splitToWidth('Leistungszeitraum: %s - %s' %
390)                                                                (el['period_start'].strftime('%d.%m.%Y'),
391)                                                                 el['period_end'].strftime('%d.%m.%Y')),

392)                                                                14.0 * cm, self.font, font_size))

393)                             else:
394)                                 desc.extend(self._splitToWidth('Leistungsdatum: %s' %
395)                                                                (el['period_start'].strftime('%d.%m.%Y'),),

396)                                                                14.0 * cm, self.font, font_size))

397)                         need_lines = len(subject) + len(desc)
398)                         # need page wrap?

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

401)                             self.canvas.setFont(self.font + '-Italic', font_size)
402)                             # Zwischensumme

403)                             self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Zwischensumme:')
404)                             self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height,
405)                                                         _formatPrice(temp_sum))

406)                             # page wrap
407)                             self._PageWrap()

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

409)                             # header
410)                             self._tableHead(part)
411)                             self.y -= self.line_padding * 3

412)                             odd = True

413)                             # übertrag
414)                             self.canvas.setFont(self.font + '-Italic', font_size)

415)                             self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Übertrag:')
416)                             self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height,
417)                                                         _formatPrice(temp_sum))

418)                             self.y -= self.font_height + self.line_padding * 3
419)                             self.canvas.setFont(self.font, self.default_font_size)

420) 

421)                         # Zwischensumme (inkl. aktueller Posten)
422)                         temp_sum += el['total']

423) 

424)                         # draw the background
425)                         if not odd:
426)                             self.canvas.setFillColorRGB(0.9, 0.9, 0.9)
427)                         else:
428)                             self.canvas.setFillColorRGB(1, 1, 1)

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

432)                         self.canvas.setFillColorRGB(0, 0, 0)
433)                         self.y -= self.line_padding

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

435)                         if el['unit']:

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

438)                         if len(part.vat) == 1:

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

441)                         else:

442)                             self.canvas.drawRightString(left + 13.3 * cm, self.y - self.font_height,
443)                                                         _formatPrice(el['price']))
444)                             self.canvas.drawString(left + 13.7 * cm, self.y - self.font_height,
445)                                                    str(part.vat[el['vat']][1]))
446)                         if el['tender']:
447)                             self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, 'eventual')

448)                         else:

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

451)                         subject = subject[1:]
452)                         x = 1
453)                         for line in subject:

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

456)                             x += 1
457)                         for line in desc:

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

460)                             x += 1
461)                         odd = not odd
462)                         self.y -= (need_lines * self.line_height) + self.line_padding
463)                 if part.summary:
464)                     need_lines = 5

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

467)                         self.canvas.setFont(self.font + '-Italic', font_size)
468)                         # Zwischensumme

469)                         self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Zwischensumme:')
470)                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, _formatPrice(temp_sum))

471)                         # page wrap
472)                         self._PageWrap()

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

474)                         # header
475)                         self._tableHead(part)

476)                         odd = True

477)                         # übertrag
478)                         self.canvas.setFont(self.font + '-Italic', font_size)

479)                         self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Übertrag:')
480)                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, _formatPrice(temp_sum))

481)                         self.y -= self.font_height + self.line_padding

482)                     self.y -= (0.3 * cm)

483)                     if part.vatType == 'gross':

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

485)                         if self.invoice.tender or not self.invoice.official:

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

487)                         else:

488)                             self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Rechnungsbetrag:')
489)                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, _formatPrice(part.sum))

490)                         if self.invoice.official:
491)                             self.canvas.setFont(self.font, font_size)
492)                             self.y -= self.line_height + self.line_padding
493)                             summaries = []
494)                             vat = 0.0
495)                             if len(part.vat) == 1 and list(part.vat.keys())[0] == 0.0:
496)                                 self.canvas.drawString(left, self.y - self.font_height,
497)                                                        'Dieser Beleg wurde ohne Ausweis von MwSt erstellt.')
498)                                 self.y -= self.line_height
499)                             else:
500)                                 if len(part.vat) == 1:
501)                                     vat = list(part.vat.keys())[0]
502)                                     if self.invoice.tender:

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

505)                                     else:

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

509)                                 else:
510)                                     for vat, vatdata in part.vat.items():
511)                                         if vat > 0:

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

515)                                         else:

516)                                             summaries.append(('%s: Durchlaufende Posten ohne Berechnung von MwSt.' % (
517)                                                 vatdata[1]), 0.0))
518)                             summaries.append(('Nettobetrag:', _formatPrice(part.sum - (part.sum / (vat + 1)) * vat)))

519)                             summaries.sort()
520)                             for line in summaries:

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

522)                                 if line[1]:

523)                                     self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, line[1])

524)                                 self.y -= self.line_height
525)                     elif len(part.vat) == 1 and part.vatType == 'net':

526)                         self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Nettobetrag:')
527)                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, _formatPrice(part.sum))

528)                         self.y -= self.line_height
529)                         summaries = []
530)                         if list(part.vat.keys())[0] == 0.0:

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

533)                             self.y -= self.line_height
534)                         else:
535)                             if len(part.vat) == 1:
536)                                 vat = list(part.vat.keys())[0]

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

538)                             else:
539)                                 for vat, vatdata in part.vat.items():

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

542)                         summaries.sort()
543)                         for line in summaries:

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

546)                             self.y -= self.line_height
547)                         sum = 0
548)                         for vat, vatdata in part.vat.items():

549)                             sum += (vat + 1) * vatdata[0]
550)                         self.canvas.setFont(self.font + '-Bold', font_size)

551)                         if self.invoice.tender:

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

553)                         else:

554)                             self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, 'Rechnungsbetrag:')
555)                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, _formatPrice(sum))

556)                         self.canvas.setFont(self.font, font_size)
557)                         self.y -= self.line_height + self.line_padding
558)                     paysum = 0.0
559)                     for pay in part.payments:
560)                         paysum += pay['amount']

561)                         descr = 'Zahlung'

562)                         if pay['type'] == 'cash':
563)                             descr = 'gegeben'
564)                         elif pay['type'] == 'return':
565)                             descr = 'zurück'
566)                         elif pay['type'] == 'ec':
567)                             descr = 'Kartenzahlung (EC)'
568)                         elif pay['type'] == 'gutschein':
569)                             descr = 'Einlösung Gutschein'
570)                         if pay['date'] != self.invoice.date:
571)                             descr += ' am %s' % (pay['date'].strftime('%d. %m. %Y'))

572)                         self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height, descr + ':')
573)                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height,
574)                                                     _formatPrice(pay['amount']))

575)                         self.y -= self.line_height
576)                     sum = part.sum
577)                     if part.vatType == 'net':
578)                         sum = 0
579)                         for vat, vatdata in part.vat.items():

580)                             sum += (vat + 1) * vatdata[0]

581)                     rest = sum - paysum
582)                     if part.payments and rest > 0:

583)                         self.canvas.setFont(self.font + '-Bold', font_size)
584)                         self.canvas.drawRightString(left + 14.5 * cm, self.y - self.font_height,
585)                                                     'Offener Rechnungsbetrag:')
586)                         self.canvas.drawRightString(left + 16.8 * cm, self.y - self.font_height, _formatPrice(rest))

587)                         self.canvas.setFont(self.font, font_size)
588)                         self.y -= self.line_height + self.line_padding

589) 

590)                     self.y -= self.line_padding

591)             elif isinstance(part, InvoiceText):
592)                 my_font_size = font_size + part.fontsize  # Relative Schriftgröße beachten

593)                 self.canvas.setFont(self.font, my_font_size)
594)                 left, right = self.leftcontent, self.rightcontent

595)                 indent = 0
596)                 if part.indent:
597)                     if isinstance(part.indent, bool):
598)                         indent = 2 * cm
599)                     else:
600)                         indent = part.indent * cm

601)                 firsttime = True
602)                 headlines = []
603)                 if part.urgent:

604)                     left += 1.5 * cm
605)                     right -= 1.5 * cm

606)                 if part.headline:

607)                     headlines = self._splitToWidth(part.headline, right - left, self.font, my_font_size)

608)                 for para in part.paragraphs:

609)                     lines = self._splitToWidth(para, right - left - indent, self.font, my_font_size)

610)                     if part.urgent:
611)                         need_height = len(lines) * self._lineHeight(my_font_size)
612)                         if len(headlines) > 0:
613)                             need_height += len(headlines) * (self._lineHeight(my_font_size) + 1) + self.line_padding
614)                         self.canvas.setFillColorRGB(0.95, 0.95, 0.95)

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

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

619)                         self.y -= self.line_padding * 3

620)                     if part.headline and firsttime:
621)                         firsttime = False

622)                         self.canvas.setFont(self.font + '-Bold', my_font_size + 1)

623)                         for line in headlines:

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

625)                             self.y -= self._lineHeight(my_font_size) + 1
626)                         self.y -= self.line_padding
627)                         self.canvas.setFont(self.font, my_font_size)
628)                     for line in lines:

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

630)                         self.y -= self._lineHeight(my_font_size)

631)                     self.y -= self.line_padding * 3
632)             elif isinstance(part, InvoiceImage):

633)                 width = (part.imagedata.width / part.dpi) * inch
634)                 height = width * (part.imagedata.height / part.imagedata.width)
635)                 x = self.leftcontent
636)                 if part.alignment == "center":

637)                     x = self.leftcontent + (self.rightcontent - self.leftcontent) / 2 - width / 2

638)                 elif part.alignment == "right":
639)                     x = self.rightcontent - width

640)                 self.canvas.drawInlineImage(part.imagedata, x, self.y - height, width=width, height=height)

641)                 self.y -= self.line_padding + height
642)                 if part.caption:

643)                     self.canvas.drawString(x, self.y - self.font_height, part.caption)

644)                     self.y -= self._lineHeight()
645)             else:
646)                 raise NotImplementedError("Cannot handle part of type %s" % type(part))

647)             self.y -= (0.5 * cm)
648)