invoice.git

1) # -* coding: utf8 *-
2) 

3) import Invoice

4) import re
5) 

6) # our page size and margins
7) from metrics import *
8) # our custom page style

9) from custom_elements import basicPage, firstPage, address_header

10) 

11) # reportlab imports
12) from reportlab.lib.units import cm
13) from reportlab.pdfgen import canvas as Canvas

14) from reportlab.lib.colors import Color

15) 

16) num_pages = 1
17) 
18) 

19) def _formatPrice(price, symbol='€'):
20)   '''_formatPrice(price, symbol='€'):
21)   Gets a floating point value and returns a formatted price, suffixed by 'symbol'. '''
22)   s = ("%.2f" % price).replace('.', ',')
23)   pat = re.compile(r'([0-9])([0-9]{3}[.,])')
24)   while pat.search(s):
25)     s = pat.sub(r'\1.\2', s)
26)   return s+' '+symbol
27) 
28) def _niceCount(value):
29)   '''_niceCount(value):
30)   Returns a tuple (integer , decimals) where decimals can be None'''
31)   if type(value) == int:
32)     return ('%i' % value, None)
33)   if round(value, 2) == int(value):
34)     return ('%i' % int(value), None)
35)   s = '%.2f' % value
36)   (integer, decimals) = s.split('.', 1)
37)   if decimals[-1] == '0':
38)     decimals = decimals[:-1]
39)   return (integer, decimals)
40) 
41) 
42) def _splitToWidth(canvas, text, width, font, size):
43)   '''_splitToWidth(canvas, text, width, font, size)
44)   Split a string to several lines of a given width.'''
45)   lines = []
46)   paras = text.split('\n')
47)   for para in paras:
48)     words = para.split(' ')
49)     while len(words) > 0:
50)       mywords = [words[0], ]
51)       del words[0]
52)       while len(words) > 0 and canvas.stringWidth(' '.join(mywords) + ' ' + words[0], font, size) <= width:
53)         mywords.append(words[0])
54)         del words[0]
55)       lines.append(' '.join(mywords))
56)   return lines
57) 
58) 

59) def _drawJustifiedString(x, y, text, canvas, width, font, size):
60)   text = text.strip()
61)   if canvas.stringWidth(text, font, size) > width:
62)     canvas.drawString(x, y, text)
63)     # too long line, I cannot handle this
64)     return
65)   if not ' ' in text:
66)     canvas.drawString(x, y, text)
67)     # no space in there, nothing to justify
68)     return
69)   
70)   words = [ '%s' % w for w in text.split(' ')]
71)   words_width = 0.0
72)   for word in words:
73)     words_width += canvas.stringWidth(word, font, size)
74)   
75)   available_space = width - words_width
76)   available_each = available_space / float((len(words) - 1))
77)  
78)   my_x = x
79)   for idx in range(len(words)):
80)     word = words[idx]
81)     canvas.drawString(my_x, y, word)
82)     my_x += canvas.stringWidth(word, font, size) + available_each
83)   return
84) 

85) 

86) def address(canvas, lines):
87)   x = 2.0 * cm
88)   y = page_height - 5.0*cm
89)   canvas.setFont(font, 8)

90)   canvas.drawString(x+0.5*cm, y+0.1*cm, 'schokokeks.org · Köchersberg 32 · 71540 Murrhardt')

91)   canvas.setLineWidth(1)
92)   canvas.line(x+0.4*cm, y, x + address_width, y)
93)   y = y - 0.2*cm
94) 
95)   line_height = 11 + 0.1*cm
96)   y -= line_height

97) 
98)   fontsize = 11

99)   for line in lines:
100)     if canvas.stringWidth(line, font, fontsize) > address_width:
101)       # Wenn es in zwei Zeilen passt, dann ist alles okay, ansonsten verkleinern

102)       if len(lines) > 4 or canvas.stringWidth(line, font, fontsize) > 2*address_width:
103)         for candidate in [10.5, 10, 9.5, 9, 8.5, 8]:
104) 	  fontsize = candidate
105)           if (len(lines) <= 4 and canvas.stringWidth(line, font, fontsize) <= 2*address_width) or canvas.stringWidth(line, font, fontsize) <= address_width:

106)             break

107)   for line in lines:
108)     if canvas.stringWidth(line, font, fontsize) > address_width:

109)       mylines = _splitToWidth(canvas, line, address_width, font, fontsize)
110)       for l in mylines:

111)   	canvas.setFont(font, fontsize)

112)         canvas.drawString(x+0.5*cm, y, l)
113)         y -= line_height
114)     else:

115)       canvas.setFont(font, fontsize)

