/[lohnrechner]/trunk/LST2008.py
ViewVC logotype

Diff of /trunk/LST2008.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

LST2006.py revision 47 by wilde, Wed Jan 18 14:02:35 2006 UTC trunk/LST2007.py revision 68 by wilde, Thu Jan 25 11:20:34 2007 UTC
# Line 1  Line 1 
1  # -*- coding: iso-8859-1 -*-  # -*- coding: iso-8859-1 -*-
2  # --------------------------------------------------------------------  # --------------------------------------------------------------------
3  # LST2005 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2005  # LST2007 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2007
4  # $Id$  # $Id$
5  # --------------------------------------------------------------------  # --------------------------------------------------------------------
6  #  #
7  # Copyright (c) 2005, 2006 by Intevation GmbH  # Copyright (c) 2005, 2006, 2007 by Intevation GmbH
8  # Authors:  # Authors:
9  # Sascha Wilde <[email protected]>  # Sascha Wilde <[email protected]>
10  #  #
# Line 51  VI  = 6 Line 51  VI  = 6
51    
52  class LST:  class LST:
53      def __init__(self,      def __init__(self,
54                   AJAHR =0,                   AJAHR =1964,
55                   ALTER1=0,                   ALTER1=0,
56                   HINZUR=0,                   HINZUR=0,
57                   JFREIB=0,                   JFREIB=0,
# Line 184  class LST: Line 184  class LST:
184                      0.024, # 2037                      0.024, # 2037
185                      0.016, # 2038                      0.016, # 2038
186                      0.008, # 2039                      0.008, # 2039
187                      0.000) # 2040                      0.000) # 2040
188          self._TAB2=(None,  # 1 als erstes Element, wie im PAP          self._TAB2=(None,  # 1 als erstes Element, wie im PAP
189                      3000,  # bis 2005                      3000,  # bis 2005
190                      2880,  # 2006                      2880,  # 2006
# Line 221  class LST: Line 221  class LST:
221                       180,  # 2037                       180,  # 2037
222                       120,  # 2038                       120,  # 2038
223                        60,  # 2039                        60,  # 2039
224                         0)  # 2040                         0)  # 2040
225          self._TAB3=(None,  # 1 als erstes Element, wie im PAP          self._TAB3=(None,  # 1 als erstes Element, wie im PAP
226                       900,  # bis 2005                       900,  # bis 2005
227                       864,  # 2006                       864,  # 2006
# Line 258  class LST: Line 258  class LST:
258                        54,  # 2037                        54,  # 2037
259                        36,  # 2038                        36,  # 2038
260                        18,  # 2039                        18,  # 2039
261                         0)  # 2040                         0)  # 2040
262          self._TAB4=self._TAB1          self._TAB4=self._TAB1
263          self._TAB5=(None,  # 1 als erstes Element, wie im PAP          self._TAB5=(None,  # 1 als erstes Element, wie im PAP
264                      1900,  # bis 2005                      1900,  # bis 2005
# Line 296  class LST: Line 296  class LST:
296                       114,  # 2037                       114,  # 2037
297                        76,  # 2038                        76,  # 2038
298                        38,  # 2039                        38,  # 2039
299                         0)  # 2040                         0)  # 2040
300          self._VBEZB = 0          self._VBEZB = 0
301          self._VHB = 0          self._VHB = 0
302          self._VSP = 0.0  # 2 Dezimalstellen          self._VSP = 0.0  # 2 Dezimalstellen
# Line 324  class LST: Line 324  class LST:
324          # ------------------------------------------------------------          # ------------------------------------------------------------
325          # Anfang der Berechnung          # Anfang der Berechnung
326          self._MRE4LZZ()          self._MRE4LZZ()
327            self._KENNZ = 0
328          self._RE4LZZ = self.RE4 - self._FVB \          self._RE4LZZ = self.RE4 - self._FVB \
329                          - self._ALTE - self.WFUNDF \                          - self._ALTE - self.WFUNDF \
330                          + self.HINZUR                          + self.HINZUR
# Line 351  class LST: Line 352  class LST:
352              self._FVBZ = 0              self._FVBZ = 0
353              self._FVB = 0              self._FVB = 0
354          else:          else:
355                if self.VJAHR < 2006:
356                    self._J = 1
357                elif self.VJAHR < 2040:
358                    self._J = VJAHR - 2004
359                else:
360                    self._J = 36
361              if self.LZZ == 1:              if self.LZZ == 1:
362                  self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS                  if ( self.STERBE + self.VKAPA ) > 0:
363                  self._FVBZ = 75 * self.ZMVB                      self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS
364                        self._HFVB = self._TAB2[self._J] * 100
365                        self._FVBZ = self._TAB3[self._J]
366                    else:
367                        self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS
368                        self._HFVB = self._TAB2[self._J] / 12 * self.ZMVB * 100
369                        self._FVBZ = ceil(self._TAB3[self._J] / 12 * self.ZMVB)
370              else:              else:
371                  self._VBEZB = self.VBEZM * 12 + self.VBEZS                  self._VBEZB = self.VBEZM * 12 + self.VBEZS
372                  self._FVBZ = 900                  self._HFVB = self._TAB2[self._J] * 100
373              self._FVB = ceil(self._VBEZB * 0.4)                  self._FVBZ = self._TAB3[self._J]
374              if self._FVB > 300000:              self._FVB = ceil(self._VBEZB * self._TAB1[self._J])
375                  self._FVB = 300000              if self._FVB > self._HFVB:
376                    self._FVB = self._HFVB
377              self._JW = self._FVB              self._JW = self._FVB
378              self._UPANTEIL()              self._UPANTEIL()
379              self._FVB = self._ANTEIL2              self._FVB = self._ANTEIL2
380          if self.ALTER1 == 0:          if self.ALTER1 == 0:
381              self._ALTE = 0              self._ALTE = 0
382          else:          else:
383                if self.AJAHR < 2006:
384                    self._K = 1
385                elif self.AJAHR < 2040:
386                    self._K = self.AJAHR - 2004
387                else:
388                    self._K = 36
389              self._BMG = self.RE4 - self.VBEZ              self._BMG = self.RE4 - self.VBEZ
390              self._ALTE = ceil(self._BMG * 0.4)              self._ALTE = ceil(self._BMG * self._TAB4[self._K])
391              self._JW = 190000              self._JW = self._TAB5[self._K] * 100
392              self._UPANTEIL()              self._UPANTEIL()
393              if self._ALTE > self._ANTEIL2:              if self._ALTE > self._ANTEIL2:
394                  self._ALTE = self._ANTEIL2                  self._ALTE = self._ANTEIL2
# Line 377  class LST: Line 397  class LST:
397          if self.LZZ == 1:          if self.LZZ == 1:
398              self._ZRE4 = FixedPointFloor(self._RE4LZZ / 100.0)              self._ZRE4 = FixedPointFloor(self._RE4LZZ / 100.0)
399              self._ZRE4VP = FixedPointFloor(self._RE4LZZV / 100.0)              self._ZRE4VP = FixedPointFloor(self._RE4LZZV / 100.0)
400                self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB) / 100.0)
401          elif self.LZZ == 2:          elif self.LZZ == 2:
402              self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.67) * 0.12)              self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.67) * 0.12)
403              self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.67) * 0.12)              self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.67) * 0.12)
404                self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.67) * 0.12)
405          elif self.LZZ == 3:          elif self.LZZ == 3:
406              self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.89) * 3.6 / 7)              self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.89) * 3.6 / 7)
407              self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.89) * 3.6 / 7)              self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.89) * 3.6 / 7)
408                self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.89) * 3.6 / 7)
409          else:          else:
410              self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.56) * 3.6)              self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.56) * 3.6)
411              self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.56) * 3.6)              self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.56) * 3.6)
412          if self._ZRE4 < 0:              self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.56) * 3.6)
413            if self._RE4LZZ < 0:
414              self._ZRE4 = 0.0              self._ZRE4 = 0.0
415            if self._RE4LZZV < 0:
416                self._ZRE4VP = 0.0
417            if (self.VBEZ == 0) and (self._FVB == 0):
418                self._ZVBEZ = 0
419            elif (self.VBEZ - self._FVB) < 0:
420                self._ZVBEZ = 0
421    
422      def _MZTABFB(self):      def _MZTABFB(self):
423          self._KZTAB = 1          self._ANP = 0
424          if self.STKL < 6:          if (self._ZVBEZ >= 0) and (self._ZVBEZ < self._FVBZ):
425              if self.VBEZ > 0:              self._FVBZ = self._ZVBEZ
426            if (self.STKL < 6) and (self._ZVBEZ > 0):
427                if (self._ZVBEZ - self._FVBZ) < 102:
428                    self._ANP = self._ZVBEZ - self._FVBZ
429                else:
430                  self._ANP = 102                  self._ANP = 102
431              if self.RE4 > self.VBEZ:          if (self.STKL < 6) and (self._ZRE4 > self._ZVBEZ):
432                if (self._ZRE4 - self._ZVBEZ) < 920:
433                    self._ANP += self._ZRE4 - self._ZVBEZ
434                else:
435                  self._ANP += 920                  self._ANP += 920
436          else:          self._KZTAB = 1
             self._ANP = 0  
