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()