116)       canvas.drawString(x+0.5*cm, y, line)
117)       y -= line_height
118) 
119) 
120) 

121) 

122) def InvoiceToPDF(iv, bankdata=True):

123)   from StringIO import StringIO
124)   fd = StringIO()
125)   canvas = Canvas.Canvas(fd, pagesize=A4)

126)   

127)   if iv.tender:
128)     canvas.setTitle("Angebot von schokokeks.org")
129)   else:
130)     canvas.setTitle("Rechnung von schokokeks.org")

131)   

132)   canvas.setFont(font, 12)
133) 
134) 
135)   # Waehrungssysmbol
136)   symbol = '€'
137)   y = topcontent
138)   font_size = default_font_size
139)   font_height = 0.35*cm
140)   line_padding = 0.1*cm
141)   line_height = font_height+0.1*cm
142) 
143)   def _partHeight(part):
144)     height = 0

145)     if type(part) == Invoice.Text:

146)       left, right = leftcontent, rightcontent
147)       if part.urgent:
148)         left += 1.5*cm
149)         right -= 1.5*cm
150)         height += len(part.paragraphs) * 3 * line_padding

151)         # Rechne eine Zeile mehr für den Rahmen
152)         height += line_height

153)       if part.headline:
154)         height += (len(_splitToWidth(canvas, part.headline, right-left, font+'-Bold', default_font_size+1)) * line_height) + line_padding
155)       for para in part.paragraphs:  
156)         height += (len(_splitToWidth(canvas, para, right-left, font, default_font_size)) * line_height) + line_padding

157)     elif type(part) == Invoice.Table:

158)       # Eine Zeile plus 2 mal line_padding für Tabellenkopf
159)       height = line_height + 2 * line_padding

160)       # Wenn nur ein Element (plus Summen) hin passt, reicht uns das
161)       el = part.entries[0]
162)       # Die Abstände oben und unten
163)       height += 2 * line_padding
164)       # Die Breite ist konservativ
165)       height += line_height*len(_splitToWidth(canvas, el['subject'], 9.3*cm, font, font_size))
166)       if 'desc' in el and el['desc'] != '':
167)         height += line_height * len(_splitToWidth(canvas, el['desc'], 11*cm, font, font_size))

168)       if part.vatType == 'net':
169)         # Eine Zeile mehr
170)         height += line_height + line_padding
171)       # Für die MwSt-Summen
172)       height += (line_height + line_padding) * len(part.vat)
173)       # Für den Rechnungsbetrag
174)       height += line_height + line_padding

175)     return height
176) 
177) 

178)   def _tableHead(y):
179)     canvas.setFont(font, font_size)
180)     canvas.drawString(left+(0.1*cm), y-line_height+line_padding, 'Anz.')
181)     canvas.drawString(left+(2.6*cm), y-line_height+line_padding, 'Beschreibung')
182)     if len(part.vat) == 1:
183)       canvas.drawRightString(left+(14.3*cm), y-line_height+line_padding, 'Einzelpreis')
184)     else:
185)       canvas.drawRightString(left+(13.7*cm), y-line_height+line_padding, 'Einzelpreis')
186)     canvas.drawRightString(left+(16.8*cm), y-line_height+line_padding, 'Gesamtpreis')
187)     canvas.setLineWidth(0.01*cm)
188)     canvas.line(left, y - line_height, right, y - line_height)
189)     y -= line_height + 0.02*cm
190)     return y

191)    

192)   def _PageWrap(canvas):
193)     '''Seitenumbruch'''
194)     global num_pages
195)     num_pages += 1
196)     canvas.setFont(font, default_font_size-2)
197)     canvas.drawRightString(rightcontent, bottomcontent + line_padding, 'Fortsetzung auf Seite %i' % num_pages)
198)     canvas.showPage()
199)     basicPage(canvas)
200)     y = topcontent - font_size
201)     canvas.setFillColor((0,0,0))
202)     canvas.setFont(font, font_size-2)
203)     canvas.drawCentredString(leftcontent + (rightcontent - leftcontent) / 2, y, '- Seite %i -' % num_pages)
204) 
205) 

206)   address(canvas, iv.addresslines)

207) 
208)   font_size = default_font_size

209)   y = firstPage(canvas)

