class dr2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): # Check for Valid Posting Routine if self.opts["rtn"] not in (1, 3, 4, 5): showError(self.opts["mf"].body, "Control Error", "Invalid Routine %s, Only 1, 3, 4 and 5 Are Allowed" % \ str(self.opts["rtn"])) return # Create SQL Object self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "drschn", "drsmst", "drstrn", "genint", "genmst", "gentrn"], prog=self.__class__.__name__) if self.sql.error: return # Check for Intercompany Facility if not self.sql.getRec("ctlmst", cols=["count(*)"], where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]: self.incoac = False else: itg = self.sql.getRec("genint", cols=["cti_inco"], where=[("cti_cono", "=", self.opts["conum"])]) if itg: self.incoac = [self.opts["conum"]] [self.incoac.append(coy[0]) for coy in itg] else: self.incoac = False self.gc = GetCtl(self.opts["mf"]) drsctl = self.gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return self.glint = drsctl["ctd_glint"] self.glinp = drsctl["ctd_glinp"] self.chains = drsctl["ctd_chain"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["drs_ctl", "vat_ctl", "dis_all"] if self.gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.drsctl = ctlctl["drs_ctl"] self.dis_all = ctlctl["dis_all"] self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.allcoy = self.opts["conum"] ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if self.chains == "N": self.chain = 0 if self.opts["rtn"] == 1: self.glt = 1 elif self.opts["rtn"] == 3: self.glt = 4 elif self.opts["rtn"] == 4: self.glt = 1 elif self.opts["rtn"] == 5: self.glt = 2 self.agevar = tk.BooleanVar() self.agevar.set(False) return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return if self.opts["rtn"] == 4: self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) def drawDialog(self): drc = { "stype": "R", "tables": ("drschn",), "cols": ( ("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])]} drm = { "stype": "R", "tables": ("drsmst",), "cols": ( ("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1"))} if self.chains == "Y": drm["where"] = [("drm_cono", "=", self.opts["conum"])] drm["whera"] = [["C", "drm_chain", 0, 1]] else: drm["where"] = [ ("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", 0)] drm["where"].append(("drm_stat", "<>", "X")) coy = { "stype": "R", "tables": ("ctlmst",), "cols": ( ("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))} glm = { "stype": "R", "tables": ("genmst",), "cols": ( ("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "whera": [["C", "glm_cono", 0, 2]]} vtm = { "stype": "R", "tables": ("ctlvmf",), "cols": ( ("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])]} viw = { "stype": "R", "tables": ("drstrn",), "cols": ( ("drt_chain", "", 0, ""), ("drt_acno", "", 0, ""), ("drt_ref1", "", 0, ""), ("drt_trdt", "", 0, ""), ("drt_tramt", "", 0, ""), ("drt_taxamt", "", 0, "")), "where": [ ("drt_cono", "=", self.opts["conum"]), ("drt_type", "=", self.opts["rtn"]), ("drt_batch", "=", self.bh.batno)], "order": "drt_seq"} fld = [ (("T",0,0,0),"OUI",9,"Batch %s Quantity" % self.bh.batno), (("T",0,0,0),"OSD",13.2,"Value"), [("C",1,0,0),"IUI",3,"Chn","Chain Store", "r","Y",self.doChain,drc,None,("efld",)], [("C",1,0,1),"INA",7,"Acc-Num","Account Number", "r","N",self.doDrsAcc,drm,None,("notblank",)], [("C",1,0,2),"ONA",10,"Name"], (("C",1,0,3),"INa",9,"Reference","Reference Number One", "i","N",self.doRef1,None,None,("notblank",)), (("C",1,0,4),"ID1",10,"Date","Transaction Date", "r","N",self.doTrnDat,None,None,("efld",)), (("C",1,0,5),"ISD",13.2,"Amount","Transaction Amount", "","N",self.doTrnAmt,None,None,("efld",))] if self.opts["rtn"] == 5: fld[4][2] = 20 fld.extend([ [["C",1,0,6],"ISD",13.2,"Discount", "Discount Amount","","N",self.doDisAmt,None,None,None,None, "Discout Amount to be Added to the Transaction Amount"], [["C",1,0,7],"OSD",13.2,"Total-Amount"], [["C",1,0,8],"INA",(20,30),"Details","Transaction Details", "","N",self.doTrnDet,None,None,None]]) elif self.glint == "Y": if self.glinp == "E": tx1 = "Exc-Amount" tx2 = "Exclusive Amount" else: tx1 = "Inc-Amount" tx2 = "Inclusive Amount" fld[4][2] = 24 fld.extend([ [["C",1,0,6],"INA",30,"Details","Transaction Details", "","N",self.doTrnDet,None,None,None], [("T",2,0,0),"OSD",13.2,"Unallocated Balance"], [("C",2,0,0),"IUI",3,"Coy","Company Number", self.opts["conum"],"N",self.doCoyNum,coy,None,None], (("C",2,0,1),"IUI",7,"Acc-Num","Account Number", "","N",self.doGenAcc,glm,None,None), (("C",2,0,2),"ONA",19,"Description"), (("C",2,0,3),"IUA",1,"V","V.A.T Code", self.taxdf,"N",self.doVatCode2,vtm,None,("notblank",)), (("C",2,0,4),"ISD",13.2,tx1,tx2, "","N",self.doAllAmt,None,None,("efld",)), (("C",2,0,5),"ISD",13.2,"V.A.T","V.A.T Amount", "","N",self.doAllVat,None,None,None), [("C",2,0,6),"INA",(26,30),"Details","", "","N",self.doAllDet,None,None,("notblank",)]]) if not self.incoac: fld[10][1] = "OUI" else: fld[4][2] = 22 fld.extend([ (("C",1,0,6),"IUA",1,"V","V.A.T Code", self.taxdf,"N",self.doVatCode1,vtm,None,("notblank",)), (("C",1,0,7),"ISD",13.2,"V.A.T","V.A.T Amount", "","N",self.doVatAmt,None,None,None), [["C",1,0,8],"INA",(20,30),"Details","Transaction Details", "","N",self.doTrnDet,None,None,None]]) if self.chains == "N": fld[2][1] = "OUI" idx = 2 else: idx = 1 but = ( ("Interrogate",None,self.queryDrs,0,("C",1,idx),("C",1,idx+1), "Interrogate Debtors Records",1), ("View Entries",viw,None,0,("C",1,idx),("C",1,idx+1), "View Batch Transactions",1), ("Maintain",None,self.maintainDrs,0,("C",1,idx),("C",1,idx+1), "Maintain Debtors Records",1), ("Canc_el",None,self.doCancel,0,("C",2,1),("C",1,1), "Cancel the Entry",1), ("Age _Normal",None,self.doAgeNormal,0,None,None, "Only Show Unallocated Transactions",2), ("Age _History",None,self.doAgeHistory,0,None,None, "Show All Transactions Including Already Allocated",2), ("Age _Automatic",None,self.doAgeAuto,0,None,None, "Automatically Allocate the Amount Starting With the "\ "Oldest Unallocated One",2), ("Age _Current",None,self.doAgeCurrent,0,None,None, "Leave the Transaction Unallocated",2)) tag = [("Transaction", None, None, None, False)] cnd = [(None,"n"), (self.endPage1,"y")] cxt = [None, self.exitPage1] if self.opts["rtn"] != 5 and self.glint == "Y": tag.append(("Allocation", None, None, None, False)) cnd.append((self.endPage2,"y")) cxt.append(self.exitPage2) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doChain(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drschn", cols=["chm_chain"], where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", w)], limit=1) if not acc: return "Invalid Chain Store" self.chain = w def doDrsAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[1] == "X": return "Invalid Account, Redundant" self.dracno = w self.name = acc[0] self.df.loadEntry("C", pag, p+1, data=self.name) def doRef1(self, frt, pag, r, c, p, i, w): self.ref1 = w acc = self.sql.getRec("drstrn", cols=["drt_batch"], where=[("drt_cono", "=", self.opts["conum"]), ("drt_chain", "=", self.chain), ("drt_acno", "=", self.dracno), ("drt_type", "=", self.opts["rtn"]), ("drt_ref1", "=", self.ref1)], limit=1) if acc: return "Transaction Already Exists" def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w if self.glint == "Y" or self.opts["rtn"] == 5: self.vatcode = "N" self.vatamt = 0 def doVatCode1(self, frt, pag, r, c, p, i, w): vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if vrte is None: return "Invalid V.A.T Code" self.vatcode = w self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p+1, self.vatamt) if not self.vatamt: return "sk1" def doVatAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.vatamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.vatamt = float(ASD(0) - ASD(w)) else: self.vatamt = w self.df.loadEntry(frt, pag, p, data=self.vatamt) def doDisAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.disamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.disamt = float(ASD(0) - ASD(w)) else: self.disamt = w self.df.loadEntry(frt, pag, p, data=self.disamt) totamt = float(ASD(self.trnamt) + ASD(self.disamt)) self.df.loadEntry(frt, pag, p+1, data=totamt) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.opts["rtn"] != 5 and self.glint == "Y": self.df.colf[2][6][5] = w self.allocated = float(0.00) def endPage1(self): self.cancel = False self.agecan = False self.batupd = False self.updateTables1() if self.cancel: return else: self.updateBatch() if self.trnamt == 0: self.df.advanceLine(1) else: self.allocated = float(0.0) if self.opts["rtn"] == 5 or self.glint == "N": self.doDrsTrn() self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.df.selPage("Allocation") self.df.loadEntry("T", 2, 0, data=self.trnamt) self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt self.amt = self.trnamt self.vat = self.vatamt if self.opts["rtn"] == 1: # Invoices recon = 0 self.dis = 0.00 elif self.opts["rtn"] == 3: # Journals recon = 0 self.dis = 0.00 elif self.opts["rtn"] == 4: # Credit Notes recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.vat = float(ASD(0) - ASD(self.vat)) self.dis = 0.00 elif self.opts["rtn"] == 5: # Payments if self.trnamt == 0: recon = self.curdt else: recon = 0 self.vat = 0.00 self.dis = self.disamt if self.opts["rtn"] == 1: self.doAgeCurrent() else: state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Choose an Ageing Option") for x in range(4, 8): if self.opts["rtn"] == 3 and x == 6: continue wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "normal") self.df.setWidget(self.df.B4, "focus") self.agevar.set(True) self.df.mstFrame.wait_variable(self.agevar) self.df.enableButtonsTags(state=state) if self.agecan: self.doCancel() return if self.glint == "N": return # General Ledger Control Transaction (Debtors) val = float(ASD(self.amt) + ASD(self.dis)) data = (self.opts["conum"], self.drsctl, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Bank) if self.opts["rtn"] == 5: val = float(ASD(0) - ASD(self.amt)) data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Discount) if self.dis: val = float(ASD(0) - ASD(self.dis)) data = (self.opts["conum"], self.dis_all, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def doAgeNormal(self): self.doAgeing("N") def doAgeHistory(self): self.doAgeing("H") def doAgeAuto(self): self.doAgeing("O") def doAgeCurrent(self): self.doAgeing("C") def doAgeing(self, atype): # Disable All Ageing Buttons for x in range(4, 8): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") self.opts["mf"].updateStatus("Select Transaction to Allocate Against") age = AgeAll(self.opts["mf"], system="drs", agetyp=atype, agekey=[self.opts["conum"], self.chain, self.dracno, self.opts["rtn"], self.ref1, self.curdt, self.amt, self.dis]) self.agecan = age.cancel if self.agevar.get(): self.agevar.set(False) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doCoyNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", w)], limit=1) if not acc: return "Invalid Company, Missing" if self.incoac and w not in self.incoac: return "Invalid Company, No Intercompany Record 1" if w != self.opts["conum"]: acc = self.sql.getRec("genint", where=[("cti_cono", "=", w), ("cti_inco", "=", self.opts["conum"])], limit=1) if not acc: return "Invalid Company, No Intercompany Record 2" self.allcoy = w def doGenAcc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.allcoy, w) if type(chk) is str: return chk if not chk[2]: self.taxgl = self.taxdf else: self.taxgl = chk[2] self.genacc = w self.df.loadEntry("C", pag, p+1, chk[0]) self.df.loadEntry("C", pag, p+2, data=self.taxgl) def doVatCode2(self, frt, pag, r, c, p, i, w): ctlctl = self.gc.getCtl("ctlctl", self.allcoy, error=False) if not ctlctl: return "Missing ctlctl Record for Company" if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]): return "Missing or Invalid Control Record" self.convat = ctlctl["vat_ctl"] self.vatrte = getVatRate(self.sql, self.allcoy, w, self.trndat) if self.vatrte is None: return "Invalid V.A.T Code" self.vatcode = w def doAllAmt(self, frt, pag, r, c, p, i, w): if not w: incamt = float(ASD(self.trnamt) - ASD(self.allocated)) elif self.glinp == "E": incamt = round((w * (100 + self.vatrte) / 100), 2) else: incamt = w self.allamt = round((incamt * 100 / (100 + self.vatrte)), 2) self.allvat = float(ASD(incamt) - ASD(self.allamt)) if self.glinp == "E": self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.df.loadEntry(frt, pag, p, data=incamt) self.df.loadEntry(frt, pag, p+1, data=self.allvat) if not self.allvat: self.df.loadEntry(frt, pag, p+2, data=self.name) return "sk1" def doAllVat(self, frt, pag, r, c, p, i, w): if (self.allamt < 0 and w > 0) or (self.allamt > 0 and w < 0): w = float(ASD(0) - ASD(w)) if self.glinp == "I" and w != self.allvat: self.allamt = float(ASD(self.allamt) + ASD(self.allvat) - ASD(w)) self.allvat = w self.df.loadEntry(frt, pag, p, data=self.allvat) self.df.loadEntry(frt, pag, p+1, data=self.name) def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): if self.agecan: ok = "yes" else: ok = askQuestion(self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.cancel = True self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) if self.glint == "Y" and self.opts["rtn"] != 5: self.df.clearFrame("C", 2) row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.selPage("Transaction") self.df.focusField("C", 1, col) def endPage2(self): self.updateTables2() self.allocated = float(ASD(self.allocated) + \ ASD(self.allamt) + ASD(self.allvat)) if self.allocated == self.trnamt: self.doDrsTrn() self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt if self.opts["rtn"] == 1: # Invoices self.credit() elif self.opts["rtn"] == 3: # Journals self.credit() elif self.opts["rtn"] == 4: # Credit Notes self.debit() def debit(self): amt = self.allamt vat = self.allvat self.restDebitCredit(amt, vat) def credit(self): amt = float(ASD(0) - ASD(self.allamt)) vat = float(ASD(0) - ASD(self.allvat)) self.restDebitCredit(amt, vat) def restDebitCredit(self, amt, vat): # VAT Transaction (ctlvtf) data = (self.allcoy, self.vatcode, "O", self.curdt, "D", self.opts["rtn"], self.bh.batno, self.ref1, self.trndat, self.dracno, self.alldet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return # General Ledger Transaction (Allocation) data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, amt, vat, self.alldet, self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany) if self.allcoy != self.opts["conum"]: # General Ledger Transaction (Intercompany From) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=", self.allcoy)], limit=1)[0] val = float(ASD(amt) + ASD(vat)) data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany To) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.allcoy), ("cti_inco", "=", self.opts["conum"])], limit=1)[0] val = float(ASD(0) - ASD(amt) - ASD(vat)) data = (self.allcoy, acc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if vat: # General Ledger Control Transaction (V.A.T.) data = (self.allcoy, self.convat, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, vat, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) self.vat = float(ASD(self.vat) + ASD(vat)) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def doDrsTrn(self): # Debtors Ledger Transaction data = [self.opts["conum"], self.chain, self.dracno, self.opts["rtn"], self.ref1, self.bh.batno, self.trndat, "", self.amt, self.vat, self.curdt, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("drstrn", data=data) if not self.dis: return data = [self.opts["conum"], self.chain, self.dracno, 6, self.ref1, self.bh.batno, self.trndat, "", self.dis, self.vat, self.curdt, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("drstrn", data=data) def updateBatch(self, rev=False): if rev: self.bh.batqty = self.bh.batqty - 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.batupd = True self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def queryDrs(self): callModule(self.opts["mf"], self.df, "dr4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def maintainDrs(self): callModule(self.opts["mf"], self.df, "dr1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class cr3080(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) crsctl = gc.getCtl("crsctl", self.opts["conum"]) if not crsctl: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.sql = Sql(self.opts["mf"].dbm, [ "ctlctl", "ctlmst", "crsctl", "crsmst", "crstrn", "crsage", "gentrn", "tplmst" ], prog=self.__class__.__name__) if self.sql.error: return self.glint = crsctl["ctc_glint"] self.bestac = crsctl["ctc_bestac"] self.besttp = crsctl["ctc_besttp"] self.bankac = crsctl["ctc_bankac"] self.tplnam = crsctl["ctc_tplnam"] self.fromad = crsctl["ctc_emadd"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if gc.chkRec(self.opts["conum"], ctlctl, ["crs_ctl"]): return self.crsctl = ctlctl["crs_ctl"] acc = self.sql.getRec("crstrn", cols=["max(crt_ref1)"], where=[("crt_cono", "=", self.opts["conum"]), ("crt_type", "=", 5), ("crt_ref1", "like", "EFT______")], limit=1) try: self.cats = int(acc[0][3:]) self.refs = int(acc[0][3:]) + 1 except: self.cats = 0 self.refs = 1 self.etotal = 0 return True def mainProcess(self): tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title", "Y")), "where": [("tpm_type", "=", "R"), ("tpm_system", "=", "CRS")], "order": "tpm_tname" } crm = { "stype": "R", "tables": ("crsmst", ), "cols": (("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")), "where": [("crm_cono", "=", self.opts["conum"]), ("crm_stat", "<>", "X")] } r1s = (("Yes", "Y"), ("Range", "R"), ("Singles", "S")) r2s = (("Yes", "Y"), ("No", "N")) r3s = (("Number", "N"), ("Name", "M"), ("Postal Code", "P")) r4s = (("Monthly", "M"), ("Daily", "D")) fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.tplnam, "Y", self.doTplNam, tpm, None, None), (("T", 0, 1, 0), ("IRB", r1s), 0, "Whole File", "", "S", "Y", self.doWhole, None, None, None), [["T", 0, 2, 0], "INA", 7, "From Account", "", "", "Y", self.doAcc, crm, None, None], [["T", 0, 3, 0], "INA", 7, "To Account", "", "", "Y", self.doAcc, crm, None, None], (("T", 0, 4, 0), ("IRB", r3s), 0, "Sort Order", "", "N", "Y", self.doSort, None, None, None), (("T", 0, 5, 0), ("IRB", r4s), 0, "Terms Base", "", "M", "Y", self.doFrequency, None, None, None), (("T", 0, 6, 0), ("IRB", r2s), 0, "Exceptions", "", "N", "Y", self.doExcepts, None, None, None), (("T", 0, 7, 0), "ID1", 10, "Due Date", "", self.sysdtw, "Y", self.doDuedat, None, None, ("efld", )), (("T", 0, 8, 0), "ID1", 10, "Payment Date", "", self.sysdtw, "Y", self.doPaydat, None, None, ("efld", ))) tnd = ((self.doEnd, "Y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, view=("N", "V"), mail=("B", "Y")) def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "R"), ("tpm_system", "=", "CRS")], limit=1) if not acc: return "Invalid Template Name" self.tname = w def doWhole(self, frt, pag, r, c, p, i, w): self.whole = w if self.whole in ("Y", "S"): self.sacc = "" self.eacc = "" self.df.loadEntry("T", 0, p + 1, data=self.sacc) self.df.loadEntry("T", 0, p + 2, data=self.eacc) return "sk2" def doAcc(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("crsmst", cols=["crm_name", "crm_stat"], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)], limit=1) if not chk: return "Invalid Creditors Account" if not chk[1] == "X": return "Invalid Account, Redundant" if c == 3: self.sacc = w else: self.eacc = w def doSort(self, frt, pag, r, c, p, i, w): self.sort = w def doFrequency(self, frt, pag, r, c, p, i, w): self.freq = w def doExcepts(self, frt, pag, r, c, p, i, w): self.excepts = w def doDuedat(self, frt, pag, r, c, p, i, w): self.duedtw = w self.duedtd = self.df.t_disp[pag][0][p] def doPaydat(self, frt, pag, r, c, p, i, w): self.paydtw = w self.paydtd = self.df.t_disp[pag][0][p] self.curdt = int(self.paydtw / 100) self.batno = "E%s" % self.curdt def doEnd(self): self.df.closeProcess() if self.excepts == "Y": self.doExceptions() self.emadd = self.df.repeml[2] if self.bestac: self.export = open( os.path.join( self.opts["mf"].rcdic["wrkdir"], "best%03d_%s.txt" % (self.opts["conum"], self.paydtw)), "w") # Header for BEST self.export.write("%1s%4s%-40s%8s%1s%8s%-15s%1s%2s%1s%9s%2s%4s"\ "\r\n" % ("*", self.bestac, self.opts["conam"], self.paydtw, "Y", "", "CREDITORS EFT", "+", self.besttp, 0, "", "01", "LIVE")) else: self.export = None if self.whole == "S": recs = getSingleRecords(self.opts["mf"], "crsmst", ("crm_acno", "crm_name"), where=[("crm_cono", "=", self.opts["conum"]), ("crm_termsb", "=", self.freq), ("crm_pyind", "<>", "N"), ("crm_stat", "<>", "X")]) else: if not self.eacc: self.eacc = "zzzzzzz" whr = [("crm_cono", "=", self.opts["conum"]), ("crm_acno", "between", self.sacc, self.eacc), ("crm_termsb", "=", self.freq), ("crm_pyind", "<>", "N"), ("crm_stat", "<>", "X")] if self.sort == "N": odr = "crm_acno" elif self.sort == "M": odr = "crm_name" else: odr = "crm_pcod" recs = self.sql.getRec("crsmst", where=whr, order=odr) if not recs: showError(self.opts["mf"].body, "Error", "No Accounts Selected") if recs: self.form = DrawForm(self.opts["mf"].dbm, self.tname, wrkdir=self.opts["mf"].rcdic["wrkdir"]) self.doLoadStatic() self.form.doNewDetail() p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True) for num, rec in enumerate(recs): p.displayProgress(num) if p.quit: self.opts["mf"].dbm.rollbackDbase() break self.doProcess(rec) p.closeProgress() if p.quit or not self.form.page: pass elif self.df.repeml[1] == "N" or self.emadd: self.df.repeml[2] = self.emadd self.doPrint() if self.bestac: # Trailer for BEST value = int(round((self.etotal * 100), 0)) self.export.write("%1s%4s%1s%30s%013u%47s\r\n" % \ (2, self.bestac, "T", "", value, "")) self.export.close() if self.glint == "Y" and self.etotal: # Create total transactions in GL data = [ self.opts["conum"], self.crsctl, self.curdt, self.paydtw, 2, self.refno, self.batno, self.etotal, 0.0, "Payment EFT%06i to EFT%06i" % (self.refs, self.cats), "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) data[1] = self.bankac data[7] = float(ASD(0) - ASD(self.etotal)) self.sql.insRec("gentrn", data=data) self.opts["mf"].dbm.commitDbase( ask=True, mess="""Would you like to commit all elecronic payments? If you decide to do this, you must remember to upload the BEST file to the Bank otherwise you are NOT going to Reconcile!""", default="no") if "wait" not in self.opts: self.opts["mf"].closeLoop() def doExceptions(self): crm = { "stype": "R", "tables": ("crsmst", ), "cols": (("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")), "where": [("crm_cono", "=", self.opts["conum"]), ("crm_termsb", "=", self.freq), ("crm_stat", "<>", "X")] } crt = { "stype": "R", "tables": ("crstrn", ), "cols": (("crt_ref1", "", 0, "Reference", "Y"), ("crt_type", ("XX", crtrtp), 3, "Typ"), ("crt_trdt", "", 0, "Date"), ("crt_tramt", "", 0, " Amount"), ("paid", "SD", 13.2, " Paid"), ("balance", "SD", 13.2, " Balance"), ("crt_paydt", "", 0, "Pay-Date"), ("crt_payind", "", 0, "I"), ("crt_payamt", "", 0, " Pay-Amnt")), "wtype": "D", "where": [], "order": "crt_ref1" } types = [] for x in range(1, len(crtrtp) + 1): types.append((x, crtrtp[x - 1][1])) typ = { "stype": "C", "titl": "Select the Required Type", "head": ("C", "Type"), "data": types } fld = ((("T", 0, 0, 0), "I@crm_acno", 0, "", "", "", "N", self.doExAcNo, crm, None, ("notblank", )), (("T", 0, 0, 0), "O@crm_name", 0, ""), (("C", 0, 0, 1), "I@crt_type", 0, "", "", "", "N", self.doExTrnTyp, typ, None, ("in", (1, 2, 3, 4, 5))), (("C", 0, 0, 0), "I@crt_ref1", 0, "", "", "", "N", self.doExTrnRef, crt, None, ("notblank", )), (("C", 0, 0, 2), "O@crt_trdt", 0, ""), (("C", 0, 0, 3), "OSD", 13.2, "Balance"), (("C", 0, 0, 4), "I@crt_payind", 0, "", "", "", "N", self.doExInd, None, None, ("in", ("Y", "N"))), (("C", 0, 0, 5), "I@crt_paydt", 0, "", "", "", "N", self.doExDte, None, None, ("efld", )), (("C", 0, 0, 6), "I@crt_payamt", 0, "", "", "", "N", self.doExAmt, None, None, ("efld", ))) tnd = ((self.doExEndTop, "n"), ) txt = (self.doExExitTop, ) cnd = ((self.doExEndCol, "y"), ) cxt = (self.doExExitCol, ) self.ex = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, cend=cnd, cxit=cxt) self.ex.mstFrame.wait_window() def doExAcNo(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec( "crsmst", cols=["crm_name", "crm_termsb", "crm_pyind", "crm_stat"], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[1] != self.freq: return "Invalid Terms Base" if acc[2] == "N": return "Invalid Payment Indicator" if acc[3] == "X": return "Invalid Account, Redundant" self.exacc = w self.ex.loadEntry(frt, pag, p + 1, data=acc[0]) def doExEndTop(self): self.ex.focusField("C", 0, 1) def doExExitTop(self): self.opts["mf"].dbm.commitDbase( ask=True, mess="Would you like to commit these exceptions?") self.ex.closeProcess() def doExTrnTyp(self, frt, pag, r, c, p, i, w): self.extyp = w data = [] # Build the data for the F1 choice selection col, dat = getTrn(self.opts["mf"].dbm, "crs", whr=[("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=", self.exacc), ("crt_type", "=", w)], zer="N") if dat: cols = ("crt_ref1", "crt_type", "crt_trdt", "crt_tramt", "paid", "balance", "crt_paydt", "crt_payind", "crt_payamt") for d in dat: rec = [] for cc in cols: rec.append(d[col.index(cc)]) data.append(rec) self.ex.colf[0][1][8]["where"] = data def doExTrnRef(self, frt, pag, r, c, p, i, w): col = ["crt_trdt", "balance", "crt_payind", "crt_paydt", "crt_payamt"] whr = [("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=", self.exacc), ("crt_type", "=", self.extyp), ("crt_ref1", "=", w)] c, d = getTrn(self.opts["mf"].dbm, "crs", whr=whr, lim=1) if not d: return "Invalid Transaction Number" if not d[0][c.index("balance")]: return "Transaction Has No Balance" self.exref = w self.exdte = d[0][c.index("crt_paydt")] self.examt = d[0][c.index("crt_payamt")] for pos, fld in enumerate(col): self.ex.loadEntry(frt, pag, p + 1 + pos, data=d[0][c.index(fld)]) def doExInd(self, frt, pag, r, c, p, i, w): self.exind = w if self.exind == "N": return "nd" def doExDte(self, frt, pag, r, c, p, i, w): self.exdte = w def doExAmt(self, frt, pag, r, c, p, i, w): self.examt = w def doExEndCol(self): # Update Transaction" self.sql.updRec("crstrn", cols=["crt_payind", "crt_paydt", "crt_payamt"], data=[self.exind, self.exdte, self.examt], where=[("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=", self.exacc), ("crt_type", "=", self.extyp), ("crt_ref1", "=", self.exref)]) self.ex.advanceLine(0) def doExExitCol(self): self.ex.focusField("T", 0, 1) def doLoadStatic(self): cmc = self.sql.ctlmst_col ctm = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"])], limit=1) for fld in cmc: dat = ctm[cmc.index(fld)] if fld in self.form.tptp: if fld == "ctm_logo": self.form.letterhead(cmc, ctm, fld, dat) continue self.form.tptp[fld][1] = dat if "letterhead" in self.form.tptp: self.form.letterhead(cmc, ctm, "letterhead", None) self.form.document_date(self.duedtd) def doProcess(self, crm): cmc = self.sql.crsmst_col tdc = self.form.sql.tpldet_col self.acno = crm[cmc.index("crm_acno")] eml = crm[cmc.index("crm_acc_email")] self.form.account_details("crm", cmc, crm, 1) for col in cmc: d = "%s_C00" % col if d in self.form.newdic: dat = crm[cmc.index(col)] self.form.newdic[d][tdc.index("tpd_text")] = dat jon = "cra_curdt <= %s" % self.curdt whr = [("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=", self.acno), ("crt_payind", "=", "Y"), ("crt_paydt", "<=", self.duedtw)] ctc, crt = getTrn(self.opts["mf"].dbm, "crs", jon=jon, whr=whr, zer="N") if not crt: return bal = 0 self.pay = 0 for d in crt: if d[ctc.index("balance")] < 0: d[ctc.index("crt_payamt")] = d[ctc.index("balance")] bal = float(ASD(bal) + ASD(d[ctc.index("balance")])) self.pay = float(ASD(self.pay) + ASD(d[ctc.index("crt_payamt")])) if self.pay > bal: self.pay = bal if self.pay > 0: self.bname = crm[cmc.index("crm_bname")] self.bibt = crm[cmc.index("crm_bibt")] self.bacc = crm[cmc.index("crm_bacc")] if self.bname and self.bibt and self.bacc: self.ptype = "E" # Electronic test = False while not test: self.cats += 1 self.refno = "EFT%06i" % self.cats # Check if Reference Number Already Exists chk = self.sql.getRec("crstrn", where=[("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=", self.acno), ("crt_type", "=", 5), ("crt_ref1", "=", self.refno) ]) if not chk: test = True else: self.ptype = "C" # Cheque self.doBody(ctc, crt, tdc) self.doTotal(tdc) self.doTail(tdc) if self.df.repeml[1] == "Y" and not self.emadd: self.df.repeml[2] = eml self.doPrint() def doPrint(self): if self.df.repeml[1] == "Y" and not self.emadd: key = "%s_%s" % (self.opts["conum"], self.acno) else: key = "%s_all" % self.opts["conum"] pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, key, ext="pdf") self.form.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header="%s Remittance Advice" % self.opts["conam"], repprt=self.df.repprt, fromad=self.fromad, repeml=self.df.repeml) if self.df.repeml[1] == "Y": self.form = DrawForm(self.opts["mf"].dbm, self.tname, wrkdir=self.opts["mf"].rcdic["wrkdir"]) self.doLoadStatic() self.form.doNewDetail() def doBody(self, ctc, crt, tdc): page = 0 count = 0 text = self.form.sql.tpldet_col.index("tpd_text") for trans in crt: trbal = trans[ctc.index("balance")] payamt = trans[ctc.index("crt_payamt")] if payamt > trbal: payamt = trbal trans[ctc.index("balance")] = payamt if not count: page += 1 count = self.doHeader(page) if count == self.form.maxlines: page = self.doCfwd(page) count = self.doHeader(page) for cod in self.form.body: if cod == "type_code": c = "crt_type" elif cod == "line_paid": c = "paid" elif cod == "line_balance": c = "balance" else: c = cod d = "%s_C%02i" % (cod, count) if cod == "type_code": ttyp = trans[ctc.index(c)] self.form.newdic[d][text] = crtrtp[ttyp - 1][0] else: self.form.newdic[d][text] = trans[ctc.index(c)] self.form.doDrawDetail(self.form.newdic[d]) if self.ptype == "E" and self.bestac: trtp = trans[ctc.index("crt_type")] ref1 = trans[ctc.index("crt_ref1")] # Create Ageing Transaction self.sql.insRec("crsage", data=[ self.opts["conum"], self.acno, trtp, ref1, self.curdt, 5, self.refno, payamt, 0 ]) count += 1 for x in range(count, self.form.maxlines): for cod in self.form.body: d = "%s_C%02i" % (cod, x) self.form.newdic[d][tdc.index("tpd_text")] = "BLANK" self.form.doDrawDetail(self.form.newdic[d]) def doHeader(self, page): tdc = self.form.sql.tpldet_col self.form.add_page() for key in self.form.newkey: nl = copyList(self.form.newdic[key]) if nl[tdc.index("tpd_place")] != "A": continue if nl[tdc.index("tpd_detseq")] == "crm_acno_C00": nl[tdc.index("tpd_text")] = self.acno elif nl[tdc.index("tpd_detseq")] == "page_number_C00": nl[tdc.index("tpd_text")] = str(page) self.form.doDrawDetail(nl) return 0 def doCfwd(self, page): if "carried_forward" in self.form.tptp: tdc = self.form.sql.tpldet_col line = copyList(self.form.cfwd) line[tdc.index("tpd_text")] = "Continued on Page %i" % (page + 1) self.form.doDrawDetail(line) return page + 1 def doTotal(self, tdc): for c in self.form.total: t = "%s_T00" % c if c in self.form.newdic: self.form.doDrawDetail(self.form.newdic[c]) elif t in self.form.newdic: self.form.doDrawDetail(self.form.newdic[t]) d = "%s_C00" % c if d in self.form.newdic: line = self.form.newdic[d] if c == "total_payment": line[tdc.index("tpd_text")] = self.pay self.form.doDrawDetail(line) if self.ptype == "E" and self.bestac: value = int(round((self.pay * 100), 0)) self.export.write("%1s%4s%06u%-7s%019u%1s%1s%011u%-20s%10s"\ "%-15s%1s\r\n" % (2, self.bestac, self.bibt, self.acno, int(self.bacc), "", "1", value, self.bname, "", self.opts["conam"][:15], "")) self.etotal = float(ASD(self.etotal) + ASD(self.pay)) # Create Payment and Ageing Transaction p = float(ASD(0) - ASD(self.pay)) self.sql.insRec("crstrn", data=[ self.opts["conum"], self.acno, 5, self.refno, self.batno, self.paydtw, "", p, 0.0, 0.0, self.curdt, 0, "", 0.0, "Electronic Payment", "", "", self.opts["capnm"], self.sysdtw, 0 ]) self.sql.insRec("crsage", data=[ self.opts["conum"], self.acno, 5, self.refno, self.curdt, 5, self.refno, p, 0 ]) def doTail(self, tdc): for c in self.form.tail: t = "%s_T00" % c if c in self.form.newdic: self.form.doDrawDetail(self.form.newdic[c]) elif t in self.form.newdic: self.form.doDrawDetail(self.form.newdic[t]) d = "%s_C00" % c if d in self.form.newdic: line = self.form.newdic[d] if c == "eft_message" and self.ptype == "E" and self.bestac: line[tdc.index("tpd_text")] = "ELECTRONIC TRANSFER AT %s "\ "REFERENCE %s" % (self.paydtd, self.refno) self.form.doDrawDetail(line) def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class bc2070(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", "bwltab", "bwlent", "bwltyp", "bwlpts", "bwlgme"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): bcp = { "stype": "R", "tables": ("bwlcmp",), "cols": ( ("bcm_code", "", 0, "Cod"), ("bcm_name", "", 0, "Name", "Y"), ("bcm_date", "", 0, "Date")), "where": [("bcm_cono", "=", self.opts["conum"])]} gme = { "stype": "R", "tables": ("bwlgme",), "cols": ( ("bcg_game", "", 0, "GC"), ("bcg_type", "", 0, "T"), ("bcg_date", "", 0, "Date")), "where": [("bcg_cono", "=", self.opts["conum"])], "whera": [("T", "bcg_ccod", 0, 0)], "group": "bcg_game"} skp = { "stype": "R", "tables": ("bwlent", "bwltab", "bwlgme"), "cols": ( ("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "", 0, "Names"), ("bcg_rink", "", 0, "RK")), "where": [ ("bce_cono", "=", self.opts["conum"]), ("btb_cono=bce_cono",), ("btb_tab=bce_scod",), ("bcg_cono=bce_cono",), ("bcg_scod=bce_scod",), ("bcg_ocod<900000",), ("bcg_sfor=0 and bcg_sagt=0",)], "whera": [ ("T", "bce_ccod", 0, 0), ("T", "bcg_ccod", 0, 0), ("T", "bcg_game", 2, 0)], "order": "bcg_rink"} fld = ( (("T",0,0,0),"I@bcm_code",0,"","", "","Y",self.doCmpCod,bcp,None,("notzero",)), (("T",0,0,0),"ONA",30,""), (("T",0,0,0),"I@bcg_game",0,"Game Number","", "","N",self.doGamCod,gme,None,("efld",)), (("T",0,0,0),"IUI",2,"Ends Completed","", 0,"N",self.doEndsFin,None,None,("efld",)), (("C",0,0,0),"I@bcg_scod",0,"","", "","N",self.doSkpCod,skp,None,("efld",)), (("C",0,0,0),"ONA",30,"Skp-Name"), (("C",0,0,0),"I@bcg_sfor",0,"","", "","N",self.doShots,None,None,("efld",)), (("C",0,0,0),"I@bcg_points",0,"","", "","N",self.doPoints,None,None,("efld",)), (("C",0,0,0),"O@bcg_ocod",0,""), (("C",0,0,0),"ONA",30,"Opp-Name"), (("C",0,0,0),"I@bcg_sagt",0,"","", "","N",self.doShots,None,None,("efld",)), (("C",0,0,0),"I@bcg_points",0,"","", "","N",self.doPoints,None,None,("efld",))) but = (("Quit",None,self.doQuit,1,None,None),) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) cnd = ((self.doEnd,"y"),) cxt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, rows=(19,), eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doCmpCod(self, frt, pag, r, c, p, i, w): com = self.sql.getRec("bwlcmp", cols=["bcm_name", "bcm_type"], where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", w)], limit=1) if not com: return "Invalid Competition Code" self.ccod = w self.code = com[1] self.df.loadEntry(frt, pag, p + 1, data=com[0]) if not self.code: bwltyp = [self.opts["conum"], 0, "KO", "K", 1, 0, 21, "N", 0, "N", "", 0, 0, "N", "N", ""] else: bwltyp = self.sql.getRec("bwltyp", where=[("bct_cono", "=", self.opts["conum"]), ("bct_code", "=", com[1])], limit=1) self.cfmat = bwltyp[self.sql.bwltyp_col.index("bct_cfmat")] self.groups = bwltyp[self.sql.bwltyp_col.index("bct_groups")] self.grgame = bwltyp[self.sql.bwltyp_col.index("bct_grgame")] 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"): totskp = self.sql.getRec("bwlent", cols=["count(*)"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)], limit=1)[0] pwrs = 2 self.games = 1 while pwrs < totskp: self.games += 1 pwrs = pwrs * 2 else: self.games = bwltyp[self.sql.bwltyp_col.index("bct_games")] self.ends = bwltyp[self.sql.bwltyp_col.index("bct_ends")] chk = self.sql.getRec("bwlgme", cols=["bcg_game", "sum(bcg_sfor)", "sum(bcg_sagt)", "sum(bcg_points)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_aflag", "in", ("", "D"))], group="bcg_game", order="bcg_game") for game in chk: self.gcod = game[0] if not game[1] and not game[2] and not game[3]: self.df.loadEntry(frt, pag, p + 2, data=self.gcod) break self.df.loadEntry(frt, pag, p + 3, data=self.ends) def doGamCod(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("bwlgme", cols=["bcg_aflag", "sum(bcg_ocod)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", w)], group="bcg_aflag") if not chk: return "Invalid Game Number" for ck in chk: if not ck[0] and not ck[1]: return "Invalid Game Number, Not Yet Drawn" if w != self.games: col = [ "bcg_game", "bcg_type", "sum(bcg_ocod)", "sum(bcg_sfor)", "sum(bcg_points)"] whr = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", ">", w)] drwn = self.sql.getRec("bwlgme", cols=col, where=whr, group="bcg_game, bcg_type", order="bcg_game") drawn = [] for n, d in enumerate(drwn): if d[1] == "S" and d[2]: if d[3] or d[4]: drawn = "X" break drawn.append(d[0]) if drawn == "X": showError(self.opts["mf"].body, "Error", "Results Have Already Been Captured for Game %s" % d[0]) return "Completed SvS Game %s" % d[0] elif drawn: if len(drawn) == 1: text = "Game %s" % drawn[0] plural = "Draw" word = "Has" else: text = "Games" for d in drawn: text += " %s" % d plural = "Draws" word = "Have" ok = askQuestion(self.opts["mf"].body, head="Draw Done", mess="""Strength v Strength %s %s Been Drawn. Do You Want to Delete the %s and Alter This Game's Results? You Will Then Have to Re-Print Reports and Re-Draw %s. If You Continue and Have Not Made a Backup You Will Not be Able to Restore. Do You Still Want to Continue?""" % (text, word, plural, text), default="no") if ok == "no": return "rf" col = ["bcg_date", "bcg_ocod", "bcg_rink"] dat = [0, 0, ""] if self.groups == "Y" and w == self.grgame: col.append("bcg_group") dat.append(0) col.extend(["bcg_sfor", "bcg_sagt", "bcg_points", "bcg_a_sfor", "bcg_a_sagt", "bcg_a_points", "bcg_aflag"]) dat.extend([0, 0, 0, 0, 0, 0, ""]) whr = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "in", tuple(drawn))] self.sql.updRec("bwlgme", cols=col, data=dat, where=whr) self.opts["mf"].dbm.commitDbase() elif chk[0] in ("A", "S"): return "Invalid Game Number, Abandoned or Skipped" self.gcod = w gtyp = self.sql.getRec("bwlgme", cols=["bcg_type"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", w)], limit=1)[0] bwlpts = self.sql.getRec("bwlpts", where=[("bcp_cono", "=", self.opts["conum"]), ("bcp_code", "=", self.code), ("bcp_ptyp", "=", gtyp)], limit=1) if not bwlpts: bwlpts = [self.opts["conum"], 0, "D", "N", 0, "N", 0, 0, 1, "N", 0, 0, ""] self.skins = bwlpts[self.sql.bwlpts_col.index("bcp_skins")] self.sends = bwlpts[self.sql.bwlpts_col.index("bcp_sends")] self.ponly = bwlpts[self.sql.bwlpts_col.index("bcp_p_only")] self.epts = bwlpts[self.sql.bwlpts_col.index("bcp_e_points")] self.spts = bwlpts[self.sql.bwlpts_col.index("bcp_s_points")] self.gpts = bwlpts[self.sql.bwlpts_col.index("bcp_g_points")] self.bpts = bwlpts[self.sql.bwlpts_col.index("bcp_bonus")] dif = bwlpts[self.sql.bwlpts_col.index("bcp_win_by")] self.win_by = [dif, dif * -1] dif = bwlpts[self.sql.bwlpts_col.index("bcp_lose_by")] self.lose_by = [dif, dif * -1] def doEndsFin(self, frt, pag, r, c, p, i, w): self.bonus = self.bpts if w != self.ends: if not w: but = (("Exit",1),("Skipped",2),("Abandoned",3)) ok = askChoice(self.opts["mf"].body, head="Zero Ends", mess="No Ends Completed, Choose Option", butt=but) if ok == 1: return "rf" elif ok == 2: self.sql.updRec("bwlgme", cols=["bcg_aflag"], data=["S"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.gcod)]) elif ok == 3: self.sql.updRec("bwlgme", cols=["bcg_ocod", "bcg_rink", "bcg_sfor", "bcg_sagt", "bcg_points", "bcg_a_sfor", "bcg_a_sagt", "bcg_a_points", "bcg_aflag"], data=[0, "", 0, 0, 0, 0, 0, 0, "A"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.gcod)]) self.opts["mf"].dbm.commitDbase() return "xt" ok = askQuestion(self.opts["mf"].body, head="Shortened", mess="Was This Game Shortened?", default="no") if ok == "no": return "rf" if self.bonus == "Y": ok = askQuestion(self.opts["mf"].body, head="Bonus Points", mess="Must Bonus Points Still be Awarded?", default="no") if ok == "no": self.bonus = "N" self.totpts = (w * self.epts) + self.gpts if self.skins == "Y": self.totpts = self.totpts + (int(w / self.sends) * self.spts) if self.bonus == "Y": self.maxpts = float(ASD(self.totpts) + ASD(1)) else: self.maxpts = self.totpts def doSkpCod(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=["btb_surname", "btb_names", "bcg_ocod", "bcg_sfor", "bcg_sagt", "bcg_points"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w), ("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)], limit=1) if not chk: return "Invalid Skip Code" if chk[3] or chk[4] or chk[5]: ok = askQuestion(self.opts["mf"].body, head="Already Entered", mess="""This Card Has Already Been Entered, Re-Enter? Shots For: %s Shots Against: %s Points: %s""" % (chk[3], chk[4], chk[5]), default="no") if ok == "no": return "rf" self.reenter = True else: self.reenter = False self.skp = w self.opp = chk[2] if self.opp > 900000: return "This Skip Had a Bye" if chk[1]: name = "%s, %s" % tuple(chk[:2]) else: name = chk[0] self.df.loadEntry(frt, pag, p + 1, data=name) if self.ponly == "N": self.df.loadEntry(frt, pag, p + 2, data=chk[3]) self.df.loadEntry(frt, pag, p + 3, data=chk[5]) self.df.loadEntry(frt, pag, p + 4, data=self.opp) if self.cfmat in ("D", "K"): opp = self.sql.getRec("bwltab", cols=["btb_surname", "btb_names"], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", self.opp)], limit=1) chk = opp + [chk[4], chk[3], 0] else: chk = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=["btb_surname", "btb_names", "bcg_sfor", "bcg_sagt", "bcg_points"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", self.opp), ("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)], limit=1) if chk[1]: name = "%s, %s" % tuple(chk[:2]) else: name = chk[0] self.df.loadEntry(frt, pag, p + 5, data=name) if self.ponly == "N": self.df.loadEntry(frt, pag, p + 6, data=chk[2]) self.df.loadEntry(frt, pag, p + 7, data=chk[4]) if self.ponly == "Y": self.mpts = self.totpts return "sk2" def doShots(self, frt, pag, r, c, p, i, w): if i == 2: self.s_for = w if self.cfmat in ("D", "K", "R"): self.p_for = 0 self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" if not self.s_for or (not self.totpts and self.bonus != "Y"): self.p_for = w self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" else: self.s_agt = w if self.cfmat in ("D", "K"): self.p_agt = 0 self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" if self.cfmat == "R": if self.s_for == self.s_agt: self.p_for = self.p_agt = .5 elif self.s_for > self.s_agt: self.p_for = 1 self.p_agt = 0 else: self.p_for = 0 self.p_agt = 1 self.df.loadEntry(frt, pag, p - 3, data=self.p_for) self.df.loadEntry(frt, pag, p + 1, data=self.p_agt) return "sk1" if not self.s_agt or (not self.totpts and self.bonus != "Y"): self.p_agt = w self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" self.mpts = self.totpts if self.bonus == "N": return diff = float(ASD(self.s_for) - ASD(self.s_agt)) if not diff: return if diff > self.win_by[0] or diff < self.win_by[1]: self.mpts = float(ASD(self.mpts) + ASD(1)) elif diff < self.lose_by[0] and diff > self.lose_by[1]: self.mpts = float(ASD(self.mpts) + ASD(1)) def doPoints(self, frt, pag, r, c, p, i, w): if w and w % 1 not in (0.0, 0.5): return "Invalid Decimal in Points" if w > self.maxpts: return "Invalid Points, Exceed Maximum" if i == 3: self.p_for = w self.df.loadEntry(frt, pag, p + 1, data=self.opp) chk = self.sql.getRec("bwltab", cols=["btb_surname", "btb_names"], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", self.opp)], limit=1) if chk[1]: name = "%s, %s" % tuple(chk[:2]) else: name = chk[0] self.df.loadEntry(frt, pag, p + 2, data=name) if self.ponly == "Y": self.s_for = w return "sk3" else: return "sk2" if not w: self.p_agt = float(ASD(self.mpts) - ASD(self.p_for)) self.df.loadEntry(frt, pag, p, data=self.p_agt) else: self.p_agt = w if self.ponly == "Y": self.s_agt = self.p_agt tot = float(ASD(self.p_for) + ASD(self.p_agt)) if tot != self.mpts: return "Invalid Total Points (%s s/b %s)" % (tot, self.mpts) def doEnd(self): if self.df.frt == "T": self.df.focusField("C", 0, 1) self.doLoadCards() else: if self.ponly == "Y" and not self.p_for and not self.p_agt: aflag = "S" elif self.ponly == "N" and not self.s_for and not self.s_agt: aflag = "S" else: aflag = "" col = [ "bcg_sfor", "bcg_sagt", "bcg_points", "bcg_a_sfor", "bcg_a_sagt", "bcg_a_points", "bcg_aflag"] whr = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.gcod)] w = whr[:] w.append(("bcg_scod", "=", self.skp)) self.sql.updRec("bwlgme", cols=col, data=[self.s_for, self.s_agt, self.p_for, self.s_for, self.s_agt, self.p_for, aflag], where=w) if self.cfmat not in ("D", "K"): w = whr[:] w.append(("bcg_scod", "=", self.opp)) self.sql.updRec("bwlgme", cols=col, data=[self.s_agt, self.s_for, self.p_agt, self.s_agt, self.s_for, self.p_agt, aflag], where=w) self.opts["mf"].dbm.commitDbase() if self.reenter: self.doLoadCards() else: self.df.advanceLine(0) def doLoadCards(self): whr = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.gcod)] if self.ponly == "Y": whr.append(("bcg_points", ">", 0)) else: whr.append(("(", "bcg_sfor", ">", 0, "or", "bcg_sagt", ">", 0, ")")) recs = self.sql.getRec("bwlgme", cols=["bcg_scod", "bcg_ocod"], where=whr, order="bcg_scod") if not recs: return self.df.clearFrame("C", 0) self.df.focusField("C", 0, 1) skips = [] seq = 0 for rec in recs: if rec[0] in skips: continue skips.extend(rec) col = [ "btb_surname", "btb_names", "bcg_sfor", "bcg_sagt", "bcg_points"] skp = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col, where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[0]), ("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)], limit=1) idx = seq * 8 self.df.loadEntry("C", 0, idx, data=rec[0]) if skp[1]: name = "%s, %s" % tuple(skp[:2]) else: name = skp[0] self.df.loadEntry("C", 0, idx + 1, data=name) self.df.loadEntry("C", 0, idx + 2, data=skp[2]) self.df.loadEntry("C", 0, idx + 3, data=skp[4]) if self.cfmat in ("D", "K"): tab = self.sql.getRec("bwltab", cols=col[:2], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", rec[1])], limit=1) opp = tab + [skp[3], skp[4], 0] else: opp = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col, where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[1]), ("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)], limit=1) self.df.loadEntry("C", 0, idx + 4, data=rec[1]) if opp[1]: name = "%s, %s" % tuple(opp[:2]) else: name = opp[0] self.df.loadEntry("C", 0, idx + 5, data=name) self.df.loadEntry("C", 0, idx + 6, data=opp[2]) self.df.loadEntry("C", 0, idx + 7, data=opp[4]) self.df.advanceLine(0) if seq < 17: seq += 1 def doExit(self): if self.df.frt == "C" and self.df.col != 1: chk = self.sql.getRec("bwlgme", where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.gcod), ("bcg_aflag", "in", ("", "D"))]) for c in chk: scod = c[self.sql.bwlgme_col.index("bcg_scod")] ocod = c[self.sql.bwlgme_col.index("bcg_ocod")] if scod > 900000 or ocod > 900000: continue if self.ponly == "Y": fors = c[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", "=", self.gcod), ("bcg_scod", "=", ocod)], limit=1)[0] else: fors = c[self.sql.bwlgme_col.index("bcg_sfor")] agts = c[self.sql.bwlgme_col.index("bcg_sagt")] if not fors and not agts: self.df.focusField(self.df.frt, self.df.pag, self.df.col, err="Missing Score Card for Skips %s and %s" % (scod, ocod)) return if self.cfmat in ("D", "K") and self.gcod != self.games: # Delete Next Round's Records whr = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod)] w = whr[:] w.append(("bcg_game", ">", self.gcod)) self.sql.delRec("bwlgme", where=w) # Create Next Round's Records whr.append(("bcg_game", "=", self.gcod)) odr = "bcg_group, bcg_pair, bcg_scod" g = self.sql.bwlgme_col for grp in range(1, 3): w = whr[:] w.append(("bcg_group", "=", grp)) recs = self.sql.getRec("bwlgme", where=w, order=odr) for num in range(0, len(recs), 2): pair = int(num / 2) + 1 rec1 = copyList(recs[num]) if len(recs) == 1: w = whr[:] w.append(("bcg_group", "=", 2)) rec2 = self.sql.getRec("bwlgme", where=w, order=odr, limit=1) grp = 2 else: rec2 = copyList(recs[num + 1]) skp1 = rec1[g.index("bcg_scod")] opp1 = rec1[g.index("bcg_ocod")] for1 = rec1[g.index("bcg_sfor")] agt1 = rec1[g.index("bcg_sagt")] skp2 = rec2[g.index("bcg_scod")] opp2 = rec2[g.index("bcg_ocod")] for2 = rec2[g.index("bcg_sfor")] agt2 = rec2[g.index("bcg_sagt")] if opp1 > 900000: pl1 = skp1 elif for1 > agt1: pl1 = skp1 else: pl1 = opp1 if opp2 > 900000: pl2 = skp2 elif for2 > agt2: pl2 = skp2 else: pl2 = opp2 dat = [self.opts["conum"], self.ccod, pl1, self.gcod + 1, "D", 0, pl2, "", grp, 0, 0, 0.0, 0, 0, 0.0, "", 0, pair] self.sql.insRec("bwlgme", data=dat) if len(recs) == 1: break self.opts["mf"].dbm.commitDbase() if self.cfmat in ("D", "K"): callModule(self.opts["mf"], self.df, "bc2050", coy=[self.opts["conum"], self.opts["conam"]], args=self.ccod) self.df.closeProcess() self.opts["mf"].closeLoop() def doQuit(self, event=None): col = ["count(*)"] whr = [ ("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.gcod), ("bcg_scod", "<", 900000), ("bcg_ocod", "<", 900000), ("bcg_sfor=0 and bcg_sagt=0",)] chk = self.sql.getRec("bwlgme", cols=col, where=whr, limit=1) if chk[0]: ok = askQuestion(self.opts["mf"].body, "Quit Capture", "Are You Sure that you would like to Quit before "\ "capturing All Results?", default="no") if ok == "no": self.df.focusField(self.df.frt, self.df.pag, self.df.col) return self.df.closeProcess() self.opts["mf"].closeLoop()
class ar2020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): if self.opts["rtn"] not in (1, 2, 3): mes = "Invalid Routine %s" % str(self.opts["rtn"]) showError(self.opts["mf"].body, "Control Error", mes) return self.gc = GetCtl(self.opts["mf"]) assctl = self.gc.getCtl("assctl", self.opts["conum"]) if not assctl: return self.glint = assctl["cta_glint"] self.rordp = assctl["cta_rordp"] tabs = [ "assgrp", "assmst", "assdep", "asstrn", "ctlvmf", "ctlvrf", "ctlvtf", "genint", "genmst", "gentrn" ] self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return if self.glint == "Y": # Check Sale of Asset Record ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"], ctlctl, "ass_sls"): return self.slsac = ctlctl["ass_sls"] # Check for VAT Control if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]): return self.convat = ctlctl["vat_ctl"] # Check All Group Control Records errs = ("Group %s Has An Invalid", "Asset Control Account (%s)", "Accumulated Depreciation Account (%s)", "Depreciation Expense Account (%s)") ass = self.sql.getRec( "assgrp", cols=["asg_group", "asg_assacc", "asg_depacc", "asg_expacc"], where=[("asg_cono", "=", self.opts["conum"])]) for acc in ass: for x in range(1, 4): chk = self.sql.getRec("genmst", where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acc[x])], limit=1) if not chk: mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x]) showError(self.opts["mf"].body, "Control Error", mess) return self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "ASS", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return if self.opts["rtn"] == 2: self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) def drawDialog(self): grp = { "stype": "R", "tables": ("assgrp", ), "cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0, "Description", "Y")), "where": [("asg_cono", "=", self.opts["conum"])] } cod = { "stype": "R", "tables": ("assmst", ), "cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0, "Description", "Y")), "where": [("asm_cono", "=", self.opts["conum"])], "whera": [["C", "asm_group", 0, 1]] } vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } data = [] for x in range(1, (len(armvtp) + 1)): data.append([x, armvtp[x - 1][1]]) mov = { "stype": "C", "titl": "Valid Types", "head": ("C", "Description"), "data": data } fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N", self.doAssGrp, grp, None, None), (("C", 1, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "r", "N", self.doAssCod, cod, None, ("notblank", )), (("C", 1, 0, 2), "ONA", 13, "Description"), (("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number One", "i", "N", self.doTrnRef, None, None, ("notblank", )), (("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 5), "IUI", 1, "M", "Movement Type", "r", "N", self.doTrnMov, mov, None, ("in", (1, 2, 3, 4, 5))), (("C", 1, 0, 6), "ISD", 13.2, "Company", "Company Amount", "", "N", self.doCoyAmt, None, None, None), (("C", 1, 0, 7), "ISD", 13.2, "Receiver", "Receiver Amount", "", "N", self.doRorAmt, None, None, None), (("C", 1, 0, 8), "IUA", 1, "V", "V.A.T Code", "C", "N", self.doVatCod, vtm, None, ("notblank", )), (("C", 1, 0, 9), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N", self.doVatAmt, None, None, None), (("C", 1, 0, 10), "INA", (13, 30), "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None)] if self.opts["rtn"] not in (1, 2) and self.glint == "Y": fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"], (("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doGenAcc, glm, None, None), (("C", 2, 0, 1), "ONA", 30, "Description"), (("C", 2, 0, 2), "ISD", 13.2, "All-Amt", "Allocation Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 3), "INA", 30, "Details", "", "", "N", self.doAllDet, None, None, ("notblank", ))]) but = (("Interrogate", None, self.queryAss, 0, ("C", 1, 1), ("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1))) tag = [("Transaction", None, None, None, False)] cnd = [(None, "n"), (self.endPage1, "y")] cxt = [None, self.exitPage1] if self.opts["rtn"] not in (1, 2) and self.glint == "Y": tag.append(("Allocation", None, None, None, False)) cnd.append((self.endPage2, "y")) cxt.append(self.exitPage2) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doAssGrp(self, frt, pag, r, c, p, i, w): whr = [("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", w)] acc = self.sql.getRec("assgrp", where=whr, limit=1) if not acc: return "Invalid Asset Group" self.group = w self.depcod = acc[self.sql.assgrp_col.index("asg_depcod")] self.assacc = acc[self.sql.assgrp_col.index("asg_assacc")] self.depacc = acc[self.sql.assgrp_col.index("asg_depacc")] self.expacc = acc[self.sql.assgrp_col.index("asg_expacc")] def doAssCod(self, frt, pag, r, c, p, i, w): self.code = w self.buydt = 0 self.seldt = 0 col = ["asm_desc", "asm_depcod"] whr = [("asm_cono", "=", self.opts["conum"]), ("asm_group", "=", self.group), ("asm_code", "=", self.code)] acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1) if not acc: ok = askQuestion(screen=self.opts["mf"].body, head="New Asset", mess="Asset does not exist, Create?") if ok == "no": return "Invalid Asset" self.doNewAsset() acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1) if not acc: return "Asset Not Found" self.new = "y" else: self.new = "n" dep = self.sql.getRec("assdep", cols=["asd_rate1r"], where=[("asd_cono", "=", self.opts["conum"]), ("asd_code", "=", acc[1])], limit=1) self.rate1r = dep[0] col = ["ast_date"] whr = [("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group), ("ast_code", "=", self.code), ("ast_mtyp", "=", 1)] pur = self.sql.getRec("asstrn", cols=col, where=whr, limit=1) if pur: self.buydt = pur[0] whr = [("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group), ("ast_code", "=", self.code), ("ast_mtyp", "in", (3, 5))] sel = self.sql.getRec("asstrn", cols=col, where=whr, limit=1) if sel: self.seldt = sel[0] self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doTrnRef(self, frt, pag, r, c, p, i, w): self.trnref = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w if self.new == "y": self.trnmov = 1 self.df.loadEntry(frt, pag, p + 1, data=self.trnmov) return "sk1" def doTrnMov(self, frt, pag, r, c, p, i, w): if type(w) == list: w = w[0] + 1 # Do some tests to see if not new again or already sold etc. if w == 4 and self.opts["rtn"] != 3: return "Depreciation Only Allowed with Journal Entries" if self.opts["rtn"] == 1 and w not in (1, 2): return "Invalid Choice For Payment" if self.opts["rtn"] == 2 and w not in (5, ): return "Invalid Choice For Receipt" if w == 1 and self.buydt: return "Asset Already Purchased" if w in (2, 3, 4, 5) and self.seldt: return "Asset Already Sold or Written Off" if w in (2, 3, 4, 5) and not self.buydt: return "Asset Not Yet Purchased" self.df.loadEntry(frt, pag, p, data=w) self.trnmov = w if self.trnmov == 3: bal = self.sql.getRec("asstrn", cols=["sum(ast_amt1)", "sum(ast_amt2)"], where=[("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group), ("ast_code", "=", self.code)], limit=1) self.coyamt = float(ASD(0) - ASD(bal[0])) self.df.loadEntry(frt, pag, p + 1, data=self.coyamt) self.roramt = float(ASD(0) - ASD(bal[0])) self.df.loadEntry(frt, pag, p + 2, data=self.roramt) self.vatcode = "" self.trnvat = 0 return "sk4" def doCoyAmt(self, frt, pag, r, c, p, i, w): if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0: ok = askQuestion(screen=self.opts["mf"].body, head="Debit", mess="Should this Amount not be a Credit Entry?") if ok == "yes": w = float(ASD(0) - ASD(w)) self.df.loadEntry(frt, pag, p, data=w) self.coyamt = w if self.rordp == "N" or not self.rate1r or self.trnmov != 4: self.roramt = 0 self.df.loadEntry(frt, pag, p + 1, data=self.roramt) if self.trnmov == 4: self.vatcode = "" self.trnvat = 0 self.df.loadEntry(frt, pag, p + 2, data=self.vatcode) self.df.loadEntry(frt, pag, p + 3, data=self.trnvat) return "sk3" return "sk1" def doRorAmt(self, frt, pag, r, c, p, i, w): if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0: ok = askQuestion(screen=self.opts["mf"].body, head="Debit", mess="Should this Amount not be a Credit Entry?") if ok == "yes": w = float(ASD(0) - ASD(w)) self.df.loadEntry(frt, pag, p, data=w) self.roramt = w self.vatcode = "" self.trnvat = 0 self.df.loadEntry(frt, pag, p + 1, data=self.vatcode) self.df.loadEntry(frt, pag, p + 2, data=self.trnvat) return "sk2" def doVatCod(self, frt, pag, r, c, p, i, w): vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if vrte is None: return "Invalid V.A.T Code" self.vatcode = w self.trnvat = round((self.coyamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p + 1, data=self.trnvat) if not self.trnvat: return "sk1" def doVatAmt(self, frt, pag, r, c, p, i, w): if self.coyamt < 0 and w > 0: self.trnvat = float(ASD(0) - ASD(w)) elif self.coyamt > 0 and w < 0: self.trnvat = float(ASD(0) - ASD(w)) else: self.trnvat = w self.df.loadEntry(frt, pag, p, data=self.trnvat) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.opts["rtn"] not in (1, 2) and self.glint == "Y": self.df.colf[2][3][5] = w def endPage1(self): self.batupd = False self.updateTables1() self.updateBatch() if self.coyamt == 0: self.df.advanceLine(1) else: self.allocated = float(0.0) if self.glint == "N" or self.opts["rtn"] in (1, 2) or \ self.trnmov == 4: self.opts["mf"].dbm.commitDbase() self.df.advanceLine(1) else: self.coyamt = float(ASD(0) - ASD(self.coyamt)) self.df.loadEntry("T", 2, 0, data=self.coyamt) self.df.selPage("Allocation") self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt self.amt = self.coyamt self.vat = self.trnvat if self.trnmov == 4: self.net = float(ASD(0) - ASD(self.coyamt)) self.ror = float(ASD(0) - ASD(self.roramt)) else: self.net = self.ror = float(ASD(self.coyamt) - ASD(self.trnvat)) if self.opts["rtn"] == 1: # Payments if self.coyamt == 0: self.recon = self.curdt else: self.recon = 0 acc = self.assacc self.glt = 2 elif self.opts["rtn"] == 2: # Receipts if self.coyamt == 0: self.recon = self.curdt else: self.recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.vat = float(ASD(0) - ASD(self.vat)) self.net = float(ASD(0) - ASD(self.net)) acc = self.assacc self.glt = 6 elif self.opts["rtn"] == 3: # Journal Entries self.recon = 0 if self.trnmov == 4: acc = self.depacc else: acc = self.assacc self.glt = 4 # Asset Register Transaction data = [ self.opts["conum"], self.group, self.code, self.opts["rtn"], self.trnref, self.bh.batno, self.trndat, self.trnmov, self.net, self.ror, self.vat, self.curdt, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("asstrn", data=data) if self.vatcode: # VAT Transaction (ctlvtf) data = (self.opts["conum"], self.vatcode, "I", self.curdt, "A", self.opts["rtn"], self.bh.batno, self.trnref, self.trndat, self.code, self.trndet, self.amt, self.vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return # General Ledger Asset or Depreciation Account data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.net, self.vat, self.trndet, self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.vat: # General Ledger Control Transaction (V.A.T.) data = [ self.opts["conum"], self.convat, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.vat, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) self.amt = float(ASD(0) - ASD(self.amt)) if self.opts["rtn"] in (1, 2): # General Ledger Control Transaction (Bank) data = [ self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.amt, 0.00, self.trndet, "N", "", self.recon, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) elif self.trnmov == 4: # General Ledger Expense Account (Depreciation) data = [ self.opts["conum"], self.expacc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.coyamt, self.vat, self.trndet, "N", "", self.recon, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) if self.trnmov == 5: # Sale of Asset # Raise Depreciation callModule(self.opts["mf"], None, "ar2030", coy=(self.opts["conum"], self.opts["conam"]), period=self.opts["period"], user=self.opts["capnm"], args=(self.curdt, self.group, self.code)) # Generate Sale amt = self.sql.getRec("asstrn", cols=["sum(ast_amt1)"], where=[("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group), ("ast_code", "=", self.code)], limit=1) if amt[0]: data = [ self.opts["conum"], self.slsac, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, amt[0], 0, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) data[1] = acc data[7] = float(ASD(0) - ASD(amt[0])) self.sql.insRec("gentrn", data=data) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doGenAcc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w) if type(chk) is str: return chk self.genacc = w self.df.loadEntry("C", pag, p + 1, data=chk[0]) def doAllAmt(self, frt, pag, r, c, p, i, w): if w == 0: self.allamt = float(ASD(self.coyamt) - ASD(self.allocated)) self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.allamt = w def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): ok = askQuestion(self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) self.df.clearFrame("C", 2) self.df.selPage("Transaction") row = int(int((self.df.last[1][1] - 1) / self.df.colq[1])) col = (row * self.df.colq[1]) + 1 self.df.focusField("C", 1, col) def endPage2(self): self.updateTables2() self.allocated = float(ASD(self.allocated) + ASD(self.allamt)) if self.allocated == self.coyamt: self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.coyamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt # General Ledger Transaction (Allocation) amt = float(ASD(0) - ASD(self.allamt)) data = (self.opts["conum"], self.genacc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, amt, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def updateBatch(self, rev=False): if rev: self.bh.batqty -= 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.coyamt)) else: self.batupd = True self.bh.batqty += 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.coyamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def doNewAsset(self): tit = ("Create New Asset", ) dep = { "stype": "R", "tables": ("assdep", ), "cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0, "Description", "Y")), "where": [("asd_cono", "=", self.opts["conum"])] } self.fld = ((("T", 0, 0, 0), "INA", 30, "Description", "", "", "N", None, None, None, ("notblank", )), (("T", 0, 1, 0), "INa", 3, "Dep Code", "Depreciation Code", self.depcod, "N", self.doDepCode, dep, None, ("notblank", )), (("T", 0, 1, 0), "ONA", 34, "")) tnd = ((self.doNewEnd, "N"), ) txt = (self.doNewXit, ) state = self.df.disableButtonsTags() self.na = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=self.fld, tend=tnd, txit=txt) self.na.mstFrame.wait_window() self.df.enableButtonsTags(state=state) 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.na.loadEntry(frt, pag, p + 1, data=chk[0]) def doNewEnd(self): dat = [self.opts["conum"], self.group, self.code] for x in range(len(self.na.t_work[0][0]) - 1): dat.append(self.na.t_work[0][0][x]) self.sql.insRec("assmst", data=dat) self.doNewXit() def doNewXit(self): self.na.closeProcess() def queryAss(self): callModule(self.opts["mf"], self.df, "ar4010", coy=(self.opts["conum"], self.opts["conam"]), period=self.opts["period"], user=self.opts["capnm"])
class ar2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): self.gc = GetCtl(self.opts["mf"]) assctl = self.gc.getCtl("assctl", self.opts["conum"]) if not assctl: return self.rordp = assctl["cta_rordp"] tabs = ["assgrp", "assmst", "assdep", "asstrn"] self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return self.dend = projectDate(self.opts["period"][1][0], -1) self.todat = 0 self.imports = False t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def drawDialog(self): grp = { "stype": "R", "tables": ("assgrp", ), "cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0, "Description", "Y")), "where": [("asg_cono", "=", self.opts["conum"])] } cod = { "stype": "R", "tables": ("assmst", ), "cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0, "Description", "Y")), "where": [("asm_cono", "=", self.opts["conum"])], "whera": [["C", "asm_group", 0, 0]] } dep = { "stype": "R", "tables": ("assdep", ), "cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0, "Description", "Y")), "where": [("asd_cono", "=", self.opts["conum"])] } self.fld = [(("T", 0, 0, 0), "ID1", 10, "Take-on Date", "", self.dend, "N", self.doTakeOnDate, None, None, ("efld", )), (("C", 0, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N", self.doAssGrp, grp, None, None), (("C", 0, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "", "N", self.doAssCod, cod, None, ("notblank", )), (("C", 0, 0, 2), "INA", 30, "Description", "Description", "", "N", self.doDesc, None, None, ("notblank", )), (("C", 0, 0, 3), "INa", 3, "Dep", "Depreciation Code", "", "N", self.doDepCode, dep, None, ("notblank", )), (("C", 0, 0, 4), "ONA", 10, "Dp-Details"), (("C", 0, 0, 5), "ID1", 10, "Purch-Date", "Purchase Date", 0, "N", self.doPurDat, None, None, ("efld", )), (("C", 0, 0, 6), "IUD", 10.2, "Cost", "Original Cost", 0, "N", self.doCost, None, None, ("notzero", )), (("C", 0, 0, 7), "IUD", 10.2, "Coy-Dep", "Company Depreciation", 0, "N", self.doCDep, None, None, ("efld", ))] if self.rordp == "Y": self.fld.append((("C", 0, 0, 8), "IUD", 10.2, "Rec-Dep", "Receiver Depreciation", 0, "N", self.doRDep, None, None, ("efld", ))) tnd = [[self.endPage, "y"]] txt = (self.exitPage, ) cnd = [[self.endPage, "y"]] cxt = (self.exitPage, ) but = ((("Import File",None,self.doImport,0,("T",0,0),("C",0,2), "Import a CSV or XLS File having the following fields: "\ "Asset Group, Code, Description, Depreciation Code, "\ "Purchase Date, Original Cost, Company Depeciation and "\ "Receiver Depreciation if applicable"),)) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, rows=(15, ), tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doTakeOnDate(self, frt, pag, r, c, p, i, w): if w < self.dend: return "Invalid Date, Too Far in the Past" self.todat = w def doAssGrp(self, frt, pag, r, c, p, i, w): self.group = w col = ["asg_depcod"] whr = [("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", self.group)] acc = self.sql.getRec("assgrp", cols=col, where=whr, limit=1) if not acc: return "Invalid Asset Group" self.depcod = acc[0] def doImport(self): self.df.closeProcess() self.imports = True impcol = [] for num, fld in enumerate(self.fld[1:]): if fld[0][3] == 4: continue if num > 4: num -= 1 impcol.append([fld[4], num, fld[1][1:], fld[2]]) fi = FileImport(self.opts["mf"], impcol=impcol) err = False for row, data in enumerate(fi.impdat): funcs = [ "doAssGrp", "doAssCod", "doDesc", "doDepCode", "doPurDat", "doCost", "doCDep" ] if self.rordp == "Y": funcs.append("doRDep") for col, func in enumerate(funcs): err = getattr(self, "%s" % func)("", 0, 0, 0, 0, 0, data[col]) if err: showError( self.opts["mf"].body, "Import Error", """Row %s Column %s - %s - %s Please Correct the Import File and Try Again.""" % (row, col, data[col], err)) break if err: break self.endPage() if err: self.opts["mf"].dbm.rollbackDbase() else: self.opts["mf"].dbm.commitDbase() self.opts["mf"].closeLoop() def doAssCod(self, frt, pag, r, c, p, i, w): self.code = w acc = self.sql.getRec("assmst", cols=["asm_desc"], where=[("asm_cono", "=", self.opts["conum"]), ("asm_group", "=", self.group), ("asm_code", "=", w)], limit=1) if acc: ok = askQuestion(screen=self.opts["mf"].body, head="Asset Exists", mess="""Asset already exists, Replace? Please Note that if you decide to Replace the Asset, the Original Asset will be Deleted along with any History which may exist.""", default="no") if ok == "no": return "Invalid Asset" self.sql.delRec("assmst", where=[("asm_cono", "=", self.opts["conum"]), ("asm_group", "=", self.group), ("asm_code", "=", self.code)]) self.sql.delRec("asstrn", where=[("ast_cono", "=", self.opts["conum"]), ("ast_group", "=", self.group), ("ast_code", "=", self.code)]) if not self.imports: self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w if not self.imports: self.df.loadEntry(frt, pag, p + 1, data=self.depcod) def doDepCode(self, frt, pag, r, c, p, i, w): col = ["asd_rate1r", "asd_desc"] chk = self.sql.getRec("assdep", cols=col, where=[("asd_cono", "=", self.opts["conum"]), ("asd_code", "=", w)], limit=1) if not chk: return "Invalid Depreciation Code" self.rate1r = chk[0] if not self.imports: self.df.loadEntry(frt, pag, p + 1, data=chk[1]) def doPurDat(self, frt, pag, r, c, p, i, w): if w > self.todat: return "Invalid Date, After Financial Period" self.purdat = w def doCost(self, frt, pag, r, c, p, i, w): self.ccst = w if self.rordp == "Y": self.rcst = w else: self.rcst = 0 def doCDep(self, frt, pag, r, c, p, i, w): self.cdep = float(ASD(0) - ASD(w)) if self.rordp == "N": self.rdep = 0 return if not self.rate1r: self.rdep = 0 if not self.imports: self.df.loadEntry(frt, pag, p + 1, data=self.rdep) return "sk1" def doRDep(self, frt, pag, r, c, p, i, w): self.rdep = float(ASD(0) - ASD(w)) def endPage(self): if self.df.frt == "T": self.df.focusField("C", 0, 1) return data = [ self.opts["conum"], self.group, self.code, self.desc, self.depcod ] self.sql.insRec("assmst", data=data) data = [ self.opts["conum"], self.group, self.code, 3, "Take-On", "Take-On", self.purdat, 1, self.ccst, self.rcst, 0, int(self.purdat / 100), "Original Cost", "", "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("asstrn", data=data) if self.cdep or self.rdep: data = [ self.opts["conum"], self.group, self.code, 3, "Take-On", "Take-On", self.todat, 4, self.cdep, self.rdep, 0, int(self.todat / 100), "Accumulated Depreciation", "", "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("asstrn", data=data) if not self.imports: self.df.advanceLine(0) def exitPage(self): self.df.closeProcess() if self.df.frt == "C": self.opts["mf"].dbm.commitDbase() self.opts["mf"].closeLoop()
class rt2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): tabs = [ "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint", "genmst", "gentrn", "rtlprm", "rtlmst", "rtlcon", "rtltrn" ] self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return if self.opts["rtn"] not in (2, 3, 4): mes = "Invalid Routine %s" % str(self.opts["rtn"]) showError(self.opts["mf"].body, "Control Error", mes) return self.gc = GetCtl(self.opts["mf"]) rtlctl = self.gc.getCtl("rtlctl", self.opts["conum"]) if not rtlctl: return self.glint = rtlctl["ctr_glint"] if self.glint == "Y": # Check All Premises Control Records errs = ("Premises %s Has An Invalid", "Rental Control Account (%s)", "Rental Income Account (%s)") ass = self.sql.getRec( "rtlprm", cols=["rtp_code", "rtp_rtlacc", "rtp_incacc"], where=[("rtp_cono", "=", self.opts["conum"])]) for acc in ass: for x in range(1, 3): chk = self.sql.getRec("genmst", where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", acc[x])], limit=1) if not chk: mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x]) showError(self.opts["mf"].body, "Control Error", mess) return # Check for VAT Control ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]): return self.convat = ctlctl["vat_ctl"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "RTL", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return if self.opts["rtn"] == 2: self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) return True def drawDialog(self): prm = { "stype": "R", "tables": ("rtlprm", ), "cols": (("rtp_code", "", 0, "Prm-Cod"), ("rtp_desc", "", 0, "Description", "Y")), "where": [("rtp_cono", "=", self.opts["conum"])] } mst = { "stype": "R", "tables": ("rtlmst", ), "cols": (("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")), "where": [("rtm_cono", "=", self.opts["conum"])], "whera": [["C", "rtm_code", 0, 1]] } con = { "stype": "R", "tables": ("rtlcon", ), "cols": (("rtc_cnum", "", 0, "Acc-Num"), ("rtc_payind", "", 0, "F"), ("rtc_start", "", 0, "Start-Date"), ("rtc_period", "", 0, "Per")), "where": [("rtc_cono", "=", self.opts["conum"])], "whera": [["C", "rtc_code", 0, 1], ["C", "rtc_acno", 1, 1]] } vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "INA", 7, "Prm-Cod", "Premises Code", "r", "N", self.doPrmCod, prm, None, None), (("C", 1, 0, 1), "INA", 7, "Acc-Num", "Account Number", "r", "N", self.doAccNum, mst, None, None), (("C", 1, 0, 2), "IUI", 3, "Seq", "Contract Sequence", "", "N", self.doConSeq, con, None, None), (("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number", "i", "N", self.doTrnRef, None, None, ("notblank", )), (("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 5), "ISD", 13.2, "Amount", "Transaction Amount", "", "N", self.doTrnAmt, None, None, None), (("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", "", "N", self.doVatCod, vtm, None, ("notblank", )), (("C", 1, 0, 7), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N", self.doVatAmt, None, None, None), [("C", 1, 0, 8), "INA", 30, "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None]] if self.opts["rtn"] not in (2, 3) and self.glint == "Y": fld[10][2] = (22, 30) fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"], (("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doGenAcc, glm, None, None), (("C", 2, 0, 1), "ONA", 30, "Description"), (("C", 2, 0, 2), "ISD", 13.2, "All-Amt", "Allocation Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 3), "INA", 30, "Details", "", "", "N", self.doAllDet, None, None, ("notblank", ))]) but = (("Interrogate", None, self.queryRtl, 0, ("C", 1, 1), ("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1))) tag = [("Transaction", None, None, None, False)] cnd = [(None, "n"), (self.endPage1, "y")] cxt = [None, self.exitPage1] if self.opts["rtn"] not in (2, 3) and self.glint == "Y": tag.append(("Allocation", None, None, None, False)) cnd.append((self.endPage2, "y")) cxt.append(self.exitPage2) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doPrmCod(self, frt, pag, r, c, p, i, w): whr = [("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", w)] acc = self.sql.getRec("rtlprm", where=whr, limit=1) if not acc: return "Invalid Premises Code" self.code = w self.rtlacc = acc[self.sql.rtlprm_col.index("rtp_rtlacc")] def doAccNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rtlmst", cols=["rtm_name", "rtm_vatind"], where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code", "=", self.code), ("rtm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" self.acno = w con = self.sql.getRec("rtlcon", where=[("rtc_cono", "=", self.opts["conum"]), ("rtc_code", "=", self.code), ("rtc_acno", "=", self.acno)], order="rtc_cnum") if not con: return "No Valid Contracts" self.cnum = con[-1:][0][3] self.df.colf[1][2][5] = self.cnum if self.opts["rtn"] == 4: self.df.colf[1][6][5] = acc[1] else: self.df.colf[1][6][5] = "N" def doConSeq(self, frt, pag, r, c, p, i, w): con = self.sql.getRec("rtlcon", where=[("rtc_cono", "=", self.opts["conum"]), ("rtc_code", "=", self.code), ("rtc_acno", "=", self.acno), ("rtc_cnum", "=", w)], order="rtc_cnum") if not con: return "Invalid Contract Sequence" self.cnum = w def doTrnRef(self, frt, pag, r, c, p, i, w): self.trnref = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w if self.opts["rtn"] in (2, 3): self.vatcode = "" self.trnvat = 0 return "sk2" def doVatCod(self, frt, pag, r, c, p, i, w): vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if vrte is None: return "Invalid V.A.T Code" self.vatcode = w self.trnvat = round((self.trnamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p + 1, data=self.trnvat) if not self.trnvat: return "sk1" def doVatAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.trnvat = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.trnvat = float(ASD(0) - ASD(w)) else: self.trnvat = w self.df.loadEntry(frt, pag, p, data=self.trnvat) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.opts["rtn"] not in (2, 3) and self.glint == "Y": self.df.colf[2][3][5] = w def endPage1(self): self.batupd = False self.updateTables1() self.updateBatch() if self.trnamt == 0: self.df.advanceLine(1) else: self.allocated = float(0.0) if self.opts["rtn"] in (2, 3) or self.glint == "N": self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.trnamt = float(ASD(self.trnamt) - ASD(self.trnvat)) self.df.loadEntry("T", 2, 0, data=self.trnamt) self.df.selPage("Allocation") self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt self.amt = self.trnamt self.vat = self.trnvat if self.opts["rtn"] == 2: # Receipts if self.trnamt == 0: self.recon = self.curdt else: self.recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.vat = float(ASD(0) - ASD(self.vat)) self.glt = 6 elif self.opts["rtn"] == 3: # Payments if self.trnamt == 0: self.recon = self.curdt else: self.recon = 0 self.glt = 2 elif self.opts["rtn"] == 4: # Journal Entries self.recon = 0 self.glt = 4 # Rental Ledger Transaction data = [ self.opts["conum"], self.code, self.acno, self.cnum, self.opts["rtn"], self.trnref, self.bh.batno, self.trndat, self.amt, self.vat, self.curdt, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("rtltrn", data=data) if self.vatcode: # VAT Transaction (ctlvtf) exc = float(ASD(0) - ASD(self.amt) + ASD(self.vat)) vat = float(ASD(0) - ASD(self.vat)) data = (self.opts["conum"], self.vatcode, "O", self.curdt, "R", self.opts["rtn"], self.bh.batno, self.trnref, self.trndat, self.code, self.trndet, exc, vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return # General Ledger Rental Account data = (self.opts["conum"], self.rtlacc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.amt, self.vat, self.trndet, self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) self.trnamt = float(ASD(0) - ASD(self.amt)) self.trnvat = float(ASD(0) - ASD(self.vat)) if self.vatcode and self.trnvat: # General Ledger Control Transaction (V.A.T.) data = (self.opts["conum"], self.convat, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.trnvat, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.opts["rtn"] in (2, 3): # General Ledger Control Transaction (Bank) data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.trnamt, 0.00, self.trndet, "N", "", self.recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doGenAcc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w) if type(chk) is str: return chk self.genacc = w self.df.loadEntry("C", pag, p + 1, data=chk[0]) def doAllAmt(self, frt, pag, r, c, p, i, w): if w == 0: self.allamt = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.allamt = w def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): ok = askQuestion(self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) self.df.clearFrame("C", 2) self.df.selPage("Transaction") row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.focusField("C", 1, col) def endPage2(self): self.updateTables2() self.allocated = float(ASD(self.allocated) + ASD(self.allamt)) if self.allocated == self.trnamt: self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt # General Ledger Transaction (Source) data = (self.opts["conum"], self.genacc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.allamt, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def updateBatch(self, rev=False): if rev: self.bh.batqty = self.bh.batqty - 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.batupd = True self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def queryRtl(self): callModule(self.opts["mf"], self.df, "rt4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class sc2030(object): def __init__(self, **opts): self.opts = opts if "test" not in opts: self.opts["test"] = None if self.setVariables(): if self.opts["test"]: self.doImport() else: self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["scpcmp", "scpmem", "scpent", "scpgme"], prog=self.__class__.__name__) if self.sql.error: return self.pair = 0 self.doimport = False return True def mainProcess(self): com = { "stype": "R", "tables": ("scpcmp", ), "cols": (("scp_ccod", "", 0, "CCD"), ("scp_name", "", 0, "Name", "Y"), ("scp_tsiz", "", 0, "S"), ("scp_fmat", "", 0, "F"), ("scp_nsec", "", 0, "NS"), ("scp_nent", "", 0, "NE")), "where": [("scp_cono", "=", self.opts["conum"])] } self.sec = { "stype": "C", "titl": "Available Sections", "head": ("Sec", "Club"), "typs": (("Ua", 3), ("NA", 30)), "data": [] } self.skp = { "stype": "R", "tables": ("scpmem", "scpgme"), "cols": (("a", "UI", 6, "S-Code"), ("b", "NA", 30, "Name", "Y"), ("c", "UI", 6, "O-Code"), ("d", "NA", 30, "Name"), ("e", "UI", 3, "For"), ("f", "UI", 3, "Agt")), "where": [], "wtype": "D" } tag = (("Results", None, ("T", 0, 0), ("T", 0, 1)), ) r1s = (("Main", "M"), ("Play-Offs", "P")) fld = ((("T", 0, 0, 0), "I@scp_ccod", 0, "", "", "", "Y", self.doCmpCod, com, None, ("notzero", )), (("T", 0, 0, 0), "O@scp_name", 0, ""), (("T", 0, 1, 0), ("IRB", r1s), 0, "Type", "", "", "N", self.doCmpTyp, None, None, None), (("T", 0, 2, 0), "I@scg_rnum", 0, "Round", "", "", "N", self.doRndNum, None, None, ("notzero", )), (("T", 1, 0, 0), "IUI", 2, "Section Number", "", "", "N", self.doSecNum, None, None, ("notzero", )), (("T", 1, 0, 0), "IUA", 1, "Sub-Section", "", "", "N", self.doSubNum, None, None, ("in", ("A", "B"))), (("C", 1, 0, 0), "I@scg_scod", 0, "", "", 0, "N", self.doSkpCod, self.skp, None, ("notzero", )), (("C", 1, 0, 0), "ONA", 30, "Skp-Name"), (("C", 1, 0, 0), "I@scg_sfor", 0, "", "", "", "N", self.doShots, None, None, ("efld", )), (("C", 1, 0, 0), "I@scg_ocod", 0, "", "", 0, "N", self.doSkpCod, self.skp, None, ("notzero", )), (("C", 1, 0, 0), "ONA", 30, "Opp-Name"), (("C", 1, 0, 0), "I@scg_sagt", 0, "", "", "", "N", self.doShots, None, None, ("efld", ))) tnd = ((self.doTopEnd, "y"), (self.doTopEnd, "n")) txt = (self.doTopExit, self.doTopExit) cnd = (None, (self.doColEnd, "n")) cxt = (None, self.doColExit) but = (("Import Results", None, self.doImport, 0, ("T", 1, 1), (("T", 1, 2), ("T", 1, 0))), ("Show Entries", None, self.doShow, 0, ("C", 1, 1), ("C", 1, 2))) self.df = TartanDialog(self.opts["mf"], tags=tag, eflds=fld, rows=(0, 16), tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doCmpCod(self, frt, pag, r, c, p, i, w): com = self.sql.getRec("scpcmp", where=[("scp_cono", "=", self.opts["conum"]), ("scp_ccod", "=", w)], limit=1) if not com: return "Invalid Competition Code" if not com[2]: return "Competiton Draw Not Yet Done" chk = self.sql.getRec("scpent", cols=["count(*)"], where=[("sce_cono", "=", self.opts["conum"]), ("sce_ccod", "=", w)], limit=1) if not chk[0]: return "There are No Entries for this Competition" self.ccod = w self.name = com[self.sql.scpcmp_col.index("scp_name")] self.fmat = com[self.sql.scpcmp_col.index("scp_fmat")] self.nsec = com[self.sql.scpcmp_col.index("scp_nsec")] self.nent = com[self.sql.scpcmp_col.index("scp_nent")] self.ssub = com[self.sql.scpcmp_col.index("scp_subs")] self.squa = com[self.sql.scpcmp_col.index("scp_qual")] self.clup = com[self.sql.scpcmp_col.index("scp_clup")] self.mrnds = com[self.sql.scpcmp_col.index("scp_mrnds")] self.prnds = com[self.sql.scpcmp_col.index("scp_prnds")] self.state = com[self.sql.scpcmp_col.index("scp_state")] if not self.doimport: self.df.loadEntry(frt, pag, p + 1, data=self.name) self.byenum = 900000 if self.state < 3: self.ctyp = "M" self.lrnd = self.mrnds if not self.doimport: self.df.loadEntry(frt, pag, p + 2, data=self.ctyp) return "sk2" elif self.state == 6: return "All Results Already Captured" else: self.ctyp = "P" self.lrnd = self.prnds if not self.doimport: self.df.loadEntry(frt, pag, p + 2, data=self.ctyp) def doCmpTyp(self, frt, pag, r, c, p, i, w): self.ctyp = w chk = self.sql.getRec( "scpgme", cols=["count(*)", "sum(scg_sfor)", "sum(scg_sagt)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P")], limit=1) if self.ctyp == "M": if chk[0] and (chk[1] or chk[2]): return "Play-Offs Already Started" self.lrnd = self.mrnds elif not chk[0]: return "Play-Offs Draw Not Yet Done" else: self.lrnd = self.prnds def doRndNum(self, frt, pag, r, c, p, i, w): if self.ctyp == "M" and self.clup == "Y" and w > 1: more = self.sql.getRec("scpgme", cols=["count(*)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_rnum", "=", w - 1), ("scg_ocod", "=", 0)], limit=1)[0] if more: return "Closed-Up Draw, Round %s Results Missing" % (w - 1) if w > self.lrnd: return "Invalid Round, Exceeds Maximum (%s)" % self.lrnd if w > 1: chk = self.sql.getRec("scpgme", cols=[ "scg_scod", "scg_ocod", "sum(scg_sfor)", "sum(scg_sagt)" ], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "=", w - 1)]) for s in chk: if s[0] < 900000 and s[1] < 900000 and not s[2] and not s[3]: return "Invalid Round, Previous Round Missing" chk = self.sql.getRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "<", w), ("scg_scod", "<", 900000), ("scg_ocod", "<", 900000), ("(", "scg_sfor", "=", 0, "and", "scg_sagt", "=", 0, ")")]) if chk: return "Previous Round Not Yet Completely Captured" chk = self.sql.getRec("scpgme", cols=["sum(scg_sfor)", "sum(scg_sagt)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", ">", w)], limit=1) if chk[0] or chk[1]: return "Invalid Round, Later Rounds Captured" chk = self.sql.getRec("scpgme", cols=["count(*)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "=", w), ("scg_scod", "<", 900000), ("scg_ocod", "<", 900000), ("scg_sfor", "=", 0), ("scg_sagt", "=", 0)])[0] if not chk: ok = askQuestion(self.opts["mf"].body, "Already Entered", """All Results for this Round Already Captured. Would you Like to Recapture this Round?""", default="no") if ok == "no": return "Already Captured" if self.fmat == "K" or self.ctyp == "R": if self.ctyp == "M" and w == self.mrnds: self.sql.delRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "R")]) else: self.sql.delRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "=", w + 1)]) self.rnum = w self.doimport = False def doImport(self): self.doimport = True if self.opts["test"]: self.ccod, self.rnum, impfle = self.opts["test"] err = self.doCmpCod("T", 0, 0, 0, 0, 0, self.ccod) if err: print(err) return self.doGetOldWin() impdlg = False else: impfle = None impdlg = True self.df.setWidget(self.df.mstFrame, state="hide") cols = [["scg_snum", 0, "UI", 2], ["scg_subs", 1, "UA", 1], ["scg_scod", 2, "UI", 6], ["scg_ocod", 3, "UI", 6], ["scg_sfor", 4, "UI", 2], ["scg_sagt", 5, "UI", 2]] fi = FileImport(self.opts["mf"], impcol=cols, impfle=impfle, impdlg=impdlg) if fi.impdat: if not self.opts["test"]: sp = ProgressBar(self.opts["mf"].body, typ="Importing Results", mxs=len(fi.impdat)) err = None for num, line in enumerate(fi.impdat): if not self.opts["test"]: sp.displayProgress(num) if not line[0]: continue whr = [("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", line[0]), ("scg_subs", "=", line[1]), ("scg_rnum", "=", self.rnum)] if self.clup == "Y": self.newo = True whr.append(("scg_scod", "in", (line[2], line[3]))) else: self.newo = False whr.append(("scg_scod", "=", line[2])) whr.append(("scg_ocod", "=", line[3])) chk = self.sql.getRec("scpgme", where=whr) if not chk: err = "Invalid Skip %s, Opponent %s" % (line[2], line[3]) break if line[2] > 900000 or line[3] > 900000: pass elif not line[4] and not line[5]: err = "Zero Results" break self.snum = line[0] self.subs = line[1] self.scod = line[2] self.ocod = line[3] self.sfor = line[4] self.sagt = line[5] self.doColEnd() if not self.opts["test"]: 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.ierr = False if self.ssub == "Y": secs = int(self.nsec / 2) else: secs = self.nsec for self.snum in range(1, secs + 1): if self.ssub == "Y": for self.subs in ("A", "B"): self.doColExit() if self.ierr: break if self.ierr: break else: self.subs = "" self.doColExit() if self.ierr: break if not self.ierr: self.opts["mf"].dbm.commitDbase() self.doTopExit() if not self.opts["test"]: self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField("T", 0, 1) def doSecNum(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", w)], limit=1) if not chk: return "Invalid Section Number" self.snum = w if self.ssub == "N" or self.ctyp == "P": self.subs = "" self.df.loadEntry(frt, pag, p + 1, data=self.subs) self.doLoadSkips() return "sk1" def doSubNum(self, frt, pag, r, c, p, i, w): self.subs = w self.doLoadSkips() def doTopEnd(self): if self.df.pag == 0: if self.ctyp == "P": self.snum = 1 self.df.loadEntry("T", 1, 0, data=self.snum) self.subs = "" self.df.loadEntry("T", 1, 1, data=self.subs) self.doLoadSkips() self.df.focusField("C", 1, 1) else: self.doGetOldWin() self.df.focusField("T", 1, 1) else: self.df.focusField("C", 1, 1) def doLoadSkips(self): col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"] whr = [("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "=", self.rnum), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_ocod", "<", 900000)] data = [] recs = self.sql.getRec("scpgme", cols=col, where=whr) for rec in recs: data.append((rec[0], self.getName(rec[0]), rec[1], self.getName(rec[1]), rec[2], rec[3])) self.skp["where"] = data def doTopExit(self): if not self.opts["test"] and self.df.pag == 0: self.df.closeProcess() self.opts["mf"].closeLoop() else: # Check all entries for round chk = self.sql.getRec("scpgme", cols=["count(*)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "=", self.rnum), ("scg_scod", "<", 900000), ("scg_ocod", "<", 900000), ("scg_sfor", "=", 0), ("scg_sagt", "=", 0)], limit=1)[0] if chk: txt = "Not All the Results for Round %s Captured" % self.rnum if self.opts["test"]: self.opts["mf"].dbm.rollbackDbase() return txt = "%s\n\nDo You want to Exit and Lose All Results for "\ "this Round?" % txt ok = askQuestion(self.opts["mf"].body, "Missing Results", txt, default="no") if ok == "yes": self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 4) else: self.df.focusField("T", 1, 1) return if self.rnum == self.lrnd: chk = self.sql.getRec("scpgme", cols=["count(*)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "M"), ("scg_scod", "<", 900000), ("scg_ocod", "<", 900000), ("scg_sfor", "=", 0), ("scg_sagt", "=", 0)], limit=1)[0] if not chk: # Update scpcmp if no missing entries self.sql.updRec("scpcmp", cols=["scp_state"], data=[3], where=[("scp_cono", "=", self.opts["conum"]), ("scp_ccod", "=", self.ccod)]) self.opts["mf"].dbm.commitDbase() if not self.doimport: if self.ctyp == "P": self.df.focusField("T", 0, 4) else: self.df.focusField("T", 0, 1) def doSkpCod(self, frt, pag, r, c, p, i, w): skp = self.sql.getRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", self.rnum), ("scg_scod", "=", w)], limit=1) if not skp: return "Invalid Skip" if skp[self.sql.scpgme_col.index("scg_ocod")] > 900000: return "Skip has a Bye" if i == 3: if w == self.scod: return "Playing Against Himself?" if skp[self.sql.scpgme_col.index("scg_ocod")]: return "Already Paired" self.ocod = w onam = self.getName(self.ocod) self.df.loadEntry("C", 1, p + 1, data=onam) self.df.loadEntry("C", 1, p + 2, data=0) return self.scod = w snam = self.getName(w) self.df.loadEntry("C", 1, p + 1, data=snam) sfor = skp[self.sql.scpgme_col.index("scg_sfor")] self.df.loadEntry("C", 1, p + 2, data=sfor) self.ocod = skp[self.sql.scpgme_col.index("scg_ocod")] if self.ocod: self.newo = False self.df.loadEntry("C", 1, p + 3, data=self.ocod) onam = self.getName(self.ocod) self.df.loadEntry("C", 1, p + 4, data=onam) ofor = skp[self.sql.scpgme_col.index("scg_sagt")] self.df.loadEntry("C", 1, p + 5, data=ofor) else: self.newo = True def getName(self, code): if code > 900000: return "Bye" nam = self.sql.getRec("scpmem", cols=["scm_surname", "scm_names"], where=[("scm_cono", "=", self.opts["conum"]), ("scm_scod", "=", code)], limit=1) return "%s, %s" % (nam[0], nam[1][0]) def doShots(self, frt, pag, r, c, p, i, w): if i == 2: self.sfor = w if not self.newo: return "sk2" else: self.sagt = w def doPoints(self, frt, pag, r, c, p, i, w): pass def doColEnd(self): if self.fmat == "K": if self.newo: self.sql.delRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", self.rnum), ("scg_scod", "=", self.ocod)]) cols = ["scg_ocod"] data = [self.ocod] else: cols = [] data = [] if self.clup == "Y": cols.extend(["scg_sfor", "scg_sagt", "scg_pair"]) self.pair += 1 data.extend([self.sfor, self.sagt, self.pair]) else: cols.extend(["scg_sfor", "scg_sagt"]) data.extend([self.sfor, self.sagt]) self.sql.updRec("scpgme", cols=cols, data=data, where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", self.rnum), ("scg_scod", "=", self.scod)]) else: if self.sfor == self.sagt: pfor = .5 pagt = .5 elif self.sfor > self.sagt: pfor = 1 pagt = 0 else: pfor = 0 pagt = 1 self.sql.updRec("scpgme", cols=["scg_sfor", "scg_sagt", "scg_pnts"], data=[self.sfor, self.sagt, pfor], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", self.rnum), ("scg_scod", "=", self.scod)]) self.sql.updRec("scpgme", cols=["scg_sfor", "scg_sagt", "scg_pnts"], data=[self.sagt, self.sfor, pagt], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", self.rnum), ("scg_scod", "=", self.ocod)]) self.scod = 0 if not self.doimport: self.doLoadSkips() self.df.advanceLine(1) def doShow(self): cols = (("scod", "Skip", 6, "UI", "N"), ("sname", "Name", 30, "NA", "N"), ("sfor", "Shots", 5, "UI", "N"), ("ocod", "Oppt", 6, "UI", "N"), ("oname", "Name", 30, "NA", "N"), ("sagt", "Shots", 5, "UI", "N")) recs = self.sql.getRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", self.rnum)]) done = [] data = [] for rec in recs: scod = rec[self.sql.scpgme_col.index("scg_scod")] ocod = rec[self.sql.scpgme_col.index("scg_ocod")] if scod in done or scod > 900000 or ocod in done or ocod > 900000: continue sfor = rec[self.sql.scpgme_col.index("scg_sfor")] sagt = rec[self.sql.scpgme_col.index("scg_sagt")] data.append((scod, self.getName(scod), sfor, ocod, self.getName(ocod), sagt)) SelectChoice(self.opts["mf"].window, "Results", cols, data) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doColExit(self): chk = self.sql.getRec("scpgme", cols=["count(*)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "=", self.rnum), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_scod", "<", 900000), ("scg_ocod", "<", 900000), ("(", "scg_sfor", "=", 0, "and", "scg_sagt", "=", 0, ")")], limit=1) if chk[0] and (self.clup == "N" or self.ctyp == "P" or \ (self.clup == "Y" and self.rnum > 1)): # All results for section not yet entered if self.doimport: showError(self.opts["mf"].body, "Missing Results", "Some Results are Missing, Please Check Import "\ "File and Retry") self.opts["mf"].dbm.rollbackDbase() self.ierr = True return ok = askQuestion(self.opts["mf"].body, "Missing Results", "Some Result are Missing. Do You want to Exit and Lose "\ "the Results for this Section?") if ok == "no": self.df.focusField(self.df.frt, self.df.pag, self.df.col) return self.opts["mf"].dbm.rollbackDbase() else: chk = self.doUpdateTables() if not self.doimport: if chk == "continue": self.df.focusField(self.df.frt, self.df.pag, self.df.col) return if chk == "abort": self.opts["mf"].dbm.rollbackDbase() else: self.opts["mf"].dbm.commitDbase() if not self.doimport: self.df.clearFrame("T", 1) self.df.clearFrame("C", 1) if self.ctyp == "P": self.df.focusField("T", 0, 4) else: self.df.focusField("T", 1, 1) def doUpdateTables(self): nrnd = self.rnum + 1 if self.fmat == "K" and self.clup == "Y" and self.ctyp == "M": # Closed up draw (1st and maybe 2nd Round) skps = self.sql.getRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", self.rnum)]) byes = [] nums = {} for skp in skps: scod = skp[self.sql.scpgme_col.index("scg_scod")] ocod = skp[self.sql.scpgme_col.index("scg_ocod")] if not ocod: byes.append(scod) nums[scod] = skp for skp in byes: if self.opts["test"]: ok = "B" else: ok = askChoice(self.opts["mf"].body, "Capture Error", "The Results for Skip %s - %s is Missing. Did he/she "\ "Withdraw or have a Bye?" % (skp, self.getName(skp)), butt=(("No", "N"), ("Withdraw", "W"), ("Bye", "B"), ("Abort", "A")), default="Bye") if ok == "N": return "continue" if ok == "A": return "abort" if ok == "W": self.sql.delRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_scod", "=", skp)]) byes.remove(skp) del nums[skp] continue for scod in nums: rec = nums[scod] scod = rec[self.sql.scpgme_col.index("scg_scod")] ocod = rec[self.sql.scpgme_col.index("scg_ocod")] sfor = rec[self.sql.scpgme_col.index("scg_sfor")] sagt = rec[self.sql.scpgme_col.index("scg_sagt")] where = [("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs), ("scg_rnum", "=", nrnd), ("scg_scod", "=", scod)] if scod in byes: self.byenum += 1 # Create bye self.sql.updRec("scpgme", cols=["scg_ocod"], data=[self.byenum], where=where) if nrnd < self.lrnd: # Create next round record rec[self.sql.scpgme_col.index("scg_rnum")] = nrnd rec[self.sql.scpgme_col.index("scg_ocod")] = 0 rec[self.sql.scpgme_col.index("scg_sfor")] = 0 rec[self.sql.scpgme_col.index("scg_sagt")] = 0 rec[self.sql.scpgme_col.index("scg_seed")] = 0 rec[self.sql.scpgme_col.index("scg_pair")] = 0 if scod not in byes and sfor < sagt and ocod: scod = ocod rec[self.sql.scpgme_col.index("scg_scod")] = scod chk = self.sql.getRec("scpgme", where=where, limit=1) if not chk: self.sql.insRec("scpgme", data=rec) else: self.sql.updRec("scpgme", data=rec, where=where) else: # Update playoff records cod = self.snum + 700000 if sfor > sagt: win = scod else: win = ocod whr = where[:6] whr[2] = ("scg_ctyp", "=", "P") whr[3] = ("scg_snum", "=", 1) whr[5] = ("scg_rnum", "=", 1) whr.append(("scg_scod", "=", cod)) self.sql.updRec("scpgme", cols=["scg_scod"], data=[win], where=whr) whr[6] = ("scg_ocod", "=", cod) self.sql.updRec("scpgme", cols=["scg_ocod"], data=[win], where=whr) if (self.fmat == "K" and self.clup == "N") or self.ctyp == "P": recs = self.sql.getRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_rnum", "=", self.rnum)], order="scg_group, scg_pair") group = 0 for num in range(0, len(recs), 2): one = recs[num] snum = one[self.sql.scpgme_col.index("scg_snum")] subs = one[self.sql.scpgme_col.index("scg_subs")] if group != one[self.sql.scpgme_col.index("scg_group")]: group = one[self.sql.scpgme_col.index("scg_group")] pair = 1 else: pair += 1 cod1 = one[self.sql.scpgme_col.index("scg_scod")] opp1 = one[self.sql.scpgme_col.index("scg_ocod")] for1 = one[self.sql.scpgme_col.index("scg_sfor")] agt1 = one[self.sql.scpgme_col.index("scg_sagt")] if opp1 > 900000 or for1 > agt1: win1 = cod1 else: win1 = opp1 if len(recs[num:]) > 1: two = recs[num + 1] cod2 = two[self.sql.scpgme_col.index("scg_scod")] opp2 = two[self.sql.scpgme_col.index("scg_ocod")] for2 = two[self.sql.scpgme_col.index("scg_sfor")] agt2 = two[self.sql.scpgme_col.index("scg_sagt")] if opp2 > 900000 or for2 > agt2: win2 = cod2 else: win2 = opp2 else: win2 = 0 # Create next round record sgc = self.sql.scpgme_col whr = [("scg_cono", "=", one[sgc.index("scg_cono")]), ("scg_ccod", "=", one[sgc.index("scg_ccod")]), ("scg_ctyp", "=", one[sgc.index("scg_ctyp")]), ("scg_snum", "=", one[sgc.index("scg_snum")]), ("scg_subs", "=", one[sgc.index("scg_subs")]), ("scg_rnum", "=", nrnd), ("scg_ktyp", "=", one[sgc.index("scg_ktyp")]), ("scg_scod", "=", win1)] one[sgc.index("scg_rnum")] = nrnd one[sgc.index("scg_scod")] = win1 one[sgc.index("scg_ocod")] = win2 one[sgc.index("scg_sfor")] = 0 one[sgc.index("scg_sagt")] = 0 one[sgc.index("scg_pnts")] = 0 one[sgc.index("scg_pair")] = pair if not self.sql.getRec("scpgme", where=whr, limit=1): self.sql.insRec("scpgme", data=one) else: self.sql.updRec("scpgme", cols=["scg_ocod", "scg_pair"], data=[win2, pair], where=whr) if self.rnum == self.lrnd and \ self.ctyp == "M" and self.nsec > 2: # Create playoff records with winners codes if not self.oldwin: if subs == "B": key = snum + 800000 else: key = snum + 700000 else: key = self.oldwin[snum] self.sql.updRec("scpgme", cols=["scg_scod"], data=[win1], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P"), ("scg_rnum", "=", 1), ("scg_scod", "=", key)]) self.sql.updRec("scpgme", cols=["scg_ocod"], data=[win1], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P"), ("scg_rnum", "=", 1), ("scg_ocod", "=", key)]) elif self.squa == "S" and self.rnum == self.lrnd: # Update playoff records with winners codes if self.ssub == "Y": lsub = "B" else: lsub = "" whr = [("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs)] if self.fmat == "K": col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"] whr.append(("scg_rnum", "=", self.lrnd)) rec = self.sql.getRec("scpgme", cols=col, where=whr, limit=1) if rec[2] > rec[3]: win = rec[0] else: win = rec[1] else: self.doGetNewWin(sect=self.snum, sub=self.subs) win = self.newwin[self.snum] if not self.oldwin: if self.subs == "B": key = self.snum + 800000 else: key = self.snum + 700000 else: key = self.oldwin[self.snum] self.sql.updRec("scpgme", cols=["scg_scod"], data=[win], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P"), ("scg_rnum", "=", 1), ("scg_scod", "=", key)]) self.sql.updRec("scpgme", cols=["scg_ocod"], data=[win], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P"), ("scg_rnum", "=", 1), ("scg_ocod", "=", key)]) if self.snum == self.nsec and self.subs == lsub: self.sql.updRec("scpgme", cols=["scg_ktyp"], data=["M"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P")]) # Check if all results for the round are captured chek = self.sql.getRec("scpgme", cols=["count(*)"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp), ("scg_rnum", "=", self.rnum), ("scg_scod", "<", 900000), ("scg_ocod", "<", 900000), ("scg_sfor", "=", 0), ("scg_sagt", "=", 0)], limit=1) if chek[0]: return if self.clup == "Y" and self.ctyp == "M" and nrnd == self.lrnd: state = 3 elif self.rnum == self.lrnd: if self.ctyp == "M": state = 3 else: state = 6 elif self.ctyp == "M": state = 2 else: state = 5 self.sql.updRec("scpcmp", cols=["scp_state"], data=[state], where=[("scp_cono", "=", self.opts["conum"]), ("scp_ccod", "=", self.ccod)]) def doGetOldWin(self): self.oldwin = {} if self.ctyp == "M" and self.rnum == self.lrnd: recs = self.sql.getRec("scpgme", cols=["scg_scod", "scg_ocod"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P"), ("scg_snum", "=", 1)]) for rec in recs: for cod in rec: if cod < 900000: sec = self.sql.getRec("scpgme", cols=["scg_snum"], where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "M"), ("scg_scod", "=", cod)], limit=1) if sec: self.oldwin[sec[0]] = cod def doGetNewWin(self, sect=None, sub=""): # Get Leaders self.newwin = {} if sect is None: secs = [] for x in range(self.nsec): secs.append(x + 1) else: secs = [sect] for sec in secs: col = [ "scg_scod", "sum(scg_pnts) as a", "sum(scg_sfor - scg_sagt) as b", "round(sum(scg_sfor) / sum(scg_sagt), 2) as c" ] whr = [("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "M"), ("scg_snum", "=", sec), ("scg_subs", "=", sub)] grp = "scg_scod" odr = "a desc, b desc, c desc" rec = self.sql.getRec("scpgme", cols=col, where=whr, group=grp, order=odr, limit=1) self.newwin[sec] = rec[0]
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 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 st2020(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, [ "gentrn", "strgrp", "strmf1", "strmf2", "strgmu", "strcmu", "strtrn", "strpom" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] self.fromad = strctl["cts_emadd"] 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" 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"), mail=("N", "Y")) 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_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "not", "in", ("R", "X")), ("st1_value_ind", "<>", "N")], "whera": [["C", "st1_group", 0, 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": "st2_loc", "index": 0 } fld = [(("T", 0, 0, 0), "INa", 9, "GRN Number", "", "", "Y", self.doGrv, None, None, ("notblank", )), (("T", 0, 0, 0), "ID1", 10, "Date", "GRN Date", self.sysdtw, "N", self.doDte, None, None, ("efld", )), (("T", 0, 0, 0), "INa", 7, "Order Number", "", "", "N", self.doOrd, None, None, ("efld", )), (("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "r", "Y", self.doGroup, gpm, None, ("notblank", )), (("C", 0, 0, 1), "INA", (15, 20), "Product Code", "", "", "N", self.doCode, stm, None, ("notblank", )), (("C", 0, 0, 2), "ONA", 15, "Description"), (("C", 0, 0, 3), "ONA", 5, "U.O.I"), [("C", 0, 0, 4), "IUA", 1, "L", "Location", "r", "N", self.doLoc, stl, None, ("notblank", )], (("C", 0, 0, 5), "ISD", 9.2, "Quantity", "", "", "N", self.doQty, None, None, ("notzero", )), (("C", 0, 0, 6), "IUD", 9.2, "Unit-Cost", "Unit Cost Price", "", "N", self.doUcost, None, None, ("notzero", )), (("C", 0, 0, 7), "IUD", 5.2, "Dis-%", "Discount Percentage", "", "N", self.doDisPer, None, None, ("efld", )), (("C", 0, 0, 8), "OSD", 9.2, "Value")] tnd = ((self.endPage0, "n"), ) txt = (self.exitPage0, ) cnd = ((self.endPage1, "y"), ) cxt = (self.exitPage1, ) but = (("Import", None, self.doImport, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2)), "Import Stock from a CSV or XLS File"), ("StrQuery", None, self.doQuery, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("Reprint", None, self.doReprint, 0, ("T", 0, 1), None), ("Cancel", None, self.doCancel, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 0)))) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doGrv(self, frt, pag, r, c, p, i, w): self.grv = w self.cancel = False 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.dtw = self.df.t_disp[0][0][i] self.curdt = int(self.dte / 100) self.batno = "S%s" % self.curdt def doOrd(self, frt, pag, r, c, p, i, w): self.odr = w def doImport(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") if self.locs == "Y": impcol = [["Location", 0, "UA", 1]] fld = [(("T",0,0,0),("IRB",(("Yes","Y"),("No","N"))),0, "Create Items","","N","N",self.doAllLoc,None,None,None,None, "Create Item in this location if it is a Valid item, i.e. "\ "Already exists in another location")] else: impcol = [] fld = [] self.allloc = "N" impcol.extend([["Group", 1, "UA", 3], ["Code", 2, "NA", 20], ["Quantity", 3, "UD", 10.2], ["Item Cost", 4, "UD", 10.2]]) fi = FileImport(self.opts["mf"], impcol=impcol, impfld=fld) self.trdis = 0 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 if self.locs == "Y": loc = line[0] idx = 1 else: loc = "1" idx = 0 self.loc = loc.work self.group = line[idx] self.code = line[idx + 1] st1 = self.sql.getRec("strmf1", where=[("st1_group", "=", self.group), ("st1_code", "=", self.code), ("st1_type", "<>", "X")], limit=1) err = False if not st1: err = "Line %s: Invalid Group %s or Code %s" % ( (num + 1), self.group, self.code) elif st1[self.sql.strmf1_col.index("st1_type")] == "R": err = "Line %s: Invalid Code (Recipe Item)" % (num + 1) elif st1[self.sql.strmf1_col.index("st1_type")] == "X": err = "Line %s: Invalid Code (Redundant" % (num + 1) elif st1[self.sql.strmf1_col.index("st1_type")] == "N": err = "Line %s: Invalid Code (Value Indicator)" % (num + 1) if err: break self.desc = st1[self.sql.strmf1_col.index("st1_desc")] st2 = self.sql.getRec("strmf2", where=[("st2_loc", "=", self.loc), ("st2_group", "=", self.group), ("st2_code", "=", self.code)], limit=1) if not st2 and self.allloc == "Y": st2 = self.sql.getRec("strmf2", where=[("st2_loc", "=", "1"), ("st2_group", "=", self.group), ("st2_code", "=", self.code)], limit=1) if st2: st2[self.sql.strmf2_col.index("st2_loc")] = self.loc st2[self.sql.strmf2_col.index("st2_bin")] = "" st2[self.sql.strmf2_col.index("st2_reord_ind")] = "A" st2[self.sql.strmf2_col.index("st2_reord_level")] = 0 st2[self.sql.strmf2_col.index("st2_reord_qty")] = 0 self.sql.insRec("strmf2", data=st2) if not st2: err = "Line %s: Invalid Location %s" % ((num + 1), self.loc) break self.qty = line[idx + 2] self.tcost = round((self.qty * line[idx + 3]), 2) self.usell = 0.00 self.updateTables() if err: showError(self.opts["mf"].body, "Import Error", err) elif fi.impdat: self.opts["mf"].dbm.commitDbase() self.df.enableButtonsTags(state=state) self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doAllLoc(self, obj, w): self.allloc = w def doGroup(self, frt, pag, r, c, p, i, w): self.group = w acc = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" def doCode(self, frt, pag, r, c, p, i, w): self.code = w acc = self.sql.getRec( "strmf1", cols=["st1_type", "st1_desc", "st1_uoi", "st1_value_ind"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] == "R": return "Invalid Code (Recipe Item)" if acc[0] == "X": return "Invalid Code (Redundant" if acc[3] == "N": return "Invalid Code (Value Indicator)" self.desc = acc[1] self.uoi = acc[2] self.df.loadEntry("C", pag, p + 1, data=self.desc) self.df.loadEntry("C", pag, p + 2, data=self.uoi) if self.locs == "N": self.loc = "1" self.df.loadEntry("C", pag, p + 3, data=self.loc) no = self.checkLoc() if no: return no return "sk3" 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", 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.qty = w # Last Cost Price lcost = getCost(self.sql, self.opts["conum"], self.group, self.code, loc=self.loc, qty=1, ind="L") self.df.loadEntry(frt, pag, p + 1, data=lcost) def doUcost(self, frt, pag, r, c, p, i, w): self.ucost = w self.tcost = round((self.qty * self.ucost), 2) def doDisPer(self, frt, pag, r, c, p, i, w): self.trdis = w udis = round((self.ucost * self.trdis / 100), 2) tdis = round((self.tcost * self.trdis / 100), 2) self.ucost = float(ASD(self.ucost) - ASD(udis)) self.tcost = float(ASD(self.tcost) - ASD(tdis)) self.df.loadEntry(frt, pag, p + 1, data=self.tcost) def endPage0(self): self.df.focusField("C", 0, 1) def endPage1(self): self.updateTables() self.df.advanceLine(0) def exitPage0(self): self.df.closeProcess() self.opts["mf"].closeLoop() def exitPage1(self): if not self.cancel and self.df.col != 1: self.opts["mf"].dbm.commitDbase() self.doPrintDoc(self.pr.repprt, self.pr.repeml) else: self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doCancel(self): ok = askQuestion( self.opts["mf"].body, "Cancel", "Are You Sure that you want to Cancel this Goods Received Note?", default="no") if ok == "yes": self.cancel = True self.exitPage1() self.df.focusField(self.df.frt, self.df.pag, self.df.col) def updateTables(self): # Stores Ledger Transaction data = [ self.opts["conum"], self.group, self.code, self.loc, self.dte, 1, self.grv, self.batno, self.odr, self.qty, self.tcost, 0, self.curdt, self.desc, 0, "", "", "STR", self.trdis, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) if self.glint == "N": return # General Ledger Control Transaction (Stock On Hand) data = [ self.opts["conum"], self.stk_soh, self.curdt, self.dte, 5, self.grv, self.batno, self.tcost, 0, self.code, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Stock Suspense) val = float(ASD(0) - ASD(self.tcost)) data = [ self.opts["conum"], self.stk_susp, self.curdt, self.dte, 5, self.grv, self.batno, val, 0, self.code, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) def doReprint(self): tit = ("Reprint Documents", ) dat = self.sql.getRec( "strtrn", cols=["stt_loc", "stt_trdt", "stt_ref1", "stt_ref2"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 1)], group="stt_loc, stt_trdt, stt_ref1, stt_ref2", order="stt_trdt, stt_ref1") data = [] for d in dat: try: # Exclude purchase orders doc = int(d[2]) chk = self.sql.getRec("strpom", where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", doc), ("pom_loc", "=", d[0]), ("pom_date", "=", d[1])]) if chk: continue except: pass data.append([d[2], d[1], d[3]]) grv = { "stype": "R", "tables": ("strtrn", "strpom"), "cols": (("stt_ref1", "", 0, "Reference", "Y"), ("stt_trdt", "", 0, "Date"), ("stt_ref2", "", 0, "Order-Num")), "wtype": "D", "where": data, "screen": self.opts["mf"].body, "comnd": self.doSelRec } grd = { "stype": "R", "tables": ("strtrn", ), "cols": (("stt_trdt", "", 0, "Date"), ("stt_ref2", "", 0, "Order-Num")), "where": [("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 1)], "whera": (("T", "stt_ref1", 0, 0), ), "group": "stt_trdt", "order": "stt_trdt" } fld = ((("T", 0, 0, 0), "INa", 9, "GRN Number", "", "", "N", self.doRepGrv, grv, None, ("notblank", )), (("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N", self.doRepDte, grd, 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=("Y", "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 doRepGrv(self, frt, pag, r, c, p, i, w): self.grv = w acc = self.sql.getRec("strtrn", where=[("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 1), ("stt_ref1", "=", w)]) if not acc: return "Invalid GRN Number" if len(acc) == 1: self.dte = acc[0][self.sql.strtrn_col.index("stt_trdt")] self.tx.loadEntry(frt, pag, p + 1, data=self.dte) self.dtw = self.tx.t_disp[0][0][i + 1] return "sk1" def doRepDte(self, frt, pag, r, c, p, i, w): self.dte = w self.dtw = self.tx.t_disp[0][0][i] acc = self.sql.getRec("strtrn", cols=["count(*)"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 1), ("stt_ref1", "=", self.grv), ("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, self.tx.repeml) def doRepExit(self): self.tx.closeProcess() def doPrintDoc(self, repprt, repeml): hds = [ "Goods Received Notes", "GRN Number: %s GRN Date: %s" % (self.grv, self.dtw) ] 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"], ["stt_cost", "SD", 11.2, "Price", "y"]] gtt = ["stt_cost"] whr = [("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 1), ("stt_ref1", "=", self.grv), ("stt_trdt", "=", self.dte)] 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=["strtrn"], heads=hds, cols=col, gtots=gtt, where=whr, order=odr, repprt=repprt, repeml=repeml, fromad=self.fromad) self.df.setWidget(self.df.mstFrame, state="show") def doQuery(self): callModule(self.opts["mf"], self.df, "st4010", coy=(self.opts["conum"], self.opts["conam"]), period=self.opts["period"], user=self.opts["capnm"])
class rc2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): tabs = [ "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genmst", "gentrn", "rcaowm", "rcaowt", "rcaprm", "rcatnm", "rcacon", "rcatnt" ] self.sql = Sql(self.opts["mf"].dbm, tabs, 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"] rcactl = gc.getCtl("rcactl", self.opts["conum"]) if not rcactl: return self.glint = rcactl["cte_glint"] self.ch1 = ((rcactl["cte_lme"] // 100) * 100) + 1 self.ch2 = projectDate(self.ch1, 2, typ="months") if self.glint == "Y": self.glbnk = rcactl["cte_glbnk"] ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = [ "rca_com", "rca_dep", "rca_fee", "rca_orx", "rca_own", "rca_tnt", "rca_trx", "vat_ctl" ] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.rcacom = ctlctl["rca_com"] self.rcadep = ctlctl["rca_dep"] self.rcafee = ctlctl["rca_fee"] self.rcaorx = ctlctl["rca_orx"] self.rcaown = ctlctl["rca_own"] self.rcatnt = ctlctl["rca_tnt"] self.rcatrx = ctlctl["rca_trx"] self.convat = ctlctl["vat_ctl"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.batno = "R%04i%02i" % (t[0], t[1]) return True def drawDialog(self): # Transaction Types typ = { "stype": "C", "titl": "Select the Required Type", "head": ("C", "Type"), "data": [] } # Movement Types data = [] for x in range(1, len(rcmvtp) + 1): data.append((x, rcmvtp[x - 1][1])) mov = { "stype": "C", "titl": "Select the Required Type", "head": ("C", "Type"), "data": data } # Premises prm = { "stype": "R", "tables": ("rcaprm", "rcaowm"), "cols": (("rcp_owner", "", 0, "Owner"), ("rom_name", "", 0, "Owner"), ("rcp_code", "", 0, "Prm-Cod"), ("rcp_addr1", "", 0, "Address-Line-1")), "where": [("rcp_cono", "=", self.opts["conum"]), ("rom_cono=rcp_cono", ), ("rom_acno=rcp_owner", )], "index": 2 } # Tenant tnm = { "stype": "R", "tables": ("rcatnm", ), "cols": (("rtn_acno", "", 0, "Acc-Num"), ("rtn_name", "", 0, "Description", "Y")), "where": [("rtn_cono", "=", self.opts["conum"])], "whera": [("T", "rtn_owner", 0, 1)] } # Contract con = { "stype": "R", "tables": ("rcacon", ), "cols": (("rcc_cnum", "", 0, "Seq"), ("rcc_payind", "", 0, "F"), ("rcc_start", "", 0, "Start-Date"), ("rcc_period", "", 0, "Per"), ("rcc_status", "", 0, "S")), "where": [("rcc_cono", "=", self.opts["conum"])], "whera": [("T", "rcc_owner", 0, 1), ("T", "rcc_code", 0, 0), ("T", "rcc_acno", 0, 2)] } # VAT Records vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } tag = ( ( "Owner", None, (("T", 2, 1), ("C", 2, 1)), # On (("C", 1, 1), ("T", 2, 2), ("C", 2, 2))), # Off ( "Tenant", None, ("C", 1, 1), # On (("C", 1, 2), ("T", 2, 1), ("C", 2, 1))), # Off ("Allocation", self.doAllocation, None, None)) fld = [ (("T", 0, 0, 0), "INA", 7, "Prm-Cod", "Premises Code", "", "Y", self.doPrmCod, prm, None, None), (("T", 0, 0, 0), "ONA", 30, "Description"), (("T", 1, 0, 0), "ONA", 7, "Acc-Num"), (("T", 1, 0, 0), "ONA", 30, "Name"), (("T", 1, 0, 0), "OSD", 11.2, "Payable"), (("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number", "i", "Y", self.doOwnRef, None, None, ("notblank", )), (("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doOwnDat, None, None, ("efld", )), (("C", 1, 0, 2), "IUI", 1, "T", "Transaction Type", "r", "N", self.doOwnTyp, typ, None, ("notzero", )), (("C", 1, 0, 3), "ISD", 11.2, "Amount", "Transaction Amount", "", "N", self.doOwnAmt, None, None, None), (("C", 1, 0, 4), "IUA", 1, "V", "V.A.T Code", "N", "N", self.doOwnCod, vtm, None, ("efld", )), (("C", 1, 0, 5), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N", self.doOwnVat, None, None, None), (("C", 1, 0, 6), "INA", 47, "Details", "Transaction Details", "", "N", self.doOwnDet, None, None, None), (("T", 2, 0, 0), "INA", 7, "Acc-Num", "Account Number", "", "Y", self.doAccNum, tnm, None, None), (("T", 2, 0, 0), "ONA", 30, "Name"), (("T", 2, 0, 0), "IUI", 3, "Seq", "Contract Number", "", "N", self.doConSeq, con, None, None), (("T", 2, 0, 0), "OSD", 11.2, "Balance"), (("C", 2, 0, 0), "INa", 9, "Reference", "Reference Number", "i", "Y", self.doTntRef, None, None, ("notblank", )), (("C", 2, 0, 1), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTntDat, None, None, ("efld", )), (("C", 2, 0, 2), "IUI", 1, "T", "Transaction Type", "r", "N", self.doTntTyp, typ, None, ("notzero", )), (("C", 2, 0, 3), "ISD", 11.2, "Amount", "Transaction Amount", "", "N", self.doTntAmt, None, None, None), (("C", 2, 0, 4), "INA", (60, 30), "Details", "Transaction Details", "", "N", self.doTntDet, None, None, None), (("T", 3, 0, 0), "OSD", 11.2, "Rentals "), (("T", 3, 0, 0), "OSD", 11.2, "Deposit "), (("T", 3, 0, 0), "OSD", 11.2, "Fees "), (("T", 3, 1, 0), "OSD", 11.2, "Services (O)"), (("T", 3, 1, 0), "OSD", 11.2, "Services (A)"), (("T", 3, 1, 0), "OSD", 11.2, "Repairs "), (("T", 3, 2, 0), "OSD", 11.2, "Allocation"), (("C", 3, 0, 0), "IUI", 1, "M", "Movement Type", "", "Y", self.doAllMov, mov, None, ("between", 1, 6)), (("C", 3, 0, 1), "ISD", 11.2, "Amount", "Allocation Amount", "", "N", self.doAllAmt, None, None, None), (("C", 3, 0, 2), "IUA", 1, "V", "V.A.T Code", "N", "N", self.doAllCod, vtm, None, ("efld", )), (("C", 3, 0, 3), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N", self.doAllVat, None, None, None), (("C", 3, 0, 4), "INA", (50, 30), "Details", "Transaction Details", "", "N", self.doAllDet, None, None, None) ] row = [0, 4, 4, 10] tnd = [(self.endPage, "y"), (self.endPage, "y"), (self.endPage, "y"), (self.endPage, "y")] txt = [self.exitPage, self.exitPage, self.exitPage, self.exitPage] cnd = [(None, "n"), (self.endPage, "y"), (self.endPage, "y"), (self.endPage, "y")] cxt = [None, self.exitPage, self.exitPage, self.exitPage] but = (("Notes", None, self.allNotes, 0, ("T", 0, 0), ("T", 0, 1)), ("Statement", None, self.allStmnt, 0, (("C", 1, 1), ("C", 2, 1)), (("T", 0, 1), ("T", 2, 1))), ("Cancel", None, self.doAllCancel, 0, ("C", 3, 1), ("C", 2, 1))) self.df = TartanDialog(self.opts["mf"], tags=tag, eflds=fld, rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doPrmCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec( "rcaprm", cols=["rcp_desc", "rcp_owner", "rcp_crate", "rcp_addr1"], where=[("rcp_cono", "=", self.opts["conum"]), ("rcp_code", "=", w)], limit=1) if not acc: return "Invalid Premises Code" self.code = w desc, self.owner, self.crate, addr1 = acc if desc: self.df.loadEntry(frt, pag, p + 1, data=desc) else: self.df.loadEntry(frt, pag, p + 1, data=addr1) acc = self.sql.getRec("rcaowm", cols=["rom_name", "rom_vatdf"], where=[("rom_cono", "=", self.opts["conum"]), ("rom_acno", "=", self.owner)], limit=1) if not acc: return "Missing Owner Record (%s)" % self.owner self.df.loadEntry("T", 1, 0, data=self.owner) self.df.loadEntry("T", 1, 1, data=acc[0]) self.vatdf = acc[1] self.acno = None def doAccNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("rcatnm", cols=["rtn_name"], where=[("rtn_cono", "=", self.opts["conum"]), ("rtn_owner", "=", self.owner), ("rtn_code", "=", self.code), ("rtn_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" self.acno = w self.name = acc[0] self.df.loadEntry(frt, pag, p + 1, data=self.name) con = self.sql.getRec("rcacon", where=[("rcc_cono", "=", self.opts["conum"]), ("rcc_owner", "=", self.owner), ("rcc_code", "=", self.code), ("rcc_acno", "=", self.acno)], order="rcc_cnum") if not con: return "No Valid Contracts" self.cnum = con[-1:][0][self.sql.rcacon_col.index("rcc_cnum")] self.df.topf[2][2][5] = self.cnum def doConSeq(self, frt, pag, r, c, p, i, w): con = self.sql.getRec("rcacon", where=[("rcc_cono", "=", self.opts["conum"]), ("rcc_code", "=", self.code), ("rcc_acno", "=", self.acno), ("rcc_cnum", "=", w)], order="rcc_cnum") if not con: return "Invalid Contract Sequence" self.cnum = w self.showTenantBalance() def doOwnRef(self, frt, pag, r, c, p, i, w): self.trnref = w def doOwnDat(self, frt, pag, r, c, p, i, w): if w < self.ch1 or w > self.ch2: ov = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="RCA", code="DateOver") if ov.flag == "no": return "Invalid Date (< %s or > %s)" % (self.ch1, self.ch2) self.trndat = w data = [] for x in range(2, len(rctrtp) + 1): data.append((x, rctrtp[x - 1][1])) self.df.colf[1][2][8]["data"] = data def doOwnTyp(self, frt, pag, r, c, p, i, w): if w not in (2, 3, 4): return "Invalid Transaction Type" self.trntyp = w def doOwnAmt(self, frt, pag, r, c, p, i, w): if self.trntyp == 3 and w > self.due: op = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="RCA", code="Overpaid") if op.flag == "no": return "Overpaid" self.trnamt = w # Ignore VAT at this stage self.vatcode = "" self.trnvat = 0 self.df.loadEntry(frt, pag, p + 1, data=self.vatcode) self.df.loadEntry(frt, pag, p + 2, data=self.trnvat) return "sk2" def doOwnCod(self, frt, pag, r, c, p, i, w): pass # vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) # if vrte is None: # return "Invalid V.A.T Code" # self.vatcode = w # self.trnvat = round((self.trnamt * vrte / (vrte + 100)), 2) # self.df.loadEntry(frt, pag, p+1, data=self.trnvat) # if not self.trnvat: # return "sk1" def doOwnVat(self, frt, pag, r, c, p, i, w): pass # if self.trnamt < 0 and w > 0: # self.trnvat = float(ASD(0) - ASD(w)) # elif self.trnamt > 0 and w < 0: # self.trnvat = float(ASD(0) - ASD(w)) # else: # self.trnvat = w # self.df.loadEntry(frt, pag, p, data=self.trnvat) def doOwnDet(self, frt, pag, r, c, p, i, w): self.trndet = w def doTntRef(self, frt, pag, r, c, p, i, w): self.trnref = w def doTntDat(self, frt, pag, r, c, p, i, w): if w < self.ch1 or w > self.ch2: ov = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="RCA", code="DateOver") if ov.flag == "no": return "Invalid Date (< %s or > %s)" % (self.ch1, self.ch2) self.trndat = w data = [] for x in range(1, len(rctrtp) + 1): data.append((x, rctrtp[x - 1][1])) self.df.colf[2][2][8]["data"] = data def doTntTyp(self, frt, pag, r, c, p, i, w): if w not in (1, 2, 3, 4): return "Invalid Transaction Type" self.trntyp = w def doTntAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w if self.trntyp == 1: # Rental Raised self.vatcode = self.vatdf vrte = getVatRate(self.sql, self.opts["conum"], self.vatcode, self.trndat) if vrte is None: vrte = 0.0 self.trnvat = round((w * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p + 1, data="Rental Raised") else: # Ignore VAT at this stage self.vatcode = "" self.trnvat = 0 def doTntDet(self, frt, pag, r, c, p, i, w): self.trndet = w def doAllocation(self): self.df.setWidget(self.df.B1, state="normal") def doAllMov(self, frt, pag, r, c, p, i, w): if w == 2 and self.trntyp not in (2, 3): return "Deposits Only Allowed for Receipts and Payments" self.allmov = w def doAllAmt(self, frt, pag, r, c, p, i, w): if not w: self.allamt = float(ASD(self.trnamt) - ASD(self.alltot)) self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.allamt = w if self.allmov == 2: # Deposit self.allcod = "" self.df.loadEntry(frt, pag, p + 1, data=self.allcod) self.allvat = 0 self.df.loadEntry(frt, pag, p + 2, data=self.allvat) return "sk2" if self.trntyp in (2, 3): # Receipt or Payment self.df.loadEntry(frt, pag, p + 1, self.vatdf) if self.trntyp == 4 and self.allmov == 3: # Journal Fee self.df.loadEntry(frt, pag, p + 1, self.taxdf) else: self.allcod = "" self.allvat = 0 def doAllCod(self, frt, pag, r, c, p, i, w): vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if vrte is None: return "Invalid V.A.T Code" self.allcod = w self.allvat = round((self.allamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p + 1, data=self.allvat) if not self.allvat: self.df.loadEntry(frt, pag, p + 2, data=self.trndet) return "sk1" def doAllVat(self, frt, pag, r, c, p, i, w): if self.allamt < 0 and w > 0: self.allvat = float(ASD(0) - ASD(w)) elif self.allamt > 0 and w < 0: self.allvat = float(ASD(0) - ASD(w)) else: self.allvat = w self.df.loadEntry(frt, pag, p, data=self.allvat) self.df.loadEntry(frt, pag, p + 1, data=self.trndet) def doAllDet(self, frt, pag, r, c, p, i, w): self.trndet = w def doAllCancel(self): self.allocs = [] self.df.clearFrame("C", 3) self.df.setWidget(self.df.B1, state="disabled") self.df.selPage("Tenant") self.df.clearLine(2, int((self.df.last[2][1] - 1) / self.df.colq[2]), "Y") def endPage(self): if self.df.frt == "T" and self.df.pag == 0: self.df.focusField("C", 1, 1) elif self.df.frt == "C" and self.df.pag == 1: # Owners self.updateTables() self.df.advanceLine(self.df.pag) elif self.df.frt == "T" and self.df.pag == 2: self.df.focusField("C", 2, 1) elif self.df.frt == "C" and self.df.pag == 2: # Tenants self.allocs = [] self.alltot = 0.0 if self.trntyp == 1: self.movtyp = 1 self.updateTables() self.df.advanceLine(self.df.pag) else: self.df.selPage("Allocation") dpp = 0.0 acc = self.sql.getRec("rcacon", cols=["rcc_deposit"], where=[("rcc_cono", "=", self.opts["conum"]), ("rcc_owner", "=", self.owner), ("rcc_code", "=", self.code), ("rcc_acno", "=", self.acno)], order="rcc_cnum") if acc: dpo = acc[-1:][0][0] else: dpo = 0.0 dat = self.sql.getRec( "rcatnt", cols=["rtu_mtyp", "round(sum(rtu_tramt), 2)"], where=[("rtu_cono", "=", self.opts["conum"]), ("rtu_owner", "=", self.owner), ("rtu_code", "=", self.code), ("rtu_acno", "=", self.acno)], group="rtu_mtyp", order="rtu_mtyp") if dat: for d in dat: if d[0] == 2: dpp = d[1] else: self.df.loadEntry("T", 3, d[0] - 1, data=d[1]) dpo = float(ASD(dpo) + ASD(dpp)) if dpo: self.df.loadEntry("T", 3, 1, data=dpo) self.df.loadEntry("T", 3, 6, data=self.trnamt) self.df.focusField("C", 3, 1) else: # Allocations self.allocs.append( [self.allmov, self.allamt, self.allcod, self.allvat]) self.alltot = float(ASD(self.alltot) + ASD(self.allamt)) bal = float(ASD(self.trnamt) - ASD(self.alltot)) if bal: pos = self.allmov - 1 if self.trntyp == 2: a = float( ASD(self.df.t_work[3][0][pos]) - ASD(self.allamt)) else: a = float( ASD(self.df.t_work[3][0][pos]) + ASD(self.allamt)) self.df.loadEntry("T", 3, pos, data=a) self.df.loadEntry("T", 3, 6, data=bal) self.df.advanceLine(3) else: for line in self.allocs: self.movtyp, self.trnamt, self.vatcode, self.trnvat = line self.updateTables() self.df.clearFrame("C", 3) self.df.selPage("Tenant") self.df.advanceLine(2) self.showOwnerTrans() if self.acno: self.showTenantTrans() def showOwnerTrans(self): whr = [("rot_cono", "=", self.opts["conum"]), ("rot_acno", "=", self.owner)] tot = self.sql.getRec("rcaowt", cols=["round(sum(rot_tramt),2)"], where=[("rot_cono", "=", self.opts["conum"]), ("rot_acno", "=", self.owner)], limit=1) if not tot or not tot[0]: self.due = 0 else: self.due = float(ASD(0) - ASD(tot[0])) arr = self.sql.getRec("rcatnt", cols=["round(sum(rtu_tramt),2)"], where=[("rtu_cono", "=", self.opts["conum"]), ("rtu_owner", "=", self.owner), ("rtu_mtyp", "in", (1, 4))], limit=1) if arr and arr[0]: self.due = float(ASD(self.due) - ASD(arr[0])) self.df.loadEntry("T", 1, 2, data=self.due) tab = ["rcaowt"] col = [ "rot_trdt", "rot_type", "rot_refno", "rot_desc", "rot_tramt", "rot_taxamt" ] whr = [("rot_cono", "=", self.opts["conum"]), ("rot_acno", "=", self.owner)] odr = "rot_trdt, rot_type, rot_refno" dat = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr) data = [] bals = 0 for d in dat: bals = float(ASD(bals) + ASD(d[4])) data.append(d + [bals]) col = (("rot_trdt", "Trans-Date", 10, "D1", "N"), ("rot_type", "Typ", 3, ("XX", rctrtp), "N"), ("rot_refno", "Reference", 9, "Na", "N"), ("rot_desc", "Details", 39, "NA", "N"), ("rot_tramt", "Amount", 11.2, "SD", "N"), ("rot_taxamt", "VAT-Amount", 11.2, "SD", "N"), ("balance", "Balance", 15.2, "SD", "N")) try: self.otrn.closeProcess() except: pass self.otrn = SelectChoice(self.df.topPage1, None, col, data, wait=False, neww=False, butt=False, sort=False, live=False, modal=False, lines=9) def showTenantTrans(self): tab = ["rcatnt"] col = [ "rtu_trdt", "rtu_type", "rtu_refno", "rtu_desc", "rtu_mtyp", "rtu_tramt", "rtu_taxamt" ] whr = [("rtu_cono", "=", self.opts["conum"]), ("rtu_owner", "=", self.owner), ("rtu_code", "=", self.code), ("rtu_acno", "=", self.acno)] odr = "rtu_trdt, rtu_type, rtu_refno, rtu_mtyp" dat = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr) data = [] bals = 0 for d in dat: bals = float(ASD(bals) + ASD(d[5])) data.append(d + [bals]) col = (("rtu_trdt", "Trans-Date", 10, "D1", "N"), ("rtu_type", "Typ", 3, ("XX", rctrtp), "N"), ("rtu_refno", "Reference", 9, "Na", "N"), ("rtu_desc", "Details", 35, "NA", "N"), ("rtu_mtyp", "Mov", 3, ("XX", rcmvtp), "N"), ("rtu_tramt", "Amount", 11.2, "SD", "N"), ("rtu_taxamt", "VAT-Amount", 11.2, "SD", "N"), ("balance", "Balance", 15.2, "SD", "N")) try: self.ttrn.closeProcess() except: pass self.ttrn = SelectChoice(self.df.topPage2, None, col, data, wait=False, neww=False, butt=False, sort=False, live=False, modal=False, lines=9) def showTenantBalance(self): bal = self.sql.getRec("rcatnt", cols=["round(sum(rtu_tramt),2)"], where=[("rtu_cono", "=", self.opts["conum"]), ("rtu_owner", "=", self.owner), ("rtu_code", "=", self.code), ("rtu_acno", "=", self.acno), ("rtu_cnum", "=", self.cnum), ("rtu_mtyp", "<>", 2)], limit=1) self.df.loadEntry("T", 2, 3, data=bal[0]) def updateTables(self): curdt = int(self.trndat / 100) amt = self.trnamt vat = self.trnvat if self.trntyp in (1, 4): # Rental and Journal gltyp = 4 elif self.trntyp == 2: # Receipt gltyp = 6 bnk = amt amt = float(ASD(0) - ASD(amt)) vat = float(ASD(0) - ASD(vat)) elif self.trntyp == 3: # Payment gltyp = 2 bnk = float(ASD(0) - ASD(amt)) if self.df.pag == 1: # Owners Transaction accod = self.owner data = [ self.opts["conum"], self.owner, self.trntyp, self.trnref, self.batno, self.trndat, amt, vat, curdt, self.trndet, self.vatcode, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("rcaowt", data=data) if self.glint == "Y": # General Ledger Transaction for Owner Control gld = "%7s %s" % (self.owner, self.trndet[:22]) data = [ self.opts["conum"], self.rcaown, curdt, self.trndat, gltyp, self.trnref, self.batno, amt, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) else: # Tenants Transaction accod = self.code data = [ self.opts["conum"], self.owner, self.code, self.acno, self.cnum, self.trntyp, self.trnref, self.batno, self.trndat, self.movtyp, amt, vat, curdt, self.trndet, self.vatcode, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("rcatnt", data=data) if self.glint == "Y": gld = "%7s %7s %7s" % (self.owner, self.code, self.acno) if self.df.pag == 3 and self.movtyp == 2: # General Ledger Transaction for Deposit Control acc = self.rcadep else: # General Ledger Transaction for Tenant Control acc = self.rcatnt data = [ self.opts["conum"], acc, curdt, self.trndat, gltyp, self.trnref, self.batno, amt, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) self.showTenantBalance() if self.trntyp in (2, 3): if self.glint == "Y": # General Ledger Transaction for Bank Account data = [ self.opts["conum"], self.glbnk, curdt, self.trndat, gltyp, self.trnref, self.batno, bnk, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) return if self.df.pag == 1 and self.df.pag == 1: # Owners Journal Entries (Unallocated) if self.glint == "Y": amt = float(ASD(0) - ASD(amt)) data = [ self.opts["conum"], self.rcaorx, curdt, self.trndat, gltyp, self.trnref, self.batno, amt, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) return if self.df.pag == 2 and self.movtyp == 1: # Rental and Commission Raised rta = float(ASD(0) - ASD(amt)) rtv = float(ASD(0) - ASD(vat)) des = "Rental on %s Premises" % self.code data = [ self.opts["conum"], self.owner, self.trntyp, self.trnref, self.batno, self.trndat, rta, rtv, curdt, des, self.vatcode, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("rcaowt", data=data) if self.glint == "Y": # General Ledger Transaction for Owner Control gld = "%7s Rental on %7s" % (self.owner, self.code) data = [ self.opts["conum"], self.rcaown, curdt, self.trndat, gltyp, self.trnref, self.batno, rta, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) if self.crate: # If there is a Commission Rate on the Premises Record cma = float(ASD(0) - ASD(round((rta * self.crate / 100.0), 2))) vrte = getVatRate(self.sql, self.opts["conum"], self.taxdf, self.trndat) if vrte is None: vrte = 0.0 cmv = round((cma * vrte / 100.0), 2) cmt = float(ASD(cma) + ASD(cmv)) cma = float(ASD(0) - ASD(cma)) tax = float(ASD(0) - ASD(cmv)) des = "Commission @ %3.5s%s Inclusive" % (self.crate, "%") data = [ self.opts["conum"], self.owner, 4, self.trnref, self.batno, self.trndat, cmt, cmv, curdt, des, self.vatdf, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("rcaowt", data=data) if self.glint == "Y": # Update Owner Control gld = "%7s Commission Raised" % self.owner data = [ self.opts["conum"], self.rcaown, curdt, self.trndat, gltyp, self.trnref, self.batno, cmt, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) # Update Commission Account data = [ self.opts["conum"], self.rcacom, curdt, self.trndat, gltyp, self.trnref, self.batno, cma, tax, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) if self.taxdf: # VAT Transaction (ctlvtf) data = [ self.opts["conum"], self.taxdf, "O", curdt, "R", self.trntyp, self.batno, self.trnref, self.trndat, self.acno, self.name, cma, tax, 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("ctlvtf", data=data) if self.glint == "Y" and tax: # Update VAT Control data = [ self.opts["conum"], self.convat, curdt, self.trndat, gltyp, self.trnref, self.batno, tax, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) return if self.df.pag == 3 and self.movtyp == 3: # Contract Fees amt = float(ASD(0) - ASD(amt) + ASD(vat)) vat = float(ASD(0) - ASD(vat)) if self.glint == "Y": # Update Contract Fee Account data = [ self.opts["conum"], self.rcafee, curdt, self.trndat, gltyp, self.trnref, self.batno, amt, vat, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) if self.taxdf: # VAT Transaction (ctlvtf) data = (self.opts["conum"], self.vatcode, "O", curdt, "R", self.trntyp, self.batno, self.trnref, self.trndat, accod, self.trndet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "Y": # Update VAT Control data = [ self.opts["conum"], self.convat, curdt, self.trndat, gltyp, self.trnref, self.batno, vat, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) return if self.df.pag == 3 and self.movtyp == 4: # Services - Owner Recovery rta = float(ASD(0) - ASD(amt)) rtv = float(ASD(0) - ASD(vat)) des = "Services Recovery on %s" % self.code data = [ self.opts["conum"], self.owner, self.trntyp, self.trnref, self.batno, self.trndat, rta, rtv, curdt, des, self.vatcode, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("rcaowt", data=data) if self.glint == "Y": # General Ledger Transaction for Owner Control gld = "%7s Services Recovery" % self.owner data = [ self.opts["conum"], self.rcaown, curdt, self.trndat, gltyp, self.trnref, self.batno, rta, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) return # Tenants Journal Entries (Unallocated) if self.glint == "Y": amt = float(ASD(0) - ASD(amt)) data = [ self.opts["conum"], self.rcatrx, curdt, self.trndat, gltyp, self.trnref, self.batno, amt, 0, gld, "", "", 0, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("gentrn", data=data) def exitPage(self): if self.df.frt == "T" and self.df.pag == 0: self.df.closeProcess() self.opts["mf"].closeLoop() elif self.df.frt == "C" and self.df.pag == 3: self.df.focusField("C", 3, self.df.col) else: self.opts["mf"].dbm.commitDbase(ask=True) try: self.otrn.closeProcess() except: pass try: self.ttrn.closeProcess() except: pass self.df.selPage("Owner") self.df.focusField("T", 0, 1) def allNotes(self): if self.df.frt == "C": state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") if self.df.pag == 1: key = "%s" % self.owner else: key = "%7s%7s%s" % (self.owner, self.code, self.acno) NotesCreate(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["capnm"], "RCA", key, commit=False) 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 allStmnt(self): if self.df.frt == "C" and self.df.pag == 1: self.sargs = [self.owner] self.repModule("rc3050") elif self.df.frt == "C" and self.df.pag == 2: self.sargs = [self.owner, self.code, self.acno] self.repModule("rc3060") else: self.df.focusField(self.df.frt, self.df.pag, self.df.col) def repModule(self, mod): self.exit = False state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") tit = ("Date and Printer Selection", ) fld = ((("T", 0, 0, 0), "ID1", 10, "Statement Date", "", self.sysdtw, "N", self.doPrtDate, None, None, ("efld", )), ) self.st = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=((self.doPrtEnd, "y"), ), txit=(self.doPrtExit, ), view=("N", "V"), mail=("B", "Y")) self.st.mstFrame.wait_window() if not self.exit: self.sargs.extend( [self.stdtw, self.stdtd, self.st.repprt, self.st.repeml]) popt = { "mf": self.opts["mf"], "conum": self.opts["conum"], "conam": self.opts["conam"], "capnm": self.opts["capnm"], "args": self.sargs } runModule(mod, **popt) 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 doPrtDate(self, frt, pag, r, c, p, i, w): self.stdtw = w self.stdtd = self.st.t_disp[0][0][0] def doPrtEnd(self): self.doPrtClose() def doPrtExit(self): self.exit = True self.doPrtClose() def doPrtClose(self): self.st.closeProcess()
class st1030(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["strgrp", "strmf1", "strmf2", "strloc", "strprc"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] return True def drawDialog(self): grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } st1 = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_code", "", 0, "Product-Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "X")], "whera": [("C", "st1_group", 0)] } loc = { "stype": "R", "tables": ("strmf2", "strloc"), "cols": (("st2_loc", "", 0, "Acc-Num"), ("srl_desc", "", 0, "Description")), "where": [("st2_cono", "=", self.opts["conum"])], "whera": (("C", "st2_group", 0), ("C", "st2_code", 1)) } self.fld = [(("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "Y", self.doGrp, grp, None, None), (("C", 0, 0, 1), "INA", 20, "Code", "Product Code", "", "N", self.doCode, st1, None, None), (("C", 0, 0, 2), "ONA", 30, "Description"), (("C", 0, 0, 3), "IUA", 1, "L", "Location", "", "N", self.doLoc, loc, None, None)] for x in range(self.plevs): lev = x + 1 txt = "Level-%s" % lev if lev == 1: ddd = self.doDelete else: ddd = None self.fld.append((("C", 0, 0, x + 4), "IUD", 10.2, txt, txt, "", "N", self.doLevel, None, ddd, ("notzero", ))) but = ( ("Import File",None,self.doImport,0,("C",0,1),("C",0,2), "Import Selling Prices from a CSV or XLS File "\ "having the following columns: Group, Code, "\ "Location, Prices by Level"), ("Exit", None, self.doExit, 1, ("C", 0, 1), ("C", 0, 2))) row = (20, ) self.df = TartanDialog(self.opts["mf"], rows=row, eflds=self.fld, cend=((self.doEnd, "y"), ), cxit=(self.doExit, ), butt=but) def doImport(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") impcol = [] pos = 0 for num, fld in enumerate(self.fld): if num == 2: continue if type(fld[2]) in (tuple, list): size = fld[2][1] else: size = fld[2] impcol.append([fld[4], pos, fld[1][1:], size]) pos += 1 fi = FileImport(self.opts["mf"], impcol=impcol) err = None for num, line in enumerate(fi.impdat): if len(line) != pos: err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \ (num + 1, pos, len(line)) break self.grp = line[0] chk = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", self.grp)], limit=1) if not chk: err = "Line %s: Invalid Group %s" % ((num + 1), self.grp) break self.cod = line[1] chk = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", self.cod)], limit=1) if not chk: err = "Line %s: Invalid Code %s" % ((num + 1), self.cod) break self.loc = line[2] chk = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.grp), ("st2_code", "=", self.cod), ("st2_loc", "=", self.loc)], limit=1) if not chk: err = "Line %s: Invalid Location %s" % ((num + 1), self.loc) break self.levs = [] for x in range(self.plevs): self.levs.append(line[x + 3]) if len(self.levs) != self.plevs: err = "Line %s: Invalid Number of Levels (S/B %s is %s)" % \ ((num + 1), self.plevs, len(self.levs)) self.doEnd(det=True) if err: showError(self.opts["mf"].body, "Import Error", err) elif fi.impdat: self.opts["mf"].dbm.commitDbase() self.df.enableButtonsTags(state=state) self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField(self.df.frt, self.df.pag, 1) def doGrp(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not chk: return "Invalid Group" self.grp = w def doCode(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("strmf1", cols=["st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", w)], limit=1) if not chk: return "Invalid Code" self.cod = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) if self.locs == "N": self.loc = "1" self.df.loadEntry(frt, pag, p + 2, data=self.loc) self.doLoadLevs(p + 3) return "sk2" def doLoc(self, frt, pag, r, c, p, i, w): chk = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.grp), ("st2_code", "=", self.cod), ("st2_loc", "=", w)], limit=1) if not chk: return "Invalid Location" self.loc = w self.doLoadLevs(p + 1) def doDelete(self): self.sql.delRec("strprc", where=[("stp_cono", "=", self.opts["conum"]), ("stp_group", "=", self.grp), ("stp_code", "=", self.cod), ("stp_loc", "=", self.loc)]) self.opts["mf"].dbm.commitDbase() self.df.clearLine(0, focus=True) def doLoadLevs(self, p): self.levs = [] for x in range(self.plevs): prc = self.sql.getRec("strprc", cols=["stp_price"], where=[("stp_cono", "=", self.opts["conum"]), ("stp_group", "=", self.grp), ("stp_code", "=", self.cod), ("stp_loc", "=", self.loc), ("stp_level", "=", x + 1)], limit=1) if not prc: prc = [0] self.df.loadEntry("C", 0, p, data=prc[0]) self.levs.append(prc[0]) p += 1 def doLevel(self, frt, pag, r, c, p, i, w): self.levs[i - 4] = w def doEnd(self, det=False): self.sql.delRec("strprc", where=[("stp_cono", "=", self.opts["conum"]), ("stp_group", "=", self.grp), ("stp_code", "=", self.cod), ("stp_loc", "=", self.loc)]) for num, lev in enumerate(self.levs): self.sql.insRec("strprc", data=[ self.opts["conum"], self.grp, self.cod, self.loc, num + 1, lev ]) self.opts["mf"].dbm.commitDbase() self.df.advanceLine(0) self.df.loadEntry("C", 0, self.df.pos, data=self.grp) self.df.focusField("C", 0, self.df.col + 1) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class ln2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): # Create SQL Object self.sql = Sql(self.opts["mf"].dbm, [ "ctlmst", "lonmf1", "lonmf2", "lonrte", "lontrn", "genint", "genmst", "gentrn" ], prog=self.__class__.__name__) if self.sql.error: return # Check for Intercompany Facility if not self.sql.getRec("ctlmst", cols=["count(*)"], where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]: self.incoac = False else: itg = self.sql.getRec("genint", cols=["cti_inco"], where=[("cti_cono", "=", self.opts["conum"]) ]) if itg: self.incoac = [self.opts["conum"]] [self.incoac.append(coy[0]) for coy in itg] else: self.incoac = False self.gc = GetCtl(self.opts["mf"]) lonctl = self.gc.getCtl("lonctl", self.opts["conum"]) if not lonctl: return self.glint = lonctl["cln_glint"] self.drte = lonctl["cln_drte"] self.crte = lonctl["cln_crte"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["lon_ctl", "int_rec", "int_pay"] if self.gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.lonctl = ctlctl["lon_ctl"] self.intrec = ctlctl["int_rec"] self.intpay = ctlctl["int_pay"] self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.allcoy = self.opts["conum"] ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "LON", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return if self.opts["rtn"] == 4: self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) def drawDialog(self): lm1 = { "stype": "R", "tables": ("lonmf1", ), "cols": (("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")), "where": [("lm1_cono", "=", self.opts["conum"])] } lm2 = { "stype": "R", "tables": ("lonmf2", ), "cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0, "Description", "Y")), "where": [("lm2_cono", "=", self.opts["conum"])], "whera": [("C", "lm2_acno", 0)] } coy = { "stype": "R", "tables": ("ctlmst", ), "cols": (("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y")) } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "whera": [["C", "glm_cono", 0, 2]] } fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "INA", 7, "Acc-Num", "Account Code", "", "Y", self.doLonAcc, lm1, None, ("efld", )), (("C", 1, 0, 1), "ONA", 10, "Name"), (("C", 1, 0, 2), "IUI", 2, "LN", "Loan Number", "", "N", self.doLonNum, lm2, None, ("efld", )), (("C", 1, 0, 3), "ITX", (12, 30), "Description", "", "", "N", self.doLonDes, None, None, ("notblank", )), (("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 5), "INa", 9, "Reference", "Reference Number One", "i", "N", self.doTrnRef, None, None, ("notblank", )), (("C", 1, 0, 6), "ISD", 13.2, "Amount", "Transaction Amount", "", "N", self.doTrnAmt, None, None, ("notzero", )), (("C", 1, 0, 7), "IUD", 6.2, "DRte-%", "Debit Rate", self.drte, "N", self.doLonDrt, None, None, None), (("C", 1, 0, 8), "IUD", 6.2, "CRte-%", "Credit Rate", self.crte, "N", self.doLonCrt, None, None, None), (("C", 1, 0, 9), "IUI", 3, "Mth", "Period in Months", "", "N", self.doLonMth, None, None, ("efld", )), (("C", 1, 0, 10), "OUD", 12.2, "Repay-Amt"), (("C", 1, 0, 11), "INA", 30, "Details", "Loan Details", "", "N", self.doTrnDet, None, None, None)] if self.opts["rtn"] == 3 and self.glint == "Y": fld.extend([(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"), [("C", 2, 0, 0), "IUI", 3, "Coy", "Company Number", self.opts["conum"], "N", self.doCoyNum, coy, None, None], (("C", 2, 0, 1), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doGenAcc, glm, None, None), (("C", 2, 0, 2), "ONA", 19, "Description"), (("C", 2, 0, 4), "ISD", 13.2, "All-Amount", "Allocation Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 6), "INA", 30, "Allocation Details", "", "", "N", self.doAllDet, None, None, ("notblank", ))]) if not self.incoac: fld[15][1] = "OUI" but = [("Interrogate", None, self.querySln, 0, ("C", 1, 1), ("C", 1, 2))] tag = [("Transaction", None, None, None, False)] cnd = [(None, "n"), (self.endPage1, "y")] cxt = [None, self.exitPage1] if self.opts["rtn"] == 3 and self.glint == "Y": but.append( ("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1))) tag.append(("Allocation", None, None, None, False)) cnd.append((self.endPage2, "y")) cxt.append(self.exitPage2) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doLonAcc(self, frt, pag, r, c, p, i, w): newacc = False if not w and self.opts["rtn"] in (1, 2, 3): yn = askQuestion(self.opts["mf"].body, "New Account", "Is This a New Account?", default="no") if yn == "no": return "Invalid Account Number" newacc = True w = callModule(self.opts["mf"], self.df, "ln1010", coy=(self.opts["conum"], self.opts["conam"]), user=self.opts["capnm"], args="auto", ret="acno") self.df.loadEntry(frt, pag, p, data=w) acc = self.sql.getRec("lonmf1", cols=["lm1_name"], where=[("lm1_cono", "=", self.allcoy), ("lm1_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" self.lonacc = w self.name = acc[0] self.df.loadEntry(frt, pag, p + 1, data=self.name) if newacc: self.lonnum = 1 self.newlon = True self.df.loadEntry(frt, pag, p + 2, data=self.lonnum) return "sk2" def doLonNum(self, frt, pag, r, c, p, i, w): self.newlon = False if not w and self.opts["rtn"] in (1, 2, 3): ok = askQuestion(self.opts["mf"].body, head="New Loan", mess="Is This a New Loan?", default="no") if ok == "yes": self.newlon = True self.lonnum = getNextCode(self.sql, "lonmf2", "lm2_loan", where=[ ("lm2_cono", "=", self.allcoy), ("lm2_acno", "=", self.lonacc) ], start=1, last=9999999) self.df.loadEntry(frt, pag, p, data=self.lonnum) else: return "Invalid Loan Number" else: self.lonmf2 = self.sql.getRec("lonmf2", where=[ ("lm2_cono", "=", self.allcoy), ("lm2_acno", "=", self.lonacc), ("lm2_loan", "=", w) ], limit=1) if not self.lonmf2: return "Invalid Loan Number" self.lonnum = w self.londes = self.lonmf2[self.sql.lonmf2_col.index("lm2_desc")] self.londat = self.lonmf2[self.sql.lonmf2_col.index("lm2_start")] self.lonmth = self.lonmf2[self.sql.lonmf2_col.index("lm2_pmths")] self.lonpay = self.lonmf2[self.sql.lonmf2_col.index("lm2_repay")] if self.opts["rtn"] in (1, 3) and self.lonmth: showError( self.opts["mf"].body, "Fixed Loan", """This is a Fixed Period Loan. Please Create a New Loan for this Account.""") return "Invalid Loan Number" self.df.loadEntry(frt, pag, p + 1, data=self.londes) return "sk1" def doLonDes(self, frt, pag, r, c, p, i, w): self.londes = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnRef(self, frt, pag, r, c, p, i, w): self.refno = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w if not self.newlon: self.londrt = 0 self.loncrt = 0 self.lonmth = 0 self.lonpay = 0 if self.opts["rtn"] in (1, 2): return "nd" else: return "sk4" def doLonDrt(self, frt, pag, r, c, p, i, w): self.londrt = w def doLonCrt(self, frt, pag, r, c, p, i, w): self.loncrt = w def doLonMth(self, frt, pag, r, c, p, i, w): self.lonmth = w if self.lonmth: rte = (self.londrt / 1200.0) self.lonpay = round( ((self.trnamt * rte) * ((1 + rte)**w)) / (((1 + rte)**w) - 1), 2) else: self.lonpay = 0 self.df.loadEntry(frt, pag, p + 1, data=self.lonpay) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.glint == "Y" and self.opts["rtn"] == 3: self.df.colf[2][4][5] = w def endPage1(self): self.batupd = False self.updateTables1() self.updateBatch() if not self.val: self.df.advanceLine(1) elif self.opts["rtn"] in (1, 2, 4) or self.glint == "N": self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.allocated = float(0.0) self.df.loadEntry("T", 2, 0, data=self.val) self.df.selPage("Allocation") self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt if self.opts["rtn"] == 1: self.glt = 2 desc = "Loan Advance" self.val = self.trnamt elif self.opts["rtn"] == 2: self.glt = 6 desc = "Loan Repayment" self.val = float(ASD(0) - ASD(self.trnamt)) elif self.opts["rtn"] == 3: self.glt = 4 desc = self.trndet self.val = self.trnamt elif self.opts["rtn"] == 4: self.glt = 4 desc = self.trndet self.val = self.trnamt if self.newlon: # Loans Masterfile self.sql.insRec("lonmf2", data=[ self.opts["conum"], self.lonacc, self.lonnum, self.londes, self.trndat, self.lonmth, self.lonpay, 0 ]) # Loans Rate File self.sql.insRec("lonrte", data=[ self.opts["conum"], self.lonacc, self.lonnum, self.trndat, self.londrt, self.loncrt ]) # Loans Transaction File self.sql.insRec("lontrn", data=[ self.opts["conum"], self.lonacc, self.lonnum, self.bh.batno, self.opts["rtn"], self.trndat, self.refno, self.val, self.curdt, desc, "N", self.opts["capnm"], self.sysdtw, 0 ]) if self.glint == "N": return # General Ledger Loans Control Account data = (self.opts["conum"], self.lonctl, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, self.val, 0.00, self.name, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.opts["rtn"] in (1, 2, 4): # General Ledger Bank or Interest self.val = float(ASD(0) - ASD(self.val)) if self.opts["rtn"] in (1, 2): ctl = self.bh.acc elif self.val < 0: ctl = self.intrec else: ctl = self.intpay data = (self.opts["conum"], ctl, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, self.val, 0.00, "Loan - %s" % self.name, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doCoyNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", w)], limit=1) if not acc: return "Invalid Company, Missing" if self.incoac and w not in self.incoac: return "Invalid Company, No Intercompany Record 1" if w != self.opts["conum"]: acc = self.sql.getRec("genint", where=[("cti_cono", "=", w), ("cti_inco", "=", self.opts["conum"]) ], limit=1) if not acc: return "Invalid Company, No Intercompany Record 2" self.allcoy = w def doGenAcc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.allcoy, w) if type(chk) is str: return chk self.genacc = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) def doAllAmt(self, frt, pag, r, c, p, i, w): if w == 0: self.allamt = float(ASD(self.val) - ASD(self.allocated)) self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.allamt = w def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): ok = askQuestion(self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) self.df.clearFrame("C", 2) self.df.selPage("Transaction") row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.focusField("C", 1, col) def endPage2(self): self.updateTables2() self.allocated = float(ASD(self.allocated) + ASD(self.allamt)) if self.allocated == self.val: self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.val) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): val = float(ASD(0) - ASD(self.allamt)) # General Ledger Transaction (Allocation) data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, val, 0.00, self.alldet, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany) if self.allcoy != self.opts["conum"]: # General Ledger Transaction (Intercompany From) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=", self.allcoy)], limit=1)[0] data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany To) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.allcoy), ("cti_inco", "=", self.opts["conum"]) ], limit=1)[0] val = float(ASD(0) - ASD(val)) data = (self.allcoy, acc, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def updateBatch(self, rev=False): if rev: self.bh.batqty = self.bh.batqty - 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.val)) else: self.batupd = True self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.val)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def querySln(self): callModule(self.opts["mf"], self.df, "ln4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class st5020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["strloc", "strgrp", "strmf1", "strmf2", "strgmu", "strcmu", "strprc", "strtrn", "strvar"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.locs = strctl["cts_locs"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.last = 0 return True def dataHeader(self): self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]), "Stores Ledger Stock Take Returns (%s)" % self.__class__.__name__) loc = { "stype": "R", "tables": ("strloc",), "cols": ( ("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])]} gpm = { "stype": "R", "tables": ("strgrp",), "cols": ( ("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])]} stm1 = { "stype": "R", "tables": ("strmf1",), "cols": ( ("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_desc", "", 0, "Description", "Y")), "where": [ ("st1_cono", "=", self.opts["conum"]), ("st1_type", "not", "in", ("R", "X"))], "whera": [["T", "st1_group", 4, 0]], "order": "st1_group, st1_code", "index": 1} r1s = (("Number","N"),("Bin Number","B")) r2s = (("Yes","Y"),("No","N")) r3s = (("No","N"),("Last","L"),("Average","A")) fld = ( (("T",0,0,0),("IRB",r1s),0,"Sort Order","", "N","Y",self.doSort,None,None,None), (("T",0,1,0),"IUA",1,"Location","", "","N",self.doLoc,loc,None,("efld",)), (("T",0,2,0),("IRB",r2s),0,"Auto Sequence","", "N","N",self.doAuto,None,None,None), (("T",0,3,0),"IUA",8,"First Bin Number","", "","N",self.doFbin,None,None,("efld",)), (("T",0,4,0),"IUA",3,"First Group","", "","N",self.doFgrp,gpm,None,None), (("T",0,5,0),"INA",20,"First Code","", "","N",self.doFcode,stm1,None,None), (("T",0,6,0),("IRB",r3s),0,"Cost Prices","", "N","N",self.doCosts,None,None,None)) tnd = ((self.endPage1,"y"),) txt = (self.exitPage1,) self.df1 = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, tend=tnd, txit=txt) def doSort(self, frt, pag, r, c, p, i, w): self.sort = w if self.locs == "N": self.loc = "1" self.df1.loadEntry(frt, pag, p+1, data=self.loc) return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not acc: return "Invalid Location Code" self.loc = w def doAuto(self, frt, pag, r, c, p, i, w): self.auto = w if self.auto != "Y": return "sk3" self.bin = "" self.fgrp = "" self.fcode = "" if self.sort == "N": return "sk1" def doFbin(self, frt, pag, r, c, p, i, w): self.fbin = w def doFgrp(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.fgrp = w if not self.fgrp: self.fcode = "" self.df1.loadEntry(frt, pag, p+1, data=self.fcode) return "sk1" def doFcode(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("strmf1", cols=["st1_type"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.fgrp), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] == "R": return "Invalid Code (Recipe Item)" if acc[0] == "X": return "Invalid Code (Redundant Item)" self.fcode = w def doCosts(self, frt, pag, r, c, p, i, w): self.costs = w def endPage1(self): self.df1.closeProcess() self.dataBody() if self.auto == "Y": whr = [("st1_cono", "=", self.opts["conum"])] if self.fgrp: whr.append(("st1_group", ">=", self.fgrp)) if self.fcode: whr.append(("st1_code", ">=", self.fcode)) whr.extend([("st1_type", "not", "in", ("R","X")), ("st2_cono=st1_cono",), ("st2_group=st1_group",), ("st2_code=st1_code",), ("st2_loc", "=", self.loc)]) self.codes = self.sql.getRec(tables=["strmf1", "strmf2"], cols=["st1_group", "st1_code", "st1_desc", "st1_uoi", "st2_bin"], where=whr, order="st1_group, st1_code") if not self.codes: showError(self.opts["mf"].body, "No Records", "No Stock Records on File") self.exitPage2() else: self.doNextOne() def exitPage1(self): self.df1.closeProcess() self.opts["mf"].closeLoop() def dataBody(self): gpm = { "stype": "R", "tables": ("strgrp",), "cols": ( ("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])]} stm2 = { "stype": "R", "tables": ("strmf1",), "cols": ( ("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_desc", "", 0, "Description", "Y")), "where": [ ("st1_cono", "=", self.opts["conum"]), ("st1_type", "not", "in", ("R", "X"))], "whera": [["C", "st1_group", 0, 0]], "index": 1} if self.auto == "Y": fld = [ (("C",0,0,0),"ONA",3,"Grp"), (("C",0,0,1),"ONA",20,"Product Code")] else: fld = [ (("C",0,0,0),"INA",3,"Grp","Product Group", "r","N",self.doGroup2,gpm,None,("notblank",)), (("C",0,0,1),"INA",20,"Product Code","", "","N",self.doCode2,stm2,None,("notblank",))] fld.extend([ (("C",0,0,2),"ONA",16,"Description"), (("C",0,0,3),"ONA",10,"U.O.I"), (("C",0,0,4),"OUA",8,"Bin")]) if self.costs == "N": fld.append((("C",0,0,5),"OUD",9.2,"Unit-Cost")) else: fld.append((("C",0,0,5),"IUD",9.2,"Unit-Cost","", "","N",self.doUcost,None,None,("efld",))) fld.append((("C",0,0,6),"ISD",9.2,"Quantity","", "","N",self.doQty,None,None,("efld",))) cnd = ((self.endPage2,"y"),) cxt = (self.exitPage2,) self.df2 = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld, cend=cnd, cxit=cxt) def doGroup2(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.group2 = w def doCode2(self, frt, pag, r, c, p, i, w): ac1 = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group2), ("st1_code", "=", w)], limit=1) if not ac1: return "Invalid Code" if ac1[0] == "R": return "Invalid Code (Recipe Item)" if ac1[0] == "X": return "Invalid Code (Redundant Item)" ac2 = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group2), ("st2_code", "=", w), ("st2_loc", "=", self.loc)], limit=1) if not ac2: return "Invalid Location For This Product" self.code2 = w self.df2.loadEntry("C", 0, p+1, data=ac1[0]) self.df2.loadEntry("C", 0, p+2, data=ac1[1]) self.bin = ac2[self.sql.strmf2_col.index("st2_bin")] self.df2.loadEntry("C", 0, p+3, data=self.bin) self.ucost, qty = self.doGetValues() self.df2.loadEntry("C", 0, p+4, data=self.ucost) self.df2.loadEntry("C", 0, p+5, data=qty) def doUcost(self, frt, pag, r, c, p, i, w): self.ucost = w def doQty(self, frt, pag, r, c, p, i, w): self.qty = w self.amt1 = round((self.qty * self.ucost), 2) def endPage2(self): self.updateTables() self.df2.advanceLine(0) if self.auto == "Y": self.last += 1 self.doNextOne() def updateTables(self): # Stores Variance Transaction whr = [ ("stv_cono", "=", self.opts["conum"]), ("stv_group", "=", self.group2), ("stv_code", "=", self.code2), ("stv_loc", "=", self.loc)] if self.sql.getRec("strvar", where=whr, limit=1): self.sql.delRec("strvar", where=whr) self.sql.insRec("strvar", data=[self.opts["conum"], self.group2, self.code2, self.loc, self.bin, self.qty, self.ucost, 0]) self.opts["mf"].dbm.commitDbase() def doNextOne(self): if self.last == len(self.codes): self.exitPage2() else: data = self.codes[self.last] self.group2 = data[0] self.code2 = data[1] self.bin = data[4] self.ucost, qty = self.doGetValues() data.extend([self.ucost, qty]) p = self.df2.pos if self.costs == "N": xs = 6 else: xs = 5 for x in range(0, 7): self.df2.loadEntry("C", 0, (p + x - xs), data=data[x]) self.df2.focusField("C", 0, p) def doGetValues(self): var = self.sql.getRec("strvar", where=[("stv_cono", "=", self.opts["conum"]), ("stv_group", "=", self.group2), ("stv_code", "=", self.code2), ("stv_loc", "=", self.loc)], limit=1) if var: qty = var[self.sql.strvar_col.index("stv_qty")] cst = var[self.sql.strvar_col.index("stv_ucost")] if not cst: bal = self.doGetCost(self.group2, self.code2) cst = bal[0] else: cst, qty = self.doGetCost(self.group2, self.code2) return (cst, qty) def doGetCost(self, grp, code): if self.costs == "N": ind = "I" else: ind = self.costs cost, bal = getCost(self.sql, self.opts["conum"], grp, code, loc=self.loc, ind=ind, bal=True) return (cost, bal[0]) def exitPage2(self): self.df2.closeProcess() self.opts["mf"].closeLoop()
class sl2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql( self.opts["mf"].dbm, ["genmst", "gentrn", "wagedc", "wagmst", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) wagctl = self.gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.glint = wagctl["ctw_glint"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"], ctlctl, ["wag_slc"]): return self.slnctl = ctlctl["wag_slc"] self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "SLN", 2, glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def dataHeader(self): wgm = { "stype": "R", "tables": ("wagmst", ), "cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0, "Surname", "Y")), "where": [("wgm_cono", "=", self.opts["conum"])] } ced = { "stype": "R", "tables": ("wagedc", ), "cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"), ("ced_desc", "", 0, "Description", "Y")), "where": [("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "D")], "index": 1 } fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 0, 0, 0), "IUI", 5, "EmpNo", "Employee Number", "", "N", self.doEmpno, wgm, None, None), (("C", 0, 0, 1), "ONA", 20, "Name"), (("C", 0, 0, 2), "OUI", 2, "Ln"), (("C", 0, 0, 3), "INA", 15, "Description", "", "", "N", self.doDesc, None, None, None), (("C", 0, 0, 4), "ID1", 10, "Date", "", "", "N", self.doSdate, None, None, None), (("C", 0, 0, 5), "INa", 9, "Ref-No", "Reference Number", "", "N", self.doRef, None, None, ("notblank", )), (("C", 0, 0, 6), "IUI", 3, "Cde", "Deduction Code", "", "N", self.doCode, ced, None, ("notzero", )), (("C", 0, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate", "", "N", self.doInt, None, None, None), (("C", 0, 0, 8), "IUD", 12.2, "Loan-Amt", "Loan Amount", "", "N", self.doAmt, None, None, ("notzero", )), (("C", 0, 0, 9), "IUD", 12.2, "Ded-Amt", "Deduction Amount", "", "N", self.doDed, None, None, ("efld", ))) but = (("Interrogate", None, self.querySln, 0, ("C", 0, 1), ("C", 0, 2)), ) cnd = ((self.endPage, "y"), ) cxt = (self.exitPage, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, cend=cnd, cxit=cxt) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 0, 1) def doEmpno(self, frt, pag, r, c, p, i, w): self.empno = w acc = self.sql.getRec("wagmst", cols=["wgm_sname", "wgm_fname"], where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", self.empno)], limit=1) if not acc: return "Invalid Employee Number" self.name = "%s, %s" % (acc[0], acc[1].split()[0]) self.df.loadEntry("C", pag, p + 1, data=self.name) self.loan = getNextCode(self.sql, "waglmf", "wlm_loan", where=[("wlm_cono", "=", self.opts["conum"]), ("wlm_empno", "=", self.empno)], start=1, last=9999999) self.df.loadEntry("C", pag, p + 2, data=self.loan) def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doSdate(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.sdate = w def doRef(self, frt, pag, r, c, p, i, w): self.ref = w def doCode(self, frt, pag, r, c, p, i, w): self.code = w desc = self.sql.getRec("wagedc", cols=["ced_desc"], where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", "D"), ("ced_code", "=", w)], limit=1) if not desc: return "Invalid Code" def doInt(self, frt, pag, r, c, p, i, w): self.rte = w def doAmt(self, frt, pag, r, c, p, i, w): self.amt = w def doDed(self, frt, pag, r, c, p, i, w): self.ded = w def endPage(self): self.updateTables() self.updateBatch() self.opts["mf"].dbm.commitDbase() self.df.advanceLine(0) def exitPage(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def updateTables(self): if self.bh.multi == "Y": curdt = int(self.sdate / 100) else: curdt = self.bh.curdt self.sql.insRec("waglmf", data=[ self.opts["conum"], self.empno, self.loan, self.desc, self.code, self.rte, self.sdate, self.ded ]) self.sql.insRec("wagltf", data=[ self.opts["conum"], self.empno, self.loan, self.bh.batno, 2, self.sdate, self.ref, self.amt, self.amt, self.ded, self.rte, curdt, self.desc, "N", self.opts["capnm"], self.sysdtw, 0 ]) if self.glint == "N": return # General Ledger Staff Loans Control Account data = (self.opts["conum"], self.slnctl, curdt, self.sdate, 2, self.ref, self.bh.batno, self.amt, 0.00, self.name, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) amt = float(ASD(0) - ASD(self.amt)) # General Ledger Bank Account data = (self.opts["conum"], self.bh.acc, curdt, self.sdate, 2, self.ref, self.bh.batno, amt, 0.00, "Staff Loan - %s" % self.name, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def updateBatch(self): self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.amt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def querySln(self): callModule(self.opts["mf"], self.df, "sl4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class sc2010(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, [ "scpcmp", "scpmem", "scpclb", "scpsec", "scprnd", "scpent", "scpgme" ], prog=self.__class__.__name__) if self.sql.error: return self.img = None self.newent = False return True def mainProcess(self): com = { "stype": "R", "tables": ("scpcmp", ), "cols": (("scp_ccod", "", 0, "Cod"), ("scp_name", "", 0, "Name", "Y"), ("scp_tsiz", "", 0, "S"), ("scp_fmat", "", 0, "F")), "where": [("scp_cono", "=", self.opts["conum"])] } fmt = { "stype": "C", "titl": "Select the Required Format", "head": ("C", "Format"), "data": [("R", "Round Robin"), ("K", "Knockout")] } log = {"stype": "F", "types": "fle", "ftype": (("Image", "*"), )} sk1 = { "stype": "R", "tables": ("scpmem", ), "cols": (("scm_scod", "", 0, "Cod"), ("scm_surname", "", 0, "Surname", "Y"), ("scm_names", "", 0, "Names")), "where": [("scm_cono", "=", self.opts["conum"])], "order": "scm_surname" } sk2 = { "stype": "R", "tables": ("scpent", "scpmem"), "cols": (("scm_scod", "", 0, "Cod"), ("scm_surname", "", 0, "Surname", "Y"), ("scm_names", "", 0, "Names")), "where": [("scm_cono", "=", self.opts["conum"]), ("scm_scod=sce_scod", )], "whera": [("T", "sce_ccod", 0, 0)], "order": "scm_surname", "butt": [("Delete", self.doDelete, True), ("Print All", self.doPrint)] } r1s = (("Male", "M"), ("Female", "F"), ("Both", "B")) r2s = (("Fours", "4"), ("Trips", "3"), ("Pairs", "2"), ("Singles", "1")) r3s = (("Knockout", "K"), ("Round-Robin", "R")) fld = ((("T", 0, 0, 0), "I@scp_ccod", 0, "Code", "Competition Code", "", "Y", self.doCmpCod, com, None, ("efld", )), (("T", 0, 0, 0), "I@scp_name", 0, "Name", "Competition Name", "", "N", self.doCmpNam, None, None, ("notblank", )), (("T", 0, 1, 0), ("IRB", r1s), 0, "Gender", "", "M", "N", self.doCmpSex, None, None, None), (("T", 0, 2, 0), ("IRB", r2s), 0, "Team Size", "", "4", "N", self.doCmpSiz, None, None, None), (("T", 0, 3, 0), ("IRB", r3s), 0, "Format", "", "K", "N", self.doCmpTyp, fmt, None, None), (("T", 0, 4, 0), "I@scp_logo", 0, "Logo", "Sponsor's Logo", "", "N", self.doCmpLogo, log, None, ("fle", "blank")), (("C", 0, 0, 0), "I@scm_scod", 0, "Skip ", "", "", "Y", self.doSkpCod, sk1, None, ("efld", )), (("C", 0, 0, 1), "ONA", 30, "Name"), (("C", 0, 0, 2), "I@scm_scod", 0, "Lead ", "", "", "n", self.doSkpCod, sk1, None, ("efld", )), (("C", 0, 0, 3), "ONA", 30, "Name")) but = (("Entered Players", sk2, None, 0, ("C", 0, 1), ("T", 0, 1)), ) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) cnd = ((self.doEnd, "n"), ) cxt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doCmpCod(self, frt, pag, r, c, p, i, w): self.skips = [] self.parts = [] nxtcod = getNextCode(self.sql, "scpcmp", "scp_ccod", where=[("scp_cono", "=", self.opts["conum"])], last=999) if not w or w > nxtcod: self.ccod = nxtcod self.df.loadEntry(frt, pag, p, data=self.ccod) else: self.ccod = w self.old = self.sql.getRec("scpcmp", where=[("scp_cono", "=", self.opts["conum"]), ("scp_ccod", "=", self.ccod)], limit=1) if not self.old: ok = askQuestion(self.opts["mf"].body, head="New Competition", mess="Is This a New Competition?", default="no") if ok == "no": return "rf" self.newcmp = True else: state = self.old[self.sql.scpcmp_col.index("scp_state")] if state > 1: return "This Competition Has Already Started" if state == 1: ok = askQuestion(self.opts["mf"].window, "Already Drawn", """This Competition Has Already Been Drawn. Do You Want to Modify and Redraw It?""", default="no") if ok == "no": return "rf" self.sql.updRec("scpcmp", cols=["scp_state"], data=[0], where=[("scp_cono", "=", self.opts["conum"]), ("scp_ccod", "=", self.ccod)]) self.sql.delRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod)]) self.sql.delRec("scprnd", where=[("scr_cono", "=", self.opts["conum"]), ("scr_ccod", "=", self.ccod)]) self.sql.delRec("scpsec", where=[("scs_cono", "=", self.opts["conum"]), ("scs_ccod", "=", self.ccod)]) self.newcmp = False self.cmpnam = self.old[self.sql.scpcmp_col.index("scp_name")] self.tsex = self.old[self.sql.scpcmp_col.index("scp_tsex")] self.tsiz = self.old[self.sql.scpcmp_col.index("scp_tsiz")] self.fmat = self.old[self.sql.scpcmp_col.index("scp_fmat")] self.logo = self.old[self.sql.scpcmp_col.index("scp_logo")] self.df.loadEntry(frt, pag, p + 1, data=self.cmpnam) self.df.loadEntry(frt, pag, p + 2, data=str(self.tsex)) self.df.loadEntry(frt, pag, p + 3, data=str(self.tsiz)) self.df.loadEntry(frt, pag, p + 4, data=self.fmat) self.df.loadEntry(frt, pag, p + 5, data=self.logo) def doCmpNam(self, frt, pag, r, c, p, i, w): self.cmpnam = w def doCmpSex(self, frt, pag, r, c, p, i, w): self.tsex = w def doCmpSiz(self, frt, pag, r, c, p, i, w): self.tsiz = int(w) def doCmpTyp(self, frt, pag, r, c, p, i, w): self.fmat = w def doCmpLogo(self, frt, pag, r, c, p, i, w): if w and not os.path.isfile(w): return "Invalid Logo Path" self.logo = w try: if self.img: self.img.destroyImage() self.img = ShowImage(self.df.topPage0, self.logo, wrkdir=self.opts["mf"].rcdic["wrkdir"], msiz=100) except: pass def doSkpCod(self, frt, pag, r, c, p, i, w): if not w: ok = askQuestion(self.opts["mf"].body, head="New Player", mess="Is This a New Player?", default="yes") if ok == "no": return "Invalid Code" cod = getNextCode(self.sql, "scpmem", "scm_scod", where=[("scm_cono", "=", self.opts["conum"])], last=899999) callModule(self.opts["mf"], self.df, "sc1010", coy=[self.opts["conum"], self.opts["conam"]], args=(cod, )) self.df.loadEntry(frt, pag, p, data=cod) else: cod = w if i == 0: if cod in self.parts: return "Invalid Skip, Already a Partner" self.skips.append(cod) self.scod = cod else: if cod in self.skips: return "Invalid Partner, Already a Skip" self.parts.append(cod) self.pcod = cod chk = self.sql.getRec("scpmem", cols=["scm_surname", "scm_names", "scm_gender"], where=[("scm_cono", "=", self.opts["conum"]), ("scm_scod", "=", cod)], limit=1) if not chk: return "Invalid Player Code" if self.tsex in ("M", "F") and chk[2] != self.tsex: return "Invalid Gender" self.df.loadEntry(frt, pag, p + 1, data=self.getName(chk=chk)) if i == 0: ent = self.sql.getRec("scpent", cols=["sce_pcod"], where=[("sce_cono", "=", self.opts["conum"]), ("sce_ccod", "=", self.ccod), ("sce_scod", "=", self.scod)], limit=1) if ent: self.newent = False if ent[0]: ptr = self.sql.getRec("scpmem", cols=["scm_surname", "scm_names"], where=[("scm_cono", "=", self.opts["conum"]), ("scm_scod", "=", ent[0])], limit=1) self.df.loadEntry(frt, pag, p + 2, data=ent[0]) self.df.loadEntry(frt, pag, p + 3, data=self.getName(chk=ptr)) else: self.newent = True if self.tsiz != 2: self.pcod = 0 return "sk3" def getName(self, scod=None, chk=None): if scod: chk = self.sql.getRec( "scpmem", cols=["scm_surname", "scm_names", "scm_gender"], where=[("scm_cono", "=", self.opts["conum"]), ("scm_scod", "=", scod)], limit=1) name = "%s," % chk[0] init = chk[1].split() for i in init: name = "%s %s" % (name, i.upper()) return name def doDelete(self, args=None): self.scod = args[1] self.sql.delRec("scpent", where=[("sce_cono", "=", self.opts["conum"]), ("sce_ccod", "=", self.ccod), ("sce_scod", "=", self.scod)]) self.sql.delRec("scpgme", where=[("scg_cono", "=", self.opts["conum"]), ("scg_ccod", "=", self.ccod), ("scg_scod", "=", self.scod)]) self.loadButton() self.doLoadEntries() def doEnd(self): if self.df.frt == "T": data = [self.opts["conum"]] + self.df.t_work[0][0] + \ [0,0,"","","",0,0,""] if self.newcmp: self.sql.insRec("scpcmp", data=data) elif data != self.old[:len(data)]: col = self.sql.scpcmp_col data.append(self.old[col.index("scp_xflag")]) self.sql.updRec("scpcmp", data=data, where=[("scp_cono", "=", self.opts["conum"]), ("scp_ccod", "=", self.ccod)]) self.loadButton() if self.newcmp: self.df.focusField("C", 0, 1) else: self.doLoadEntries() else: if self.newent: self.sql.insRec( "scpent", data=[self.opts["conum"], self.ccod, self.scod, self.pcod]) self.df.advanceLine(0) else: self.sql.updRec("scpent", cols=["sce_scod", "sce_pcod"], data=[self.scod, self.pcod], where=[("sce_cono", "=", self.opts["conum"]), ("sce_ccod", "=", self.ccod), ("sce_scod", "=", self.scod)]) self.doLoadEntries() self.loadButton() def doLoadEntries(self): self.skips = [] ents = self.sql.getRec("scpent", cols=["sce_scod", "sce_pcod"], where=[("sce_cono", "=", self.opts["conum"]), ("sce_ccod", "=", self.ccod)]) self.df.clearFrame("C", 0) self.df.focusField("C", 0, 1) for num, ent in enumerate(ents): self.skips.append(ent[0]) self.df.loadEntry("C", 0, self.df.pos, data=ent[0]) self.df.loadEntry("C", 0, self.df.pos + 1, data=self.getName(ent[0])) if ent[1]: self.parts.append(ent[1]) self.df.loadEntry("C", 0, self.df.pos + 2, data=ent[1]) self.df.loadEntry("C", 0, self.df.pos + 3, data=self.getName(ent[1])) self.df.advanceLine(0) def loadButton(self): rec = self.sql.getRec("scpent", cols=["count(*)"], where=[("sce_cono", "=", self.opts["conum"]), ("sce_ccod", "=", self.ccod)], limit=1) self.df.B0.setLabel("Entered Players (%s)" % int(rec[0]), udl=0) def doPrint(self): self.df.setWidget(self.df.mstFrame, state="hide") hdr = ["Skips Entered for the %s" % self.cmpnam] tab = ["scpent", "scpmem"] col = [ "scm_scod", "scm_surname", "scm_names", "scm_phone", ["scm_email", "TX", 30, "Email-Address"] ] whr = [("sce_ccod", "=", self.ccod), ("scm_scod=sce_scod", )] odr = "scm_surname" RepPrt(self.opts["mf"], name=self.__class__.__name__, heads=hdr, tables=tab, cols=col, where=whr, order=odr, prtdia=(("Y", "V"), ("Y", "N"))) self.df.setWidget(self.df.mstFrame, state="show") def doExit(self): if self.df.frt == "C": chk = self.sql.getRec("scpent", where=[("sce_cono", "=", self.opts["conum"]), ("sce_ccod", "=", self.ccod)]) if chk: self.opts["mf"].dbm.commitDbase() else: self.opts["mf"].dbm.rollbackDbase() self.df.closeProcess() self.opts["mf"].closeLoop()
class st1010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "ctlvmf", "ctlrep", "drschn", "drsmst", "genmst", "slsiv1", "slsiv2", "strgrp", "strloc", "strmf1", "strmf2", "strgmu", "strcmu", "strprc", "strrcp", "struoi", "strtrn", "strpot", "strvar", "slsiv3", "chglog" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] self.automu = strctl["cts_automu"] self.drsctl = gc.getCtl("drsctl", self.opts["conum"], error=False) if not self.drsctl: self.chains = "N" else: self.chains = self.drsctl["ctd_chain"] return True def mainProcess(self): gpm = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } stm = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "X")], "whera": [], "index": 1 } loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } unm = { "stype": "R", "tables": ("struoi", ), "cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0, "Description", "Y")), "where": [("unm_cono", "=", self.opts["conum"])] } drc = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } drm = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1")) } if self.chains == "Y": drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_stat", "<>", "X")] drm["whera"] = [["T", "drm_chain", 10]] else: drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", 0), ("drm_stat", "<>", "X")] vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } tag = (("Basic-_A", None, ("T", 0, 0), ("T", 0, 1)), ("Basic-_B", None, ("T", 0, 0), ("T", 0, 1)), ("Recipes", self.doReadLoadRecipe, None, ("T", 0, 1))) r1s = (("Normal", "N"), ("Recipe", "R")) r2s = (("Average", "A"), ("Standard", "S"), ("None", "N")) r3s = (("Manual", "M"), ("Automatic", "A"), ("Zero", "N")) self.fld = [(("T", 0, 0, 0), "IUA", 3, "Group", "Product Group", "", "Y", self.doGroup, gpm, None, ("notblank", )), (("T", 0, 0, 0), "INA", 20, "Code", "Product Code", "", "N", self.doCode, stm, None, ("notblank", )), (("T", 0, 0, 0), "IUA", 1, "Loc", "Location", "1", "N", self.doLoc, loc, None, ("notblank", )), (("T", 0, 0, 0), "ONA", 30, ""), (("T", 1, 0, 0), ("IRB", r1s), 0, "Type of Item", "", "N", "N", self.doType, None, None, None), (("T", 1, 1, 0), "INA", 30, "Description", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 1, 2, 0), "INA", 10, "Unit of Issue", "", "", "N", self.doUoi, unm, None, ("notblank", )), (("T", 1, 2, 0), "ONA", 30, ""), (("T", 1, 3, 0), ("IRB", r2s), 0, "Cost Price Indicator", "", "A", "N", self.doValInd, None, None, None), (("T", 1, 4, 0), "IUA", 1, "VAT Code", "", "", "N", self.doVat, vtm, None, ("notblank", )), (("T", 1, 4, 0), "ONA", 30, ""), (("T", 1, 5, 0), "IUI", 3, "Exclusive Chainstore", "", "", "N", self.doChnExcl, drc, None, ("efld", )), (("T", 1, 5, 0), "ONA", 30, ""), (("T", 1, 6, 0), "INA", 7, "Exclusive Account", "", "", "N", self.doAccExcl, drm, None, ("efld", )), (("T", 1, 6, 0), "ONA", 30, ""), (("T", 1, 7, 0), "IUI", 7, "Sales Code", "", "", "N", self.doSales, glm, None, ("efld", )), (("T", 1, 7, 0), "ONA", 30, ""), (("T", 1, 8, 0), "IUI", 7, "COS Code", "", "", "N", self.doCos, glm, None, ("efld", )), (("T", 1, 8, 0), "ONA", 30, ""), (("T", 2, 0, 0), "IUA", 8, "Bin Number", "", "", "N", None, None, self.doDelete, ("efld", )), (("T", 2, 1, 0), ("IRB", r3s), 0, "Re-Order Indicator", "", "A", "N", self.doReord, None, None, None), (("T", 2, 2, 0), "IUI", 7, "Re-Order Level", "", "", "N", None, None, None, ("efld", )), (("T", 2, 3, 0), "IUI", 7, "Re-Order Quantity", "", "", "N", None, None, None, ("efld", ))] if self.automu in ("A", "L"): self.fld.append( (("T", 2, 4, 0), "IUD", 6.2, "Percentabge Markup Lv1", "", "", "N", None, None, None, ("efld", ))) for x in range(1, self.plevs): self.fld.append((("T", 2, 4, 0), "IUD", 6.2, "Lv%s" % (x + 1), "", "", "N", None, None, None, ("efld", ))) self.fld.extend([(("C", 3, 0, 0), "INA", 3, "Grp", "Product Group", "r", "N", self.doRecGrp, gpm, None, None), (("C", 3, 0, 1), "INA", 20, "Product-Code", "Product Code", "", "N", self.doRecCod, stm, None, None), (("C", 3, 0, 2), "ONA", 30, "Description"), (("C", 3, 0, 3), "IUD", 11.2, "Quantity", "", "", "N", self.doRecQty, None, self.doDelRec, ("notzero", ))]) but = (("Edit", None, self.doEditor, 0, ("C", 3, 1), None), ("Accept", None, self.doAccept, 0, ("T", 0, 0), ("T", 0, 1)), ("Cancel", None, self.doCancel, 0, ("T", 0, 0), ("T", 0, 1)), ("Quit", None, self.doQuit, 1, None, None)) tnd = ((self.doEnd, "N"), (self.doEnd, "N"), (self.doEnd, "Y"), None) txt = (self.doExit, self.doExit, self.doExit, self.doExit) cnd = (None, None, None, (self.doEnd, "N")) cxt = (None, None, None, self.doExit) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, tags=tag, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, clicks=self.doClick) def doClick(self, *opts): if self.df.pag == 0 or not self.gtype: return if opts[0] == (1, 0) and not self.newcode: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doGroup(self, frt, pag, r, c, p, i, w): self.grpacc = self.sql.getRec( "strgrp", cols=["gpm_vatcode", "gpm_sales", "gpm_costs"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not self.grpacc: return "Invalid Group" self.group = w self.df.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]] def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.mups = [0, 0, 0, 0, 0] self.old1 = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", w)], limit=1) if not self.old1: self.newcode = True self.gtype = None elif self.old1[3] == "X": return "Redundant Code" else: self.newcode = False d = 3 for x in range(0, self.df.topq[1]): if x in (3, 6, 8, 10, 12, 14): continue if x == 0: self.gtype = self.old1[d] self.df.loadEntry("T", 1, x, data=self.old1[d]) if x == 2: get = self.getUoi(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 5: get = self.getVat(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 7: get = self.getChnExcl(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 9: get = self.getAccExcl(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if self.glint == "Y" and x in (11, 13): get = self.getGenDes(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) d += 1 if self.locs == "N": self.loc = "1" self.df.loadEntry("T", 0, 2, data=self.loc) err = self.checkLoc() if err: return err return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): if w == 0: return "Invalid Location" self.loc = w err = self.checkLoc() if err: return err def checkLoc(self): acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Location Code" else: self.df.loadEntry("T", 0, 3, data=acc[0]) self.old2 = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)], limit=1) if not self.old2: ok = askQuestion(self.opts["mf"].body, "New Location", "This location does not exist for this product. " \ "Are you sure that you want to create it?") if ok == "yes": self.newloc = "Y" else: return "Rejected Location" if not self.old2: self.newloc = "Y" else: self.newloc = "N" d = 3 for x in range(0, 4): d = d + 1 self.df.loadEntry("T", 2, x, data=self.old2[d]) if self.automu in ("A", "L"): for y in range(self.plevs): mup = getMarkup(self.sql, self.opts["conum"], self.group, self.code, self.loc, y + 1) self.df.loadEntry("T", 2, 4 + y, data=mup) self.mups[y] = mup def doType(self, frt, pag, r, c, p, i, w): self.gtype = w if self.gtype == "R": self.df.enableTag(2) else: self.df.disableTag(2) def doUoi(self, frt, pag, r, c, p, i, w): acc = self.getUoi(w) if not acc: return "Invalid UOI Record" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doValInd(self, frt, pag, r, c, p, i, w): self.df.topf[1][5][5] = self.grpacc[0] def doVat(self, frt, pag, r, c, p, i, w): acc = self.getVat(w) if not acc: return "Invalid VAT Record" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if not self.drsctl: self.chain = 0 self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 1, data="") if self.glint == "N": return "sk9" else: return "sk4" def doChnExcl(self, frt, pag, r, c, p, i, w): if w: acc = self.getChnExcl(w) if not acc: return "Invalid Chainstore" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) self.chain = w def doAccExcl(self, frt, pag, r, c, p, i, w): if w: acc = self.getAccExcl(w) if not acc: return "Invalid Debtors Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if self.glint == "N": return "sk5" if self.newcode: self.df.loadEntry(frt, pag, p + 2, data=self.grpacc[1]) if self.grpacc[1]: acc = self.getGenDes(self.grpacc[1]) if not acc: return "Invalid Sales Code" self.df.loadEntry(frt, pag, p + 3, data=acc[0]) self.df.loadEntry(frt, pag, p + 4, data=self.grpacc[2]) if self.grpacc[2]: acc = self.getGenDes(self.grpacc[2]) if not acc: return "Invalid C.O.S. Code" self.df.loadEntry(frt, pag, p + 5, data=acc[0]) def doSales(self, frt, pag, r, c, p, i, w): acc = self.getGenDes(w) if not acc: return "Invalid Sales Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doCos(self, frt, pag, r, c, p, i, w): acc = self.getGenDes(w) if not acc: return "Invalid COS Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doReord(self, frt, pag, r, c, p, i, w): if w == "N": self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 2, data=0) return "sk2" def getUoi(self, dat): acc = self.sql.getRec("struoi", cols=["unm_desc"], where=[("unm_cono", "=", self.opts["conum"]), ("unm_unit", "=", dat)], limit=1) return acc def getVat(self, dat): acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", dat)], limit=1) return acc def getChnExcl(self, dat): self.chain = dat if dat: acc = self.sql.getRec("drschn", cols=["chm_name"], where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", dat)], limit=1) return acc def getAccExcl(self, dat): if dat: acc = self.sql.getRec("drsmst", cols=["drm_name"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", dat), ("drm_stat", "<>", "X")], limit=1) return acc def getGenDes(self, dat): if dat: acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", dat)], limit=1) return acc def doRecGrp(self, frt, pag, r, c, p, i, w): self.rgroup = w acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.df.topf[0][1][8]["whera"] = [["C", "st1_group", 0, 3]] def doRecCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.rgroup), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] == "R": return "Invalid Type (Recipe)" self.df.loadEntry(frt, pag, p + 1, data=acc[1]) acc = self.sql.getRec("strmf2", cols=["st2_bin"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.rgroup), ("st2_code", "=", w), ("st2_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Code (2)" self.rcode = w acc = self.sql.getRec("strrcp", cols=["srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)], limit=1) if acc: self.newrec = "n" self.df.loadEntry(frt, pag, p + 2, data=acc[0]) else: self.newrec = "y" def doRecQty(self, frt, pag, r, c, p, i, w): self.rqty = w def doEditor(self): if self.df.pag != 3: self.df.focusField(self.df.frt, self.df.pag, self.df.col) return # Display recipe items and allow editing of details data = self.sql.getRec( tables=["strrcp", "strmf1"], cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ), ("st1_code=srr_rcode", )]) if data: titl = "Recipe Items" head = ("Grp", "Product-Code", "Description", "Quantity") lin = { "stype": "C", "titl": titl, "head": head, "typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 10.2)), "data": data } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Product to Edit") chg = self.df.selChoice(lin) if chg and chg.selection: self.change = chg.selection self.doChgChanges() self.df.enableButtonsTags(state=state) self.df.focusField("C", 3, self.df.col) def doChgChanges(self): tit = ("Change Items", ) gpm = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } stm = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"])], "whera": [], "index": 1 } fld = ((("T", 0, 0, 0), "INA", 3, "Group", "Product Group", "", "N", self.doChgGrp, gpm, None, ('notblank', )), (("T", 0, 1, 0), "INA", 20, "Code", "Product Code", "", "N", self.doChgCod, stm, None, ('notblank', )), (("T", 0, 2, 0), "ONA", 30, "Description"), (("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N", self.doChgQty, None, None, ('notzero', ))) but = [["Delete", None, self.doChgDel, 1, None, None]] self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doChgEnd, "n"), ), txit=(self.doChgExit, )) self.cg.loadEntry("T", 0, 0, data=self.change[0]) self.cg.loadEntry("T", 0, 1, data=self.change[1]) self.cg.loadEntry("T", 0, 2, data=self.change[2]) self.cg.loadEntry("T", 0, 3, data=self.change[3]) self.cg.focusField("T", 0, 1, clr=False) self.cg.mstFrame.wait_window() def doChgGrp(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.rgroup = w self.cg.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]] def doChgCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.rgroup), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] != "N": return "Invalid Type" cnt = self.sql.getRec("strrcp", cols=["count(*)"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.rgroup), ("srr_code", "=", w)], limit=1) if cnt[0]: return "Product Already In Recipe" self.rcode = w self.cg.loadEntry("T", 0, 2, data=acc[1]) def doChgQty(self, frt, pag, r, c, p, i, w): self.rqty = w def doChgDel(self): self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.change[0]), ("srr_rcode", "=", self.change[1])]) self.doReadLoadRecipe() self.doChgExit() def doChgEnd(self): self.sql.updRec("strrcp", cols=["srr_rgroup", "srr_rcode", "srr_rqty"], data=[self.rgroup, self.rcode, self.rqty], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.loc), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.change[0]), ("srr_rcode", "=", self.change[1])]) self.doReadLoadRecipe() self.doChgExit() def doChgExit(self): self.cg.closeProcess() def doDelete(self): trn = self.sql.getRec("strpot", cols=["count(*)"], where=[("pot_cono", "=", self.opts["conum"]), ("pot_group", "=", self.group), ("pot_code", "=", self.code)], limit=1) if trn[0]: return "Purchase Orders Exist, Not Deleted" trn = self.sql.getRec("strtrn", cols=["count(*)"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_group", "=", self.group), ("stt_code", "=", self.code), ("stt_loc", "=", self.loc)], limit=1) if trn[0]: return "Stores Transactions Exist, Not Deleted" trn = self.sql.getRec("slsiv2", cols=["count(*)"], where=[("si2_cono", "=", self.opts["conum"]), ("si2_group", "=", self.group), ("si2_code", "=", self.code), ("si2_loc", "=", self.loc)], limit=1) if trn[0]: return "Sales-2 Transactions Exist, Not Deleted" trn = self.sql.getRec("slsiv3", cols=["count(*)"], where=[("si3_cono", "=", self.opts["conum"]), ("si3_rgroup", "=", self.group), ("si3_rcode", "=", self.code)], limit=1) if trn[0]: return "Sales-3 Transactions Exist, Not Deleted" self.sql.delRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["strmf2", "D", "%03i%-3s%-20s%-1s" % \ (self.opts["conum"], self.group, self.code, self.loc), "", dte, self.opts["capnm"], "", "", "", 0]) st2 = self.sql.getRec("strmf2", cols=["count(*)"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code)], limit=1) if not st2[0]: self.sql.delRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", self.code)]) self.sql.insRec("chglog", data=["strmf1", "D", "%03i%-3s%-20s" % \ (self.opts["conum"], self.group, self.code), "", dte, self.opts["capnm"], "", "", "", 0]) # Other Files self.sql.delRec("strcst", where=[("stc_cono", "=", self.opts["conum"]), ("stc_group", "=", self.group), ("stc_code", "=", self.code), ("stc_loc", "=", self.loc)]) self.sql.delRec("strprc", where=[("stp_cono", "=", self.opts["conum"]), ("stp_group", "=", self.group), ("stp_code", "=", self.code), ("stp_loc", "=", self.loc)]) self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc)]) self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.group), ("srr_rcode", "=", self.code)]) self.sql.delRec("strvar", where=[("stv_cono", "=", self.opts["conum"]), ("stv_group", "=", self.group), ("stv_code", "=", self.code), ("stv_loc", "=", self.loc)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doDelRec(self): self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)]) self.df.clearLine(2, focus=True) def doEnd(self): if self.df.frt == "T" and self.df.pag == 0: if self.newcode: self.df.focusField("T", 1, 1) else: if self.gtype == "R": self.df.enableTag(2) self.df.skip[1] = [1] self.df.focusField("T", 1, 2, clr=False) elif self.df.frt == "T" and self.df.pag == 1: self.df.selPage("Basic-B") elif self.df.frt == "T" and self.df.pag == 2: if self.gtype == "R": self.df.selPage("Recipes") else: self.doEnder() elif self.df.frt == "C" and self.df.pag == 3: data = [ self.opts["conum"], self.group, self.code, self.loc, self.rgroup, self.rcode, self.rqty ] if self.newrec == "y": self.sql.insRec("strrcp", data=data) self.df.advanceLine(3) else: whr = [("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)] self.sql.updRec("strrcp", data=data, where=whr) self.doReadLoadRecipe() def doEnder(self): data = [self.opts["conum"]] for x in range(0, 2): data.append(self.df.t_work[0][0][x]) for x in range(0, len(self.df.t_work[1][0])): if x in (3, 6, 8, 10, 12, 14): continue data.append(self.df.t_work[1][0][x]) if self.newcode: self.sql.insRec("strmf1", data=data) elif data != self.old1[:len(data)]: col = self.sql.strmf1_col data.append(self.old1[col.index("st1_xflag")]) self.sql.updRec("strmf1", data=data, where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", self.code)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old1): if dat != data[num]: self.sql.insRec( "chglog", data=[ "strmf1", "U", "%03i%-3s%-20s" % (self.opts["conum"], self.group, self.code), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) data = [self.opts["conum"], self.group, self.code, self.loc] for x in range(0, 4): data.append(self.df.t_work[2][0][x]) if self.newloc == "Y": self.sql.insRec("strmf2", data=data) elif data != self.old2[:len(data)]: col = self.sql.strmf2_col data.append(self.old2[col.index("st2_xflag")]) self.sql.updRec("strmf2", data=data, where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old2): if dat != data[num]: self.sql.insRec("chglog", data=[ "strmf2", "U", "%03i%-3s%-20s%-1s" % (self.opts["conum"], self.group, self.code, self.loc), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.sql.delRec("strcmu", where=[("smc_cono", "=", self.opts["conum"]), ("smc_group", "=", self.group), ("smc_code", "=", self.code), ("smc_loc", "=", self.loc)]) for num, mup in enumerate(self.df.t_work[2][0][4:]): if mup and mup != self.mups[num]: self.sql.insRec("strcmu", data=[ self.opts["conum"], self.group, self.code, self.loc, num + 1, mup ]) self.opts["mf"].dbm.commitDbase() self.df.selPage("Basic-A") self.df.focusField("T", 0, 1) def doReadLoadRecipe(self): self.df.clearFrame("C", 3) self.df.focusField("C", 3, 1) rec = self.sql.getRec( tables=["strrcp", "strmf1"], cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ), ("st1_code=srr_rcode", )]) if rec: mxs = (self.df.rows[3] - 1) * self.df.colq[3] for l, r in enumerate(rec): for i, d in enumerate(r): c = l * self.df.colq[3] if c > mxs: c = mxs self.df.loadEntry("C", 3, (c + i), data=d) self.df.advanceLine(3) def doExit(self): if self.df.frt == "T" and self.df.pag == 0: self.doQuit() elif self.df.frt == "T" and self.df.pag == 1: if self.newcode: self.df.focusField("T", 1, 1) else: self.df.skip[1] = [1] self.df.focusField("T", 1, 2, clr=False) elif self.df.frt == "T" and self.df.pag == 2: self.df.focusField("T", 2, 1) elif self.df.frt == "C" and self.df.pag == 3: if self.df.col == 1: self.df.focusField("C", 3, 1) else: self.doEnder() def doAccept(self): ok = "yes" for page in (1, 2): frt, pag, col, err = self.df.doCheckFields(("T", page, None)) if err: ok = "no" if pag and pag != self.df.pag: self.df.selPage(self.df.tags[pag - 1][0]) self.df.focusField(frt, pag, (col + 1), err=err) break if ok == "yes": self.doEnder() def doQuit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop() def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.selPage("Basic-A") self.df.focusField("T", 0, 1)
class bc2040(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", "bwltab", "bwlent", "bwltyp", "bwlgme"], 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.nstart = bwlctl["ctb_nstart"] self.dbase = bwlctl["ctb_dbase"] return True def mainProcess(self): com = { "stype": "R", "tables": ("bwlcmp",), "cols": ( ("bcm_code", "", 0, "Cod"), ("bcm_name", "", 0, "Name", "Y"), ("bcm_date", "", 0, "Date")), "where": [("bcm_cono", "=", self.opts["conum"])]} typ = { "stype": "R", "tables": ("bwltyp",), "cols": ( ("bct_code", "", 0, "Cod"), ("bct_desc", "", 0, "Description", "Y")), "where": [("bct_cono", "=", self.opts["conum"])]} sk1 = { "stype": "R", "tables": ("bwltab",), "cols": ( ("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "", 0, "Names")), "where": [("btb_cono", "=", self.opts["conum"])], "order": "btb_surname"} sk2 = { "stype": "R", "tables": ("bwlent", "bwltab"), "cols": ( ("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "", 0, "Names"), ("bce_tcod", "", 0, "T"), ("bce_paid", "", 0, "P")), "where": [ ("btb_cono", "=", self.opts["conum"]), ("btb_tab=bce_scod",)], "whera": [("T", "bce_ccod", 0, 0)], "order": "btb_surname"} fld = ( (("T",0,0,0),"I@bcm_code",0,"Code","Competition Code", "","Y",self.doCmpCod,com,None,("efld",)), (("T",0,0,0),"I@bcm_name",0,"Name","", "","N",self.doCmpNam,None,self.doDelCmp,("notblank",)), (("T",0,0,0),"I@bcm_date",0,"Date","", "","N",None,None,None,("efld",)), (("T",0,0,0),"I@bcm_type",0,"Type","", "","N",self.doCmpTyp,typ,None,("efld",)), (("C",0,0,0),"I@btb_tab",0,"P-Code","Player's Code", "","Y",self.doSkpCod,sk1,None,("efld",)), (("C",0,0,1),"ONA",30,"Name","", "","N",None,None,None,("notblank",)), (("C",0,0,2),"I@bce_tcod",0,"T","Team Code (H or V)", "H","n",self.doTeam,None,None,("in", ("H","V"))), (("C",0,0,4),"I@bce_paid",0,"","Paid Flag (Y or N)", "N","N",self.doPaid,None,self.doDelSkp,("in", ("Y","N")))) but = (("Entered Players",sk2,None,0,("C",0,1),("T",0,1)),) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) cnd = ((self.doEnd,"n"),) cxt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doCmpCod(self, frt, pag, r, c, p, i, w): self.erase = False self.skips = [] if not w: self.ccod = getNextCode(self.sql, "bwlcmp", "bcm_code", where=[("bcm_cono", "=", self.opts["conum"])], last=999) self.df.loadEntry(frt, pag, p, data=self.ccod) else: self.ccod = w self.cmp = self.sql.getRec("bwlcmp", where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", self.ccod)], limit=1) if not self.cmp: ok = askQuestion(self.opts["mf"].body, head="New Competition", mess="Is This a New Competition?", default="no") if ok == "no": return "rf" self.newcmp = True else: if self.cmp[self.sql.bwlcmp_col.index("bcm_poff")]: showError(self.opts["mf"].body, "Complete", "This Sectional Competition Has Been Completed.") return "rf" gme = self.sql.getRec("bwlgme", cols=["count(*)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_ocod", "<>", 0)], limit=1) if gme[0]: ok = askQuestion(self.opts["mf"].body, "Error", """This Competition Has Already Been Drawn. Do You Want to Erase All Draws and Results?""", default="no") if ok == "no": return "rf" self.erase = True self.newcmp = False for num, fld in enumerate(self.cmp[1:-2]): self.df.loadEntry(frt, pag, p+num, data=fld) ent = self.sql.getRec("bwlent", cols=["bce_scod"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)]) for e in ent: self.skips.append(e[0]) def doDelCmp(self): if self.newcmp: showError(self.opts["mf"].body, "Delete", "New Competition") return if self.skips: ok = askQuestion(self.opts["mf"].body, "Delete", "Entries Exist "\ "for this Competition, Are You Sure it must be Deleted?", default="no") if ok == "no": return self.sql.delRec("bwlcmp", where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", self.ccod)]) if self.skips: self.sql.delRec("bwlent", where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)]) self.sql.delRec("bwlgme", where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doCmpNam(self, frt, pag, r, c, p, i, w): self.cmpnam = w def doCmpTyp(self, frt, pag, r, c, p, i, w): if not w: ok = askQuestion(self.opts["mf"].body, head="New Type", mess="Is This a New Competition Type?") if ok == "yes": w = getNextCode(self.sql, "bwltyp", "bct_code", where=[("bct_cono", "=", self.opts["conum"])], last=99) w = callModule(self.opts["mf"], self.df, "bc1040", coy=(self.opts["conum"], self.opts["conam"]), args=w, ret="ctype") self.df.loadEntry(frt, pag, p, data=w) self.typ = self.sql.getRec("bwltyp", where=[("bct_cono", "=", self.opts["conum"]), ("bct_code", "=", w)], limit=1) if not self.typ: return "Invalid Competition Type" self.cfmat = self.typ[self.sql.bwltyp_col.index("bct_cfmat")] self.tsize = self.typ[self.sql.bwltyp_col.index("bct_tsize")] def doSkpCod(self, frt, pag, r, c, p, i, w): if not w: ok = askQuestion(self.opts["mf"].body, head="New Non-Member", mess="Is This a New Non-Member Player?", default="yes") if ok == "no": return "Invalid Skip Code" cod = self.doNewCode() if not cod: return "Invalid Skip Code" self.df.loadEntry(frt, pag, p, data=cod) else: cod = w if cod not in self.skips: self.skips.append(cod) self.scod = cod chk = self.sql.getRec("bwltab", cols=["btb_surname", "btb_names"], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", self.scod)], limit=1) if not chk: return "Invalid Player Code" self.df.loadEntry(frt, pag, p+1, data=self.getName(chk)) ent = self.sql.getRec("bwlent", cols=["bce_tcod", "bce_paid"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod), ("bce_scod", "=", self.scod)], limit=1) if ent: self.newent = False self.df.loadEntry(frt, pag, p+2, data=ent[0]) self.df.loadEntry(frt, pag, p+3, data=ent[1]) else: self.newent = True if self.cfmat == "X": if self.scod < self.nstart: self.tcod = "H" else: self.tcod = "V" self.df.loadEntry(frt, pag, p+2, data=self.tcod) else: self.tcod = "" return "sk2" def doTeam(self, frt, pag, r, c, p, i, w): self.tcod = w def doNewCode(self): r1s = (("Male","M"), ("Female","F")) r2s = (("Skip",4), ("Third",3), ("Second",2), ("Lead",1)) fld = ( (("T",0,0,0),("IRB",r1s),0,"Gender","", "M","Y",None,None,None,None), (("T",0,1,0),"I@btb_surname",0,"","", "","Y",None,None,None,("notblank",)), (("T",0,2,0),"I@btb_names",0,"","", "","Y",None,None,None,("notblank",)), (("T",0,3,0),"I@btb_home",0,"","", "","Y",None,None,None,("efld",)), (("T",0,4,0),"I@btb_work",0,"","", "","Y",None,None,None,("efld",)), (("T",0,5,0),"I@btb_cell",0,"","", "","Y",None,None,None,("efld",)), (("T",0,6,0),"I@btb_mail",0,"","", "","Y",self.doNMail,None,None,("efld",)), (("T",0,7,0),("IRB",r2s),0,"Position","", 4,"Y",self.doNPos,None,None,None), (("T",0,8,0),"I@btb_rate1",0,"Rating","", "","Y",None,None,None,("efld",))) state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") self.new = TartanDialog(self.opts["mf"], eflds=fld, tend=((self.doNEnd,"y"),), txit=(self.doNExit,)) self.new.mstFrame.wait_window() self.df.setWidget(self.df.mstFrame, state="show") self.df.enableButtonsTags(state) return self.newcod def doNMail(self, frt, pag, r, c, p, i, w): if self.cfmat in ("T", "K", "R", "X"): if self.dbase in ("C", "P"): self.new.loadEntry(frt, pag, p+1, data=4) else: self.new.loadEntry(frt, pag, p+1, data=0) if self.dbase in ("C", "R"): self.new.loadEntry(frt, pag, p+2, data=5) else: self.new.loadEntry(frt, pag, p+2, data=0) return "sk2" if self.dbase == "R": self.new.loadEntry(frt, pag, p+1, data=0) return "sk1" def doNPos(self, frt, pag, r, c, p, i, w): if self.dbase == "P": self.new.loadEntry(frt, pag, p+1, data=0) return "sk1" def doNEnd(self): self.new.closeProcess() self.newcod = getNextCode(self.sql, "bwltab", "btb_tab", where=[("btb_cono", "=", self.opts["conum"])], start=self.nstart, last=900000) data = [self.opts["conum"], self.newcod, 0] data.extend(self.new.t_work[0][0][1:3]) data.extend([self.new.t_work[0][0][0], "", "", "", ""]) data.extend(self.new.t_work[0][0][3:]) data.extend(self.new.t_work[0][0][7:]) data.append(0) self.sql.insRec("bwltab", data=data) def doNExit(self): self.new.closeProcess() self.newcod = None def getName(self, chk): name = chk[0] if chk[1]: name += "," for i in chk[1].split(): name = "%s %s" % (name, i) return name.upper() def doPaid(self, frt, pag, r, c, p, i, w): self.paid = w def doDelSkp(self): self.sql.delRec("bwlent", where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod), ("bce_scod", "=", self.scod)]) self.sql.delRec("bwlgme", where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", self.scod)]) self.loadButton() def doEnd(self): if self.df.frt == "T": data = [self.opts["conum"]] + self.df.t_work[0][0] + [0] if self.newcmp: self.sql.insRec("bwlcmp", data=data) else: if self.erase: self.sql.delRec("bwlgme", where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod)]) if self.cfmat in ("D", "K"): self.sql.delRec("bwltms", where=[("btd_cono", "=", self.opts["conum"]), ("btd_ccod", "=", self.ccod)]) self.sql.delRec("bwlrnd", where=[("bcr_cono", "=", self.opts["conum"]), ("bcr_ccod", "=", self.ccod)]) if self.cfmat in ("T", "X"): recs = self.sql.getRec("bwlent", cols=["bce_scod"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)], order="bce_scod") skips = [] for rec in recs: skips.append(rec[0]) self.doPopulate(skips) data.append(self.cmp[self.sql.bwlcmp_col.index("bcm_xflag")]) self.sql.updRec("bwlcmp", data=data, where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", self.ccod)]) self.loadButton() self.df.focusField("C", 0, 1) else: if self.newent: self.sql.insRec("bwlent", data=[self.opts["conum"], self.ccod, self.scod, self.tcod, self.paid]) if self.cfmat in ("T", "X"): self.doPopulate([self.scod]) else: self.sql.updRec("bwlent", cols=["bce_tcod", "bce_paid"], data=[self.tcod, self.paid], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod), ("bce_scod", "=", self.scod)]) self.loadButton() self.df.advanceLine(0) def doPopulate(self, scods): # Populate bwlgme records num = self.typ[self.sql.bwltyp_col.index("bct_games")] dgm = self.typ[self.sql.bwltyp_col.index("bct_drawn")] for scod in scods: data = [self.opts["conum"], self.ccod, scod, 0, "", 0, 0, "", 0, 0, 0, 0, 0, 0, 0, "", 0, 0] for x in range(0, dgm): data[3] = x + 1 data[4] = "D" self.sql.insRec("bwlgme", data=data) for x in range(dgm, num): data[3] = x + 1 data[4] = "S" self.sql.insRec("bwlgme", data=data) def loadButton(self): rec = self.sql.getRec("bwlent", cols=["count(*)"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)], limit=1) self.df.B0.setLabel("Entered Players (%s)" % int(rec[0]), udl=0) def doExit(self): if self.df.frt == "C": self.opts["mf"].dbm.commitDbase() self.df.closeProcess() self.opts["mf"].closeLoop()
class ln2030(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "genmst", "gentrn", "lonctl", "lonmf1", "lonmf2", "lonrte", "lontrn" ], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) lonctl = self.gc.getCtl("lonctl", self.opts["conum"]) if not lonctl: return self.glint = lonctl["cln_glint"] self.drate = lonctl["cln_drte"] self.crate = lonctl["cln_crte"] self.lastd = lonctl["cln_last"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"], ctlctl, ["lon_ctl"]): return self.glctl = (ctlctl["lon_ctl"], ctlctl["int_rec"], ctlctl["int_pay"]) else: self.glctl = None t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def dataHeader(self): lm1 = { "stype": "R", "tables": ("lonmf1", ), "cols": (("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")), "where": [("lm1_cono", "=", self.opts["conum"])] } lm2 = { "stype": "R", "tables": ("lonmf2", ), "cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0, "Description", "Y")), "where": [("lm2_cono", "=", self.opts["conum"])], "whera": [("C", "lm2_acno", 0, 0)] } dte = { "stype": "R", "tables": ("lonrte", ), "cols": (("lrt_start", "", 0, "Start-Date"), ("lrt_drte", "", 0, "DRte-%"), ("lrt_crte", "", 0, "CRte-%")), "where": [("lrt_cono", "=", self.opts["conum"])], "whera": [("C", "lrt_acno", 0, 0), ("C", "lrt_loan", 2, 0)], "order": "lrt_start" } r1s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "All Current Rates", "", "N", "N", self.doAll, None, None, None), (("T", 0, 1, 0), "ID1", 10, "Effective Date", "", "", "N", self.doSdate, None, None, ("efld", )), (("T", 0, 2, 0), "IUD", 6.2, "Debit Rate - Old", "", self.drate, "N", self.doDRte, None, None, None), (("T", 0, 2, 0), "IUD", 6.2, "New", "New Debit Rate", "", "N", self.doDRte, None, None, None), (("T", 0, 3, 0), "IUD", 6.2, "Credit Rate - Old", "", self.crate, "N", self.doCRte, None, None, None), (("T", 0, 3, 0), "IUD", 6.2, "New", "New Credit Rate", "", "N", self.doCRte, None, None, None), (("C", 0, 0, 0), "IUA", 7, "Acc-Num", "Account Number", "", "N", self.doAcc, lm1, None, None), (("C", 0, 0, 1), "ONA", 30, "Name"), (("C", 0, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N", self.doLon, lm2, None, None), (("C", 0, 0, 3), "ONA", 30, "Description"), (("C", 0, 0, 4), "ID1", 10, "Date", "", "", "N", self.doSdate, dte, None, ("efld", )), (("C", 0, 0, 5), "IUD", 6.2, "DRte-%", "Debit Rate", "", "N", self.doDRte, None, None, None), (("C", 0, 0, 6), "IUD", 6.2, "CRte-%", "Credit Rate", "", "N", self.doCRte, None, None, None)) tnd = ((self.endPage, "y"), ) txt = (self.exitPage, ) cnd = ((self.endPage, "y"), ) cxt = (self.exitPage, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doAll(self, frt, pag, r, c, p, i, w): self.allrte = w if self.allrte == "N": return "nd" def doSdate(self, frt, pag, r, c, p, i, w): if w <= self.lastd: return "Invalid Date, Before Last Interest Raise Date" self.sdate = w self.curdt = int(w / 100) self.chgrte = False if self.allrte == "N": chk = self.sql.getRec("lonrte", where=[("lrt_cono", "=", self.opts["conum"]), ("lrt_acno", "=", self.acno), ("lrt_loan", "=", self.loan), ("lrt_start", "=", w)], limit=1) if chk: self.df.loadEntry(frt, pag, p + 1, data=chk[4]) self.df.loadEntry(frt, pag, p + 2, data=chk[5]) ok = askQuestion(self.opts["mf"].body, "Exists", """This Date "Already Exists. Debit Rate: %s Credit Rate: %s Changing It Could Cause Problems. Would You Like to Continue?""" % (chk[4], chk[5]), default="no") if ok == "no": return "rf" self.chgrte = True def doDRte(self, frt, pag, r, c, p, i, w): if self.df.frt == "T" and p == 2: self.oldd = w else: self.newd = w def doCRte(self, frt, pag, r, c, p, i, w): if self.df.frt == "T" and p == 4: self.oldc = w else: self.newc = w def doAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("lonmf1", cols=["lm1_name"], where=[("lm1_cono", "=", self.opts["conum"]), ("lm1_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" self.acno = w self.name = acc[0] self.df.loadEntry("C", pag, p + 1, data=self.name) def doLon(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("lonmf2", where=[("lm2_cono", "=", self.opts["conum"]), ("lm2_acno", "=", self.acno), ("lm2_loan", "=", w)], limit=1) if not acc: return "Invalid Loan Number" self.loan = w desc = acc[self.sql.lonmf2_col.index("lm2_desc")] self.start = acc[self.sql.lonmf2_col.index("lm2_start")] self.pmths = acc[self.sql.lonmf2_col.index("lm2_pmths")] if self.pmths: return "Fixed Loan, Rate Change Not Allowed" self.df.loadEntry("C", pag, p + 1, data=desc) def endPage(self): if self.df.frt == "T": if self.allrte == "N": self.df.focusField("C", 0, 1) else: self.updateTables() self.opts["mf"].dbm.commitDbase(True) self.exitPage() else: self.updateTables() self.df.advanceLine(0) def exitPage(self): if self.df.frt == "C": self.opts["mf"].dbm.commitDbase(True) self.df.closeProcess() self.opts["mf"].closeLoop() def updateTables(self): if self.allrte == "Y": if self.oldd == self.drate and self.oldc == self.crate: self.sql.updRec("lonctl", cols=["cln_drte", "cln_crte"], data=[self.newd, self.newc], where=[("cln_cono", "=", self.opts["conum"])]) whr = [("lm2_cono", "=", self.opts["conum"]), ("lrt_cono=lm2_cono", ), ("lrt_acno=lm2_acno", ), ("lrt_loan=lm2_loan", ), ("lrt_drte", "=", self.oldd), ("lrt_crte", "=", self.oldc)] recs = self.sql.getRec(tables=["lonmf2", "lonrte"], cols=["lm2_acno", "lm2_loan", "lm2_pmths"], where=whr, group="lm2_acno, lm2_loan, lm2_pmths", order="lm2_acno") else: recs = [[self.acno, self.loan, 0]] for rec in recs: if rec[2]: # Fixed Period Loan, No Rate Changes Allowed continue # Loans Rate Record if self.chgrte: self.sql.updRec("lonrte", cols=["lrt_drte", "lrt_crte"], data=[self.newd, self.newc], where=[("lrt_cono", "=", self.opts["conum"]), ("lrt_acno", "=", rec[0]), ("lrt_loan", "=", rec[1]), ("lrt_start", "=", self.sdate)]) else: self.sql.insRec("lonrte", data=[ self.opts["conum"], rec[0], rec[1], self.sdate, self.newd, self.newc ])
class wg2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["wagedc", "wagmst", "wagcap", "wagcod"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) wagctl = gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.m_hrs = wagctl["ctw_m_hrs"] self.w_hrs = wagctl["ctw_w_hrs"] self.d_hrs = wagctl["ctw_d_hrs"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.edit = None return True def dataHeader(self): wgm = { "stype": "R", "tables": ("wagmst", ), "cols": (("wgm_empno", "", 0, "Emp-Num"), ("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0, "First Names")), "where": [("wgm_cono", "=", self.opts["conum"]), ("wgm_term", "=", 0)] } wed = { "stype": "R", "tables": ("wagedc", ), "cols": (("ced_code", "", 0, "Code"), ("ced_desc", "", 0, "Description", "Y")), "where": [("ced_cono", "=", self.opts["conum"])], "whera": [["C", "ced_type", 4, 0]] } fld = ((("C", 0, 0, 0), "IUI", 5, "EmpNo", "Employee Number", "r", "N", self.doEmpno, wgm, None, ("efld", )), (("C", 0, 0, 1), "ONA", 40, "Name"), (("C", 0, 0, 2), "OUI", 3, "Dep"), (("C", 0, 0, 3), "IUI", 5, "JobNo", "Job Number", "r", "N", None, None, None, ("efld", )), (("C", 0, 0, 4), "IUA", 1, "T", "Earnings/Deduction/NoPay", "r", "N", self.doType, None, None, ("in", ("E", "D"))), (("C", 0, 0, 5), "IUI", 3, "Cde", "Code Number", "", "N", self.doCode, wed, None, ("efld", )), (("C", 0, 0, 6), "ONA", 20, "Description"), (("C", 0, 0, 7), "IUA", 1, "P", "Pay (Y or N)", "Y", "N", self.doPay, None, None, ("in", ("Y", "N"))), [ ("C", 0, 0, 8), "ISD", 13.2, "Amount", "", "", "N", self.doAmt, None, None, None ]) but = (("Edit", None, self.editData, 0, ("C", 0, 1), ("C", 0, 2)), ("Interrogate", None, self.queryWag, 0, ("C", 0, 1), ("C", 0, 2))) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, cend=((self.endData, "y"), ), cxit=(self.exitData, )) def doEmpno(self, frt, pag, r, c, p, i, w): rec = self.sql.getRec("wagmst", cols=[ "wgm_sname", "wgm_fname", "wgm_dept", "wgm_freq", "wgm_term" ], where=[("wgm_cono", "=", self.opts["conum"]), ("wgm_empno", "=", w)], limit=1) if not rec: return "Invalid Employee Number" elif rec[4]: return "Employment Terminated" self.empno = w name = "%s, %s" % (rec[0], rec[1].split()[0]) self.df.loadEntry(frt, pag, p + 1, data=name) self.df.loadEntry(frt, pag, p + 2, data=rec[2]) self.freq = rec[3] def doType(self, frt, pag, r, c, p, i, w): self.rtyp = w def doCode(self, frt, pag, r, c, p, i, w): self.code = w rec = self.readWagedc() if not rec: return "Invalid Code" chk = self.sql.getRec("wagcap", where=[("wcp_cono", "=", self.opts["conum"]), ("wcp_empno", "=", self.empno), ("wcp_type", "=", self.rtyp), ("wcp_code", "=", self.code)]) if chk: if self.rtyp == "E": txt = "Earnings" else: txt = "Deduction" ok = askQuestion(self.df.mstFrame, head="Duplicate", mess="An Entry for this %s Code Already Exists "\ "for this Employee.\n\nIs This Correct?" % txt) if ok == "no": return "rf" self.df.loadEntry(frt, pag, p + 1, rec[0]) if self.rtyp == "E" and self.code == 1: std = self.sql.getRec("wagcod", cols=["wcd_eamt"], where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type", "=", "E"), ("wcd_code", "=", self.code)], limit=1) if std and std[0]: hrs = std[0] elif self.freq == "M": hrs = self.m_hrs elif self.freq == "W": hrs = self.w_hrs elif self.freq == "D": hrs = self.d_hrs else: hrs = self.m_hrs self.df.colf[0][8][5] = hrs else: self.df.colf[0][8][5] = "" def doPay(self, frt, pag, r, c, p, i, w): pass def doAmt(self, frt, pag, r, c, p, i, w): self.xrow = r def readWagedc(self): rec = self.sql.getRec("wagedc", cols=["ced_desc"], where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", self.rtyp), ("ced_code", "=", self.code)], limit=1) if not rec: return None else: return rec def endData(self): r = self.xrow data = [ self.opts["conum"], self.empno, self.df.c_work[0][r][2], self.df.c_work[0][r][3], self.df.c_work[0][r][4], self.df.c_work[0][r][5], self.df.c_work[0][r][7], self.df.c_work[0][r][8], "N", self.opts["capnm"], self.sysdtw ] if self.edit: data.append(self.edit) self.sql.updRec("wagcap", data=data, where=[("wcp_seq", "=", self.edit)]) self.edit = None else: data.append(0) self.sql.insRec("wagcap", data=data) self.df.advanceLine(0) def exitData(self): self.opts["mf"].dbm.commitDbase() self.df.closeProcess() self.opts["mf"].closeLoop() def editData(self): # Display captured items and allow editing col = [ "wcp_empno", "wgm_sname", "wcp_dept", "wcp_job", "wcp_type", "wcp_code", "ced_desc", "wcp_ind", "wcp_amt", "wcp_seq" ] whr = [("wcp_cono", "=", self.opts["conum"]), ("wcp_paid", "=", "N"), ("wgm_cono=wcp_cono", ), ("wgm_empno=wcp_empno", ), ("ced_cono=wcp_cono", ), ("ced_type=wcp_type", ), ("ced_code=wcp_code", )] data = self.sql.getRec(tables=["wagcap", "wagmst", "wagedc"], cols=col, where=whr, order="wcp_empno") if not data: self.df.focusField(self.df.frt, self.df.pag, self.df.col) return titl = "Captured Items" head = ("EmpNo", "Surname", "Dep", "JobNo", "T", "Cod", "Description", "I", "Amount", "Sequence") lin = { "stype": "C", "titl": titl, "head": head, "typs": [("UI", 5), ("NA", 30), ("UI", 3), ("UI", 5), ("UA", 1), ("UI", 3), ("NA", 20), ("UA", 1), ("SD", 13.2), ("UI", 10)], "data": data, "butt": [("Delete", self.doDelete, True)] } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select an Item to Edit") chg = SChoice(self.opts["mf"], deco=True, titl=lin["titl"], head=lin["head"], data=lin["data"], typs=lin["typs"], mode="S", retn="D", butt=lin["butt"], scrn=self.df.mstFrame) self.df.enableButtonsTags(state=state) if chg and chg.selection: for num, fld in enumerate(chg.selection): if num in (0, 3, 4, 5): self.df.doKeyPressed("C", 0, self.df.pos, fld) elif num == (len(chg.selection) - 1): self.edit = int(fld) else: self.df.loadEntry(self.df.frt, self.df.pag, num, data=fld) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doDelete(self, args): self.sql.delRec("wagcap", where=[("wcp_seq", "=", args[-1:][0])]) def queryWag(self): callModule(self.opts["mf"], self.df, "wg4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class gl2010(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, ["ctlynd", "genmst", "genbal"], prog=self.__class__.__name__) if self.sql.error: return per = self.sql.getRec("ctlynd", where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", 0)], limit=1) if not per: showError( self.opts["mf"].body, "Period Error", """No Period 0! Please Contact your Software Support and Quote this Message as this is a Serious Error!""" ) return self.start = per[self.sql.ctlynd_col.index("cye_start")] return True def drawDialog(self): sel_acc = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } sel_all = { "stype": "R", "tables": ("genbal", "genmst"), "cols": (("glo_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description"), ("glo_trdt", "", 0, "Date"), ("glo_cyr", "", 0, "Balance")), "where": [("glo_cono", "=", self.opts["conum"]), ("glm_cono=glo_cono", ), ("glm_acno=glo_acno", ), ("glo_trdt", "=", self.start)] } fld = ((("C", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doAcc, sel_acc, None, None), (("C", 0, 0, 1), "ONA", 30, "Description"), (("C", 0, 0, 2), "ISD", 13.2, "Balance", "Balance Value", "", "N", self.doBal, None, None, None)) but = (("Import File", None, self.doImport, 0, ("C", 0, 1), ("C", 0, 2), "Import Opening Balances from a CSV or XLS File."), ("All Entries", sel_all, None, 1, ("C", 0, 1), None, "Display All Existing Balances"), ("Exit", None, self.exitData, 1, ("C", 0, 1), ("C", 0, 2))) row = (20, ) self.df = TartanDialog(self.opts["mf"], rows=row, eflds=fld, cend=((self.endData, "y"), ), cxit=(self.exitData, ), butt=but) def doImport(self): state = self.df.disableButtonsTags() self.df.setWidget(self.df.mstFrame, state="hide") impcol = [["Account Number", 0, "UI", 7], ["Opening Balance", 1, "SD", 13.2]] fi = FileImport(self.opts["mf"], impcol=impcol) err = None for num, line in enumerate(fi.impdat): if len(line) != 2: err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \ (num + 1, 2, len(line)) break self.acc = line[0] chk = self.sql.getRec("genmst", where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", self.acc)], limit=1) if not chk: err = "Line %s: Invalid Account %s" % ((num + 1), self.acc) break self.bal = line[1] self.old = self.sql.getRec("genbal", cols=["glo_cyr"], where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", self.acc), ("glo_trdt", "=", self.start)], limit=1) if not self.old: self.new_acc = "y" else: self.new_acc = "n" self.endData(det=True) if err: showError(self.opts["mf"].body, "Import Error", err) elif fi.impdat: self.opts["mf"].dbm.commitDbase() self.df.enableButtonsTags(state=state) self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doAcc(self, frt, pag, r, c, p, i, w): desc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) if not desc: return "Invalid Account Number" self.acc = w self.df.loadEntry(frt, pag, p + 1, data=desc[0]) self.old = self.sql.getRec("genbal", where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", self.acc), ("glo_trdt", "=", self.start)], limit=1) if not self.old: self.new_acc = "y" else: self.new_acc = "n" bal = self.old[self.sql.genbal_col.index("glo_cyr")] self.df.loadEntry(frt, pag, p + 2, data=bal) def doBal(self, frt, pag, r, c, p, i, w): self.bal = w def endData(self, det=False): data = [self.opts["conum"], self.acc, self.start, self.bal] if self.new_acc == "y": self.sql.insRec("genbal", data=data) elif data != self.old[:len(data)]: col = self.sql.genbal_col data.append(self.old[col.index("glo_xflag")]) self.sql.updRec("genbal", data=data, where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", self.acc), ("glo_trdt", "=", self.start)]) if det: return self.opts["mf"].dbm.commitDbase() nxt = self.sql.getRec("genmst", cols=["glm_acno"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", ">", self.acc)], limit=1) if nxt: self.df.colf[0][0][5] = nxt[0] else: self.df.colf[0][0][5] = 0 self.df.advanceLine(0) def exitData(self): bals = self.sql.getRec("genbal", cols=["sum(glo_cyr)"], where=[("glo_cono", "=", self.opts["conum"]), ("glo_trdt", "=", self.start)], limit=1) if bals[0]: diff = CCD(bals[0], "SD", 13.2) showError(self.opts["mf"].body, "Out of Balance", "Opening Balances Do Not Balance by %s" % diff.disp) self.df.focusField(self.df.frt, self.df.pag, self.df.col) else: showInfo( self.opts["mf"].body, "Year End", """A Year End for the Previous Period Must be Executed to Include These Opening Balances. If the Current Period is 1 then the Year End for Period 0 must be Executed.""") self.df.closeProcess() self.opts["mf"].closeLoop()
class cs2010(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"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" cshctl = gc.getCtl("cshctl", self.opts["conum"]) if not cshctl: return self.glint = cshctl["ccc_glint"] if self.glint == "Y": tabs = ["genmst"] else: tabs = ["cshmst"] tabs.extend(["cshana", "cshcnt"]) self.sql = Sql(self.opts["mf"].dbm, tables=tabs, prog=self.__class__.__name__) if self.sql.error: return if self.glint == "Y": self.ctl = [["csh_ctl", "Cash Control", 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]] t = time.localtime() self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2]) self.denoms = (("R200", 200), ("R100", 100), ("R50", 50), ("R20", 20), ("R10", 10), ("R5", 5), ("R2", 2), ("R1", 1), ("C50", .5), ("C20", .2), ("C10", .1), ("C5", .05), ("C2", .02), ("C1", .01)) return True def mainProcess(self): tag = (("Expenses", None, None, None, False), ("Income", None, None, None, False), ("Cash", None, None, None, False)) dte = { "stype": "R", "tables": ("cshcnt", ), "cols": (("cct_date", "", 0, "Date"), ), "where": [("cct_cono", "=", self.opts["conum"])], "group": "cct_date" } if self.glint == "Y": self.cod = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])], "order": "glm_acno" } else: self.cod = { "stype": "R", "tables": ("cshmst", ), "cols": (("ccm_acno", "", 0, "Acc-Num"), ("ccm_desc", "", 0, "Description", "Y")), "where": [("ccm_cono", "=", self.opts["conum"])], "order": "ccm_acno" } des = { "stype": "R", "tables": ("cshana", ), "cols": (("can_desc", "", 0, "Description", "Y"), ("can_vatcod", "", 0, "V")), "where": [("can_cono", "=", self.opts["conum"])], "whera": (("C", "can_code", 1, 1), ), "group": "can_desc", "order": "can_desc" } r1s = (("Expenses", "P"), ("Income", "T"), ("Cash", "C")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Type", "", "P", "N", self.doType, None, None, None), (("T", 0, 1, 0), "I@cct_date", 0, "", "", self.sysdtw, "N", self.doDate, dte, None, ("efld", )), (("T", 0, 2, 0), "OSD", 13.2, "Expenses Total"), (("T", 0, 3, 0), "OSD", 13.2, "Income Total"), (("T", 0, 4, 0), "OSD", 13.2, "Cash Total"), (("C", 1, 0, 0), "I@can_trdt", 0, "", "", "", "N", None, None, None, ("efld", )), (("C", 1, 1, 0), "I@can_code", 0, "", "", "", "N", self.doCode, self.cod, None, None), (("C", 1, 2, 0), "I@can_desc", 0, "", "", "", "N", self.doDesc, des, None, ("notblank", )), (("C", 1, 3, 0), "I@can_vatcod", 0, "", "", "N", "N", self.doVCode, None, None, ("notblank", )), (("C", 1, 4, 0), "I@can_incamt", 0, "", "", "", "N", self.doIncAmt, None, None, ("efld", )), (("C", 1, 5, 0), "I@can_vatamt", 0, "", "", "", "N", None, None, None, ("efld", )), (("C", 2, 0, 0), "I@can_trdt", 0, "", "", "", "N", None, None, None, ("efld", )), (("C", 2, 1, 0), "I@can_code", 0, "", "", "", "N", self.doCode, self.cod, None, None), (("C", 2, 2, 0), "I@can_desc", 0, "", "", "", "N", self.doDesc, des, None, ("notblank", )), (("C", 2, 3, 0), "I@can_vatcod", 0, "", "", "N", "N", self.doVCode, None, None, ("notblank", )), (("C", 2, 4, 0), "I@can_incamt", 0, "", "", "", "N", self.doIncAmt, None, None, ("efld", )), (("C", 2, 5, 0), "I@can_vatamt", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 3, 0, 0), "ISD", 13.2, "Cheques", "", "", "N", self.doCheq, None, None, ("efld", )), (("C", 3, 0, 0), "IUI", 5, "Quant", "Quantity", 0, "N", self.doQty, None, None, None, ("Denomination", 14)), (("C", 3, 1, 0), "OSD", 13.2, "Value", "", "", "N", None, None, None, ("efld", ))) tnd = ((self.doTopEnd, "y"), None, None, (self.doTopEnd, "n")) txt = (self.doTopExit, None, None, None) cnd = (None, (self.doColEnd, "y"), (self.doColEnd, "y"), (self.doColEnd, "n")) cxt = (None, self.doColExit, self.doColExit, self.doColExit) but = (("Accept", None, self.doColExit, 0, (("C", 1, 1), ("C", 2, 1)), (("C", 1, 2), ("C", 2, 2))), ("Edit", None, self.doEdit, 0, (("C", 1, 1), ("C", 2, 1)), (("C", 1, 2), ("C", 2, 2))), ("Quit", None, self.doQuit, 0, ("T", 0, 0), ("T", 0, 1))) self.df = TartanDialog(self.opts["mf"], tags=tag, eflds=fld, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but, focus=False) for x in range(14): self.df.colLabel[3][x].configure(text=self.denoms[x][0]) self.df.focusField("T", 0, 1) def doType(self, frt, pag, r, c, p, i, w): self.trtp = w self.edit = None self.amend = False self.loader = False self.etotal = 0 self.itotal = 0 self.ctotal = 0 def doDate(self, frt, pag, r, c, p, i, w): self.date = w rec = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", "P"), ("can_date", "=", self.date)]) if rec and self.trtp == "P": self.amend = True for rr in rec: self.etotal = float(ASD(self.etotal) + ASD(rr[7])) self.df.loadEntry(frt, pag, p + 1, data=self.etotal) rec = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", "T"), ("can_date", "=", self.date)]) if rec and self.trtp == "T": self.amend = True for rr in rec: self.itotal = float(ASD(self.itotal) + ASD(rr[7])) self.df.loadEntry(frt, pag, p + 2, data=self.itotal) self.rec = self.sql.getRec("cshcnt", where=[("cct_cono", "=", self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date", "=", self.date)], limit=1) if self.rec and self.trtp == "C": self.amend = True if self.amend: return "nc" def doCode(self, frt, pag, r, c, p, i, w): if self.glint == "N" and not w: ok = askQuestion(self.opts["mf"].body, "Code Maintenance", "Do You Want to Add or Edit Codes?", default="no") if ok == "no": return "rf" w = callModule(self.opts["mf"], self.df, "cs1010", coy=[self.opts["conum"], self.opts["conam"]], user=self.opts["capnm"], args=True, ret="acno") self.df.loadEntry(frt, pag, p, data=w) if self.glint == "Y": acc = self.sql.getRec("genmst", cols=["glm_desc", "glm_vat"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) else: acc = self.sql.getRec("cshmst", cols=["ccm_desc", "ccm_vat"], where=[("ccm_cono", "=", self.opts["conum"]), ("ccm_acno", "=", w)], limit=1) if not acc: return "Invalid Code" self.code = w self.vcod = acc[1] self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doDesc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("cshana", cols=["can_vatcod"], where=[("can_cono", "=", self.opts["conum"]), ("can_code", "=", self.code), ("can_desc", "=", w)], order="can_date desc", limit=1) if acc: self.df.loadEntry(frt, pag, p + 1, data=acc[0]) else: self.df.loadEntry(frt, pag, p + 1, data=self.vcod) def doVCode(self, frt, pag, r, c, p, i, w): self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.date) if self.vatrte is None: ask = askQuestion(self.opts["mf"].body, "New Code", "Code Does Not Exist, Create a New Code?", default="no") if ask == "no": return "Invalid VAT Code" w = callModule(self.opts["mf"], self.df, "ms1040", coy=[self.opts["conum"], self.opts["conam"]], user=self.opts["capnm"], args=w, ret="code") self.df.loadEntry(frt, pag, p, data=w) self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.date) if self.vatrte is None: return "Invalid VAT Code" def doIncAmt(self, frt, pag, r, c, p, i, w): self.iamt = w if self.vatrte: vat = self.iamt * self.vatrte / float(ASD(100) + ASD(self.vatrte)) self.df.loadEntry(frt, pag, p + 1, data=round(vat, 2)) else: self.df.loadEntry(frt, pag, p + 1, data=0) if not self.loader: return "sk1" def doCheq(self, frt, pag, r, c, p, i, w): self.ctotal = w self.df.loadEntry("T", 0, 4, data=self.ctotal) def doQty(self, frt, pag, r, c, p, i, w): val = w * self.denoms[int(p / 2)][1] self.df.loadEntry(frt, pag, p + 1, val) self.ctotal = float(ASD(self.ctotal) + ASD(val)) self.df.loadEntry("T", 0, 4, data=self.ctotal) def doEdit(self): if self.df.pag in (1, 2): self.doEditPage12() else: self.doEditPage3() def doEditPage12(self): ana = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", self.trtp), ("can_date", "=", self.date)]) data = [] for rec in ana: dat = [] for n, d in enumerate(rec): if n in (0, 1, 2, 9): continue dat.append(d) data.append(dat) titl = "Analysis" head = ("Date", "Code", "Description", "V", "Inc-Amount", "VAT-Amount", "Seq") lin = { "stype": "C", "titl": titl, "head": head, "typs": (("D1", 10), ("UI", 7), ("NA", 30), ("UA", 1), ("SD", 13.2), ("SD", 13.2), ("UA", 1), ("US", 10)), "data": data } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Line to Edit") chg = self.df.selChoice(lin) if chg and chg.selection: self.edit = self.sql.getRec("cshana", where=[("can_seq", "=", chg.selection[-1])], limit=1) self.doChgChanges() else: self.edit = None self.doLoadAnalysis() self.df.enableButtonsTags(state=state) def doChgChanges(self): tit = ("Change Line", ) fld = ((("T", 0, 0, 0), "I@can_trdt", 10, "", "", "", "N", self.doChgDate, None, None, ("efld", )), (("T", 0, 1, 0), "I@can_code", 0, "", "", "", "N", None, self.cod, None, None), (("T", 0, 2, 0), "I@can_desc", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 3, 0), "I@can_vatcod", 0, "", "", "", "N", self.doChgVCode, None, None, ("efld", )), (("T", 0, 4, 0), "I@can_incamt", 0, "", "", "", "N", self.doChgIncAmt, None, None, ("efld", )), (("T", 0, 5, 0), "I@can_vatamt", 0, "", "", "", "N", None, None, None, ("efld", ))) but = [["Delete", None, self.doChgDel, 1, None, None]] self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doChgEnd, "n"), ), txit=(self.doChgExit, ), focus=False) for num, dat in enumerate(self.edit[3:9]): self.cg.loadEntry("T", 0, num, data=dat) self.cg.focusField("T", 0, 1, clr=False) self.cg.mstFrame.wait_window() def doChgDate(self, frt, pag, r, c, p, i, w): self.chgdte = w def doChgVCode(self, frt, pag, r, c, p, i, w): self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.chgdte) if self.vatrte is None: return "Invalid VAT Code" def doChgIncAmt(self, frt, pag, r, c, p, i, w): self.iamt = w if self.vatrte: vat = self.iamt * self.vatrte / float(ASD(100) + ASD(self.vatrte)) self.cg.loadEntry(frt, pag, p + 1, data=round(vat, 2)) else: self.cg.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doChgDel(self): self.sql.delRec("cshana", data=self.edit) self.doChgExit() def doChgEnd(self): self.sql.delRec("cshana", data=self.edit) for num, fld in enumerate(self.cg.t_work[0][0]): self.edit[num + 3] = fld self.sql.insRec("cshana", data=self.edit) self.opts["mf"].dbm.commitDbase() self.doChgExit() def doChgExit(self): self.cg.closeProcess() def doEditPage3(self): titl = "Denominations" data = [] for num, rec in enumerate(self.df.c_work[3]): data.append([self.denoms[num][0], rec[0], rec[1]]) lin = { "stype": "C", "deco": True, "titl": titl, "head": ("Denom", "Qty", "Value"), "typs": (("NA", 4), ("UI", 5), ("SD", 13.2)), "data": data, "retn": "I" } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Denomination to Edit") chg = self.df.selChoice(lin) self.df.enableButtonsTags(state=state) if chg and chg.selection: self.edit = self.df.col qty, val = self.df.c_work[3][chg.selection[0]] self.ctotal = float(ASD(self.ctotal) - ASD(val)) self.df.focusField("C", 3, (chg.selection[0] * 2) + 1) else: self.edit = None self.df.focusField("C", 3, self.df.col) def doTopEnd(self): if self.df.pag == 0: if self.trtp == "P": self.df.selPage("Expenses") if self.amend: self.doLoadAnalysis() else: self.df.focusField("C", 1, 1) elif self.trtp == "T": self.df.selPage("Income") if self.amend: self.doLoadAnalysis() else: self.df.focusField("C", 2, 1) else: self.df.selPage("Cash") if not self.amend: self.df.focusField("T", 3, 1) else: self.doLoadCash() elif self.df.pag == 3: self.df.focusField("C", 3, 1) def doColEnd(self): if self.trtp in ("P", "T"): if self.trtp == "P": data = [self.opts["conum"], self.trtp, self.date] data.extend(self.df.c_work[1][self.df.row]) data.append("N") self.sql.insRec("cshana", data=data) self.etotal = float(ASD(self.etotal) + ASD(self.iamt)) self.df.loadEntry("T", 0, 2, data=self.etotal) self.df.advanceLine(1) else: data = [self.opts["conum"], self.trtp, self.date] data.extend(self.df.c_work[2][self.df.row]) data.append("N") self.sql.insRec("cshana", data=data) self.itotal = float(ASD(self.itotal) + ASD(self.iamt)) self.df.loadEntry("T", 0, 3, data=self.itotal) self.df.advanceLine(2) else: if self.df.col == 28: ask = askQuestion(self.opts["mf"].body, "Accept", "Accept All Entries") if ask == "yes": data = [self.opts["conum"], "T", self.date] data.append(self.df.t_work[3][0][0]) for x in range(14): data.append(self.df.c_work[3][x][0]) if self.amend: self.sql.delRec("cshcnt", where=[("cct_cono", "=", self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date", "=", self.date)]) self.sql.insRec("cshcnt", data=data) self.opts["mf"].dbm.commitDbase() self.doRestart() else: self.df.focusField("T", 3, 1, clr=False) elif self.edit: col = self.edit self.edit = None self.df.focusField("C", 3, col) else: self.df.advanceLine(self.df.pag) def doLoadCash(self): self.df.doInvoke(["T", 3, 1, self.doCheq], self.rec[3]) for num, qty in enumerate(self.rec[4:-1]): col = (num * 2) + 1 self.df.doInvoke(["C", 3, col, self.doQty], qty) def doLoadAnalysis(self): self.loader = True total = 0 if self.trtp == "P": pag = 1 else: pag = 2 self.df.clearFrame("C", pag) ana = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", self.trtp), ("can_date", "=", self.date)], order="can_seq") if not ana: self.df.focusField("C", pag, 1) else: for num, rec in enumerate(ana): if num > 14: num = 14 for pos, dat in enumerate(rec[3:9]): col = (num * 6) + pos + 1 if pos == 3: self.df.doInvoke(["C", pag, col, self.doVCode], dat) elif pos == 4: self.df.doInvoke(["C", pag, col, self.doIncAmt], dat) else: self.df.doInvoke(["C", pag, col, "rt"], dat) total = float(ASD(total) + ASD(self.iamt)) self.df.advanceLine(pag) if self.trtp == "P": self.etotal = total self.df.loadEntry("T", 0, 2, data=self.etotal) else: self.itotal = total self.df.loadEntry("T", 0, 3, data=self.itotal) self.loader = False def doQuit(self): self.opts["mf"].dbm.rollbackDbase() self.doRestart() def doTopExit(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doColExit(self): if self.df.pag != 3: self.opts["mf"].dbm.commitDbase() self.doRestart() elif self.df.pos: self.df.loadEntry("C", 3, self.df.pos, data=self.df.c_work[3][self.df.row][self.df.idx]) r = self.df.row - 1 c = self.df.col - 2 self.ctotal = float( ASD(self.ctotal) - ASD(self.df.c_work[3][r][1])) self.df.focusField("C", 3, c) def doRestart(self): self.df.clearFrame("C", 1) self.df.clearFrame("C", 2) self.df.clearFrame("T", 3) self.df.clearFrame("C", 3) self.df.selPage("Expenses") self.df.focusField("T", 0, 1, clr=True)
class ml2020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): # Check for Valid Posting Routine if self.opts["rtn"] != 5: mes = "Invalid Routine %s" % str(self.opts["rtn"]) showError(self.opts["mf"].body, "Control Error", mes) return tabs = ["ctlvmf", "memmst", "memtrn"] self.gc = GetCtl(self.opts["mf"]) memctl = self.gc.getCtl("memctl", self.opts["conum"]) if not memctl: return self.glint = memctl["mcm_glint"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["mem_ctl", "vat_ctl", "dis_all"] if self.gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.memctl = ctlctl["mem_ctl"] self.dis_all = ctlctl["dis_all"] tabs.extend(["genmst", "gentrn"]) # Setup SQL Object 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"], "MEM", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] self.glt = 4 self.agevar = tk.BooleanVar() self.agevar.set(False) return True def drawDialog(self): mlm = { "stype": "R", "tables": ("memmst", ), "cols": (("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"), ("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"), ("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0, "Names", "F")), "where": [("mlm_cono", "=", self.opts["conum"])], "order": "mlm_surname, mlm_names", "sort": False } tag = (("Deposit", None, None, None, False), ("Allocation", None, None, None, False)) fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One", "i", "Y", self.doRefno, None, None, ("efld", )), (("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount", "", "N", self.doTrnAmt, None, None, ("notzero", )), (("C", 1, 0, 3), "INA", 30, "Details", "Deposit Details", "", "N", self.doTrnDet, None, None, None), (("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"), (("C", 2, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N", self.doMemAcc, mlm, None, ("notblank", )), (("C", 2, 0, 1), "ONA", 30, "Name"), (("C", 2, 0, 2), "ISD", 13.2, "Receipt", "Receipt Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 3), "ISD", 13.2, "Discount", "Discount Amount", "", "N", self.doDisAmt, None, None, ("efld", ), None, "Discount Amount to be Added to the Receipt Amount."), (("C", 2, 0, 4), "OSD", 13.2, "Total-Amount")) but = ( ("Age _Normal",None,self.doAgeNormal,0,None,None, "Only Show Unallocated Transactions",1), ("Age _History",None,self.doAgeHistory,0,None,None, "Show All Transactions Including Already Allocated",1), ("Age _Automatic",None,self.doAgeAuto,0,None,None, "Automatically Allocate the Amount Starting With the "\ "Oldest Unallocated One",1), ("Age _Current",None,self.doAgeCurrent,0,None,None, "Leave the Transaction Unallocated",1), ("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1)) txt = (None, None, None) cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")] cxt = [None, self.exitPage1, self.exitPage2] self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, txit=txt, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doRefno(self, frt, pag, r, c, p, i, w): if not w: trns = self.sql.getRec("memtrn", cols=["mlt_refno"], where=[("mlt_cono", "=", self.opts["conum"]), ("mlt_refno", "like", "R________")], order="mlt_refno desc") auto = False for trn in trns: try: w = "R%08i" % (int(trn[0][1:]) + 1) auto = True break except: pass if not auto: w = "R00000001" self.df.loadEntry(frt, pag, p, data=w) chk = self.sql.getRec("memtrn", cols=["mlt_memno"], where=[("mlt_cono", "=", self.opts["conum"]), ("mlt_type", "=", self.opts["rtn"]), ("mlt_refno", "=", w)]) if chk: return "A Transaction with this Number Already Exists" self.refno = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w self.allocated = float(0.00) def endPage1(self): self.batupd = False self.updateTables1() self.updateBatch() self.agecan = False self.allocated = float(0.0) self.df.selPage("Allocation") self.df.loadEntry("T", 2, 0, data=self.trnamt) self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt if self.glint == "Y": # General Ledger Control Transaction (Bank) data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, self.trnamt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doMemAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("memmst", cols=["mlm_title", "mlm_initial", "mlm_surname"], where=[("mlm_cono", "=", self.opts["conum"]), ("mlm_memno", "=", w)], limit=1) if not acc: return "Invalid Member Number" self.memno = w self.name = "%s, %s %s" % (acc[2], acc[0], acc[1]) self.df.loadEntry("C", pag, p + 1, data=self.name) self.allref = self.refno while self.sql.getRec("memtrn", cols=["mlt_batch"], where=[("mlt_cono", "=", self.opts["conum"]), ("mlt_memno", "=", self.memno), ("mlt_type", "=", self.opts["rtn"]), ("mlt_refno", "=", self.allref)]): self.doGetAnotherRef() def doGetAnotherRef(self): tit = ("Duplicate Reference Number", ) fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref, "N", None, None, None, None), (("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N", self.doRefNew, None, None, ("notblank", ))) tnd = ((self.doRefEnd, "n"), ) txt = (self.doRefExit, ) state = self.df.disableButtonsTags() self.tf = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=tnd, txit=txt) self.tf.mstFrame.wait_window() self.df.enableButtonsTags(state=state) def doRefExit(self): self.tf.focusField("T", 0, 2) def doRefNew(self, frt, pag, r, c, p, i, w): self.allref = w def doRefEnd(self): self.tf.closeProcess() def doAllAmt(self, frt, pag, r, c, p, i, w): if w == 0: self.allamt = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.allamt = w def doDisAmt(self, frt, pag, r, c, p, i, w): if self.allamt < 0 and w > 0: ok = self.checkSign() elif self.allamt > 0 and w < 0: ok = self.checkSign() else: ok = "yes" if ok != "yes": return "Invalid Discount Amount (Sign Error)" self.disamt = w totamt = float(ASD(self.allamt) + ASD(self.disamt)) self.df.loadEntry(frt, pag, p + 1, data=totamt) def checkSign(self): return askQuestion(self.opts["mf"].body, "Check Sign", "The Sign of the Discount Amount is not the same as the Sign "\ "of the Receipt Amount, Is This Correct?") def endPage2(self): self.amt = float(ASD(0) - ASD(self.allamt)) self.dis = float(ASD(0) - ASD(self.disamt)) state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Choose an Ageing Option") for x in range(0, 5): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "normal") self.df.setWidget(self.df.B0, "focus") self.agevar.set(True) self.df.mstFrame.wait_variable(self.agevar) self.df.enableButtonsTags(state=state) if self.agecan: self.doCancel() return # Members Ledger Transaction data = [ self.opts["conum"], self.memno, self.opts["rtn"], self.allref, self.bh.batno, self.trndat, self.amt, 0.00, self.curdt, "", 0, self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("memtrn", data=data) if self.dis: data = [ self.opts["conum"], self.memno, 6, self.allref, self.bh.batno, self.trndat, self.dis, 0.00, self.curdt, "", 0, self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("memtrn", data=data, unique="mlt_refno") self.allocated = float(ASD(self.allocated) + ASD(self.allamt)) if self.glint == "Y": # General Ledger Control Transaction (Members) amt = float(ASD(self.amt) + ASD(self.dis)) data = (self.opts["conum"], self.memctl, self.curdt, self.trndat, self.glt, self.allref, self.bh.batno, amt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Discount) if self.disamt: data = (self.opts["conum"], self.dis_all, self.curdt, self.trndat, self.glt, self.allref, self.bh.batno, self.disamt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.allocated == self.trnamt: self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Deposit") self.df.advanceLine(1) else: bal = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def doAgeNormal(self): self.doAgeing("N") def doAgeHistory(self): self.doAgeing("H") def doAgeAuto(self): self.doAgeing("O") def doAgeCurrent(self): self.doAgeing("C") def doAgeing(self, atype): # Disable All Ageing Buttons for x in range(0, 4): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") self.opts["mf"].updateStatus("Select Transaction to Allocate Against") age = AgeAll(self.opts["mf"], system="mem", agetyp=atype, agekey=[ self.opts["conum"], self.memno, self.opts["rtn"], self.allref, self.curdt, self.amt, self.dis ]) self.agecan = age.cancel self.agevar.set(False) def doCancel(self): if self.agecan: ok = "yes" else: ok = askQuestion( self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) self.df.clearFrame("C", 2) self.df.selPage("Deposit") row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.focusField("C", 1, col) def updateBatch(self, rev=False): if rev: self.bh.batqty -= 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.batupd = True self.bh.batqty += 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def exitPage2(self): self.df.focusField("C", 2, self.df.col)
class bc2030(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, ["bwltab", "bwlflf", "bwlflm", "bwlflt"], prog=self.__class__.__name__) if self.sql.error: return 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"])] } dte = { "stype": "R", "tables": ("bwlflt", ), "cols": (("bft_date", "", 0, "Match-Date"), ), "where": [("bft_cono", "=", self.opts["conum"])], "whera": [("T", "bft_fmat", 0, 0), ("T", "bft_type", 4, 0)], "group": "bft_date", "order": "bft_date" } skp = { "stype": "R", "tables": ("bwlflt", "bwlfls", "bwltab"), "cols": (("bft_skip", "", 0, "Skp"), ("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "", 0, "Names"), ("bft_shotsf", "", 0, "For"), ("bft_shotsa", "", 0, "Agt")), "where": [("bfs_cono", "=", self.opts["conum"]), ("bfs_league", "=", "M"), ("bfs_code=bft_team", ), ("btb_tab=bft_skip", )], "whera": [("T", "bft_fmat", 0, 0), ("T", "bft_type", 4, 0), ("T", "bft_date", 5, 0)], "group": "bft_skip", "order": "btb_surname, btb_names" } plr = { "stype": "R", "tables": ("bwlflt", "bwltab"), "cols": (("bft_player", "", 0, "Plr"), ("bft_position", "", 0, "P"), ("btb_surname", "", 0, "Name", "Y"), ("btb_names", "", 0, "Name")), "where": [("btb_cono", "=", self.opts["conum"]), ("btb_cono=bft_cono", ), ("btb_tab=bft_player", )], "whera": [["T", "bft_fmat", 0, 0], ["T", "bft_type", 4, 0], ["T", "bft_date", 5, 0], ["C", "bft_skip", 0, 0]], "group": "bft_player", "order": "bft_position" } r1s = (("Fixture", "F"), ("Practice", "P")) fld = ((("T", 0, 0, 0), "I@bft_fmat", 0, "", "", 0, "N", self.doFmat, fmt, None, ("efld", )), (("T", 0, 0, 0), "ONA", 30, ""), (("T", 0, 1, 0), "OUI", 1, "Number of Forms"), (("T", 0, 2, 0), "OUA", 1, "Assess Self"), (("T", 0, 3, 0), ("IRB", r1s), 0, "Type", "", "F", "N", self.doType, None, None, None), (("T", 0, 4, 0), "I@bft_date", 0, "", "", "", "N", self.doDate, dte, None, ("efld", )), (("C", 0, 0, 0), "I@bft_skip", 0, "", "", "r", "N", self.doSkip, skp, None, None), (("C", 0, 0, 1), "ONA", 20, ""), (("C", 0, 0, 2), "I@bft_player", 0, "", "", "", "N", self.doPlayer, plr, None, None), (("C", 0, 0, 3), "ONA", 20, ""), (("C", 0, 0, 4), "I@bft_shotsf", 0, "", "", "", "N", self.doShotsf, None, None, None), (("C", 0, 0, 5), "I@bft_shotsa", 0, "", "", "", "N", self.doShotsa, None, None, None), (("C", 0, 0, 6), "I@bft_points", 0, "", "", "", "N", self.doPoints, None, None, None), (("C", 0, 0, 7), "I@bft_rating1", 0, "", "", "", "N", self.doRate1, None, None, None), (("C", 0, 0, 8), "I@bft_rating2", 0, "", "", "", "N", self.doRate2, None, None, None), (("C", 0, 0, 9), "I@bft_rating3", 0, "", "", "", "N", self.doRate3, None, None, None), (("C", 0, 0, 10), "I@bft_rating4", 0, "", "", "", "N", self.doRate4, None, None, None), (("C", 0, 0, 11), "I@bft_remarks", 20, "", "", "", "N", self.doRemarks, None, None, None)) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) cnd = ((self.doEnd, "n"), ) cxt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, 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" if acc[self.sql.bwlflf_col.index("bff_assess")] == "N": return "Assessment Forms Disabled" self.fmat = w desc = acc[self.sql.bwlflf_col.index("bff_desc")] self.forms = acc[self.sql.bwlflf_col.index("bff_forms")] self.self = acc[self.sql.bwlflf_col.index("bff_self")] self.df.loadEntry(frt, pag, p + 1, data=desc) self.df.loadEntry(frt, pag, p + 2, data=self.forms) self.df.loadEntry(frt, pag, p + 3, data=self.self) def doType(self, frt, pag, r, c, p, i, w): self.ftyp = w def doDate(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("bwlflm", where=[("bfm_cono", "=", self.opts["conum"]), ("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp), ("bfm_date", "=", w)], limit=1) if not acc: return "Invalid Date" self.date = w def doSkip(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec(tables=["bwlflt", "bwltab"], cols=[ "btb_surname", "btb_names", "bft_shotsf", "bft_shotsa", "bft_rating1", "bft_rating2", "bft_rating3", "bft_rating4", "bft_remarks" ], where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=", self.date), ("bft_skip", "=", w), ("btb_cono=bft_cono", ), ("btb_tab=bft_skip", )], limit=1) if not acc: return "Invalid Skip" acc[0] = self.getName(acc[0], acc.pop(1)) if w == self.skip: self.repeat = True else: self.repeat = False self.skip = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if self.forms == 1: for x in range(1, 8): self.df.loadEntry(frt, pag, p + x + 3, data=acc[x]) return "sk3" def doPlayer(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec(tables=["bwlflt", "bwltab"], cols=[ "btb_surname", "btb_names", "bft_position", "bft_shotsf", "bft_shotsa", "bft_points", "bft_rating1", "bft_rating2", "bft_rating3", "bft_rating4", "bft_remarks" ], where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp), ("bft_date", "=", self.date), ("bft_skip", "=", self.skip), ("bft_player", "=", w), ("btb_tab=bft_player", )], limit=1) if not acc: return "This Player Did Not Play for this Skip on this Date" acc[0] = self.getName(acc[0], acc.pop(1)) self.player = w self.position = acc[1] self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if self.repeat: self.df.loadEntry(frt, pag, p + 2, data=self.shotsf) self.df.loadEntry(frt, pag, p + 3, data=self.shotsa) self.df.loadEntry(frt, pag, p + 4, data=self.points) else: self.df.loadEntry(frt, pag, p + 2, data=acc[2]) self.df.loadEntry(frt, pag, p + 3, data=acc[3]) self.df.loadEntry(frt, pag, p + 4, data=acc[4]) for x in range(5, 10): self.df.loadEntry(frt, pag, p + x, data=acc[x]) if self.repeat: if self.forms == 4 and self.self == "N" and self.position == 1: self.rate1 = 0 self.df.loadEntry(frt, pag, p + 5, data=self.rate1) return "sk5" else: return "sk4" def doShotsf(self, frt, pag, r, c, p, i, w): self.shotsf = w def doShotsa(self, frt, pag, r, c, p, i, w): self.shotsa = w def doPoints(self, frt, pag, r, c, p, i, w): self.points = w if self.forms == 4 and self.self == "N" and self.position == 1: self.rate1 = 0 self.df.loadEntry(frt, pag, p + 1, data=self.rate1) return "sk1" def doRate1(self, frt, pag, r, c, p, i, w): self.rate1 = w if self.forms == 4 and self.self == "N" and self.position == 2: self.rate2 = 0 self.df.loadEntry(frt, pag, p + 1, data=self.rate2) return "sk1" def doRate2(self, frt, pag, r, c, p, i, w): self.rate2 = w if self.forms == 4 and self.self == "N" and self.position == 3: self.rate3 = 0 self.df.loadEntry(frt, pag, p + 1, data=self.rate3) return "sk1" def doRate3(self, frt, pag, r, c, p, i, w): self.rate3 = w if self.forms == 4 and self.self == "N" and self.position == 4: self.rate4 = 0 self.df.loadEntry(frt, pag, p + 1, data=self.rate4) return "sk1" def doRate4(self, frt, pag, r, c, p, i, w): self.rate4 = w def doRemarks(self, frt, pag, r, c, p, i, w): self.remarks = w def doEnd(self): if self.df.frt == "T": self.df.focusField("C", 0, 1) return col = ["bft_shotsf", "bft_shotsa", "bft_points"] dat = [self.shotsf, self.shotsa, self.points] self.sql.updRec("bwlflt", cols=col, data=dat, where=[("bft_fmat", "=", self.fmat), ("bft_date", "=", self.date), ("bft_skip", "=", self.skip)]) col = [ "bft_rating1", "bft_rating2", "bft_rating3", "bft_rating4", "bft_remarks" ] dat = [self.rate1, self.rate2, self.rate3, self.rate4, self.remarks] if self.forms == 1: for x in range(1, 5): self.sql.updRec("bwlflt", cols=col, data=dat, where=[("bft_fmat", "=", self.fmat), ("bft_date", "=", self.date), ("bft_skip", "=", self.skip), ("bft_position", "=", x)]) dat[4] = "" else: self.sql.updRec("bwlflt", cols=col, data=dat, where=[("bft_fmat", "=", self.fmat), ("bft_date", "=", self.date), ("bft_skip", "=", self.skip), ("bft_player", "=", self.player)]) self.df.advanceLine(0) def doExit(self): if self.df.frt == "C": self.opts["mf"].dbm.commitDbase(ask=True) self.df.closeProcess() self.opts["mf"].closeLoop() def getName(self, snam, fnam): if fnam: for i in fnam.split(): snam = "%s %s" % (snam, i[0]) return snam.upper()
class bc2060(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): t = time.localtime() self.today = ((t[0] * 10000) + (t[1] * 100) + t[2]) self.sql = Sql(self.opts["mf"].dbm, ["bwlcmp", "bwltab", "bwlgme", "bwltyp", "bwlent"], prog=self.__class__.__name__) if self.sql.error: return return True def mainProcess(self): com = { "stype": "R", "tables": ("bwlcmp", ), "cols": (("bcm_code", "", 0, "Cod"), ("bcm_name", "", 0, "Name", "Y"), ("bcm_date", "", 0, "Date")), "where": [("bcm_cono", "=", self.opts["conum"])] } skp = { "stype": "R", "tables": ("bwltab", "bwlgme"), "cols": (("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "", 0, "Names"), ("bcg_rink", "", 0, "RK"), ("bcg_ocod", "", 0, "Opp")), "where": [("btb_cono", "=", self.opts["conum"]), ("bcg_cono=btb_cono", ), ("bcg_scod=btb_tab", )], "whera": [("T", "bcg_ccod", 0, 0), ("T", "bcg_game", 2, 0)], "group": "btb_tab", "order": "btb_tab" } fld = ( (("T",0,0,0),"I@bcm_code",0,"","", "","Y",self.doCmpCod,com,None,("notzero",)), (("T",0,0,0),"ONA",30,""), (("T",0,1,0),"I@bcg_game",0,"Game Number","", 1,"N",self.doGame,None,None,("efld",)), (("T",0,1,0),"I@bcg_date",0,"Date","", self.today,"N",self.doDate,None,None,("efld",)), (("T",0,2,0),"IUA",30,"Greens","Greens (A,B,C)", "","N",self.doGreens,None,None,("efld",),None,"Available "\ "Greens in the format A,B or A,B345 showing Green Code and "\ "Rinks. If the Rinks are Not Entered they will Default to 6."), (("C",0,0,0),"I@bcg_scod",0,"","", "","N",self.doSkpCod,skp,None,("notzero",)), (("C",0,0,0),"ONA",30,"Skp-Name"), (("C",0,0,0),"I@bcg_ocod",0,"","", "","N",self.doOppCod,skp,None,("notzero",)), (("C",0,0,0),"ONA",30,"Opp-Name"), (("C",0,0,0),"I@bcg_rink",0,"","", "","N",self.doRink,None,None,("notblank",))) but = (("Quit", None, self.doQuit, 1, None, None), ) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) cnd = ((self.doEnd, "y"), ) cxt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], tops=False, eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doCmpCod(self, frt, pag, r, c, p, i, w): com = self.sql.getRec("bwlcmp", cols=["bcm_name", "bcm_date", "bcm_type"], where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", w)], limit=1) if not com: return "Invalid Competition Code" name, self.sdat, ctyp = com self.df.loadEntry(frt, pag, p + 1, data=name) chk = self.sql.getRec("bwltyp", cols=["bct_cfmat"], where=[("bct_cono", "=", self.opts["conum"]), ("bct_code", "=", ctyp)], limit=1) if chk[0] in ("D", "K", "R"): return "Knockout and R/Robin Draws Cannot be Changed" chk = self.sql.getRec("bwlgme", cols=[ "bcg_game", "bcg_date", "bcg_aflag", "sum(bcg_ocod)", "sum(bcg_sfor)" ], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", w)], group="bcg_game, bcg_date, bcg_aflag") self.ccod = w self.game = 0 self.draws = {} self.manual = False for ck in chk: if ck[2] == "A" or ck[4]: continue if ck[4]: continue if ck[2] in ("", "D", "S") and ck[3]: self.draws[ck[0]] = ck[1:] if not self.draws: ok = askQuestion(self.opts["mf"].body, "Manual Draw", "Is this the First Game and is it going to be a "\ "Manual Draw?", default="no") if ok == "no": return "rf" self.manual = True self.game = 1 self.df.loadEntry(frt, pag, p + 2, data=self.game) self.totskp = self.sql.getRec("bwlent", cols=["count(*)"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)], limit=1)[0] return "sk2" def doGame(self, frt, pag, r, c, p, i, w): if w not in self.draws: return "Invalid Game Number" self.game = w self.date = self.draws[w][0] self.df.loadEntry(frt, pag, p + 1, data=self.date) self.totskp = self.sql.getRec("bwlent", cols=["count(*)"], where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)], limit=1)[0] def doDate(self, frt, pag, r, c, p, i, w): if w < self.today or w < self.sdat: return "Invalid Date, in the Past or Before the Starting Date" self.date = w def doGreens(self, frt, pag, r, c, p, i, w): if not w: return "Invalid Greens" self.rinks = [] rinks = 0 grns = w.split(",") for gr in grns: if len(gr) == 1: for x in range(1, 7): self.rinks.append("%s%s" % (gr[0], x)) rinks += 6 elif len(gr) == 2 and gr[1] == "7": for x in range(1, 8): self.rinks.append("%s%s" % (gr[0], x)) rinks += 7 else: for rk in gr[1:]: self.rinks.append("%s%s" % (gr[0], rk)) rinks += 1 if int(self.totskp / 2) > rinks: return "Not Enough Rinks" def doSkpCod(self, frt, pag, r, c, p, i, w): skp = self.sql.getRec( tables=["bwlgme", "bwltab"], cols=["btb_surname", "btb_names", "bcg_ocod", "bcg_rink"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w), ("bcg_game", "=", self.game), ("btb_cono=bcg_cono", ), ("btb_tab=bcg_scod", )], limit=1) if not skp: return "Invalid Skip Code" self.skip = w self.old_opp = skp[2] self.old_rink = skp[3] if skp[1]: name = "%s, %s" % tuple(skp[:2]) else: name = skp[0] self.df.loadEntry(frt, pag, p + 1, data=name) if self.old_opp: self.df.loadEntry(frt, pag, p + 2, data=self.old_opp) opp = self.sql.getRec("bwltab", cols=["btb_surname", "btb_names"], where=[("btb_cono", "=", self.opts["conum"]), ("btb_tab", "=", skp[2])], limit=1) if opp[1]: name = "%s, %s" % tuple(opp[:2]) else: name = opp[0] self.df.loadEntry(frt, pag, p + 3, data=name) if self.old_rink: self.df.loadEntry(frt, pag, p + 4, data=self.old_rink) def doOppCod(self, frt, pag, r, c, p, i, w): opp = self.sql.getRec( tables=["bwlgme", "bwltab"], cols=["btb_surname", "btb_names", "bcg_ocod", "bcg_rink"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w), ("bcg_game", "=", self.game), ("btb_cono=bcg_cono", ), ("btb_tab=bcg_scod", )], limit=1) if not opp: return "Invalid Opponents Code" self.new_opp = w self.chg_skp = opp[2] if opp[1]: name = "%s, %s" % tuple(opp[:2]) else: name = opp[0] self.df.loadEntry(frt, pag, p + 1, data=name) def doRink(self, frt, pag, r, c, p, i, w): if w not in self.rinks: return "Invalid Rink" self.new_rink = w def doEnd(self): if self.df.frt == "T": self.df.focusField("C", 0, 1) else: self.df.advanceLine(0) self.sql.updRec("bwlgme", cols=["bcg_date", "bcg_ocod", "bcg_rink"], data=[self.date, self.new_opp, self.new_rink], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", self.skip), ("bcg_game", "=", self.game)]) self.sql.updRec("bwlgme", cols=["bcg_date", "bcg_ocod", "bcg_rink"], data=[self.date, self.skip, self.new_rink], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", self.new_opp), ("bcg_game", "=", self.game)]) def doExit(self): if self.df.frt == "C": chk = self.sql.getRec("bwlgme", cols=["bcg_ocod", "count(*)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.game)], group="bcg_ocod", order="bcg_ocod") for c in chk: if c[0] and c[1] != 1: skp = self.sql.getRec("bwlgme", cols=["bcg_scod"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.game), ("bcg_ocod", "=", c[0])], order="bcg_scod") err = "Opponent %s is Drawn Against %s Skips\n" % tuple(c) for s in skp: err = err + "\nSkip %s" % s[0] skp = self.sql.sqlRec("Select bce_scod from bwlent where "\ "bce_ccod = %s and bce_scod not in (select bcg_ocod "\ "from bwlgme where bcg_ccod = %s and bcg_game = %s)" % (self.ccod, self.ccod, self.game)) err = err + "\n\nSkips Without Opponents\n" for s in skp: err = err + "\nSkip %s" % s[0] showError(self.opts["mf"].body, "Skip Error", err) self.df.focusField(self.df.frt, self.df.pag, self.df.col) return chk = self.sql.getRec("bwlgme", cols=["bcg_rink", "count(*)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.game)], group="bcg_rink", order="bcg_rink") for c in chk: if c[1] != 2: skp = self.sql.getRec("bwlgme", cols=["bcg_scod", "bcg_ocod"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.game), ("bcg_rink", "=", c[0])], group="bcg_scod, bcg_ocod, bcg_rink", order="bcg_scod") skps = [] for s in skp: if [s[1], s[0]] not in skps: skps.append(s) err = "Rink %s Shows %s time(s)\n" % (c[0], int(c[1] / 2)) for s in skps: err = err + "\nSkip %2s Opp %2s" % (s[0], s[1]) rnk = self.sql.getRec("bwlgme", cols=["bcg_rink", "count(*)"], where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game", "=", self.game)], group="bcg_rink", order="bcg_rink") rnks = [] for r in rnk: rnks.append(r[0]) mis = "" for r in self.rinks: if r not in rnks: if not mis: mis = r else: mis = "%s, %s" % (mis, r) err = err + "\n\nAvailable Rink(s)\n\n%s" % mis showError(self.opts["mf"].body, "Rink Error", err) self.df.focusField(self.df.frt, self.df.pag, self.df.col) return self.opts["mf"].dbm.commitDbase(ask=True) self.df.closeProcess() self.opts["mf"].closeLoop() def doQuit(self): self.opts["mf"].dbm.rollbackDbase() self.df.closeProcess() self.opts["mf"].closeLoop()
class st2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.exit = False self.selectPrinter() if not self.exit: self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "ctlmst", "ctlmes", "ctlvrf", "ctlrep", "crsmst", "gentrn", "strgrp", "strloc", "strmf1", "strmf2", "strpom", "strpot", "strtrn", "strgmu", "strcmu", "tplmst" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return mods = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): mods.append(ctlmst["ctm_modules"][x:x + 2]) if "CR" not in mods: showError( self.opts["mf"].body, "System Error", "This module requires you to have a Creditor's Activated") return strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.stgl = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] self.dtpl = strctl["cts_tplnam"] if self.stgl == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["stk_soh", "stk_susp"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.soh = ctlctl["stk_soh"] self.ssp = ctlctl["stk_susp"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def selectPrinter(self): tit = ("Printer Selection", ) tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title", "Y")), "where": [("tpm_type", "=", "O"), ("tpm_system", "=", "STR")], "order": "tpm_tname" } fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.dtpl, "N", self.doTplNam, tpm, None, None), (("T", 0, 1, 0), "ID1", 10, "Order Date", "", self.sysdtw, "N", self.doOrdDate, None, None, ("efld", ))) self.pr = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=((self.doPrtEnd, "y"), ), txit=(self.doPrtExit, ), view=("N", "P"), mail=("N", "Y", "Y")) self.opts["mf"].startLoop() def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "O"), ("tpm_system", "=", "STR")], limit=1) if not acc: return "Invalid Template Name" self.tname = w def doOrdDate(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not In Financial Period" self.trdt = w self.trdd = self.pr.t_disp[0][0][1] self.curdt = int(self.trdt / 100) self.batch = "S%s" % self.curdt def doPrtEnd(self): self.doPrtClose() def doPrtExit(self): self.exit = True self.doPrtClose() def doPrtClose(self): self.pr.closeProcess() self.opts["mf"].closeLoop() def mainProcess(self): doc = { "stype": "R", "tables": ("strpom", "crsmst"), "cols": (("pom_ordno", "", 0, "Ord-Num"), ("pom_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")), "where": [("pom_cono", "=", self.opts["conum"]), ("crm_cono=pom_cono", ), ("crm_acno=pom_acno", ), ("pom_delno", "=", "")] } loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } crm = { "stype": "R", "tables": ("crsmst", ), "cols": [("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")], "where": [("crm_cono", "=", self.opts["conum"]), ("crm_stat", "<>", "X")], "index": 0 } odr = { "stype": "R", "tables": ("ctlrep", ), "cols": [("rep_code", "", 0, "Ord"), ("rep_name", "", 0, "Name", "Y")], "where": [("rep_cono", "=", self.opts["conum"])], "index": 0 } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } cod = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_code", "", 0, "Product-Code"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "not", "in", ("R", "X")), ("st1_value_ind", "<>", "N")], "whera": [("C", "st1_group", 0)], "order": "st1_group, st1_code" } r1s = (("New", "N"), ("Amend", "A"), ("Receive", "R"), ("Cancel", "C")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Action", "", "N", "Y", self.doActTyp, None, None, None), (("T", 0, 1, 0), "IUI", 9, "Ord-No", "Order Number", "", "N", self.doOrdNum, doc, None, ("notblank", )), (("T", 0, 2, 0), "IUA", 1, "Loc", "Location Code", "1", "N", self.doLoc, loc, None, None), (("T", 0, 2, 0), "ONA", 30, ""), (("T", 0, 3, 0), "INA", 7, "Acc-No", "Account Number", "", "N", self.doCrsAcc, crm, None, None), (("T", 0, 3, 0), "ONA", 30, ""), (("T", 0, 4, 0), "INa", 3, "Ord-By", "Ordered By", "", "N", self.doOrdBy, odr, None, None), (("T", 0, 4, 0), "ONA", 30, ""), (("T", 0, 5, 0), "INa", 7, "Del-No", "Delivery Note Number", "", "N", self.doDelNum, None, None, ("notblank", )), (("T", 0, 5, 0), "ID1", 10, "Date", "Delivery Date", self.trdt, "N", self.doDelDate, None, None, ("efld", )), (("C", 0, 0, 0), "INA", 3, "Grp", "Product Group", "", "Y", self.doGrp, grp, None, None), (("C", 0, 0, 1), "INA", 20, "Product-Code", "", "", "N", self.doCod, cod, None, None), (("C", 0, 0, 2), "INA", (20, 30), "Description", "", "", "N", self.doDes, None, None, None), (("C", 0, 0, 3), "ISD", 11.2, "Quantity", "", 1, "N", self.doQty, None, None, ("notzero", )), (("C", 0, 0, 4), "IUA", 1, "V", "V.A.T. Code", "I", "N", self.doVat, None, None, ("notblank", )), (("C", 0, 0, 5), "IUD", 10.2, "Price", "Exclusive Price", "", "N", self.doPri, None, None, None), (("C", 0, 0, 6), "IUD", 6.2, "Dis-%", "Trade Discount", "", "N", self.doDis, None, None, None), (("C", 0, 0, 7), "OSD", 10.2, "Value")) self.row = (15, ) self.but = (("Cancel", None, self.doCancel, 1, ("C", 0, 1), ("T", 0, 1)), ("DelAdd", None, self.doDelAdd, 1, ("C", 0, 1), ("T", 0, 1)), ("Ribbon", None, self.doRibbon, 1, ("C", 0, 1), ("T", 0, 1)), ("Message", None, self.doMessag, 1, ("C", 0, 1), ("T", 0, 1)), ("Edit", None, self.doEdit, 0, ("C", 0, 1), ("C", 0, 2)), ("Reprint", None, self.doReprnt, 0, ("T", 0, 1), ("T", 0, 2)), ("CrsMaint", None, self.doCrsMaint, 0, ("T", 0, 5), ("T", 0, 6)), ("CrsQuery", None, self.doCrsQuery, 1, None, None), ("StrMaint", None, self.doStrMaint, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("StrQuery", None, self.doStkQuery, 1, None, None), ("Exit", None, self.doTopExit, 0, ("T", 0, 1), (("T", 0, 2), ("T", 0, 3), ("T", 0, 5)), "Exit Purchase Orders"), ("Accept", None, self.doAccept, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2)))) tnd = ((self.doTopEnd, "n"), ) txt = (self.doTopExit, ) cnd = ((self.doColEnd, "n"), ) cxt = (None, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, rows=self.row, butt=self.but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, vport=True) def doActTyp(self, frt, pag, r, c, p, i, w): # Initialise Action Variables self.acttyp = w # Initialise Variables self.dnum = "" self.onum = "" self.jnum = "" self.dadd = "" self.cnam = "" self.vatn = "" self.ribbon = None ctl = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"])], limit=1) self.deladd = [ ctl[self.sql.ctlmst_col.index("ctm_sadd1")], ctl[self.sql.ctlmst_col.index("ctm_sadd2")], ctl[self.sql.ctlmst_col.index("ctm_sadd3")], ctl[self.sql.ctlmst_col.index("ctm_spcode")] ] self.message = "" for x in (1, 2, 3): if self.acttyp == "R": self.df.butt[x][1] = 0 self.df.butt[x][2] = None else: self.df.butt[x][1] = 1 self.df.butt[x][2] = ["C", 0, 1] if self.acttyp == "N": # Location default if self.locs == "N": self.loc = "1" self.df.loadEntry(frt, pag, p + 2, data=self.loc) self.df.loadEntry(frt, pag, p + 3, data="Location One") return "sk3" return "sk1" def doOrdNum(self, frt, pag, r, c, p, i, w): strpom = self.sql.getRec("strpom", where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", w)], limit=1) if not strpom: return "Invalid Document" if strpom[self.sql.strpom_col.index("pom_delno")] == "cancel": if self.acttyp == "C": return "Already Cancelled" ok = askQuestion( self.opts["mf"].body, "Cancelled", "This order was Cancelled.\n\nDo you want to Reinstate It?", default="no") if ok == "no": return "Order Cancelled" self.sql.updRec("strpom", cols=["pom_delno"], data=[""], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", w)]) strpom[self.sql.strpom_col.index("pom_delno")] = "" elif strpom[self.sql.strpom_col.index("pom_delno")]: return "Order Already Received" self.ordno = CCD(w, "UI", 9.0).work self.othno = CCD(w, "Na", 9.0).work self.loc = strpom[self.sql.strpom_col.index("pom_loc")] self.acno = strpom[self.sql.strpom_col.index("pom_acno")] self.cnam = strpom[self.sql.strpom_col.index("pom_contact")] self.vatn = strpom[self.sql.strpom_col.index("pom_vatno")] self.ordby = strpom[self.sql.strpom_col.index("pom_ordby")] self.ribbon = ["", "", self.cnam, self.vatn] self.df.loadEntry(frt, pag, p + 1, data=self.loc) self.doLoc(frt, pag, r, c + 1, p + 1, i + 1, self.loc) self.df.loadEntry(frt, pag, p + 3, data=self.acno) self.doCrsAcc(frt, pag, r, c + 3, p + 3, i + 3, self.acno) self.df.loadEntry(frt, pag, p + 5, data=self.ordby) self.doOrdBy(frt, pag, r, c + 5, p + 5, i + 5, self.ordby) if self.acttyp == "R": return "sk6" else: return "nd" def doLoc(self, frt, pag, r, c, p, i, w): desc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not desc: return "Invalid Location" self.loc = w self.df.loadEntry(frt, pag, p + 1, data=desc[0]) def doCrsAcc(self, frt, pag, r, c, p, i, w): self.crsmst = self.sql.getRec("crsmst", where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)], limit=1) if not self.crsmst: return "Invalid Account" if self.crsmst[self.sql.crsmst_col.index("crm_stat")] == "X": return "Invalid Account, Redundant" self.acno = w self.name = self.crsmst[self.sql.crsmst_col.index("crm_name")] self.df.loadEntry(frt, pag, p + 1, data=self.name) def doOrdBy(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlrep", cols=["rep_name"], where=[("rep_cono", "=", self.opts["conum"]), ("rep_code", "=", w)], limit=1) if not acc: return "Invalid Code" self.ordby = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) return "sk3" def doDelNum(self, frt, pag, r, c, p, i, w): self.delno = w def doDelDate(self, frt, pag, r, c, p, i, w): self.deldt = w def doTopEnd(self): if self.acttyp == "N": # Get and Display Next Document Number ordno = self.sql.getRec("strpom", cols=["max(pom_ordno)"], where=[("pom_cono", "=", self.opts["conum"])], limit=1) if not ordno[0]: self.ordno = CCD(1, "UI", 9).work self.othno = CCD(1, "Na", 9).work else: self.ordno = CCD((int(ordno[0]) + 1), "UI", 9).work self.othno = CCD((int(ordno[0]) + 1), "Na", 9).work self.df.loadEntry(self.df.frt, self.df.pag, 1, data=self.ordno) # Create Document Transaction (Head) self.dad1, self.dad2, self.dad3, self.dad4 = "", "", "", "" data = [ self.opts["conum"], self.ordno, self.loc, self.trdt, self.acno, self.dad1, self.dad2, self.dad3, self.dad4, "", "", "", "", self.ordby, "", "", 0, self.opts["capnm"], self.sysdtw ] # Write and Commit Header self.sql.insRec("strpom", data=data) self.opts["mf"].dbm.commitDbase() # Clear Totals self.doClearTots() elif self.acttyp == "C": self.doReadLoadStr() ok = askQuestion(self.opts["mf"].body, "Cancel", "Are You Sure This Order Must be Cancelled?", default="no") if ok == "yes": # Print Cancellation self.df.setWidget(self.df.mstFrame, state="hide") PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.ordno, tname=self.tname, repprt=self.pr.repprt, repeml=self.pr.repeml, copy=self.acttyp.lower()) self.df.setWidget(self.df.mstFrame, state="show") # Update Deletetion self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno)]) self.opts["mf"].dbm.commitDbase() # Clear totals and focus self.doClearTots() self.df.focusField("T", 0, 1) else: self.doReadLoadStr() self.amend = False def doReadLoadStr(self): self.doClearTots() data = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if not data: return for seq, line in enumerate(data): self.doExtData(line) if seq >= self.row[0]: self.df.scrollScreen(0) pos = (self.row[0] - 1) * 9 else: pos = seq * 9 # Load Values self.df.loadEntry("C", 0, pos, data=self.grp) self.df.loadEntry("C", 0, pos + 1, data=self.code) self.df.loadEntry("C", 0, pos + 2, data=self.desc) self.df.loadEntry("C", 0, pos + 3, data=self.qty) self.df.loadEntry("C", 0, pos + 5, data=self.vatcod) self.df.loadEntry("C", 0, pos + 6, data=self.price) self.df.loadEntry("C", 0, pos + 7, data=self.disrat) self.df.loadEntry("C", 0, pos + 8, data=self.excamt) self.vattot = float(ASD(self.vattot) + ASD(self.vatamt)) self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt)) self.inctot = float(ASD(self.inctot) + ASD(self.incamt)) if seq >= (self.row[0] - 1): self.df.scrollScreen(0) else: self.df.focusField("C", 0, pos + 10) self.df.setViewPort("O", self.inctot) def doTopExit(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doClearTots(self): self.vattot = 0 self.ordtot = 0 self.inctot = 0 self.df.clearFrame("C", 0) self.df.focusField("C", 0, 1) self.df.setViewPort(None, 0) def doGrp(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group Code" self.grp = w def doCod(self, frt, pag, r, c, p, i, w): strmf1 = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", w)], limit=1) if not strmf1: return "Invalid Code" if strmf1[self.sql.strmf1_col.index("st1_type")] == "R": return "Invalid Code (Recipe)" if strmf1[self.sql.strmf1_col.index("st1_type")] == "X": return "Invalid Code (Redundant)" if strmf1[self.sql.strmf1_col.index("st1_value_ind")] == "N": return "Invalid Code (Value Indicator)" self.vatcod = strmf1[self.sql.strmf1_col.index("st1_vatcode")] strmf2 = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.grp), ("st2_code", "=", w), ("st2_loc", "=", self.loc)], limit=1) if not strmf2: return "Invalid Location" odt = self.sql.getRec("strpot", cols=["count(*)"], where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", self.grp), ("pot_code", "=", w)], limit=1) if odt[0]: return "This Item is Already On This Order" odq = self.sql.getRec(tables=["strpom", "strpot"], cols=["sum(pot_qty)"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_loc", "=", self.loc), ("pom_delno", "=", ""), ("pot_cono", "=", self.opts["conum"]), ("pot_ordno=pom_ordno", ), ("pot_group", "=", self.grp), ("pot_code", "=", w)], limit=1) if odq[0]: state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="DupOrd", desc="%s of this Item is Already On Order" % odq[0]) self.df.enableButtonsTags(state=state) if cf.flag == "no": return "rf" self.code = w desc = strmf1[self.sql.strmf1_col.index("st1_desc")] self.uoi = strmf1[self.sql.strmf1_col.index("st1_uoi")] self.df.loadEntry(frt, pag, p + 1, data=desc) def doDes(self, frt, pag, r, c, p, i, w): self.desc = w def doQty(self, frt, pag, r, c, p, i, w): self.qty = w self.df.loadEntry(frt, pag, p + 1, data=self.vatcod) def doVat(self, frt, pag, r, c, p, i, w): self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trdt) if self.vatrte is None: return "Invalid V.A.T Code" self.vatcod = w # Last Cost Price lcost = getCost(self.sql, self.opts["conum"], self.grp, self.code, loc=self.loc, qty=1, ind="L") self.df.loadEntry(frt, pag, p + 1, data=lcost) def doPri(self, frt, pag, r, c, p, i, w): self.price = w self.inc = round((self.price * (self.vatrte + 100.0) / 100.0), 4) self.exc = round((self.price * 1), 2) dis = self.crsmst[self.sql.crsmst_col.index("crm_trdis")] self.df.loadEntry(frt, pag, p + 1, data=dis) def doDis(self, frt, pag, r, c, p, i, w): self.disrat = w dis = float(ASD(100) - ASD(self.disrat)) self.excamt = round((self.qty * self.exc * dis / 100.0), 2) self.incamt = round((self.qty * self.inc * dis / 100.0), 2) self.vatamt = float(ASD(self.incamt) - ASD(self.excamt)) self.df.loadEntry(frt, pag, p + 1, data=self.excamt) self.vattot = float(ASD(self.vattot) + ASD(self.vatamt)) self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt)) self.inctot = float(ASD(self.inctot) + ASD(self.incamt)) self.df.setViewPort("O", self.inctot) def doColEnd(self): # Create Purchase Order Transaction (Body) data = [ self.opts["conum"], self.ordno, self.grp, self.code, self.uoi, self.desc, self.qty, self.price, self.disrat, self.vatcod, self.vatrte, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strpot", data=data) if self.acttyp == "A": self.amend = True self.df.advanceLine(0) def doCrsQuery(self): callModule(self.opts["mf"], self.df, "cr4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def doStkQuery(self): callModule(self.opts["mf"], self.df, "st4010", coy=(self.opts["conum"], self.opts["conam"]), period=self.opts["period"], user=self.opts["capnm"]) def doDelAdd(self): tit = ("Delivery Address", ) fld = ((("T", 0, 0, 0), "INA", 30, "Address-1", "Address Line 1", "", "N", None, None, None, None), (("T", 0, 1, 0), "INA", 30, "Address-2", "Address Line 2", "", "N", None, None, None, None), (("T", 0, 2, 0), "INA", 30, "Address-3", "Address Line 3", "", "N", None, None, None, None), (("T", 0, 3, 0), "INA", 30, "Address-4", "Address Line 4", "", "N", None, None, None, None)) state = self.df.disableButtonsTags() self.da = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doDelEnd, "n"), ), txit=(self.doDelExit, ), focus=False) for x in range(0, len(self.deladd)): self.da.loadEntry("T", 0, 0 + x, data=self.deladd[x]) self.da.focusField("T", 0, 1, clr=False) self.da.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doDelEnd(self): self.deladd = [] for x in range(0, self.da.topq[0]): self.deladd.append(self.da.t_work[0][0][x]) self.doDelExit() def doDelExit(self): self.da.closeProcess() def doMessag(self): tit = ("Order Message", ) cod = { "stype": "R", "tables": ("ctlmes", ), "cols": [("mss_message", "", 0, "Cod"), ("mss_detail", "", 60, "Details")], "where": [("mss_system", "=", "STR")], "screen": self.df.mstFrame } fld = ((("T", 0, 0, 0), "IUI", 3, "Message Code", "", "", "N", self.doMesCod, cod, None, None), (("T", 0, 1, 0), "ITv", (30, 6), "Message", "", self.message, "N", None, None, None, None)) but = (("Accept", None, self.doMesEnd, 0, ("T", 0, 1), ("T", 0, 0)), ) state = self.df.disableButtonsTags() self.mg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doMesEnd, "n"), ), txit=(self.doMesExit, ), butt=but) self.mg.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doMesCod(self, frt, pag, r, c, p, i, w): if w: mess = self.sql.getRec("ctlmes", where=[("mss_system", "=", "STR"), ("mss_message", "=", w)], limit=1) if not mess: return "Invalid Message Code" self.message = mess[self.sql.ctlmse_col.index("mss_detail")] self.mg.loadEntry(frt, pag, p + 1, data=self.message) def doMesEnd(self): wid, self.message = self.mg.getEntry("T", 0, 1) self.doMesExit() def doMesExit(self): self.mg.closeProcess() def doEdit(self): # Display document items and allow editing of desc, qty and price recs = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if recs: data = [] for l in recs: qty = CCD(l[self.sql.strpot_col.index("pot_qty")], "SD", 11.2) prc = CCD(l[self.sql.strpot_col.index("pot_price")], "UD", 10.2) dis = CCD(l[self.sql.strpot_col.index("pot_disper")], "UD", 6.2) data.append([ l[self.sql.strpot_col.index("pot_group")], l[self.sql.strpot_col.index("pot_code")], l[self.sql.strpot_col.index("pot_desc")], qty.disp, l[self.sql.strpot_col.index("pot_vatcod")], prc.disp, dis.disp ]) head = ("Grp", "Product-Code", "Description", "Quantity", "V", "Price", "Disc-%") lin = { "stype": "C", "head": head, "typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 11.2), ("UA", 1), ("UD", 10.2), ("UD", 6.2)), "data": data } state = self.df.disableButtonsTags() chg = self.df.selChoice(lin) if chg and chg.selection: self.change = chg.selection self.doChanges() self.df.enableButtonsTags(state=state) self.df.focusField("C", 0, self.df.col) def doChanges(self): tit = ("Change Items", ) fld = ((("T", 0, 1, 0), "ONA", 3, "Group"), (("T", 0, 2, 0), "ONA", 20, "Code"), (("T", 0, 3, 0), "INA", 30, "Description", "", "", "N", self.doChgDes, None, None, ("notblank", )), (("T", 0, 4, 0), "ISD", 11.2, "Quantity", "", "", "N", self.doChgQty, None, None, ("notzero", )), (("T", 0, 5, 0), "IUD", 10.2, "Selling Price", "", "", "N", self.doChgPrc, None, None, ("notzero", )), (("T", 0, 6, 0), "IUD", 6.2, "Discount Percent", "", "", "N", self.doChgDis, None, None, ("efld", ))) but = (("Delete", None, self.doChgDel, 1, None, None), ) tnd = ((self.doChgEnd, "n"), ) txt = (self.doChgExit, ) self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=tnd, txit=txt) self.cg.loadEntry("T", 0, 0, data=self.change[0]) self.cg.loadEntry("T", 0, 1, data=self.change[1]) self.cg.loadEntry("T", 0, 2, data=self.change[2]) self.cg.loadEntry("T", 0, 3, data=self.change[3]) self.cg.loadEntry("T", 0, 4, data=self.change[5]) self.cg.loadEntry("T", 0, 5, data=self.change[6]) self.cg.focusField("T", 0, 3, clr=False) self.cg.mstFrame.wait_window() def doChgDes(self, frt, pag, r, c, p, i, w): self.desc = w def doChgQty(self, frt, pag, r, c, p, i, w): self.qty = w def doChgPrc(self, frt, pag, r, c, p, i, w): self.price = w def doChgDis(self, frt, pag, r, c, p, i, w): self.disrat = w def doChgDel(self): grp = self.change[0] cod = self.change[1] self.sql.delRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", grp), ("pot_code", "=", cod)]) if self.acttyp == "A": self.amend = True self.doChgExit(loader=True) def doChgEnd(self): grp = self.change[0] cod = self.change[1] col = ["pot_desc", "pot_qty", "pot_price", "pot_disper"] dat = [self.desc, self.qty, self.price, self.disrat] whr = [("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", grp), ("pot_code", "=", cod)] self.sql.updRec("strpot", cols=col, data=dat, where=whr) if self.acttyp == "A": self.amend = True self.doChgExit(loader=True) def doChgExit(self, loader=False): self.cg.closeProcess() if loader: self.doReadLoadStr() def doReprnt(self): tit = ("Reprint Orders", ) odr = { "stype": "R", "tables": ("strpom", "crsmst"), "cols": [("pom_ordno", "", 0, "Doc-Num"), ("pom_date", "", 0, "Date"), ("pom_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")], "where": [("pom_cono", "=", self.opts["conum"]), ("pom_cono=crm_cono", ), ("pom_acno=crm_acno", )], "screen": self.opts["mf"].body } r1s = (("Copies", "C"), ("Originals", "O")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Document Mode", "", "C", "N", self.doMode, None, None, None), (("T", 0, 1, 0), "IUI", 9, "From Number", "From Document Number", "", "N", self.doOrd, odr, None, ("notzero", )), [("T", 0, 2, 0), "IUI", 9, "To Number", "To Document Number", "", "N", None, odr, None, ("notzero", )]) state = self.df.disableButtonsTags() self.rp = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doReprntEnd, "n"), ), txit=(self.doReprntExit, ), view=("N", "V"), mail=("B", "Y")) self.rp.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doMode(self, frt, pag, r, c, p, i, w): if w == "C": self.copy = "y" else: self.copy = "n" def doOrd(self, frt, pag, r, c, p, i, w): self.rp.topf[pag][2][5] = w def doReprntEnd(self): self.rp.closeProcess() self.df.setWidget(self.df.mstFrame, state="hide") frm = self.rp.t_work[0][0][1] if not self.rp.t_work[0][0][2]: to = frm else: to = self.rp.t_work[0][0][2] odr = self.sql.getRec("strpom", cols=["pom_ordno"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", ">=", frm), ("pom_ordno", "<=", to)]) if odr: PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], odr, tname=self.tname, repprt=self.rp.repprt, repeml=self.rp.repeml, copy=self.copy) self.df.setWidget(self.df.mstFrame, state="show") def doReprntExit(self): self.rp.closeProcess() def doCrsMaint(self): state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="NewCrs") if cf.flag == "yes": callModule(self.opts["mf"], self.df, "cr1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doStrMaint(self): state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="NewStr") if cf.flag == "yes": callModule(self.opts["mf"], self.df, "st1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doAccept(self): self.df.setWidget(self.df.B11, "disabled") if self.df.col == 1: self.doCancel() else: # Update Tables self.doUpdateTables() # Commit Transaction self.opts["mf"].dbm.commitDbase() # Print Document if self.acttyp == "N" or (self.acttyp == "A" and self.amend): self.df.setWidget(self.df.mstFrame, state="hide") PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.ordno, tname=self.tname, repprt=self.pr.repprt, repeml=self.pr.repeml, copy=self.acttyp.lower()) self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField("T", 0, 1) def doRibbon(self): tit = ("Ribbon Line", ) fld = ((("T", 0, 0, 0), "INA", 30, "Customer Order", "", self.cnam, "N", None, None, None, None), (("T", 0, 1, 0), "INA", 30, "Job Number", "", self.cnam, "N", None, None, None, None), (("T", 0, 2, 0), "INA", 30, "Contact Person", "", self.cnam, "N", None, None, None, None), (("T", 0, 3, 0), "INA", 10, "VAT Number", "", self.vatn, "N", self.doVatNum, None, None, None)) state = self.df.disableButtonsTags() self.rb = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doRibEnd, "n"), ), txit=(self.doRibExit, ), focus=False) if self.ribbon: self.rb.loadEntry("T", 0, 0, data=self.ribbon[0]) self.rb.loadEntry("T", 0, 1, data=self.ribbon[1]) self.rb.loadEntry("T", 0, 2, data=self.ribbon[2]) self.rb.loadEntry("T", 0, 3, data=self.ribbon[3]) self.rb.focusField("T", 0, 1) self.rb.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doVatNum(self, frt, pag, r, c, p, i, w): if self.ordtot >= 1000.00 and not w: return "Invalid VAT Number" def doRibEnd(self): self.ribbon = [] for x in range(0, self.rb.topq[0]): self.ribbon.append(self.rb.t_work[0][0][x]) self.doRibExit() def doRibExit(self): self.rb.closeProcess() def doUpdateTables(self): # Update strpom with ribbon, delivery and message details whr = [("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)] if self.ribbon: self.sql.updRec( "strpom", cols=["pom_cusord", "pom_jobnum", "pom_contact", "pom_vatno"], data=[ self.ribbon[0], self.ribbon[1], self.ribbon[2], self.ribbon[3] ], where=whr) if not self.vatn: self.sql.updRec("crsmst", cols=["crm_vatno"], data=[self.ribbon[1]], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", self.acno)]) if self.deladd: self.sql.updRec( "strpom", cols=["pom_add1", "pom_add2", "pom_add3", "pom_add4"], data=[ self.deladd[0], self.deladd[1], self.deladd[2], self.deladd[3] ], where=whr) if self.message: self.sql.updRec("strpom", cols=["pom_mess"], data=[self.message], where=whr) if self.acttyp != "R": return # Receipt of Order # Create Stores Transactions and update strpot lines trn = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if not trn: return for line in trn: self.doExtData(line) curdt = int(self.deldt / 100) # Update strpom record self.sql.updRec("strpom", cols=["pom_delno", "pom_deldt"], data=[self.delno, self.deldt], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno)]) # Write strtrn record data = [ self.opts["conum"], self.grp, self.code, self.loc, self.deldt, 1, self.othno, self.batch, self.delno, self.qty, self.excamt, 0, curdt, self.name, 0, self.acno, "", "STR", self.disrat, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) # If Integrated Create GL Transaction (SOH and Recon Accounts) if self.stgl == "Y" and self.excamt: # Stock on Hand Control data = (self.opts["conum"], self.soh, curdt, self.deldt, 5, self.othno, self.batch, self.excamt, 0, self.name, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) cst = float(ASD(0) - ASD(self.excamt)) # Stock Reconciliation Control data = (self.opts["conum"], self.ssp, curdt, self.deldt, 5, self.othno, self.batch, cst, 0, self.name, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def doExtData(self, line): self.grp = line[self.sql.strpot_col.index("pot_group")] self.code = line[self.sql.strpot_col.index("pot_code")] self.uoi = line[self.sql.strpot_col.index("pot_uoi")] self.desc = line[self.sql.strpot_col.index("pot_desc")] self.qty = line[self.sql.strpot_col.index("pot_qty")] self.price = line[self.sql.strpot_col.index("pot_price")] self.disrat = line[self.sql.strpot_col.index("pot_disper")] self.vatcod = line[self.sql.strpot_col.index("pot_vatcod")] self.vatrte = line[self.sql.strpot_col.index("pot_vatrat")] # Calculate Values rat = float(ASD(100) + ASD(self.vatrte)) inc = round((self.price * rat / 100.0), 4) exc = round((self.price * 1), 2) dis = float(ASD(100) - ASD(self.disrat)) self.excamt = round((self.qty * exc * dis / 100.0), 2) self.incamt = round((self.qty * inc * dis / 100.0), 2) self.vatamt = float(ASD(self.incamt) - ASD(self.excamt)) def doCancel(self): self.opts["mf"].dbm.rollbackDbase() if self.acttyp == "N": self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1)
class ml2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): # Check for Valid Posting Routine if self.opts["rtn"] not in (1, 2, 3, 4): showError(self.opts["mf"].body, "Control Error", "Invalid Routine %s, Only 1-4 Are Allowed" % \ str(self.opts["rtn"])) return tabs = ["ctlvmf", "ctlvrf", "ctlvtf", "memmst", "memtrn"] self.gc = GetCtl(self.opts["mf"]) memctl = self.gc.getCtl("memctl", self.opts["conum"]) if not memctl: return self.glint = memctl["mcm_glint"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["mem_ctl", "vat_ctl", "dis_all"] if self.gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.memctl = ctlctl["mem_ctl"] self.dis_all = ctlctl["dis_all"] tabs.extend(["gentrn", "genmst"]) # Create SQL Object 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"], "MEM", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if self.opts["rtn"] == 1: self.glt = 1 elif self.opts["rtn"] == 2: self.glt = 2 elif self.opts["rtn"] == 3: self.glt = 4 elif self.opts["rtn"] == 4: self.glt = 1 self.agevar = tk.BooleanVar() self.agevar.set(False) return True def drawDialog(self): mlm = { "stype": "R", "tables": ("memmst", ), "cols": (("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"), ("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"), ("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0, "Names", "F")), "where": [("mlm_cono", "=", self.opts["conum"])], "order": "mlm_surname, mlm_names", "sort": False } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_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"])] } fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N", self.doMemAcc, mlm, None, ("notzero", )), [("C", 1, 0, 1), "ONA", 10, "Name"], (("C", 1, 0, 2), "INa", 9, "Reference", "Reference Number One", "i", "N", self.doRefno, None, None, ("notblank", )), (("C", 1, 0, 3), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 4), "ISD", 13.2, "Amount", "Transaction Amount", "", "N", self.doTrnAmt, None, None, ("efld", ))] if self.opts["rtn"] == 2: fld[3][2] = 20 fld.extend([ (("C", 1, 0, 5), "ISD", 13.2, "Discount", "Discount Amount", "", "N", self.doDisAmt, None, None, None, None, "Discount Amount to be Added to the Transaction Amount."), (("C", 1, 0, 6), "OSD", 13.2, "Total-Amount"), (("C", 1, 0, 7), "INA", (20, 30), "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None) ]) elif self.glint == "Y": fld[3][2] = 24 fld.extend([ (("C", 1, 0, 5), "INA", 30, "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None), (("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"), (("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doGenAcc, glm, None, None), (("C", 2, 0, 1), "ONA", 19, "Description"), (("C", 2, 0, 2), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N", self.doVatCode2, vtm, None, ("notblank", )), (("C", 2, 0, 3), "ISD", 13.2, "All-Amt", "Allocation Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 4), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N", self.doAllVat, None, None, None), (("C", 2, 0, 5), "INA", (26, 30), "Details", "", "", "N", self.doAllDet, None, None, ("notblank", )) ]) else: fld[3][2] = 22 fld.extend([ (("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N", self.doVatCode1, vtm, None, ("notblank", )), (("C", 1, 0, 7), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N", self.doVatAmt, None, None, None), (("C", 1, 0, 8), "INA", (20, 30), "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None) ]) but = ( ("Age _Normal",None,self.doAgeNormal,0,None,None, "Only Show Unallocated Transactions",1), ("Age _History",None,self.doAgeHistory,0,None,None, "Show All Transactions Including Already Allocated",1), ("Age _Automatic",None,self.doAgeAuto,0,None,None, "Automatically Allocate the Amount Starting With the "\ "Oldest Unallocated One",1), ("Age _Current",None,self.doAgeCurrent,0,None,None, "Leave the Transaction Unallocated",1), ("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1)) tag = [("Transaction", None, None, None, False)] cnd = [(None, "n"), (self.endPage1, "y")] cxt = [None, self.exitPage1] if self.opts["rtn"] != 2 and self.glint == "Y": tag.append(("Allocation", None, None, None, False)) cnd.append((self.endPage2, "y")) cxt.append(self.exitPage2) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doMemAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("memmst", cols=["mlm_title", "mlm_initial", "mlm_surname"], where=[("mlm_cono", "=", self.opts["conum"]), ("mlm_memno", "=", w)], limit=1) if not acc: return "Invalid Member Number" self.memno = w self.name = "%s, %s %s" % (acc[2], acc[0], acc[1]) self.df.loadEntry("C", pag, p + 1, data=self.name) def doRefno(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("memtrn", cols=["mlt_batch"], where=[("mlt_cono", "=", self.opts["conum"]), ("mlt_memno", "=", self.memno), ("mlt_type", "=", self.opts["rtn"]), ("mlt_refno", "=", w)], limit=1) if acc: return "Transaction Already Exists" self.refno = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if w > mthendDate(self.bh.curdt * 100): return "Invalid Date, After Batch Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w if self.glint == "Y" or self.opts["rtn"] == 2: self.vatcode = "N" self.vatamt = 0 def doVatCode1(self, frt, pag, r, c, p, i, w): vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if vrte is None: return "Invalid V.A.T Code" self.vatcode = w self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p + 1, self.vatamt) if not self.vatamt: return "sk1" def doVatAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.vatamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.vatamt = float(ASD(0) - ASD(w)) else: self.vatamt = w self.df.loadEntry(frt, pag, p, data=self.vatamt) def doDisAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.disamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.disamt = float(ASD(0) - ASD(w)) else: self.disamt = w self.df.loadEntry(frt, pag, p, data=self.disamt) totamt = float(ASD(self.trnamt) + ASD(self.disamt)) self.df.loadEntry(frt, pag, p + 1, data=totamt) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.opts["rtn"] != 2 and self.glint == "Y": self.df.colf[2][5][5] = w self.allocated = float(0.00) def endPage1(self): self.cancel = False self.agecan = False self.batupd = False self.updateTables1() if self.cancel: return else: self.updateBatch() if self.trnamt == 0: self.df.advanceLine(1) else: self.allocated = float(0.0) if self.opts["rtn"] == 2 or self.glint == "N": self.doMemTrn() self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.df.selPage("Allocation") self.df.loadEntry("T", 2, 0, data=self.trnamt) self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt self.amt = self.trnamt self.vat = self.vatamt if self.opts["rtn"] == 1: # Invoices recon = 0 self.dis = 0.00 elif self.opts["rtn"] == 2: # Payment if self.trnamt == 0: recon = self.curdt else: recon = 0 self.vat = 0.00 self.dis = self.disamt elif self.opts["rtn"] == 3: # Journal recon = 0 self.dis = 0.00 elif self.opts["rtn"] == 4: # Credit Note recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.dis = 0.00 if self.opts["rtn"] == 1: self.ageloop = False self.doAgeCurrent() else: state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Choose an Ageing Option") for x in range(0, 4): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "normal") self.df.setWidget(self.df.B0, "focus") self.agevar.set(True) self.df.mstFrame.wait_variable(self.agevar) self.df.enableButtonsTags(state=state) if self.agecan: self.doCancel() return if self.glint == "N": return # General Ledger Control Transaction (Members) val = float(ASD(self.amt) + ASD(self.dis)) data = (self.opts["conum"], self.memctl, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Bank) if self.opts["rtn"] == 2: val = float(ASD(0) - ASD(self.amt)) data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Discount) if self.dis: val = float(ASD(0) - ASD(self.dis)) data = (self.opts["conum"], self.dis_all, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, val, 0.00, self.trndet, "N", "", recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def doAgeNormal(self): self.doAgeing("N") def doAgeHistory(self): self.doAgeing("H") def doAgeAuto(self): self.doAgeing("O") def doAgeCurrent(self): self.doAgeing("C") def doAgeing(self, atype): # Disable All Ageing Buttons for x in range(0, 4): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") self.opts["mf"].updateStatus("Select Transaction to Allocate Against") age = AgeAll(self.opts["mf"], system="mem", agetyp=atype, agekey=[ self.opts["conum"], self.memno, self.opts["rtn"], self.refno, self.curdt, self.amt, self.dis ]) self.agecan = age.cancel if self.agevar.get(): self.agevar.set(False) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def 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 if not chk[2]: self.taxgl = self.taxdf else: self.taxgl = chk[2] self.genacc = w self.df.loadEntry("C", pag, p + 1, data=chk[0]) self.df.loadEntry("C", pag, p + 2, data=self.taxgl) def doVatCode2(self, frt, pag, r, c, p, i, w): ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"], error=False) if not ctlctl: return "Missing ctlctl Record for Company" if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]): return "Missing or Invalid Control Record" self.convat = ctlctl["vat_ctl"] self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if self.vatrte is None: return "Invalid V.A.T Code" self.vatcode = w def doAllAmt(self, frt, pag, r, c, p, i, w): if w == 0: allamt = float(ASD(self.trnamt) - ASD(self.allocated)) self.allamt = round((allamt * 100 / (100 + self.vatrte)), 2) self.df.loadEntry(frt, pag, p, data=self.allamt) self.allvat = float(ASD(allamt) - ASD(self.allamt)) else: self.allamt = w self.allvat = round((self.allamt * self.vatrte / 100), 2) self.df.loadEntry(frt, pag, p + 1, data=self.allvat) if not self.allvat: self.df.loadEntry(frt, pag, p + 2, data=self.name) return "sk1" def doAllVat(self, frt, pag, r, c, p, i, w): if self.allamt < 0 and w > 0: self.allvat = float(ASD(0) - ASD(w)) elif self.allamt > 0 and w < 0: self.allvat = float(ASD(0) - ASD(w)) else: self.allvat = w self.df.loadEntry(frt, pag, p, data=self.allvat) self.df.loadEntry(frt, pag, p + 1, data=self.name) def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): if self.agecan: ok = "yes" else: ok = askQuestion( self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.cancel = True self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) if self.glint == "Y": self.df.clearFrame("C", 2) row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.selPage("Transaction") self.df.focusField("C", 1, col) def endPage2(self): self.updateTables2() self.allocated = float(ASD(self.allocated) + \ ASD(self.allamt) + ASD(self.allvat)) if self.allocated == self.trnamt: self.doMemTrn() self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt if self.opts["rtn"] == 1: # Invoices self.credit() elif self.opts["rtn"] == 3: # Journal Entry self.credit() elif self.opts["rtn"] == 4: # Credit Notes self.debit() def debit(self): amt = self.allamt vat = self.allvat self.restDebitCredit(amt, vat) def credit(self): amt = float(ASD(0) - ASD(self.allamt)) vat = float(ASD(0) - ASD(self.allvat)) self.restDebitCredit(amt, vat) def restDebitCredit(self, amt, vat): # VAT Transaction (ctlvtf) data = (self.opts["conum"], self.vatcode, "O", self.curdt, "M", self.glt, self.bh.batno, self.refno, self.trndat, self.memno, self.alldet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return # General Ledger Transaction (Expense) data = (self.opts["conum"], self.genacc, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, amt, vat, self.alldet, self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if vat: # General Ledger Control Transaction (V.A.T.) data = (self.opts["conum"], self.convat, self.curdt, self.trndat, self.glt, self.refno, self.bh.batno, vat, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) vat = float(ASD(0) - ASD(vat)) self.vat += vat def exitPage2(self): self.df.focusField("C", 2, self.df.col) def doMemTrn(self): # Members Ledger Transaction data = [ self.opts["conum"], self.memno, self.opts["rtn"], self.refno, self.bh.batno, self.trndat, self.amt, self.vat, self.curdt, "", 0, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("memtrn", data=data) if self.dis: data = [ self.opts["conum"], self.memno, 6, self.refno, self.bh.batno, self.trndat, self.dis, self.vat, self.curdt, "", 0, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("memtrn", data=data, unique="mlt_refno") def updateBatch(self, rev=False): if rev: self.bh.batqty -= 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.batupd = True self.bh.batqty += 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval)
class cr2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): # Check for Valid Posting Routine if self.opts["rtn"] not in (1, 2, 3, 4, 5): showError(self.opts["mf"].body, "Control Error", "Invalid Routine %s, Only 1 - 5 Are Allowed" % \ str(self.opts["rtn"])) return # Create SQL Object self.sql = Sql(self.opts["mf"].dbm, [ "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "crsmst", "crstrn", "genint", "genmst", "gentrn", "lonmf1", "lonmf2", "lonrte", "lontrn", "wagedc", "wagmst", "waglmf", "wagltf" ], prog=self.__class__.__name__) if self.sql.error: return # Check for Company record self.gc = GetCtl(self.opts["mf"]) self.allcoy = self.opts["conum"] self.allnam = self.opts["conam"] ctlmst = self.gc.getCtl("ctlmst", self.allcoy) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] # Check for Intercompany Facility if not self.sql.getRec("ctlmst", cols=["count(*)"], where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]: self.incoac = False else: rec = self.sql.getRec("genint", cols=["cti_inco"], where=[("cti_cono", "=", self.opts["conum"]) ]) if rec: self.incoac = [self.opts["conum"]] [self.incoac.append(coy[0]) for coy in rec] else: self.incoac = False # Get Enabled Modules self.lonmod = False self.lonpag = None self.slnmod = False self.slnpag = None for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): if ctlmst["ctm_modules"][x:x + 2] == "LN": self.lonmod = True elif ctlmst["ctm_modules"][x:x + 2] == "SL": self.slnmod = True # Rest of Controls crsctl = self.gc.getCtl("crsctl", self.opts["conum"]) if not crsctl: return self.glint = crsctl["ctc_glint"] self.glinp = crsctl["ctc_glinp"] if self.glint == "Y": self.ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not self.ctlctl: return ctls = ["crs_ctl", "vat_ctl", "dis_rec"] if self.gc.chkRec(self.opts["conum"], self.ctlctl, ctls): return self.crsctl = self.ctlctl["crs_ctl"] self.disrec = self.ctlctl["dis_rec"] # Batch Header self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] if self.opts["rtn"] == 1: self.glt = 5 elif self.opts["rtn"] == 2: self.glt = 6 elif self.opts["rtn"] == 3: self.glt = 4 elif self.opts["rtn"] == 4: self.glt = 5 elif self.opts["rtn"] == 5: self.glt = 2 self.agevar = tk.BooleanVar() self.othvar = tk.BooleanVar() self.agevar.set(False) self.othvar.set(False) return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "CRS", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return def drawDialog(self): crm = { "stype": "R", "tables": ("crsmst", ), "cols": (("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")), "where": [("crm_cono", "=", self.opts["conum"]), ("crm_stat", "<>", "X")] } coy = { "stype": "R", "tables": ("ctlmst", ), "cols": (("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y")) } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "whera": [("C", "glm_cono", 0, 2)] } vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } if self.opts["rtn"] in (1, 4) and self.lonmod: lm1 = { "stype": "R", "tables": ("lonmf1", ), "cols": (("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")), "whera": [("C", "lm1_cono", 0, 2)] } lm2 = { "stype": "R", "tables": ("lonmf2", ), "cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0, "Description", "Y")), "whera": [("C", "lm2_cono", 0, 2), ("C", "lm2_acno", 0)] } if self.opts["rtn"] in (1, 4) and self.slnmod: wgm = { "stype": "R", "tables": ("wagmst", ), "cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0, "Names")), "whera": [("C", "wgm_cono", 0, 2)] } lnm = { "stype": "R", "tables": ("waglmf", ), "cols": (("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0, "Description", "Y")), "where": [("wlm_cono", "=", self.opts["conum"])], "whera": [("C", "wgm_cono", 0, 2), ("C", "wlm_empno", 0)] } ced = { "stype": "R", "tables": ("wagedc", ), "cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"), ("ced_desc", "", 0, "Description", "Y")), "where": [("ced_type", "=", "D")], "whera": [("C", "wgm_cono", 0, 2)], "index": 1 } viw = { "stype": "R", "tables": ("crstrn", ), "cols": (("crt_acno", "", 0, ""), ("crt_ref1", "", 0, ""), ("crt_trdt", "", 0, ""), ("crt_tramt", "", 0, ""), ("crt_taxamt", "", 0, "")), "where": [("crt_cono", "=", self.opts["conum"]), ("crt_type", "=", self.opts["rtn"]), ("crt_batch", "=", self.bh.batno)], "order": "crt_seq", "comnd": self.doView } fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "INA", 7, "Acc-Num", "Account Number", "r", "Y", self.doCrsAcc, crm, None, None), [("C", 1, 0, 1), "ONA", 10, "Name"], (("C", 1, 0, 2), "INa", 9, "Reference", "Reference Number One", "i", "N", self.doRef1, None, None, ("notblank", )), (("C", 1, 0, 3), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 4), "ISD", 13.2, "Amount", "Transaction Amount", "", "N", self.doTrnAmt, None, None, None)] if self.opts["rtn"] in (2, 5): fld[3][2] = 22 fld.extend([ (("C", 1, 0, 5), "ISD", 13.2, "Discount", "Discount Amount", "", "N", self.doDisAmt, None, None, None, None, "Discount Amount to be Added to the Transaction Amount."), (("C", 1, 0, 6), "OSD", 13.2, "Total-Amount"), [("C", 1, 0, 7), "INA", (22, 30), "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None] ]) elif self.glint == "Y": if self.glinp == "E": tx1 = "Exc-Amount" tx2 = "Exclusive Amount" else: tx1 = "Inc-Amount" tx2 = "Inclusive Amount" fld[3][2] = 30 fld.extend([(("C", 1, 0, 5), "INA", (27, 30), "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None), [("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"], [("C", 2, 0, 0), "IUI", 3, "Coy", "Company Number", self.opts["conum"], "N", self.doCoyNum, coy, None, None], (("C", 2, 0, 1), "IUI", 7, "Acc-Num", "Account Number", "", "N", self.doGenAcc, glm, None, None), (("C", 2, 0, 2), "ONA", 19, "Description"), (("C", 2, 0, 3), "IUA", 1, "V", "V.A.T Code", "", "N", self.doVatCode2, vtm, None, ("notblank", )), (("C", 2, 0, 4), "ISD", 13.2, tx1, tx2, "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 5), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N", self.doAllVat, None, None, None), (("C", 2, 0, 6), "INA", (26, 30), "Details", "", "", "N", self.doAllDet, None, None, ("notblank", ))]) if not self.incoac: fld[9][1] = "OUI" nxt = 3 if self.opts["rtn"] in (1, 4) and self.lonmod: fld.extend([ (("T", nxt, 0, 0), "OSD", 13.2, "Unallocated Balance"), (("C", nxt, 0, 0), "IUA", 7, "Acc-Num", "Account Number", 0, "N", self.doLonAcc, lm1, None, None), (("C", nxt, 0, 1), "ONA", 30, "Name"), (("C", nxt, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N", self.doLonNum, lm2, None, None), (("C", nxt, 0, 3), "INA", 30, "Description", "", "", "N", self.doLonDes, None, None, ("notblank", )), (("C", nxt, 0, 4), "ISD", 13.2, "Amount", "", "", "N", self.doLonAmt, None, None, ("efld", )), (("C", nxt, 0, 5), "IUD", 6.2, "DRte-%", "Debit Rate", "", "N", self.doLonDri, None, None, None), (("C", nxt, 0, 6), "IUD", 6.2, "CRte-%", "Credit Rate", "", "N", self.doLonDri, None, None, None), (("C", nxt, 0, 7), "IUI", 3, "Mth", "Period in Months", "", "N", self.doLonMth, None, None, ("efld", )), (("C", nxt, 0, 8), "OUD", 12.2, "Repayment") ]) self.lonpag = nxt nxt += 1 if self.opts["rtn"] in (1, 4) and self.slnmod: fld.extend([ (("T", nxt, 0, 0), "OSD", 13.2, "Unallocated Balance"), (("C", nxt, 0, 0), "IUI", 5, "EmpNo", "Employee Number", 0, "N", self.doEmpNum, wgm, None, None), (("C", nxt, 0, 1), "ONA", 20, "Name"), (("C", nxt, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N", self.doSlnNum, lnm, None, None), (("C", nxt, 0, 3), "INA", 20, "Description", "", "", "N", self.doSlnDes, None, None, ("notblank", )), (("C", nxt, 0, 4), "ISD", 13.2, "Amount", "", "", "N", self.doSlnAmt, None, None, ("efld", )), (("C", nxt, 0, 5), "IUI", 3, "Cde", "Deduction Code", "", "N", self.doSlnCod, ced, None, ("efld", )), (("C", nxt, 0, 6), "ONA", 20, "Description"), (("C", nxt, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate", "", "N", self.doSlnInt, None, None, None), (("C", nxt, 0, 8), "IUD", 13.2, "Ded-Amt", "Deduction Amount", "", "N", self.doSlnDed, None, None, ("efld", )) ]) self.slnpag = nxt else: fld[3][2] = 20 fld.extend([(("C", 1, 0, 5), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N", self.doVatCode1, vtm, None, ("notblank", )), (("C", 1, 0, 6), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N", self.doVatAmt, None, None, None), [("C", 1, 0, 7), "INA", (18, 30), "Details", "Transaction Details", "", "N", self.doTrnDet, None, None, None]]) but = ( ("Interrogate",None,self.queryCrs,0,("C",1,1),("C",1,2), "Interrogate Creditors Records",1), ("View Entries",viw,None,0,("C",1,1),("C",1,2), "View Batch Transactions",1), ("Maintain",None,self.maintainCrs,0,("C",1,1),("C",1,2), "Maintain Creditors Records",1), ("Canc_el",None,self.doCancel,0,("C",2,1),("C",1,1), "Cancel the Entry",1), ("Age _Normal",None,self.doAgeNormal,0,None,None, "Only Show Unallocated Transactions",2), ("Age _History",None,self.doAgeHistory,0,None,None, "Show All Transactions Including Already Allocated",2), ("Age _Automatic",None,self.doAgeAuto,0,None,None, "Automatically Allocate the Amount Starting With the "\ "Oldest Unallocated Transaction",2), ("Age _Current",None,self.doAgeCurrent,0,None,None, "Leave the Transaction Unallocated",2)) tag = [("Transaction", None, None, None, False)] cnd = [(None, "n"), (self.endPage1, "y")] cxt = [None, self.exitPage1] if self.opts["rtn"] not in (2, 5) and self.glint == "Y": tag.append(("Allocation", None, None, None, False)) cnd.append((self.endPage2, "y")) cxt.append(self.exitPage2) if self.opts["rtn"] in (1, 4) and self.lonmod: tag.append(("LON", None, None, None, False)) cnd.append((self.endLon, "y")) cxt.append(self.exitLon) if self.opts["rtn"] in (1, 4) and self.slnmod: tag.append(("SLN", None, None, None, False)) cnd.append((self.endSln, "y")) cxt.append(self.exitSln) self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doView(self, *event): self.df.focusField("C", 1, 1) def doCrsAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("crsmst", cols=[ "crm_name", "crm_terms", "crm_vatno", "crm_termsb", "crm_stday", "crm_pydis", "crm_glac", "crm_stat" ], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[7] == "X": return "Invalid Account, Redundant" self.cracno = w self.name = acc[0] self.term = acc[1] self.vatn = acc[2] self.base = acc[3] self.stdt = acc[4] self.pdis = acc[5] self.glac = acc[6] self.popv = False self.df.loadEntry(frt, pag, p + 1, data=self.name) def doRef1(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("crstrn", cols=["crt_batch"], where=[("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=", self.cracno), ("crt_type", "=", self.opts["rtn"]), ("crt_ref1", "=", w)], limit=1) if acc: return "Transaction Already Exists" self.trnref = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w if self.glint == "Y" or self.opts["rtn"] in (2, 5): self.vatcode = "N" self.vatamt = 0 if self.opts["rtn"] not in (2, 5) and self.glint == "N": if not self.vatn: self.df.loadEntry(frt, pag, p + 1, data="N") else: self.df.loadEntry(frt, pag, p + 1, data=self.taxdf) def doVatCode1(self, frt, pag, r, c, p, i, w): vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat) if vrte is None: return "Invalid V.A.T Code" if vrte and not self.vatn: ok = askQuestion(self.opts["mf"].window, "VAT Number", "This Account Does Not Have a VAT Number.\n\nMust "\ "it be Populated?", default="yes") if ok == "yes": self.vatn = w self.popv = True self.vatcode = w self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2) self.df.loadEntry(frt, pag, p + 1, data=self.vatamt) if not self.vatamt: return "sk1" def doVatAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.vatamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.vatamt = float(ASD(0) - ASD(w)) else: self.vatamt = w self.df.loadEntry(frt, pag, p, data=self.vatamt) def doDisAmt(self, frt, pag, r, c, p, i, w): if self.trnamt < 0 and w > 0: self.disamt = float(ASD(0) - ASD(w)) elif self.trnamt > 0 and w < 0: self.disamt = float(ASD(0) - ASD(w)) else: self.disamt = w self.df.loadEntry(frt, pag, p, data=self.disamt) totamt = float(ASD(self.trnamt) + ASD(self.disamt)) self.df.loadEntry(frt, pag, p + 1, data=totamt) def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w if self.opts["rtn"] not in (2, 5) and self.glint == "Y": self.df.colf[2][6][5] = w self.allocated = float(0.00) def endPage1(self): self.cancel = False self.agecan = False self.batupd = False self.updateTables1() if self.cancel: return else: self.updateBatch() if self.trnamt == 0: self.df.advanceLine(1) else: self.allocated = float(0.0) if self.opts["rtn"] in (2, 5) or self.glint == "N": self.doCrsTrn() self.opts["mf"].dbm.commitDbase() self.df.selPage("Transaction") self.df.advanceLine(1) else: self.df.selPage("Allocation") self.df.loadEntry("T", 2, 0, data=self.trnamt) self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt self.amt = self.trnamt self.vat = self.vatamt if self.opts["rtn"] == 1: # Invoices self.recon = 0 self.dis = 0.00 self.per = self.pdis elif self.opts["rtn"] == 2: # Receipts if self.trnamt == 0: self.recon = self.curdt else: self.recon = 0 self.vat = 0.00 self.dis = self.disamt self.per = 0.00 elif self.opts["rtn"] == 3: # Journals self.recon = 0 self.dis = 0.00 self.per = 0.00 elif self.opts["rtn"] == 4: # Credit Notes self.recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.vat = float(ASD(0) - ASD(self.vat)) self.dis = 0.00 self.per = self.pdis elif self.opts["rtn"] == 5: # Payments if self.trnamt == 0: self.recon = self.curdt else: self.recon = 0 self.amt = float(ASD(0) - ASD(self.amt)) self.vat = 0.00 self.dis = float(ASD(0) - ASD(self.disamt)) self.per = 0.00 if self.opts["rtn"] == 1: self.doAgeCurrent() else: state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Choose an Ageing Option") for x in range(4, 8): if self.opts["rtn"] == 3 and x == 6: continue wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "normal") self.df.setWidget(self.df.B4, "focus") self.agevar.set(True) self.df.mstFrame.wait_variable(self.agevar) self.df.enableButtonsTags(state=state) if self.agecan: self.doCancel() return if self.glint == "N": return # General Ledger Control Transaction (Creditors) val = float(ASD(0) - ASD(self.amt) - ASD(self.dis)) data = (self.opts["conum"], self.crsctl, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, val, 0.00, self.trndet, "N", "", self.recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Bank) if self.opts["rtn"] in (2, 5): data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.amt, 0.00, self.trndet, "N", "", self.recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Discount) if self.dis: data = (self.opts["conum"], self.disrec, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, self.dis, 0.00, self.trndet, "N", "", self.recon, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def doAgeNormal(self): self.doAgeing("N") def doAgeHistory(self): self.doAgeing("H") def doAgeAuto(self): self.doAgeing("O") def doAgeCurrent(self): self.doAgeing("C") def doAgeing(self, atype): # Disable All Ageing Buttons for x in range(4, 8): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") self.opts["mf"].updateStatus("Select Transaction to Allocate Against") age = AgeAll(self.opts["mf"], system="crs", agetyp=atype, agekey=[ self.opts["conum"], self.cracno, self.opts["rtn"], self.trnref, self.curdt, self.amt, self.dis ]) self.agecan = age.cancel if self.agevar.get(): self.agevar.set(False) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doCoyNum(self, frt, pag, r, c, p, i, w): nam = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", w)], limit=1) if not nam: return "Invalid Company, Missing" if self.incoac and w not in self.incoac: return "Invalid Company, No Intercompany Record 1" if w != self.opts["conum"]: acc = self.sql.getRec("genint", where=[("cti_cono", "=", w), ("cti_inco", "=", self.opts["conum"]) ], limit=1) if not acc: return "Invalid Company, No Intercompany Record 2" self.ctlctl = self.gc.getCtl("ctlctl", w) if not self.ctlctl: return "rf" self.allcoy = w self.allnam = nam[0] self.df.loadEntry(frt, pag, p + 1, data=self.glac) def doGenAcc(self, frt, pag, r, c, p, i, w): ctl = True self.loan = False if "lon_ctl" in self.ctlctl and w == self.ctlctl["lon_ctl"]: self.loan = "other" elif "wag_slc" in self.ctlctl and w == self.ctlctl["wag_slc"]: self.loan = "staff" if self.loan: ctl = False chk = chkGenAcc(self.opts["mf"], self.allcoy, w, ctl=ctl) if type(chk) is str: return chk if not self.vatn: self.taxgl = "N" elif not chk[2]: self.taxgl = self.taxdf else: self.taxgl = chk[2] self.genacc = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) self.df.loadEntry(frt, pag, p + 2, data=self.taxgl) def doVatCode2(self, frt, pag, r, c, p, i, w): ctlctl = self.gc.getCtl("ctlctl", self.allcoy, error=False) if not ctlctl: return "Missing ctlctl Record for Company" if self.gc.chkRec(self.allcoy, ctlctl, ["vat_ctl"]): return "Missing or Invalid Control Record" self.convat = ctlctl["vat_ctl"] self.vatrte = getVatRate(self.sql, self.allcoy, w, self.trndat) if self.vatrte is None: return "Invalid V.A.T Code" if self.vatrte and not self.vatn: ok = askQuestion(self.opts["mf"].window, "VAT Number", "This Account Does Not Have a VAT Number.\n\nMust "\ "it be Populated?", default="yes") if ok == "yes": self.vatn = w self.popv = True self.vatcode = w def doAllAmt(self, frt, pag, r, c, p, i, w): if not w: incamt = float(ASD(self.trnamt) - ASD(self.allocated)) elif self.glinp == "E": incamt = round((w * (100 + self.vatrte) / 100), 2) else: incamt = w self.allamt = round((incamt * 100 / (100 + self.vatrte)), 2) self.allvat = float(ASD(incamt) - ASD(self.allamt)) if self.glinp == "E": self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.df.loadEntry(frt, pag, p, data=incamt) self.df.loadEntry(frt, pag, p + 1, data=self.allvat) if not self.allvat: self.df.loadEntry(frt, pag, p + 2, data=self.name) return "sk1" def doAllVat(self, frt, pag, r, c, p, i, w): if (self.allamt < 0 and w > 0) or (self.allamt > 0 and w < 0): w = float(ASD(0) - ASD(w)) if self.glinp == "I" and w != self.allvat: self.allamt = float(ASD(self.allamt) + ASD(self.allvat) - ASD(w)) self.allvat = w self.df.loadEntry(frt, pag, p, data=self.allvat) self.df.loadEntry(frt, pag, p + 1, data=self.name) def doAllDet(self, frt, pag, r, c, p, i, w): self.alldet = w def doCancel(self): if self.agecan: ok = "yes" else: ok = askQuestion( self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.cancel = True self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) for pg in range(self.df.pgs, 1, -1): self.df.clearFrame("C", pg) self.df.selPage("Transaction") row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.focusField("C", 1, col) if self.othvar.get(): self.othvar.set(False) def endPage2(self): self.updateTables2() if self.loan and self.loan == "other": self.othtot = self.allamt self.df.selPage("LON") self.df.loadEntry("T", self.lonpag, 0, data=self.othtot) self.df.focusField("C", self.lonpag, 1) self.othvar.set(True) self.df.mstFrame.wait_variable(self.othvar) if self.cancel: return elif self.loan and self.loan == "staff": self.othtot = self.allamt self.df.selPage("SLN") self.df.loadEntry("T", self.slnpag, 0, data=self.othtot) self.df.focusField("C", self.slnpag, 1) self.othvar.set(True) self.df.mstFrame.wait_variable(self.othvar) if self.cancel: return self.allocated = float(ASD(self.allocated) + ASD(self.allamt) + \ ASD(self.allvat)) if self.allocated == self.trnamt: self.doCrsTrn() self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Transaction") self.df.advanceLine(1) else: bal = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def updateTables2(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt if self.opts["rtn"] == 1: # Invoices self.debit() elif self.opts["rtn"] == 3: # Journals self.debit() elif self.opts["rtn"] == 4: # Credit Notes self.credit() def debit(self): amt = self.allamt vat = self.allvat self.restDebitCredit(amt, vat) def credit(self): amt = float(ASD(0) - ASD(self.allamt)) vat = float(ASD(0) - ASD(self.allvat)) self.restDebitCredit(amt, vat) def restDebitCredit(self, amt, vat): # VAT Transaction (ctlvtf) data = (self.allcoy, self.vatcode, "I", self.curdt, "C", self.opts["rtn"], self.bh.batno, self.trnref, self.trndat, self.cracno, self.alldet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) if self.glint == "N": return # General Ledger Transaction (Expense) data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, amt, vat, self.alldet, self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany) if self.allcoy != self.opts["conum"]: # General Ledger Transaction (Intercompany From) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=", self.allcoy)], limit=1)[0] val = float(ASD(amt) + ASD(vat)) data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany To) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.allcoy), ("cti_inco", "=", self.opts["conum"]) ], limit=1)[0] val = float(ASD(0) - ASD(amt) - ASD(vat)) data = (self.allcoy, acc, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, val, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if vat: # General Ledger Control Transaction (V.A.T.) data = (self.allcoy, self.convat, self.curdt, self.trndat, self.glt, self.trnref, self.bh.batno, vat, 0.00, self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) self.vat = float(ASD(self.vat) + ASD(vat)) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def doCrsTrn(self): # Creditors Master File if self.popv: self.sql.updRec("crsmst", cols=["crm_vatno"], data=["Unknown"], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", self.cracno)]) # Creditors Ledger Transaction paydt = paymentDate(self.base, self.stdt, self.term, self.trndat) data = [ self.opts["conum"], self.cracno, self.opts["rtn"], self.trnref, self.bh.batno, self.trndat, "", self.amt, self.vat, self.per, self.curdt, paydt, "Y", self.amt, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("crstrn", data=data) if not self.dis: return data = [ self.opts["conum"], self.cracno, 6, self.trnref, self.bh.batno, self.trndat, "", self.dis, self.vat, 0, self.curdt, paydt, "Y", self.dis, self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("crstrn", data=data) def updateBatch(self, rev=False): if rev: self.bh.batqty = self.bh.batqty - 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.batupd = True self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def queryCrs(self): callModule(self.opts["mf"], self.df, "cr4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def maintainCrs(self): callModule(self.opts["mf"], self.df, "cr1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def doLonAcc(self, frt, pag, r, c, p, i, w): newacc = False if not w and self.opts["rtn"] == 1: yn = askQuestion(self.opts["mf"].body, "New Account", "Is This a New Account?", default="no") if yn == "no": return "Invalid Account Number" newacc = True w = callModule(self.opts["mf"], self.df, "ln1010", coy=(self.allcoy, self.allnam), user=self.opts["capnm"], args="auto", ret="acno") self.df.loadEntry(frt, pag, p, data=w) acc = self.sql.getRec("lonmf1", cols=["lm1_name"], where=[("lm1_cono", "=", self.allcoy), ("lm1_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" self.lonacc = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if newacc: self.lonnum = 1 self.newlon = True self.df.loadEntry(frt, pag, p + 2, data=self.lonnum) return "sk2" def doLonNum(self, frt, pag, r, c, p, i, w): if not w and self.opts["rtn"] == 1: ok = askQuestion(self.opts["mf"].body, head="New Loan", mess="Is This a New Loan?", default="no") if ok == "yes": self.newlon = True self.lonnum = getNextCode(self.sql, "lonmf2", "lm2_loan", where=[ ("lm2_cono", "=", self.allcoy), ("lm2_acno", "=", self.lonacc) ], start=1, last=9999999) self.df.loadEntry(frt, pag, p, data=self.lonnum) else: return "Invalid Loan Number" else: self.lonmf2 = self.sql.getRec("lonmf2", where=[ ("lm2_cono", "=", self.allcoy), ("lm2_acno", "=", self.lonacc), ("lm2_loan", "=", w) ], limit=1) if not self.lonmf2: return "Invalid Loan Number" self.lonnum = w self.newlon = False self.londes = self.lonmf2[self.sql.lonmf2_col.index("lm2_desc")] self.londat = self.lonmf2[self.sql.lonmf2_col.index("lm2_start")] self.lonmth = self.lonmf2[self.sql.lonmf2_col.index("lm2_pmths")] self.lonpay = self.lonmf2[self.sql.lonmf2_col.index("lm2_repay")] if self.lonmth: return "Invalid Entry, Fixed Loan" self.df.loadEntry(frt, pag, p + 1, data=self.londes) return "sk1" def doLonDes(self, frt, pag, r, c, p, i, w): self.londes = w def doLonAmt(self, frt, pag, r, c, p, i, w): self.lonamt = w if not self.lonamt: self.lonamt = self.othtot self.df.loadEntry(frt, pag, p, data=self.lonamt) if not self.newlon: self.newdri = 0 return "nd" def doLonDri(self, frt, pag, r, c, p, i, w): self.newdri = w def doLonCri(self, frt, pag, r, c, p, i, w): self.newcri = w def doLonMth(self, frt, pag, r, c, p, i, w): self.lonmth = w if self.lonmth: rte = (self.newdri / 1200.0) self.lonpay = round( ((self.lonamt * rte) * ((1 + rte)**w)) / (((1 + rte)**w) - 1), 2) else: self.lonpay = 0 self.df.loadEntry(frt, pag, p + 1, data=self.lonpay) def endLon(self): if self.opts["rtn"] == 4: tramt = float(ASD(0.0) - ASD(self.lonamt)) else: tramt = self.lonamt self.othtot = float(ASD(self.othtot) - ASD(self.lonamt)) if self.newlon: # Loans Rate self.sql.insRec("lonrte", data=[ self.allcoy, self.lonacc, self.lonnum, self.trndat, self.newdri, self.newcri ]) # Loans Ledger Masterfile self.sql.insRec("lonmf2", data=[ self.allcoy, self.lonacc, self.lonnum, self.londes, self.trndat, self.lonmth, self.lonpay, 0 ]) self.othrtn = 2 else: self.othrtn = 3 # Loans Ledger Transaction data = [ self.allcoy, self.lonacc, self.lonnum, self.bh.batno, self.othrtn, self.trndat, self.trnref, tramt, self.curdt, self.alldet, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("lontrn", data=data) if self.othtot: self.df.loadEntry("T", self.lonpag, 0, data=self.othtot) self.df.advanceLine(self.lonpag) else: self.othvar.set(False) def exitLon(self): self.df.focusField("C", self.lonpag, self.df.col) def doEmpNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("wagmst", cols=["wgm_sname", "wgm_fname"], where=[("wgm_cono", "=", self.allcoy), ("wgm_empno", "=", w)], limit=1) if not acc: return "Invalid Employee Number" self.empnum = w empnam = "%s, %s" % (acc[0], acc[1].split()[0]) self.df.loadEntry(frt, pag, p + 1, data=empnam) def doSlnNum(self, frt, pag, r, c, p, i, w): if not w and self.opts["rtn"] == 1: ok = askQuestion(self.opts["mf"].body, head="New Loan", mess="Is This a New Loan?", default="no") if ok == "yes": self.newsln = True self.slnnum = getNextCode(self.sql, "waglmf", "wlm_loan", where=[ ("wlm_cono", "=", self.allcoy), ("wlm_empno", "=", self.empnum) ], start=1, last=9999999) self.df.loadEntry(frt, pag, p, data=self.slnnum) else: return "Invalid Loan Number" else: acc = self.sql.getRec("waglmf", where=[("wlm_cono", "=", self.allcoy), ("wlm_empno", "=", self.empnum), ("wlm_loan", "=", w)], limit=1) if not acc: return "Invalid Loan Number" self.slnnum = w self.newsln = False self.slndes = acc[self.sql.waglmf_col.index("wlm_desc")] self.slncod = acc[self.sql.waglmf_col.index("wlm_code")] self.slnrte = acc[self.sql.waglmf_col.index("wlm_rate")] self.slndat = acc[self.sql.waglmf_col.index("wlm_start")] self.slnded = acc[self.sql.waglmf_col.index("wlm_repay")] self.df.loadEntry(frt, pag, p + 1, data=self.slndes) return "sk1" def doSlnDes(self, frt, pag, r, c, p, i, w): self.slndes = w def doSlnAmt(self, frt, pag, r, c, p, i, w): self.slnamt = w if not self.slnamt: self.slnamt = self.othtot self.df.loadEntry(frt, pag, p, data=self.slnamt) if not self.newsln: self.df.loadEntry(frt, pag, p + 1, data=self.slncod) def doSlnCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("wagedc", cols=["ced_desc"], where=[("ced_cono", "=", self.allcoy), ("ced_type", "=", "D"), ("ced_code", "=", w)], limit=1) if not acc: return "Invalid Code" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) self.slncod = w if not self.newsln: self.newrte = 0 self.slnded = 0 return "nd" def doSlnInt(self, frt, pag, r, c, p, i, w): self.newrte = w if not self.newsln: self.df.loadEntry(frt, pag, p + 2, data=self.slnded) def doSlnDed(self, frt, pag, r, c, p, i, w): self.slnded = w def endSln(self): if self.opts["rtn"] == 4: tramt = float(ASD(0.0) - ASD(self.slnamt)) else: tramt = self.slnamt self.othtot = float(ASD(self.othtot) - ASD(self.slnamt)) if self.newsln: # Staff Loans Ledger Masterfile self.sql.insRec("waglmf", data=[ self.allcoy, self.empnum, self.slnnum, self.slndes, self.slncod, self.newrte, self.trndat, self.slnded ]) self.othrtn = 2 else: self.othrtn = 3 # Staff Loans Ledger Transaction data = [ self.allcoy, self.empnum, self.slnnum, self.bh.batno, self.othrtn, self.trndat, self.trnref, tramt, tramt, self.slnded, self.newrte, self.curdt, self.alldet, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("wagltf", data=data) if self.othtot: self.df.loadEntry("T", self.slnpag, 0, data=self.othtot) self.df.advanceLine(self.slnpag) else: self.othvar.set(False) def exitSln(self): self.df.focusField("C", self.slnpag, self.df.col)
class dr2020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.drawDialog() self.opts["mf"].startLoop() def setVariables(self): # Check for Valid Posting Routine if self.opts["rtn"] != 2: mes = "Invalid Routine %s" % str(self.opts["rtn"]) showError(self.opts["mf"].body, "Control Error", mes) return # Setup SQL Object self.sql = Sql(self.opts["mf"].dbm, [ "ctlmst", "ctlvmf", "drschn", "drsmst", "drstrn", "genint", "genmst", "gentrn" ], prog=self.__class__.__name__) if self.sql.error: return # Check for Intercompany Facility if not self.sql.getRec("ctlmst", cols=["count(*)"], where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]: self.incoac = False else: itg = self.sql.getRec("genint", cols=["cti_inco"], where=[("cti_cono", "=", self.opts["conum"]) ]) if itg: self.incoac = [self.opts["conum"]] [self.incoac.append(coy[0]) for coy in itg] else: self.incoac = False # self.gc = GetCtl(self.opts["mf"]) drsctl = self.gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return self.glint = drsctl["ctd_glint"] self.chains = drsctl["ctd_chain"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["drs_ctl", "vat_ctl", "dis_all"] if self.gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.drsctl = ctlctl["drs_ctl"] self.dis_all = ctlctl["dis_all"] self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.allcoy = self.opts["conum"] ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if self.chains == "N": self.chain = 0 self.glt = 6 self.agevar = tk.BooleanVar() self.agevar.set(False) return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"], glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return self.bh.batval = float(ASD(0) - ASD(self.bh.batval)) def drawDialog(self): drc = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } drm = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1")) } if self.chains == "Y": drm["where"] = [("drm_cono", "=", self.opts["conum"])] drm["whera"] = [["C", "drm_chain", 0, 1]] else: drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", 0)] drm["where"].append(("drm_stat", "<>", "X")) coy = { "stype": "R", "tables": ("ctlmst", ), "cols": (("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y")) } viw = { "stype": "R", "tables": ("drstrn", ), "cols": (("drt_chain", "", 0, ""), ("drt_acno", "", 0, ""), ("drt_ref1", "", 0, ""), ("drt_trdt", "", 0, ""), ("drt_tramt", "", 0, ""), ("drt_taxamt", "", 0, "")), "where": [("drt_cono", "=", self.opts["conum"]), ("drt_type", "=", self.opts["rtn"]), ("drt_batch", "=", self.bh.batno)], "order": "drt_seq" } tag = (("Deposit", None, None, None, False), ("Allocation", None, None, None, False)) fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno), (("T", 0, 0, 0), "OSD", 13.2, "Value"), (("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One", "i", "Y", self.doRef1, None, None, ("efld", )), (("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r", "N", self.doTrnDat, None, None, ("efld", )), (("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount", "", "N", self.doTrnAmt, None, None, ("notzero", )), (("C", 1, 0, 3), "INA", (30), "Details", "Deposit Details", "", "N", self.doTrnDet, None, None, None), (("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"), [("C", 2, 0, 0), "OUI", 3, "Coy", "Company Number", self.opts["conum"], "N", self.doCoyNum, coy, None, ("notzero", )], [("C", 2, 0, 1), "IUI", 3, "Chn", "Chain Store", "r", "N", self.doChain, drc, None, ("efld", )], (("C", 2, 0, 2), "INA", 7, "Acc-Num", "Account Number", "r", "N", self.doDrsAcc, drm, None, ("notblank", )), (("C", 2, 0, 3), "ONA", 30, "Name"), (("C", 2, 0, 4), "ISD", 13.2, "Receipt", "Receipt Amount", "", "N", self.doAllAmt, None, None, ("efld", )), (("C", 2, 0, 5), "ISD", 13.2, "Discount", "Discount Amount", "", "N", self.doDisAmt, None, None, ("efld", ), None, "Discount Amount to be Added to the Receipt Amount"), (("C", 2, 0, 6), "OSD", 13.2, "Total-Amount")] if self.glint == "Y" and self.incoac: fld[7][1] = "IUI" if self.chains == "N": fld[8][1] = "OUI" but = [("View Entries", viw, None, 1, ("C", 2, 3), ("C", 2, 4), "View Batch Transactions", 1), ("Interrogate", None, self.queryDrs, 0, ("C", 2, 3), ("C", 2, 0), "Interrogate Debtors Accounts", 1), ("Maintain", None, self.maintainDrs, 0, ("C", 2, 3), ("C", 2, 4), "Maintain Debtors Accounts", 1), ("Canc_el", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1), "", 1)] else: but = [("View Entries", viw, None, 0, ("C", 2, 3), ("C", 2, 4), "View Batch Transactions", 1), ("Interrogate", None, self.queryDrs, 0, ("C", 2, 2), ("C", 2, 0), "Interrogate Debtors Accounts", 1), ("Maintain", None, self.maintainDrs, 0, ("C", 2, 2), ("C", 2, 3), "Maintain Debtors Accounts", 1), ("Canc_el", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1), "", 1)] but.extend(( ("Age _Normal",None,self.doAgeNormal,0,None,None, "Only Show Unallocated Transactions",2), ("Age _History",None,self.doAgeHistory,0,None,None, "Show All Transactions, Including Already Allocated",2), ("Age _Automatic",None,self.doAgeAuto,0,None,None, "Automatically Allocate the Amount Starting With the "\ "Oldest Unallocated One",2), ("Age _Current",None,self.doAgeCurrent,0,None,None, "Leave the Transaction Unallocated",2))) txt = (None, None, None) cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")] cxt = [None, self.exitPage1, self.exitPage2] self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, txit=txt, cend=cnd, cxit=cxt, butt=but) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) self.df.focusField("C", 1, 1) def doRef1(self, frt, pag, r, c, p, i, w): if not w: trns = self.sql.getRec("drstrn", cols=["drt_ref1"], where=[("drt_cono", "=", self.opts["conum"]), ("drt_ref1", "like", "R________")], order="drt_ref1 desc") auto = False for trn in trns: try: w = "R%08i" % (int(trn[0][1:]) + 1) auto = True break except: pass if not auto: w = "R00000001" self.df.loadEntry(frt, pag, p, data=w) chk = self.sql.getRec("drstrn", cols=["drt_acno"], where=[("drt_cono", "=", self.opts["conum"]), ("drt_type", "=", self.opts["rtn"]), ("drt_ref1", "=", w)]) if chk: return "A Transaction with this Reference Already Exists" self.ref1 = w def doTrnDat(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" if self.bh.multi == "N" and int(w / 100) > self.bh.curdt: return "Invalid Date, After Batch Period" self.trndat = w def doTrnAmt(self, frt, pag, r, c, p, i, w): self.trnamt = w def doTrnDet(self, frt, pag, r, c, p, i, w): self.trndet = w self.allocated = float(0.00) def endPage1(self): self.agecan = False self.batupd = False self.updateTables1() self.updateBatch() self.allocated = float(0.0) self.df.selPage("Allocation") self.df.loadEntry("T", 2, 0, data=self.trnamt) self.df.focusField("C", 2, 1) def updateTables1(self): if self.bh.multi == "Y": self.curdt = int(self.trndat / 100) else: self.curdt = self.bh.curdt if self.glint == "Y": # General Ledger Control Transaction (Bank) data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat, self.glt, self.ref1, self.bh.batno, self.trnamt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def exitPage1(self): self.df.closeProcess() self.bh.doBatchTotal() self.opts["mf"].closeLoop() def doCoyNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", w)], limit=1) if not acc: return "Invalid Company, Missing" if self.incoac and w not in self.incoac: return "Invalid Company, No Intercompany Record 1" if w != self.opts["conum"]: acc = self.sql.getRec("genint", where=[("cti_cono", "=", w), ("cti_inco", "=", self.opts["conum"]) ], limit=1) if not acc: return "Invalid Company, No Intercompany Record 2" self.allcoy = w def doChain(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drschn", cols=["chm_chain"], where=[("chm_cono", "=", self.allcoy), ("chm_chain", "=", w)], limit=1) if not acc: return "Invalid Chain Store" self.chain = w def doDrsAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"], where=[("drm_cono", "=", self.allcoy), ("drm_chain", "=", self.chain), ("drm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[1] == "X": return "Invalid Account, Redundant" self.dracno = w self.name = acc[0] self.df.loadEntry("C", pag, p + 1, data=self.name) self.allref = self.ref1 while self.sql.getRec("drstrn", cols=["drt_batch"], where=[("drt_cono", "=", self.allcoy), ("drt_chain", "=", self.chain), ("drt_acno", "=", self.dracno), ("drt_type", "=", self.opts["rtn"]), ("drt_ref1", "=", self.allref)]): self.doGetAnotherRef() def doGetAnotherRef(self): tit = ("Duplicate Reference Number", ) fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref, "N", None, None, None, None), (("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N", self.doRefNew, None, None, ("notblank", ))) tnd = ((self.doRefEnd, "n"), ) txt = (self.doRefExit, ) state = self.df.disableButtonsTags() self.tf = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=tnd, txit=txt) self.tf.mstFrame.wait_window() self.df.enableButtonsTags(state=state) def doRefExit(self): self.tf.focusField("T", 0, 2) def doRefNew(self, frt, pag, r, c, p, i, w): self.allref = w def doRefEnd(self): self.tf.closeProcess() def doAllAmt(self, frt, pag, r, c, p, i, w): if w == 0: self.allamt = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry(frt, pag, p, data=self.allamt) else: self.allamt = w def doDisAmt(self, frt, pag, r, c, p, i, w): if self.allamt < 0 and w > 0: ok = self.checkSign() elif self.allamt > 0 and w < 0: ok = self.checkSign() else: ok = "yes" if ok != "yes": return "Invalid Discount Amount (Sign Error)" self.disamt = w totamt = float(ASD(self.allamt) + ASD(self.disamt)) self.df.loadEntry(frt, pag, p + 1, data=totamt) def checkSign(self): return askQuestion(self.opts["mf"].body, "Check Sign", "The Sign of the Discount Amount is not the same "\ "as the Sign of the Receipt Amount, Is This Correct?") def endPage2(self): self.amt = float(ASD(0) - ASD(self.allamt)) self.dis = float(ASD(0) - ASD(self.disamt)) state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Choose an Ageing Option") for x in range(4, 8): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "normal") self.agevar.set(True) self.df.mstFrame.wait_variable(self.agevar) self.df.enableButtonsTags(state=state) if self.agecan: self.doCancel() return # Debtors Ledger Transaction data = [ self.allcoy, self.chain, self.dracno, self.opts["rtn"], self.allref, self.bh.batno, self.trndat, "", self.amt, 0.00, self.curdt, self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("drstrn", data=data) if self.dis: data = [ self.allcoy, self.chain, self.dracno, 6, self.allref, self.bh.batno, self.trndat, "", self.dis, 0.00, self.curdt, self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("drstrn", data=data) self.allocated = float(ASD(self.allocated) + ASD(self.allamt)) if self.glint == "Y": # General Ledger Control Transaction (Debtors) amt = float(ASD(self.amt) + ASD(self.dis)) data = (self.allcoy, self.drsctl, self.curdt, self.trndat, self.glt, self.allref, self.bh.batno, amt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Control Transaction (Discount) if self.disamt: data = (self.allcoy, self.dis_all, self.curdt, self.trndat, self.glt, self.allref, self.bh.batno, self.disamt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany) if self.allcoy != self.opts["conum"]: # General Ledger Transaction (Intercompany From) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=", self.allcoy)], limit=1)[0] data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt, self.allref, self.bh.batno, self.amt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # General Ledger Transaction (Intercompany To) acc = self.sql.getRec("genint", cols=["cti_acno"], where=[("cti_cono", "=", self.allcoy), ("cti_inco", "=", self.opts["conum"])], limit=1)[0] amt = float(ASD(0) - ASD(self.amt)) data = (self.allcoy, acc, self.curdt, self.trndat, self.glt, self.allref, self.bh.batno, amt, 0.00, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.allocated == self.trnamt: self.opts["mf"].dbm.commitDbase() self.df.clearFrame("C", 2) self.df.selPage("Deposit") self.df.advanceLine(1) else: bal = float(ASD(self.trnamt) - ASD(self.allocated)) self.df.loadEntry("T", 2, 0, data=bal) self.df.advanceLine(2) def doAgeNormal(self): self.doAgeing("N") def doAgeHistory(self): self.doAgeing("H") def doAgeAuto(self): self.doAgeing("O") def doAgeCurrent(self): self.doAgeing("C") def doAgeing(self, atype): # Disable All Ageing Buttons for x in range(4, 8): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") self.opts["mf"].updateStatus("Select Transaction to Allocate Against") age = AgeAll(self.opts["mf"], system="drs", agetyp=atype, agekey=[ self.allcoy, self.chain, self.dracno, self.opts["rtn"], self.allref, self.curdt, self.amt, self.dis ]) self.agecan = age.cancel self.agevar.set(False) def doCancel(self): if self.agecan: ok = "yes" else: ok = askQuestion( self.opts["mf"].body, head="Cancel", mess="Are You Certain You Want to Cancel This Entry?") if ok == "yes": self.opts["mf"].dbm.rollbackDbase() if self.batupd: self.updateBatch(rev=True) self.df.clearFrame("C", 2) self.df.selPage("Deposit") row = int((self.df.last[1][1] - 1) / self.df.colq[1]) col = (row * self.df.colq[1]) + 1 self.df.focusField("C", 1, col) def exitPage2(self): self.df.focusField("C", 2, self.df.col) def updateBatch(self, rev=False): if rev: self.bh.batqty = self.bh.batqty - 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.batupd = True self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) self.df.loadEntry("T", 0, 0, data=self.bh.batqty) self.df.loadEntry("T", 0, 1, data=self.bh.batval) def queryDrs(self): callModule(self.opts["mf"], self.df, "dr4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def maintainDrs(self): callModule(self.opts["mf"], self.df, "dr1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"])
class gl6050(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.doProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlctl", "genmst", "gentrn"], prog=self.__class__.__name__) if self.sql.error: return return True def doProcess(self): glm = { "stype": "R", "tables": ("ctlctl", "genmst"), "cols": ( ("ctl_conacc", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [ ("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono",), ("glm_acno=ctl_conacc",)]} typ = { "stype": "C", "title": "Select Type", "head": ("C", "Type"), "data": ((2, "Payment"), (4, "Journal"), (6, "Receipt"))} self.glt = { "stype": "R", "tables": ("gentrn",), "cols": ( ("glt_trdt", "", 0, "Date"), ("glt_type", ("XX", gltrtp), 3, "Typ"), ("glt_refno", "", 0, "Reference", "Y"), ("glt_seq", "", 0, "Sequence"), ("glt_tramt", "", 0, "Amount"), ("glt_desc", "", 0, "Details")), "where": [], "index": 2, "zero": "0"} r1s = (("Yes","Y"), ("No","N")) fld = ( (("T",0,0,0),"IUI",7,"Bank Account","", "","N",self.doBankAcc,glm,None,("notzero",)), (("T",0,0,0),"ONA",30,""), (("T",0,1,0),"ID2",7,"Last Period","Last Reconciliation Period", 0,"N",self.doLastPer,None,None,("efld",)), (("T",0,2,0),("IRB",r1s),7,"Clear History","", "N","N",self.doClear,None,None,None), (("C",0,0,0),"IUA",1,"T","Reference Type", 2,"N",self.doTrnTyp,typ,None,("in", ("2","4","6"))), (("C",0,0,1),"INa",9,"Ref-Num","Reference Number", "i","N",self.doTrnRef,self.glt,None,("notblank",)), (("C",0,0,2),"OD1",10,"Date"), (("C",0,0,3),"OSD",13.2,"Amount"), (("C",0,0,4),"ONA",30,"Details")) tnd = ((self.endTop,"y"),) txt = (self.exitTop,) cnd = ((self.endCol,"y"),) cxt = (self.exitCol,) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doBankAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec(tables=["ctlctl", "genmst"], cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w), ("ctl_cono=glm_cono",), ("ctl_conacc=glm_acno",), ("ctl_code", "like", "bank_%")], limit=1) if not acc: return "Invalid Bank Account Number" self.acno = w self.df.loadEntry("T", 0, p+1, data=acc[0]) def doLastPer(self, frt, pag, r, c, p, i, w): self.curdt = w def doClear(self, frt, pag, r, c, p, i, w): self.clear = w def endTop(self): whr = [ ("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.acno)] if self.clear == "Y": self.sql.updRec("gentrn", cols=["glt_recon"], data=[0], where=whr) whr.extend([("glt_curdt", "<=", self.curdt), ("glt_recon", "=", 0)]) self.sql.updRec("gentrn", cols=["glt_recon"], data=[self.curdt], where=whr) self.df.focusField("C", 0, 1) def exitTop(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doTrnTyp(self, frt, pag, r, c, p, i, w): self.opts["rtn"] = w self.df.colf[0][1][8]["where"] = [ ("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.acno), ("glt_type", "=", self.opts["rtn"]), ("glt_curdt", "<=", self.curdt), ("glt_recon", "<>", 0)] try: self.df.rs.selection = None except: pass def doTrnRef(self, frt, pag, r, c, p, i, w): self.trnref = w try: rs = self.df.rs.selection except: rs = None if not rs: wa = [ ("glt_type", "=", self.opts["rtn"]), ("glt_refno", "=", self.trnref)] opt = {} for k in self.glt: if k == "where": opt[k] = copyList(self.glt[k]) opt[k].extend(wa) elif type(self.glt[k]) == list: opt[k] = copyList(self.glt[k]) else: opt[k] = self.glt[k] rs = self.df.selRecord(1, opt).selection if rs: self.df.loadEntry("C", 0, p+1, data=rs[0]) self.df.loadEntry("C", 0, p+2, data=rs[4]) self.df.loadEntry("C", 0, p+3, data=rs[5]) self.seq = rs[3] return "nd" else: return "Invalid Transaction" def endCol(self): self.sql.updRec("gentrn", cols=["glt_recon"], data=[0], where=[("glt_seq", "=", self.seq)]) self.df.advanceLine(0) def exitCol(self): self.opts["mf"].dbm.commitDbase(ask=True) self.df.closeProcess() self.opts["mf"].closeLoop()