class dr3060(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["drsact", "drstyp", "drsmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.fromad = drsctl["ctd_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2])
self.sysdttm = "(Printed on: %i/%02i/%02i at %02i:%02i)" % \
(t[0], t[1], t[2], t[3], t[4])
self.colsh = [
"Chn", "Acc-Num", "Name", "Address", "Code", "Tel-Number",
"Fax-Number", "Contact Details", "Deliver", "Rep", "Act", "Typ",
"P", "Rft", "C-Limit"
]
self.forms = [("UI", 3), ("NA", 7), ("NA", 30), ("NA", 30), ("NA", 4),
("NA", 12), ("NA", 12), ("NA", 40), ("Na", 7), ("Na", 3),
("UA", 3), ("UA", 3), ("UI", 1), ("UI", 3), ("UI", 3),
("UI", 7)]
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Debtors Master Listing (%s)" % self.__class__.__name__)
daa = self.sql.getRec("drsmst",
cols=["drm_bus_activity", "count(*)"],
where=[("drm_cono", "=", self.opts["conum"])],
group="drm_bus_activity",
order="drm_bus_activity")
act = {
"stype": "C",
"titl": "Valid Activities",
"head": ("Act", "Quantity"),
"data": daa,
"typs": (("NA", 3), ("UI", 8)),
"size": (400, 400)
}
dab = self.sql.getRec("drsmst",
cols=["drm_bus_type", "count(*)"],
where=[("drm_cono", "=", self.opts["conum"])],
group="drm_bus_type",
order="drm_bus_type")
typ = {
"stype": "C",
"titl": "Valid Types",
"head": ("Typ", "Quantity"),
"data": dab,
"typs": (("NA", 3), ("UI", 8)),
"size": (400, 400)
}
r1s = (("Number", "N"), ("Name", "M"))
r2s = (("Yes", "Y"), ("No", "N"))
r3s = (("Manager", "M"), ("Accounts", "A"), ("Sales", "S"))
r4s = (("Yes", "Y"), ("No", "N"), ("Only", "O"))
fld = ((("T", 0, 0, 0), "INA", 3, "Activity", "Account Activity", "",
"N", self.doAct, act, None, None), (("T", 0, 0, 0), "ONA", 30,
""),
(("T", 0, 1, 0), "INA", 3, "Type", "Account Type", "", "N",
self.doTyp, typ, None, None), (("T", 0, 1, 0), "ONA", 30, ""),
(("T", 0, 2, 0), ("IRB", r1s), 0, "Sort Order", "", "N", "Y",
self.doSort, None, None,
None), (("T", 0, 3, 0), ("IRB", r2s), 0, "Full Address", "",
"N", "Y", self.doAddress, None, None, None),
(("T", 0, 4, 0), ("IRB", r3s), 0, "Contact Details", "", "M",
"Y", self.doContact, None, None,
None), (("T", 0, 5, 0), ("IRB", r4s), 0, "Include Redundant",
"", "N", "Y", self.doRedu, None, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "N"))
def doAct(self, frt, pag, r, c, p, i, w):
self.act = w
if not self.act:
self.df.loadEntry(frt, pag, p + 1, "All Activities")
else:
chk = self.sql.getRec("drsact",
where=[("dac_code", "=", self.act)],
limit=1)
if not chk:
return "Invalid Activity Code"
self.df.loadEntry(frt, pag, p + 1, chk[1])
def doTyp(self, frt, pag, r, c, p, i, w):
self.typ = w
if not self.typ:
self.df.loadEntry(frt, pag, p + 1, "All Types")
else:
chk = self.sql.getRec("drstyp",
where=[("dtp_code", "=", self.typ)],
limit=1)
if not chk:
return "Invalid Type Code"
self.df.loadEntry(frt, pag, p + 1, chk[1])
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
def doAddress(self, frt, pag, r, c, p, i, w):
self.address = w
def doContact(self, frt, pag, r, c, p, i, w):
self.condet = w
def doRedu(self, frt, pag, r, c, p, i, w):
self.redu = w
def doEnd(self):
self.df.closeProcess()
whr = [("drm_cono", "=", self.opts["conum"])]
if self.act:
whr.append(("drm_bus_activity", "=", self.act))
if self.typ:
whr.append(("drm_bus_type", "=", self.typ))
if self.redu == "N":
whr.append(("drm_stat", "<>", "X"))
elif self.redu == "O":
whr.append(("drm_stat", "=", "X"))
if self.sort == "N":
odr = "drm_chain, drm_acno"
else:
odr = "drm_name"
recs = self.sql.getRec("drsmst", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Selection Error",
"No Records Selected")
elif self.df.repprt[2] == "export":
self.exportReport(recs)
else:
self.printReport(recs)
self.closeProcess()
def exportReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
expnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"])
expheads = [
"%03u %-30s %s %6s" % (self.opts["conum"], self.opts["conam"],
self.sysdttm, self.__class__.__name__)
]
expheads.append("Debtors Master Code List as at %s" % self.sysdtd)
expcolsh = [self.colsh]
expforms = self.forms
expdatas = []
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
p.closeProgress()
return
vals = self.getValues(dat)
expdatas.append([
"BODY",
[
vals[0].work, vals[1].work, vals[2].work, vals[3].work,
vals[4].work, vals[5].work, vals[6].work, vals[7].work,
vals[8].work, vals[9].work, vals[10].work, vals[11].work,
vals[12].work, vals[13].work, vals[14].work, vals[15].work
]
])
p.closeProgress()
doWriteExport(xtype=self.df.repprt[1],
name=expnam,
heads=expheads,
colsh=expcolsh,
forms=expforms,
datas=expdatas,
rcdic=self.opts["mf"].rcdic)
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
self.head = "%03u %-179s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.pglin = 999
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
vals = self.getValues(dat)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.fpdf.drawText("%s %s %s %s %s %s %s %s %s %s %s %s "\
"%s %s %s %s" % (vals[0].disp, vals[1].disp, vals[2].disp,
vals[3].disp, vals[4].disp, vals[5].disp, vals[6].disp,
vals[7].disp, vals[8].disp, vals[9].disp, vals[10].disp,
vals[11].disp, vals[12].disp, vals[13].disp, vals[14].disp,
vals[15].disp))
if self.address == "Y" and vals[16].work:
self.fpdf.drawText("%42s %-30s" % ("", vals[16].disp))
self.pglin += 1
if self.address == "Y" and vals[17].work:
self.fpdf.drawText("%42s %-30s" % ("", vals[17].disp))
self.pglin += 1
self.pglin += 1
p.closeProgress()
if self.fpdf.page and not p.quit:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
def getValues(self, dat):
col = self.sql.drsmst_col
chn = CCD(dat[col.index("drm_chain")], "UI", 3)
acno = CCD(dat[col.index("drm_acno")], "NA", 7)
name = CCD(dat[col.index("drm_name")], "NA", 30)
add1 = CCD(dat[col.index("drm_add1")], "NA", 30)
pcod = CCD(dat[col.index("drm_pcod")], "NA", 4)
tel = CCD(dat[col.index("drm_tel")], "NA", 12)
fax = CCD(dat[col.index("drm_fax")], "NA", 12)
if self.condet == "M":
contact = dat[col.index("drm_mgr")]
email = dat[col.index("drm_mgr_email")].split(",")
elif self.condet == "A":
contact = dat[col.index("drm_acc")]
email = dat[col.index("drm_acc_email")].split(",")
else:
contact = dat[col.index("drm_sls")]
email = dat[col.index("drm_sls_email")].split(",")
nameml = CCD("%s <%s>" % (contact, email[0]), "NA", 40)
delv = CCD(dat[col.index("drm_delivery")], "Na", 7)
rep = CCD(dat[col.index("drm_rep")], "Na", 3)
bact = CCD(dat[col.index("drm_bus_activity")], "UA", 3)
btyp = CCD(dat[col.index("drm_bus_type")], "UA", 3)
prices = CCD(dat[col.index("drm_plev")], "UI", 1)
rfterm = CCD(dat[col.index("drm_rfterms")], "UI", 3)
rjterm = CCD(dat[col.index("drm_rjterms")], "UI", 3)
limit = CCD(dat[col.index("drm_limit")], "UI", 7)
add2 = CCD(dat[col.index("drm_add2")], "NA", 30)
add3 = CCD(dat[col.index("drm_add3")], "NA", 30)
return (chn, acno, name, add1, pcod, tel, fax, nameml, delv, rep, bact,
btyp, prices, rfterm, rjterm, limit, add2, add3)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-32s %-150s" % \
("Debtors Ledger Master List as at", self.sysdtd))
self.fpdf.drawText()
self.fpdf.drawText("(%-15s%1s)" %
("Options: Sort-", self.df.t_disp[0][0][0]))
self.fpdf.drawText()
if self.condet == "M":
det = "Manager's Contact Details"
elif self.condet == "A":
det = "Accounts Contact Details"
else:
det = "Orders Contact Details"
self.fpdf.drawText("%-3s %-7s %-30s %-30s %-4s %-12s %-12s %-40s "\
"%-7s %-3s %-3s %-3s %1s %-3s %-3s %-7s" % ("Chn", "Acc-Num",
"Name", "Address", "Code", "Tel-Number", "Fax-Number", det,
"Deliver", "Rep", "Act", "Typ", "P", "Rft","Rjt","C-Limit"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 8
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class ml3060(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.reptyp = "A"
if self.opts["args"][0] > self.opts["args"][1]:
self.start = CCD(self.opts["args"][1], "D1", 10)
else:
self.start = CCD(self.opts["args"][0], "D1", 10)
self.dte = int("%08i000000" % self.start.work)
self.end = CCD(self.opts["args"][1], "D1", 10)
self.chgtyp = "A"
self.cat = ""
self.cod = 0
self.processRecords()
else:
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Members Category Changes (%s)" % self.__class__.__name__)
self.sql = Sql(self.opts["mf"].dbm,
["chglog", "memcat", "memctc", "memmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
memctl = gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.fromad = memctl["mcm_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdttm = "(Printed on: %i/%02i/%02i at %02i:%02i)" % \
(t[0], t[1], t[2], t[3], t[4])
self.head = "%03u %-30s" % (self.opts["conum"], self.opts["conam"])
self.colsh = [
"Mem-No", "Titles", "Inits", "Surname", "Actions", "Category",
"Action-Dte", "Operator", "Start-Date", " End-Date", "Last-Date"
]
self.forms = [("UI", 6), ("NA", 6), ("NA", 5), ("NA", 30), ("UA", 7),
("NA", 30), ("D1", 10), ("NA", 20), ("d1", 10),
("d1", 10), ("d1", 10)]
self.ctyp = (("All", "A"), ("New", "N"), ("Updated", "U"), ("Deleted",
"D"))
self.catg = (("All", "X"), ("Fees", "A"), ("Main", "B"),
("Sports", "C"), ("Debentures", "D"))
return True
def mainProcess(self):
cod = {
"stype":
"R",
"tables": ("memctc", ),
"cols": (("mcc_code", "", 0, "Cd"), ("mcc_desc", "", 0,
"Description", "Y")),
"where": [("mcc_cono", "=", self.opts["conum"])],
"whera": [["T", "mcc_type", 3]],
"order":
"mcc_code",
"size": (400, 600)
}
r1s = (("Actual", "A"), ("Pending", "P"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Report Type", "", "A", "Y",
self.doRepTyp, None, None,
None), (("T", 0, 1, 0), "Id1", 10, "Starting Date", "",
self.sysdtw, "Y", self.doStartDate, None, None, None),
(("T", 0, 2, 0), "ID1", 10, "Ending Date", "Ending Date",
self.sysdtw, "Y", self.doEndDate, None, None, ("notzero", )),
(("T", 0, 3, 0), ("IRB", self.ctyp), 0, "Change Type", "", "A",
"Y", self.doChgTyp, None, None,
None), (("T", 0, 4, 0), ("IRB", self.catg), 0, "Category", "",
"X", "Y", self.doCat, None, None,
None), (("T", 0, 5, 0), "IUI", 2, "Code", "", 0, "Y",
self.doCod, cod, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "N"))
def doRepTyp(self, frt, pag, r, c, p, i, w):
self.reptyp = w
def doStartDate(self, frt, pag, r, c, p, i, w):
self.start = CCD(w, "d1", 10)
self.dte = int("%08i000000" % self.start.work)
if self.reptyp == "P":
self.end = self.start
self.df.loadEntry(frt, pag, p + 1, data=self.end.work)
return "sk1"
def doEndDate(self, frt, pag, r, c, p, i, w):
if w < self.start.work:
return "Invalid End Date, Before Start Date"
self.end = CCD(w, "D1", 10)
if self.reptyp == "P":
self.chgtyp = "A"
self.cat = None
self.cod = None
self.df.loadEntry(frt, pag, p + 1, data="A")
self.df.loadEntry(frt, pag, p + 2, data="X")
self.df.loadEntry(frt, pag, p + 3, data=0)
return "sk3"
def doChgTyp(self, frt, pag, r, c, p, i, w):
self.chgtyp = w
def doCat(self, frt, pag, r, c, p, i, w):
self.cat = w
if w == "X":
self.cat = None
self.cod = None
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
self.cat = w
def doCod(self, frt, pag, r, c, p, i, w):
self.cod = w
def doEnd(self):
self.df.closeProcess()
if self.reptyp == "P":
sp = SplashScreen(self.opts["mf"].body,
"Preparing Report ... Please Wait")
recs = self.sql.getRec("memmst",
cols=["mlm_memno"],
where=[("mlm_cono", "=",
self.opts["conum"]),
("mlm_state", "=", "A")])
for rec in recs:
data = doChkCatChg(self.opts["mf"], self.opts["conum"], rec[0],
self.start.work)
if data:
self.sql.insRec(
"chglog",
data=[
"memcat", "D",
"%03i%06i%1s%02i" %
(self.opts["conum"], rec[0], "B", data[0]), "",
self.dte, "",
str(data[1]),
str(data[2]), "", 0
])
self.sql.insRec(
"chglog",
data=[
"memcat", "N",
"%03i%06i%1s%02i" %
(self.opts["conum"], rec[0], "B", data[7]), "",
self.dte, "",
str(self.start.work),
str(0), "", 0
])
sp.closeSplash()
self.processRecords()
self.closeProcess()
def processRecords(self):
if "args" in self.opts:
self.repprt = ["N", "V", "view"]
self.repeml = None
else:
self.repprt = self.df.repprt
self.repeml = self.df.repeml
whr = [("chg_tab", "=", "memcat")]
if self.reptyp == "P":
whr.append(("chg_dte", "=", self.dte))
else:
end = str((self.end.work * 1000000) + 999999)
if self.start.work:
start = str(self.start.work * 1000000)
whr.append(("chg_dte", "between", start, end))
else:
whr.append(("chg_dte", "<=", end))
if self.chgtyp != "A":
whr.append(("chg_act", "=", self.chgtyp))
if self.cat:
key = "%03i______%1s" % (self.opts["conum"], self.cat)
if self.cod:
key = "%s%02i" % (key, self.cod)
else:
key = "%s__" % key
whr.append(("chg_key", "like", key))
odr = "chg_key, chg_seq"
chg = self.sql.getRec("chglog", where=whr, order=odr)
if self.reptyp == "P":
self.opts["mf"].dbm.rollbackDbase()
if not chg:
showError(self.opts["mf"].body, "Selection Error",
"No Available Records")
elif self.repprt[2] == "export":
self.exportReport(chg)
else:
self.printReport(chg)
def exportReport(self, chg):
p = ProgressBar(self.opts["mf"].body, mxs=len(chg), esc=True)
expnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"])
self.expheads = [self.head + " %s" % self.sysdttm]
self.expheads.append("Members Category Changes between %s and %s" %
(self.start.disp, self.end.disp))
self.expheads.append(self.getOptions())
self.expcolsh = [self.colsh]
self.expforms = self.forms
self.expdatas = []
lmemno = 0
for num, dat in enumerate(chg):
p.displayProgress(num)
if p.quit:
p.closeProgress()
return
vals = self.getValues(dat)
if not vals:
continue
if vals[0].work == lmemno:
self.expdatas.append([
"BODY",
[
"", "", "", "", vals[4], vals[5].work, vals[6].work,
vals[7].work, vals[8].work, vals[9].work, vals[10].work
]
])
else:
self.expdatas.append([
"BODY",
[
vals[0].work, vals[1].work, vals[2].work, vals[3].work,
vals[4], vals[5].work, vals[6].work, vals[7].work,
vals[8].work, vals[9].work, vals[10].work
]
])
lmemno = vals[0].work
p.closeProgress()
doWriteExport(xtype=self.repprt[1],
name=expnam,
heads=self.expheads,
colsh=self.expcolsh,
forms=self.expforms,
datas=self.expdatas,
rcdic=self.opts["mf"].rcdic)
def printReport(self, chg):
p = ProgressBar(self.opts["mf"].body, mxs=len(chg), esc=True)
self.fpdf = MyFpdf(name=self.__class__.__name__, head=154)
self.pgnum = 0
self.pglin = 999
for num, dat in enumerate(chg):
p.displayProgress(num)
if p.quit:
break
vals = self.getValues(dat)
if not vals:
continue
if self.pglin > self.fpdf.lpp:
self.pageHeading()
lmemno = 0
if vals[0].work == lmemno:
self.fpdf.drawText("%6s %6s %5s %30s %s %s %s %s %s %s %s" % \
("", "", "", "", vals[4], vals[5].disp, vals[6].disp,
vals[7].disp, vals[8].disp, vals[9].disp, vals[10].disp))
else:
self.fpdf.drawText("%s %s %s %s %s %s %s %s %s %s %s" % \
(vals[0].disp, vals[1].disp, vals[2].disp, vals[3].disp,
vals[4], vals[5].disp, vals[6].disp, vals[7].disp,
vals[8].disp, vals[9].disp, vals[10].disp))
lmemno = vals[0].work
self.pglin += 1
p.closeProgress()
if self.fpdf.page and not p.quit:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.repprt,
fromad=self.fromad,
repeml=self.repeml)
def getValues(self, data):
key = data[self.sql.chglog_col.index("chg_key")]
cono = CCD(key[:3], "UI", 3)
if cono.work != self.opts["conum"]:
return
memno = CCD(key[3:9], "UI", 6)
ctype = CCD(key[9:10], "UA", 1)
code = CCD(key[10:12], "UI", 2)
last = CCD(0, "d1", 10)
if data[self.sql.chglog_col.index("chg_act")] == "D":
act = "Removed"
elif data[self.sql.chglog_col.index("chg_act")] == "N":
act = "Added "
last = self.sql.getRec("memcat",
cols=["mlc_last"],
where=[("mlc_cono", "=",
self.opts["conum"]),
("mlc_memno", "=", memno.work),
("mlc_type", "=", ctype.work),
("mlc_code", "=", code.work)],
limit=1)
if not last:
last = CCD("Removed?", "NA", 10)
else:
last = CCD(last[0], "d1", 10)
elif data[self.sql.chglog_col.index("chg_act")] == "U":
act = "Changed"
else:
act = "Unknown"
dte = int(data[self.sql.chglog_col.index("chg_dte")])
dte = CCD(int(dte / 1000000), "D1", 10)
usr = CCD(data[self.sql.chglog_col.index("chg_usr")], "NA", 20)
old = CCD(data[self.sql.chglog_col.index("chg_old")], "d1", 10)
new = CCD(data[self.sql.chglog_col.index("chg_new")], "d1", 10)
mst = self.sql.getRec("memmst",
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", memno.work)],
limit=1)
if not mst:
return
tit = CCD(mst[self.sql.memmst_col.index("mlm_title")], "UA", 6)
ini = CCD(mst[self.sql.memmst_col.index("mlm_initial")], "UA", 5)
sur = CCD(mst[self.sql.memmst_col.index("mlm_surname")], "NA", 30)
cat = self.sql.getRec("memctc",
where=[("mcc_cono", "=", self.opts["conum"]),
("mcc_type", "=", ctype.work),
("mcc_code", "=", code.work)],
limit=1)
if not cat:
return
des = CCD(cat[self.sql.memctc_col.index("mcc_desc")], "NA", 30)
return (memno, tit, ini, sur, act, des, dte, usr, old, new, last)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.pgnum += 1
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-32s %10s %3s %10s %89s %5s" % \
("Members Category Changes between", self.start.disp, "and",
self.end.disp, "Page", self.pgnum))
self.fpdf.drawText()
self.fpdf.drawText(self.getOptions())
self.fpdf.drawText()
self.fpdf.drawText("%6s %-6s %-5s %-30s %1s %-30s %10s %-20s %10s "\
"%10s %10s" % ("Mem-No", "Titles", "Inits", "Surname", "Actions",
"Category", "Action-Dte", "Operator", "Start-Date", " End-Date",
"Last-Date"))
self.fpdf.underLine(txt="X" * 154)
self.fpdf.setFont()
self.pglin = 8
def getOptions(self):
if self.reptyp == "A":
mess = "Options: Actual"
else:
mess = "Options: Pending"
for x in self.ctyp:
if self.chgtyp == x[1]:
mess = mess + ", Type %s" % x[0]
break
for x in self.catg:
if self.cat == x[1]:
mess = mess + ", Category %s" % x[0]
if self.cod:
mess = mess + ", Code %s" % self.cod
return mess
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class glc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genmst", "genint"],
prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if chk[0] == 1:
showInfo(self.opts["mf"].body, "Intercompany",
"There is Only 1 Company Record")
return
return True
def mainProcess(self):
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy-Num"),
("ctm_name", "", 0, "Name", "Y")),
"where": [("ctm_cono", "!=", self.opts["conum"])]}
gl1 = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]}
gl2 = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"whera": [["T", "glm_cono", 0, 0]]}
data = self.sql.getRec(tables=["genint", "genmst"], cols=["cti_inco",
"glm_desc"], where=[("cti_cono", "=", self.opts["conum"]),
("glm_cono=cti_cono",), ("glm_acno=cti_acno",)], order="cti_inco")
self.gl3 = {
"stype": "C",
"titl": "Existing Companies",
"head": ("Coy","Name"),
"typs": (("UI", 3), ("NA", 30)),
"data": data}
fld = (
(("T",0,0,0,14),"IUI",3,"Coy-Num","Company Number",
"","Y",self.doCoyNum,coy,None,None),
(("T",0,0,17),"ONA",30,""),
(("T",0,1,0,10),"IUI",7,"Acc-Num-1","G/L Account Number",
"","N",self.doAccNum1,gl1,self.doDelete,("notzero",),None,
"The above company's account number in company %s." %
self.opts["conum"]),
(("T",0,1,17),"ONA",30,""),
(("T",0,2,0,10),"IUI",7,"Acc-Num-2","G/L Account Number",
"","N",self.doAccNum2,gl2,None,("notzero",),None,
"Company %s's account number in the above company." %
self.opts["conum"]),
(("T",0,2,17),"ONA",30,""))
but = (
("Show All",self.gl3,None,0,("T",0,1),("T",0,2)),
("Cancel",None,self.doCancel,0,("T",0,3),("T",0,1)),
("Quit",None,self.doExit,1,None,None))
tnd = ((self.doEnd,"Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but,
tend=tnd, txit=txt)
def doCoyNum(self, frt, pag, r, c, p, i, w):
if w == 0:
return "Invalid Company Number"
if w == self.opts["conum"]:
return "Invalid Company, Same Company Not Allowed"
self.cono2 = w
acc = self.sql.getRec("ctlmst", cols=["ctm_name"],
where=[("ctm_cono", "=", self.cono2)], limit=1)
if not acc:
return "Invalid Company Number"
self.df.loadEntry(frt, pag, 1, data=acc[0])
self.acc1 = self.sql.getRec("genint", where=[("cti_cono",
"=", self.opts["conum"]), ("cti_inco", "=", self.cono2)], limit=1)
if not self.acc1:
self.new1 = "y"
else:
self.new1 = "n"
self.acno1 = self.acc1[self.sql.genint_col.index("cti_acno")]
desc = self.readAcno(self.opts["conum"], self.acno1)
self.df.loadEntry(frt, pag, 2, data=self.acno1)
self.df.loadEntry(frt, pag, 3, data=desc[0])
self.acc2 = self.sql.getRec("genint", where=[("cti_cono",
"=", self.cono2), ("cti_inco", "=", self.opts["conum"])], limit=1)
if not self.acc2:
self.new2 = "y"
else:
self.new2 = "n"
self.acno2 = self.acc2[self.sql.genint_col.index("cti_acno")]
desc = self.readAcno(self.cono2, self.acno2)
self.df.loadEntry(frt, pag, 4, data=self.acno2)
self.df.loadEntry(frt, pag, 5, data=desc[0])
def doDelete(self):
if self.new1 == "n":
self.sql.delRec("genint", where=[("cti_cono", "=",
self.opts["conum"]), ("cti_inco", "=", self.cono2)])
if self.new2 == "n":
self.sql.delRec("genint", where=[("cti_cono", "=", self.cono2),
("cti_inco", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccNum1(self, frt, pag, r, c, p, i, w):
desc = self.readAcno(self.opts["conum"], w)
if not desc:
return "Invalid Account Number"
self.acno1 = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
def doAccNum2(self, frt, pag, r, c, p, i, w):
desc = self.readAcno(self.cono2, w)
if not desc:
return "Invalid Account Number"
self.acno2 = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
def readAcno(self, cono, acno):
acc = self.sql.getRec("genmst", cols=["glm_desc"],
where=[("glm_cono", "=", cono), ("glm_acno", "=", acno)], limit=1)
return acc
def doEnd(self):
data1 = [self.opts["conum"], self.cono2, self.acno1]
data2 = [self.cono2, self.opts["conum"], self.acno2]
if self.new1 == "y":
self.sql.insRec("genint", data=data1)
elif data1 != self.acc1[:len(data1)]:
col = self.sql.genint_col
data1.append(self.acc1[col.index("cti_xflag")])
self.sql.updRec("genint", data=data1, where=[("cti_cono", "=",
self.opts["conum"]), ("cti_inco", "=", self.cono2)])
if self.new2 == "y":
self.sql.insRec("genint", data=data2)
elif data2 != self.acc2[:len(data2)]:
col = self.sql.genint_col
data2.append(self.acc2[col.index("cti_xflag")])
self.sql.updRec("genint", data=data2, where=[("cti_cono", "=",
self.cono2), ("cti_inco", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
data = self.sql.getRec(tables=["genint", "genmst"], cols=["cti_cono",
"glm_desc"], where=[("cti_cono", "=", self.opts["conum"]),
("glm_cono=cti_inco",)], order="cti_inco")
self.gl3["data"] = data
self.df.focusField("T", 0, 1)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class dr3030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["drsmst", "drstrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.fromad = drsctl["ctd_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Debtors Transactions Due For Payment (%s)" %
self.__class__.__name__)
if "args" in self.opts and "noprint" in self.opts["args"]:
view = None
mail = None
else:
view = ("N", "V")
mail = ("Y", "N")
fld = ((("T", 0, 0, 0), "ID1", 10, "Payment Date", "", self.sysdtw,
"Y", self.doPayDate, None, None, ("efld", )), )
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=view,
mail=mail)
def doPayDate(self, frt, pag, r, c, p, i, w):
if w == 0:
w = self.sysdtw
self.pdatw = w
self.pdatd = self.df.t_disp[0][0][0]
self.df.loadEntry(frt, pag, p, data=self.pdatw)
def doEnd(self):
self.df.closeProcess()
mst = self.sql.getRec("drsmst",
cols=["drm_chain", "drm_acno", "drm_name"],
where=[("drm_cono", "=", self.opts["conum"])],
order="drm_chain, drm_acno")
if not mst:
showError(self.opts["mf"].body, "Selection Error",
"No Accounts Selected")
else:
self.printReport(mst)
if "args" in self.opts and "noprint" in self.opts["args"]:
self.t_work = [self.df.t_work[0][0]]
self.closeProcess()
def printReport(self, mst):
p = ProgressBar(self.opts["mf"].body, mxs=len(mst), esc=True)
self.head = "%03u %-71s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.ctots = [0, 0, 0]
self.gtots = [0, 0, 0]
self.pglin = 999
for seq, rec in enumerate(mst):
p.displayProgress(seq)
if p.quit:
break
chn = CCD(rec[0], "UI", 3)
acno = CCD(rec[1], "NA", 7)
name = CCD(rec[2], "NA", 30)
col, trns = getTrn(self.opts["mf"].dbm,
"drs",
whr=[("drt_cono", "=", self.opts["conum"]),
("drt_chain", "=", chn.work),
("drt_acno", "=", acno.work),
("drt_trdt", "<=", self.pdatw)],
neg=False,
zer="N")
if not trns:
continue
if self.pglin == 999:
self.pageHeading(chn.disp, acno.disp, name.disp)
else:
self.newAccount(chn.disp, acno.disp, name.disp)
for trn in trns:
ref1 = CCD(trn[col.index("drt_ref1")], "Na", 9)
ref2 = CCD(trn[col.index("drt_ref2")], "Na", 9)
trtp = CCD(trn[col.index("drt_type")], "UI", 1)
trdt = CCD(trn[col.index("drt_trdt")], "d1", 10)
tramt = CCD(trn[col.index("drt_tramt")], "SD", 13.2)
paid = CCD(trn[col.index("paid")], "SD", 13.2)
trbal = CCD(trn[col.index("balance")], "SD", 13.2)
if self.pglin > self.fpdf.lpp:
self.pageHeading(chn.disp, acno.disp, name.disp)
self.fpdf.drawText(
"%s %s %s %s %s %s %s" %
(ref1.disp, ref2.disp, drtrtp[trtp.work - 1][0], trdt.disp,
tramt.disp, paid.disp, trbal.disp))
self.pglin += 1
self.ctots[0] = float(ASD(self.ctots[0]) + ASD(tramt.work))
self.ctots[1] = float(ASD(self.ctots[1]) + ASD(paid.work))
self.ctots[2] = float(ASD(self.ctots[2]) + ASD(trbal.work))
self.gtots[0] = float(ASD(self.gtots[0]) + ASD(tramt.work))
self.gtots[1] = float(ASD(self.gtots[1]) + ASD(paid.work))
self.gtots[2] = float(ASD(self.gtots[2]) + ASD(trbal.work))
if self.fpdf.page:
self.accountTotal()
p.closeProgress()
if self.fpdf.page and not p.quit:
self.grandTotal()
if "args" not in self.opts or "noprint" not in self.opts["args"]:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
def pageHeading(self, chn, acno, name):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-42s %-32s" % \
("Debtors Transactions Due For Payment as at", self.pdatd))
self.fpdf.drawText()
self.fpdf.drawText("%-19s%-10s%-1s" % \
("(Options: Pay Date-", self.df.t_disp[0][0][0], ")"))
self.fpdf.setFont()
self.pglin = 5
self.newAccount(chn, acno, name)
def newAccount(self, chn, acno, name):
if self.pglin > (self.fpdf.lpp - 10):
self.pageHeading(chn, acno, name)
else:
self.fpdf.setFont(style="B")
self.fpdf.underLine(txt=self.head)
self.fpdf.drawText("%-7s %-3s %-7s %-30s" % \
("Account", chn, acno, name))
self.fpdf.drawText()
self.fpdf.drawText("%-9s %-9s %-3s %-10s %-13s %-13s %-13s" % \
("Reference", "Ref-Num-2", "Typ", " Date",
" Amount", " Paid", " Balance"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 5
def accountTotal(self):
j = CCD(self.ctots[0], "SD", 13.2)
k = CCD(self.ctots[1], "SD", 13.2)
l = CCD(self.ctots[2], "SD", 13.2)
self.fpdf.drawText()
self.fpdf.drawText("%-34s %-13s %13s %13s" % \
("Account Totals", j.disp, k.disp, l.disp))
self.ctots = [0, 0, 0]
self.pglin += 2
def grandTotal(self):
j = CCD(self.gtots[0], "SD", 13.2)
k = CCD(self.gtots[1], "SD", 13.2)
l = CCD(self.gtots[2], "SD", 13.2)
self.fpdf.drawText()
self.fpdf.drawText("%-34s %13s %-13s %13s" % \
("Grand Totals", j.disp, k.disp, l.disp))
self.fpdf.drawText()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class gl1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
self.gldep = ctlsys["sys_gl_dep"]
self.gldig = ctlsys["sys_gl_dig"]
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
self.mods = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
self.mods.append(ctlmst["ctm_modules"][x:x + 2])
tabs = [
"ctlctl", "ctldep", "ctlvmf", "genmst", "genbal", "genbud",
"genrpt", "gentrn", "chglog"
]
if "CR" in self.mods:
tabs.append("crsctl")
if "DR" in self.mods:
tabs.append("drsctl")
if "ST" in self.mods:
tabs.extend(["strctl", "strloc"])
if "SI" in self.mods:
tabs.append("slsctl")
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("genmst",
cols=["count(*)"],
where=[("glm_cono", "=", self.opts["conum"])],
limit=1)
if chk[0]:
self.newgen = False
else:
self.newgen = True
if "args" in self.opts:
self.acno = None
return True
def mainProcess(self):
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vat = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "Acc-Num"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
r1s = (("Profit & Loss", "P"), ("Balance Sheet", "B"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = [(("T", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "Y",
self.doAccNum, glm, None, ("notzero", )),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Account Type", "", "P", "N",
self.doTypCod, None, self.doDelete, None),
(("T", 0, 2,
0), "INA", 30, "Description", "Account Description", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), ("IRB", r2s), 0, "Allow Postings", "", "Y",
"N", None, None, None, None),
[("T", 0, 4, 0), "IUA", 1, "Tax Default", "", "", "N",
self.doVatCod, vat, None, ("notblank", )]]
but = [
("Import",None,self.doImport,0,("T",0,1),("T",0,2),
"Import a Chart of Accounts from a CSV or XLS file "\
"having the following fields: Account Number, "\
"Account Type (P/B), Description, Direct Postings (Y/N), "\
"VAT Code"),
["Populate",None,self.doPopulate,0,("T",0,1),("T",0,2),
"Generate a Chart of Accounts with Accompanying Control "\
"Records and Financial Statement Report. This Only Applies "\
"to Unpopulated (NEW) Ledgers."],
("Accept",None,self.doAccept,0,(("T",0,2),("T",0,5)),
(("T",0,0),("T",0,1))),
("Cancel",None,self.doCancel,0,(("T",0,2),("T",0,5)),
(("T",0,0),("T",0,1))),
("Quit",None,self.doQuit,1,None,None,"",1,4)]
tnd = ((self.doEnd, "y"), )
txt = (self.doQuit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if not self.newgen:
self.df.butt[1][4] = None
self.df.butt[1][5] = None
self.df.setWidget(self.df.B1, state="disabled")
def doAccNum(self, frt, pag, r, c, p, i, w):
self.acno = w
self.old = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", self.acno)],
limit=1)
if not self.old:
self.new = True
if self.gldep == "Y":
err = self.doCheckDep(self.acno)
if err:
return err
elif "args" in self.opts:
showError(self.opts["mf"].body, "Error",
"Only a New Account is Allowed")
return "rf"
else:
self.new = False
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=self.old[x + 1])
def doTypCod(self, frt, pag, r, c, p, i, w):
if self.new:
if w == "P":
self.df.topf[pag][4][5] = self.taxdf
else:
self.df.topf[pag][4][5] = "N"
elif not self.df.topf[pag][4][5]:
self.df.topf[pag][4][5] = "N"
def doVatCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not acc:
return "Invalid VAT Code"
def doDelete(self):
t = self.sql.getRec("gentrn",
cols=["count(*)"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno)],
limit=1)
if t[0]:
return "Transactions Exist, Not Deleted"
self.sql.delRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acno)])
self.sql.delRec("genbal",
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acno)])
self.sql.delRec("genbud",
where=[("glb_cono", "=", self.opts["conum"]),
("glb_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"genmst", "D",
"%03i%07i" % (self.opts["conum"], self.acno), "",
dte, self.opts["capnm"], "", "", "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
if self.newgen:
self.df.butt[1][4] = None
self.df.butt[1][5] = None
data = [
self.opts["conum"], self.acno, self.df.t_work[0][0][1],
self.df.t_work[0][0][2], self.df.t_work[0][0][3],
self.df.t_work[0][0][4]
]
if self.new:
self.sql.insRec("genmst", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genmst_col
data.append(self.old[col.index("glm_xflag")])
self.sql.updRec("genmst",
data=data,
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"genmst", "U",
"%03i%07i" % (self.opts["conum"], self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.B3, state="disabled")
if "args" in self.opts:
self.doQuit()
else:
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doImport(self):
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="genmst", impskp=["glm_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Chart of Accounts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", line[0])],
limit=1)
if chk:
err = "%s %s Already Exists" % (fi.impcol[0][0], line[0])
break
if self.gldep == "Y":
err = self.doCheckDep(line[0])
if err:
break
if line[1] not in ("B", "P"):
err = "Invalid %s %s, Only B or P" % (fi.impcol[1][0], line[1])
break
if not line[2]:
err = "Blank Description"
break
if line[3] not in ("Y", "N"):
err = "Invalid %s %s" % (fi.impcol[3][0], line[3])
break
chk = self.sql.getRec("ctlvmf",
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", line[4])],
limit=1)
if not chk:
err = "%s %s Does Not Exist" % (fi.impcol[4][0], line[4])
break
line.insert(0, self.opts["conum"])
self.sql.insRec("genmst", data=line)
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doCheckDep(self, acno):
dep = int(acno / (10**(7 - self.gldig)))
acc = int(acno % (10**(7 - self.gldig)))
if dep:
chk = self.sql.getRec("ctldep",
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", dep)],
limit=1)
if not chk:
return "Invalid Department Number (%s)" % dep
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc)],
limit=1)
if chk:
return "This Account Number (%s) is in Use" % acc
def doPopulate(self):
if not self.newgen:
showError(self.opts["mf"].body, "Populate Error",
"You Cannot Populate with Existing Accounts")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
if self.gldep == "Y":
showError(self.opts["mf"].body, "Populate Error",
"You Cannot Populate with Departments Enabled")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.igcrs = "N"
self.igdrs = "N"
self.igstr = "N"
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Integrate Subsiduary Ledgers", )
r1s = (("Yes", "Y"), ("No", "N"))
fld = []
col = 0
if "CR" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Creditor's Ledger",
"Creditor's Ledger", "N", "N", self.doIgCrs, None,
None, None, None))
col += 1
if "DR" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Debtor's Ledger",
"Debtor's Ledger", "N", "N", self.doIgDrs, None, None,
None, None))
col += 1
if "ST" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Stores's Ledger",
"Stores's Ledger", "N", "N", self.doIgStr, None, None,
None, None))
if fld:
self.ig = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doIgEnd, "y"), ),
txit=(self.doIgExit, ))
self.ig.mstFrame.wait_window()
if self.igexit:
self.doQuit()
return
sp = SplashScreen(self.opts["mf"].body,
"Populating Records\n\nPlease Wait ...")
# genmst
genmst = datdic["genmst"]
for dat in genmst:
dat.insert(0, self.opts["conum"])
dat.append("Y")
if dat[2] == "B":
dat.append("N")
else:
dat.append(self.taxdf)
self.sql.insRec("genmst", data=dat)
# genrpt
genrpt = datdic["genrpt"]
for dat in genrpt:
dat.insert(0, self.opts["conum"])
self.sql.insRec("genrpt", data=dat)
# ctlctl
crsctl = 0
drsctl = 0
stksoh = 0
ctlctl = datdic["ctlctl"]
for dat in ctlctl:
if dat[0] in ("crs_ctl", "dis_rec"):
if self.igcrs != "Y":
continue
if dat[0] == "crs_ctl":
crsctl = int(dat[2])
elif dat[0] in ("drs_ctl", "dis_all"):
if self.igdrs != "Y":
continue
if dat[0] == "drs_ctl":
drsctl = int(dat[2])
elif dat[0] in ("stk_soh", "stk_susp"):
if self.igstr != "Y":
continue
if dat[0] == "stk_soh":
stksoh = int(dat[2])
elif dat[0] in ("wag_ctl", "wag_slc", "wag_sli"):
continue
dat.insert(0, self.opts["conum"])
self.sql.insRec("ctlctl", data=dat)
if "CR" in self.mods:
chk = self.sql.getRec("crsctl",
where=[("ctc_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("crsctl",
data=[
self.opts["conum"], self.igcrs, "E", "", 0,
0, "remittance_advice", ""
])
else:
self.sql.updRec("crsctl",
cols=["ctc_glint"],
data=[self.igcrs],
where=[("ctc_cono", "=", self.opts["conum"])])
if self.igcrs == "Y" and crsctl:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", crsctl)])
if "DR" in self.mods:
chk = self.sql.getRec("drsctl",
where=[("ctd_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("drsctl",
data=[
self.opts["conum"], self.igdrs, "E", "N",
"statement_normal", "Y", ""
])
else:
self.sql.updRec("drsctl",
cols=["ctd_glint"],
data=[self.igdrs],
where=[("ctd_cono", "=", self.opts["conum"])])
if self.igdrs == "Y" and drsctl:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", drsctl)])
if "ST" in self.mods:
chk = self.sql.getRec("strctl",
where=[("cts_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("strctl",
data=[
self.opts["conum"], self.igstr, "N", 1,
"N", "purchase_order", ""
])
else:
self.sql.updRec("strctl",
cols=["cts_glint"],
data=[self.igstr],
where=[("cts_cono", "=", self.opts["conum"])])
chk = self.sql.getRec("strloc",
where=[("srl_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("strloc",
data=[
self.opts["conum"], "1",
"Location Number One", "", "", "", ""
])
if self.igstr == "Y" and stksoh:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", stksoh)])
if "SI" in self.mods:
chk = self.sql.getRec("slsctl",
where=[("ctv_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec(
"slsctl",
data=[self.opts["conum"], "Y", "Y", "sales_document", ""])
sp.closeSplash()
self.df.butt[1][4] = None
self.df.butt[1][5] = None
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doIgCrs(self, frt, pag, r, c, p, i, w):
self.igcrs = w
def doIgDrs(self, frt, pag, r, c, p, i, w):
self.igdrs = w
def doIgStr(self, frt, pag, r, c, p, i, w):
self.igstr = w
def doIgEnd(self):
self.igexit = False
self.ig.closeProcess()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.focusField("T", 0, 1)
def doIgExit(self):
self.igexit = True
self.ig.closeProcess()
def doQuit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class st6030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["strmf1", "strtrn", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.curdt = int(self.sysdtw / 100)
return True
def dataHeader(self):
grp = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
self.stm = {
"stype": "R",
"tables": ("strmf1",),
"cols": (
("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [],
"whera": [["T", "st1_group", 0, 0]],
"index": 0}
fld = [
(("T",0,0,0),"INA",3,"Group","Product Group",
"","Y",self.doGroup,grp,None,("notblank",)),
(("T",0,1,0),"INA",20,"Code","Product Code",
"","N",self.doCode,self.stm,None,("notblank",)),
(("T",0,2,0),"ONA",30,"Description")]
but = (
("Generate",None,self.doGenerate,1,None,(("T",0,1),("T",0,2)),
"Mark zero items, which have been inactive, as redundant"),
("Create",None,self.doCreate,1,None,(("T",0,1),("T",0,2)),
"Mark a zero item as redundant"),
("Restore",None,self.doRestore,1,None,(("T",0,1),("T",0,2)),
"Mark a redundant item as normal"),
("Exit",None,self.exitPage,1,None,(("T",0,1),("T",0,2))))
tnd = ((self.endPage, "y"),)
txt = (self.exitPage,)
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, focus=False)
self.df.setWidget(self.df.B0, state="normal")
self.df.setWidget(self.df.B1, state="normal")
self.df.setWidget(self.df.B2, state="normal")
self.df.setWidget(self.df.B3, state="normal")
def doGenerate(self):
tit = "Generate Redundant Items"
fld = (
(("T",0,0,0),"IUI",3,"Months Inactive","",
24,"Y",self.doMonths,None,None,("efld",)),)
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.mt = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doMthEnd, "y"),), txit=(self.doMthExit,))
self.mt.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doMonths(self, frt, pag, r, c, p, i, w):
months = w
yr = int(self.curdt / 100)
mt = self.curdt % 100
for mth in range(months):
mt -= 1
if not mt:
mt = 12
yr -= 1
self.startp = (yr * 100) + mt
def doMthEnd(self):
self.mt.closeProcess()
whr = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "=", "N"),
("stt_cono=st1_cono",),
("stt_group=st1_group",),
("stt_code=st1_code",)]
accs = self.sql.getRec(tables=["strmf1", "strtrn"], cols=["st1_group",
"st1_code", "max(stt_curdt)", "sum(stt_qty)", "sum(stt_cost)"],
where=whr, order="st1_group, st1_code")
chgs = []
for acc in accs:
if acc[2] < self.startp and not acc[3] and not acc[4]:
chgs.append(acc[:2])
if not chgs:
showError(self.opts["mf"].body, "Processing Error",
"No Redundant Records")
else:
self.cnt = 0
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
p = ProgressBar(self.opts["mf"].body, mxs=len(chgs),
typ="Redundant Items")
for num, rec in enumerate(chgs):
p.displayProgress(num)
self.sql.updRec("strmf1", cols=["st1_type"], data=["X"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", rec[0]), ("st1_code", "=", rec[1])])
key = "%03i%-3s%-20s" % (self.opts["conum"], rec[0], rec[1])
self.sql.insRec("chglog", data=["strmf1", "U", key,
"st1_type", dte, self.opts["capnm"], "N", "X", "", 0])
p.closeProgress()
mess = """%s Items Will be Marked as Redundant.
Would you like to COMMIT these Changes?""" % len(chgs)
self.opts["mf"].dbm.commitDbase(ask=True, mess=mess)
def doMthExit(self):
self.mt.closeProcess()
def doCreate(self):
self.flag = "C"
self.stm["where"] = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")]
self.df.focusField("T", 0, 1)
def doRestore(self):
self.flag = "R"
self.stm["where"] = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "=", "X")]
self.df.focusField("T", 0, 1)
def doGroup(self, frt, pag, r, c, p, i, w):
if self.flag == "C":
chk = self.sql.getRec("strmf1", where=[("st1_cono",
"=", self.opts["conum"]), ("st1_group", "=", w),
("st1_type", "<>", "X")], limit=1)
else:
chk = self.sql.getRec("strmf1", where=[("st1_cono",
"=", self.opts["conum"]), ("st1_group", "=", w),
("st1_type", "=", "X")], limit=1)
if not chk:
return "Invalid Group"
self.grp = w
def doCode(self, frt, pag, r, c, p, i, w):
whr = [
("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", w)]
if self.flag == "C":
err = "Invalid, Not Normal"
whr.append(("st1_type", "=", "N"))
else:
err = "Invalid, Not Redundant"
whr.append(("st1_type", "=", "X"))
chk = self.sql.getRec("strmf1", where=whr, limit=1)
if not chk:
return err
if self.flag == "C":
qty = self.sql.getRec("strtrn", cols=["sum(stt_qty)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_group", "=", self.grp), ("stt_code", "=", w)],
limit=1)
if qty[0]:
return "Balance Exists"
self.cod = w
desc = chk[self.sql.strmf1_col.index("st1_desc")]
self.df.loadEntry(frt, pag, p+1, data=desc)
def endPage(self):
if self.flag == "C":
old = "N"
new = "X"
else:
old = "X"
new = "N"
self.sql.updRec("strmf1", cols=["st1_type"], data=[new],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp), ("st1_code", "=", self.cod)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
key = "%03i%-3s%-20s" % (self.opts["conum"], self.grp, self.cod)
self.sql.insRec("chglog", data=["strmf1", "U", key,
"st1_type", dte, self.opts["capnm"], old, new, "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("T", 0)
self.flag = ""
def exitPage(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rt3020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "rtlmst", "rtltrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.fromad = rtlctl["ctr_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdttm = "(Printed on: %i/%02i/%02i at %02i:%02i)" % \
(t[0], t[1], t[2], t[3], t[4])
self.colsh = [
"TP", "BatchNo", "Prm-Cod", "Acc-Num", "Name", "Reference", "Date",
"Debits", "Credits", "Tax-Amount", "T", "Remarks"
]
self.forms = [("UI", 2, False, False, True), ("Na", 7), ("NA", 7),
("NA", 7), ("NA", 30), ("Na", 9), ("D1", 10),
("SD", 13.2), ("SD", 13.2), ("SD", 13.2), ("UA", 1),
("NA", 30)]
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
self.gqt = [0] * (len(rttrtp) + 1)
self.gdr = [0] * (len(rttrtp) + 1)
self.gcr = [0] * (len(rttrtp) + 1)
self.gvt = [0] * (len(rttrtp) + 1)
self.totind = "N"
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Rental's Ledger Audit Trail (%s)" %
self.__class__.__name__)
data = ["All Types"]
for typ in rttrtp:
data.append(typ[1])
btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"}
btm = {
"stype":
"R",
"tables": ("rtltrn", ),
"cols": (("rtt_batch", "", 0,
"Bat-Num"), ("rtt_type", ("xx", rttrtp), 20, "Type"),
("rtt_curdt", "", 0, "Cur-Dat")),
"where": [],
"group":
"rtt_batch, rtt_type, rtt_curdt",
"order":
"rtt_type, rtt_curdt, rtt_batch"
}
r1s = (("Financial", "F"), ("Capture", "C"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Period Type", "", "F", "Y",
self.doPtyp, None, None, None),
(("T", 0, 1, 0), "Id2", 7, "Starting Period", "", self.s_per,
"Y", self.doStartPer, None, None, ("efld", )),
(("T", 0, 2, 0), "Id2", 7, "Ending Period", "", self.e_per, "Y",
self.doEndPer, None, None, ("efld", )),
(("T", 0, 3, 0), "Id1", 10, "Starting Date", "", self.sysdtw,
"Y", self.doStartDat, None, None, ("efld", )),
(("T", 0, 4, 0), "Id1", 10, "Ending Date", "", self.sysdtw, "Y",
self.doEndDat, None, None, ("efld", )),
(("T", 0, 5, 0), "IUI", 1, "Type", "Transaction Type", "", "Y",
self.doBatTyp, btt, None, None),
(("T", 0, 6, 0), "INa", 7, "Batch Number", "", "", "Y",
self.doBatNum, btm, None, None),
(("T", 0, 7, 0), ("IRB", r2s), 0, "Totals Only", "", "Y", "Y",
self.doTots, None, None, None)]
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "N"))
def doPtyp(self, frt, pag, r, c, p, i, w):
self.ptyp = w
if self.ptyp == "C":
return "sk2"
def doStartPer(self, frt, pag, r, c, p, i, w):
if not w:
w = self.s_per
elif w < self.s_per or w > self.e_per:
return "Invalid Period"
self.sperw = w
self.df.loadEntry(frt, pag, p, data=self.sperw)
self.sperd = self.df.t_disp[pag][0][i]
def doEndPer(self, frt, pag, r, c, p, i, w):
if not w:
w = self.e_per
elif w < self.sperw or w > self.e_per:
return "Invalid Period"
self.eperw = w
self.df.loadEntry(frt, pag, p, self.eperw)
self.eperd = self.df.t_disp[pag][0][i]
return "sk2"
def doStartDat(self, frt, pag, r, c, p, i, w):
self.sdatw = w
self.df.loadEntry(frt, pag, p, data=self.sdatw)
self.sperd = self.df.t_disp[pag][0][i]
def doEndDat(self, frt, pag, r, c, p, i, w):
if w < self.sdatw:
return "Invalid Date"
self.edatw = w
self.df.loadEntry(frt, pag, p, self.edatw)
self.eperd = self.df.t_disp[pag][0][i]
def doBatTyp(self, frt, pag, r, c, p, i, w):
if w > len(rttrtp):
return "Invalid Batch Type"
self.btyp = w
self.whr = [("rtt_cono", "=", self.opts["conum"])]
if self.ptyp == "F":
self.whr.append(("rtt_curdt", "between", self.sperw, self.eperw))
else:
self.whr.append(("rtt_capdt", "between", self.sdatw, self.edatw))
if self.btyp:
self.whr.append(("rtt_type", "=", self.btyp))
self.df.topf[pag][i + 1][8]["where"] = self.whr
def doBatNum(self, frt, pag, r, c, p, i, w):
self.batch = w
def doTots(self, frt, pag, r, c, p, i, w):
self.totsonly = w
if self.totsonly == "Y":
self.df.setWidget(self.df.topEntry[0][8][3][0], state="hide")
self.df.setWidget(self.df.topEntry[0][8][4][0], state="hide")
else:
self.df.setWidget(self.df.topEntry[0][8][3][0], state="show")
self.df.setWidget(self.df.topEntry[0][8][4][0], state="show")
def doEnd(self):
self.df.closeProcess()
jon = "left outer join rtlmst on rtt_cono=rtm_cono and "\
"rtt_code=rtm_code and rtt_acno=rtm_acno"
col = [
"rtt_code", "rtt_acno", "rtt_trdt", "rtt_type", "rtt_refno",
"rtt_batch", "rtt_tramt", "rtt_taxamt", "rtt_desc", "rtt_taxind",
"rtm_name"
]
odr = "rtt_type, rtt_batch, rtt_trdt, rtt_refno"
recs = self.sql.getRec("rtltrn",
join=jon,
cols=col,
where=self.whr,
order=odr)
if not recs:
showError(self.opts["mf"].body, "Transaction Error",
"No Transactions Selected")
elif self.df.repprt[2] == "export":
self.exportReport(recs)
else:
self.printReport(recs)
self.closeProcess()
def exportReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
expnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"])
self.expheads = [
"%03u %-30s %s" %
(self.opts["conum"], self.opts["conam"], self.sysdttm)
]
self.expheads.append("Rental's Ledger Audit Trail for Period "\
"%s to %s" % (self.sperd, self.eperd))
self.expcolsh = [self.colsh]
self.expforms = self.forms
self.expdatas = []
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
p.closeProgress()
return
vals = self.getValues(dat)
if not vals:
continue
code, acno, trdt, trtp, refno, batch, debit, credit, taxamt, \
detail, taxind, name = vals
line = [
"BODY",
[
trtp.work, batch.work, code.work, acno.work, name.work,
refno.work, trdt.work, debit.work, credit.work,
taxamt.work, taxind.work, detail.work
]
]
self.expdatas.append(line)
p.closeProgress()
self.grandTotal()
doWriteExport(xtype=self.df.repprt[1],
name=expnam,
heads=self.expheads,
colsh=self.expcolsh,
forms=self.expforms,
datas=self.expdatas,
rcdic=self.opts["mf"].rcdic)
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
if self.totsonly == "Y":
self.head = "%03u %-87s" % (self.opts["conum"], self.opts["conam"])
else:
self.head = "%03u %-133s" % (self.opts["conum"],
self.opts["conam"])
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.bqty = 0
self.bdrs = 0
self.bcrs = 0
self.bvat = 0
self.tqty = 0
self.tdrs = 0
self.tcrs = 0
self.tvat = 0
self.trtp = 0
self.pglin = 999
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
vals = self.getValues(dat)
if not vals:
continue
code, acno, trdt, trtp, refno, batch, debit, credit, taxamt, \
detail, taxind, name = vals
if not self.trtp:
self.trtp = trtp.work
self.batch = batch.work
if trtp.work != self.trtp:
self.batchTotal()
self.typeTotal()
self.trtp = trtp.work
self.batch = batch.work
self.pglin = 999
if batch.work != self.batch:
self.batchTotal()
self.batch = batch.work
if self.totsonly != "Y":
self.typeHeading()
if self.pglin > self.fpdf.lpp:
self.pageHeading()
if self.totsonly != "Y":
self.fpdf.drawText(
"%s %s %s %s %s %s %s %s %s %s" %
(code.disp, acno.disp, name.disp, refno.disp, trdt.disp,
debit.disp, credit.disp, taxamt.disp, taxind.disp,
detail.disp))
self.pglin += 1
# Batch Totals
self.bqty += 1
self.bdrs = float(ASD(self.bdrs) + ASD(debit.work))
self.bcrs = float(ASD(self.bcrs) + ASD(credit.work))
self.bvat = float(ASD(self.bvat) + ASD(taxamt.work))
# Type Totals
self.tqty += 1
self.tdrs = float(ASD(self.tdrs) + ASD(debit.work))
self.tcrs = float(ASD(self.tcrs) + ASD(credit.work))
self.tvat = float(ASD(self.tvat) + ASD(taxamt.work))
p.closeProgress()
if self.fpdf.page and not p.quit:
self.batchTotal()
self.typeTotal()
self.grandTotal()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
def getValues(self, data):
code = CCD(data[0], "NA", 7)
acno = CCD(data[1], "NA", 7)
trdt = CCD(data[2], "D1", 10)
trtp = CCD(data[3], "UI", 2)
refno = CCD(data[4], "Na", 9)
batch = CCD(data[5], "Na", 7)
if data[6] < 0:
debit = CCD(0, "SD", 13.2)
credit = CCD(data[6], "SD", 13.2)
else:
debit = CCD(data[6], "SD", 13.2)
credit = CCD(0, "SD", 13.2)
taxamt = CCD(data[7], "SD", 13.2)
detail = CCD(data[8], "NA", 30)
taxind = CCD(data[9], "NA", 1)
name = CCD(data[10], "NA", 30)
self.gqt[trtp.work - 1] = self.gqt[trtp.work - 1] + 1
self.gdr[trtp.work - 1] = float(ASD(self.gdr[trtp.work - 1]) + \
ASD(debit.work))
self.gcr[trtp.work - 1] = float(ASD(self.gcr[trtp.work - 1]) + \
ASD(credit.work))
self.gvt[trtp.work - 1] = float(ASD(self.gvt[trtp.work - 1]) + \
ASD(taxamt.work))
return (code, acno, trdt, trtp, refno, batch, debit, credit, taxamt,
detail, taxind, name)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-38s %-7s %-2s %-7s" % \
("Rental's Ledger Audit Trail for Period",
self.sperd, "to", self.eperd))
self.fpdf.drawText()
self.pglin = 4
if self.totind == "N":
self.typeHeading()
else:
self.fpdf.drawText("%-14s" % "Totals Summary")
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-27s%-8s %-13s %-13s %-13s %-13s" % \
("Document Type", "Quantity", " Debits",
" Credits", " Difference", " V.A.T."))
else:
self.fpdf.drawText("%-34s%-8s %-13s %-13s %-13s %-13s" % \
("Document Type", "Quantity", " Debits",
" Credits", " Difference", " V.A.T."))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def typeHeading(self):
if self.totsonly != "Y":
batch = self.batch
else:
batch = "Various"
if self.fpdf.lpp - self.pglin < 7:
self.pageHeading()
return
self.fpdf.setFont(style="B")
self.fpdf.drawText("%-7s %7s %-10s %3s" % \
("Batch", batch, " Type", rttrtp[self.trtp - 1][1]))
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-36s %-13s %-13s %-13s %-13s" % \
("Details", " Debits", " Credits", " Difference",
" V.A.T."))
else:
self.fpdf.drawText("%-7s %-7s %-30s %-9s %-10s %-13s %-13s %-13s "\
"%-1s %-30s" % ("Prm-Num", "Acc-Num", "Name", "Reference",
" Date", " Debits", " Credits", " Tax-Amount",
"T", "Remarks"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def batchTotal(self):
j = CCD(self.bdrs, "SD", 13.2)
k = CCD(self.bcrs, "SD", 13.2)
l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 13.2)
m = CCD(self.bvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-36s %13s %13s %13s %13s" % \
("Batch " + self.batch + " Totals", j.disp,
k.disp, l.disp, m.disp))
self.pglin += 1
else:
self.fpdf.drawText()
self.fpdf.drawText("%-15s %-51s %13s %13s %13s" %
(" ", "Batch " + self.batch + " Totals", j.disp,
k.disp, m.disp))
self.fpdf.drawText()
self.pglin += 3
self.bqty = 0
self.bcrs = 0
self.bdrs = 0
self.bvat = 0
def typeTotal(self):
j = CCD(self.tdrs, "SD", 13.2)
k = CCD(self.tcrs, "SD", 13.2)
l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 13.2)
m = CCD(self.tvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText()
self.fpdf.drawText("%-36s %13s %13s %13s %13s" % \
("Type Totals", j.disp, k.disp, l.disp, m.disp))
self.pglin += 2
else:
self.fpdf.drawText("%-15s %-51s %13s %13s %13s" % \
(" ", "Type-Totals", j.disp, k.disp, m.disp))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
self.tqty = 0
self.tcrs = 0
self.tdrs = 0
self.tvat = 0
def grandTotal(self):
tot = [0, 0, 0, 0, 0]
if self.df.repprt[2] == "export":
for x in range(0, len(rttrtp)):
tot[0] = float(ASD(tot[0]) + ASD(self.gdr[x]))
tot[1] = float(ASD(tot[1]) + ASD(self.gcr[x]))
tot[2] = float(ASD(tot[2]) + ASD(self.gvt[x]))
self.expdatas.append(["ULINES"])
self.expdatas.append([
"TOTAL",
[
"", "", "", "", "Grand Totals", "", "", tot[0], tot[1],
tot[2], ""
]
])
self.expdatas.append(["ULINED"])
return
self.totind = "Y"
self.pageHeading()
for x, t in enumerate(rttrtp):
qt = CCD(self.gqt[x], "SI", 8)
dr = CCD(self.gdr[x], "SD", 13.2)
cr = CCD(self.gcr[x], "SD", 13.2)
df = float(ASD(dr.work) + ASD(cr.work))
df = CCD(df, "SD", 13.2)
vt = CCD(self.gvt[x], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-27s %s %s %s %s %s" % \
(t[1], qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
else:
self.fpdf.drawText("%-34s %s %s %s %s %s" % \
(t[1], qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
tot[0] = tot[0] + qt.work
tot[1] = float(ASD(tot[1]) + ASD(dr.work))
tot[2] = float(ASD(tot[2]) + ASD(cr.work))
tot[3] = float(ASD(tot[3]) + ASD(df.work))
tot[4] = float(ASD(tot[4]) + ASD(vt.work))
self.fpdf.drawText()
qt = CCD(tot[0], "SI", 8)
dr = CCD(tot[1], "SD", 13.2)
cr = CCD(tot[2], "SD", 13.2)
df = CCD(tot[3], "SD", 13.2)
vt = CCD(tot[4], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-27s %s %s %s %s %s" % \
("Grand Totals", qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
else:
self.fpdf.drawText("%-34s %s %s %s %s %s" % \
("Grand Totals", qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
self.fpdf.drawText()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class gl3080(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlctl", "genbal", "genmst",
"gentrn", "genrct"], prog=self.__class__.__name__)
if self.sql.error:
return
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
t = time.localtime()
self.c_per = (t[0] * 100) + t[1]
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"General Ledger Bank Reconciliation (%s)" % self.__class__.__name__)
glm = {
"stype": "R",
"tables": ("ctlctl", "genmst"),
"cols": (
("ctl_conacc", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"where": [
("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "like", "bank_%"),
("glm_cono=ctl_cono",),
("glm_acno=ctl_conacc",)]}
fld = (
(("T",0,0,0),"IUI",7,"Bank Account","",
"","Y",self.doBankAcc,glm,None,("efld",)),
(("T",0,1,0),"Id2",7,"Accounting Period","",
self.c_per,"Y",self.doPer,None,None,("efld",)))
tnd = ((self.doEnd,"y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld,
tend=tnd, txit=txt, view=("N","V"), mail=("Y","N"))
def doBankAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["ctlctl", "genmst"], cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w),
("ctl_cono=glm_cono",), ("ctl_conacc=glm_acno",), ("ctl_code",
"like", "bank_%")], limit=1)
if not acc:
return "Invalid Bank Account Number"
self.acno = w
self.name = acc[0]
def doPer(self, frt, pag, r, c, p, i, w):
self.perw = w
self.perd = self.df.t_disp[pag][r][p]
def doEnd(self):
self.df.closeProcess()
self.extractBalance()
self.sortPayments()
self.sortReceipts()
self.sortImports()
self.printReport()
self.closeProcess()
def sortPayments(self):
col = ["glt_trdt", "glt_refno", "glt_desc", "glt_tramt"]
whr = [
("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_curdt", "<=", self.perw),
("(", "glt_recon", "=", 0, "or", "glt_recon", ">", self.perw, ")"),
("glt_type", "in", (2, 4))]
odr = "glt_curdt, glt_trdt, glt_type, glt_refno, glt_batch"
self.pays = self.sql.getRec("gentrn", cols=col, where=whr,
order=odr)
if not self.pays:
self.pays = []
def sortReceipts(self):
col = ["glt_trdt", "glt_refno", "glt_desc", "glt_tramt"]
whr = [
("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_curdt", "<=", self.perw),
("(", "glt_recon", "=", 0, "or", "glt_recon", ">", self.perw, ")"),
("glt_type", "=", 6)]
odr = "glt_curdt, glt_trdt, glt_type, glt_refno, glt_batch"
self.recs = self.sql.getRec("gentrn", cols=col, where=whr,
order=odr)
if not self.recs:
self.recs = []
def sortImports(self):
dte = mthendDate((self.perw * 100) + 1)
col = ["grt_date", "grt_refno", "grt_memo", "grt_amount"]
whr = [
("grt_cono", "=", self.opts["conum"]),
("grt_acno", "=", self.acno),
("grt_date", "<=", dte),
("grt_flag", "=", "N")]
odr = "grt_date, grt_refno"
self.imps = self.sql.getRec("genrct", cols=col, where=whr,
order=odr)
if not self.imps:
self.imps = []
def printReport(self):
p = ProgressBar(self.opts["mf"].body,
mxs=(len(self.pays) + len(self.recs) + len(self.imps)))
self.head = "%03u %-30s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=90)
self.pglin = 999
self.tot_chq = 0
self.tot_dep = 0
self.tot_imp = 0
self.pageHeading()
bal = CCD(self.bal, "SD", 13.2)
self.fpdf.drawText("%-71s %-13s" % ("Balance as per Cash Book",
bal.disp))
if self.pays:
self.fpdf.drawText()
self.fpdf.drawText("%-70s" % ("Add: Cheques Not Presented",))
self.fpdf.drawText()
self.pglin += 4
mxs = len(self.pays) - 1
for num, pay in enumerate(self.pays):
p.displayProgress(num)
self.printLine(num, mxs, pay, "C")
self.pglin += 1
if self.recs:
self.fpdf.drawText()
self.fpdf.drawText("%-70s" % ("Less: Deposits Not Presented",))
self.fpdf.drawText()
self.pglin += 3
mxs = len(self.recs) - 1
for num, rec in enumerate(self.recs):
p.displayProgress(len(self.pays) + num)
self.printLine(num, mxs, rec, "D")
# Bank Imports
if self.imps:
self.fpdf.drawText()
self.fpdf.drawText("%-70s" % ("+-: Imports Not Captured",))
self.fpdf.drawText()
self.pglin += 3
mxs = len(self.imps) - 1
for num, rec in enumerate(self.imps):
p.displayProgress(len(self.pays) + len(self.imps) + num)
self.printLine(num, mxs, rec, "I")
p.closeProgress()
self.fpdf.underLine(txt="%72s%12s" % ("", 12 * self.fpdf.suc))
b = float(ASD(self.bal) + ASD(self.tot_chq) - ASD(self.tot_dep) + \
ASD(self.tot_imp))
bal = CCD(b, "SD", 13.2)
self.fpdf.drawText("%-71s %-13s" % ("Balance as per Bank Statement",
bal.disp))
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=self.df.repprt,
repeml=self.df.repeml)
def printLine(self, num, mxs, dat, typ):
trdt = CCD(dat[0], "D1", 10)
refno = CCD(dat[1], "Na", 9)
desc = CCD(dat[2], "NA", 30)
if typ in ("D", "I"):
amt = dat[3]
else:
amt = float(ASD(0) - ASD(dat[3]))
tramt = CCD(amt, "SD", 13.2)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
if typ == "C":
self.tot_chq = float(ASD(self.tot_chq) + ASD(tramt.work))
if num == mxs:
bal = CCD(self.tot_chq, "SD", 13.2)
elif typ == "D":
self.tot_dep = float(ASD(self.tot_dep) + ASD(tramt.work))
if num == mxs:
bal = CCD(self.tot_dep, "SD", 13.2)
else:
self.tot_imp = float(ASD(self.tot_imp) + ASD(tramt.work))
if num == mxs:
bal = CCD(self.tot_imp, "SD", 13.2)
if num == mxs:
self.fpdf.drawText("%-5s %-9s %-10s %-30s %-13s %-13s" % \
("", refno.disp, trdt.disp, desc.disp, tramt.disp, bal.disp))
else:
self.fpdf.drawText("%-5s %-9s %-10s %-30s %-13s" % \
("", refno.disp, trdt.disp, desc.disp, tramt.disp))
self.pglin += 1
def extractBalance(self):
o = self.sql.getRec("genbal", cols=["glo_cyr"],
where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno",
"=", self.acno), ("glo_trdt", "=", self.opts["period"][1][0])],
limit=1)
if o:
b = CCD(o[0], "SD", 13.2)
else:
b = CCD(0, "SD", 13.2)
self.bal = b.work
o = self.sql.getRec("gentrn", cols=["round(sum(glt_tramt), 2)"],
where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=",
self.acno), ("glt_curdt", ">=", self.s_per), ("glt_curdt", "<=",
self.perw)], limit=1)
if o[0]:
b = CCD(o[0], "SD", 13.2)
else:
b = CCD(0, "SD", 13.2)
self.bal = float(ASD(self.bal) + ASD(b.work))
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("Bank Reconciliation for %s (%s) up to Period %s" %
(self.name, self.acno, self.perd))
self.fpdf.underLine()
self.fpdf.setFont()
self.pglin = 4
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class ar2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
if self.opts["rtn"] not in (1, 2, 3):
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
self.gc = GetCtl(self.opts["mf"])
assctl = self.gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.glint = assctl["cta_glint"]
self.rordp = assctl["cta_rordp"]
tabs = [
"assgrp", "assmst", "assdep", "asstrn", "ctlvmf", "ctlvrf",
"ctlvtf", "genint", "genmst", "gentrn"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.glint == "Y":
# Check Sale of Asset Record
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, "ass_sls"):
return
self.slsac = ctlctl["ass_sls"]
# Check for VAT Control
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return
self.convat = ctlctl["vat_ctl"]
# Check All Group Control Records
errs = ("Group %s Has An Invalid", "Asset Control Account (%s)",
"Accumulated Depreciation Account (%s)",
"Depreciation Expense Account (%s)")
ass = self.sql.getRec(
"assgrp",
cols=["asg_group", "asg_assacc", "asg_depacc", "asg_expacc"],
where=[("asg_cono", "=", self.opts["conum"])])
for acc in ass:
for x in range(1, 4):
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", acc[x])],
limit=1)
if not chk:
mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x])
showError(self.opts["mf"].body, "Control Error", mess)
return
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"ASS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 2:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("assmst", ),
"cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0,
"Description", "Y")),
"where": [("asm_cono", "=", self.opts["conum"])],
"whera": [["C", "asm_group", 0, 1]]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
data = []
for x in range(1, (len(armvtp) + 1)):
data.append([x, armvtp[x - 1][1]])
mov = {
"stype": "C",
"titl": "Valid Types",
"head": ("C", "Description"),
"data": data
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N",
self.doAssGrp, grp, None, None),
(("C", 1, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "r", "N",
self.doAssCod, cod, None, ("notblank", )),
(("C", 1, 0, 2), "ONA", 13, "Description"),
(("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "IUI", 1, "M", "Movement Type", "r", "N",
self.doTrnMov, mov, None, ("in", (1, 2, 3, 4, 5))),
(("C", 1, 0, 6), "ISD", 13.2, "Company", "Company Amount", "",
"N", self.doCoyAmt, None, None, None),
(("C", 1, 0, 7), "ISD", 13.2, "Receiver", "Receiver Amount", "",
"N", self.doRorAmt, None, None, None),
(("C", 1, 0, 8), "IUA", 1, "V", "V.A.T Code", "C", "N",
self.doVatCod, vtm, None, ("notblank", )),
(("C", 1, 0, 9), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
(("C", 1, 0,
10), "INA", (13, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = (("Interrogate", None, self.queryAss, 0, ("C", 1, 1),
("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1)))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doAssGrp(self, frt, pag, r, c, p, i, w):
whr = [("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", w)]
acc = self.sql.getRec("assgrp", where=whr, limit=1)
if not acc:
return "Invalid Asset Group"
self.group = w
self.depcod = acc[self.sql.assgrp_col.index("asg_depcod")]
self.assacc = acc[self.sql.assgrp_col.index("asg_assacc")]
self.depacc = acc[self.sql.assgrp_col.index("asg_depacc")]
self.expacc = acc[self.sql.assgrp_col.index("asg_expacc")]
def doAssCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.buydt = 0
self.seldt = 0
col = ["asm_desc", "asm_depcod"]
whr = [("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group), ("asm_code", "=", self.code)]
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
ok = askQuestion(screen=self.opts["mf"].body,
head="New Asset",
mess="Asset does not exist, Create?")
if ok == "no":
return "Invalid Asset"
self.doNewAsset()
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
return "Asset Not Found"
self.new = "y"
else:
self.new = "n"
dep = self.sql.getRec("assdep",
cols=["asd_rate1r"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", acc[1])],
limit=1)
self.rate1r = dep[0]
col = ["ast_date"]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "=", 1)]
pur = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if pur:
self.buydt = pur[0]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "in", (3, 5))]
sel = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if sel:
self.seldt = sel[0]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
if self.new == "y":
self.trnmov = 1
self.df.loadEntry(frt, pag, p + 1, data=self.trnmov)
return "sk1"
def doTrnMov(self, frt, pag, r, c, p, i, w):
if type(w) == list:
w = w[0] + 1
# Do some tests to see if not new again or already sold etc.
if w == 4 and self.opts["rtn"] != 3:
return "Depreciation Only Allowed with Journal Entries"
if self.opts["rtn"] == 1 and w not in (1, 2):
return "Invalid Choice For Payment"
if self.opts["rtn"] == 2 and w not in (5, ):
return "Invalid Choice For Receipt"
if w == 1 and self.buydt:
return "Asset Already Purchased"
if w in (2, 3, 4, 5) and self.seldt:
return "Asset Already Sold or Written Off"
if w in (2, 3, 4, 5) and not self.buydt:
return "Asset Not Yet Purchased"
self.df.loadEntry(frt, pag, p, data=w)
self.trnmov = w
if self.trnmov == 3:
bal = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)", "sum(ast_amt2)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
self.coyamt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 1, data=self.coyamt)
self.roramt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 2, data=self.roramt)
self.vatcode = ""
self.trnvat = 0
return "sk4"
def doCoyAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.coyamt = w
if self.rordp == "N" or not self.rate1r or self.trnmov != 4:
self.roramt = 0
self.df.loadEntry(frt, pag, p + 1, data=self.roramt)
if self.trnmov == 4:
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 2, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 3, data=self.trnvat)
return "sk3"
return "sk1"
def doRorAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.roramt = w
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 1, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 2, data=self.trnvat)
return "sk2"
def doVatCod(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.trnvat = round((self.coyamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.trnvat)
if not self.trnvat:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.coyamt < 0 and w > 0:
self.trnvat = float(ASD(0) - ASD(w))
elif self.coyamt > 0 and w < 0:
self.trnvat = float(ASD(0) - ASD(w))
else:
self.trnvat = w
self.df.loadEntry(frt, pag, p, data=self.trnvat)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
self.df.colf[2][3][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if self.coyamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.glint == "N" or self.opts["rtn"] in (1, 2) or \
self.trnmov == 4:
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(1)
else:
self.coyamt = float(ASD(0) - ASD(self.coyamt))
self.df.loadEntry("T", 2, 0, data=self.coyamt)
self.df.selPage("Allocation")
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.coyamt
self.vat = self.trnvat
if self.trnmov == 4:
self.net = float(ASD(0) - ASD(self.coyamt))
self.ror = float(ASD(0) - ASD(self.roramt))
else:
self.net = self.ror = float(ASD(self.coyamt) - ASD(self.trnvat))
if self.opts["rtn"] == 1: # Payments
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
acc = self.assacc
self.glt = 2
elif self.opts["rtn"] == 2: # Receipts
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.net = float(ASD(0) - ASD(self.net))
acc = self.assacc
self.glt = 6
elif self.opts["rtn"] == 3: # Journal Entries
self.recon = 0
if self.trnmov == 4:
acc = self.depacc
else:
acc = self.assacc
self.glt = 4
# Asset Register Transaction
data = [
self.opts["conum"], self.group, self.code, self.opts["rtn"],
self.trnref, self.bh.batno, self.trndat, self.trnmov, self.net,
self.ror, self.vat, self.curdt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.vatcode:
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "I", self.curdt, "A",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.code, self.trndet, self.amt, self.vat, 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Asset or Depreciation Account
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, self.net, self.vat, self.trndet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.vat:
# General Ledger Control Transaction (V.A.T.)
data = [
self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.vat, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
self.amt = float(ASD(0) - ASD(self.amt))
if self.opts["rtn"] in (1, 2):
# General Ledger Control Transaction (Bank)
data = [
self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
elif self.trnmov == 4:
# General Ledger Expense Account (Depreciation)
data = [
self.opts["conum"], self.expacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.coyamt, self.vat,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.trnmov == 5:
# Sale of Asset
# Raise Depreciation
callModule(self.opts["mf"],
None,
"ar2030",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"],
args=(self.curdt, self.group, self.code))
# Generate Sale
amt = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
if amt[0]:
data = [
self.opts["conum"], self.slsac, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt[0], 0,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
data[1] = acc
data[7] = float(ASD(0) - ASD(amt[0]))
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int(int((self.df.last[1][1] - 1) / self.df.colq[1]))
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.coyamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
# General Ledger Transaction (Allocation)
amt = float(ASD(0) - ASD(self.allamt))
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt, 0.00, self.alldet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.coyamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.coyamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def doNewAsset(self):
tit = ("Create New Asset", )
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INA", 30, "Description", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 1, 0), "INa", 3, "Dep Code", "Depreciation Code",
self.depcod, "N", self.doDepCode, dep, None,
("notblank", )), (("T", 0, 1, 0), "ONA", 34, ""))
tnd = ((self.doNewEnd, "N"), )
txt = (self.doNewXit, )
state = self.df.disableButtonsTags()
self.na = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=self.fld,
tend=tnd,
txit=txt)
self.na.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doDepCode(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.na.loadEntry(frt, pag, p + 1, data=chk[0])
def doNewEnd(self):
dat = [self.opts["conum"], self.group, self.code]
for x in range(len(self.na.t_work[0][0]) - 1):
dat.append(self.na.t_work[0][0][x])
self.sql.insRec("assmst", data=dat)
self.doNewXit()
def doNewXit(self):
self.na.closeProcess()
def queryAss(self):
callModule(self.opts["mf"],
self.df,
"ar4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
class dr3050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["drsact", "drstyp", "drsmst", "drstrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.fromad = drsctl["ctd_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdttm = "(Printed on: %i/%02i/%02i at %02i:%02i) %6s" % (
t[0], t[1], t[2], t[3], t[4], self.__class__.__name__)
self.head = "%03u %-30s" % (self.opts["conum"], self.opts["conam"])
self.colsh = [
"Chn", "Acc-Num", "Name", "Cr-Balance", "Tot-Balance", "Current",
"30-Days", "60-Days", "90-Days", "Over-90-Days"
]
self.forms = [("UI", 3), ("NA", 7), ("NA", 30)] + [("SD", 13.2)] * 7
self.gtots = [0] * 7
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Debtors Age Analysis (%s)" % self.__class__.__name__)
dra = {
"stype":
"R",
"tables": ("drsact", ),
"cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0,
"Description", "Y"))
}
drt = {
"stype":
"R",
"tables": ("drstyp", ),
"cols": (("dtp_code", "", 0, "Cod"), ("dtp_desc", "", 0,
"Description", "Y"))
}
r1s = (("Agedt", "A"), ("Curdt", "C"))
r2s = (("Yes", "Y"), ("No", "N"))
r3s = (("Yes", "Y"), ("No", "N"), ("Only", "O"))
if "args" in self.opts and "noprint" in self.opts["args"]:
var = self.opts["args"]["work"][0]
view = None
mail = None
else:
var = ["A", "", "N", "", "", 0, "Y", "Y"]
view = ("Y", "V")
mail = ("Y", "N")
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Base", "", var[0], "Y",
self.doBase, None, None, None),
(("T", 0, 1, 0), "ID2", 7, "Cut-Off Period", "",
int(self.sysdtw / 100), "N", self.doCutOff, None, None,
None), (("T", 0, 2, 0), ("IRB", r2s), 0, "Totals Only", "",
var[2], "N", self.doTots, None, None, None),
(("T", 0, 3, 0), "IUA", 3, "Business Activity", "", var[3], "N",
self.doDrsAct, dra, None,
None), (("T", 0, 4, 0), "IUA", 3, "Business Type", "", var[4],
"N", self.doDrsTyp, drt, None, None),
(("T", 0, 5, 0), "IUI", 7, "Lower Balance Limit", "", var[5],
"N", self.doLimit, None, None, None),
(("T", 0, 6, 0), ("IRB", r3s), 0, "Include Credit Balances", "",
var[6], "N", self.doCredit, None, None, None),
(("T", 0, 7, 0), ("IRB", r2s), 0, "Ignore Zero Balances", "",
var[7], "N", self.doZero, None, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=view,
mail=mail)
def doBase(self, frt, pag, r, c, p, i, w):
self.base = w
def doCutOff(self, frt, pag, r, c, p, i, w):
self.cutoff = w
self.opts["period"] = self.df.t_disp[pag][r][p]
def doTots(self, frt, pag, r, c, p, i, w):
self.totsonly = w
if self.totsonly == "Y":
if "args" not in self.opts or "noprint" not in self.opts["args"]:
self.df.setWidget(self.df.topEntry[0][8][3][0], state="hide")
self.df.setWidget(self.df.topEntry[0][8][4][0], state="hide")
self.drsact = "All"
self.df.loadEntry(frt, pag, p + 1, data=self.drsact)
self.drstyp = "All"
self.df.loadEntry(frt, pag, p + 2, data=self.drstyp)
self.limit = 0
self.df.loadEntry(frt, pag, p + 3, data=self.limit)
self.credit = "Y"
self.df.loadEntry(frt, pag, p + 4, data=self.credit)
self.zero = "Y"
self.df.loadEntry(frt, pag, p + 5, data=self.zero)
return "sk5"
elif "args" in self.opts and "noprint" in self.opts["args"]:
pass
else:
self.df.setWidget(self.df.topEntry[0][8][3][0], state="show")
self.df.setWidget(self.df.topEntry[0][8][4][0], state="show")
def doDrsAct(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsact",
where=[("dac_code", "=", w)],
limit=1)
if not acc:
return "Invalid Account Activity"
self.drsact = w
else:
self.drsact = "All"
def doDrsTyp(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drstyp",
where=[("dtp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Account Activity"
self.drstyp = w
else:
self.drstyp = "All"
def doLimit(self, frt, pag, r, c, p, i, w):
self.limit = w
if self.limit:
self.credit = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.limit)
self.zero = "Y"
self.df.loadEntry(frt, pag, p + 3, data=self.zero)
return "sk2"
def doCredit(self, frt, pag, r, c, p, i, w):
self.credit = w
if self.credit == "O":
self.zero = "Y"
self.df.loadEntry(frt, pag, p + 1, data=self.zero)
return "sk1"
def doZero(self, frt, pag, r, c, p, i, w):
self.zero = w
def doEnd(self):
self.df.closeProcess()
whr = [("drm_cono", "=", self.opts["conum"])]
if self.drsact != "All":
whr.append(("drm_bus_activity", "=", self.drsact))
if self.drstyp != "All":
whr.append(("drm_bus_type", "=", self.drstyp))
odr = "drm_chain, drm_acno"
recs = self.sql.getRec("drsmst",
cols=["drm_chain", "drm_acno", "drm_name"],
where=whr,
order=odr)
if not recs:
showError(self.opts["mf"].body, "Selection Error",
"No Records Selected")
elif self.df.repprt[2] == "export":
self.exportReport(recs)
else:
self.printReport(recs)
if "args" in self.opts and "noprint" in self.opts["args"]:
self.t_work = [self.df.t_work[0][0]]
self.closeProcess()
def exportReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
expnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"])
self.expheads = [self.head + " %s" % self.sysdttm]
self.expheads.append("Debtor's Age Analaysis up to %s" %
self.opts["period"])
self.expheads.append("Options: Activity %s Type %s Low-Bal %s "\
"Cr-Bals %s Ignore-Zeros %s" % (self.drsact, self.drstyp,
self.limit, self.credit, self.zero))
self.expcolsh = [self.colsh]
self.expforms = self.forms
self.expdatas = []
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
p.closeProgress()
return
vals = self.getValues(dat)
if not vals:
continue
line = ["BODY", [vals[0].work, vals[1].work, vals[2].work]]
for val in vals[3:]:
line[1].append(val.work)
self.expdatas.append(line)
p.closeProgress()
self.grandTotal()
doWriteExport(xtype=self.df.repprt[1],
name=expnam,
heads=self.expheads,
colsh=self.expcolsh,
forms=self.expforms,
datas=self.expdatas,
rcdic=self.opts["mf"].rcdic)
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
chrs = len(self.colsh)
for f in self.forms:
chrs += int(f[1])
if f[0][0].lower() == "s":
chrs -= 2
else:
chrs -= 1
self.head1 = self.head
self.head2 = "Debtor's Age Analysis up to %s" % self.opts["period"]
pad = chrs - len(self.head2)
self.head2 = self.head2 + (" " * pad)
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head2)
self.pglin = 999
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
if self.fpdf.page:
self.fpdf.drawText()
self.fpdf.drawText("Print Job ABORTED")
break
vals = self.getValues(dat)
if not vals:
continue
if self.totsonly != "Y":
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.fpdf.drawText("%s %s %s %s %s %s %s %s %s %s" % \
(vals[0].disp, vals[1].disp, vals[2].disp, vals[3].disp,
vals[4].disp, vals[5].disp, vals[6].disp, vals[7].disp,
vals[8].disp, vals[9].disp))
self.pglin += 1
p.closeProgress()
if p.quit:
return
if self.totsonly == "Y":
self.pageHeading()
if self.fpdf.page:
self.grandTotal()
if "args" not in self.opts or "noprint" not in self.opts["args"]:
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
def getValues(self, data):
chn = CCD(data[0], "UI", 3)
acc = CCD(data[1], "NA", 7)
name = CCD(data[2], "NA", 30)
if self.base == "A":
bals = Balances(self.opts["mf"],
"DRS",
self.opts["conum"],
self.cutoff,
keys=(data[0], data[1]))
obal, cbal, ages = bals.doAllBals()
else:
pers = []
yr = int(self.cutoff / 100)
mt = int(self.cutoff % 100)
for x in range(4):
pers.append((yr * 100) + mt)
mt -= 1
if not mt:
yr -= 1
mt = 12
cbal = 0
ages = [0, 0, 0, 0, 0]
bals = self.sql.getRec("drstrn",
cols=["drt_curdt", "sum(drt_tramt)"],
where=[("drt_cono", "=",
self.opts["conum"]),
("drt_chain", "=", chn.work),
("drt_acno", "=", acc.work),
("drt_curdt", "<=", pers[0])],
group="drt_curdt",
order="drt_curdt")
for bal in bals:
try:
idx = pers.index(bal[0])
except:
idx = 4
ages[idx] = float(ASD(ages[idx]) + ASD(bal[1]))
cbal = float(ASD(cbal) + ASD(bal[1]))
bal = CCD(cbal, "SD", 13.2)
if self.limit and bal.work < self.limit:
return
if self.zero == "Y" and not bal.work:
return
if self.credit == "N" and bal.work < 0:
return
if self.credit == "O" and bal.work >= 0:
return
cur = CCD(ages[0], "SD", 13.2)
d30 = CCD(ages[1], "SD", 13.2)
d60 = CCD(ages[2], "SD", 13.2)
d90 = CCD(ages[3], "SD", 13.2)
d120 = CCD(ages[4], "SD", 13.2)
if bal.work < 0:
deb = CCD(bal.work, "SD", 13.2)
else:
deb = CCD(0, "SD", 13.2)
self.gtots[0] = float(ASD(self.gtots[0]) + ASD(deb.work))
self.gtots[1] = float(ASD(self.gtots[1]) + ASD(bal.work))
self.gtots[2] = float(ASD(self.gtots[2]) + ASD(cur.work))
self.gtots[3] = float(ASD(self.gtots[3]) + ASD(d30.work))
self.gtots[4] = float(ASD(self.gtots[4]) + ASD(d60.work))
self.gtots[5] = float(ASD(self.gtots[5]) + ASD(d90.work))
self.gtots[6] = float(ASD(self.gtots[6]) + ASD(d120.work))
return (chn, acc, name, deb, bal, cur, d30, d60, d90, d120)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head1)
self.fpdf.drawText()
self.fpdf.drawText(self.head2)
self.fpdf.drawText()
self.fpdf.drawText(
"(%s%-3s%3s%6s%-3s%3s%9s%-8s%3s%13s%1s%3s%17s%s)" %
("Options: Activity: ", self.drsact, "", "Type: ", self.drstyp, "",
"Low-Bal: ", self.limit, "", "Cr-Bals: ", self.credit, "",
"Ignore-Zero-Bal: ", self.zero))
self.fpdf.drawText()
self.fpdf.drawText("%-3s %-7s %-30s %-13s %-13s %-13s %-13s %-13s "\
"%-13s %-13s" % ("Chn", "Acc-Num", "Name", " Cr-Balance",
" Tot-Balance", " Current", " 30-Days", " 60-Days",
" 90-Days", "Over-90-Days"))
self.fpdf.drawText("%s" % (self.fpdf.suc * len(self.head2)))
self.fpdf.setFont()
self.pglin = 8
def grandTotal(self):
if self.df.repprt[2] == "export":
self.expdatas.append(["ULINES"])
self.expdatas.append(
["TOTAL", ["", "", "Grand Totals"] + self.gtots])
self.expdatas.append(["ULINED"])
return
ldic = {}
for x in range(0, 7):
ldic["t%s" % x] = CCD(self.gtots[x], "SD", 13.2)
if self.gtots[1] == 0:
ldic["p%s" % x] = CCD(0, "SD", 13.2)
else:
ldic["p%s" % x] = CCD(
round((self.gtots[x] / self.gtots[1] * 100), 2), "OSD",
13.2)
self.fpdf.drawText()
self.fpdf.drawText("%-11s %-30s %13s %13s %13s %13s %13s %13s %13s" %
(" ", "Grand Totals", ldic["t0"].disp,
ldic["t1"].disp, ldic["t2"].disp, ldic["t3"].disp,
ldic["t4"].disp, ldic["t5"].disp, ldic["t6"].disp))
self.fpdf.drawText()
self.fpdf.drawText("%-11s %-30s %13s %13s %13s %13s %13s %13s %13s" %
(" ", "Percentages", ldic["p0"].disp,
ldic["p1"].disp, ldic["p2"].disp, ldic["p3"].disp,
ldic["p4"].disp, ldic["p5"].disp, ldic["p6"].disp))
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class bc3050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["bwlflf", "bwlflm", "bwlfls",
"bwlflt", "bwltab"], prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.fromad = bwlctl["ctb_emadd"]
self.pos = ["", "Skip", " 3rd", " 2nd", "Lead"]
return True
def mainProcess(self):
fmt = {
"stype": "R",
"tables": ("bwlflf",),
"cols": (
("bff_code", "", 0, "Cod"),
("bff_desc", "", 0, "Description", "Y")),
"where": [("bff_cono", "=", self.opts["conum"])]}
dte = {
"stype": "R",
"tables": ("bwlflm",),
"cols": (("bfm_date", "", 0, "Match-Date"),),
"where": [("bfm_cono", "=", self.opts["conum"])],
"whera": [
("T", "bfm_fmat", 0, 0),
("T", "bfm_type", 2, 0)],
"group": "bfm_date"}
r1s = (("Fixture", "F"), ("Practice", "P"))
fld = (
(("T",0,0,0),"I@bfm_fmat",0,"","",
"","N",self.doFmat,fmt,None,("efld",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,1,0),("IRB",r1s),0,"Type","",
"F","N",self.doType,fmt,None,None),
(("T",0,2,0),"I@bfm_date",0,"","",
"","N",self.doDate,dte,None,("efld",)))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt, view=("Y","V"), mail=("Y","Y"))
def doFmat(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlflf", where=[("bff_cono", "=",
self.opts["conum"]), ("bff_code", "=", w)], limit=1)
if not acc:
return "Invalid Format"
if acc[self.sql.bwlflf_col.index("bff_assess")] == "N":
return "Assessment Forms Disabled"
self.fmat = w
self.fnam = acc[self.sql.bwlflf_col.index("bff_desc")]
self.forms = acc[self.sql.bwlflf_col.index("bff_forms")]
self.df.loadEntry(frt, pag, p+1, data=self.fnam)
def doType(self, frt, pag, r, c, p, i, w):
self.ftyp = w
def doDate(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlflm", where=[("bfm_cono", "=",
self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_type",
"=", self.ftyp), ("bfm_date", "=", w)], limit=1)
if not acc:
return "Invalid Match Date"
self.date = w
self.disp = self.df.t_disp[0][0][3]
def doEnd(self):
self.df.closeProcess()
data = []
recs = self.sql.getRec(tables=["bwlflt", "bwlfls"], cols=["bft_skip",
"bft_player", "bft_position", "bft_shotsf", "bft_shotsa",
"bft_points", "bft_rating1", "bft_rating2", "bft_rating3",
"bft_rating4", "bft_remarks"], where=[("bft_cono", "=",
self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type",
"=", self.ftyp),
("bft_date", "=", self.date), ("bfs_cono=bft_cono",),
("bfs_fmat=bft_fmat",), ("bfs_league", "=", "M"),
("bfs_code=bft_team",)], order="bfs_code, bft_skip, bft_position")
for player in recs:
pos = player[2]
his = player[5 + pos]
if pos == 1:
names = self.sql.getRec(tables=["bwlflt", "bwltab"],
cols=["btb_surname", "btb_names"], where=[("bft_cono",
"=", self.opts["conum"]), ("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp), ("bft_date", "=", self.date),
("bft_skip", "=", player[0]), ("btb_cono=bft_cono",),
("btb_tab=bft_player",)], order="bft_position")
for nm in names:
nm[0] = self.getName(nm[0], nm.pop(1))
sc = self.sql.getRec("bwlflt", cols=["bft_rating%s" % pos],
where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=",
self.fmat), ("bft_type", "=", self.ftyp), ('bft_date', '=',
self.date), ("bft_skip", "=", player[0])])
tot = sc[0][0] + sc[1][0] + sc[2][0] + sc[3][0]
tav = self.getHistory(player[1])
if tav == "error":
break
if not tav:
tav = tot
if self.forms == 1:
if player[1] == player[0]:
desc = textFormat(player[10], width=70)
if desc:
text = desc.pop(0)
else:
text = ""
data.append([names[player[2]-1][0], self.pos[pos], player[3],
player[4], player[5], sc[0][0], tav, text])
else:
if his:
div = 4.0
else:
div = 3.0
data.append([names[player[2]-1][0], self.pos[pos], player[3],
player[4], player[5], sc[0][0], sc[1][0], sc[2][0],
sc[3][0], round(tot / div, 1), his,
round((tot - his) / 3.0, 1), tav, player[10]])
if pos == 4:
data.append(["BLANK"])
if tav != "error":
head = ("Match Assessment for %s Match Played on %s" % \
(self.fnam, self.disp),)
cols = [
["a", "NA", 20, "Player", "y"],
["b", "NA", 4, "Posn", "y"],
["c", "UI", 3, "For", "y"],
["d", "UI", 3, "Agt", "y"],
["e", "UI", 1, "P", "y"]]
if self.forms == 1:
cols.append(["f", "UD", 4.1, " Ass", "y"])
elif self.forms == 4:
cols.extend([
["f", "UD", 4.1, " Skp", "y"],
["g", "UD", 4.1, " 3rd", "y"],
["h", "UD", 4.1, " 2nd", "y"],
["i", "UD", 4.1, "Lead", "y"],
["j", "UD", 4.1, " Avg", "y"],
["k", "UD", 4.1, " Own", "y"],
["l", "UD", 4.1, " Adj", "y"]])
cols.extend([
["m", "UD", 4.1, " ATD", "y"],
["n", "NA", 70, "Remarks", "y"]])
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=data,
heads=head, cols=cols, ttype="D", repprt=self.df.repprt,
repeml=self.df.repeml, fromad=self.fromad)
self.opts["mf"].closeLoop()
def getHistory(self, player):
sdate = 0
acc = self.sql.getRec("bwlflm", cols=["bfm_date"],
where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=",
self.fmat), ("bfm_type", "=", self.ftyp), ("bfm_round", "=", 1)],
order="bfm_date")
for a in acc:
if dateDiff(a[0], self.date, ptype="months") < 4:
sdate = a[0]
break
if not sdate:
showError(self.opts["mf"].body, "ERROR",
"No Start Date of 1st Round")
return "error"
rounds = self.sql.getRec("bwlflm", cols=["bfm_round",
"bfm_date"], where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp),
("bfm_date", ">=", sdate, "and", "bfm_date", "<=", self.date)],
group="bfm_round, bfm_date", order="bfm_round")
cnt = 0
his = 0
tot = 0
for rnd in rounds:
pl = self.sql.getRec(tables=["bwlfls", "bwlflt"],
cols=["bft_position", "bft_rating1", "bft_rating2",
"bft_rating3", "bft_rating4", "bft_skip"],
where=[("bfs_cono", "=", self.opts["conum"]), ("bfs_fmat", "=",
self.fmat), ("bft_type", "=", self.ftyp), ("bfs_league",
"=", "M"), ("bft_date", "=", rnd[1]), ("bft_player", "=",
player), ("bft_fmat=bfs_fmat",), ("bft_team=bfs_code",)],
limit=1)
if not pl:
# Did not play
continue
if not pl[1] and not pl[2] and not pl[3] and not pl[4]:
# Not yet assessed
continue
cnt += 1.0
his += pl[pl[0]]
team = self.sql.getRec("bwlflt", cols=["bft_player",
"bft_rating1","bft_rating2","bft_rating3","bft_rating4"],
where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=",
self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=",
rnd[1]), ("bft_skip", "=", pl[5])])
for tm in team:
tot += tm[pl[0]]
if tot:
return round((tot - his) / 3.0 / cnt, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def getName(self, snam, fnam):
if fnam:
return "%s, %s" % (snam.upper(), fnam.split()[0][0].upper())
else:
return snam.upper()
class gl2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlynd", "genmst", "genbal"],
prog=self.__class__.__name__)
if self.sql.error:
return
per = self.sql.getRec("ctlynd",
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", 0)],
limit=1)
if not per:
showError(
self.opts["mf"].body, "Period Error", """No Period 0!
Please Contact your Software Support and Quote this Message as this is a Serious Error!"""
)
return
self.start = per[self.sql.ctlynd_col.index("cye_start")]
return True
def drawDialog(self):
sel_acc = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
sel_all = {
"stype":
"R",
"tables": ("genbal", "genmst"),
"cols":
(("glo_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description"),
("glo_trdt", "", 0, "Date"), ("glo_cyr", "", 0, "Balance")),
"where": [("glo_cono", "=", self.opts["conum"]),
("glm_cono=glo_cono", ), ("glm_acno=glo_acno", ),
("glo_trdt", "=", self.start)]
}
fld = ((("C", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N",
self.doAcc, sel_acc, None, None), (("C", 0, 0, 1), "ONA", 30,
"Description"),
(("C", 0, 0, 2), "ISD", 13.2, "Balance", "Balance Value", "",
"N", self.doBal, None, None, None))
but = (("Import File", None, self.doImport, 0, ("C", 0, 1), ("C", 0,
2),
"Import Opening Balances from a CSV or XLS File."),
("All Entries", sel_all, None, 1, ("C", 0, 1), None,
"Display All Existing Balances"),
("Exit", None, self.exitData, 1, ("C", 0, 1), ("C", 0, 2)))
row = (20, )
self.df = TartanDialog(self.opts["mf"],
rows=row,
eflds=fld,
cend=((self.endData, "y"), ),
cxit=(self.exitData, ),
butt=but)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
impcol = [["Account Number", 0, "UI", 7],
["Opening Balance", 1, "SD", 13.2]]
fi = FileImport(self.opts["mf"], impcol=impcol)
err = None
for num, line in enumerate(fi.impdat):
if len(line) != 2:
err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \
(num + 1, 2, len(line))
break
self.acc = line[0]
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc)],
limit=1)
if not chk:
err = "Line %s: Invalid Account %s" % ((num + 1), self.acc)
break
self.bal = line[1]
self.old = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)],
limit=1)
if not self.old:
self.new_acc = "y"
else:
self.new_acc = "n"
self.endData(det=True)
if err:
showError(self.opts["mf"].body, "Import Error", err)
elif fi.impdat:
self.opts["mf"].dbm.commitDbase()
self.df.enableButtonsTags(state=state)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doAcc(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not desc:
return "Invalid Account Number"
self.acc = w
self.df.loadEntry(frt, pag, p + 1, data=desc[0])
self.old = self.sql.getRec("genbal",
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)],
limit=1)
if not self.old:
self.new_acc = "y"
else:
self.new_acc = "n"
bal = self.old[self.sql.genbal_col.index("glo_cyr")]
self.df.loadEntry(frt, pag, p + 2, data=bal)
def doBal(self, frt, pag, r, c, p, i, w):
self.bal = w
def endData(self, det=False):
data = [self.opts["conum"], self.acc, self.start, self.bal]
if self.new_acc == "y":
self.sql.insRec("genbal", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genbal_col
data.append(self.old[col.index("glo_xflag")])
self.sql.updRec("genbal",
data=data,
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)])
if det:
return
self.opts["mf"].dbm.commitDbase()
nxt = self.sql.getRec("genmst",
cols=["glm_acno"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", ">", self.acc)],
limit=1)
if nxt:
self.df.colf[0][0][5] = nxt[0]
else:
self.df.colf[0][0][5] = 0
self.df.advanceLine(0)
def exitData(self):
bals = self.sql.getRec("genbal",
cols=["sum(glo_cyr)"],
where=[("glo_cono", "=", self.opts["conum"]),
("glo_trdt", "=", self.start)],
limit=1)
if bals[0]:
diff = CCD(bals[0], "SD", 13.2)
showError(self.opts["mf"].body, "Out of Balance",
"Opening Balances Do Not Balance by %s" % diff.disp)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
else:
showInfo(
self.opts["mf"].body, "Year End",
"""A Year End for the Previous Period Must be Executed to Include These Opening Balances.
If the Current Period is 1 then the Year End for Period 0 must be Executed.""")
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rc3060(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.own, self.prm, self.acc, self.datew, self.dated, \
self.repprt, self.repeml = self.opts["args"]
self.emadd = self.repeml[2]
self.tname = self.stpl
self.zeros = "Y"
self.minus = "Y"
self.mesno = 0
whr = [("rtn_cono", "=", self.opts["conum"]),
("rtn_owner", "=", self.own),
("rtn_code", "=", self.prm),
("rtn_acno", "=", self.acc)]
rtn = self.sql.getRec("rcatnm", where=whr, limit=1)
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
self.doProcess(rtn)
if self.form.page and (self.repeml[1] == "N" or self.emadd):
self.repeml[2] = self.emadd
self.doPrint()
else:
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlpwu", "ctlmes", "ctlmst", "rcatnm", "rcatnt", "rcaprm",
"rcacon", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rcactl = gc.getCtl("rcactl", self.opts["conum"])
if not rcactl:
return
self.stpl = rcactl["cte_tpltnt"]
usr = self.sql.getRec("ctlpwu",
cols=["usr_emadd"],
where=[("usr_name", "=", self.opts["capnm"])],
limit=1)
if usr[0]:
self.fromad = usr[0]
else:
self.fromad = rcactl["cte_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "S"), ("tpm_system", "=", "RCA"),
("tpm_sttp", "=", "T")],
"order":
"tpm_tname"
}
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details")),
"where": [("mss_system", "=", "RCA")]
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.stpl, "Y",
self.doTplNam, tpm, None, None),
(("T", 0, 1,
0), ("IRB", r1s), 0, "Whole File", "", "Y", "Y", self.doWhole,
None, None, None), (("T", 0, 2, 0), ("IRB", r1s), 0,
"Zero Balances", "Include Zero Balances",
"N", "Y", self.doZeros, None, None, None),
(("T", 0, 3, 0), ("IRB", r1s), 0, "Minus Balances",
"Include Minus Balances", "N", "Y", self.doMinus, None, None,
None), (("T", 0, 4, 0), "IUI", 3, "Message Number", "", "",
"Y", self.doMessno, mss, None, ("efld", )),
(("T", 0, 5, 0), "ID1", 10, "Statement Date", "", self.sysdtw,
"Y", self.doDat, None, None, ("efld", )))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("B", "Y"))
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "S"),
("tpm_system", "=", "RCA"),
("tpm_sttp", "=", "T")],
limit=1)
if not acc:
return "Invalid Template Name"
self.tname = w
def doWhole(self, frt, pag, r, c, p, i, w):
self.whole = w
def doZeros(self, frt, pag, r, c, p, i, w):
self.zeros = w
def doMinus(self, frt, pag, r, c, p, i, w):
self.minus = w
def doMessno(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "RCA"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Message Number"
self.mesno = w
def doDat(self, frt, pag, r, c, p, i, w):
self.datew = w
self.dated = self.df.t_disp[pag][0][p]
def doEnd(self):
self.df.closeProcess()
self.repprt = self.df.repprt
self.repeml = self.df.repeml
self.emadd = self.df.repeml[2]
if self.whole == "N":
recs = getSingleRecords(
self.opts["mf"],
"rcatnm", ("rtn_owner", "rtn_code", "rtn_acno", "rtn_name"),
where=[("rtn_cono", "=", self.opts["conum"])])
else:
whr = [("rtn_cono", "=", self.opts["conum"])]
odr = "rtn_owner, rtn_code, rtn_acno"
recs = self.sql.getRec("rcatnm", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Error",
"No Accounts Selected")
if recs:
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
for num, rec in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
self.doProcess(rec)
p.closeProgress()
if p.quit or not self.form.page:
pass
elif self.repeml[1] == "N" or self.emadd:
self.df.repeml[2] = self.emadd
self.doPrint()
self.opts["mf"].closeLoop()
def doLoadStatic(self):
cmc = self.sql.ctlmst_col
ctm = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])],
limit=1)
for fld in cmc:
dat = ctm[cmc.index(fld)]
if fld in self.form.tptp:
if fld == "ctm_logo":
self.form.letterhead(cmc, ctm, fld, dat)
continue
self.form.tptp[fld][1] = dat
if "letterhead" in self.form.tptp:
self.form.letterhead(cmc, ctm, "letterhead", None)
self.form.document_date(self.dated)
def doProcess(self, rtn):
tmc = self.sql.rcatnm_col
tdc = self.form.sql.tpldet_col
self.own = rtn[tmc.index("rtn_owner")]
self.prm = rtn[tmc.index("rtn_code")]
self.acc = rtn[tmc.index("rtn_acno")]
eml = rtn[tmc.index("rtn_email")]
acc = self.sql.getRec("rcacon",
cols=["rcc_cnum", "rcc_deposit", "rcc_status"],
where=[("rcc_cono", "=", self.opts["conum"]),
("rcc_owner", "=", self.own),
("rcc_code", "=", self.prm),
("rcc_acno", "=", self.acc)],
order="rcc_cnum")
if acc:
dps, dep, sta = acc[-1:][0]
else:
dps, dep, sta = 0, 0.0, ""
if sta != "C":
dep = 0.0
dos = 0.0
else:
dos = dep
self.tots = [0.0, dep, 0.0, 0.0, 0.0, dep]
tots = self.sql.getRec(
"rcatnt",
cols=["rtu_type", "rtu_mtyp", "round(sum(rtu_tramt), 2)"],
where=[("rtu_cono", "=", self.opts["conum"]),
("rtu_owner", "=", self.own), ("rtu_code", "=", self.prm),
("rtu_acno", "=", self.acc),
("rtu_trdt", "<=", self.datew)],
group="rtu_type, rtu_mtyp")
self.dpp = 0.0
for t in tots:
if t[1] == 1:
self.tots[0] = float(ASD(self.tots[0]) + ASD(t[2]))
self.tots[5] = float(ASD(self.tots[5]) + ASD(t[2]))
elif t[1] == 2:
self.dpp = float(ASD(self.dpp) + ASD(t[2]))
if dep:
dos = float(ASD(dos) + ASD(t[2]))
self.tots[1] = float(ASD(self.tots[1]) + ASD(t[2]))
self.tots[5] = float(ASD(self.tots[5]) + ASD(t[2]))
elif t[1] == 3:
self.tots[2] = float(ASD(self.tots[2]) + ASD(t[2]))
self.tots[5] = float(ASD(self.tots[5]) + ASD(t[2]))
elif t[1] in (4, 5):
self.tots[3] = float(ASD(self.tots[3]) + ASD(t[2]))
self.tots[5] = float(ASD(self.tots[5]) + ASD(t[2]))
else:
self.tots[4] = float(ASD(self.tots[4]) + ASD(t[2]))
self.tots[5] = float(ASD(self.tots[5]) + ASD(t[2]))
if not dos and not tots:
return
if self.zeros == "N" and not dos and not self.tots[5]:
return
if self.minus == "N" and not dos and self.tots[5] < 0:
return
prc = self.sql.rcaprm_col
prm = self.sql.getRec("rcaprm",
where=[("rcp_cono", "=", self.opts["conum"]),
("rcp_owner", "=", self.own),
("rcp_code", "=", self.prm)],
limit=1)
ttc = [
"rtu_trdt", "rtu_refno", "rtu_type", "rtu_desc", "rtu_cnum",
"rtu_mtyp", "balance"
]
rtt = self.sql.getRec("rcatnt", cols=["rtu_trdt",
"rtu_refno", "rtu_type", "rtu_desc", "rtu_cnum", "rtu_mtyp",
"round(sum(rtu_tramt), 2)"], where=[("rtu_cono", "=",
self.opts["conum"]), ("rtu_owner", "=", self.own), ("rtu_code",
"=", self.prm), ("rtu_acno", "=", self.acc), ("rtu_type", "<>", 5),
("rtu_trdt", "<=", self.datew)], group="rtu_trdt, rtu_refno, "\
"rtu_type, rtu_desc, rtu_cnum, rtu_mtyp", order="rtu_trdt, "\
"rtu_cnum, rtu_refno")
if not rtt:
rtt = []
if dos > 0:
rtt.append(
[self.datew, "Deposit", 4, "Outstanding Deposit", dps, 2, dos])
elif dos < 0:
rtt.append(
[self.datew, "Deposit", 4, "Overpaid Deposit", dps, 2, dos])
nad = rtn[tmc.index("rtn_name")]
if rtn[tmc.index("rtn_addr1")]:
nad = "%s\n%s" % (nad, rtn[tmc.index("rtn_addr1")])
if rtn[tmc.index("rtn_addr2")]:
nad = "%s\n%s" % (nad, rtn[tmc.index("rtn_addr2")])
if rtn[tmc.index("rtn_addr3")]:
nad = "%s\n%s" % (nad, rtn[tmc.index("rtn_addr3")])
if rtn[tmc.index("rtn_pcode")]:
nad = "%s\n%s" % (nad, rtn[tmc.index("rtn_pcode")])
elif prm[prc.index("rcp_addr1")]:
nad = "%s\n%s" % (nad, prm[prc.index("rcp_addr1")])
if prm[prc.index("rcp_addr2")]:
nad = "%s\n%s" % (nad, prm[prc.index("rcp_addr2")])
if prm[prc.index("rcp_addr3")]:
nad = "%s\n%s" % (nad, prm[prc.index("rcp_addr3")])
if prm[prc.index("rcp_pcode")]:
nad = "%s\n%s" % (nad, prm[prc.index("rcp_pcode")])
else:
nad = "%s\n\n\n\n" % nad
self.form.newdic["account_details_C00"][tdc.index("tpd_text")] = nad
for col in tmc:
d = "%s_C00" % col
if d in self.form.newkey:
dat = rtn[tmc.index(col)]
self.form.newdic[d][tdc.index("tpd_text")] = dat
for col in prc:
d = "%s_C00" % col
if d in self.form.newkey:
dat = prm[prc.index(col)]
self.form.newdic[d][tdc.index("tpd_text")] = dat
if len(rtt) <= self.form.maxlines:
self.doBody(ttc, rtt, tdc)
else:
bal = 0
lines = len(rtt) - self.form.maxlines + 1
for _ in range(lines):
trn = rtt.pop(0)
if trn[ttc.index("rtu_mtyp")] == 2:
continue
bal = float(ASD(bal) + ASD(trn[ttc.index("balance")]))
trn[ttc.index("rtu_refno")] = "B/FWD"
trn[ttc.index("rtu_type")] = 4
trn[ttc.index("rtu_desc")] = "Balance Brought Forward"
trn[ttc.index("balance")] = bal
rtt.insert(0, trn)
self.doBody(ttc, rtt, tdc)
self.doTotal(tdc)
self.doTail(tdc)
if self.repeml[1] == "Y" and not self.emadd:
self.repeml[2] = eml
self.doPrint()
def doPrint(self):
if self.repeml[1] == "Y" and not self.emadd:
key = "%s_%s_%s_%s" % (self.opts["conum"], self.own, self.prm,
self.acc)
else:
key = "%s_all_all_all" % self.opts["conum"]
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
key,
ext="pdf")
self.form.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header="%s Statement at %s" %
(self.opts["conam"], self.dated),
fromad=self.fromad,
repprt=self.repprt,
repeml=self.repeml)
if self.repeml[1] == "Y":
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
def doBody(self, ttc, rtt, tdc):
page = 0
count = 0
rbal = 0
text = tdc.index("tpd_text")
for trans in rtt:
if not count:
page += 1
count = self.doHeader(page)
if count == self.form.maxlines:
page = self.doCfwd(page)
count = self.doHeader(page)
for cod in self.form.body:
if cod == "type_code":
c = "rtu_type"
elif cod == "mvtype_code":
c = "rtu_mtyp"
elif cod == "line_paid":
c = "paid"
elif cod == "line_balance":
c = "balance"
else:
c = cod
d = "%s_C%02i" % (cod, count)
if cod == "type_code":
ttyp = trans[ttc.index(c)]
self.form.newdic[d][text] = rctrtp[ttyp - 1][0]
elif cod == "mvtype_code":
ttyp = trans[ttc.index(c)]
self.form.newdic[d][text] = rcmvtp[ttyp - 1][0]
elif cod == "running_balance":
self.form.newdic[d][text] = rbal
else:
self.form.newdic[d][text] = trans[ttc.index(c)]
if cod == "line_balance":
mtp = trans[ttc.index("rtu_mtyp")]
if trans[ttc.index("rtu_desc")]:
dsc = trans[ttc.index("rtu_desc")].split()[0]
else:
dsc = ""
if mtp == 2 and dsc not in ("Outstanding", "Overpaid"):
pass
else:
rbal = float(ASD(rbal) + ASD(trans[ttc.index(c)]))
self.form.doDrawDetail(self.form.newdic[d])
count += 1
for x in range(count, self.form.maxlines):
for cod in self.form.body:
d = "%s_C%02i" % (cod, x)
self.form.newdic[d][tdc.index("tpd_text")] = "BLANK"
self.form.doDrawDetail(self.form.newdic[d])
def doHeader(self, page):
self.form.add_page()
tdc = self.form.sql.tpldet_col
for key in self.form.newkey:
nl = copyList(self.form.newdic[key])
if nl[tdc.index("tpd_place")] != "A":
continue
if nl[tdc.index("tpd_detseq")] == "rtn_acno_C00":
nl[tdc.index("tpd_text")] = self.acc
self.form.doDrawDetail(nl)
return 0
def doCfwd(self, page):
if "carried_forward" in self.form.tptp:
tdc = self.form.sql.tpldet_col
line = copyList(self.form.cfwd)
line[tdc.index("tpd_text")] = "Continued on Page %i" % (page + 1)
self.form.doDrawDetail(line)
return page + 1
def doTotal(self, tdc):
for c in self.form.total:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
if c == "total_rental":
line[tdc.index("tpd_text")] = self.tots[0]
elif c == "total_receipts":
line[tdc.index("tpd_text")] = self.tots[1]
elif c == "total_payments":
line[tdc.index("tpd_text")] = self.tots[2]
elif c == "total_journals":
line[tdc.index("tpd_text")] = self.tots[3]
elif c == "total_deposit":
line[tdc.index("tpd_text")] = self.tots[4]
elif c == "total_balance":
line[tdc.index("tpd_text")] = self.tots[5]
self.form.doDrawDetail(line)
def doTail(self, tdc):
for c in self.form.tail:
if c == "message" and not self.mesno:
continue
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
if c == "deposit":
dep = float(ASD(0) - ASD(self.dpp))
self.form.newdic[d][tdc.index("tpd_text")] = dep
elif d == "message_C00" and self.mesno:
mes = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "STA"),
("mss_message", "=",
self.mesno)],
limit=1)
self.form.newdic[d][tdc.index("tpd_text")] = mes[0]
self.form.doDrawDetail(self.form.newdic[d])
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