210)   if bankdata==False:
211)     # Bankdaten überschreiben wenn Lastschrift
212)     canvas.setFillColor( Color(255,255,255, alpha=0.8) )
213)     canvas.rect(leftcontent+((rightcontent-leftcontent)/3)*2 - 2, bottomcontent - 2, (rightcontent-leftcontent)/3, -40, fill=True, stroke=False)
214)     canvas.setFillColor( Color(0,0,0, alpha=1) ) 
215)     canvas.saveState()
216)     canvas.translate( leftcontent+((rightcontent-leftcontent)/3)*2 + 2, bottomcontent - 40 )
217)     canvas.rotate( 15 )
218)     canvas.drawString( 0, 0, "Bitte nicht überweisen" )
219)     canvas.restoreState()
220)     #canvas.drawString(leftcontent+((rightcontent-leftcontent)/3)*2 + 2, bottomcontent - 20, "Bitte nicht überweisen")
221) 

222) 
223)   canvas.setFont(font+'-Bold', font_size+3)

224)   min_y = y
225)   if iv.caption:
226)     canvas.drawString(leftcontent, y, iv.caption)
227)     min_y -= (font_size + 3) + 0.5*cm

228) 

229)   if type(iv) == Invoice.Tender:

230)     canvas.setFont(font, font_size)
231)     canvas.drawString(rightcolumn, y, "Erstellungsdatum:")
232)     canvas.drawRightString(rightcontent, y, "%s" % iv.date.strftime('%d. %m. %Y'))
233)     y -= (font_size + 0.1*cm)

234)   elif type(iv) == Invoice.Generic:
235)     canvas.setFont(font, font_size)
236)     canvas.drawString(rightcolumn, y, "Datum:")
237)     canvas.drawRightString(rightcontent, y, "%s" % iv.date.strftime('%d. %m. %Y'))
238)     y -= (font_size + 0.1*cm)
239)   elif type(iv) == Invoice.Invoice:

240)     canvas.setFont(font+'-Bold', font_size)
241)     canvas.drawString(rightcolumn, y, "Bei Fragen bitte immer angeben:")
242)     y -= (font_size + 0.2*cm)
243)     canvas.setFont(font, font_size)
244)     canvas.drawString(rightcolumn, y, "Rechnungsdatum:")
245)     canvas.drawRightString(rightcontent, y, "%s" % iv.date.strftime('%d. %m. %Y'))
246)     y -= (font_size + 0.1*cm)
247)     canvas.drawString(rightcolumn, y, "Rechnungsnummer:")
248)     canvas.drawRightString(rightcontent, y, "%i" % iv.id)
249)     y -= (font_size + 0.1*cm)
250)   if iv.customerno:
251)     canvas.drawString(rightcolumn, y, "Kundennummer:")
252)     canvas.drawRightString(rightcontent, y, "%s" % iv.customerno)
253)     y -= (font_size + 0.5*cm)
254)   canvas.setFont(font, font_size)

255)   y = min(min_y, y)
256) 
257)   if iv.salutation:
258)     canvas.drawString(leftcontent, y, iv.salutation)
259)     y -= font_size + 0.2*cm
260)     if type(iv) in [Invoice.Tender, Invoice.Invoice]:
261)       introText = 'hiermit stellen wir Ihnen die nachfolgend genannten Leistungen in Rechnung.'
262)       if type(iv) == Invoice.Tender:
263)         introText = 'hiermit unterbreiten wir Ihnen folgendes Angebot.'
264)       intro = _splitToWidth(canvas, introText, rightcontent - leftcontent, font, font_size)
265)       for line in intro:
266)         canvas.drawString(leftcontent, y, line)
267)         y -= font_size + 0.1*cm
268)       y -= font_size + 0.1*cm

269) 
270)   font_size = default_font_size
271)   for part in iv.parts:
272)     if y - _partHeight(part) < (bottomcontent + (0.5*cm)):
273)       _PageWrap(canvas)

274)       y = topcontent - font_size - line_padding*3

275)     # Debug: Was hat die Höhenbestimmung für diesen Teil als Höhe herausgefunden?
276)     #canvas.line(leftcontent, y-_partHeight(part), rightcontent, y-_partHeight(part))
277) 

278)     if type(part) == Invoice.Table:

279)         
280)       left = leftcontent
281)       right = rightcontent
282)       top = topcontent
283)       bottom = bottomcontent

284)       temp_sum = 0.0
285)       y = _tableHead(y)

286)       odd=True
287)       for el in part.entries:
288)         subject = []
289)         if len(part.vat) == 1:
290)           subject = _splitToWidth(canvas, el['subject'], 10.3*cm, font, font_size)
291)         else:
292)           subject = _splitToWidth(canvas, el['subject'], 9.3*cm, font, font_size)
293)         desc = []
294)         if 'desc' in el and el['desc'] != '':

295)           desc = _splitToWidth(canvas, el['desc'], 11*cm, font, font_size)

