class gl1050(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.doProcess() self.opts["mf"].startLoop() def setVariables(self): # Check for control record and departments gc = GetCtl(self.opts["mf"]) ctlsys = gc.getCtl("ctlsys") if not ctlsys: return # Check for multiple companies self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genrpc", "genstr", "gendtm", "genrpt"], prog=self.__class__.__name__) if self.sql.error: return acc = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1) if acc[0] > 1: self.coys = True else: self.coys = False self.strm = 0 return True def doProcess(self): st1 = { "stype": "R", "tables": ("genstr",), "cols": ( ("gls_strm", "", 0, "Str"), ("gls_desc", "", 0, "Description", "Y")), "where": [("gls_cono", "=", self.opts["conum"])], "group": "gls_strm, gls_desc"} st2 = { "stype": "R", "tables": ("genstr",), "cols": ( ("gls_seq", "", 0, "Seq"), ("gls_typ", "", 0, "T"), ("gls_cno", "", 0, "CN"), ("gls_con", "", 0, "C"), ("gls_rep", "", 0, "Rep"), ("gls_gen", "", 0, "G"), ("gls_val", "", 0, "V"), ("gls_det", "", 0, "Det"), ("gls_var", "", 0, "B"), ("gls_zer", "", 0, "Z"), ("gls_opt", "", 0, "O"), ("gls_num", "", 0, "N"), ("gls_prnt", "", 20, "Printer-Name"), ("gls_mail", "", 20, "E-Mail-Address")), "where": [("gls_cono", "=", self.opts["conum"])], "whera": (("T", "gls_strm", 0, 0),), "comnd": self.doSelTyp} typ = { "stype": "C", "title": "Available Types", "head": ("C", "Description"), "data": ( ("S", "YTD Report"), ("H", "Last 3 Years YTD Report"), ("L", "MTD and YTD Report"), ("M", "Monthly Report"), ("C", "Customised Report"))} rpc = { "stype": "R", "tables": ("genrpc",), "cols": ( ("glc_cusno", "", 0, "CN"), ("glc_head1", "", 0, "Heading-1"), ("glc_head2", "", 0, "Heading-2"), ("glc_head3", "", 0, "Heading-3"), ("glc_head4", "", 0, "Heading-4")), "where": [("glc_cono", "=", self.opts["conum"])]} rpt = { "stype": "R", "tables": ("genrpt",), "cols": ( ("glr_cono", "", 0, "Coy"), ("glr_repno", "", 0, "Rep"), ("glr_type", "", 0, "T"), ("glr_desc", "", 0, "Description", "Y")), "where": [("(", "glr_cono", "=", 0, "or", "glr_cono", "=", self.opts["conum"], ")"), ("glr_seq", "=", 0)], "group": "glr_cono, glr_repno, glr_type, glr_desc", "index": 1} con = { "stype": "C", "title": "Available Options", "head": ("C", "Description"), "data": ( ("V", "Actuals"), ("B", "Budgets"), ("C", "Actuals and Budgets"), ("X", "Variance to Budget"), ("D", "Detail"))} det = { "stype": "R", "tables": ("gendtm",), "cols": ( ("gdm_code", "", 0, "Cod"), ("gdm_desc", "", 0, "Description")), "where": [("gdm_cono", "=", self.opts["conum"])]} prts = getPrinters(wrkdir=self.opts["mf"].rcdic["wrkdir"]) prts.insert(1, "Export") if "None" not in prts: prts.append("None") prt = { "stype": "C", "titl": "Select Required Printer", "head": ("Name", "Description"), "data": prts} cts = ("V", "B", "C", "X", "D") fld = ( (("T",0,0,0),"IUI",3,"Stream-Number","Stream Number", 0,"Y",self.doStr,st1,None,("notzero",)), (("T",0,0,0),"INA",30,"Description","", "","N",self.doDsc,None,self.doDelStr,("notblank",)), (("C",0,0,0),"IUI",3,"Seq","Sequence Number", "i","N",self.doSeq,st2,None,("efld",)), (("C",0,0,1),"IUA",1,"T","Report Type", "S","N",self.doTyp,typ,self.doDelLin, ("in",("S","H","L","M","C"))), (("C",0,0,2),"IUI",2,"CN","Custom Number", 0,"N",self.doCus,rpc,None,("efld",)), (("C",0,0,3),"IUA",1,"C","Consolidate (Y/N)", "N","N",self.doCon,None,None,("in",("Y","N"))), (("C",0,0,4),"IUI",3,"Rep","Report Number", 0,"N",self.doRep,rpt,None,("notzero",)), (("C",0,0,5),"IUA",1,"G","General Report (Y/N)", "N","N",self.doGen,None,None,("in",("Y","N"))), (("C",0,0,6),"IUA",1,"V","Report Contents", "V","N",self.doContent,con,None,("in",cts)), (("C",0,0,7),"INa",2,"Cod","Details Code", "","N",self.doCod,det,None,None), (("C",0,0,8),"IUA",1,"V","Variance (B/P/N)", "B","N",self.doVar,None,None,("in",("B","P","N"))), (("C",0,0,9),"IUA",1,"Z","Ignore Zeros (Y/N)", "Y","N",None,None,None,("in",("Y","N"))), (("C",0,0,10),"IUA",1,"O","Print Options (Y/N)", "N","N",None,None,None,("in",("Y","N"))), (("C",0,0,11),"IUA",1,"N","Print Numbers (Y/N)", "N","N",None,None,None,("in",("Y","N"))), (("C",0,0,12),"ITX",30,"Printer Name","Printer-Name", "Default","N",self.doPrt,prt,None,("in",prts)), (("C",0,0,13),"ITX",30,"E-Mail Address","E-Mail-Address", "","N",None,None,None,("email",))) but = ( ("Cancel",None,self.doCancel,0,("C",0,1),("T",0,1)), ("Quit",None,self.exitTops,1,None,None)) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=((self.endTops,"n"),), txit=(self.exitTops,), cend=((self.endData,"y"),), cxit=(self.exitData,), butt=but) self.df.focusField("T", 0, 1) def doStr(self, frt, pag, r, c, p, i, w): self.strm = w self.old = self.sql.getRec("genstr", where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm)], limit=1) if not self.old: self.new = "y" else: self.new = "n" self.desc = self.old[self.sql.genstr_col.index("gls_desc")] self.df.loadEntry(frt, pag, p+1, self.desc) def doDelStr(self): if self.new == "y": return self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm)]) def doDsc(self, frt, pag, r, c, p, i, w): self.desc = w def doSeq(self, frt, pag, r, c, p, i, w): self.seq = w dt = self.sql.getRec("genstr", where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm), ("gls_seq", "=", self.seq)], limit=1) if not dt: self.newlin = "y" else: self.newlin = "n" for n, d in enumerate(dt[3:-1]): self.df.loadEntry(frt, pag, p+n, data=d) def doTyp(self, frt, pag, r, c, p, i, w): self.typ = w if self.typ != "C": self.cno = 0 if not self.coys: self.con = "N" self.df.loadEntry(frt, pag, p+2, data="N") return "sk2" return "sk1" def doCus(self, frt, pag, r, c, p, i, w): cn = self.sql.getRec("genrpc", where=[("glc_cono", "=", self.opts["conum"]), ("glc_cusno", "=", w)], limit=1) if not cn: return "Invalid Custom Report Number" self.cno = w if not self.coys: self.con = "N" self.df.loadEntry(frt, pag, p+1, data="N") return "sk1" def doCon(self, frt, pag, r, c, p, i, w): self.con = w def doRep(self, frt, pag, r, c, p, i, w): rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"], where=[("(", "glr_cono", "=", 0, "or", "glr_cono", "=", self.opts["conum"], ")"), ("glr_repno", "=", w)], limit=1) if not rp: return "No Such Report" self.rep = w def doGen(self, frt, pag, r, c, p, i, w): if w == "Y": c = 0 else: c = self.opts["conum"] rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"], where=[("glr_cono", "=", c), ("glr_repno", "=", self.rep)], limit=1) if not rp: return "No Such Report" self.gen = w def doContent(self, frt, pag, r, c, p, i, w): if w in ("B", "C", "X") and self.typ in ("S", "L", "C"): return "Invalid Choice for this Report Type" if w == "D": return self.df.loadEntry(frt, pag, p+1, data="") return "sk1" def doCod(self, frt, pag, r, c, p, i, w): d = self.sql.getRec("gendtm", cols=["gdm_desc"], where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=", w)], limit=1) if not d: return "Invalid Detail Code" def doVar(self, frt, pag, r, c, p, i, w): if self.typ == "C" and w not in ("B", "P"): return "Invalid Variance, Only B or P" def doPrt(self, frt, pag, r, c, p, i, w): if w == "Export": self.df.loadEntry(frt, pag, p+1, data="") return "sk1" def endTops(self): if self.new == "y": self.df.focusField("C", 0, 1) else: self.doLoadLines() def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def exitTops(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doSelTyp(self, frt, pag, r, c, p, i, w): self.newlin = "n" self.seq = w[0] self.typ = w[1] self.cno = w[2] self.con = w[3] self.rep = w[4] self.gen = w[5] for x, d in enumerate(w): self.df.loadEntry(frt, pag, p+x, data=d) self.df.focusField(frt, pag, c+1) def doDelLin(self): if self.newlin == "y": return self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm), ("gls_seq", "=", self.seq)]) self.doReSeq() def endData(self): data = [self.opts["conum"], self.strm, self.desc, self.seq, self.typ, self.cno, self.con, self.rep, self.gen] for x in range(6, 14): data.append(self.df.c_work[self.df.pag][self.df.row][x]) if self.newlin == "y": self.sql.insRec("genstr", data=data) elif data != self.old[:len(data)]: col = self.sql.genstr_col data.append(self.old[col.index("gls_xflag")]) self.sql.updRec("genstr", data=data, where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm), ("gls_seq", "=", self.seq)]) self.doLoadLines() def exitData(self): self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doReSeq(self): recs = self.sql.getRec("genstr", where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm)], order="gls_seq") if not recs: self.newlin = "y" self.df.focusField("C", 0, 1) return self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm)]) for seq, acc in enumerate(recs): acc[3] = seq self.sql.insRec("genstr", data=acc) self.doLoadLines() def doLoadLines(self): self.df.clearFrame("C", 0) pos = 0 recs = self.sql.getRec("genstr", where=[("gls_cono", "=", self.opts["conum"]), ("gls_strm", "=", self.strm)], order="gls_seq") for row, rec in enumerate(recs): for num, dat in enumerate(rec[3:-1]): self.df.loadEntry("C", 0, pos, data=dat) pos += 1 if pos == (self.df.rows[0] * self.df.colq[0]): self.df.scrollScreen(0) pos = pos - self.df.colq[0] pos += 1 self.df.focusField("C", 0, pos)
class ms1040(object): def __init__(self, **opts): self.opts = opts if "args" in opts: self.code = opts["args"] else: self.code = None if self.setVariables(): self.mainProcess() if self.code: self.df.doKeyPressed("T", 0, 0, self.code) 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", "ctlvrf", "ctlvtf", "chglog"], prog=self.__class__.__name__) if self.sql.error: return if not self.code: gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return if not ctlmst["ctm_taxno"]: showError(self.opts["mf"].body, "Unregistered", "The Company Record Does Not Have a V.A.T. Number") return return True def mainProcess(self): vtm = { "stype": "R", "tables": ("ctlvmf",), "cols": ( ("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y"), ("vtm_cat", "", 0, "C")), "where": [("vtm_cono", "=", self.opts["conum"])]} vtr = { "stype": "R", "tables": ("ctlvrf",), "cols": ( ("vtr_date", "", 0, "Start-Date"), ("vtr_rate", "", 0, "Rate")), "where": [("vtr_cono", "=", self.opts["conum"])], "whera": [["T", "vtr_code", 0, 0]]} vtt = { "stype": "C", "titl": "VAT Types", "head": ("C", "Description"), "data": [ ["N", "None"], ["S", "Standard"], ["Z", "Zero Rated"], ["C", "Capital Item"], ["X", "Excluded Item"]]} fld = ( (("T",0,0,0),"IUA",1,"V.A.T. Code","", "","Y",self.doCode,vtm,None,("notblank",)), (("T",0,1,0),"INA",30,"Description","", "","N",self.doDesc,None,self.doDelete,("notblank",)), (("T",0,2,0),"IUA",1,"Category","", "S","N",self.doCat,vtt,None,("in", ("C","N","S","X","Z"))), (("C",0,0,0),"Id1",10,"Start-Date","The Starting Date", "","N",self.doStart,vtr,None,("efld",)), (("C",0,0,1),"IUD",6.2,"Rate-%","The Rate", "","N",self.doRate,None,None,("efld",))) but = ( ("Print",None,self.doPrint,0,("T",0,1),(("T",0,0),("T",0,2))), ("Add",None,self.doAdd,0,("T",0,0),None), ("Edit",None,self.doEdit,0,("T",0,0),None), ("Exit",None,self.doExit,0,("T",0,0),(("T",0,1),("C",0,1)))) tnd = ((self.doTEnd,"y"), ) txt = (self.doTExit, ) cnd = ((self.doCEnd,"y"), ) cxt = (self.doCExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, rows=(15,)) def doPrint(self): hds = "V.A.T. Records" col = [ ["vtm_code", "UA", 1, "C"], ["vtm_desc", "NA", 30, "Description"], ["vtm_cat", "UA", 1, "T"], ["vtr_date", "d1", 10, "Start-Date"], ["vtr_rate", "UD", 6.2, "Rate"]] recs = self.sql.getRec(tables=["ctlvmf", "ctlvrf"], cols=["vtm_code", "vtm_desc", "vtm_cat", "vtr_date", "vtr_rate"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtr_cono=vtm_cono",), ("vtr_code=vtm_code",)], order="vtm_code, vtr_date") code = None data = copyList(recs) for num, rec in enumerate(recs): if rec[0] == code: data[num][0] = "" data[num][1] = "" data[num][2] = "" code = rec[0] state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=data, heads=[hds], ttype="D", cols=col, prtdia=(("Y","V"), ("Y","N"))) self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) self.df.focusField("T", 0, 1) def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.oldm = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", self.code)], limit=1) if not self.oldm: self.newm = True else: self.newm = False self.desc = self.oldm[self.sql.ctlvmf_col.index("vtm_desc")] self.df.loadEntry(frt, pag, p+1, data=self.desc) self.cat = self.oldm[self.sql.ctlvmf_col.index("vtm_cat")] self.df.loadEntry(frt, pag, p+2, data=self.cat) self.doLoadRates() return "ff2" def doDelete(self): if self.df.frt == "T": if self.doCheckTrn(): showError(self.opts["mf"].body, "Exists", "Transactions Exist for this Code, Not Deleted") return self.sql.delRec("ctlvmf", where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", self.code)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["ctlvmf", "D", "%03i%-1s" % \ (self.opts["conum"], self.code), "", dte, self.opts["capnm"], "", "", "", 0]) self.sql.delRec("ctlvrf", where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doCat(self, frt, pag, r, c, p, i, w): self.cat = w def doTEnd(self): self.edit = False datm = [self.opts["conum"]] datm.extend(self.df.t_work[0][0][:3]) if self.newm: self.sql.insRec("ctlvmf", data=datm) if self.cat in ("N", "X", "Z"): newr = [self.opts["conum"], self.code, 0, 0] self.sql.insRec("ctlvrf", data=newr) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) else: self.doButtons() self.df.focusField("C", 0, 1) elif self.cat in ("N", "X", "Z"): self.df.focusField("T", 0, 1) elif datm != self.oldm[:len(datm)]: col = self.sql.ctlvmf_col datm.append(self.oldm[col.index("vtm_xflag")]) self.sql.updRec("ctlvmf", data=datm, where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", self.code)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.oldm): if dat != datm[num]: self.sql.insRec("chglog", data=["ctlvmf", "U", "%03i%-1s" % (self.opts["conum"], self.code), col[num], dte, self.opts["capnm"], str(dat), str(datm[num]), "", 0]) self.doButtons() self.opts["mf"].dbm.commitDbase() def doTExit(self): chks = "" recs = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=", self.opts["conum"])]) for rec in recs: rte = self.sql.getRec("ctlvrf", where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", rec[1])]) if not rte: if rec[3] in ("N", "X", "Z"): self.sql.insRec("ctlvrf", data=[rec[0], rec[1], 0, 0]) self.opts["mf"].dbm.commitDbase() continue chks = "%s\n%1s %-30s %1s" % (chks, rec[1], rec[2], rec[3]) if chks: showError(self.opts["mf"].body, "Missing Rate Record", "The "\ "following VAT Codes do Not have Rate Records:\n%s\n\n"\ "You will Not be able to Exit until you either Create "\ "Rate Records or Delete these codes." % chks) self.df.focusField("T", 0, 1) else: self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop() def doAdd(self): for num, rec in enumerate(self.df.c_work[0]): if not rec[0] and not rec[1]: pos = (num * 2) + 1 self.df.focusField("C", 0, pos) break def doEdit(self): self.edit = True self.newr = False tit = "Edit Rate" vtr = { "stype": "R", "tables": ("ctlvrf",), "cols": ( ("vtr_date", "", 0, "Start-Date"), ("vtr_rate", "", 0, "Rate")), "where": [ ("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code)]} fld = ( (("T",0,0,0),"OUA",1,"V.A.T. Code"), (("T",0,1,0),"ONA",30,"Description"), (("T",0,2,0),"OUA",1,"Category"), (("T",0,3,0),"Id1",10,"Start-Date","The Starting Date", "","N",self.doEStart,vtr,self.doEDelete,("efld",)), (("T",0,4,0),"IUD",6.2,"Rate-%","The Rate", "","N",self.doERate,None,self.doEDelete,("notzero",))) state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") self.ed = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doEEnd,"n"),), txit=(self.doEExit,)) self.ed.loadEntry("T", 0, 0, data=self.code) self.ed.loadEntry("T", 0, 1, data=self.desc) self.ed.loadEntry("T", 0, 2, data=self.cat) self.ed.mstFrame.wait_window() self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) if self.exit: self.df.focusField("T", 0, 1) else: self.doExit() def doEDelete(self): self.exit = False if self.ed.pos == 3: if self.doCheckTrn(): return ("T", 0, 4, "Transactions Exist, Not Deleted") self.sql.delRec("ctlvmf", where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", self.code)]) self.sql.delRec("ctlvrf", where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code)]) else: if self.doCheckTrn(self.start): return ("T", 0, 5, "Transactions Exist, Not Deleted") self.sql.delRec("ctlvrf", where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code), ("vtr_date", "=", self.start)]) self.ed.closeProcess() chk = self.sql.getRec("ctlvrf", cols=["count(*)"], where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code)], limit=1) if not chk[0]: self.sql.delRec("ctlvmf", where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", self.code)]) self.exit = True self.opts["mf"].dbm.commitDbase() return "nf" def doEStart(self, frt, pag, r, c, p, i, w): self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code), ("vtr_date", "=", w)], limit=1) if not self.oldr: return "Date Does Not Exist" if self.doCheckTrn(w): showError(self.opts["mf"].body, "Date Error", "Transactions Exist for Date, Editing Not Allowed.") return "Invalid Date" self.start = w self.rate = self.oldr[3] self.ed.loadEntry(frt, pag, p+1, data=self.rate) def doERate(self, frt, pag, r, c, p, i, w): if not w: yes = askQuestion(self.opts["mf"].body, "Zero Rate", "Are You Sure That This Rate is Correct?", default="no") if yes == "no": return "Invalid Rate" self.rate = w def doEEnd(self): self.ed.closeProcess() self.doCEnd() def doEExit(self): self.ed.closeProcess() def doStart(self, frt, pag, r, c, p, i, w): if self.doCheckTrn(w): showError(self.opts["mf"].body, "Date Error", "Transactions Exist On or After This Starting Date.") return "Invalid Date" self.start = w self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code), ("vtr_date", "=", self.start)], limit=1) if not self.oldr: self.newr = True if self.cat in ("N", "X", "Z"): if self.edit: self.ed.loadEntry(frt, pag, p+1, data=0) else: self.df.loadEntry(frt, pag, p+1, data=0) return "nd" else: self.newr = False if self.edit: self.ed.loadEntry(frt, pag, p+1, data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")]) else: self.df.loadEntry(frt, pag, p+1, data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")]) def doRate(self, frt, pag, r, c, p, i, w): if not w: yes = askQuestion(self.opts["mf"].body, "Zero Rate", "Are You Sure That This Rate is Correct?", default="no") if yes == "no": return "Invalid Rate" self.rate = w def doCheckTrn(self, date=None): where = [ ("vtt_cono", "=", self.opts["conum"]), ("vtt_code", "=", self.code)] if date: where.append(("vtt_refdt", ">=", date)) return self.sql.getRec("ctlvtf", cols=["count(*)"], where=where, limit=1)[0] def doCEnd(self): datr = [self.opts["conum"], self.code, self.start, self.rate] if self.newr: self.sql.insRec("ctlvrf", data=datr) elif datr != self.oldr[:len(datr)]: col = self.sql.ctlvrf_col datr.append(self.oldr[col.index("vtr_xflag")]) self.sql.updRec("ctlvrf", data=datr, where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code), ("vtr_date", "=", self.start)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.oldr): if dat != datr[num]: self.sql.insRec("chglog", data=["ctlvrf", "U", "%03i%-1s" % (self.opts["conum"], self.code), col[num], dte, self.opts["capnm"], str(dat), str(datr[num]), "", 0]) self.opts["mf"].dbm.commitDbase() self.edit = False self.doExit() def doCExit(self): self.edit = False self.doExit() def doLoadRates(self): self.df.clearFrame("C", 0) recs = self.sql.getRec("ctlvrf", cols=["vtr_date", "vtr_rate"], where=[("vtr_cono", "=", self.opts["conum"]), ("vtr_code", "=", self.code)], order="vtr_date") for num, rec in enumerate(recs): pos = (num * 2) if pos > 27: self.df.scrollScreen(0) pos = 26 self.df.focusField("C", 0, pos + 1) self.df.loadEntry("C", 0, pos, data=rec[0]) self.df.focusField("C", 0, pos + 2) self.df.loadEntry("C", 0, pos + 1, data=rec[1], zero=True) def doButtons(self): self.df.setWidget(self.df.B1, "normal") self.df.setWidget(self.df.B2, "normal") self.df.setWidget(self.df.B3, "normal") self.opts["mf"].window.focus_set() def doExit(self): self.df.setWidget(self.df.B3, "disabled") self.df.focusField("T", 0, 1)
class st2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.exit = False self.selectPrinter() if not self.exit: self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "ctlmst", "ctlmes", "ctlvrf", "ctlrep", "crsmst", "gentrn", "strgrp", "strloc", "strmf1", "strmf2", "strpom", "strpot", "strtrn", "strgmu", "strcmu", "tplmst" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return mods = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): mods.append(ctlmst["ctm_modules"][x:x + 2]) if "CR" not in mods: showError( self.opts["mf"].body, "System Error", "This module requires you to have a Creditor's Activated") return strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.stgl = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] self.dtpl = strctl["cts_tplnam"] if self.stgl == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["stk_soh", "stk_susp"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.soh = ctlctl["stk_soh"] self.ssp = ctlctl["stk_susp"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def selectPrinter(self): tit = ("Printer Selection", ) tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title", "Y")), "where": [("tpm_type", "=", "O"), ("tpm_system", "=", "STR")], "order": "tpm_tname" } fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.dtpl, "N", self.doTplNam, tpm, None, None), (("T", 0, 1, 0), "ID1", 10, "Order Date", "", self.sysdtw, "N", self.doOrdDate, None, None, ("efld", ))) self.pr = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=((self.doPrtEnd, "y"), ), txit=(self.doPrtExit, ), view=("N", "P"), mail=("N", "Y", "Y")) self.opts["mf"].startLoop() def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "O"), ("tpm_system", "=", "STR")], limit=1) if not acc: return "Invalid Template Name" self.tname = w def doOrdDate(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" self.trdt = w self.trdd = self.pr.t_disp[0][0][1] self.curdt = int(self.trdt / 100) self.batch = "S%s" % self.curdt def doPrtEnd(self): self.doPrtClose() def doPrtExit(self): self.exit = True self.doPrtClose() def doPrtClose(self): self.pr.closeProcess() self.opts["mf"].closeLoop() def mainProcess(self): doc = { "stype": "R", "tables": ("strpom", "crsmst"), "cols": (("pom_ordno", "", 0, "Ord-Num"), ("pom_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")), "where": [("pom_cono", "=", self.opts["conum"]), ("crm_cono=pom_cono", ), ("crm_acno=pom_acno", ), ("pom_delno", "=", "")] } loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } 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")], "index": 0 } odr = { "stype": "R", "tables": ("ctlrep", ), "cols": [("rep_code", "", 0, "Ord"), ("rep_name", "", 0, "Name", "Y")], "where": [("rep_cono", "=", self.opts["conum"])], "index": 0 } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } cod = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_code", "", 0, "Product-Code"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "not", "in", ("R", "X")), ("st1_value_ind", "<>", "N")], "whera": [("C", "st1_group", 0)], "order": "st1_group, st1_code" } r1s = (("New", "N"), ("Amend", "A"), ("Receive", "R"), ("Cancel", "C")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Action", "", "N", "Y", self.doActTyp, None, None, None), (("T", 0, 1, 0), "IUI", 9, "Ord-No", "Order Number", "", "N", self.doOrdNum, doc, None, ("notblank", )), (("T", 0, 2, 0), "IUA", 1, "Loc", "Location Code", "1", "N", self.doLoc, loc, None, None), (("T", 0, 2, 0), "ONA", 30, ""), (("T", 0, 3, 0), "INA", 7, "Acc-No", "Account Number", "", "N", self.doCrsAcc, crm, None, None), (("T", 0, 3, 0), "ONA", 30, ""), (("T", 0, 4, 0), "INa", 3, "Ord-By", "Ordered By", "", "N", self.doOrdBy, odr, None, None), (("T", 0, 4, 0), "ONA", 30, ""), (("T", 0, 5, 0), "INa", 7, "Del-No", "Delivery Note Number", "", "N", self.doDelNum, None, None, ("notblank", )), (("T", 0, 5, 0), "ID1", 10, "Date", "Delivery Date", self.trdt, "N", self.doDelDate, None, None, ("efld", )), (("C", 0, 0, 0), "INA", 3, "Grp", "Product Group", "", "Y", self.doGrp, grp, None, None), (("C", 0, 0, 1), "INA", 20, "Product-Code", "", "", "N", self.doCod, cod, None, None), (("C", 0, 0, 2), "INA", (20, 30), "Description", "", "", "N", self.doDes, None, None, None), (("C", 0, 0, 3), "ISD", 11.2, "Quantity", "", 1, "N", self.doQty, None, None, ("notzero", )), (("C", 0, 0, 4), "IUA", 1, "V", "V.A.T. Code", "I", "N", self.doVat, None, None, ("notblank", )), (("C", 0, 0, 5), "IUD", 10.2, "Price", "Exclusive Price", "", "N", self.doPri, None, None, None), (("C", 0, 0, 6), "IUD", 6.2, "Dis-%", "Trade Discount", "", "N", self.doDis, None, None, None), (("C", 0, 0, 7), "OSD", 10.2, "Value")) self.row = (15, ) self.but = (("Cancel", None, self.doCancel, 1, ("C", 0, 1), ("T", 0, 1)), ("DelAdd", None, self.doDelAdd, 1, ("C", 0, 1), ("T", 0, 1)), ("Ribbon", None, self.doRibbon, 1, ("C", 0, 1), ("T", 0, 1)), ("Message", None, self.doMessag, 1, ("C", 0, 1), ("T", 0, 1)), ("Edit", None, self.doEdit, 0, ("C", 0, 1), ("C", 0, 2)), ("Reprint", None, self.doReprnt, 0, ("T", 0, 1), ("T", 0, 2)), ("CrsMaint", None, self.doCrsMaint, 0, ("T", 0, 5), ("T", 0, 6)), ("CrsQuery", None, self.doCrsQuery, 1, None, None), ("StrMaint", None, self.doStrMaint, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("StrQuery", None, self.doStkQuery, 1, None, None), ("Exit", None, self.doTopExit, 0, ("T", 0, 1), (("T", 0, 2), ("T", 0, 3), ("T", 0, 5)), "Exit Purchase Orders"), ("Accept", None, self.doAccept, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2)))) tnd = ((self.doTopEnd, "n"), ) txt = (self.doTopExit, ) cnd = ((self.doColEnd, "n"), ) cxt = (None, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, rows=self.row, butt=self.but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, vport=True) def doActTyp(self, frt, pag, r, c, p, i, w): # Initialise Action Variables self.acttyp = w # Initialise Variables self.dnum = "" self.onum = "" self.jnum = "" self.dadd = "" self.cnam = "" self.vatn = "" self.ribbon = None ctl = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"])], limit=1) self.deladd = [ ctl[self.sql.ctlmst_col.index("ctm_sadd1")], ctl[self.sql.ctlmst_col.index("ctm_sadd2")], ctl[self.sql.ctlmst_col.index("ctm_sadd3")], ctl[self.sql.ctlmst_col.index("ctm_spcode")] ] self.message = "" for x in (1, 2, 3): if self.acttyp == "R": self.df.butt[x][1] = 0 self.df.butt[x][2] = None else: self.df.butt[x][1] = 1 self.df.butt[x][2] = ["C", 0, 1] if self.acttyp == "N": # Location default if self.locs == "N": self.loc = "1" self.df.loadEntry(frt, pag, p + 2, data=self.loc) self.df.loadEntry(frt, pag, p + 3, data="Location One") return "sk3" return "sk1" def doOrdNum(self, frt, pag, r, c, p, i, w): strpom = self.sql.getRec("strpom", where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", w)], limit=1) if not strpom: return "Invalid Document" if strpom[self.sql.strpom_col.index("pom_delno")] == "cancel": if self.acttyp == "C": return "Already Cancelled" ok = askQuestion( self.opts["mf"].body, "Cancelled", "This order was Cancelled.\n\nDo you want to Reinstate It?", default="no") if ok == "no": return "Order Cancelled" self.sql.updRec("strpom", cols=["pom_delno"], data=[""], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", w)]) strpom[self.sql.strpom_col.index("pom_delno")] = "" elif strpom[self.sql.strpom_col.index("pom_delno")]: return "Order Already Received" self.ordno = CCD(w, "UI", 9.0).work self.othno = CCD(w, "Na", 9.0).work self.loc = strpom[self.sql.strpom_col.index("pom_loc")] self.acno = strpom[self.sql.strpom_col.index("pom_acno")] self.cnam = strpom[self.sql.strpom_col.index("pom_contact")] self.vatn = strpom[self.sql.strpom_col.index("pom_vatno")] self.ordby = strpom[self.sql.strpom_col.index("pom_ordby")] self.ribbon = ["", "", self.cnam, self.vatn] self.df.loadEntry(frt, pag, p + 1, data=self.loc) self.doLoc(frt, pag, r, c + 1, p + 1, i + 1, self.loc) self.df.loadEntry(frt, pag, p + 3, data=self.acno) self.doCrsAcc(frt, pag, r, c + 3, p + 3, i + 3, self.acno) self.df.loadEntry(frt, pag, p + 5, data=self.ordby) self.doOrdBy(frt, pag, r, c + 5, p + 5, i + 5, self.ordby) if self.acttyp == "R": return "sk6" else: return "nd" def doLoc(self, frt, pag, r, c, p, i, w): desc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not desc: return "Invalid Location" self.loc = w self.df.loadEntry(frt, pag, p + 1, data=desc[0]) def doCrsAcc(self, frt, pag, r, c, p, i, w): self.crsmst = self.sql.getRec("crsmst", where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)], limit=1) if not self.crsmst: return "Invalid Account" if self.crsmst[self.sql.crsmst_col.index("crm_stat")] == "X": return "Invalid Account, Redundant" self.acno = w self.name = self.crsmst[self.sql.crsmst_col.index("crm_name")] self.df.loadEntry(frt, pag, p + 1, data=self.name) def doOrdBy(self, frt, pag, r, c, p, i, 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 Code" self.ordby = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) return "sk3" def doDelNum(self, frt, pag, r, c, p, i, w): self.delno = w def doDelDate(self, frt, pag, r, c, p, i, w): self.deldt = w def doTopEnd(self): if self.acttyp == "N": # Get and Display Next Document Number ordno = self.sql.getRec("strpom", cols=["max(pom_ordno)"], where=[("pom_cono", "=", self.opts["conum"])], limit=1) if not ordno[0]: self.ordno = CCD(1, "UI", 9).work self.othno = CCD(1, "Na", 9).work else: self.ordno = CCD((int(ordno[0]) + 1), "UI", 9).work self.othno = CCD((int(ordno[0]) + 1), "Na", 9).work self.df.loadEntry(self.df.frt, self.df.pag, 1, data=self.ordno) # Create Document Transaction (Head) self.dad1, self.dad2, self.dad3, self.dad4 = "", "", "", "" data = [ self.opts["conum"], self.ordno, self.loc, self.trdt, self.acno, self.dad1, self.dad2, self.dad3, self.dad4, "", "", "", "", self.ordby, "", "", 0, self.opts["capnm"], self.sysdtw ] # Write and Commit Header self.sql.insRec("strpom", data=data) self.opts["mf"].dbm.commitDbase() # Clear Totals self.doClearTots() elif self.acttyp == "C": self.doReadLoadStr() ok = askQuestion(self.opts["mf"].body, "Cancel", "Are You Sure This Order Must be Cancelled?", default="no") if ok == "yes": # Print Cancellation self.df.setWidget(self.df.mstFrame, state="hide") PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.ordno, tname=self.tname, repprt=self.pr.repprt, repeml=self.pr.repeml, copy=self.acttyp.lower()) self.df.setWidget(self.df.mstFrame, state="show") # Update Deletetion self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno)]) self.opts["mf"].dbm.commitDbase() # Clear totals and focus self.doClearTots() self.df.focusField("T", 0, 1) else: self.doReadLoadStr() self.amend = False def doReadLoadStr(self): self.doClearTots() data = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if not data: return for seq, line in enumerate(data): self.doExtData(line) if seq >= self.row[0]: self.df.scrollScreen(0) pos = (self.row[0] - 1) * 9 else: pos = seq * 9 # Load Values self.df.loadEntry("C", 0, pos, data=self.grp) self.df.loadEntry("C", 0, pos + 1, data=self.code) self.df.loadEntry("C", 0, pos + 2, data=self.desc) self.df.loadEntry("C", 0, pos + 3, data=self.qty) self.df.loadEntry("C", 0, pos + 5, data=self.vatcod) self.df.loadEntry("C", 0, pos + 6, data=self.price) self.df.loadEntry("C", 0, pos + 7, data=self.disrat) self.df.loadEntry("C", 0, pos + 8, data=self.excamt) self.vattot = float(ASD(self.vattot) + ASD(self.vatamt)) self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt)) self.inctot = float(ASD(self.inctot) + ASD(self.incamt)) if seq >= (self.row[0] - 1): self.df.scrollScreen(0) else: self.df.focusField("C", 0, pos + 10) self.df.setViewPort("O", self.inctot) def doTopExit(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doClearTots(self): self.vattot = 0 self.ordtot = 0 self.inctot = 0 self.df.clearFrame("C", 0) self.df.focusField("C", 0, 1) self.df.setViewPort(None, 0) def doGrp(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group Code" self.grp = w def doCod(self, frt, pag, r, c, p, i, w): strmf1 = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", w)], limit=1) if not strmf1: return "Invalid Code" if strmf1[self.sql.strmf1_col.index("st1_type")] == "R": return "Invalid Code (Recipe)" if strmf1[self.sql.strmf1_col.index("st1_type")] == "X": return "Invalid Code (Redundant)" if strmf1[self.sql.strmf1_col.index("st1_value_ind")] == "N": return "Invalid Code (Value Indicator)" self.vatcod = strmf1[self.sql.strmf1_col.index("st1_vatcode")] strmf2 = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.grp), ("st2_code", "=", w), ("st2_loc", "=", self.loc)], limit=1) if not strmf2: return "Invalid Location" odt = self.sql.getRec("strpot", cols=["count(*)"], where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", self.grp), ("pot_code", "=", w)], limit=1) if odt[0]: return "This Item is Already On This Order" odq = self.sql.getRec(tables=["strpom", "strpot"], cols=["sum(pot_qty)"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_loc", "=", self.loc), ("pom_delno", "=", ""), ("pot_cono", "=", self.opts["conum"]), ("pot_ordno=pom_ordno", ), ("pot_group", "=", self.grp), ("pot_code", "=", w)], limit=1) if odq[0]: state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="DupOrd", desc="%s of this Item is Already On Order" % odq[0]) self.df.enableButtonsTags(state=state) if cf.flag == "no": return "rf" self.code = w desc = strmf1[self.sql.strmf1_col.index("st1_desc")] self.uoi = strmf1[self.sql.strmf1_col.index("st1_uoi")] self.df.loadEntry(frt, pag, p + 1, data=desc) def doDes(self, frt, pag, r, c, p, i, w): self.desc = w def doQty(self, frt, pag, r, c, p, i, w): self.qty = w self.df.loadEntry(frt, pag, p + 1, data=self.vatcod) def doVat(self, frt, pag, r, c, p, i, w): self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trdt) if self.vatrte is None: return "Invalid V.A.T Code" self.vatcod = w # Last Cost Price lcost = getCost(self.sql, self.opts["conum"], self.grp, self.code, loc=self.loc, qty=1, ind="L") self.df.loadEntry(frt, pag, p + 1, data=lcost) def doPri(self, frt, pag, r, c, p, i, w): self.price = w self.inc = round((self.price * (self.vatrte + 100.0) / 100.0), 4) self.exc = round((self.price * 1), 2) dis = self.crsmst[self.sql.crsmst_col.index("crm_trdis")] self.df.loadEntry(frt, pag, p + 1, data=dis) def doDis(self, frt, pag, r, c, p, i, w): self.disrat = w dis = float(ASD(100) - ASD(self.disrat)) self.excamt = round((self.qty * self.exc * dis / 100.0), 2) self.incamt = round((self.qty * self.inc * dis / 100.0), 2) self.vatamt = float(ASD(self.incamt) - ASD(self.excamt)) self.df.loadEntry(frt, pag, p + 1, data=self.excamt) self.vattot = float(ASD(self.vattot) + ASD(self.vatamt)) self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt)) self.inctot = float(ASD(self.inctot) + ASD(self.incamt)) self.df.setViewPort("O", self.inctot) def doColEnd(self): # Create Purchase Order Transaction (Body) data = [ self.opts["conum"], self.ordno, self.grp, self.code, self.uoi, self.desc, self.qty, self.price, self.disrat, self.vatcod, self.vatrte, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strpot", data=data) if self.acttyp == "A": self.amend = True self.df.advanceLine(0) def doCrsQuery(self): callModule(self.opts["mf"], self.df, "cr4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def doStkQuery(self): callModule(self.opts["mf"], self.df, "st4010", coy=(self.opts["conum"], self.opts["conam"]), period=self.opts["period"], user=self.opts["capnm"]) def doDelAdd(self): tit = ("Delivery Address", ) fld = ((("T", 0, 0, 0), "INA", 30, "Address-1", "Address Line 1", "", "N", None, None, None, None), (("T", 0, 1, 0), "INA", 30, "Address-2", "Address Line 2", "", "N", None, None, None, None), (("T", 0, 2, 0), "INA", 30, "Address-3", "Address Line 3", "", "N", None, None, None, None), (("T", 0, 3, 0), "INA", 30, "Address-4", "Address Line 4", "", "N", None, None, None, None)) state = self.df.disableButtonsTags() self.da = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doDelEnd, "n"), ), txit=(self.doDelExit, ), focus=False) for x in range(0, len(self.deladd)): self.da.loadEntry("T", 0, 0 + x, data=self.deladd[x]) self.da.focusField("T", 0, 1, clr=False) self.da.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doDelEnd(self): self.deladd = [] for x in range(0, self.da.topq[0]): self.deladd.append(self.da.t_work[0][0][x]) self.doDelExit() def doDelExit(self): self.da.closeProcess() def doMessag(self): tit = ("Order Message", ) cod = { "stype": "R", "tables": ("ctlmes", ), "cols": [("mss_message", "", 0, "Cod"), ("mss_detail", "", 60, "Details")], "where": [("mss_system", "=", "STR")], "screen": self.df.mstFrame } fld = ((("T", 0, 0, 0), "IUI", 3, "Message Code", "", "", "N", self.doMesCod, cod, None, None), (("T", 0, 1, 0), "ITv", (30, 6), "Message", "", self.message, "N", None, None, None, None)) but = (("Accept", None, self.doMesEnd, 0, ("T", 0, 1), ("T", 0, 0)), ) state = self.df.disableButtonsTags() self.mg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doMesEnd, "n"), ), txit=(self.doMesExit, ), butt=but) self.mg.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doMesCod(self, frt, pag, r, c, p, i, w): if w: mess = self.sql.getRec("ctlmes", where=[("mss_system", "=", "STR"), ("mss_message", "=", w)], limit=1) if not mess: return "Invalid Message Code" self.message = mess[self.sql.ctlmse_col.index("mss_detail")] self.mg.loadEntry(frt, pag, p + 1, data=self.message) def doMesEnd(self): wid, self.message = self.mg.getEntry("T", 0, 1) self.doMesExit() def doMesExit(self): self.mg.closeProcess() def doEdit(self): # Display document items and allow editing of desc, qty and price recs = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if recs: data = [] for l in recs: qty = CCD(l[self.sql.strpot_col.index("pot_qty")], "SD", 11.2) prc = CCD(l[self.sql.strpot_col.index("pot_price")], "UD", 10.2) dis = CCD(l[self.sql.strpot_col.index("pot_disper")], "UD", 6.2) data.append([ l[self.sql.strpot_col.index("pot_group")], l[self.sql.strpot_col.index("pot_code")], l[self.sql.strpot_col.index("pot_desc")], qty.disp, l[self.sql.strpot_col.index("pot_vatcod")], prc.disp, dis.disp ]) head = ("Grp", "Product-Code", "Description", "Quantity", "V", "Price", "Disc-%") lin = { "stype": "C", "head": head, "typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 11.2), ("UA", 1), ("UD", 10.2), ("UD", 6.2)), "data": data } state = self.df.disableButtonsTags() chg = self.df.selChoice(lin) if chg and chg.selection: self.change = chg.selection self.doChanges() self.df.enableButtonsTags(state=state) self.df.focusField("C", 0, self.df.col) def doChanges(self): tit = ("Change Items", ) fld = ((("T", 0, 1, 0), "ONA", 3, "Group"), (("T", 0, 2, 0), "ONA", 20, "Code"), (("T", 0, 3, 0), "INA", 30, "Description", "", "", "N", self.doChgDes, None, None, ("notblank", )), (("T", 0, 4, 0), "ISD", 11.2, "Quantity", "", "", "N", self.doChgQty, None, None, ("notzero", )), (("T", 0, 5, 0), "IUD", 10.2, "Selling Price", "", "", "N", self.doChgPrc, None, None, ("notzero", )), (("T", 0, 6, 0), "IUD", 6.2, "Discount Percent", "", "", "N", self.doChgDis, None, None, ("efld", ))) but = (("Delete", None, self.doChgDel, 1, None, None), ) tnd = ((self.doChgEnd, "n"), ) txt = (self.doChgExit, ) self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=tnd, txit=txt) 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.loadEntry("T", 0, 4, data=self.change[5]) self.cg.loadEntry("T", 0, 5, data=self.change[6]) self.cg.focusField("T", 0, 3, clr=False) self.cg.mstFrame.wait_window() def doChgDes(self, frt, pag, r, c, p, i, w): self.desc = w def doChgQty(self, frt, pag, r, c, p, i, w): self.qty = w def doChgPrc(self, frt, pag, r, c, p, i, w): self.price = w def doChgDis(self, frt, pag, r, c, p, i, w): self.disrat = w def doChgDel(self): grp = self.change[0] cod = self.change[1] self.sql.delRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", grp), ("pot_code", "=", cod)]) if self.acttyp == "A": self.amend = True self.doChgExit(loader=True) def doChgEnd(self): grp = self.change[0] cod = self.change[1] col = ["pot_desc", "pot_qty", "pot_price", "pot_disper"] dat = [self.desc, self.qty, self.price, self.disrat] whr = [("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", grp), ("pot_code", "=", cod)] self.sql.updRec("strpot", cols=col, data=dat, where=whr) if self.acttyp == "A": self.amend = True self.doChgExit(loader=True) def doChgExit(self, loader=False): self.cg.closeProcess() if loader: self.doReadLoadStr() def doReprnt(self): tit = ("Reprint Orders", ) odr = { "stype": "R", "tables": ("strpom", "crsmst"), "cols": [("pom_ordno", "", 0, "Doc-Num"), ("pom_date", "", 0, "Date"), ("pom_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")], "where": [("pom_cono", "=", self.opts["conum"]), ("pom_cono=crm_cono", ), ("pom_acno=crm_acno", )], "screen": self.opts["mf"].body } r1s = (("Copies", "C"), ("Originals", "O")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Document Mode", "", "C", "N", self.doMode, None, None, None), (("T", 0, 1, 0), "IUI", 9, "From Number", "From Document Number", "", "N", self.doOrd, odr, None, ("notzero", )), [("T", 0, 2, 0), "IUI", 9, "To Number", "To Document Number", "", "N", None, odr, None, ("notzero", )]) state = self.df.disableButtonsTags() self.rp = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doReprntEnd, "n"), ), txit=(self.doReprntExit, ), view=("N", "V"), mail=("B", "Y")) self.rp.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doMode(self, frt, pag, r, c, p, i, w): if w == "C": self.copy = "y" else: self.copy = "n" def doOrd(self, frt, pag, r, c, p, i, w): self.rp.topf[pag][2][5] = w def doReprntEnd(self): self.rp.closeProcess() self.df.setWidget(self.df.mstFrame, state="hide") frm = self.rp.t_work[0][0][1] if not self.rp.t_work[0][0][2]: to = frm else: to = self.rp.t_work[0][0][2] odr = self.sql.getRec("strpom", cols=["pom_ordno"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", ">=", frm), ("pom_ordno", "<=", to)]) if odr: PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], odr, tname=self.tname, repprt=self.rp.repprt, repeml=self.rp.repeml, copy=self.copy) self.df.setWidget(self.df.mstFrame, state="show") def doReprntExit(self): self.rp.closeProcess() def doCrsMaint(self): state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="NewCrs") if cf.flag == "yes": callModule(self.opts["mf"], self.df, "cr1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doStrMaint(self): state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="NewStr") if cf.flag == "yes": callModule(self.opts["mf"], self.df, "st1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doAccept(self): self.df.setWidget(self.df.B11, "disabled") if self.df.col == 1: self.doCancel() else: # Update Tables self.doUpdateTables() # Commit Transaction self.opts["mf"].dbm.commitDbase() # Print Document if self.acttyp == "N" or (self.acttyp == "A" and self.amend): self.df.setWidget(self.df.mstFrame, state="hide") PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.ordno, tname=self.tname, repprt=self.pr.repprt, repeml=self.pr.repeml, copy=self.acttyp.lower()) self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField("T", 0, 1) def doRibbon(self): tit = ("Ribbon Line", ) fld = ((("T", 0, 0, 0), "INA", 30, "Customer Order", "", self.cnam, "N", None, None, None, None), (("T", 0, 1, 0), "INA", 30, "Job Number", "", self.cnam, "N", None, None, None, None), (("T", 0, 2, 0), "INA", 30, "Contact Person", "", self.cnam, "N", None, None, None, None), (("T", 0, 3, 0), "INA", 10, "VAT Number", "", self.vatn, "N", self.doVatNum, None, None, None)) state = self.df.disableButtonsTags() self.rb = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doRibEnd, "n"), ), txit=(self.doRibExit, ), focus=False) if self.ribbon: self.rb.loadEntry("T", 0, 0, data=self.ribbon[0]) self.rb.loadEntry("T", 0, 1, data=self.ribbon[1]) self.rb.loadEntry("T", 0, 2, data=self.ribbon[2]) self.rb.loadEntry("T", 0, 3, data=self.ribbon[3]) self.rb.focusField("T", 0, 1) self.rb.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doVatNum(self, frt, pag, r, c, p, i, w): if self.ordtot >= 1000.00 and not w: return "Invalid VAT Number" def doRibEnd(self): self.ribbon = [] for x in range(0, self.rb.topq[0]): self.ribbon.append(self.rb.t_work[0][0][x]) self.doRibExit() def doRibExit(self): self.rb.closeProcess() def doUpdateTables(self): # Update strpom with ribbon, delivery and message details whr = [("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)] if self.ribbon: self.sql.updRec( "strpom", cols=["pom_cusord", "pom_jobnum", "pom_contact", "pom_vatno"], data=[ self.ribbon[0], self.ribbon[1], self.ribbon[2], self.ribbon[3] ], where=whr) if not self.vatn: self.sql.updRec("crsmst", cols=["crm_vatno"], data=[self.ribbon[1]], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", self.acno)]) if self.deladd: self.sql.updRec( "strpom", cols=["pom_add1", "pom_add2", "pom_add3", "pom_add4"], data=[ self.deladd[0], self.deladd[1], self.deladd[2], self.deladd[3] ], where=whr) if self.message: self.sql.updRec("strpom", cols=["pom_mess"], data=[self.message], where=whr) if self.acttyp != "R": return # Receipt of Order # Create Stores Transactions and update strpot lines trn = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if not trn: return for line in trn: self.doExtData(line) curdt = int(self.deldt / 100) # Update strpom record self.sql.updRec("strpom", cols=["pom_delno", "pom_deldt"], data=[self.delno, self.deldt], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno)]) # Write strtrn record data = [ self.opts["conum"], self.grp, self.code, self.loc, self.deldt, 1, self.othno, self.batch, self.delno, self.qty, self.excamt, 0, curdt, self.name, 0, self.acno, "", "STR", self.disrat, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) # If Integrated Create GL Transaction (SOH and Recon Accounts) if self.stgl == "Y" and self.excamt: # Stock on Hand Control data = (self.opts["conum"], self.soh, curdt, self.deldt, 5, self.othno, self.batch, self.excamt, 0, self.name, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) cst = float(ASD(0) - ASD(self.excamt)) # Stock Reconciliation Control data = (self.opts["conum"], self.ssp, curdt, self.deldt, 5, self.othno, self.batch, cst, 0, self.name, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def doExtData(self, line): self.grp = line[self.sql.strpot_col.index("pot_group")] self.code = line[self.sql.strpot_col.index("pot_code")] self.uoi = line[self.sql.strpot_col.index("pot_uoi")] self.desc = line[self.sql.strpot_col.index("pot_desc")] self.qty = line[self.sql.strpot_col.index("pot_qty")] self.price = line[self.sql.strpot_col.index("pot_price")] self.disrat = line[self.sql.strpot_col.index("pot_disper")] self.vatcod = line[self.sql.strpot_col.index("pot_vatcod")] self.vatrte = line[self.sql.strpot_col.index("pot_vatrat")] # Calculate Values rat = float(ASD(100) + ASD(self.vatrte)) inc = round((self.price * rat / 100.0), 4) exc = round((self.price * 1), 2) dis = float(ASD(100) - ASD(self.disrat)) self.excamt = round((self.qty * exc * dis / 100.0), 2) self.incamt = round((self.qty * inc * dis / 100.0), 2) self.vatamt = float(ASD(self.incamt) - ASD(self.excamt)) def doCancel(self): self.opts["mf"].dbm.rollbackDbase() if self.acttyp == "N": self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1)
class gl1020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.buildScreen() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "genmst", "genjlm", "genjlt"], prog=self.__class__.__name__) if self.sql.error: return self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) return True def buildScreen(self): num_sel = { "stype": "R", "tables": ("genjlm", ), "cols": (("gjm_num", "", 0, "Number"), ("gjm_desc", "", 0, "Description", "Y"), ("gjm_freq", "", 0, "Freq"), ("gjm_start", "", 0, "Start"), ("gjm_end", "", 0, "End")), "where": [("gjm_cono", "=", self.opts["conum"])] } seq_sel = { "stype": "R", "tables": ("genjlt", ), "cols": (("gjt_seq", "", 0, "Seq"), ("gjt_acno", "", 0, "Acc-Num"), ("gjt_amnt", "", 0, "Amount")), "where": [("gjt_cono", "=", self.opts["conum"])], "whera": (("T", "gjt_num", 0), ) } acc_sel = { "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), "INa", 9, "Number", "Journal Number", "", "Y", self.doNum, num_sel, None, ("notblank", )), (("T", 0, 1, 0), "INA", 30, "Description", "", "", "N", self.doDesc, None, self.doDelNum, ("notblank", )), (("T", 0, 2, 0), "IUA", 1, "Frequency", "Frequency (M/3/6/Y)", "", "N", self.doFreq, None, None, ("in", ("M", "3", "6", "Y"))), (("T", 0, 3, 0), "ID2", 7, "Starting Period", "", "", "N", self.doStart, None, None, ("efld", )), (("T", 0, 3, 0), "ID2", 7, "Ending Period", "", "", "N", self.doEnd, None, None, ("efld", )), (("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i", "N", self.doSeq, seq_sel, None, ("notzero", )), (("C", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doAcc, acc_sel, self.doDelSeq, ("efld", )), (("C", 0, 0, 0), "ONA", 30, "Description", "", "", "N", None, None, None, None), (("C", 0, 0, 0), "IUA", 1, "V", "V.A.T. Indicator", "", "N", self.doVat, None, None, ("notblank", )), (("C", 0, 0, 0), "ISD", 13.2, "Value", "Period Value", "", "N", self.doValue, None, None, ("efld", ))) but = (("Show Entries", seq_sel, None, 0, ("C", 0, 1), ("C", 0, 2)), ("Show Total", None, self.doTotal, 0, ("C", 0, 1), ("C", 0, 2)), ("Abort Journal", None, self.doAbort, 0, ("C", 0, 1), ("T", 0, 1))) tnd = ((self.endTop, "y"), ) txt = (self.exitTop, ) cnd = ((self.endCol, "y"), ) cxt = (self.exitCol, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doNum(self, frt, pag, r, c, p, i, w): self.num = w self.old = self.sql.getRec("genjlm", where=[("gjm_cono", "=", self.opts["conum"]), ("gjm_num", "=", self.num)], limit=1) if not self.old: self.new_num = "y" self.nxtcol = 1 else: d = self.sql.genjlm_col self.new_num = "n" self.df.loadEntry(frt, pag, p + 1, data=self.old[d.index("gjm_desc")]) self.df.loadEntry(frt, pag, p + 2, data=self.old[d.index("gjm_freq")]) self.df.loadEntry(frt, pag, p + 3, data=self.old[d.index("gjm_start")]) self.df.loadEntry(frt, pag, p + 4, data=self.old[d.index("gjm_end")]) for x in range(3): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") def doDelNum(self): if self.new_num == "y": return self.sql.delRec("genjlm", where=[("gjm_cono", "=", self.opts["conum"]), ("gjm_num", "=", self.num)]) try: self.sql.delRec("genjlt", where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.acc)]) except: pass self.opts["mf"].dbm.commitDbase() def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doFreq(self, frt, pag, r, c, p, i, w): self.freq = w def doStart(self, frt, pag, r, c, p, i, w): if w < self.s_per or w > self.e_per: return "Invalid Start Date" self.start = w def doEnd(self, frt, pag, r, c, p, i, w): if w < self.start or w > self.e_per: return "Invalid End Date" self.end = w def endTop(self): data = [ self.opts["conum"], self.num, self.desc, self.freq, self.start, self.end, 0 ] if self.new_num == "y": self.sql.insRec("genjlm", data=data) self.df.loadEntry("C", 0, 0, data=1) else: if data != self.old[:len(data)]: col = self.sql.genjlm_col data.append(self.old[col.index("gjm_xflag")]) self.sql.updRec("genjlm", data=data, where=[("gjm_cono", "=", self.opts["conum"]), ("gjm_num", "=", self.num)]) self.doReload() self.df.focusField("C", 0, self.nxtcol) def exitTop(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doSeq(self, frt, pag, r, c, p, i, w): self.seq = w self.seqdat = self.sql.getRec("genjlt", where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.num), ("gjt_seq", "=", self.seq)], limit=1) if not self.seqdat: self.new_seq = "y" else: self.new_seq = "n" col = self.sql.genjlt_col acc = self.seqdat[col.index("gjt_acno")] des = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acc)], limit=1)[0] self.df.loadEntry(frt, pag, p + 1, data=acc) self.df.loadEntry(frt, pag, p + 2, data=des) self.df.loadEntry(frt, pag, p + 3, data=self.seqdat[col.index("gjt_vatc")]) self.df.loadEntry(frt, pag, p + 4, data=self.seqdat[col.index("gjt_amnt")]) def doDelSeq(self): if self.new_seq == "y": return self.sql.delRec("genjlt", where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.num), ("gjt_seq", "=", self.seq)]) self.doReload() self.df.focusField("C", 0, self.nxtcol) def doAcc(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.acc = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) self.df.loadEntry(frt, pag, p + 2, data=chk[2]) def doVat(self, frt, pag, r, c, p, i, w): vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) if not vat: return "Invalid VAT Code" self.vat = w def doValue(self, frt, pag, r, c, p, i, w): self.val = w def endCol(self): data = [ self.opts["conum"], self.num, self.seq, self.acc, self.vat, self.val ] if self.new_seq == "y": self.sql.insRec("genjlt", data=data) else: col = self.sql.genjlt_col data.append(self.seqdat[col.index("gjt_xflag")]) self.sql.updRec("genjlt", data=data, where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.num), ("gjt_seq", "=", self.seq)]) self.doReload() self.df.focusField("C", 0, self.nxtcol) def exitCol(self): tot = self.sql.getRec("genjlt", cols=["count(*)", "round(sum(gjt_amnt), 2)"], where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.num)], limit=1) if tot[0] and not tot[1]: self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) elif tot[1]: self.df.focusField("C", 0, self.df.col, err="Debits Not Equal Credits") else: self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doAbort(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doReload(self): self.df.clearFrame("C", 0) last = (self.df.rows[0] - 1) * 5 trn = self.sql.getRec( tables=["genjlt", "genmst"], cols=["gjt_seq", "gjt_acno", "glm_desc", "gjt_vatc", "gjt_amnt"], where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.num), ("glm_cono=gjt_cono", ), ("glm_acno=gjt_acno", )], order="gjt_seq") if trn: for s, t in enumerate(trn): if s >= self.df.rows[0]: self.df.scrollScreen(0) p = last else: p = s * 5 self.df.loadEntry("C", 0, p, data=t[0]) self.df.loadEntry("C", 0, p + 1, data=t[1]) self.df.loadEntry("C", 0, p + 2, data=t[2]) self.df.loadEntry("C", 0, p + 3, data=t[3]) self.df.loadEntry("C", 0, p + 4, data=t[4]) if p == last: self.df.scrollScreen(0) self.nxtcol = last + 1 else: self.nxtcol = p + 6 def doTotal(self): tot = self.sql.getRec("genjlt", cols=["round(sum(gjt_amnt),2)"], where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.num)], limit=1) if not tot[0]: tot = CCD(0, "SD", 15.2) else: tot = CCD(tot[0], "SD", 15.2) showInfo(self.opts["mf"].body, "Journal Total", tot.disp) self.df.focusField(self.df.frt, self.df.pag, self.df.col)
class dr1020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.buildScreen() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql( self.opts["mf"].dbm, ["ctlvmf", "drschn", "drsmst", "drsrcm", "drsrct", "genmst"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" drsctl = self.gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return self.glint = drsctl["ctd_glint"] self.chains = drsctl["ctd_chain"] self.glac = 0 if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["drs_ctl", "vat_ctl", "dis_all"] if self.gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) return True def buildScreen(self): num_sel = { "stype": "R", "tables": ("drsrcm", ), "cols": (("dcm_num", "", 0, "Number"), ("dcm_desc", "", 0, "Description", "Y"), ("dcm_freq", "", 0, "F")), "where": [("dcm_cono", "=", self.opts["conum"])] } seq_sel = { "stype": "R", "tables": ("drsrct", ), "cols": (("dct_seq", "", 0, "Seq"), ("dct_chain", "", 0, "Chn"), ("dct_acno", "", 0, "Acc-Num"), ("dct_detail", "", 0, "Charge Details"), ("dct_amnt", "", 0, "Amount"), ("dct_start", "", 0, "Start"), ("dct_end", "", 0, "End")), "where": [("dct_cono", "=", self.opts["conum"])], "whera": (("T", "dct_num", 0), ) } chn_sel = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } drm_sel = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y")), "where": [("drm_cono", "=", self.opts["conum"]), ("drm_stat", "<>", "X")], "whera": (("C", "drm_chain", 1, 0), ) } glm_sel = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } vat_sel = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"), ("Annually", "Y")) fld = [ (("T",0,0,0),"IUI",3, "Number","Charge Number", "","Y",self.doNum,num_sel,None,None), (("T",0,1,0),"INA",30,"Description","", "","N",self.doDesc,None,self.doDelNum,("notblank",)), (("T",0,2,0),("IRB",r1s),0, "Frequency","", "M","N",self.doFreq,None,None,None), (("T",0,3,0),"IUI",2, "Day of the Month","Day of the Month", "","N",self.doDay,num_sel,None,("between",1,30),None, "Enter the day of the month when the entry must be raised. "\ "Use 30 to denote the last day of the month.")] if self.glint == "Y": fld.append( (("T", 0, 4, 0), "IUI", 7, "Charge Account", "G/L Account", "", "N", self.doGlAc, glm_sel, None, ("notzero", ))) fld.append((("T", 0, 4, 0), "ONA", 30, "")) nxt = 5 else: nxt = 4 fld.append( (("T", 0, nxt, 0), "IUA", 1, "VAT Code", "V.A.T. Code", self.taxdf, "N", self.doVat, vat_sel, None, ("notblank", ))) fld.append((("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i", "N", self.doSeq, seq_sel, None, ("notzero", ))) if self.chains == "Y": fld.append((("C", 0, 0, 0), "IUI", 3, "Chn", "Chain Store", "", "N", self.doChn, chn_sel, self.doDelSeq, ("efld", ))) else: self.chn = 0 fld.append((("C", 0, 0, 0), "OUI", 3, "Chn")) fld.append((("C", 0, 0, 1), "INA", 7, "Acc-Num", "Account Number", "", "N", self.doAcc, drm_sel, self.doDelSeq, ("efld", ))) fld.extend( ((("C", 0, 0, 2), "ONA", 30, "Name", "", "", "N", None, None, None, None), (("C", 0, 0, 3), "ITX", 30, "Charge-Details", "Charge Details", "", "N", self.doDetail, None, None, None), (("C", 0, 0, 4), "ISD", 13.2, "Excl-Value", "Period Exclusive Value", "", "N", self.doValue, None, None, ("efld", )), (("C", 0, 0, 5), "ID2", 7, "Start", "Starting Period", "", "N", self.doStart, None, None, ("efld", )), (("C", 0, 0, 6), "ID2", 7, "End", "Ending Period", "", "N", self.doEnd, None, None, ("efld", )))) but = (("All Entries", seq_sel, None, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("Re-Sequence", None, self.doReSeq, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("Abort Changes", None, self.doAbort, 0, ("C", 0, 1), ("T", 0, 1))) tnd = ((self.endTop, "y"), ) txt = (self.exitTop, ) cnd = ((self.endCol, "y"), ) cxt = (self.exitCol, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doNum(self, frt, pag, r, c, p, i, w): if not w: num = self.sql.getRec("drsrcm", cols=["max(dcm_num)"], where=[("dcm_cono", "=", self.opts["conum"]) ], limit=1) if not num or not num[0]: self.num = 1 else: self.num = num[0] + 1 self.df.loadEntry(frt, pag, p, data=self.num) else: self.num = w self.rcm = self.sql.getRec("drsrcm", where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", self.num)], limit=1) if not self.rcm: if self.num == 999: return "Invalid Number (999), Reserved for Sales Invoices" self.new_num = "y" self.nxt = 1 else: d = self.sql.drsrcm_col self.new_num = "n" self.df.loadEntry(frt, pag, p + 1, data=self.rcm[d.index("dcm_desc")]) self.df.loadEntry(frt, pag, p + 2, data=self.rcm[d.index("dcm_freq")]) self.df.loadEntry(frt, pag, p + 3, data=self.rcm[d.index("dcm_day")]) if self.glint == "Y": self.df.loadEntry(frt, pag, p + 4, data=self.rcm[d.index("dcm_glac")]) self.df.loadEntry(frt, pag, p + 5, data=self.getAccount()) self.df.loadEntry(frt, pag, p + 6, data=self.rcm[d.index("dcm_vat")]) else: self.df.loadEntry(frt, pag, p + 4, data=self.rcm[d.index("dcm_vat")]) for x in range(2): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") if self.num == 999: return "nd" def getAccount(self): return self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", self.df.t_work[0][0][4])], limit=1)[0] def doDelNum(self): if self.new_num == "y": return self.sql.delRec("drsrcm", where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", self.num)]) try: self.sql.delRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.acc)]) except: pass def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doFreq(self, frt, pag, r, c, p, i, w): self.freq = w if self.glint == "N": self.vcod = self.taxdf def doDay(self, frt, pag, r, c, p, i, w): self.day = w def doGlAc(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.glac = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) if not chk[2]: self.vcod = self.taxdf else: self.vcod = chk[2] self.df.topf[0][4][8] = self.vcod def doVat(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) if not acc: return "Invalid VAT Code" self.vcod = w def endTop(self): data = [ self.opts["conum"], self.num, self.desc, self.freq, self.day, self.vcod, self.glac, 0 ] if self.new_num == "y": self.sql.insRec("drsrcm", data=data) self.df.loadEntry("C", 0, 0, data=1) self.df.focusField("C", 0, self.nxt) else: if data != self.rcm[:len(data)]: col = self.sql.drsrcm_col data.append(self.rcm[col.index("dcm_xflag")]) self.sql.updRec("drsrcm", data=data, where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", self.num)]) self.doReload() def exitTop(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doSeq(self, frt, pag, r, c, p, i, w): self.seq = w self.rct = self.sql.getRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("dct_seq", "=", self.seq)], limit=1) if not self.rct: self.new_seq = "y" else: self.new_seq = "n" col = self.sql.drsrct_col self.df.loadEntry(frt, pag, p + 1, data=self.rct[col.index("dct_chain")]) self.df.loadEntry(frt, pag, p + 2, data=self.rct[col.index("dct_acno")]) acc = self.sql.getRec("drsmst", cols=["drm_name"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.rct[col.index("dct_chain")]), ("drm_acno", "=", self.rct[col.index("dct_acno")])], limit=1) self.df.loadEntry(frt, pag, p + 3, data=acc[0]) self.df.loadEntry(frt, pag, p + 4, data=self.rct[col.index("dct_detail")]) self.df.loadEntry(frt, pag, p + 5, data=self.rct[col.index("dct_amnt")]) self.df.loadEntry(frt, pag, p + 6, data=self.rct[col.index("dct_start")]) self.df.loadEntry(frt, pag, p + 7, data=self.rct[col.index("dct_end")]) def doDelSeq(self): if self.new_seq == "y": return self.sql.delRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("dct_seq", "=", self.seq)]) self.doReload() def doChn(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drschn", where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", w)], limit=1) if not acc: return "Invalid Chain Store" self.chn = w def doAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chn), ("drm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[1] == "X": return "Invalid Account, Redundant" self.acc = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doDetail(self, frt, pag, r, c, p, i, w): self.det = w def doValue(self, frt, pag, r, c, p, i, w): self.val = w def doStart(self, frt, pag, r, c, p, i, w): self.start = w def doEnd(self, frt, pag, r, c, p, i, w): if w < self.start: return "Invalid End Date, Before Start" self.end = w def endCol(self): data = [ self.opts["conum"], self.num, self.seq, self.chn, self.acc, self.det, self.val, self.start, self.end ] if self.new_seq == "y": self.sql.insRec("drsrct", data=data) elif data != self.rct[:len(data)]: col = self.sql.drsrct_col data.append(self.rct[col.index("dct_xflag")]) self.sql.updRec("drsrct", data=data, where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("dct_seq", "=", self.seq)]) self.doReload() def exitCol(self): self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doReSeq(self): recs = self.sql.getRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num)], order="dct_chain, dct_acno") self.sql.delRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num)]) seq = 0 for rec in recs: seq += 1 rec[2] = seq self.sql.insRec("drsrct", data=rec) self.doReload() def doAbort(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doReload(self): self.df.clearFrame("C", 0) last = (self.df.rows[0] - 1) * 8 trn = self.sql.getRec(tables=["drsrct", "drsmst"], cols=[ "dct_seq", "dct_chain", "dct_acno", "drm_name", "dct_detail", "dct_amnt", "dct_start", "dct_end" ], where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("drm_cono=dct_cono", ), ("drm_chain=dct_chain", ), ("drm_acno=dct_acno", )], order="dct_seq") if trn: for s, t in enumerate(trn): if s >= self.df.rows[0]: self.df.scrollScreen(0) p = last else: p = s * 8 self.df.loadEntry("C", 0, p, data=t[0]) self.df.loadEntry("C", 0, p + 1, data=t[1]) self.df.loadEntry("C", 0, p + 2, data=t[2]) self.df.loadEntry("C", 0, p + 3, data=t[3]) self.df.loadEntry("C", 0, p + 4, data=t[4]) self.df.loadEntry("C", 0, p + 5, data=t[5]) self.df.loadEntry("C", 0, p + 6, data=t[6]) self.df.loadEntry("C", 0, p + 7, data=t[7]) if p == last: self.df.scrollScreen(0) self.nxt = last + 1 else: self.nxt = p + 9 else: self.nxt = 1 self.df.focusField("C", 0, self.nxt)
class tb1010(object): def __init__(self, **opts): self.opts = opts self.opts["mf"].dbm.openDbase() if self.setVariables(): self.doProcess() 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 return True def doProcess(self): fft = { "stype": "R", "tables": ("ftable", ), "cols": (("ft_tabl", "", 0, "Table"), ("ft_desc", "", 0, "Description", "Y")), "where": [("ft_seq", "=", 1)] } ffl = { "stype": "R", "tables": ("ffield", ), "cols": (("ff_seq", "", 0, "Seq"), ("ff_name", "", 0, "Name"), ("ff_desc", "", 0, "Description", "Y"), ("ff_type", "", 0, "Tp"), ("ff_size", "", 0, "Size")), "whera": (("T", "ff_tabl", 0, 0), ), "index": 0 } ffi = { "stype": "R", "tables": ("ftable", ), "cols": (("ft_seq", "", 0, "Seq"), ("ft_type", "", 0, "T"), ("ft_key0", "", 0, "Column-1"), ("ft_key1", "", 0, "Column-2"), ("ft_key2", "", 0, "Column-3"), ("ft_key3", "", 0, "Column-4"), ("ft_key4", "", 0, "Column-5"), ("ft_key4", "", 0, "Column-6"), ("ft_key4", "", 0, "Column-7")), "whera": (("T", "ft_tabl", 0, 0), ), "comnd": self.doIdxCmd } typ = { "stype": "C", "titl": "Select the Required Data Type", "head": ("Cd", "Description"), "data": dattyp, "index": 0 } valtyp = [] for t in dattyp: valtyp.append(t[0]) self.col = { "stype": "C", "titl": "Select the Required Column", "head": ("Table", "Description"), "data": [] } fld = [(("T", 0, 0, 0), "INA", 20, "Table ", "Table Name", "", "Y", self.doTable, fft, None, ("notin", ("", "ftable", "ffield"))), (("T", 0, 0, 0), "INA", 30, " Description ", "Description", "", "N", self.doDesc, None, None, None), (("C", 1, 0, 0), "IUI", 3, "Seq", "Column Sequence", "i", "N", self.doColSeq, ffl, None, ("between", 0, 999)), (("C", 1, 0, 1), "INA", 20, "Column", "Column Name", "", "N", None, None, None, ("notblank", )), (("C", 1, 0, 2), "INA", 2, "Tp", "Data Type", "", "N", None, typ, None, ("in", valtyp)), (("C", 1, 0, 3), "IUD", 6.1, "Size", "Field Size", "", "N", None, None, None, ("notzero", )), (("C", 1, 0, 4), "INA", 30, "Description", "", "", "N", None, None, None, None), (("C", 1, 0, 5), "INA", 30, "Heading", "Report Heading", "", "N", None, None, None, ("notblank", )), (("C", 2, 0, 0), "IUI", 1, "S", "Sequence", "i", "N", self.doIdxSeq, ffi, None, ("efld", )), (("C", 2, 0, 1), "IUA", 1, "T", "Type (U/N)", "", "N", None, None, None, ("in", ("U", "N"))), (("C", 2, 0, 2), "INA", (14, 20), "Column-0", "", "", "N", self.doIdxCol, self.col, None, ("notblank", )), (("C", 2, 0, 3), "INA", (14, 20), "Column-1", "", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 4), "INA", (14, 20), "Column-2", "", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 5), "INA", (14, 20), "Column-3", "", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 6), "INA", (14, 20), "Column-4", "", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 7), "INA", (5, 20), "Col-5", "Column-5", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 8), "INA", (5, 20), "Col-6", "Column-6", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 9), "INA", (5, 20), "Col-7", "Column-7", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 10), "INA", (5, 20), "Col-8", "Column-8", "", "N", self.doIdxCol, self.col, None, ("efld", )), (("C", 2, 0, 11), "INA", (5, 20), "Col-9", "Column-9", "", "N", self.doIdxCol, self.col, None, ("efld", ))] tag = (("Columns", None, ("C", 1, 1), ("T", 0, 1)), ("Indexes", None, ("C", 1, 1), ("T", 0, 1))) row = (0, 15, 5) tnd = ((self.endTop, "y"), ) txt = (self.exitTop, ) cnd = ((None, "n"), (self.endPage1, "y"), (self.endPage2, "y")) cxt = (None, self.exitPage1, self.exitPage2) but = (("Print", None, self.doPrint, 0, ("T", 0, 2), ("T", 0, 1)), ("Cancel", None, self.doRestart, 0, ("T", 0, 2), ("T", 0, 1))) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doTable(self, frt, pag, r, c, p, i, w): self.tab = w tab = self.sql.getRec("ftable", cols=["ft_tabl", "ft_desc"], where=[("ft_tabl", "=", w), ("ft_seq", "=", 1)], limit=1) if not tab: self.new = "y" else: self.new = "n" self.df.loadEntry(frt, pag, p + 1, data=tab[1]) yn = askQuestion(screen=self.opts["mf"].body, head="Table Exists", mess="Changing This Record Could Result In Loss of Data, "\ "Are You Sure You Want to Continue?", default="no") if yn == "no": return yn def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def endTop(self): self.fld = makeArray(6, 100, 1, "S") self.idx = makeArray(12, 20, 1, "S") if self.new == "n": fld = self.sql.getRec("ffield", where=[("ff_tabl", "=", self.tab)], order="ff_seq") for n, f in enumerate(fld): self.fld[n] = f[1:] idx = self.sql.getRec("ftable", where=[("ft_tabl", "=", self.tab)], order="ft_seq") for n, f in enumerate(idx): self.idx[n] = f[2:] self.idx[n][0] = n self.doPopulate("fld") else: self.df.focusField("C", 1, 1) def exitTop(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doColSeq(self, frt, pag, r, c, p, i, w): self.colseq = w for n, s in enumerate(self.fld[self.colseq][1:]): self.df.loadEntry("C", 1, p + n + 1, data=s) def endPage1(self): pos = int(self.df.col / self.df.colq[1]) - 1 self.fld[self.colseq] = copyList(self.df.c_work[1][pos]) self.doPopulate("fld") def exitPage1(self): self.createCols() self.df.selPage("Indexes") self.doPopulate("idx") def createCols(self): self.valcol = [] self.col["data"] = [] for fld in self.fld: self.valcol.append(fld[1]) self.col["data"].append([fld[1], fld[4]]) def doIdxCmd(self, frt, pag, r, c, p, i, w): idxseq = int(w[0]) - 1 self.doIdxSeq(frt, pag, r, c, p, i, idxseq) self.df.focusField(frt, pag, c + 1) def doIdxSeq(self, frt, pag, r, c, p, i, w): self.idxseq = w for n, s in enumerate(self.idx[self.idxseq][1:]): self.df.loadEntry("C", 2, p + n + 1, data=s) def doIdxCol(self, frt, pag, r, c, p, i, w): if w and w not in self.valcol: return "Invalid Column" def endPage2(self): pos = int(self.df.col / self.df.colq[2]) - 1 self.idx[self.idxseq] = copyList(self.df.c_work[2][pos]) self.doPopulate("idx") def exitPage2(self): if self.new == "y" and self.df.col == 1: self.df.selPage("Columns") else: if self.tab in tabdic: tabdic[self.tab]["fld"] = [] tabdic[self.tab]["idx"] = [] else: tabdic[self.tab] = {"fld": [], "idx": []} for dat in self.fld: if dat == [""] * 6: break tabdic[self.tab]["fld"].append(dat) for num, dat in enumerate(self.idx): if dat == [""] * 12: break if num == 0: dat.insert(0, self.df.t_work[0][0][1]) else: dat.insert(0, "") dat[1] = num + 1 fmt = '"%s",%s,"%s"' ddd = dat[:3] for n, d in enumerate(dat[3:]): if d: fmt += ',"%s"' ddd.append(d) fmt += "\n" tabdic[self.tab]["idx"].append(ddd) fle = os.path.join(getPrgPath(), "stdtab.py") outf = open(fle, "w") outf.write("""tabdic = {""") tabs = list(tabdic.keys()) tabs.sort() for tab in tabs: outf.write(""" "%s": {""" % tab) for key in ("fld", "idx"): outf.write(""" "%s": [""" % key) for fld in tabdic[tab][key]: outf.write(""" %s""" % json.dumps(fld)) if fld == tabdic[tab][key][-1]: outf.write("""]""") else: outf.write(""",""") if key == "fld": outf.write(""",""") outf.write("""}""") if tab != tabs[-1]: outf.write(""",""") outf.write("""}""") outf.close() self.doRestart() def doPopulate(self, ftyp=None): if ftyp == "fld": self.df.clearFrame("C", 1) for num, dat in enumerate(self.fld): if dat == [""] * 6: break if num > 14: self.df.scrollScreen(1) pos = 14 else: pos = num self.df.focusField("C", 1, (pos * 6) + 1) for n, c in enumerate(dat): self.df.loadEntry("C", 1, (pos * 6) + n, data=c) self.df.advanceLine(1) return self.df.clearFrame("C", 2) for num, dat in enumerate(self.idx): if dat == [""] * 12: break if num > 4: self.df.scrollScreen(2) pos = 4 else: pos = num self.df.focusField("C", 2, (pos * 12) + 1) for n, c in enumerate(dat): self.df.loadEntry("C", 2, (pos * 12) + n, data=c) self.df.advanceLine(2) self.df.focusField("C", 2, self.df.col) def doRestart(self): self.df.last[0] = [0, 0] self.df.selPage("Columns") self.df.focusField("T", 0, 1) def doPrint(self): state = self.df.disableButtonsTags() cols = [["ff_seq", "UI", 3.0, "Seq"], ["ff_name", "NA", 20.0, "Field Name"], ["ff_type", "NA", 2.0, "Tp"], ["ff_size", "NA", 6.1, "Size"], ["ff_desc", "NA", 30.0, "Description"], ["ff_head", "NA", 20.0, "Heading"]] whr = [("ff_tabl", "=", self.tab)] RepPrt(self.opts["mf"], name=self.tab + "_fld", tables=["ffield"], heads=[ "Table Fields for Table %s" % self.tab, ], cols=cols, where=whr) cols = [["ft_desc", "NA", 30.0, "Table Description"], ["ft_seq", "UI", 2.0, "Sq"], ["ft_type", "NA", 1.0, "T"], ["ft_key0", "NA", 10.0, "1st-Key"], ["ft_key1", "NA", 10.0, "2nd-Key"], ["ft_key2", "NA", 10.0, "3rd-Key"], ["ft_key3", "NA", 10.0, "4th-Key"], ["ft_key4", "NA", 10.0, "5th-Key"], ["ft_key5", "NA", 10.0, "6th-Key"], ["ft_key6", "NA", 10.0, "7th-Key"], ["ft_key7", "NA", 10.0, "8th-Key"], ["ft_key8", "NA", 10.0, "9th-Key"], ["ft_key9", "NA", 10.0, "10th-Key"]] whr = [("ft_tabl", "=", self.tab)] RepPrt(self.opts["mf"], name=self.tab + "_idx", tables=["ftable"], heads=[ "Table Keys for Table %s" % self.tab, ], cols=cols, where=whr) self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col)