class gl1040(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, ["gendtm", "gendtt"], prog=self.__class__.__name__) if self.sql.error: return self.sper = int(self.opts["period"][1][0] / 100) self.eper = int(self.opts["period"][2][0] / 100) return True def buildScreen(self): cod_sel = { "stype": "R", "tables": ("gendtm", ), "cols": (("gdm_code", "", 0, "Cod"), ("gdm_desc", "", 0, "Description", "Y")), "where": [("gdm_cono", "=", self.opts["conum"])] } per_sel = { "stype": "R", "tables": ("gendtt", ), "cols": (("gdt_curdt", "", 0, "Period"), ("gdt_value", "", 0, "Value")), "where": [("gdt_cono", "=", self.opts["conum"]), ("gdt_curdt", "between", self.sper, self.eper)], "whera": (("T", "gdt_code", 0), ) } fld = ((("T", 0, 0, 0, 4), "INa", 2, "Code", "", "", "Y", self.doCode, cod_sel, None, ("notblank", )), (("T", 0, 0, 0), "INA", 30, "Description", "", "", "N", self.doDesc, None, self.doDelCode, ("notblank", )), (("C", 0, 0, 0), "ID2", 7, "Period", "Financial Period", "p", "N", self.doPeriod, per_sel, None, None), (("C", 0, 0, 1), "ISD", 13.2, "Value", "Period Value", "", "N", self.doValue, None, self.doDelPeriod, None)) row = (17, ) but = (("Cancel", None, self.doCancel, 0, ("C", 0, 1), ("T", 0, 1)), ("Quit", None, self.exitTops, 1, None, None)) txt = (self.exitTops, ) tnd = ((self.endTops, "y"), ) cnd = ((self.endData, "y"), ) cxt = (self.exitData, ) self.df = TartanDialog(self.opts["mf"], sc=None, eflds=fld, rows=row, butt=but, tend=tnd, cend=cnd, txit=txt, cxit=cxt) def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.oldm = self.sql.getRec("gendtm", where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=", self.code)], limit=1) if not self.oldm: self.newcod = True else: self.newcod = False desc = self.oldm[self.sql.gendtm_col.index("gdm_desc")] self.df.loadEntry(frt, pag, p + 1, data=desc) self.loadPeriods(focus=False) def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doDelCode(self): self.sql.delRec("gendtm", where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=", self.code)]) self.sql.delRec("gendtt", where=[("gdt_cono", "=", self.opts["conum"]), ("gdt_code", "=", self.code)]) self.exitData() def endTops(self): data = [self.opts["conum"], self.code, self.desc] if self.newcod: self.sql.insRec("gendtm", data=data) self.df.focusField("C", 0, 1) else: if data != self.oldm[:len(data)]: col = self.sql.gendtm_col data.append(self.oldm[col.index("gdm_xflag")]) self.sql.updRec("gendtm", data=data, where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=", self.code)]) self.df.focusField("C", 0, self.col) def doPeriod(self, frt, pag, r, c, p, i, w): if w < self.sper or w > self.eper: return "Invalid Period" self.per = w self.oldt = self.sql.getRec("gendtt", where=[("gdt_cono", "=", self.opts["conum"]), ("gdt_code", "=", self.code), ("gdt_curdt", "=", self.per)], limit=1) if not self.oldt: self.newper = "y" else: self.newper = "n" val = self.oldt[self.sql.gendtt_col.index("gdt_value")] self.df.loadEntry(frt, pag, p + 1, data=val) def doDelPeriod(self): if self.newper == "y": return self.sql.delRec("gendtt", where=[("gdt_cono", "=", self.opts["conum"]), ("gdt_code", "=", self.code), ("gdt_curdt", "=", self.per)]) self.loadPeriods() def doValue(self, frt, pag, r, c, p, i, w): self.val = w def endData(self): data = [self.opts["conum"], self.code, self.per, self.val] if self.newper == "y": self.sql.insRec("gendtt", data=data) elif data != self.oldt[:len(data)]: col = self.sql.gendtt_col data.append(self.oldt[col.index("gdt_xflag")]) self.sql.updRec("gendtt", data=data, where=[("gdt_cono", "=", self.opts["conum"]), ("gdt_code", "=", self.code), ("gdt_curdt", "=", self.per)]) self.loadPeriods() def loadPeriods(self, focus=True): self.df.clearFrame("C", 0) pers = self.sql.getRec("gendtt", cols=["gdt_curdt", "gdt_value"], where=[("gdt_cono", "=", self.opts["conum"]), ("gdt_code", "=", self.code), ("gdt_curdt", "between", self.sper, self.eper)]) if pers: for num, per in enumerate(pers): p = (num * 2) self.df.loadEntry("C", 0, p, data=per[0]) self.df.loadEntry("C", 0, p + 1, data=per[1]) self.col = p + 3 else: self.col = 1 if focus: self.df.focusField("C", 0, self.col) 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 exitData(self): self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1)
class ms1010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlynd", "ctlvmf", "ctlvrf", "chglog"], prog=self.__class__.__name__) if self.sql.error: return cnt = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1) if not cnt[0]: self.first = True else: self.first = False self.img = None return True def mainProcess(self): self.tit = ("Company Records File Maintenance", ) ctm = { "stype": "R", "tables": ("ctlmst", ), "cols": (("ctm_cono", "", 0, "Num"), ("ctm_name", "", 0, "Name", "Y")) } log = {"stype": "F", "types": "fle", "ftype": (("Image", "*"), )} r1s = (("Yes", "Y"), ("No", "N")) tag = (("General", None, ("T", 1, 2), ("T", 1, 1)), ("Banking", None, ("T", 1, 2), ("T", 1, 1)), ("Systems", None, ("T", 1, 2), ("T", 1, 1)), ("Logo", None, ("T", 1, 2), ("T", 1, 1))) fld = [[("T", 1, 0, 0), "IUI", 3, "Company Number", "Number", "", "Y", self.doCoyNum, ctm, None, ("notzero", )], (("T", 1, 1, 0), "INA", 30, "Name", "Company Name", "", "N", self.doCoyNam, None, self.doDelete, ("notblank", )), (("T", 1, 2, 0), "INA", 30, "Postal Address Line-1", "Address Line-1", "", "N", None, None, None, None), (("T", 1, 3, 0), "INA", 30, " Line-2", "Address Line-2", "", "N", None, None, None, None), (("T", 1, 4, 0), "INA", 30, " Line-3", "Address Line-3", "", "N", None, None, None, None), (("T", 1, 5, 0), "INA", 4, "Postal Code", "", "", "N", None, None, None, None), (("T", 1, 6, 0), "INA", 30, "Street Address Line-1", "Street Address Line-1", "", "N", None, None, None, None), (("T", 1, 7, 0), "INA", 30, " Line-2", "Address Line-2", "", "N", None, None, None, None), (("T", 1, 8, 0), "INA", 30, " Line-3", "Address Line-3", "", "N", None, None, None, None), (("T", 1, 9, 0), "INA", 4, "Street Code", "", "", "N", None, None, None, None), (("T", 1, 10, 0), "INA", 30, "Contact Name", "", "", "N", None, None, None, None), (("T", 1, 11, 0), "INA", 15, "Telephone", "Telephone No", "", "N", None, None, None, None), (("T", 1, 12, 0), "INA", 15, "Facsimile", "Facsimile No", "", "N", None, None, None, None), (("T", 1, 13, 0), "INA", 15, "Mobile", "Mobile Number", "", "N", None, None, None, None), (("T", 1, 14, 0), "ITX", 50, "E-Mail Address", "", "", "N", None, None, None, ("email", )), (("T", 1, 15, 0), "ITX", 50, "Internet URL", "", "", "N", None, None, None, ("efld", )), (("T", 1, 16, 0), "INA", 20, "Registration No", "", "", "N", None, None, None, None), (("T", 1, 17, 0), "INA", 20, "V.A.T. Number", "", "", "N", self.doVatNum, None, None, None), (("T", 1, 18, 0), "IUA", 1, "V.A.T. Default", "", "", "N", self.doVatCod, None, None, ("notblank", )), (("T", 2, 0, 0), "INA", 30, "Bank Name", "", "", "N", None, None, None, None), (("T", 2, 1, 0), "INA", 30, "Bank Branch", "", "", "N", None, None, None, None), (("T", 2, 2, 0), "INA", 8, "Bank IBT", "Bank IBT Number", "", "N", None, None, None, None), (("T", 2, 3, 0), "INA", 16, "Bank Account", "Bank Account Number", "", "N", None, None, None, None)] pos = 1 self.sys = [] for x in range(len(allsys)): for sss in allsys: if allsys[sss][3] == pos: self.sys.append(allsys[sss][1]) fld.append( (("T", 3, pos, 0), ("IRB", r1s), 0, allsys[sss][0], "", "N", "N", None, None, None, None)) pos += 1 fld.append((("T", 4, 0, 0), "IFF", 75, "Letterhead Image", "", "", "N", self.doLogo, log, None, ("fle", "blank"))) but = (("Accept", None, self.doAccept, 0, ("T", 1, 2), (("T", 1, 1), ("T", 4, 0))), ("Print", None, self.doPrint, 0, ("T", 1, 2), (("T", 1, 1), ("T", 4, 0))), ("Cancel", None, self.doCancel, 0, ("T", 1, 2), (("T", 1, 1), ("T", 4, 0))), ("Quit", None, self.doExit1, 1, None, None)) tnd = (None, (self.doEnd, "n"), (self.doEnd, "n"), (self.doEnd, "n"), (self.doEnd, "y")) txt = (None, self.doExit1, self.doExit2, self.doExit3, self.doExit4) self.df = TartanDialog(self.opts["mf"], title=self.tit, tags=tag, eflds=fld, butt=but, tend=tnd, txit=txt, clicks=self.doClick) if self.first: self.opts["conum"] = 1 self.new = True self.df.topf[1][0][1] = "OUI" self.df.loadEntry("T", 1, 0, data=self.opts["conum"]) self.df.focusField("T", 1, 2) def doClick(self, *opts): if self.df.pag == 1 and self.df.col == 1: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doCoyNum(self, frt, pag, r, c, p, i, w): if w == 0: return "Invalid Company Number" elif w != 1: chk = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", 1)], limit=1) if not chk: return "Company 1 Must First Exist" self.opts["conum"] = w self.old = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"]) ], limit=1) if not self.old: self.new = True else: self.new = False self.opts["conam"] = self.old[self.sql.ctlmst_col.index( "ctm_name")] for x in range(1, self.df.topq[pag]): data = self.old[x] self.df.loadEntry(frt, pag, x, data=data) for x in range(0, self.df.topq[pag + 1]): data = self.old[x + self.df.topq[pag]] self.df.loadEntry(frt, pag + 1, x, data=data) for x in range(0, self.df.topq[pag + 2]): self.df.loadEntry(frt, pag + 2, x, data="N") mods = self.old[self.sql.ctlmst_col.index("ctm_modules")].rstrip() for x in range(0, len(mods), 2): idx = self.sys.index(mods[x:x + 2]) self.df.loadEntry(frt, pag + 2, idx, data="Y") self.logo = self.old[self.sql.ctlmst_col.index("ctm_logo")] self.df.loadEntry(frt, pag + 3, 0, data=self.logo) if self.logo: self.displayLogo(self.logo) def doDelete(self): if self.opts["conum"] == 1: showError(self.opts["mf"].body, "Deletion Error", "Company 1 Cannot be Deleted") return err = False skp = { "ctlmst": "ctm_cono", "ctlynd": "cye_cono", "ctlvmf": "vtm_cono", "ctlvrf": "vtr_cono" } for tab in tabdic: if tab in skp: continue chk = tabdic[tab]["fld"][0][1] if chk.count("_cono"): sql = Sql(self.opts["mf"].dbm, tab, prog=self.__class__.__name__) err = sql.getRec(tables=tab, where=[(chk, "=", self.opts["conum"])]) if err: break if err: showError(self.opts["mf"].body, "Deletion Error", "%s Records Exist for This Company, Cannot Delete" % tab) return for tab in skp: self.sql.delRec(tab, where=[(skp[tab], "=", self.opts["conum"])]) self.opts["mf"].dbm.commitDbase(ask=True) def doCoyNam(self, frt, pag, r, c, p, i, w): self.opts["conam"] = w chk = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=", self.opts["conum"])], limit=1) if not chk: self.sql.insRec("ctlvmf", data=[self.opts["conum"], "N", "No VAT", "N"]) self.sql.insRec("ctlvrf", data=[self.opts["conum"], "N", 0, 0]) def doVatNum(self, frt, pag, r, c, p, i, w): self.vatnum = w if not self.vatnum: 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): self.vat = w acc = self.doReadVat(self.vat) if not acc: ok = askQuestion( self.opts["mf"].body, "VAT Code", "This Code Does Not Exist, Do You Want to Create It?") if ok == "no": return "Invalid Code" state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") callModule(self.opts["mf"], None, "ms1040", coy=(self.opts["conum"], self.opts["conam"]), user=self.opts["capnm"], args=self.vat) self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) acc = self.doReadVat(self.vat) if not acc: self.df.loadEntry(frt, pag, p, data="") return "Invalid Code" def doLogo(self, frt, pag, r, c, p, i, w): if not w: if self.img: self.img.destroyImage() else: self.logo = os.path.normpath(w) if self.displayLogo(self.logo): return "Invalid Logo Image" self.df.loadEntry(frt, pag, p, data=self.logo) def displayLogo(self, logo): try: if self.img: try: self.img.destroyImage() except: pass self.img = ShowImage(self.df.nb.Page4, logo, wrkdir=self.opts["mf"].rcdic["wrkdir"], msiz=640) except: return "error" def doReadVat(self, w): acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) return acc def doEnd(self): if self.df.pag == 1: self.df.selPage("Banking") self.df.focusField("T", 2, 1) elif self.df.pag == 2: self.df.selPage("Systems") self.df.focusField("T", 3, 1) elif self.df.pag == 3: self.df.selPage("Logo") self.df.focusField("T", 4, 1) else: data = [] mods = "" for x in range(0, len(self.df.t_work[1][0])): data.append(self.df.t_work[1][0][x]) for x in range(0, len(self.df.t_work[2][0])): data.append(self.df.t_work[2][0][x]) fin = False for x in range(0, len(self.df.t_work[3][0])): if self.df.t_work[3][0][x] == "Y": mod = self.sys[x] if mod not in ("BC", "BS", "SC"): fin = True mods = mods + mod data.append(mods) data.extend(self.df.t_work[4][0][0:2]) if self.new: self.sql.insRec("ctlmst", data=data) elif data != self.old[:len(data)]: col = self.sql.ctlmst_col data.append(self.old[col.index("ctm_xflag")]) self.sql.updRec("ctlmst", data=data, where=[("ctm_cono", "=", self.opts["conum"])]) 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=[ "ctlmst", "U", "%03i" % self.opts["conum"], col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) if fin: # Financial Systems ynd = self.sql.getRec("ctlynd", cols=["count(*)"], where=[("cye_cono", "=", self.opts["conum"])], limit=1) if not ynd[0]: self.doFinPeriod() if self.xits == "y": self.doCancel() return True self.opts["mf"].dbm.commitDbase() if self.first: self.doExit1() else: self.df.selPage("General") self.df.focusField("T", 1, 1) def doFinPeriod(self): tit = ("Initial Financial Period", ) fld = ((("T", 0, 0, 0), "ID1", 10, "Period Start Date", "", "", "N", self.doStartPer, None, None, ("efld", )), (("T", 0, 1, 0), "ID1", 10, "Period End Date", "", "", "N", self.doEndPer, None, None, ("efld", ))) tnd = ((self.doPerEnd, "y"), ) txt = (self.doPerExit, ) state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") self.pf = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=tnd, txit=txt) self.pf.mstFrame.wait_window() self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) self.opts["mf"].head.configure(text=self.tit[0]) def doStartPer(self, frt, pag, r, c, p, i, w): y = int(w / 10000) - 1 m = int((w % 10000) / 100) if m == 2: if not y % 4: d = 29 else: d = 28 else: d = w % 100 self.s0 = (y * 10000) + (m * 100) + d self.s1 = w y = int(w / 10000) + 1 m -= 1 if not m: m = 12 y -= 1 self.pf.t_work[0][0][1] = mthendDate((y * 10000) + (m * 100) + 1) def doEndPer(self, frt, pag, r, c, p, i, w): if w <= self.s1: return "Invalid End Period" y = int(w / 10000) - 1 m = int((w % 10000) / 100) if m == 2: if not y % 4: d = 29 else: d = 28 else: d = w % 100 self.e0 = (y * 10000) + (m * 100) + d self.e1 = w def doPerEnd(self): self.sql.insRec("ctlynd", data=[self.opts["conum"], 0, self.s0, self.e0, 0, "N"]) self.sql.insRec("ctlynd", data=[self.opts["conum"], 1, self.s1, self.e1, 0, "N"]) self.xits = "n" self.closeProcess() def doPerExit(self): self.xits = "y" self.closeProcess() def closeProcess(self): self.pf.closeProcess() def doAccept(self): for page in range(4): frt, pag, col, mes = self.df.doCheckFields(("T", page + 1, None)) if mes: break if mes: self.df.last[pag][0] = col + 1 self.df.selPage(self.df.tags[pag - 1][0]) self.df.focusField(frt, pag, (col + 1), err=mes) else: mod = False for x in range(len(self.df.t_work[3][0])): if self.df.t_work[3][0][x] == "Y": mod = True break if not mod: self.df.selPage("Systems") self.df.focusField("T", 3, 1, err="Missing System Module") else: if self.img: self.img.destroyImage() self.df.selPage("Logo") self.df.doEndFrame("T", 4, cnf="N") def doPrint(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") TabPrt(self.opts["mf"], self.opts["conum"], name=self.__class__.__name__, tabs="ctlmst", where=[("ctm_cono", "=", self.opts["conum"])]) 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.selPage("General") self.df.focusField("T", 1, 1) def doExit1(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doExit2(self): self.df.selPage("General") def doExit3(self): self.df.selPage("Banking") def doExit4(self): self.df.selPage("Systems")
class sl2020(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", "wagmst", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return self.col = self.sql.waglmf_col gc = GetCtl(self.opts["mf"]) wagctl = gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.glint = wagctl["ctw_glint"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["wag_slc", "wag_sli"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.glctls = (ctlctl["wag_slc"], ctlctl["wag_sli"]) else: self.glctls = None self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "SLN", 5, glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return def dataHeader(self): wgm = { "stype": "R", "tables": ("wagmst", ), "cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0, "Names")), "where": [("wgm_cono", "=", self.opts["conum"])] } lnm = { "stype": "R", "tables": ("waglmf", ), "cols": (("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0, "Description", "Y")), "where": [("wlm_cono", "=", self.opts["conum"])], "whera": (("C", "wlm_empno", 0), ), "index": 0 } typ = { "stype": "C", "titl": "Transaction Types", "head": ("C", "Description"), "data": ((1, "Interest Adjustment"), (3, "Further Advance"), (4, "Loan Repayment"), (5, "Loan Adjustment")), "index": 0 } 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), "IUI", 5, "EmpNo", "Employee Number", "", "N", self.doEmp, wgm, None, None), (("C", 1, 0, 1), "ONA", 10, "Name"), (("C", 1, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N", self.doLoan, lnm, None, ("notzero", )), (("C", 1, 0, 3), "ONA", 10, "Descript", "Description", "", "N", None, None, None, None), (("C", 1, 0, 4), "ID1", 10, "Trans-Date", "Transaction Date", self.sysdtw, "N", self.doTrdate, None, None, None), (("C", 1, 0, 5), "IUI", 1, "T", "Transaction Type", "", "N", self.doTyp, typ, None, ("in", (1, 3, 4, 5))), (("C", 1, 0, 6), "INa", 9, "Reference", "Reference Number", "i", "N", self.doRef, None, None, ("notblank", )), (("C", 1, 0, 7), "IUD", 6.2, "Intr-%", "New Interest Rate", "", "N", self.doPer, None, None, None), (("C", 1, 0, 8), "ISD", 13.2, "Interest", "Interest (Adds to interest raised)", "", "Y", self.doInt, None, None, ("notzero", )), (("C", 1, 0, 9), "ISD", 13.2, "Amount", "Amount (Adds to advances or payments)", "", "Y", self.doPay, None, None, ("notzero", )), (("C", 1, 0, 10), "IUD", 9.2, "Deduct", "Deduction Amount (New total deduction)", "", "Y", self.doDed, None, None, ("efld", ))] if self.glint == "Y": fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"], (("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doGenAcc, glm, None, None), (("C", 2, 0, 1), "ONA", 30, "Description"), (("C", 2, 0, 2), "ISD", 13.2, "All-Amt", "Allocation Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 3), "INA", 30, "Details", "", "", "N", self.doAllDet, None, None, ("notblank", ))]) but = [("Interrogate", None, self.querySln, 0, ("C", 1, 1), ("C", 1, 2))] tag = [("Transaction", None, None, None, False)] cnd = [(None, "n"), (self.endPage1, "y")] cxt = [None, self.exitPage1] if self.glint == "Y": but.append( ("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1))) 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 doEmp(self, frt, pag, r, c, p, i, w): self.empno = w acc = self.sql.getRec("wagmst", cols=["wgm_sname"], where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", self.empno)], limit=1) if not acc: return "Invalid Employee Number" self.name = acc[0] self.df.loadEntry("C", pag, p + 1, data=self.name) chk = self.sql.getRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno)]) if len(chk) == 1: self.acc = chk[0] self.loan = self.acc[self.col.index("wlm_loan")] desc = self.acc[self.col.index("wlm_desc")] self.df.loadEntry("C", pag, p + 2, data=self.loan) self.df.loadEntry("C", pag, p + 3, data=desc) return "sk3" def doLoan(self, frt, pag, r, c, p, i, w): self.loan = w self.acc = self.sql.getRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno), ("wlm_loan", "=", self.loan)], limit=1) if not self.acc: return "Invalid Loan Number" desc = self.acc[self.col.index("wlm_desc")] self.df.loadEntry("C", pag, p + 1, data=desc) def doTrdate(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.trdate = w def doTyp(self, frt, pag, r, c, p, i, w): self.typ = w def doRef(self, frt, pag, r, c, p, i, w): self.ref = w per = self.acc[self.col.index("wlm_rate")] self.df.loadEntry("C", pag, p + 1, data=per) def doPer(self, frt, pag, r, c, p, i, w): self.per = w if self.typ in (3, 4, 5): self.intp = 0 return "sk1" def doInt(self, frt, pag, r, c, p, i, w): self.intp = w self.pay = 0 self.ded = 0 return "sk2" def doPay(self, frt, pag, r, c, p, i, w): self.pay = w amt = self.acc[self.col.index("wlm_repay")] self.df.loadEntry("C", pag, p + 1, data=amt) def doDed(self, frt, pag, r, c, p, i, w): self.ded = w def endPage1(self): self.batupd = False self.updateTables1() self.updateBatch() if not self.val: self.df.advanceLine(1) elif self.typ == 1 or self.glint == "N": self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.allocated = float(0.0) self.df.selPage("Allocation") self.df.loadEntry("T", 2, 0, data=self.val) self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trdate / 100) else: self.curdt = self.bh.curdt if self.typ == 1: self.glt = 4 desc = "Interest Adj" self.val = self.intp ded = self.acc[self.col.index("wlm_repay")] cap = 0.00 elif self.typ == 3: self.glt = 2 desc = "Advance" self.val = self.pay ded = self.ded cap = self.val elif self.typ == 4: self.glt = 6 desc = "Repayment" self.val = float(ASD(0) - ASD(self.pay)) ded = self.ded cap = 0.00 elif self.typ == 5: self.glt = 4 desc = "Adjustment" self.val = self.pay ded = self.ded cap = 0.00 self.sql.updRec("waglmf", cols=["wlm_rate", "wlm_repay"], data=[self.per, ded], where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno), ("wlm_loan", "=", self.loan)]) self.sql.insRec("wagltf", data=[ self.opts["conum"], self.empno, self.loan, self.bh.batno, self.typ, self.trdate, self.ref, self.val, cap, ded, self.per, self.curdt, desc, "N", self.opts["capnm"], self.sysdtw, 0 ]) if self.glint == "N": return # General Ledger Staff Loans Control Account data = (self.opts["conum"], self.glctls[0], self.curdt, self.trdate, self.glt, self.ref, self.bh.batno, self.val, 0.00, self.name, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) self.val = float(ASD(0) - ASD(self.val)) if self.typ == 1: # General Ledger Interest Received data = (self.opts["conum"], self.glctls[1], self.curdt, self.trdate, self.glt, self.ref, self.bh.batno, self.val, 0.00, "Staff Loan - %s" % self.name, "N", "", 0, 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.val) - 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.val: self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.val) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): # General Ledger Transaction (Source) data = (self.opts["conum"], self.genacc, self.curdt, self.trdate, self.glt, self.ref, 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.val)) else: self.batupd = True self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.val)) 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 dr2030(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.doProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlvrf", "ctlvtf", "drsmst", "drstrn", "drsrcm", "drsrct", "genmst", "gentrn"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) drsctl = self.gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return self.glint = drsctl["ctd_glint"] self.fromad = drsctl["ctd_emadd"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"],ctlctl,["drs_ctl","vat_ctl"]): return self.drsctl = ctlctl["drs_ctl"] self.vatctl = ctlctl["vat_ctl"] ctl = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"])], limit=1) for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3", "ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_tel", "ctm_fax", "ctm_b_name", "ctm_b_branch", "ctm_b_ibt", "ctm_b_acno", "ctm_logo"): setattr(self, "%s" % col, ctl[self.sql.ctlmst_col.index(col)]) if "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 self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"], multi="N", glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return def doProcess(self): r1s = ( ("Monthly","M"), ("Quarterly","3"), ("Bi-Annually","6"), ("Annually","Y")) r2s = (("Yes", "Y"), ("No", "N")) fld = ( (("T",0,0,0),("IRB",r1s),0,"Frequency","", "M","N",self.doFreq,None,None,None), (("T",0,1,0),("IRB",r2s),1,"All Charges","", "N","N",self.doAll,None,None,None), (("T",0,2,0),"INa",9,"2nd Reference","", "","N",self.doRef2,None,None,None), (("T",0,3,0),("IRB",r2s),1,"Invoices","", "N","N",self.doInv,None,None,None)) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, view=("N","P"), mail=("N","Y")) def doFreq(self, frt, pag, r, c, p, i, w): self.freq = w self.wher = [("dcm_cono", "=", self.opts["conum"]), ("dcm_freq", "=", self.freq), ("dcm_last", "<", self.bh.curdt)] data = self.sql.getRec("drsrcm", where=self.wher) if not data: return "No Valid Recurring Charges" if self.freq == "M": self.mths = 1 elif self.freq == "3": self.mths = 3 elif self.freq == "6": self.mths = 6 else: self.mths = 12 def doAll(self, frt, pag, r, c, p, i, w): self.allc = w def doRef2(self, frt, pag, r, c, p, i, w): self.ref2 = w def doInv(self, frt, pag, r, c, p, i, w): self.inv = w if self.inv == "N": self.df.loadEntry(frt, pag, p+2, data="") return "nd" def doEml(self, frt, pag, r, c, p, i, w): self.eml = w def doEnd(self): self.df.closeProcess() if self.allc == "N": recs = getSingleRecords(self.opts["mf"], "drsrcm", ("dcm_num", "dcm_desc"), where=self.wher) else: recs = self.sql.getRec("drsrcm", where=self.wher) if recs: if self.inv == "Y" and self.df.repeml[1] == "N": self.fpdf = MyFpdf(orientation="L", fmat="A4", name=self.__class__.__name__, head=128) for dcm in recs: num = dcm[self.sql.drsrcm_col.index("dcm_num")] desc = dcm[self.sql.drsrcm_col.index("dcm_desc")] day = dcm[self.sql.drsrcm_col.index("dcm_day")] if day == 30: self.trdt = mthendDate((self.bh.curdt * 100) + 1) else: self.trdt = (self.bh.curdt * 100) + day vat = dcm[self.sql.drsrcm_col.index("dcm_vat")] self.vatrte = getVatRate(self.sql, self.opts["conum"], vat, self.trdt) glac = dcm[self.sql.drsrcm_col.index("dcm_glac")] nxt = self.sql.getRec("drstrn", cols=["max(drt_ref1)"], where=[("drt_cono", "=", self.opts["conum"]), ("drt_ref1", "like", "RC%03i%s" % (num, "%"))], limit=1) if not nxt[0]: nxt = 0 else: nxt = int(nxt[0][5:]) tot_val = 0 tot_vat = 0 rec = self.sql.getRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", num), ("dct_start", "<=", self.bh.curdt), ("dct_end", ">=", self.bh.curdt)]) col = self.sql.drsrct_col for dct in rec: self.chain = dct[col.index("dct_chain")] self.acno = dct[col.index("dct_acno")] # Check for Redundancy chk = self.sql.getRec("drsmst", cols=["drm_stat"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)], limit=1) if chk[0] == "X": continue # Check for Valid Period charge = False start = dct[col.index("dct_start")] year = int(start / 100) month = start % 100 while start <= self.bh.curdt: if start == self.bh.curdt: charge = True break month += self.mths if month > 12: year += 1 month -= 12 start = (year * 100) + month if not charge: continue # Create Transactions nxt += 1 self.ref = "RC%03i%04i" % (num, nxt) self.detail = textFormat(dct[col.index("dct_detail")], 73) self.amnt = dct[col.index("dct_amnt")] self.vmnt = round(self.amnt * self.vatrte / 100, 2) self.tmnt = float(ASD(self.amnt) + ASD(self.vmnt)) tot_val = float(ASD(tot_val) + ASD(self.amnt)) tot_vat = float(ASD(tot_vat) + ASD(self.vmnt)) # Debtors (drstrn) self.sql.insRec("drstrn", data=[self.opts["conum"], self.chain, self.acno, 1, self.ref, self.bh.batno, self.trdt, self.ref2, self.tmnt, self.vmnt, self.bh.curdt, self.detail[0], vat, "Y", self.opts["capnm"], self.sysdtw, 0]) if self.inv == "Y": # Create Invoice self.doInvoice() # VAT (ctlvtf) amnt = float(ASD(0) - ASD(self.amnt)) vmnt = float(ASD(0) - ASD(self.vmnt)) data = [self.opts["conum"], vat, "O", self.bh.curdt, "D", 1, self.bh.batno, self.ref, self.trdt, self.acno, self.detail[0], amnt, vmnt, 0, self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("ctlvtf", data=data) if self.glint == "Y": ref = "RC%07i" % num # Update Debtors Control amnt = float(ASD(tot_val) + ASD(tot_vat)) data = (self.opts["conum"], self.drsctl, self.bh.curdt, self.trdt, 1, ref, self.bh.batno, amnt, 0, desc, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # Update Sales Account amnt = float(ASD(0) - ASD(tot_val)) data = (self.opts["conum"], glac, self.bh.curdt, self.trdt, 1, ref, self.bh.batno, amnt, 0, desc, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) amnt = float(ASD(0) - ASD(tot_vat)) if amnt: # Update VAT Control data = (self.opts["conum"], self.vatctl, self.bh.curdt, self.trdt, 1, ref, self.bh.batno, amnt, 0, desc, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # Update Recurring Charge (drsrcm) self.sql.updRec("drsrcm", cols=["dcm_last"], data=[self.bh.curdt], where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", num), ("dcm_freq", "=", self.freq)]) self.opts["mf"].dbm.commitDbase() if self.inv == "Y" and self.df.repeml[1] == "N": self.doPrint() self.opts["mf"].closeLoop() def doInvoice(self): if self.df.repeml[1] == "Y": self.fpdf = MyFpdf(orientation="L", fmat="A4", name=self.__class__.__name__, head=128) cw = self.fpdf.get_string_width("X") ld = self.fpdf.font[2] ica = CCD(self.tmnt, "SD", 13.2) iva = CCD(float(ASD(self.tmnt) - ASD(self.amnt)), "SD", 13.2) ivr = CCD(self.vatrte, "UD", 5.2) self.drawInvoice(cw, ld) row = 20 for detail in self.detail: row += 1 self.fpdf.drawText(x=22.2*cw, y=row*ld, txt=detail) self.fpdf.drawText(x=97*cw, y=row*ld, txt=ivr.disp) self.fpdf.drawText(x=103*cw, y=row*ld, txt=ica.disp) self.printTotals(cw, ld, ica, iva) if self.df.repeml[1] == "Y": self.doPrint() def drawInvoice(self, cw, ld): self.fpdf.add_page() self.fpdf.setFont("courier", "B", 16) self.fpdf.drawText(x=22*cw, y=1*ld, txt=self.ctm_name) self.fpdf.setFont("courier", "B", 14) self.fpdf.drawText(x=108*cw, y=2*ld, w=16, align="R", txt="Tax Invoice") self.fpdf.setFont("courier", "B", self.fpdf.font[1]) if self.ctm_logo: self.fpdf.image(self.ctm_logo, 45, 3, 138, 28) else: self.fpdf.drawText(x=22*cw, y=2.5*ld, txt=self.ctm_add1) self.fpdf.drawText(x=22*cw, y=3.5*ld, txt=self.ctm_add2) self.fpdf.drawText(x=22*cw, y=4.5*ld, txt=self.ctm_add3) self.fpdf.drawText(x=22*cw, y=5.5*ld, txt=self.ctm_pcode) self.fpdf.drawText(x=54*cw, y=2.5*ld, txt="RegNo: %s" % self.ctm_regno) self.fpdf.drawText(x=54*cw, y=3.5*ld, txt="TaxNo: %s" % self.ctm_taxno) self.fpdf.drawText(x=54*cw, y=4.5*ld, txt="TelNo: %s" % self.ctm_tel) self.fpdf.drawText(x=54*cw, y=5.5*ld, txt="FaxNo: %s" % self.ctm_fax) drm = self.sql.getRec("drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)], limit=1) col = self.sql.drsmst_col self.fpdf.drawText(x=22.5*cw, y=10.5*ld, txt=drm[col.index("drm_name")]) self.fpdf.drawText(x=22.5*cw, y=11.5*ld, txt=drm[col.index("drm_add1")]) self.fpdf.drawText(x=22.5*cw, y=12.5*ld, txt=drm[col.index("drm_add2")]) self.fpdf.drawText(x=22.5*cw, y=13.5*ld, txt=drm[col.index("drm_add3")]) self.fpdf.drawText(x=22.5*cw, y=14.5*ld, txt=drm[col.index("drm_pcod")]) if self.ctm_b_name: dat = "Name: %s" % self.ctm_b_name dat = "%s\nBranch: %s" % (dat, self.ctm_b_branch) dat = "%s\nCode: %s" % (dat, self.ctm_b_ibt) dat = "%s\nAccount: %s\n " % (dat, self.ctm_b_acno) self.fpdf.drawText(x=22.5*cw, y=37*ld, txt=dat, ctyp="M") self.emadd = CCD(drm[col.index("drm_acc_email")], "TX") # Tables r1 = { "margins": ((22.5, 53), (8, 9)), "repeat": (1, 1), "rows": [ [22, 8.5, [[32, 1.5, .8, "Charge To:", False]]], [22, 10, [[32, 5.5]]], [22, 16, [ [9, 1.5, .8, "Acc-Num", True], [20, 1.5, .8, "V.A.T. Number", True], [42, 1.5, .8, "Contact Person", True], [12, 1.5, .8, "Date", True], [11, 1.5, .8, "Inv-Number", True]]], [22, 17.5, [ [9, 1.5, 0, self.acno, True], [20, 1.5, 0, drm[col.index("drm_vatno")], True], [42, 1.5, 0, drm[col.index("drm_sls")]], [12, 1.5, 0, CCD(self.trdt, "D1", 10).disp, True], [11, 1.5, 0, "%10s" % self.ref]]], [22, 19, [ [74, 1.5, .8, "Description", False], [7, 1.5, .8, " Tax-%", False], [13, 1.5, .8, " Value", False]]], [22, 20.5, [ [74, 12.5], [7, 12.5], [13, 12.5]]], [22, 33, [ [11, 1.5, .8, "Taxable"], [12, 1.5], [12, 1.5, .8, "Non-Taxable"], [12, 1.5], [11, 1.5, .8, "Total Tax"], [11, 1.5], [12, 1.5, .8, "Total Value"], [13, 1.5]]]]} if self.ctm_b_name: r1["rows"].extend([ [22, 35, [[32, 1.5, .8, "Banking Details", False]]], [22, 36.5, [[32, 5.5]]]]) doDrawTable(self.fpdf, r1, cw=cw, ld=ld, font=False) def printTotals(self, cw, ld, ica, iva): tot = [0, 0, iva.work, ica.work] if iva.work: tot[0] = float(ASD(ica.work) - ASD(iva.work)) else: tot[1] = ica.work self.fpdf.drawText(x=32*cw, y=33.2*ld, txt=CCD(tot[0],"SD",13.2).disp) self.fpdf.drawText(x=56*cw, y=33.2*ld, txt=CCD(tot[1],"SD",13.2).disp) self.fpdf.drawText(x=78*cw, y=33.2*ld, txt=CCD(tot[2],"SD",13.2).disp) self.fpdf.drawText(x=103*cw, y=33.2*ld, txt=CCD(tot[3],"SD",13.2).disp) def doPrint(self): if not self.fpdf.page: return if self.df.repeml[1] == "Y": self.df.repeml[2] = self.emadd.work key = "%s_%s_%s" % (self.opts["conum"], self.chain, self.acno) else: key = "%s_all_all" % self.opts["conum"] pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, key, ext="pdf") self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header="%s Invoice" % self.opts["conam"], repprt=self.df.repprt, fromad=self.fromad, repeml=self.df.repeml) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bcc110(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, [ "memctl", "memctc", "memmst", "memadd", "memkon", "bwlctl", "bwltab", "chglog" ], prog=self.__class__.__name__) if self.sql.error: if self.sql.error == ["memctl"]: self.memctl = False self.chgint = False self.mlint = None self.same = "N" else: return else: self.memctl = True self.acc = self.sql.getRec("bwlctl", where=[("ctb_cono", "=", self.opts["conum"]) ], limit=1) if not self.acc: self.new = True self.acc = [ self.opts["conum"], "N", "N", 0, 0, 0, 0, "C", "A", "N", "Y", 4, 0, 0, "A", "B", "", "" ] else: self.new = False self.oldm = self.acc[self.sql.bwlctl_col.index("ctb_mstart")] self.oldf = self.acc[self.sql.bwlctl_col.index("ctb_fstart")] self.oldn = self.acc[self.sql.bwlctl_col.index("ctb_nstart")] if self.memctl: self.mlint = self.sql.getRec("memctl", where=[("mcm_cono", "=", self.opts["conum"])], limit=1) return True def drawDialog(self): cat = { "stype": "R", "tables": ("memctc", ), "cols": (("mcc_code", "", 0, "Code"), ("mcc_desc", "", 0, "Description")), "where": (("mcc_cono", "=", self.opts["conum"]), ("mcc_type", "=", "C")) } r1s = (("Yes", "Y"), ("No", "N")) r2s = (("Position", "P"), ("Rating", "R"), ("Combined", "C")) r3s = (("Ascending", "A"), ("Descending", "D")) r4s = (("S32L-S32L", "A"), ("S32L-L23S", "B")) if self.memctl: self.fld = [ (("T",0,0,0),["IRB",r1s],0,"M/L Integration","", self.acc[1],"N",self.doMlint,None,None,None,None, "Select whether to Integrate this system with the "\ "Members Ledger System."), (("T",0,1,0),("IRB",r1s),0,"Same Numbers","", self.acc[2],"N",self.doSame,None,None,None,None, "If the Members Ledger is Integrated select "\ "whether the Tab numbers and Members Ledger numbers "\ "are the Same."), (("T",0,2,0),"IUI",2,"Category Code","", self.acc[3],"N",self.doCat,cat,None,None,None, "If the Members Ledger is Integrated enter which "\ "Members Ledger Sports category is for Bowls.")] seq = 3 else: self.fld = [] seq = 0 self.fld.extend([ (("T",0,seq,0),"IUI",6,"Male Start Seq","", self.acc[4],"N",self.doMStart,None,None,("notzero",),None, "The Starting Tab number for Males."), (("T",0,seq + 1,0),"IUI",6,"Female Start Seq","", self.acc[5],"N",self.doFStart,None,None,("notzero",),None, "The Starting Tab number for Females."), (("T",0,seq + 2,0),"IUI",6,"Non-Member Start Seq","", self.acc[6],"N",self.doNStart,None,None,("notzero",),None, "The Starting Tab number for Visitors."), (("T",0,seq + 3,0),("IRB",r2s),0,"Draw Base","", self.acc[7],"N",self.doBase,None,None,None,None, "The Default method of doing Draws."), (("T",0,seq + 4,0),("IRB",r3s),0,"Rating Order","", self.acc[8],"N",None,None,None,None,None, "With Ratings select whether Ratings are Ascending "\ "or Descending in strength."), (("T",0,seq + 5,0),("IRB",r1s),0,"Mixed Ratings","", self.acc[9],"N",None,None,None,None,None, "Select if Different Ratings are Used for Mixed "\ "Gender Draws."), (("T",0,seq + 6,0),("IRB",r1s),0,"Replace Fours","", self.acc[10],"N",None,None,None,None,None, "When the Draw is Trips Use Pairs Instead of Fours "\ "when Applicable."), (("T",0,seq + 7,0),"IUI",2,"Weeks Between Draws","", self.acc[11],"N",None,None,None,("between", 0, 4),None, "Minimum number of Weeks that Players Should Not be "\ "Drawn in the Same Team."), (("T",0,seq + 8,0),"IUD",5.2,"Rate - Member","", self.acc[12],"N",None,None,None,("efld",)), (("T",0,seq + 9,0),"IUD",5.2,"Rate - Visitor","", self.acc[13],"N",None,None,None,("efld",)), (("T",0,seq + 10,0),"IUA",6,"Greens","", self.acc[14],"N",self.doGreens,None,None,("notblank",)), (("T",0,seq + 11,0),("IRB",r4s),0,"Draw Format","", self.acc[15],"N",None,None,None,None), (("T",0,seq + 12,0),"ITX",50,"Email Address","", self.acc[16],"N",None,None,None,("email",))]) but = (("Accept", None, self.doAccept, 0, ("T", 0, 1), ("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) if not self.new: if self.memctl: seq = 1 self.oldint = self.acc[0] else: seq = 4 for n, f in enumerate(self.acc[seq:-1]): self.df.loadEntry("T", 0, n, data=f) if not self.memctl: self.chgint = False self.same = "N" self.df.focusField("T", 0, 1, clr=False) def doMlint(self, frt, pag, r, c, p, i, w): if w == "Y" and not self.mlint: return "Invalid Selection, Member's System Not Set Up" if not self.new and w != self.oldint: self.chgint = True else: self.chgint = False if w == "N": self.same = "N" self.df.loadEntry(frt, pag, p + 1, data=self.same) self.mcat = 0 self.df.loadEntry(frt, pag, p + 2, data=self.mcat) return "sk2" def doSame(self, frt, pag, r, c, p, i, w): self.same = w def doCat(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("memctc", where=[("mcc_cono", "=", self.opts["conum"]), ("mcc_type", "=", "C"), ("mcc_code", "=", w)], limit=1) if not chk: return "Invalid Code" self.mcat = w def doMStart(self, frt, pag, r, c, p, i, w): self.mstart = w def doFStart(self, frt, pag, r, c, p, i, w): if w == self.mstart and self.same == "N": return "Invalid Number, Same as Male" if w != self.mstart: if w < self.mstart: r = self.mstart - w g = "Female" else: r = w - self.mstart g = "Male" if r < 200: return "ff5|Invalid Numbers, Too Few %s Tabs. (Minimum 200)" % g self.fstart = w def doNStart(self, frt, pag, r, c, p, i, w): if w < self.mstart or w < self.fstart or w > 890000: return "Invalid Number, Less than Male or Female or > 890000" if self.mstart == self.fstart: t = "Members" r = w - self.mstart m = 400 elif self.fstart < self.mstart: t = "Male" r = w - self.mstart m = 200 else: t = "Female" r = w - self.fstart m = 200 if r < m: return "Invalid Number, Too Few %s Tabs. (Minimum %s)" % (t, m) self.nstart = w def doBase(self, frt, pag, r, c, p, i, w): if w == "P": self.df.loadEntry(frt, pag, p + 1, data="A") return "sk1" if not self.acc[7]: self.df.t_work[0][0][p + 1] = "A" def doGreens(self, frt, pag, r, c, p, i, w): w = w.strip().replace(" ", "") self.df.loadEntry(frt, pag, p, data=w) def doEnd(self): err = None if self.same == "Y": if self.mstart + 400 > self.nstart: err = "Invalid Range, Too Few Members Allowed For" elif self.mstart == self.fstart and self.same == "N": err = "Same Male and Female Starting Numbers" elif self.mstart < self.fstart: if self.fstart - self.mstart < 200: err = "Invalid Range, Too Few Male Numbers" elif self.nstart < self.fstart + 200: err = "Invalid Range, Too Few Female Numbers" elif self.mstart - self.fstart < 200: err = "Invalid Range, Too Few Female Numbers" elif self.nstart < self.mstart + 200: err = "Invalid Range, Too Few Male Numbers" if err: self.df.focusField("T", 0, 3, err=err) else: data = [self.opts["conum"]] if not self.memctl: data.extend(["N", "N"]) 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("bwlctl", data=data) elif data != self.acc[:len(data)]: col = self.sql.bwlctl_col data.append(self.acc[col.index("ctb_xflag")]) self.sql.updRec("bwlctl", data=data, where=[("ctb_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=[ "bwlctl", "U", "%03i" % self.opts["conum"], col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) if self.chgint and self.oldint == "Y": recs = self.sql.getRec("bwltab", cols=["btb_memno"], where=[("btb_cono", "=", self.opts["conum"])]) for rec in recs: data = self.doLoadMember(rec[0]) if data == [0, "", "", "", "", "", "", "", ""]: continue self.sql.updRec("bwltab", cols=[ "btb_memno", "btb_add1", "btb_add2", "btb_add3", "btb_pcod", "btb_home", "btb_work", "btb_cell", "btb_mail" ], data=data, where=[("btb_cono", "=", self.opts["conum"]), ("btb_memno", "=", rec[0])]) if not self.new and (self.mstart != self.oldm or \ self.fstart != self.oldf or self.nstart != self.oldn): # Tab ranges changed ok = askQuestion(self.opts["mf"].body, "Ranges", "Tab Ranges "\ "Have Changed, Do You Want to Change the Tabs to the "\ "New Ranges?", default="no") if ok == "yes": mdif = self.mstart - self.oldm fdif = self.fstart - self.oldf ndif = self.nstart - self.oldn recs = [] if ndif > 0: recs.extend(self.getNon()) if self.oldm > self.oldf: recs.extend(self.getWom()) recs.extend(self.getMen()) else: recs.extend(self.getMen()) recs.extend(self.getWom()) if ndif < 0: recs.extend(self.getNon()) self.df.setWidget(self.df.mstFrame, state="hide") pb = ProgressBar(self.opts["mf"].body, typ="Changing Tabs", mxs=len(recs)) for num, rec in enumerate(recs): pb.displayProgress(num) tab = rec[self.sql.bwltab_col.index("btb_tab")] gdr = rec[self.sql.bwltab_col.index("btb_gender")] if tab < self.oldn: if gdr == "M": new = tab + mdif else: new = tab + fdif else: new = tab + ndif callModule( self.opts["mf"], None, "bc6010", coy=[self.opts["conum"], self.opts["conam"]], args=[tab, new]) pb.closeProgress() self.df.setWidget(self.df.mstFrame, state="show") self.opts["mf"].dbm.commitDbase() self.doExit() def getMen(self): recs = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "<", self.oldn), ("btb_gender", "=", "M")], order="btb_tab") return recs def getWom(self): recs = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "<", self.oldn), ("btb_gender", "=", "F")], order="btb_tab") return recs def getNon(self): end = self.oldm if self.oldf > end: end = self.oldf recs = self.sql.getRec("bwltab", where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", ">=", self.oldn)], order="btb_tab") return recs def doLoadMember(self, memno): 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 [0, "", "", "", "", "", "", "", ""] self.df.loadEntry("T", 0, 1, data=memno) self.df.loadEntry("T", 0, 2, data=acc[0]) self.df.loadEntry("T", 0, 3, data=acc[1]) self.gender = acc[2] self.df.loadEntry("T", 0, 4, data=self.gender) for typ in ("A", "P"): data = 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 data: break if data: data.insert(0, 0) else: data = ["", "", "", "", ""] 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: data.append(kk[0]) else: data.append("") return data def doAccept(self): frt, pag, col, mes = self.df.doCheckFields() if mes: self.df.focusField(frt, pag, (col + 1), err=mes) else: self.same = self.df.t_work[0][0][1] self.mcat = self.df.t_work[0][0][2] self.mstart = self.df.t_work[0][0][3] self.fstart = self.df.t_work[0][0][4] self.nstart = self.df.t_work[0][0][5] self.df.doEndFrame("T", 0, cnf="N") def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class sl1010(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", "wagedc", "wagmst", "waglmf"], 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")), "where": [("wgm_cono", "=", self.opts["conum"])] } lnm = { "stype": "R", "tables": ("waglmf", ), "cols": (("wlm_empno", "", 0, "EmpNo"), ("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0, "Description", "Y")), "where": [("wlm_cono", "=", self.opts["conum"])], "whera": [["T", "wlm_empno", 0]], "index": 1 } 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), "IUI", 5, "Emp-Num", "Employee Number", "", "Y", self.doEmp, wgm, None, ("notzero", )), (("T", 0, 0, 0), "ONA", 30, ""), (("T", 0, 1, 0), "IUI", 3, "Loan-Num", "Loan Number", "", "N", self.doLoan, lnm, None, ("notzero", )), (("T", 0, 2, 0), "INA", 30, "Description", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 3, 0), "IUI", 3, "Deduction Code", "", "", "N", self.doDed, ced, None, ("notzero", )), (("T", 0, 4, 0), "IUD", 6.2, "Interest Percentage", "", "", "N", None, None, None, ("efld", )), (("T", 0, 5, 0), "ID1", 10, "Start Date", "", "", "N", None, None, None, ("efld", )), (("T", 0, 6, 0), "IUD", 10.2, "Deduction Amount", "", "", "N", None, None, None, ("efld", ))) tnd = ((self.doEnd, "n"), (self.doEnd, "y")) txt = (self.doExit, self.doExit) but = (("Accept", None, self.doAccept, 0, ("T", 0, 4), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 4), ("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None)) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, butt=but) def doEmp(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("T", pag, p + 1, data=self.name) def doLoan(self, frt, pag, r, c, p, i, w): self.loan = w self.rec = self.sql.getRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno), ("wlm_loan", "=", self.loan)], limit=1) if not self.rec: return "Invalid Loan Number" wlc = self.sql.waglmf_col self.df.loadEntry(frt, pag, p + 1, data=self.rec[wlc.index("wlm_desc")]) self.df.loadEntry(frt, pag, p + 2, data=self.rec[wlc.index("wlm_code")]) self.df.loadEntry(frt, pag, p + 3, data=self.rec[wlc.index("wlm_rate")]) self.df.loadEntry(frt, pag, p + 4, data=self.rec[wlc.index("wlm_start")]) self.df.loadEntry(frt, pag, p + 5, data=self.rec[wlc.index("wlm_repay")]) def doDed(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 doEnd(self): data = [self.opts["conum"]] for p in range(0, len(self.df.t_work[0][0])): if p == 1: continue data.append(self.df.t_work[0][0][p]) if data != self.rec[:len(data)]: col = self.sql.waglmf_col data.append(self.rec[col.index("wlm_xflag")]) self.sql.updRec("waglmf", data=data, where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno), ("wlm_loan", "=", self.loan)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.rec): if dat != data[num]: self.sql.insRec( "chglog", data=[ "waglmf", "U", "%03i%05i%02i" % (self.opts["conum"], self.empno, self.loan), 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.last[0] = [0, 0] self.df.focusField("T", 0, 1) def doExit(self): if not self.df.pag: self.doCloseProcess() elif self.df.pag == 1: self.df.focusField("T", 0, 2) def doCloseProcess(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class rcc210(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, "ctlmes", prog=self.__class__.__name__) if self.sql.error: return self.system = "RCA" return True def mainProcess(self): mss = { "stype": "R", "tables": ("ctlmes", ), "cols": (("mss_message", "", 0, "Mss"), ("mss_detail", "NA", 50, "Details")), "where": [("mss_system", "=", self.system)], "order": "mss_message" } self.fld = ((("T", 0, 0, 0), "IUI", 3, "Message Number", "", "", "N", self.doMes, mss, None, ("notzero", )), (("T", 0, 1, 0), "ITv", (30, 6), "Details", "", "", "N", self.doDetail, None, self.doDelete, None)) 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 doMes(self, frt, pag, r, c, p, i, w): self.message = w self.old = self.sql.getRec("ctlmes", where=[("mss_system", "=", self.system), ("mss_message", "=", self.message)], order="mss_message", limit=1) if not self.old: self.new = "Y" self.df.loadEntry(frt, pag, p + 1, data="") else: self.new = "N" self.detail = self.old[self.sql.ctlmes_col.index("mss_detail")] self.df.loadEntry(frt, pag, p + 1, data=self.detail) def doDetail(self, frt, pag, r, c, p, i, w): if len(w) > 150: return "Invalid Message Length, Maximum 150 Characters" def doDelete(self): self.sql.delRec("ctlmes", where=[("mss_system", "=", self.system), ("mss_message", "=", self.message)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): wid, self.detail = self.df.getEntry("T", 0, 1) if len(self.detail) > 150: self.df.focusField( "T", 0, 2, err="Invalid Message Length, Maximum 150 Characters") else: data = [self.system, self.message, self.detail] if self.new == "Y": self.sql.insRec("ctlmes", data=data) elif data != self.old[:len(data)]: col = self.sql.ctlmes_col data.append(self.old[col.index("mss_xflag")]) self.sql.updRec("ctlmes", data=data, where=[("mss_system", "=", self.system), ("mss_message", "=", self.message)]) 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 dr2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): # Check for Valid Posting Routine if self.opts["rtn"] not in (1, 3, 4, 5): showError(self.opts["mf"].body, "Control Error", "Invalid Routine %s, Only 1, 3, 4 and 5 Are Allowed" % \ str(self.opts["rtn"])) return # Create SQL Object self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "drschn", "drsmst", "drstrn", "genint", "genmst", "gentrn"], 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"]) drsctl = self.gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return self.glint = drsctl["ctd_glint"] self.glinp = drsctl["ctd_glinp"] self.chains = drsctl["ctd_chain"] 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.drsctl = ctlctl["drs_ctl"] self.dis_all = ctlctl["dis_all"] self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.allcoy = self.opts["conum"] ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if self.chains == "N": self.chain = 0 if self.opts["rtn"] == 1: self.glt = 1 elif self.opts["rtn"] == 3: self.glt = 4 elif self.opts["rtn"] == 4: self.glt = 1 elif self.opts["rtn"] == 5: self.glt = 2 self.agevar = tk.BooleanVar() self.agevar.set(False) return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return if self.opts["rtn"] == 4: self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) def drawDialog(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"] = [["C", "drm_chain", 0, 1]] else: drm["where"] = [ ("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", 0)] drm["where"].append(("drm_stat", "<>", "X")) 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": [["C", "glm_cono", 0, 2]]} vtm = { "stype": "R", "tables": ("ctlvmf",), "cols": ( ("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])]} viw = { "stype": "R", "tables": ("drstrn",), "cols": ( ("drt_chain", "", 0, ""), ("drt_acno", "", 0, ""), ("drt_ref1", "", 0, ""), ("drt_trdt", "", 0, ""), ("drt_tramt", "", 0, ""), ("drt_taxamt", "", 0, "")), "where": [ ("drt_cono", "=", self.opts["conum"]), ("drt_type", "=", self.opts["rtn"]), ("drt_batch", "=", self.bh.batno)], "order": "drt_seq"} 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),"IUI",3,"Chn","Chain Store", "r","Y",self.doChain,drc,None,("efld",)], [("C",1,0,1),"INA",7,"Acc-Num","Account Number", "r","N",self.doDrsAcc,drm,None,("notblank",)], [("C",1,0,2),"ONA",10,"Name"], (("C",1,0,3),"INa",9,"Reference","Reference Number One", "i","N",self.doRef1,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,("efld",))] if self.opts["rtn"] == 5: fld[4][2] = 20 fld.extend([ [["C",1,0,6],"ISD",13.2,"Discount", "Discount Amount","","N",self.doDisAmt,None,None,None,None, "Discout Amount to be Added to the Transaction Amount"], [["C",1,0,7],"OSD",13.2,"Total-Amount"], [["C",1,0,8],"INA",(20,30),"Details","Transaction Details", "","N",self.doTrnDet,None,None,None]]) elif self.glint == "Y": if self.glinp == "E": tx1 = "Exc-Amount" tx2 = "Exclusive Amount" else: tx1 = "Inc-Amount" tx2 = "Inclusive Amount" fld[4][2] = 24 fld.extend([ [["C",1,0,6],"INA",30,"Details","Transaction Details", "","N",self.doTrnDet,None,None,None], [("T",2,0,0),"OSD",13.2,"Unallocated Balance"], [("C",2,0,0),"IUI",3,"Coy","Company Number", self.opts["conum"],"N",self.doCoyNum,coy,None,None], (("C",2,0,1),"IUI",7,"Acc-Num","Account Number", "","N",self.doGenAcc,glm,None,None), (("C",2,0,2),"ONA",19,"Description"), (("C",2,0,3),"IUA",1,"V","V.A.T Code", self.taxdf,"N",self.doVatCode2,vtm,None,("notblank",)), (("C",2,0,4),"ISD",13.2,tx1,tx2, "","N",self.doAllAmt,None,None,("efld",)), (("C",2,0,5),"ISD",13.2,"V.A.T","V.A.T Amount", "","N",self.doAllVat,None,None,None), [("C",2,0,6),"INA",(26,30),"Details","", "","N",self.doAllDet,None,None,("notblank",)]]) if not self.incoac: fld[10][1] = "OUI" else: fld[4][2] = 22 fld.extend([ (("C",1,0,6),"IUA",1,"V","V.A.T Code", self.taxdf,"N",self.doVatCode1,vtm,None,("notblank",)), (("C",1,0,7),"ISD",13.2,"V.A.T","V.A.T Amount", "","N",self.doVatAmt,None,None,None), [["C",1,0,8],"INA",(20,30),"Details","Transaction Details", "","N",self.doTrnDet,None,None,None]]) if self.chains == "N": fld[2][1] = "OUI" idx = 2 else: idx = 1 but = ( ("Interrogate",None,self.queryDrs,0,("C",1,idx),("C",1,idx+1), "Interrogate Debtors Records",1), ("View Entries",viw,None,0,("C",1,idx),("C",1,idx+1), "View Batch Transactions",1), ("Maintain",None,self.maintainDrs,0,("C",1,idx),("C",1,idx+1), "Maintain Debtors Records",1), ("Canc_el",None,self.doCancel,0,("C",2,1),("C",1,1), "Cancel the Entry",1), ("Age _Normal",None,self.doAgeNormal,0,None,None, "Only Show Unallocated Transactions",2), ("Age _History",None,self.doAgeHistory,0,None,None, "Show All Transactions Including Already Allocated",2), ("Age _Automatic",None,self.doAgeAuto,0,None,None, "Automatically Allocate the Amount Starting With the "\ "Oldest Unallocated One",2), ("Age _Current",None,self.doAgeCurrent,0,None,None, "Leave the Transaction Unallocated",2)) tag = [("Transaction", None, None, None, False)] cnd = [(None,"n"), (self.endPage1,"y")] cxt = [None, self.exitPage1] if self.opts["rtn"] != 5 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 doChain(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drschn", cols=["chm_chain"], where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", w)], limit=1) if not acc: return "Invalid Chain Store" self.chain = w def doDrsAcc(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.chain), ("drm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[1] == "X": return "Invalid Account, Redundant" self.dracno = w self.name = acc[0] self.df.loadEntry("C", pag, p+1, data=self.name) def doRef1(self, frt, pag, r, c, p, i, w): self.ref1 = w acc = self.sql.getRec("drstrn", cols=["drt_batch"], where=[("drt_cono", "=", self.opts["conum"]), ("drt_chain", "=", self.chain), ("drt_acno", "=", self.dracno), ("drt_type", "=", self.opts["rtn"]), ("drt_ref1", "=", self.ref1)], limit=1) if acc: return "Transaction Already Exists" 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.glint == "Y" or self.opts["rtn"] == 5: self.vatcode = "N" self.vatamt = 0 def doVatCode1(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.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p+1, self.vatamt) if not self.vatamt: return "sk1" def doVatAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.vatamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.vatamt = float(ASD(0) - ASD(w)) else: self.vatamt = w self.df.loadEntry(frt, pag, p, data=self.vatamt) def doDisAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.disamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.disamt = float(ASD(0) - ASD(w)) else: self.disamt = w self.df.loadEntry(frt, pag, p, data=self.disamt) totamt = float(ASD(self.trnamt) + ASD(self.disamt)) self.df.loadEntry(frt, pag, p+1, data=totamt) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.opts["rtn"] != 5 and self.glint == "Y": self.df.colf[2][6][5] = w self.allocated = float(0.00) def endPage1(self): self.cancel = False self.agecan = False self.batupd = False self.updateTables1() if self.cancel: return else: self.updateBatch() if self.trnamt == 0: self.df.advanceLine(1) else: self.allocated = float(0.0) if self.opts["rtn"] == 5 or self.glint == "N": self.doDrsTrn() self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.df.selPage("Allocation") self.df.loadEntry("T", 2, 0, data=self.trnamt) 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.vatamt if self.opts["rtn"] == 1: # Invoices recon = 0 self.dis = 0.00 elif self.opts["rtn"] == 3: # Journals recon = 0 self.dis = 0.00 elif self.opts["rtn"] == 4: # Credit Notes recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.vat = float(ASD(0) - ASD(self.vat)) self.dis = 0.00 elif self.opts["rtn"] == 5: # Payments if self.trnamt == 0: recon = self.curdt else: recon = 0 self.vat = 0.00 self.dis = self.disamt if self.opts["rtn"] == 1: self.doAgeCurrent() else: state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Choose an Ageing Option") for x in range(4, 8): if self.opts["rtn"] == 3 and x == 6: continue wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "normal") self.df.setWidget(self.df.B4, "focus") self.agevar.set(True) self.df.mstFrame.wait_variable(self.agevar) self.df.enableButtonsTags(state=state) if self.agecan: self.doCancel() return if self.glint == "N": return # General Ledger Control Transaction (Debtors) val = float(ASD(self.amt) + ASD(self.dis)) data = (self.opts["conum"], self.drsctl, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Bank) if self.opts["rtn"] == 5: val = float(ASD(0) - ASD(self.amt)) data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Discount) if self.dis: val = float(ASD(0) - ASD(self.dis)) data = (self.opts["conum"], self.dis_all, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def doAgeNormal(self): self.doAgeing("N") def doAgeHistory(self): self.doAgeing("H") def doAgeAuto(self): self.doAgeing("O") def doAgeCurrent(self): self.doAgeing("C") def doAgeing(self, atype): # Disable All Ageing Buttons for x in range(4, 8): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") self.opts["mf"].updateStatus("Select Transaction to Allocate Against") age = AgeAll(self.opts["mf"], system="drs", agetyp=atype, agekey=[self.opts["conum"], self.chain, self.dracno, self.opts["rtn"], self.ref1, self.curdt, self.amt, self.dis]) self.agecan = age.cancel if self.agevar.get(): self.agevar.set(False) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doCoyNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", w)], limit=1) if not acc: return "Invalid Company, Missing" if self.incoac and w not in self.incoac: return "Invalid Company, No Intercompany Record 1" if w != self.opts["conum"]: acc = self.sql.getRec("genint", where=[("cti_cono", "=", w), ("cti_inco", "=", self.opts["conum"])], limit=1) if not acc: return "Invalid Company, No Intercompany Record 2" self.allcoy = w def doGenAcc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.allcoy, w) if type(chk) is str: return chk if not chk[2]: self.taxgl = self.taxdf else: self.taxgl = chk[2] self.genacc = w self.df.loadEntry("C", pag, p+1, chk[0]) self.df.loadEntry("C", pag, p+2, data=self.taxgl) def doVatCode2(self, frt, pag, r, c, p, i, w): ctlctl = self.gc.getCtl("ctlctl", self.allcoy, error=False) if not ctlctl: return "Missing ctlctl Record for Company" if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]): return "Missing or Invalid Control Record" self.convat = ctlctl["vat_ctl"] self.vatrte = getVatRate(self.sql, self.allcoy, w, self.trndat) if self.vatrte is None: return "Invalid V.A.T Code" self.vatcode = w def doAllAmt(self, frt, pag, r, c, p, i, w): if not w: incamt = float(ASD(self.trnamt) - ASD(self.allocated)) elif self.glinp == "E": incamt = round((w * (100 + self.vatrte) / 100), 2) else: incamt = w self.allamt = round((incamt * 100 / (100 + self.vatrte)), 2) self.allvat = float(ASD(incamt) - ASD(self.allamt)) if self.glinp == "E": self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.df.loadEntry(frt, pag, p, data=incamt) self.df.loadEntry(frt, pag, p+1, data=self.allvat) if not self.allvat: self.df.loadEntry(frt, pag, p+2, data=self.name) return "sk1" def doAllVat(self, frt, pag, r, c, p, i, w): if (self.allamt < 0 and w > 0) or (self.allamt > 0 and w < 0): w = float(ASD(0) - ASD(w)) if self.glinp == "I" and w != self.allvat: self.allamt = float(ASD(self.allamt) + ASD(self.allvat) - ASD(w)) self.allvat = w self.df.loadEntry(frt, pag, p, data=self.allvat) self.df.loadEntry(frt, pag, p+1, data=self.name) def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): if self.agecan: ok = "yes" else: ok = askQuestion(self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.cancel = True self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) if self.glint == "Y" and self.opts["rtn"] != 5: self.df.clearFrame("C", 2) row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.selPage("Transaction") self.df.focusField("C", 1, col) def endPage2(self): self.updateTables2() self.allocated = float(ASD(self.allocated) + \ ASD(self.allamt) + ASD(self.allvat)) if self.allocated == self.trnamt: self.doDrsTrn() 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 if self.opts["rtn"] == 1: # Invoices self.credit() elif self.opts["rtn"] == 3: # Journals self.credit() elif self.opts["rtn"] == 4: # Credit Notes self.debit() def debit(self): amt = self.allamt vat = self.allvat self.restDebitCredit(amt, vat) def credit(self): amt = float(ASD(0) - ASD(self.allamt)) vat = float(ASD(0) - ASD(self.allvat)) self.restDebitCredit(amt, vat) def restDebitCredit(self, amt, vat): # VAT Transaction (ctlvtf) data = (self.allcoy, self.vatcode, "O", self.curdt, "D", self.opts["rtn"], self.bh.batno, self.ref1, self.trndat, self.dracno, self.alldet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return # General Ledger Transaction (Allocation) data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, amt, vat, self.alldet, self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany) if self.allcoy != self.opts["conum"]: # General Ledger Transaction (Intercompany From) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=", self.allcoy)], limit=1)[0] val = float(ASD(amt) + ASD(vat)) data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany To) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.allcoy), ("cti_inco", "=", self.opts["conum"])], limit=1)[0] val = float(ASD(0) - ASD(amt) - ASD(vat)) data = (self.allcoy, acc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if vat: # General Ledger Control Transaction (V.A.T.) data = (self.allcoy, self.convat, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, vat, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) self.vat = float(ASD(self.vat) + ASD(vat)) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def doDrsTrn(self): # Debtors Ledger Transaction data = [self.opts["conum"], self.chain, self.dracno, self.opts["rtn"], self.ref1, 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("drstrn", data=data) if not self.dis: return data = [self.opts["conum"], self.chain, self.dracno, 6, self.ref1, self.bh.batno, self.trndat, "", self.dis, self.vat, self.curdt, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("drstrn", data=data) 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 queryDrs(self): callModule(self.opts["mf"], self.df, "dr4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def maintainDrs(self): callModule(self.opts["mf"], self.df, "dr1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class mlm010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): mc = GetCtl(self.opts["mf"]) ctlmst = mc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] memctl = mc.getCtl("memctl", self.opts["conum"]) if not memctl: return self.glint = memctl["mcm_glint"] self.ldays = memctl["mcm_ldays"] self.lme = memctl["mcm_lme"] self.lmd = int(memctl["mcm_lme"] / 100) yr = int(self.lme / 10000) mth = (int(self.lme / 100) % 100) + 1 if mth > 12: yr += 1 mth = 1 self.tme = mthendDate((yr * 10000) + (mth * 100) + 00) tabs = [ "chglog", "ctlbat", "ctlmst", "ctlvrf", "ctlvtf", "memage", "memcat", "memctc", "memctl", "memctp", "memmst", "memtrn" ] if self.glint == "Y": tabs.append("gentrn") ctlctl = mc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["mem_ctl", "mem_pen", "vat_ctl"] if mc.chkRec(self.opts["conum"], ctlctl, ctls): return self.memctl = ctlctl["mem_ctl"] self.penctl = ctlctl["mem_pen"] self.vatctl = ctlctl["vat_ctl"] else: self.penctl = 0 self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return if self.glint == "Y": check = self.sql.getRec("memctc", where=[("mcc_cono", "=", self.opts["conum"]), ("mcc_freq", "<>", "N"), ("mcc_glac", "=", 0)]) if check: mess = "The following Category Record(s) are Missing G/L "\ "Accounts:\n" for rec in check: mess = "%s\n%s, %2s, %s" % (mess, rec[1], rec[2], rec[3]) showError(self.opts["mf"].body, "Invalid Category", mess) return t = time.localtime() self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2] self.ynd = False return True def mainProcess(self): r1s = (("No", "N"), ("Yes", "Y")) fld = ((("T", 0, 0, 0), "OD1", 10, "Last Month End Date"), (("T", 0, 1, 0), "ID1", 10, "This Month End Date", "", self.tme, "N", self.doTme, None, None, ("efld", )), (("T", 0, 2, 0), ("IRB", r1s), 0, "Raise Penalties", "", "N", "N", self.doPenalty, None, None, None), (("T", 0, 3, 0), "ID1", 10, "Cut-off Date", "", "", "N", self.doCutOff, None, None, ("efld", ))) tnd = ((self.doEnd, "Y"), ) txt = (self.closeProcess, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, focus=False) self.df.loadEntry("T", 0, 0, data=self.lme) self.df.focusField("T", 0, 2) def doTme(self, frt, pag, r, c, p, i, w): if w <= self.lme: return "Invalid Month-End Date, Before Last Month End" if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Month-End Date, Out of Financial Period" if int(w / 100) == int(self.opts["period"][2][0] / 100): ok = askQuestion(self.opts["mf"].body, "Year End", "Is this the Financial Year End?", default="yes") if ok == "yes": self.ynd = True w = self.opts["period"][2][0] self.df.loadEntry(frt, pag, p, data=w) else: return "Invalid Month-End Date, Same as Year-End" if dateDiff(self.lme, w, "months") != 1: return "There Seems to be a Missing Month End" self.tme = w self.curdt = int(w / 100) yy = int(self.curdt / 100) mm = (self.curdt % 100) + 1 while mm > 12: yy += 1 mm -= 12 self.nxtdt = (yy * 10000) + (mm * 100) + 1 self.nxtcd = int(self.nxtdt / 100) self.batch = "M%06s" % self.curdt chk = self.sql.getRec("memtrn", cols=["count(*)"], where=[("mlt_cono", "=", self.opts["conum"]), ("mlt_type", "=", 1), ("mlt_batch", "=", self.batch), ("mlt_trdt", "=", self.nxtdt), ("mlt_curdt", "=", self.nxtcd)], limit=1) if chk[0]: return "Month-End Already Executed" num = self.sql.getRec("memtrn", cols=["max(mlt_refno)"], where=[("mlt_cono", "=", self.opts["conum"]), ("mlt_type", "=", 1), ("mlt_refno", "like", "A________")], limit=1) if not num[0]: self.refnum = 0 else: self.refnum = int(num[0][4:]) def doPenalty(self, frt, pag, r, c, p, i, w): self.penalty = w if self.penalty == "N": return "sk1" def doCutOff(self, frt, pag, r, c, p, i, w): if w >= self.tme: return "Invalid Cut-off Date" self.cutoff = w self.pcodes = {} acc = self.sql.getRec("memctp", cols=["mcp_type", "mcp_code", "mcp_penalty"], where=[("mcp_cono", "=", self.opts["conum"]), ("mcp_date", "<=", self.cutoff), ("mcp_penalty", "<>", 0)], order="mcp_date") for a in acc: self.pcodes["%s%02i" % (a[0], a[1])] = a[2] def doEnd(self): recs = self.sql.getRec("ctlbat", cols=["count(*)"], where=[("btm_cono", "=", self.opts["conum"]), ("btm_styp", "=", "MEM"), ("btm_ind", "=", "N"), ("btm_curdt", "=", self.curdt)], limit=1) if recs[0]: ok = askQuestion(self.opts["mf"].body, "Unbalanced Batches Exist", "There are Unbalanced Batches for this Month. You "\ "Should Not Continue, but Print a Batch Error Report, and "\ "Correct the Errors. Continue, YES or NO ?", default="no") if ok == "yes": ok = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="MST", code="UnbalBatch") if ok.flag == "no": self.closeProcess() else: self.doEnder() else: self.closeProcess() else: self.doEnder() def doEnder(self): self.df.closeProcess() recs = self.sql.getRec("memmst", cols=["mlm_memno"], where=[("mlm_cono", "=", self.opts["conum"]), ("mlm_state", "=", "A")]) if self.ynd: p = ProgressBar(self.opts["mf"].body, typ="Checking Member Categories", mxs=len(recs)) for num, acc in enumerate(recs): p.displayProgress(num) self.memno = acc[0] data = doChkCatChg(self.opts["mf"], self.opts["conum"], self.memno, self.nxtdt) if data: if not data[3]: self.doRaiseCharge("B", data[0], data[1], data[2], data[3], data[4], data[5], data[6], skip=True) dte = int("%04i%02i%02i%02i%02i%02i" % \ time.localtime()[:-3]) self.sql.delRec("memcat", where=[("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_type", "=", "B"), ("mlc_code", "=", data[0])]) self.sql.insRec( "chglog", data=[ "memcat", "D", "%03i%06i%1s%02i" % (self.opts["conum"], self.memno, "B", data[0]), "", dte, self.opts["capnm"], str(data[1]), str(data[2]), "", 0 ]) self.sql.insRec("memcat", data=[ self.opts["conum"], self.memno, "B", data[7], "", self.nxtdt, 0, 0 ]) self.sql.insRec( "chglog", data=[ "memcat", "N", "%03i%06i%1s%02i" % (self.opts["conum"], self.memno, "B", data[7]), "", dte, self.opts["capnm"], str(self.nxtdt), str(0), "", 0 ]) p.closeProgress() ok = askQuestion(self.opts["mf"].body, "Category Changes", "Would You Like to Display Category Changes?", default="yes") if ok == "yes": callModule(self.opts["mf"], None, "ml3060", coy=(self.opts["conum"], self.opts["conam"]), args=(projectDate(self.lme, 1), self.nxtdt)) ok = askQuestion( self.opts["mf"].body, "Continue", "Would You Like to Continue with the Month End?", default="yes") if ok == "no": self.opts["mf"].closeLoop() return p = ProgressBar(self.opts["mf"].body, typ="F", mxs=len(recs)) for num, acc in enumerate(recs): p.displayProgress(num) self.memno = acc[0] if self.penalty == "Y": amount = 0 join = "left outer join memage on mta_cono=mlt_cono and "\ "mta_memno=mlt_memno and mta_type=mlt_type and "\ "mta_refno=mlt_refno" cols = ["mlt_ctyp", "mlt_ccod", "sum(mlt_tramt)"] wher = [("mlt_cono", "=", self.opts["conum"]), ("mlt_memno", "=", self.memno), ("mlt_trdt", "<=", self.cutoff)] grps = "mlt_ctyp, mlt_ccod" ordr = "mlt_trdt" recs = self.sql.getRec("memtrn", join=join, cols=cols, where=wher, group=grps, order=ordr) for rec in recs: key = "%s%02i" % (rec[0], rec[1]) if key in self.pcodes: amt = round(rec[2] * self.pcodes[key] / 100.0, 2) if amt > 0: amount = float(ASD(amount) + ASD(amt)) if amount: self.doUpdateTables("", "", "Penalty on Overdue Amounts", self.penctl, self.tme, amount) cols = [ "mlc_type", "mlc_code", "mcc_desc", "mcc_freq", "mlc_start", "mlc_end", "mlc_last", "mcc_glac" ] wher = [("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_start", ">", 0), ("mlc_start", "<=", self.nxtdt), ("mcc_cono=mlc_cono", ), ("mcc_type=mlc_type", ), ("mcc_code=mlc_code", ), ("mcc_freq", "<>", "N")] cats = self.sql.getRec(tables=["memcat", "memctc"], cols=cols, where=wher, order="mlc_type, mlc_code") for ctyp, code, desc, freq, start, end, last, glac in cats: if start > self.nxtdt: # Not yet Started continue if last and end and end < self.nxtdt: # Ended continue if last and freq == "O": # Once Off continue if not self.ynd and last and freq == "A" and \ last >= self.opts["period"][1][0] and \ last <= self.opts["period"][2][0]: # Out of Period continue self.doRaiseCharge(ctyp, code, start, end, last, freq, desc, glac) p.closeProgress() self.sql.updRec("memctl", cols=["mcm_lme"], data=[self.tme], where=[("mcm_cono", "=", self.opts["conum"])]) ok = askQuestion(self.opts["mf"].body, "Audit Trail", "Would You Like to Display an Audit Trail?", default="yes") if ok == "yes": callModule(self.opts["mf"], None, "ml3020", coy=(self.opts["conum"], self.opts["conam"]), args=("F", 0, self.nxtcd, 1, self.batch)) self.opts["mf"].dbm.commitDbase(ask=True, mess="Do You Want To Save All Entries?\n\nPlease Note That "\ "Once The Entries Have Been Saved, There Is No Going Back "\ "Without Restoring From Backup!") if self.ynd and self.opts["mf"].dbm.commit == "yes": callModule(self.opts["mf"], None, "msy010", coy=(self.opts["conum"], self.opts["conam"]), period=self.opts["period"], user=self.opts["capnm"], args="N") self.opts["mf"].closeLoop() def doRaiseCharge(self, ctyp, code, start, end, last, freq, desc, glac, skip=False): if freq == "O": dte = True nxt = False else: dte = False nxt = bool(self.ynd or freq == "M") if not last: if dateDiff(start, self.tme, "days") > self.ldays: dte = True else: nxt = True if dte: trdt = start amt = self.doGetCharge(ctyp, code, trdt) if amt: self.doUpdateTables(ctyp, code, desc, glac, trdt, amt) if not skip and nxt: if end and self.nxtdt > end: return trdt = self.nxtdt amt = self.doGetCharge(ctyp, code, trdt) if amt: self.doUpdateTables(ctyp, code, desc, glac, trdt, amt) def doGetCharge(self, ctyp, code, date): prc = self.sql.getRec("memctp", where=[("mcp_cono", "=", self.opts["conum"]), ("mcp_type", "=", ctyp), ("mcp_code", "=", code), ("mcp_date", "<=", date)], order="mcp_date desc", limit=1) if not prc: # No Price return if prc[5] == "N" or (self.ynd and date == self.nxtdt): # Not Pro Rata or End of Financial Year amt = CCD(prc[6], "UD", 12.2).work else: # Extract Pro Rata Rate mths = 17 - dateDiff(date, self.opts["period"][2][0], "months") if mths < 1: mths = 12 amt = CCD(prc[mths], "UD", 12.2).work if not amt: # No Charge return else: return amt def doUpdateTables(self, ctyp, code, desc, glac, trdt, amt): self.refnum += 1 ref = CCD("A%08i" % self.refnum, "Na", 9).work curdt = int(trdt / 100) # VAT Rate and Amount vrte = getVatRate(self.sql, self.opts["conum"], self.taxdf, trdt) if vrte is None: vrte = 0.0 vat = CCD(round(((amt * vrte) / (vrte + 100)), 2), "UD", 12.2).work # Members Ledger Transaction (memtrn) data = [ self.opts["conum"], self.memno, 1, ref, self.batch, trdt, amt, vat, curdt, ctyp, code, desc, self.taxdf, "", self.opts["capnm"], self.sysdt, 0 ] self.sql.insRec("memtrn", data=data) # Members Ledger Category (memcat) self.sql.updRec("memcat", cols=["mlc_last"], data=[trdt], where=[("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_type", "=", ctyp), ("mlc_code", "=", code)]) if vat: # VAT Transaction (ctlvtf) val = float(ASD(0) - ASD(amt) + ASD(vat)) tax = float(ASD(0) - ASD(vat)) data = [ self.opts["conum"], self.taxdf, "O", curdt, "M", 1, self.batch, ref, trdt, self.memno, desc, val, tax, 0, self.opts["capnm"], self.sysdt, 0 ] self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return ref = "ML/MthEnd" # General Ledger Member Control whr = [("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.memctl), ("glt_batch", "=", self.batch), ("glt_curdt", "=", curdt), ("glt_trdt", "=", trdt), ("glt_type", "=", 1)] glt = self.sql.getRec("gentrn", where=whr) if glt and len(glt) == 1: tmp = glt[0][self.sql.gentrn_col.index("glt_tramt")] tmp = float(ASD(tmp) + ASD(amt)) self.sql.updRec("gentrn", cols=["glt_tramt"], data=[tmp], where=whr) else: data = [ self.opts["conum"], self.memctl, curdt, trdt, 1, ref, self.batch, amt, 0, "Month End Raising Charges", "", "", 0, self.opts["capnm"], self.sysdt, 0 ] self.sql.insRec("gentrn", data=data) val = float(ASD(0) - ASD(amt) + ASD(vat)) tax = float(ASD(0) - ASD(vat)) # General Ledger Income Account whr[1] = ("glt_acno", "=", glac) glt = self.sql.getRec("gentrn", where=whr) if glt and len(glt) == 1: tmp = glt[0][self.sql.gentrn_col.index("glt_tramt")] tmp = float(ASD(tmp) + ASD(val)) glt[0][self.sql.gentrn_col.index("glt_tramt")] = tmp tmp = glt[0][self.sql.gentrn_col.index("glt_taxamt")] tmp = float(ASD(tmp) + ASD(tax)) glt[0][self.sql.gentrn_col.index("glt_taxamt")] = tmp self.sql.updRec("gentrn", data=glt[0], where=whr) else: data = [ self.opts["conum"], glac, curdt, trdt, 1, ref, self.batch, val, tax, "Month End Raising Charges", self.taxdf, "", 0, self.opts["capnm"], self.sysdt, 0 ] self.sql.insRec("gentrn", data=data) if not tax: return # General Ledger VAT Account whr = [("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.vatctl), ("glt_batch", "=", self.batch), ("glt_curdt", "=", curdt), ("glt_trdt", "=", trdt), ("glt_type", "=", 1)] glt = self.sql.getRec("gentrn", where=whr) if glt and len(glt) == 1: tmp = glt[0][self.sql.gentrn_col.index("glt_tramt")] tmp = float(ASD(tmp) + ASD(tax)) self.sql.updRec("gentrn", cols=["glt_tramt"], data=[tmp], where=whr) else: data = [ self.opts["conum"], self.vatctl, curdt, trdt, 1, ref, self.batch, tax, 0.00, "Month End Raising Charges", "", "", 0, self.opts["capnm"], self.sysdt, 0 ] self.sql.insRec("gentrn", data=data) def closeProcess(self): self.df.closeProcess() self.opts["mf"].closeLoop()
def doCleanDatabase(self): txt = "Cleaning Database ... Please Wait" if self.opts["mf"] and self.opts["mf"].window: self.opts["mf"].updateStatus(txt) elif self.opts["bar"]: print(txt) # Removing unused tables self.doGetTables() if self.opts["bar"] and self.opts["mf"] and self.opts["mf"].window: pb = ProgressBar(self.opts["mf"].body, mxs=(len(self.old) + len(self.tabs)), typ=txt) for n1, t in enumerate(self.old): if self.opts["mf"] and self.opts["mf"].window: self.opts["mf"].updateStatus(t) if self.opts["bar"]: pb.displayProgress(n1) if t not in self.tabs: self.dbm.dropTable(t, True) self.dbm.commitDbase() # Creating new tables and/or indexes if self.opts["mf"] and self.opts["mf"].window: self.opts["mf"].updateStatus("") for n2, t in enumerate(self.tabs): if self.opts["mf"] and self.opts["mf"].window: self.opts["mf"].updateStatus(t) if self.opts["bar"]: pb.displayProgress(n1 + n2) if not self.dbm.checkTable(t): opts = copyList(self.topts) opts.append(("-t", t)) DBCreate(dbm=self.dbm, opts=opts) self.tabs.append(t) else: self.doCreateIndexes(t) self.dbm.commitDbase() if self.opts["mf"] and self.opts["mf"].window: self.opts["mf"].updateStatus("") if self.opts["bar"]: pb.closeProgress() # Fix ctlmst and Stores Markup tabs = ["ctlmst", "strctl", "strgrp", "strgmu", "strcmu"] sql = Sql(self.dbm, tabs) coys = sql.getRec("ctlmst", cols=["ctm_cono"]) for coy in coys: mods = sql.getRec("ctlmst", cols=["ctm_modules"], where=[("ctm_cono", "=", coy[0])], limit=1) newm = "" for x in range(0, len(mods[0]), 2): if mods[0][x:x + 2] == "PS": continue newm += mods[0][x:x + 2] sql.updRec("ctlmst", cols=["ctm_modules"], data=[newm], where=[("ctm_cono", "=", coy[0])]) sctl = sql.getRec("strctl", cols=["cts_plevs", "cts_automu"], where=[("cts_cono", "=", coy[0])], limit=1) if sctl: if sctl[1] == "N": sql.delRec("strgmu", where=[("smg_cono", "=", coy[0])]) sql.delRec("strcmu", where=[("smc_cono", "=", coy[0])]) else: if sctl[1] == "Y": sql.updRec("strctl", cols=["cts_automu"], data=["L"], where=[("cts_cono", "=", coy[0])]) sctl[1] = "L" grps = sql.getRec("strgrp", cols=["gpm_group"], where=[("gpm_cono", "=", coy[0])]) for grp in grps: for lvl in range(1, sctl[0] + 1): sql.delRec("strcmu", where=[("smc_cono", "=", coy[0]), ("smc_group", "=", grp[0]), ("smc_level", "=", lvl), ("smc_markup", "=", 0)]) gmu = sql.getRec("strgmu", cols=["smg_markup"], where=[("smg_cono", "=", coy[0]), ("smg_group", "=", grp[0]), ("smg_level", "=", lvl)], limit=1) if gmu: if not gmu[0]: sql.delRec("strgmu", where=[ ("smg_cono", "=", coy[0]), ("smg_group", "=", grp[0]), ("smg_level", "=", lvl) ]) sql.delRec("strcmu", where=[("smc_cono", "=", coy[0]), ("smc_group", "=", grp[0]), ("smc_level", "=", lvl), ("smc_markup", "=", gmu[0])]) # Standard Records if self.opts["mf"] and self.opts["mf"].window: spl = SplashScreen(self.opts["mf"].body, "Creating Standard Records\n\nPlease Wait") self.opts["mf"].updateStatus("Creating Standard Records") elif self.opts["bar"]: print("Creating Standard Records .... Please Wait") sql = Sql(self.dbm, ["ffield", "frelat"], error=False, prog=self.__class__.__name__) if not sql.error: sql.sqlRec("Delete from frelat") self.doPopulate(sql, "frelat", "_cono") sql = Sql(self.dbm, "wagrcv", error=False, prog=self.__class__.__name__) if not sql.error: sql.sqlRec("Delete from wagrcv") self.doPopulate(sql, "wagrcv") sql = Sql(self.dbm, ["tplmst", "tpldet"], error=False, prog=self.__class__.__name__) if not sql.error: for tpl in stdtpl: sql.sqlRec("Delete from tplmst where tpm_tname = '%s'" % tpl) sql.sqlRec("Delete from tpldet where tpd_tname = '%s'" % tpl) for dat in datdic["tplmst"]: sql.insRec("tplmst", data=dat) for dat in datdic["tpldet"]: sql.insRec("tpldet", data=dat) sql = Sql(self.dbm, ["wagtxa", "wagtxr"], error=False, prog=self.__class__.__name__) if not sql.error: try: from tartanWork import payeRates, siteRates, uifRates, sdlRates for t in ("wagtxa", "wagtxr"): if t == "wagtxa": for year in payeRates: sql.delRec(t, where=[("wta_year", "=", int(year))]) data = [int(year)] for n, d in enumerate(payeRates[year]["allow"]): data.append(d) if n == 1 and \ len(payeRates[year]["allow"]) == 3: data.append(d) data.append(siteRates[year]) data.extend(uifRates[year]) data.extend(sdlRates[year]) sql.insRec("wagtxa", data=data) elif t == "wagtxr": for year in payeRates: sql.delRec(t, where=[("wtr_year", "=", int(year))]) to = 9999999 for rate in payeRates[year]["rates"]: dat = [int(year)] if rate[0]: dat.append(rate[0] + 1) dat.append(to) dat.extend(rate[1:]) to = rate[0] else: dat.append(0) dat.append(to) dat.extend(rate[1:]) sql.insRec("wagtxr", data=dat) except: pass # Close Splash if self.opts["mf"] and self.opts["mf"].window: self.opts["mf"].updateStatus("") spl.closeSplash() self.dbm.commitDbase()
class bc3080(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): if "args" in self.opts: self.ctyp = self.opts["args"][0] self.cnam = self.opts["args"][1] self.card = False self.qty = 1 self.doEnd() else: 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, ["bwlcmp", "bwltyp", "bwlpts", "bwlnot"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) bwlctl = gc.getCtl("bwlctl", self.opts["conum"]) if not bwlctl: return self.fromad = bwlctl["ctb_emadd"] t = time.localtime() self.sysdt = time.strftime("%d %B %Y %H:%M:%S", t) self.image = os.path.join(self.opts["mf"].rcdic["wrkdir"], "bowls.png") if not os.path.exists(self.image): getImage("bowls", fle=self.image) if not os.path.exists(self.image): self.image = None self.card = True return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Competition Format") com = { "stype": "R", "tables": ("bwlcmp",), "cols": ( ("bcm_code", "", 0, "Cod"), ("bcm_name", "", 0, "Name", "Y"), ("bcm_date", "", 0, "Date")), "where": [("bcm_cono", "=", self.opts["conum"])]} r1s = (("A4 Page", "P"), ("A6 Card", "C")) fld = ( (("T",0,0,0),"I@bcm_code",0,"","", "","Y",self.doCmpCod,com,None,("notzero",)), (("T",0,0,0),"ONA",30,""), (("T",0,1,0),"ITV",(50,10),"Notes","", "","N",self.doNotes,None,None,None,None,"""Enter All Additional Rules and Notes for the Competition e.g. what to do in these cases: Trial Ends - Only 1 trial end per game. Burnt Ends - Replay the end."""), (("T",0,2,0),("IRB",r1s),0,"Paper Type","", "P","N",self.doPaper,None,None,None), (("T",0,3,0),"IUI",2,"Quantity","", 1,"N",self.doQty,None,None,("notzero",))) but = (("Edit Notes", None, self.doEdit, 0, ("T",0,4), ("T",0,5)),) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, butt=but, tend=tnd, txit=txt, view=("N","V"), mail=("Y","N")) def doCmpCod(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("bwlcmp", cols=["bcm_name", "bcm_type"], where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", w)], limit=1) if not chk: return "Invalid Competition Code" self.ccod = w self.cnam = chk[0] self.ctyp = chk[1] self.df.loadEntry(frt, pag, p+1, data=self.cnam) nte = self.sql.getRec("bwlnot", where=[("bcn_cono", "=", self.opts["conum"]), ("bcn_ccod", "=", self.ccod)], limit=1) if nte: self.notes = nte[2] self.df.loadEntry(frt, pag, p+2, self.notes) return "sk2" def doEdit(self): self.df.focusField("T", 0, 3, tag=False) def doNotes(self, frt, pag, r, c, p, i, w): self.notes = w def doPaper(self, frt, pag, r, c, p, i, w): if w == "P": self.card = False else: self.card = True def doQty(self, frt, pag, r, c, p, i, w): self.qty = w def doEnd(self): if "args" not in self.opts: hdr = self.tit prt = copyList(self.df.repprt) eml = copyList(self.df.repeml) self.df.closeProcess() else: hdr = "%03i %s - %s" % (self.opts["conum"], self.opts["conam"], "Competition Format") prt = ["Y", "V", "view"] eml = None self.drawFormat() 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"], pdfnam=pdfnam, header=hdr, repprt=prt, fromad=self.fromad, repeml=eml) if "wait" not in self.opts: self.opts["mf"].closeLoop() def drawFormat(self): whr = [ ("bct_cono", "=", self.opts["conum"]), ("bct_code", "=", self.ctyp)] rec = self.sql.getRec("bwltyp", where=whr, limit=1) ldic = {} for col in self.sql.bwltyp_col[3:]: ldic[col] = rec[self.sql.bwltyp_col.index(col)] whr = [ ("bcp_cono", "=", self.opts["conum"]), ("bcp_code", "=", self.ctyp)] rec = self.sql.getRec("bwlpts", where=whr) for r in rec: if r[self.sql.bwlpts_col.index("bcp_ptyp")] == "D": ptyp = "drawn" else: ptyp = "svs" ldic[ptyp] = {} for col in self.sql.bwlpts_col[3:]: ldic[ptyp][col] = r[self.sql.bwlpts_col.index(col)] if self.card: self.fpdf = MyFpdf(auto=True) self.fpdf.set_margins(55, 5, 55) self.fpdf.c_margin = self.fpdf.c_margin * 2 self.fpdf.set_font("Arial","",8) h = 3.5 else: self.fpdf = MyFpdf(auto=True) self.fpdf.set_font("Arial","",14) h = 6 self.fpdf.header = self.pageHeading cwth = self.fpdf.get_string_width("X") x1 = self.fpdf.l_margin + (cwth * 20) x2 = self.fpdf.l_margin + (cwth * 22) for page in range(self.qty): self.fpdf.add_page() self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_cfmat"][4], h=h, ln=0) if ldic["bct_cfmat"] == "T": txt = "Tournament" elif ldic["bct_cfmat"] in ("D", "K"): txt = "Knockout" elif ldic["bct_cfmat"] == "R": txt = "Round Robin" else: txt = "Match" self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_tsize"][4], h=h, ln=0) self.fpdf.drawText(txt=ldic["bct_tsize"], x=x1, h=h, ctyp="M") #if ldic["bct_cfmat"] in ("D", "K", "R"): # return self.fpdf.drawText(txt="Draw", h=h, ln=0) if ldic["bct_drawn"] == ldic["bct_games"]: txt = "All Games will be Random Draws." else: if ldic["bct_drawn"] == 1: txt = "The First Game will be a Random Draw and "\ "thereafter Strength v Strength." else: txt = "The First %s Games will be Random Draws and "\ "thereafter Strength v Strength." % ldic["bct_drawn"] self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") if ldic["bct_games"]: self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_games"][4], h=h, ln=0) self.fpdf.drawText(txt=ldic["bct_games"], x=x1, h=h, ctyp="M") self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_ends"][4],h=h,ln=0) self.fpdf.drawText(txt=ldic["bct_ends"], x=x1, h=h, ctyp="M") if ldic["bct_grgame"]: self.fpdf.drawText(txt="Groups", h=h, ln=0) txt = "Teams will be Split into Groups After Game %s." % \ ldic["bct_grgame"] self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") if ldic["bct_adjust"] == "Y": txt = "With the Exception of Group A, the Scores will be "\ "Adjusted as follows:" self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") if ldic["bct_expunge"]: gms = ldic["bct_expunge"].split(",") if len(gms) == 1: txt = "Game %s will be Expunged" % gms[0] else: txt = "Games %s" % gms[0] for n, g in enumerate(gms[1:]): if n == len(gms) - 2: txt = "%s and %s" % (txt, g) else: txt = "%s, %s" % (txt, g) txt = "%s will be Expunged." % txt self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M") if ldic["bct_percent"]: if ldic["bct_expunge"]: txt = "The Balance of the Games" else: txt = "All Games" txt = "%s will Retain %s%s of their score." % (txt, ldic["bct_percent"], "%") self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M") # Points self.fpdf.drawText(h=h) if ldic["bct_pdiff"] == "Y": nums = ["drawn", "svs"] else: nums = ["drawn"] for ptyp in nums: if ldic["bct_pdiff"] == "N": txt = "Scoring for All Games" elif ptyp == "drawn": txt = "Scoring for Drawn Games" else: txt = "Scoring for S v S Games" self.fpdf.drawText(txt=txt, h=h) self.fpdf.underLine(h=h, txt=txt) if ldic[ptyp]["bcp_sends"]: self.fpdf.drawText(txt="Skins", h=h, ln=0) self.fpdf.drawText(txt="Each Set of %s Ends will "\ "Constitute a Skin." % ldic[ptyp]["bcp_sends"], x=x1, h=h, ctyp="M") self.fpdf.drawText(txt="Points", h=h, ln=0) txt = "" pts = 0 if ldic[ptyp]["bcp_e_points"]: if ldic[ptyp]["bcp_e_points"] == 1: txt = "%s Point per End" % ldic[ptyp]["bcp_e_points"] else: txt = "%s Points per End" % ldic[ptyp]["bcp_e_points"] self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") pts += (ldic[ptyp]["bcp_e_points"] * ldic["bct_ends"]) if ldic[ptyp]["bcp_s_points"]: if ldic[ptyp]["bcp_s_points"] == 1: txt = "%s Point per Skin" % ldic[ptyp]["bcp_s_points"] else: txt = "%s Points per Skin" % ldic[ptyp]["bcp_s_points"] self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") pts += (ldic[ptyp]["bcp_s_points"] * int(ldic["bct_ends"] / ldic[ptyp]["bcp_sends"])) if ldic[ptyp]["bcp_g_points"]: if ldic[ptyp]["bcp_g_points"] == 1: txt = "%s Point per Game" % ldic[ptyp]["bcp_g_points"] else: txt = "%s Points per Game" % ldic[ptyp]["bcp_g_points"] self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") pts += ldic[ptyp]["bcp_g_points"] if ldic[ptyp]["bcp_bonus"] == "Y": txt = "1 Bonus Point will be Awarded as Follows:" self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") txt = "Winning by %s or More Shots or" % \ (ldic[ptyp]["bcp_win_by"] + 1) self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M") txt = "Losing by %s or Less Shots" % \ (ldic[ptyp]["bcp_lose_by"] - 1) self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M") pts += 1 if pts: if pts == 1: txt = "Point" else: txt = "Points" txt = "Therefore a Maximum of %s %s per Game." % (pts, txt) self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M") if self.notes: txt = "Notes" self.fpdf.drawText(h=h) self.fpdf.drawText(txt=txt, h=h) self.fpdf.underLine(h=h, txt=txt) self.fpdf.drawText(txt=self.notes, h=h, ctyp="M") self.sql.delRec("bwlnot", where=[("bcn_cono", "=", self.opts["conum"]), ("bcn_ccod", "=", self.ccod)]) self.sql.insRec("bwlnot", data=[self.opts["conum"], self.ccod, self.notes]) self.opts["mf"].dbm.commitDbase() def pageHeading(self): if self.card: self.fpdf.set_fill_color(220) self.fpdf.set_font("Arial","B",12) self.fpdf.drawText("Competiton Format and Points", h=6, align="C", border="TLRB", fill=True) self.fpdf.set_line_width(1) self.fpdf.rect(self.fpdf.l_margin, self.fpdf.t_margin, 100, 140) self.fpdf.set_line_width(0) self.fpdf.ln(4) return if self.image: if self.card: self.fpdf.image(self.image, x=10, y=10, w=7, h=5) else: self.fpdf.image(self.image, x=10, y=10, w=15, h=11) self.fpdf.set_font("Arial","B",15) self.fpdf.cell(20) self.fpdf.cell(0,10,"Format Sheet for the %s" % self.cnam,1,0,"C") self.fpdf.ln(20) def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class mlc410(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", "memctk", "memkon"], prog=self.__class__.__name__) if self.sql.error: return chk = self.sql.getRec("memctk") if not chk: self.sql.insRec("memctk", data=[1, "H", "Home Telephone Number"]) self.sql.insRec("memctk", data=[2, "W", "Work Telephone Number"]) self.sql.insRec("memctk", data=[3, "M", "Mobile Telephone Number"]) self.sql.insRec("memctk", data=[4, "F", "Facsimile Number"]) self.sql.insRec("memctk", data=[5, "E", "E-Mail Address"]) self.opts["mf"].dbm.commitDbase() return True def mainProcess(self): cod = { "stype": "R", "tables": ("memctk", ), "cols": (("mck_code", "", 0, "CD"), ("mck_desc", "", 0, "Description", "Y")) } typ = { "stype": "C", "title": "Available Types", "head": ("C", "Description"), "data": (("E", "E-Mail"), ("F", "Facsimile"), ("H", "Home Phone"), ("M", "Mobile"), ("W", "Work Phone")) } fld = ((("T", 0, 0, 0), "I@mck_code", 0, "", "", "", "N", self.doCode, cod, None, ("notzero", )), (("T", 0, 1, 0), "I@mck_type", 0, "", "", "", "N", self.doType, typ, None, ("in", ("E", "F", "H", "M", "W"))), (("T", 0, 2, 0), "I@mck_desc", 0, "", "", "", "N", self.doDesc, 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=fld, butt=but, tend=tnd, txit=txt) def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.old = self.sql.getRec("memctk", where=[("mck_code", "=", self.code)], limit=1) if self.old: self.new = False self.ktyp = self.old[self.sql.memctk_col.index("mck_type")] self.df.loadEntry(frt, pag, p + 1, data=self.ktyp) self.desc = self.old[self.sql.memctk_col.index("mck_desc")] self.df.loadEntry(frt, pag, p + 2, data=self.desc) else: self.new = True def doType(self, frt, pag, r, c, p, i, w): self.ktyp = w def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doDelete(self): if self.code in (1, 2, 3, 4, 5): return "Static Code, Not Deleted" chk = self.sql.getRec("memkon", cols=["count(*)"], where=[("mlk_code", "=", self.code)], limit=1) if chk[0]: return "Code in Use (memkon), Not Deleted" self.sql.delRec("memctk", where=[("mck_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [self.code, self.ktyp, self.desc] if self.new: self.sql.insRec("memctk", data=data) elif data != self.old[:len(data)]: col = self.sql.memctk_col data.append(self.old[col.index("mck_xflag")]) self.sql.updRec("memctk", data=data, where=[("mck_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 cs2020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) cshctl = gc.getCtl("cshctl", self.opts["conum"]) if not cshctl: return self.glint = cshctl["ccc_glint"] if self.glint == "N": showError(self.opts["mf"].window, "Error", "Cash Analysis Not Integrated.") return ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) self.cshctl = ctlctl["csh_ctl"] self.vatctl = ctlctl["vat_ctl"] tabs = ["cshana", "cshcnt", "gentrn", "ctlvtf"] self.sql = Sql(self.opts["mf"].dbm, tables=tabs, prog=self.__class__.__name__) if self.sql.error: return self.dte = self.sql.getRec("cshcnt", cols=["max(cct_date)"], where=[("cct_cono", "=", self.opts["conum"])], limit=1)[0] t = time.localtime() self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2] return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Cash Merge (%s)" % self.__class__.__name__) dte = { "stype": "R", "tables": ("cshcnt",), "cols": ( ("cct_date", "", 0, "Date"),), "where": [("cct_cono", "=", self.opts["conum"])], "group": "cct_date"} fld = ( (("T",0,0,0),"ID1",10,"From Date","", self.dte,"Y",self.doFrom,dte,None,("efld",)), (("T",0,1,0),"Id1",10,"To Date","To Date", "","Y",self.doTo,dte,None,("efld",))) tnd = ((self.doEnd,"Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, tend=tnd, txit=txt) def doFrom(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.fm = w self.fmd = self.df.t_disp[pag][r][p] self.df.loadEntry(frt, pag, p+1, data=self.fm) def doTo(self, frt, pag, r, c, p, i, w): if not w: w = self.fm elif w < self.fm: return "Invalid To Date" if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" self.to = w self.tod = CCD(w, "D1", 10).disp csh = self.sql.getRec("cshcnt", where=[("cct_cono", "=", self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date", "between", self.fm, self.to)]) if not csh: return "ff1|Invalid Cash Capture Dates" def doEnd(self): self.df.closeProcess() recs = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_trdt", "between", self.fm, self.to), ("can_gflag", "=", "N")], order="can_trdt") if not recs: showInfo(self.opts["mf"].window, "Merge", "There are No Records to Merge.") else: for rec in recs: # Expense and Income acc = self.sql.getRec("gentrn", cols=["max(glt_refno)"], where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.cshctl), ("glt_type", "=", 4), ("glt_refno", "like", "CS_______")], limit=1) if acc: try: auto = int(acc[0][2:]) + 1 except: auto = 1 else: auto = 1 refno = "CS%07d" % auto ttyp = rec[self.sql.cshana_col.index("can_type")] iamnt = rec[self.sql.cshana_col.index("can_incamt")] vamnt = rec[self.sql.cshana_col.index("can_vatamt")] eamnt = float(ASD(iamnt) - ASD(vamnt)) if ttyp == "T": iamnt = float(ASD(0) - ASD(iamnt)) vamnt = float(ASD(0) - ASD(vamnt)) eamnt = float(ASD(0) - ASD(eamnt)) vcod = rec[self.sql.cshana_col.index("can_vatcod")] data = [rec[self.sql.cshana_col.index("can_cono")]] acno = rec[self.sql.cshana_col.index("can_code")] trdt = rec[self.sql.cshana_col.index("can_trdt")] curdt = int(trdt / 100) data.extend([acno, curdt, trdt, 4, refno, "CSHMRGE", eamnt, vamnt, "Cash Analysis", vcod]) data.extend(["", 0, self.opts["capnm"], self.sysdt]) self.sql.insRec("gentrn", data=data) # VAT Control data[1] = self.vatctl data[7] = vamnt data[8] = 0 self.sql.insRec("gentrn", data=data) # Cash Control data[1] = self.cshctl data[7] = float(ASD(0) - ASD(iamnt)) data[8] = 0 data[9] = rec[self.sql.cshana_col.index("can_desc")] self.sql.insRec("gentrn", data=data) # VAT Record data = [rec[self.sql.cshana_col.index("can_cono")]] data.append(vcod) if ttyp == "T": data.append("O") else: data.append("I") data.extend([curdt, "G", 4, "CSHMRG", refno, trdt, acno, "Cash Analysis", eamnt, vamnt, 0, self.opts["capnm"], self.sysdt]) self.sql.insRec("ctlvtf", data=data) # Update seq = rec[self.sql.cshana_col.index("can_seq")] self.sql.updRec("cshana", cols=["can_gflag"], data=["Y"], where=[("can_seq", "=", seq)]) self.opts["mf"].dbm.commitDbase(True) self.closeProcess() def doExit(self): self.df.closeProcess() self.closeProcess() def closeProcess(self): self.opts["mf"].closeLoop()
class ar2030(object): def __init__(self, **opts): self.opts = opts if "args" in self.opts: self.args = self.opts["args"] else: self.args = None if self.setVariables(): if self.args: if not self.doChkDate(self.args[0]): self.endPage0() else: self.dataHeader() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) assctl = gc.getCtl("assctl", self.opts["conum"]) if not assctl: return self.glint = assctl["cta_glint"] self.rordp = assctl["cta_rordp"] self.lastp = assctl["cta_lastp"] self.sper = int(self.opts["period"][1][0] / 100) self.eper = int(self.opts["period"][2][0] / 100) yr = int(self.lastp / 100) mt = (self.lastp % 100) + 1 if mt > 12: yr += 1 mt = 1 self.curdt = (yr * 100) + mt if self.curdt > self.eper: self.curdt = self.eper t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] tabs = ["assctl", "assgrp", "assmst", "assdep", "asstrn", "gentrn"] self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return chk = self.sql.getRec("asstrn", where=[("ast_cono", "=", self.opts["conum"]), ("ast_mtyp", "=", 4), ("ast_curdt", ">", self.eper)]) if chk: if not self.args: showError(self.opts["mf"].body, "Period Error", "Depreciation Has Already Been Raised in "\ "the Next Financial Period") return return True def dataHeader(self): fld = ((("T", 0, 0, 0), "ID2", 7, "Cut-off Period", "", self.curdt, "N", self.doTrdate, None, None, None), ) tnd = ((self.endPage0, "y"), ) txt = (self.exitPage0, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt) def doTrdate(self, frt, pag, r, c, p, i, w): chk = self.doChkDate(w) if chk: return chk def doChkDate(self, date): if date < self.sper or date > self.eper: return "Invalid Date, Not in Financial Period" if self.lastp and self.lastp < self.sper: dte1 = mthendDate(self.lastp * 100) dte2 = mthendDate(self.sper * 100) if dateDiff(dte1, dte2, "months") > 1: return "Missing Depreciation for Previous Period" self.curdt = date def endPage0(self): if self.args: recs = self.sql.getRec("assmst", where=[("asm_cono", "=", self.opts["conum"]), ("asm_group", "=", self.args[1]), ("asm_code", "=", self.args[2])]) else: self.df.closeProcess() recs = self.sql.getRec("assmst", where=[("asm_cono", "=", self.opts["conum"]) ]) if recs: self.doRaiseAll(recs) if "wait" not in self.opts: self.opts["mf"].closeLoop() def doRaiseAll(self, recs): if not self.args: p = ProgressBar(self.opts["mf"].body, mxs=len(recs), typ="Raising Depreciation ... Please Wait") for num, dat in enumerate(recs): if not self.args: p.displayProgress(num) self.group = CCD(dat[self.sql.assmst_col.index("asm_group")], "UA", 3) grp = self.sql.getRec("assgrp", where=[("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", self.group.work)], limit=1) if not grp: if not self.args: showError(self.opts["mf"].body, "Group Error", "Missing Group (%s) Record" % self.group.disp) abort = True break self.depacc = grp[self.sql.assgrp_col.index("asg_depacc")] self.expacc = grp[self.sql.assgrp_col.index("asg_expacc")] self.code = dat[self.sql.assmst_col.index("asm_code")] depcod = dat[self.sql.assmst_col.index("asm_depcod")] # Get Depreciation Record self.dep = self.sql.getRec(tables="assdep", where=[("asd_cono", "=", self.opts["conum"]), ("asd_code", "=", depcod)], limit=1) if not self.dep: showError(self.opts["mf"].body, "Error", "Depreciation Code %s Does Not Exist.\n\n"\ "Aborting." % depcod) abort = True break bals = Balances(self.opts["mf"], "ASS", self.opts["conum"], self.sper, keys=(self.group.work, self.code)) asset = bals.doAssBals() if not asset: continue self.cap, cdp, rdp, cbl, rbl, mov = asset # Raise depreciation from start period to curdt or sale date self.lurdt = self.sper sales = False while not sales and self.lurdt <= self.curdt: trans = self.sql.getRec( "asstrn", cols=["ast_mtyp", "round(sum(ast_amt1), 2)"], where=[("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group.work), ("ast_code", "=", self.code), ("ast_curdt", "=", self.lurdt), ("ast_mtyp", "<>", 4)], group="ast_mtyp") if trans: for mov, amt in trans: if mov == 5: sales = True self.cap = 0 break self.cap = float(ASD(self.cap) + ASD(amt)) if self.cap: self.doRaiseDep() self.lurdt = self.doIncrCurdt() if not self.args: p.closeProgress() if abort: self.opts["mf"].dbm.rollbackDbase() else: self.sql.updRec("assctl", cols=["cta_lastp"], data=[self.curdt], where=[("cta_cono", "=", self.opts["conum"])]) self.opts["mf"].dbm.commitDbase() def doIncrCurdt(self): yr = int(self.lurdt / 100) mt = self.lurdt % 100 if mt == 12: yr += 1 mt = 1 else: mt += 1 return (yr * 100) + mt def doRaiseDep(self): # Calculate Depreciations and check if Raised # else create transaction and accumulate variables # # Extract Closing Balance at lurdt where = [("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group.work), ("ast_code", "=", self.code)] whr = copyList(where) whr.append(("ast_curdt", "<=", self.lurdt)) bal = self.sql.getRec( "asstrn", cols=["round(sum(ast_amt1), 2)", "round(sum(ast_amt2), 2)"], where=whr, limit=1) if bal and bal[0] <= 0: return # Get Date Purchased and Months to trdt self.trdt = mthendDate(self.lurdt * 100) acc = self.sql.getRec("asstrn", cols=["min(ast_date)"], where=[("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group.work), ("ast_code", "=", self.code), ("ast_mtyp", "=", 1)], limit=1) years = dateDiff(acc[0], self.trdt, "years") if years > 6: # Maximum of 7 variable rates in assdep record years = 6 # Extract Depreciation up to previous year end whr = copyList(where) whr.extend([("ast_mtyp", "=", 4), ("ast_curdt", "<", self.sper)]) pmd = self.sql.getRec( "asstrn", cols=["round(sum(ast_amt1), 2)", "round(sum(ast_amt2), 2)"], where=whr, limit=1) if not pmd[0]: pmd[0] = 0 if not pmd[1]: pmd[1] = 0 # # Extract Depreciation for lurdt whr = copyList(where) whr.extend([("ast_mtyp", "=", 4), ("ast_curdt", "=", self.lurdt)]) cmd = self.sql.getRec("asstrn", cols=[ "max(ast_refno)", "round(sum(ast_amt1), 2)", "round(sum(ast_amt2), 2)" ], where=whr, limit=1) if not cmd[0] or cmd[0] == "Take-On": self.refno = CCD(1, "Na", 9).work else: self.refno = CCD(cmd[0], "Na", 9).work if not cmd[1]: cmd[1] = 0 if not cmd[2]: cmd[2] = 0 if self.dep[self.sql.assdep_col.index("asd_typec")] == "S": # Straight Line cval = self.cap crat = self.dep[self.sql.assdep_col.index("asd_rate1c")] for x in range(2, years + 2): n = self.dep[self.sql.assdep_col.index("asd_rate%sc" % x)] if n: crat = n else: # Depreciating Balance cval = float(ASD(self.cap) + ASD(pmd[0])) crat = self.dep[self.sql.assdep_col.index("asd_rate1c")] if cval: if cval < 0: cdep = 0 else: cdep = round((cval * crat / 100.0 / 12), 2) cdep = float(ASD(cdep) + ASD(cmd[1])) cbal = float(ASD(bal[0]) - ASD(cdep)) if cbal < 0: cdep = float(ASD(cdep) + ASD(cbal)) cdep = float(ASD(0) - ASD(cdep)) typer = self.dep[self.sql.assdep_col.index("asd_typer")] if self.rordp == "N" or typer == "N": rdep = 0 else: if typer == "S": # Straight Line rval = self.cap rrat = self.dep[self.sql.assdep_col.index("asd_rate1r")] for x in range(2, years + 2): n = self.dep[self.sql.assdep_col.index("asd_rate%sr" % x)] if n: rrat = n else: # Depreciating Balance rval = float(ASD(self.cap) + ASD(pmd[1])) rrat = self.dep[self.sql.assdep_col.index("asd_rate1r")] if rval: if rval < 0: rdep = 0 else: rdep = round((rval * rrat / 100.0 / 12), 2) rdep = float(ASD(rdep) + ASD(cmd[2])) rbal = float(ASD(bal[1]) - ASD(rdep)) if rbal < 0: rdep = float(ASD(rdep) + ASD(rbal)) rdep = float(ASD(0) - ASD(rdep)) if cdep or rdep: data = [ self.opts["conum"], self.group.work, self.code, 4, self.refno, "AutoDep", self.trdt, 4, cdep, rdep, 0, self.lurdt, "Auto Raising of Depreciation", "", "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("asstrn", data=data) if self.glint == "Y" and cdep: self.doWriteGen(self.depacc, cdep) cdep = float(ASD(0) - ASD(cdep)) self.doWriteGen(self.expacc, cdep) def doWriteGen(self, accno, amnt): whr = [("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", accno), ("glt_batch", "=", "AutoDep"), ("glt_curdt", "=", self.lurdt), ("glt_trdt", "=", self.trdt), ("glt_type", "=", 4)] acc = self.sql.getRec("gentrn", where=whr) if acc and len(acc) == 1: amt = acc[0][self.sql.gentrn_col.index("glt_tramt")] amt = float(ASD(amt) + ASD(amnt)) self.sql.updRec("gentrn", cols=["glt_tramt"], data=[amt], where=whr) else: data = [ self.opts["conum"], accno, self.lurdt, self.trdt, 4, self.refno, "AutoDep", amnt, 0, "Auto Raising of Depreciation", "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) def exitPage0(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class cs1010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) cshctl = gc.getCtl("cshctl", self.opts["conum"]) if not cshctl: return glint = cshctl["ccc_glint"] if glint == "Y": showError(self.opts["mf"].window, "Error", "Cash Analysis is Integrated with General Ledger.") return ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" self.mods = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): self.mods.append(ctlmst["ctm_modules"][x:x+2]) tabs = ["ctlvmf", "cshmst", "genbal", "genbud", "genrpt", "gentrn", "chglog"] if "CR" in self.mods: tabs.append("crsctl") if "DR" in self.mods: tabs.append("drsctl") if "ST" in self.mods: tabs.extend(["strctl", "strloc"]) if "SI" in self.mods: tabs.append("slsctl") self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return chk = self.sql.getRec("cshmst", cols=["count(*)"], where=[("ccm_cono", "=", self.opts["conum"])], limit=1) if chk[0]: self.newgen = False else: self.newgen = True if "args" in self.opts: self.acno = None return True def mainProcess(self): glm = { "stype": "R", "tables": ("cshmst",), "cols": ( ("ccm_acno", "", 0, "Acc-Num"), ("ccm_desc", "", 0, "Description", "Y")), "where": [("ccm_cono", "=", self.opts["conum"])]} vat = { "stype": "R", "tables": ("ctlvmf",), "cols": ( ("vtm_code", "", 0, "Acc-Num"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])]} fld = ( (("T",0,0,0),"IUI",7,"Acc-Num","Account Number", "","Y",self.doAccNum,glm,None,("notzero",)), (("T",0,1,0),"INA",30,"Description","Account Description", "","N",None,None,None,("notblank",)), (("T",0,2,0),"IUA",1,"Tax Default","", self.taxdf,"N",self.doVatCod,vat,None,("notblank",))) but = ( ("Accept",None,self.doAccept,0,("T",0,2),(("T",0,0),("T",0,1))), ("Cancel",None,self.doCancel,0,("T",0,2),(("T",0,0),("T",0,1))), ("Quit",None,self.doQuit,1,None,None)) tnd = ((self.doEnd,"y"), ) txt = (self.doQuit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt) def doAccNum(self, frt, pag, r, c, p, i, w): self.acno = w self.old = self.sql.getRec("cshmst", where=[("ccm_cono", "=", self.opts["conum"]), ("ccm_acno", "=", self.acno)], limit=1) if not self.old: self.new = True elif "args" in self.opts: showError(self.opts["mf"].body, "Error", "Only a New Account is Allowed") return "rf" else: self.new = False for x in range(0, self.df.topq[pag]): self.df.loadEntry(frt, pag, p+x, data=self.old[x+1]) def doTypCod(self, frt, pag, r, c, p, i, w): if self.new: if w == "P": self.df.topf[pag][4][5] = self.taxdf else: self.df.topf[pag][4][5] = "N" elif not self.df.topf[pag][4][5]: self.df.topf[pag][4][5] = "N" def doVatCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) if not acc: return "Invalid VAT Code" def doDelete(self): t = self.sql.getRec("cshana", cols=["count(*)"], where=[("can_cono", "=", self.opts["conum"]), ("can_code", "=", self.acno)], limit=1) if t[0]: return "Transactions Exist, Not Deleted" self.sql.delRec("cshmst", where=[("ccm_cono", "=", self.opts["conum"]), ("ccm_code", "=", self.acno)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["cshmst", "D", "%03i%07i" % (self.opts["conum"], self.acno), "", dte, self.opts["capnm"], "", "", "", 0]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): if self.newgen: self.df.butt[1][4] = None self.df.butt[1][5] = None data = [self.opts["conum"], self.acno, self.df.t_work[0][0][1], self.df.t_work[0][0][2]] if self.new: self.sql.insRec("cshmst", data=data) elif data != self.old[:len(data)]: col = self.sql.cshmst_col data.append(self.old[col.index("ccm_xflag")]) self.sql.updRec("cshmst", data=data, where=[("ccm_cono", "=", self.opts["conum"]), ("ccm_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=["cshmst", "U", "%03i%07i" % (self.opts["conum"], self.acno), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0]) self.opts["mf"].dbm.commitDbase() if "args" in self.opts: self.doQuit() else: self.df.focusField("T", 0, 1) def doAccept(self): frt, pag, col, mes = self.df.doCheckFields() if mes: self.df.focusField(frt, pag, (col+1), err=mes) else: self.df.doEndFrame("T", 0, cnf="N") def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.last[0] = [0, 0] self.df.focusField("T", 0, 1) def doIgExit(self): self.igexit = True self.ig.closeProcess() def doQuit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class ml3080(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, ["memmst", "memsta", "memtrn", "memcat", "memctc", "memctp"], prog=self.__class__.__name__) if self.sql.error: return mc = GetCtl(self.opts["mf"]) memctl = mc.getCtl("memctl", self.opts["conum"]) if not memctl: return self.fromad = memctl["mcm_emadd"] self.s_per = int(self.opts["period"][1][0] / 100) t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def mainProcess(self): r1s = (("Number", "N"), ("Surname", "M")) r2s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Sort Order", "", "N", "Y", self.doSort, None, None, None), (("T", 0, 1, 0), ("IRB", r2s), 0, "Include Pay Plan", "", "N", "Y", self.doPayPlan, 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=("Y", "V"), mail=("Y", "N")) def doSort(self, frt, pag, r, c, p, i, w): self.sort = w def doPayPlan(self, frt, pag, r, c, p, i, w): self.plan = w def doEnd(self): self.df.closeProcess() col = [ "mlm_memno", "mlm_surname", "mlm_names", "mlm_payplan", "mlc_code" ] whr = [("mlm_cono", "=", self.opts["conum"]), ("mlm_state", "=", "A")] if self.plan == "N": whr.append(("mlm_payplan", "=", "N")) whr.extend([("mlc_cono=mlm_cono", ), ("mlc_memno=mlm_memno", ), ("mlc_type", "=", "B")]) grp = "mlm_memno, mlm_surname, mlm_names, mlm_payplan, mlc_code" if self.sort == "N": odr = "mlm_memno" else: odr = "mlm_surname" sp = SplashScreen(self.opts["mf"].body, "Preparing Report ... Please Wait") recs = self.sql.getRec(tables=["memmst", "memcat"], cols=col, where=whr, group=grp, order=odr) sp.closeSplash() if not recs: self.opts["mf"].closeLoop() return p = ProgressBar(self.opts["mf"].body, typ="Generating the Report", mxs=len(recs), esc=True) data = [] for num, rec in enumerate(recs): p.displayProgress(num) if p.quit: break whr = [("mlt_cono", "=", self.opts["conum"]), ("mlt_memno", "=", rec[0])] trn = getTrn(self.opts["mf"].dbm, "mem", whr=whr, zer="N") bal = 0 inv = 0 for t in trn[1]: c = trn[0] bal = float(ASD(bal) + ASD(t[c.index("mlt_tramt")])) if t[c.index("mlt_type")] == 1 and \ t[c.index("mlt_curdt")] >= self.s_per: inv = float(ASD(inv) + ASD(t[c.index("mlt_tramt")])) if not bal or bal < inv: continue cat = self.sql.getRec(tables=["memctc", "memctp"], cols=["mcc_desc", "mcp_rate_01"], where=[("mcc_cono", "=", self.opts["conum"]), ("mcc_type", "=", "B"), ("mcc_code", "=", rec[4]), ("mcp_cono=mcc_cono", ), ("mcp_type=mcc_type", ), ("mcp_code=mcc_code", )], order="mcp_date desc", limit=1) if not cat or bal < cat[1]: continue rec[1] = "%s, %s" % (rec[1], rec[2]) del rec[2] rec[3] = cat[0] rec.append(cat[1]) rec.append(inv) rec.append(bal) data.append(rec) p.closeProgress() if p.quit: self.opts["mf"].closeLoop() return name = self.__class__.__name__ head = ["Members Suspension Report"] cols = [["a", "NA", 7, "Mem-No", "y"], ["b", "NA", 50, "Name", "y"], ["d", "UA", 1, "P", "y"], ["c", "NA", 30, "Active-Category", "y"], ["e", "SD", 13.2, "Subscription", "y"], ["f", "SD", 13.2, "Tot-Invoiced", "y"], ["g", "SD", 13.2, "Tot-Balance", "y"]] rep = RepPrt(self.opts["mf"], conum=self.opts["conum"], conam=self.opts["conam"], name=name, tables=data, heads=head, cols=cols, gtots=("e", "f", "g"), ttype="D", repprt=self.df.repprt, repeml=self.df.repeml, fromad=self.fromad) if not rep.xits: ask = askChoice(self.opts["mf"].body, "Suspend Members", "Select Members to Suspend", butt=(("All", "A"), ("Some", "S"), ("None", "N")), default="None") if ask in ("A", "S"): if ask == "S": cols = ["memno", "name"] dics = { "memno": ("", 0, "UI", 6, "Member Number", "Mem-No"), "name": ("", 1, "NA", 50, "Member Name", "Name") } newd = [] for dat in data: newd.append((dat[0], dat[1])) data = getSingleRecords(self.opts["mf"], "", cols, where=newd, ttype="D", dic=dics) if data: p = ProgressBar(self.opts["mf"].body, typ="Suspending Members", mxs=len(data)) for num, rec in enumerate(data): p.displayProgress(num) self.sql.updRec("memmst", cols=["mlm_state", "mlm_sdate"], data=["S", self.sysdtw], where=[("mlm_cono", "=", self.opts["conum"]), ("mlm_memno", "=", rec[0])]) self.sql.insRec("memsta", data=[ self.opts["conum"], rec[0], "S", self.sysdtw, self.opts["capnm"], self.sysdtw, 0 ]) self.opts["mf"].dbm.commitDbase() p.closeProgress() self.opts["mf"].closeLoop() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class st1020(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, ["strgrp", "strmf1", "strmf2", "strloc", "strcst"], 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"] return True def drawDialog(self): grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } st1 = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_code", "", 0, "Product-Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "X")], "whera": [("C", "st1_group", 0)] } loc = { "stype": "R", "tables": ("strmf2", "strloc"), "cols": (("st2_loc", "", 0, "Acc-Num"), ("srl_desc", "", 0, "Description")), "where": [("st2_cono", "=", self.opts["conum"])], "whera": (("C", "st2_group", 0), ("C", "st2_code", 1)) } self.fld = ((("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "Y", self.doGrp, grp, None, None), (("C", 0, 0, 1), "INA", 20, "Code", "Product Code", "", "N", self.doCode, st1, None, None), (("C", 0, 0, 2), "ONA", 30, "Description"), (("C", 0, 0, 3), "IUA", 1, "L", "Location", "", "N", self.doLoc, loc, None, None), (("C", 0, 0, 4), "IUD", 10.2, "Cost-Price", "Standard Cost Price", "", "N", self.doCst, None, None, ("notzero", ))) but = ( ("Import File",None,self.doImport,0,("C",0,1),("C",0,2), "Import Cost Prices from a CSV or XLS File "\ "having the following columns: Group, Code, "\ "Location, Cost-Price"), ("Exit", None, self.doExit, 1, ("C", 0, 1), ("C", 0, 2))) row = (20, ) self.df = TartanDialog(self.opts["mf"], rows=row, eflds=self.fld, cend=((self.doEnd, "y"), ), cxit=(self.doExit, ), butt=but) def doImport(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") impcol = [] pos = 0 err = None for num, fld in enumerate(self.fld): if num == 2: continue if type(fld[2]) in (tuple, list): size = fld[2][1] else: size = fld[2] impcol.append([fld[4], pos, fld[1][1:], size]) pos += 1 fi = FileImport(self.opts["mf"], impcol=impcol) for num, line in enumerate(fi.impdat): if len(line) != pos: err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \ (num + 1, pos, len(line)) break self.grp = line[0] chk = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", self.grp)], limit=1) if not chk: err = "Line %s: Invalid Group %s" % ((num + 1), self.grp) break self.cod = line[1] chk = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", self.cod)], limit=1) if not chk: err = "Line %s: Invalid Code %s" % ((num + 1), self.cod) break if chk[self.sql.strmf1_col.index("st1_value_ind")] != "S": err = "Line %s: Invalid Value-Ind %s" % ((num + 1), self.cod) break self.loc = line[2] chk = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.grp), ("st2_code", "=", self.cod), ("st2_loc", "=", self.loc)], limit=1) if not chk: err = "Line %s: Invalid Location %s" % ((num + 1), self.loc) break self.cst = line[3] if not self.cst: err = "Line %s: Invalid Cost %s" % ((num + 1), self.cst) break self.doEnd(det=True) if err: showError(self.opts["mf"].body, "Import Error", err) elif fi.impdat: self.opts["mf"].dbm.commitDbase() self.df.enableButtonsTags(state=state) self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField(self.df.frt, self.df.pag, 1) def doGrp(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not chk: return "Invalid Group" self.grp = w def doCode(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("strmf1", cols=["st1_desc", "st1_value_ind"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", w)], limit=1) if not chk: return "Invalid Code" if chk[1] != "S": return "Invalid Value-Ind" self.cod = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) if self.locs == "N": self.loc = "1" self.df.loadEntry(frt, pag, p + 2, data=self.loc) self.doLoadCost(p + 3) return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.grp), ("st2_code", "=", self.cod), ("st2_loc", "=", w)], limit=1) if not chk: return "Invalid Location" self.loc = w self.doLoadCost(p + 1) def doLoadCost(self, pos): chk = self.sql.getRec("strcst", cols=["stc_cost"], where=[("stc_cono", "=", self.opts["conum"]), ("stc_group", "=", self.grp), ("stc_code", "=", self.cod), ("stc_loc", "=", self.loc)], limit=1) if chk: self.df.loadEntry("C", 0, pos, data=chk[0]) def doDelete(self): self.sql.delRec("strcst", where=[("stc_cono", "=", self.opts["conum"]), ("stc_group", "=", self.grp), ("stc_code", "=", self.cod), ("stc_loc", "=", self.loc)]) self.opts["mf"].dbm.commitDbase() self.df.clearLine(0, focus=True) def doCst(self, frt, pag, r, c, p, i, w): self.cst = w def doEnd(self, det=False): self.sql.delRec("strcst", where=[("stc_cono", "=", self.opts["conum"]), ("stc_group", "=", self.grp), ("stc_code", "=", self.cod), ("stc_loc", "=", self.loc)]) self.sql.insRec( "strcst", data=[self.opts["conum"], self.grp, self.cod, self.loc, self.cst]) self.opts["mf"].dbm.commitDbase() self.df.advanceLine(0) self.df.loadEntry("C", 0, self.df.pos, data=self.grp) self.df.focusField("C", 0, self.df.col + 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class td1010(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, ["ctlnot", "telmst", "telgrp", "telcon"], prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.name = "" return True def mainProcess(self): acc = self.sql.getRec("telmst", cols=["count(*)"], limit=1) if acc[0] > 500: autoc = False else: autoc = True tdm = { "stype": "R", "tables": ("telmst", ), "cols": (("tdm_name", "TX", 30, "Name", "Y"), ("tdm_telno", "TX", 20, "Telephone"), ("tdm_mobile", "TX", 20, "Mobile"), ("tdm_email", "TX", 50, "Email-Address"), ("tdm_group", "UA", 12, "Grp")), "order": "tdm_name", "autoc": autoc, "sort": "n" } grp = { "stype": "S", "tables": "telgrp", "cols": ("tdg_group", "tdg_desc"), "order": "tdg_desc" } self.fld = ((("T", 0, 0, 0), "I@tdm_name", 50, "", "", "", "Y", self.doName, tdm, None, ("notblank", )), (("T", 0, 1, 0), "I@tdm_adr1", 0, "", "", "", "N", None, None, self.doDelAll, ("efld", )), (("T", 0, 2, 0), "I@tdm_adr2", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 3, 0), "I@tdm_adr3", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 4, 0), "I@tdm_pcode", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 5, 0), "I@tdm_telno", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 6, 0), "I@tdm_faxno", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 7, 0), "I@tdm_mobile", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 8, 0), "I@tdm_email", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 9, 0), "I@tdm_group", 0, "", "", "", "N", self.doGroup, grp, None, ("efld", ), None, "Comma separated groups which this contact belongs to.")) but = ( ("Back",None,self.doUp,1,None,("T",0,1),"",1), ("Forward",None,self.doDn,1,None,("T",0,1),"",1), ("Import",None,self.doImport,1,("T",0,1),("T",0,2), "Import Names, Addresses and Contact Details from "\ "Booking, Creditor, Debtor and Member Records, if "\ "Available",1), ("Notes",None,self.doNotes,1,("T",0,2),("T",0,1),"",1), ("Print",None,self.doPrint,1,None,None,"",1), ("Apply",None,self.doApply,0,("T",0,2),("T",0,1),"",1), ("Contacts",None,self.doContacts,0,("T",0,2),("T",0,1),"",2,2), ("Cancel",None,self.doCancel,0,("T",0,2),("T",0,1),"",2,2), ("Quit",None,self.doTopExit,1,None,None,"",2,2)) tnd = ((self.doTopEnd, "y"), ) txt = (self.doTopExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt, clicks=self.doClick) def doClick(self, *opts): if not self.name or opts[0][1] == 11: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doName(self, frt, pag, r, c, p, i, w): self.name = w self.acc = self.sql.getRec("telmst", where=[("tdm_name", "like", self.name + "%") ], order="tdm_name asc", limit=1) if not self.acc: self.newmst = True self.con = 0 else: self.newmst = False self.df.setWidget(self.df.B0, "normal") self.df.setWidget(self.df.B1, "normal") self.doLoadDetail(self.acc[:-1]) def doGroup(self, frt, pag, r, c, p, i, w): try: grp = eval(w) self.group = "" for g in grp: if not self.group: self.group = g[0] else: self.group = "%s,%s" % (self.group, g[0]) except: self.group = w self.df.loadEntry(frt, pag, p, data=self.group) if not self.group: return check = self.group.split(",") err = None for chk in check: acc = self.sql.getRec("telgrp", cols=["tdg_desc"], where=[("tdg_group", "=", chk)], limit=1) if not acc: err = "Invalid Group %s" % chk break return err def doDelAll(self): self.sql.delRec("telmst", where=[("tdm_name", "=", self.name)]) self.sql.delRec("telcon", where=[("tdc_name", "=", self.name)]) self.sql.delRec("ctlnot", where=[("not_cono", "=", 0), ("not_sys", "=", "TEL"), ("not_key", "=", self.name)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doTopEnd(self): data = self.df.t_work[0][0][:] if self.newmst: self.sql.insRec("telmst", data=data) elif data != self.acc[:len(data)]: tdm = self.sql.telmst_col data.append(self.acc[tdm.index("tdm_xflag")]) self.sql.updRec("telmst", data=data, where=[("tdm_name", "=", self.name)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doTopExit(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doUp(self): acc = self.sql.getRec("telmst", where=[("tdm_name", "<", self.name)], order="tdm_name desc", limit=1) if acc: self.doLoadDetail(acc) self.df.focusField("T", 0, 2) else: showWarning(self.opts["mf"].body, "Beginning of File", "This is the beginning of the file.") self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doDn(self): acc = self.sql.getRec("telmst", where=[("tdm_name", ">", self.name)], order="tdm_name asc", limit=1) if acc: self.doLoadDetail(acc) self.df.focusField("T", 0, 2, "N") else: showWarning(self.opts["mf"].body, "End of File", "You have reached the end of the file.") self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doContacts(self): # Display contacts and allow adding, editing etc. recs = self.sql.getRec("telcon", cols=[ "tdc_contact", "tdc_desig", "tdc_telno", "tdc_celno", "tdc_email" ], where=[("tdc_name", "=", self.name)], order="tdc_contact") if not recs: recs = [["", "", "", "", ""]] titl = "Contacts" cols = (("a", "Name", 30, "NA"), ("b", "Designation", 20, "NA"), ("c", "Telephone", 20, "NA"), ("d", "Mobile", 20, "NA"), ("e", "Email-Address", 50, "TX")) butt = (("Add", self.doConAdd), ("Exit", self.doConExit)) state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Contact to Edit or an Action") self.contyp = None self.chg = SelectChoice(self.df.mstFrame, titl=titl, cols=cols, data=recs, butt=butt, sort=False) self.df.enableButtonsTags(state=state) if not self.contyp and self.chg.selection: self.contyp = "chg" con = self.chg.selection[1].strip() self.conchg = self.sql.getRec("telcon", where=[("tdc_name", "=", self.name), ("tdc_contact", "=", con)], limit=1) if self.contyp in ("add", "chg"): self.doConChanges() self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doConAdd(self): self.contyp = "add" def doConExit(self): self.contyp = "quit" def doConChanges(self): fld = [] if self.contyp == "chg": tit = ("Change Contact", ) but = (("Delete", None, self.doChgDelete, 1, None, None), ("Apply", None, self.doChgEnd, 1, None, None), ("Quit", None, self.doChgExit, 1, None, None)) self.contact = self.conchg[1] else: tit = ("Add Contact", ) but = None fld = ((("T", 0, 0, 0), "I@tdc_contact", 0, "", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 1, 0), "I@tdc_desig", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 2, 0), "I@tdc_telno", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 3, 0), "I@tdc_celno", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 4, 0), "I@tdc_email", 0, "", "", "", "N", None, None, None, ("efld", ))) state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") self.rp = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doChgEnd, "n"), ), txit=(self.doChgExit, )) if self.contyp == "chg": for x in range(5): self.rp.loadEntry("T", 0, x, data=self.conchg[x + 1]) self.rp.focusField("T", 0, 1, clr=False) else: self.rp.focusField("T", 0, 1) self.rp.mstFrame.wait_window() self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state=state) def doChgDelete(self): self.sql.delRec("telcon", where=[("tdc_name", "=", self.name), ("tdc_contact", "=", self.conchg[1])]) self.opts["mf"].dbm.commitDbase() self.doChgExit() def doChgEnd(self): data = [self.name] data.extend(self.rp.t_work[0][0]) if self.contyp == "add": self.sql.insRec("telcon", data=data) self.opts["mf"].dbm.commitDbase() elif self.contyp == "chg" and data != self.conchg[:len(data)]: tdc = self.sql.telcon_col data.append(self.conchg[tdc.index("tdc_xflag")]) self.sql.updRec("telcon", data=data, where=[("tdc_name", "=", self.name), ("tdc_contact", "=", self.contact)]) self.opts["mf"].dbm.commitDbase() self.doChgExit() def doChgExit(self): self.rp.closeProcess() def doImport(self): grps = [] commit = False self.opts["mf"].updateStatus("") self.df.mstFrame.focus_force() self.df.mstFrame.winfo_toplevel().update() self.df.setWidget(self.df.mstFrame, state="hide") spl = SplashScreen(self.opts["mf"].body, "Importing Contact Details\n\nPlease Wait") sql = Sql(self.opts["mf"].dbm, tables="ftable", prog=self.__class__.__name__) bkm = sql.getRec("ftable", where=[("ft_tabl", "=", "bkmcon")], cols=["count(*)"], limit=1) if bkm and bkm[0]: commit = True sql = Sql(self.opts["mf"].dbm, tables="bkmcon", prog=self.__class__.__name__) bkc = sql.bkmcon_col recs = sql.getRec("bkmcon") for rec in recs: if not rec[bkc.index("bkc_telno")] and not \ rec[bkc.index("bkc_faxno")] and not \ rec[bkc.index("bkc_celno")] and not \ rec[bkc.index("bkc_email")]: continue nam = rec[bkc.index("bkc_sname")] fnm = rec[bkc.index("bkc_names")] if fnm: nam = "%s, %s" % (nam, fnm.split()[0]) data = [ nam, rec[bkc.index("bkc_addr1")], rec[bkc.index("bkc_addr2")], rec[bkc.index("bkc_addr3")], rec[bkc.index("bkc_pcode")], rec[bkc.index("bkc_telno")], rec[bkc.index("bkc_faxno")], rec[bkc.index("bkc_celno")], rec[bkc.index("bkc_email")], "BKM" ] chk = self.sql.getRec("telmst", where=[("tdm_name", "=", nam)], limit=1) if not chk: self.sql.insRec("telmst", data=data) elif data != chk[:len(data)]: tdm = self.sql.telmst_col data.append(chk[tdm.index("tdm_xflag")]) self.sql.updRec("telmst", data=data, where=[("tdm_name", "=", nam)]) grps.append(["BKM", "Bookings"]) bwl = sql.getRec("ftable", where=[("ft_tabl", "=", "bwltab")], cols=["count(*)"], limit=1) if bwl and bwl[0]: commit = True sql = Sql(self.opts["mf"].dbm, tables="bwltab", prog=self.__class__.__name__) btb = sql.bwltab_col recs = sql.getRec("bwltab") for rec in recs: if not rec[btb.index("btb_home")] and not \ rec[btb.index("btb_work")] and not \ rec[btb.index("btb_cell")] and not \ rec[btb.index("btb_mail")]: continue nam = rec[btb.index("btb_surname")] fnm = rec[btb.index("btb_names")] if fnm: nam = "%s, %s" % (nam, fnm.split()[0]) data = [ nam, rec[btb.index("btb_add1")], rec[btb.index("btb_add2")], rec[btb.index("btb_add3")], rec[btb.index("btb_pcod")], rec[btb.index("btb_home")], rec[btb.index("btb_work")], rec[btb.index("btb_cell")], rec[btb.index("btb_mail")], "BWL" ] chk = self.sql.getRec("telmst", where=[("tdm_name", "=", nam)], limit=1) if not chk: self.sql.insRec("telmst", data=data) elif data != chk[:len(data)]: tdm = self.sql.telmst_col data.append(chk[tdm.index("tdm_xflag")]) self.sql.updRec("telmst", data=data, where=[("tdm_name", "=", nam)]) grps.append(["BWL", "Bowls"]) crs = sql.getRec("ftable", where=[("ft_tabl", "=", "crsmst")], cols=["count(*)"], limit=1) if crs and crs[0]: commit = True sql = Sql(self.opts["mf"].dbm, tables="crsmst", prog=self.__class__.__name__) crm = sql.crsmst_col recs = sql.getRec("crsmst", where=[("crm_stat", "<>", "X")]) for rec in recs: nam = "%s" % rec[crm.index("crm_name")] data = [ nam, rec[crm.index("crm_add1")], rec[crm.index("crm_add2")], rec[crm.index("crm_add3")], rec[crm.index("crm_pcod")], rec[crm.index("crm_tel")], rec[crm.index("crm_fax")], "", "", "CRS" ] chk = self.sql.getRec("telmst", where=[("tdm_name", "=", nam)], limit=1) if not chk: self.sql.insRec("telmst", data=data) elif data != chk[:len(data)]: tdm = self.sql.telmst_col data.append(chk[tdm.index("tdm_xflag")]) self.sql.updRec("telmst", data=data, where=[("tdm_name", "=", nam)]) con = rec[crm.index("crm_mgr")] eml = rec[crm.index("crm_mgr_email")] if eml: data = [nam, con, "Manager", "", "", eml] chk = self.sql.getRec("telcon", where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)], limit=1) if not chk: self.sql.insRec("telcon", data=data) elif data != chk[:len(data)]: tdc = self.sql.telcon_col data.append(chk[tdc.index("tdc_xflag")]) self.sql.updRec("telcon", data=data, where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)]) con = rec[crm.index("crm_acc")] eml = rec[crm.index("crm_acc_email")] if eml: data = [nam, con, "Accounts", "", "", eml] chk = self.sql.getRec("telcon", where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)], limit=1) if not chk: self.sql.insRec("telcon", data=data) elif data != chk[:len(data)]: tdc = self.sql.telcon_col data.append(chk[tdc.index("tdc_xflag")]) self.sql.updRec("telcon", data=data, where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)]) con = rec[crm.index("crm_ord")] eml = rec[crm.index("crm_ord_email")] if eml: data = [nam, con, "Orders", "", "", eml] chk = self.sql.getRec("telcon", where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)], limit=1) if not chk: self.sql.insRec("telcon", data=data) elif data != chk[:len(data)]: tdc = self.sql.telcon_col data.append(chk[tdc.index("tdc_xflag")]) self.sql.updRec("telcon", data=data, where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)]) grps.append(["CRS", "Creditors"]) drs = sql.getRec("ftable", where=[("ft_tabl", "=", "drsmst")], cols=["count(*)"], limit=1) if drs and drs[0]: commit = True sql = Sql(self.opts["mf"].dbm, tables="drsmst", prog=self.__class__.__name__) drm = sql.drsmst_col recs = sql.getRec("drsmst", where=[("drm_stat", "<>", "X")]) for rec in recs: nam = "%s" % rec[drm.index("drm_name")] data = [ nam, rec[drm.index("drm_add1")], rec[drm.index("drm_add2")], rec[drm.index("drm_add3")], rec[drm.index("drm_pcod")], rec[drm.index("drm_tel")], rec[drm.index("drm_fax")], "", "", "DRS" ] chk = self.sql.getRec("telmst", where=[("tdm_name", "=", nam)], limit=1) if not chk: self.sql.insRec("telmst", data=data) elif data != chk[:len(data)]: tdm = self.sql.telmst_col data.append(chk[tdm.index("tdm_xflag")]) self.sql.updRec("telmst", data=data, where=[("tdm_name", "=", nam)]) con = rec[drm.index("drm_mgr")] eml = rec[drm.index("drm_mgr_email")] if eml: data = [nam, con, "Manager", "", "", eml] chk = self.sql.getRec("telcon", where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)], limit=1) if not chk: self.sql.insRec("telcon", data=data) elif data != chk[:len(data)]: tdc = self.sql.telcon_col data.append(chk[tdc.index("tdc_xflag")]) self.sql.updRec("telcon", data=data, where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)]) con = rec[drm.index("drm_acc")] eml = rec[drm.index("drm_acc_email")] if eml: data = [nam, con, "Accounts", "", "", eml] chk = self.sql.getRec("telcon", where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)], limit=1) if not chk: self.sql.insRec("telcon", data=data) elif data != chk[:len(data)]: tdc = self.sql.telcon_col data.append(chk[tdc.index("tdc_xflag")]) self.sql.updRec("telcon", data=data, where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)]) con = rec[drm.index("drm_sls")] eml = rec[drm.index("drm_sls_email")] if eml: data = [nam, con, "Orders", "", "", eml] chk = self.sql.getRec("telcon", where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)], limit=1) if not chk: self.sql.insRec("telcon", data=data) elif data != chk[:len(data)]: tdc = self.sql.telcon_col data.append(chk[tdc.index("tdc_xflag")]) self.sql.updRec("telcon", data=data, where=[("tdc_name", "=", nam), ("tdc_contact", "=", con)]) grps.append(["DRS", "Debtors"]) mem = sql.getRec("ftable", where=[("ft_tabl", "=", "memmst")], cols=["count(*)"], limit=1) if mem and mem[0]: commit = True sql = Sql(self.opts["mf"].dbm, tables=["memmst", "memadd", "memkon"], prog=self.__class__.__name__) mlm = sql.memmst_col mla = sql.memadd_col recs = sql.getRec("memmst", where=[("mlm_state", "=", "A")]) for rec in recs: coy = rec[mlm.index("mlm_cono")] num = rec[mlm.index("mlm_memno")] nam = "%s, %s" % (rec[mlm.index("mlm_surname")], rec[mlm.index("mlm_names")]) add = sql.getRec("memadd", where=[("mla_cono", "=", coy), ("mla_memno", "=", num), ("mla_type", "=", "P")], limit=1) if not add: add = [coy, num, "P", "", "", "", "", "", "", ""] add3 = add[mla.index("mla_add3")] city = add[mla.index("mla_city")] coun = add[mla.index("mla_country")] if not add3: if city: add3 = city if coun: add3 = "%s, %s" % (add3, coun) elif coun: add3 = coun kon = sql.getRec(tables=["memctk", "memkon"], cols=["mck_type", "mlk_detail"], where=[("mlk_cono", "=", coy), ("mlk_memno", "=", num), ("mck_code=mlk_code", )]) tel = "" fax = "" cel = "" eml = "" for k in kon: if k[0] == "E" and not eml: eml = k[1] elif k[0] == "H": tel = k[1] elif k[0] == "W" and not tel: tel = k[1] elif k[0] == "M": cel = k[1] data = [ nam, add[mla.index("mla_add1")], add[mla.index("mla_add2")], add3, add[mla.index("mla_code")], tel, fax, cel, eml, "MEM" ] chk = self.sql.getRec("telmst", where=[("tdm_name", "=", nam)], limit=1) if not chk: self.sql.insRec("telmst", data=data) elif data != chk[:len(data)]: tdm = self.sql.telmst_col data.append(chk[tdm.index("tdm_xflag")]) self.sql.updRec("telmst", data=data, where=[("tdm_name", "=", nam)]) grps.append(["MEM", "Members"]) # Others tabs = { "BKS": [ "Book Club", "bksown", None, [ "bof_snam", "bof_fnam", "bof_add1", "bof_add2", "bof_add3", "bof_pcod", "bof_home", "bof_work", "bof_cell", "bof_mail" ] ], "LON": [ "Loan Ledger", "lonmf1", "lm1_cono", [ "lm1_name", "lm1_addr1", "lm1_addr2", "lm1_addr3", "lm1_pcode", "lm1_telno", "lm1_faxno", "lm1_celno", "lm1_email" ] ], "OWN": [ "Property Owners", "rcaowm", "rom_cono", [ "rom_name", "rom_add1", "rom_add2", "rom_add3", "rom_pcod", "rom_home", "rom_office", "rom_mobile", "rom_fax", "rom_email" ] ], "TNT": [ "Property Tenants", "rcatnm", "rtn_cono", [ "rtn_name", "rtn_addr1", "rtn_addr2", "rtn_addr3", "rtn_pcode", "rtn_telno", "rtn_email" ] ], "RTL": [ "Rental Tenants", "rtlmst", "rtm_cono", [ "rtm_name", "rtm_addr1", "rtm_addr2", "rtm_addr3", "rtm_pcode", "rtm_telno", "rtm_email" ] ], "SCP": [ "Sectional Competitions", "scpmem", "scm_cono", ["scm_surname", "scm_names", "scm_email", "scm_phone"] ], "EMP": [ "Employees", "wagmst", "wgm_cono", [ "wgm_sname", "wgm_fname", "wgm_addr1", "wgm_addr2", "wgm_addr3", "wgm_pcode", "wgm_telno", "wgm_emadd" ] ] } for grp in tabs: des = tabs[grp][0] tab = tabs[grp][1] coy = tabs[grp][2] col = tabs[grp][3] sql = Sql(self.opts["mf"].dbm, ["telmst", tab]) if sql.error: continue rec = sql.getRec(tab, cols=col) for r in rec: snam = None data = ["", "", "", "", "", "", "", "", "", grp] for n, c in enumerate(col): x = c.split("_")[1] if r[n]: if x == "name": data[0] = r[n] elif x in ("snam", "surname", "sname"): snam = r[n] elif snam and x in ("fnam", "names", "fname"): data[0] = "%s, %s" % (snam, r[n].split()[0]) snam = None elif x in ("add1", "addr1"): data[1] = r[n] elif x in ("add2", "addr2"): data[2] = r[n] elif x in ("add3", "addr3"): data[3] = r[n] elif x in ("pcod", "pcode"): data[4] = r[n] elif x in ("home", "work", "office", "phone"): data[5] = r[n] elif x in ("faxno", "fax"): data[6] = r[n] elif x in ("cell", "celno", "mobile"): data[7] = r[n] elif x in ("mail", "email", "emadd"): data[8] = r[n] if not data[5] and not data[6] and not data[7] and not data[8]: continue chk = sql.getRec("telmst", where=[("tdm_name", "=", data[0])], limit=1) if not chk: sql.insRec("telmst", data=data) elif data != chk[:len(data)]: tdm = self.sql.telmst_col data.append(chk[tdm.index("tdm_xflag")]) sql.updRec("telmst", data=data, where=[("tdm_name", "=", data[0])]) grps.append([grp, des]) # Groups for g in grps: chk = self.sql.getRec("telgrp", where=[("tdg_group", "=", g[0])], limit=1) if not chk: self.sql.insRec("telgrp", data=g) spl.closeSplash() if commit: self.opts["mf"].dbm.commitDbase(ask=True) self.df.setWidget(self.df.mstFrame, state="show") self.df.window.update_idletasks() self.df.focusField("T", 0, 1) def doLoadDetail(self, data): self.name = data[0] for num, fld in enumerate(data[:-1]): self.df.loadEntry(self.df.frt, self.df.pag, num, data=fld) def doNotes(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") NotesCreate(self.opts["mf"], 0, "", self.opts["capnm"], "TEL", self.name) 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 doPrint(self): titl = "Select the Required Print Options" cols = (("a", "C", 1, "UA", "N"), ("b", "Description", 30, "NA", "N")) if self.df.last[0][0] != 1: data = [("A", "Print Card")] else: data = [] data.extend([("B", "Print Directory"), ("C", "Print Contacts"), ("D", "Print Notes")]) ss = SelectChoice(self.df.mstFrame, titl, cols, data, sort=False) self.opts["mf"].updateStatus("") if not ss.selection: self.df.focusField(self.df.frt, self.df.pag, self.df.col) return state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") if ss.selection[1] == "A": head = ["Card for %s" % self.name] whr = [("tdm_name", "=", self.name)] TabPrt(self.opts["mf"], name=self.__class__.__name__, tabs="telmst", head=head, where=whr) elif ss.selection[1] == "D": self.notes = NotesPrint(self.opts["mf"], 0, "", "TEL", loop=False) if not self.notes.data: pass else: data = [] p = ProgressBar(self.opts["mf"].body, typ="Generating the Report", mxs=len(self.notes.data), esc=True) for num, dat in enumerate(self.notes.data): p.displayProgress(num) if p.quit: break desc = textFormat(dat[5], width=50) for n, d in enumerate(desc): if not n: data.append([ dat[2], dat[4], CCD(dat[3], "d1", 10).disp, dat[6], CCD(dat[7], "d1", 10).disp, d ]) else: data.append(["", "", "", "", "", d]) p.closeProgress() if not p.quit: name = self.__class__.__name__ head = ["Telephone Directory Notes Listing"] cols = [["a", "NA", 30, "Name", "y"], ["b", "NA", 20, "User-Name", "y"], ["c", "NA", 10, "Cap-Date", "y"], ["d", "UA", 1, "F", "y"], ["e", "NA", 10, "Act-Date", "y"], ["f", "NA", 50, "Details", "y"]] RepPrt(self.opts["mf"], name=name, tables=data, heads=head, cols=cols, ttype="D", repprt=self.notes.df.repprt, repeml=self.notes.df.repeml) else: tit = ["Telephone Directory"] grp = { "stype": "R", "tables": ("telgrp", ), "cols": (("tdg_group", "UA", 3, "Grp"), ("tdg_desc", "NA", 30, "Description")), "order": "tdg_desc" } fld = ((("T", 0, 0, 0), "IUA", 3, "Group", "", "", "N", self.prGrp, grp, None, ("efld", )), ) self.pr = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=((self.prEnd, "y"), ), txit=(self.prExit, )) self.pr.mstFrame.wait_window() if not self.prxit: if self.prgrp: if ss.selection[1] == "B": head = ["Details for Group %s" % self.prgrp] whr = [("tdm_group", "=", self.prgrp)] else: head = ["Contacts for Group %s" % self.prgrp] whr = [("tdm_group", "=", self.prgrp), ("tdc_name=tdm_name", )] else: if ss.selection[1] == "B": head = ["Cards for All Groups"] whr = [] else: head = ["Contacts for All Groups"] whr = [] if ss.selection[1] == "B": tab = ["telmst"] col = [ "tdm_name", "tdm_telno", "tdm_faxno", "tdm_mobile", "tdm_email" ] else: tab = ["telmst", "telcon"] col = [ "tdm_name", "tdc_contact", "tdc_desig", "tdc_telno", "tdc_celno", "tdc_email" ] prtdia = (("Y", "V"), ("Y", "N")) RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=tab, heads=head, cols=col, where=whr, order="tdm_name", prtdia=prtdia) 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 prGrp(self, frt, pag, r, c, p, i, w): self.prgrp = w def prEnd(self): self.prxit = False self.pr.closeProcess() def prExit(self): self.prxit = True self.pr.closeProcess() def doApply(self): data = self.df.t_work[0][0][:] if self.df.frt == "T": if self.newmst: self.sql.insRec("telmst", data=data) else: data.append(self.acc[self.sql.telmst_col.index("tdm_xflag")]) self.sql.updRec("telmst", data=data, where=[("tdm_name", "=", self.name)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1)
class st2040(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, ["strgrp", "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"] if self.locs == "N": showError(self.opts["mf"].body, "Error", "Multiple Locations Are Not Enabled") return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def dataHeader(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_desc", "", 0, "Description", "Y")), "where": [ ("st1_cono", "=", self.opts["conum"]), ("st1_type", "not", "in", ("R", "X"))], "whera": [["C", "st1_group", 0, 0]], "order": "st1_group, st1_code", "index": 1} stl = { "stype": "R", "tables": ("strloc", "strmf2"), "cols": ( ("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Location", "Y")), "where": [ ("srl_cono", "=", self.opts["conum"]), ("srl_loc=st2_loc",), ("st2_cono=srl_cono",)], "whera": [["C", "st2_group", 0], ["C", "st2_code", 1]], "order": "srl_loc", "index": 0} fld = [ (("T",0,0,0),"INa",7,"Transfer Number","", "","N",self.doTrf,None,None,("notblank",)), (("T",0,0,0),"ID1",10,"Date","Transfer Date", self.sysdtw,"N",self.doDte,None,None,("efld",)), (("C",0,0,0),"IUA",3,"Grp","Product Group", "r","N",self.doGroup,gpm,None,("notblank",)), (("C",0,0,1),"INA",20,"Product Code","", "","N",self.doCode,stm,None,("notblank",)), (("C",0,0,2),"ONA",25,"Description"), (("C",0,0,3),"ONA",10,"U.O.I"), (("C",0,0,4),"ISD",9.2,"Quantity","", "","N",self.doQty,None,None,("notzero",)), (("C",0,0,5),"IUA",1,"F","From Location", "","N",self.doLoc1,stl,None,("notblank",)), (("C",0,0,6),"IUA",1,"T","To Location", "","N",self.doLoc2,stl,None,("notblank",)), (("C",0,0,7),"ISD",9.2,"Unit-Cost","Unit Cost Price", "","N",None,None,None,("notzero",)), (("C",0,0,8),"INA",(15,30),"Details","Transaction Details", "","N",self.doTrnDet,None,None,None)] row = (15,) tnd = ((self.endPage0,"n"),) txt = (self.exitPage0,) cnd = ((self.endPage1,"y"),) cxt = (self.exitPage1,) self.df = TartanDialog(self.opts["mf"], eflds=fld, rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doTrf(self, frt, pag, r, c, p, i, w): self.trf = w def doDte(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.dte = w self.curdt = int(self.dte / 100) self.batno = "S%s" % self.curdt def doGroup(self, frt, pag, r, c, p, i, w): self.group = 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" def doCode(self, frt, pag, r, c, p, i, w): self.code = w acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc", "st1_uoi"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] == "R": return "Invalid Code (Recipe Item)" if acc[0] == "X": return "Invalid Code (Redundant)" self.df.loadEntry("C", pag, p+1, data=acc[1]) self.df.loadEntry("C", pag, p+2, data=acc[2]) def doQty(self, frt, pag, r, c, p, i, w): self.qty = w def doLoc1(self, frt, pag, r, c, p, i, w): self.acc = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", w)], limit=1) if not self.acc: return "Invalid Location For This Product" self.loc1 = w self.extractCost() self.amt = round((self.qty * self.ucost), 2) self.df.loadEntry("C", pag, p+2, data=self.ucost) def doLoc2(self, frt, pag, r, c, p, i, w): if w == self.loc1: return "Invalid Location, Same as From" self.newloc = "N" acc = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", w)], limit=1) if not acc: 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 "Invalid Location For This Product" self.loc2 = w return "sk1" def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w def endPage0(self): self.df.focusField("C", 0, 1) def endPage1(self): self.updateTables() self.opts["mf"].dbm.commitDbase() self.df.advanceLine(0) def exitPage0(self): self.df.closeProcess() self.opts["mf"].closeLoop() def exitPage1(self): self.df.focusField("T", 0, 1) def extractCost(self): qbal = 0 vbal = 0 self.ucost = 0 stt_rslt = self.sql.getRec("strtrn", cols=["round(sum(stt_qty),2)", "round(sum(stt_cost),2)"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_group", "=", self.group), ("stt_code", "=", self.code), ("stt_loc", "=", self.loc1)]) if stt_rslt: qbal = CCD(stt_rslt[0][0], "SD", 13.2).work vbal = CCD(stt_rslt[0][1], "SD", 13.2).work if qbal: self.ucost = round((vbal / qbal), 2) def updateTables(self): # Stores Ledger Transaction qty = float(ASD(0) - ASD(self.qty)) val = float(ASD(0) - ASD(self.amt)) if qty >= 0: rtn = 3 else: rtn = 4 self.sql.insRec("strtrn", data=[self.opts["conum"], self.group, self.code, self.loc1, self.dte, rtn, self.trf, self.batno, "", qty, val, 0, self.curdt, self.trndet, 0, "", "", "STR", 0, "N", self.opts["capnm"], self.sysdtw, 0]) # Stores Ledger Transaction if self.qty >= 0: rtn = 3 else: rtn = 4 if self.newloc == "Y": self.acc[self.sql.strmf2_col.index("st2_loc")] = self.loc2 self.sql.insRec("strmf2", data=self.acc) self.sql.insRec("strtrn", data=[self.opts["conum"], self.group, self.code, self.loc2, self.dte, rtn, self.trf, self.batno, "", self.qty, self.amt, 0, self.curdt, self.trndet, 0, "", "", "STR", 0, "", self.opts["capnm"], self.sysdtw, 0])