296)         need_lines = len(subject) + len(desc)

297) 

298) 	# need page wrap?
299)       	if y - (need_lines+2 * font_size) < (bottomcontent + 2*cm):
300)           canvas.setFont(font, font_size)
301) 	  # Zwischensumme
302)           canvas.drawRightString(left + 14.5*cm, y-font_height, 'Zwischensumme:')
303)           canvas.drawRightString(left + 16.8*cm, y-font_height, _formatPrice(temp_sum))
304) 	  # page wrap
305) 	  _PageWrap(canvas)
306)           y = topcontent - font_size - line_padding*3
307) 	  # header
308) 	  y = _tableHead(y)
309)           odd=True
310) 	  # übertrag
311)           canvas.setFont(font, font_size)
312)           canvas.drawRightString(left + 14.5*cm, y-font_height, 'Übertrag:')
313)           canvas.drawRightString(left + 16.8*cm, y-font_height, _formatPrice(temp_sum))
314) 	  y -= font_height + line_padding
315) 
316) 	# Zwischensumme (inkl. aktueller Posten)
317)         temp_sum += el['total']

318)         # draw the background
319)         if not odd:
320)           canvas.setFillColorRGB(0.9, 0.9, 0.9)
321)         else:
322)           canvas.setFillColorRGB(1, 1, 1)
323)         canvas.rect(left, y - (need_lines*line_height)-(2*line_padding), height = (need_lines*line_height)+(2*line_padding), width = right-left, fill=1, stroke=0)
324)         canvas.setFillColorRGB(0, 0, 0)
325)         y -= line_padding
326)         (integer, decimals) = _niceCount(el['count'])
327)         canvas.drawRightString(left+0.8*cm, y-font_height, integer)

328) 	suffix = ''
329) 	if decimals:
330) 	  suffix = ',%s' % decimals
331) 	if el['unit']:
332) 	  suffix = suffix + ' ' + el['unit']
333)         if suffix:
334)           canvas.drawString(left+0.8*cm, y-font_height, '%s' % suffix)
335) 	  

336)         if len(part.vat) < 2:

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

338)           canvas.drawRightString(left+14.3*cm, y-font_height, _formatPrice(el['price']))
339)           if el['tender']:  
340)             canvas.drawRightString(left+16.8*cm, y-font_height, 'eventual')
341)           else:
342)             canvas.drawRightString(left+16.8*cm, y-font_height, _formatPrice(el['total']))
343)           subject = subject[1:]
344)           x = 1
345)           for line in subject:

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

347)             x += 1

348)           for line in desc[:-1]:

349)             _drawJustifiedString(left+2.7*cm, y-(x * line_height)-font_height, line, canvas, 11*cm, font, font_size)

350)             x += 1

351)           canvas.drawString(left+2.7*cm, y-(x * line_height)-font_height, desc[-1])

352)           x += 1

353)         else:

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

355)           canvas.drawRightString(left+13.3*cm, y-font_height, _formatPrice(el['price']))
356)           canvas.drawString(left+13.7*cm, y-font_height, str(part.vat[el['vat']][1]))
357)           if el['tender']:  
358)             canvas.drawRightString(left+16.8*cm, y-font_height, 'eventual')
359)           else:
360)             canvas.drawRightString(left+16.8*cm, y-font_height, _formatPrice(el['total']))
361)           subject = subject[1:]
362)           x = 1
363)           for line in subject:

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

365)             x += 1
366)           for line in desc:

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

368)             x += 1
369)         odd = not odd
370)         y -= (need_lines * line_height) + line_padding
371)       if part.summary:
372)         y -= (0.3*cm)
373)         if part.vatType == 'gross':
374)           canvas.setFont(font+'-Bold', font_size)
375)           if iv.tender:
376)             canvas.drawRightString(left + 14.5*cm, y-font_height, 'Gesamtbetrag:')
377)           else:
378)             canvas.drawRightString(left + 14.5*cm, y-font_height, 'Rechnungsbetrag:')
379)           canvas.drawRightString(left + 16.8*cm, y-font_height, _formatPrice(part.sum))
380)           canvas.setFont(font, font_size)
381)           y -= line_height + line_padding
382)           summaries = []
383)           if len(part.vat) == 1:
384)             vat = part.vat.keys()[0]

385)             (integer, decimals) = _niceCount( (vat * 100) )
386)             vatstr = '%s' % integer
387)             if decimals:
388)               vatstr += ',%s' % decimals

389)             if iv.tender:

390)               summaries.append(('Im Gesamtbetrag sind %s%% MwSt enthalten:' % vatstr, _formatPrice((part.sum/(vat+1))*vat)))

