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 wg1010(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, ["ctldep", "chglog", "wagbal", "wagcap", "wagcod", "wagedc", "wagmst", "wagtf1", "wagtf2", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): wgm = { "stype": "R", "tables": ("wagmst",), "cols": ( ("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0, "Names"), ("wgm_freq", "", 0, "F"), ("wgm_start", "", 0, "Start-Date"), ("wgm_term", "", 0, "Term-Date")), "where": [("wgm_cono", "=", self.opts["conum"])]} dep = { "stype": "R", "tables": ("ctldep",), "cols": ( ("dep_code", "", 0, "Dep"), ("dep_name", "", 0, "Name", "Y")), "where": [("dep_cono", "=", self.opts["conum"])]} wec = { "stype": "R", "tables": ("wagedc",), "cols": ( ("ced_code", "", 0, "Code"), ("ced_desc", "", 0, "Description", "Y")), "where": [ ("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "E")]} wdc = { "stype": "R", "tables": ("wagedc",), "cols": ( ("ced_code", "", 0, "Code"), ("ced_desc", "", 0, "Description", "Y")), "where": [ ("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "D")]} r1s = (("Weekly","W"),("2xWeekly","F"),("Monthly ","M")) r2s = (("Cash ","C"),("Cheque ","Q"),("Electronic","E")) r3s = (("Yes","Y"),("No","N")) r4s = (("Current","1"),("Transmission","2"),("Savings","3")) fld = ( (("T",0,0,0),"IUI",5,"Emp-Num","Employee Number", "","Y",self.doEmpNum,wgm,None,("notzero",)), (("T",0,0,0),"IUI",3,"Department","", "","N",self.doDept,dep,None,None), (("T",0,0,0),"IUI",1,"Class","", "","N",None,None,None,None), (("T",1,0,0),"INA",30,"Surname","", "","N",None,None,None,("notblank",)), (("T",1,1,0),"INA",30,"Names","", "","N",None,None,None,("notblank",)), (("T",1,2,0),"ID1",10,"Date of Birth","", "","N",self.doDOB,None,None,("efld",)), (("T",1,3,0),"INA",13,"ID Number","", "","N",self.doIdNo,None,None,("idno",)), (("T",1,4,0),"INA",16,"Spouse Name","", "","N",None,None,None,None), (("T",1,5,0),"INA",13,"Spouse ID Number","", "","N",self.doIdNo,None,None,("idno",)), (("T",1,6,0),"INA",30,"Address Line 1","", "","N",None,None,None,("notblank",)), (("T",1,7,0),"INA",30,"Address Line 2","", "","N",None,None,None,None), (("T",1,8,0),"INA",30,"Address Line 3","", "","N",None,None,None,None), (("T",1,9,0),"INA",4,"Postal Code","", "","N",None,None,None,("notblank",)), (("T",1,10,0),"INA",16,"Telephone Number","", "","N",None,None,None,None), (("T",1,11,0),"ITX",50,"E-Mail Address","", "","N",None,None,None,("email",)), (("T",1,12,0),"ID1",10,"Start Date","", "","N",None,None,None,("efld",)), (("T",1,13,0),"IUD",10.2,"Salary/Rate","", "","N",None,None,None,("efld",)), (("T",1,14,0),("IRB",r1s),0,"Pay Freq","Pay Frequency", "M","N",None,None,None,None), (("T",1,15,0),("IRB",r2s),0,"Pay Type","", "E","N",self.doPayTyp,None,None,None), (("T",2,0,0),("IRB",r3s),0,"P.A.Y.E.","", "Y","N",None,None,None,None), (("T",2,1,0),"INA",16,"Tax Office","", "","N",None,None,None,None), (("T",2,2,0),"INA",10,"Tax Number","", "","N",None,None,None,None), (("T",2,3,0),"IUA",1,"Nature of Employee","", "A","N",None,None,None,("notblank",)), (("T",2,4,0),"IUI",9,"Reg Number","Registration Number", "","N",None,None,None,None), (("T",2,5,0),"IUA",1,"Voluntary Excess","", "N","N",None,None,None,None), (("T",2,6,0),"IUD",6.2,"Fixed Rate","", "","N",None,None,None,None), (("T",2,7,0),"INA",13,"Directive","", "","N",None,None,None,None), (("T",3,0,0),("IRB",r4s),0,"Account Type","Bank Account Type", "1","N",None,None,None,None), (("T",3,1,0),"INA",30,"Bank Name","", "","N",self.doBankNam,None,None,None), (("T",3,2,0),"IUI",8,"Branch Code","Bank Branch Code", "","N",self.doBankBch,None,None,None), (("T",3,3,0),"INA",16,"Account Number","Bank Account Number", "","N",self.doBankAcc,None,None,None), (("T",3,4,0),"INA",30,"Account Holder's Name","", "","N",self.doHolderNam,None,None,None), (("T",3,5,0),"IUI",1,"Holder's Relationship","", "","N",self.doHolderRel,None,None,None), (("C",4,0,0),"IUI",3,"Cod","Earnings Code", "","N",self.doEarnCod,wec,None,("efld",)), (("C",4,0,1),"ONA",30,"Description"), (("C",4,0,2),"ISD",13.2,"Amnt/Rate","Amount or Rate", "","N",self.doEarnAmt,None,self.doCodeDelete,("efld",)), (("C",5,0,0),"IUI",3,"Cod","Deduction Code", "","N",self.doDedCod,wdc,None,("efld",)), (("C",5,0,1),"ONA",30,"Description"), (("C",5,0,2),"ISD",13.2,"Amnt/Rate","Employees Amount or Rate", "","N",self.doDedEAmt,None,self.doCodeDelete,("efld",)), (("C",5,0,3),"ISD",13.2,"Amnt/Rate","Employers Amount or Rate", "","N",self.doDedRAmt,None,None,("efld",)), (("T",6,0,0),"ISD",13.2,"Balance-1","", "","N",None,None,None,("efld",)), (("T",6,1,0),"ISD",13.2,"Balance-2","", "","N",None,None,None,("efld",)), (("T",6,2,0),"ISD",13.2,"Balance-3","", "","N",None,None,None,("efld",))) tag = ( ("General",None,("T",0,0),("T",0,1)), ("Tax",None,("T",0,0),("T",0,1)), ("Bank",None,("T",0,0),("T",0,1)), ("Earnings",None,("T",0,0),("T",0,1)), ("Deductions",None,("T",0,0),("T",0,1)), ("Balances",None,("T",0,0),("T",0,1))) tnd = ( (self.doEnd, "n"), (self.doEnd, "n"), (self.doEnd, "n"), (self.doEnd, "n"), None, None, (self.doEnd, "y")) txt = ( self.doExit, self.doExit, self.doExit, self.doExit, None, None, self.doExit) cnd = ( None, None, None, None, (self.doEndEarn, "y"), (self.doEndDed, "y"), None) cxt = ( None, None, None, None, self.doExit, self.doExit, None) but = ( ("Accept",None,self.doAccept,0,("T",0,2),("T",0,1)), ("Print",None,self.doPrint,0,("T",0,2),("T",0,0)), ("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0)), ("Quit",None,self.doCloseProcess,1,None,None)) row = [0,0,0,0,15,15,0] self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but, clicks=self.doClick) def doClick(self, *opts): if self.df.pag == 0: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doEmpNum(self, frt, pag, r, c, p, i, w): self.empno = w self.oldm = self.sql.getRec("wagmst", where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", self.empno)], limit=1) self.oldb = self.sql.getRec("wagbal", where=[("wbl_cono", "=", self.opts["conum"]), ("wbl_empno", "=", self.empno)], order="wbl_balno") if not self.oldm: self.new = True self.term = 0 self.ptyp = "" else: self.new = False self.term = self.oldm[len(self.oldm)-1] d = 1 for pg in range(0, self.df.pgs): for x in range(0, self.df.topq[pg]): self.df.loadEntry("T", pg, x, data=self.oldm[d]) d = d + 1 self.ptyp = self.df.t_work[1][0][15] self.doLoadEarnDed("E") self.doLoadEarnDed("D") if self.oldb: for b in self.oldb: self.df.loadEntry("T", 6, b[2]-1, data=b[3]) def doDept(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctldep", cols=["dep_name"], where=[("dep_cono", "=", self.opts["conum"]), ("dep_code", "=", w)], limit=1) if not acc: return "Invalid Department" self.dept = w def doDOB(self, frt, pag, r, c, p, i, w): self.dob = w def doIdNo(self, frt, pag, r, c, p, i, w): if p == 6: a = int(int(w) / 10000000) b = int(self.dob % 1000000) if a != b: return "ID Number Does Not Agree with Birth Date" def doPayTyp(self, frt, pag, r, c, p, i, w): self.ptyp = w def doBankNam(self, frt, pag, r, c, p, i, w): if self.ptyp == "E" and not w: return "Invalid Bank Name" def doBankBch(self, frt, pag, r, c, p, i, w): if self.ptyp == "E" and not w: return "Invalid Branch" def doBankAcc(self, frt, pag, r, c, p, i, w): if self.ptyp == "E" and not w: return "Invalid Account" def doHolderNam(self, frt, pag, r, c, p, i, w): self.holnam = w def doHolderRel(self, frt, pag, r, c, p, i, w): self.holrel = w def doEnd(self): if self.df.pag == 0: self.df.focusField("T", 1, 1) elif self.df.pag == 1: self.df.selPage("Tax") self.df.focusField("T", 2, 1) elif self.df.pag == 2: self.df.selPage("Bank") self.df.focusField("T", 3, 1) elif self.df.pag == 3: self.df.selPage("Earnings") elif self.df.pag == 6: self.doAccept() def doEarnCod(self, frt, pag, r, c, p, i, w): desc = self.sql.getRec("wagedc", cols=["ced_desc"], where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "E"), ("ced_code", "=", w)], limit=1) if not desc: return "Invalid Code" self.code = w self.df.loadEntry(frt, pag, p+1, data=desc[0]) code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"], where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type", "=", "E"), ("wcd_code", "=", w)], limit=1) if not code: self.ncod = "y" else: self.ncod = "n" self.df.loadEntry(frt, pag, p+2, data=code[0]) def doEarnAmt(self, frt, pag, r, c, p, i, w): self.eamt = w self.ramt = 0 def doEndEarn(self): self.doEndCode("E") def doDedCod(self, frt, pag, r, c, p, i, w): desc = self.sql.getRec("wagedc", cols=["ced_desc"], where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "D"), ("ced_code", "=", w)], limit=1) if not desc: return "Invalid Code" self.code = w self.df.loadEntry(frt, pag, p+1, data=desc[0]) code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"], where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type", "=", "D"), ("wcd_code", "=", w)], limit=1) if not code: self.ncod = "y" else: self.ncod = "n" self.df.loadEntry(frt, pag, p+2, data=code[0]) self.df.loadEntry(frt, pag, p+3, data=code[1]) def doDedEAmt(self, frt, pag, r, c, p, i, w): self.eamt = w def doDedRAmt(self, frt, pag, r, c, p, i, w): self.ramt = w def doEndDed(self): self.doEndCode("D") def doEndCode(self, rtype): if self.ncod == "y": self.sql.insRec("wagcod", data=[self.opts["conum"], self.empno, rtype, self.code, self.eamt, self.ramt]) else: self.sql.updRec("wagcod", cols=["wcd_eamt", "wcd_ramt"], data=[self.eamt, self.ramt], where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type", "=", rtype), ("wcd_code", "=", self.code)]) self.doLoadEarnDed(rtype, focus=True) def doLoadEarnDed(self, rtype, focus=False): if rtype == "E": pag = 4 else: pag = 5 self.df.clearFrame("C", pag) codes = self.sql.getRec(tables=["wagcod", "wagedc"], cols=["wcd_code", "ced_desc", "wcd_eamt", "wcd_ramt"], where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type", "=", rtype), ("ced_cono = wcd_cono",), ("ced_type = wcd_type",), ("ced_code = wcd_code",)]) if not codes: return p = 0 for cod in codes: for i, c in enumerate(cod): if rtype == "E" and i == 3: continue self.df.loadEntry("C", pag, p, data=c) p = p + 1 if focus: self.df.focusField("C", pag, p+1) else: self.df.last[pag][1] = p + 1 def doCodeDelete(self): if self.df.pag == 4: rtype = "E" else: rtype = "D" code = self.df.c_work[self.df.pag][self.df.row][self.df.idx-2] self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type", "=", rtype), ("wcd_code", "=", code)]) self.doLoadEarnDed(rtype, focus=True) def doAccept(self): frt, pag, col, mes = self.df.doCheckFields(("T",0,None)) if not mes: frt, pag, col, mes = self.df.doCheckFields(("T",1,None)) if not mes: frt, pag, col, mes = self.df.doCheckFields(("T",2,None)) if not mes and self.df.t_work[1][0][15] == "E": frt, pag, col, mes = self.df.doCheckFields(("T",3,None)) if mes: if pag > 0 and pag != self.df.pag: if frt == "T": self.df.last[pag][0] = col+1 else: self.df.last[pag][1] = col+1 self.df.selPage(self.df.tags[pag - 1][0]) self.df.focusField(frt, pag, (col+1), err=mes) else: data = [self.opts["conum"]] for p in range(0, self.df.pgs): for x in range(0, self.df.topq[p]): data.append(self.df.t_work[p][0][x]) data.append(self.term) if self.new: self.sql.insRec("wagmst", data=data) for b in range(3): data = [self.opts["conum"], self.empno, b+1, self.df.t_work[6][0][b], ""] self.sql.insRec("wagbal", data=data) else: dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) if data != self.oldm[:len(data)]: col = self.sql.wagmst_col data.append(self.oldm[col.index("wgm_xflag")]) self.sql.updRec("wagmst", data=data, where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", self.empno)]) for num, dat in enumerate(self.oldm): if dat != data[num]: self.sql.insRec("chglog", data=["wagmst", "U", "%03i%05i" % (self.opts["conum"], self.empno), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0]) for n, b in enumerate(self.df.t_work[6][0]): lvl = n + 1 data = [self.opts["conum"], self.empno, lvl, b] whr = [ ("wbl_cono", "=", self.opts["conum"]), ("wbl_empno", "=", self.empno), ("wbl_balno", "=", lvl)] chk = self.sql.getRec("wagbal", where=whr, limit=1) if not chk: self.sql.insRec("wagbal", data=data) continue if data != self.oldb[n][:len(data)]: col = self.sql.wagbal_col data.append(self.oldb[n][col.index("wbl_xflag")]) self.sql.updRec("wagbal", data=data, where=whr) for num, dat in enumerate(self.oldb[n]): if dat != data[num]: self.sql.insRec("chglog", data=["wagbal", "U", "%03i%05i%i" % (self.opts["conum"], self.empno, lvl), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0]) self.opts["mf"].dbm.commitDbase() self.df.last[0] = [0, 0] self.df.selPage("General") self.df.focusField("T", 0, 1) def doMainDelete(self): t = self.sql.getRec("wagtf1", cols=["count(*)"], where=[("wt1_cono", "=", self.opts["conum"]), ("wt1_empno", "=", self.empno)], limit=1) if t[0]: return "Transactions 1 Exist, Not Deleted" t = self.sql.getRec("wagtf2", cols=["count(*)"], where=[("wt2_cono", "=", self.opts["conum"]), ("wt2_empno=%s", "=", self.empno)], limit=1) if t[0]: return "Transactions 2 Exist, Not Deleted" t = self.sql.getRec("wagltf", cols=["count(*)"], where=[("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=", self.empno)], limit=1) if t[0]: return "Loan Transactions Exist, Not Deleted" self.sql.delRec("wagbal", where=[("wbl_cono", "=", self.opts["conum"]), ("wbl_empno", "=", self.empno)]) self.sql.delRec("wagcap", where=[("wcp_cono", "=", self.opts["conum"]), ("wcp_empno", "=", self.empno)]) self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=", self.empno)]) self.sql.delRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno)]) self.sql.delRec("wagmst", where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", self.empno)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["wagmst", "D", "%03i%05i" % (self.opts["conum"], self.empno), "", dte, self.opts["capnm"], "", "", "", 0]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doPrint(self): tables = [] for pag in range(0, (self.df.pgs+1)): for x in range(0, self.df.topq[pag]): lin = [] lin.append(self.df.topf[pag][x][3]) lin.append(self.df.t_disp[pag][0][x]) tables.append(lin) heads = ["Salaries and Wages File Maintenance"] cols = [["a","NA",30.0,"Field Name"], ["b","NA",30.0,"Values"]] state = self.df.disableButtonsTags() RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=tables, heads=heads, cols=cols, conum=self.opts["conum"], conam=self.opts["conam"], ttype="D") self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.last[0] = [0, 0] self.df.selPage("General") self.df.focusField("T", 0, 1) def doExit(self): if self.df.pag == 0: self.doCloseProcess() elif self.df.pag == 1: self.df.focusField("T", 0, 3) elif self.df.pag == 2: self.df.selPage("General") elif self.df.pag == 3: self.df.selPage("Tax") elif self.df.pag == 4: self.df.selPage("Deductions") elif self.df.pag == 5: self.df.selPage("Balances") def doCloseProcess(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class st3110(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, ["ctlvrf", "strgrp", "strloc", "strprc", "strmf1", "strmf2", "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"] 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"]), "Print Stores Labels (%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"])]} gpm = { "stype": "R", "tables": ("strgrp",), "cols": ( ("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])]} stm = { "stype": "R", "tables": ("strmf1",), "cols": ( ("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_desc", "", 0, "Description", "Y")), "where": [ ("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "X")], "whera": [["T", "st1_group", 2, 0]], "index": 1} lab = { "stype": "C", "head": ("Codes",), "data": list(labels.keys())} r1s = (("Normal", "N"), ("Recipes", "R")) r2s = (("Average", "A"), ("Standard", "S"), ("All", "B")) r3s = (("No", "N"), ("Yes", "Y")) fld = [ (("T",0,0,0),"ID1",10,"Reporting Date","", self.sysdtw,"Y",self.doDate,None,None,("efld",)), [("T",0,1,0),"IUA",1,"Location","", 0,"Y",self.doLoc,loc,None,None], (("T",0,2,0),"IUA",3,"Product Group","", "","Y",self.doGrp,gpm,None,None), (("T",0,3,0),"INA",20,"Product Code","", "","Y",self.doCode,stm,None,None), (("T",0,4,0),("IRB",r1s),0,"Item Types","", "N","Y",self.doTypes,None,None,None), (("T",0,5,0),("IRB",r2s),0,"Value Indicator","", "A","Y",self.doValInd,None,None,None), (("T",0,6,0),("IRB",r3s),0,"Include Out of Stock ","", "N","Y",self.doOuts,None,None,None), (("T",0,7,0),"IUA",10,"Cost Price Code","", "","Y",self.doCCode,None,None,None), (("T",0,8,0),"IUA",5,"Avery A4 Code","", "L7159","Y",self.doAvery,lab,None,("in",labels)), (("T",0,9,0),"IUI",2,"First Label Row","", 1,"Y",self.doRow,None,None,("notzero",)), (("T",0,10,0),"IUI",2,"First Label Column","", 1,"Y",self.doCol,None,None,("notzero",))] 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=("N","V")) def doDate(self, frt, pag, r, c, p, i, w): self.date = w if self.locs == "N": self.loc = "1" self.df.loadEntry(frt, pag, p+1, data=self.loc) return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): self.loc = w if self.loc: acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Location Code" def doGrp(self, frt, pag, r, c, p, i, w): self.grp = w if self.grp: acc = self.sql.getRec("strgrp", cols=["gpm_group"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" def doCode(self, frt, pag, r, c, p, i, w): self.code = w if self.code: acc = self.sql.getRec("strmf1", cols=["st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", w), ("st1_type", "<>", "X")], limit=1) if not acc: return "Invalid or Redundant Code" def doTypes(self, frt, pag, r, c, p, i, w): self.types = w def doValInd(self, frt, pag, r, c, p, i, w): self.valind = w def doOuts(self, frt, pag, r, c, p, i, w): self.outs = w def doCCode(self, frt, pag, r, c, p, i, w): self.ccode = w if self.ccode: spl = w.split() if len(spl) != 1 or len(spl[0]) != 10: return "Must Have 10 Valid Characters" def doAvery(self, frt, pag, r, c, p, i, w): self.label = w def doRow(self, frt, pag, r, c, p, i, w): if w > labels[self.label]["NY"]: return "Out of Range" self.srow = w def doCol(self, frt, pag, r, c, p, i, w): if w > labels[self.label]["NX"]: return "Out of Range" self.scol = w def doEnd(self): self.df.closeProcess() self.prnt = False whr = [("st1_cono", "=", self.opts["conum"])] if self.grp: whr.append(("st1_group", "=", self.grp)) if self.code: whr.append(("st1_code", "=", self.code)) whr.append(("st1_type", "=", self.types)) if self.valind in ("A", "S"): whr.append(("st1_value_ind", "=", self.valind)) if self.loc: whr.append(("st2_loc", "=", self.loc)) whr.extend([ ("st2_cono=st1_cono",), ("st2_group=st1_group",), ("st2_code=st1_code",)]) rec = self.sql.getRec(tables=["strmf1", "strmf2"], cols=["st2_loc", "st2_group", "st2_code", "st1_desc", "st1_value_ind", "st1_vatcode"], where=whr, order="st2_group, st2_code, st2_loc") if not rec: showError(self.opts["mf"].body, "Error", "No Records Selected") else: self.fpdf = TartanLabel(self.label, posY=self.srow, posX=self.scol) self.fpdf.add_page() p = ProgressBar(self.opts["mf"].body, mxs=len(rec), esc=True) for num, dat in enumerate(rec): p.displayProgress(num) if p.quit: break self.doProcess(dat) 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) self.closeProcess() def doProcess(self, dat): loc, group, code, desc, valind, vatcod = dat icost, bal = getCost(self.sql, self.opts["conum"], group, code, loc=loc, qty=1, ind="I", bal=True) if self.outs == "N" and not bal[0]: return if self.ccode: # Calculate cost price code cost = CCD(int(icost * 100), "UI", 9) ncost = " " * (9 - len(str(cost.work))) for x in str(cost.work): ncost = ncost + self.ccode[int(x)] lab = "%-30s %13s" % (self.df.t_disp[0][0][0], ncost) else: lab = "%-30s" % self.df.t_disp[0][0][0] #################################################################### lab = "%s\n%s %s %s" % (lab, loc, group, code) lab = "%s\n%s\n" % (lab, desc) prc = getSell(self.sql, self.opts["conum"], group, code, loc) price1 = CCD(prc, "UD", 9.2) vrte = getVatRate(self.sql, self.opts["conum"], vatcod, self.date) if vrte is None: vrte = CCD(0, "UD", 9.2) else: vrte = CCD(vrte, "UD", 9.2) price2 = CCD(round((price1.work * float(ASD(100) + \ ASD(vrte.work)) / 100.0), 2), "OUD", 9.2) lab = "%s\n%s %s %s" % (lab, vatcod, price1.disp, price2.disp) self.fpdf.add_label(lab) def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class st1010(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, [ "ctlvmf", "ctlrep", "drschn", "drsmst", "genmst", "slsiv1", "slsiv2", "strgrp", "strloc", "strmf1", "strmf2", "strgmu", "strcmu", "strprc", "strrcp", "struoi", "strtrn", "strpot", "strvar", "slsiv3", "chglog" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] self.automu = strctl["cts_automu"] self.drsctl = gc.getCtl("drsctl", self.opts["conum"], error=False) if not self.drsctl: self.chains = "N" else: self.chains = self.drsctl["ctd_chain"] return True def mainProcess(self): gpm = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } stm = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "X")], "whera": [], "index": 1 } loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } unm = { "stype": "R", "tables": ("struoi", ), "cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0, "Description", "Y")), "where": [("unm_cono", "=", self.opts["conum"])] } drc = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } drm = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1")) } if self.chains == "Y": drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_stat", "<>", "X")] drm["whera"] = [["T", "drm_chain", 10]] else: drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", 0), ("drm_stat", "<>", "X")] vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } tag = (("Basic-_A", None, ("T", 0, 0), ("T", 0, 1)), ("Basic-_B", None, ("T", 0, 0), ("T", 0, 1)), ("Recipes", self.doReadLoadRecipe, None, ("T", 0, 1))) r1s = (("Normal", "N"), ("Recipe", "R")) r2s = (("Average", "A"), ("Standard", "S"), ("None", "N")) r3s = (("Manual", "M"), ("Automatic", "A"), ("Zero", "N")) self.fld = [(("T", 0, 0, 0), "IUA", 3, "Group", "Product Group", "", "Y", self.doGroup, gpm, None, ("notblank", )), (("T", 0, 0, 0), "INA", 20, "Code", "Product Code", "", "N", self.doCode, stm, None, ("notblank", )), (("T", 0, 0, 0), "IUA", 1, "Loc", "Location", "1", "N", self.doLoc, loc, None, ("notblank", )), (("T", 0, 0, 0), "ONA", 30, ""), (("T", 1, 0, 0), ("IRB", r1s), 0, "Type of Item", "", "N", "N", self.doType, None, None, None), (("T", 1, 1, 0), "INA", 30, "Description", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 1, 2, 0), "INA", 10, "Unit of Issue", "", "", "N", self.doUoi, unm, None, ("notblank", )), (("T", 1, 2, 0), "ONA", 30, ""), (("T", 1, 3, 0), ("IRB", r2s), 0, "Cost Price Indicator", "", "A", "N", self.doValInd, None, None, None), (("T", 1, 4, 0), "IUA", 1, "VAT Code", "", "", "N", self.doVat, vtm, None, ("notblank", )), (("T", 1, 4, 0), "ONA", 30, ""), (("T", 1, 5, 0), "IUI", 3, "Exclusive Chainstore", "", "", "N", self.doChnExcl, drc, None, ("efld", )), (("T", 1, 5, 0), "ONA", 30, ""), (("T", 1, 6, 0), "INA", 7, "Exclusive Account", "", "", "N", self.doAccExcl, drm, None, ("efld", )), (("T", 1, 6, 0), "ONA", 30, ""), (("T", 1, 7, 0), "IUI", 7, "Sales Code", "", "", "N", self.doSales, glm, None, ("efld", )), (("T", 1, 7, 0), "ONA", 30, ""), (("T", 1, 8, 0), "IUI", 7, "COS Code", "", "", "N", self.doCos, glm, None, ("efld", )), (("T", 1, 8, 0), "ONA", 30, ""), (("T", 2, 0, 0), "IUA", 8, "Bin Number", "", "", "N", None, None, self.doDelete, ("efld", )), (("T", 2, 1, 0), ("IRB", r3s), 0, "Re-Order Indicator", "", "A", "N", self.doReord, None, None, None), (("T", 2, 2, 0), "IUI", 7, "Re-Order Level", "", "", "N", None, None, None, ("efld", )), (("T", 2, 3, 0), "IUI", 7, "Re-Order Quantity", "", "", "N", None, None, None, ("efld", ))] if self.automu in ("A", "L"): self.fld.append( (("T", 2, 4, 0), "IUD", 6.2, "Percentabge Markup Lv1", "", "", "N", None, None, None, ("efld", ))) for x in range(1, self.plevs): self.fld.append((("T", 2, 4, 0), "IUD", 6.2, "Lv%s" % (x + 1), "", "", "N", None, None, None, ("efld", ))) self.fld.extend([(("C", 3, 0, 0), "INA", 3, "Grp", "Product Group", "r", "N", self.doRecGrp, gpm, None, None), (("C", 3, 0, 1), "INA", 20, "Product-Code", "Product Code", "", "N", self.doRecCod, stm, None, None), (("C", 3, 0, 2), "ONA", 30, "Description"), (("C", 3, 0, 3), "IUD", 11.2, "Quantity", "", "", "N", self.doRecQty, None, self.doDelRec, ("notzero", ))]) but = (("Edit", None, self.doEditor, 0, ("C", 3, 1), None), ("Accept", None, self.doAccept, 0, ("T", 0, 0), ("T", 0, 1)), ("Cancel", None, self.doCancel, 0, ("T", 0, 0), ("T", 0, 1)), ("Quit", None, self.doQuit, 1, None, None)) tnd = ((self.doEnd, "N"), (self.doEnd, "N"), (self.doEnd, "Y"), None) txt = (self.doExit, self.doExit, self.doExit, self.doExit) cnd = (None, None, None, (self.doEnd, "N")) cxt = (None, None, None, self.doExit) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, tags=tag, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, clicks=self.doClick) def doClick(self, *opts): if self.df.pag == 0 or not self.gtype: return if opts[0] == (1, 0) and not self.newcode: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doGroup(self, frt, pag, r, c, p, i, w): self.grpacc = self.sql.getRec( "strgrp", cols=["gpm_vatcode", "gpm_sales", "gpm_costs"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not self.grpacc: return "Invalid Group" self.group = w self.df.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]] def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.mups = [0, 0, 0, 0, 0] self.old1 = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", w)], limit=1) if not self.old1: self.newcode = True self.gtype = None elif self.old1[3] == "X": return "Redundant Code" else: self.newcode = False d = 3 for x in range(0, self.df.topq[1]): if x in (3, 6, 8, 10, 12, 14): continue if x == 0: self.gtype = self.old1[d] self.df.loadEntry("T", 1, x, data=self.old1[d]) if x == 2: get = self.getUoi(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 5: get = self.getVat(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 7: get = self.getChnExcl(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 9: get = self.getAccExcl(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if self.glint == "Y" and x in (11, 13): get = self.getGenDes(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) d += 1 if self.locs == "N": self.loc = "1" self.df.loadEntry("T", 0, 2, data=self.loc) err = self.checkLoc() if err: return err return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): if w == 0: return "Invalid Location" self.loc = w err = self.checkLoc() if err: return err def checkLoc(self): acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Location Code" else: self.df.loadEntry("T", 0, 3, data=acc[0]) self.old2 = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)], limit=1) if not self.old2: ok = askQuestion(self.opts["mf"].body, "New Location", "This location does not exist for this product. " \ "Are you sure that you want to create it?") if ok == "yes": self.newloc = "Y" else: return "Rejected Location" if not self.old2: self.newloc = "Y" else: self.newloc = "N" d = 3 for x in range(0, 4): d = d + 1 self.df.loadEntry("T", 2, x, data=self.old2[d]) if self.automu in ("A", "L"): for y in range(self.plevs): mup = getMarkup(self.sql, self.opts["conum"], self.group, self.code, self.loc, y + 1) self.df.loadEntry("T", 2, 4 + y, data=mup) self.mups[y] = mup def doType(self, frt, pag, r, c, p, i, w): self.gtype = w if self.gtype == "R": self.df.enableTag(2) else: self.df.disableTag(2) def doUoi(self, frt, pag, r, c, p, i, w): acc = self.getUoi(w) if not acc: return "Invalid UOI Record" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doValInd(self, frt, pag, r, c, p, i, w): self.df.topf[1][5][5] = self.grpacc[0] def doVat(self, frt, pag, r, c, p, i, w): acc = self.getVat(w) if not acc: return "Invalid VAT Record" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if not self.drsctl: self.chain = 0 self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 1, data="") if self.glint == "N": return "sk9" else: return "sk4" def doChnExcl(self, frt, pag, r, c, p, i, w): if w: acc = self.getChnExcl(w) if not acc: return "Invalid Chainstore" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) self.chain = w def doAccExcl(self, frt, pag, r, c, p, i, w): if w: acc = self.getAccExcl(w) if not acc: return "Invalid Debtors Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if self.glint == "N": return "sk5" if self.newcode: self.df.loadEntry(frt, pag, p + 2, data=self.grpacc[1]) if self.grpacc[1]: acc = self.getGenDes(self.grpacc[1]) if not acc: return "Invalid Sales Code" self.df.loadEntry(frt, pag, p + 3, data=acc[0]) self.df.loadEntry(frt, pag, p + 4, data=self.grpacc[2]) if self.grpacc[2]: acc = self.getGenDes(self.grpacc[2]) if not acc: return "Invalid C.O.S. Code" self.df.loadEntry(frt, pag, p + 5, data=acc[0]) def doSales(self, frt, pag, r, c, p, i, w): acc = self.getGenDes(w) if not acc: return "Invalid Sales Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doCos(self, frt, pag, r, c, p, i, w): acc = self.getGenDes(w) if not acc: return "Invalid COS Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doReord(self, frt, pag, r, c, p, i, w): if w == "N": self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 2, data=0) return "sk2" def getUoi(self, dat): acc = self.sql.getRec("struoi", cols=["unm_desc"], where=[("unm_cono", "=", self.opts["conum"]), ("unm_unit", "=", dat)], limit=1) return acc def getVat(self, dat): acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", dat)], limit=1) return acc def getChnExcl(self, dat): self.chain = dat if dat: acc = self.sql.getRec("drschn", cols=["chm_name"], where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", dat)], limit=1) return acc def getAccExcl(self, dat): if dat: acc = self.sql.getRec("drsmst", cols=["drm_name"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", dat), ("drm_stat", "<>", "X")], limit=1) return acc def getGenDes(self, dat): if dat: acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", dat)], limit=1) return acc def doRecGrp(self, frt, pag, r, c, p, i, w): self.rgroup = 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.df.topf[0][1][8]["whera"] = [["C", "st1_group", 0, 3]] def doRecCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.rgroup), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] == "R": return "Invalid Type (Recipe)" self.df.loadEntry(frt, pag, p + 1, data=acc[1]) acc = self.sql.getRec("strmf2", cols=["st2_bin"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.rgroup), ("st2_code", "=", w), ("st2_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Code (2)" self.rcode = w acc = self.sql.getRec("strrcp", cols=["srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)], limit=1) if acc: self.newrec = "n" self.df.loadEntry(frt, pag, p + 2, data=acc[0]) else: self.newrec = "y" def doRecQty(self, frt, pag, r, c, p, i, w): self.rqty = w def doEditor(self): if self.df.pag != 3: self.df.focusField(self.df.frt, self.df.pag, self.df.col) return # Display recipe items and allow editing of details data = self.sql.getRec( tables=["strrcp", "strmf1"], cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ), ("st1_code=srr_rcode", )]) if data: titl = "Recipe Items" head = ("Grp", "Product-Code", "Description", "Quantity") lin = { "stype": "C", "titl": titl, "head": head, "typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 10.2)), "data": data } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Product to Edit") chg = self.df.selChoice(lin) if chg and chg.selection: self.change = chg.selection self.doChgChanges() self.df.enableButtonsTags(state=state) self.df.focusField("C", 3, self.df.col) def doChgChanges(self): tit = ("Change Items", ) gpm = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } stm = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"])], "whera": [], "index": 1 } fld = ((("T", 0, 0, 0), "INA", 3, "Group", "Product Group", "", "N", self.doChgGrp, gpm, None, ('notblank', )), (("T", 0, 1, 0), "INA", 20, "Code", "Product Code", "", "N", self.doChgCod, stm, None, ('notblank', )), (("T", 0, 2, 0), "ONA", 30, "Description"), (("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N", self.doChgQty, None, None, ('notzero', ))) but = [["Delete", None, self.doChgDel, 1, None, None]] self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doChgEnd, "n"), ), txit=(self.doChgExit, )) self.cg.loadEntry("T", 0, 0, data=self.change[0]) self.cg.loadEntry("T", 0, 1, data=self.change[1]) self.cg.loadEntry("T", 0, 2, data=self.change[2]) self.cg.loadEntry("T", 0, 3, data=self.change[3]) self.cg.focusField("T", 0, 1, clr=False) self.cg.mstFrame.wait_window() def doChgGrp(self, frt, pag, r, c, p, i, 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.rgroup = w self.cg.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]] def doChgCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.rgroup), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] != "N": return "Invalid Type" cnt = self.sql.getRec("strrcp", cols=["count(*)"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.rgroup), ("srr_code", "=", w)], limit=1) if cnt[0]: return "Product Already In Recipe" self.rcode = w self.cg.loadEntry("T", 0, 2, data=acc[1]) def doChgQty(self, frt, pag, r, c, p, i, w): self.rqty = w def doChgDel(self): self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.change[0]), ("srr_rcode", "=", self.change[1])]) self.doReadLoadRecipe() self.doChgExit() def doChgEnd(self): self.sql.updRec("strrcp", cols=["srr_rgroup", "srr_rcode", "srr_rqty"], data=[self.rgroup, self.rcode, self.rqty], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.loc), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.change[0]), ("srr_rcode", "=", self.change[1])]) self.doReadLoadRecipe() self.doChgExit() def doChgExit(self): self.cg.closeProcess() def doDelete(self): trn = self.sql.getRec("strpot", cols=["count(*)"], where=[("pot_cono", "=", self.opts["conum"]), ("pot_group", "=", self.group), ("pot_code", "=", self.code)], limit=1) if trn[0]: return "Purchase Orders Exist, Not Deleted" trn = self.sql.getRec("strtrn", cols=["count(*)"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_group", "=", self.group), ("stt_code", "=", self.code), ("stt_loc", "=", self.loc)], limit=1) if trn[0]: return "Stores Transactions Exist, Not Deleted" trn = self.sql.getRec("slsiv2", cols=["count(*)"], where=[("si2_cono", "=", self.opts["conum"]), ("si2_group", "=", self.group), ("si2_code", "=", self.code), ("si2_loc", "=", self.loc)], limit=1) if trn[0]: return "Sales-2 Transactions Exist, Not Deleted" trn = self.sql.getRec("slsiv3", cols=["count(*)"], where=[("si3_cono", "=", self.opts["conum"]), ("si3_rgroup", "=", self.group), ("si3_rcode", "=", self.code)], limit=1) if trn[0]: return "Sales-3 Transactions Exist, Not Deleted" self.sql.delRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["strmf2", "D", "%03i%-3s%-20s%-1s" % \ (self.opts["conum"], self.group, self.code, self.loc), "", dte, self.opts["capnm"], "", "", "", 0]) st2 = self.sql.getRec("strmf2", cols=["count(*)"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code)], limit=1) if not st2[0]: self.sql.delRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", self.code)]) self.sql.insRec("chglog", data=["strmf1", "D", "%03i%-3s%-20s" % \ (self.opts["conum"], self.group, self.code), "", dte, self.opts["capnm"], "", "", "", 0]) # Other Files self.sql.delRec("strcst", where=[("stc_cono", "=", self.opts["conum"]), ("stc_group", "=", self.group), ("stc_code", "=", self.code), ("stc_loc", "=", self.loc)]) self.sql.delRec("strprc", where=[("stp_cono", "=", self.opts["conum"]), ("stp_group", "=", self.group), ("stp_code", "=", self.code), ("stp_loc", "=", self.loc)]) self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc)]) self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.group), ("srr_rcode", "=", self.code)]) self.sql.delRec("strvar", where=[("stv_cono", "=", self.opts["conum"]), ("stv_group", "=", self.group), ("stv_code", "=", self.code), ("stv_loc", "=", self.loc)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doDelRec(self): self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)]) self.df.clearLine(2, focus=True) def doEnd(self): if self.df.frt == "T" and self.df.pag == 0: if self.newcode: self.df.focusField("T", 1, 1) else: if self.gtype == "R": self.df.enableTag(2) self.df.skip[1] = [1] self.df.focusField("T", 1, 2, clr=False) elif self.df.frt == "T" and self.df.pag == 1: self.df.selPage("Basic-B") elif self.df.frt == "T" and self.df.pag == 2: if self.gtype == "R": self.df.selPage("Recipes") else: self.doEnder() elif self.df.frt == "C" and self.df.pag == 3: data = [ self.opts["conum"], self.group, self.code, self.loc, self.rgroup, self.rcode, self.rqty ] if self.newrec == "y": self.sql.insRec("strrcp", data=data) self.df.advanceLine(3) else: whr = [("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)] self.sql.updRec("strrcp", data=data, where=whr) self.doReadLoadRecipe() def doEnder(self): data = [self.opts["conum"]] for x in range(0, 2): data.append(self.df.t_work[0][0][x]) for x in range(0, len(self.df.t_work[1][0])): if x in (3, 6, 8, 10, 12, 14): continue data.append(self.df.t_work[1][0][x]) if self.newcode: self.sql.insRec("strmf1", data=data) elif data != self.old1[:len(data)]: col = self.sql.strmf1_col data.append(self.old1[col.index("st1_xflag")]) self.sql.updRec("strmf1", data=data, where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", self.code)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old1): if dat != data[num]: self.sql.insRec( "chglog", data=[ "strmf1", "U", "%03i%-3s%-20s" % (self.opts["conum"], self.group, self.code), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) data = [self.opts["conum"], self.group, self.code, self.loc] for x in range(0, 4): data.append(self.df.t_work[2][0][x]) if self.newloc == "Y": self.sql.insRec("strmf2", data=data) elif data != self.old2[:len(data)]: col = self.sql.strmf2_col data.append(self.old2[col.index("st2_xflag")]) self.sql.updRec("strmf2", data=data, where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old2): if dat != data[num]: self.sql.insRec("chglog", data=[ "strmf2", "U", "%03i%-3s%-20s%-1s" % (self.opts["conum"], self.group, self.code, self.loc), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.sql.delRec("strcmu", where=[("smc_cono", "=", self.opts["conum"]), ("smc_group", "=", self.group), ("smc_code", "=", self.code), ("smc_loc", "=", self.loc)]) for num, mup in enumerate(self.df.t_work[2][0][4:]): if mup and mup != self.mups[num]: self.sql.insRec("strcmu", data=[ self.opts["conum"], self.group, self.code, self.loc, num + 1, mup ]) self.opts["mf"].dbm.commitDbase() self.df.selPage("Basic-A") self.df.focusField("T", 0, 1) def doReadLoadRecipe(self): self.df.clearFrame("C", 3) self.df.focusField("C", 3, 1) rec = self.sql.getRec( tables=["strrcp", "strmf1"], cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ), ("st1_code=srr_rcode", )]) if rec: mxs = (self.df.rows[3] - 1) * self.df.colq[3] for l, r in enumerate(rec): for i, d in enumerate(r): c = l * self.df.colq[3] if c > mxs: c = mxs self.df.loadEntry("C", 3, (c + i), data=d) self.df.advanceLine(3) def doExit(self): if self.df.frt == "T" and self.df.pag == 0: self.doQuit() elif self.df.frt == "T" and self.df.pag == 1: if self.newcode: self.df.focusField("T", 1, 1) else: self.df.skip[1] = [1] self.df.focusField("T", 1, 2, clr=False) elif self.df.frt == "T" and self.df.pag == 2: self.df.focusField("T", 2, 1) elif self.df.frt == "C" and self.df.pag == 3: if self.df.col == 1: self.df.focusField("C", 3, 1) else: self.doEnder() def doAccept(self): ok = "yes" for page in (1, 2): frt, pag, col, err = self.df.doCheckFields(("T", page, None)) if err: ok = "no" if pag and pag != self.df.pag: self.df.selPage(self.df.tags[pag - 1][0]) self.df.focusField(frt, pag, (col + 1), err=err) break if ok == "yes": self.doEnder() def doQuit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop() def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.selPage("Basic-A") self.df.focusField("T", 0, 1)
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 cr6020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): if "args" in opts: self.curdt = opts["args"][0] for self.acno in opts["args"][1]: self.doReAgeAuto() self.opts["mf"].dbm.commitDbase() else: self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["crsmst", "crstrn", "crsage"], 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 t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.curdt = int(self.sysdtw / 100) if "args" not in self.opts: self.agevar = tk.BooleanVar() self.agevar.set(False) return True def dataHeader(self): crm = { "stype": "R", "tables": ("crsmst",), "cols": ( ("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")), "where": [ ("crm_cono", "=", self.opts["conum"]), ("crm_stat", "<>", "X")]} fld = [ [["T",0,0,0],"ID2",7,"Period","Current Financial Period", self.curdt,"N",self.doCurdt,None,None,("efld",)], [["T",0,1,0],"INA",7,"Acc-Num","Account Number", "","N",self.doAccno,crm,None,("notblank",)], [["T",0,1,0],"ONA",30,"Name"]] tnd = ((self.endTop, "n"),) txt = (self.exitTop,) self.but = ( ("Normal", None, self.doReAgeNormal, 0, None, None, "Only Show Unallocated Transactions"), ("History", None, self.doReAgeHistory, 0, None, None, "Show All Transactions, Including Already Allocated"), ("Automatic", None, self.doReAgeAuto, 0, None, None, "Automatically Re-Age the Account Based on Date")) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, butt=self.but) def doCurdt(self, frt, pag, r, c, p, i, w): self.curdt = w def doAccno(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("crsmst", cols=["crm_name", "crm_stat"], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[1] == "X": return "Invalid Account, Redundant" self.acno = w self.key = None self.df.loadEntry("T", pag, p+1, data=acc[0]) self.opts["mf"].updateStatus("Select Routine") for b in range(3): wid = getattr(self.df, "B%s" % b) self.df.setWidget(wid, "normal") self.df.setWidget(self.df.B0, "focus") self.agevar.set(True) self.df.mstFrame.wait_variable(self.agevar) if self.key in ("normal", "history"): return "nd" elif self.key == "cancel": return "nc" def doReAgeNormal(self): self.key = "normal" self.doReAge() def doReAgeHistory(self): self.key = "history" self.doReAge() def doReAge(self): self.opts["mf"].updateStatus("") for b in range(3): wid = getattr(self.df, "B%s" % b) self.df.setWidget(wid, "disabled") col = ["crt_trdt","crt_ref1","crt_type","crt_tramt","paid","balance"] whr = [ ("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=", self.acno)] if self.key == "normal": dtc, recs = getTrn(self.opts["mf"].dbm, "crs", whr=whr, zer="N") else: dtc, recs = getTrn(self.opts["mf"].dbm, "crs", whr=whr) if recs: data = [] for rec in recs: dat = [] for c in col: dat.append(rec[dtc.index(c)]) data.append(dat) age = AgeTrans(self.opts["mf"], "crs", data, 0, xits=False) if not age.ccl and age.data: if age.total.work: while not age.ccl: age.doAllocate() if age.ccl or not age.total.work: break if age.ccl: self.key = "cancel" age.data = [] for tr in age.data: if tr[6]: w = copyList(whr) w.extend([("crt_type", "=", tr[2]), ("crt_ref1", "=", tr[1])]) self.sql.insRec("crsage", data=[self.opts["conum"], self.acno, tr[2], tr[1], self.curdt, tr[2], tr[1], tr[6], 0]) else: self.key = "cancel" self.agevar.set(False) def doReAgeAuto(self): self.key = "normal" if "args" not in self.opts: for b in range(3): wid = getattr(self.df, "B%s" % b) self.df.setWidget(wid, "disabled") self.opts["mf"].updateStatus("Re-Ageing .... Please Wait!") self.df.setWidget(self.df.mstFrame, state="hide") txt = "Re-Allocating ... Please Wait" pb = ProgressBar(self.opts["mf"].body, typ=("G", txt)) doAutoAge(self.opts["mf"].dbm, "crs", self.opts["conum"], acno=self.acno, pbar=pb) pb.closeProgress() self.df.setWidget(self.df.mstFrame, state="show") self.agevar.set(False) else: doAutoAge(self.opts["mf"].dbm, "crs", self.opts["conum"], acno=self.acno, pbar=None) def endTop(self): self.df.clearEntry("T", 0, 2) self.df.clearEntry("T", 0, 3) self.df.focusField("T", 0, 2) def exitTop(self): self.opts["mf"].dbm.commitDbase(ask=True) self.df.closeProcess() 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 sl2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql( self.opts["mf"].dbm, ["genmst", "gentrn", "wagedc", "wagmst", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) wagctl = self.gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.glint = wagctl["ctw_glint"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"], ctlctl, ["wag_slc"]): return self.slnctl = ctlctl["wag_slc"] self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "SLN", 2, glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def dataHeader(self): wgm = { "stype": "R", "tables": ("wagmst", ), "cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0, "Surname", "Y")), "where": [("wgm_cono", "=", self.opts["conum"])] } ced = { "stype": "R", "tables": ("wagedc", ), "cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"), ("ced_desc", "", 0, "Description", "Y")), "where": [("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "D")], "index": 1 } fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 0, 0, 0), "IUI", 5, "EmpNo", "Employee Number", "", "N", self.doEmpno, wgm, None, None), (("C", 0, 0, 1), "ONA", 20, "Name"), (("C", 0, 0, 2), "OUI", 2, "Ln"), (("C", 0, 0, 3), "INA", 15, "Description", "", "", "N", self.doDesc, None, None, None), (("C", 0, 0, 4), "ID1", 10, "Date", "", "", "N", self.doSdate, None, None, None), (("C", 0, 0, 5), "INa", 9, "Ref-No", "Reference Number", "", "N", self.doRef, None, None, ("notblank", )), (("C", 0, 0, 6), "IUI", 3, "Cde", "Deduction Code", "", "N", self.doCode, ced, None, ("notzero", )), (("C", 0, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate", "", "N", self.doInt, None, None, None), (("C", 0, 0, 8), "IUD", 12.2, "Loan-Amt", "Loan Amount", "", "N", self.doAmt, None, None, ("notzero", )), (("C", 0, 0, 9), "IUD", 12.2, "Ded-Amt", "Deduction Amount", "", "N", self.doDed, None, None, ("efld", ))) but = (("Interrogate", None, self.querySln, 0, ("C", 0, 1), ("C", 0, 2)), ) cnd = ((self.endPage, "y"), ) cxt = (self.exitPage, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, cend=cnd, cxit=cxt) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 0, 1) def doEmpno(self, frt, pag, r, c, p, i, w): self.empno = w acc = self.sql.getRec("wagmst", cols=["wgm_sname", "wgm_fname"], where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", self.empno)], limit=1) if not acc: return "Invalid Employee Number" self.name = "%s, %s" % (acc[0], acc[1].split()[0]) self.df.loadEntry("C", pag, p + 1, data=self.name) self.loan = getNextCode(self.sql, "waglmf", "wlm_loan", where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno)], start=1, last=9999999) self.df.loadEntry("C", pag, p + 2, data=self.loan) def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doSdate(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.sdate = w def doRef(self, frt, pag, r, c, p, i, w): self.ref = w def doCode(self, frt, pag, r, c, p, i, w): self.code = w desc = self.sql.getRec("wagedc", cols=["ced_desc"], where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "D"), ("ced_code", "=", w)], limit=1) if not desc: return "Invalid Code" def doInt(self, frt, pag, r, c, p, i, w): self.rte = w def doAmt(self, frt, pag, r, c, p, i, w): self.amt = w def doDed(self, frt, pag, r, c, p, i, w): self.ded = w def endPage(self): self.updateTables() self.updateBatch() self.opts["mf"].dbm.commitDbase() self.df.advanceLine(0) def exitPage(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def updateTables(self): if self.bh.multi == "Y": curdt = int(self.sdate / 100) else: curdt = self.bh.curdt self.sql.insRec("waglmf", data=[ self.opts["conum"], self.empno, self.loan, self.desc, self.code, self.rte, self.sdate, self.ded ]) self.sql.insRec("wagltf", data=[ self.opts["conum"], self.empno, self.loan, self.bh.batno, 2, self.sdate, self.ref, self.amt, self.amt, self.ded, self.rte, curdt, self.desc, "N", self.opts["capnm"], self.sysdtw, 0 ]) if self.glint == "N": return # General Ledger Staff Loans Control Account data = (self.opts["conum"], self.slnctl, curdt, self.sdate, 2, self.ref, self.bh.batno, self.amt, 0.00, self.name, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) amt = float(ASD(0) - ASD(self.amt)) # General Ledger Bank Account data = (self.opts["conum"], self.bh.acc, curdt, self.sdate, 2, self.ref, self.bh.batno, amt, 0.00, "Staff Loan - %s" % self.name, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def updateBatch(self): self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.amt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def querySln(self): callModule(self.opts["mf"], self.df, "sl4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
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 bc1010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() if "args" in self.opts: self.tabcvt = False self.gentab = False self.newtab = True self.tab = self.opts["args"] self.df.loadEntry("T", 0, 0, data=self.tab) self.df.topf[0][0][1] = "OUI" self.df.topf[0][1][1] = "OUI" self.df.focusField("T", 0, 2) 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, [ "chglog", "bwlent", "bwlgme", "bwltab", "bwldrt", "bwlflm", "bwlflt", "memmst", "memkon", "memadd", "memcat" ], prog=self.__class__.__name__) if self.sql.error: if self.sql.error == ["memmst", "memkon"]: self.memmst = False else: return else: self.memmst = True gc = GetCtl(self.opts["mf"]) bwlctl = gc.getCtl("bwlctl", self.opts["conum"]) if not bwlctl: return self.mlint = bwlctl["ctb_mlint"] self.samen = bwlctl["ctb_samen"] self.mscat = bwlctl["ctb_mscat"] self.mstart = bwlctl["ctb_mstart"] self.fstart = bwlctl["ctb_fstart"] self.nstart = bwlctl["ctb_nstart"] self.dbase = bwlctl["ctb_dbase"] self.order = bwlctl["ctb_order"] self.mixed = bwlctl["ctb_mixed"] self.fromad = bwlctl["ctb_emadd"] self.keys = (("bwltab", "btb_cono", "btb_tab"), ("bwldrt", "bdt_cono", "bdt_tab"), ("bwlent", "bce_cono", "bce_scod"), ("bwlflt", "bft_cono", "bft_player"), ("bwlgme", "bcg_cono", "bcg_scod"), ("bwldrt", "bdt_cono", "bdt_team1"), ("bwldrt", "bdt_cono", "bdt_team2"), ("bwldrt", "bdt_cono", "bdt_team3"), ("bwlflt", "bft_cono", "bft_skip"), ("bwlgme", "bcg_cono", "bcg_ocod")) return True def mainProcess(self): tab = { "stype": "R", "tables": ("bwltab", ), "cols": [("btb_tab", "", 0, "Tab"), ("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "", 0, "Names"), ("btb_bsano", "", 0, "BSA-No")], "where": [("btb_cono", "=", self.opts["conum"])], "order": "btb_surname" } if self.mlint == "N": mlm = None else: tab["cols"].insert(3, ("btb_memno", "", 0, "Mem-No")) mlm = { "stype": "R", "tables": ("memmst", ), "cols": (("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"), ("mlm_idnum", "", 0, "Identity-Numb"), ("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"), ("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0, "Names", "F")), "where": [("mlm_cono", "=", self.opts["conum"])], "order": "mlm_surname, mlm_names" } r1s = (("Male", "M"), ("Female", "F")) if self.dbase == "R": r2s = (("None", "0"), ) else: r2s = (("Skip", "4"), ("Third", "3"), ("Second", "2"), ("Lead", "1")) fld = [(("T", 0, 0, 0), "I@btb_tab", 0, "", "", "", "Y", self.doTab, tab, None, ("efld", ), None, "Note: Tab numbers Must be Unique."), [("T", 0, 1, 0), "I@btb_memno", 0, "", "", "", "N", self.doMember, mlm, self.doDelete, ("efld", )], (("T", 0, 2, 0), "I@btb_surname", 0, "", "", "", "N", self.doSurname, None, self.doDelete, ("notblank", )), (("T", 0, 3, 0), "I@btb_names", 0, "", "", "", "N", self.doNames, None, None, ("efld", )), (("T", 0, 4, 0), ("IRB", r1s), 0, "Gender", "", "M", "N", self.doGender, None, None, None), (("T", 0, 5, 0), "I@btb_add1", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 6, 0), "I@btb_add2", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 7, 0), "I@btb_add3", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 8, 0), "I@btb_pcod", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 9, 0), "I@btb_home", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 10, 0), "I@btb_work", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 11, 0), "I@btb_cell", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 12, 0), "I@btb_mail", 0, "", "", "", "N", self.doEmail, None, None, ("efld", )), (("T", 0, 13, 0), ("IRB", r2s), 0, "Position - Primary", "", "1", "N", self.doPos, None, self.doDelete, None), (("T", 0, 14, 0), "I@btb_rate1", 0, "", "", "", "N", self.doRate, None, None, ("efld", )), (("T", 0, 15, 0), ("IRB", r2s), 0, "Position - Mixed", "", "1", "N", self.doPos, None, None, None), (("T", 0, 16, 0), "I@btb_rate2", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 17, 0), "I@btb_bsano", 0, "", "", "", "N", None, None, None, ("efld", ))] if self.mlint == "N": fld[1] = [("T", 0, 1, 0), "O@btb_memno", 0, ""] if self.mlint == "Y": but = [] else: but = [("Import", None, self.doImport, 0, ("T", 0, 1), (("T", 0, 2), ("T", 0, 3)), "Import Tabs and/or Ratings from a CSV or XLS File.")] but.extend([("Accept", None, self.doEnd, 0, ("T", 0, 3), ("T", 0, 0), "Accept All Fields and Continue"), ("Convert", None, self.doConvert, 0, ("T", 0, 3), ("T", 0, 4), "Convert a Visitor's Tab to a Member's Tab"), ("Print", None, self.doPrint, 1, None, None)]) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, butt=but, tend=tnd, txit=txt, clicks=self.doClick) def doClick(self, *opts): if self.df.col == 1: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doTab(self, frt, pag, r, c, p, i, w): self.tab = w self.newvis = False self.tabcvt = False self.tabchg = False if not self.tab: if self.mlint == "Y" and self.samen == "Y": ok = askQuestion(self.opts["mf"].body, "New Tab", "Is this TAB for a Visitor", default="no") if ok == "no": return "New Member, Please Create in Ledger" self.newvis = True self.gentab = True self.newtab = True else: self.gentab = False self.oldtab = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", self.tab)], limit=1) if not self.oldtab: self.newtab = True else: self.newtab = False for num, fld in enumerate(self.oldtab[1:-1]): if num == 2: self.snam = fld elif num == 3: self.fnam = fld elif num == 4: self.gender = fld elif num in (13, 15): fld = str(fld) if num == 13: self.pos1 = fld self.df.loadEntry(frt, pag, num, data=fld) if self.tab and self.mlint == "Y": if self.oldtab: memno = self.oldtab[self.sql.bwltab_col.index("btb_memno")] elif self.tab < self.nstart and self.samen == "Y": memno = self.tab else: memno = 0 else: memno = 0 if memno: chk = self.doLoadMember(memno) if chk: return chk if self.dbase == "R": return "sk13" return "sk12" if self.newvis or self.tab >= self.nstart: return "sk1" def doMember(self, frt, pag, r, c, p, i, w): if w: if self.newtab or not self.oldtab[2]: chk = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_memno", "=", w)], limit=1) if chk: return "Member Already Has a TAB" chk = self.doLoadMember(w) if chk: return chk if self.newtab and not self.tab: chk = self.getNextTab() if not chk: return "Invalid Membership Number" if self.dbase == "R": return "sk12" return "sk11" elif self.tab and self.tab < self.nstart and self.mlint == "Y": return "Invalid Membership Number" def doLoadMember(self, memno): # Check member acc = self.sql.getRec("memmst", cols=["mlm_surname", "mlm_names", "mlm_gender"], where=[("mlm_cono", "=", self.opts["conum"]), ("mlm_memno", "=", memno)], limit=1) if not acc: return "Member %s Does Not Exist" % memno # Check category if self.mscat: cat = self.sql.getRec("memcat", where=[("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", memno), ("mlc_type", "=", "C"), ("mlc_code", "=", self.mscat)], limit=1) if not cat: return "Member %s is Not in the Bowls Category" % memno self.snam = acc[0] self.fnam = acc[1] self.gender = acc[2] self.df.loadEntry("T", 0, 1, data=memno) self.df.loadEntry("T", 0, 2, data=self.snam) self.df.loadEntry("T", 0, 3, data=self.fnam) self.df.loadEntry("T", 0, 4, data=self.gender) for typ in ("A", "P"): ad = self.sql.getRec( "memadd", cols=["mla_add1", "mla_add2", "mla_add3", "mla_code"], where=[("mla_cono", "=", self.opts["conum"]), ("mla_memno", "=", memno), ("mla_type", "=", typ)], limit=1) if ad: break if ad: self.df.loadEntry("T", 0, 5, data=ad[0]) self.df.loadEntry("T", 0, 6, data=ad[1]) self.df.loadEntry("T", 0, 7, data=ad[2]) self.df.loadEntry("T", 0, 8, data=ad[3]) for num, cod in enumerate((1, 2, 3, 5)): kk = self.sql.getRec("memkon", cols=["mlk_detail"], where=[("mlk_cono", "=", self.opts["conum"]), ("mlk_memno", "=", memno), ("mlk_code", "=", cod)], limit=1) if kk: self.df.loadEntry("T", 0, num + 9, data=kk[0]) def doSurname(self, frt, pag, r, c, p, i, w): self.sname = w def doNames(self, frt, pag, r, c, p, i, w): if self.newtab: chk = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_surname", "=", self.sname, "and", "btb_names", "=", w)], limit=1) if chk: tab = chk[self.sql.bwltab_col.index("btb_tab")] self.doTab(frt, pag, 0, 1, 0, 0, tab) return "ff3" if self.mstart < self.fstart and self.tab >= self.fstart: self.df.loadEntry(frt, pag, p + 1, data="F") elif self.fstart < self.mstart and self.tab < self.mstart: self.df.loadEntry(frt, pag, p + 1, data="F") return if self.sname != self.snam or w != self.fnam: but = [("Amendment", "A"), ("Re-Issue", "R"), ("Neither", "N")] ok = askChoice(self.opts["mf"].body, "Name Change", "Please Select the Reason for the Name Change", butt=but, default="Neither") if ok == "N": return "ff3" if ok == "R": self.tabchg = True for x in range(1, 15): self.df.clearEntry(frt, pag, c + x) def doGender(self, frt, pag, r, c, p, i, w): self.gender = w if self.gentab: chk = self.getNextTab() if not chk: return "ff2|Invalid Membership Number" if self.tab < self.nstart: if self.mstart < self.fstart: if self.gender == "M" and self.tab >= self.fstart: return "ff5|Invalid Gender for Tab Number" elif self.gender == "F" and self.tab < self.fstart: return "ff5|Invalid Gender for Tab Number" else: if self.gender == "F" and self.tab >= self.mstart: return "ff5|Invalid Gender for Tab Number" elif self.gender == "M" and self.tab < self.mstart: return "ff5|Invalid Gender for Tab Number" def doEmail(self, frt, pag, r, c, p, i, w): if self.dbase in ("C", "P") and self.df.t_work[0][0][13] == "0": self.df.t_work[0][0][13] = "1" if self.dbase == "R": self.pos1 = "0" self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 1, data="") return "sk1" def doPos(self, frt, pag, r, c, p, i, w): if p == 13: self.pos1 = w self.df.loadEntry(frt, pag, p + 2, data=w) if self.dbase == "P": self.df.loadEntry(frt, pag, p + 1, data="") if p == 13: self.df.loadEntry(frt, pag, p + 3, data="") if self.mixed == "N": return "sk3" else: return "sk1" def doRate(self, frt, pag, r, c, p, i, w): self.df.loadEntry(frt, pag, p + 1, data=self.pos1) self.df.loadEntry(frt, pag, p + 2, data=w) if self.dbase == "R": self.df.loadEntry(frt, pag, p + 1, data="") if self.mixed == "N": return "sk2" else: return "sk1" if self.mixed == "N": return "sk2" def getNextTab(self): if self.newvis: ok = "yes" else: ok = askQuestion(self.opts["mf"].body, "Type", "Is this TAB for a Visitor", default="no") if ok == "no": if self.samen == "Y": return if self.gender == "M": start = self.mstart if self.mstart < self.fstart: last = self.fstart else: last = self.nstart else: start = self.fstart if self.mstart < self.fstart: last = self.nstart else: last = self.mstart else: start = self.nstart last = 900000 self.tab = getNextCode(self.sql, "bwltab", "btb_tab", where=[("btb_cono", "=", self.opts["conum"])], start=start, last=last) self.df.loadEntry("T", 0, 0, data=self.tab) return True def doDelete(self): if self.newtab: return error = False for key in self.keys: if key[0] == "bwltab": continue chk = self.sql.getRec(tables=key[0], where=[(key[1], "=", self.opts["conum"]), (key[2], "=", self.tab)], limit=1) if chk: error = True break if error: if self.tab < self.nstart: # Member ok = askQuestion(self.opts["mf"].body, "Convert", "Convert this Member to a Visitor", default="yes") if ok == "no": return "Not Deleted nor Converted" tab = getNextCode(self.sql, "bwltab", "btb_tab", where=[("btb_cono", "=", self.opts["conum"]) ], start=self.nstart, last=900000) for key in self.keys: self.sql.updRec(key[0], cols=[key[2]], data=[tab], where=[(key[1], "=", self.opts["conum"]), (key[2], "=", self.tab)]) else: # Visitor chk = self.sql.getRec("bwlent", where=[("bce_cono", "=", self.opts["conum"]), ("bce_scod", "=", self.tab)]) if chk: return "There is History for this Player, Not Deleted" self.sql.delRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", self.tab)]) else: self.sql.delRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", self.tab)]) self.opts["mf"].dbm.commitDbase() def doConvert(self): titl = "Enter Member's Tab Number" ent = SimpleDialog(parent=self.df.window, title=titl, cols=(("a", "Tab Number ", 6, "UI", "Tab"), )) ent.sframe.wait_window() try: self.merge = False if self.gender == "M": start = self.mstart if self.mstart < self.fstart: last = self.fstart - 1 else: last = self.nstart - 1 else: start = self.fstart if self.mstart < self.fstart: last = self.nstart - 1 else: last = self.mstart - 1 tab = ent.data[0] if not tab: tab = getNextCode(self.sql, "bwltab", "btb_tab", where=[("btb_cono", "=", self.opts["conum"]) ], start=start, last=last) if tab < start or tab > last: showInfo(self.opts["mf"].body, "Error", "Invalid Tab Number for Gender") raise Exception chk = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", tab)], limit=1) if chk: ok = askQuestion( self.opts["mf"].body, "Invalid", "This Tab is Already Allocated, Do You Want to Merge?") if ok == "no": raise Exception self.merge = True self.tabcvt = True self.old = self.tab self.tab = tab self.df.loadEntry(self.df.frt, self.df.pag, 0, data=self.tab) self.df.focusField(self.df.frt, self.df.pag, 6) except: self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doPrint(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") if self.mlint == "Y": self.colsd = [["Membership Number", "N", "btb_memno"]] else: self.colsd = [] self.colsd.extend([["Surname & Initials", "Y", "name"], ["Surname", "N", "btb_surname"], ["First Names", "N", "btb_names"], ["Gender", "N", "btb_gender"], ["Address", "N", "address"], ["Telephone - Home", "N", "btb_home"], ["Telephone - Work", "N", "btb_work"], ["Telephone - Cell", "N", "btb_cell"], ["Email Address", "N", "btb_mail"], ["Ratings", "N", "ratings"], ["BSA Number", "N", "btb_bsano"], ["Order", "T", "order"]]) r1s = (("Members", "M"), ("Guests", "G"), ("All", "A")) r2s = (("Males", "M"), ("Females", "F"), ("All", "A")) r3s = (("Yes", "Y"), ("No", "N")) r4s = (("Tab", "T"), ("Surname", "S"), ("Rating", "R")) fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Tab Group", "", "M", "Y", self.doCGroup, None, None, None), (("T", 0, 1, 0), ("IRB", r2s), 0, "Gender", "", "A", "Y", self.doCGender, None, None, None)] idx = 1 for dat in self.colsd: idx += 1 if dat == self.colsd[-1]: rb = r4s else: rb = r3s fld.append((("T", 0, idx, 0), ("IRB", rb), 0, dat[0], "", dat[1], "N", self.doCField, None, None, None)) tnd = ((self.doCEnd, "Y"), ) txt = (self.doCExit, ) self.pr = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, view=("Y", "V"), mail=("Y", "Y")) self.pr.mstFrame.wait_window() if self.cols: cols = [] dic = self.sql.bwltab_dic for col in self.cols: if col == "name": cols.append(["name", "NA", 30, "Name"]) elif col == "address": cols.append([ "btb_add1", dic["btb_add1"][2], dic["btb_add1"][3], dic["btb_add1"][5] ]) cols.append([ "btb_add2", dic["btb_add2"][2], dic["btb_add2"][3], dic["btb_add2"][5] ]) cols.append([ "btb_add3", dic["btb_add3"][2], dic["btb_add3"][3], dic["btb_add3"][5] ]) cols.append([ "btb_pcod", dic["btb_pcod"][2], dic["btb_pcod"][3], dic["btb_pcod"][5] ]) elif col == "ratings": if self.dbase == "P": cols.append([ "btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3], dic["btb_pos1"][5] ]) cols.append([ "btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3], dic["btb_pos2"][5] ]) elif self.dbase == "R": cols.append([ "btb_rate1", dic["btb_rate1"][2], dic["btb_rate1"][3], dic["btb_rate1"][5] ]) cols.append([ "btb_rate2", dic["btb_rate2"][2], dic["btb_rate2"][3], dic["btb_rate2"][5] ]) else: cols.append([ "btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3], dic["btb_pos1"][5] ]) cols.append([ "btb_rate1", dic["btb_rate1"][2], dic["btb_rate1"][3], dic["btb_rate1"][5] ]) cols.append([ "btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3], dic["btb_pos2"][5] ]) cols.append([ "btb_rate2", dic["btb_rate2"][2], dic["btb_rate2"][3], dic["btb_rate2"][5] ]) else: cols.append([col, dic[col][2], dic[col][3], dic[col][5]]) whr = [("btb_cono", "=", self.opts["conum"])] if self.cgroup == "M": whr.append(("btb_tab", "<", self.nstart)) elif self.cgroup == "G": whr.append(("btb_tab", ">=", self.nstart)) if self.cgender in ("F", "M"): whr.append(("btb_gender", "=", self.cgender)) if self.odr == "T": odr = "btb_tab" elif self.odr == "S": odr = "btb_surname, btb_names" else: odr = "btb_pos1 desc, btb_rate1 desc, btb_surname, btb_names" recs = self.sql.getRec("bwltab", where=whr, order=odr) data = [] btc = self.sql.bwltab_col for rec in recs: dat = [] for col in self.cols: if col == "name": snam = rec[btc.index("btb_surname")] fnam = rec[btc.index("btb_names")] if fnam: fnam = fnam.split() for num, nam in enumerate(fnam): if not num: init = nam[0].upper() else: init = "%s %s" % (init, nam[0].upper()) dat.append("%s, %s" % (snam, init)) else: dat.append(snam) elif col == "address": dat.append(rec[btc.index("btb_add1")]) dat.append(rec[btc.index("btb_add2")]) dat.append(rec[btc.index("btb_add3")]) dat.append(rec[btc.index("btb_pcod")]) elif col == "ratings": if self.dbase == "P": dat.append(rec[btc.index("btb_pos1")]) dat.append(rec[btc.index("btb_pos2")]) elif self.dbase == "R": dat.append(rec[btc.index("btb_rate1")]) dat.append(rec[btc.index("btb_rate2")]) else: dat.append(rec[btc.index("btb_pos1")]) dat.append(rec[btc.index("btb_rate1")]) dat.append(rec[btc.index("btb_pos2")]) dat.append(rec[btc.index("btb_rate2")]) else: dat.append(rec[btc.index(col)]) data.append(dat) tit = "Tabs Lising for" if self.cgroup == "A": tit = "%s Members and Guests" % tit elif self.cgroup == "M": tit = "%s Members Only" % tit else: tit = "%s Guests Only" % tit if self.cgender == "A": tit = "%s (All Genders)" % tit elif self.cgender == "M": tit = "%s (Males Only)" % tit else: tit = "%s (Females Only)" % tit RepPrt(self.opts["mf"], name=self.__class__.__name__, conum=self.opts["conum"], conam=self.opts["conam"], heads=[tit], ttype="D", tables=data, cols=cols, repprt=self.pr.repprt, repeml=self.pr.repeml, fromad=self.fromad) self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) self.df.window.focus_force() self.df.focusField("T", 0, 1) def doCGroup(self, frt, pag, r, c, p, i, w): self.cgroup = w def doCGender(self, frt, pag, r, c, p, i, w): self.cgender = w def doCField(self, frt, pag, r, c, p, i, w): if self.mlint == "N": idx = 2 else: idx = 3 if p == idx and w == "Y": self.pr.loadEntry(frt, pag, p + 1, data="N") self.pr.loadEntry(frt, pag, p + 2, data="N") return "sk2" def doCEnd(self): self.pr.closeProcess() self.cols = ["btb_tab"] if self.pr.repeml[0] == "N": end = -2 else: end = -4 for num, dat in enumerate(self.pr.t_work[0][0][2:end]): if dat == "Y": self.cols.append(self.colsd[num][2]) elif dat in ("T", "S", "R"): self.odr = dat def doCExit(self): self.cols = [] self.pr.closeProcess() def doEnd(self): if self.tabcvt: # Conversion to Member for key in self.keys: if key[0] == "bwltab" and self.merge: self.sql.delRec(key[0], where=[(key[1], "=", self.opts["conum"]), (key[2], "=", self.old)]) continue self.sql.updRec(key[0], cols=[key[2]], data=[self.tab], where=[(key[1], "=", self.opts["conum"]), (key[2], "=", self.old)]) # Continue cols = [] for x in range(18): cols.append(x) if self.dbase == "R": cols.remove(13) cols.remove(15) flds = ("T", 0, cols) frt, pag, col, mes = self.df.doCheckFields(flds) if mes: self.df.focusField(frt, pag, (col + 1), err=mes) return tabdat = [self.opts["conum"]] + self.df.t_work[0][0] if self.newtab: self.sql.insRec("bwltab", data=tabdat) elif self.tabchg: tabdat.append("") self.doTabChg(tabdat) elif tabdat != self.oldtab[:len(tabdat)]: col = self.sql.bwltab_col tabdat.append(self.oldtab[col.index("btb_xflag")]) self.sql.updRec("bwltab", data=tabdat, where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", self.tab)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.oldtab): if dat != tabdat[num]: self.sql.insRec( "chglog", data=[ "bwltab", "U", "%03i%06s" % (self.opts["conum"], self.tab), col[num], dte, self.opts["capnm"], str(dat), str(tabdat[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() if "args" in self.opts: self.doExit() else: self.df.focusField("T", 0, 1) def doTabChg(self, tabdat): code = getNextCode(self.sql, "bwltab", "btb_tab", where=[("btb_cono", "=", self.opts["conum"])], start=self.nstart, last=900000) tables = (("bwldrt", "bdt_cono", "bdt_tab", "bdt_team1", "bdt_team2", "bdt_team3"), ("bwlent", "bce_cono", "bce_scod"), ("bwlflm", "bfm_cono", "bfm_captain"), ("bwlflt", "bft_cono", "bft_skip", "bft_player"), ("bwlgme", "bcg_cono", "bcg_scod", "bcg_ocod"), ("bwltab", "btb_cono", "btb_tab")) for tab in tables: for col in tab[2:]: self.sql.updRec(tab[0], cols=[col], data=[code], where=[(tab[1], "=", self.opts["conum"]), (col, "=", self.tab)]) self.sql.insRec("bwltab", data=tabdat) def doImport(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") tit = ("Import Details", ) r1s = (("Ratings Only", "R"), ("All Fields", "A")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Details", "", "R", "N", self.doImpDet, None, None, None), ) self.ip = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doImpEnd, "y"), ), txit=(self.doImpExit, )) self.ip.mstFrame.wait_window() # Populate if self.impdet is None: self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) return fi = FileImport(self.opts["mf"], imptab="bwltab", impskp=self.impskp) sp = ProgressBar(self.opts["mf"].body, typ="Importing Ratings", mxs=len(fi.impdat)) err = None for num, line in enumerate(fi.impdat): sp.displayProgress(num) if self.mixed == "N": line.extend([0, ""]) chk = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", line[0])], limit=1) if not chk: if self.impdet == "R": err = "%s %s Does Not Exist" % (fi.impcol[0][0], line[0]) break line.insert(0, self.opts["conum"]) if self.mlint == "N": line.insert(2, 0) self.sql.insRec("bwltab", data=line) else: tmp = ["btb_pos1", "btb_rate1", "btb_pos2", "btb_rate2"] if self.impdet == "R": cols = tmp else: cols = [ "btb_surname", "btb_names", "btb_gender", "btb_add1", "btb_add2", "btb_add3", "btb_pcod", "btb_home", "btb_work", "btb_cell", "btb_mail" ] + tmp + ["btb_bsano"] self.sql.updRec("bwltab", cols=cols, data=line[1:], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", line[0])]) sp.closeProgress() if err: err = "Line %s: %s" % ((num + 1), err) showError( self.opts["mf"].body, "Import Error", """%s Please Correct your Import File and then Try Again.""" % err) self.opts["mf"].dbm.rollbackDbase() else: self.opts["mf"].dbm.commitDbase() self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doImpDet(self, frt, pag, r, c, p, i, w): self.impdet = w def doImpEnd(self): self.impskp = ["btb_cono"] if self.mlint == "N": self.impskp.append("btb_memno") if self.impdet == "R": self.impskp.extend([ "btb_surname", "btb_names", "btb_gender", "btb_add1", "btb_add2", "btb_add3", "btb_pcod", "btb_home", "btb_work", "btb_cell", "btb_mail", "btb_bsano" ]) if self.mixed == "N": self.impskp.extend(["btb_pos2", "btb_rate2"]) self.impskp.append("btb_xflag") self.ip.closeProcess() def doImpExit(self): self.impdet = None self.ip.closeProcess() def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class rt6010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.tables = ( ("ctlnot", "not_key"), ("ctlvtf", "vtt_cono", "vtt_acno", "vtt_styp"), ("rtlmst", "rtm_cono", "rtm_code", "rtm_acno"), ("rtlcon", "rtc_cono", "rtc_code", "rtc_acno"), ("rtltrn", "rtt_cono", "rtt_code", "rtt_acno")) tabs = ["rtlprm"] for tab in self.tables: tabs.append(tab[0]) self.sql = Sql(self.opts["mf"].dbm, tabs, 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 return True def mainProcess(self): prm = { "stype": "R", "tables": ("rtlprm",), "cols": ( ("rtp_code", "", 0, "Cod"), ("rtp_desc", "", 0, "Description", "Y")), "where": [("rtp_cono", "=", self.opts["conum"])]} rtm = { "stype": "R", "tables": ("rtlmst",), "cols": [ ("rtm_code", "", 0, "Cod"), ("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")], "where": [("rtm_cono", "=", self.opts["conum"])], "whera": [["T", "rtm_code", 0]], "index": 1} fld = [ (("T",0,0,0),"IRW",7,"Old Code","Old Premises Code", "","Y",self.doOldCod,prm,None,("notblank",)), (("T",0,0,0),"O@rtp_desc",0,""), (("T",0,1,0),"IRW",7,"Old Account","Old Account Number", "","Y",self.doOldAcc,rtm,None,("notblank",)), (("T",0,1,0),"O@rtm_name",0,""), (("T",0,2,0),"I@rtp_code",0,"New Code","New Premises Code", "","Y",self.doNewCod,prm,None,("notblank",)), (("T",0,2,0),"O@rtp_desc",0,""), (("T",0,3,0),"I@rtm_acno",0,"New Account","New Account Number", "","Y",self.doNewAcc,None,None,("notblank",))] tnd = ((self.doProcess,"y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt) def doOldCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlprm", cols=["rtp_desc"], where=[("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", w)], limit=1) if not acc: return "Invalid Premises Number, Does Not exist" self.oldprm = w self.df.loadEntry(frt, pag, p+1, data=acc[0]) def doOldAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlmst", cols=["rtm_name"], where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code", "=", self.oldprm), ("rtm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number, Does Not exist" self.oldacc = w self.oldnot = "%7s%s" % (self.oldprm, self.oldacc) self.df.loadEntry(frt, pag, p+1, data=acc[0]) def doNewCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlprm", cols=["rtp_desc"], where=[("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", w)], limit=1) if not acc: return "Invalid Premises Number, Does Not exist" self.newprm = w self.df.loadEntry(frt, pag, p+1, data=acc[0]) def doNewAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlmst", where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code", "=", self.newprm), ("rtm_acno", "=", w)], limit=1) if acc: return "Invalid Account Number, Already Exists" self.newacc = w self.newnot = "%7s%s" % (self.newprm, w) def doProcess(self, focus=True): for tab in self.tables: if tab[0] == "ctlnot": whr = [ ("not_cono", "=", self.opts["conum"]), ("not_sys", "=", "RTL"), (tab[1], "=", self.oldnot)] dat = [self.newnot] col = [tab[1]] elif tab[0] == "ctlvtf": whr = [ (tab[1], "=", self.opts["conum"]), (tab[2], "=", self.oldacc), (tab[3], "=", "R")] dat = [self.newacc] col = [tab[2]] else: whr = [ (tab[1], "=", self.opts["conum"]), (tab[2], "=", self.oldprm), (tab[3], "=", self.oldacc)] dat = [self.newprm, self.newacc] col = [tab[2], tab[3]] self.sql.updRec(tab[0], where=whr, data=dat, cols=col) if focus: self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].dbm.commitDbase(ask=True) self.opts["mf"].closeLoop()
class dr1010(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, [ "ctlmes", "ctlrep", "chglog", "ctlnot", "slsiv1", "drsact", "drschn", "drsdel", "drsmst", "drstrn", "drstyp" ], 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.chains = drsctl["ctd_chain"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def mainProcess(self): drc = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } drm = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1")) } if self.chains == "Y": drm["where"] = [("drm_cono", "=", self.opts["conum"])] drm["whera"] = [["T", "drm_chain", 0]] else: drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", 0)] drm["where"].append(("drm_stat", "<>", "X")) dlm = { "stype": "R", "tables": ("drsdel", ), "cols": (("del_code", "", 0, "Del-Cod"), ("del_add1", "", 0, "Address", "Y")) } rpm = { "stype": "R", "tables": ("ctlrep", ), "cols": (("rep_code", "", 0, "Rep"), ("rep_name", "", 0, "Name", "Y")), "where": [("rep_cono", "=", self.opts["conum"])] } act = { "stype": "R", "tables": ("drsact", ), "cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0, "Description", "Y")) } typ = { "stype": "R", "tables": ("drstyp", ), "cols": (("dtp_code", "", 0, "Cod"), ("dtp_desc", "", 0, "Description", "Y")) } msi = { "stype": "R", "tables": ("ctlmes", ), "cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50, "Details", "Y")), "where": [("mss_system", "=", "INV")] } mss = { "stype": "R", "tables": ("ctlmes", ), "cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50, "Details", "Y")), "where": [("mss_system", "=", "STA")] } tag = (("Basic-_A", None, ("T", 1, 1), ("T", 0, 1)), ("Basic-_B", None, ("T", 1, 1), ("T", 0, 1))) r1s = (("Yes", "Y"), ("No", "N")) r2s = (("New", "N"), ("Good", "G"), ("Fair", "F"), ("Poor", "P"), ("Bad", "B")) self.fld = [ [("T",0,0,0),"IUI",3,"Chain Store","", "","Y",self.doChain,drc,None,("efld",)], [("T",0,0,14),"INA",7,"Acc-Num","Account Number", "","N",self.doAcno,drm,None,("efld",),None, "To Automatically Generate Account Numbers for "\ "New Accounts enter a Blank Account Number."], (("T",0,0,30),"INA",30,"Name","", "","N",self.doName,None,self.doDelete,("notblank",)), [("T",0,0,0),"INA",7,"Acc-Num","Account Number", "","Y",self.doAcno,drm,None,("efld",),None, "To Automatically Generate Account Numbers for "\ "New Accounts enter a Blank Account Number."], (("T",0,0,14),"INA",30,"Name","", "","N",self.doName,None,self.doDelete,("notblank",)), (("T",1,0,0),"INA",30,"Address Line 1","", "","N",None,None,None,("notblank",)), (("T",1,1,0),"INA",30,"Address Line 2","", "","N",None,None,None,("efld",)), (("T",1,2,0),"INA",30,"Address Line 3","", "","N",None,None,None,("efld",)), (("T",1,3,0),"INA",4,"Postal Code","", "","N",None,None,None,("efld",)), (("T",1,4,0),"INA",20,"Telephone","", "","N",None,None,None,("efld",)), (("T",1,5,0),"INA",20,"Fax","", "","N",None,None,None,("efld",)), (("T",1,6,0),"INA",30,"Manager","Manager's Name", "","N",None,None,None,("efld",)), (("T",1,6,47),"ITX",30,"E-Mail","Manager's E-Mail Address", "","N",None,None,None,("email",)), (("T",1,7,0),"INA",30,"Accounts","Accounts Contact", "","N",None,None,None,("efld",)), (("T",1,7,47),"ITX",30,"E-Mail","Accounts E-Mail Address", "","N",None,None,None,("email",)), (("T",1,8,0),"INA",30,"Sales","Sales Contact", "","N",None,None,None,("efld",)), (("T",1,8,47),"ITX",30,"E-Mail","Sales E-Mail Address", "","N",None,None,None,("email",)), (("T",1,9,0),"Id1",10,"Date Opened","Date Account Opened", self.sysdtw,"N",None,None,None,("efld",)), (("T",1,10,0),"Id1",10,"Date Registered","", "","N",None,None,None,("efld",)), (("T",1,11,0),"INA",10,"V.A.T Number","", "","N",None,None,None,("efld",)), (("T",1,12,0),"INa",7,"Delivery Code","", "","N",self.doDelivery,dlm,None,("efld",)), (("T",1,13,0),"INa",3,"Rep Code","", "","N",self.doRep,rpm,None,("efld",)), (("T",1,13,20),"ONA",26,""), (("T",1,14,0),"IUA",3,"Business Activity","", "","N",self.doBusAct,act,None,("efld",)), (("T",1,14,20),"ONA",26,""), (("T",1,15,0),"IUA",3,"Business Type","", "","N",self.doBusTyp,typ,None,("efld",)), (("T",1,15,20),"ONA",26,""), (("T",2,0,0),"IUI",1,"Price Level","", "","N",None,None,None,("efld",)), (("T",2,1,0),"IUD",5.2,"Discount Percentage","", "","N",None,None,None,("efld",)), (("T",2,2,0),"IUD",5.2,"Interest Percentage","", "","N",None,None,None,("efld",)), (("T",2,3,0),"IUI",3,"Referral Terms","", "","N",None,None,None,("efld",)), (("T",2,4,0),"IUI",3,"Rejected Terms","", "","N",None,None,None,("efld",)), (("T",2,5,0),"IUI",5,"Credit Limit","", "","N",None,None,None,("efld",)), (("T",2,6,0),("IRB",r1s),0,"Stop Indicator","", "N","N",None,None,None,None), (("T",2,7,0),"IUI",3,"Invoice Message","", "","N",self.doImes,msi,None,("efld",)), (("T",2,7,22),"ONA",50,""), (("T",2,8,0),"IUI",3,"Statement Message","", "","N",self.doSmes,mss,None,("efld",)), (("T",2,8,22),"ONA",50,""), (("T",2,9,0),("IRB",r2s),0,"Credit Rating","", "N","N",None,None,None,None)] but = (("Import", None, self.doImport, 0, ("T", 0, 1), ("T", 0, 2), "Import Account Details from a CSV or XLS File."), ("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 1)), ("Print", None, self.doPrint, 0, ("T", 1, 1), ("T", 0, 1)), ("Cancel", None, self.doCancel, 0, ("T", 1, 1), ("T", 0, 1)), ("Quit", None, self.doExit1, 1, None, None)) tnd = ((self.doEnd1, "N"), (self.doEnd2, "N"), (self.doAccept, "Y")) txt = (self.doExit1, self.doExit2, self.doExit3) if self.chains == "Y": del self.fld[3] del self.fld[3] else: del self.fld[0] del self.fld[0] del self.fld[0] self.chain = 0 self.df = TartanDialog(self.opts["mf"], eflds=self.fld, tags=tag, butt=but, tend=tnd, txit=txt, clicks=self.doClick) if "args" in self.opts: if self.chains == "Y": self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][0]) self.df.doKeyPressed("T", 0, 1, data=self.opts["args"][1]) else: self.chain = self.opts["args"][0] self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][1]) def doClick(self, *opts): if self.df.pag == 0: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doChain(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drschn", where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", self.chain)], limit=1) if not acc: return "Invalid Chain Store" self.chain = w def doAcno(self, frt, pag, r, c, p, i, w): self.acno = w if self.acno: self.old = self.sql.getRec("drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)], limit=1) if not self.acno or not self.old: ok = askQuestion(self.opts["mf"].body, "New Account", "Is This a New Account?", default="no") if ok == "no": return "Invalid Account Number" pw = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="DRS", code="NewAcc") if pw.flag == "no": if "args" in self.opts: return "xt" else: return "New Account Creation is Not Allowed" self.new = True elif self.old[self.sql.drsmst_col.index("drm_stat")] == "X": return "Invalid Account, Redundant" else: self.new = False self.df.loadEntry("T", pag, p + 1, data=self.old[3]) d = 4 for pg in range(1, self.df.pgs + 1): for x in range(0, self.df.topq[pg]): if pg == 1 and x in (17, 19, 21): continue if pg == 2 and x in (8, 10): continue if pg == 2 and x == 11 and not self.old[d]: data = "N" else: data = self.old[d] self.df.loadEntry("T", pg, x, data=data) d += 1 self.loadRep() self.loadAct() self.loadTyp() self.loadInvMess() self.loadStaMess() def loadRep(self): acc = self.sql.getRec("ctlrep", cols=["rep_name"], where=[("rep_cono", "=", self.opts["conum"]), ("rep_code", "=", self.df.t_work[1][0][16])], limit=1) if acc: self.df.loadEntry("T", 1, 17, data=acc[0]) def loadAct(self): acc = self.sql.getRec("drsact", cols=["dac_desc"], where=[("dac_code", "=", self.df.t_work[1][0][18])], limit=1) if acc: self.df.loadEntry("T", 1, 19, data=acc[0]) def loadTyp(self): acc = self.sql.getRec("drstyp", cols=["dtp_desc"], where=[("dtp_code", "=", self.df.t_work[1][0][20])], limit=1) if acc: self.df.loadEntry("T", 1, 21, data=acc[0]) def loadInvMess(self): acc = self.sql.getRec("ctlmes", cols=["mss_detail"], where=[("mss_system", "=", "INV"), ("mss_message", "=", self.df.t_work[2][0][7])], limit=1) if acc: self.df.loadEntry("T", 2, 8, data=acc[0]) def loadStaMess(self): acc = self.sql.getRec("ctlmes", cols=["mss_detail"], where=[("mss_system", "=", "STA"), ("mss_message", "=", self.df.t_work[2][0][9])], limit=1) if acc: self.df.loadEntry("T", 2, 10, data=acc[0]) def doName(self, frt, pag, r, c, p, i, w): self.name = w if self.new and not self.acno: for x in range(1, 100): self.acno = genAccNum(self.name, x, 7) chk = self.sql.getRec("drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)], limit=1) if not chk: break self.df.loadEntry("T", 0, 0, data=self.acno) def doDelivery(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drsdel", where=[("del_code", "=", w)], limit=1) if not acc: ok = askQuestion(self.opts["mf"].body, head="Delivery Address", mess="This Delivery Address Does Not Exist, Would "\ "You Like to Create It Now?", default="no") if ok == "no": return "rf" callModule(self.opts["mf"], self.df, "drc410", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=None, args=w) acc = self.sql.getRec("drsdel", where=[("del_code", "=", w)], limit=1) if not acc: return "rf" def doRep(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("ctlrep", cols=["rep_name"], where=[("rep_cono", "=", self.opts["conum"]), ("rep_code", "=", w)], limit=1) if not acc: return "Invalid Rep" self.df.loadEntry("T", 1, p + 1, data=acc[0]) def doBusAct(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drsact", cols=["dac_desc"], where=[("dac_code", "=", w)], limit=1) if not acc: return "Invalid Business Activity" self.df.loadEntry("T", 1, p + 1, data=acc[0]) def doBusTyp(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drstyp", cols=["dtp_desc"], where=[("dtp_code", "=", w)], limit=1) if not acc: return "Invalid Business Type" self.df.loadEntry("T", 1, p + 1, data=acc[0]) def doImes(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("ctlmes", cols=["mss_detail"], where=[("mss_system", "=", "INV"), ("mss_message", "=", w)], limit=1) if not acc: return "Invalid Invoice Message" self.df.loadEntry("T", 2, p + 1, data=acc[0]) def doSmes(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("ctlmes", cols=["mss_detail"], where=[("mss_system", "=", "STA"), ("mss_message", "=", w)], limit=1) if not acc: return "Invalid Statement Message" self.df.loadEntry("T", 2, p + 1, data=acc[0]) def doDelete(self): trs = self.sql.getRec("drstrn", cols=["count(*)"], where=[("drt_cono", "=", self.opts["conum"]), ("drt_chain", "=", self.chain), ("drt_acno", "=", self.acno)], limit=1) if trs[0]: return "%s Transactions Exist, Not Deleted" % trs[0] iv1 = self.sql.getRec("slsiv1", cols=["count(*)"], where=[("si1_cono", "=", self.opts["conum"]), ("si1_chain", "=", self.chain), ("si1_acno", "=", self.acno)], limit=1) if iv1[0]: return "%s Sales Document Exists, Not Deleted" % iv1[0] key = "%03i%s" % (self.chain, self.acno) nte = self.sql.getRec("ctlnot", cols=["count(*)"], where=[("not_cono", "=", self.opts["conum"]), ("not_sys", "=", "DRS"), ("not_key", "=", key)], limit=1) if nte[0]: return "%s Notes Exist, Not Deleted" % nte[0] dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.delRec("drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)]) self.sql.insRec("chglog", data=["drsmst", "D", "%03i%03i%-7s" % \ (self.opts["conum"], self.chain, self.acno), "", dte, self.opts["capnm"], "", "", "", 0]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd1(self): self.df.focusField("T", 1, 1, clr=self.new) def doEnd2(self): self.df.selPage("Basic-B") self.df.focusField("T", 2, 1, clr=self.new) def doAccept(self): frt, pag, col, mes = self.df.doCheckFields() if mes: if pag > 0 and pag != self.df.pag: if frt == "T": self.df.last[pag][0] = col + 1 else: self.df.last[pag][1] = col + 1 self.df.selPage(self.df.tags[pag - 1][0]) else: self.df.focusField(frt, pag, (col + 1), err=mes) else: data = [self.opts["conum"], self.chain] if self.chains == "Y": f = 1 else: f = 0 for x in range(f, f + 2): data.append(self.df.t_work[0][0][x]) for x in range(0, len(self.df.t_work[1][0])): if x in (17, 19, 21): continue data.append(self.df.t_work[1][0][x]) for x in range(0, len(self.df.t_work[2][0])): if x in (8, 10): continue data.append(self.df.t_work[2][0][x]) if self.new: data.extend(["N", ""]) self.sql.insRec("drsmst", data=data) else: col = self.sql.drsmst_col data.append(self.old[col.index("drm_stat")]) data.append(self.old[col.index("drm_xflag")]) if data != self.old: self.sql.updRec("drsmst", data=data, where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old): if dat != data[num]: self.sql.insRec( "chglog", data=[ "drsmst", "U", "%03i%03i%-7s" % (self.opts["conum"], self.chain, self.acno), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) if "args" in self.opts: self.doExit1() else: self.opts["mf"].dbm.commitDbase() self.df.last[0] = [0, 0] self.df.selPage("Basic-A") self.df.focusField("T", 0, 1) def doImport(self): self.df.setWidget(self.df.B3, state="disabled") self.df.setWidget(self.df.mstFrame, state="hide") fi = FileImport(self.opts["mf"], imptab="drsmst", impskp=["drm_cono"]) sp = ProgressBar(self.opts["mf"].body, typ="Importing Debtor's Accounts", mxs=len(fi.impdat)) err = None for num, line in enumerate(fi.impdat): sp.displayProgress(num) if not line[1]: if not line[2]: err = "Blank Account Number and Blank Name" break for x in range(1, 100): line[1] = genAccNum(line[2], x, 7) chk = self.sql.getRec("drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", line[0]), ("drm_acno", "=", line[1])], limit=1) if not chk: break chk = self.sql.getRec("drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", line[0]), ("drm_acno", "=", line[1])], limit=1) if chk: err = "%s %s %s %s Already Exists" % (fi.impcol[0][0], line[0], fi.impcol[1][0], line[1]) break if not line[2]: err = "Blank Name" break if not line[15]: line[15] = self.sysdtw if not line[28]: line[28] = "N" if not line[31]: line[31] = "N" line.insert(0, self.opts["conum"]) self.sql.insRec("drsmst", data=line) sp.closeProgress() if err: err = "Line %s: %s" % ((num + 1), err) showError( self.opts["mf"].body, "Import Error", """%s Please Correct your Import File and then Try Again.""" % err) self.opts["mf"].dbm.rollbackDbase() else: self.opts["mf"].dbm.commitDbase() self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doPrint(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") TabPrt(self.opts["mf"], self.opts["conum"], self.opts["conam"], name=self.__class__.__name__, tabs="drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)]) self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.last[0] = [0, 0] self.df.selPage("Basic-A") self.df.focusField("T", 0, 1) def doExit1(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop() def doExit2(self): self.df.focusField("T", 0, 1) def doExit3(self): self.df.selPage("Basic-A")
class wgc210(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, "wagrcv", prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): rcv = { "stype": "R", "tables": ("wagrcv", ), "cols": (("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details")) } self.fld = ((("T", 0, 0, 0), "IUI", 4, "Item Code", "", "", "N", self.doCode, rcv, None, ("notzero", )), (("T", 0, 1, 0), "INA", 50, "Description", "", "", "N", None, None, self.doDelete, ("notblank", ))) but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None)) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doCode(self, frt, pag, r, c, p, i, w): self.code = w acc = self.sql.getRec("wagrcv", where=[("rcv_code", "=", self.code)], limit=1) if not acc: self.new = "Y" else: self.new = "N" for x in range(1, self.df.topq[pag]): self.df.loadEntry(frt, pag, p + x, data=acc[x]) def doDelete(self): self.sql.delRec("wagrcv", where=[("rcv_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): dat = [] for x in range(0, len(self.df.t_work[0][0])): dat.append(self.df.t_work[0][0][x]) if self.new == "Y": self.sql.insRec("wagrcv", data=dat) else: self.sql.updRec("wagrcv", data=dat, where=[("rcv_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doAccept(self): frt, pag, col, mes = self.df.doCheckFields() if mes: self.df.focusField(frt, pag, (col + 1), err=mes) else: self.df.doEndFrame("T", 0, cnf="N") def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bkc410(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, tables="bkmlet", prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): r1s = (("Query", "Q"), ("Confirm", "C"), ("Settle", "S"), ("Cancel", "X")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Letter Type", "", "Q", "Y", self.doType, None, None, None), (("T", 0, 1, 0), "ITV", (80, 10), "Body", "", "", "N", None, None, None, ("notblank", ))) but = (("Save", None, self.doSave, 0, ("T", 0, 2), ("T", 0, 1)), ("Quit", None, self.doQuit, 1, None, ("T", 0, 1))) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt) def doType(self, frt, pag, r, c, p, i, w): self.ltyp = w self.let = self.sql.getRec("bkmlet", where=[("bkl_cono", "=", self.opts["conum"]), ("bkl_code", "=", self.ltyp)], limit=1) if not self.let: self.lnew = True else: self.lnew = False self.df.loadEntry( frt, pag, p + 1, data=self.let[self.sql.bkmlet_col.index("bkl_body")]) def doSave(self): self.df.loadEntry("T", 0, 1, data=self.df.getEntry("T", 0, 1)[1]) self.doEnd() def doEnd(self): data = [self.opts["conum"], self.ltyp, self.df.t_work[0][0][1]] if self.lnew: self.sql.insRec("bkmlet", data=data) elif data != self.let[:len(data)]: col = self.sql.bkmlet_col data.append(self.let[col.index("bkl_xflag")]) self.sql.updRec("bkmlet", data=data, where=[("bkl_cono", "=", self.opts["conum"]), ("bkl_code", "=", self.ltyp)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doQuit(self): self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class st6040(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, ["crsmst", "strloc", "strpom", "strpot"], 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"] 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"]), "Purchase Order Cancellations (%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"])]} orm = { "stype": "R", "tables": ("strpom",), "cols": ( ("pom_ordno", "", 0, "OrderNo"), ("pom_acno", "", 0, "Crs-Num"), ("pom_date", "", 0, "Order-Date")), "where": [ ("pom_cono", "=", self.opts["conum"]), ("pom_delno", "=", "")], "whera": [("T", "pom_loc", 0)], "order": "pom_ordno"} if self.locs == "N": self.locw = "1" fld = [ (("T",0,0,0),"OUA",1,"Location")] else: fld = [ (("T",0,0,0),"IUA",1,"Location","", "1","Y",self.doLoc,loc,None,None)] fld.extend([ (("T",0,1,0),"Id1",10,"Orders Older Than","", "","Y",self.doOld,orm,None,None), (("T",0,2,0),"IUI",9,"From Order Number","", "","Y",self.doOrd,orm,None,None), (("T",0,3,0),"IUI",9,"To Order Number","", "","Y",self.doOrd,orm,None,None)]) tnd = ((self.doEnd,"y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, tend=tnd, txit=txt) if self.locs == "N": self.df.loadEntry("T", 0, 0, data=self.locw) 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.locw = w def doOld(self, frt, pag, r, c, p, i, w): self.oldr = w if self.oldr: self.df.loadEntry(frt, pag, p+1, data="") self.df.loadEntry(frt, pag, p+2, data="") return "nd" def doOrd(self, frt, pag, r, c, p, i, w): if p == 3 and w < self.ord1: return "Invalid, Last Order less than First Order" acc = self.sql.getRec("strpom", where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", w), ("pom_loc", "=", self.locw), ("pom_delno", "=", "")], limit=1) if not acc: return "Invalid Order Number" if p == 2: self.ord1 = w else: self.ord2 = w def doEnd(self): self.df.closeProcess() if self.oldr: whr = [ ("pom_cono", "=", self.opts["conum"]), ("pom_loc", "=", self.locw), ("pom_date", "<", self.oldr), ("pom_delno", "<>", "cancel"), ("pom_deldt", "=", 0)] else: whr = [ ("pom_cono", "=", self.opts["conum"]), ("pom_loc", "=", self.locw), ("pom_ordno", ">=", self.ord1), ("pom_ordno", "<=", self.ord2), ("pom_delno", "<>", "cancel"), ("pom_deldt", "=", 0)] self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"], where=whr) self.opts["mf"].dbm.commitDbase(ask=True) self.opts["mf"].closeLoop() def doExit(self): self.df.closeProcess() 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 ml3120(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, "memsta", prog=self.__class__.__name__) if self.sql.error: return self.desc = { "A": ["Active",0,0,0,0,0,0,0,0,0,0,0,0], "D": ["Deceased",0,0,0,0,0,0,0,0,0,0,0,0], "I": ["Inactive",0,0,0,0,0,0,0,0,0,0,0,0], "R": ["Resigned",0,0,0,0,0,0,0,0,0,0,0,0], "S": ["Suspended",0,0,0,0,0,0,0,0,0,0,0,0], "X": ["Defaulted",0,0,0,0,0,0,0,0,0,0,0,0]} return True def mainProcess(self): fld = ( (("T",0,0,0),"ID2",7,"Starting Period","", "","N",self.doStartPer,None,None,None), (("T",0,1,0),"ID2",7,"Ending Period","", "","N",self.doEndPer,None,None,None)) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt) def doStartPer(self, frt, pag, r, c, p, i, w): self.sdate = (w * 100) + 1 y = int(w / 100) m = (w % 100) + 11 if m > 12: y += 1 m -= 12 self.df.loadEntry(frt, pag, p+1, ((y * 100) + m)) def doEndPer(self, frt, pag, r, c, p, i, w): self.edate = mthendDate((w * 100) + 1) if dateDiff(self.sdate, self.edate, "months") > 11: return "More than 12 month period" def doEnd(self): self.df.closeProcess() rec = self.sql.getRec("memsta", cols=["mls_status", "mls_date/100 as date", "count(*)"], where=[("mls_date", "between", self.sdate, self.edate)], group="mls_status, date") num = 1 lookup = {} mth = int(self.sdate / 100) % 100 end = int(self.edate / 100) % 100 lookup[mth] = num while mth != end: mth += 1 if mth > 12: mth = 1 num += 1 lookup[mth] = num for r in rec: mth = r[1] % 100 self.desc[r[0]][lookup[mth]] = r[2] achart = [] for s in self.desc: achart.append([s] + self.desc[s]) CreateChart(self.opts["mf"], self.opts["conum"], self.opts["conam"], [int(self.sdate / 100), int(self.edate / 100)], [[self.opts["conam"], "Status Summary"], "Count"], achart, achart) self.opts["mf"].closeLoop() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class rtc110(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["rtlctl", "tplmst", "chglog"], prog=self.__class__.__name__) if self.sql.error: return self.acc = self.sql.getRec("rtlctl", where=[("ctr_cono", "=", self.opts["conum"]) ], limit=1) if not self.acc: self.new = True self.acc = [self.opts["conum"], "N", 0, "statement_rental", "", ""] else: self.new = False return True def drawDialog(self): tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")), "where": [("tpm_type", "=", "S"), ("tpm_system", "=", "RTL")], "order": "tpm_tname" } r1s = (("Yes", "Y"), ("No", "N")) self.fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "", self.acc[1], "N", None, None, None, None), (("T", 0, 1, 0), "ID1", 10, "Last Month End", "", self.acc[2], "N", None, None, None, ("efld", )), (("T", 0, 2, 0), "INA", 20, "Statement Template", "", self.acc[3], "N", self.doTplNam, tpm, None, None), (("T", 0, 3, 0), "ITX", 50, "Email Address", "", self.acc[4], "N", None, None, None, ("email", ))) but = (("Quit", None, self.doExit, 1, None, None), ) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) if not self.new: for n, f in enumerate(self.acc[1:-1]): self.df.loadEntry("T", 0, n, data=f) def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "S"), ("tpm_system", "=", "RTL")], limit=1) if not acc: return "Invalid Template Name" def doEnd(self): data = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): data.append(self.df.t_work[0][0][x]) if self.new: self.sql.insRec("rtlctl", data=data) elif data != self.acc[:len(data)]: col = self.sql.rtlctl_col data.append(self.acc[col.index("ctr_xflag")]) self.sql.updRec("rtlctl", data=data, where=[("ctr_cono", "=", self.opts["conum"])]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.acc): if dat != data[num]: self.sql.insRec("chglog", data=[ "rtlctl", "U", "%03i" % self.opts["conum"], col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.doExit() 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 cp1010: def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.gc = GetCtl(self.opts["mf"]) ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.mods = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): self.mods.append(ctlmst["ctm_modules"][x:x+2]) tabs = ["ctlmst", "ctlynd", "ctlvtf", "ctlbat", "asstrn", "bkmtrn", "crstrn", "crsage", "drstrn", "drsage", "gentrn", "lontrn", "memtrn", "memage", "rcaowt", "rcatnt", "rtltrn", "wagltf"] self.syss = { "ASS": ["assctl", "cta_glint", [0, 2, 6, 4, 4], [["ast_cono", "ast_type", "ast_batch", "ast_curdt"]]], "BKM": ["bkmctl", "cbk_glint", [0, 0, 1, 6, 2, 4, 1, 6], [["bkt_cono", "bkt_type", "bkt_batch", "bkt_curdt"]]], "CRS": ["crsctl", "ctc_glint", [0, 5, 6, 4, 5, 2, 2], [["crt_cono", "crt_type", "crt_batch", "crt_curdt"]], ["crt_ref1", "cra_cono", "cra_curdt", "cra_atyp", "cra_aref"]], "DRS": ["drsctl", "ctd_glint", [0, 1, 6, 4, 1, 2, 6], [["drt_cono", "drt_type", "drt_batch", "drt_curdt"]], ["drt_ref1", "dra_cono", "dra_curdt", "dra_atyp", "dra_aref"]], "GEN": [], "LON": ["lonctl", "cln_glint", [0, 2, 6, 4, 4], [["lnt_cono", "lnt_type", "lnt_batch", "lnt_curdt"]]], "MEM": ["memctl", "mcm_glint", [0, 1, 2, 4, 1, 6, 6], [["mlt_cono", "mlt_type", "mlt_batch", "mlt_curdt"]], ["mlt_refno", "mta_cono", "mta_curdt", "mta_atyp", "mta_aref"]], "RCA": ["rcactl", "cte_glint", [0, 1, 6, 2, 4], [ ["rot_cono", "rot_type", "rot_batch", "rot_curdt"], ["rtu_cono", "rtu_type", "rtu_batch", "rtu_curdt"]]], "RTL": ["rtlctl", "ctr_glint", [0, 1, 6, 2, 4], [["rtt_cono", "rtt_type", "rtt_batch", "rtt_curdt"]]], "SLN": ["wagctl", "ctw_glint", [0, 4, 2, 2, 6, 4], [["wlt_cono", "wlt_type", "wlt_batch", "wlt_curdt"]]]} self.sql = Sql(self.opts["mf"].dbm, tabs, prog=__name__) if self.sql.error: return self.i_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) return True def mainProcess(self): tit = "Change Batch Current Period" data = [] for ss in allsys: if ss not in self.syss: continue if allsys[ss][1] not in self.mods: continue data.append((ss, allsys[ss][0])) data.sort() sss = { "stype": "C", "titl": "Systems", "head": ["COD", "Description"], "data": data} self.ttt = { "stype": "C", "titl": "Batch Types", "head": ["BT", "Description"], "data": []} self.bat = { "stype": "R", "tables": ("ctlbat",), "cols": ( ("btm_batno", "", 0, "Bat-Num"), ("btm_curdt", "", 0, "Cur-Dte")), "where": [ ("btm_cono", "=", self.opts["conum"]), ("btm_curdt", "between", self.i_per, self.e_per)], "whera": ( ("T", "btm_styp", 0, 0), ("T", "btm_rtyp", 2, 0)), "order": "btm_curdt, btm_batno"} fld = ( (("T",0,0,0),"IUA",3,"System Code","", "","N",self.doSysCod,sss,None,("notblank",)), (("T",0,0,0),"ONA",30,""), (("T",0,1,0),"IUI",2,"Transaction Type","", "","N",self.doTrnTyp,self.ttt,None,("notzero",)), (("T",0,1,0),"ONA",30,""), (("T",0,2,0),"INa",7,"Batch Number","", "","N",self.doBatNum,self.bat,None,("notblank",)), (("T",0,3,0),"OD2",7,"Captured Period"), (("T",0,4,0),"ID2",7,"Change to Period","", "","N",self.doNewPer,None,None,("efld",))) but = (("Exit", None, self.doExit, 0, ("T",0,1), ("T",0,0)),) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, title=tit, eflds=fld, butt=but, tend=tnd, txit=txt) def doSysCod(self, frt, pag, r, c, p, i, w): if w not in self.syss: return "Invalid System" if allsys[w][1] not in self.mods: return "Invalid System" self.syscod = w self.ttt["data"] = [] exec("from tartanWork import %strtp as trtp" % allsys[w][1].lower()) setattr(self, "trtp", locals()["trtp"]) for n, t in enumerate(self.trtp): self.ttt["data"].append((n+1, t[1])) self.df.loadEntry(frt, pag, p+1, data=allsys[self.syscod][0]) def doTrnTyp(self, frt, pag, r, c, p, i, w): if (w < 1 or w > len(self.trtp)): return "Invalid Type" self.battyp = w rtn = self.trtp[w-1][1] self.df.loadEntry(frt, pag, p+1, data=rtn) def doBatNum(self, frt, pag, r, c, p, i, w): self.batnum = w self.btm = [ ("btm_cono", "=", self.opts["conum"]), ("btm_styp", "=", self.syscod), ("btm_rtyp", "=", self.battyp), ("btm_batno", "=", self.batnum)] chk = self.sql.getRec("ctlbat", cols=["btm_curdt"], where=self.btm, limit=1) if not chk: return "Invalid Batch(B)" per = self.doChkPer(chk[0]) if per: return per self.oldper = chk[0] self.df.loadEntry(frt, pag, p+1, data=self.oldper) def doNewPer(self, frt, pag, r, c, p, i, w): per = self.doChkPer(w) if per: return per self.newper = w def doChkPer(self, per): if per < self.i_per or per > self.e_per: return "Invalid Period(P)" whr = ( ("cye_cono", "=", self.opts["conum"]), ("cye_start", ">=", per), ("cye_end", "<=", per)) chk = self.sql.getRec("ctlynd", cols=["cye_final"], where=whr, limit=1) if chk and chk[0] == "Y": return "Invalid Period(F)" def doEnd(self): self.sql.updRec("ctlbat", cols=["btm_curdt"], data=[self.newper], where=self.btm) if self.syscod == "GEN": if self.battyp not in list(range(1, 8)): raise Exception if self.battyp == 7: gltyp = (2, 6) else: gltyp = (self.battyp,) glint = "N" else: ctl = self.syss[self.syscod] glint = self.gc.getCtl(ctl[0], self.opts["conum"])[ctl[1]] if glint == "Y": gltyp = (ctl[2][self.battyp],) sqv = [ ("vtt_cono", "=", self.opts["conum"]), ("vtt_curdt", "=", self.oldper), ("vtt_styp", "=", self.syscod[0])] if self.syscod == "GEN": sqv.append(("vtt_ttyp", "in", gltyp)) else: sqv.append(("vtt_ttyp", "=", self.battyp)) sqv.append(("vtt_batch", "=", self.batnum)) self.sql.updRec("ctlvtf", cols=["vtt_curdt"], data=[self.newper], where=sqv) if self.syscod == "GEN" or glint == "Y": sqt = [ ("glt_cono", "=", self.opts["conum"]), ("glt_curdt", "=", self.oldper), ("glt_type", "in", gltyp), ("glt_batch", "=", self.batnum)] tmp = sqt[:] tmp.append(("glt_recon", "=", self.oldper)) self.sql.updRec("gentrn", cols=["glt_recon"], data=[self.newper], where=tmp) self.sql.updRec("gentrn", cols=["glt_curdt"], data=[self.newper], where=sqt) if self.syscod == "GEN": codes = list(self.syss.keys()) else: codes = [self.syscod] for syscod in codes: if syscod == "GEN": continue ctl = self.syss[syscod] if self.syscod == "GEN": trtyp = [] for cod in gltyp: trtyp.append(self.syss[syscod][2].index(cod)) else: trtyp = (self.battyp,) if syscod == "RCA": tabs = ["rcaowt", "rcatnt"] elif syscod == "SLN": tabs = ["wagltf"] else: tabs = ["%strn" % syscod.lower()] for seq, tab in enumerate(tabs): sqt = [ (ctl[3][seq][0], "=", self.opts["conum"]), (ctl[3][seq][1], "in", trtyp), (ctl[3][seq][2], "=", self.batnum), (ctl[3][seq][3], "=", self.oldper)] if syscod in ("CRS", "DRS", "MEM"): recs = self.sql.getRec(tab, cols=[ctl[4][0]], where=sqt) self.sql.updRec(tab, cols=[ctl[3][seq][3]], data=[self.newper], where=sqt) if syscod in ("CRS", "DRS", "MEM"): tab = "%sage" % syscod.lower() for rec in recs: sqa = ( (ctl[4][1], "=", self.opts["conum"]), (ctl[4][2], "=", self.oldper), (ctl[4][3], "in", trtyp), (ctl[4][4], "=", rec[0])) self.sql.updRec("%sage" % syscod.lower(), cols=[ctl[4][2]], data=[self.newper], where=sqa) self.opts["mf"].dbm.commitDbase(ask=True) self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bsc210(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, ["bksaut", "bksmst"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): clb = { "stype": "R", "tables": ("bksaut",), "cols": ( ("baf_code", "", 0, "Cod"), ("baf_snam", "", 0, "Surname", "Y"), ("baf_fnam", "", 0, "Names")), "order": "baf_snam"} fld = ( (("T",0,0,0),"I@baf_code",0,"","", "","Y",self.doCode,clb,None,("efld",)), (("T",0,1,0),"I@baf_snam",0,"","", "","N",self.doSnam,None,self.doDelete,("notblank",)), (("T",0,2,0),"I@baf_fnam",0,"","", "","N",self.doFnam,None,None,("efld",))) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt) def doCode(self, frt, pag, r, c, p, i, w): if not w: self.author = getNextCode(self.sql, "bksaut", "baf_code", last=999) self.df.loadEntry(frt, pag, p, data=self.author) else: self.author = w self.old = self.sql.getRec("bksaut", where=[("baf_code", "=", self.author)], limit=1) if not self.old: self.newaut = True else: self.newaut = False for num, fld in enumerate(self.old[:-1]): self.df.loadEntry(frt, pag, num, data=fld) def doDelete(self): chk = self.sql.getRec("bksmst", where=[("bmf_auth", "=", self.author)], limit=1) if chk: showError(self.opts["mf"].body, "Error", "Author in Use") return self.sql.delRec("bksaut", where=[("baf_code", "=", self.author)]) self.opts["mf"].dbm.commitDbase() def doSnam(self, frt, pag, r, c, p, i, w): self.snam = w def doFnam(self, frt, pag, r, c, p, i, w): if self.newaut: chk = self.sql.getRec("bksaut", where=[("baf_snam", "=", self.snam), ("baf_fnam", "=", w)], limit=1) if chk: return "An Author with this Name Already Exists" def doEnd(self): data = self.df.t_work[0][0][:] if self.newaut: self.sql.insRec("bksaut", data=data) elif data != self.old[:len(data)]: col = self.sql.bksaut_col data.append(self.old[col.index("baf_xflag")]) self.sql.updRec("bksaut", data=data, where=[("baf_code", "=", self.author)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() 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 gl6060(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, ["ctlctl", "genmst", "genrct"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Delete Imported Bank Statements (%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", )] } r1s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "IUI", 7, "Bank Account", "", "", "Y", self.doBankAcc, glm, None, ("efld", )), (("T", 0, 1, 0), "Id1", 10, "From Date", "From Date (0 for Beginning)", 0, "Y", self.doFrom, None, None, ("efld", )), (("T", 0, 2, 0), "Id1", 10, "To Date", "To Date (0 for End)", 0, "Y", self.doTo, None, None, ("efld", )), (("T", 0, 3, 0), ("IRB", r1s), 0, "Unallocated Only", "", "Y", "Y", self.doUnall, 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) 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.acnow = w self.acnod = self.df.t_disp[pag][r][p] self.name = acc[0] def doFrom(self, frt, pag, r, c, p, i, w): self.start = w def doTo(self, frt, pag, r, c, p, i, w): if w and self.start and w < self.start: return "Invalid Date, Earlier than From Date" self.to = w def doUnall(self, frt, pag, r, c, p, i, w): self.unall = w def doEnd(self): self.df.closeProcess() whr = [("grt_cono", "=", self.opts["conum"]), ("grt_acno", "=", self.acnow)] if self.start: whr.append(("grt_date", ">=", self.start)) if self.to: whr.append(("grt_date", "<=", self.to)) if self.unall == "Y": whr.append(("grt_flag", "=", "N")) cnt = self.sql.getRec("genrct", cols=["count(*)"], where=whr, limit=1) self.sql.delRec("genrct", where=whr) self.opts["mf"].dbm.commitDbase( ask=True, mess="A Total of %s Records were Deleted" % cnt[0], default="no") self.closeProcess() def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): if "wait" not in self.opts: self.opts["mf"].closeLoop()
class ms3040(object): def __init__(self, **opts): self.opts = opts self.setVariables() self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] def mainProcess(self): tab = { "stype": "R", "tables": ("chglog", ), "cols": (("chg_tab", "", 0, "Table Name", "TabNam"), ), "group": "chg_tab", "order": "chg_tab" } usr = { "stype": "R", "tables": ("chglog", ), "cols": (("chg_usr", "", 0, "User Login name", "User-Login-Name"), ), "group": "chg_usr", "order": "chg_usr" } r1s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "Id1", 10, "Date From", "", 0, "N", self.doDate, None, None, ("efld", )), (("T", 0, 1, 0), "ID1", 10, "Date To", "", self.sysdtw, "N", self.doDate, None, None, ("efld", )), (("T", 0, 2, 0), "INA", 6, "Table Name", "", "", "N", self.doTable, tab, None, ("efld", )), (("T", 0, 2, 0), "ONA", 30, ""), (("T", 0, 3, 0), ("IRB", r1s), 0, "Order By Table", "", "Y", "N", self.doOrder, None, None, None), (("T", 0, 4, 0), "INA", 20, "User Login", "", "", "N", self.doUser, usr, None, ("efld", )), (("T", 0, 4, 0), "ONA", 30, "")) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt, view=("Y", "V"), mail=("Y", "N")) def doDate(self, frt, pag, r, c, p, i, w): if p == 0: self.frm = CCD(w, "d1", 10) elif w < self.frm.work: return "Invalid Date, Less than Start Date" else: self.too = CCD(w, "D1", 10) def doTable(self, frt, pag, r, c, p, i, w): self.table = w if self.table: if self.table not in tabdic: return "Invalid Table Name" self.tname = tabdic[w]["idx"][0][0] self.df.loadEntry(frt, pag, p + 1, data=self.tname) def doUser(self, frt, pag, r, c, p, i, w): self.user = w if self.user: acc = self.sql.getRec("chglog", cols=["usr_fnam"], where=[("usr_name", "=", self.user)], limit=1) if not acc: return "Invalid User Login" self.tname = acc[0] self.df.loadEntry(frt, pag, p + 1, data=self.tname) def doOrder(self, frt, pag, r, c, p, i, w): self.byusr = w def doEnd(self): self.df.closeProcess() if not self.frm.work: frm = "Beginning" else: frm = self.frm.disp hds = "Changes Log Report from %s to %s" % (frm, self.too.disp) col = [("chg_tab", "NA", 6.0, "TabNam"), ("chg_act", "UA", 1.0, "A"), ("chg_key", "NA", 30.0, "Record-Key"), ("chg_col", "NA", 20.0, "Column-Name"), ("chg_old", "TX", 50.0, "Old-Details"), ("chg_new", "TX", 50.0, "New-Details"), ("chg_dte", "TS", 19.0, "Date-&-Time-Changed"), ("chg_usr", "NA", 20.0, "User-Login")] whr = [("chg_dte", ">=", str(self.frm.work * 1000000)), ("chg_dte", "<=", str((self.too.work * 1000000) + 999999))] if self.byusr == "Y": odr = "chg_tab, chg_dte desc" else: odr = "chg_dte desc" if self.table: whr.append(("chg_tab", "=", self.table)) if self.user: whr.append(("chg_usr", "=", self.user)) RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=["chglog"], heads=[hds], cols=col, where=whr, order=odr, repprt=self.df.repprt, repeml=self.df.repeml) self.opts["mf"].closeLoop() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class gl1060(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): # Create SQL Object self.sql = Sql(self.opts["mf"].dbm, [ "assgrp", "crsmst", "ctlctl", "ctlmst", "ctlvmf", "drsmst", "drschn", "genint", "genmst", "genrcc", "rtlprm" ], prog=self.__class__.__name__) if self.sql.error: return # Check for Intercompany Facility if not self.sql.getRec("ctlmst", cols=["count(*)"], where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]: self.incoac = False else: itg = self.sql.getRec("genint", cols=["cti_inco"], where=[("cti_cono", "=", self.opts["conum"]) ]) if itg: self.incoac = [self.opts["conum"]] [self.incoac.append(coy[0]) for coy in itg] else: self.incoac = False # self.gc = GetCtl(self.opts["mf"]) return True def mainProcess(self): ctl = { "stype": "R", "tables": ("ctlctl", "genmst"), "cols": (("ctl_code", "", 0, "Ctl-Code"), ("ctl_conacc", "", 0, "G/L-Num"), ("glm_desc", "", 30, "Description")), "where": [("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono", ), ("glm_acno=ctl_conacc", )], "index": 1 } rcc = { "stype": "R", "tables": ("genrcc", ), "cols": (("grc_memo", "", 0, "Code"), ("grc_desc1", "", 0, "Details"), ("grc_rtn", "", 0, "R"), ("grc_acoy", "", 0, "Coy"), ("grc_aacc", "", 0, "Acc-Num"), ("grc_acrs", "", 0, "Crs-Acc"), ("grc_achn", "", 0, "Chn"), ("grc_adrs", "", 0, "Drs-Acc"), ("grc_vat", "", 0, "V")), "where": [("grc_cono", "=", self.opts["conum"])], "whera": [["T", "grc_acno", 0]] } rct = { "stype": "R", "tables": ("genrct", ), "cols": (("grt_memo", "", 75, "Details"), ("grt_amount", "SD", 13.2, "Value")), "where": [("grt_cono", "=", self.opts["conum"]), ("grt_flag", "=", "N")], "whera": [["T", "grt_acno", 0, 0]], "group": "grt_memo", "order": "grt_memo", "comnd": self.doSameField } coy = { "stype": "R", "tables": ("ctlmst", ), "cols": (("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y")) } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "whera": [["T", "glm_cono", 7]] } chn = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "whera": [["T", "chm_cono", 7]] } self.crm = { "stype": "R", "tables": ("crsmst", ), "cols": (("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y"), ("crm_add1", "", 0, "Address Line 1")), "where": [("crm_stat", "<>", "X")], "whera": [["T", "crm_cono", 7]] } self.drm = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1")), "where": [("drm_stat", "<>", "X")], "whera": [["T", "drm_cono", 7], ["T", "drm_chain", 11]] } vat = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "Acc-Num"), ("vtm_desc", "", 0, "Description", "Y")), "whera": [["T", "vtm_cono", 7]] } r1s = (("Payment", "P"), ("Receipt", "R")) r2s = (("Oldest", "O"), ("Current", "C")) fld = [[("T", 0, 0, 0), "IUI", 7, "Bank Account", "", "", "Y", self.doAccNum, ctl, None, None], (("T", 0, 0, 0), "ONA", 30, ""), [("T", 0, 1, 0), "IUI", 5, "Memo Code", "Memo Code (Blank for Next)", "", "Y", self.doMemo, rcc, None, None], [("T", 0, 2, 0), "INA", 50, "Memo Desc Contains", "", "", "N", self.doDesc1, rct, self.doDelete, ("notblank", )], (("T", 0, 3, 0), "INA", 50, " and Contains", "Desc Also Contains", "", "N", self.doDesc2, rct, None, None), (("T", 0, 4, 0), "INA", 50, " and Contains", "Desc Also Contains", "", "N", self.doDesc3, rct, None, None), (("T", 0, 5, 0), ("IRB", r1s), 0, "Transaction Type", "", "P", "N", self.doTypCod, None, None, None), (("T", 0, 6, 0), "IUI", 7, "Allocation Company", "", self.opts["conum"], "N", self.doAllCoy, coy, None, ("notzero", )), (("T", 0, 6, 0), "ONA", 30, ""), (("T", 0, 7, 0), "IUI", 7, "Allocation Account", "", "", "N", self.doAllAcc, glm, None, ("notzero", )), (("T", 0, 7, 0), "ONA", 30, ""), [["T", 0, 8, 0], "IUI", 3, "Chn", "Chain Store Code", 0, "N", self.doDrsChn, chn, None, ("efld", )], (("T", 0, 8, 0), "ONA", 30, ""), [("T", 0, 9, 0), "INA", 7, "Acc-Num", "Account Number", "", "N", self.doCrsDrsAcc, self.crm, None, ("notblank", )], (("T", 0, 9, 0), "ONA", 30, ""), (("T", 0, 10, 0), ("IRB", r2s), 0, "Ageing Code", "", "O", "N", self.doCrsDrsAge, None, None, None, None, """ The Ageing Codes are as follows: Oldest - Automatically age against the oldest outstanding transactions. Current - Do not age the transaction. """), (("T", 0, 11, 0), "INA", 1, "Vat Code", "", "", "N", self.doVatCod, vat, None, None)] but = [("Cancel", None, self.doCancel, 0, ("T", 0, 4), ("T", 0, 1)), ("Quit", None, self.doExit, 1, None, None)] if "args" in self.opts: for f in (0, 2, 3): if f == 3: fld[f][4] += "(noesc)" else: fld[f][7] = None fld[f][8] = None fld[f][9] = None del but[0] tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) if "args" in self.opts: foc = False else: foc = True self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt, focus=foc) if "args" in self.opts: self.df.loadEntry("T", 0, 0, data=self.opts["args"][0]) self.doAccNum("T", 0, 0, 1, 0, 0, self.opts["args"][0]) self.df.loadEntry("T", 0, 2, data=0) self.doMemo("T", 0, 0, 3, 2, 2, 0) self.df.loadEntry("T", 0, 3, data=self.opts["args"][1][2]) self.df.focusField("T", 0, 4) def doAccNum(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" self.acno = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doSameField(self, frt, pag, r, c, p, i, w): self.df.loadEntry("T", 0, self.df.pos, data=w[0]) self.df.focusField("T", 0, self.df.col) def doMemo(self, frt, pag, r, c, p, i, w): if not w: w = self.sql.getRec("genrcc", cols=["max(grc_memo)"], where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno)], limit=1) if not w or not w[0]: self.memo = 1 else: self.memo = w[0] + 1 self.df.loadEntry(frt, pag, p, data=self.memo) else: self.memo = w self.old = self.sql.getRec("genrcc", where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno), ("grc_memo", "=", self.memo)], limit=1) if not self.old: self.new = "y" else: self.new = "n" col = self.sql.genrcc_col self.desc1 = self.old[col.index("grc_desc1")] self.desc2 = self.old[col.index("grc_desc2")] self.desc3 = self.old[col.index("grc_desc3")] self.opts["rtn"] = self.old[col.index("grc_rtn")] self.acoy = self.old[col.index("grc_acoy")] self.aacc = self.old[col.index("grc_aacc")] self.acrs = self.old[col.index("grc_acrs")] self.achn = self.old[col.index("grc_achn")] self.aage = self.old[col.index("grc_aage")] self.adrs = self.old[col.index("grc_adrs")] self.vat = self.old[col.index("grc_vat")] self.df.loadEntry(frt, pag, 3, data=self.desc1) self.df.loadEntry(frt, pag, 4, data=self.desc2) self.df.loadEntry(frt, pag, 5, data=self.desc3) self.df.loadEntry(frt, pag, 6, data=self.opts["rtn"]) self.df.loadEntry(frt, pag, 7, data=self.acoy) self.df.loadEntry(frt, pag, 8, data=self.getCoyName()) self.df.loadEntry(frt, pag, 9, data=self.aacc) self.df.loadEntry(frt, pag, 10, data=self.getAccDesc()) # Creditor and Debtor Details if self.acrs: self.crsdrs = "crs" self.df.loadEntry(frt, pag, 11, data=0) self.df.loadEntry(frt, pag, 12, data="") self.df.loadEntry(frt, pag, 13, data=self.acrs) self.df.loadEntry(frt, pag, 14, data=self.getCrsName()) self.df.loadEntry(frt, pag, 15, data=self.aage) elif self.adrs: self.crsdrs = "drs" self.df.loadEntry(frt, pag, 11, data=self.achn) if self.achn: self.df.loadEntry(frt, pag, 12, data=self.getChainName()) else: self.df.loadEntry(frt, pag, 12, data="") self.df.loadEntry(frt, pag, 13, data=self.adrs) self.df.loadEntry(frt, pag, 14, data=self.getDrsName()) self.df.loadEntry(frt, pag, 15, data=self.aage) else: self.crsdrs = None self.df.loadEntry(frt, pag, 11, data=0) self.df.loadEntry(frt, pag, 12, data="") self.df.loadEntry(frt, pag, 13, data="") self.df.loadEntry(frt, pag, 14, data="") self.df.loadEntry(frt, pag, 15, data="") # VAT Code self.df.loadEntry(frt, pag, 16, data=self.vat) def doDesc1(self, frt, pag, r, c, p, i, w): self.desc1 = w def doDesc2(self, frt, pag, r, c, p, i, w): self.desc2 = w if not self.desc2: self.desc3 = "" self.df.loadEntry(frt, pag, p + 1, data=self.desc3) if "args" in self.opts: if self.opts["args"][1][-1] < 0: self.opts["rtn"] = "P" else: self.opts["rtn"] = "R" self.df.loadEntry(frt, pag, p + 2, data=self.opts["rtn"]) return "sk2" return "sk1" def doDesc3(self, frt, pag, r, c, p, i, w): self.desc3 = w if "args" in self.opts: if self.opts["args"][1][-1] < 0: self.opts["rtn"] = "P" else: self.opts["rtn"] = "R" self.df.loadEntry(frt, pag, p + 1, data=self.opts["rtn"]) return "sk1" def doTypCod(self, frt, pag, r, c, p, i, w): self.opts["rtn"] = w if not self.incoac: self.acoy = self.opts["conum"] if self.doChkLoadCtls(): return "rf" else: self.df.loadEntry(frt, pag, p + 1, data=self.acoy) self.df.loadEntry(frt, pag, p + 2, data=self.getCoyName()) return "sk2" def doAllCoy(self, frt, pag, r, c, p, i, w): self.acoy = w name = self.getCoyName() if not name: return "Invalid Company Number" self.df.loadEntry(frt, pag, p + 1, data=name) return self.doChkLoadCtls() def doChkLoadCtls(self): # Check for Intercompany Records if self.acoy != self.opts["conum"]: acc = self.sql.getRec("genint", where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=", self.acoy)], limit=1) if not acc: return "Invalid Company, No Intercompany Record 1" acc = self.sql.getRec("genint", where=[("cti_cono", "=", self.acoy), ("cti_inco", "=", self.opts["conum"]) ], limit=1) if not acc: return "Invalid Company, No Intercompany Record 2" # Get Company Details ctlmst = self.gc.getCtl("ctlmst", self.acoy) if not ctlmst: return "rf" # Set Company VAT Default self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" # Check for Integrated Systems mod = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): mod.append(ctlmst["ctm_modules"][x:x + 2]) # Check for Control Records e.g. VAT and Discounts self.ctlctl = self.gc.getCtl("ctlctl", self.acoy) if not self.ctlctl: return "rf" ctls = ["vat_ctl"] # Load Crs Integration if mod.count("CR"): ctl = self.gc.getCtl("crsctl", self.acoy) if not ctl: return "rf" self.crs_gl = ctl["ctc_glint"] if self.crs_gl == "Y": ctls.extend(["crs_ctl", "dis_rec"]) else: self.crs_gl = "N" # Load Drs Integration and Chain Store Flag if mod.count("DR"): ctl = self.gc.getCtl("drsctl", self.acoy) if not ctl: return "rf" self.drs_gl = ctl["ctd_glint"] self.drs_ch = ctl["ctd_chain"] if self.drs_gl == "Y": ctls.extend(["drs_ctl", "dis_all"]) else: self.drs_gl = "N" if self.gc.chkRec(self.acoy, self.ctlctl, ctls): return "rf" def doAllAcc(self, frt, pag, r, c, p, i, w): if self.acoy == self.opts["conum"] and w == self.acno: return "This is the Bank Account Number" ctl = True self.crsdrs = False if self.crs_gl == "Y" and w == self.ctlctl["crs_ctl"]: self.crsdrs = "crs" self.df.topf[0][p + 4][8] = self.crm elif self.drs_gl == "Y" and w == self.ctlctl["drs_ctl"]: self.crsdrs = "drs" self.df.topf[0][p + 4][8] = self.drm if self.crsdrs: ctl = False chk = chkGenAcc(self.opts["mf"], self.acoy, w, ctl=ctl) if type(chk) is str: return chk self.aacc = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) if self.crsdrs: if self.crsdrs == "crs" or self.drs_ch == "N": self.achn = 0 self.df.topf[0][p + 2][1] = "OUI" self.df.loadEntry(frt, pag, p + 2, data=self.achn) self.df.loadEntry(frt, pag, p + 3, data="") return "sk3" elif self.crsdrs == "drs": self.df.topf[0][p + 2][1] = "IUI" return "sk1" else: self.acrs = "" self.achn = 0 self.adrs = "" self.aage = "" self.df.loadEntry(frt, pag, p + 2, data=0) self.df.loadEntry(frt, pag, p + 3, data="") self.df.loadEntry(frt, pag, p + 4, data="") self.df.loadEntry(frt, pag, p + 5, data="") self.df.loadEntry(frt, pag, p + 6, data="") if not self.df.t_work[pag][0][p + 7]: if chk[2]: self.df.loadEntry(frt, pag, p + 7, data=chk[2]) else: self.df.loadEntry(frt, pag, p + 7, data=self.taxdf) return "sk6" def doDrsChn(self, frt, pag, r, c, p, i, w): self.achn = w name = self.getChainName() if not name: return "Invalid Account Number" self.df.loadEntry(frt, pag, p + 1, data=name) def doCrsDrsAcc(self, frt, pag, r, c, p, i, w): if self.crsdrs == "crs": self.acrs = w name = self.getCrsName() else: self.adrs = w name = self.getDrsName() if not name: return "Invalid Account Number %s" % self.crsdrs.capitalize() if name[1] == "X": return "Invalid Account %s, Redundant" % self.crsdrs.capitalize() self.df.loadEntry(frt, pag, p + 1, data=name[0]) def doCrsDrsAge(self, frt, pag, r, c, p, i, w): self.aage = w self.vat = "N" self.df.loadEntry(frt, pag, p + 1, data=self.vat) return "sk1" def doVatCod(self, frt, pag, r, c, p, i, w): vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.acoy), ("vtm_code", "=", w)], limit=1) if not vat: return "Invalid VAT Code" self.vat = w def doDelete(self): self.sql.delRec("genrcc", where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno), ("grc_memo", "=", self.memo)]) def doEnd(self): data = [ self.opts["conum"], self.acno, self.memo, self.desc1, self.desc2, self.desc3, self.opts["rtn"], self.acoy, self.aacc ] if self.crsdrs: if self.crsdrs == "crs": data.extend([self.acrs, 0, "", self.aage, self.vat]) else: data.extend(["", self.achn, self.adrs, self.aage, self.vat]) else: data.extend(["", 0, "", "", self.vat]) if self.new == "y": self.sql.insRec("genrcc", data=data) elif data != self.old[:len(data)]: col = self.sql.genrcc_col data.append(self.old[col.index("grc_xflag")]) self.sql.updRec("genrcc", data=data, where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno), ("grc_memo", "=", self.memo)]) if "args" in self.opts: self.doExit() else: for x in range(2, self.df.topq[0]): self.df.loadEntry("T", 0, x, data="") self.df.focusField("T", 0, 3) def getCoyName(self): coy = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", self.acoy)], limit=1) if coy: return coy[0] def getAccDesc(self): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.acoy), ("glm_acno", "=", self.aacc)], limit=1) if acc: return acc[0] def getCrsName(self): acc = self.sql.getRec("crsmst", cols=["crm_name", "ctm_stat"], where=[("crm_cono", "=", self.acoy), ("crm_acno", "=", self.acrs)], limit=1) if acc: return acc def getChainName(self): acc = self.sql.getRec("drschn", cols=["chm_name"], where=[("chm_cono", "=", self.acoy), ("chm_chain", "=", self.achn)], limit=1) if acc: return acc[0] def getDrsName(self): acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"], where=[("drm_cono", "=", self.acoy), ("drm_chain", "=", self.achn), ("drm_acno", "=", self.adrs)], limit=1) if acc: return acc def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doExit(self): self.opts["mf"].dbm.commitDbase() self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class rtc210(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, ["chglog", "genmst", "rtlprm", "rtlmst"], 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.glint = rtlctl["ctr_glint"] return True def mainProcess(self): prm = { "stype": "R", "tables": ("rtlprm", ), "cols": (("rtp_code", "", 0, "Prm-Code"), ("rtp_desc", "", 0, "Description", "Y")), "where": [("rtp_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])], "order": "glm_acno" } self.fld = [(("T", 0, 0, 0), "INA", 7, "Premises Code", "Premises", "", "N", self.doPrmCod, prm, None, ("notblank", )), (("T", 0, 1, 0), "INA", 30, "Description", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N", None, None, None, ("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N", None, None, None, ("efld", )), (("T", 0, 5, 0), "INA", 4, "Postal Code", "PCod", "", "N", None, None, None, ("notblank", ))] if self.glint == "Y": self.fld.append( (("T", 0, 6, 0), "IUI", 7, "Rental Account", "", "", "N", self.doRental, glm, None, ("notzero", ), None, "Rental Control Account in the General Ledger.")) self.fld.append((("T", 0, 6, 0), "ONA", 30, "")) self.fld.append( (("T", 0, 7, 0), "IUI", 7, "Income Account", "", "", "N", self.doIncome, glm, None, ("notzero", ), None, "Rental Income Account in the General Ledger.")) self.fld.append((("T", 0, 7, 0), "ONA", 30, "")) but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None)) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doPrmCod(self, frt, pag, r, c, p, i, w): self.code = w self.old = self.sql.getRec("rtlprm", where=[("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", self.code)], limit=1) if not self.old: self.new = "y" else: self.new = "n" acc = copyList(self.old[:-1]) acc.append("") acc.insert(8, "") for x in range(0, self.df.topq[pag]): self.df.loadEntry(frt, pag, p + x, data=acc[x + 1]) if self.glint == "N": return des = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acc[7])], limit=1) if des: self.df.loadEntry("T", 0, 7, data=des[0]) des = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acc[9])], limit=1) if des: self.df.loadEntry("T", 0, 9, data=des[0]) def doRental(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) if not acc: return "Invalid G/L Account" self.df.loadEntry("T", 0, 7, data=acc[0]) def doIncome(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) if not acc: return "Invalid G/L Account" self.df.loadEntry("T", 0, 9, data=acc[0]) def doDelete(self): mst = self.sql.getRec("rtlmst", cols=["count(*)"], where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code", "=", self.code)], limit=1) if mst[0]: return "Accounts Exist, Not Deleted" self.sql.delRec("rtlprm", where=[("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", self.code)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=[ "rtlprm", "D", "%03i%-7s" % (self.opts["conum"], self.code), "", dte, self.opts["capnm"], "", "", "", 0 ]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): if self.glint == "Y" and x in (7, 9): continue data.append(self.df.t_work[0][0][x]) if self.glint == "N": data.extend([0, 0]) if self.new == "y": self.sql.insRec("rtlprm", data=data) elif data != self.old[:len(data)]: col = self.sql.rtlprm_col data.append(self.old[col.index("rtp_xflag")]) self.sql.updRec("rtlprm", data=data, where=[("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", self.code)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old): if dat != data[num]: self.sql.insRec( "chglog", data=[ "rtlprm", "U", "%03i%-7s" % (self.opts["conum"], self.code), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doAccept(self): frt, pag, col, mes = self.df.doCheckFields() if mes: self.df.focusField(frt, pag, (col + 1), err=mes) else: self.df.doEndFrame("T", 0, cnf="N") def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bk3020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.sper = int(self.opts["period"][1][0] / 100) self.eper = int(self.opts["period"][2][0] / 100) self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Bookings Manager Audit Trail (%s)" % self.__class__.__name__) self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "bkmmst", "bkmtrn", "bkmcon"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) bkmctl = gc.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] 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 = [ "TP", "BatchNo", "Book-Num", "Name", "Reference", "Date", "Debits", "Credits", "Tax-Amount", "T", "Remarks" ] self.forms = [("UI", 2, False, False, True), ("Na", 7), ("NA", 8, False, False, True), ("NA", 30), ("Na", 9), ("D1", 10), ("SD", 13.2), ("SD", 13.2), ("SD", 13.2), ("UA", 1), ("NA", 30)] self.gqt = [0] * (len(bktrtp) + 1) self.gdr = [0] * (len(bktrtp) + 1) self.gcr = [0] * (len(bktrtp) + 1) self.gvt = [0] * (len(bktrtp) + 1) self.totind = "N" return True def mainProcess(self): data = ["All Types"] for typ in bktrtp: data.append(typ[1]) btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"} btm = { "stype": "R", "tables": ("bkmtrn", ), "cols": (("bkt_batch", "", 0, "Bat-Num"), ("bkt_type", ("xx", bktrtp), 20, "Type"), ("bkt_curdt", "", 0, "Cur-Dat")), "where": [], "group": "bkt_batch, bkt_type, bkt_curdt", "order": "bkt_type, bkt_curdt, bkt_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.sper, "Y", self.doStartPer, None, None, ("efld", )), (("T", 0, 2, 0), "Id2", 7, "Ending Period", "", self.eper, "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.sper elif w < self.sper or w > self.eper: 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.eper elif w < self.sperw or w > self.eper: 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(bktrtp): return "Invalid Batch Type" self.btyp = w self.whr = [("bkt_cono", "=", self.opts["conum"])] if self.ptyp == "F": self.whr.append(("bkt_curdt", "between", self.sperw, self.eperw)) else: self.whr.append(("bkt_capdt", "between", self.sdatw, self.edatw)) if self.btyp: self.whr.append(("bkt_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 if self.batch: self.whr.append(("bkt_batch", "=", self.batch)) def doTots(self, frt, pag, r, c, p, i, w): self.totsonly = w mx = len(self.df.topEntry[0][8]) if self.totsonly == "Y": if mx > 3: self.df.setWidget(self.df.topEntry[0][8][3][0], state="hide") if mx > 4: self.df.setWidget(self.df.topEntry[0][8][4][0], state="hide") else: if mx > 3: self.df.setWidget(self.df.topEntry[0][8][3][0], state="show") if mx > 4: self.df.setWidget(self.df.topEntry[0][8][4][0], state="show") def doEnd(self): self.df.closeProcess() recs = self.getRecords() if recs: if self.df.repprt[2] == "export": self.exportReport(recs) else: self.printReport(recs) self.closeProcess() def getRecords(self): col = [ "bkt_number", "bkt_date", "bkt_type", "bkt_refno", "bkt_batch", "bkt_tramt", "bkt_taxamt", "bkt_desc", "bkt_taxind", "bkc_sname", "bkc_names" ] self.whr.extend([("bkm_cono=bkt_cono", ), ("bkm_number=bkt_number", ), ("bkc_cono=bkt_cono", ), ("bkc_ccode=bkm_ccode", )]) odr = "bkt_type, bkt_batch, bkt_date, bkt_refno" recs = self.sql.getRec(tables=["bkmtrn", "bkmmst", "bkmcon"], cols=col, where=self.whr, order=odr) if not recs: showError(self.opts["mf"].body, "Transaction Error", "No Transactions Selected") else: return recs 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("Bookings Manager 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 bkmno, trdt, trtp, refno, batch, debit, credit, taxamt, \ detail, taxind, name = self.getValues(dat) line = [ "BODY", [ trtp.work, batch.work, bkmno.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 bkmno, trdt, trtp, refno, batch, debit, credit, taxamt, \ detail, taxind, name = self.getValues(dat) 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" % (bkmno.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): bkmno = CCD(data[0], "UI", 7) trdt = CCD(data[1], "D1", 10) trtp = CCD(data[2], "UI", 2) refno = CCD(data[3], "Na", 9) batch = CCD(data[4], "Na", 7) if data[5] < 0: debit = CCD(0, "SD", 13.2) credit = CCD(data[5], "SD", 13.2) else: debit = CCD(data[5], "SD", 13.2) credit = CCD(0, "SD", 13.2) taxamt = CCD(data[6], "SD", 13.2) detail = CCD(data[7], "NA", 30) taxind = CCD(data[8], "NA", 1) name = CCD("%s, %s" % (data[9], data[10]), "NA", 30) 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 (bkmno, 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() if self.totsonly == "Y": self.fpdf.drawText("%-38s %-7s %2s %-40s" % \ ("Bookings Manager Audit Trail for Period", self.sperd, "to", self.eperd)) else: self.fpdf.drawText("%-38s %-7s %2s %-86s" % \ ("Bookings Manager 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("%-33s%-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", bktrtp[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 %-30s %-9s %-10s %-13s %-13s %-13s "\ "%-1s %-30s" % ("Booking", "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("%-7s %-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("%-7s %-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, t in enumerate(bktrtp): 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(bktrtp): 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("%-33s %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("%-33s %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 rt2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): tabs = [ "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint", "genmst", "gentrn", "rtlprm", "rtlmst", "rtlcon", "rtltrn" ] self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return if self.opts["rtn"] not in (2, 3, 4): mes = "Invalid Routine %s" % str(self.opts["rtn"]) showError(self.opts["mf"].body, "Control Error", mes) return self.gc = GetCtl(self.opts["mf"]) rtlctl = self.gc.getCtl("rtlctl", self.opts["conum"]) if not rtlctl: return self.glint = rtlctl["ctr_glint"] if self.glint == "Y": # Check All Premises Control Records errs = ("Premises %s Has An Invalid", "Rental Control Account (%s)", "Rental Income Account (%s)") ass = self.sql.getRec( "rtlprm", cols=["rtp_code", "rtp_rtlacc", "rtp_incacc"], where=[("rtp_cono", "=", self.opts["conum"])]) for acc in ass: for x in range(1, 3): chk = self.sql.getRec("genmst", where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acc[x])], limit=1) if not chk: mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x]) showError(self.opts["mf"].body, "Control Error", mess) return # Check for VAT Control ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]): return self.convat = ctlctl["vat_ctl"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "RTL", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return if self.opts["rtn"] == 2: self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) return True def drawDialog(self): prm = { "stype": "R", "tables": ("rtlprm", ), "cols": (("rtp_code", "", 0, "Prm-Cod"), ("rtp_desc", "", 0, "Description", "Y")), "where": [("rtp_cono", "=", self.opts["conum"])] } mst = { "stype": "R", "tables": ("rtlmst", ), "cols": (("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")), "where": [("rtm_cono", "=", self.opts["conum"])], "whera": [["C", "rtm_code", 0, 1]] } con = { "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": [["C", "rtc_code", 0, 1], ["C", "rtc_acno", 1, 1]] } vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "INA", 7, "Prm-Cod", "Premises Code", "r", "N", self.doPrmCod, prm, None, None), (("C", 1, 0, 1), "INA", 7, "Acc-Num", "Account Number", "r", "N", self.doAccNum, mst, None, None), (("C", 1, 0, 2), "IUI", 3, "Seq", "Contract Sequence", "", "N", self.doConSeq, con, None, None), (("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number", "i", "N", self.doTrnRef, None, None, ("notblank", )), (("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 5), "ISD", 13.2, "Amount", "Transaction Amount", "", "N", self.doTrnAmt, None, None, None), (("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", "", "N", self.doVatCod, vtm, None, ("notblank", )), (("C", 1, 0, 7), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N", self.doVatAmt, None, None, None), [("C", 1, 0, 8), "INA", 30, "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None]] if self.opts["rtn"] not in (2, 3) and self.glint == "Y": fld[10][2] = (22, 30) fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"], (("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doGenAcc, glm, None, None), (("C", 2, 0, 1), "ONA", 30, "Description"), (("C", 2, 0, 2), "ISD", 13.2, "All-Amt", "Allocation Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 3), "INA", 30, "Details", "", "", "N", self.doAllDet, None, None, ("notblank", ))]) but = (("Interrogate", None, self.queryRtl, 0, ("C", 1, 1), ("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1))) tag = [("Transaction", None, None, None, False)] cnd = [(None, "n"), (self.endPage1, "y")] cxt = [None, self.exitPage1] if self.opts["rtn"] not in (2, 3) and self.glint == "Y": tag.append(("Allocation", None, None, None, False)) cnd.append((self.endPage2, "y")) cxt.append(self.exitPage2) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doPrmCod(self, frt, pag, r, c, p, i, w): whr = [("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", w)] acc = self.sql.getRec("rtlprm", where=whr, limit=1) if not acc: return "Invalid Premises Code" self.code = w self.rtlacc = acc[self.sql.rtlprm_col.index("rtp_rtlacc")] def doAccNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlmst", cols=["rtm_name", "rtm_vatind"], where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code", "=", self.code), ("rtm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" self.acno = w 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 "No Valid Contracts" self.cnum = con[-1:][0][3] self.df.colf[1][2][5] = self.cnum if self.opts["rtn"] == 4: self.df.colf[1][6][5] = acc[1] else: self.df.colf[1][6][5] = "N" def doConSeq(self, frt, pag, r, c, p, i, w): con = self.sql.getRec("rtlcon", where=[("rtc_cono", "=", self.opts["conum"]), ("rtc_code", "=", self.code), ("rtc_acno", "=", self.acno), ("rtc_cnum", "=", w)], order="rtc_cnum") if not con: return "Invalid Contract Sequence" self.cnum = w def doTrnRef(self, frt, pag, r, c, p, i, w): self.trnref = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w if self.opts["rtn"] in (2, 3): self.vatcode = "" self.trnvat = 0 return "sk2" def doVatCod(self, frt, pag, r, c, p, i, w): vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if vrte is None: return "Invalid V.A.T Code" self.vatcode = w self.trnvat = round((self.trnamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p + 1, data=self.trnvat) if not self.trnvat: return "sk1" def doVatAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.trnvat = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.trnvat = float(ASD(0) - ASD(w)) else: self.trnvat = w self.df.loadEntry(frt, pag, p, data=self.trnvat) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.opts["rtn"] not in (2, 3) and self.glint == "Y": self.df.colf[2][3][5] = w def endPage1(self): self.batupd = False self.updateTables1() self.updateBatch() if self.trnamt == 0: self.df.advanceLine(1) else: self.allocated = float(0.0) if self.opts["rtn"] in (2, 3) or self.glint == "N": self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.trnamt = float(ASD(self.trnamt) - ASD(self.trnvat)) self.df.loadEntry("T", 2, 0, data=self.trnamt) self.df.selPage("Allocation") self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt self.amt = self.trnamt self.vat = self.trnvat if self.opts["rtn"] == 2: # Receipts if self.trnamt == 0: self.recon = self.curdt else: self.recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.vat = float(ASD(0) - ASD(self.vat)) self.glt = 6 elif self.opts["rtn"] == 3: # Payments if self.trnamt == 0: self.recon = self.curdt else: self.recon = 0 self.glt = 2 elif self.opts["rtn"] == 4: # Journal Entries self.recon = 0 self.glt = 4 # Rental Ledger Transaction data = [ self.opts["conum"], self.code, self.acno, self.cnum, self.opts["rtn"], self.trnref, self.bh.batno, self.trndat, self.amt, self.vat, self.curdt, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("rtltrn", data=data) if self.vatcode: # VAT Transaction (ctlvtf) exc = float(ASD(0) - ASD(self.amt) + ASD(self.vat)) vat = float(ASD(0) - ASD(self.vat)) data = (self.opts["conum"], self.vatcode, "O", self.curdt, "R", self.opts["rtn"], self.bh.batno, self.trnref, self.trndat, self.code, self.trndet, exc, vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return # General Ledger Rental Account data = (self.opts["conum"], self.rtlacc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.amt, self.vat, self.trndet, self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) self.trnamt = float(ASD(0) - ASD(self.amt)) self.trnvat = float(ASD(0) - ASD(self.vat)) if self.vatcode and self.trnvat: # General Ledger Control Transaction (V.A.T.) data = (self.opts["conum"], self.convat, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.trnvat, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.opts["rtn"] in (2, 3): # General Ledger Control Transaction (Bank) data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.trnamt, 0.00, self.trndet, "N", "", self.recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doGenAcc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w) if type(chk) is str: return chk self.genacc = w self.df.loadEntry("C", pag, p + 1, data=chk[0]) def doAllAmt(self, frt, pag, r, c, p, i, w): if w == 0: self.allamt = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.allamt = w def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): ok = askQuestion(self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) self.df.clearFrame("C", 2) self.df.selPage("Transaction") row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.focusField("C", 1, col) def endPage2(self): self.updateTables2() self.allocated = float(ASD(self.allocated) + ASD(self.allamt)) if self.allocated == self.trnamt: self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt # General Ledger Transaction (Source) data = (self.opts["conum"], self.genacc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.allamt, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def updateBatch(self, rev=False): if rev: self.bh.batqty = self.bh.batqty - 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.batupd = True self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def queryRtl(self): callModule(self.opts["mf"], self.df, "rt4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class bk3070(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): if "args" in self.opts: self.doEnd() else: self.mainProcess() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) bkmctl = gc.getCtl("bkmctl", self.opts["conum"]) if not bkmctl: return self.stpl = bkmctl["cbk_statpl"] self.fromad = bkmctl["cbk_emadd"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.sysdtd = CCD(self.sysdtw, "D1", 10).disp self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "bkmcon", "bkmmst", "bkmtrn", "tplmst"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title", "Y")), "where": [("tpm_type", "=", "S"), ("tpm_system", "=", "BKM")], "order": "tpm_tname" } bkm = { "stype": "R", "tables": ("bkmmst", "bkmcon"), "cols": (("bkm_number", "", 0, "Booking"), ("bkc_sname", "", 0, "Surname", "Y"), ("bkc_names", "", 0, "Names", "F")), "where": (("bkm_cono", "=", self.opts["conum"]), ("bkm_state", "<>", "X"), ("bkc_cono=bkm_cono", ), ("bkc_ccode=bkm_ccode", )) } r1s = (("Yes", "Y"), ("Range", "R"), ("Singles", "S")) r2s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.stpl, "Y", self.doTplNam, tpm, None, None), (("T", 0, 1, 0), ("IRB", r1s), 0, "Whole File", "", "Y", "N", self.doWhole, None, None, None), (("T", 0, 2, 0), "IUI", 7, "From Booking", "", "", "N", self.doAcc, bkm, None, None), (("T", 0, 3, 0), "IUI", 7, "To Booking", "", "", "N", self.doAcc, bkm, None, None), (("T", 0, 4, 0), ("IRB", r2s), 0, "Include Cancellations", "", "Y", "N", self.doCancel, 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 doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "S"), ("tpm_system", "=", "BKM")], limit=1) if not acc: return "Invalid Template Name" self.tname = w def doWhole(self, frt, pag, r, c, p, i, w): self.whole = w if self.whole in ("Y", "S"): self.snum = 0 self.enum = 0 self.df.loadEntry("T", 0, p + 1, data="") self.df.loadEntry("T", 0, p + 2, data="") return "sk2" def doAcc(self, frt, pag, r, c, p, i, w): if p == 2: self.snum = w else: self.enum = w chk = self.sql.getRec("bkmmst", where=[("bkm_cono", "=", self.opts["conum"]), ("bkm_number", "=", w)], limit=1) if not chk: return "Invalid Booking Number" if p == 2: self.df.loadEntry(frt, pag, p + 1, data=self.snum) def doCancel(self, frt, pag, r, c, p, i, w): self.cancel = w def doEnd(self): if "args" in self.opts: self.cancel = "Y" self.tname = self.stpl self.whole = "A" self.snum = 0 self.enum = 0 if len(self.opts["args"]) == 1: self.repprt = ["N", "V", "view"] self.repeml = ["N", "N", "", "", "Y"] else: self.repprt = self.opts["args"][1] self.repeml = self.opts["args"][2] else: self.df.closeProcess() self.repprt = self.df.repprt self.repeml = self.df.repeml if not self.enum: self.enum = 9999999 self.emadd = self.repeml[2] tab = ["bkmmst"] whr = [("bkm_cono", "=", self.opts["conum"])] if self.cancel == "N": whr.append(("bkm_state", "<>", "X")) odr = "bkm_number" if self.whole == "A": if type(self.opts["args"][0]) == int: whr.append(("bkm_number", "=", self.opts["args"][0])) else: whr.append(("bkm_number", "in", self.opts["args"][0])) recs = self.sql.getRec("bkmmst", where=whr, order=odr) elif self.whole == "S": tab.append("bkmcon") col = ["bkm_number", "bkc_sname", "bkc_names"] whr.extend([("bkc_cono=bkm_cono", ), ("bkc_ccode=bkm_ccode", )]) dic = {} for c in col: for t in tab: d = getattr(self.sql, "%s_dic" % t) if c in d: dic[c] = d[c] data = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr) data = getSingleRecords(self.opts["mf"], tab, col, dic=dic, where=data, ttype="D") recs = [] for dat in data: acc = self.sql.getRec("bkmmst", where=[("bkm_cono", "=", self.opts["conum"]), ("bkm_number", "=", dat[0])]) recs.append(acc[0]) else: if self.whole == "R": whr.extend([("bkm_number", ">=", self.snum), ("bkm_number", "<=", self.enum)]) recs = self.sql.getRec("bkmmst", where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Error", "No Bookings Selected") else: self.form = DrawForm(self.opts["mf"].dbm, self.tname, wrkdir=self.opts["mf"].rcdic["wrkdir"]) self.doLoadStatic() self.form.doNewDetail() p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) for num, rec in enumerate(recs): p.displayProgress(num) if p.quit: break self.doProcess(rec) p.closeProgress() if p.quit or not self.form.page: pass elif self.repeml[1] == "N" or self.emadd: self.repeml[2] = self.emadd self.doPrint() if "wait" not in self.opts: self.opts["mf"].closeLoop() def doLoadStatic(self): cmc = self.sql.ctlmst_col ctm = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"])], limit=1) for fld in cmc: dat = ctm[cmc.index(fld)] if fld in self.form.tptp: if fld == "ctm_logo": self.form.letterhead(cmc, ctm, fld, dat) continue self.form.tptp[fld][1] = dat if "letterhead" in self.form.tptp: self.form.letterhead(cmc, ctm, "letterhead", None) self.form.document_date(self.sysdtd) self.form.bank_details(cmc, ctm, 0) def doProcess(self, bkm): bmc = self.sql.bkmmst_col ccc = self.sql.bkmcon_col btc = self.sql.bkmtrn_col tdc = self.form.sql.tpldet_col self.num = bkm[bmc.index("bkm_number")] self.cod = bkm[bmc.index("bkm_ccode")] con = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", self.cod)], limit=1) eml = con[self.sql.bkmcon_col.index("bkc_email")] if "contact_details" in self.form.tptp: dat = "%s %s %s" % (con[ccc.index("bkc_title")], con[ccc.index("bkc_names")], con[ccc.index("bkc_sname")]) if bkm[bmc.index("bkm_group")]: dat = "%s\n%s" % (dat, bkm[bmc.index("bkm_group")][:40]) for fld in ("addr1", "addr2", "addr3", "pcode"): dat = "%1s\n%s" % (dat, con[ccc.index("bkc_%s" % fld)]) self.form.newdic["contact_details_C00"][tdc.index( "tpd_text")] = dat for col in bmc: d = "%s_C00" % col if d in self.form.newdic: dat = bkm[bmc.index(col)] self.form.newdic[d][tdc.index("tpd_text")] = dat bkt = self.sql.getRec("bkmtrn", where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number", "=", self.num)], order="bkt_date, bkt_refno") if not bkt: return self.doBody(btc, bkt, tdc) self.doTotal(tdc) self.doTail() if self.repeml[1] == "Y" and not self.emadd: self.repeml[2] = eml self.doPrint() def doPrint(self): if self.repeml[1] == "Y" and not self.emadd: key = "%s_%s" % (self.opts["conum"], self.num) else: key = "%s_all" % self.opts["conum"] pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, key, ext="pdf") self.form.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header="%s Statement at %s" % (self.opts["conam"], self.sysdtd), repprt=self.repprt, fromad=self.fromad, repeml=self.repeml) if self.repeml[1] == "Y": self.form = DrawForm(self.opts["mf"].dbm, self.tname, wrkdir=self.opts["mf"].rcdic["wrkdir"]) self.doLoadStatic() self.form.doNewDetail() def doBody(self, btc, bkt, tdc): page = 0 count = 0 self.tbal = 0 for trans in bkt: if not count: page += 1 count = self.doHeader(page) if count == self.form.maxlines: page = self.doCfwd(page) count = self.doHeader(page) ldic = {} for cod in self.form.body: if cod in ("type_code", "line_paid", "line_balance"): continue if cod == "bkt_desc": des = self.form.doSplitText("bkt_desc_C00", trans[btc.index(cod)]) if len(des) > 1 and not des[-1]: del des[-1] else: ldic[cod] = CCD(trans[btc.index(cod)], self.form.tptp[cod][0][1], self.form.tptp[cod][0][2]) ldic["line_paid"] = 0 ldic["line_balance"] = ldic["bkt_tramt"].work self.tbal = float(ASD(self.tbal) + ASD(ldic["bkt_tramt"].work)) for n, l in enumerate(des): if count == self.form.maxlines: page = self.doCfwd(page) count = self.doHeader(page) if n == 0 and len(des) == 1: include = copyList(self.form.body) elif n == 0: include = ("bkt_date", "bkt_refno", "type_code") elif n + 1 == len(des): include = copyList(self.form.body) include.remove("bkt_date") include.remove("bkt_refno") include.remove("type_code") else: include = [] for code in self.form.body: seq = "%s_C%02i" % (code, count) if code == "bkt_desc": data = l elif code in include: if code == "type_code": data = bktrtp[trans[btc.index("bkt_type")] - 1][0] else: data = ldic[code].work else: data = "BLANK" self.form.newdic[seq][tdc.index("tpd_text")] = data self.form.doDrawDetail(self.form.newdic[seq]) count += 1 for x in range(count, self.form.maxlines): for cod in self.form.body: d = "%s_C%02i" % (cod, x) self.form.newdic[d][tdc.index("tpd_text")] = "BLANK" self.form.doDrawDetail(self.form.newdic[d]) def doHeader(self, page): self.form.add_page() tdc = self.form.sql.tpldet_col for key in self.form.newkey: nl = copyList(self.form.newdic[key]) if nl[tdc.index("tpd_place")] != "A": continue if nl[tdc.index("tpd_detseq")] == "bkm_number_C00": nl[tdc.index("tpd_text")] = self.num elif nl[tdc.index("tpd_detseq")] == "page_number_C00": nl[tdc.index("tpd_text")] = str(page) self.form.doDrawDetail(nl) return 0 def doCfwd(self, page): if "carried_forward" in self.form.tptp: tdc = self.form.sql.tpldet_col line = copyList(self.form.cfwd) line[tdc.index("tpd_text")] = "Continued on Page %i" % (page + 1) self.form.doDrawDetail(line) return page + 1 def doTotal(self, tdc): for c in self.form.total: if c != "total_balance": continue t = "%s_T00" % c if c in self.form.newdic: self.form.doDrawDetail(self.form.newdic[c]) elif t in self.form.newdic: self.form.doDrawDetail(self.form.newdic[t]) d = "%s_C00" % c if d in self.form.newdic: line = self.form.newdic[d] line[tdc.index("tpd_text")] = self.tbal self.form.doDrawDetail(line) def doTail(self): for c in self.form.tail: t = "%s_T00" % c if c in self.form.newdic: self.form.doDrawDetail(self.form.newdic[c]) elif t in self.form.newdic: self.form.doDrawDetail(self.form.newdic[t]) d = "%s_C00" % c if d in self.form.newdic: self.form.doDrawDetail(self.form.newdic[d]) def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()