437          if self.STKL == 1:          if self.STKL == 1:
438              self._SAP = 36              self._SAP = 36
439              self._KFB = self.ZKF * 5808              self._KFB = self.ZKF * 5808
# Line 415  class LST: Line 451  class LST:
451          else:          else:
452              self._KFB = 0              self._KFB = 0
453          self._ZTABFB = self._EFA + self._ANP + self._SAP + self._FVBZ          self._ZTABFB = self._EFA + self._ANP + self._SAP + self._FVBZ
         self._KENNZ = 0  
454    
455      def _MLSTJAHR(self):      def _MLSTJAHR(self):
456          if self.STKL < 5:          if self.STKL < 5:
# Line 428  class LST: Line 463  class LST:
463          else:          else:
464              self._X = floor(float(self._ZVE) / self._KZTAB)              self._X = floor(float(self._ZVE) / self._KZTAB)
465          if self.STKL < 5:          if self.STKL < 5:
466              self._UPTAB05()              self._UPTAB07()
467          else:          else:
468              self._MST5_6()              self._MST5_6()
469    
470      def _UPEVP(self):      def _UPEVP(self):
471          if self.KRV == 1:          if self.KRV == 1:
472              self._VSP1 = 1.0              self._VSP1 = 0.0
473          else:          else:
474              if self._ZRE4VP > 62400:              if self._ZRE4VP > 63000:
475                  self._ZRE4VP = 62400                  self._ZRE4VP = 63000
476              self._VSP1 = 0.2 * self._ZRE4VP              self._VSP1 = 0.28 * self._ZRE4VP
477              self._VSP1 = FixedPointFloor(self._VSP1 * 0.0975)              self._VSP1 = FixedPointFloor(self._VSP1 * 0.0995)
478          self._VSP2 = FixedPointFloor(0.11 * self._ZRE4VP)          self._VSP2 = FixedPointFloor(0.11 * self._ZRE4VP)
479          self._VHB = 1500 * self._KZTAB          self._VHB = 1500 * self._KZTAB
480          if self._VSP2 > self._VHB:          if self._VSP2 > self._VHB:
# Line 450  class LST: Line 485  class LST:
485              self._VSP = self._VSPN              self._VSP = self._VSPN
486    
487      def _MVSP(self):      def _MVSP(self):
488          self._VSPO = self._ZRE4VP * 0.2          if self._KENNZ == 1:
489                self._VSPO = self._ZRE4VP1 * 0.2
490            else:
491                self._VSPO = self._ZRE4VP * 0.2
492          self._VSPVOR = 3068 * self._KZTAB          self._VSPVOR = 3068 * self._KZTAB
493          self._VSPMAX1 = 1334 * self._KZTAB          self._VSPMAX1 = 1334 * self._KZTAB
494          self._VSPMAX2 = 667 * self._KZTAB          self._VSPMAX2 = 667 * self._KZTAB
# Line 459  class LST: Line 497  class LST:
497              if self._VSPO > self._VSPKURZ:              if self._VSPO > self._VSPKURZ:
498                  self._VSP = self._VSPKURZ                  self._VSP = self._VSPKURZ
499              else:              else:
500                  self._VSP = ceil(self._VSPO)                  self._VSP = floor(self._VSPO)
501          else:          else:
502              self._UMVSP()              self._UMVSP()
503    
504      def _UMVSP(self):      def _UMVSP(self):
505          if self._KENNZ == 1:          if self._KENNZ == 1:
506              self._VSPVOR = self._VSPVOR - self._ZRE4VP1 * 0.16              self._VSPVOR -= self._ZRE4VP1 * 0.16
507          else:          else:
508              self._VSPVOR = self._VSPVOR - self._ZRE4VP * 0.16              self._VSPVOR -= self._ZRE4VP * 0.16
509          if self._VSPVOR < 0:          if self._VSPVOR < 0:
510              self._VSPVOR = 0.0              self._VSPVOR = 0.0
511          if self._VSPO > self._VSPVOR:          if self._VSPO > self._VSPVOR:
# Line 477  class LST: Line 515  class LST:
515                  self._VSP += self._VSPMAX1                  self._VSP += self._VSPMAX1
516                  self._VSPREST = FixedPointCeil((self._VSPREST - self._VSPMAX1) / 2.0)                  self._VSPREST = FixedPointCeil((self._VSPREST - self._VSPMAX1) / 2.0)
517                  if self._VSPREST > self._VSPMAX2:                  if self._VSPREST > self._VSPMAX2:
518                      self._VSP = ceil(self._VSP + self._VSPMAX2)                      self._VSP = floor(self._VSP + self._VSPMAX2)
519                  else:                  else:
520                      self._VSP = ceil(self._VSP + self._VSPREST)                      self._VSP = floor(self._VSP + self._VSPREST)
521              else:              else:
522                  self._VSP = ceil(self._VSP + self._VSPREST)                  self._VSP = floor(self._VSP + self._VSPREST)
523          else:          else:
524              self._VSP = ceil(self._VSPO)              self._VSP = floor(self._VSPO)
525    
526      def _MST5_6(self):      def _MST5_6(self):
527          self._ZZX = self._X          self._ZZX = self._X
528          if self._ZZX > 25812:          if self._ZZX > 25812:
529              self._ZX = 25812              self._ZX = 25812
530              self._UP5_6()              self._UP5_6()
531              self._ST = floor(self._ST + (self._ZZX - 25812) * 0.42)              if self._ZZX > 200000:
532                    self._ST += (200000 - 25812) * 0.42
533                    self._ST = floor(self._ST + (self._ZZX - 200000) * 0.45)
534                else:
535                    self._ST = floor(self._ST + (self._ZZX - 25812) * 0.42)
536          else:          else:
537              self._ZX = self._ZZX              self._ZX = self._ZZX
538              self._UP5_6()              self._UP5_6()
# Line 506  class LST: Line 548  class LST:
548    
549      def _UP5_6(self):      def _UP5_6(self):
550          self._X = self._ZX * 1.25          self._X = self._ZX * 1.25
551          self._UPTAB05()          self._UPTAB07()
552          self._ST1 = self._ST          self._ST1 = self._ST
553          self._X = self._ZX * 0.75          self._X = self._ZX * 0.75
554          self._UPTAB05()          self._UPTAB07()
555          self._ST2 = self._ST          self._ST2 = self._ST
556          self._DIFF = (self._ST1 - self._ST2) * 2          self._DIFF = (self._ST1 - self._ST2) * 2
557          self._MIST = floor(self._ZX * 0.15)          self._MIST = floor(self._ZX * 0.15)
# Line 551  class LST: Line 593  class LST:
593              self._ANTEIL1 = floor(self._JW / 360.0)              self._ANTEIL1 = floor(self._JW / 360.0)
594              self._ANTEIL2 = ceil(self._JW / 360.0)              self._ANTEIL2 = ceil(self._JW / 360.0)
595    
596      def _UPTAB05(self):      def _UPTAB07(self):
597          if self._X < 7665:          if self._X < 7665:
598              self._ST = 0              self._ST = 0
599          elif self._X < 12740:          elif self._X < 12740:
# Line 565  class LST: Line 607  class LST:
607              self._RW += 2397              self._RW += 2397
608              self._RW *= self._Y              self._RW *= self._Y
609              self._ST = floor(self._RW + 989)              self._ST = floor(self._RW + 989)
610          else:          elif self._X < 250001:
611              self._ST = floor(self._X * 0.42 - 7914)              self._ST = floor(self._X * 0.42 - 7914)
612            else:
613                self._ST = floor(self._X * 0.45 - 15414)
614          self._ST *= self._KZTAB          self._ST *= self._KZTAB
615    
616      def _MSONST(self):      def _MSONST(self):
617          if self.SONSTB > 0:          if self.SONSTB == 0:
618                self.STS = 0
619                self.SOLZS = 0
620                self.BKS = 0
621            else:
622              # ------------------------------              # ------------------------------
623              # Nicht im offiziellen Programm-              # Nicht im offiziellen Programm-
624              # ablaufplan: Attribute sichern              # ablaufplan: Attribute sichern
# Line 583  class LST: Line 631  class LST:
631              self.RE4 = self.JRE4              self.RE4 = self.JRE4
632              self._MRE4LZZ()              self._MRE4LZZ()
633              self._MRE4LZZ2()              self._MRE4LZZ2()
             self._MRE4()  
             self._MZTABFB()  
