| Current Path : /home/ift/52_procpy/fibu/ |
Linux ift1.ift-informatik.de 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64 |
| Current File : //home/ift/52_procpy/fibu/fibu_basic.py |
# coding: utf8
import os,sys,re,glob,time,datetime
import codecs
import random
import sqlite3
#******************************************************************************
class Basic (object):
def __init__ (self,rootdir,dbname=":memory:",dbtable="buchungen"):
self.rootdir = re.sub(r"^(.*)[\\\/](.*)\.py$","\\1",rootdir)
self.rootdir = re.sub(r"[\\\/]+$","",self.rootdir)
if not dbname == ":memory:":
dbname = self.rootdir+"/"+dbname
self.buchungen_exists = os.path.isfile(dbname)
self.buchungen = sqlite3.connect(dbname)
self.buchungen.row_factory = sqlite3.Row
self.dbtable = dbtable
self.func = None
self.ktoname = {}
self.qual_strings = {}
self.kto_list = {}
self.saldovortraege = {}
self.idem = {}
self.cursor = self.buchungen.cursor()
self.cursor.execute("create table if not exists " + dbtable +
"(BNR unique,DATUM,BETRAG,KTOA,KTOB,KTOC,REMARK,TIMEDIFF,REMUPPER default '')")
try:
self.cursor.execute("create index BNR_IDX on " + dbtable + " (BNR)" )
self.cursor.execute("create index DATUM_IDX on " + dbtable + " (DATUM)" )
self.cursor.execute("create index KTOA_IDX on " + dbtable + " (KTOA)" )
self.cursor.execute("create index KTOB_IDX on " + dbtable + " (KTOB)" )
self.cursor.execute("create index KTOC_IDX on " + dbtable + " (KTOB)" )
self.cursor.execute("create index BETRAG_IDX on " + dbtable + " (BETRAG)")
except Exception as e:
pass
self.mark("")
#**********************************************************
def buchhaltung (self,buchh,rootdir=None):
self.buchh = buchh
if rootdir:
self.buchh.rootdir = rootdir
for o in self.buchh.ukto_list().split("\n"):
m = re.search("^ *(\S+) *(\S+) *$",o)
if m:
o = re.sub(r"[\\\/]","-",m.group(1),9999)
o = re.sub(r"-[123456789ABCIJKLMNP]$","",o)
self.ktoname[o] = m.group(2)
#**********************************************************
def name (self,ukto,dir=None):
if dir:
ukto = re.sub(r"[\\\/]","-",dir+"/"+ukto)
if ukto in self.ktoname: # and not re.search(r"[0123456789ABCIJKLMN]$",ukto):
return(self.ktoname[ukto])
return("")
#**********************************************************
def mark (self,remark=""):
t = time.clock()
if 't0' in vars(self):
print ("%13.9f" % (t-self.t0)) + " " + remark
self.t0 = t
#******************************************************************************
def commit (self):
self.buchungen.commit()
#******************************************************************************
def add (self,datum="",betrag="",ktoa="",ktob="",remark="",func=None):
ktoa = re.sub(r"(^|-)-","\\1",ktoa,9999)
ktob = re.sub(r"(^|-)-","\\1",ktob,9999)
if type(datum) == type([]):
for buchung in datum:
self.add(*buchung)
return()
if type(datum) == type({}):
betrag = str(float((datum.setdefault('betrag', 0))))
remark = datum.setdefault('remark', "")
ktoa = datum.setdefault('ktoa', "")
ktob = datum.setdefault('ktob', "")
datum = str(datum.setdefault('datum', ""))
m = re.search(r"^(.*?)\[(\d+)\-(\d+)\](.*)$",datum)
if m:
nr = m.group(2)
fmt = "%0" + str(len(m.group(2))) + "u"
while (0 == 0):
self.add(m.group(1)+nr+m.group(4),betrag,ktoa,ktob,remark)
nr = fmt % (int(nr) + 1)
if nr > m.group(3):
return()
if not re.search(r"^\d\d\d\d\d\d\d\d$",datum):
for line in datum.split("\n"):
m = re.search(r"^([0123456789\[\-\]]+) +(\-?\d+\.\d\d) +(\S+) +(\S+) +(.*?) *$",line)
if m:
self.add(m.group(1),m.group(2),m.group(3),m.group(4),m.group(5),None)
return()
recurse = False
# print [datum,betrag,ktoa,ktob,remark,func]
for mod_obj in self.buchh.modify_buchungen:
break
buchungen = mod_obj.qualify([datum,betrag,ktoa,ktob,remark,func])
if buchungen == None:
continue
if True: # len(buchungen) > 1 or len(buchungen) == 1 and not buchungen[0] == (datum,betrag,ktoa,ktob,remark,func):
recurse = True
for buchung in buchungen:
self.add(buchung[0],buchung[1],buchung[2],buchung[3],buchung[4],buchung[5])
break
if recurse:
return()
try:
timediff = datetime.datetime.strptime(datum,"%Y%m%d")
except:
year = "%04u" % min(9999,max(1970,int(datum[0:4])))
month = "%02u" % min(12,max(1,int(datum[4:6])))
day = "%02u" % min(28,max(1,int(datum[6:8])))
timediff = datetime.datetime.strptime(year+month+day,"%Y%m%d")
# print timediff - datetime.datetime.strptime("20000101","%Y%m%d")
timediff = "%1u" % (timediff - datetime.datetime.strptime("20000101","%Y%m%d")).days
ktoc = self.ukto_from_betrag(str(betrag))
ktoa = re.sub(r"-BETRAG(-|$)","-"+ktoc+"\\1",ktoa)
ktob = re.sub(r"-BETRAG(-|$)","-"+ktoc+"\\1",ktob)
while (0 == 0):
bnr = "B" + ("%12u" % random.randint(100000000001,999999999900))
qstr = ("insert into " + self.dbtable + "(BNR,DATUM,BETRAG,KTOA,KTOB,KTOC,REMARK,TIMEDIFF,REMUPPER) values " +
"('" + bnr + "','" + datum + "','" + str(betrag) + "','" +
ktoa + "-','" + ktob + "-','" + ktoc + "-','" +
remark + "','" + timediff
+ "','" + remark.upper()
+ "')")
self.cursor.execute(qstr)
try:
break
except:
print "WARNING 24: DOUBLE ID", bnr
#******************************************************************************
def assign_buchungen (self,kto0,text):
for cond in text.split("\n"):
m = re.search(r"^ *([\d\[\]\-\%]+) +(\S+) +(\S+) +(\S+) +([\d\-\.]+|) +(.*?) *$",cond)
if not m:
continue
datum = m.group(1)
ktoa = m.group(3)
kto1 = "'"+re.sub(r"[\[\]]","",m.group(4)) + "-'"
kto1 = re.sub(r"-BETRAG-'","-'||KTOC",kto1)
pattern = m.group(6).upper()
m = re.search(r"\[(.*?)\]",cond)
if m:
pattern = re.sub(r"XXX",m.group(1).upper(),pattern,9999)
usteuer = ""
if pattern[0:3] in ["++|","+-|"]:
usteuer = ", REMARK = '" + pattern[0:2] + "' || REMARK "
pattern = pattern[3:]
cursor = self.buchungen.cursor()
qu_string = ( "update " + self.dbtable + " set KTOB = " + kto1 + usteuer +
" where KTOA like '" + ktoa + "' and KTOB like '" + kto0 + "-" + "' and DATUM like '" + datum + "'" )
p = []
for o in pattern.split("|"):
if o:
p.append( "\n REMUPPER LIKE '%" + o + "%' " )
if len(p) > 0:
qu_string = qu_string + " and (" + " or ".join(p) + ") "
# print qu_string
cursor.execute( qu_string )
#******************************************************************************
def koinzidente_buchungen (self,zeitraum_vs_mindestbetrag,kontoliste):
cursor = self.buchungen.cursor()
qu_string = ( "select f1.BNR,f1.DATUM,f1.BETRAG,f1.KTOA,f1.KTOB,f1.REMARK," +
" f2.BNR,f2.DATUM,f2.BETRAG,f2.KTOA,f2.KTOB,f2.REMARK\n" +
"from " + self.dbtable + " as f1, " + self.dbtable + " as f2\n" +
"where not f1.BNR = f2.BNR and not f1.TIMEDIFF < f2.TIMEDIFF and\n" +
"not f1.DATUM < f2.DATUM and " +
"abs(f1.BETRAG) = abs(f2.BETRAG)\n" )
zeitraeume = []
for o in zeitraum_vs_mindestbetrag:
zeitraeume.append("\n (f1.TIMEDIFF - f2.TIMEDIFF < " + str(o) + " and not abs(f1.BETRAG) < " +
str(zeitraum_vs_mindestbetrag[o]) + ")")
if len(zeitraeume) > 0:
qu_string = qu_string + "and (" + " or ".join(zeitraeume) + "\n) \n"
konten = []
for kto in kontoliste.split(","):
konten.append("\n f1.KTOA like '" + kto + "%' or f2.KTOA like '" + kto + "%' or " +
"f1.KTOB like '" + kto + "%' or f2.KTOB like '" + kto + "%'")
if len(konten) > 0:
qu_string = qu_string + "and ( " + " or ".join(konten) + "\n) \n"
# return()
cursor.execute( qu_string )
while (0 == 0):
entry = cursor.fetchone()
if not entry:
break
print entry
#******************************************************************************
def koinzidente_buchungen_2 (self,zeitraum_vs_mindestbetrag,kto0,kto1):
cursor = self.buchungen.cursor()
qu_string = "select BNR,DATUM,BETRAG,KTOA,KTOB,REMARK,TIMEDIFF from " + self.dbtable + " \n"
cursor.exectue()
# konten = []
# kto0 = kto0 + "-"
# kto1 = kto1 + "-"
# konten.append("\n KTOA = '" + kto0 + "' or KTOB = '" + kto0 + "'")
# if len(konten) > 0:
# qu_string = qu_string + " where ( " + " or ".join(konten) + "\n) \n"
qu_string = qu_string + " order by DATUM"
cursor.execute( qu_string )
entries = {}
matched_entries = []
zaehler = 0
while (0 == 0):
zaehler = zaehler + 1
entry = cursor.fetchone()
if not entry:
break
entry0 = list(entry)
entry0[6] = int(entry0[6])
day = int(entry[6])
id = re.sub(r"^\-","",entry[2])
if id in entries and len(entries[id]) == 1:
entry1 = entries[id][0]
for zaehler in (0,1,2,3,4,5,6,7):
entries
diff = day - int(entries[id][0][6])
entry0 = list(entry)
entry1 = list(entries[id][0])
matched = True
id1 = re.sub("\.","",id)
id1 = re.sub(r"^(.*?0)0*","\\1",id1)
id1 = ktoneu[0:min(5,len(id1))]
ktoneu = kto1 + id1 + "-"
if entry0[3] == kto0 and entry1[3] == kto0 and not entry0[2] == entry1[2]:
entry0[3] = ktoneu
entry1[3] = ktoneu
elif entry0[4] == kto0 and entry1[4] == kto0 and not entry0[2] == entry1[2]:
entry0[4] = ktoneu
entry1[4] = ktoneu
elif entry0[3] == kto0 and entry1[4] == kto0 and entry0[2] == entry1[2]:
entry0[3] = ktoneu
entry1[4] = ktoneu
elif entry0[4] == kto0 and entry1[3] == kto0 and entry0[2] == entry1[2]:
entry0[4] = ktoneu
entry1[3] = ktoneu
else:
matched = False
if len( {entry0[3]:1,entry0[4]:1,entry1[3]:1,entry1[4]:1}.keys() ) == 2:
matched = False
if len( {entry0[3]:1,entry0[4]:1,entry1[3]:1,entry1[4]:1}.keys() ) == 2:
matched = False
if len(ktoneu) < 4 and diff > 3 or len(ktoneu) < 5 and diff > 15 or len(ktoneu) < 120 and diff > 5:
matched = False
if matched:
o = entry0[5] + " / " + entry1[5]
o1 = entry1[5] + " / " + entry0[5]
entry0[5] = o
entry1[5] = o1
matched_entries.append(entry0)
matched_entries.append(entry1)
del entries[id]
if matched == False:
try:
entries[id].append(entry)
except:
entries[id] = [entry]
if zaehler % 100 == 0:
entries1 = {}
for o in entries:
for entry in entries[o]:
if day - int(entry[6]) > 50:
continue
id = re.sub(r"^\-","",entry[2])
try:
entries1[abs(float(entry[2]))].append(entry)
except:
entries1[abs(float(entry[2]))] = [entry]
entries = entries1
for entry in matched_entries:
# print entry
qu_string = ( "update " + self.dbtable + " set KTOA = '" + entry[3] + "', " +
" KTOB = '" + entry[4] + "', REMARK ='" + entry[5] + "'" +
" where BNR = '" + entry[0] + "'")
cursor.execute( qu_string )
# print entry
#******************************************************************************
def ukto_from_betrag (self,betrag):
id = re.sub(r"^\-","",betrag)
id = re.sub("\.","",id)
id = re.sub(r"^(.*?0)0*$","\\1",id)
id = id + "00000" # damit immer 5 Zeichen lang
id = id[0:min(5,len(id))]
# print self.idem,id
if int(id) in self.idem:
# print id
id = str(self.idem[int(id)])
return(id)
#******************************************************************************
def set_idem (self,idem):
self.idem = {}
for o in idem:
o1 = o.split(",")
o2 = o1[0]
for o3 in o1[1:]:
self.idem[int(o3)] = int(o2)
# print self.idem
#******************************************************************************
def fixpoint (self,list_of_functions):
fields = ["DATUM","BETRAG","KTOA","KTOB","REMARK","TIMEDIFF"]
cursor = self.buchungen.cursor()
cursor.execute("select BNR,DATUM,BETRAG,KTOA,KTOB,REMARK,TIMEDIFF from " + self.dbtable +
" where not TIMEDIFF = ''")
fixpoints = {}
while (0 == 0):
entry = cursor.fetchone()
if not entry:
break
fixpoints[entry[0]] = dict(zip(fields,entry[1:]))
zaehler = 0
while (0 == 0):
zaehler = zaehler + 1
fixpoint_reached = True
for entry in fixpoints:
entry0 = entry.copy()
entry["FUNC"](entry)
fixpoint_reached = fixpoint_reached and (entry0 == entry)
if fixpoint_reached or zaehler > 1000:
break
for entry in fixpoints:
cursor.execute("update " + self.dbtable + " set DATUM = '" + str(entry["DATUM"]) + "'" +
+ ",BETRAG = '" + "%3.2f" % float(entry["BETRAG"]) + "'" +
+ ",KTOA = '" + entry["KTOA"] + "'" +
+ ",KTOB = '" + entry["KTOB"] + "'" +
+ ",REMARK = '" + entry["REMARK"] + "'")
#******************************************************************************
def import_file (self,item):
textliste = []
itemlist = []
for item0 in item.split(","):
for item1 in glob.glob(self.rootdir+"/"+item0):
itemlist.append(item1)
itemlist.sort()
for item2 in itemlist:
self.import_file1(item2,textliste)
return(textliste)
#******************************************************************************
def import_file1 (self,item,textliste):
if os.path.isdir(item):
dateiliste = os.listdir(item)
dateiliste.sort()
dir = item + "/"
else:
dateiliste = [item]
dir = ""
for datei in dateiliste:
textliste.append( self.read_ktofile(re.sub("^[\\\/]","",dir+"/"+datei)) )
#******************************************************************************
def read_ktofile (self,datei):
text = None
m = re.search(r"^(\S+)\.(pdf|PDF)$",datei)
if m: # caching of pdf files
datei1 = m.group(1)
dir = "./"
m2 = re.search(r"^(.*)[\\\/](.*)$",datei1)
if m2:
dir = m2.group(1) + "/"
datei1 = m2.group(2)
if os.path.isfile(dir+datei1+".ocr"):
datei = dir + datei1 + ".ocr"
elif os.path.isfile(dir+datei1+".txt"):
datei = dir + datei1 + ".txt"
else:
text = os.popen("ps2ascii "+datei).read()
text = re.sub(chr(12),"",text,99999999)
codecs.open(dir+datei1+".txt","w",encoding="utf8").write(text)
datei = dir + datei1 + ".txt"
if text:
return("["+datei+"]\n"+self.normalize_text(text))
if os.path.isfile(datei):
ttt = codecs.open(datei,"r",encoding="utf8").read().encode("utf8")
return( "["+datei+"]\n"+self.normalize_text(ttt) )
return(datei)
#**********************************************************************************
def normalize_text (self,text):
text = re.sub(r"ä", "ae",text,99999999)
text = re.sub(r"ö", "oe",text,99999999)
text = re.sub(r"ü", "ue",text,99999999)
text = re.sub(r"Ä", "Ae",text,99999999)
text = re.sub(r"Ö", "Oe",text,99999999)
text = re.sub(r"Ü", "Ue",text,99999999)
text = re.sub(r"ß", "ss",text,99999999)
text = re.sub(r"a\"", "ae",text,99999999)
text = re.sub(r"o\"", "oe",text,99999999)
text = re.sub(r"u\"", "ue",text,99999999)
text = re.sub(r"A\"", "Ae",text,99999999)
text = re.sub(r"O\"", "Oe",text,99999999)
text = re.sub(r"U\"", "Ue",text,99999999)
text = re.sub(r"s\"", "ss",text,99999999)
text = re.sub(chr(13),"", text,99999999)
return(text)
#**********************************************************************************
def sort_konten (self,buchung):
zaehler = 1
text = buchung[2] + " " + buchung[3]
rem = buchung[4]
rem = re.sub(r"^(\+\+|\+\-)","",rem)
rem = re.sub(r"^ +\d+ v\.H\..*?\(","",rem)
rem = re.sub(r"\) *$","Z",rem)
for o in self.buchh.sort_konten().split(","):
if ("-"+o) in text:
return(buchung[0] + rem + ("%03u" % zaehler))
zaehler = zaehler + 1
return(buchung[0] + rem + "999")
#**********************************************************************************
def ukto (self,ukto,start="00000000",ende="99999999",saldovortrag=None):
cursor = self.buchungen.cursor()
query_string = ( "select DATUM,BETRAG,KTOA,KTOB,REMARK from " + self.dbtable +
" where DATUM <= '" + str(ende) + "'" )
if not ukto == "":
query_string = query_string + " and (KTOA like '" + ukto + "-%' or KTOB like '" + ukto + "-%')"
if not start[6:8] == "00" or saldovortrag: # nicht noetig, alle Buchungen von Anfang an zu berechnen
query_string = query_string + " and DATUM >= '" + str(start) + "'"
query_string = query_string + " order by DATUM,KTOA,KTOB"
# print query_string
cursor.execute(query_string)
ul = len(ukto)
sums = {"": 0.00}
text = []
if start[6:8] == "00":
if saldovortrag:
sums = { "" : saldovortrag }
text = [ [ start,sums[""],"-","11-1805","Startsaldo" ] ]
maxa = 0
maxb = 0
while (0 == 0):
entry = cursor.fetchone()
if not entry:
break
betrag = float(entry[1])
ktoa = entry[2][:-1]
ktob = entry[3][:-1]
anz = 0
if ktoa[0:ul] == ukto:
ktoa = ktoa[ul:]
self.ukto_sums(sums,ktoa,betrag,entry[0]>start)
if ktoa == "":
ktoa = "-"
anz = anz + 1
if ktob[0:ul] == ukto:
ktob = ktob[ul:]
self.ukto_sums(sums,ktob,-betrag,entry[0]>start)
if ktob == "":
ktob = "-"
if anz == 0:
o = ktoa
ktoa = ktob
ktob = o
betrag = -betrag
anz = anz + 1
if anz == 1:
datum = entry[0]
remark = entry[4]
if entry[0] < start:
betrag = sums[""]
datum = start
remark = "Startsaldo"
ktoa = "-"
ktob = "11-1805"
text = []
text1 = [datum,betrag,ktoa,ktob,remark]
# text1 = [ datum + " " + ("%13.2f" % betrag) + " ", ktoa, ktob,
# " " + ("%13.2f" % sums[""]) + " " + remark ]
maxa = max(maxa,len(ktoa))
maxb = max(maxb,len(ktob))
# text1 = [ datum + " " + ("%13.2f" % betrag) + " ", + ("%-14s" % ktoa) + " " +
# ("%-25s" % ktob) + ("%13.2f" % sums[""]) + " " + remark )
# print text1
text.append(text1)
# if saldovortrag:
# if type(saldovortrag) == type(1.1):
# pass
# else:
# self.saldovortraege[ukto] = sums[""]
text.sort(key=self.sort_konten)
zaehler = 0
maxa = "%-" + str(max(9,maxa)) + "s"
maxb = "%-" + str(max(9,maxb)) + "s"
gesamt = 0.00
# if saldovortrag:
# gesamt = saldovortrag
while zaehler < len(text):
gesamt = gesamt + float(text[zaehler][1])
text[zaehler] = ( text[zaehler][0] + " " + ("%13.2f" % text[zaehler][1]) + " " +
(maxa % text[zaehler][2]) + " " + (maxb % text[zaehler][3]) + " " +
("%13.2f" % gesamt) + " " + text[zaehler][4] )
zaehler = zaehler + 1
if len(text) == 0:
text == None
elif len(text) == 1 and "Saldovortrag" in text[0]:
if re.search(" 0\.00 +Saldovortrag",text):
text = None
else:
text = []
return(text,sums)
#**********************************************************************************
def saldo_gesamt (self,ukto,ende="99999999",sums={}):
cursor = self.buchungen.cursor()
query_string = "select KTOA,sum(BETRAG) from " + self.dbtable + " where DATUM <= '" + str(ende)
if not ukto == "":
query_string = query_string + "' and KTOA like '" + ukto + "-%"
query_string = query_string + "' group by KTOA"
fac = 1.0
for i in (1,2):
# print query_string
cursor.execute(query_string)
while (0 == 0):
entry = cursor.fetchone()
# print entry
if not entry:
break
k = re.sub("^"+ukto,"",entry[0])
self.ukto_sums(sums,re.sub(r"^-","",k[:-1]),fac*entry[1])
query_string = re.sub(r" KTOA"," KTOB",query_string,99)
fac = -1.0
sums_keys = sums.keys()
sums_keys.sort()
text1 = ""
for k in sums_keys:
level = re.sub(r"-"," ", re.sub(r"[^-]","",k,9999),9999 )
text1 = text1 + ("%-49s" % (("%-22s" % k) + self.name(k)) ) + level + ("%13.2f" % sums[k]) + "\n"
return (text1,sums)
#******************************************************************************
def ukto_sums (self,sums,ktox,betrag,bed=None):
# if not bed and re.search(r"^(12|13)\-",ktox):
# betrag = 0.00
while (0 == 0):
# print ktox
if not ktox in sums:
sums[ktox] = betrag
else:
sums[ktox] = sums[ktox] + betrag
if ktox == "":
break
ktox = re.sub("(^|-)[^-]+$","",ktox)
#******************************************************************************
def print_ukto (self,ukto,udir,start="00000000",ende="99999999",saldovortrag=None):
# print "AA", ukto,udir,start,ende
(text1,sums) = self.ukto(ukto,start,ende,saldovortrag)
if text1 == None:
return("")
text = ("%-40s" % (udir + " " + self.name(ukto))) + ("%13.2f" % float(sums[""])) + "\n\n"
list_of_unterkonten = sums.keys()
list_of_unterkonten.sort()
text2 = []
unterkonten = []
for k in list_of_unterkonten:
self.kto_list[ukto+k] = 1
k0 = re.sub(r"^-","",k)
level = re.sub(r"-"," ", re.sub(r"[^-]","",k,9999),9999 )
text2.append(
("%-49s" % (("%-22s" % k0) + self.name(ukto+k)) ) + level + ("%13.2f" % sums[k]) )
if level == " ":
k1 = self.name(ukto+k)
if not k1 == "":
k0 = k0 + "__" + k1
unterkonten.append(k0)
self.saldo (ukto,ende)
text = text + "\n".join(text1) + "\n\n\n" + "\n".join(text2) + "\n\n"
return([text.encode("utf8"),unterkonten])
#******************************************************************************
def write_ukto (self,ukto):
start = None
ukto = re.sub(r"[\\\/]","/",ukto,9999)
ktodir = self.rootdir
m = re.search(r"^(.*)\-([123456789ABCIJKLMNP])$",ukto)
if m:
ukto = m.group(1)
try:
intv = { "A" : ["1001","1099","-A"],
"B" : ["1101","1199","-B"],
"C" : ["1201","1299","-C"],
"I" : ["0101","0399","-I"],
"J" : ["0401","0699","-J"],
"K" : ["0701","0999","-K"],
"L" : ["1001","1299","-L"],
"M" : ["0101","0699","-M"],
"N" : ["0701","1299","-N"],
"P" : ["0101","1299","-P"] } [ m.group(2) ]
except:
intv = [ "0"+m.group(2)+"01","0"+m.group(2)+"99","-"+m.group(2) ]
else:
intv = ["0000","9999",""]
ukto1 = ""
for udir in ukto.split("/"):
udir = re.sub(r"^(.*)\__(.*)$","\\1",udir)
if start == None:
m = re.search(r"^(\d\d\d\d|\d\d\d\d_\d\d\d\d|\d\d\d\d\d\d\d\d\_\d\d\d\d\d\d\d\d)(\/.*|$)",ukto)
if not m:
return(False)
jahr = m.group(1)
ukto = re.sub(r"^\/","",m.group(2))
if len(jahr) == 4:
ktodir = ktodir + "/" + jahr
start = jahr
ende = jahr
elif len(jahr) == 9:
ktodir = ktodir + "/div1"
m = re.search(r"^(\d\d\d\d)\_(\d\d\d\d)$",jahr)
start = m.group(1)
ende = m.group(2)
else:
ktodir = ktodir + "/div1"
m = re.search(r"^(\d\d\d\d\d\d\d\d)\_(\d\d\d\d\d\d\d\d)$",jahr)
start = m.group(1)
ende = m.group(2)
intv = ["","",""]
else:
if ukto1 == "":
ukto1 = udir
else:
ukto1 = ukto1 + "-" + udir
ktoname = self.name(ukto1)
ktodir = ktodir + "/" + udir
if not ktoname == "":
ktodir = ktodir + "__" + ktoname
if not os.path.isdir(ktodir):
os.mkdir(ktodir)
if ukto == "":
udir = ""
saldovortrag = None
if re.search(r"^\d\d\d\d$",jahr):
vorjahr = "%04u" % (int(jahr)-1)
file = re.sub(r"_($|\.|-)","\\1",ktodir + "/" + self.buchh.fibuname + "_" + vorjahr + "_" + ukto1 + intv[2]) + ".kto"
file = re.sub("/"+jahr+"/","/"+vorjahr+"/",file)
if file in self.saldovortraege:
text3 = self.saldovortraege[file]
else:
try:
text3 = open(file).readline(250)
except Exception as e:
# print str(e)
text3 = ""
m = re.search(r" (\-?\d+\.\d\d)",text3)
if m:
saldovortrag = float(m.group(1))
file = re.sub(r"_($|\.|-)","\\1",ktodir + "/" + self.buchh.fibuname + "_" + jahr + "_" + ukto1 + intv[2]) + ".kto"
if not os.path.isfile(file):
text = self.print_ukto (ukto1,udir,start+intv[0],ende+intv[1],saldovortrag)
unterkonten = text[1]
text = text[0]
# self.saldovortraege[file] = text[0:250] # es ist nicht klar, ob das ueberhaupt eine Verbesserung bringen wuerde
try:
open(file,"w").write("")
except:
return()
if text == "":
os.unlink(file)
try:
os.rmdir(ktodir)
except:
pass
else:
open (file,"w").write(text)
for o in unterkonten:
try:
os.mkdir(ktodir+"/"+o)
except:
pass
return(file)
#******************************************************************************
def saldo (self,ukto,start="00000000",ende="99999999"):
cursor = self.buchungen.cursor()
cursor.execute("select SUM(BETRAG) from " + self.dbtable +
" where KTOA like '" + ukto + "-%'" +
" and DATUM > '" + str(start) + "' and DATUM < '" + str(ende) + "'")
sum = cursor.fetchone()[0]
if sum == None:
sum = 0.00
cursor.execute("select SUM(BETRAG) from " + self.dbtable +
" where KTOB like '" + ukto + "%'" +
" and DATUM > '" + str(start) + "' and DATUM < '" + str(ende) + "'")
sum1 = cursor.fetchone()[0]
if not sum1 == None:
sum = sum - sum1
return(sum)
#**********************************************************************************
def parse_kto (self,texte,uktoa="",uktob="",filter=None):
if not type(texte) == type([]):
texte = self.import_file(texte)
buchungen = []
for text in texte:
for zeile in text.split("\n"):
if filter and not filter.search(zeile):
continue
m = re.search(r"^(\d\d\d\d\d\d\d\d) +(\-?\d+\.\d\d) +\-?(\S*) *(\S+) +(\-?\d+\.\d\d) +(.*)$",zeile)
if m:
ktoa = uktoa + "-" + m.group(3)
ktob = uktob + "-" + m.group(4)
ktoa = re.sub(r"--","-",ktoa,9999)
ktob = re.sub(r"--","-",ktob,9999)
ktoa = re.sub(r"(^-|-$)","",ktoa,9999)
ktob = re.sub(r"(^-|-$)","",ktob,9999)
buchungen.append([m.group(1),m.group(2),ktoa,ktob,m.group(6)])
return(buchungen)
#******************************************************************************
def generate_konten (self,saldovortrag=False):
jahre = []
for o in os.listdir(self.rootdir):
if re.search(r"^\d\d\d\d$",o):
jahre.append(o)
jahre.sort()
if not self.buchungen_exists:
self.buchh.load_konten()
self.buchungen_exists = True
self.mark("generate_konten")
for ukto in self.buchh.ukto_list().split("\n"):
if re.search(r"^\s*$",ukto):
continue
m = re.search(r"^( *)(.*)$",ukto)
ukto = m.group(2).strip()
m1 = re.search(r"^(.*?) +(.*)",ukto)
if m1:
ukto = m1.group(1)
o = re.sub(r"[\\\/]","-",ukto,9999)
o = re.sub(r"-[123456789ABCIJKLMNP]","",o)
self.ktoname[o] = m1.group(2)
if len(m.group(1)) == 0:
if re.search(r"^(\d\d\d\d\d\d\d\d)\_(\d\d\d\d\d\d\d\d)",ukto):
self.write_ukto(ukto)
self.mark(ukto)
else:
for jahr in jahre:
self.write_ukto(jahr+"/"+ukto)
self.mark(jahr + " " + ukto)
# if len(ukto) == 5:
# self.ktoname[ukto[1]] = ukto[4]
# self.write_ukto( ukto[0], ukto[1], ukto[2], ukto[3], saldovortrag )
# self.mark(ukto[0]+ukto[1])
#
# konten = self.kto_list.keys()
# konten.sort()
#
# text = []
# for kto in konten:
# text1 = dir + "/JAHR/ " + ("%-30s" % kto) + " JAHR0000 JAHR999"
# if re.search("\-1[01][\- ]",text1) or "-" not in text1:
# text1 = text1 + "9"
# else:
# text1 = text1 + "8"
# text1 = text1 + " " + self.name(kto)
# text.append(text1)
#
# try:
# open(dir+"/konten.txt","w").write("\n".join(text)+"\n\n")
# except Exception as e:
# print "ERROR 15", str(e)
#******************************************************************************
def assign (self,buchung):
if not text in self.qual_strings:
qual_string = []
for zeile in text.split("\n"):
m = re.search("(.*?) +([\+\-]*) +(.*)",zeile)
if m:
qual_string.append([m.group(1),m.group(2),re.compile(m.group(3).lower())])
self.qual_strings[text] = qual_string
else:
qual_string = self.qual_strings[text]
buchung0 = buchung[:]
buchung1 = " ".join(buchung[:-1]).lower() # bcz the last parameter is a function handle (or None)
for bed in self.qual_strings[text]:
if bed[2].search(buchung1):
if not bed[0] in (buchung[2],buchung[3]) and not buchung[4][0:2] == " ":
buchung[3] = bed[0]
if not buchung[4][0:len(bed[1])] == bed[1]:
buchung[4] = bed[1] + buchung[4]
return(None)
if buchung0 == buchung:
return(None)
return(tuple(buchung))
#****************************************************************************
def clean (self):
print "CLEAN"
def rmdir (x):
# print x
if os.path.isdir(x):
try:
os.rmdir(x)
except:
pass
dirnr = 6
while dirnr > 0:
dirnr = dirnr - 1
map (os.unlink, glob.glob(self.rootdir + "/????/" + "*/"*dirnr + "*.kto"))
map (rmdir, glob.glob(self.rootdir + "/????/" + "*/"*dirnr))
#****************************************************************************
def make_kto (self,ukto=None,editor=None):
m = re.search(r"^(.*)\.$",ukto)
if m:
ukto = editor
editor = m.group(1)
kto = re.sub(r"[\\\/]$","",os.path.relpath(".",self.rootdir))
if ukto:
ukto = re.sub(r"[\\\/]$","",ukto)
if kto == ".":
kto = ukto
else:
kto = kto + "/" + ukto
kto = re.sub(r"__(.*?)(\\|\/|-|$)","\\2",kto,9999)
if editor == "bilanz":
(text1,sums) = self.saldo_gesamt("",kto+"0000")
sums1 = {}
for k in sums:
if re.search(r"^(12|13|14|15|16)(-|$)",k):
sums1[k] = - sums[k]
(text1,sums1) = self.saldo_gesamt("",kto+"9999",sums1)
text1 = self.make_bilanz(text1)
print text1
else:
file = self.write_ukto(kto)
if editor:
try:
os.system(editor + " " + file)
except:
pass
#****************************************************************************
def make_bilanz (self,text0):
text = ""
bilanz_konten = re.sub(r",","|",self.buchh.bilanz_konten(),9999)
bilanz_konten = '^([^-]+|' + bilanz_konten + ')(|\-[^-]+)$'
for zeile in text0.split("\n"):
m = re.search(r"^(\S+)",zeile)
if not m:
continue
ukto = m.group(1)
if ukto.count("-") == 0:
text = text + "\n" + zeile + "\n"
elif re.search(bilanz_konten,ukto):
text = text + zeile + "\n"
return(text)