def doEnd(self): self.df.closeProcess() col = ["btb_surname", "btb_names", "btb_mail", "btb_cell"] whr = [ ("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod), ("btb_cono=bce_cono",), ("btb_tab=bce_scod",), ("(", "btb_mail", "=", "", "or", "btb_cell", "=", "", ")")] recs = self.sql.getRec(tables=["bwlent", "bwltab"], cols=col, where=whr, order="btb_surname") if recs: fpdf = MyFpdf(name=self.__class__.__name__, head=90, foot=False) for num, rec in enumerate(recs): if not num % 5: fpdf.add_page() fpdf.drawText("Contact Details", h=12, align="C", font=["courier", "B", 24], border="TLRB", fill=1) fpdf.drawText("Name", w=50, h=10, fill=1, ln=0, font=["courier", "B", 18], border="TLRB") if rec[1]: nam = "%s, %s" % (rec[0].upper(), rec[1].split()[0].upper()) else: nam = rec[0].upper() fpdf.drawText(nam, h=10, border="TLRB") fpdf.drawText("Email", w=50, h=10, border="TLRB", fill=1, ln=0) fpdf.drawText(rec[2], h=10, border="TLRB") fpdf.drawText("Phone", w=50, h=10, border="TLRB", fill=1, ln=0) fpdf.drawText(rec[3], h=10, border="TLRB") fpdf.drawText() fpdf.drawText() fpdf.drawText() pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, self.opts["conum"], ext="pdf") fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], pdfnam=pdfnam, repprt=self.df.repprt) self.opts["mf"].closeLoop()
class gl3040(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): if "args" in self.opts and "noprint" not in self.opts["args"]: self.opebal = "N" self.incope = "Y" self.start = self.s_per self.end, self.zerbal, self.repprt, self.repeml, self.fpdf = \ self.opts["args"] self.doEnd() elif "wait" in self.opts: self.mainProcess() self.df.mstFrame.wait_window() else: self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["genbal", "genmst", "gentrn"], prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() 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.head1 = ("%03u %-30s" % (self.opts["conum"], self.opts["conam"])) self.colsh = ["Acc-Num", "T", "Description", "Debit", "Credit"] self.forms = [("UI", 7), ("UA", 1), ("NA", 40)] + [("SD", 14.2)] * 2 self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) self.dtot = 0.00 self.ctot = 0.00 self.gp = 0.00 return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "General Ledger Trial Balance (%s)" % self.__class__.__name__) r1s = (("Yes", "Y"), ("No", "N")) if "args" in self.opts and "noprint" in self.opts["args"]: var = self.opts["args"]["work"][0] view = None mail = None else: var = ["N", "Y", "", "", "Y"] view = ("Y", "V") mail = ("Y", "N") fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Opening Balances Only", "", var[0], "Y", self.doOpeBal1, None, None, None), (("T", 0, 1, 0), ("IRB", r1s), 0, "Include Opening Balances", "", var[1], "N", self.doOpeBal2, None, None, None), (("T", 0, 2, 0), "Id2", 7, "Starting Period", "", self.s_per, "N", self.doStartPer, None, None, ("efld", )), (("T", 0, 3, 0), "Id2", 7, "Ending Period", "", self.e_per, "N", self.doEndPer, None, None, ("efld", )), (("T", 0, 4, 0), ("IRB", r1s), 0, "Ignore Zero Balances", "", var[4], "N", self.doZerBal, 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 doOpeBal1(self, frt, pag, r, c, p, i, w): self.opebal = w if self.opebal == "Y": self.start = None self.end = None self.incope = None return "sk3" def doOpeBal2(self, frt, pag, r, c, p, i, w): self.incope = w if self.incope == "Y": self.start = self.s_per self.df.loadEntry("T", 0, 2, data=self.start) return "sk1" def doStartPer(self, frt, pag, r, c, p, i, w): if w < self.s_per or w > self.e_per: return "Invalid Period, Outside Financial Period" self.start = w def doEndPer(self, frt, pag, r, c, p, i, w): if w < self.start: return "Invalid Period, Before Start Period" if w > self.e_per: return "Invalid Period, Outside Financial Period" self.end = w def doZerBal(self, frt, pag, r, c, p, i, w): self.zerbal = w def doEnd(self): if "args" not in self.opts or "noprint" in self.opts["args"]: self.repprt = self.df.repprt self.repeml = self.df.repeml self.t_work = [self.df.t_work[0][0]] self.df.closeProcess() recs = self.sql.getRec("genmst", cols=["glm_acno", "glm_desc", "glm_type"], where=[("glm_cono", "=", self.opts["conum"])], order="glm_type desc, glm_acno") if not recs: showError(self.opts["mf"].body, "Selection Error", "No Accounts") elif self.repprt[2] == "export": self.exportReport(recs) else: self.printReport(recs) if "args" not in self.opts or "noprint" in self.opts["args"]: 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 = [self.head1 + " %s" % self.sysdttm] if self.opebal == "Y": date = CCD(self.opts["period"][1][0], "D1", 10) expheads.append("General Ledger Opening Balances as at %s" % \ date.disp) else: sdate = CCD(self.start, "D2", 7) edate = CCD(self.end, "D2", 7) expheads.append("General Ledger Trial Balance for Period %s "\ "to %s" % (sdate.disp, edate.disp)) expheads.append("(Options: Opening Balances Included %s)" % \ self.incope) expcolsh = [self.colsh] 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 self.expdatas.append([ "BODY", [ vals[0].work, vals[1].work, vals[2].work, vals[3].work, vals[4].work ] ]) p.closeProgress() self.grandTotal() doWriteExport(xtype=self.repprt[1], name=expnam, heads=expheads, colsh=expcolsh, forms=expforms, datas=self.expdatas, rcdic=self.opts["mf"].rcdic) def printReport(self, recs): chrs = len(self.colsh) for f in self.forms: chrs += int(f[1]) if f[0][0].lower() == "s": chrs -= 2 else: chrs -= 1 if self.opebal == "Y": date = CCD(self.opts["period"][1][0], "D1", 10.0) self.head2 = "General Ledger Opening Balances as at %s%s" % \ (date.disp, "%s%s") else: sdate = CCD(self.start, "D2", 7) edate = CCD(self.end, "D2", 7) self.head2 = "General Ledger Trial Balance for Period %s to %s" % \ (sdate.disp, edate.disp) p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) if "args" not in self.opts or "noprint" in self.opts["args"]: self.fpdf = MyFpdf(name=self.__class__.__name__, head=80) self.pglin = 999 for num, rec in enumerate(recs): p.displayProgress(num) if p.quit: break vals = self.getValues(rec) if not vals: continue if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText("%s %1s %-40s %s %s" % (vals[0].disp, vals[1].disp, vals[2].disp, vals[3].disp, vals[4].disp)) self.pglin += 1 p.closeProgress() if self.fpdf.page and not p.quit: self.grandTotal() if "args" not in self.opts: 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, repeml=self.repeml) def getValues(self, data): acno = CCD(data[0], "UI", 7) desc = CCD(data[1], "NA", 40) atyp = CCD(data[2], "UA", 1) bal = 0.0 if self.opebal == "Y" or self.incope == "Y": o = self.sql.getRec("genbal", cols=["glo_cyr"], where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", acno.work), ("glo_trdt", "=", self.opts["period"][1][0])], limit=1) if o: b = CCD(o[0], "SD", 14.2) else: b = CCD(0, "SD", 14.2) bal = float(ASD(bal) + ASD(b.work)) if self.opebal == "N" and self.incope == "Y": o = self.sql.getRec("gentrn", cols=["round(sum(glt_tramt),2)"], where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", acno.work), ("glt_curdt", ">", self.s_per), ("glt_curdt", "<", self.start)], limit=1) if o and o[0]: b = CCD(float(o[0]), "SD", 14.2) else: b = CCD(0, "SD", 14.2) bal = float(ASD(bal) + ASD(b.work)) if self.opebal == "N": o = self.sql.getRec("gentrn", cols=["round(sum(glt_tramt),2)"], where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", acno.work), ("glt_curdt", "between", self.start, self.end)], limit=1) if o and o[0]: b = CCD(float(o[0]), "SD", 14.2) else: b = CCD(0, "SD", 14.2) bal = float(ASD(bal) + ASD(b.work)) if bal == 0 and self.zerbal == "Y": return if bal < 0: cr = CCD(bal, "SD", 14.2) dr = CCD(0.00, "SD", 14.2) else: dr = CCD(bal, "SD", 14.2) cr = CCD(0.00, "SD", 14.2) self.dtot = float(ASD(self.dtot) + ASD(dr.work)) self.ctot = float(ASD(self.ctot) + ASD(cr.work)) if atyp.work == "P": self.gp = float(ASD(self.gp) + ASD(dr.work) + ASD(cr.work)) return (acno, atyp, desc, dr, cr) 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) if self.opebal == "N": self.fpdf.drawText() self.fpdf.drawText("(Options: Opening Balances Included %s)" % \ (self.incope)) self.fpdf.drawText() self.fpdf.drawText("%-7s %-1s %-40s %14s %14s" % \ ("Acc-Num", "T", "Description", "Debit ", "Credit ")) self.fpdf.underLine() self.fpdf.setFont() if self.opebal == "Y": self.pglin = 6 else: self.pglin = 8 def grandTotal(self): if self.repprt[2] == "export": self.expdatas.append(["ULINES"]) self.expdatas.append( ["TOTAL", ["", "", "Grand Totals", self.dtot, self.ctot]]) self.expdatas.append(["ULINED"]) return d = CCD(self.dtot, "SD", 14.2) c = CCD(self.ctot, "SD", 14.2) self.fpdf.setFont(style="B") if self.fpdf.lpp - self.pglin < 5: self.pageHeading() else: self.fpdf.underLine() self.fpdf.drawText("%9s %-40s %14s %14s" % \ ("", "Grand-Totals", d.disp, c.disp)) self.pglin += 2 if self.pglin > self.fpdf.lpp: self.pageHeading() gp = CCD(self.gp, "SD", 14.2) if gp.work > 0: self.fpdf.drawText() self.fpdf.drawText("%9s %-40s %14s %14s" % \ ("", "Gross-Loss", gp.disp, "")) else: self.fpdf.drawText() self.fpdf.drawText("%9s %-40s %14s %14s" % \ ("", "Gross-Profit", "", gp.disp)) self.pglin += 2 diff = CCD(float(ASD(d.work) + ASD(c.work)), "SD", 14.2) if diff.work: if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText() self.fpdf.drawText("%9s %-40s %14s %14s" % \ ("", "Difference", "", diff.disp)) self.fpdf.setFont() def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): if "wait" not in self.opts: self.opts["mf"].closeLoop()
class si3010(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, ["ctlrep", "drsmst", "slsiv1", "slsiv2"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) slsctl = gc.getCtl("slsctl", self.opts["conum"]) if not slsctl: return self.fromad = slsctl["ctv_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.slstot = [0, 0, 0, 0] self.tot2 = 0 self.tot3 = 0 self.tot4 = 0 return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Sales Orders Outstanding (%s)" % self.__class__.__name__) si1 = { "stype": "R", "tables": ("slsiv1", ), "cols": (("si1_docno", "", 0, "Order-Num"), ("si1_chain", "", 0, "Chn"), ("si1_acno", "", 0, "Drs-Acc"), ("si1_date", "", 0, "Order-Date")), "where": [("si1_cono", "=", self.opts["conum"]), ("si1_invno", "=", "")], "whera": [("T", "si1_rtn", 0)] } r1s = (("Sales", "O"), ("Works", "W"), ("Quotes", "Q")) r2s = (("List", "L"), ("Detail", "D")) r3s = (("Rep's Name", "R"), ("Delivery Address", "D")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Order Type", "", "O", "Y", self.doOrdTyp, None, None, None), (("T", 0, 1, 0), ("IRB", r2s), 0, "Report Type", "", "L", "Y", self.doRepTyp, None, None, None), (("T", 0, 2, 0), ("IRB", r3s), 0, "Content", "", "R", "Y", self.doContent, None, None, None), (("T", 0, 3, 0), "IUI", 9, "From Order Number", "", "", "Y", self.doOrd1, si1, None, None), (("T", 0, 4, 0), "IUI", 9, "To Order Number", "", "", "Y", self.doOrd2, si1, 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 doOrdTyp(self, frt, pag, r, c, p, i, w): self.otype = w def doRepTyp(self, frt, pag, r, c, p, i, w): self.rtype = w if self.rtype == "L": self.ord1 = 0 self.ord2 = 999999999 self.df.setWidget(self.df.topEntry[0][5][3][0], state="show") self.df.setWidget(self.df.topEntry[0][5][4][0], state="show") else: self.df.loadEntry(frt, pag, p + 1, data="") self.df.setWidget(self.df.topEntry[0][5][3][0], state="hide") self.df.setWidget(self.df.topEntry[0][5][4][0], state="hide") return "sk1" def doContent(self, frt, pag, r, c, p, i, w): self.content = w return "sk2" def doOrd1(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("slsiv1", where=[("si1_cono", "=", self.opts["conum"]), ("si1_rtn", "=", self.otype), ("si1_docno", "=", w), ("si1_invno", "=", "")], limit=1) if not acc: return "This is Not an Outstanding Order" self.ord1 = w def doOrd2(self, frt, pag, r, c, p, i, w): if w: if w < self.ord1: return "Invalid Last Order < First Order" acc = self.sql.getRec("slsiv1", where=[("si1_cono", "=", self.opts["conum"]), ("si1_rtn", "=", self.otype), ("si1_docno", "=", w), ("si1_invno", "=", "")], limit=1) if not acc: return "This is Not an Outstanding Order" self.ord2 = w else: self.ord2 = 999999999 def doEnd(self): self.df.closeProcess() whr = (("si1_cono", "=", self.opts["conum"]), ("si1_rtn", "=", self.otype), ("si1_docno", "between", self.ord1, self.ord2), ("si1_invno", "=", "")) odr = "si1_docno" recs = self.sql.getRec("slsiv1", where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Selection Error", "No Orders 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("Outstanding Sales Orders Report as at %s" % \ self.sysdtd) self.expcolsh = [[ "Order-Num", "Order-Date", "Chn", "Acc-Num", "Name", "Rep", "Rep-Name", "Job-Num", "Taxable", "Non-Taxable", "Total-Tax", "Total-Value" ]] if self.rtype == "L" and self.content == "D": self.expcolsh[0][6] = "Delivery-Address" self.expforms = [("Na", 9), ("D1", 10), ("UI", 3), ("NA", 7), ("NA", 30), ("Na", 3), ("NA", 30), ("Na", 7), ("SD", 13.2), ("SD", 13.2), ("SD", 13.2), ("SD", 13.2)] self.expdatas = [] for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: p.closeProgress() return if not self.getValues(dat): continue self.getOrdTot() self.expdatas.append([ "BODY", [ self.odr.work, self.dte.work, self.chn.work, self.drs.work, self.drsnam, self.rep.work, self.context, self.job.work, self.total_taxable, self.total_nontaxable, self.total_tax, self.total_value ] ]) self.expdatas.append(["BLANK"]) self.expdatas.append(["TOTAL", [""] * 8 + self.slstot]) p.closeProgress() 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.rtype == "L": self.head = "%03u %-157s" % (self.opts["conum"], self.opts["conam"]) else: self.head = "%03u %-86s" % (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 if not self.getValues(dat): continue if self.rtype == "D": self.printHeader() self.printBody() if self.rtype == "L": t1 = CCD(self.slstot[0], "SD", 13.2) t2 = CCD(self.slstot[1], "SD", 13.2) t3 = CCD(self.slstot[2], "SD", 13.2) t4 = CCD(self.slstot[3], "SD", 13.2) self.fpdf.drawText() self.fpdf.drawText("%106s %s %s %s %s" % ("", t1.disp, t2.disp, t3.disp, t4.disp)) p.closeProgress() if 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, data): col = self.sql.slsiv1_col self.odr = CCD(data[col.index("si1_docno")], "Na", 9) self.si2 = self.sql.getRec("slsiv2", where=[("si2_cono", "=", self.opts["conum"]), ("si2_rtn", "=", self.otype), ("si2_docno", "=", self.odr.work)], order="si2_line") if not self.si2: return self.mod = CCD(data[col.index("si1_mode")], "UA", 1) self.chn = CCD(data[col.index("si1_chain")], "UI", 3) self.drs = CCD(data[col.index("si1_acno")], "NA", 7) acc = self.sql.getRec("drsmst", cols=["drm_name"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chn.work), ("drm_acno", "=", self.drs.work)], limit=1) if not acc: self.drsnam = "" else: self.drsnam = acc[0] self.dte = CCD(data[col.index("si1_date")], "D1", 10) self.job = CCD(data[col.index("si1_jobno")], "Na", 7) self.rep = CCD(data[col.index("si1_rep")], "Na", 3) if self.rtype == "L" and self.content == "R": acc = self.sql.getRec("ctlrep", cols=["rep_name"], where=[("rep_cono", "=", self.opts["conum"]), ("rep_code", "=", self.rep.work)], limit=1) if not acc: self.context = "" else: self.context = acc[0] else: self.context = data[col.index("si1_add1")] return True def printHeader(self): self.pageHeading() self.fpdf.setFont(style="B") self.fpdf.drawText() if self.rtype == "L": if self.content == "R": text = "Rep-Name" else: text = "Delivery-Address" self.fpdf.drawText("%-9s %-10s %-3s %-7s %-30s %-3s %-30s %-7s"\ "%13s %13s %13s %13s" % ("Order-Num", "Order-Date", "Chn", "Acc-Num", "Name", "Rep", text, "Job-Num", "Taxable", "Non-Taxable", "Total-Tax", "Total-Value")) self.pglin += 3 else: text = "Order Number: %-9s Date: %-10s Salesman: %-3s %-30s" % \ (self.odr.disp, self.dte.disp, self.rep.disp, self.context) self.fpdf.drawText(text) self.fpdf.drawText() text = "Chain: %-3s Acc-Num: %-7s Name: %-30s" % ( self.chn.disp, self.drs.disp, self.drsnam) self.fpdf.drawText(text) self.fpdf.drawText() self.fpdf.drawText("%-3s %-20s %-30s %-1s %10s %-1s %11s %-6s" % \ ("Grp", "Product-Code", "Description", "L", "Qty-Ord", "V", "U-Price", "Disc-%")) self.pglin += 7 self.fpdf.underLine(txt=self.head) self.fpdf.setFont() def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() if self.otype == "O": txt = "Sales" elif self.otype == "W": txt = "Works" else: txt = "Quote" self.fpdf.drawText("%-37s %-10s" % \ ("Outstanding %s Documents Report as at" % txt, self.sysdtd)) self.fpdf.setFont() self.pglin = 3 def printBody(self): if self.rtype == "L": if self.pglin > self.fpdf.lpp: self.printHeader() self.getOrdTot() v1 = CCD(self.total_taxable, "SD", 13.2) v2 = CCD(self.total_nontaxable, "SD", 13.2) v3 = CCD(self.total_tax, "SD", 13.2) v4 = CCD(self.total_value, "SD", 13.2) text = "%s %s %s %s %-30s %s %-30s %s %s %s %s %s" % \ (self.odr.disp, self.dte.disp, self.chn.disp, self.drs.disp, self.drsnam, self.rep.disp, self.context, self.job.disp, v1.disp, v2.disp, v3.disp, v4.disp) self.fpdf.drawText(text) self.pglin += 1 else: col = self.sql.slsiv2_col for dat in self.si2: grp = CCD(dat[col.index("si2_group")], "UA", 3) cod = CCD(dat[col.index("si2_code")], "NA", 20) des = CCD(dat[col.index("si2_desc")], "NA", 30) loc = CCD(dat[col.index("si2_loc")], "UA", 1) qty = CCD(dat[col.index("si2_qty")], "SD", 11.2) vat = CCD(dat[col.index("si2_vat_code")], "UA", 1) prc = CCD(dat[col.index("si2_price")], "UD", 11.2) dis = CCD(dat[col.index("si2_disc_per")], "UD", 6.2) if self.pglin > self.fpdf.lpp: self.printHeader() self.fpdf.drawText("%s %s %s %s %s %s %s %s" % (grp.disp, cod.disp, des.disp, loc.disp, qty.disp, vat.disp, prc.disp, dis.disp)) self.pglin += 1 def getOrdTot(self): self.total_taxable = 0 self.total_nontaxable = 0 self.total_tax = 0 self.total_value = 0 col = self.sql.slsiv2_col for dat in self.si2: dis = CCD(dat[col.index("si2_disc_per")], "UD", 6.2) qty = CCD(dat[col.index("si2_qty")], "SD", 13.2) pri = CCD(dat[col.index("si2_price")], "UD", 12.2) vat = CCD(dat[col.index("si2_vat_rate")], "UD", 6.2) excpri = round((pri.work * 1), 2) incrat = float(ASD(100.0) + ASD(vat.work)) incpri = round((pri.work * incrat / 100.0), 4) net = float(ASD(100.0) - ASD(dis.work)) excamt = round((qty.work * excpri * net / 100.0), 2) incamt = round((qty.work * incpri * net / 100.0), 2) vatamt = float(ASD(incamt) - ASD(excamt)) if excamt == incamt: self.total_nontaxable = float(ASD(self.total_nontaxable) + \ ASD(excamt)) else: self.total_taxable = float(ASD(self.total_taxable) + \ ASD(excamt)) self.total_tax = float(ASD(self.total_tax) + ASD(vatamt)) self.total_value = float(ASD(self.total_value) + ASD(incamt)) self.slstot[0] = float(ASD(self.slstot[0]) + ASD(self.total_taxable)) self.slstot[1] = float( ASD(self.slstot[1]) + ASD(self.total_nontaxable)) self.slstot[2] = float(ASD(self.slstot[2]) + ASD(self.total_tax)) self.slstot[3] = float(ASD(self.slstot[3]) + ASD(self.total_value)) def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class cr3010(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, ["ctlbat", "crstrn"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) crsctl = gc.getCtl("crsctl", self.opts["conum"]) if not crsctl: return self.fromad = crsctl["ctc_emadd"] return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Creditors Batch Error Listing (%s)" % self.__class__.__name__) data = ["All Types"] for typ in crtrtp: data.append(typ[1]) btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"} btm = { "stype": "R", "tables": ("ctlbat", ), "cols": (("btm_batno", "", 0, "Bat-Num"), ("btm_rtyp", ("xx", crtrtp), 20, "Type"), ("btm_curdt", "", 0, "Curr-Dt"), ("btm_multi", "", 0, "M")), "where": [("btm_cono", "=", self.opts["conum"]), ("btm_styp", "=", "CRS"), ("btm_ind", "=", "N")], "whera": [] } fld = ((("T", 0, 0, 0), "IUI", 1, "Type", "Transaction Type", "", "Y", self.doBatTyp, btt, None, None), (("T", 0, 1, 0), "INa", 7, "Batch-Number", "Batch Number", "", "Y", self.doBatNum, btm, 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=("N", "V")) def doBatTyp(self, frt, pag, r, c, p, i, w): if w > len(crtrtp): return "Invalid Batch Type" self.rtyp = w if self.rtyp: self.df.topf[pag][1][8]["whera"] = [["T", "btm_rtyp", 0]] else: self.df.topf[pag][1][8]["whera"] = [] def doBatNum(self, frt, pag, r, c, p, i, w): self.batno = w def doEnd(self): self.df.closeProcess() whr = [("btm_cono", "=", self.opts["conum"]), ("btm_styp", "=", "CRS")] if self.rtyp: whr.append(("btm_rtyp", "=", self.rtyp)) if self.batno: whr.append(("btm_batno", "=", self.batno)) whr.append(("btm_ind", "=", "N")) odr = "btm_rtyp, btm_batno" recs = self.sql.getRec("ctlbat", where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Batch Error", "No Batch Transactions Selected") else: self.printReport(recs) self.closeProcess() def printReport(self, recs): p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) self.head = "%03u %-82s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.btot = [0, 0] self.pgnum = 0 self.pglin = 999 bc = self.sql.ctlbat_col tc = self.sql.crstrn_col for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break self.rtyp = CCD(dat[bc.index("btm_rtyp")], "UI", 1) self.batno = CCD(dat[bc.index("btm_batno")], "Na", 7) self.curdt = CCD(dat[bc.index("btm_curdt")], "D2", 7) self.multi = CCD(dat[bc.index("btm_multi")], "UA", 1) self.trno = CCD(dat[bc.index("btm_trno")], "UI", 7) self.trval = CCD(dat[bc.index("btm_trval")], "SD", 13.2) whr = [("crt_cono", "=", self.opts["conum"]), ("crt_type", "=", self.rtyp.work), ("crt_batch", "=", self.batno.work), ("crt_batind", "=", "N")] odr = "crt_seq" trndat = self.sql.getRec("crstrn", where=whr, order=odr) if not trndat: continue if self.pglin > self.fpdf.lpp: self.pageHeading() else: self.batchHeading() for trn in trndat: acno = CCD(trn[tc.index("crt_acno")], "NA", 7) trdt = CCD(trn[tc.index("crt_trdt")], "D1", 10) ref1 = CCD(trn[tc.index("crt_ref1")], "Na", 9) desc = CCD(trn[tc.index("crt_desc")], "NA", 30) tramt = CCD(trn[tc.index("crt_tramt")], "SD", 13.2) taxamt = CCD(trn[tc.index("crt_taxamt")], "SD", 13.2) if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText("%s %s %s %s %s %s" % (acno.disp, trdt.disp, ref1.disp, desc.disp, tramt.disp, taxamt.disp)) self.btot[0] += 1 self.btot[1] = float(ASD(self.btot[1]) + ASD(tramt.work)) self.pglin += 1 self.batchTotal() 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 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( "%-36s %43s %5s" % ("Creditors Ledger Batch Error Listing", "Page", self.pgnum)) self.fpdf.drawText() self.fpdf.setFont() self.pglin = 4 self.batchHeading() def batchHeading(self): if self.pglin > self.fpdf.lpp - 4: self.pageHeading() return self.fpdf.setFont(style="B") self.fpdf.drawText( "%-s %-s %-s %-17s %-s %-s %-s %s" % ("Batch:", self.batno.disp, "Type:", crtrtp[self.rtyp.work - 1][1], "Current Date:", self.curdt.disp, "Multi Allocations:", self.multi.disp)) self.fpdf.drawText() self.fpdf.drawText("%-7s %-10s %-9s %-30s %-13s %-13s" % ("Acc-Num", " Date", "Reference", "Description", " Trn-Amount", " Tax-Amount")) self.fpdf.underLine(self.head) self.fpdf.setFont() self.pglin += 4 def batchTotal(self): if self.pglin > self.fpdf.lpp - 5: self.pageHeading() self.fpdf.drawText() j = CCD(self.trno.work, "SI", 7) k = CCD(self.trval.work, "SD", 13.2) self.fpdf.drawText("%-39s %-10s %-7s %-10s %-13s" % ("Prelisted", "Quantity", j.disp, "Value", k.disp)) l = CCD(self.btot[0], "SI", 7) m = CCD(self.btot[1], "SD", 13.2) self.fpdf.drawText("%-39s %-10s %-7s %-10s %-13s" % ("Entered", "Quantity", l.disp, "Value", m.disp)) n = CCD((j.work - l.work), "SI", 7) o = CCD(float(ASD(k.work) - ASD(m.work)), "SD", 13.2) self.fpdf.drawText("%-39s %-10s %-7s %-10s %-13s" % ("Difference", "Quantity", n.disp, "Value", o.disp)) self.fpdf.setFont(style="B") self.fpdf.underLine(self.head) self.fpdf.setFont() self.btot[0] = 0 self.btot[1] = 0 self.pglin += 5 def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class gl3020(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, ["ctlmst", "genmst", "gentrn"], prog=self.__class__.__name__) if self.sql.error: return # Check for Multiple Companies coy = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1) if coy[0]: self.multi = "Y" else: self.multi = "N" 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 = [ "TP", "BatchNo", "Coy", "Acc-Num", "Description", "Reference", "Date", "Debits", "Credits", "Tax-Amount", "T", "Remarks" ] self.forms = [("UI", 2, False, False, True), ("Na", 7), ("UI", 3, False, False, True), ("UI", 7, False, False, True), ("NA", 30), ("Na", 9), ("D1", 10), ("SD", 15.2), ("SD", 15.2), ("SD", 15.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(gltrtp) + 1) self.gdr = [0] * (len(gltrtp) + 1) self.gcr = [0] * (len(gltrtp) + 1) self.gvt = [0] * (len(gltrtp) + 1) self.totind = "N" self.other = "N" return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "General Ledger Audit Trail (%s)" % self.__class__.__name__) data = ["All Types"] for typ in gltrtp: data.append(typ[1]) btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"} btm = { "stype": "R", "tables": ("gentrn", ), "cols": (("glt_batch", "", 0, "Bat-Num"), ("glt_type", ("xx", gltrtp), 20, "Type"), ("glt_curdt", "", 0, "Cur-Dat")), "where": [], "group": "glt_batch, glt_type, glt_curdt", "order": "glt_type, glt_curdt, glt_batch" } r1s = (("Financial", "F"), ("Capture", "C")) r2s = (("Yes", "Y"), ("No", "N")) if "args" in self.opts and "noprint" in self.opts["args"]: var = self.opts["args"]["work"][0] view = None mail = None else: var = ["F", "", "", "", "", "", "", "Y"] view = ("Y", "V") mail = ("Y", "N") fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Period Type", "", var[0], "Y", self.doPtyp, None, None, None), (("T", 0, 1, 0), "Id2", 7, "Starting Period", "", self.s_per, "N", self.doStartPer, None, None, ("efld", )), (("T", 0, 2, 0), "Id2", 7, "Ending Period", "", self.e_per, "N", self.doEndPer, None, None, ("efld", )), (("T", 0, 3, 0), "Id1", 10, "Starting Date", "", self.sysdtw, "N", self.doStartDat, None, None, ("efld", )), (("T", 0, 4, 0), "Id1", 10, "Ending Date", "", self.sysdtw, "N", self.doEndDat, None, None, ("efld", )), (("T", 0, 5, 0), "IUI", 1, "Type", "Transaction Type", var[5], "N", self.doBatTyp, btt, None, None), (("T", 0, 6, 0), "INa", 7, "Batch Number", "", var[6], "N", self.doBatNum, btm, None, None), (("T", 0, 7, 0), ("IRB", r2s), 0, "Totals Only", "", var[7], "N", self.doTots, None, None, None)] if self.multi == "Y": fld.append((("T", 0, 8, 0), ("IRB", r2s), 10, "Other Companies", "", "N", "N", self.doCoy, 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 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(gltrtp): return "Invalid Batch Type" self.btyp = w whr = [("glt_cono", "=", self.opts["conum"])] if self.ptyp == "F": whr.append(("glt_curdt", "between", self.sperw, self.eperw)) else: whr.append(("glt_capdt", "between", self.sdatw, self.edatw)) if self.btyp: whr.append(("glt_type", "=", self.btyp)) self.df.topf[pag][i + 1][8]["where"] = 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 "args" in self.opts and "noprint" in self.opts["args"]: return if self.totsonly == "Y": if self.multi == "Y": self.df.setWidget(self.df.topEntry[0][9][3][0], state="hide") self.df.setWidget(self.df.topEntry[0][9][4][0], state="hide") else: 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: if self.multi == "Y": self.df.setWidget(self.df.topEntry[0][9][3][0], state="show") self.df.setWidget(self.df.topEntry[0][9][4][0], state="show") 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 doCoy(self, frt, pag, r, c, p, i, w): self.other = w def doEnd(self): self.df.closeProcess() jon = "left outer join genmst on glt_cono=glm_cono and "\ "glt_acno=glm_acno" col = [ "glt_cono", "glt_acno", "glt_trdt", "glt_type", "glt_refno", "glt_batch", "glt_tramt", "glt_taxamt", "glt_desc", "glt_taxind", "glm_desc" ] if self.other == "Y": self.doSelCoy() if self.con == "X": self.closeProcess() return whr = [("glt_cono", "in", tuple(self.con))] else: whr = [("glt_cono", "=", self.opts["conum"])] if self.ptyp == "F": whr.append(("glt_curdt", "between", self.sperw, self.eperw)) else: whr.append(("glt_capdt", "between", self.sdatw, self.edatw)) if self.btyp: whr.append(("glt_type", "=", self.btyp)) if self.batch: whr.append(("glt_batch", "=", self.batch)) odr = "glt_type, glt_batch, glt_trdt, glt_refno" recs = self.sql.getRec("gentrn", join=jon, cols=col, where=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) if "args" in self.opts and "noprint" in self.opts["args"]: self.t_work = [self.df.t_work[0][0]] self.closeProcess() def doSelCoy(self): tit = ("Company Selection", ) self.coys = self.sql.getRec("ctlmst", cols=["ctm_cono", "ctm_name"], order="ctm_cono") coy = { "stype": "C", "head": ("Num", "Name"), "typs": (("UI", 3), ("NA", 30)), "data": self.coys, "mode": "M", "comnd": self.doCoyCmd } r1s = (("Yes", "Y"), ("Include", "I"), ("Exclude", "E")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "All Companies", "", "Y", "N", self.doAllCoy, None, None, None, None), (("T", 0, 1, 0), "INA", 30, "Companies", "", "", "N", self.doCoySel, coy, None, None, None)) self.cf = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=((self.doCoyEnd, "y"), ), txit=(self.doCoyExit, )) self.cf.mstFrame.wait_window() def doAllCoy(self, frt, pag, r, c, p, i, w): self.con = w if self.con == "Y": self.con = [] for coy in self.coys: self.con.append(coy[0]) return "nd" elif self.con == "I": self.cf.topf[pag][i + 1][8]["titl"] = "Select Companies to Include" else: self.cf.topf[pag][i + 1][8]["titl"] = "Select Companies to Exclude" def doCoyCmd(self, frt, pag, r, c, p, i, w): c = "" for co in w: if int(co): c = c + str(int(co)) + "," if len(c) > 1: c = c[:-1] self.cf.loadEntry(frt, pag, p, data=c) def doCoySel(self, frt, pag, r, c, p, i, w): if w[-1:] == ",": w = w[:-1] self.coy = w.split(",") def doCoyEnd(self): if self.con == "I": self.con = self.coy elif self.con == "E": self.con = [] for co in self.coys: self.con.append(int(co[0])) for co in self.coy: del self.con[self.con.index(int(co))] self.con.sort() self.doCoyClose() def doCoyExit(self): self.con = "X" self.doCoyClose() def doCoyClose(self): self.cf.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("General 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 cono, acno, trdt, trtp, refno, batch, debit, credit, taxamt, \ detail, taxind, desc = vals line = [ "BODY", [ trtp.work, batch.work, cono.work, acno.work, desc.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 = "%03i %-95s" % (self.opts["conum"], self.opts["conam"]) else: self.head = "%03i %-138s" % (self.opts["conum"], self.opts["conam"]) 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 cono, acno, trdt, trtp, refno, batch, debit, credit, taxamt, \ detail, taxind, desc = 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" % (cono.disp, acno.disp, desc.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() 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, repeml=self.df.repeml) def getValues(self, data): cono = CCD(data[0], "UI", 3) acno = CCD(data[1], "UI", 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", 15.2) credit = CCD(data[6], "SD", 15.2) else: debit = CCD(data[6], "SD", 15.2) credit = CCD(0, "SD", 15.2) taxamt = CCD(data[7], "SD", 15.2) detail = CCD(data[8], "NA", 30) taxind = CCD(data[9], "NA", 1) desc = 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 (cono, acno, trdt, trtp, refno, batch, debit, credit, taxamt, detail, taxind, desc) def pageHeading(self): self.fpdf.add_page() self.fpdf.drawText(self.head, font=["B"]) self.fpdf.drawText() if self.totsonly == "Y": self.fpdf.drawText("%-37s %-7s %-2s %-50s" % ("General Ledger Audit Trail for Period", self.sperd, "to", self.eperd)) else: self.fpdf.drawText("%-37s %-7s %-2s %-94s" % ("General 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 %-15s %-15s %-15s %-15s" % ("Document Type", "Quantity", " Debits", " Credits", " Difference", " V.A.T.")) else: self.fpdf.drawText( "%-34s%-8s %-15s %-15s %-15s %-15s" % ("Document Type", "Quantity", " Debits", " Credits", " Difference", " V.A.T.")) self.fpdf.underLine(self.head) self.pglin += 4 self.fpdf.setFont() def typeHeading(self): if self.fpdf.lpp - self.pglin < 4: self.pageHeading() return if self.totsonly != "Y": batch = self.batch else: batch = "Various" self.fpdf.drawText( "%-7s %7s %-10s %3s" % ("Batch", batch, " Type", gltrtp[self.trtp - 1][1]), font=["B"]) self.fpdf.drawText() if self.totsonly == "Y": self.fpdf.drawText("%-36s %-15s %-15s %-15s %-15s" % ("Details", " Debits", " Credits", " Difference", " V.A.T.")) else: self.fpdf.drawText("%-3s %-7s %-30s %-9s %-10s %-15s %-15s "\ "%-15s %-1s %-30s" % ("Coy", "Acc-Num", "Description", "Reference", " Date", " Debits", " Credits", " Tax-Amount", "T", "Remarks")) self.fpdf.underLine(self.head) self.fpdf.setFont() self.pglin += 4 def batchTotal(self): if self.fpdf.lpp - self.pglin < 3: self.pageHeading() j = CCD(self.bdrs, "SD", 15.2) k = CCD(self.bcrs, "SD", 15.2) l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 15.2) m = CCD(self.bvat, "SD", 15.2) if self.totsonly == "Y": self.fpdf.drawText("%-36s %15s %15s %15s %15s" % ("Batch " + self.batch + " Totals", j.disp, k.disp, l.disp, m.disp)) self.pglin += 1 else: self.fpdf.drawText() self.fpdf.drawText("%-11s %-51s %15s %15s %15s" % (" ", "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): if self.fpdf.lpp - self.pglin < 2: self.pageHeading() j = CCD(self.tdrs, "SD", 15.2) k = CCD(self.tcrs, "SD", 15.2) l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 15.2) m = CCD(self.tvat, "SD", 15.2) if self.totsonly == "Y": self.fpdf.drawText() self.fpdf.drawText("%-36s %15s %15s %15s %15s" % ("Type Totals", j.disp, k.disp, l.disp, m.disp)) self.pglin += 2 else: self.fpdf.drawText("%-11s %-51s %15s %15s %15s" % (" ", "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(gltrtp)): 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(gltrtp): qt = CCD(self.gqt[x], "SI", 8) dr = CCD(self.gdr[x], "SD", 15.2) cr = CCD(self.gcr[x], "SD", 15.2) df = float(ASD(dr.work) + ASD(cr.work)) df = CCD(df, "SD", 15.2) vt = CCD(self.gvt[x], "SD", 15.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", 15.2) cr = CCD(tot[2], "SD", 15.2) df = CCD(tot[3], "SD", 15.2) vt = CCD(tot[4], "SD", 15.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): if "wait" not in self.opts: self.opts["mf"].closeLoop()
class st3120(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, ["strloc", "strgrp", "strmf1", "strmf2"], 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 self.locs = strctl["cts_locs"] self.fromad = strctl["cts_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.head = "%03u %-30s" % (self.opts["conum"], self.opts["conam"]) self.colsh = [ "Grp", "Product-Code", "Description", "U.O.I", "Qty-Balance", "Qty-OnOrder", "Qty-BkOrder", "Qty-ToOrder" ] self.forms = [("UA", 3), ("NA", 20), ("NA", 30), ("NA", 10), ("SD", 12, 2), ("SD", 12.2), ("SD", 12.2), ("SD", 12.2)] self.stot = 0 self.gtot = 0 return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Stock On Hand Report (%s)" % self.__class__.__name__) loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } r1s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "ID1", 10, "Reporting Date", "", self.sysdtw, "Y", self.doDate, None, None, ("efld", )), (("T", 0, 1, 0), "IUA", 1, "Location", "", "", "Y", self.doLoc, loc, None, ("efld", )), (("T", 0, 2, 0), "IUA", 3, "Product Group", "", "", "Y", self.doGrp, grp, None, ("efld", )), (("T", 0, 3, 0), ("IRB", r1s), 0, "Include Zeros", "", "N", "Y", self.doZero, None, None, None, None, "Include Items Which Have a Zero Order Quantity")) 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 doDate(self, frt, pag, r, c, p, i, w): self.repdtw = w self.repdtd = self.df.t_disp[pag][0][0] def doLoc(self, frt, pag, r, c, p, i, w): if not w: self.loc = "" self.locd = "ALL" else: acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not acc: return "Invalid Location" self.loc = w self.locd = acc[0] def doGrp(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.group = w def doZero(self, frt, pag, r, c, p, i, w): self.zero = w def doEnd(self): self.df.closeProcess() whr = [("st1_cono", "=", self.opts["conum"])] if self.group: whr.append(("st1_group", "=", self.group)) whr.append(("st1_type", "<>", "X")) whr.append(("st1_value_ind", "=", "A")) recs = self.sql.getRec( "strmf1", cols=["st1_group", "st1_code", "st1_desc", "st1_uoi"], where=whr, order="st1_group, st1_code") if not recs: showError(self.opts["mf"].body, "Processing Error", "No Records Selected") elif self.df.repprt[2] == "export": self.exportReport(recs) else: self.printReport(recs) self.opts["mf"].closeLoop() 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("Stock to Order Report as at %s" % self.sysdtd) self.expheads.append("(Options: Report Date %s)" % self.repdtd) self.expheads.append("Location %s %s" % (self.loc, self.locd)) 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 self.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 ] ]) p.closeProgress() 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): 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 = "Stock to Order Report as at %s" % self.sysdtd pad = chrs - len(self.head2) self.head2 = self.head2 + (" " * pad) p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) 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: break vals = self.getValues(dat) if not vals: continue if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText( "%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)) self.pglin += 1 p.closeProgress() if self.fpdf.page and not p.quit: if self.pglin > (self.fpdf.lpp - 2): self.pageHeading() 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) self.closeProcess() def getValues(self, data): grp = CCD(data[0], "UA", 3) code = CCD(data[1], "NA", 20) desc = CCD(data[2], "UA", 30) uoi = CCD(data[3], "NA", 10) whr = [("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", grp.work), ("st2_code", "=", code.work)] if self.loc: whr.append(("st2_loc", "=", self.loc)) st2 = self.sql.getRec( "strmf2", cols=["st2_reord_ind", "st2_reord_level", "st2_reord_qty"], where=whr, limit=1) if not st2: return if self.zero == "N" and not st2[1]: return req = CCD(st2[1], "SD", 12.2) bals = Balances(self.opts["mf"], "STR", self.opts["conum"], int(self.repdtw / 100), keys=(grp.work, code.work, self.loc)) cbal, obal, bbal = bals.doStrOrds() tbal = float(ASD(cbal.work) + ASD(obal.work) - ASD(bbal.work)) if req.work < tbal: if self.zero == "N": return tbal = CCD(0, "SD", 12.2) return (grp, code, desc, uoi, cbal, obal, bbal, tbal) tbal = float(ASD(req.work) - ASD(tbal)) if tbal < st2[2]: tbal = st2[2] tbal = CCD(tbal, "SD", 12.2) if self.zero == "N" and not tbal.work: return if self.zero == "Y" and not cbal.work and not obal.work and not \ bbal.work and not tbal.work: return return (grp, code, desc, uoi, cbal, obal, bbal, tbal) 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("%-22s%-10s%-1s" % \ ("(Options: Report Date-", self.df.t_disp[0][0][0], ")")) self.fpdf.drawText() self.fpdf.drawText("%-8s %s %s" % \ ("Location", self.loc, self.locd)) self.fpdf.drawText() self.fpdf.drawText("%-3s %-20s %-30s %-10s %11s %11s %11s %11s" % \ ("Grp", "Product-Code", "Description", "U.O.I", "Qty-Balance", "Qty-OnOrder", "Qty-BkOrder", "Qty-ToOrder")) self.fpdf.drawText("%s" % (self.fpdf.suc * len(self.head2))) self.fpdf.setFont() self.pglin = 10 def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class ar3020(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, "asstrn", prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) assctl = gc.getCtl("assctl", self.opts["conum"]) if not assctl: return self.fromad = assctl["cta_emadd"] self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) self.totind = "N" return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Asset Register Audit Trail (%s)" % self.__class__.__name__) data = ["All Types"] for typ in artrtp: data.append(typ[1]) btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"} btm = { "stype": "R", "tables": ("asstrn", ), "cols": (("ast_batch", "", 0, "Bat-Num"), ("ast_type", ("xx", artrtp), 20, "Type"), ("ast_curdt", "", 0, "Cur-Dat")), "where": [], "group": "ast_batch, ast_type, ast_curdt", "order": "ast_type, ast_curdt, ast_batch" } r1s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "Id2", 7, "Starting Period", "", "", "Y", self.doStartPer, None, None, ("efld", )), (("T", 0, 1, 0), "Id2", 7, "Ending Period", "", "", "Y", self.doEndPer, None, None, ("efld", )), (("T", 0, 2, 0), "IUI", 1, "Type", "Transaction Type", "", "Y", self.doBatTyp, btt, None, None), (("T", 0, 3, 0), "INa", 7, "Batch Number", "", "", "Y", self.doBatNum, btm, None, None), (("T", 0, 4, 0), ("IRB", r1s), 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=("N", "V"), mail=("Y", "N")) 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.sdat = self.df.loadEntry(frt, pag, p, data=w) def doEndPer(self, frt, pag, r, c, p, i, w): if not w: w = self.e_per elif w < self.sdat.work or w > self.e_per: return "Invalid Period" self.edat = self.df.loadEntry(frt, pag, p, data=w) def doBatTyp(self, frt, pag, r, c, p, i, w): if w > len(artrtp): return "Invalid Batch Type" self.btype = w whr = [("ast_cono", "=", self.opts["conum"]), ("ast_curdt", "between", self.sdat.work, self.edat.work)] if self.btype: whr.append(("ast_type", "=", self.btype)) self.df.topf[pag][i + 1][8]["where"] = 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 def doEnd(self): self.df.closeProcess() if not self.btype: styp = 0 etyp = 99 else: styp = etyp = self.btype if not self.batch: sbat = "" ebat = "zzzzzzz" else: sbat = ebat = self.batch recs = self.sql.getRec("asstrn", where=[("ast_cono", "=", self.opts["conum"]), ("ast_curdt", "between", self.sdat.work, self.edat.work), ("ast_batch", "between", sbat, ebat), ("ast_type", "between", styp, etyp)], order="ast_type, ast_batch, ast_refno") if not recs: showError(self.opts["mf"].body, "Processing Error", "No Asset Transactions Selected") else: self.printReport(recs) self.closeProcess() def printReport(self, recs): p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) self.head = "%03u %-105s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.bcnt = 0 self.bmt1 = 0 self.bmt2 = 0 self.bvat = 0 self.tcnt = 0 self.tmt1 = 0 self.tmt2 = 0 self.tvat = 0 self.gcnt = [0, 0, 0, 0, 0] self.gmt1 = [0, 0, 0, 0, 0] self.gmt2 = [0, 0, 0, 0, 0] self.gvat = [0, 0, 0, 0, 0] self.trtp = 0 self.pglin = 999 tc = self.sql.asstrn_col for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break trtp = CCD(dat[tc.index("ast_type")], "UI", 2) batch = CCD(dat[tc.index("ast_batch")], "Na", 7) grp = CCD(dat[tc.index("ast_group")], "UA", 3) code = CCD(dat[tc.index("ast_code")], "Na", 7) refno = CCD(dat[tc.index("ast_refno")], "Na", 9) mtyp = CCD(dat[tc.index("ast_mtyp")], "UI", 1) trdt = CCD(dat[tc.index("ast_date")], "D1", 10) desc = CCD(dat[tc.index("ast_desc")], "NA", 30) amt1 = CCD(dat[tc.index("ast_amt1")], "SD", 13.2) amt2 = CCD(dat[tc.index("ast_amt2")], "SD", 13.2) vat = CCD(dat[tc.index("ast_vat")], "SD", 13.2) taxind = CCD(dat[tc.index("ast_taxind")], "NA", 1) 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" % \ (grp.disp, code.disp, refno.disp, trdt.disp, desc.disp, mtyp.disp, amt1.disp, amt2.disp, vat.disp, taxind.disp)) self.pglin += 1 self.bcnt = self.bcnt + 1 self.bmt1 = float(ASD(self.bmt1) + ASD(amt1.work)) self.bmt2 = float(ASD(self.bmt2) + ASD(amt2.work)) self.bvat = float(ASD(self.bvat) + ASD(vat.work)) self.tcnt = self.tcnt + 1 self.tmt1 = float(ASD(self.tmt1) + ASD(amt1.work)) self.tmt2 = float(ASD(self.tmt2) + ASD(amt2.work)) self.tvat = float(ASD(self.tvat) + ASD(vat.work)) self.gcnt[trtp.work - 1] = self.gcnt[trtp.work - 1] + 1 self.gmt1[trtp.work - 1] = float(ASD(self.gmt1[trtp.work - 1]) + \ ASD(amt1.work)) self.gmt2[trtp.work - 1] = float(ASD(self.gmt2[trtp.work - 1]) + \ ASD(amt2.work)) self.gvat[trtp.work - 1] = float(ASD(self.gvat[trtp.work - 1]) + \ ASD(vat.work)) p.closeProgress() if self.fpdf.page and not p.quit: self.batchTotal() self.typeTotal() self.grandTotal() 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, fromad=self.fromad) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-36s %-7s %-2s %-61s" % ("Asset Register Audit Trail for Period", self.sdat.disp, "to", self.edat.disp)) self.fpdf.drawText() self.pglin = 4 if self.totind == "N": self.typeHeading() else: self.fpdf.drawText("%-14s" % "Totals Summary") self.fpdf.drawText() self.fpdf.drawText("%-30s %-8s %-13s %-13s %-13s" % ("Document Type", " Number", " Amount-1", " Amount-2", " VAT-Amt")) 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" self.fpdf.setFont(style="B") self.fpdf.drawText("%-7s %7s %-10s %3s" % \ ("Batch", batch, " Type", artrtp[self.trtp - 1][1])) self.fpdf.drawText() self.fpdf.drawText("%-3s %-7s %-9s %-10s %-30s %1s %-13s %-13s %-13s "\ "%1s" % ("Grp", "Code", "Reference", " Date", "Remarks", "M", " Amount-1", " Amount-2", " VAT-Amt", "I")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin += 4 def batchTotal(self): k = CCD(self.bmt1, "SD", 13.2) l = CCD(self.bmt2, "SD", 13.2) m = CCD(self.bvat, "SD", 13.2) if self.totsonly != "Y": self.fpdf.drawText() self.pglin += 1 self.fpdf.drawText("%-32s %-32s %13s %13s %13s" % \ (" ", "Batch " + self.batch + " Totals", k.disp, l.disp, m.disp)) self.pglin += 1 if self.totsonly == "N": self.fpdf.drawText() self.pglin += 1 self.bcnt = 0 self.bmt1 = 0 self.bmt2 = 0 self.bvat = 0 def typeTotal(self): k = CCD(self.tmt1, "SD", 13.2) l = CCD(self.tmt2, "SD", 13.2) m = CCD(self.tvat, "SD", 13.2) if self.totsonly == "Y": self.fpdf.drawText() self.pglin += 1 self.fpdf.drawText("%-32s %-32s %13s %13s %13s" % \ (" ", "Type-Totals", k.disp, l.disp, m.disp)) self.pglin += 1 self.tcnt = 0 self.tmt1 = 0 self.tmt2 = 0 self.tvat = 0 def grandTotal(self): self.totind = "Y" self.pageHeading() tot = [0, 0, 0, 0] for x, t in enumerate(artrtp): cnt = CCD(self.gcnt[x], "SI", 7) mt1 = CCD(self.gmt1[x], "SD", 13.2) mt2 = CCD(self.gmt2[x], "SD", 13.2) vat = CCD(self.gvat[x], "SD", 13.2) self.fpdf.drawText("%-31s %s %s %s %s" % \ (t[1], cnt.disp, mt1.disp, mt2.disp, vat.disp)) tot[0] = tot[0] + cnt.work tot[1] = float(ASD(tot[1]) + ASD(mt1.work)) tot[2] = float(ASD(tot[2]) + ASD(mt2.work)) tot[3] = float(ASD(tot[3]) + ASD(vat.work)) self.fpdf.drawText() cnt = CCD(tot[0], "SI", 8) mt1 = CCD(tot[1], "SD", 13.2) mt2 = CCD(tot[2], "SD", 13.2) vat = CCD(tot[3], "SD", 13.2) self.fpdf.drawText("%-30s %s %s %s %s" % \ ("Grand Totals", cnt.disp, mt1.disp, mt2.disp, vat.disp)) self.fpdf.drawText() def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class si3020(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, ["strgrp", "strloc", "strmf1"], 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 self.locs = strctl["cts_locs"] slsctl = gc.getCtl("slsctl", self.opts["conum"]) if not slsctl: return self.fromad = slsctl["ctv_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.colsh = [[ "", "", "", "", ["*********** Month to Date **********", 4, 7], ["*********** Year To Date ***********", 8, 11] ]] self.colsh.append([ "Grp", "Product-Code", "Description", "U.O.I", "Quantity", "Value", "Profit", "Prft-%", "Quantity", "Value", "Profit", "Prft-%" ]) self.forms = [("UA", 3), ("NA", 20), ("NA", 30), ("NA", 10), ("SI", 9), ("SI", 9), ("SI", 9), ("SD", 7.2), ("SI", 9), ("SI", 9), ("SI", 9), ("SD", 7.2)] self.stot = [0] * 6 self.gtot = [0] * 6 return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Sales By Product Report (%s)" % self.__class__.__name__) loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } if "args" in self.opts and "noprint" in self.opts["args"]: var = self.opts["args"]["work"][0] view = None mail = None else: var = ["", "", ""] view = ("Y", "V") mail = ("Y", "N") fld = ((("T", 0, 0, 0), "ID2", 7, "Cut-Off Period", "", int(self.sysdtw / 100), "Y", self.doCut, None, None, ("efld", )), (("T", 0, 1, 0), "IUA", 1, "Location", "", var[1], "N", self.doLoc, loc, None, ("efld", )), (("T", 0, 2, 0), "IUA", 3, "Product Group", "", var[2], "N", self.doGroup, grp, 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 doCut(self, frt, pag, r, c, p, i, w): self.cutoff = w self.cutper = self.df.t_disp[pag][r][p] if self.locs == "N": self.loc = "" self.locd = "ALL" return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): if not w: self.locd = "ALL" else: acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not acc: return "Invalid Location" self.locd = "%s %s" % (w, acc[0]) self.loc = w def doGroup(self, frt, pag, r, c, p, i, w): if w: acc = self.getGroup(w) if not acc: return "Invalid Group" self.group = w def doEnd(self): self.df.closeProcess() if not self.group: sgrp = "" egrp = "zzz" else: sgrp = egrp = self.group recs = self.sql.getRec( "strmf1", cols=["st1_group", "st1_code", "st1_desc", "st1_uoi"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", ">=", sgrp), ("st1_group", "<=", egrp)], order="st1_group, st1_code") if not recs: showError(self.opts["mf"].body, "Processing 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 = [ "%03u %-30s %s" % (self.opts["conum"], self.opts["conam"], self.sysdttm) ] self.expheads.append("Sales Report By Product up to %s" % self.cutper) 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, desc, uoi, mq, ms, mp, mn, yq, ys, yp, yn = vals self.expdatas.append([ "BODY", [ self.grp.work, code.work, desc.work, uoi.work, mq.work, ms.work, mp.work, mn.work, yq.work, ys.work, yp.work, yn.work ] ]) 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) self.head = "%03u %-138s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) lstgrp = "" self.pglin = 999 for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break vals = self.getValues(dat) if not vals: continue if lstgrp and lstgrp != self.grp.work: self.groupTotal() self.pglin = 999 if self.pglin > self.fpdf.lpp: self.pageHeading() code, desc, uoi, mq, ms, mp, mn, yq, ys, yp, yn = vals self.fpdf.drawText("%s %s %s %s %s %s %s %s %s %s %s" % \ (code.disp, desc.disp, uoi.disp, mq.disp, ms.disp, mp.disp, mn.disp, yq.disp, ys.disp, yp.disp, yn.disp)) self.stot[0] = float(ASD(self.stot[0]) + ASD(mq.work)) self.stot[1] = float(ASD(self.stot[1]) + ASD(ms.work)) self.stot[2] = float(ASD(self.stot[2]) + ASD(mp.work)) self.stot[3] = float(ASD(self.stot[3]) + ASD(yq.work)) self.stot[4] = float(ASD(self.stot[4]) + ASD(ys.work)) self.stot[5] = float(ASD(self.stot[5]) + ASD(yp.work)) self.pglin += 1 lstgrp = self.grp.work p.closeProgress() if self.fpdf.page and not p.quit: self.groupTotal() 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 getValues(self, data): self.grp = CCD(data[0], "UA", 3) code = CCD(data[1], "NA", 20) desc = CCD(data[2], "NA", 30) uoi = CCD(data[3], "NA", 10) bals = Balances(self.opts["mf"], "STR", self.opts["conum"], self.cutoff, keys=(self.grp.work, code.work, self.loc, ("P", self.opts["period"][0]))) m_ob, m_mv, m_cb, y_ob, y_mv, y_cb, ac, lc, ls = bals.doStrBals() m_qty = 0 m_cst = 0 m_sls = 0 for t, q, c, s in m_mv: if t == 7: m_qty = q m_cst = c m_sls = s break y_qty = 0 y_cst = 0 y_sls = 0 for t, q, c, s in y_mv: if t == 7: y_qty = q y_cst = c y_sls = s break mq = CCD(float(ASD(0) - ASD(m_qty)), "SI", 9) mc = CCD(float(ASD(0) - ASD(m_cst)), "SI", 9) ms = CCD(float(ASD(0) - ASD(m_sls)), "SI", 9) mp = float(ASD(ms.work) - ASD(mc.work)) mp = CCD(mp, "SI", 9) if ms.work == 0: mn = 0 else: mn = round((mp.work * 100 / ms.work), 2) mn = CCD(mn, "SD", 7.2) yq = CCD(float(ASD(0) - ASD(y_qty)), "SI", 9) yc = CCD(float(ASD(0) - ASD(y_cst)), "SI", 9) ys = CCD(float(ASD(0) - ASD(y_sls)), "SI", 9) yp = float(ASD(ys.work) - ASD(yc.work)) yp = CCD(yp, "SI", 9) if not ys.work: yn = 0 else: yn = round((yp.work * 100.0 / ys.work), 2) yn = CCD(yn, "SD", 7.2) if mq.work == 0 and mc.work == 0 and ms.work == 0 and \ yq.work == 0 and yc.work == 0 and ys.work == 0: return self.gtot[0] = float(ASD(self.gtot[0]) + ASD(mq.work)) self.gtot[1] = float(ASD(self.gtot[1]) + ASD(ms.work)) self.gtot[2] = float(ASD(self.gtot[2]) + ASD(mp.work)) self.gtot[3] = float(ASD(self.gtot[3]) + ASD(yq.work)) self.gtot[4] = float(ASD(self.gtot[4]) + ASD(ys.work)) self.gtot[5] = float(ASD(self.gtot[5]) + ASD(yp.work)) return (code, desc, uoi, mq, ms, mp, mn, yq, ys, yp, yn) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-29s %-7s" % \ ("Sales Report By Product up to", self.cutper)) self.fpdf.drawText() acc = self.getGroup(self.grp.work) if acc: grpd = acc[0] else: grpd = "Missing Group Record" self.fpdf.drawText("%s %s %s %s %s" % \ ("Group:", self.grp.disp, grpd, "Location:", self.locd)) self.fpdf.drawText() self.fpdf.drawText("%-62s %-36s %-5s%-36s " % ("", "*********** Month T0 Date **********", "", "*********** Year To Date ***********")) self.fpdf.drawText("%-20s %-30s %-10s %9s %9s %9s %7s "\ "%9s %9s %9s %7s" % ("Product-Code", "Description", "U.O.I", "Quantity ", "Value ", "Profit ", "Prft-% ", "Quantity ", "Value ", "Profit ", "Prft-% ")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 9 def getGroup(self, grp): acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", grp)], limit=1) return acc def groupTotal(self): self.fpdf.drawText() mq = CCD(self.stot[0], "SI", 9) ms = CCD(self.stot[1], "SI", 9) mp = CCD(self.stot[2], "SI", 9) if ms.work == 0: mn = 0 else: mn = round((mp.work * 100 / ms.work), 2) mn = CCD(mn, "SD", 7.2) yq = CCD(self.stot[3], "SI", 9) ys = CCD(self.stot[4], "SI", 9) yp = CCD(self.stot[5], "SI", 9) if ys.work == 0: yn = 0 else: yn = round((yp.work * 100 / ys.work), 2) yn = CCD(yn, "SD", 7.2) self.fpdf.drawText("%-20s %-41s %s %s %s %s %s %s %s %s" % \ ("", "Group Totals", mq.disp, ms.disp, mp.disp, mn.disp, yq.disp, ys.disp, yp.disp, yn.disp)) self.stot = [0] * 6 def grandTotal(self): mq = CCD(self.gtot[0], "SI", 9) ms = CCD(self.gtot[1], "SI", 9) mp = CCD(self.gtot[2], "SI", 9) if ms.work == 0: mn = 0 else: mn = round((mp.work * 100 / ms.work), 2) mn = CCD(mn, "SD", 7.2) yq = CCD(self.gtot[3], "SI", 9) ys = CCD(self.gtot[4], "SI", 9) yp = CCD(self.gtot[5], "SI", 9) if ys.work == 0: yn = 0 else: yn = round((yp.work * 100 / ys.work), 2) yn = CCD(yn, "SD", 7.2) if self.df.repprt[2] == "export": self.expdatas.append(["ULINES"]) self.expdatas.append([ "TOTAL", [ "", "", "Grand Totals", "", mq.work, ms.work, mp.work, mn.work, yq.work, ys.work, yp.work, yn.work ] ]) self.expdatas.append(["ULINED"]) return self.fpdf.drawText() self.fpdf.drawText("%-20s %-41s %s %s %s %s %s %s %s %s" % \ ("", "Grand Totals", mq.disp, ms.disp, mp.disp, mn.disp, yq.disp, ys.disp, yp.disp, yn.disp)) def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): if "wait" not in self.opts: self.opts["mf"].closeLoop()
class bk3030(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, tables=["bkmmst", "bkmcon", "bkmrtt", "bkmtrn", "bkmunm", "ctlmst", "ctlvtf", "gentrn", "tplmst"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) ctl = gc.getCtl("ctlmst", self.opts["conum"]) if not ctl: return for col in ( "ctm_name", "ctm_add1", "ctm_add2", "ctm_add3", "ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_taxdf", "ctm_tel", "ctm_fax", "ctm_b_name", "ctm_b_ibt", "ctm_b_acno", "ctm_logo"): setattr(self, col, ctl[col]) if self.ctm_logo and "LETTERHEAD" in os.environ: self.ctm_logo = os.environ["LETTERHEAD"] if not self.ctm_logo or not os.path.exists(self.ctm_logo): self.ctm_logo = None bkmctl = gc.getCtl("bkmctl", self.opts["conum"]) if not bkmctl: return self.glint = bkmctl["cbk_glint"] self.tplnam = bkmctl["cbk_invtpl"] self.fromad = bkmctl["cbk_emadd"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["vat_ctl", "bkm_ctl"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.vatctl = ctlctl["vat_ctl"] self.bkmctl = ctlctl["bkm_ctl"] 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"]), "Booking Arrivals Listing (%s)" % self.__class__.__name__) tpm = { "stype": "R", "tables": ("tplmst",), "cols": ( ("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title", "Y")), "where": [ ("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")], "order": "tpm_tname"} r1s = (("Weekdays","D"), ("Weekend","E"), ("Range", "R")) r2s = (("Yes","Y"), ("No","N")) fld = ( (("T",0,0,0),("IRB",r1s),0,"Period","", "D","Y",self.doPeriod,None,None,None), (("T",0,1,0),"ID1",10,"Starting Date","", 0,"N",self.doStartDate,None,None,("efld",)), (("T",0,2,0),"ID1",10,"Ending Date","", 0,"N",self.doEndDate,None,None,("efld",)), (("T",0,3,0),("IRB",r2s),0,"Include Queries","", "N","Y",self.doQuery,None,None,None), (("T",0,4,0),("IRB",r2s),0,"Housekeeping Report","", "Y","Y",self.doHkRpt,None,None,None), (("T",0,5,0),("IRB",r2s),0,"Generate Invoices","", "Y","Y",self.doGenInv,None,None,None), (("T",0,6,0),("IRB",r2s),0,"Print Invoices","", "Y","Y",self.doPrtInv,None,None,None), (("T",0,7,0),"INA",20,"Template Name","", self.tplnam,"N",self.doTplNam,tpm,None,None)) tnd = ((self.doEnd,"y"), ) txt = (self.doExit, ) if "args" in self.opts: tops = self.opts["args"] else: tops = False self.df = TartanDialog(self.opts["mf"], tops=tops, title=self.tit, eflds=fld, tend=tnd, txit=txt, view=("N","P"), mail=("Y","N")) def doPeriod(self, frt, pag, r, c, p, i, w): self.period = w if self.period in ("D", "E"): self.start = self.getStart() self.df.loadEntry(frt, pag, p+1, data=self.start) def doStartDate(self, frt, pag, r, c, p, i, w): self.start = w if self.period in ("D", "E"): if self.getStart(self.start): return "Invalid Start Date" if self.period == "D": self.end = projectDate(self.start, 3) else: self.end = projectDate(self.start, 2) self.df.loadEntry(frt, pag, p+1, data=self.end) return "sk1" def getStart(self, date=None): if self.period == "D": chk = 0 else: chk = 4 if date: year = int(date / 10000) month = int(date / 100) % 100 day = date % 100 if datetime.date(year, month, day).weekday() != chk: return True else: date = projectDate(self.sysdtw, -1) dte = 99 while dte != chk: date = projectDate(date, 1) year = int(date / 10000) month = int(date / 100) % 100 day = date % 100 dte = datetime.date(year, month, day).weekday() return date def doEndDate(self, frt, pag, r, c, p, i, w): if w < self.start: return "Invalid End Date, Before Start Date" days = dateDiff(self.start, w, ptype="days") if days > 7: return "Range More Than 7 Days" self.end = w def doQuery(self, frt, pag, r, c, p, i, w): self.query = w def doHkRpt(self, frt, pag, r, c, p, i, w): self.house = w def doGenInv(self, frt, pag, r, c, p, i, w): self.geninv = w if self.geninv == "N": self.prtinv = "N" self.df.loadEntry(frt, pag, p+1, data=self.prtinv) return "sk2" def doPrtInv(self, frt, pag, r, c, p, i, w): self.prtinv = w if self.prtinv == "N": return "sk1" def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")], limit=1) if not acc: return "Invalid Template Name" self.tname = w def doEnd(self): self.df.closeProcess() # Headings and Mail subject self.cdes = "%-30s" % self.opts["conam"] start = self.getDate(self.start) end = self.getDate(projectDate(self.end, 1)) if self.period == "D": self.hdes = "Arrivals for Weekdays %s to %s" % (start, end) elif self.period == "E": self.hdes = "Arrivals for Weekend %s to %s" % (start, end) else: self.hdes = "Arrivals for Period %s to %s" % (start, end) self.fpdf = MyFpdf(name=self.__class__.__name__, head=80, auto=True) self.fpdf.header = self.pageHeading self.rtyp = "A" self.doArrival() if self.house == "Y": self.rtyp = "H" self.hdes = self.hdes.replace("Arrivals", "Units") if self.fpdf.page: self.fpdf.add_page() self.doHKeeping() if self.fpdf.page: pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, self.opts["conum"], ext="pdf") self.fpdf.output(pdfnam, "F") subj = "%s - %s" % (self.cdes, self.hdes) doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=subj, repprt=self.df.repprt, fromad=self.fromad, repeml=self.df.repeml) if self.prtinv == "Y" and self.docs: # Print Invoice self.docs.sort() PrintBookingInvoice(self.opts["mf"], self.opts["conum"], self.opts["conam"], "I", self.docs, tname=self.tname, repprt=self.df.repprt, repeml=self.df.repeml) # Print Statement self.book.sort() callModule(self.opts["mf"], None, "bk3070", coy=(self.opts["conum"], self.opts["conam"]), args=[self.book, self.df.repprt, self.df.repeml]) if "wait" not in self.opts: self.opts["mf"].closeLoop() def doArrival(self): state = ["C", "S"] if self.query == "Y": state.append("Q") recs = self.sql.getRec("bkmmst", where=[("bkm_cono", "=", self.opts["conum"]), ("bkm_state", "in", tuple(state))], order="bkm_ccode") self.book = [] self.docs = [] last = 0 for rec in recs: number = rec[self.sql.bkmmst_col.index("bkm_number")] ccode = rec[self.sql.bkmmst_col.index("bkm_ccode")] btype = rec[self.sql.bkmmst_col.index("bkm_btype")] arrive = rec[self.sql.bkmmst_col.index("bkm_arrive")] depart = rec[self.sql.bkmmst_col.index("bkm_depart")] if btype == "A": if depart <= self.start or arrive > self.end: continue elif depart < self.start or arrive > self.end: continue if self.geninv == "Y": self.doRaiseInvoice(number, arrive) con = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", ccode)], limit=1) sname = con[self.sql.bkmcon_col.index("bkc_sname")].strip() names = con[self.sql.bkmcon_col.index("bkc_names")].strip() if names: name = "%s %s (%s)" % (names.split()[0], sname, number) else: name = "%s (%s)" % (sname, number) bal = self.sql.getRec("bkmtrn", cols=["sum(bkt_tramt)"], where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number", "=", number)], limit=1) rtts = self.sql.getRec("bkmrtt", cols=["brt_udesc", "brt_uroom", "sum(brt_quant)"], where=[("brt_cono", "=", self.opts["conum"]), ("brt_number", "=", number)], group="brt_utype, brt_ucode, brt_udesc, brt_uroom", order="brt_utype, brt_ucode, brt_uroom") if not rtts: continue units = [] unt = None for rtt in rtts: if rtt[1]: if not unt: unt = ["%s - R%s" % (rtt[0], rtt[1]), rtt[2]] else: unt = ["%s & R%s" % (unt[0], rtt[1]), rtt[2]] else: unt = (rtt[0], rtt[2]) units.append(unt) namq = len(wrap(name, break_long_words=False, width=25)) untq = 0 for unit in units: untq += len(wrap(unit[0], break_long_words=False, width=25)) if namq and untq > namq: hh = [(untq * 8.0) / namq, 8, untq * 8] elif untq and namq > untq: hh = [8, (namq * 8.0) / untq, namq * 8] elif namq: hh = [8, 8, namq * 8] else: hh = [8, 8, untq * 8] if not self.fpdf.page or self.fpdf.get_y() + hh[0] > 280: self.fpdf.add_page() oldnm = None for unit in units: if name == oldnm: name = "" else: oldnm = name if arrive >= self.start: yr = int(arrive / 10000) mt = int(arrive / 100) % 100 dy = arrive % 100 d = datetime.date(yr, mt, dy) arr = d.strftime("%a") else: arr = "<--" if btype == "A": td = projectDate(depart, -1) else: td = depart if td <= self.end: yr = int(depart / 10000) mt = int(depart / 100) % 100 dy = depart % 100 e = datetime.date(yr, mt, dy) dep = e.strftime("%a") else: dep = "-->" if last != number and bal[0]: amt = CCD(bal[0], "SD", 13.2).disp else: amt = CCD(0, "SD", 13.2).disp self.printLine(name, unit[0], unit[1], arr, dep, amt, hh) last = number self.opts["mf"].dbm.commitDbase() def doHKeeping(self): recs = self.sql.getRec("bkmunm", cols=["bum_btyp", "bum_code", "bum_desc"], where=[("bum_cono", "=", self.opts["conum"]), ("bum_room", "<>", 999)], order="bum_btyp, bum_code") for rec in recs: col = ["bkm_number", "bkm_btype", "bkm_group", "bkc_sname", "bkc_names", "bkm_arrive", "bkm_depart", "sum(brt_quant)"] state = ["C", "S"] if self.query == "Y": state.append("Q") bks = self.sql.getRec(tables=["bkmmst", "bkmrtt", "bkmcon"], cols=col, where=[("bkm_cono", "=", self.opts["conum"]), ("bkm_state", "in", tuple(state)), ("brt_cono=bkm_cono",), ("brt_number=bkm_number",), ("brt_utype", "=", rec[0]), ("brt_ucode", "=", rec[1]), ("bkc_cono=bkm_cono",), ("bkc_ccode=bkm_ccode",)], order="bkm_arrive, bkc_sname") qty = "" arr = "" dep = "" amt = "" totq = 0 lines = [] hh = [8, 8, 8] for bk in bks: number = bk[0] btype = bk[1] if bk[2]: name = bk[2] elif bk[4]: name = "%s %s" % (bk[4].split()[0], bk[3]) else: name = bk[3] name = "%s\n(%s)" % (name.strip(), number) arrive = bk[5] depart = bk[6] if btype == "A": if depart <= self.start or arrive > self.end: continue elif depart < self.start or arrive > self.end: continue if arrive >= self.start: yr = int(arrive / 10000) mt = int(arrive / 100) % 100 dy = arrive % 100 dt = datetime.date(yr, mt, dy) arrive = dt.strftime("%a") else: arrive = "<--" if btype == "A": td = projectDate(depart, -1) else: td = depart if td <= self.end: yr = int(depart / 10000) mt = int(depart / 100) % 100 dy = depart % 100 dt = datetime.date(yr, mt, dy) depart = dt.strftime("%a") else: depart = "-->" rms = self.sql.getRec("bkmrtt", cols=["brt_uroom"], where=[ ("brt_cono", "=", self.opts["conum"]), ("brt_number", "=", number), ("brt_utype", "=", rec[0]), ("brt_ucode", "=", rec[1])], order="brt_uroom") rm = False for r in rms: if not r[0]: continue if not rm: name = "%s - R%s" % (name, r[0]) rm = True else: name = "%s & R%s" % (name, r[0]) quant = bk[7] bal = self.sql.getRec("bkmtrn", cols=["sum(bkt_tramt)"], where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number", "=", number)], limit=1) namq = len(wrap(name, break_long_words=False, width=25)) totq += namq hh[2] = namq * 8 qty = CCD(quant, "UI", 3).disp arr = CCD(arrive, "NA", 3).disp dep = CCD(depart, "NA", 3).disp amt = CCD(bal[0], "SD", 13.2).disp lines.append([name, qty, arr, dep, amt, copyList(hh)]) if not self.fpdf.page or self.fpdf.get_y() + (totq * 8) > 280: self.fpdf.add_page() untq = len(wrap(rec[2], break_long_words=False, width=25)) if not lines: hh[1] = hh[2] = 8.0 * untq self.y = self.fpdf.get_y() self.printLine(rec[2], "", "", "", "", "", hh) self.fpdf.set_y(self.y) self.printLine(None, "", "", "", "", "", hh) else: if untq > totq: hh[1] = hh[2] = (untq * 8.0) / totq elif totq > untq: hh[0] = (totq * 8.0) / untq else: hh[2] = totq * 8 self.y = self.fpdf.get_y() self.printLine(rec[2], "", "", "", "", "", hh) self.fpdf.set_y(self.y) for l in lines: self.printLine(None, l[0], l[1], l[2], l[3], l[4], l[5]) def doRaiseInvoice(self, number, trdt): # Raise the Invoice incamt = 0 vatamt = 0 curdt = int(trdt / 100) batno = "B%s" % curdt gls = {} recs = self.sql.getRec("bkmrtt", where=[("brt_cono", "=", self.opts["conum"]), ("brt_number", "=", number), ("brt_invno", "=", 0)]) if not recs: return invno = self.getRef(number) self.docs.append(invno) if number not in self.book: self.book.append(number) for rec in recs: utyp = rec[self.sql.bkmrtt_col.index("brt_utype")] ucod = rec[self.sql.bkmrtt_col.index("brt_ucode")] rcod = rec[self.sql.bkmrtt_col.index("brt_rcode")] rbas = rec[self.sql.bkmrtt_col.index("brt_rbase")] quan = rec[self.sql.bkmrtt_col.index("brt_quant")] rate = rec[self.sql.bkmrtt_col.index("brt_arate")] days = rec[self.sql.bkmrtt_col.index("brt_bdays")] umst = self.sql.getRec("bkmunm", where=[("bum_cono", "=", self.opts["conum"]), ("bum_btyp", "=", utyp), ("bum_code", "=", ucod)], limit=1) vatc = umst[self.sql.bkmunm_col.index("bum_vatc")] if not vatc: vatc = self.ctm_taxdf vrte = getVatRate(self.sql, self.opts["conum"], vatc, trdt) if vrte is None: vrte = 0.0 if rbas == "A": inca = quan * days * rate elif rbas == "B": inca = quan * rate elif rbas == "C": inca = days * rate else: inca = rate vata = round(inca * vrte / (100 + vrte), 2) exca = float(ASD(inca) - ASD(vata)) incamt = float(ASD(incamt) + ASD(inca)) vatamt = float(ASD(vatamt) - ASD(vata)) if self.glint == "Y": slsa = umst[self.sql.bkmunm_col.index("bum_slsa")] if slsa not in gls: gls[slsa] = [0, 0, vatc] gls[slsa][0] = float(ASD(gls[slsa][0]) - ASD(exca)) gls[slsa][1] = float(ASD(gls[slsa][1]) - ASD(vata)) data = [self.opts["conum"], number, 2, invno, batno, trdt, inca, vata, curdt, "Booking %s-%s Raised" % (utyp, ucod), vatc, "", self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("bkmtrn", data=data) self.sql.updRec("bkmrtt", cols=["brt_invno", "brt_invdt", "brt_vrate"], data=[invno, trdt, vrte], where=[("brt_cono", "=", self.opts["conum"]), ("brt_number", "=", number), ("brt_utype", "=", utyp), ("brt_ucode", "=", ucod), ("brt_rcode", "=", rcod)]) if vata: exc = float(ASD(0) - ASD(exca)) vat = float(ASD(0) - ASD(vata)) data = [self.opts["conum"], vatc, "O", curdt, "B", 1, batno, invno, trdt, number, "Booking %s" % number, exc, vat, 0, self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("ctlvtf", data=data) if self.glint == "Y": data = [self.opts["conum"], self.bkmctl, curdt, trdt, 1, invno, batno, incamt, 0, "Booking %s" % number, "", "", 0, self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("gentrn", data=data) for acc in gls: data = [self.opts["conum"], acc, curdt, trdt, 1, invno, batno, gls[acc][0], gls[acc][1], "Booking %s" % number, gls[acc][2], "", 0, self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("gentrn", data=data) if gls[acc][1]: data = [self.opts["conum"], self.vatctl, curdt, trdt, 1, invno, batno, gls[acc][1], 0, "Booking %s" % number, "", "", 0, self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("gentrn", data=data) return True def getRef(self, number): rec = self.sql.getRec("bkmtrn", cols=["max(bkt_refno)"], where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number", "=", number), ("bkt_refno", "like", "%7s%s" % (number, "%"))], limit=1) if not rec or not rec[0]: num = 1 else: num = int(rec[0][-2:]) + 1 return "%7s%02i" % (number, num) def pageHeading(self): self.fpdf.drawText(self.cdes, x=7, font=["courier", "B", 24]) self.fpdf.drawText(font=["courier", "B", 14]) self.fpdf.drawText(self.hdes, x=7, font=["courier", "B", 16]) if self.query == "Y": ides = "Queries Included" else: ides = "Queries Not Included" if self.rtyp == "A": if self.geninv == "Y": ides = "%s, Invoices Generated" % ides else: ides = "%s, Invoices Not Generated" % ides self.fpdf.drawText() self.fpdf.drawText(ides, x=7, font=["courier", "B", 16]) if self.rtyp == "A": self.fpdf.drawText(font=["courier", "B", 12]) self.printLine("%-25s" % "Name or Group", "%-25s" % "Unit Description", "Qty", "Arr", "Dep", " Balance ", (8, 8, 8), fill=1) else: self.fpdf.drawText(font=["courier", "B", 12]) self.printLine("%-25s" % "Unit Description", "%-25s" % "Name or Group", "Qty", "Arr", "Dep", " Balance ", (8, 8, 8), fill=1) def getDate(self, date): if type(date) == str: date = int(date.replace("-", "")) yy = int(date / 10000) mm = int(date / 100) % 100 dd = date % 100 return "%s %s %s" % (dd, mthnam[mm][1], yy) def printLine(self, a, b, c, d, e, f, hh, bdr="TLB", fill=0): if self.rtyp == "H" and a is None: if hh[2] > 8: ctyp = "M" else: ctyp = "S" elif hh[0] > 8 or hh[1] > 8 or hh[2] > 8: ctyp = "M" else: ctyp = "S" ft = ["courier", "B", 12] self.fpdf.set_font(ft[0], ft[1], ft[2]) w = self.fpdf.get_string_width("X" * 26) x = 7 y = self.fpdf.get_y() if a: self.fpdf.drawText(a, x=x, y=y, w=w, h=hh[0], border=bdr, fill=fill, ctyp=ctyp, font=ft) if self.rtyp == "H" and not fill: return x += w w = self.fpdf.get_string_width("X" * 26) self.fpdf.drawText(b, x=x, y=y, w=w, h=hh[1], border=bdr, fill=fill, ctyp=ctyp, font=ft) x += w w = self.fpdf.get_string_width("X" * 4) + 1 h = self.fpdf.get_y() - y if self.rtyp == "A": self.fpdf.drawText(c, x=x, y=y, w=w, h=h, border=bdr, align="R", fill=fill, font=ft) else: self.fpdf.drawText(c, x=x, y=y, w=w, h=hh[2], border=bdr, align="R", fill=fill, ctyp=ctyp, font=ft) ly = self.fpdf.get_y() if a or self.rtyp == "H": x += w w = self.fpdf.get_string_width("X" * 4) if self.rtyp == "A": self.fpdf.drawText(d, x=x, y=y, w=w, h=hh[2], border=bdr, fill=fill, font=ft) else: self.fpdf.drawText(d, x=x, y=y, w=w, h=hh[2], border=bdr, fill=fill, ctyp=ctyp, font=ft) x += w w = self.fpdf.get_string_width("X" * 4) if self.rtyp == "A": self.fpdf.drawText(e, x=x, y=y, w=w, h=hh[2], border=bdr, fill=fill, font=ft) else: self.fpdf.drawText(e, x=x, y=y, w=w, h=hh[2], border=bdr, fill=fill, ctyp=ctyp, font=ft) x += w w = self.fpdf.get_string_width("X" * 14) if self.rtyp == "A": self.fpdf.drawText(f, x=x, y=y, w=w, h=hh[2], border="TLRB", fill=fill, font=ft) else: self.fpdf.drawText(f, x=x, y=y, w=w, h=hh[2], border="TLRB", fill=fill, ctyp=ctyp, font=ft) self.fpdf.set_y(ly) def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class st3050(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, ["strgrp", "strmf1", "strloc", "strrcp"], 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 self.locs = strctl["cts_locs"] self.fromad = strctl["cts_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]) return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Stores Recipe Listing (%s)" % self.__class__.__name__) loc = { "stype": "R", "tables": ("strloc",), "cols": ( ("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])]} grp = { "stype": "R", "tables": ("strgrp",), "cols": ( ("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])]} r1s = (("Yes","Y"), ("Singles", "S")) r2s = (("Yes","Y"), ("No","N")) if self.locs == "N": self.loc = "1" fld = [] else: fld = [[("T",0,0,0),"IUA",1,"Location","", "1","Y",self.doLoc,loc,None,("notblank",)]] fld.extend([ (("T",0,1,0),"IUA",3,"Product Group","", "","Y",self.doGroup,grp,None,None), (("T",0,2,0),("IRB",r1s),0,"Whole File","", "S","Y",self.doWhole,None,None,None), (("T",0,3,0),("IRB",r2s),0,"Recipe per Page","Recipe per Page", "N","Y",self.doPage,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=("N","V"), mail=("Y","N")) def doLoc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not acc: return "Invalid Location" self.loc = w def doGroup(self, frt, pag, r, c, p, i, w): if not w: self.group = "" else: acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.group = w def doWhole(self, frt, pag, r, c, p, i, w): self.whole = w def doPage(self, frt, pag, r, c, p, i, w): self.page = w def doEnd(self): self.df.closeProcess() if not self.group: self.sgrp = "" self.egrp = "zzz" else: self.sgrp = self.group self.egrp = self.group whr = [ ("st1_cono", "=", self.opts["conum"]), ("st1_group", ">=", self.sgrp), ("st1_group", "<=", self.egrp), ("st1_type", "=", "R")] odr = "st1_group, st1_code" if self.whole == "S": recs = getSingleRecords(self.opts["mf"], "strmf1", ("st1_group", "st1_code", "st1_desc"), where=whr, order=odr) else: recs = self.sql.getRec("strmf1", where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Processing Error", "No Records Selected") else: self.printReport(recs) self.closeProcess() def printReport(self, recs): p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) self.head = "%03u %-71s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) oldrec = "" self.pglin = 999 st1 = self.sql.strmf1_col srr = self.sql.strrcp_col for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break grp = CCD(dat[st1.index("st1_group")], "UA", 3) cod = CCD(dat[st1.index("st1_code")], "NA", 20) dsc = CCD(dat[st1.index("st1_desc")], "NA", 30) whr = [ ("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", grp.work), ("srr_code", "=", cod.work)] if self.locs == "Y": whr.append(("srr_loc", "=", self.loc)) odr = "srr_rgroup, srr_rcode" rec = self.sql.getRec("strrcp", where=whr, order=odr) if not rec: continue newrec = "%s%s" % (grp.work, cod.work) if oldrec and newrec != oldrec: self.pageHeading(grp, cod, dsc, chg=True) for z in rec: if self.pglin > self.fpdf.lpp: self.pageHeading(grp, cod, dsc) gp = CCD(z[srr.index("srr_rgroup")], "UA", 3) cd = CCD(z[srr.index("srr_rcode")], "NA", 20) qt = CCD(z[srr.index("srr_rqty")], "UD", 11.2) dd = self.sql.getRec("strmf1", cols=["st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", gp.work), ("st1_code", "=", cd.work)], limit=1) if dd: dc = dd[0] else: dc = "" self.fpdf.drawText("%s %s %-38s %s" % (gp.disp, cd.disp, dc, qt.disp)) self.pglin += 1 oldrec = newrec 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 pageHeading(self, grp, cod, dsc, chg=False): if self.page == "N" and chg and self.pglin < (self.fpdf.lpp - 10): self.fpdf.drawText() self.fpdf.drawText() self.fpdf.setFont(style="B") self.pglin += 2 else: self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-19s %-10s" % ("Stock Recipes as at", self.sysdtd)) self.fpdf.drawText() self.pglin = 4 if self.locs == "Y": self.fpdf.drawText("%-5s %s %-4s %s %-8s %s %s" % ("Group", grp.disp, "Code", cod.disp, dsc.disp, "Loc", self.loc)) else: self.fpdf.drawText("%-5s %s %-4s %s %s" % ("Group", grp.disp, "Code", cod.disp, dsc.disp)) self.fpdf.drawText() self.fpdf.drawText("%-3s %-20s %-38s %11s" % ("Grp", "Product-Code", "Description", "Quantity")) self.fpdf.underLine(txt=self.head) self.pglin += 4 self.fpdf.setFont() def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class bs3010(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, ["bksmst", "bksaut", "bksown"], prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.curdt = time.strftime("%Y-%m", t) self.image = os.path.join(self.opts["mf"].rcdic["wrkdir"], "books.png") if not os.path.exists(self.image): getImage("books", fle=self.image) if not os.path.exists(self.image): self.image = None return True def mainProcess(self): lst = { "stype": "R", "tables": ("bksmst", ), "cols": (("bmf_mnth", "", 0, "Month"), ), "where": [("bmf_cono", "=", self.opts["conum"])], "group": "bmf_mnth", "order": "bmf_mnth" } r1s = (("All", "A"), ("Current", "C"), ("Removed", "R")) r2s = (("Title", "T"), ("Date", "D"), ("Author", "A"), ("Owner", "O")) fld = ((("T", 0, 0, 0), "ID2", 7, "Last Meeting", "", "", "N", self.doLast, lst, None, ("efld", )), (("T", 0, 1, 0), ("IRB", r1s), 0, "Status", "", "A", "N", self.doStatus, None, None, None), (("T", 0, 2, 0), ("IRB", r2s), 0, "Order", "", "T", "N", self.doOrder, None, None, None)) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt, view=("N", "V"), mail=("B", "Y")) def doLast(self, frt, pag, r, c, p, i, w): self.last = w self.new = False def doStatus(self, frt, pag, r, c, p, i, w): self.status = w def doOrder(self, frt, pag, r, c, p, i, w): self.order = w def doEnd(self): self.df.closeProcess() if self.df.repeml[1] == "Y": if not self.df.repeml[2]: owns = self.sql.getRec("bksown", cols=["bof_mail"], where=[("bof_mail", "<>", ""), ("bof_stat", "=", "C")]) adds = None for own in owns: if not adds: adds = own[0] else: adds = "%s,%s" % (adds, own[0]) self.df.repeml[2] = adds if not self.df.repeml[3]: self.df.repeml[3] = """Dear Member Attached please find the latest list of books. All books which came onto the list at the last meeting are highlighted and, if available, a precis will be printed at the end. Thanks and Regards. """ tab = ["bksmst", "bksaut", "bksown"] col = [ "bmf_stat", "bmf_titl", "bmf_code", "baf_snam", "baf_fnam", "bmf_mnth", "bof_fnam", "bof_snam" ] odr = "" if self.status == "C": whr = [("bmf_stat", "=", "C")] elif self.status == "R": whr = [("bmf_stat", "=", "X")] else: whr = [] odr = "bmf_stat" whr.extend([("baf_code=bmf_auth", ), ("bof_code=bmf_ownr", )]) if self.order == "T": if odr: odr = "%s, bmf_titl" % odr else: odr = "bmf_titl" elif self.order == "D": if odr: odr = "%s, bmf_mnth, bmf_titl" % odr else: odr = "bmf_mnth, bmf_titl" elif self.order == "A": if odr: odr = "%s, baf_snam, baf_fnam, bmf_titl" % odr else: odr = "baf_snam, baf_fnam, bmf_titl" elif self.order == "O": if odr: odr = "%s, bmf_ownr, bmf_titl" % odr else: odr = "bmf_ownr, bmf_titl" recs = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Selection Error", "No Records Selected") self.opts["mf"].closeLoop() return self.fpdf = MyFpdf(name="bs3010", head=90, auto=True) self.fpdf.header = self.pageHeading self.stat = recs[0][0] self.fpdf.add_page() new = [] for rec in recs: stat = CCD(rec[0], "UA", 1).disp if stat != self.stat: self.stat = stat self.fpdf.add_page() titl = CCD(rec[1], "NA", 30).disp code = CCD(rec[2], "UI", 4).disp auth = CCD("%s, %s" % (rec[3], rec[4]), "NA", 30).disp mnth = CCD(rec[5], "D2", 7).disp ownr = CCD("%s %s" % (rec[6], rec[7][0]), "NA", 12).disp if rec[5] < self.last: fill = 0 else: new.append([auth, titl]) fill = 1 self.fpdf.drawText("%1s %30s %4s %30s %7s %10s" % (stat, titl, code, auth, mnth, ownr), h=5, fill=fill) if new: sp = SplashScreen( self.opts["mf"].body, "Preparing Summary of New Books ... Please Wait") self.new = True self.fpdf.add_page() for book in new: try: if self.fpdf.get_y() > 260: self.fpdf.add_page() desc = self.getDesc(book) if desc: w = self.fpdf.cwth * 9 desc = desc.rstrip().encode("latin-1", "ignore").decode( "latin-1", "ignore") self.fpdf.drawText(w=w, txt="Title: ", font="B", ln=0) self.fpdf.drawText(txt=book[1].rstrip(), font="I") self.fpdf.drawText(w=w, txt="Author: ", font="B", ln=0) self.fpdf.drawText(txt=book[0].rstrip(), font="I") self.fpdf.drawText(w=w, txt="Details: ", font="B", ln=0) self.fpdf.drawText(txt=desc, font="I", ctyp="M") if book != new[-1]: self.fpdf.drawText() except: pass sp.closeSplash() pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, self.opts["conum"], ext="pdf") self.fpdf.output(pdfnam, "F") head = "Book List as at %s" % (self.curdt) doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=head, repprt=self.df.repprt, repeml=self.df.repeml) self.opts["mf"].closeLoop() def pageHeading(self, new=False): self.fpdf.setFont("Arial", "B", 15) x = self.fpdf.get_x() if self.image: self.fpdf.image(self.image, 11, 10, 15, 20) self.fpdf.image(self.image, 185, 10, 15, 20) self.fpdf.cell(20) self.fpdf.set_x(x) self.fpdf.cell(0, 10, self.opts["conam"], "TLR", 1, "C") if self.new: txt = "Summary of New Books" elif self.stat == "C": txt = "Current Books as at %s" % self.curdt else: txt = "Removed Books as at %s" % self.curdt self.fpdf.cell(0, 10, txt, "LRB", 1, "C") self.fpdf.ln(8) self.fpdf.setFont(style="B") if not self.new: self.fpdf.cell( 0, 5, "%-1s %-30s %-4s %-30s %-7s %-12s" % ("S", "Title", "Code", "Author", "Mth-Rec", "Owner"), "B") self.fpdf.ln(5) def getDesc(self, book): auth = book[0].strip().lower() titl = book[1].strip().lower().replace(",", "") if titl[:4] == "the ": titl = titl[4:] elif titl[-4:] == " the": titl = titl[:-4] get = requests.get("https://www.googleapis.com/books/v1/volumes?q="\ "{intitle:'%s'+inauthor:'%s'" % (titl, auth), timeout=5) if get.status_code == 200 and get.json()["totalItems"]: ok = False for item in get.json()["items"]: tita = titl.lower().\ replace("the ","").replace(", the", "") titb = item["volumeInfo"]["title"].lower().\ replace("the ","").replace(", the", "") if titb.count(tita): if "description" in item["volumeInfo"]: ok = True break if ok: return item["volumeInfo"]["description"] def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class tb3010(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, ["ftable", "ffield"], prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.head = "Tartan Systems" return True def mainProcess(self): dats = [["ALL", "All Systems"]] syss = list(allsys.keys()) syss.sort() for s in syss: dats.append((s, allsys[s][0])) syss.append("ALL") sts = { "stype": "C", "titl": "Select the Required System", "head": ("COD", "System"), "data": dats } r1s = (("All", "A"), ("System", "S"), ("Singles", "X")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Tables", "", "X", "Y", self.doTab, None, None, None), (("T", 0, 1, 0), "IUA", 3, "System", "", "ALL", "Y", self.doSys, sts, None, ("in", syss))) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, view=("N", "V"), mail=("Y", "N")) def doTab(self, frt, pag, r, c, p, i, w): self.seltab = w if self.seltab != "S": self.sys = None return "sk1" def doSys(self, frt, pag, r, c, p, i, w): if w == "MST": self.sys = "ctl" else: self.sys = w def doEnd(self): self.df.closeProcess() self.printReport() self.opts["mf"].closeLoop() def printReport(self): if self.seltab == "X": tabs = getSingleRecords(self.opts["mf"], "ftable", ("ft_tabl", "ft_desc"), where=[("ft_seq", "=", 1)]) else: whr = [("ft_seq", "=", 1)] if self.seltab == "S": whr.append(("ft_tabl", "like", self.sys.lower() + "%")) tabs = self.sql.getRec("ftable", cols=["ft_tabl", "ft_desc"], where=whr, order="ft_tabl") if not tabs: return self.fpdf = MyFpdf(name=self.__class__.__name__, head=80) self.pgnum = 0 p = ProgressBar(self.opts["mf"].body, mxs=len(tabs), esc=True) for num, tab in enumerate(tabs): p.displayProgress(num) if p.quit: break recs = self.sql.getRec("ffield", where=[("ff_tabl", "=", tab[0])], order="ff_seq") if not recs: continue self.doHeading("F", tab[0]) for rec in recs: a = CCD(rec[1], "UI", 3).disp b = CCD(rec[2], "NA", 20).disp c = CCD(rec[3], "NA", 2).disp d = CCD(rec[4], "UD", 6.1).disp e = CCD(rec[5], "NA", 30).disp f = CCD(rec[6], "NA", 30).disp self.fpdf.drawText("%3s %-20s %2s %6s %-30s %-30s" % \ (a, b, c, d, e, f)) recs = self.sql.getRec("ftable", where=[("ft_tabl", "=", tab[0])], order="ft_seq") if not recs: continue self.doHeading("I", tab[0]) for rec in recs: a = CCD(rec[1], "NA", 20).disp b = CCD(rec[2], "UI", 1).disp c = CCD(rec[3], "NA", 1).disp d = CCD(rec[4], "NA", 10).disp e = CCD(rec[5], "NA", 10).disp f = CCD(rec[6], "NA", 10).disp g = CCD(rec[7], "NA", 10).disp h = CCD(rec[8], "NA", 10).disp i = CCD(rec[9], "NA", 10).disp j = CCD(rec[10], "NA", 10).disp self.fpdf.drawText("%-20s %2s %1s %-10s %-10s %-10s %-10s "\ "%-10s %-10s %-10s" % (a, b, c, d, e, f, g, h, i, j)) p.closeProgress() if self.fpdf.page and not p.quit: pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, 0, ext="pdf") self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=1, pdfnam=pdfnam, header="Table Fields and Indexes", repprt=self.df.repprt, repeml=self.df.repeml) def doHeading(self, htyp, table): self.fpdf.setFont(style="B") if htyp == "F": self.fpdf.add_page() self.pgnum += 1 self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-90s %-5s %5s" % ("Table Fields for "\ "Table %s" % table, "Page", self.pgnum)) head = "%3s %-20s %2s %6s %-30s %-30s" % ( "Seq", "Field Name", "Tp", "Size", "Description", "Heading") else: self.fpdf.drawText() self.fpdf.drawText("Table Indexes for Table %s" % table) head = "%-20s %2s %1s %-10s %-10s %-10s %-10s %-10s %-10s "\ "%-10s" % ("Table Description", "Sq", "T", "1st-Col", "2nd-Col", "3rd-Col", "4th-Col", "5th-Col", "6th-Col", "7th-Col") self.fpdf.drawText() self.fpdf.drawText(head) self.fpdf.underLine(head) self.fpdf.setFont() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class rt3030(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, ["rtlmst", "rtltrn", "rtlcon"], 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.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2]) return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Rentals Ledger Master Listing (%s)" % self.__class__.__name__) r1s = (("Yes", "Y"), ("No", "N")) r2s = (("All", "Y"), ("Current", "C"), ("Arrears", "A"), ("Expiring", "E"), ("Expired", "X")) fld = ((("T", 0, 0, 0), "ID1", 10, "Report Date", "", self.sysdtw, "Y", self.doDate, None, None, ("efld", )), (("T", 0, 1, 0), ("IRB", r2s), 0, "Contracts", "Contracts to Print", "Y", "Y", self.doType, None, None, None), (("T", 0, 2, 0), "IUI", 2, "Months to Expiry", "", 1, "Y", self.doMonths, None, None, ("notzero", )), (("T", 0, 3, 0), ("IRB", r1s), 0, "Consolidate", "", "N", "Y", self.doCons, 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=("N", "V"), mail=("Y", "N")) def doDate(self, frt, pag, r, c, p, i, w): self.date = w self.datd = self.df.t_disp[0][0][0] def doType(self, frt, pag, r, c, p, i, w): self.styp = w if self.styp != "E": self.months = 0 if self.styp != "Y": self.cons = "N" return "sk2" return "sk1" def doMonths(self, frt, pag, r, c, p, i, w): self.months = w if self.styp != "Y": self.cons = "N" return "sk1" def doCons(self, frt, pag, r, c, p, i, w): self.cons = w def doEnd(self): self.df.closeProcess() odr = "rtc_code, rtc_acno, rtc_cnum" whr = [("rtc_cono", "=", self.opts["conum"]), ("rtc_start", "<=", self.date)] if self.styp in ("C", "X"): whr.append(("rtc_status", "=", self.styp)) if self.cons == "Y": recs = [] cols = ["rtc_code", "rtc_acno", "max(rtc_cnum)"] accs = self.sql.getRec("rtlcon", cols=cols, where=whr, group="rtc_code, rtc_acno", order="rtc_code, rtc_acno") for acc in accs: w = copyList(whr) w.append(("rtc_code", "=", acc[0])) w.append(("rtc_acno", "=", acc[1])) w.append(("rtc_cnum", "=", acc[2])) rec = self.sql.getRec("rtlcon", where=w, limit=1) recs.append(rec) else: recs = self.sql.getRec("rtlcon", where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Selection Error", "No Records Selected") else: self.printReport(recs) self.closeProcess() def printReport(self, recs): p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) self.head = "%03u %-145s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.pglin = 999 mst = self.sql.rtlmst_col con = self.sql.rtlcon_col self.tots = [0, 0, 0, 0, 0] for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break code = CCD(dat[con.index("rtc_code")], "NA", 7) acno = CCD(dat[con.index("rtc_acno")], "NA", 7) cnum = CCD(dat[con.index("rtc_cnum")], "UI", 3) freq = CCD(dat[con.index("rtc_payind")], "UA", 1) strt = CCD(dat[con.index("rtc_start")], "D1", 10) prds = CCD(dat[con.index("rtc_period")], "UI", 3) stat = CCD(dat[con.index("rtc_status")], "UA", 1) if self.styp != "X": curdt = int(self.date / 100) if self.months: yy = int(curdt / 100) mm = (curdt % 100) + self.months while mm > 12: yy += 1 mm -= 12 curdt = (yy * 100) + mm if freq.work == "M": mths = 1 * prds.work elif freq.work == "3": mths = 3 * prds.work elif freq.work == "6": mths = 6 * prds.work else: mths = 12 * prds.work yy = int(strt.work / 10000) mm = int((strt.work % 10000) / 100) + mths - 1 while mm < 1: yy -= 1 mm += 12 while mm > 12: yy += 1 mm -= 12 chkmth = copyList(mthnam) if mm == 2: if not yy % 4: chkmth[2][2] = 29 else: chkmth[2][2] = 28 exdt = CCD(((yy * 10000) + (mm * 100) + chkmth[mm][2]), "D1", 10) if self.styp == "E" and int(exdt.work / 100) > curdt: continue else: exdt = CCD(0, "d1", 10) acc = self.sql.getRec("rtlmst", where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code", "=", code.work), ("rtm_acno", "=", acno.work)], limit=1) name = CCD(acc[mst.index("rtm_name")], "NA", 30) if self.cons == "Y": trn = self.sql.getRec( "rtltrn", cols=["rtt_type", "round(sum(rtt_tramt), 2)"], where=[("rtt_cono", "=", self.opts["conum"]), ("rtt_code", "=", code.work), ("rtt_acno", "=", acno.work), ("rtt_trdt", "<=", self.date)], group="rtt_type") else: trn = self.sql.getRec( "rtltrn", cols=["rtt_type", "round(sum(rtt_tramt), 2)"], where=[("rtt_cono", "=", self.opts["conum"]), ("rtt_code", "=", code.work), ("rtt_acno", "=", acno.work), ("rtt_cnum", "=", cnum.work), ("rtt_trdt", "<=", self.date)], group="rtt_type") rtl = CCD(0, "SD", 13.2) rec = CCD(0, "SD", 13.2) pmt = CCD(0, "SD", 13.2) jnl = CCD(0, "SD", 13.2) if trn: for t in trn: if t[0] == 1: rtl = CCD(t[1], "SD", 13.2) elif t[0] == 2: rec = CCD(t[1], "SD", 13.2) elif t[0] == 3: pmt = CCD(t[1], "SD", 13.2) elif t[0] == 4: jnl = CCD(t[1], "SD", 13.2) bal = float(ASD(rtl.work) + ASD(rec.work) + ASD(pmt.work) + \ ASD(jnl.work)) bal = CCD(bal, "SD", 13.2) 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" % \ (code.disp, acno.disp, cnum.disp, name.disp, freq.disp, strt.disp, prds.disp, exdt.disp, stat.disp, rtl.disp, rec.disp, pmt.disp, jnl.disp, bal.disp)) self.tots[0] = float(ASD(self.tots[0]) + ASD(rtl.work)) self.tots[1] = float(ASD(self.tots[1]) + ASD(rec.work)) self.tots[2] = float(ASD(self.tots[2]) + ASD(pmt.work)) self.tots[3] = float(ASD(self.tots[3]) + ASD(jnl.work)) self.tots[4] = float(ASD(self.tots[4]) + ASD(bal.work)) self.pglin += 1 t = [] for x in range(5): t.append(CCD(self.tots[x], "SD", 13.2).disp) self.fpdf.underLine(txt=self.head) self.fpdf.drawText("%19s %-30s %29s %-13s %-13s %-13s %-13s %-13s" % \ ("", "Grand Totals", "", t[0], t[1], t[2], t[3], t[4])) 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) self.closeProcess() def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-34s %-10s" % ("Rentals Ledger Master "\ "Report as at", self.datd)) self.fpdf.drawText() opts = "%-14s %-1s" % ("(Options: Type", self.styp) if self.styp == "E": opts = "%s %-6s %-2s)" % \ (opts, "Months", self.months) elif self.cons == "Y": opts = "%s %-12s %-1s)" % \ (opts, "Consolidated", self.cons) else: opts = "%s)" % opts self.fpdf.drawText(opts) self.fpdf.drawText() self.fpdf.drawText("%-7s %-7s %-3s %-30s %-1s %-10s %-3s %-10s %-1s "\ "%-13s %-13s %-13s %-13s %-13s" % ("Prm-Cod", "Acc-Num", "Seq", "Name", "F", "Start-Date", "Per", "Expir-Date", "S", " Rentals ", " Receipts ", " Payments ", " Journals ", " Balance ")) 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 bk3010(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, ["bkmmst", "bkmcon", "bkmtrn"], prog=self.__class__.__name__) if self.sql.error: return mc = GetCtl(self.opts["mf"]) bkmctl = mc.getCtl("bkmctl", self.opts["conum"]) if not bkmctl: return self.fromad = bkmctl["cbk_emadd"] t = time.localtime() self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2]) return True def mainProcess(self): tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Deposits Due") r1s = (("No","N"), ("Yes","Y")) r2s = (("Arrival","A"), ("Due","D")) fld = ( (("T",0,0,0),("IRB",r1s),0,"Expired Only","", "N","Y",self.doExpired,None,None,None), (("T",0,1,0),("IRB",r2s),0,"Order","", "A","Y",self.doOrder,None,None,None)) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) if "args" in self.opts: tops = self.opts["args"] else: tops = False self.df = TartanDialog(self.opts["mf"], tops=tops, title=tit, eflds=fld, tend=tnd, txit=txt, view=("Y","V"), mail=("Y","N")) def doExpired(self, frt, pag, r, c, p, i, w): self.expired = w def doOrder(self, frt, pag, r, c, p, i, w): self.order = w def doEnd(self): self.df.closeProcess() tab = ["bkmmst"] col = [ "bkm_number", "bkm_group", "bkm_ccode", "bkm_arrive", "bkm_depart", "bkm_stddep", "bkm_stddte", "bkm_grpdep", "bkm_grpdte", "bkm_state"] whr = [ ("bkm_cono", "=", self.opts["conum"]), ("bkm_state", "in", ("C", "Q"))] if self.order == "A": odr = "bkm_arrive, bkm_ccode" else: odr = "bkm_stddte, bkm_grpdte, bkm_ccode" recs = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr) self.fpdf = MyFpdf(name=self.__class__.__name__, head=80, auto=True) self.fpdf.header = self.pageHeading self.fpdf.add_page() newrec = [] for rec in recs: if not rec[5] and not rec[7]: continue num = CCD(rec[0], "UI", 6) trn = self.sql.getRec("bkmtrn", where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number", "=", num.work)]) inv = False bal = 0.0 for tr in trn: typ = tr[self.sql.bkmtrn_col.index("bkt_type")] amt = tr[self.sql.bkmtrn_col.index("bkt_tramt")] bal = float(ASD(bal) + ASD(amt)) if typ == 2: inv = True if inv: continue dp1 = float(ASD(rec[5]) + ASD(bal)) dt1 = rec[6] if dp1 > 0: dp2 = rec[7] dt2 = rec[8] elif rec[7]: dp2 = float(ASD(rec[7]) + ASD(dp1)) dt2 = rec[8] dp1 = 0 else: dp1 = 0 dp2 = 0 dt2 = 0 if self.expired == "Y": if dp1 and dt1 > self.sysdtw: continue if not dp1 and dp2 and dt2 > self.sysdtw: continue elif dp1 <= 0 and dp2 <= 0: continue if dp1 and dp1 > 0: b = CCD(dt1, "D1", 10).disp if dp2: b = "%s\n%s" % (b, CCD(dt2, "D1", 10).disp) elif dp2 and dp2 > 0: b = CCD(dt2, "D1", 10).disp else: continue con = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", rec[2])], limit=1) snam = con[self.sql.bkmcon_col.index("bkc_sname")] fnam = con[self.sql.bkmcon_col.index("bkc_names")] if fnam: c = "%s %s" % (fnam.split()[0], snam) else: c = snam l = 8 if rec[1]: c = "%s\n%s" % (c, rec[1]) l = 16 d = CCD(rec[3], "D1", 10).disp e = CCD(rec[4], "D1", 10).disp if dp1: f = CCD(dp1, "UD", 10.2).disp if dp2: f = "%s\n%s" % (f, CCD(dp2, "UD", 10.2).disp) l = 16 else: f = CCD(dp2, "UD", 10.2).disp newrec.append([num.disp, b, c, d, e, f]) if newrec: if self.order == "D": newrec = sorted(newrec, key=itemgetter(1)) for rec in newrec: if self.fpdf.get_y() + l > 260: self.fpdf.add_page() self.printLine(rec[0], rec[1], rec[2], rec[3], rec[4], rec[5]) if self.fpdf.page: 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"], header=self.head, pdfnam=pdfnam, repprt=self.df.repprt, fromad=self.fromad, repeml=self.df.repeml) if "wait" not in self.opts: self.opts["mf"].closeLoop() def pageHeading(self): cd1 = "%-30s" % self.opts["conam"] self.fpdf.drawText(cd1, x=7, font=["courier", "B", 24]) self.fpdf.drawText(font=["courier", "B", 14]) if self.expired == "N": cd2 = "Deposits Due Report" else: cd2 = "Deposits Expired Report" self.head = "%s - %s" % (cd1, cd2) self.fpdf.drawText(cd2, x=7, font=["courier", "B", 16]) self.fpdf.drawText(font=["courier", "B", 14]) self.printLine("Number", " Due-Date ", "%-20s" % "Name & Group", " Arrive ", " Depart ", " Amount", fill=1) def printLine(self, a, b, c, d, e, f, fill=0): ft = ["courier", "B", 13] self.fpdf.set_font(ft[0], ft[1], ft[2]) c, cq = self.getLines(c, self.fpdf.get_string_width("X"*21)) f, fq = self.getLines(f, self.fpdf.get_string_width("X"*11)) if cq > fq: ch = 8 h = cq * 8 fh = int(h / fq) elif fq > cq: fh = 8 h = fq * 8 ch = int(h / cq) else: h = cq * 8 ch = fh = 8 if cq > 1 or fq > 1: ctyp = "M" else: ctyp = "S" # Booking number x = 7 y = self.fpdf.get_y() w = self.fpdf.get_string_width("X"*7) self.fpdf.drawText(a, x=x, y=y, w=w, h=h, border="TLB", fill=fill, ctyp=ctyp, font=ft) # Name and group x += w w = self.fpdf.get_string_width("X"*21) self.fpdf.drawText(c, x=x, y=y, w=w, h=ch, border="TLB", fill=fill, ctyp=ctyp, font=ft) # Arrival date x += w w = self.fpdf.get_string_width("X"*11) self.fpdf.drawText(d, x=x, y=y, w=w, h=h, border="TLB", fill=fill, ctyp=ctyp, font=ft) # Departure date x += w w = self.fpdf.get_string_width("X"*11) self.fpdf.drawText(e, x=x, y=y, w=w, h=h, border="TLB", fill=fill, ctyp=ctyp, font=ft) # Deposit due date x += w w = self.fpdf.get_string_width("X"*11) self.fpdf.drawText(b, x=x, y=y, w=0, h=fh, border="TLB", fill=fill, ctyp=ctyp, font=ft) # Deposit amount x += w w = self.fpdf.get_string_width("X"*11) self.fpdf.drawText(f, x=x, y=y, w=w, h=fh, border="TLRB", fill=fill, ctyp=ctyp, font=ft) def getLines(self, t, w): tmp = t.split("\n") nam = self.fpdf.multi_cell(w, 8, tmp[0], split_only=True) t = nam[0] q = 1 for n in nam[1:]: t = "%s\n%s" % (t, n) q += 1 if len(tmp) > 1: nam = self.fpdf.multi_cell(w, 8, tmp[1], split_only=True) for n in nam: t = "%s\n%s" % (t, n) q += 1 return t, q def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class ln3030(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, ["lonmf1", "lonmf2", "lontrn"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) lonctl = gc.getCtl("lonctl", self.opts["conum"]) if not lonctl: return self.fromad = lonctl["cln_emadd"] t = time.localtime() self.curdt = int(((t[0] * 10000) + (t[1] * 100) + t[2]) / 100) return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Loans Balances Listing (%s)" % self.__class__.__name__) r1s = (("Number", "N"), ("Name", "M")) r2s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "ID2", 7, "Reporting Period", "", self.curdt, "Y", self.doDate, None, None, ("efld", )), (("T", 0, 1, 0), ("IRB", r1s), 1, "Sort Order", "", "N", "Y", self.doSort, None, None, None), (("T", 0, 2, 0), ("IRB", r2s), 1, "Include Zero Balances", "", "N", "Y", self.doZero, None, None, None), (("T", 0, 3, 0), ("IRB", r2s), 1, "Include Pending Interest", "", "N", "Y", self.doPend, 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=("N", "V"), mail=("Y", "N")) def doDate(self, frt, pag, r, c, p, i, w): self.curdt = w self.cdte = self.df.t_disp[pag][0][i] self.date = mthendDate(w * 100) def doSort(self, frt, pag, r, c, p, i, w): self.sort = w def doZero(self, frt, pag, r, c, p, i, w): self.zero = w def doPend(self, frt, pag, r, c, p, i, w): self.pend = w def doEnd(self): self.df.closeProcess() if self.sort == "N": odr = "lm1_acno" else: odr = "lm1_name" lm1 = self.sql.getRec("lonmf1", where=[("lm1_cono", "=", self.opts["conum"])], order=odr) if not lm1: showError(self.opts["mf"].body, "Loans Error", "No Loans Selected") else: self.printReport(lm1) self.closeProcess() def printReport(self, recs): p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) if self.pend == "Y": self.head = "%03u %-118s" % (self.opts["conum"], self.opts["conam"]) else: self.head = "%03u %-90s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) ltot = 0 itot = 0 ntot = 0 self.pglin = 999 for num, rec in enumerate(recs): p.displayProgress(num) if p.quit: break acc = CCD(rec[self.sql.lonmf1_col.index("lm1_acno")], "UA", 7) nam = CCD(rec[self.sql.lonmf1_col.index("lm1_name")], "NA", 28) lm2 = self.sql.getRec("lonmf2", where=[("lm2_cono", "=", self.opts["conum"]), ("lm2_acno", "=", acc.work)], order="lm2_loan") for dat in lm2: lon = CCD(dat[self.sql.lonmf2_col.index("lm2_loan")], "UI", 2) des = CCD(dat[self.sql.lonmf2_col.index("lm2_desc")], "NA", 30) dte = CCD(dat[self.sql.lonmf2_col.index("lm2_start")], "d1", 10) col = ["sum(lnt_tramt)"] whr = [("lnt_cono", "=", self.opts["conum"]), ("lnt_acno", "=", acc.work), ("lnt_loan", "=", lon.work), ("lnt_curdt", "<=", self.curdt)] lbal = self.sql.getRec("lontrn", cols=col, where=whr, limit=1) lbal = CCD(lbal[0], "SD", 13.2) if self.zero == "N" and not lbal.work: continue if self.pglin > self.fpdf.lpp: self.pageHeading() ltot = float(ASD(ltot) + ASD(lbal.work)) if self.pend == "Y": LoanInterest("L", self.opts["mf"].dbm, dat, update="Y", tdate=self.date, batch="Pending", curdt=self.curdt) nbal = self.sql.getRec("lontrn", cols=col, where=whr, limit=1) nbal = CCD(nbal[0], "SD", 13.2) ntot = float(ASD(ntot) + ASD(nbal.work)) ibal = CCD(nbal.work - lbal.work, "SD", 13.2) itot = float(ASD(itot) + ASD(ibal.work)) self.fpdf.drawText( "%s %s %s %s %s %s %s %s" % (acc.disp, nam.disp, lon.disp, des.disp, dte.disp, lbal.disp, ibal.disp, nbal.disp)) else: self.fpdf.drawText("%s %s %s %s %s %s" % (acc.disp, nam.disp, lon.disp, des.disp, dte.disp, lbal.disp)) self.pglin += 1 p.closeProgress() if self.fpdf.page and not p.quit: self.fpdf.underLine(txt=self.head) ltot = CCD(ltot, "SD", 13.2) if self.pend == "Y": itot = CCD(itot, "SD", 13.2) ntot = CCD(ntot, "SD", 13.2) self.fpdf.drawText( "%8s%-74s%13s %13s %13s" % ("", "Totals", ltot.disp, itot.disp, ntot.disp)) else: self.fpdf.drawText("%8s%-74s%13s" % ("", "Totals", ltot.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, fromad=self.fromad, repeml=self.df.repeml) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() txt = "%-29s %-7s" % ("Loans Balances Listing as at", self.cdte) self.fpdf.drawText(txt=txt) self.fpdf.drawText() self.fpdf.drawText("%s %s %s %s)" % \ ("(Options: Sort:", self.sort, "Include-Zero-Bal:", self.zero)) self.fpdf.drawText() txt = "%-7s %-28s %-2s %-30s %-10s" % \ ("Acc-Num", "Name", "Ln", "Description", "Start-Date") if self.pend == "Y": txt = "%s %13s %13s %13s" % \ (txt, "Ledger-Bal ", "Interest ", "Balance ") else: txt = "%s %13s" % (txt, "Balance ") self.fpdf.drawText(txt=txt) 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 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 rt4010(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, ["rtlprm", "rtlmst", "rtlcon", "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 t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2]) return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Rental Ledger Interrogation (%s)" % self.__class__.__name__) prm = { "stype": "R", "tables": ("rtlprm", ), "cols": (("rtp_code", "", 0, "Prm-Code"), ("rtp_desc", "", 0, "Description", "Y")), "where": [("rtp_cono", "=", self.opts["conum"])] } acc = { "stype": "R", "tables": ("rtlmst", ), "cols": (("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")), "where": [("rtm_cono", "=", self.opts["conum"])], "whera": (("T", "rtm_code", 0, 0), ) } seq = { "stype": "R", "tables": ("rtlcon", ), "cols": (("rtc_cnum", "", 0, "Acc-Num"), ("rtc_payind", "", 0, "F"), ("rtc_start", "", 0, "Start-Date"), ("rtc_period", "", 0, "Per")), "where": [("rtc_cono", "=", self.opts["conum"])], "whera": [["T", "rtc_code", 0, 0], ["T", "rtc_acno", 1, 0]] } tag = (("Premises", self.doTagSelect, ("T", 0, 0), ("T", 0, 1)), ("Tenant", self.doTagSelect, ("T", 0, 0), ("T", 0, 1)), ("Balances", self.doTagSelect, ("T", 0, 0), ("T", 0, 1)), ("Transactions", self.doTrans1, ("T", 0, 0), ("T", 0, 1))) fld = ((("T", 0, 0, 0), "INA", 7, "Premises", "Premises Code", "", "Y", self.doPremises, prm, None, ("notblank", )), (("T", 0, 0, 0), "INA", 7, "Account", "Account Code", "", "N", self.doAccount, acc, None, ("notblank", )), (("T", 0, 0, 0), "ONA", 30, "Name"), (("T", 1, 0, 0), "ONA", 30, "Description"), (("T", 1, 1, 0), "ONA", 30, "Address-1"), (("T", 1, 2, 0), "ONA", 30, "Address-2"), (("T", 1, 3, 0), "ONA", 30, "Address-3"), (("T", 1, 4, 0), "ONA", 4, "Postal Code"), (("T", 2, 0, 0), "ONA", 30, "Address-1"), (("T", 2, 1, 0), "ONA", 30, "Address-2"), (("T", 2, 2, 0), "ONA", 30, "Address-3"), (("T", 2, 3, 0), "ONA", 4, "Postal Code"), (("T", 2, 4, 0), "ONA", 20, "Telephone Number"), (("T", 2, 5, 0), "OTX", 50, "E-Mail Address"), (("T", 2, 6, 0), "OUA", 1, "VAT Indicator"), (("T", 2, 7, 0), "ONA", 10, "VAT Number"), (("T", 2, 8, 0), "OUA", 1, "Payment Frequency"), (("T", 2, 9, 0), "OD1", 10, "Start Date"), (("T", 2, 10, 0), "OUI", 3, "Number of Periods"), (("T", 2, 11, 0), "OUD", 12.2, "Rental Amount"), (("T", 2, 12, 0), "OUA", 1, "Status"), (("C", 3, 0, 0), "OSD", 13.2, "Value", "", "", "N", None, None, None, None, ("Details", 5)), (("T", 4, 0, 0), "IUI", 3, "Sequence Number", "", "N", "N", self.doTrans2, seq, None, None)) but = (("Clear", None, self.doClear, 0, ("T", 0, 0), ("T", 0, 1)), ("Notes", None, self.doNotes, 0, ("T", 0, 0), ("T", 0, 1)), ("Print", None, self.doPrint, 0, ("T", 0, 0), ("T", 0, 1)), ("Quit", None, self.doExit, 1, None, None)) tnd = ((self.doEndTop, "N"), None, None, None, None) txt = (self.doExit, None, None, None, self.doExit) self.df = TartanDialog(self.opts["mf"], title=self.tit, tags=tag, eflds=fld, butt=but, tend=tnd, txit=txt) self.df.colLabel[3][0].configure(text="Rentals ") self.df.colLabel[3][1].configure(text="Receipts") self.df.colLabel[3][2].configure(text="Payments") self.df.colLabel[3][3].configure(text="Journals") self.df.colLabel[3][4].configure(text="Balance ") def doPremises(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlprm", where=[("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", w)], limit=1) if not acc: return "Invalid Premises" self.code = w for num, fld in enumerate(acc): if num < 2 or num > 6: continue self.df.loadEntry("T", 1, (num - 2), data=fld) def doAccount(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlmst", where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code", "=", self.code), ("rtm_acno", "=", w)], limit=1) if not acc: return "Invalid Account" self.acno = w self.name = acc[self.sql.rtlmst_col.index("rtm_name")] con = self.sql.getRec("rtlcon", where=[("rtc_cono", "=", self.opts["conum"]), ("rtc_code", "=", self.code), ("rtc_acno", "=", self.acno)], order="rtc_cnum") if not con: return "Invalid Contract" self.df.loadEntry(frt, pag, p + 1, data=acc[3]) for num, fld in enumerate(acc[4:]): self.df.loadEntry("T", 2, num, data=fld) self.cnum = con[-1:][0][3] self.df.topf[4][0][5] = self.cnum for num, fld in enumerate(con[-1:][0][4:-1]): self.df.loadEntry("T", 2, num + 8, data=fld) self.loadBalances() self.opts["mf"].updateStatus("") def doEndTop(self): self.df.last[0] = [0, 0] self.df.setWidget(self.df.topEntry[0][0], state="disabled") def loadBalances(self): rtl = 0 rec = 0 pmt = 0 jnl = 0 bal = self.sql.getRec("rtltrn", cols=["rtt_type", "round(sum(rtt_tramt), 2)"], where=[("rtt_cono", "=", self.opts["conum"]), ("rtt_code", "=", self.code), ("rtt_acno", "=", self.acno)], group="rtt_type", order="rtt_type") if bal: for a in bal: if a[0] == 1: rtl = a[1] if a[0] == 2: rec = a[1] if a[0] == 3: pmt = a[1] if a[0] == 4: jnl = a[1] bal = float(ASD(rtl) + ASD(rec) + ASD(pmt) + ASD(jnl)) self.df.loadEntry("C", 3, 0, data=rtl) self.df.loadEntry("C", 3, 1, data=rec) self.df.loadEntry("C", 3, 2, data=pmt) self.df.loadEntry("C", 3, 3, data=jnl) self.df.loadEntry("C", 3, 4, data=bal) self.trn = self.sql.getRec("rtltrn", where=[("rtt_cono", "=", self.opts["conum"]), ("rtt_code", "=", self.code), ("rtt_acno", "=", self.acno)], order="rtt_trdt, rtt_type") def doTagSelect(self): self.opts["mf"].updateStatus("") def doTrans1(self): self.df.focusField("T", 4, 1) def doTrans2(self, frt, pag, r, c, p, i, w): tit = "Transactions for Account: %s %s - %s" % \ (self.code, self.acno, self.name) tab = ["rtltrn"] col = (("rtt_trdt", "", 0, " Date"), ("rtt_curdt", "", 0, "Curr-Dt"), ("rtt_batch", "", 0, "Batch"), ("rtt_type", ("XX", rttrtp), 3, "Typ"), ("rtt_refno", "", 0, "Reference", "Y"), ("rtt_tramt", "", 0, " Amount"), ("rtt_taxamt", "", 0, " VAT-Amount"), ("rtt_desc", "", 0, "Details")) whr = [("rtt_cono", "=", self.opts["conum"]), ("rtt_code", "=", self.code), ("rtt_acno", "=", self.acno)] if w: whr.append(("rtt_cnum", "=", w)) odr = "rtt_trdt, rtt_type" state = self.df.disableButtonsTags() SRec(self.opts["mf"], screen=self.df.nb.Page2, title=tit, tables=tab, cols=col, where=whr, order=odr) self.df.enableButtonsTags(state=state) self.doTrans1() def doNotes(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") NotesCreate(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["capnm"], "RTL", "%7s%s" % (self.code, self.acno)) self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) def doClear(self): self.df.selPage("Premises") self.df.focusField("T", 0, 1) def doPrint(self): mess = "Select the Required Print Option." butt = (("Information", "I"), ("Transactions", "T"), ("Both", "B"), ("None", "N")) self.doPrintOption( askChoice(self.opts["mf"].body, "Print Options", mess, butt=butt)) if self.df.topq[self.df.pag]: self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doPrintOption(self, opt): if opt == "N": return self.head = "%03u %-101s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.pglin = 999 if opt != "T": self.pageHeading() self.printInfo() pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, self.opts["conum"], ext="pdf") if opt == "I": self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) elif opt == "B": if not self.trn: self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) else: self.pageHeading() self.pageHeadingTrans() self.printTrans() self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) elif opt == "T": if self.trn: self.pageHeading() self.pageHeadingTrans() self.printTrans() self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) def printInfo(self): for x in range(0, len(self.df.topf[0])): self.fpdf.drawText( "%-26s%-25s %s" % ("", self.df.topf[0][x][3], self.df.t_disp[0][0][x])) self.fpdf.drawText() for x in range(0, len(self.df.topf[1])): self.fpdf.drawText( "%-26s%-25s %s" % ("", self.df.topf[1][x][3], self.df.t_disp[1][0][x])) self.fpdf.drawText() for x in range(0, len(self.df.topf[2])): self.fpdf.drawText( "%-26s%-25s %s" % ("", self.df.topf[2][x][3], self.df.t_disp[2][0][x])) self.fpdf.drawText() self.pglin += 3 + len(self.df.topf[3]) self.fpdf.setFont(style="B") self.fpdf.drawText("%26s%-34s %13s" % ("", "Details", "Amount ")) self.fpdf.drawText("%26s%s" % ("", self.fpdf.suc * 48)) self.fpdf.setFont() desc = ("Rentals ", "Receipts", "Payments", "Journals", "Balance ") for n, d in enumerate(self.df.c_disp[3]): self.fpdf.drawText("%26s%-34s %13s" % ("", desc[n], d[0])) def printTrans(self): col = self.sql.rtltrn_col bal = 0 for ct in self.trn: trdt = CCD(ct[col.index("rtt_trdt")], "D1", 10) refno = CCD(ct[col.index("rtt_refno")], "Na", 9) trtp = CCD(ct[col.index("rtt_type")], "UI", 1) batch = CCD(ct[col.index("rtt_batch")], "Na", 7) desc = CCD(ct[col.index("rtt_desc")], "NA", 30) tramt = ct[col.index("rtt_tramt")] if tramt < 0: debit = CCD(0, "SD", 13.2) credit = CCD(tramt, "SD", 13.2) else: debit = CCD(tramt, "SD", 13.2) credit = CCD(0, "SD", 13.2) bal = float(ASD(bal) + ASD(tramt)) tot = CCD(bal, "SD", 13.2) taxamt = CCD(ct[col.index("rtt_taxamt")], "SD", 13.2) if self.pglin > self.fpdf.lpp: self.pageHeading() self.pageHeadingTrans() self.fpdf.drawText( "%s %s %s %s %s %s %s %s %s" % (trdt.disp, refno.disp, rttrtp[(trtp.work - 1)][0], batch.disp, desc.disp, debit.disp, credit.disp, tot.disp, taxamt.disp)) self.pglin += 1 def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-34s %-10s" % \ ("Rentals Ledger Interrogation as at", self.sysdtd)) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 6 def pageHeadingTrans(self): self.fpdf.drawText( "%-16s %s %s %s %s %s %s %s %s" % ("", self.df.topf[0][0][3], self.df.t_disp[0][0][0], "", self.df.topf[0][1][3], self.df.t_disp[0][0][1], "", self.df.topf[0][2][3], self.df.t_disp[0][0][2])) self.fpdf.drawText() self.fpdf.setFont(style="B") self.fpdf.drawText("%-10s %-9s %-3s %-7s %-30s %-13s %-13s %-13s" % \ (" Date", "Reference", "Typ", "Batch", "Remarks", " Debit", " Credit", " Balance")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 8 def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class si3040(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, ["strgrp", "strloc", "strmf1"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) drsctl = gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: self.chnstr = "N" else: self.chnstr = drsctl["ctd_chain"] strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.locs = strctl["cts_locs"] slsctl = gc.getCtl("slsctl", self.opts["conum"]) if not slsctl: return self.fromad = slsctl["ctv_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.forms = [("UA", 3), ("NA", 20), ("NA", 30), ("NA", 10)] + [("SI", 10)] * 12 self.stots = [0] * 12 self.gtots = [0] * 12 self.mchart = [] self.tipe = None return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Product Sales History (%s)" % self.__class__.__name__) loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } chm = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Chn"), ("chm_name", "", 0, "Name", "Y")), "where": (("chm_cono", "=", self.opts["conum"]), ) } r1s = (("Quantity", "Q"), ("Value", "V"), ("Profit", "P")) r2s = (("Yes", "Y"), ("No", "N")) if "args" in self.opts and "noprint" in self.opts["args"]: var = self.opts["args"]["work"][0] self.accs = self.opts["args"]["work"][1] view = None mail = None else: var = ["", "V", "", "", 0, "Y"] self.accs = [] view = ("Y", "V") mail = ("Y", "N") fld = ((("T", 0, 0, 0), "ID2", 7, "Cut-Off Period", "", int(self.sysdtw / 100), "Y", self.doCut, None, None, ("efld", )), (("T", 0, 1, 0), ("IRB", r1s), 0, "Type", "", var[1], "N", self.doType, None, None, None), (("T", 0, 2, 0), "IUA", 1, "Location", "", var[2], "N", self.doLoc, loc, None, ("efld", )), (("T", 0, 3, 0), "IUA", 3, "Product Group", "", var[3], "N", self.doGroup, grp, None, None), (("T", 0, 4, 0), "IUI", 3, "Chain Store", "", var[4], "N", self.doDrsChn, chm, None, None), (("T", 0, 5, 0), ("IRB", r2s), 0, "All Accounts", "", var[5], "N", self.doDrsAcc, 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 doCut(self, frt, pag, r, c, p, i, w): self.coffw = w self.coffd = self.df.t_disp[pag][r][p] def doType(self, frt, pag, r, c, p, i, w): self.rtype = w if self.locs == "N": self.loc = "" self.locd = "ALL" return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): if not w: self.locd = "ALL" else: acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not acc: return "Invalid Location" self.locd = "%s %s" % (w, acc[0]) self.loc = w def doGroup(self, frt, pag, r, c, p, i, w): if w: acc = self.getGroup(w) if not acc: return "Invalid Group" self.grp = w if self.chnstr == "N": self.chain = "" self.df.loadEntry(frt, pag, p + 1, data="") return "sk1" def doDrsChn(self, frt, pag, r, c, p, i, w): self.chain = w def doDrsAcc(self, frt, pag, r, c, p, i, w): self.acno = [] if w == "Y": return whr = [("drm_cono", "=", self.opts["conum"])] if self.chain: whr.append(("drm_chain", "=", self.chain)) acc = getSingleRecords(self.opts["mf"], "drsmst", ("drm_acno", "drm_name"), where=whr, order="drm_chain, drm_acno", items=[0, self.accs]) for a in acc: self.acno.append(a[2]) def doEnd(self): self.df.closeProcess() if not self.grp: sgrp = "" egrp = "zzz" else: sgrp = egrp = self.grp recs = self.sql.getRec( "strmf1", cols=["st1_group", "st1_code", "st1_desc", "st1_uoi"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", ">=", sgrp), ("st1_group", "<=", egrp)], order="st1_group, st1_code") if not recs: showError(self.opts["mf"].body, "Processing Error", "No Records Selected") else: self.start = self.coffw - 99 if self.start % 100 == 13: self.start = self.start + 88 s = self.start % 100 self.mthhead = "" self.colsh = ["Grp", "Stock-Code", "Description", "U.O.I."] for _ in range(12): if self.mthhead: self.mthhead = "%s%9s " % (self.mthhead, mthnam[s][1]) else: self.mthhead = "%9s " % mthnam[s][1] self.colsh.append(mthnam[s][1]) s += 1 if s == 13: s = 1 if 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.t_work.append(self.acno) 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("Stores Sales History for the 12 Month Period "\ "to %s" % self.coffd) 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 cod, dsc, uoi, amt, purchd, purchw = vals line = ["BODY", [self.grp.work, cod.work, dsc.work, uoi.work]] line[1].extend(purchw) 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) self.head = "%03u %-182s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.pglin = 999 self.lstgrp = "" for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break vals = self.getValues(dat) if not vals: continue cod, dsc, uoi, amt, purchd, purchw = vals if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText( "%s %s %s %s %s" % (self.grp.disp, cod.disp, dsc.disp, uoi.disp, purchd)) self.pglin += 1 self.lstgrp = self.grp.work p.closeProgress() if not self.fpdf.page or p.quit: return self.groupTotal() self.grandTotal() if "args" in self.opts and "noprint" in self.opts["args"]: return 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) if self.df.repprt[1] == "X" or not self.tipe: return CreateChart(self.opts["mf"], self.opts["conum"], self.opts["conam"], [self.start, self.coffw], [[self.opts["conam"], "Product Sales History"], self.tipe], None, self.mchart, ylab=self.tipe) def getValues(self, data): self.grp = CCD(data[0], "UA", 3) if self.df.repprt[2] != "export": if self.lstgrp and self.lstgrp != self.grp.work: self.groupTotal() cod = CCD(data[1], "NA", 20) dsc = CCD(data[2], "NA", 30) uoi = CCD(data[3], "NA", 10) bals = Balances(self.opts["mf"], "STR", self.opts["conum"], self.coffw, keys=(self.grp.work, cod.work, self.loc, ("S", self.start))) more = [] if self.chain: more.append(("stt_chain", "=", self.chain)) if self.acno: more.append(("stt_acno", "in", tuple(self.acno))) this, hist = bals.doStrHist(more=more) bals = hist[2] purchd = "" purchw = [] tot = 0 for x in range(11, -1, -1): if self.rtype == "Q": amt = float(ASD(0) - ASD(bals[x][0])) elif self.rtype == "V": amt = float(ASD(0) - ASD(bals[x][2])) else: amt = float(ASD(0) - ASD(bals[x][2]) + ASD(bals[x][1])) amt = CCD(round(amt, 0), "SI", 10) tot = float(ASD(tot) + ASD(amt.work)) self.stots[x] = float(ASD(self.stots[x]) + ASD(amt.work)) self.gtots[x] = float(ASD(self.gtots[x]) + ASD(amt.work)) purchd = purchd + amt.disp purchw.append(amt.work) if tot == 0: return return (cod, dsc, uoi, amt, purchd, purchw) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-47s %-7s" % \ ("Stores Sales History for the 12 Month Period to", self.coffd)) self.fpdf.drawText() acc = self.getGroup(self.grp.work) if acc: grpd = acc[0] else: grpd = "Missing Group Record" if self.rtype == "Q": self.tipe = "Quantities" elif self.rtype == "V": self.tipe = "Values" else: self.tipe = "Profits" self.fpdf.drawText("%s %s %s %s %s %s" % \ ("Group:", self.grp.disp, grpd, "Location:", self.locd, self.tipe)) self.fpdf.drawText() self.fpdf.drawText("%-3s %-20s %-30s %-10s %s" % \ ("Grp", "Stock-Code", "Description", "U.O.I.", self.mthhead)) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 8 def getGroup(self, grp): acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", grp)], limit=1) return acc def groupTotal(self): purchd = "" mchart = ["T", "Group %s Totals" % self.lstgrp] p = None for x in range(11, -1, -1): a = CCD(self.stots[x], "SI", 10) self.stots[x] = 0 purchd = purchd + a.disp mchart.append(a.work) if a.work: p = "y" if p: self.mchart.append(mchart) self.fpdf.drawText() self.fpdf.drawText("%-24s %-41s %s" % (" ", mchart[1], purchd)) self.pageHeading() def grandTotal(self): if self.df.repprt[2] == "export": self.expdatas.append(["ULINES"]) datas = ["TOTAL", ["", "", "Grand Totals", ""]] for x in range(11, -1, -1): datas[1].append(CCD(self.gtots[x], "SI", 10).work) self.expdatas.append(datas) self.expdatas.append(["ULINED"]) return purchd = "" mchart = ["T", "Grand Totals"] for x in range(11, -1, -1): a = CCD(self.gtots[x], "SI", 10) purchd = purchd + a.disp mchart.append(a.work) self.mchart.append(mchart) self.fpdf.drawText() self.fpdf.drawText("%-24s %-41s %s" % (" ", mchart[1], purchd)) 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 sl4010(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, ["ctlynd", "wagmst", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) wagctl = gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2]) # Get the current period starting date period = self.sql.getRec("ctlynd", cols=["max(cye_period)"], where=[("cye_cono", "=", self.opts["conum"])], limit=1)[0] self.opts["period"] = getPeriods(self.opts["mf"], self.opts["conum"], period)[0].work return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Staff Loans Interrogation (%s)" % self.__class__.__name__) wgm = { "stype": "R", "tables": ("waglmf", "wagmst"), "cols": ( ("wlm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0, "Names")), "where": [ ("wlm_cono", "=", self.opts["conum"]), ("wgm_cono=wlm_cono",), ("wgm_empno=wlm_empno",)], "group": "wlm_empno"} lnm = { "stype": "R", "tables": ("waglmf",), "cols": ( ("wlm_empno", "", 0, "EmpNo"), ("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0, "Description", "Y")), "where": [("wlm_cono", "=", self.opts["conum"])], "whera": [["T", "wlm_empno", 0, 0]], "order": "wlm_empno, wlm_loan", "index": 1} r1s = (("Yes", "Y"), ("No", "N")) tag = ( ("General", self.doGeneral, ("T",0,0), ("T",0,1)), ("Trans", self.doTrans1, ("T",0,0), ("T",0,1))) fld = ( (("T",0,0,0),"IUI",5,"Emp-Num","Employee Number", "","N",self.doEmp,wgm,None,("notzero",)), (("T",0,0,0),"ONA",40,"Name"), (("T",0,1,0),"IUI",5,"Loan-Num","Loan Number", "","N",self.doLoan,lnm,None,("notzero",)), (("T",0,1,0),"ONA",40,"Desc"), (("T",1,0,0),"OUI",3,"Deduction Code"), (("T",1,1,0),"OUD",6.2,"Interest Percentage"), (("T",1,2,0),"OD1",10,"Start Date"), (("T",1,3,0),"OSD",13.2,"Deduction Amount"), (("T",1,4,0),"OSD",13.2,"Total Advances"), (("T",1,5,0),"OSD",13.2,"Total Interest"), (("T",1,6,0),"OSD",13.2,"Total Repayments"), (("T",1,7,0),"OSD",13.2,"Total Adjustments"), (("T",1,8,0),"OSD",13.2,"Balance"), (("T",1,9,0),"Od1",10,"Last Interest Raised"), (("T",1,10,0),"Od1",10,"Last Payment Received"), (("T",2,0,0),("IRB",r1s),0,"History","", "Y","Y",self.doTrans2,None,None,None)) tnd = ((self.doEndTop,"N"), None, None) txt = (self.doExit, None, None) cnd = (None, None, None) cxt = (None, None, None) but = ( ("Clear",None,self.doClear,0,("T",0,0),("T",0,1)), ("Print",None,self.doPrint,0,("T",0,0),("T",0,1)), ("Quit",None,self.doExit,1,None,None)) self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, tags=tag, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doEmp(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("wagmst", cols=["wgm_sname", "wgm_fname"], where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", w)], limit=1) if not acc: return "Invalid Employee Number" self.empno = w self.name = "%s, %s" % (acc[0], acc[1]) self.history = "Y" self.df.loadEntry("T", pag, p+1, data=self.name) def doLoan(self, frt, pag, r, c, p, i, w): lmc = self.sql.waglmf_col rec = self.sql.getRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno), ("wlm_loan", "=", w)], limit=1) if not rec: return "Invalid Loan Number" self.loan = w self.desc = rec[lmc.index("wlm_desc")] self.df.loadEntry("T", pag, p+1, data=self.desc) self.df.loadEntry("T", 1, 0, data=rec[lmc.index("wlm_code")]) self.df.loadEntry("T", 1, 1, data=rec[lmc.index("wlm_rate")]) self.df.loadEntry("T", 1, 2, data=rec[lmc.index("wlm_start")]) self.df.loadEntry("T", 1, 3, data=rec[lmc.index("wlm_repay")]) # Raise Interest LoanInterest("S", self.opts["mf"].dbm, rec, update="Y", curdt=int(self.sysdtw / 100), tdate=self.sysdtw, refno="Pending") # Get Balances self.lon = 0.0 self.imt = 0.0 self.pay = 0.0 self.adj = 0.0 self.bal = 0.0 self.idt = 0 self.pdt = 0 whr = [ ("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=", self.empno), ("wlt_loan", "=", self.loan)] odr = "wlt_trdt, wlt_type" self.wlt = self.sql.getRec("wagltf", where=whr, order=odr) if self.wlt: col = self.sql.wagltf_col for rec in self.wlt: dat = CCD(rec[col.index("wlt_trdt")], "d1", 10) typ = CCD(rec[col.index("wlt_type")], "UI", 2) amt = CCD(rec[col.index("wlt_amt")], "SD",13.2) self.bal = float(ASD(self.bal) + ASD(amt.work)) if typ.work == 1: self.idt = dat.work self.imt = float(ASD(self.imt) + ASD(amt.work)) elif typ.work in (2, 3): self.lon = float(ASD(self.lon) + ASD(amt.work)) elif typ.work == 4: self.pay = float(ASD(self.pay) + ASD(amt.work)) self.pdt = dat.work elif typ.work == 5: self.adj = float(ASD(self.adj) + ASD(amt.work)) # Load Balances self.df.loadEntry("T", 1, 4, data=self.lon) self.df.loadEntry("T", 1, 5, data=self.imt) self.df.loadEntry("T", 1, 6, data=self.pay) self.df.loadEntry("T", 1, 7, data=self.adj) self.df.loadEntry("T", 1, 8, data=self.bal) self.df.loadEntry("T", 1, 9, data=self.idt) self.df.loadEntry("T", 1, 10, data=self.pdt) self.opts["mf"].updateStatus("") def doHist(self, frt, pag, r, c, p, i, w): self.history = w def doEndTop(self): self.df.last[0] = [0, 0] self.df.setWidget(self.df.topEntry[0][0], state="disabled") def loadBalances(self): whr = [ ("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=", self.empno), ("wlt_loan", "=", self.loan)] odr = "wlt_trdt, wlt_type" self.wlt = self.sql.getRec("wagltf", where=whr, order=odr) if self.wlt: for rec in self.wlt: dat = CCD(rec[self.sql.wagltf_col.index("wlt_trdt")], "d1", 10) typ = CCD(rec[self.sql.wagltf_col.index("wlt_type")], "UI", 2) amt = CCD(rec[self.sql.wagltf_col.index("wlt_amt")], "SD",13.2) self.bal = float(ASD(self.bal) + ASD(amt.work)) self.cap = float(ASD(self.cap) + ASD(amt.work)) if typ.work == 1: if dat.work >= self.opts["period"] and \ dat.work >= self.df.t_work[1][0][3]: self.cap = float(ASD(self.cap) - ASD(amt.work)) self.due = float(ASD(self.due) + ASD(amt.work)) self.imt = float(ASD(self.imt) + ASD(amt.work)) self.idt = dat.work elif typ.work in (2, 3): self.lon = float(ASD(self.lon) + ASD(amt.work)) elif typ.work == 4: self.pay = float(ASD(self.pay) + ASD(amt.work)) self.pdt = dat.work elif typ.work == 5: self.adj = float(ASD(self.adj) + ASD(amt.work)) def doGeneral(self): self.opts["mf"].updateStatus("") def doTrans1(self): self.df.focusField("T", 2, 1) def doTrans2(self, frt, pag, r, c, p, i, w): self.history = w tit = "Transactions for Loan: %s %s - %s" % \ (self.empno, self.name, self.desc) tab = ["wagltf"] col = (("wlt_trdt", "", 0, " Date"), ("wlt_batch", "", 0, "Batch"), ("wlt_type", ("XX", sltrtp), 3, "Typ"), ("wlt_ref", "", 0, "Reference", "Y"), ("wlt_per", "", 0, " Int-%"), ("wlt_amt", "", 0, " Amount"), ("wlt_ded", "", 0, " Deduction"), ("wlt_desc", "", 0, "Remarks")) whr = [ ("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=", self.empno), ("wlt_loan", "=", self.loan)] if self.history == "N": whr.append(("wlt_curdt", ">=", int(self.opts["period"] / 100))) odr = "wlt_trdt, wlt_type, wlt_ref" state = self.df.disableButtonsTags() SRec(self.opts["mf"], screen=self.df.nb.Page2, title=tit, tables=tab, cols=col, where=whr, order=odr) self.df.enableButtonsTags(state=state) self.df.focusField("T", 2, 1) def doClear(self): self.df.selPage("General") self.df.focusField("T", 0, 1) def doPrint(self): mess = "Select the Required Print Option." butt = ( ("Information", "I"), ("Transactions", "T"), ("Both", "B"), ("None", "N")) self.doPrintOption(askChoice(self.opts["mf"].body, "Print Options", mess, butt=butt)) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doPrintOption(self, opt): print(opt) if opt == "N": return self.head = "%03u %-93s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.pglin = 999 if opt != "T": self.pageHeading() self.printInfo() pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, self.opts["conum"], ext="pdf") if opt == "I": self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) elif opt == "B": if not self.wlt: self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) else: self.acctot = 0.0 self.pageHeading() self.pageHeadingTrans() self.printTrans() self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) elif opt == "T": if self.wlt: self.acctot = 0.0 self.pageHeading() self.pageHeadingTrans() self.printTrans() self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"]) def printInfo(self): self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "", self.df.topf[0][0][3], self.df.t_disp[0][0][0])) self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "", self.df.topf[0][1][3], self.df.t_disp[0][0][1])) self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "", self.df.topf[0][2][3], self.df.t_disp[0][0][2])) self.fpdf.drawText() for x in range(0, len(self.df.topf[1])): self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "", self.df.topf[1][x][3], self.df.t_disp[1][0][x])) self.fpdf.drawText() def printTrans(self): whr = [ ("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=", self.empno), ("wlt_loan", "=", self.loan)] odr = "wlt_trdt, wlt_type" if self.history == "N": whr.append(("wlt_curdt", ">=", int(self.opts["period"] / 100))) recs = self.sql.getRec("wagltf", where=whr, order=odr) for rec in recs: trd = CCD(rec[self.sql.wagltf_col.index("wlt_trdt")], "D1", 10) typ = CCD(rec[self.sql.wagltf_col.index("wlt_type")], "UI", 1) ref = CCD(rec[self.sql.wagltf_col.index("wlt_ref")], "Na", 9) bat = CCD(rec[self.sql.wagltf_col.index("wlt_batch")], "Na", 7) rte = CCD(rec[self.sql.wagltf_col.index("wlt_per")], "UD", 6.2) amt = CCD(rec[self.sql.wagltf_col.index("wlt_amt")], "SD", 13.2) ded = CCD(rec[self.sql.wagltf_col.index("wlt_ded")], "SD", 13.2) det = CCD(rec[self.sql.wagltf_col.index("wlt_desc")], "NA", 30) if self.pglin > self.fpdf.lpp: self.pageHeading() self.pageHeadingTrans() self.acctot = float(ASD(self.acctot) + ASD(amt.work)) self.fpdf.drawText("%s %s %s %s %s %s %s %s" % (trd.disp, sltrtp[(typ.work - 1)][0], ref.disp, bat.disp, rte.disp, amt.disp, ded.disp, det.disp)) self.pglin += 1 self.fpdf.underLine(txt=self.head) b = CCD(self.acctot, "SD", 13.2) self.fpdf.drawText("%-39s %13s %13s %-30s" % \ ("", b.disp, "", "Closing Balance")) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("Staff Loans Interrogation as at %s" % self.sysdtd) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 3 def pageHeadingTrans(self): self.fpdf.setFont(style="B") text = "%-8s %5s %-4s %s" % (self.df.topf[0][0][3], self.df.t_disp[0][0][0], self.df.topf[0][1][3], self.df.t_disp[0][0][1]) self.fpdf.drawText(text) text = "%-8s %5s %-4s %s" % (self.df.topf[0][2][3], self.df.t_disp[0][0][2], self.df.topf[0][3][3], self.df.t_disp[0][0][3]) self.fpdf.drawText(text) self.fpdf.drawText() self.fpdf.drawText("%-10s %-3s %-9s %-7s %6s %12s %12s %-30s" % \ (" Date", "Typ", "Reference", "Batch", "Int%", " Amount", " Deduction", "Remarks")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 7 b = CCD(self.acctot, "SD", 13.2) if self.acctot != 0: self.fpdf.drawText("%-39s %13s %13s %-30s" % \ ("", b.disp, "", "Brought Forward")) self.pglin += 1 def doExit(self): try: self.opts["mf"].dbm.rollbackDbase() except: pass self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class cs3010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) cshctl = gc.getCtl("cshctl", self.opts["conum"]) if not cshctl: return self.glint = cshctl["ccc_glint"] self.fromad = cshctl["ccc_emadd"] if self.glint == "Y": tabs = ["genmst"] else: tabs = ["cshmst"] tabs.extend(["cshcnt", "cshana"]) self.sql = Sql(self.opts["mf"].dbm, tables=tabs, prog=self.__class__.__name__) if self.sql.error: return self.dte = self.sql.getRec("cshcnt", cols=["max(cct_date)"], where=[("cct_cono", "=", self.opts["conum"]) ], limit=1)[0] self.denoms = (("R200", 200), ("R100", 100), ("R50", 50), ("R20", 20), ("R10", 10), ("R5", 5), ("R2", 2), ("R1", 1), ("C50", .5), ("C20", .2), ("C10", .1), ("C5", .05), ("C2", .02), ("C1", .01)) return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Cash Reconciliation Report (%s)" % self.__class__.__name__) dte = { "stype": "R", "tables": ("cshcnt", ), "cols": (("cct_date", "", 0, "Date"), ), "where": [("cct_cono", "=", self.opts["conum"])], "group": "cct_date" } fld = ((("T", 0, 0, 0), "ID1", 10, "From Date", "", self.dte, "Y", self.doFrom, dte, None, ("efld", )), (("T", 0, 1, 0), "Id1", 10, "To Date", "To Date", "", "Y", self.doTo, dte, None, ("efld", )), (("T", 0, 2, 0), "ISD", 13.2, "Float", "Cash Float", 2000, "Y", self.doFloat, None, None, ("notzero", ))) 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 doFrom(self, frt, pag, r, c, p, i, w): self.fm = w self.fmd = self.df.t_disp[pag][r][p] self.df.loadEntry(frt, pag, p + 1, data=self.fm) def doTo(self, frt, pag, r, c, p, i, w): if not w: w = self.fm elif w < self.fm: return "Invalid To Date" self.to = w self.tod = CCD(w, "D1", 10).disp csh = self.sql.getRec("cshcnt", where=[("cct_cono", "=", self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date", "between", self.fm, self.to) ]) if not csh: return "ff1|Invalid Cash Capture Dates" def doFloat(self, frt, pag, r, c, p, i, w): self.float = CCD(w, "SD", 13.2) def doEnd(self): self.df.closeProcess() self.tk1 = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", "P"), ("can_date", "between", self.fm, self.to)], order="can_trdt, can_code") self.tk2 = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", "T"), ("can_date", "between", self.fm, self.to)], order="can_trdt, can_code") self.head = "%03u %-78s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.pglin = 999 if self.tk1: self.pageHeading() self.printExpTak(self.tk1, 1) if not self.quit: if self.tk2: self.pageHeading() self.printExpTak(self.tk2, 2) if not self.quit: self.doSummary() if not self.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) self.closeProcess() def printExpTak(self, recs, ptyp=None): self.fpdf.setFont(style="B") if ptyp == 1: self.fpdf.drawText("Cash Expenditure") else: self.fpdf.drawText("Cash Takings") self.fpdf.drawText() self.fpdf.drawText( "%-10s %-36s %7s %13s %13s" % (" Date", "Description", "Code", "Vat-Amount ", "Inc-Amount ")) self.fpdf.underLine(txt=self.head) self.pglin += 4 self.fpdf.setFont() tot = 0 vat = 0 c1 = self.sql.cshana_col pb = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) for num, dat in enumerate(recs): pb.displayProgress(num) self.quit = pb.quit if self.quit: break trdt = CCD(dat[c1.index("can_trdt")], "D1", 10) code = CCD(dat[c1.index("can_code")], "UI", 7) desc = CCD(dat[c1.index("can_desc")], "NA", 36) inca = CCD(dat[c1.index("can_incamt")], "SD", 13.2) vata = CCD(dat[c1.index("can_vatamt")], "SD", 13.2) if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText( "%s %s %s %s %s" % (trdt.disp, desc.disp, code.disp, vata.disp, inca.disp)) self.pglin += 1 tot = float(ASD(tot) + ASD(inca.work)) vat = float(ASD(vat) + ASD(vata.work)) pb.closeProgress() if self.quit: return tot = CCD(tot, "SD", 13.2) vat = CCD(vat, "SD", 13.2) self.fpdf.drawText("%55s %-12s %-12s" % ("", self.fpdf.suc * 12, self.fpdf.suc * 12)) if ptyp == 1: self.fpdf.drawText("%10s %-36s %13s %13s" % ("", "Total Expenses", vat.disp, tot.disp)) else: self.fpdf.drawText("%10s %-36s %13s %13s" % ("", "Total Takings", vat.disp, tot.disp)) self.fpdf.drawText() def doSummary(self): self.pageHeading() if self.glint == "Y": tab = ["cshana", "genmst"] col = [ "can_code", "glm_desc", "sum(can_incamt)", "sum(can_vatamt)" ] whr = [("can_cono", "=", self.opts["conum"]), ("can_date", "between", self.fm, self.to), ("glm_cono=can_cono", ), ("glm_acno=can_code", )] grp = "can_code, glm_desc" else: tab = ["cshana", "cshmst"] col = [ "can_code", "ccm_desc", "sum(can_incamt)", "sum(can_vatamt)" ] whr = [("can_cono", "=", self.opts["conum"]), ("can_date", "between", self.fm, self.to), ("ccm_cono=can_cono", ), ("ccm_acno=can_code", )] grp = "can_code, ccm_desc" w = whr[:] w.insert(2, ("can_type", "=", "P")) recs = self.sql.getRec(tables=tab, cols=col, where=w, group=grp, order="can_code") self.printSummary(recs, 1) w = whr[:] w.insert(2, ("can_type", "=", "T")) recs = self.sql.getRec(tables=tab, cols=col, where=w, group=grp, order="can_code") self.printSummary(recs, 2) def printSummary(self, recs, ptyp=None): self.fpdf.setFont(style="B") if ptyp == 1: self.fpdf.drawText("Expenses Summary") else: self.fpdf.drawText("Takings Summary") self.fpdf.drawText() self.fpdf.drawText("%7s %-61s %13s" % ("Code", "Description", "Amount ")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin += 4 tot = 0 vat = 0 for rec in recs: if self.pglin > self.fpdf.lpp: self.pageHeading() a = CCD(rec[2], "SD", 13.2) b = CCD(rec[3], "SD", 13.2) c = CCD(float(ASD(a.work) - ASD(b.work)), "SD", 13.2) tot = float(ASD(tot) + ASD(a.work)) vat = float(ASD(vat) + ASD(b.work)) self.fpdf.drawText("%7s %-61s %s" % (rec[0], rec[1], c.disp)) self.pglin += 1 vat = CCD(vat, "SD", 13.2) self.fpdf.drawText("%7s %-61s %s" % ("", "Value Added Tax", vat.disp)) self.fpdf.drawText("%69s %-12s" % ("", self.fpdf.suc * 12)) if ptyp == 1: self.exp = CCD(tot, "SD", 13.2) self.fpdf.drawText("%7s %-61s %s" % ("", "Total", self.exp.disp)) else: self.tak = CCD(tot, "SD", 13.2) self.fpdf.drawText("%7s %-61s %s" % ("", "Total", self.tak.disp)) self.fpdf.drawText() self.fpdf.drawText() self.pglin += 5 if ptyp == 1: return if (self.pglin + 30) > self.fpdf.lpp: self.pageHeading() self.fpdf.setFont(style="B") self.fpdf.drawText("Cash Summary") self.fpdf.drawText() self.fpdf.drawText("%-26s %42s %13s" % ("Denomination", "Quantity", "Amount ")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin += 4 col = [ "sum(cct_cheq)", "sum(cct_r200)", "sum(cct_r100)", "sum(cct_r50)", "sum(cct_r20)", "sum(cct_r10)", "sum(cct_r5)", "sum(cct_r2)", "sum(cct_r1)", "sum(cct_c50)", "sum(cct_c20)", "sum(cct_c10)", "sum(cct_c5)", "sum(cct_c2)", "sum(cct_c1)" ] recs = self.sql.getRec("cshcnt", cols=col, where=[("cct_cono", "=", self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date", "between", self.fm, self.to) ], limit=1) if recs and recs[0]: val = CCD(recs[0], "SD", 13.2) csh = val.work self.fpdf.drawText("%-26s %42s %s" % ("Cheques", "", val.disp)) self.pglin += 1 else: csh = 0 for x in range(1, 15): if recs[x]: qty = CCD(recs[x], "UI", 5) val = CCD(qty.work * self.denoms[x - 1][1], "SD", 13.2) csh = float(ASD(csh) + ASD(val.work)) self.fpdf.drawText("%-26s %42s %s" % (self.denoms[x - 1][0], qty.disp, val.disp)) self.pglin += 1 self.fpdf.drawText("%69s %-12s" % ("", self.fpdf.suc * 12)) csh = CCD(csh, "SD", 13.2) self.fpdf.drawText("%-26s %42s %s" % ("Total", "", csh.disp)) self.fpdf.drawText() self.fpdf.setFont(style="B") self.fpdf.drawText("Cash Reconciliation") self.fpdf.setFont() self.fpdf.drawText() self.fpdf.drawText("%-26s %42s %s" % ("Total Takings", "", self.tak.disp)) self.fpdf.drawText("%-26s %42s %s" % ("Total Expended", "", self.exp.disp)) self.fpdf.drawText("%69s %-12s" % ("", self.fpdf.suc * 12)) dif = CCD(float(ASD(self.tak.work) - ASD(self.exp.work)), "SD", 13.2) self.fpdf.drawText("%-26s %42s %s" % ("Cash Expected", "", dif.disp)) self.fpdf.drawText("%-26s %42s %s" % ("Cash Actual", "", csh.disp)) self.fpdf.drawText("%69s %-12s" % ("", self.fpdf.suc * 12)) dif = CCD(float(ASD(dif.work) - ASD(csh.work)), "SD", 13.2) if dif.work: if dif.work < 0: text = "Cash Over" dif = CCD(float(ASD(0) - ASD(dif.work)), "SD", 13.2) else: text = "Cash Under" self.fpdf.drawText("%-26s %42s %s" % (text, "", dif.disp)) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-30s %10s to %-35s" % \ ("Cash Reconciliation for Period", self.fmd, self.tod)) self.fpdf.drawText() self.pglin = 4 self.fpdf.setFont() def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class sl3040(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, ["wagmst", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) wagctl = gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.fromad = wagctl["ctw_emadd"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.head = "%03u %-118s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) return True def mainProcess(self): r1s = (("Yes", "Y"), ("Singles", "S")) r2s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "Id1", 10, "Start Date", "", "", "Y", self.doFdate, None, None, ("efld", )), (("T", 0, 1, 0), "ID1", 10, "Last Date", "", self.sysdtw, "Y", self.doLdate, None, None, ("efld", )), (("T", 0, 2, 0), ("IRB", r1s), 0, "Whole File", "", "S", "Y", self.doWhole, None, None, None), (("T", 0, 3, 0), ("IRB", r2s), 0, "Ignore Paid Ups", "", "Y", "Y", self.doPaidup, None, None, None)) 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 doFdate(self, frt, pag, r, c, p, i, w): self.fdate = w def doLdate(self, frt, pag, r, c, p, i, w): self.ldate = w self.dated = self.df.t_disp[pag][0][p] def doWhole(self, frt, pag, r, c, p, i, w): self.whole = w def doPaidup(self, frt, pag, r, c, p, i, w): self.paidup = w def doEnd(self): self.df.closeProcess() if self.whole == "S": col = [ "wlm_empno", "wgm_sname", "wgm_fname", "wlm_loan", "wlm_desc" ] whr = [("wlm_cono", "=", self.opts["conum"]), ("wgm_cono=wlm_cono", ), ("wgm_empno=wlm_empno", )] dic = {} dic["wlm_empno"] = self.sql.waglmf_dic["wlm_empno"] dic["wlm_loan"] = self.sql.waglmf_dic["wlm_loan"] dic["wlm_desc"] = self.sql.waglmf_dic["wlm_desc"] dic["wgm_sname"] = self.sql.wagmst_dic["wgm_sname"] dic["wgm_fname"] = self.sql.wagmst_dic["wgm_fname"] dat = self.sql.getRec(tables=["waglmf", "wagmst"], cols=col, where=whr, order="wlm_empno, wlm_loan") get = getSingleRecords(self.opts["mf"], "waglmf", col, where=dat, ttype="D", dic=dic) if get: acc = [] for g in get: acc.append(g[0]) whr = [("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "in", acc)] odr = "wlm_empno, wlm_loan" recs = self.sql.getRec("waglmf", where=whr, order=odr) else: recs = None else: whr = [("wlm_cono", "=", self.opts["conum"])] odr = "wlm_empno, wlm_loan" recs = self.sql.getRec("waglmf", where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Error", "No Accounts Selected") else: p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) for num, emp in enumerate(recs): p.displayProgress(num) if p.quit: break self.doProcess(emp) p.closeProgress() if self.fpdf.page and not p.quit and self.df.repeml[1] == "N": self.doPrint() self.opts["mf"].closeLoop() def doProcess(self, emp): self.totbal = 0 wlc = self.sql.waglmf_col self.emp = CCD(emp[wlc.index("wlm_empno")], "UI", 5) whr = [("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", self.emp.work)] col = ("wgm_sname", "wgm_fname", "wgm_emadd") mst = self.sql.getRec("wagmst", where=whr, cols=col, limit=1) self.nam = CCD(mst[0] + ", " + mst[1], "NA", 60) self.lon = CCD(emp[wlc.index("wlm_loan")], "UI", 2) self.des = CCD(emp[wlc.index("wlm_desc")], "NA", 30) whr = [("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=", self.emp.work), ("wlt_loan", "=", self.lon.work)] col = ("wlt_trdt", "wlt_type", "wlt_ref", "wlt_batch", "wlt_per", "wlt_amt", "wlt_ded", "wlt_desc") odr = "wlt_trdt, wlt_type, wlt_ref" wlt = self.sql.getRec("wagltf", where=whr, cols=col, order=odr) if wlt: self.loadBalances(wlt) if self.paidup == "Y" and not self.cbal: pass else: self.printHeader() self.printBody(wlt) if self.df.repeml[1] == "Y": self.df.repeml[2] = mst[2] self.doPrint() def loadBalances(self, wlt): self.obal = 0.0 self.cbal = 0.0 for x, w in enumerate(wlt): dat = CCD(w[0], "d1", 10) amt = CCD(w[5], "SD", 13.2) if self.fdate and dat.work < self.fdate: self.obal = float(ASD(self.obal) + ASD(float(amt.work))) if dat.work <= self.ldate: self.cbal = float(ASD(self.cbal) + ASD(float(amt.work))) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-27s %-15s %2s %15s" % \ ("Staff Loans Statements from", self.df.t_disp[0][0][0], "to", self.df.t_disp[0][0][1])) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 4 def printHeader(self): self.pageHeading() self.pglin += 1 self.fpdf.setFont(style="B") mess = "%-8s %-5s %-60s %-4s %-2s %-30s" % ( "Employee", self.emp.disp, self.nam.disp, "Loan", self.lon.disp, self.des.disp) self.fpdf.drawText(mess) self.pglin += 1 self.fpdf.drawText() self.pglin += 1 mess = "%-10s %-3s %-9s %-7s %-6s %-13s %-13s %-13s %-30s" % \ (" Date", "Typ", "Reference", "Batch", " Int-%", " Amount", " Deduction", " Balance", "Remarks") self.fpdf.drawText(mess) self.pglin += 1 self.fpdf.underLine(txt=self.head) self.pglin += 1 self.fpdf.setFont() def printBody(self, wlt): for trn in wlt: dat = CCD(trn[0], "d1", 10) bat = CCD(trn[3], "Na", 7) typ = CCD(trn[1], "UI", 2) ref = CCD(trn[2], "Na", 9) per = CCD(trn[4], "UD", 7.2) amt = CCD(trn[5], "SD", 13.2) ded = CCD(trn[6], "SD", 13.2) des = CCD(trn[7], "NA", 30) if self.fdate and dat.work < self.fdate: continue if dat.work > self.ldate: continue if self.pglin > self.fpdf.lpp: self.printHeader() bal = CCD(self.obal, "SD", 13.2) if bal.work: mess = "%-69s%s%-30s" % ("", bal.disp, " Brought Forward") self.fpdf.drawText(mess) self.pglin += 1 self.obal = float(ASD(self.obal) + ASD(float(amt.work))) bal = CCD(self.obal, "SD", 13.2) mess = "%s %s %s %s %s %s %s %s %s" % \ (dat.disp, sltrtp[typ.work - 1][0], ref.disp, bat.disp, per.disp, amt.disp, ded.disp, bal.disp, des.disp) self.fpdf.drawText(mess) self.pglin += 1 def doPrint(self): 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="%s Loan Statement at %s" % (self.opts["conam"], self.dated), fromad=self.fromad, repprt=self.df.repprt, repeml=self.df.repeml) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class st3080(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, ["strloc", "strgrp", "strmf1", "strtrn"], 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 self.locs = strctl["cts_locs"] self.fromad = strctl["cts_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) %6s" % ( t[0], t[1], t[2], t[3], t[4], self.__class__.__name__) self.colsh = [ "Grp", "Product-Code", "Description", "U.O.I", "Qty-Balance", "Val-Balance" ] self.forms = [("UA", 3), ("NA", 20), ("NA", 30), ("NA", 10), ("SD", 12.2), ("SD", 12.2)] self.gtot = 0 return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Stock On Hand Report (%s)" % self.__class__.__name__) loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } r1s = (("Yes", "Y"), ("No", "N")) if "args" in self.opts and "noprint" in self.opts["args"]: var = self.opts["args"]["work"][0] view = None mail = None else: var = ["", "", "", "Y", "Y"] view = ("Y", "V") mail = ("Y", "N") fld = [(("T", 0, 0, 0), "ID2", 7, "Reporting Period", "", int(self.sysdtw / 100), "Y", self.doPeriod, None, None, ("efld", )), [("T", 0, 1, 0), "IUA", 1, "Location", "", var[1], "N", self.doLoc, loc, None, ("efld", )], (("T", 0, 2, 0), "IUA", 3, "Product Group", "", var[2], "N", self.doGroup, grp, None, None), (("T", 0, 3, 0), ("IRB", r1s), 0, "Ignore Zero Balances", "", var[3], "N", self.doZero, None, None, None), (("T", 0, 4, 0), ("IRB", r1s), 0, "Ignore Redundant Stock", "", var[4], "N", self.doRedt, None, None, None)] if self.locs == "N": fld[1][1] = "OUA" 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 doPeriod(self, frt, pag, r, c, p, i, w): if w > int(self.sysdtw / 100): return "Invalid Period" self.curdt = w self.date = CCD(mthendDate(w * 100), "D1", 10) if self.locs == "N": self.df.loadEntry(frt, pag, p + 1, data="1") no = self.doLoc(frt, pag, r, c + 1, p + 1, i + 1, "1") if no: return no return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): if not w: self.loc = "" self.locd = "ALL" else: acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not acc: return "Invalid Location" self.loc = w self.locd = acc[0] def doGroup(self, frt, pag, r, c, p, i, w): if not w: self.group = "" else: acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.group = w def doZero(self, frt, pag, r, c, p, i, w): self.zero = w if self.zero == "Y": self.redt = "Y" self.df.loadEntry(frt, pag, p + 1, data=self.redt) return "sk1" def doRedt(self, frt, pag, r, c, p, i, w): self.redt = w def doEnd(self): self.df.closeProcess() if not self.group: self.sgrp = "" self.egrp = "zzz" else: self.sgrp = self.group self.egrp = self.group whr = [("st1_cono", "=", self.opts["conum"]), ("st1_group", ">=", self.sgrp), ("st1_group", "<=", self.egrp)] if self.redt == "Y": whr.append(("st1_type", "not", "in", ("R", "X"))) else: whr.append(("st1_type", "<>", "R")) recs = self.sql.getRec( "strmf1", cols=["st1_group", "st1_code", "st1_desc", "st1_uoi"], where=whr, order="st1_group, st1_code") if not recs: showError(self.opts["mf"].body, "Processing 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 = [ "%03u %-30s %s" % (self.opts["conum"], self.opts["conam"], self.sysdttm) ] self.expheads.append("Stock On Hand Report as at %s" % self.date.disp) 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 self.expdatas.append([ "BODY", [ vals[0].work, vals[1].work, vals[2].work, vals[3].work, vals[4].work, vals[5].work ] ]) 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) self.head = "%03u %-83s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.stot = 0 old_grp = "" self.pglin = 999 for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break vals = self.getValues(dat) if not vals: continue grp, code, desc, uoi, qbal, vbal = vals if old_grp and old_grp != grp.work: self.groupTotal() self.pglin = 999 if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText("%s %s %s %s %s" % \ (code.disp, desc.disp, uoi.disp, qbal.disp, vbal.disp)) self.pglin += 1 self.stot = float(ASD(self.stot) + ASD(vbal.work)) old_grp = grp.work p.closeProgress() if self.fpdf.page and not p.quit: self.groupTotal() 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 getValues(self, data): grp = CCD(data[0], "UA", 3) self.groupd = grp.disp code = CCD(data[1], "NA", 20) desc = CCD(data[2], "NA", 30) uoi = CCD(data[3], "NA", 10) whr = [("stt_cono", "=", self.opts["conum"]), ("stt_group", "=", grp.work), ("stt_code", "=", code.work)] if self.loc: whr.append(("stt_loc", "=", self.loc)) whr.append(("stt_curdt", "<=", self.curdt)) bal = self.sql.getRec( "strtrn", cols=["round(sum(stt_qty), 2)", "round(sum(stt_cost), 2)"], where=whr, limit=1) if not bal[0]: bal[0] = 0 if not bal[1]: bal[1] = 0 qbal = CCD(bal[0], "SD", 12.2) vbal = CCD(bal[1], "SD", 12.2) if self.zero == "Y" and qbal.work == 0 and vbal.work == 0: return self.gtot = float(ASD(self.gtot) + ASD(vbal.work)) return (grp, code, desc, uoi, qbal, vbal) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-26s %-10s" % \ ("Stock On Hand Report as at", self.date.disp)) self.fpdf.drawText() self.fpdf.drawText( "%-5s %3s %-8s %s %s" % ("Group", self.groupd, "Location", self.loc, self.locd)) self.fpdf.drawText() self.fpdf.drawText("%-20s %-30s %-10s %11s %12s" % ("Product-Code", "Description", "U.O.I", "Qty-Balance", "Val-Balance")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 8 def groupTotal(self): val = CCD(self.stot, "SD", 12.2) self.fpdf.drawText() self.fpdf.drawText("%-20s %-41s %12s %12s" % \ ("", "Group Totals", "", val.disp)) self.fpdf.drawText() self.stot = 0 def grandTotal(self): if self.df.repprt[2] == "export": self.expdatas.append(["ULINES"]) self.expdatas.append( ["TOTAL", ["", "", "Grand Totals", "", "", self.gtot]]) self.expdatas.append(["ULINED"]) return val = CCD(self.gtot, "SD", 12.2) self.fpdf.drawText("%-20s %-41s %12s %12s" % \ (" ", "Grand Totals", "", val.disp)) def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): if "wait" not in self.opts: self.opts["mf"].closeLoop()
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 gl4010(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, ["genmst", "genbal", "genbud", "gentrn"], prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2]) self.i_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) df = self.e_per - self.i_per - 87 if df > 12: self.d_per = df - 12 yr = int(self.i_per / 100) mt = int(self.i_per % 100) for _ in range(self.d_per): mt += 1 if mt > 12: mt -= 12 yr += 1 self.s_per = (yr * 100) + mt else: self.d_per = 0 self.s_per = self.i_per self.d_pyr = 0 if self.opts["period"][0]: s, e, f = getPeriods(self.opts["mf"], self.opts["conum"], (self.opts["period"][0] - 1)) if (s, e, f) == (None, None, None): return self.s_lyr = s.work self.i_pyr = int(s.work / 100) self.e_pyr = int(e.work / 100) df = self.e_pyr - self.i_pyr - 87 if df > 12: self.d_pyr = df - 12 yr = int(self.i_pyr / 100) mt = self.i_pyr % 100 for _ in range(self.d_pyr): mt += 1 if mt > 12: mt -= 12 yr += 1 self.s_pyr = (yr * 100) + mt else: self.s_pyr = self.i_pyr self.trnper = 0 return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "General Ledger Interrogation (%s)" % self.__class__.__name__) glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])], "order": "glm_acno" } fld = ((("T", 0, 0, 0, 7), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doAccNum, glm, None, None), (("T", 0, 0, 0), "ONA", 30, "Description"), (("T", 0, 0, 0), "OUA", 1, "Type"), (("T", 0, 0, 0), "OUA", 1, "Indicator"), (("C", 1, 0, 0), "OSD", 13.2, "Actual", "", "", "N", None, None, None, None, ("Months", 14)), (("C", 1, 0, 1), "OSD", 13.2, "Budget"), (("C", 1, 0, 2), "OSD", 13.2, "Variance"), (("C", 1, 0, 3), "OSD", 13.2, "Last-Year"), (("T", 2, 0, 0), "Id2", 7, "Period (YYYYMM)", "Financial Period (0=All)", self.trnper, "Y", self.doPeriod, None, None, None)) tag = (("Balances", self.doBals, ("T", 0, 2), ("T", 0, 1)), ("Transactions", self.doTrans1, ("T", 0, 2), ("T", 0, 1))) but = (("Clear", None, self.doClear, 0, ("T", 0, 0), ("T", 0, 1)), ("Notes", None, self.doNotes, 0, ("T", 0, 0), ("T", 0, 1)), ("Print", None, self.doPrint, 1, ("T", 0, 0), ("T", 0, 1)), ("Quit", None, self.doExit, 1, None, None)) tnd = ((self.doTopEnd, "N"), None, (self.doTrans2, "N")) txt = (self.doExit, None, self.doExit) self.df = TartanDialog(self.opts["mf"], title=self.tit, tags=tag, eflds=fld, butt=but, tend=tnd, txit=txt) mon = self.s_per % 100 yer = int(self.s_per / 100) for x in range(14): if x == 0: txt = "Opening Balance" self.df.colLabel[1][x].configure(text=txt) elif x == 13: txt = "Closing Balance" self.df.colLabel[1][x].configure(text=txt) else: nam = mthnam[mon][1] nam = nam + (" " * (11 - len(nam))) + str(yer) self.df.colLabel[1][x].configure(text=nam) if x not in (0, 13): mon = mon + 1 if mon > 12: mon = mon - 12 yer = yer + 1 txt = "Closing Balance" self.df.colLabel[1][13].configure(text=txt) def doAccNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("genmst", cols=["glm_desc", "glm_type", "glm_ind"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) if not acc: return "Invalid Account" self.acno = w self.desc = acc[0] for x in range(1, self.df.topq[pag]): self.df.loadEntry(frt, pag, p + x, data=acc[x - 1]) if self.opts["period"][0]: gp = self.sql.getRec("genbal", cols=["glo_cyr"], where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", self.acno), ("glo_trdt", "=", self.s_lyr)]) gc = self.sql.getRec("genbal", cols=["glo_cyr"], where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", self.acno), ("glo_trdt", "=", self.opts["period"][1][0])]) gt = self.sql.getRec("gentrn", cols=["glt_type", "glt_curdt", "glt_tramt"], where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.acno), ("glt_curdt", "between", self.i_per, self.e_per)]) gb = self.sql.getRec("genbud", cols=["glb_curdt", "glb_tramt"], where=[("glb_cono", "=", self.opts["conum"]), ("glb_acno", "=", self.acno), ("glb_curdt", "between", self.i_per, self.e_per)]) if self.opts["period"][0]: gl = self.sql.getRec("gentrn", cols=["glt_curdt", "glt_tramt"], where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.acno), ("glt_curdt", "between", self.i_pyr, self.e_pyr)]) act = [0] * 14 bud = [0] * 14 lyr = [0] * 14 adc = [] adl = [] if self.d_per: # Current period more than 12 months sy = sy = int(self.i_per / 100) sm = self.i_per % 100 for _ in range(self.d_per): adc.append(sm) sm += 1 if sm > 12: sy += 1 sm = 1 elif self.d_pyr: # Previous period more than 12 months sy = sy = int(self.i_pyr / 100) sm = self.i_pyr % 100 for _ in range(self.d_pyr): adl.append(sm) sm += 1 if sm > 12: sy += 1 sm = 1 if gc: self.obal = gc[0][0] act[0] = float(ASD(act[0]) + ASD(self.obal)) act[13] = float(ASD(act[13]) + ASD(self.obal)) if self.opts["period"][0] and gp: lyr[0] = float(ASD(lyr[0]) + ASD(float(gp[0][0]))) lyr[13] = float(ASD(lyr[13]) + ASD(float(gp[0][0]))) else: self.obal = 0 yre = self.e_per % 100 if gt: for x, t in enumerate(gt): cyr = int(t[1] / 100) mon = t[1] % 100 if adc and cyr == sy and mon in adc: col = 1 else: col = mon - yre if col <= 0: col = col + 12 act[col] = float(ASD(act[col]) + ASD(float(t[2]))) act[13] = float(ASD(act[13]) + ASD(float(t[2]))) if gb: for x, t in enumerate(gb): mon = int(str(t[0])[4:6]) col = mon - yre if col <= 0: col = col + 12 bud[col] = float(ASD(bud[col]) + ASD(float(t[1]))) bud[13] = float(ASD(bud[13]) + ASD(float(t[1]))) if self.opts["period"][0] and gl: for x, t in enumerate(gl): cyr = int(t[0] / 100) mon = t[0] % 100 if adl and cyr == sy and mon in adl: col = 1 else: col = mon - yre if col <= 0: col = col + 12 lyr[col] = float(ASD(lyr[col]) + ASD(float(t[1]))) lyr[13] = float(ASD(lyr[13]) + ASD(float(t[1]))) p = 0 for x in range(14): i = 0 self.df.loadEntry("C", 1, p, data=act[x]) p = p + 1 i = i + 1 self.df.loadEntry("C", 1, p, data=bud[x]) p = p + 1 i = i + 1 data = float(ASD(bud[x]) - ASD(act[x])) self.df.loadEntry("C", 1, p, data=data) p = p + 1 i = i + 1 self.df.loadEntry("C", 1, p, data=lyr[x]) p = p + 1 self.df.last[0] = [0, 0] self.opts["mf"].updateStatus("") def doBals(self): self.opts["mf"].updateStatus("") def doTrans1(self): self.df.focusField("T", 2, 1) def doTrans2(self): tit = "Transactions for Account: %s - %s" % (self.acno, self.desc) gtt = ["gentrn"] gtc = (("glt_trdt", "", 0, " Date"), ("glt_refno", "", 0, "Reference", "Y"), ("glt_type", ("XX", gltrtp), 3, "Typ"), ("glt_batch", "", 0, "Batch"), ("glt_tramt", "", 0, " Debit"), ("glt_tramt", "", 0, " Credit"), ("balance", "SD", 13.2, " Balance"), ("glt_desc", "", 0, "Remarks"), ("glt_seq", "", 0, "Sequence")) mthno, acctot = self.getObal() if mthno.work == 0: d = self.opts["period"][1][0] else: d = (self.trnper * 100) + 1 if acctot: if acctot < 0: dr = 0 cr = acctot else: dr = acctot cr = 0 data = [[d, "B/Fwd", 4, "", dr, cr, acctot, "Opening Balance", 0]] else: data = [] trn = self.getTrans() if trn: col = self.sql.gentrn_col for rec in trn: acctot = float(ASD(acctot) + ASD(rec[col.index("glt_tramt")])) if rec[col.index("glt_tramt")] < 0: dr = 0 cr = rec[col.index("glt_tramt")] else: dr = rec[col.index("glt_tramt")] cr = 0 data.append([ rec[col.index("glt_trdt")], rec[col.index("glt_refno")], rec[col.index("glt_type")], rec[col.index("glt_batch")], dr, cr, acctot, rec[col.index("glt_desc")], rec[col.index("glt_seq")] ]) state = self.df.disableButtonsTags() while True: rec = SRec(self.opts["mf"], screen=self.df.nb.Page2, title=tit, tables=gtt, cols=gtc, where=data, wtype="D", sort=False) # Display all transaction details if rec.selection: self.df.setWidget(self.df.mstFrame, state="hide") whr = [("glt_seq", "=", rec.selection[8])] TabPrt(self.opts["mf"], tabs="gentrn", where=whr, pdia=False) self.df.setWidget(self.df.mstFrame, state="show") else: break self.df.enableButtonsTags(state=state) self.doTrans1() def doNotes(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") NotesCreate(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["capnm"], "GEN", self.acno) self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) def doTopEnd(self): self.df.last[0] = [0, 0] self.df.setWidget(self.df.topEntry[0][0], state="disabled") def doClear(self): self.df.selPage("Balances") self.df.focusField("T", 0, 1) def doPrint(self): self.df.setWidget(self.df.mstFrame, state="hide") tit = ("Printer/Email Selection", ) r1s = (("Info", "I"), ("Trans", "T")) fld = ((("T", 0, 1, 0), ("IRB", r1s), 0, "Selection", "", "I", "N", self.doPrtSel, None, None, None), (("T", 0, 2, 0), "Id2", 7, "Period (YYYYMM)", "Financial Period (0=All)", self.trnper, "Y", self.doPeriod, None, None, None)) self.pr = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=((self.doPrtEnd, "y"), ), txit=(self.doPrtExit, ), view=("Y", "V"), mail=("Y", "N")) self.pr.mstFrame.wait_window() self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField("T", 2, 1) def doPrtSel(self, frt, pag, r, c, p, i, w): self.sel = w for x in (2, 3): if bool(self.sel == "I"): self.pr.setWidget(self.pr.topEntry[0][2][x][0], state="hide") else: self.pr.setWidget(self.pr.topEntry[0][2][x][0], state="show") if self.sel == "I": return "sk1" def doPrtEnd(self): self.pr.closeProcess() self.head = "%03u %-99s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.pgnum = 0 self.pglin = 999 self.num = self.df.t_disp[0][0][0] self.dsc = self.df.t_disp[0][0][1] atype = self.df.t_disp[0][0][2] ind = self.df.t_disp[0][0][3] if self.pr.t_work[0][0][0] == "I": self.pageHeading() self.fpdf.drawText("%-8s %-12s %-6s %-35s %-6s %-7s %-11s %s" % \ ("Acc No:", self.num, "Desc:", self.dsc, "Type:", atype, "Indicator:", ind)) self.fpdf.drawText() self.fpdf.drawText("%-21s %-20s %-18s %-19s %-18s" % \ ("", "Actual", "Budget", "Variance", "Last Year")) self.fpdf.drawText() m = self.s_per % 100 for x in range(14): if x == 0: mon = "Opening" elif x == 13: mon = "Closing" else: mon = mthnam[m][1] m = m + 1 if m > 12: m = m - 12 act = self.df.c_disp[1][x][0] bud = self.df.c_disp[1][x][1] var = self.df.c_disp[1][x][2] lyr = self.df.c_disp[1][x][3] self.fpdf.drawText("%-15s %-20s %-20s %-20s %-20s" % (mon, act, bud, var, lyr)) if x in (0, 12): self.fpdf.drawText() 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.pr.repprt, repeml=self.pr.repeml) else: trn = self.getTrans() if trn: heads = ["General Ledger Interrogation as at %s" % self.sysdtd] mthno, acctot = self.getObal() if mthno.work == 0: x = "(For all months)" d = self.opts["period"][1][0] else: x = "(For month " + mthno.disp + ")" d = (self.trnper * 100) + 1 heads.append("Account %s %s %s" % (self.num, self.dsc, x)) cols = [["glt_trdt", "D1", 10, " Date"], ["glt_refno", "Na", 9, "Reference"], ["glt_type", "NA", 3, "Typ"], ["glt_batch", "Na", 7, "BatchNo"], ["debit", "SD", 13.2, " Debit "], ["credit", "SD", 13.2, " Credit "], ["balance", "SD", 13.2, " Balance "], ["glt_desc", "NA", 30, "Remarks"]] if acctot: if acctot < 0: dr = 0 cr = acctot else: dr = acctot cr = 0 data = [(d, "B/Fwd", "", "", dr, cr, acctot, "Opening Balance")] else: data = [] col = self.sql.gentrn_col for num, rec in enumerate(trn): trdt = rec[col.index("glt_trdt")] refno = rec[col.index("glt_refno")] trtp = gltrtp[(rec[col.index("glt_type")]) - 1][0] batch = rec[col.index("glt_batch")] tramt = rec[col.index("glt_tramt")] if tramt < 0: debit = 0 credit = tramt else: debit = tramt credit = 0 detail = rec[col.index("glt_desc")] acctot = float(ASD(acctot) + ASD(tramt)) data.append((trdt, refno, trtp, batch, debit, credit, acctot, detail)) RepPrt(self.opts["mf"], name=self.__class__.__name__, conum=self.opts["conum"], conam=self.opts["conam"], tables=data, heads=heads, cols=cols, ttype="D", repprt=self.pr.repprt, repeml=self.pr.repeml) def doPrtExit(self): self.pr.closeProcess() def doPeriod(self, frt, pag, r, c, p, i, w): if w != 0 and (w < self.i_per or w > self.e_per): return "Invalid Period" self.trnper = w 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("%-34s %-10s %51s %5s" % \ ("General Ledger Interrogation as at", self.sysdtd, "Page", self.pgnum)) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 4 def getObal(self): acbal = self.obal if self.trnper: o = self.sql.getRec("gentrn", cols=["round(sum(glt_tramt), 2)"], where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.acno), ("glt_curdt", ">=", self.i_per), ("glt_curdt", "<", self.trnper)], limit=1) if o[0]: acbal = float(ASD(acbal) + ASD(o[0])) mthno = CCD(self.trnper % 100, "UI", 2.0) return mthno, acbal def getTrans(self): odr = "glt_acno, glt_curdt, glt_trdt, glt_type, glt_refno, glt_batch" if not self.trnper: whr = [("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.acno), ("glt_curdt", "between", self.i_per, self.e_per)] else: whr = [("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.acno), ("glt_curdt", "=", self.trnper)] return self.sql.getRec("gentrn", where=whr, order=odr) def doExit(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 sl3030(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, ["wagmst", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) wagctl = gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.fromad = wagctl["ctw_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]) return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Staff Loans Master Listing (%s)" % self.__class__.__name__) r1s = (("Number", "N"), ("Name", "M")) r2s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 1, "Sort Order", "", "N", "Y", self.doSort, None, None, None), (("T", 0, 1, 0), ("IRB", r2s), 1, "Ignore Zero Balances", "Ignore Zero Balances", "Y", "Y", 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=("N", "V"), mail=("Y", "N")) def doSort(self, frt, pag, r, c, p, i, w): self.sort = w def doZero(self, frt, pag, r, c, p, i, w): self.zero = w def doEnd(self): self.df.closeProcess() col = [ "wlm_empno", "wgm_sname", "wgm_fname", "wlm_loan", "wlm_desc", "wlm_code", "wlm_start", "wlm_rate", "wlm_repay", "sum(wlt_amt)" ] whr = [("wlm_cono", "=", self.opts["conum"]), ("wlm_cono=wgm_cono", ), ("wlm_empno=wgm_empno", ), ("wlt_cono=wgm_cono", ), ("wlt_empno=wgm_empno", ), ("wlt_loan=wlm_loan", )] if self.sort == "N": odr = "wlm_empno, wlm_loan" else: odr = "wlm_sname, wlm_loan" recs = self.sql.getRec(tables=["waglmf", "wagmst", "wagltf"], cols=col, where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Transaction Error", "No Transactions Selected") else: self.printReport(recs) self.closeProcess() def printReport(self, recs): p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) self.head = "%03u %-115s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) tot = 0 self.pglin = 999 for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break emp = CCD(dat[0], "UI", 5) nam = CCD("%s, %s" % (dat[1], dat[2].split()[0]), "NA", 40) lon = CCD(dat[3], "UI", 2) des = CCD(dat[4], "NA", 20) cod = CCD(dat[5], "UI", 2) dte = CCD(dat[6], "d1", 10) per = CCD(dat[7], "UD", 6.2) ded = CCD(dat[8], "SD", 13.2) bal = CCD(dat[9], "SD", 13.2) if self.zero == "Y" and not bal.work: continue tot = float(ASD(tot) + ASD(bal.work)) if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText( "%s %s %s %s %s %s %s %s %s" % (emp.disp, nam.disp, lon.disp, des.disp, cod.disp, dte.disp, per.disp, ded.disp, bal.disp)) self.pglin += 1 p.closeProgress() if self.fpdf.page and not p.quit: tot = CCD(tot, "SD", 13.2) self.fpdf.drawText() self.fpdf.drawText("%5s %-100s%s" % ("", "Total", tot.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, fromad=self.fromad, repeml=self.df.repeml) def pageHeading(self): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() self.fpdf.drawText("%-29s %-10s" % \ ("Staff Loans Master List as at", self.sysdtd)) self.fpdf.drawText() self.fpdf.drawText("%-15s%-1s%-3s%-16s%-1s%-3s%-4s%-1s%-1s" % \ ("(Options: Sort-", self.df.t_disp[0][0][0], "", "Ignore Zero Bal-", self.df.t_disp[0][0][1], "", "Csv-", self.df.t_disp[0][0][2], ")")) self.fpdf.drawText() self.fpdf.drawText("%-5s %-40s %-2s %-20s %-2s %-10s %-6s %-13s "\ "%-13s" % ("EmpNo", "Name", "Ln", "Description", "Cd", "Start-Date", "I-Rate", " Deduction", " Balance")) 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 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 si3030(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, ["strgrp", "strloc", "strmf1"], 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 self.locs = strctl["cts_locs"] slsctl = gc.getCtl("slsctl", self.opts["conum"]) if not slsctl: return self.fromad = slsctl["ctv_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"]), "Period Sales By Product Report (%s)" % self.__class__.__name__) loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } if "args" in self.opts and "noprint" in self.opts["args"]: var = self.opts["args"]["work"][0] view = None mail = None else: var = ["", "", ""] view = ("N", "V") mail = ("Y", "N") fld = ((("T", 0, 0, 0), "ID2", 7, "Period", "", int(self.sysdtw / 100), "Y", self.doPer, None, None, ("efld", )), (("T", 0, 1, 0), "IUA", 1, "Location", "", var[1], "N", self.doLoc, loc, None, ("efld", )), (("T", 0, 2, 0), "IUA", 3, "Product Group", "", var[2], "N", self.doGroup, grp, 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 doPer(self, frt, pag, r, c, p, i, w): if w < int(self.opts["period"][1][0] / 100) or \ w > int(self.opts["period"][2][0] / 100): return "Invalid Period" self.per = w if self.locs == "N": self.loc = "" self.locd = "ALL" return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): if not w: self.locd = "ALL" else: acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not acc: return "Invalid Location" self.locd = "%s %s" % (w, acc[0]) self.loc = w def doGroup(self, frt, pag, r, c, p, i, w): if w: acc = self.getGroup(w) if not acc: return "Invalid Group" self.grp = w def doEnd(self): self.df.closeProcess() if not self.grp: sgrp = "" egrp = "zzz" else: sgrp = egrp = self.grp recs = self.sql.getRec( "strmf1", cols=["st1_group", "st1_code", "st1_desc", "st1_uoi"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", ">=", sgrp), ("st1_group", "<=", egrp)], order="st1_group, st1_code") if not recs: showError(self.opts["mf"].body, "Processing Error", "No Records Selected") 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 printReport(self, recs): p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) self.head = "%03u %-108s" % (self.opts["conum"], self.opts["conam"]) self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head) self.stot = [0] * 3 self.gtot = [0] * 3 lstgrp = "" self.pglin = 999 for num, rec in enumerate(recs): p.displayProgress(num) if p.quit: break self.grp = CCD(rec[0], "UA", 3) code = CCD(rec[1], "NA", 20) desc = CCD(rec[2], "NA", 30) uoi = CCD(rec[3], "NA", 10) bals = Balances(self.opts["mf"], "STR", self.opts["conum"], self.per, keys=(self.grp.work, code.work, self.loc, ("P", self.opts["period"][0]))) m_ob, m_mv, m_cb, y_ob, y_mv, y_cb, ac, lc, ls = bals.doStrBals() m_qty = 0 m_cst = 0 m_sls = 0 for t, q, c, s in m_mv: if t == 7: m_qty = q m_cst = c m_sls = s break mq = CCD(float(ASD(0) - ASD(m_qty)), "SD", 13.2) mc = CCD(float(ASD(0) - ASD(m_cst)), "SD", 13.2) ms = CCD(float(ASD(0) - ASD(m_sls)), "SD", 13.2) mp = float(ASD(ms.work) - ASD(mc.work)) mp = CCD(mp, "SD", 13.2) if ms.work == 0: mn = 0 else: mn = round((mp.work * 100.0 / ms.work), 2) mn = CCD(mn, "SD", 7.2) if mq.work == 0 and mc.work == 0 and ms.work == 0: continue if lstgrp and lstgrp != self.grp.work: self.groupTotal() self.pglin = 999 if self.pglin > self.fpdf.lpp: self.pageHeading() self.fpdf.drawText("%s %s %s %s %s %s %s" % (code.disp, desc.disp, uoi.disp, mq.disp, ms.disp, mp.disp, mn.disp)) self.stot[0] = float(ASD(self.stot[0]) + ASD(mq.work)) self.stot[1] = float(ASD(self.stot[1]) + ASD(ms.work)) self.stot[2] = float(ASD(self.stot[2]) + ASD(mp.work)) self.gtot[0] = float(ASD(self.gtot[0]) + ASD(mq.work)) self.gtot[1] = float(ASD(self.gtot[1]) + ASD(ms.work)) self.gtot[2] = float(ASD(self.gtot[2]) + ASD(mp.work)) self.pglin += 1 lstgrp = self.grp.work p.closeProgress() if self.fpdf.page and not p.quit: self.groupTotal() 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): self.fpdf.add_page() self.fpdf.setFont(style="B") self.fpdf.drawText(self.head) self.fpdf.drawText() per = CCD(self.per, "D2", 7) self.fpdf.drawText("%-27s %-7s" % \ ("Period Sales By Product for", per.disp)) self.fpdf.drawText() acc = self.getGroup(self.grp.work) if acc: grpd = acc[0] else: grpd = "Missing Group Record" self.fpdf.drawText("%s %s %s %s %s" % \ ("Group:", self.grp.disp, grpd, "Location:", self.locd)) self.fpdf.drawText() self.fpdf.drawText("%-20s %-30s %-10s %13s %13s %13s %7s" % \ ("Product-Code", "Description", "U.O.I", "Quantity ", "Value ", "Profit ", "Prft-% ")) self.fpdf.underLine(txt=self.head) self.fpdf.setFont() self.pglin = 8 def getGroup(self, grp): acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", grp)], limit=1) return acc def groupTotal(self): self.fpdf.drawText() mq = CCD(self.stot[0], "SD", 13.2) ms = CCD(self.stot[1], "SD", 13.2) mp = CCD(self.stot[2], "SD", 13.2) if ms.work == 0: mn = 0 else: mn = round((mp.work * 100.0 / ms.work), 2) mn = CCD(mn, "SD", 7.2) self.fpdf.drawText("%-20s %-41s %s %s %s %s" % \ ("", "Group Totals", mq.disp, ms.disp, mp.disp, mn.disp)) self.stot = [0] * 3 def grandTotal(self): self.fpdf.drawText() mq = CCD(self.gtot[0], "SD", 13.2) ms = CCD(self.gtot[1], "SD", 13.2) mp = CCD(self.gtot[2], "SD", 13.2) if ms.work == 0: mn = 0 else: mn = round((mp.work * 100.0 / ms.work), 2) mn = CCD(mn, "SD", 7.2) self.fpdf.drawText("%-20s %-41s %s %s %s %s" % \ ("", "Grand Totals", mq.disp, ms.disp, mp.disp, mn.disp)) def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): if "wait" not in self.opts: 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()