634              self._MLSTJAHR()              self._MLSTJAHR()
635              self._LST1 = self._ST * 100              self._LST1 = self._ST * 100
636              self.VBEZ = self.JVBEZ + self.VBS              self.VBEZ = self.JVBEZ + self.VBS
637              self.RE4 = self.JRE4 + self.SONSTB              self.RE4 = self.JRE4 + self.SONSTB
638                self.VBEZS += self.STERBE
639              self._MRE4LZZ()              self._MRE4LZZ()
640              self._MRE4LZZ2()              self._MRE4LZZ2()
             self._MRE4()  
641              self._MLSTJAHR()              self._MLSTJAHR()
642              self._LST2 = self._ST * 100              self._LST2 = self._ST * 100
643              self.STS = self._LST2 - self._LST1              self.STS = self._LST2 - self._LST1
644              self.SOLZS = self.STS * 5.5 / 100              if (self.SONSTB > 0) and (self.STS < 0):
645                    self.STS = 0
646                self.SOLZS = floor(self.STS * 5.5 / 100)
647              if self.R > 0:              if self.R > 0:
648                  self.BKS = self.STS                  self.BKS = self.STS
649              else:              else:
# Line 608  class LST: Line 656  class LST:
656              self.VBEZ = old_vbez              self.VBEZ = old_vbez
657              self.RE4 = old_re4              self.RE4 = old_re4
658              # ------------------------------              # ------------------------------
         else:  
             self.STS = 0  
             self.SOLZS = 0  
             self.BKS = 0  
