class wgc310(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genmst", "wagrcv", "wagedc", "wagtf2"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) wagctl = self.gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.glint = wagctl["ctw_glint"] return True def mainProcess(self): ced = { "stype": "R", "tables": ("wagedc", ), "cols": (("ced_code", "", 0, "Cde"), ("ced_desc", "", 0, "Description", "Y")), "where": [("ced_cono", "=", self.opts["conum"])], "whera": [["T", "ced_type", 0]], "order": "ced_code" } bas = { "stype": "C", "titl": "Available Base Rates", "head": ("C", "Description"), "data": ((1, "X * Normal Rate of Pay * Factor"), (2, "Normal Pay * Factor"), (3, "Normal Pay * Factor / 100"), (4, "X * Daily Rate of Pay * Factor"), (5, "X * Hourly Rate of Pay * Factor"), (6, "U.I.F. Pay * Factor"), (7, "S.D.L. Pay * Factor")) } 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")), "where": [("glm_cono", "=", self.opts["conum"])] } rcv = { "stype": "R", "tables": ("wagrcv", ), "cols": (("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details", "Y")) } r1s = (("Variable", "V"), ("Fixed", "F")) r2s = (("Amount", "A"), ("Rate", "R")) r3s = (("Salary", "S"), ("Commission", "C")) r4s = (("Amount", "A"), ("Rate", "R"), ("None", "N")) r5s = (("Yes", "Y"), ("No", "N"), ("Notional", "T"), ("One Time", "O"), ("Retrench", "R")) r6s = (("Yes", "Y"), ("No", "N")) tag = (("Detail-_A", None, ("T", 0, 0), ("T", 0, 1)), ("Detail-_B", None, ("T", 0, 0), ("T", 0, 1))) self.fld = ((("T", 0, 0, 0), "IUA", 1, "Type", "Earning/Deduction Type", "E", "N", self.doType, None, None, ("in", ("E", "D"))), (("T", 0, 0, 0), "IUI", 3, "Code", "", "", "N", self.doCode, ced, None, ("notzero", )), (("T", 0, 0, 0), "ONA", 30, "Description"), (("T", 1, 0, 0), "INA", 30, "Description", "", "", "N", self.doDesc, None, self.doDelete, ("notblank", )), (("T", 1, 1, 0), ("IRB", r1s), 0, "Type", "", "V", "N", None, None, None, None), (("T", 1, 2, 0), ("IRB", r2s), 0, "Employee Portion", "", "A", "N", self.doEmployeePortion, None, None, None), (("T", 1, 3, 0), "IUI", 3, " Base", "", "", "N", self.doEmployeeBase, bas, None, ("between", 0, 7)), (("T", 1, 4, 0), "IUD", 8.2, " Value", "", "", "N", self.doValue, None, None, ("efld", )), (("T", 1, 5, 0), "IUD", 8.2, " Limit", "", "", "N", self.doElim, None, None, ("efld", )), (("T", 1, 6, 0), "IUI", 3, " GL/Cono", "", "", "N", self.doEglco, coy, None, ("efld", )), (("T", 1, 6, 0), "IUI", 7, " GL/Acno", "", "", "N", self.doEglno, glm, None, ("efld", )), (("T", 1, 7, 0), ("IRB", r3s), 0, "Earnings Type", "", "S", "N", self.doEarnType, None, None, None), (("T", 1, 8, 0), ("IRB", r4s), 0, "Employer Portion", "", "N", "N", self.doEmployerPortion, None, None, None), (("T", 1, 9, 0), "IUI", 3, " Base", "Base", "", "N", self.doEmployerBase, bas, None, ("between", 0, 7)), (("T", 1, 10, 0), "IUD", 8.2, " Value", "", "", "N", None, None, None, ("efld", )), (("T", 1, 11, 0), "IUD", 8.2, " Limit", "", "", "N", self.doRlim, None, None, ("efld", )), (("T", 1, 12, 0), "IUI", 3, " GL/Cono", "", "", "N", self.doRglco, coy, None, ("efld", )), (("T", 1, 12, 0), "IUI", 7, " GL/Acno", "", "", "N", self.doRglno, glm, None, ("efld", )), (("T", 1, 13, 0), ("IRB", r5s), 0, "Tax Code", "", "N", "N", self.doTaxcode, None, None, None), (("T", 1, 14, 0), "IUD", 6.2, "Tax Portion", "", "", "N", self.doTaxportion, None, None, ("efld", )), (("T", 2, 0, 0), "IUI", 4, "Rec Of Rev Code", "", "", "N", self.doRcv, rcv, None, ("notzero", )), (("T", 2, 0, 0), "ONA", 30, ""), (("T", 2, 1, 0), ("IRB", r6s), 0, "Union Report", "", "N", "N", self.doUniRep, None, None, None), (("T", 2, 2, 0), ("IRB", r6s), 0, "Must Pay", "", "N", "N", None, None, None, None), (("T", 2, 3, 0), "IUI", 2, "Balance Number", "", "", "N", self.doBalNo, None, None, ("between", 0, 3)), (("T", 2, 4, 0), "IUD", 5.2, "Hourly Limit", "", "", "N", self.doLimit, None, None, ("efld", )), (("T", 2, 5, 0), ("IRB", r6s), 0, "Monthly Deduction", "", "N", "N", self.doMthly, None, None, None), (("T", 2, 6, 0), "IUD", 6.2, "UIF Percentage", "", "", "N", None, None, None, ("efld", )), (("T", 2, 7, 0), "IUD", 6.2, "SDL Percentage", "", "", "N", None, None, None, ("efld", ))) but = (("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 1, 1), ("T", 0, 0)), ("Quit", None, self.doExit0, 1, None, None)) tnd = ((self.doEnd0, "N"), (self.doEnd1, "N"), (self.doEnd2, "Y")) txt = (self.doExit0, self.doExit1, self.doExit2) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, tags=tag, butt=but, tend=tnd, txit=txt) def doType(self, frt, pag, r, c, p, i, w): self.rtype = w if self.rtype == "E": self.df.topf[1][15][5] = "Y" else: self.df.topf[1][15][5] = "Y" def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.acc = self.sql.getRec("wagedc", where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", self.rtype), ("ced_code", "=", self.code)], limit=1) if not self.acc: self.new = True if self.rtype == "D" and self.code == 1: showInfo(self.opts["mf"].body, "PAYE", "This code is Reserved for PAYE Deductions") elif self.rtype == "D" and self.code == 2: showInfo(self.opts["mf"].body, "UIF", "This code is Reserved for UIF Deductions") else: self.new = False d = 3 self.df.loadEntry(frt, pag, p + 1, data=self.acc[d]) for pg in range(1, self.df.pgs + 1): for x in range(0, self.df.topq[pg]): if pg == 2 and x == 1: continue self.df.loadEntry("T", pg, x, data=self.acc[d]) if pg == 2 and not x: ror = self.sql.getRec("wagrcv", limit=1, cols=["rcv_desc"], where=[("rcv_code", "=", self.acc[d])]) if not ror: desc = "" else: desc = ror[0] self.df.loadEntry("T", 2, 1, data=desc) d = d + 1 def doDesc(self, frt, pag, r, c, p, i, w): self.df.loadEntry("T", 0, 2, data=self.df.t_disp[1][0][0]) if self.rtype == "E" and self.code < 6: self.df.loadEntry("T", 1, p + 1, data="V") self.df.loadEntry("T", 1, p + 2, data="R") if self.code == 5: self.df.loadEntry("T", 1, p + 3, data=4) else: self.df.loadEntry("T", 1, p + 3, data=1) if self.code in (1, 5): self.df.loadEntry("T", 1, p + 4, data=1) self.df.loadEntry("T", 1, p + 5, data=0) if self.glint != "Y": self.df.loadEntry("T", 1, p + 6, data=0) self.df.loadEntry("T", 1, p + 7, data=0) self.df.loadEntry("T", 1, p + 8, data="S") return "sk8" else: return "sk5" else: return "sk3" elif self.rtype == "D" and self.code in (1, 2): if self.code == 1: self.df.loadEntry("T", 1, 1, data="V") self.df.loadEntry("T", 1, 2, data="R") if self.glint != "Y": self.df.loadEntry("T", 1, p + 6, data=0) self.df.loadEntry("T", 1, p + 7, data=0) self.df.loadEntry("T", 1, p + 9, data="N") self.df.loadEntry("T", 1, p + 15, data="N") return "nd" return "sk5" elif self.code == 2: self.df.loadEntry("T", 1, 1, data="V") self.df.loadEntry("T", 1, 2, data="R") self.df.loadEntry("T", 1, 3, data=6) return "sk3" def doDelete(self): t = self.sql.getRec("wagtf2", cols=["count(*)"], where=[("wt2_cono", "=", self.opts["conum"]), ("wt2_type", "=", self.rtype), ("wt2_code", "=", self.code)], limit=1) if t[0]: return "Transactions Exist, Not Deleted" self.sql.delRec("wagedc", where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", self.rtype), ("ced_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEmployeePortion(self, frt, pag, r, c, p, i, w): if w == "A": self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doEmployeeBase(self, frt, pag, r, c, p, i, w): if w > 7: return "Invalid Employee Base" def doValue(self, frt, pag, r, c, p, i, w): self.value = w if self.rtype == "E" and self.code < 6: self.df.loadEntry("T", 1, p + 1, data=0) if self.glint != "Y": self.df.loadEntry("T", 1, p + 2, data=0) self.df.loadEntry("T", 1, p + 3, data=0) self.df.loadEntry("T", 1, p + 4, data="S") return "sk3" else: return "sk1" def doElim(self, frt, pag, r, c, p, i, w): self.elim = w if self.glint != "Y": self.df.loadEntry("T", 1, p + 1, data=0) self.df.loadEntry("T", 1, p + 2, data=0) if self.rtype == "E": return "sk2" else: self.df.loadEntry("T", 1, p + 3, data="") return "sk3" def doEglco(self, frt, pag, r, c, p, i, w): if self.rtype == "E" and self.code < 6 and not w: # Use department code for integration self.eglco = w self.df.loadEntry("T", 1, p + 1, data=0) self.df.loadEntry("T", 1, p + 2, data="S") self.df.loadEntry("T", 1, p + 9, data="Y") self.df.loadEntry("T", 1, p + 10, data=100.00) return "sk10" if w: self.eglco = w else: self.eglco = self.opts["conum"] name = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", self.eglco)], limit=1) if not name: return "Invalid Company" def doEglno(self, frt, pag, r, c, p, i, w): if self.rtype == "D": ctl = self.gc.getCtl("ctlctl", self.eglco) if ctl and not self.gc.chkRec(self.eglco, ctl, ["wag_slc"]): sln = ctl["wag_slc"] else: sln = None else: sln = None if w and w != sln: chk = chkGenAcc(self.opts["mf"], self.eglco, w) if type(chk) is str: return chk self.eglno = w if self.rtype == "D": if self.code == 2: self.df.loadEntry(frt, pag, 9, data="R") self.df.loadEntry(frt, pag, 10, data=6) self.df.loadEntry(frt, pag, 11, data=self.value) self.df.loadEntry(frt, pag, 12, data=self.elim) self.df.loadEntry(frt, pag, 13, data=self.eglco) self.df.loadEntry(frt, pag, 14, data=self.eglno) return "sk7" else: return "sk1" if self.code < 6: self.df.loadEntry("T", 1, p + 1, data="S") self.df.loadEntry("T", 1, p + 8, data="Y") self.df.loadEntry("T", 1, p + 9, data=100.00) return "sk9" def doEarnType(self, frt, pag, r, c, p, i, w): if self.rtype == "E": return "sk6" def doEmployerPortion(self, frt, pag, r, c, p, i, w): if w == "N": for x in range(1, 6): self.df.loadEntry(frt, pag, p + x, data=0) return "sk5" if w == "A": self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doEmployerBase(self, frt, pag, r, c, p, i, w): if w > 7: return "Invalid Employer Base" def doRlim(self, frt, pag, r, c, p, i, w): if self.glint != "Y": return "sk2" def doRglco(self, frt, pag, r, c, p, i, w): if not w: w = self.opts["conum"] name = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", w)], limit=1) if not name: return "Invalid Company" self.rglco = w def doRglno(self, frt, pag, r, c, p, i, w): if w: chk = chkGenAcc(self.opts["mf"], self.rglco, w) if type(chk) is str: return chk def doTaxcode(self, frt, pag, r, c, p, i, w): if self.rtype == "D" and w not in ("Y", "T", "N"): return "Invalid Selection" if w == "N": self.df.loadEntry("T", pag, p + 1, data=0) return "sk1" if self.glint == "Y" and not self.eglno and w != "T": return "ff8|Invalid G/L Account Number" def doTaxportion(self, frt, pag, r, c, p, i, w): if not w: return "Invalid Tax Portion" def doRcv(self, frt, pag, r, c, p, i, w): if w == 4101: return "SITE Code Not Allowed" acc = self.sql.getRec("wagrcv", cols=["rcv_desc"], where=[("rcv_code", "=", w)], limit=1) if not acc: return "Invalid Rec of Rev Code" else: self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doUniRep(self, frt, pag, r, c, p, i, w): self.df.loadEntry(frt, pag, p + 1, data="N") if self.rtype == "E": if self.code in (1, 2, 3, 4, 5): self.df.loadEntry(frt, pag, p + 2, data=0) self.df.loadEntry(frt, pag, p + 3, data=0) self.df.loadEntry(frt, pag, p + 4, data="N") self.df.loadEntry(frt, pag, p + 5, data=100.00) return "sk5" return "sk4" return "sk1" def doBalNo(self, frt, pag, r, c, p, i, w): if self.rtype == "E": self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 2, data="N") self.df.loadEntry(frt, pag, p + 3, data="N") return "sk3" def doLimit(self, frt, pag, r, c, p, i, w): pass def doMthly(self, frt, pag, r, c, p, i, w): self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doEnd0(self): self.df.focusField("T", 1, 1, clr=self.new) def doEnd1(self): self.df.selPage("Detail-B") self.df.focusField("T", 2, 1, clr=self.new) def doEnd2(self): dat = [self.opts["conum"]] for x in range(0, 2): dat.append(self.df.t_work[0][0][x]) for x in range(0, len(self.df.t_work[1][0])): dat.append(self.df.t_work[1][0][x]) for x in range(0, len(self.df.t_work[2][0])): if x in (0, 2, 3, 4, 5, 6, 7, 8): dat.append(self.df.t_work[2][0][x]) if self.new: self.sql.insRec("wagedc", data=dat) elif dat != self.acc[:len(dat)]: col = self.sql.wagedc_col dat.append(self.acc[col.index("ced_xflag")]) self.sql.updRec("wagedc", data=dat, where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", self.rtype), ("ced_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.last[0] = [0, 0] self.df.selPage("Detail-A") self.df.focusField("T", 0, 1) def doAccept(self): if self.rtype == "D": frt, pag, col, mes = self.df.doCheckFields(("T", 0, None)) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14))) if not mes: if self.df.t_work[1][0][15] not in ("Y", "N", "T", "O", "R"): frt = "T" pag = 1 col = 15 mes = "Invalid Tax Code Selection" if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 1, (16, ))) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 2, (0, 2, 3, 4, 5, 6))) else: frt, pag, col, mes = self.df.doCheckFields(("T", 0, None)) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 8, 15, 16))) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 2, (0, 2, 3))) if mes: if pag > 0 and pag != self.df.pag: if frt == "T": self.df.last[pag][0] = col + 1 else: self.df.last[pag][1] = col + 1 self.df.selPage(self.df.tags[pag - 1][0]) self.df.focusField(frt, pag, (col + 1), err=mes) else: self.doEnd2() def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doExit0(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doExit1(self): self.df.focusField("T", 0, 1) def doExit2(self): self.df.selPage("Detail-A")
class gl2050(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.doProcess() self.opts["mf"].startLoop() def setVariables(self): # Check for Company Record self.gc = GetCtl(self.opts["mf"]) ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return # Check and Load VAT Control self.ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not self.ctlctl: return if self.gc.chkRec(self.opts["conum"], self.ctlctl, ["vat_ctl"]): return self.convat = self.ctlctl["vat_ctl"] # Set Batch Indicator self.batind = "Y" # Create SQL Object tabs = [ "ctlctl", "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint", "genjlm", "genjlt", "genmst", "gentrn", "assgrp", "rtlprm" ] self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "GEN", self.opts["rtn"], multi="Y") self.bh.doBatchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2]) self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][1][0] / 100) return True 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), 9, "All Journals", "", "N", "N", self.doAllJnl, None, None, None), (("T", 0, 2, 0), ("IRB", r2s), 1, "All Periods", "", "N", "N", self.doAllPer, None, None, None)) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt) def doFreq(self, frt, pag, r, c, p, i, w): self.freq = w self.wher = [("gjm_cono", "=", self.opts["conum"]), ("gjm_freq", "=", self.freq), ("gjm_start", "<=", self.bh.curdt), ("gjm_end", ">=", self.bh.curdt), ("gjm_last", "<", self.bh.curdt)] data = self.sql.getRec("genjlm", cols=["gjm_num", "gjm_desc"], where=self.wher) if not data: return "No Valid Standard Journals" 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 doAllJnl(self, frt, pag, r, c, p, i, w): self.alljnl = w def doAllPer(self, frt, pag, r, c, p, i, w): self.allper = w def doEnd(self): self.df.closeProcess() if self.alljnl == "N": recs = getSingleRecords(self.opts["mf"], "genjlm", ("gjm_num", "gjm_desc"), where=self.wher) else: recs = self.sql.getRec("genjlm", where=self.wher) if not recs: self.opts["mf"].closeLoop() return for gjm in recs: self.trnref = gjm[self.sql.genjlm_col.index("gjm_num")] self.trndet = gjm[self.sql.genjlm_col.index("gjm_desc")] start = gjm[self.sql.genjlm_col.index("gjm_start")] last = gjm[self.sql.genjlm_col.index("gjm_last")] dates = [] while start <= self.bh.curdt: if start < self.s_per or start <= last: pass elif self.allper == "N" and start == self.bh.curdt: dates.append(start) elif self.allper == "Y" and start <= self.bh.curdt: dates.append(start) start = self.nextPeriod(start) for self.curdt in dates: self.trndat = mthendDate((self.curdt * 100)) data = self.sql.getRec( "genjlt", cols=["gjt_acno", "gjt_amnt", "gjt_vatc"], where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.trnref), ("gjt_amnt", "<>", 0)]) if not data: continue for tran in data: self.acno = tran[0] self.trnamt = tran[1] self.vatcod = tran[2] vrte = getVatRate(self.sql, self.opts["conum"], self.vatcod, self.trndat) if vrte is None: vrte = 0.0 self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2) self.updateTables() self.updateBatch() self.sql.updRec("genjlm", cols=["gjm_last"], data=[self.curdt], where=[("gjm_cono", "=", self.opts["conum"]), ("gjm_num", "=", self.trnref), ("gjm_freq", "=", self.freq)]) self.opts["mf"].dbm.commitDbase() self.opts["mf"].closeLoop() def nextPeriod(self, period): yy = int(period / 100) mm = (period % 100) + self.mths if mm > 12: yy += 1 mm -= 12 return (yy * 100) + mm def updateTables(self): amt = float(ASD(self.trnamt) - ASD(self.vatamt)) data = (self.opts["conum"], self.acno, self.curdt, self.trndat, self.opts["rtn"], self.trnref, self.bh.batno, amt, self.vatamt, self.trndet, self.vatcod, self.batind, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.vatcod: if self.vatamt: data = (self.opts["conum"], self.convat, self.curdt, self.trndat, self.opts["rtn"], self.trnref, self.bh.batno, self.vatamt, 0.00, self.trndet, self.vatcod, self.batind, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if amt < 0: vtyp = "O" else: vtyp = "I" data = (self.opts["conum"], self.vatcod, vtyp, self.curdt, "G", self.opts["rtn"], self.bh.batno, self.trnref, self.trndat, self.acno, self.trndet, amt, self.vatamt, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", 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.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class ml3070(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", "ctlvrf", "memctc", "memctk", "memcto", "memctp", "memmst", "memcat", "memadd", "memkon", "memtrn" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] memctl = gc.getCtl("memctl", self.opts["conum"]) if not memctl: return self.ldays = memctl["mcm_ldays"] self.fromad = memctl["mcm_emadd"] t = time.localtime() self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2] self.colsd = { 0: ["Membership Number", "Y", ["Mem-No", "UI", 6]], 1: ["Status", "N", ["Status", "NA", 10]], 2: ["Status Date", "N", ["State-Date", "D1", 10]], 3: ["Surname/Title/Initials", "Y", ["Name", "TX", 30]], 4: ["Surname", "N", ["Surname", "TX", 30]], 5: ["Title", "N", ["Title", "TX", 6]], 6: ["First Names", "N", ["First-Names", "TX", 30]], 7: ["Gender", "N", ["G", "UA", 1]], 8: ["Date of Birth", "N", ["Birth-Date", "D1", 10]], 9: ["Age", "N", ["Age", "UI", 3]], 10: ["Identity Number", "N", ["ID-Number", "UI", 13]], 11: ["Entry Date", "N", ["Entry-Date", "d1", 10]], 12: ["Entry Years", "N", ["YR", "UI", 2]], 13: ["Payment Plan", "N", ["P", "UA", 1]], 14: ["Active Category", "N", ["Active-Category", "TX", 30]], 15: ["Telephone - Home", "Y", ["Home-Telephone", "TX", 20]], 16: ["Telephone - Work", "Y", ["Work-Telephone", "TX", 20]], 17: ["Mobile Number", "Y", ["Mobile-Number", "TX", 20]], 18: ["Email Address 1", "Y", ["Email-Address-1", "TX", 30]], 19: ["Email Address 2", "N", ["Email-Address-2", "TX", 30]], 20: ["Address - Postal", "N", ["Postal-Address", "TX", 120]], 21: ["Address - Street", "N", ["Street-Address", "TX", 120]], 22: ["Category Notes", "N", ["Category-Notes", "TX", 50]], 23: ["Proposer", "N", ["Proposer", "TX", 20], ["YR", "UI", 2]], 24: ["Seconder", "N", ["Seconder", "TX", 20], ["YR", "UI", 2]], 25: ["Account Balance", "N", ["Balance", "SD", 13.2]], 26: ["Sports Categories", "N"], 27: ["Last Note", "N", ["Last-Text-Note", "TX", 30]], 28: ["Nationality", "N", ["Nationality", "TX", 30]], 29: ["Occupation", "N", ["Occupation", "TX", 30]] } rgp = self.sql.getRec("memctc", cols=["mcc_rgrp"], where=[("mcc_cono", "=", self.opts["conum"]), ("mcc_type", "=", "C")], group="mcc_rgrp", order="mcc_rgrp") self.rgrps = [] for g in rgp: self.rgrps.append(g[0]) self.colsd[26].append([g[0], "UA", 2]) self.padcol = [0, 0, 0, 0, 0, 0, 0] self.sadcol = [0, 0, 0, 0, 0, 0, 0] return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Members Ledger Master Listing (%s)" % self.__class__.__name__) rgp = {"stype": "C", "head": ("RG", ), "data": self.rgrps, "retn": "D"} cod = { "stype": "R", "tables": ("memctc", ), "cols": (("mcc_code", "", 0, "Cd"), ("mcc_desc", "", 0, "Description", "Y")), "where": [("mcc_cono", "=", self.opts["conum"])], "whera": [("T", "mcc_type", 2, 0)], "order": "mcc_code", "size": (400, 600) } r1s = (("All", "A"), ("Main", "B"), ("Sports", "C"), ("Debentures", "D")) r2s = (("All", "Z"), ("Active", "A"), ("Deceased", "D"), ("Inactive", "I"), ("Resigned", "R"), ("Suspended", "S"), ("Defaulted", "X")) r3s = (("All", "A"), ("Male", "M"), ("Female", "F")) r4s = (("Number", "N"), ("Surname", "M")) fld = ((("T", 0, 0, 0), "ID1", 10, "Report Date", "", self.sysdt, "Y", self.doDate, None, None, ("efld", )), (("T", 0, 1, 0), ("IRB", r2s), 0, "Status", "", "A", "Y", self.doStat, None, None, None), (("T", 0, 2, 0), ("IRB", r1s), 0, "Category", "", "A", "Y", self.doCat, None, None, None), (("T", 0, 3, 0), "IUA", 2, "Report Group", "", 0, "Y", self.doRgrp, rgp, None, None), (("T", 0, 3, 0), "IUI", 2, "Code", "", 0, "Y", self.doCod, cod, None, None), (("T", 0, 3, 0), "ONA", 30, ""), (("T", 0, 4, 0), ("IRB", r3s), 0, "Gender", "", "A", "Y", self.doGender, None, None, None), (("T", 0, 5, 0), ("IRB", r4s), 0, "Sort Order", "", "N", "Y", self.doSort, None, None, None), (("T", 0, 6, 0), "Id1", 10, "From Entry", "From Entry Date", 0, "Y", self.doEFrom, None, None, ("efld", )), (("T", 0, 7, 0), "ID1", 10, "To Entry", "To Entry Date", 0, "Y", self.doETo, None, None, ("efld", )), (("T", 0, 8, 0), "Id1", 10, "From Status", "From Status Date", 0, "Y", self.doSFrom, None, None, ("efld", )), (("T", 0, 9, 0), "ID1", 10, "To Status", "To Status Date", 0, "Y", self.doSTo, None, None, ("efld", ))) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, tend=tnd, txit=txt, view=("Y", "V"), mail=("Y", "N")) def doDate(self, frt, pag, r, c, p, i, w): self.repdt = w self.repdtd = self.df.t_disp[pag][r][i] self.df.topf[0][9][5] = self.repdt self.df.topf[0][11][5] = self.repdt def doStat(self, frt, pag, r, c, p, i, w): self.state = w def doCat(self, frt, pag, r, c, p, i, w): if w == "A": self.cat = "" self.rgp = "" self.cod = "" self.df.loadEntry(frt, pag, p + 3, data="All Categories and Sections") return "sk2" self.cat = w if self.cat not in ("C", "D"): self.rgp = "" return "sk1" def doRgrp(self, frt, pag, r, c, p, i, w): if w and w not in self.rgrps: return "Invalid Report Group" self.rgp = w if self.rgp: self.cod = 0 return "sk2" def doCod(self, frt, pag, r, c, p, i, w): self.codchk = self.sql.getRec("memctc", cols=["mcc_desc"], where=[("mcc_cono", "=", self.opts["conum"]), ("mcc_type", "=", self.cat), ("mcc_code", "=", w)], limit=1) if not self.codchk: return "Invalid Category Code" self.cod = w self.df.loadEntry(frt, pag, p + 1, data=self.codchk[0]) def doGender(self, frt, pag, r, c, p, i, w): self.gender = w def doSort(self, frt, pag, r, c, p, i, w): self.sort = w def doEFrom(self, frt, pag, r, c, p, i, w): self.estart = w self.estartd = self.df.t_disp[pag][r][i] def doETo(self, frt, pag, r, c, p, i, w): self.eend = w self.eendd = self.df.t_disp[pag][r][i] if self.state == "A": self.sstart = 0 self.send = 0 return "sk2" def doSFrom(self, frt, pag, r, c, p, i, w): self.sstart = w self.sstartd = self.df.t_disp[pag][r][i] def doSTo(self, frt, pag, r, c, p, i, w): self.send = w self.sendd = self.df.t_disp[pag][r][i] def doEnd(self): self.df.closeProcess() self.doChooseFields() if self.cnums: # Member's masterfile tab = ["memmst"] col = self.sql.memmst_col whr = [("mlm_cono", "=", self.opts["conum"])] if self.gender != "A": whr.append(("mlm_gender", "=", self.gender)) if self.state != "Z": whr.append(("mlm_state", "=", self.state)) if self.estart: whr.append(("mlm_entry", ">=", self.estart)) if self.eend: whr.append(("mlm_entry", "<=", self.eend)) if self.sstart: if self.state == "R" and self.cat: pass else: whr.append(("mlm_sdate", ">=", self.sstart)) if self.send: if self.state == "R" and self.cat: pass else: whr.append(("mlm_sdate", "<=", self.send)) if self.cat: tab.append("memcat") whr.append(("mlc_cono=mlm_cono", )) whr.append(("mlc_memno=mlm_memno", )) whr.append(("mlc_type", "=", self.cat)) if self.cod: whr.append(("mlc_code", "=", self.cod)) if self.rgp: tab.append("memctc") whr.append(("mcc_cono=mlc_cono", )) whr.append(("mcc_type=mlc_type", )) whr.append(("mcc_code=mlc_code", )) whr.append(("mcc_rgrp", "=", self.rgp)) if self.state == "A": whr.append(("mlc_end", "=", 0)) elif self.state == "R": whr.append(("(", "mlm_state", "=", "R", "and", "mlm_sdate", "between", self.sstart, self.send, "or", "mlm_state", "=", "A", "and", "mlc_end", "between", self.sstart, self.send, ")")) grp = col[0] for c in col[1:]: grp = "%s, %s" % (grp, c) else: grp = None if self.sort == "N": odr = "mlm_memno" else: odr = "mlm_surname" recs = self.sql.getRec(tables=tab, cols=col, where=whr, group=grp, order=odr) if not recs: showError(self.opts["mf"].body, "Selection Error", "No Accounts Selected") else: self.printReport(recs) self.opts["mf"].closeLoop() def printReport(self, recs): data = [] typ = "Generating the Report ... Please Wait" p = ProgressBar(self.opts["mf"].body, mxs=len(recs), typ=typ, esc=True) for num, dat in enumerate(recs): p.displayProgress(num) if p.quit: break data.append(self.getValues(dat)) p.closeProgress() if not p.quit: head = ["Member's Master Report as at %s" % self.repdtd] colsh = [] for n1 in self.cnums: for n2, d2 in enumerate(self.colsd[n1][2:]): if n1 in (20, 21) and self.df.repprt[2] == "export": if n1 == 20: prefix = "P" col = copyList(self.padcol) else: prefix = "S" col = copyList(self.sadcol) colsh.append(("name1%s_%s" % (n1, n2), "NA", col[0], "%s-Address-Line-1" % prefix, "y")) colsh.append(("name2%s_%s" % (n1, n2), "NA", col[1], "%s-Address-Line-2" % prefix, "y")) colsh.append(("name3%s_%s" % (n1, n2), "NA", col[2], "%s-Address-Line-3" % prefix, "y")) colsh.append(("name4%s_%s" % (n1, n2), "NA", col[3], "%s-City" % prefix, "y")) colsh.append(("name5%s_%s" % (n1, n2), "NA", col[4], "%s-Code" % prefix, "y")) colsh.append(("name6%s_%s" % (n1, n2), "NA", col[5], "%s-Region" % prefix, "y")) colsh.append(("name7%s_%s" % (n1, n2), "NA", col[6], "%s-Country" % prefix, "y")) else: colsh.append( ("name%s_%s" % (n1, n2), d2[1], d2[2], d2[0], "y")) RepPrt(self.opts["mf"], name=self.__class__.__name__, heads=head, tables=data, cols=colsh, opts=self.getDes(), ttype="D", conum=self.opts["conum"], conam=self.opts["conam"], repprt=self.df.repprt, repeml=self.df.repeml, fromad=self.fromad, pbar="P") def doChooseFields(self): r1s = (("Yes", "Y"), ("No", "N")) fld = [] idx = 0 for num in range(0, len(self.colsd), 2): des = self.colsd[num][0] dft = self.colsd[num][1] fld.append((("T", 0, idx, 0, 27), ("IRB", r1s), 0, des, des, dft, "N", self.doCField, None, None, None)) if (num + 1) == len(self.colsd): continue des = " %s" % self.colsd[num + 1][0] dft = self.colsd[num + 1][1] fld.append((("T", 0, idx, 40, 67), ("IRB", r1s), 0, des, des, dft, "N", self.doCField, None, None, None)) idx += 1 tnd = ((self.doCEnd, "Y"), ) txt = (self.doCExit, ) self.cf = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt) self.cf.mstFrame.wait_window() def doCField(self, frt, pag, r, c, p, i, w): mxs = 0 for n, x in enumerate(self.cf.t_work[pag][0]): if x == "Y": for y in self.colsd[n][2:]: if mxs: mxs += 1 mxs += y[2] if mxs > 210 and self.df.repprt[2] != "export": return "Maximum Print Width Exceeded" if p == 3 and w == "Y": self.cf.loadEntry(frt, pag, p + 1, data="N") self.cf.loadEntry(frt, pag, p + 2, data="N") self.cf.loadEntry(frt, pag, p + 3, data="N") return "sk3" def doCEnd(self): self.cf.closeProcess() self.cnums = [] for n1, d1 in enumerate(self.cf.t_work[0][0]): if d1 == "Y": self.cnums.append(n1) def doCExit(self): self.cnums = [] self.cf.closeProcess() def getDes(self): if self.state == "Z": des = "All Statuses" elif self.state == "A": des = "Active Members" elif self.state == "D": des = "Deceased Members" elif self.state == "I": des = "Inactive Members" elif self.state == "R": des = "Resigned Members" elif self.state == "S": des = "Suspended Members" elif self.state == "X": des = "Defaulted Members" if self.gender == "M": des = "%s (Male)" % des elif self.gender == "F": des = "%s (Female)" % des if self.cat in ("", "A"): des = "%s for All Categories and Sections" % des elif self.cat == "B": des = "%s for Main Category" % des elif self.cat == "C": des = "%s for Sports Category" % des elif self.cat == "D": des = "%s for Debenture Category" % des if self.cat and self.rgp: des = "%s: Report Group %s" % (des, self.rgp) if self.cod: des = "%s: %s" % (des, self.codchk[0]) else: des = "%s: All Sections" % des elif self.cat and self.cod: des = "%s: %s" % (des, self.codchk[0]) elif self.cat: des = "%s: All Sections" % des if self.estart: des = "%s who Joined Between %s and %s" % (des, self.estartd, self.eendd) else: des = "%s who Joined On or Before %s" % (des, self.eendd) return des def getValues(self, data): col = self.sql.memmst_col # Membership Number self.memno = data[col.index("mlm_memno")] # Title tit = data[col.index("mlm_title")] # Surname sur = data[col.index("mlm_surname")] # First Names nam = data[col.index("mlm_names")] # Initials ini = data[col.index("mlm_initial")] # Combined Name sti = "%s, %s %s" % (sur, tit, ini) # Gender gen = data[col.index("mlm_gender")] # Date of Birth dob = data[col.index("mlm_dob")] # Age if dob: age = dateDiff(dob, self.repdt, "years") else: age = 0 # Identity Number idn = data[col.index("mlm_idnum")] # Entry Date doe = data[col.index("mlm_entry")] # Payment Plan pay = data[col.index("mlm_payplan")] # Entry Years if doe: yrs = dateDiff(doe, self.repdt, "years") else: yrs = 0 # Status if data[col.index("mlm_state")] == "A": sta = "Active" elif data[col.index("mlm_state")] == "D": sta = "Deceased" elif data[col.index("mlm_state")] == "I": sta = "Inactive" elif data[col.index("mlm_state")] == "R": sta = "Resigned" elif data[col.index("mlm_state")] == "S": sta = "Suspended" elif data[col.index("mlm_state")] == "X": sta = "Defaulted" # Status Date sdt = data[col.index("mlm_sdate")] # Proposer prp = self.sql.getRec("memmst", where=[("mlm_cono", "=", self.opts["conum"]), ("mlm_memno", "=", data[col.index("mlm_proposer")])], limit=1) if not prp: prn = "Unknown" pry = 0 else: prn = "%s, %s %s" % (prp[col.index("mlm_surname")], prp[col.index("mlm_title")], prp[col.index("mlm_initial")]) if prp[col.index("mlm_entry")]: pry = dateDiff(prp[col.index("mlm_entry")], self.repdt, "years") else: pry = 0 # Seconder sec = self.sql.getRec("memmst", where=[("mlm_cono", "=", self.opts["conum"]), ("mlm_memno", "=", data[col.index("mlm_seconder")])], limit=1) if not sec: sen = "Unknown" sey = 0 else: sen = "%s, %s %s" % (sec[col.index("mlm_surname")], sec[col.index("mlm_title")], sec[col.index("mlm_initial")]) if sec[col.index("mlm_entry")]: sey = dateDiff(sec[col.index("mlm_entry")], self.repdt, "years") else: sey = 0 # Postal Address rcp = self.sql.getRec("memadd", where=[("mla_cono", "=", self.opts["conum"]), ("mla_memno", "=", self.memno), ("mla_type", "=", "P")], limit=1) if not rcp: rcp = [ self.opts["conum"], self.memno, "P", "", "", "", "", "", "", "" ] if self.df.repprt[2] == "export": pad = rcp[3:] for x in range(3, len(rcp)): if self.padcol[x - 3] < len(rcp[x]): self.padcol[x - 3] = len(rcp[x]) else: pad = rcp[3] if rcp[4]: pad = "%s, %s" % (pad, rcp[4]) if rcp[5]: pad = "%s, %s" % (pad, rcp[5]) if rcp[7]: pad = "%s, %s" % (pad, rcp[7]) # Street Address rcs = self.sql.getRec("memadd", where=[("mla_cono", "=", self.opts["conum"]), ("mla_memno", "=", self.memno), ("mla_type", "=", "R")], limit=1) if not rcs: rcs = [ self.opts["conum"], self.memno, "R", "", "", "", "", "", "", "" ] if self.df.repprt[2] == "export": sad = rcs[3:] for x in range(3, len(rcs)): if self.sadcol[x - 3] < len(rcs[x]): self.sadcol[x - 3] = len(rcs[x]) else: sad = rcs[3] if rcs[4]: sad = "%s, %s" % (sad, rcs[4]) if rcs[5]: sad = "%s, %s" % (sad, rcs[5]) if rcs[7]: sad = "%s, %s" % (sad, rcs[7]) # Active Category whr = [("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_type", "=", "B"), ("mcc_cono=mlc_cono", ), ("mcc_type=mlc_type", ), ("mcc_code=mlc_code", )] cat = self.sql.getRec(tables=["memcat", "memctc"], cols=["mcc_desc"], where=whr, limit=1) if cat: cat = cat[0] else: cat = "Unknown Category" # Contact Details kon = self.sql.getRec(tables=["memctk", "memkon"], cols=["mck_type", "mlk_detail"], where=[("mlk_cono", "=", self.opts["conum"]), ("mlk_memno", "=", self.memno), ("mck_code=mlk_code", )]) # Home Tel htl = "" # Work Tel wtl = "" # Mobile cel = "" # Email em1 = "" em2 = "" for k in kon: if k[0] == "H" and not htl: htl = k[1] if k[0] == "W" and not wtl: wtl = k[1] if k[0] == "M" and not cel: cel = k[1] if k[0] == "E": if not em1: em1 = k[1] else: em2 = k[1] nat = countries[data[col.index("mlm_nation")]] if nat: nat = nat[1] else: nat = "Unknown" occ = self.sql.getRec("memcto", cols=["mco_desc"], where=[("mco_code", "=", data[col.index("mlm_occup")])], limit=1) if occ: occ = occ[0] else: occ = "Unknown" if 22 in self.cnums: # Category Notes if self.cat == "C" or (self.cat == "D" and self.cod): nte = self.sql.getRec("memcat", cols=["mlc_note"], where=[("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_type", "=", self.cat), ("mlc_code", "=", self.cod)], limit=1) if not nte: nte = [""] elif self.cat == "D": chk = self.sql.getRec("memcat", cols=["mlc_note"], where=[("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_type", "=", self.cat)]) if not chk: nte = ["Unknown"] else: nte = "" for n in chk: if not n[0]: continue if not nte: nte = n[0] else: nte = "%s, %s" % (nte, n[0]) if nte: nte = [nte] else: nte = ["Unknown"] else: nte = [""] nte = nte[0] if 25 in self.cnums: # Account Balance if sta == "Active": self.raiseExtraTrans() bal = self.sql.getRec("memtrn", cols=["sum(mlt_tramt)"], where=[("mlt_cono", "=", self.opts["conum"]), ("mlt_memno", "=", self.memno)], limit=1) if not bal: bal = 0 else: bal = bal[0] self.opts["mf"].dbm.rollbackDbase() if 26 in self.cnums: # Sports Categories col = ["mcc_rgrp"] whr = [("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_type", "=", "C"), ("mlc_end", "=", 0), ("mcc_cono=mlc_cono", ), ("mcc_type=mlc_type", ), ("mcc_code=mlc_code", )] spc = self.sql.getRec(tables=["memcat", "memctc"], cols=col, where=whr) chk = [] for s in spc: chk.append(s[0]) asc = [] for g in self.rgrps: if g in chk: asc.append(g) else: asc.append(" ") val = [] if 0 in self.cnums: val.append(self.memno) if 1 in self.cnums: val.append(sta) if 2 in self.cnums: val.append(sdt) if 3 in self.cnums: val.append(sti) if 4 in self.cnums: val.append(sur) if 5 in self.cnums: val.append(tit) if 6 in self.cnums: val.append(nam) if 7 in self.cnums: val.append(gen) if 8 in self.cnums: val.append(dob) if 9 in self.cnums: val.append(age) if 10 in self.cnums: val.append(idn) if 11 in self.cnums: val.append(doe) if 12 in self.cnums: val.append(yrs) if 13 in self.cnums: val.append(pay) if 14 in self.cnums: val.append(cat) if 15 in self.cnums: val.append(htl) if 16 in self.cnums: val.append(wtl) if 17 in self.cnums: val.append(cel) if 18 in self.cnums: val.append(em1) if 19 in self.cnums: val.append(em2) if 20 in self.cnums: if self.df.repprt[2] == "export": val.extend(pad) else: val.append(pad) if 21 in self.cnums: if self.df.repprt[2] == "export": val.extend(sad) else: val.append(sad) if 22 in self.cnums: val.append(nte) if 23 in self.cnums: val.append(prn) val.append(pry) if 24 in self.cnums: val.append(sen) val.append(sey) if 25 in self.cnums: val.append(bal) if 26 in self.cnums: val.extend(asc) if 27 in self.cnums: nte = self.sql.getRec("ctlnot", cols=["not_desc"], where=[("not_cono", "=", self.opts["conum"]), ("not_sys", "=", "MEM"), ("not_key", "=", str(self.memno))], order="not_seq desc", limit=1) if nte: val.append(nte[0]) else: val.append("") if 28 in self.cnums: val.append(nat) if 29 in self.cnums: val.append(occ) return val def getCode(self, desc): a = desc.split() if len(a) == 1: return "%s " % a[0][0].capitalize() if a[1] == "-": return "%s%s" % (a[0][0].capitalize(), a[2][0].capitalize()) return "%s%s" % (a[0][0].capitalize(), a[1][0].capitalize()) def raiseExtraTrans(self): self.tme = mthendDate(self.repdt) if int(self.tme / 100) == int(self.opts["period"][2][0] / 100): self.ynd = True else: self.ynd = False yy = int(self.tme / 10000) mm = (int(self.tme / 100) % 100) + 1 while mm > 12: yy += 1 mm -= 12 self.nxtdt = (yy * 10000) + (mm * 100) + 1 self.refno = 0 if self.ynd: data = doChkCatChg(self.opts["mf"], self.opts["conum"], self.memno, self.nxtdt) if data: self.doRaiseCharge("B", data[0], data[1], data[3], data[4], data[5], skip=True) self.sql.delRec("memcat", where=[("mlc_cono", "=", self.opts["conum"]), ("mlc_memno", "=", self.memno), ("mlc_type", "=", "B"), ("mlc_code", "=", data[0])]) self.sql.insRec("memcat", data=[ self.opts["conum"], self.memno, "B", data[7], "", self.nxtdt, 0, 0 ]) cols = [ "mlc_type", "mlc_code", "mcc_desc", "mcc_freq", "mlc_start", "mlc_end", "mlc_last" ] 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 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 last and last > self.opts["period"][2][0]: # Already Raised for Next Period in Advance continue if not self.ynd and last and freq == "A" and \ last >= self.opts["period"][1][0] and \ last <= self.opts["period"][2][0]: # Already Raised in Financial Period continue self.doRaiseCharge(ctyp, code, start, last, freq, desc) def doRaiseCharge(self, ctyp, code, start, last, freq, desc, 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, trdt, amt) if not skip and nxt: trdt = self.nxtdt amt = self.doGetCharge(ctyp, code, trdt) if amt: self.doUpdateTables(ctyp, code, desc, trdt, amt) if dte or (not skip and nxt): 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)]) 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, trdt, amt): batch = "PROFORM" self.refno += 1 refno = "PF%07i" % self.refno 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) / 114), 2), "UD", 12.2).work # Members Ledger Transaction (memtrn) self.sql.insRec("memtrn", data=[ self.opts["conum"], self.memno, 1, refno, batch, trdt, amt, vat, curdt, ctyp, code, desc, self.taxdf, "", self.opts["capnm"], self.sysdt, 0 ], unique="mlt_refno") def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bkc510(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", "bkmcon", "bkmmst"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) bkmctl = gc.getCtl("bkmctl", self.opts["conum"]) if not bkmctl: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def mainProcess(self): con = { "stype": "R", "tables": ("bkmcon", ), "cols": (("bkc_ccode", "", 0, "Code"), ("bkc_title", "", 0, "Title"), ("bkc_sname", "", 0, "Surname", "Y"), ("bkc_names", "", 0, "Names", "F"), ("bkc_email", "", 0, "Email Address")) } self.fld = ((("T", 0, 0, 0), "IUA", 7, "Code", "", "", "Y", self.doCode, con, None, None), (("T", 0, 1, 0), "ITX", 6, "Title", "", "", "N", self.doTitle, None, self.doDelete, ("notblank", )), (("T", 0, 2, 0), "ITX", 30, "Surname", "", "", "N", self.doSurname, None, None, ("notblank", )), (("T", 0, 3, 0), "ITX", 30, "Names", "", "", "N", self.doNames, None, None, ("notblank", )), (("T", 0, 4, 0), "ITX", 30, "Address Line 1", "", "", "N", None, None, None, ("efld", )), (("T", 0, 5, 0), "ITX", 30, "Address Line 2", "", "", "N", None, None, None, ("efld", )), (("T", 0, 6, 0), "ITX", 30, "Address Line 3", "", "", "N", None, None, None, ("efld", )), (("T", 0, 7, 0), "ITX", 4, "Postal Code", "", "", "N", None, None, None, ("efld", )), (("T", 0, 8, 0), "ITX", 20, "Telephone Number", "", "", "N", None, None, None, ("efld", )), (("T", 0, 9, 0), "ITX", 20, "Fax Number", "", "", "N", None, None, None, ("efld", )), (("T", 0, 10, 0), "ITX", 20, "Mobile Number", "", "", "N", None, None, None, ("efld", )), (("T", 0, 11, 0), "ITX", 30, "E-Mail Address", "", "", "N", None, None, None, ("email", )), (("T", 0, 12, 0), "INA", 10, "V.A.T Number", "", "", "N", None, None, None, ("efld", ))) but = ( ("Import",None,self.doImport,0,("T",0,1),("T",0,2), "Import Contact Details from a CSV or XLS File having "\ "the following fields: Code, Title, Surname, Names, "\ "Address Line1, Line2, Line3, Postal Code, Telephone Number, "\ "Fax Number, Mobile Number, Email Address, VAT Number"), ("Accept",None,self.doAccept,0,("T",0,2),("T",0,1)), ("Print", None, self.doPrint,0,("T",0,2),("T",0,1)), ("Quit", None, self.doExit,1,None,None)) tnd = ((self.doAccept, "N"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt, clicks=self.doClick) def doClick(self, *opts): self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doCode(self, frt, pag, r, c, p, i, w): self.ccode = w if w: self.oldcon = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", w)], limit=1) if not self.oldcon: return "Invalid Contact Code" self.newcon = False self.title = self.oldcon[self.sql.bkmcon_col.index("bkc_title")] self.sname = self.oldcon[self.sql.bkmcon_col.index("bkc_sname")] self.names = self.oldcon[self.sql.bkmcon_col.index("bkc_names")] self.email = self.oldcon[self.sql.bkmcon_col.index("bkc_email")] for num, dat in enumerate(self.oldcon[1:-1]): self.df.loadEntry("T", 0, num, data=dat) else: self.newcon = True self.acno = w def doTitle(self, frt, pag, r, c, p, i, w): self.title = w def doSurname(self, frt, pag, r, c, p, i, w): self.sname = w def doNames(self, frt, pag, r, c, p, i, w): self.names = w def doEmail(self, frt, pag, r, c, p, i, w): self.email = w def doDelete(self): chk = self.sql.getRec("bkmmst", cols=["count(*)"], where=[("bkm_cono", "=", self.opts["conum"]), ("bkm_ccode", "=", self.ccode)], limit=1) if chk[0]: return "Bookings Exist, Not Deleted" dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.delRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", self.ccode)]) self.sql.insRec("chglog", data=[ "bkmcon", "D", "%03i%-7s" % (self.opts["conum"], self.ccode), "", dte, self.opts["capnm"], "", "", "", 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) return # Create/Update Record if self.newcon: self.ccode = self.genCode(self.sname) self.df.loadEntry("T", 0, 0, data=self.ccode) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) data = [self.opts["conum"]] for x in range(len(self.df.t_work[0][0])): data.append(self.df.t_work[0][0][x]) if self.newcon: self.sql.insRec("bkmcon", data=data) elif data != self.oldcon[:len(data)]: col = self.sql.bkmcon_col data.append(self.oldcon[col.index("bkc_xflag")]) self.sql.updRec("bkmcon", data=data, where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", self.ccode)]) for num, dat in enumerate(self.oldcon): if dat != data[num]: self.sql.insRec( "chglog", data=[ "bkmcon", "U", "%03i%-7s" % (self.opts["conum"], self.ccode), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doImport(self): self.df.setWidget(self.df.mstFrame, state="hide") fi = FileImport(self.opts["mf"], imptab="bkmcon", impskp=["bkc_cono"]) sp = ProgressBar(self.opts["mf"].body, typ="Importing Contacts", mxs=len(fi.impdat)) err = None for num, line in enumerate(fi.impdat): sp.displayProgress(num) if not line[0]: if not line[2]: err = "Blank Code and Blank Surname" break chk = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_sname", "=", line[2]), ("bkc_names", "=", line[3])], limit=1) if chk: err = "%s: %s %s: %s\n\nAlready Exists" % ( fi.impcol[2][0], line[2], fi.impcol[3][0], line[3]) break for _ in range(1, 100): line[0] = self.genCode(line[2]) chk = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", line[0])], limit=1) if not chk: break else: chk = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", line[0])], limit=1) if chk: err = "%s: %s %s: %s\n\nAlready Exists" % ( fi.impcol[0][0], line[0], fi.impcol[2][0], line[2]) break if not line[1]: line[1] = "Ms" if not line[2]: err = "Blank Surname" break if not line[3]: err = "Blank Names" break line.insert(0, self.opts["conum"]) self.sql.insRec("bkmcon", data=line) sp.closeProgress() if err: err = "Line %s: %s" % ((num + 1), err) showError( self.opts["mf"].body, "Import Error", """%s Please Correct your Import File and then Try Again.""" % err) self.opts["mf"].dbm.rollbackDbase() else: self.opts["mf"].dbm.commitDbase() self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doPrint(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") TabPrt(self.opts["mf"], self.opts["conum"], self.opts["conam"], name=self.__class__.__name__, tabs="bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", self.ccode)]) 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 genCode(self, sname): # Remove invalid characters sname = sname.replace(" ", "") for c in (" ", ".", ",", ";", ":", "'", '"'): sname = sname.replace(c, "") if len(sname) < 5: sname = sname + ("0" * (5 - len(sname))) ccod1 = "" for c in range(0, 5): ccod1 = (ccod1 + sname[c]).upper() ccod1 = ccod1.strip() text = "%s%0" + str((7 - len(ccod1))) + "d" for x in range(1, 100): ccod2 = text % (ccod1, x) chk = self.sql.getRec("bkmcon", where=[("bkc_cono", "=", self.opts["conum"]), ("bkc_ccode", "=", ccod2)], limit=1) if not chk: break return ccod2 def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bkc110(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return mods = ctlmst["ctm_modules"] self.genleg = False for x in range(0, len(mods), 2): if mods[x:x + 2] == "GL": self.genleg = True break tabs = ["bkmctl", "tplmst", "chglog"] if self.genleg: tabs.extend(["ctlctl", "genmst"]) self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return self.acc = self.sql.getRec("bkmctl", where=[("cbk_cono", "=", self.opts["conum"]) ], limit=1) if not self.acc: self.new = True self.acc = [ self.opts["conum"], "N", "booking_form", "booking_invoice", "booking_statement", "", "", "" ] else: self.new = False if self.genleg: self.ctl = [["bkm_ctl", "Bookings Control", 0], ["bkm_chq", "Cheques Received", 0], ["bkm_csh", "Cash Received", 0], ["bkm_ccg", "Cancellation Fee", 0]] ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return for num, ctl in enumerate(self.ctl): if ctl[0] in ctlctl: self.ctl[num][2] = ctlctl[ctl[0]] return True def drawDialog(self): tpb = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")), "where": [("tpm_type", "=", "B"), ("tpm_system", "=", "BKM")], "order": "tpm_tname" } tpi = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")), "where": [("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")], "order": "tpm_tname" } tps = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")), "where": [("tpm_type", "=", "S"), ("tpm_system", "=", "BKM")], "order": "tpm_tname" } trm = {"stype": "F", "types": "fle"} r1s = (("Yes", "Y"), ("No", "N")) if self.genleg: glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30, "Description")), "where": [("glm_cono", "=", self.opts["conum"])] } fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "", self.acc[1], "N", self.doGlint, None, None, None), (("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "", self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 1, 0), "ONA", 30, ""), (("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "", self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 2, 0), "ONA", 30, ""), (("T", 0, 3, 0), "IUI", 7, self.ctl[2][1], "", self.ctl[2][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 3, 0), "ONA", 30, ""), (("T", 0, 4, 0), "IUI", 7, self.ctl[3][1], "", self.ctl[3][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 4, 0), "ONA", 30, "")] seq = 5 else: fld = [] seq = 0 fld.extend([(("T", 0, seq, 0), "INA", 20, "Booking Template", "", self.acc[2], "N", self.doBkgTpl, tpb, None, None), (("T", 0, seq + 1, 0), "INA", 20, "Invoice Template", "", self.acc[3], "N", self.doInvTpl, tpi, None, None), (("T", 0, seq + 2, 0), "INA", 20, "Statement Template", "", self.acc[4], "N", self.doStaTpl, tps, None, None), (("T", 0, seq + 3, 0), "ITX", 50, "Terms and Conditions", "", self.acc[5], "N", None, trm, None, ("fle", "blank")), (("T", 0, seq + 4, 0), "ITX", 50, "Email Address", "", self.acc[6], "N", None, None, None, ("email", ))]) but = (("Quit", None, self.doExit, 1, None, None), ) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt) if not self.new: s = 0 for n, f in enumerate(self.acc[1:-1]): if not self.genleg and not n: continue self.df.loadEntry("T", 0, s, data=f) s += 1 if not n: for c in self.ctl: self.df.loadEntry("T", 0, s, data=c[2]) s += 1 self.df.loadEntry("T", 0, s, data=self.getDes(c[2])) s += 1 self.df.focusField("T", 0, 1, clr=False) def doGlint(self, frt, pag, r, c, p, i, w): self.glint = w if self.glint == "N": for x in range(1, 9): self.df.loadEntry(frt, pag, p + x, data="") return "sk8" def doGenAcc(self, frt, pag, r, c, p, i, w): des = self.getDes(w) if not des: return "Invalid Account Number" self.df.loadEntry(frt, pag, p + 1, data=des) def getDes(self, acno): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acno)], limit=1) if acc: return acc[0] else: return "" def doBkgTpl(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "B"), ("tpm_system", "=", "BKM")], limit=1) if not acc: return "Invalid Template Name" def doInvTpl(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")], limit=1) if not acc: return "Invalid Template Name" def doStaTpl(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "S"), ("tpm_system", "=", "BKM")], limit=1) if not acc: return "Invalid Template Name" def doEnd(self): data = [self.opts["conum"]] if not self.genleg: data.append("N") for x, d in enumerate(self.df.t_work[0][0]): if self.genleg and x < 9: if x in (1, 3, 5, 7): y = int((x - 1) / 2) chk = self.sql.getRec("ctlctl", where=[("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "=", self.ctl[y][0])], limit=1) if chk: self.sql.updRec("ctlctl", cols=["ctl_conacc"], data=[d], where=[("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "=", self.ctl[y][0])]) else: self.sql.insRec("ctlctl", data=[ self.opts["conum"], self.ctl[y][0], self.ctl[y][1], d, "", "N", "N" ]) elif x in (2, 4, 6, 8): continue else: data.append(d) else: data.append(d) if self.new: self.sql.insRec("bkmctl", data=data) elif data != self.acc[:len(data)]: col = self.sql.bkmctl_col data.append(self.acc[col.index("cbk_xflag")]) self.sql.updRec("bkmctl", data=data, where=[("cbk_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=[ "bkmctl", "U", "%03i" % self.opts["conum"], col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.doExit() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class rc1010(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", "rcaowm", "rcaowt", "chglog"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] return True def mainProcess(self): own = { "stype": "R", "tables": ("rcaowm", ), "cols": (("rom_acno", "", 0, "Acc-Num"), ("rom_name", "", 0, "Name", "Y")), "where": [("rom_cono", "=", self.opts["conum"])] } self.fld = ((("T", 0, 0, 0), "INA", 7, "Account Number", "", "", "Y", self.doOwner, own, None, ("notblank", )), (("T", 0, 1, 0), "INA", 30, "Name", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N", None, None, None, ("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N", None, None, None, ("efld", )), (("T", 0, 5, 0), "INA", 4, "Postal Code", "PCod", "", "N", None, None, None, ("notblank", )), (("T", 0, 6, 0), "INA", 20, "Home Number", "", "", "N", None, None, None, ("efld", )), (("T", 0, 7, 0), "INA", 20, "Office Number", "", "", "N", None, None, None, ("efld", )), (("T", 0, 8, 0), "INA", 20, "Mobile Number", "", "", "N", None, None, None, ("efld", )), (("T", 0, 9, 0), "INA", 20, "Fax Number", "", "", "N", None, None, None, ("efld", )), (("T", 0, 10, 0), "ITX", 50, "E-Mail Address", "", "", "N", None, None, None, ("email", )), (("T", 0, 11, 0), "INA", 10, "VAT Number", "VAT-Number", "", "N", None, None, None, ("efld", )), (("T", 0, 12, 0), "IUA", 1, "VAT Default", "V", "", "N", None, None, None, ("efld", )), (("T", 0, 13, 0), "INA", 20, "Bank Name", "Bank-Name", "", "N", None, None, None, ("efld", )), (("T", 0, 14, 0), "IUI", 8, "Bank Branch", "Bank-IBT", "", "N", None, None, None, ("efld", )), (("T", 0, 15, 0), "INA", 16, "Bank Account", "Bank-Account-Num", "", "N", None, None, None, ("efld", ))) 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 doOwner(self, frt, pag, r, c, p, i, w): self.acno = w self.oldm = self.sql.getRec("rcaowm", where=[("rom_cono", "=", self.opts["conum"]), ("rom_acno", "=", self.acno)], limit=1) if not self.oldm: self.new = "y" for num in range(2, self.df.topq[0]): self.df.clearEntry(frt, pag, num + 1) else: self.new = "n" for num, fld in enumerate(self.oldm[1:-1]): self.df.loadEntry(frt, pag, p + num, data=fld) trn = self.sql.getRec("rcaowt", cols=["count(*)"], where=[("rot_cono", "=", self.opts["conum"]), ("rot_acno", "=", self.acno)], limit=1) if trn[0]: self.trn = True else: self.trn = False def doName(self, frt, pag, r, c, p, i, w): pass def doTelno(self, frt, pag, r, c, p, i, w): pass def doEmail(self, frt, pag, r, c, p, i, w): pass def doVatInd(self, frt, pag, r, c, p, i, w): pass def doVatNum(self, frt, pag, r, c, p, i, w): if self.new == "n" and self.trn: return "sk1" def doStart(self, frt, pag, r, c, p, i, w): pass def doPeriod(self, frt, pag, r, c, p, i, w): pass def doPayInd(self, frt, pag, r, c, p, i, w): pass def doAmount(self, frt, pag, r, c, p, i, w): if self.new == "y": self.df.loadEntry(frt, pag, p + 1, data="C") def doStatus(self, frt, pag, r, c, p, i, w): pass def doDelete(self): if self.trn: return "Transactions Exist, Not Deleted" self.sql.delRec("rcaowm", where=[("rom_cono", "=", self.opts["conum"]), ("rom_acno", "=", self.acno)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["rcaowm", "D", "%03i%-7s" % \ (self.opts["conum"], self.acno), "", dte, self.opts["capnm"], "", "", "", 0]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): datm = [self.opts["conum"]] for num, fld in enumerate(self.df.t_work[0][0]): datm.append(fld) if self.new == "y": self.sql.insRec("rcaowm", data=datm) elif datm != self.oldm[:len(datm)]: col = self.sql.rcaowm_col datm.append(self.oldm[col.index("rom_xflag")]) self.sql.updRec("rcaowm", data=datm, where=[("rom_cono", "=", self.opts["conum"]), ("rom_acno", "=", self.acno)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.oldm): if dat != datm[num]: self.sql.insRec( "chglog", data=[ "rcaowm", "U", "%03i%-7s" % (self.opts["conum"], self.acno), col[num], dte, self.opts["capnm"], str(dat), str(datm[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doAccept(self): frt, pag, col, mes = self.df.doCheckFields() if mes: self.df.focusField(frt, pag, (col + 1), err=mes) else: self.df.doEndFrame("T", 0, cnf="N") def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class stc310(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, ["ctlvmf", "genmst", "strmf1", "strgrp", "strgmu"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.plevs = strctl["cts_plevs"] self.automu = strctl["cts_automu"] return True def mainProcess(self): gpm = { "stype": "R", "tables": ("strgrp",), "cols": ( ("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])]} vtm = { "stype": "R", "tables": ("ctlvmf",), "cols": ( ("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])]} glm = { "stype": "R", "tables": ("genmst",), "cols": ( ("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])]} self.fld = [ (("T",0,0,0),"IUA",3,"Product Group","", "","N",self.doGroup,gpm,None,("notblank",)), (("T",0,1,0),"INA",30,"Description","", "","N",None,None,self.doDelete,("notblank",)), (("T",0,2,0),"IUA",1,"Vat Code","", "","N",self.doVat,vtm,None,("notblank",))] row = 3 if self.glint == "Y": self.fld.append((("T",0,3,0),"IUI",7,"Sales Account","", "","N",self.doSales,glm,None,("notzero",))) self.fld.append((("T",0,3,0),"ONA",30,"")) self.fld.append((("T",0,4,0),"IUI",7,"COS Account","", "","N",self.doCos,glm,None,("notzero",))) self.fld.append((("T",0,4,0),"ONA",30,"")) row = 5 if self.automu in ("A", "L"): self.fld.append((("T",0,row,0),"IUD",5.1,"Mark-Up Lv1","", "","N",None,None,None,("efld",))) if self.plevs > 1: for x in range(1, self.plevs): self.fld.append((("T",0,row,0),"IUD",5.1,"Lv%s" % (x+1),"", "","N",None,None,None,("efld",))) but = ( ("Accept",None,self.doAccept,0,("T",0,2),("T",0,0)), ("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0))) tnd = ((self.doEnd,"Y"), ) txt = (self.doCloseProcess, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doGroup(self, frt, pag, r, c, p, i, w): self.group = w self.acc = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", self.group)], limit=1) if not self.acc: self.new = "Y" else: self.new = "N" col = self.sql.strgrp_col self.df.loadEntry(frt, pag, p+1, data=self.acc[col.index("gpm_desc")]) self.df.loadEntry(frt, pag, p+2, data=self.acc[col.index("gpm_vatcode")]) p = 3 if self.glint == "Y": self.df.loadEntry(frt, pag, p, data=self.acc[col.index("gpm_sales")]) des = self.getGenDesc(self.acc[col.index("gpm_sales")]) if not des: self.df.loadEntry(frt, pag, p+1, data="Invalid Sales Code") else: self.df.loadEntry(frt, pag, p+1, data=des[0]) self.df.loadEntry(frt, pag, p+2, data=self.acc[col.index("gpm_costs")]) des = self.getGenDesc(self.acc[col.index("gpm_costs")]) if not des: self.df.loadEntry(frt, pag, p+3, data="Invalid Costs Code") else: self.df.loadEntry(frt, pag, p+3, data=des[0]) p = 7 if self.automu in ("A", "L"): for lev in range(self.plevs): mup = self.sql.getRec("strgmu", cols=["smg_markup"], where=[("smg_cono", "=", self.opts["conum"]), ("smg_group", "=", self.group), ("smg_level", "=", lev + 1)], limit=1) if not mup: mup = [0] self.df.loadEntry(frt, pag, p+lev, data=mup[0]) def doVat(self, frt, pag, r, c, p, i, w): vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) if not vat: return "Invalid VAT Code" self.code = w def doSales(self, frt, pag, r, c, p, i, w): acc = self.getGenDesc(w) if not acc: return "Invalid Sales Code" self.sales = w self.df.loadEntry("T", 0, 4, data=acc[0]) def doCos(self, frt, pag, r, c, p, i, w): acc = self.getGenDesc(w) if not acc: return "Invalid COS Code" self.cos = w self.df.loadEntry("T", 0, 6, data=acc[0]) def doDelete(self): st1 = self.sql.getRec("strmf1", cols=["count(*)"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group)], limit=1) if st1[0]: return "Records Exist for this Group, Not Deleted" self.sql.delRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", self.group)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): if x == 7: break if self.glint == "Y": # Account Names if x in (4, 6): continue elif x == 3: data.append(0) data.append(0) break data.append(self.df.t_work[0][0][x]) if self.new == "Y": self.sql.insRec("strgrp", data=data) elif data != self.acc[:len(data)]: col = self.sql.strgrp_col data.append(self.acc[col.index("gpm_xflag")]) self.sql.updRec("strgrp", data=data, where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", self.group)]) self.sql.delRec("strgmu", where=[("smg_cono", "=", self.opts["conum"]), ("smg_group", "=", self.group)]) if self.automu in ("A", "L"): for lvl, mup in enumerate(self.df.t_work[0][0][x:]): if not mup: continue self.sql.insRec("strgmu", data=[self.opts["conum"], self.group, lvl + 1, mup]) 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 getGenDesc(self, acno): return self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acno)], limit=1) def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doCloseProcess(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class drc510(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, "ctlmes", prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): mss = { "stype": "R", "tables": ("ctlmes", ), "cols": (("mss_system", "", 0, "Sys"), ("mss_message", "", 0, "Mss"), ("mss_detail", "NA", 50, "Details")), "where": [], "index": 1 } r1s = (("Invoice", "I"), ("Statement", "S"), ("Conditions", "C")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Message Type", "", "I", "Y", self.doType, None, None, None), (("T", 0, 1, 0), "IUI", 3, "Message Number", "", "", "N", self.doMes, mss, None, ("notzero", )), (("T", 0, 2, 0), "ITv", (30, 6), "Details", "", "", "N", self.doDetail, None, self.doDelete, None)) but = (("Accept", None, self.doAccept, 0, ("T", 0, 3), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 3), ("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 doType(self, frt, pag, r, c, p, i, w): if w == "I": self.system = "INV" elif w == "S": self.system = "STA" else: self.system = "CON" self.df.loadEntry(frt, pag, p + 1, data=1) self.doMes(frt, pag, r, c + 1, p + 1, i + 1, 1) return "sk1" self.df.topf[pag][1][8]["where"] = [("mss_system", "=", self.system)] def doMes(self, frt, pag, r, c, p, i, w): self.message = w self.acc = self.sql.getRec("ctlmes", where=[("mss_system", "=", self.system), ("mss_message", "=", self.message)], order="mss_message", limit=1) if not self.acc: self.new = "Y" self.df.loadEntry(frt, pag, p + 1, data="") else: self.new = "N" self.detail = self.acc[2] 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, 2) if len(self.detail) > 150: self.df.focusField( "T", 0, 3, 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.acc[:len(data)]: col = self.sql.ctlmes_col data.append(self.acc[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() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class msy020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawScreen() self.opts["mf"].startLoop() def setVariables(self): if self.opts["period"][0] == 0: showError(self.opts["mf"].body, "Year-End Error", "Period 0 Cannot be Changed, Change Period 1 Instead!") return self.sql = Sql(self.opts["mf"].dbm, "ctlynd", prog=self.__class__.__name__) if self.sql.error: return self.pers = self.sql.getRec("ctlynd", where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", ">=", self.opts["period"][0])], order="cye_period") if self.pers[0][self.sql.ctlynd_col.index("cye_final")] == "Y": showError(self.opts["mf"].body, "Year-End Error", "This Period Has Already Been Finalised") return self.s_per = self.pers[0][self.sql.ctlynd_col.index("cye_start")] self.e_per = self.pers[0][self.sql.ctlynd_col.index("cye_end")] self.m_per = self.getEndDate(self.s_per) self.l_per = self.pers[-1][self.sql.ctlynd_col.index("cye_period")] if self.opts["period"][0] == 1 and self.l_per > 1: showError(self.opts["mf"].body, "Year-End Error", "Period 1 Cannot be Changed as Periods > 1 Exist!") return return True def getEndDate(self, date): yr = int(date / 10000) + 1 mt = (int(date / 100) % 100) - 1 if not mt: yr -= 1 mt = 12 return mthendDate(((yr * 10000) + (mt * 100) + 1)) def getStartDate(self, date): yr = int(date / 10000) mt = (int(date / 100) % 100) + 1 if mt > 12: yr += 1 mt = 1 return ((yr * 10000) + (mt * 100) + 1) def drawScreen(self): fld = [ [("T",0,0,0),"I@cye_start",0,"","", self.s_per,"N",self.doStartPer,None,None,("efld",)], (("T",0,1,0),"I@cye_end",0,"","", self.e_per,"N",self.doEndPer,None,None,("efld",))] if self.opts["period"][0] != 1: fld[0][1] = "O@cye_start" fld[0][7] = None tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt, focus=True) if self.opts["period"][0] != 1: self.df.loadEntry("T", 0, 0, data=self.s_per) 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.s_per = w def doEndPer(self, frt, pag, r, c, p, i, w): if w <= self.s_per: return "Invalid Date, Before Start" if int(w / 100) - int(self.s_per / 100) - 87 > 15: return "Invalid Date, More than 15 Months" 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.e_per = w def doEnd(self): self.df.closeProcess() if self.opts["period"][0] == 1: self.sql.updRec("ctlynd", cols=["cye_start", "cye_end"], data=[self.s0, self.e0], where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", 0)]) for per in self.pers: num = per[self.sql.ctlynd_col.index("cye_period")] if num == self.opts["period"][0]: self.start = self.s_per self.end = self.e_per else: self.start = self.getStartDate(self.end) self.end = self.getEndDate(self.start) self.sql.updRec("ctlynd", cols=["cye_start", "cye_end"], data=[self.start, self.end], where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", num)]) spl = SplashScreen(self.opts["mf"].body, text="Running Year End Routine for Period %s" % num) per = getPeriods(self.opts["mf"], self.opts["conum"], num - 1) per = (num - 1, (per[0].work, per[0].disp), (per[1].work, per[1].disp)) callModule(self.opts["mf"], None, "msy010", coy=(self.opts["conum"], self.opts["conam"]), period=per, user=self.opts["capnm"], args="N") spl.closeSplash() self.opts["mf"].dbm.commitDbase(ask=True) self.opts["mf"].closeLoop() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class tdc110(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, ["telgrp", "telmst"], prog=self.__class__.__name__) if self.sql.error: return return True def drawDialog(self): grp = { "stype": "R", "tables": ("telgrp", ), "cols": [("tdg_group", "", 0, "Code"), ("tdg_desc", "", 0, "Description")], "order": "tdg_desc" } self.fld = ((("T", 0, 0, 0), "I@tdg_group", 0, "", "", "", "N", self.doGroup, grp, None, ("notblank", )), (("T", 0, 1, 0), "I@tdg_desc", 0, "", "", "", "N", None, None, self.doDelete, ("notblank", ))) but = (("Quit", None, self.doExit, 1, None, None), ) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doGroup(self, frt, pag, r, c, p, i, w): self.group = w self.acc = self.sql.getRec("telgrp", where=[("tdg_group", "=", self.group)], limit=1) if not self.acc: self.new = True else: self.new = False des = self.acc[self.sql.telgrp_col.index("tdg_desc")] self.df.loadEntry(frt, pag, p + 1, data=des) def doDelete(self): chk = self.sql.getRec("telmst", cols=["tdm_group"], where=[("tdm_group", "<>", "")]) if chk: err = None for c in chk: d = c[0].split(",") if self.group in d: err = "Group In Use, Not Deleted" if err: return err self.sql.delRec("telgrp", where=[("tdg_group", "=", self.group)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [] 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("telgrp", data=data) elif data != self.acc[:len(data)]: col = self.sql.telgrp_col data.append(self.acc[col.index("tdg_xflag")]) self.sql.updRec("telgrp", data=data, where=[("tdg_group", "=", self.group)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bcc210(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", "bwlclb", "bwlflo"], prog=self.__class__.__name__) if self.sql.error: return acc = self.sql.getRec("bwlclb", where=[("bcc_code", "=", self.opts["conum"])], limit=1) if not acc: self.sql.insRec("bwlclb", data=[self.opts["conum"], self.opts["conam"]]) self.opts["mf"].dbm.commitDbase() return True def mainProcess(self): clb = { "stype": "R", "tables": ("bwlclb",), "cols": ( ("bcc_code", "", 0, "Cod"), ("bcc_name", "", 0, "Name", "Y")), "order": "bcc_name"} fld = ( (("T",0,0,0),"I@bcc_code",0,"","", "","Y",self.doClbCod,clb,None,("efld",)), (("T",0,1,0),"I@bcc_name",0,"","", "","N",self.doName,None,self.doDelete,("notblank",))) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt) def doClbCod(self, frt, pag, r, c, p, i, w): if not w: self.club = getNextCode(self.sql, "bwlclb", "bcc_code", last=999) self.df.loadEntry(frt, pag, p, data=self.club) else: self.club = w self.old = self.sql.getRec("bwlclb", where=[("bcc_code", "=", self.club)], limit=1) if not self.old: self.newclb = True else: self.newclb = False for num, fld in enumerate(self.old[:-1]): self.df.loadEntry(frt, pag, num, data=fld) def doName(self, frt, pag, r, c, p, i, w): if self.newclb: chk = self.sql.getRec("bwlclb", where=[("bcc_name", "ilike", w)]) if chk: return "A Club with this Name Already Exists" def doDelete(self): if self.newclb: return if self.club == self.opts["conum"]: return "Cannot Delete Own Club" error = False for tab in (("bwlflo", "bfo_cono", "bfo_club"),): chk = self.sql.getRec(tables=tab[0], where=[(tab[1], "=", self.opts["conum"]), (tab[2], "=", self.club)], limit=1) if chk: error = True break if error: return "There are Entries for this Club, Not Deleted" self.sql.delRec("bwlclb", where=[("bcc_code", "=", self.club)]) self.opts["mf"].dbm.commitDbase() def doEnd(self): data = self.df.t_work[0][0][:] if self.newclb: self.sql.insRec("bwlclb", data=data) elif data != self.old[:len(data)]: col = self.sql.bwlclb_col data.append(self.old[col.index("bcc_xflag")]) self.sql.updRec("bwlclb", data=data, where=[("bcc_code", "=", self.club)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class ln2020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) lonctl = gc.getCtl("lonctl", self.opts["conum"]) if not lonctl: return glint = lonctl["cln_glint"] tab = ["lonctl", "lonmf2", "lontrn"] if glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["lon_ctl", "int_rec", "int_pay"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.glctl = ( ctlctl["lon_ctl"], ctlctl["int_rec"], ctlctl["int_pay"]) tab.append("gentrn") else: self.glctl = None self.sql = Sql(self.opts["mf"].dbm, tables=tab, prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] yr = int(self.sysdtw / 10000) mt = (int(self.sysdtw / 100) % 100) - 1 self.lme = mthendDate((yr * 10000) + (mt * 100) + 1) return True def dataHeader(self): fld = ( (("T",0,0,0),"ID1",10,"Transaction Date","", self.lme,"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): self.trdate = w if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if w != mthendDate(w): return "Invalid Date, Not a Month End" def endPage0(self): self.df.closeProcess() recs = self.sql.getRec("lonmf2", where=[("lm2_cono", "=", self.opts["conum"]), ("lm2_start", "<", self.trdate)], order="lm2_acno, lm2_loan") p = ProgressBar(self.opts["mf"].body, mxs=len(recs)) for num, lonmf2 in enumerate(recs): p.displayProgress(num) batch = "L%s" % int(self.trdate / 100) LoanInterest("L", self.opts["mf"].dbm, lonmf2, update="Y", tdate=self.trdate, batch=batch, curdt=int(self.trdate / 100), refno=True, glctl=self.glctl, capnm=self.opts["capnm"]) p.closeProgress() self.sql.updRec("lonctl", cols=["cln_last"], data=[self.trdate], where=[("cln_cono", "=", self.opts["conum"])]) self.opts["mf"].dbm.commitDbase() self.opts["mf"].closeLoop() def exitPage0(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class mlc310(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 = "MEM" 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.oldm = self.sql.getRec("ctlmes", where=[("mss_system", "=", self.system), ("mss_message", "=", self.message)], order="mss_message", limit=1) if not self.oldm: self.new = "Y" self.df.loadEntry(frt, pag, p + 1, data="") else: self.new = "N" self.detail = self.oldm[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.oldm[:len(data)]: col = self.sql.ctlmes_col data.append(self.oldm[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 si6010(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, ["drsmst", "slsiv1"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): iv1 = { "stype": "R", "tables": ("drsmst", "slsiv1"), "cols": (("si1_docno", "", 0, "Inv-Numbr"), ("si1_date", "", 0, "Invoice-Dt"), ("si1_chain", "", 0, "Chn"), ("si1_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name"), ("si1_cus_ord", "", 0, "Cust-Ord-Num")), "where": [("si1_cono", "=", self.opts["conum"]), ("si1_rtn", "=", "I"), ("si1_invno", "<>", "cancel"), ("drm_cono=si1_cono", ), ("drm_chain=si1_chain", ), ("drm_acno=si1_acno", )], "order": "si1_docno" } fld = ((("T", 0, 0, 0), "IUI", 9, "Invoice Number", "", "", "Y", self.doInvNum, iv1, None, ("notzero", )), (("T", 0, 1, 0), "O@si1_date", 0, ""), (("T", 0, 2, 0), "O@si1_chain", 0, ""), (("T", 0, 3, 0), "O@si1_acno", 0, ""), (("T", 0, 4, 0), "O@drm_name", 0, ""), (("T", 0, 5, 0), "I@si1_cus_ord", 0, "", "", "", "N", self.doNewOrd, None, None, ("efld", ))) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt) def doInvNum(self, frt, pag, r, c, p, i, w): whr = [("si1_cono", "=", self.opts["conum"]), ("si1_rtn", "=", "I"), ("si1_docno", "=", w), ("drm_cono=si1_cono", ), ("drm_chain=si1_chain", ), ("drm_acno=si1_acno", )] acc = self.sql.getRec(tables=["slsiv1", "drsmst"], cols=[ "si1_date", "si1_chain", "si1_acno", "drm_name", "si1_cus_ord" ], where=whr, limit=1) if not acc: return "Invalid Invoice Number" self.invno = w for n, a in enumerate(acc): self.df.loadEntry(frt, pag, p + 1 + n, data=a) def doNewOrd(self, frt, pag, r, c, p, i, w): self.ordno = w def doEnd(self): self.sql.updRec("slsiv1", cols=["si1_cus_ord"], data=[self.ordno], where=[("si1_cono", "=", self.opts["conum"]), ("si1_rtn", "=", "I"), ("si1_docno", "=", self.invno)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class gl1030(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"]) ctlsys = gc.getCtl("ctlsys") if not ctlsys: return self.dep = ctlsys["sys_gl_dep"] self.dig = ctlsys["sys_gl_dig"] self.sql = Sql(self.opts["mf"].dbm, ["genmst", "genrpt"], prog=self.__class__.__name__) if self.sql.error: return self.genrpt_fd = self.sql.genrpt_dic self.genrpt_cl = self.sql.genrpt_col self.pags = ["","Q","H","L","G","S","T","U","C","P"] self.head = ["glr_desc", "glr_high", "glr_ffeed", "glr_ignore"] self.ledger = [ "glr_from", "glr_to", "glr_high", "glr_obal", "glr_accum", "glr_print", "glr_norm", "glr_acbal", "glr_ignore", "glr_store", "glr_snum1", "glr_acstr"] self.group = [ "glr_group", "glr_desc", "glr_from", "glr_to", "glr_high", "glr_obal", "glr_accum", "glr_print", "glr_norm", "glr_acbal", "glr_ignore", "glr_store", "glr_snum1", "glr_acstr", "glr_label"] self.store = [ "glr_desc", "glr_high", "glr_print", "glr_norm", "glr_acbal", "glr_clear", "glr_snum1", "glr_strper"] self.total = [ "glr_desc", "glr_high", "glr_total", "glr_print", "glr_norm", "glr_clear", "glr_store", "glr_snum1", "glr_acstr", "glr_label"] self.uline = ["glr_high", "glr_uline"] self.calc = [ "glr_desc", "glr_high", "glr_cbase", "glr_ctype", "glr_snum2", "glr_camnt", "glr_snum3"] self.percent = ["glr_desc", "glr_high", "glr_snum1", "glr_snum2"] return True def mainProcess(self): data = [ ("H","Heading"), ("L","Ledger Accounts"), ("G","Group of Accounts"), ("S","Stored Amount"), ("T","Total"), ("U","Underline"), ("C","Calculation"), ("P","Percentage")] typ = { "stype": "C", "titl": "Select the Required Type", "head": ("T", "Description"), "data": data} coy = { "stype": "R", "tables": ("ctlmst",), "cols": ( ("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Description", "Y")), "order": "ctm_cono"} glr = { "stype": "R", "tables": ("genrpt",), "cols": ( ("glr_cono", "", 0, "Coy"), ("glr_repno", "", 0, "Rep"), ("glr_type", "", 0, "T"), ("glr_desc", "", 0, "Description", "Y")), "where": [("glr_seq", "=", 0)], "whera": (("T", "glr_cono", 0, 0),), "order": "glr_cono, glr_repno", "index": 1} gls = { "stype": "R", "tables": ("genrpt",), "cols": ( ("glr_seq", "", 0, "Seq"), ("glr_type", "", 0, "T"), ("glr_group", "", 0, "Grp"), ("glr_from", "", 0, "From-Ac"), ("glr_to", "", 0, " To-Ac"), ("glr_desc", "", 0, "Description", "Y")), "where": [("glr_seq", ">", 0)], "whera": (("T", "glr_cono", 0, 0),("T", "glr_repno", 1, 0))} self.glm = { "stype": "C", "titl": "Account Numbers", "head": ("Number", "Description"), "data": []} ryn = (("Yes","Y"),("No","N")) rys = (("Yes","Y"),("No","N"),("Debit","+"),("Credit","-")) rns = (("Positive","P"),("Negative","N")) ras = (("Add","A"),("Subtract","S")) rat = (("Add","A"),("Subtract","S"),("Ignore","I")) rcb = (("Percentage","P"),("Amount","A"),("Store","S")) rct = (("Plus","+"),("Minus","-"),("Multiply","*"),("Divide","/")) rsd = (("Single","S"),("Double","D"),("Blank","B")) pts = ( "Accumulate Month Values", "Add, Subtract or Ignore", "Calculation Base", "Calculation Type", "Clear Stored Value", "Clear Total", "Highlight", "Ignore Account Type", "Include Opening Balance", "Normal Sign", "Percentage of Stored Value", "Print Values", "Store Amount", "Add or Subtract") tag = [ ("Sequence",None,None,None,False), ("Heading",None,None,None,False), ("Ledger",None,None,None,False), ("Group",None,None,None,False), ("Stored",None,None,None,False), ("Total",None,None,None,False), ("Uline",None,None,None,False), ("Calc",None,None,None,False), ("Percent",None,None,None,False)] fld = ( (("T",0,0,0),"IUI",3,"Company","Company Number, 0=All", self.opts["conum"],"Y",self.doCoyNum,coy,None, ("in", (self.opts["conum"], 0))), (("T",0,0,0),"IUI",3,"Report","Report Number", "","N",self.doRepNum,glr,None,("notzero",)), (("T",0,0,0),"IUA",1,"Type","Report Type (B, P, O)", "P","N",self.doRepTyp,None,self.doDelRpt, ("in", ("O","P","B"))), (("T",0,0,0),"INA",30,"Heading","Report Heading", "","N",None,None,None,("notblank",)), (("T",1,0,0),"IUD",7.2,"Seq-Num","Sequence Number", "","N",self.doSeqNum,gls,None,("efld",)), (("T",1,1,0),"IUA",1,"Sequence Type","", "","N",self.doSeqType,typ,self.doDelSeq, ("in",("H","L","G","T","S","U","P","C"))), (("T",2,0,0),"INA",30,"Description","", "","N",None,None,None,("notblank",)), (("T",2,1,0),("IRB",ryn),0,pts[6],"", "Y","N",None,None,None,None), (("T",2,2,0),("IRB",ryn),0,"New Page","New Page (Y/N)", "N","N",None,None,None,None), (("T",2,3,0),("IRB",ryn),0,pts[7],"", "N","N",None,None,None,None), (("T",3,0,0),"IUI",7,"From Account","From Account Number", "","N",self.doAcno,self.glm,None,("notzero",)), (("T",3,1,0),"IUI",7,"To Account","To Account Number", "","N",self.doAcno,self.glm,None,("efld",)), (("T",3,2,0),("IRB",ryn),0,pts[6],"", "N","N",None,None,None,None), (("T",3,3,0),("IRB",ryn),0,pts[8],"", "Y","N",None,None,None,None), (("T",3,4,0),("IRB",ryn),0,pts[0],"", "N","N",None,None,None,None), (("T",3,5,0),("IRB",rys),0,pts[11],"", "Y","N",None,None,None,None), (("T",3,6,0),("IRB",rns),0,pts[9],"", "P","N",None,None,None,None), (("T",3,7,0),("IRB",rat),0,pts[1],"", "A","N",None,None,None,None), (("T",3,8,0),("IRB",ryn),0,pts[7],"", "N","N",None,None,None,None), (("T",3,9,0),("IRB",ryn),0,pts[12],"", "N","N",self.doStore,None,None,None), (("T",3,10,0),"IUI",2,"Storage Number","", "","N",None,None,None,("notzero",)), (("T",3,11,0),("IRB",ras),0,pts[13],"", "A","N",None,None,None,None), (("T",4,0,0),"IUI",3,"Group Number","", "","N",self.doGrpNum,None,None,("efld",)), (("T",4,1,0),"INA",30,"Description","", "","N",None,None,None,("notblank",)), (("T",4,2,0),"IUI",7,"From Account","From Account Number", "","N",self.doAcno,self.glm,None,("notzero",)), (("T",4,3,0),"IUI",7,"To Account","To Account Number", "","N",self.doAcno,self.glm,None,("efld",)), (("T",4,4,0),("IRB",ryn),0,pts[6],"", "N","N",None,None,None,None), (("T",4,5,0),("IRB",ryn),0,pts[8],"", "Y","N",None,None,None,None), (("T",4,6,0),("IRB",ryn),0,pts[0],"", "N","N",None,None,None,None), (("T",4,7,0),("IRB",rys),0,pts[11],"", "Y","N",None,None,None,None), (("T",4,8,0),("IRB",rns),0,pts[9],"", "P","N",None,None,None,None), (("T",4,9,0),("IRB",rat),0,pts[1],"", "A","N",None,None,None,None), (("T",4,10,0),("IRB",ryn),0,pts[7],"", "N","N",None,None,None,None), (("T",4,11,0),("IRB",ryn),0,pts[12],"", "N","N",self.doStore,None,None,None), (("T",4,12,0),"IUI",2,"Storage Number","", "","N",None,None,None,("notzero",)), (("T",4,13,0),("IRB",ras),0,pts[13],"", "A","N",None,None,None,None), (("T",4,14,0),"INA",10,"Chart Label","", "","N",None,None,None,None), (("T",5,0,0),"INA",30,"Description","", "","N",None,None,None,("notblank",)), (("T",5,1,0),("IRB",ryn),0,pts[6],"", "N","N",None,None,None,None), (("T",5,2,0),("IRB",rys),0,pts[11],"", "Y","N",None,None,None,None), (("T",5,3,0),("IRB",rns),0,pts[9],"", "P","N",None,None,None,None), (("T",5,4,0),("IRB",rat),0,pts[1],"", "A","N",None,None,None,None), (("T",5,5,0),("IRB",ryn),0,pts[4],"", "N","N",None,None,None,None), (("T",5,6,0),"IUI",2,"Storage Number","", "","N",None,None,None,("notzero",)), (("T",5,7,0),"IUD",6.2,pts[10],"", 0,"N",None,None,None,("notzero",)), (("T",6,0,0),"INA",30,"Description","", "","N",None,None,None,("efld",)), (("T",6,1,0),("IRB",ryn),0,pts[6],"", "Y","N",None,None,None,None), (("T",6,2,0),"IUI",1,"Total Level","", "","N",None,None,None,("between",1,9)), (("T",6,3,0),("IRB",rys),0,pts[11],"", "Y","N",None,None,None,None), (("T",6,4,0),("IRB",rns),0,pts[9],"", "P","N",None,None,None,None), (("T",6,5,0),("IRB",ryn),0,pts[5],"", "Y","N",None,None,None,None), (("T",6,6,0),("IRB",ryn),0,pts[12],"", "N","N",self.doStore,None,None,None), (("T",6,7,0),"IUI",2,"Storage Number","", "","N",None,None,None,("notzero",)), (("T",6,8,0),("IRB",ras),0,pts[13],"", "A","N",None,None,None,None), (("T",6,9,0),"INA",10,"Chart Label","", "","N",None,None,None,None), (("T",7,0,0),("IRB",ryn),0,pts[6],"", "Y","N",None,None,None,None), (("T",7,1,0),("IRB",rsd),0,"Underline Type","", "S","N",None,None,None,None), (("T",8,0,0),"INA",30,"Description","", "","N",None,None,None,("notblank",)), (("T",8,1,0),("IRB",ryn),0,pts[6],"", "N","N",None,None,None,None), (("T",8,2,0),("IRB",rcb),0,pts[2],"", "A","N",self.doPAS,None,None,None), (("T",8,3,0),("IRB",rct),0,pts[3],"", "+","N",None,None,None,None), (("T",8,4,0),"IUI",2,"Storage Number (Base)","", "","N",self.doStore1,None,None,("notzero",)), (("T",8,5,0),"ISD",13.2,"Amount","Percent/Amount", "","N",self.doAmount,None,None,("efld",)), (("T",8,6,0),"IUI",2,"Storage Number (Calc)","", "","N",None,None,None,("efld",)), (("T",9,0,0),"INA",30,"Description","", "","N",None,None,None,("notblank",)), (("T",9,1,0),("IRB",ryn),0,pts[6],"", "N","N",None,None,None,None), (("T",9,2,0),"IUI",2,"Storage Number (Base)","", "","N",None,None,None,("notzero",)), (("T",9,3,0),"IUI",2,"Storage Number (Calc)","", "","N",None,None,None,("notzero",))) tnd = ( (self.doT0End,"y"), (self.doT1End,"n"), (self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y")) txt = ( self.doT0Exit, self.doT1Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit) but = ( ("Import",None,self.doImpRpt,0,("T",0,1),("T",0,2)), ("Export",None,self.doExpRpt,0,("T",0,3),(("T",0,2),("T",0,4))), ("Copy",None,self.doCpyRpt,0,("T",0,3),(("T",0,2),("T",0,4))), ("Re-Sequence",None,self.doReSeq,0,("T",1,1),("T",1,2),None,1), ("Preview",None,self.doPreview,0,("T",1,1),("T",1,2),None,1), ("Print",None,self.doPrint,0,("T",1,1),("T",1,2),None,1)) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, tags=tag, butt=but) def doCoyNum(self, frt, pag, r, c, p, i, w): self.selcoy = w if self.selcoy == 0: acc = self.sql.getRec("genmst", cols=["glm_acno", "glm_desc"], group="glm_acno, glm_desc", order="glm_acno") else: acc = self.sql.getRec("genmst", cols=["glm_acno", "glm_desc"], where=[("glm_cono", "=", self.selcoy)], group="glm_acno, glm_desc", order="glm_acno") if self.dep == "Y": dep = {} chs = 10 ** (7 - self.dig) for a in acc: dep[a[0] % chs] = a[1] acc = [] for a in dep: acc.append([a, dep[a]]) acc.sort() self.glm["data"] = acc def doRepNum(self, frt, pag, r, c, p, i, w): self.repno = w rep = self.doReadRep(self.selcoy, self.repno, 0) if not rep: self.newrep = True self.df.setWidget(self.df.B1, "normal") else: self.newrep = False self.df.setWidget(self.df.B1, "disabled") self.df.loadEntry(frt, pag, p+1, data=rep[3]) self.df.loadEntry(frt, pag, p+2, data=rep[4]) def doRepTyp(self, frt, pag, r, c, p, i, w): self.df.setWidget(self.df.B1, "disabled") def doImpRpt(self): self.df.setWidget(self.df.B0, state="disabled") self.df.setWidget(self.df.mstFrame, state="hide") sel = FileDialog(parent=self.opts["mf"].body, title="Import File", initd=self.opts["mf"].rcdic["wrkdir"], ftype=[("Report", "*.rpt")]) nam = sel.askopenfilename() err = None if nam: fle = open(nam, "r") for num, line in enumerate(fle): dat = line.split("|") if not num: if dat[0] != "genrpt": err = "This File Does Not Contain a Valid Format" break chk = self.sql.getRec("genrpt", where=[("glr_cono", "=", dat[1]), ("glr_repno", "=", dat[2]), ("glr_seq", "=", 0)], limit=1) if chk: ok = askQuestion(self.opts["mf"].body, "Replace?", "This Report Already Exists, Would you like "\ "to Replace It?") if ok == "yes": self.sql.delRec("genrpt", where=[("glr_cono", "=", dat[1]), ("glr_repno", "=", dat[2])]) else: err = "Report Already Exists" break self.sql.insRec("genrpt", data=dat[1:]) else: self.sql.insRec(dat[0], data=dat[1:]) if not err: self.opts["mf"].dbm.commitDbase(ask=True) else: showError(self.opts["mf"].body, "Invalid Import", err) self.df.setWidget(self.df.mstFrame, "show") self.df.focusField("T", 0, 1) def doExpRpt(self): fle = open(os.path.join(self.opts["mf"].rcdic["wrkdir"], "C%s_R%s.rpt" % (self.selcoy, self.repno)), "w") rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq") for lin in rpt: mes = "genrpt" for dat in lin: mes = "%s|%s" % (mes, str(dat)) fle.write("%s\n" % mes) fle.close() self.df.focusField("T", 0, 1) def doCpyRpt(self): if not self.newrep: showError(self.opts["mf"].body, "Invalid Copy Request", "You can only Copy a report when Creating a New report, "\ "not when Changing an Existing report!") self.df.focusField("T", 0, 3) return tit = ("Copy Existing Report Layout",) coy = { "stype": "R", "tables": ("ctlmst",), "cols": ( ("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))} glr = { "stype": "R", "tables": ("genrpt",), "cols": ( ("glr_cono", "", 0, "Coy"), ("glr_repno", "", 0, "Rep"), ("glr_type", "", 0, "T"), ("glr_desc", "", 0, "Description", "Y")), "where": [("glr_seq", "=", 0)], "whera": (("T", "glr_cono", 0, 0),), "index": 1} fld = ( (("T",0,0,0),"IUI",3,"Company Number","", "","N",self.doCpyCoy,coy,None,None), (("T",0,1,0),"IUI",3,"Report Number","", "","N",self.doRptNum,glr,None,None)) state = self.df.disableButtonsTags() self.cp = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doCpyEnd, "n"),), txit=(self.doCpyExit,)) self.cp.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField("T", 0, 1) def doCpyCoy(self, frt, pag, r, c, p, i, w): self.cpycoy = w def doRptNum(self, frt, pag, r, c, p, i, w): self.cpynum = w def doCpyEnd(self): rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=", self.cpycoy), ("glr_repno", "=", self.cpynum)]) if rpt: for rec in rpt: rec[0] = self.selcoy rec[1] = self.repno self.sql.insRec("genrpt", data=rec) self.opts["mf"].dbm.commitDbase() self.doCpyCloseProcess() def doCpyExit(self): self.doCpyCloseProcess() def doCpyCloseProcess(self): self.cp.closeProcess() def doDelRpt(self): self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doT0End(self): rtype = self.df.t_work[0][0][2] desc = self.df.t_work[0][0][3] if self.newrep: data = [self.selcoy, self.repno, 0, rtype, desc] for x in range(5, len(self.genrpt_cl)): if self.genrpt_fd[self.genrpt_cl[x]][2][1] in ("A", "a"): data.append("") else: data.append(0) self.sql.insRec("genrpt", data=data) else: self.sql.updRec("genrpt", cols=["glr_type", "glr_desc"], data=[rtype, desc], where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno), ("glr_seq", "=", 0)]) self.df.selPage("Sequence") self.df.focusField("T", 1, 1) def doReSeq(self): whr = [("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)] recs = self.sql.getRec("genrpt", where=whr, order="glr_seq") self.sql.delRec("genrpt", where=whr) for seq, rec in enumerate(recs): rec = list(rec) rec[2] = float(seq) self.sql.insRec("genrpt", data=rec) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doPreview(self): self.cols = [ ("a", "Seq-Num", 7.2, "UD"), ("b", "T", 1, "UA"), ("c", "Grp", 3, "Na"), ("d", "Lvl", 3, "Na"), ("e", "Acc-Num", 7, "Na"), ("f", "Description", 30, "NA")] self.data = [] self.newp = [] recs = self.sql.getRec("genrpt", where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq") pgp = 0 lsq = 0 rpc = self.sql.genrpt_col for num, rec in enumerate(recs): seq = rec[rpc.index("glr_seq")] rtp = rec[rpc.index("glr_type")] if rtp in ("B", "P", "O"): self.titl = rec[rpc.index("glr_desc")] continue des = rec[rpc.index("glr_desc")] prt = rec[rpc.index("glr_print")] if prt == "N": continue if rtp == "H": if rec[rpc.index("glr_ffeed")] == "Y": self.data.append((seq, "N", "", "", "", "---------- New Page ----------")) elif lsq: ptp = recs[lsq][rpc.index("glr_type")] utp = recs[lsq][rpc.index("glr_uline")] if ptp == "H" or (ptp == "U" and utp == "B"): pass else: self.data.append((seq, "", "", "", "", "")) self.data.append((seq, rtp, "", "", "", des)) self.data.append((seq, "", "", "", "", "")) elif rtp == "L": frm = rec[rpc.index("glr_from")] too = rec[rpc.index("glr_to")] whr = [("glm_cono", "=", self.selcoy)] if too: whr.append(("glm_acno", "between", frm, too)) else: whr.append(("glm_acno", "=", frm)) accs = self.sql.getRec("genmst", cols=["glm_acno", "glm_desc"], where=whr, order="glm_acno") for acc in accs: self.data.append((seq, rtp, "", "", acc[0], acc[1])) elif rtp == "G": grp = rec[rpc.index("glr_group")] if not pgp or grp != pgp: self.data.append((seq, rtp, grp, "", "", des)) pgp = grp elif rtp == "T": tot = rec[rpc.index("glr_total")] self.data.append((seq, rtp, "", tot, "", des)) elif rtp == "S": self.data.append((seq, rtp, "", "", "", des)) elif rtp == "U": utp = rec[rpc.index("glr_uline")] if utp == "B": des = "" elif utp == "S": des = "-" * 30 else: des = "=" * 30 self.data.append((seq, rtp, "", "", "", des)) else: continue lsq = num self.pprt = False self.sc = SelectChoice(self.opts["mf"].window, self.titl, self.cols, self.data, sort=False, butt=(("Print", self.doPrePrt),)) if self.pprt: cols = [] for col in self.cols: cols.append([col[0], col[3], col[2], col[1], "y"]) state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, "hide") RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=self.data, heads=[self.titl], cols=cols, ttype="D", prtdia=(("Y","V"),("Y","N"))) self.df.setWidget(self.df.mstFrame, "show") self.df.enableButtonsTags(state=state) self.df.focusField("T", 1, 1) elif self.sc.selection: self.df.doKeyPressed("T", 1, 0, self.sc.selection[1]) self.df.doKeyPressed("T", 1, 1, self.sc.selection[2]) else: self.df.focusField("T", 1, 1) def doPrePrt(self): self.pprt = True def doPrint(self): table = ["genrpt"] heads = ["General Ledger Report %s Layout" % self.repno] state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, "hide") RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=table, heads=heads, where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq asc", prtdia=(("Y","V"), ("Y","N"))) self.df.setWidget(self.df.mstFrame, "show") self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doSeqNum(self, frt, pag, r, c, p, i, w): if not w: acc = self.sql.getRec("genrpt", cols=["max(glr_seq)"], where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)], limit=1) if not acc: w = 1 else: w = int(acc[0] + 1) self.df.loadEntry(frt, pag, i, data=w) self.seqno = w self.seq = self.doReadRep(self.selcoy, self.repno, self.seqno) if not self.seq: self.newseq = "y" else: self.newseq = "n" self.df.loadEntry(frt, pag, p+1, data=self.seq[3]) def doSeqType(self, frt, pag, r, c, p, i, w): self.stype = w if self.newseq == "y": return if self.stype == self.seq[3]: return yn = askQuestion(self.opts["mf"].body, "Change Type?", "Change the Type?", default="no") if yn == "no": return "No Change" self.newseq = "c" def doDelSeq(self): if self.newseq == "y": showError(self.opts["mf"].body, "Invalid Delete Request", "You can only delete Existing report lines.") return self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno), ("glr_seq", "=", self.seqno)]) self.df.clearFrame("T", 1) self.df.focusField("T", 1, 1) return "nf" def doT1End(self): for x in range(2, 10): self.df.clearFrame("T", x) pag = self.pags.index(self.stype) if self.newseq == "n": cl = self.genrpt_cl fld = self.doLoadTypes() for x, f in enumerate(fld): data = self.seq[cl.index(f)] self.df.loadEntry("T", pag, x, data=data) self.df.selPage(self.df.tags[pag - 1][0]) def doAcno(self, frt, pag, r, c, p, i, w): if w: if pag == 3 and p == 1 and w < self.df.t_work[pag][0][0]: return "To Account Less Than From Account" if pag == 4 and p == 3 and w < self.df.t_work[pag][0][2]: return "To Account Less Than From Account" found = False for acc in self.glm["data"]: if w == acc[0]: found = True if not found: return "Invalid Account Number" def doStore(self, frt, pag, r, c, p, i, w): if w == "N": self.df.loadEntry(frt, pag, p+1, data=0) self.df.loadEntry(frt, pag, p+2, data="") return "sk2" def doGrpNum(self, frt, pag, r, c, p, i, w): if not w: gno = self.sql.getRec("genrpt", cols=["max(glr_group)"], where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno), ("glr_type", "=", "G")], limit=1) self.gno = gno[0] + 1 self.df.loadEntry(frt, pag, p, data=self.gno) else: self.gno = w col = ["glr_desc", "glr_high", "glr_obal", "glr_accum", "glr_print", "glr_norm", "glr_acbal", "glr_ignore", "glr_store", "glr_snum1", "glr_acstr", "glr_label"] grp = "" for cc in col: grp = "%s%s," % (grp, cc) grp = grp[:-1] self.grp = self.sql.getRec("genrpt", cols=col, where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno), ("glr_group", "=", self.gno)], group=grp) if self.grp: for n, f in enumerate(col): data = self.grp[0][n] self.df.loadEntry("T", pag, self.group.index(f), data=data) def doPAS(self, frt, pag, r, c, p, i, w): self.pas = w if self.pas == "P": self.df.loadEntry(frt, pag, p+1, data="*") return "sk1" def doStore1(self, frt, pag, r, c, p, i, w): if self.pas == "S": self.df.loadEntry(frt, pag, p+1, data=0) return "sk1" def doAmount(self, frt, pag, r, c, p, i, w): self.df.loadEntry(frt, pag, p+1, data=0) return "sk1" def doT2End(self): ff = self.doLoadTypes() data = [self.selcoy, self.repno, self.seqno, self.stype] for nm, cl in enumerate(self.genrpt_cl): if nm < 4: continue if cl in ff: data.append(self.df.t_work[self.pags.index(self.stype)] [0][ff.index(cl)]) elif self.genrpt_fd[cl][2][1] in ("A", "a"): data.append("") else: data.append(0) data.append("") if self.newseq in ("c", "n"): self.doDelSeq() self.sql.insRec("genrpt", data=data) if self.stype == "G" and self.grp: grp = self.sql.getRec("genrpt", where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno), ("glr_group", "=", self.gno)], order="glr_seq") for g in grp: if g[2] == self.seqno: continue data[2] = g[2] data[8] = g[8] data[9] = g[9] data[29] = g[29] self.sql.updRec("genrpt", data=data, where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno), ("glr_group", "=", self.gno), ("glr_seq", "=", g[2])]) self.doT2Exit() if self.newseq == "y": self.df.loadEntry("T", 1, 0, data=(self.seqno + 1)) else: self.df.clearEntry("T", 1, 1) self.df.clearEntry("T", 1, 2) self.df.focusField("T", 1, 1) def doLoadTypes(self): if self.stype == "H": fld = self.head elif self.stype == "L": fld = self.ledger elif self.stype == "G": fld = self.group elif self.stype == "S": fld = self.store elif self.stype == "T": fld = self.total elif self.stype == "U": fld = self.uline elif self.stype == "C": fld = self.calc elif self.stype == "P": fld = self.percent return fld def doT0Exit(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doT1Exit(self): # Check for duplicate group numbers errmess = """Group Number %s at Sequence Line %s is Duplicated or is Not Contiguous i.e. All Group Lines Must Follow One Another! Please Delete, or Correct This Line!""" seq = self.sql.getRec("genrpt", cols=["glr_type", "glr_seq", "glr_group"], where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq") gp = [] lg = 0 for t, s, g in seq: if t == "G": if not lg and g in gp: showError( self.opts["mf"].body, "Group Error", errmess % (g, s)) self.df.loadEntry("T", 1, 0, data=s) self.df.focusField("T", 1, 1) return if lg and lg != g: if g in gp: showError(self.opts["mf"].body, "Group Error", errmess % (g, s)) self.df.loadEntry("T", 1, 0, data=s) self.df.focusField("T", 1, 1) return lg = g gp.append(g) continue if not lg: lg = g gp.append(g) continue else: lg = 0 self.opts["mf"].dbm.commitDbase(ask=True, mess="Save All Changes?") self.df.focusField("T", 0, 1) def doT2Exit(self): self.df.selPage("Sequence") def doReadRep(self, coy, rep, seq): rep = self.sql.getRec("genrpt", where=[("glr_cono", "=", coy), ("glr_repno", "=", rep), ("glr_seq", "=", seq)], limit=1) return rep
class st2030(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.exit = False self.setPrinter() if not self.exit: self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "genmst", "gentrn", "strgrp", "strmf1", "strmf2", "strtrn", "strrcp" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.locs = strctl["cts_locs"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["stk_soh", "stk_susp"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.stk_soh = ctlctl["stk_soh"] self.stk_susp = ctlctl["stk_susp"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] if self.locs == "N": self.loc = "1" self.glnum = 0 return True def setPrinter(self): tit = ("Printer Selection", ) self.pr = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=[], tend=((self.doPrtEnd, "y"), ), txit=(self.doPrtExit, ), view=("N", "P")) self.opts["mf"].startLoop() def doPrtEnd(self): self.doPrtClose() def doPrtExit(self): self.exit = True self.doPrtClose() def doPrtClose(self): self.pr.closeProcess() self.opts["mf"].closeLoop() 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_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "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 } 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), "INa", 9, "Issue Number", "", "", "N", self.doIss, None, None, ("notblank", )), (("T", 0, 0, 0), "ID1", 10, "Date", "Issue Date", self.sysdtw, "N", self.doDte, None, None, ("efld", )), (("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "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", 5, "U.O.I"), (("C", 0, 0, 3), "IUA", 1, "L", "Location", "r", "N", self.doLoc, stl, None, ("notblank", )), (("C", 0, 0, 4), "ISD", 9.2, "Quantity", "", "", "N", self.doQty, None, None, ("notzero", )), (("C", 0, 0, 5), "OUD", 9.2, "Unit-Cost"), (("C", 0, 0, 6), "OSD", 9.2, "Value")] if self.glint == "Y": fld.append( (("C", 0, 0, 7), "IUI", 7, "G/L-Acc", "G/L Account Number", self.stk_susp, "N", self.doGenAcc, glm, None, None)) fld.append((("C", 0, 0, 8), "ONA", 10, "Desc")) fld.append((("C",0,0,9),"INA",(20,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, ) but = (("Reprint", None, self.doReprint, 0, ("T", 0, 1), None), ) self.df = TartanDialog(self.opts["mf"], eflds=fld, rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doIss(self, frt, pag, r, c, p, i, w): self.iss = 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.ddt = self.df.t_disp[pag][0][p] self.curdt = int(self.dte / 100) self.batno = "S%s" % self.curdt def doGroup(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.group = w def doCode(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_desc", "st1_type", "st1_uoi"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", w), ("st1_type", "<>", "X")], limit=1) if not acc: return "Invalid or Redundant Code" self.code = w self.desc = acc[0] self.gtype = acc[1] self.df.loadEntry(frt, pag, p + 1, data=acc[2]) if self.locs == "N": self.loc = "1" self.df.loadEntry("C", pag, p + 2, data=self.loc) no = self.checkLoc() if no: return no else: return "sk2" def doLoc(self, frt, pag, r, c, p, i, w): self.loc = w no = self.checkLoc() if no: return no def checkLoc(self): acc = self.sql.getRec("strmf2", cols=["st2_bin"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Location For This Product" def doQty(self, frt, pag, r, c, p, i, w): self.quant = w if self.gtype == "R" and self.doRecipe(): return "ff2" if self.extractCost(): return "rf" self.df.loadEntry("C", pag, p + 1, data=self.ucost) self.df.loadEntry("C", pag, p + 2, data=self.tcost) def doRecipe(self): self.recipe = self.sql.getRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc)], order="srr_rgroup, srr_rcode") if not self.recipe: err = "Invalid Recipe, No Items" showError(self.opts["mf"].body, "Recipe Error", err) return err else: return self.doRecChg() def doRecChg(self): # Display recipe items and allow editing of quantities etc. data = [] for num, item in enumerate(self.recipe): st1 = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", item[4]), ("st1_code", "=", item[5])], limit=1) err = False if not st1: err = "Invalid Stock Record in Recipe" elif st1[0] == "X": err = "Redundant Stock Record in Recipe" if err: showError( self.opts["mf"].body, "Recipe Error", """%s! Group: %s Code: %s""" % (err, item[4], item[5])) return err data.append([num, item[4], item[5], st1[1], item[6]]) titl = "Recipe Items" head = ("Seq", "Grp", "Product-Code", "Description", "Quantity") lin = { "stype": "C", "titl": titl, "head": head, "typs": [("UI", 2), ("NA", 3), ("NA", 20), ("NA", 30), ("SD", 11.2)], "data": data } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus( "Select a Product to Edit or Exit to Continue") chg = self.df.selChoice(lin) if chg and chg.selection: self.recchg = chg.selection self.doRecChanges() self.doRecChg() else: self.df.enableButtonsTags(state=state) def doRecChanges(self): tit = ("Change Items", ) fld = ((("T", 0, 0, 0), "ONA", 3, "Group"), (("T", 0, 1, 0), "ONA", 20, "Code"), (("T", 0, 2, 0), "ONA", 30, "Description"), (("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N", self.doRecQty, None, None, ('notzero', ))) but = (("Delete", None, self.doRecDel, 1, None, None), ) self.rp = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doRecEnd, "n"), ), txit=(self.doRecExit, )) self.rp.loadEntry("T", 0, 0, data=self.recchg[1]) self.rp.loadEntry("T", 0, 1, data=self.recchg[2]) self.rp.loadEntry("T", 0, 2, data=self.recchg[3]) self.rp.loadEntry("T", 0, 3, data=self.recchg[4]) self.rp.focusField("T", 0, 4, clr=False) self.rp.mstFrame.wait_window() def doRecQty(self, frt, pag, r, c, p, i, w): self.recqty = w def doRecDel(self): del self.recipe[int(self.recchg[0])] self.doRecExit() def doRecEnd(self): self.recipe[int(self.recchg[0])][6] = self.recqty self.doRecExit() def doRecExit(self): self.rp.closeProcess() 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.glnum = w self.df.loadEntry("C", pag, p + 1, data=chk[0]) def doTrnDet(self, frt, pag, r, c, p, i, w): if not w: self.trndet = self.desc else: 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): if self.df.col != 1: self.doPrintDoc(self.pr.repprt) self.df.focusField("T", 0, 1) def extractCost(self): self.ucost = 0 self.tcost = 0 if self.gtype == "R": for item in self.recipe: quant = item[6] * self.quant tcost = self.doCalCost(item[4], item[5], quant) if tcost is None: return "error" self.tcost = float(ASD(self.tcost) + ASD(tcost)) else: tcost = self.doCalCost(self.group, self.code, self.quant) if tcost is None: return "error" self.tcost = tcost self.ucost = round(self.tcost / self.quant, 2) def updateTables(self): if self.gtype == "R": # Issue individual items for item in self.recipe: acc = self.sql.getRec("strmf1", cols=["st1_desc"], where=[("st1_cono", "=", item[0]), ("st1_group", "=", item[4]), ("st1_code", "=", item[5])], limit=1) if acc: des = acc[0] else: des = "Unknown Description" qty = item[6] * self.quant tcost = self.doCalCost(item[4], item[5], qty, chk=False) qty = float(ASD(0) - ASD(qty)) val = float(ASD(0) - ASD(tcost)) data = [ self.opts["conum"], item[4], item[5], self.loc, self.dte, 6, self.iss, self.batno, self.glnum, qty, val, 0, self.curdt, des, 0, "", "", "STR", 0, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) # Receive recipe item data = [ self.opts["conum"], self.group, self.code, self.loc, self.dte, 5, self.iss, self.batno, self.glnum, self.quant, self.tcost, 0, self.curdt, self.desc, 0, "", "", "STR", 0, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) # Stores Ledger Transaction qty = float(ASD(0) - ASD(self.quant)) val = float(ASD(0) - ASD(self.tcost)) data = [ self.opts["conum"], self.group, self.code, self.loc, self.dte, 2, self.iss, self.batno, self.glnum, qty, val, 0, self.curdt, self.desc, 0, "", "", "STR", 0, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) if self.glint == "N": return col = self.sql.gentrn_col # General Ledger Control Transaction (Stock On Hand) acc = self.sql.getRec("gentrn", where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.stk_soh), ("glt_curdt", "=", self.curdt), ("glt_trdt", "=", self.dte), ("glt_type", "=", 4), ("glt_refno", "=", self.iss), ("glt_batch", "=", self.batno)], limit=1) if acc: amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(val)) self.sql.updRec("gentrn", cols=["glt_tramt"], data=[amnt], where=[("glt_seq", "=", acc[col.index("glt_seq")]) ]) else: self.sql.insRec("gentrn", data=[ self.opts["conum"], self.stk_soh, self.curdt, self.dte, 4, self.iss, self.batno, val, 0, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ]) # General Ledger Transaction (Expense) acc = self.sql.getRec("gentrn", where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.glnum), ("glt_curdt", "=", self.curdt), ("glt_trdt", "=", self.dte), ("glt_type", "=", 4), ("glt_refno", "=", self.iss), ("glt_batch", "=", self.batno)], limit=1) if acc: amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(self.tcost)) self.sql.updRec("gentrn", cols=["glt_tramt"], data=[amnt], where=[("glt_seq", "=", acc[col.index("glt_seq")]) ]) else: self.sql.insRec("gentrn", data=[ self.opts["conum"], self.glnum, self.curdt, self.dte, 4, self.iss, self.batno, self.tcost, 0, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ]) def doCalCost(self, grp, code, qty, chk=True): # Calculate cost price icost, tcost, bal = getCost(self.sql, self.opts["conum"], grp, code, loc=self.loc, qty=qty, tot=True, bal=True) if chk and qty > bal[0]: acc = self.sql.getRec("strmf1", cols=["st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", grp), ("st1_code", "=", code)], limit=1) cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="ExQty", product=(grp, code, acc[0])) if cf.flag == "no": return return tcost def doReprint(self): tit = ("Reprint Documents", ) data = self.sql.getRec("strtrn", cols=["stt_ref1", "stt_trdt"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 2)], group="stt_ref1, stt_trdt", order="stt_trdt, stt_ref1") iss = { "stype": "R", "tables": ("strtrn", ), "cols": (("stt_ref1", "", 0, "Reference"), ("stt_trdt", "", 0, "Date", "Y")), "wtype": "D", "where": data, "screen": self.opts["mf"].body, "comnd": self.doSelRec } isd = { "stype": "R", "tables": ("strtrn", ), "cols": (("stt_trdt", "", 0, "Date"), ), "where": [("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 2)], "whera": (("T", "stt_ref1", 0, 0), ), "group": "stt_trdt", "order": "stt_trdt", "screen": self.opts["mf"].body } fld = ((("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N", self.doRepIss, iss, None, ("notblank", )), (("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N", self.doRepDte, isd, None, ("notzero", ))) state = self.df.disableButtonsTags() self.tx = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doRepEnd, "n"), ), txit=(self.doRepExit, ), view=("N", "V"), mail=("Y", "N")) self.tx.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doSelRec(self, frt, pag, r, c, p, i, w): self.tx.doKeyPressed(frt, pag, p, w[0]) self.tx.doKeyPressed(frt, pag, p + 1, w[1]) def doRepIss(self, frt, pag, r, c, p, i, w): self.iss = w def doRepDte(self, frt, pag, r, c, p, i, w): self.dte = w self.ddt = self.df.t_disp[pag][0][p] acc = self.sql.getRec("strtrn", cols=["count(*)"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 2), ("stt_ref1", "=", self.iss), ("stt_trdt", "=", self.dte)], limit=1) if not acc[0]: return "No Document Found" def doRepEnd(self): self.tx.closeProcess() self.doPrintDoc(self.tx.repprt) def doRepExit(self): self.tx.closeProcess() def doPrintDoc(self, repprt): hds = [ "Goods Issued Notes", "GIN Number: %s GIN Date: %s" % (self.iss, self.ddt) ] tab = ["strmf1", "strtrn"] col = [["stt_group", "UA", 3, "Grp", "y"], ["stt_code", "NA", 20, "Product-Code", "y"], ["stt_desc", "NA", 40, "Description", "y"], ["stt_loc", "UA", 1, "L", "y"], ["stt_qty", "SD", 11.2, "Quantity", "y", "y"], ["stt_cost", "SD", 11.2, "Price", "y", "y"]] gtt = ["stt_cost"] whr = [("stt_cono", "=", self.opts["conum"]), ("stt_type", "in", (2, 6)), ("stt_ref1", "=", self.iss), ("stt_trdt", "=", self.dte), ("st1_cono=stt_cono", ), ("st1_group=stt_group", ), ("st1_code=stt_code", ), ("st1_type", "<>", "R")] odr = "stt_seq" self.df.setWidget(self.df.mstFrame, state="hide") RepPrt(self.opts["mf"], conum=self.opts["conum"], conam=self.opts["conam"], name=self.__class__.__name__, tables=tab, heads=hds, cols=col, gtots=gtt, where=whr, order=odr, repprt=repprt) self.df.setWidget(self.df.mstFrame, state="show")
class bkc310(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] bkmctl = gc.getCtl("bkmctl", self.opts["conum"]) if not bkmctl: return self.glint = bkmctl["cbk_glint"] self.sql = Sql( self.opts["mf"].dbm, ["ctlvmf", "genmst", "bkmmst", "bkmunm", "bkmrtm", "bkmrtt"], prog=self.__class__.__name__) if self.sql.error: return return True def drawDialog(self): unm = { "stype": "R", "tables": ("bkmunm", ), "cols": [("bum_code", "", 0, "Code"), ("bum_desc", "", 0, "Description"), ("bum_room", "", 0, "Rms"), ("bum_maxg", "", 0, "Qty"), ("bum_dflt", "", 0, "Rte")], "where": [("bum_cono", "=", self.opts["conum"])], "whera": (("T", "bum_btyp", 0, 0), ), "order": "bum_btyp, bum_code" } if self.glint == "Y": unm["cols"].append(("bum_slsa", "", 0, "Acc-Num")) rte = { "stype": "R", "tables": ("bkmrtm", ), "cols": (("brm_code", "", 0, "Cod"), ("brm_desc", "", 0, "Description"), ("brm_base", "", 0, "B")), "where": [], "order": "brm_type, brm_code" } vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } r1s = (("Accomodation", "A"), ("Other", "O")) self.fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Booking Type", "", "A", "N", self.doBtype, None, None, None), (("T", 0, 1, 0), "IUA", 6, "Unit Code", "", "", "N", self.doUcode, unm, None, ("notblank", )), (("T", 0, 2, 0), "ITX", 30, "Description", "", "", "N", self.doUDesc, None, self.doDelete, ("notblank", )), (("T", 0, 3, 0), "IUI", 3, "Number of Rooms", "", 0, "N", self.doURooms, None, None, ("efld", )), (("T", 0, 4, 0), "IUI", 3, "Total Capacity", "", 0, "N", None, None, None, ("notzero", )), (("T", 0, 5, 0), "IUI", 3, "Default Rate", "", 0, "N", self.doUrate, rte, None, ("notzero", )), (("T", 0, 6, 0), "IUA", 1, "V.A.T. Code", "", self.taxdf, "N", self.doVat, vtm, None, ("notblank", ))] if self.glint == "Y": self.fld.extend([(("T", 0, 7, 0), "IUI", 7, "Sales Account", "", "", "N", self.doSales, glm, None, ("notzero", )), (("T", 0, 7, 0), "ONA", 30, "")]) but = (("Quit", None, self.doExit, 1, None, None), ) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doBtype(self, frt, pag, r, c, p, i, w): self.btyp = w self.df.topf[0][5][8]["where"] = [("brm_cono", "=", self.opts["conum"]), ("brm_type", "=", self.btyp)] def doUcode(self, frt, pag, r, c, p, i, w): self.ucod = w self.unm = self.sql.getRec("bkmunm", where=[("bum_cono", "=", self.opts["conum"]), ("bum_btyp", "=", self.btyp), ("bum_code", "=", self.ucod)], limit=1) if not self.unm: self.new = True else: self.new = False des = self.unm[self.sql.bkmunm_col.index("bum_desc")] rms = self.unm[self.sql.bkmunm_col.index("bum_room")] qty = self.unm[self.sql.bkmunm_col.index("bum_maxg")] vcd = self.unm[self.sql.bkmunm_col.index("bum_vatc")] dfr = self.unm[self.sql.bkmunm_col.index("bum_dflt")] sls = self.unm[self.sql.bkmunm_col.index("bum_slsa")] self.df.loadEntry(frt, pag, p + 1, data=des) self.df.loadEntry(frt, pag, p + 2, data=rms) self.df.loadEntry(frt, pag, p + 3, data=qty) self.df.loadEntry(frt, pag, p + 4, data=dfr) self.df.loadEntry(frt, pag, p + 5, data=vcd) if self.glint == "Y": self.df.loadEntry(frt, pag, p + 6, data=sls) des = self.getGenDesc(sls) if not des: self.df.loadEntry(frt, pag, p + 7, data="Invalid Sales Code") else: self.df.loadEntry(frt, pag, p + 7, data=des[0]) def doUDesc(self, frt, pag, r, c, p, i, w): self.udes = w if self.btyp == "O": self.urms = 0 self.df.loadEntry(frt, pag, p + 1, data=self.urms) return "sk1" def doURooms(self, frt, pag, r, c, p, i, w): if self.btyp == "A" and not w: return "Invalid Number of Rooms" self.urms = w def doUrate(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("bkmrtm", where=[("brm_cono", "=", self.opts["conum"]), ("brm_type", "=", self.btyp), ("brm_code", "=", w)], limit=1) if not acc: return "Invalid Rate Code" def doVat(self, frt, pag, r, c, p, i, w): vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) if not vat: return "Invalid VAT Code" def doSales(self, frt, pag, r, c, p, i, w): acc = self.getGenDesc(w) if not acc: return "Invalid Sales Code" self.sales = w self.df.loadEntry("T", 0, p + 1, data=acc[0]) def getGenDesc(self, acno): return self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acno)], limit=1) def doDelete(self): chk = self.sql.getRec("bkmrtt", where=[("brt_cono", "=", self.opts["conum"]), ("brt_utype", "=", self.btyp), ("brt_ucode", "=", self.ucod)]) if chk: return "Unit Used, Not Deleted" self.sql.delRec("bkmunm", where=[("bum_cono", "=", self.opts["conum"]), ("bum_btyp", "=", self.btyp), ("bum_code", "=", self.ucod)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): if self.glint == "Y" and x == 8: continue data.append(self.df.t_work[0][0][x]) if self.glint == "N": data.append(0) if self.new: self.sql.insRec("bkmunm", data=data) elif data != self.unm[:len(data)]: col = self.sql.bkmunm_col data.append(self.unm[col.index("bum_xflag")]) self.sql.updRec("bkmunm", data=data, where=[("bum_cono", "=", self.opts["conum"]), ("bum_btyp", "=", self.btyp), ("bum_code", "=", self.ucod)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class lnc110(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return mods = ctlmst["ctm_modules"] self.genleg = False for x in range(0, len(mods), 2): if mods[x:x + 2] == "GL": self.genleg = True break tabs = ["lonctl", "tplmst", "chglog"] if self.genleg: tabs.extend(["ctlctl", "genmst"]) self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return self.acc = self.sql.getRec("lonctl", where=[("cln_cono", "=", self.opts["conum"]) ], limit=1) if not self.acc: self.new = True self.acc = [ self.opts["conum"], "N", "D", "A", "A", 0, 0, 0, "statement_loan", "", "" ] else: self.new = False if self.genleg: self.ctl = [["lon_ctl", "Loans Control", 0], ["int_rec", "Interest Received", 0], ["int_pay", "Interest Paid", 0]] ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return for num, ctl in enumerate(self.ctl): if ctl[0] in ctlctl: self.ctl[num][2] = ctlctl[ctl[0]] return True def drawDialog(self): tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")), "where": [("tpm_type", "=", "S"), ("tpm_system", "=", "LON")], "order": "tpm_tname" } r1s = (("Yes", "Y"), ("No", "N")) r2s = (("Daily", "D"), ("Monthly", "M")) r3s = (("Anniversary", "A"), ("Financial", "F")) r4s = (("Annual", "A"), ("Bi-Annual", "B")) if self.genleg: glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30, "Description")), "where": [("glm_cono", "=", self.opts["conum"])] } fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "", self.acc[1], "N", self.doGlint, None, None, None), (("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "", self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 1, 0), "ONA", 30, ""), (("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "", self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 2, 0), "ONA", 30, ""), (("T", 0, 3, 0), "IUI", 7, self.ctl[2][1], "", self.ctl[2][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 3, 0), "ONA", 30, "")] seq = 4 else: fld = [] seq = 0 fld.extend([ (("T", 0, seq, 0), ("IRB", r2s), 0, "Interest Method", "", self.acc[2], "N", None, None, None, None), (("T", 0, seq + 1, 0), ("IRB", r3s), 0, "Capitalisation Base", "", self.acc[3], "N", None, None, None, None), (("T", 0, seq + 2, 0), ("IRB", r4s), 0, "Capitalisation Freq", "", self.acc[4], "N", None, None, None, None), (("T", 0, seq + 3, 0), "IUD", 6.2, "Debit Rate", "", self.acc[5], "N", None, None, None, ("efld", )), (("T", 0, seq + 4, 0), "IUD", 6.2, "Credit Rate", "", self.acc[6], "N", None, None, None, ("efld", )), (("T", 0, seq + 5, 0), "Id1", 10.0, "Last Interest Date", "", self.acc[7], "N", None, None, None, ("efld", )), (("T", 0, seq + 6, 0), "INA", 20, "Statement Template", "", self.acc[8], "N", self.doTplNam, tpm, None, ("efld", )), (("T", 0, seq + 7, 0), "ITX", 50, "Email Address", "", self.acc[9], "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=fld, butt=but, tend=tnd, txit=txt) if not self.new: s = 0 for n, f in enumerate(self.acc[1:-1]): if not self.genleg and not n: continue self.df.loadEntry("T", 0, s, data=f) s += 1 if n == 0: for c in self.ctl: self.df.loadEntry("T", 0, s, data=c[2]) s += 1 self.df.loadEntry("T", 0, s, data=self.getDes(c[2])) s += 1 self.df.focusField("T", 0, 1, clr=False) def doGlint(self, frt, pag, r, c, p, i, w): if w == "N": for x in range(1, 7): self.df.loadEntry(frt, pag, p + x, data="") return "sk6" def doGenAcc(self, frt, pag, r, c, p, i, w): des = self.getDes(w) if not des: return "Invalid Account Number" self.df.loadEntry(frt, pag, p + 1, data=des) def getDes(self, acno): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acno)], limit=1) if acc: return acc[0] else: return "" def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "S"), ("tpm_system", "=", "LON")], limit=1) if not acc: return "Invalid Template" def doEnd(self): data = [self.opts["conum"]] if not self.genleg: data.append("N") for x, d in enumerate(self.df.t_work[0][0]): if self.genleg and x < 7: if x in (1, 3, 5): y = int((x - 1) / 2) chk = self.sql.getRec("ctlctl", where=[("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "=", self.ctl[y][0])], limit=1) if chk: self.sql.updRec("ctlctl", cols=["ctl_conacc"], data=[d], where=[("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "=", self.ctl[y][0])]) else: self.sql.insRec("ctlctl", data=[ self.opts["conum"], self.ctl[y][0], self.ctl[y][1], d, "", "N", "N" ]) elif x in (2, 4, 6): continue else: data.append(d) else: data.append(d) if self.new: self.sql.insRec("lonctl", data=data) elif data != self.acc[:len(data)]: col = self.sql.lonctl_col data.append(self.acc[col.index("cln_xflag")]) self.sql.updRec("lonctl", data=data, where=[("cln_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=[ "lonctl", "U", "%03i" % self.opts["conum"], col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.doExit() def 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 doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bk2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, tables=[ "bkmmst", "bkmcon", "bkmrtt", "bkmtrn", "bkmunm", "ctlmst", "ctlvtf", "gentrn", "tplmst" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) ctl = gc.getCtl("ctlmst", self.opts["conum"]) if not ctl: return for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3", "ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_taxdf", "ctm_tel", "ctm_fax", "ctm_b_name", "ctm_b_ibt", "ctm_b_acno", "ctm_logo"): setattr(self, "%s" % col, ctl[col]) if self.ctm_logo and "LETTERHEAD" in os.environ: self.ctm_logo = os.environ["LETTERHEAD"] if not self.ctm_logo or not os.path.exists(self.ctm_logo): self.ctm_logo = None bkmctl = gc.getCtl("bkmctl", self.opts["conum"]) if not bkmctl: return self.glint = bkmctl["cbk_glint"] self.tplnam = bkmctl["cbk_invtpl"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["vat_ctl", "bkm_ctl"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.vatctl = ctlctl["vat_ctl"] self.bkmctl = ctlctl["bkm_ctl"] t = time.localtime() self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2]) return True def mainProcess(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Booking Invoices (%s)" % self.__class__.__name__) tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title", "Y")), "where": [("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")], "order": "tpm_tname" } r1s = (("Yes", "Y"), ("No", "N")) r2s = (("Singles", "S"), ("All", "A")) fld = ((("T", 0, 0, 0), "Id1", 10, "Starting Date", "", 0, "Y", self.doSDate, None, None, ("efld", )), (("T", 0, 1, 0), "ID1", 10, "Ending Date", "", self.sysdtw, "Y", self.doEDate, None, None, ("efld", )), (("T", 0, 2, 0), ("IRB", r1s), 0, "Include Queries", "", "N", "Y", self.doBkmQry, None, None, None), (("T", 0, 3, 0), ("IRB", r2s), 0, "Bookings", "", "S", "Y", self.doBkmDoc, None, None, None), (("T", 0, 4, 0), "INA", 20, "Template Name", "", self.tplnam, "N", self.doTplNam, tpm, None, None)) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, tend=tnd, txit=txt, view=("N", "V"), mail=("N", "Y")) def doSDate(self, frt, pag, r, c, p, i, w): self.sdate = w def doEDate(self, frt, pag, r, c, p, i, w): self.edate = w def doBkmQry(self, frt, pag, r, c, p, i, w): self.bkmqry = w def doBkmDoc(self, frt, pag, r, c, p, i, w): self.bkmdoc = w def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")], limit=1) if not acc: return "Invalid Template Name" self.tname = w def doEnd(self): self.df.closeProcess() tab = ["bkmmst", "bkmcon", "bkmrtt"] col = ["bkm_number", "bkc_sname", "bkc_names", "bkm_arrive"] whr = [("bkm_cono", "=", self.opts["conum"])] if self.bkmqry == "N": whr.append(("bkm_state", "in", ("C", "S"))) else: whr.append(("bkm_state", "in", ("C", "Q", "S"))) whr.extend([("bkm_arrive", "between", self.sdate, self.edate), ("bkc_cono=bkm_cono", ), ("bkc_ccode=bkm_ccode", ), ("brt_cono=bkm_cono", ), ("brt_number=bkm_number", ), ("brt_invno", "=", 0)]) grp = "bkm_number, bkm_arrive, bkm_ccode, bkc_sname, bkc_names" odr = "bkm_arrive, bkm_ccode" dic = {} for c in col: for t in tab: d = getattr(self.sql, "%s_dic" % t) if c in d: dic[c] = d[c] if self.bkmdoc == "S": recs = self.sql.getRec(tables=tab, cols=col, where=whr, group=grp, order=odr) recs = getSingleRecords(self.opts["mf"], tab, col, dic=dic, where=recs, ttype="D") else: recs = self.sql.getRec(tables=tab, cols=col, where=whr, group=grp, order=odr) docs = [] for rec in recs: # Raise the Invoice bkno = rec[0] trdt = rec[3] incamt = 0 vatamt = 0 curdt = int(trdt / 100) batno = "B%s" % curdt gls = {} trns = self.sql.getRec("bkmrtt", where=[("brt_cono", "=", self.opts["conum"]), ("brt_number", "=", bkno), ("brt_invno", "=", 0)]) if not trns: continue invno = self.getRef(bkno) for trn in trns: utyp = trn[self.sql.bkmrtt_col.index("brt_utype")] ucod = trn[self.sql.bkmrtt_col.index("brt_ucode")] rcod = trn[self.sql.bkmrtt_col.index("brt_rcode")] rbas = trn[self.sql.bkmrtt_col.index("brt_rbase")] quan = trn[self.sql.bkmrtt_col.index("brt_quant")] rate = trn[self.sql.bkmrtt_col.index("brt_arate")] days = trn[self.sql.bkmrtt_col.index("brt_bdays")] umst = self.sql.getRec("bkmunm", where=[("bum_cono", "=", self.opts["conum"]), ("bum_btyp", "=", utyp), ("bum_code", "=", ucod)], limit=1) vatc = umst[self.sql.bkmunm_col.index("bum_vatc")] if not vatc: vatc = self.ctm_taxdf vrte = getVatRate(self.sql, self.opts["conum"], vatc, trdt) if vrte is None: vrte = 0.0 if rbas == "A": inca = quan * days * rate elif rbas == "B": inca = quan * rate elif rbas == "C": inca = days * rate else: inca = rate vata = round(inca * vrte / (100 + vrte), 2) exca = float(ASD(inca) - ASD(vata)) incamt = float(ASD(incamt) + ASD(inca)) vatamt = float(ASD(vatamt) - ASD(vata)) if self.glint == "Y": slsa = umst[self.sql.bkmunm_col.index("bum_slsa")] if slsa not in gls: gls[slsa] = [0, 0, vatc] gls[slsa][0] = float(ASD(gls[slsa][0]) - ASD(exca)) gls[slsa][1] = float(ASD(gls[slsa][1]) - ASD(vata)) data = [ self.opts["conum"], bkno, 2, invno, batno, trdt, inca, vata, curdt, "Booking %s-%s Raised" % (utyp, ucod), vatc, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("bkmtrn", data=data) self.sql.updRec("bkmrtt", cols=["brt_vrate", "brt_invno", "brt_invdt"], data=[vrte, invno, trdt], where=[("brt_cono", "=", self.opts["conum"]), ("brt_number", "=", bkno), ("brt_utype", "=", utyp), ("brt_ucode", "=", ucod), ("brt_rcode", "=", rcod)]) if vata: exc = float(ASD(0) - ASD(exca)) vat = float(ASD(0) - ASD(vata)) data = [ self.opts["conum"], vatc, "O", curdt, "B", 1, batno, invno, trdt, bkno, "Booking %s" % bkno, exc, vat, 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("ctlvtf", data=data) if self.glint == "Y": data = [ self.opts["conum"], self.bkmctl, curdt, trdt, 1, invno, batno, incamt, 0, "Booking %s" % bkno, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) for acc in gls: data = [ self.opts["conum"], acc, curdt, trdt, 1, invno, batno, gls[acc][0], gls[acc][1], "Booking %s" % bkno, gls[acc][2], "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) if gls[acc][1]: data = [ self.opts["conum"], self.vatctl, curdt, trdt, 1, invno, batno, gls[acc][1], 0, "Booking %s" % bkno, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) if invno not in docs: docs.append(invno) self.opts["mf"].dbm.commitDbase() if docs: PrintBookingInvoice(self.opts["mf"], self.opts["conum"], self.opts["conam"], "I", docs, tname=self.tname, repprt=self.df.repprt, repeml=self.df.repeml, copy="O") self.doExit() def getRef(self, bkno): rec = self.sql.getRec("bkmtrn", cols=["max(bkt_refno)"], where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number", "=", bkno), ("bkt_refno", "like", "%7s%s" % (bkno, "%"))], limit=1) if not rec or not rec[0]: num = 1 else: num = int(rec[0][-2:]) + 1 return "%7s%02i" % (bkno, num) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class drc610(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["drsact", "drsmst"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): act = { "stype": "R", "tables": ("drsact", ), "cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0, "Description", "Y")) } self.fld = ((("T", 0, 0, 0), "IUA", 3, "Code", "Business Activity Code", "", "N", self.doAct, act, None, ("notblank", )), (("T", 0, 1, 0), "INA", 30, "Description", "", "", "N", None, None, self.doDelete, ("notblank", ))) but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None)) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doAct(self, frt, pag, r, c, p, i, w): self.code = w self.acc = self.sql.getRec("drsact", where=[("dac_code", "=", self.code)], limit=1) if not self.acc: self.new = "Y" else: self.new = "N" desc = self.acc[self.sql.drsact_col.index("dac_desc")] self.df.loadEntry(frt, pag, p + 1, data=desc) def doDelete(self): acc = self.sql.getRec("drsmst", cols=["count(*)"], where=[("drm_bus_activity", "=", self.code)], limit=1) if acc[0]: return "Code in Use, Not Deleted" self.sql.delRec("drsact", where=[("dac_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [] for x in range(0, len(self.df.t_work[0][0])): data.append(self.df.t_work[0][0][x]) if self.new == "Y": self.sql.insRec("drsact", data=data) elif data != self.acc[:len(data)]: col = self.sql.drsact_col data.append(self.acc[col.index("dac_xflag")]) self.sql.updRec("drsact", data=data, where=[("dac_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 bc6030(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, ["bwlcmp", "bwlent", "bwlgme", "bwlrnd", "bwltyp", "bwlpts", "bwlfls", "bwlflm", "bwlflt", "bwlflo"], prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.today = ((t[0] * 10000) + (t[1] * 100) + t[2]) return True def mainProcess(self): r1s = (("Yes", "Y"), ("No", "N")) r2s = (("No", "N"), ("All", "A"), ("Unplayed", "U")) fld = ( (("T",0,0,0),("IRB",r1s),0,"Tabs-Inn","", "N","Y",self.doTabs,None,None,None), (("T",0,1,0),("IRB",r1s),0,"League","", "N","N",self.doLeague,None,None,None), (("T",0,2,0),("IRB",r2s),0,"Competition Entries","", "N","N",self.doComps,None,None,None), (("T",0,3,0),("IRB",r1s),0,"Competition Types","", "N","N",self.doTypes,None,None,None)) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt) def doTabs(self, frt, pag, r, c, p, i, w): self.tabs = w def doLeague(self, frt, pag, r, c, p, i, w): self.league = w def doComps(self, frt, pag, r, c, p, i, w): self.comps = w def doTypes(self, frt, pag, r, c, p, i, w): self.types = w def doEnd(self): self.df.closeProcess() if self.tabs == "Y": self.sql.delRec("bwldrm", where=[("bdm_cono", "=", self.opts["conum"])]) self.sql.delRec("bwldrt", where=[("bdt_cono", "=", self.opts["conum"])]) if self.league == "Y": self.sql.delRec("bwlfls", where=[("bfs_cono", "=", self.opts["conum"])]) self.sql.delRec("bwlflm", where=[("bfm_cono", "=", self.opts["conum"])]) self.sql.delRec("bwlflt", where=[("bft_cono", "=", self.opts["conum"])]) self.sql.delRec("bwlflo", where=[("bfo_cono", "=", self.opts["conum"])]) delc = [] delt = [] if self.comps in ("A", "U"): tabs = [ ("bwlcmp", "bcm_cono", "bcm_code"), ("bwlcmp", "bcm_cono", "bcm_poff"), ("bwlent", "bce_cono", "bce_ccod"), ("bwlgme", "bcg_cono", "bcg_ccod"), ("bwlrnd", "bcr_cono", "bcr_ccod")] whr = [("bcm_cono", "=", self.opts["conum"])] if self.comps == "U": whr.append(("bcm_date", "<=", self.today)) comps = self.sql.getRec("bwlcmp", cols=["bcm_code"], where=whr, order="bcm_code") if self.comps == "A": for comp in comps: delc.append(comp[0]) elif self.comps == "U": col = ["sum(bcg_sfor)", "sum(bcg_sagt)", "sum(bcg_points)"] for comp in comps: chk = self.sql.getRec("bwlgme", cols=col, where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", comp[0])], limit=1) if not chk: delc.append(comp[0]) continue if not chk[0] and not chk[1] and not chk[2]: delc.append(comp[0]) if delc: for tab in tabs: whr = [(tab[1], "=", self.opts["conum"])] if self.comps == "U": whr.append((tab[2], "in", delc)) self.sql.delRec(tab[0], where=whr) if self.comps == "U": # Renumber competitions comps = self.sql.getRec("bwlcmp", where=[("bcm_cono", "=", self.opts["conum"])], order="bcm_code") self.sql.delRec("bwlcmp", where=[("bcm_cono", "=", self.opts["conum"])]) for num, dat in enumerate(comps): ccod = num + 1 nrec = dat[:] nrec[1] = ccod self.sql.insRec("bwlcmp", data=nrec) for tab in tabs[1:]: self.sql.updRec(tab[0], cols=[tab[2]], data=[ccod], where=[(tab[1], "=", self.opts["conum"]), (tab[2], "=", dat[1])]) if self.types == "Y": typs = self.sql.getRec("bwltyp", cols=["bct_code"], where=[("bct_cono", "=", self.opts["conum"])]) for typ in typs: cnt = self.sql.getRec("bwlcmp", cols=["count(*)"], where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_type", "=", typ[0])], limit=1) if not cnt[0]: delt.append(typ[0]) self.sql.delRec("bwltyp", where=[("bct_cono", "=", self.opts["conum"]), ("bct_code", "=", typ[0])]) self.sql.delRec("bwlpts", where=[("bcp_cono", "=", self.opts["conum"]), ("bcp_code", "=", typ[0])]) # Renumber types types = self.sql.getRec("bwltyp", where=[("bct_cono", "=", self.opts["conum"])], order="bct_code") self.sql.delRec("bwltyp", where=[("bct_cono", "=", self.opts["conum"])]) for num, dat in enumerate(types): ctyp = num + 1 nrec = dat[:] nrec[1] = ctyp self.sql.insRec("bwltyp", data=nrec) self.sql.updRec("bwlpts", cols=["bcp_code"], data=[ctyp], where=[("bcp_cono", "=", self.opts["conum"]), ("bcp_code", "=", dat[1])]) self.sql.updRec("bwlcmp", cols=["bcm_type"], data=[ctyp], where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_type", "=", dat[1])]) if self.types == "Y" and delt: mess = "Delete (%s) Types" % len(delt) else: mess = "" if self.comps in ("A", "U") and delc: mess = "%s\nDelete (%s) Competitions" % (mess, len(delc)) if delt or delc: self.opts["mf"].dbm.commitDbase(ask=True, mess=mess) self.opts["mf"].closeLoop() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class bc2020(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"]) bwlctl = gc.getCtl("bwlctl", self.opts["conum"]) if not bwlctl: return self.nstart = bwlctl["ctb_nstart"] self.fromad = bwlctl["ctb_emadd"] self.sql = Sql(self.opts["mf"].dbm, [ "ctlmst", "bwlclb", "bwlflf", "bwlflm", "bwlflo", "bwltab", "bwlfls", "bwlflt" ], prog=self.__class__.__name__) if self.sql.error: return acc = self.sql.getRec("bwlclb", where=[("bcc_code", "=", self.opts["conum"])]) if not acc: self.sql.insRec("bwlclb", data=[self.opts["conum"], self.opts["conam"]]) self.opts["mf"].dbm.commitDbase() self.reprint = False self.fmat = 0 self.date = 0 self.skip = 0 return True def mainProcess(self): fmt = { "stype": "R", "tables": ("bwlflf", ), "cols": (("bff_code", "", 0, "Cod"), ("bff_desc", "", 0, "Description", "Y")), "where": [("bff_cono", "=", self.opts["conum"])] } sid = { "stype": "R", "tables": ("bwlfls", ), "cols": (("bfs_code", "", 0, "Cod"), ("bfs_desc", "", 0, "Description", "Y"), ("bfs_division", "", 0, "DV")), "where": [("bfs_cono", "=", self.opts["conum"]), ("bfs_active", "=", "Y")], "whera": [("T", "bfs_fmat", 0, 0)], "order": "bfs_desc" } opp = { "stype": "R", "tables": ("bwlflo", ), "cols": (("bfo_code", "", 0, "Cod"), ("bfo_desc", "", 0, "Description", "Y")), "where": [("bfo_cono", "=", self.opts["conum"])], "whera": [("T", "bfo_fmat", 0, 0)], "order": "bfo_desc" } self.plr = { "stype": "R", "tables": ("bwltab", ), "cols": (("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "", 0, "Names")), "where": [], "order": "btb_surname, btb_names" } r1s = (("Fixture", "F"), ("Practice", "P")) fld = ((("T", 0, 0, 0), "I@bfm_fmat", 0, "", "", "", "Y", self.doFmat, fmt, None, ("efld", )), (("T", 0, 0, 0), "ONA", 30, ""), (("T", 0, 1, 0), ("IRB", r1s), 0, "Type", "", "F", "N", self.doType, None, None, None), (("T", 0, 2, 0), "I@bfm_date", 0, "", "", "", "N", self.doDate, None, None, ("efld", )), (("T", 0, 3, 0), "I@bfm_round", 0, "", "", "", "N", self.doRound, None, None, ("notzero", )), (("T", 0, 4, 0), "I@bfm_team", 0, "", "", "", "N", self.doSide, sid, None, None), (("T", 0, 4, 0), "ONA", 20, ""), (("T", 0, 5, 0), "I@bfm_opps", 0, "", "", "", "N", self.doOpp, opp, None, None), (("T", 0, 5, 0), "ONA", 30, ""), (("T", 0, 6, 0), "I@bfm_venue", 0, "Venue (H/A/Name)", "", "", "N", self.doVenue, None, None, ("efld", )), (("T", 0, 7, 0), "IUD", 5.2, "Meeting Time", "", "", "N", self.doMTime, None, None, ("efld", )), (("T", 0, 7, 0), "INA", 20, " At (H/A/Name)", "", "H", "N", self.doMPlace, None, None, ("efld", )), (("T", 0, 8, 0), "I@bfm_captain", 0, "", "", "", "N", self.doCaptain, self.plr, None, ("notzero", )), (("T", 0, 8, 0), "ONA", 30, ""), (("C", 0, 0, 1), "I@bft_skip", 0, "Skp", "", "", "N", self.doSkip, self.plr, None, ("notzero", )), (("C", 0, 0, 2), "ONA", 20, ""), (("C", 0, 0, 3), "I@bft_player", 0, "3rd", "", "", "N", self.doPlayer, self.plr, None, ("notzero", )), (("C", 0, 0, 4), "ONA", 20, ""), (("C", 0, 0, 5), "I@bft_player", 0, "2nd", "", "", "N", self.doPlayer, self.plr, None, ("notzero", )), (("C", 0, 0, 6), "ONA", 20, ""), (("C", 0, 0, 7), "I@bft_player", 0, "1st", "", "", "N", self.doPlayer, self.plr, None, ("notzero", )), (("C", 0, 0, 8), "ONA", 20, "")) but = (("Quit", None, self.doQuit, 1, None, None), ) tnd = ((self.doEnd, "n"), ) txt = (self.doExit, ) cnd = ((self.doEnd, "n"), ) cxt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, rows=[3], butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doFmat(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("bwlflf", where=[("bff_cono", "=", self.opts["conum"]), ("bff_code", "=", w)], limit=1) if not acc: return "Invalid Format" self.fmat = w self.fdes = acc[self.sql.bwlflf_col.index("bff_desc")].upper() self.plr["where"] = [("btb_cono", "=", self.opts["conum"]), ("btb_tab", "<", self.nstart)] gndr = acc[self.sql.bwlflf_col.index("bff_gender")] if gndr in ("F", "M"): self.plr["where"].append(("btb_gender", "=", gndr)) self.assess = acc[self.sql.bwlflf_col.index("bff_assess")] self.df.loadEntry(frt, pag, p + 1, data=self.fdes) def doType(self, frt, pag, r, c, p, i, w): self.ftyp = w def doDate(self, frt, pag, r, c, p, i, w): self.date = w self.disp = "%i %s %i" % (w % 100, mthnam[int(w / 100) % 100][1], int(w / 10000)) acc = self.sql.getRec("bwlflt", cols=["sum(bft_shotsf)"], where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=", self.date)], limit=1) self.reprint = False if acc[0]: self.reprint = True return "xt" if acc[0] == 0: # Edit acc = self.sql.getRec("bwlflm", cols=["bfm_round"], where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp), ("bfm_date", "=", self.date)], limit=1) self.rnd = acc[0] else: # New acc = self.sql.getRec("bwlflm", cols=["max(bfm_date)", "max(bfm_round)"], where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp)], limit=1) if not acc[0] or dateDiff(acc[0], self.date, ptype="months") > 6: self.rnd = 1 else: self.rnd = acc[1] + 1 self.df.loadEntry(frt, pag, p + 1, data=self.rnd) def doRound(self, frt, pag, r, c, p, i, w): if w != self.rnd: ok = askQuestion(self.opts["mf"].body, "Round Change", "The Round Has Been Changed, Please Confirm", default="no") if ok == "no": return "Invalid Round Number" self.sql.updRec("bwlflm", cols=["bfm_round"], data=[w], where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp), ("bfm_date", "=", self.date)]) self.rnd = w def doSide(self, frt, pag, r, c, p, i, w): if not w: if askQuestion(self.opts["mf"].body, "New Side", "Do You Want to Enter a New Side") == "yes": w = self.enterNewSide() self.df.loadEntry(frt, pag, p, data=w) acc = self.sql.getRec("bwlfls", cols=["bfs_desc", "bfs_number"], where=[("bfs_cono", "=", self.opts["conum"]), ("bfs_fmat", "=", self.fmat), ("bfs_code", "=", w), ("bfs_active", "=", "Y")], limit=1) if not acc: return "Invalid Side" self.team = w self.qty = acc[1] self.df.loadEntry(frt, pag, p + 1, data=acc[0]) acc = self.sql.getRec(tables=["bwlflm", "bwlfls", "bwlflo", "bwltab"], cols=[ "bfo_code", "bfo_desc", "bfm_venue", "bfm_mtime", "bfm_mplace", "bfm_captain", "btb_surname", "btb_names" ], where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_date", "=", self.date), ("bfm_team", "=", self.team), ("bfs_cono=bfm_cono", ), ("bfs_fmat=bfm_fmat", ), ("bfs_code=bfm_team", ), ("bfo_cono=bfm_cono", ), ("bfo_fmat=bfm_fmat", ), ("bfo_code=bfm_opps", ), ("btb_cono=bfm_cono", ), ("btb_tab=bfm_captain", )], limit=1) if acc: self.opp = acc[0] self.venue = acc[2] self.mtime = acc[3] self.mplace = acc[4] self.captain = acc[5] for x in range(6): self.df.loadEntry(frt, pag, p + x + 2, data=acc[x]) self.df.loadEntry(frt, pag, p + 8, data=self.getName(acc[6], acc[7])) self.loadPlayers() else: for x in range(c + 2, c + 9): self.df.clearEntry("T", 0, x) self.df.clearFrame("C", 0) # Get previous captain acc = self.sql.getRec( tables=["bwlflm", "bwltab"], cols=["bfm_captain", "btb_surname", "btb_names"], where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_team", "=", self.team), ("btb_cono=bfm_cono", ), ("btb_tab=bfm_captain", )], order="bfm_date desc", limit=1) if acc: self.df.loadEntry("T", 0, 12, data=acc[0]) self.df.loadEntry("T", 0, 13, data=self.getName(acc[1], acc[2])) # Get previous team members col = ["bft_date", "bft_player", "btb_surname", "btb_names"] odr = "bft_date desc, bft_skip, bft_position" acc = self.sql.getRec(tables=["bwlflt", "bwltab"], cols=col, where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_team", "=", self.team), ("btb_cono=bft_cono", ), ("btb_tab=bft_player", )], order=odr) if acc: date = acc[0][0] for num, data in enumerate(acc): if data[0] != date: break pos = num * 2 self.df.loadEntry("C", 0, pos, data=data[1]) self.df.loadEntry("C", 0, pos + 1, data=self.getName(data[2], data[3])) def doOpp(self, frt, pag, r, c, p, i, w): if not w: if askQuestion(self.opts["mf"].body, "New Opponent", "Do You Want to Enter a New Opponent") == "yes": w = self.enterNewOpp() self.df.loadEntry(frt, pag, p, data=w) acc = self.sql.getRec("bwlflm", where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_date", "=", self.date), ("bfm_opps", "=", w), ("bfm_team", "<>", self.team)], limit=1) if acc: return "Invalid Opposition, Already Selected" acc = self.sql.getRec("bwlflo", cols=["bfo_desc"], where=[("bfo_cono", "=", self.opts["conum"]), ("bfo_fmat", "=", self.fmat), ("bfo_code", "=", w)], limit=1) if not acc: return "Invalid Opposition" self.opp = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def loadPlayers(self): acc = self.sql.getRec(tables=["bwlflt", "bwltab"], cols=["bft_player", "btb_surname", "btb_names"], where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=", self.date), ("bft_team", "=", self.team), ("btb_cono=bft_cono", ), ("btb_tab=bft_player", )], order="bft_skip, bft_position") if acc: for num, name in enumerate(acc): pos = num * 2 self.df.loadEntry("C", 0, pos, data=name[0]) self.df.loadEntry("C", 0, pos + 1, data=self.getName(name[1], name[2])) def doVenue(self, frt, pag, r, c, p, i, w): w = w.strip() if len(w.strip()) == 1: w = w.upper() if w not in ("A", "H"): return "Invalid Venue" self.venue = w self.df.loadEntry(frt, pag, p, data=self.venue) if not self.df.t_work[0][0][p + 1]: if self.venue == "H": self.df.loadEntry(frt, pag, p + 1, data=1.30) else: self.df.loadEntry(frt, pag, p + 1, data=1.15) def doMTime(self, frt, pag, r, c, p, i, w): self.mtime = w def doMPlace(self, frt, pag, r, c, p, i, w): w = w.strip() if len(w.strip()) == 1: w = w.upper() if w not in ("A", "H"): return "Invalid Place" self.mplace = w self.df.loadEntry(frt, pag, p, data=self.mplace) def doCaptain(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("bwltab", cols=["btb_surname", "btb_names"], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", w)], limit=1) if not acc: return "Invalid Tab" self.captain = w self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1])) def doSkip(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("bwltab", cols=["btb_surname", "btb_names"], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", w)], limit=1) if not acc: return "Invalid Tab" self.skip = w self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1])) def doPlayer(self, frt, pag, r, c, p, i, w): if w == self.skip: return "Invalid Player, This is the Skip" acc = self.sql.getRec("bwltab", cols=["btb_surname", "btb_names"], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", w)], limit=1) if not acc: return "Invalid Tab" self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1])) def enterNewSide(self): tit = ("New Side", ) lge = (("Main", "M"), ("Friendly", "F")) fld = ((("T", 0, 0, 0), "I@bfs_desc", 0, "", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 1, 0), ("IRB", lge), 0, "League", "", "M", "N", None, None, None, None), (("T", 0, 2, 0), "I@bfs_division", 0, "", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 3, 0), "I@bfs_number", 0, "", "", "", "N", None, None, None, ("notzero", ))) state = self.df.disableButtonsTags() self.new = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doSideEnd, "y"), ), txit=(self.doSideExit, )) self.new.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) return self.team def doSideEnd(self): team = self.sql.getRec("bwlfls", cols=["max(bfs_code)"], where=[("bfs_cono", "=", self.opts["conum"]), ("bfs_fmat", "=", self.fmat)], limit=1) if not team[0]: self.team = 1 else: self.team = team[0] + 1 self.sql.insRec("bwlfls", data=[self.opts["conum"], self.fmat, self.team] + self.new.t_work[0][0] + ["Y"]) self.opts["mf"].dbm.commitDbase() self.new.closeProcess() def doSideExit(self): self.team = 0 self.new.closeProcess() def enterNewOpp(self): tit = ("New Opponent", ) clb = { "stype": "R", "tables": ("bwlclb", ), "cols": (("bcc_code", "", 0, "Cod"), ("bcc_name", "", 0, "Name", "Y")) } fld = ((("T", 0, 0, 0), "I@bcc_code", 0, "", "", "", "N", self.doClubCode, clb, None, ("efld", )), (("T", 0, 0, 0), "I@bcc_name", 0, "", "", "", "N", self.doClubDesc, None, None, ("notblank", )), (("T", 0, 1, 0), "I@bfo_desc", 0, "", "", "", "N", None, None, None, ("notblank", ))) state = self.df.disableButtonsTags() self.nop = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doOppEnd, "y"), ), txit=(self.doOppExit, )) self.nop.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) return self.opp def doClubCode(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("bwlclb", where=[("bcc_code", "=", w)], limit=1) if acc: self.nop.loadEntry(frt, pag, p + 1, data=acc[1]) return "sk1" def doClubDesc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("bwlclb", where=[("bcc_name", "=", w)], limit=1) if acc: self.nop.loadEntry(frt, pag, p - 1, data=acc[0]) else: self.club = getNextCode(self.sql, "bwlclb", "bcc_code", last=999) self.nop.loadEntry(frt, pag, p - 1, data=self.club) self.sql.insRec("bwlclb", data=[self.club, w]) self.opts["mf"].dbm.commitDbase() def doOppEnd(self): opp = self.sql.getRec("bwlflo", where=[("bfo_cono", "=", self.opts["conum"]), ("bfo_fmat", "=", self.fmat), ("bfo_desc", "=", self.nop.t_work[0][0][2])], limit=1) if opp: self.opp = opp[1] else: opp = self.sql.getRec("bwlflo", cols=["max(bfo_code)"], where=[("bfo_cono", "=", self.opts["conum"]), ("bfo_fmat", "=", self.fmat)], limit=1) if not opp[0]: self.opp = 1 else: self.opp = opp[0] + 1 self.sql.insRec("bwlflo", data=[ self.opts["conum"], self.fmat, self.opp, self.nop.t_work[0][0][0], self.nop.t_work[0][0][2] ]) self.opts["mf"].dbm.commitDbase() self.nop.closeProcess() def doOppExit(self): self.opp = 0 self.nop.closeProcess() def doEnd(self): if self.df.frt == "T": self.df.focusField("C", 0, 1) elif self.df.row == (self.qty - 1): self.doUpdate() else: self.df.advanceLine(0) def doUpdate(self): self.sql.delRec("bwlflm", where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp), ("bfm_date", "=", self.date), ("bfm_team", "=", self.team)]) self.sql.insRec("bwlflm", data=[ self.opts["conum"], self.fmat, self.ftyp, self.date, self.rnd, self.team, self.opp, self.venue, self.mtime, self.mplace, self.captain ]) self.sql.delRec("bwlflt", where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=", self.date), ("bft_team", "=", self.team)]) for x in range(self.qty): for y in range(4): data = [ self.opts["conum"], self.fmat, self.ftyp, self.date, self.team, self.df.c_work[0][x][0], self.df.c_work[0][x][y * 2], y + 1, 0, 0, 0, 0, 0, 0, 0, "" ] acc = self.sql.getRec("bwlflt", where=[("bft_cono", "=", data[0]), ("bft_fmat", "=", data[1]), ("bft_type", "=", data[2]), ("bft_date", "=", data[3]), ("bft_team", "=", data[4]), ("bft_player", "=", data[6])], limit=1) if acc: showError( self.opts["mf"].body, "Duplicate", "Player Code %s is Entered More than Once" % data[6]) self.df.focusField("C", 0, 1) self.opts["mf"].dbm.rollbackDbase() return self.sql.insRec("bwlflt", data=data) for x in range(6, 15): self.df.clearEntry("T", 0, x) self.df.clearFrame("C", 0) self.df.skip = [[1, 2, 3, 4, 5]] self.df.focusField("T", 0, 6) def doExit(self): if self.df.frt == "C": self.df.focusField("C", 0, self.df.col) return if not self.fmat or not self.date: self.df.closeProcess() self.opts["mf"].closeLoop() return plrs = {} acc = self.sql.getRec( "bwlflt", cols=["bft_player", "bft_team", "bft_skip", "bft_position"], where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=", self.date)], order="bft_player") for a in acc: if a[0] in plrs: showError( self.opts["mf"].body, "Duplicate", "Player Code %s is in Team Codes %s and %s" % (a[0], plrs[a[0]][0], a[1])) self.df.focusField("T", 0, 6) return else: plrs[a[0]] = [a[1], a[2], a[3]] self.df.closeProcess() if not self.reprint: self.opts["mf"].dbm.commitDbase() ok = askQuestion(self.opts["mf"].body, "Print", "Do You Want to View/Print the Selections") if ok == "yes": self.doPrintSelection() self.opts["mf"].closeLoop() def doPrintSelection(self): fld = ((("T", 0, 0, 0), "INA", 70, "Note-Line-1", "", "", "N", None, None, None, ("efld", )), (("T", 0, 1, 0), "INA", 70, "Note-Line-2", "", "", "N", None, None, None, ("efld", ))) self.pr = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=((self.doPrint, "y"), ), txit=None, view=("N", "V"), mail=("Y", "N")) self.pr.mstFrame.wait_window() def doPrint(self): self.pr.closeProcess() pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, "select_%s" % self.date, ext="pdf") fpdf = MyFpdf(name=self.__class__.__name__, head=90) cw = fpdf.get_string_width("X") # character width ld = 4.5 # line depth fm = { "margins": ((10, 80), (5, 12.5)), # left, right, top, bottom "repeat": (1, 5), # repeat across and below "rows": ( # x, y, w, h, fill, text, qty (10, 5, 80, 1.5, .8), (10, 6.5, ((10, 1.5, .9, ("Skip", "Third", "Second", "Lead")), (23, 1.5), (23, 1.5), (24, 1.5)), 4), (10, 12.5, 80, 1.5)) } ff = { "margins": ((10, 80), ((5, 15))), # left, right, top, bottom "repeat": (1, 3), # repeat across and below "rows": ( # x, y, w, h, fill, text, qty (10, 5, 80, 2, .8), (10, 7, ((10, 2, .9, ("Skip", "Third", "Second", "Lead")), (70, 2)), 4), (10, 15, 80, 2)) } for div in ("Main", "Friendly"): whr = [("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp), ("bfm_date", "=", self.date)] if div == "Main": ppad = 1 rr = fm if self.ftyp == "P": ftyp = "PRACTICE" else: ftyp = "FIXTURE" h1 = "TEAMS FOR %s %s - %s %s %s" % ( self.fdes, ftyp, self.date % 100, mthnam[int( self.date / 100) % 100][1], int(self.date / 10000)) whr.append(("bfs_league", "=", "M")) else: ppad = 1.5 rr = ff h1 = "TEAMS FOR %s FRIENDLY - %s %s %s" % ( self.fdes, self.date % 100, mthnam[int( self.date / 100) % 100][1], int(self.date / 10000)) whr.append(("bfs_league", "=", "F")) whr.extend([("bfs_cono=bfm_cono", ), ("bfs_fmat=bfm_fmat", ), ("bfs_code=bfm_team", ), ("bfo_cono=bfm_cono", ), ("bfo_fmat=bfm_fmat", ), ("bfo_code=bfm_opps", ), ("bcc_code=bfo_club", )]) games = self.sql.getRec( tables=["bwlflm", "bwlfls", "bwlflo", "bwlclb"], cols=[ "bfm_round", "bfm_team", "bfs_desc", "bfo_desc", "bfm_venue", "bfm_mtime", "bfm_mplace", "bfm_captain", "bcc_name", "bfs_number" ], where=whr, order="bfm_team") if not games: continue fpdf.add_page() if games[0][0] == 0: h1 = h1.replace("FIXTURE", "PRACTICE") totp = 0 for game in games: if totp < game[9]: totp = game[9] * 4 # Draw headings fpdf.drawText(x=0, y=1 * ld, w=90 * cw, align="C", txt=h1, font=("helvetica", "B", 18)) fpdf.setFont("helvetica", "B", 12) # Draw table last, table = doDrawTable(fpdf, rr, ppad, spad=2, cw=cw, ld=ld) # Fill Form tc = [] pl = [] fpdf.setFont("helvetica", "B", 12) for x, game in enumerate(games): tc.append(game[7]) if game[4].strip().upper() == "H": text = "%s vs %s at %s" % (game[2], game[3], self.opts["conam"]) elif game[4].strip().upper() == "A": text = "%s vs %s at %s" % (game[2], game[3], game[8]) else: text = "%s vs %s at %s" % (game[2], game[3], game[4]) pos = table[0][1][x] + .5 fpdf.drawText(x=0, y=pos * ld, w=90 * cw, align="C", txt=text) pos = table[-1][1][x] + .5 if game[6].strip().upper() in ("H", "A"): text = "Meet at the Club at %5.2f" % game[5] else: text = "Meet at %s at %5.2f" % (game[6], game[5]) fpdf.drawText(x=0, y=pos * ld, w=90 * cw, align="C", txt=text) plrs = self.sql.getRec( tables=["bwlflt", "bwltab"], cols=["btb_tab", "btb_surname", "btb_names"], where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=", self.date), ("bft_team", "=", game[1]), ("btb_cono=bft_cono", ), ("btb_tab=bft_player", )], order="bft_team, bft_skip, bft_position") while len(plrs) < totp: plrs.append(["", "", ""]) pl.extend(plrs) fpdf.setFont("helvetica", "", 12) col = len(rr["rows"][1][2]) cnt = 0 for p in pl: if p == ["", "", ""]: continue pn = self.getName(p[1], p[2]) if p[0] in tc: pn = "%s (C)" % pn x = table[(int((cnt % totp) / 4) + 2)][0][0] + 1 y = table[( (cnt - (int(cnt / 4) * 4)) * col) + 2][1][int(cnt / totp)] + .5 fpdf.drawText(x=x * cw, y=y * ld, txt=pn) cnt += 1 # Draw trailer fpdf.setFont("helvetica", "B", 14) txt = """Please tick your names on the right hand side to indicate availability. If unavailable please inform skips and skips to inform selectors.""" if self.assess == "Y": txt = """%s Captains (C) are responsible to distribute and return assessment forms, completed and initialled, to a selector.""" % txt txt = """%s %s %s""" % (txt, self.pr.t_work[0][0][0], self.pr.t_work[0][0][1]) fpdf.drawText(x=10.0 * cw, y=(last + 3) * ld, txt=txt, ctyp="M") fpdf.output(pdfnam, "F") head = "Match Selections for %s" % self.disp doPrinter(mf=self.opts["mf"], header=head, pdfnam=pdfnam, repprt=self.pr.repprt, fromad=self.fromad, repeml=self.pr.repeml) def getName(self, snam, fnam): if fnam: return "%s, %s" % (snam.upper(), fnam.split()[0][0].upper()) else: return snam.upper() def doQuit(self): self.df.closeProcess() self.opts["mf"].dbm.rollbackDbase() self.opts["mf"].closeLoop()
class bc3100(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, ["bwlcmp", "bwlgme", "bwltab", "bwltyp", "bwlpts", "bwlent"], 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"] return True def mainProcess(self): com = { "stype": "R", "tables": ("bwlcmp",), "cols": ( ("bcm_code", "", 0, "Cod"), ("bcm_name", "", 0, "Name", "Y")), "where": [("bcm_cono", "=", self.opts["conum"])]} gme = { "stype": "R", "tables": ("bwlgme",), "cols": (("bcg_game", "", 0, "GC"),), "where": [("bcg_cono", "=", self.opts["conum"])], "whera": [("T", "bcg_ccod", 0, 0)], "group": "bcg_game"} r1s = (("Yes", "Y"), ("No", "N")) fld = ( (("T",0,0,0),"I@bcm_code",0,"","", 0,"N",self.doCmpCod,com,None,None), (("T",0,0,0),"ONA",30,""), (("T",0,1,0),"IUI",2,"Last Game","", 0,"N",self.doLstGam,gme,None,("efld",)), (("T",0,2,0),("IRB",r1s),0,"Game Report","", "N","N",self.doGamRep,None,None,None), (("T",0,3,0),("IRB",r1s),0,"Session Prizes","", "N","N",self.doSesPrz,None,None,None), (("T",0,4,0),("IRB",r1s),0,"Session Prizes by Group","", "N","N",self.doSesGrp,None,None,None)) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, tend=tnd, txit=txt, view=("N","V"), mail=("B","N")) def doCmpCod(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("bwlcmp", where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", w)], limit=1) if not chk: return "Invalid Competition Code" self.ccod = w self.cdes = chk[self.sql.bwlcmp_col.index("bcm_name")] self.ctyp = chk[self.sql.bwlcmp_col.index("bcm_type")] self.poff = chk[self.sql.bwlcmp_col.index("bcm_poff")] chk = self.sql.getRec("bwltyp", where=[("bct_cono", "=", self.opts["conum"]), ("bct_code", "=", self.ctyp)], limit=1) self.cfmat = chk[self.sql.bwltyp_col.index("bct_cfmat")] self.tsize = chk[self.sql.bwltyp_col.index("bct_tsize")] if self.cfmat == "R": games = self.sql.getRec("bwlgme", cols=["count(*)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", 1)], group="bcg_group") self.games = 0 for gme in games: if gme[0] > self.games: self.games = gme[0] self.games -= 1 elif self.cfmat in ("D", "K"): self.games = self.sql.getRec("bwlgme", cols=["count(*)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", 1)], limit=1)[0] - 1 else: self.games = chk[self.sql.bwltyp_col.index("bct_games")] self.groups = chk[self.sql.bwltyp_col.index("bct_groups")] self.grgame = chk[self.sql.bwltyp_col.index("bct_grgame")] col = ["bcg_game", "bcg_aflag", "sum(bcg_sfor)", "sum(bcg_sagt)", "sum(bcg_points)"] game = self.sql.getRec("bwlgme", cols=col, where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod)], group="bcg_game, bcg_aflag", order="bcg_game") self.lgame = 0 for g in game: if not g[1] and not g[2] and not g[3] and not g[4]: break self.lgame = g[0] if not self.lgame: return "Knockout or No Completed Games" self.df.loadEntry(frt, pag, p+1, data=self.cdes) self.df.loadEntry(frt, pag, p+2, data=self.lgame) def doLstGam(self, frt, pag, r, c, p, i, w): if not w: chk = self.sql.getRec("bwlgme", cols=["bcg_game", "sum(bcg_points)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod)], group="bcg_game", order="bcg_game") game = 0 for g in chk: if g[1]: game = g[0] else: break if not game: return "No Completed Games" self.df.loadEntry(frt, pag, p, data=game) else: game = w chk = self.sql.getRec("bwlgme", cols=["count(*)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", game), ("bcg_aflag", "=", "A")], group="bcg_aflag", limit=1) if chk and chk[0]: return "Game Abandoned" chk = self.sql.getRec("bwlgme", where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", game), ("bcg_aflag", "in", ("", "D"))]) if not chk: return "Invalid Game Number" ptyp = chk[0][self.sql.bwlgme_col.index("bcg_type")] pts = self.sql.getRec("bwlpts", where=[("bcp_cono", "=", self.opts["conum"]), ("bcp_code", "=", self.ctyp), ("bcp_ptyp", "=", ptyp)], limit=1) self.ponly = pts[self.sql.bwlpts_col.index("bcp_p_only")] non = [] for ck in chk: scod = ck[self.sql.bwlgme_col.index("bcg_scod")] ocod = ck[self.sql.bwlgme_col.index("bcg_ocod")] if scod > 900000 or ocod > 900000: continue if self.ponly == "Y": fors = ck[self.sql.bwlgme_col.index("bcg_points")] agts = self.sql.getRec("bwlgme", cols=["bcg_points"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", game), ("bcg_scod", "=", ocod)], limit=1)[0] else: fors = ck[self.sql.bwlgme_col.index("bcg_sfor")] agts = ck[self.sql.bwlgme_col.index("bcg_sagt")] if not fors and not agts: if scod not in non: non.append(scod) if non: return "%s Result(s) Not Yet Entered" % int(len(non) / 2) self.pgame = w if self.pgame == 1: self.gamrep = "N" self.df.loadEntry(frt, pag, p+1, data=self.gamrep) if self.pgame < self.games: self.sesp = "N" self.sesg = "N" self.df.loadEntry(frt, pag, p+1, data=self.sesp) self.df.loadEntry(frt, pag, p+2, data=self.sesg) return "sk3" return "sk1" if self.cfmat in ("D", "K", "R") or self.pgame < self.lgame: self.df.topf[0][3][5] = "N" else: self.df.topf[0][3][5] = "Y" def doGamRep(self, frt, pag, r, c, p, i, w): self.gamrep = w if self.cfmat in ("D", "K", "R") or self.pgame < self.lgame: self.sesp = "N" self.sesg = "N" self.df.loadEntry(frt, pag, p+1, data=self.sesp) self.df.loadEntry(frt, pag, p+2, data=self.sesg) return "sk2" def doSesPrz(self, frt, pag, r, c, p, i, w): self.sesp = w if self.sesp == "N" or self.groups == "N": self.sesg = "N" self.df.loadEntry(frt, pag, p+1, data=self.sesg) return "sk1" def doSesGrp(self, frt, pag, r, c, p, i, w): self.sesg = w def doEnd(self): self.df.closeProcess() chk = self.sql.getRec("bwlgme", cols=["bcg_group", "bcg_scod"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.pgame)], order="bcg_group") if chk[0][0] and self.cfmat == "R": groups = "Y" else: groups = self.groups self.grps = {} for rec in chk: if rec[0] not in self.grps: self.grps[rec[0]] = [[rec[1]], [], []] else: self.grps[rec[0]][0].append(rec[1]) self.keys = list(self.grps.keys()) self.keys.sort() self.fpdf = MyFpdf(name=self.__class__.__name__, head=65) self.lastg = None for g in self.keys: self.pageHeading() if self.gamrep == "Y": self.doReport("G", g) if g == 0 and len(chk) > 20: self.pageHeading() self.doReport("M", g) if self.pgame == self.games: # Enter Prizes for key in self.keys: if self.cfmat == "R" and groups == "Y": self.grps[key][1] = 0 else: self.doPrizes(key) # Match Winners & Summary self.gqty = len(self.keys) self.wins = {} self.allp = [] self.swin = [] self.where = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "<=", self.pgame), ("btb_cono=bcg_cono",), ("btb_tab=bcg_scod",)] for grp in range(self.gqty): if groups == "Y": gcod = grp + 1 else: gcod = grp whr = copyList(self.where) whr.append(("bcg_group", "=", gcod)) col = [ "bcg_scod", "btb_surname", "btb_names", "sum(bcg_a_sfor) as sfor", "sum(bcg_a_sagt) as sagt", "sum(bcg_a_sfor - bcg_a_sagt) as agg", "sum(bcg_a_points) as pts"] recs = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col, where=whr, group="bcg_scod, btb_surname, btb_names", order="pts desc, agg desc, sagt asc") if not recs: continue self.wins[gcod] = [] for x in range(self.grps[gcod][1]): self.allp.append(recs[x][0]) if recs[x][2]: nam = "%s, %s" % (recs[x][1], recs[x][2].split()[0]) else: nam = recs[x][1] self.wins[gcod].append(nam) if self.cfmat == "R" and groups == "Y": self.swin.append(self.grps[gcod][0][0]) if self.sesp == "Y": self.pageHeading("S") self.doSesWin() else: for grp in self.wins: if self.wins[grp]: self.pageHeading("S") break self.doMatchWin() pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, "report", ext="pdf") self.fpdf.output(pdfnam, "F") if self.df.repeml[1] == "Y": if not self.df.repeml[2]: col = ["btb_mail"] whr = [ ("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod), ("btb_cono=bce_cono",), ("btb_tab=bce_scod",), ("btb_mail", "<>", "")] recs = self.sql.getRec(tables=["bwlent", "bwltab"], cols=col, where=whr) self.df.repeml[2] = [] for rec in recs: self.df.repeml[2].append(rec[0]) head = "%s - Results after game %s" % (self.cdes, self.pgame) doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header=head, repprt=self.df.repprt, fromad=self.fromad, repeml=self.df.repeml) if self.pgame == self.lgame and self.cfmat == "R" and \ groups == "Y" and not self.poff: ok = askQuestion(self.opts["mf"].body, "Play-Offs", "Must a Play-Off Draw be Created and/or Printed?", default="yes") if ok == "yes": self.doSecEnd() self.opts["mf"].closeLoop() def doReport(self, rtyp, grp): whr = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("btb_tab=bcg_scod",)] col = ["bcg_scod", "btb_surname", "btb_names"] if rtyp == "G": whr.extend([ ("bcg_scod", "in", self.grps[grp][0]), ("bcg_game", "=", self.pgame)]) col.extend([ "sum(bcg_sfor) as sfor", "sum(bcg_sagt) as sagt", "sum(bcg_sfor - bcg_sagt) as agg", "sum(bcg_points) as pts"]) else: whr.extend([ ("bcg_scod", "in", self.grps[grp][0]), ("bcg_game", "<=", self.pgame)]) if self.pgame <= self.grgame: col.extend([ "sum(bcg_sfor) as sfor", "sum(bcg_sagt) as sagt", "sum(bcg_sfor - bcg_sagt) as agg", "sum(bcg_points) as pts"]) else: col.extend([ "sum(bcg_a_sfor) as sfor", "sum(bcg_a_sagt) as sagt", "sum(bcg_a_sfor - bcg_a_sagt) as agg", "sum(bcg_a_points) as pts"]) recs = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col, where=whr, group="btb_tab, btb_surname, btb_names", order="pts desc, agg desc, sagt asc") if not recs: return self.groupHeading(rtyp, grp) if self.cfmat == "X": tms = {"H": [0, 0, 0, 0], "V": [0, 0, 0, 0]} for num, (scod,snam,fnam,sfor,sagt,agg,pts) in enumerate(recs): if fnam: nam = "%s, %s" % (snam.upper(), fnam.split()[0].upper()) else: nam = snam.upper() a = CCD(num+1, "UI", 3) b = CCD(nam, "NA", 30) c = CCD(sfor, "SD", 7.1) d = CCD(sagt, "SD", 7.1) e = CCD(agg, "SD", 7.1) f = CCD(pts, "SD", 7.1) self.printLine(a.disp, b.disp, c.disp, d.disp, e.disp, f.disp) if self.cfmat == "X": tm = self.sql.getRec("bwlent", cols=["bce_tcod"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod), ("bce_scod", "=", scod)], limit=1) tms[tm[0]][0] = float(ASD(tms[tm[0]][0]) + ASD(c.work)) tms[tm[0]][1] = float(ASD(tms[tm[0]][1]) + ASD(d.work)) tms[tm[0]][2] = float(ASD(tms[tm[0]][2]) + ASD(e.work)) tms[tm[0]][3] = float(ASD(tms[tm[0]][3]) + ASD(f.work)) self.pglin += 1 if self.cfmat == "X": cwth = self.fpdf.cwth self.fpdf.drawText() self.fpdf.drawText("Match Summary", font=["courier", "B", 18]) self.fpdf.setFont(style="B") self.fpdf.drawText() self.fpdf.drawText("Home", w=cwth * 32, border="TLRB", align="C", fill=1, ln=0) self.fpdf.drawText("Visitors", w=cwth * 32, border="TLRB", align="C", fill=1, ln=1) x = self.fpdf.get_x() y = self.fpdf.get_y() for tm in ("H", "V"): self.fpdf.drawText("+For", x=x, y=y, w=cwth * 8, h=8, border="TLRB", align="C", fill=1) val = CCD(tms[tm][0], "SD", 7.1) self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8, border="TLRB", align="C", fill=0) x += (cwth * 8) self.fpdf.drawText("-Agt", x=x, y=y, w=cwth * 8, h=8, border="TLRB", align="C", fill=1) val = CCD(tms[tm][1], "SD", 7.1) self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8, border="TLRB", align="C", fill=0) x += (cwth * 8) self.fpdf.drawText("=Dif", x=x, y=y, w=cwth * 8, h=8, border="TLRB", align="C", fill=1) val = CCD(tms[tm][2], "SD", 7.1) self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8, border="TLRB", align="C", fill=0) x += (cwth * 8) self.fpdf.drawText("Pts", x=x, y=y, w=cwth * 8, h=8, border="TLRB", align="C", fill=1) val = CCD(tms[tm][3], "SD", 7.1) self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8, border="TLRB", align="C", fill=0) x += (cwth * 8) def doSesWin(self): # Session Winners sess = {} for gme in range(1, self.games + 1): col = [ "bcg_scod", "btb_surname", "btb_names", "sum(bcg_sfor) as sfor", "sum(bcg_sagt) as sagt", "sum(bcg_sfor - bcg_sagt) as agg", "sum(bcg_points) as pts"] whr = copyList(self.where) whr.append(("bcg_game", "=", gme)) grp = "bcg_scod, btb_surname, btb_names" odr = "pts desc, agg desc, sagt asc" if self.sesg == "Y" and gme > self.grgame: col.append("bcg_group") grp = "bcg_group, %s" % grp odr = "bcg_group, %s" % odr recs = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col, where=whr, group=grp, order=odr) done = None for rec in recs: if len(rec) == 7: gpc = 0 else: gpc = rec[7] if gpc == done: continue ign = False if self.ponly == "Y" and not rec[6]: break if self.ponly == "N" and (not rec[3] and not rec[4]): break for grp in range(self.gqty): if rec[0] in self.allp: ign = True break if not ign: self.allp.append(rec[0]) if gme not in sess: sess[gme] = {} if rec[2]: nam = "%s, %s" % (rec[1], rec[2].split()[0]) else: nam = rec[1] sess[gme][gpc] = nam done = gpc mess = "Session Winners" self.fpdf.setFont(style="B", size=14) self.fpdf.drawText(mess, align="C", border="TLRB", fill=1) self.fpdf.drawText("Ses", w=12, border="TLRB", fill=1, ln=0) if self.sesg == "Y": self.fpdf.drawText("Grp", w=12, border="TLRB", fill=1, ln=0) self.fpdf.drawText("Name", border="TLRB", fill=1) self.fpdf.setFont() for gme in range(1, self.games + 1): stxt = str("%3s" % gme) if gme not in sess: self.fpdf.drawText(stxt, w=12, border="TLRB", ln=0) if self.sesg == "Y": self.fpdf.drawText("", w=12, border="TLRB", ln=0) self.fpdf.drawText("* No Valid Winner or Abandoned *", border="TLRB") continue grps = list(sess[gme].keys()) grps.sort() for grp in grps: gtxt = "%3s" % chr(64 + grp) self.fpdf.drawText(stxt, w=12, border="TLRB", ln=0) if self.sesg == "Y": self.fpdf.drawText(gtxt, w=12, border="TLRB", ln=0) self.fpdf.drawText(sess[gme][grp], border="TLRB") self.fpdf.drawText() def doMatchWin(self): for num, gcod in enumerate(self.keys): if self.wins[gcod]: if gcod: if self.cfmat == "R": mess = "Match Winners - Section %s" % chr(64 + gcod) else: mess = "Match Winners - Group %s" % chr(64 + gcod) else: mess = "Match Winners" self.fpdf.setFont(style="B", size=14) self.fpdf.drawText(mess, align="C", border="TLRB", fill=1) self.fpdf.drawText("Pos", w=12, border="TLRB", fill=1, ln=0) self.fpdf.drawText("Name", border="TLRB", fill=1) self.fpdf.setFont() for n, s in enumerate(self.wins[gcod]): ptxt = "%3s" % (n + 1) self.fpdf.drawText(ptxt, w=12, border="TLRB", ln=0) self.fpdf.drawText(s, border="TLRB") if not num % 2: ly = self.fpdf.get_y() if num % 2 and self.fpdf.get_y() > ly: ly = self.fpdf.get_y() self.fpdf.drawText() place = ["1st", "2nd", "3rd"] for x in range(4, 21): place.append("%sth" % x) if self.tsize == 2: ppos = ("Skip", "Lead") elif self.tsize == 3: ppos = ("Skip", "Second", "Lead") elif self.tsize == 4: ppos = ("Skip", "Third", "Second", "Lead") for gcod in self.keys: if not self.grps[gcod][2]: continue for num, skp in enumerate(self.wins[gcod]): self.fpdf.add_page() self.fpdf.setFont(style="B", size=24) self.fpdf.drawText(self.cdes, h=10, align="C") self.fpdf.drawText() self.fpdf.setFont(style="B", size=18) if gcod: self.fpdf.drawText("GROUP %s" % chr(64 + gcod), h=10, align="C") self.fpdf.drawText() self.fpdf.drawText("%s Prize R%s - %s" % (place[num], self.grps[gcod][2][num], skp), h=10, align="C") self.fpdf.setFont(style="B", size=16) for pos in ppos: self.fpdf.drawText() self.fpdf.drawText() self.fpdf.drawText("%s's Name" % pos, w=50, h=8, border="TLRB", ln=0, fill=1) self.fpdf.drawText("", h=8, border="TLRB") self.fpdf.drawText("Bank Name", w=50, h=8, border="TLRB", ln=0, fill=1) self.fpdf.drawText("", h=8, border="TLRB") self.fpdf.drawText("Branch Name", w=50, h=8, border="TLRB", ln=0, fill=1) self.fpdf.drawText("", h=8, border="TLRB") self.fpdf.drawText("Branch Code", w=50, h=8, border="TLRB", ln=0, fill=1) self.fpdf.drawText("", h=8, border="TLRB") self.fpdf.drawText("Account Number", w=50, h=8, border="TLRB", ln=0, fill=1) self.fpdf.drawText("", h=8, border="TLRB") self.fpdf.drawText() self.fpdf.setFont(style="B", size=18) self.fpdf.drawText("Congratulations and Well Done!", h=10, align="C") def pageHeading(self, htyp=None): self.fpdf.add_page() head = "%s - %s" % (self.opts["conam"], self.cdes) self.fpdf.drawText(head, font=["courier", "B", 18], align="C") if htyp == "S": self.fpdf.drawText() self.fpdf.drawText("Match Summary", font=["courier", "B", 16], align="C") self.fpdf.drawText() self.pglin = 4 else: self.pglin = 1 def groupHeading(self, rtyp, group): self.fpdf.drawText(font=["courier", "B", 18], align="C") if rtyp == "G": head = "Results for Game Number: %s" % self.pgame else: head = "Match Standings After Game Number: %s" % self.pgame if group: if self.cfmat == "R": head += " for Section: %s" % chr(64 + group) else: head += " for Group: %s" % chr(64 + group) self.fpdf.drawText(head, font=["courier", "B", 16], align="C") self.fpdf.drawText() self.fpdf.setFont(style="B") self.printLine("Pos", "%-30s" % "Name", " +For ", " -Agt ", " =Dif ", " Pts ", fill=1) self.fpdf.setFont() self.pglin += 4 def printLine(self, a, b, c, d, e, f, fill=0): x = 10 w = self.fpdf.get_string_width("X"*len(a)) + 1 self.fpdf.drawText(a, x=x, w=w, border="TLB", fill=fill, ln=0) x += w w = self.fpdf.get_string_width("X"*len(b)) + 1 self.fpdf.drawText(b, x=x, w=w, border="TLB", fill=fill, ln=0) x += w w = self.fpdf.get_string_width("X"*len(c)) + 1 self.fpdf.drawText(c, x=x, w=w, border="TLB", fill=fill, ln=0) x += w w = self.fpdf.get_string_width("X"*len(d)) + 1 self.fpdf.drawText(d, x=x, w=w, border="TLB", fill=fill, ln=0) x += w w = self.fpdf.get_string_width("X"*len(e)) + 1 self.fpdf.drawText(e, x=x, w=w, border="TLB", fill=fill, ln=0) x += w w = self.fpdf.get_string_width("X"*len(f)) + 1 self.fpdf.drawText(f, x=x, w=w, border="TLRB", fill=fill) def doPrizes(self, grp): self.przgrp = grp if grp: if self.cfmat == "R": tit = "Prizes for Section %s" % chr(64 + grp) else: tit = "Prizes for Group %s" % chr(64 + grp) else: tit = "Prizes for Match" r1s = (("Yes", "Y"), ("No", "N")) fld = ( (("T",0,0,0),"IUI",2,"Number of Prizes","", 3,"N",self.doPrzNum,None,None,("efld",)), (("T",0,1,0),("IRB",r1s),0,"EFT Forms","", "N","N",self.doPrzEft,None,None,None), (("T",0,2,0),"IUI",5,"1st Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,3,0),"IUI",5,"2nd Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,4,0),"IUI",5,"3rd Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,5,0),"IUI",5,"4th Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,6,0),"IUI",5,"5th Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,7,0),"IUI",5,"6th Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,8,0),"IUI",5,"7th Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,9,0),"IUI",5,"8th Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,10,0),"IUI",5,"9th Prize","", 0,"N",self.doPrzAmt,None,None,None), (("T",0,11,0),"IUI",5,"10th Prize","", 0,"N",self.doPrzAmt,None,None,None)) tnd = ((self.doPrzEnd,"n"),) self.pz = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=tnd, txit=None) for x in range(10): self.pz.setWidget(self.pz.topLabel[0][2+x], state="hide") self.pz.setWidget(self.pz.topEntry[0][2+x], state="hide") self.pz.mstFrame.wait_window() def doPrzNum(self, frt, pag, r, c, p, i, w): if not w and self.cfmat != "R": ok = askQuestion(self.opts["mf"].body, "Prizes", "Are You Sure that there are No Prizes?", default="no") if ok == "no": return "Invalid Number od Prizes" self.prznum = w if not self.prznum: self.przeft = [] self.pz.loadEntry(frt, pag, p+1, data="N") return "nd" def doPrzEft(self, frt, pag, r, c, p, i, w): if w == "N": self.przeft = [] return "nd" self.przeft = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] for x in range(self.prznum): self.pz.setWidget(self.pz.topLabel[0][2+x], state="show") self.pz.setWidget(self.pz.topEntry[0][2+x], state="show") for x in range(self.prznum, 10): self.pz.setWidget(self.pz.topLabel[0][2+x], state="hide") self.pz.setWidget(self.pz.topEntry[0][2+x], state="hide") def doPrzAmt(self, frt, pag, r, c, p, i, w): self.przeft[p-2] = w if p == self.prznum + 1: return "nd" def doPrzEnd(self): self.grps[self.przgrp][1] = self.prznum self.grps[self.przgrp][2] = self.przeft self.pz.closeProcess() def doSecEnd(self): ccod = getNextCode(self.sql, "bwlcmp", "bcm_code", where=[("bcm_cono", "=", self.opts["conum"])], last=999) self.sql.updRec("bwlcmp", cols=["bcm_poff"], data=[ccod], where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", self.ccod)]) cdes = self.cdes + " Play-Off" t = time.localtime() cdte = ((t[0] * 10000) + (t[1] * 100) + t[2]) self.sql.insRec("bwlcmp", data=[self.opts["conum"], ccod, cdes, cdte, 0, ""]) for skp in self.swin: self.sql.insRec("bwlent", data=[self.opts["conum"], ccod, skp, 0, "Y", ""]) callModule(self.opts["mf"], self.df, "bc2050", coy=[self.opts["conum"], self.opts["conam"]], args=ccod) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class arc310(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, ["assdep", "assgrp", "assmst", "genmst"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) assctl = gc.getCtl("assctl", self.opts["conum"]) if not assctl: return self.glint = assctl["cta_glint"] return True def mainProcess(self): grp = { "stype": "R", "tables": ("assgrp", ), "cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0, "Description", "Y")), "where": [("asg_cono", "=", self.opts["conum"])] } dep = { "stype": "R", "tables": ("assdep", ), "cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0, "Description", "Y")), "where": [("asd_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])], "order": "glm_acno" } fld = [(("T", 0, 0, 0), "IUA", 3, "Asset Group", "", "", "N", self.doGroup, grp, None, ("notblank", )), (("T", 0, 1, 0), "INA", 30, "Description", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 0, 2, 0), "INa", 3, "Depreciation Code", "", "", "N", self.doDepCode, dep, None, None), (("T", 0, 2, 0), "ONA", 34, "")] if self.glint == "Y": fld.extend([(("T", 0, 3, 0), "IUI", 7, "Asset Account", "", "", "N", self.doAsset, glm, None, ("notzero", )), (("T", 0, 3, 0), "ONA", 30, ""), (("T", 0, 4, 0), "IUI", 7, "Accum Account", "", "", "N", self.doAccum, glm, None, ("notzero", )), (("T", 0, 4, 0), "ONA", 30, ""), (("T", 0, 5, 0), "IUI", 7, "Expense Account", "", "", "N", self.doExpense, glm, None, ("notzero", )), (("T", 0, 5, 0), "ONA", 30, "")]) but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None)) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt) def doGroup(self, frt, pag, r, c, p, i, w): self.group = w self.acc = self.sql.getRec("assgrp", where=[("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", self.group)], limit=1) if not self.acc: self.new = "Y" else: self.new = "N" self.df.loadEntry(frt, pag, p + 1, data=self.acc[2]) self.df.loadEntry(frt, pag, p + 2, data=self.acc[3]) dep = self.sql.getRec("assdep", cols=["asd_desc"], where=[("asd_cono", "=", self.opts["conum"]), ("asd_code", "=", self.acc[3])], limit=1) if dep: self.df.loadEntry(frt, pag, p + 3, data=dep[0]) if self.glint == "N": return self.df.loadEntry(frt, pag, p + 4, data=self.acc[4]) des = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", self.acc[4])], limit=1) if des: self.df.loadEntry("T", pag, p + 5, data=des[0]) self.df.loadEntry(frt, pag, p + 6, data=self.acc[5]) des = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", self.acc[5])], limit=1) if des: self.df.loadEntry("T", pag, p + 7, data=des[0]) self.df.loadEntry(frt, pag, p + 8, data=self.acc[6]) des = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", self.acc[6])], limit=1) if des: self.df.loadEntry("T", pag, p + 9, data=des[0]) def doDepCode(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("assdep", cols=["asd_desc"], where=[("asd_cono", "=", self.opts["conum"]), ("asd_code", "=", w)], limit=1) if not chk: return "Invalid Depreciation Code" self.df.loadEntry(frt, pag, p + 1, data=chk[0]) def doAsset(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) if not acc: return "Invalid G/L Account" self.df.loadEntry("T", pag, p + 1, data=acc[0]) def doAccum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) if not acc: return "Invalid G/L Account" self.df.loadEntry("T", pag, p + 1, data=acc[0]) def doExpense(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) if not acc: return "Invalid G/L Account" self.df.loadEntry("T", pag, p + 1, data=acc[0]) def doDelete(self): chk = self.sql.getRec("assmst", where=[("asm_cono", "=", self.opts["conum"]), ("asm_group", "=", self.group)]) if chk: return "Group in Use, Not Deleted" self.sql.delRec("assgrp", where=[("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", self.group)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): if x == 3 or (self.glint == "Y" and x in (5, 7, 9)): continue data.append(self.df.t_work[0][0][x]) if self.glint == "N": data.extend([0, 0, 0]) if self.new == "Y": self.sql.insRec("assgrp", data=data) elif data != self.acc[:len(data)]: col = self.sql.assgrp_col data.append(self.acc[col.index("asg_xflag")]) self.sql.updRec("assgrp", data=data, where=[("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", self.group)]) 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 ms1030(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", "ctlpwr"], prog=self.__class__.__name__) if self.sql.error: return self.pwd = "" return True def mainProcess(self): sss = [] self.sys_data = [] for ctl in pwctrl: if ctl[0] not in sss: sss.append(ctl[0]) for s in sss: self.sys_data.append([s, allsys[s][0]]) self.sys_data.sort() coy = { "stype": "R", "tables": ("ctlmst",), "cols": ( ("ctm_cono", "", 0, "Num"), ("ctm_name", "", 0, "Name", "Y")), "extra": ((0, "All Companies"),)} sys = { "stype": "C", "titl": "Select the System", "head": ("SYS", "Description"), "data": self.sys_data} self.ctl = { "stype": "C", "titl": "Available Control Codes", "head": ("Sys","Code","Description"), "data": pwctrl, "index": 1, "retn": "D"} pwd = { "stype": "R", "tables": ("ctlpwr",), "cols": ( ("pwd_code", "", 0, "Code"), ("pwd_desc", "", 0, "Description", "Y")), "whera": [["T", "pwd_cono", 0], ["T", "pwd_sys", 1]]} fld = ( (("T",0,0,0),"IUI",3,"Company","", "","Y",self.doCompany,coy,None,None), (("T",0,1,0),"IUA",3,"System","", "","N",self.doSystem,sys,None,("notblank",)), (("T",0,2,0),"INA",20,"Code","", "","N",self.doCode,pwd,None,("notblank",)), (("T",0,3,0),"ONA",50,"Description"), (("T",0,4,0),"IHA",30,"Password","", "","N",self.doPwd,None,self.doDelete,None)) but = ( ("Show All",self.ctl,None,0,("T",0,1),("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 doCompany(self, frt, pag, r, c, p, i, w): if w: nam = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", w)], limit=1) if not nam: return "Invalid Company Number" self.coy = w self.sys = None def doSystem(self, frt, pag, r, c, p, i, w): d1 = "" for sys in self.sys_data: if w in sys: d1 = sys[1] break if not d1: return "Invalid System Code" if w == "MST" and self.coy: return "Company Invalid with MST Code" self.sys = w self.mod_data = [] for mod in pwctrl: if self.sys == mod[0]: self.mod_data.append(mod) self.ctl["data"] = self.mod_data def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.desc = "" for cod in self.mod_data: if self.code in cod: self.desc = cod[2] break if not self.desc: return "Invalid Password Code" self.df.loadEntry(frt, pag, p+1, data=self.desc) acc = self.sql.getRec("ctlpwr", cols=["pwd_desc", "pwd_pass"], where=[("pwd_cono", "=", self.coy), ("pwd_sys", "=", self.sys), ("pwd_code", "=", self.code)], limit=1) if not acc: self.new = "y" else: self.new = "n" self.df.loadEntry(frt, pag, p+2, data=b64Convert("decode", acc[1])) def doPwd(self, frt, pag, r, c, p, i, w): self.pwd = w def doEnd(self): if self.pwd: pwd = b64Convert("encode", self.pwd) if self.new == "y": self.sql.insRec("ctlpwr", data=[self.coy, self.sys, self.code, self.desc, pwd]) else: self.sql.updRec("ctlpwr", cols=["pwd_desc", "pwd_pass"], data=[self.desc, pwd], where=[("pwd_cono", "=", self.coy), ("pwd_sys", "=", self.sys), ("pwd_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) elif self.new == "n": self.doDelete() def doDelete(self): self.sql.delRec("ctlpwr", where=[("pwd_cono", "=", self.coy), ("pwd_sys", "=", self.sys), ("pwd_code", "=", self.code)]) 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) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class stc410(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, "strloc", 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 return True def mainProcess(self): loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } self.fld = ((("T", 0, 0, 0), "IUA", 1, "Location Code", "", "", "N", self.doLoc, loc, None, ("notblank", )), (("T", 0, 1, 0), "INA", 30, "Description", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N", None, None, None, None), (("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N", None, None, None, None), (("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N", None, None, None, None), (("T", 0, 5, 0), "INA", 30, "Address Line 4", "", "", "N", None, None, None, None)) but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0))) tnd = ((self.doEnd, "Y"), ) txt = (self.doCloseProcess, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doLoc(self, frt, pag, r, c, p, i, w): if w == "0": return "Invalid Location" self.loc = w self.acc = self.sql.getRec("strloc", where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", self.loc)], limit=1) if not self.acc: self.new = "Y" else: self.new = "N" for x in range(1, self.df.topq[pag]): self.df.loadEntry(frt, pag, p + x, data=self.acc[x + 1]) def doDelete(self): self.sql.delRec("strloc", where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", self.loc)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): data.append(self.df.t_work[0][0][x]) if self.new == "Y": self.sql.insRec("strloc", data=data) elif data != self.acc[:len(data)]: col = self.sql.strloc_col data.append(self.acc[col.index("srl_xflag")]) self.sql.updRec("strloc", data=data, where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", self.loc)]) 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 doCloseProcess(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class msc110(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, ["ctlsys", "ctlpwu", "chglog", "genmst"], prog=self.__class__.__name__) if self.sql.error: if self.sql.error == ["genmst"]: self.gl = False else: return else: self.gl = True self.acc = self.sql.getRec("ctlsys", limit=1) if not self.acc: self.new = True self.acc = [ 0, "N", 0, 0, 0, "", 0, 0, 0, "", "", "N", "", "", "N", 0 ] else: self.new = False return True def drawDialog(self): r1s = (("Yes", "Y"), ("No", "N")) r2s = (("None", "0"), ("STARTTLS", "1"), ("SSL/TLS", "2")) r3s = (("None", "0"), ("Normal", "1"), ("Encrypted", "2")) self.fld = ( (("T",0,0,0),"IUI",2,"Years to Keep History","", self.acc[0],"N",self.doHist,None,None,None,None, "The number of years that historical data must be kept, "\ "Use 0 for No Limit"), (("T",0,1,0),("IRB",r1s),0,"Enforce Passwords","", self.acc[1],"N",self.doMust,None,None,None), (("T",0,2,0),"IUI",2,"Minimum Characters","", self.acc[2],"N",None,None,None,None), (("T",0,3,0),"IUI",2,"Maximum Life (Days)","", self.acc[3],"N",None,None,None,None), (("T",0,4,0),"IUI",3,"Backup History (Days)","", self.acc[4],"N",None,None,None,None,None, "0 for No Limit"), (("T",0,5,0),"ITX",30,"SMTP Server","", self.acc[5],"N",self.doSmtp,None,None,None), (("T",0,6,0),("IRB",r2s),0,"SMTP Security","", self.acc[6],"N",None,None,None,None), (("T",0,7,0),("IRB",r3s),0,"SMTP Authentication","", self.acc[7],"N",self.doAuth,None,None,None), (("T",0,8,0),"IUI",4,"SMTP Port","", self.acc[8],"N",None,None,None,None), (("T",0,9,0),"ITX",20,"SMTP Username","", self.acc[9],"N",self.doUsr,None,None,None), (("T",0,10,0),"IHA",20,"SMTP Password","", self.acc[10],"N",None,None,None,None), (("T",0,11,0),("IRB",r1s),0,"SMS Service","", self.acc[11],"N",self.doSms,None,None,None), (("T",0,12,0),"ITX",20,"SMS Username","", self.acc[12],"N",self.doSmsUsr,None,None,None), (("T",0,13,0),"IHA",20,"SMS Password","", self.acc[13],"N",self.doSmsPwd,None,None,None), (("T",0,14,0),("IRB",r1s),0,"G/L Departments","", self.acc[14],"N",self.doGlDept,None,None,None,None, "G/L Account Numbers include Department Numbers"), (("T",0,15,0),"IUI",1,"Number of Digits","", self.acc[15],"N",None,None,None,None,None, "The Number of Digits used for Department Numbers")) but = (("Accept", None, self.doAccept, 0, (("T", 0, 1), ("T", 0, 6)), ("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, focus=False) for n, f in enumerate(self.acc): self.df.loadEntry("T", 0, n, data=f) self.df.focusField("T", 0, 1, clr=False) def doHist(self, frt, pag, r, c, p, i, w): if w and w < 5: return "At least 5 Years of History should be kept" def doMust(self, frt, pag, r, c, p, i, w): if w == "N": self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 2, data=0) return "sk2" def doSmtp(self, frt, pag, r, c, p, i, w): if not w: self.df.loadEntry(frt, pag, p + 1, data="0") self.df.loadEntry(frt, pag, p + 2, data="0") self.df.loadEntry(frt, pag, p + 3, data="") self.df.loadEntry(frt, pag, p + 4, data="") self.df.loadEntry(frt, pag, p + 5, data="") return "sk5" def doAuth(self, frt, pag, r, c, p, i, w): if not int(w): self.df.loadEntry(frt, pag, p + 1, 25) self.df.loadEntry(frt, pag, p + 2, "") self.df.loadEntry(frt, pag, p + 3, "") return "sk3" elif int(self.df.t_work[0][0][6]) == 1: self.df.loadEntry(frt, pag, p + 1, 587) elif int(self.df.t_work[0][0][6]) == 2: self.df.loadEntry(frt, pag, p + 1, 465) def doUsr(self, frt, pag, r, c, p, i, w): if not w: return "Invalid SMTP Name" def doSms(self, frt, pag, r, c, p, i, w): if w == "Y" and not chkMod("requests"): showError(self.opts["mf"].body, "Error", "Missing requests Module") w = "N" self.df.loadEntry(frt, pag, p, data=w) if w == "N": self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 2, data="") if not self.gl: self.df.loadEntry(frt, pag, p + 3, data="N") self.df.loadEntry(frt, pag, p + 4, data=0) return "sk4" return "sk2" def doSmsUsr(self, frt, pag, r, c, p, i, w): if not w: return "Invalid SMS User Name" def doSmsPwd(self, frt, pag, r, c, p, i, w): if not w: return "Invalid SMS Password" def doGlDept(self, frt, pag, r, c, p, i, w): if w == "N": self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doEnd(self): svr = self.df.t_work[0][0][5] if svr: prt = self.df.t_work[0][0][8] sec = self.df.t_work[0][0][6] aut = self.df.t_work[0][0][7] nam = self.df.t_work[0][0][9] pwd = self.df.t_work[0][0][10] chk = sendMail([svr, prt, sec, aut, nam, pwd], "", "", "", check=True, err=self.opts["mf"].body, wrkdir=self.opts["mf"].rcdic["wrkdir"]) if not chk: self.df.focusField("T", 0, 6) return tme = time.localtime() data = copyList(self.df.t_work[0][0]) if self.new: self.sql.insRec("ctlsys", data=data) elif data != self.acc[:len(data)]: self.sql.updRec("ctlsys", data=data) dte = int("%04i%02i%02i%02i%02i%02i" % tme[:-3]) for num, dat in enumerate(self.acc): if dat != data[num]: self.sql.insRec("chglog", data=[ "ctlsys", "U", "%03i" % 0, self.sql.ctlsys_col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) # Reset all password dates to current date (Temporary Fix) dte = (tme[0] * 10000) + (tme[1] * 100) + tme[2] self.sql.updRec("ctlpwu", cols=["usr_last"], data=[dte]) self.opts["mf"].dbm.commitDbase() self.doExit() 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 doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class drc210(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"]) drsctl = gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return if drsctl["ctd_chain"] == "N": showError(self.opts["mf"].body, "Error", "Chain Stores are Not Enabled") return self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "drschn"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): chm = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Chn"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } self.fld = ((("T", 0, 0, 0), "IUI", 3, "Chn", "Chainstore Number", "", "N", self.doChain, chm, None, ("notzero", )), (("T", 0, 1, 0), "INA", 30, "Name", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N", None, None, None, ("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N", None, None, None, ("efld", )), (("T", 0, 5, 0), "INA", 4, "Postal Code", "", "", "N", None, None, None, ("efld", )), (("T", 0, 6, 0), "INA", 20, "Telephone", "", "", "N", None, None, None, ("efld", )), (("T", 0, 7, 0), "INA", 20, "Fax", "", "", "N", None, None, None, ("efld", )), (("T", 0, 8, 0), "ITX", 50, "E-Mail Address", "", "", "N", None, None, None, ("email", )), (("T", 0, 9, 0), "INA", 30, "Contact", "", "", "N", None, None, None, ("efld", )), (("T", 0, 10, 0), "IUA", 1, "Vat Code", "", "", "N", self.doVat, vtm, None, ("notblank", )), (("T", 0, 10, 0), "ONA", 30, "")) but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None)) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, butt=but, tend=tnd, txit=txt) def doChain(self, frt, pag, r, c, p, i, w): self.chain = w self.acc = self.sql.getRec("drschn", where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", self.chain)], limit=1) if not self.acc: self.new = "Y" else: self.new = "N" vat = self.sql.getRec( "ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", self.acc[self.sql.drschn_col.index("chm_vatind")])], limit=1) if not vat: txt = "Invalid Vat Record" else: txt = vat[0] for x in range(0, self.df.topq[pag]): if x == (self.df.topq[pag] - 1): self.df.loadEntry(frt, pag, p + x, data=txt) else: self.df.loadEntry(frt, pag, p + x, data=self.acc[x + 1]) def doVat(self, frt, pag, r, c, p, i, w): vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) if not vat: return "Invalid Vat Record" self.df.loadEntry(frt, pag, p + 1, data=vat[0]) def doDelete(self): self.sql.delRec("drschn", where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", self.chain)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): dat = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): if x == 11: continue dat.append(self.df.t_work[0][0][x]) if self.new == "Y": self.sql.insRec("drschn", data=dat) elif dat != self.acc[:len(dat)]: col = self.sql.drschn_col dat.append(self.acc[col.index("chm_xflag")]) self.sql.updRec("drschn", data=dat, where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", self.chain)]) 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 rcc310(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, ["rcaint", "chglog"], prog=self.__class__.__name__) if self.sql.error: return return True def drawDialog(self): dat = { "stype": "R", "tables": ("rcaint", ), "cols": (("rci_date", "", 0, "Date-Chg"), ("rci_prime", "", 0, "Prime"), ("rci_bankr", "", 0, "BankR"), ("rci_admin", "", 0, "Admin")), "where": [("rci_cono", "=", self.opts["conum"])], "order": "rci_date" } self.fld = ((("T", 0, 0, 0), "ID1", 10, "Date of Change", "", 0, "N", self.doDate, dat, None, ("efld", )), (("T", 0, 1, 0), "IUD", 5.2, "Prime Rate", "", 0, "N", None, None, self.doDelete, ("notzero", )), (("T", 0, 2, 0), "IUD", 5.2, "Bank Rate", "", 0, "N", None, None, None, ("notzero", )), (("T", 0, 3, 0), "IUD", 5.2, "Comm Rate", "", 0, "N", None, None, None, ("efld", ))) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) but = (("_Import File",None,self.doImport,0,("T", 0, 1),("T", 0, 2), "Import a File with the Correct Format i.e. Date, Prime Rate, "\ "Bank Rate, Fee Rate"),) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, tend=tnd, txit=txt, butt=but) def doImport(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") tit = ("Interest File Import", ) fle = { "stype": "F", "types": "fle", "ftype": (("CSV & XLS Files", "*.[c,x][s,l][v,s]"), ) } r1s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), "IFF", 50, "File Name", "", "", "N", self.doImpFle, fle, None, ("file", )), (("T", 0, 1, 0), ("IRB", r1s), 0, "Delete Existing", "", "N", "N", self.doImpDel, None, None, None)) tnd = ((self.doImpEnd, "n"), ) txt = (self.doImpExit, ) self.ip = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=tnd, txit=txt) self.ip.mstFrame.wait_window() 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 doImpFle(self, frt, pag, r, c, p, i, w): self.impfle = w def doImpDel(self, frt, pag, r, c, p, i, w): self.impdel = w def doImpEnd(self): self.ip.closeProcess() if self.impdel == "Y": self.sql.delRec("rcaint", where=[("rci_cono", "=", self.opts["conum"])]) impcol = [["Date", 0, "D1", 10], ["Prime Rate", 1, "UD", 5.2], ["Bank Rate", 2, "UD", 5.2], ["Fee Rate", 3, "UD", 5.2]] fi = FileImport(self.opts["mf"], impfle=self.impfle, impcol=impcol) err = None for num, line in enumerate(fi.impdat): if len(line) != len(impcol): err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \ (num + 1, len(impcol), len(line)) break date = CCD(line[0], "D1", 10) prime = CCD(line[1], "UD", 5.2) bank = CCD(line[2], "UD", 5.2) fees = CCD(line[3], "UD", 5.2) chk = self.sql.getRec("rcaint", where=[("rci_cono", "=", self.opts["conum"]), ("rci_date", "=", date.work)]) if chk: err = "Line %s: A Record for Date, %s, Already Exists" % \ (num + 1, date.disp) break self.sql.insRec("rcaint", data=[ self.opts["conum"], date.work, prime.work, bank.work, fees.work ]) if err: showError(self.opts["mf"].body, "Import Error", err) else: self.opts["mf"].dbm.commitDbase( ask=True, mess="Would you like to COMMIT All Imported Interest Rates?") def doImpExit(self): self.ip.closeProcess() def doDate(self, frt, pag, r, c, p, i, w): self.date = w self.acc = self.sql.getRec("rcaint", where=[("rci_cono", "=", self.opts["conum"]), ("rci_date", "=", self.date)], limit=1) if self.acc: self.new = False for n, f in enumerate(self.acc[1:-1]): self.df.loadEntry("T", 0, n, data=f) else: self.new = True def doDelete(self): self.sql.delRec("rcaint", where=[("rci_cono", "=", self.opts["conum"]), ("rci_date", "=", self.date)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["rcaint", "D", "%03i%8s" % \ (self.opts["conum"], self.date), "", dte, self.opts["capnm"], "", "", "", 0]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEnd(self): data = [self.opts["conum"]] for x in range(0, len(self.df.t_work[0][0])): data.append(self.df.t_work[0][0][x]) if self.new: self.sql.insRec("rcaint", data=data) elif data != self.acc[:len(data)]: col = self.sql.rcaint_col data.append(self.acc[col.index("rci_xflag")]) self.sql.updRec("rcaint", data=data, where=[("rci_cono", "=", self.opts["conum"]), ("rci_date", "=", self.date)]) 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=[ "rcaint", "U", "%03i%8s" % (self.opts["conum"], self.date), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class rcc110(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return mods = ctlmst["ctm_modules"] self.genleg = False for x in range(0, len(mods), 2): if mods[x:x + 2] == "GL": self.genleg = True break tabs = ["rcactl", "tplmst", "chglog"] if self.genleg: tabs.extend(["ctlctl", "genmst"]) self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return self.acc = self.sql.getRec("rcactl", where=[("cte_cono", "=", self.opts["conum"]) ], limit=1) if not self.acc: self.new = True self.acc = [ self.opts["conum"], "N", 0, 0, "statement_owner", "statement_tenant", "", "" ] else: self.new = False if self.genleg: self.ctl = [["rca_com", "Commission Raised", 0], ["rca_dep", "Deposits Control", 0], ["rca_fee", "Contract Fees", 0], ["rca_own", "Owners Control", 0], ["rca_orx", "Owners Charges", 0], ["rca_tnt", "Tenants Control", 0], ["rca_trx", "Tenants Charges", 0]] ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return for num, ctl in enumerate(self.ctl): if ctl[0] in ctlctl: self.ctl[num][2] = ctlctl[ctl[0]] return True def drawDialog(self): ctl = { "stype": "R", "tables": ("ctlctl", "genmst"), "cols": (("ctl_code", "", 0, "Ctl-Code"), ("ctl_conacc", "", 0, "G/L-Num"), ("glm_desc", "", 30, "Description")), "where": [("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono", ), ("glm_acno=ctl_conacc", )], "index": 1 } tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")), "where": [("tpm_type", "=", "R"), ("tpm_system", "=", "RCA")], "order": "tpm_tname" } r1s = (("Yes", "Y"), ("No", "N")) if self.genleg: glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30, "Description")), "where": [("glm_cono", "=", self.opts["conum"])] } fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "", self.acc[1], "N", self.doGlint, None, None, None), (("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "", self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 1, 0), "ONA", 30, ""), (("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "", self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 2, 0), "ONA", 30, ""), (("T", 0, 3, 0), "IUI", 7, self.ctl[2][1], "", self.ctl[2][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 3, 0), "ONA", 30, ""), (("T", 0, 4, 0), "IUI", 7, self.ctl[3][1], "", self.ctl[3][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 4, 0), "ONA", 30, ""), (("T", 0, 5, 0), "IUI", 7, self.ctl[4][1], "", self.ctl[4][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 5, 0), "ONA", 30, ""), (("T", 0, 6, 0), "IUI", 7, self.ctl[5][1], "", self.ctl[5][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 6, 0), "ONA", 30, ""), (("T", 0, 7, 0), "IUI", 7, self.ctl[6][1], "", self.ctl[6][2], "N", self.doGenAcc, glm, None, ("efld", )), (("T", 0, 7, 0), "ONA", 30, ""), (("T", 0, 8, 0), "IUI", 7, "Bank Account", "", self.acc[2], "N", self.doGlbnk, ctl, None, ("efld", ))] seq = 9 else: fld = [] seq = 0 fld.extend([(("T", 0, seq, 0), "ID1", 10, "Last Month End", "", self.acc[3], "N", None, None, None, ("efld", )), (("T", 0, seq + 1, 0), "INA", 20, "Owner Template", "", self.acc[4], "N", self.doTplNam, tpm, None, None), (("T", 0, seq + 2, 0), "INA", 20, "Tenant Template", "", self.acc[5], "N", self.doTplNam, tpm, None, None), (("T", 0, seq + 3, 0), "ITX", 50, "Email Address", "", self.acc[6], "N", None, None, None, ("email", ))]) but = (("Quit", None, self.doExit, 1, None, None), ) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt) if not self.new: s = 0 for n, f in enumerate(self.acc[1:-1]): if not self.genleg and n < 2: continue self.df.loadEntry("T", 0, s, data=f) s += 1 if not n: for c in self.ctl: self.df.loadEntry("T", 0, s, data=c[2]) s += 1 self.df.loadEntry("T", 0, s, data=self.getDes(c[2])) s += 1 self.df.focusField("T", 0, 1, clr=False) def doGlint(self, frt, pag, r, c, p, i, w): if w == "N": for x in range(1, 16): self.df.loadEntry(frt, pag, p + x, data="") return "sk15" def doGenAcc(self, frt, pag, r, c, p, i, w): des = self.getDes(w) if not des: return "Invalid Account Number" self.df.loadEntry(frt, pag, p + 1, data=des) def getDes(self, acno): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acno)], limit=1) if acc: return acc[0] else: return "" def doGlbnk(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec(tables=["ctlctl", "genmst"], cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w), ("ctl_cono=glm_cono", ), ("ctl_conacc=glm_acno", ), ("ctl_code", "like", "bank_%")], limit=1) if not acc: return "Invalid Bank Account Number" def doTplNam(self, frt, pag, r, c, p, i, w): if c == 18: typ = "O" else: typ = "T" acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "S"), ("tpm_system", "=", "RCA"), ("tpm_sttp", "=", typ)], limit=1) if not acc: return "Invalid Template Name" def doEnd(self): data = [self.opts["conum"]] if not self.genleg: data.extend(["N", 0]) for x, d in enumerate(self.df.t_work[0][0]): if self.genleg and x < 16: if x in (1, 3, 5, 7, 9, 11, 13): y = int((x - 1) / 2) chk = self.sql.getRec("ctlctl", where=[("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "=", self.ctl[y][0])], limit=1) if chk: self.sql.updRec("ctlctl", cols=["ctl_conacc"], data=[d], where=[("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "=", self.ctl[y][0])]) else: self.sql.insRec("ctlctl", data=[ self.opts["conum"], self.ctl[y][0], self.ctl[y][1], d, "", "N", "N" ]) elif x in (2, 4, 6, 8, 10, 12, 14): continue else: data.append(d) else: data.append(d) if self.new: self.sql.insRec("rcactl", data=data) elif data != self.acc[:len(data)]: col = self.sql.rcactl_col data.append(self.acc[col.index("cte_xflag")]) self.sql.updRec("rcactl", data=data, where=[("cte_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=[ "rcactl", "U", "%03i" % self.opts["conum"], col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.opts["mf"].dbm.commitDbase() self.doExit() def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()