391)             else:

392)               summaries.append(('Im Rechnungsbetrag sind %s%% MwSt enthalten:' % vatstr, _formatPrice((part.sum/(vat+1))*vat)))

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

394)           else:
395)             for vat, vatdata in part.vat.iteritems():

396)               (integer, decimals) = _niceCount( (vat * 100) )
397)               vatstr = '%s' % integer
398)               if decimals:
399)                 vatstr += ',%s' % decimals
400)               summaries.append(('%s: Im Teilbetrag von %s sind %s%% MwSt enthalten:' % (vatdata[1], _formatPrice(vatdata[0]), vatstr), _formatPrice((vatdata[0]/(vat+1))*vat)))

401)           summaries.sort()
402)           for line in summaries:
403)             canvas.drawRightString(left + 14.5*cm, y-font_height, line[0])
404)             canvas.drawRightString(left + 16.8*cm, y-font_height, line[1])
405)             y -= line_height
406)         else:
407)           canvas.drawRightString(left + 14.5*cm, y-font_height, 'Nettobetrag:')
408)           canvas.drawRightString(left + 16.8*cm, y-font_height, _formatPrice(part.sum))
409)           y -= line_height
410)           summaries = []
411)           if len(part.vat) == 1:
412)             vat = part.vat.keys()[0]

413)             (integer, decimals) = _niceCount( (vat * 100) )
414)             vatstr = '%s' % integer
415)             if decimals:
416)               vatstr += ',%s' % decimals
417)             summaries.append(('zzgl. %s%% MwSt:' % vatstr, _formatPrice(vat*part.sum)))

418)           elif len(part.vat) > 1:

419)             for vat, vatdata in part.vat.iteritems():

420)               (integer, decimals) = _niceCount( (vat * 100) )
421)               vatstr = '%s' % integer
422)               if decimals:
423)                 vatstr += ',%s' % decimals
424)               summaries.append(('zzgl. %s%% MwSt (%s):' % (vatstr, vatdata[1]), _formatPrice(vat*vatdata[0])))

425)           summaries.sort()
426)           for line in summaries:
427)             canvas.drawRightString(left + 14.5*cm, y-font_height, line[0])
428)             canvas.drawRightString(left + 16.8*cm, y-font_height, line[1])
429)             y -= line_height

430)           sum = part.sum

431)           for vat, vatdata in part.vat.iteritems():

432)             sum += vat*vatdata[0]

433)           canvas.setFont(font+'-Bold', font_size)
434)           if iv.tender:
435)             canvas.drawRightString(left + 14.5*cm, y-font_height, 'Gesamtbetrag:')
436)           else:
437)             canvas.drawRightString(left + 14.5*cm, y-font_height, 'Rechnungsbetrag:')
438)           canvas.drawRightString(left + 16.8*cm, y-font_height, _formatPrice(sum))
439)           canvas.setFont(font, font_size)
440)           y -= line_height + line_padding

441)     elif type(part) == Invoice.Text:

442)       my_font_size = font_size
443)       canvas.setFont(font, my_font_size)
444)       left, right = leftcontent, rightcontent
445)       firsttime = True
446)       headlines = []
447)       if part.urgent:
448)         left += 1.5*cm
449)         right -= 1.5*cm
450)       if part.headline:
451)         headlines = _splitToWidth(canvas, part.headline, right-left, font, my_font_size)
452)       for para in part.paragraphs:
453)         lines = _splitToWidth(canvas, para, right-left, font, my_font_size)
454)         if part.urgent:
455)           need_height = len(lines) * line_height
456)           if len(headlines) > 0:
457)             need_height += len(headlines) * (line_height + 1) + line_padding
458)           canvas.setFillColorRGB(0.95, 0.95, 0.95)
459)           canvas.rect(left-0.5*cm, y - (need_height+(6*line_padding)), height = need_height+(6*line_padding), width = right-left+1*cm, fill=1, stroke=1)
460)           canvas.setFillColorRGB(0, 0, 0)
461)           y -= line_padding*3
462)         if part.headline and firsttime:
463)           firsttime = False
464)           canvas.setFont(font+'-Bold', my_font_size+1)
465)           for line in headlines:
466)             canvas.drawString(left, y-(font_height+1), line)
467)             y -= line_height + 1
468)           y -= line_padding
469)           canvas.setFont(font, my_font_size)

470)         for line in lines[:-1]:
471)           _drawJustifiedString(left, y-font_height, line, canvas, right-left, font, my_font_size)

472)           y -= line_height

473)         canvas.drawString(left, y-font_height, lines[-1])
474)         y -= line_height
475)