659    
660      def _MRE4LZZ2(self):      def _MRE4LZZ2(self):
661          self._RE4LZZ = self.RE4 - self._FVB - self._ALTE \          self._RE4LZZ = self.RE4 - self._FVB - self._ALTE \
662                         - self.JFREIB + self.JHINZU                         - self.JFREIB + self.JHINZU
663          self._RE4LZZV = self.RE4 - self._FVB - self._ALTE          self._RE4LZZV = self.RE4 - self._FVB - self._ALTE
664            self._MRE4()
665            self._MZTABFB()
666    
667      def _MVMT(self):      def _MVMT(self):
668          if self.VMT > 0:          # ------------------------------
669              # ------------------------------          # Nicht im offiziellen Programm-
670              # Nicht im offiziellen Programm-          # ablaufplan: Attribute sichern
671              # ablaufplan: Attribute sichern          old_lzz = self.LZZ
672              old_lzz = self.LZZ          old_vbez = self.VBEZ
673              old_vbez = self.VBEZ          old_re4 = self.RE4
674              old_re4 = self.RE4          # ------------------------------
675              # ------------------------------          if self.VKAPA < 0:
676                self.VKAPA = 0
677            if (self.VMT + self.VKAPA) > 0:
678              self.LZZ = 1              self.LZZ = 1
679              self.VBEZ = self.JVBEZ + self.VBS              self.VBEZ = self.JVBEZ + self.VBS
680              self.RE4 = self.JRE4 + self.SONSTB              self.RE4 = self.JRE4 + self.SONSTB
681              self._MRE4LZZ()              self._MRE4LZZ()
682              self._MRE4LZZ2()              self._MRE4LZZ2()
             self._MRE4()  
             self._MZTABFB()  
683              self._MLSTJAHR()              self._MLSTJAHR()
684              self._LST1 = self._ST * 100              self._LST1 = self._ST * 100
685                self.VMT += self.VKAPA
686                self.VBEZS += self.VKAPA
687                self.VBEZ += self.VKAPA
688              self.RE4 = self.JRE4 + self.SONSTB + self.VMT              self.RE4 = self.JRE4 + self.SONSTB + self.VMT
689              self._MRE4LZZ()              self._MRE4LZZ()
690              self._MRE4LZZ2()              self._MRE4LZZ2()
             self._MRE4()  
691              self._KENNZ = 1              self._KENNZ = 1
692              self._ZRE4VP1 = self._ZRE4VP              self._ZRE4VP1 = self._ZRE4VP
693              self._MLSTJAHR()              self._MLSTJAHR()
694              self._LST3 = self._ST * 100              self._LST3 = self._ST * 100
695                self.VBEZ -= self.VKAPA
696                self.VBEZS -= self.VKAPA
697              self.RE4 = self.JRE4 + self.SONSTB              self.RE4 = self.JRE4 + self.SONSTB
698              self._MRE4LZZ()              self._MRE4LZZ()
699              self.RE4 = self.JRE4 + self.SONSTB + self.VMT / 5              if (self.RE4 - self.JFREIB + self.JHINZU) < 0:
700              self._MRE4LZZ2()                  self.RE4 -= self.JFREIB + self.JHINZU
701              self._MRE4()                  self.JFREIB = 0
702              self._MLSTJAHR()                  self.JHINZU = 0
703              self._LST2 = self._ST * 100                  self.RE4 = (self.RE4 + self.VMT) / 5
704              self.STV = (self._LST2 - self._LST1) * 5                  self._MRE4LZZ2()
705                    self._MLSTJAHR()
706                    self._LST2 = self._ST * 100
707                    self.STV = self._LST2 * 5
708                else:
709                    self.RE4 += self.VMT / 5
710                    self._MRE4LZZ2()
711                    self._MLSTJAHR()
712                    self._LST2 = self._ST * 100
713                    self.STV = (self._LST2 - self._LST1) * 5
714              self._LST3 -= self._LST1              self._LST3 -= self._LST1
715              if self._LST3 < self.STV:              if self._LST3 < self.STV:
716                  self.STV = self._LST3                  self.STV = self._LST3
# Line 677  class LST: Line 736  class LST:
736      # FIX ME: Pr�fung _sehr_ unvollst�ndig      # FIX ME: Pr�fung _sehr_ unvollst�ndig
737    
738      def Set_AJAHR(self, value):      def Set_AJAHR(self, value):
739          self.HINZUR = value          assert type(value) == type(0), "must be integer"
740            assert value >= 1900, "must be greater than 1900"
741            self.AJAHR = value
742    
743      def Set_ALTER1(self, value):      def Set_ALTER1(self, value):
744          assert value in (0,1), "must be 0 or 1"          assert value in (0,1), "must be 0 or 1"
# Line 767  class LST: Line 828  class LST:
828  # Berechnungen, es fehlen insbesondere die Berechnungen zu Mehrj�hrigen  # Berechnungen, es fehlen insbesondere die Berechnungen zu Mehrj�hrigen
829  # Bez�gen und Sonstigen Leistungen.  # Bez�gen und Sonstigen Leistungen.
830    
831  class LStRechner2005(LST):  class LStRechner2007(LST):
832      def __init__(self):      def __init__(self):
833          LST.__init__(self)          LST.__init__(self)
834    
835        def SetGeb(self, geb):
836            """Setzt das Geburtsjahr"""
837            self.Set_AJAHR(geb + 65)
838            if self.AJAHR <= 2007:
839                self.Set_ALTER1(1)
840            else:
841                self.Set_ALTER1(0)
842    
843      def SetLohn(self, lohn):      def SetLohn(self, lohn):
844          """Setzt Lohn in Euro.Cent"""          """Setzt Lohn in Euro.Cent"""
845          self.Set_RE4(round (lohn * 100.0))          self.Set_RE4(round (lohn * 100.0))
Legend:
Removed from v.47  
changed lines
  Added in v.68
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26