def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "gentrn", "strmf1", "strmf2", "strgmu", "strcmu", "strprc", "strtrn" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] 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] return True
def setVariables(self): gc = GetCtl(self.opts["mf"]) lonctl = gc.getCtl("lonctl", self.opts["conum"]) if not lonctl: return glint = lonctl["cln_glint"] tab = ["lonctl", "lonmf2", "lontrn"] if glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["lon_ctl", "int_rec", "int_pay"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.glctl = ( ctlctl["lon_ctl"], ctlctl["int_rec"], ctlctl["int_pay"]) tab.append("gentrn") else: self.glctl = None self.sql = Sql(self.opts["mf"].dbm, tables=tab, prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] yr = int(self.sysdtw / 10000) mt = (int(self.sysdtw / 100) % 100) - 1 self.lme = mthendDate((yr * 10000) + (mt * 100) + 1) return True
def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["genmst", "gentrn", "wagmst", "waglmf", "wagltf"], prog=self.__class__.__name__) if self.sql.error: return self.col = self.sql.waglmf_col gc = GetCtl(self.opts["mf"]) wagctl = gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.glint = wagctl["ctw_glint"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["wag_slc", "wag_sli"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.glctls = (ctlctl["wag_slc"], ctlctl["wag_sli"]) else: self.glctls = None self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True
def setVariables(self): mc = GetCtl(self.opts["mf"]) ctlmst = mc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] memctl = mc.getCtl("memctl", self.opts["conum"]) if not memctl: return self.glint = memctl["mcm_glint"] self.ldays = memctl["mcm_ldays"] self.lme = memctl["mcm_lme"] self.lmd = int(memctl["mcm_lme"] / 100) yr = int(self.lme / 10000) mth = (int(self.lme / 100) % 100) + 1 if mth > 12: yr += 1 mth = 1 self.tme = mthendDate((yr * 10000) + (mth * 100) + 00) tabs = [ "chglog", "ctlbat", "ctlmst", "ctlvrf", "ctlvtf", "memage", "memcat", "memctc", "memctl", "memctp", "memmst", "memtrn" ] if self.glint == "Y": tabs.append("gentrn") ctlctl = mc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["mem_ctl", "mem_pen", "vat_ctl"] if mc.chkRec(self.opts["conum"], ctlctl, ctls): return self.memctl = ctlctl["mem_ctl"] self.penctl = ctlctl["mem_pen"] self.vatctl = ctlctl["vat_ctl"] else: self.penctl = 0 self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return if self.glint == "Y": check = self.sql.getRec("memctc", where=[("mcc_cono", "=", self.opts["conum"]), ("mcc_freq", "<>", "N"), ("mcc_glac", "=", 0)]) if check: mess = "The following Category Record(s) are Missing G/L "\ "Accounts:\n" for rec in check: mess = "%s\n%s, %2s, %s" % (mess, rec[1], rec[2], rec[3]) showError(self.opts["mf"].body, "Invalid Category", mess) return t = time.localtime() self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2] self.ynd = False return True
def setVariables(self): gc = GetCtl(self.opts["mf"]) wagctl = gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.hrsmt = float(wagctl["ctw_m_hrs"]) self.hrswk = float(wagctl["ctw_w_hrs"]) self.hrsdy = float(wagctl["ctw_d_hrs"]) self.glint = wagctl["ctw_glint"] self.bestac = wagctl["ctw_bestac"] self.besttp = wagctl["ctw_besttp"] self.tplnam = wagctl["ctw_tplnam"] tabs = [ "tplmst", "wagcod", "wagedc", "wagmst", "wagcap", "wagbal", "wagtf1", "wagtf2", "waglmf", "wagltf", "wagtxa", "wagtxr" ] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if gc.chkRec(self.opts["conum"], ctlctl, ["wag_ctl"]): return self.wagctl = ctlctl["wag_ctl"] self.slnctl = ctlctl["wag_slc"] tabs.extend(["ctldep", "ctlmst", "genmst", "genint", "gentrn"]) self.sql = Sql(self.opts["mf"].dbm, tables=tabs, prog=self.__class__.__name__) if self.sql.error: return accs = self.sql.getRec("waglmf", cols=["wlm_code"], where=[("wlm_cono", "=", self.opts["conum"])], group="wlm_code") self.lonacc = [] for acc in accs: self.lonacc.append(acc[0]) t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.sysdtd = CCD(self.sysdtw, "d1", 10).disp self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) self.etotal = 0 self.pgnum = 0 self.empnos = [] return True
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 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 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 setVariables(self): self.sql = Sql(self.opts["mf"].dbm, tables=[ "bkmmst", "bkmcon", "bkmrtt", "bkmtrn", "bkmunm", "ctlmst", "ctlvtf", "gentrn", "tplmst" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) ctl = gc.getCtl("ctlmst", self.opts["conum"]) if not ctl: return for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3", "ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_taxdf", "ctm_tel", "ctm_fax", "ctm_b_name", "ctm_b_ibt", "ctm_b_acno", "ctm_logo"): setattr(self, "%s" % col, ctl[col]) if self.ctm_logo and "LETTERHEAD" in os.environ: self.ctm_logo = os.environ["LETTERHEAD"] if not self.ctm_logo or not os.path.exists(self.ctm_logo): self.ctm_logo = None bkmctl = gc.getCtl("bkmctl", self.opts["conum"]) if not bkmctl: return self.glint = bkmctl["cbk_glint"] self.tplnam = bkmctl["cbk_invtpl"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["vat_ctl", "bkm_ctl"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.vatctl = ctlctl["vat_ctl"] self.bkmctl = ctlctl["bkm_ctl"] t = time.localtime() self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2]) return True
def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "ctlvrf", "ctlvtf", "gentrn", "rcactl", "rcaprm", "rcaowm", "rcaowt", "rcatnm", "rcacon", "rcatnt" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) rcactl = gc.getCtl("rcactl", self.opts["conum"]) if not rcactl: return self.lme = rcactl["cte_lme"] self.glint = rcactl["cte_glint"] if self.glint == "Y": self.glbnk = rcactl["cte_glbnk"] ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["rca_com", "rca_own", "rca_tnt", "vat_ctl"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.rcacom = ctlctl["rca_com"] self.rcaown = ctlctl["rca_own"] self.rcatnt = ctlctl["rca_tnt"] self.rcatrx = ctlctl["rca_trx"] self.convat = ctlctl["vat_ctl"] # Check for Company Record ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return # Set Company VAT Default self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.tme = mthendDate(self.sysdtw) return True
def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlbat", "ctlvrf", "ctlvtf", "gentrn", "rtlctl", "rtlprm", "rtlmst", "rtlcon", "rtltrn"], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) rtlctl = gc.getCtl("rtlctl", self.opts["conum"]) if not rtlctl: return self.glint = rtlctl["ctr_glint"] self.lme = rtlctl["ctr_lme"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if 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.tme = mthendDate(self.sysdtw) return True
def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["wagctl", "waglmf"], 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 glint = wagctl["ctw_glint"] if glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["wag_slc", "wag_sli"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.glctl = (ctlctl["wag_slc"], ctlctl["wag_sli"], ctlctl["wag_sli"]) else: self.glctl = None t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True
class gl2050(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.doProcess() self.opts["mf"].startLoop() def setVariables(self): # Check for Company Record self.gc = GetCtl(self.opts["mf"]) ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return # Check and Load VAT Control self.ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not self.ctlctl: return if self.gc.chkRec(self.opts["conum"], self.ctlctl, ["vat_ctl"]): return self.convat = self.ctlctl["vat_ctl"] # Set Batch Indicator self.batind = "Y" # Create SQL Object tabs = [ "ctlctl", "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint", "genjlm", "genjlt", "genmst", "gentrn", "assgrp", "rtlprm" ] self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "GEN", self.opts["rtn"], multi="Y") self.bh.doBatchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2]) self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][1][0] / 100) return True def doProcess(self): r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"), ("Annually", "Y")) r2s = (("Yes", "Y"), ("No", "N")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Frequency", "", "M", "N", self.doFreq, None, None, None), (("T", 0, 1, 0), ("IRB", r2s), 9, "All Journals", "", "N", "N", self.doAllJnl, None, None, None), (("T", 0, 2, 0), ("IRB", r2s), 1, "All Periods", "", "N", "N", self.doAllPer, None, None, None)) tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt) def doFreq(self, frt, pag, r, c, p, i, w): self.freq = w self.wher = [("gjm_cono", "=", self.opts["conum"]), ("gjm_freq", "=", self.freq), ("gjm_start", "<=", self.bh.curdt), ("gjm_end", ">=", self.bh.curdt), ("gjm_last", "<", self.bh.curdt)] data = self.sql.getRec("genjlm", cols=["gjm_num", "gjm_desc"], where=self.wher) if not data: return "No Valid Standard Journals" if self.freq == "M": self.mths = 1 elif self.freq == "3": self.mths = 3 elif self.freq == "6": self.mths = 6 else: self.mths = 12 def doAllJnl(self, frt, pag, r, c, p, i, w): self.alljnl = w def doAllPer(self, frt, pag, r, c, p, i, w): self.allper = w def doEnd(self): self.df.closeProcess() if self.alljnl == "N": recs = getSingleRecords(self.opts["mf"], "genjlm", ("gjm_num", "gjm_desc"), where=self.wher) else: recs = self.sql.getRec("genjlm", where=self.wher) if not recs: self.opts["mf"].closeLoop() return for gjm in recs: self.trnref = gjm[self.sql.genjlm_col.index("gjm_num")] self.trndet = gjm[self.sql.genjlm_col.index("gjm_desc")] start = gjm[self.sql.genjlm_col.index("gjm_start")] last = gjm[self.sql.genjlm_col.index("gjm_last")] dates = [] while start <= self.bh.curdt: if start < self.s_per or start <= last: pass elif self.allper == "N" and start == self.bh.curdt: dates.append(start) elif self.allper == "Y" and start <= self.bh.curdt: dates.append(start) start = self.nextPeriod(start) for self.curdt in dates: self.trndat = mthendDate((self.curdt * 100)) data = self.sql.getRec( "genjlt", cols=["gjt_acno", "gjt_amnt", "gjt_vatc"], where=[("gjt_cono", "=", self.opts["conum"]), ("gjt_num", "=", self.trnref), ("gjt_amnt", "<>", 0)]) if not data: continue for tran in data: self.acno = tran[0] self.trnamt = tran[1] self.vatcod = tran[2] vrte = getVatRate(self.sql, self.opts["conum"], self.vatcod, self.trndat) if vrte is None: vrte = 0.0 self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2) self.updateTables() self.updateBatch() self.sql.updRec("genjlm", cols=["gjm_last"], data=[self.curdt], where=[("gjm_cono", "=", self.opts["conum"]), ("gjm_num", "=", self.trnref), ("gjm_freq", "=", self.freq)]) self.opts["mf"].dbm.commitDbase() self.opts["mf"].closeLoop() def nextPeriod(self, period): yy = int(period / 100) mm = (period % 100) + self.mths if mm > 12: yy += 1 mm -= 12 return (yy * 100) + mm def updateTables(self): amt = float(ASD(self.trnamt) - ASD(self.vatamt)) data = (self.opts["conum"], self.acno, self.curdt, self.trndat, self.opts["rtn"], self.trnref, self.bh.batno, amt, self.vatamt, self.trndet, self.vatcod, self.batind, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if self.vatcod: if self.vatamt: data = (self.opts["conum"], self.convat, self.curdt, self.trndat, self.opts["rtn"], self.trnref, self.bh.batno, self.vatamt, 0.00, self.trndet, self.vatcod, self.batind, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) if amt < 0: vtyp = "O" else: vtyp = "I" data = (self.opts["conum"], self.vatcod, vtyp, self.curdt, "G", self.opts["rtn"], self.bh.batno, self.trnref, self.trndat, self.acno, self.trndet, amt, self.vatamt, 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("ctlvtf", data=data) def updateBatch(self, rev=False): if rev: self.bh.batqty = self.bh.batqty - 1 self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt)) else: self.bh.batqty = self.bh.batqty + 1 self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt)) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class 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 dr2030(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.doProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlvrf", "ctlvtf", "drsmst", "drstrn", "drsrcm", "drsrct", "genmst", "gentrn"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) drsctl = self.gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return self.glint = drsctl["ctd_glint"] self.fromad = drsctl["ctd_emadd"] if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"],ctlctl,["drs_ctl","vat_ctl"]): return self.drsctl = ctlctl["drs_ctl"] self.vatctl = ctlctl["vat_ctl"] ctl = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"])], limit=1) for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3", "ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_tel", "ctm_fax", "ctm_b_name", "ctm_b_branch", "ctm_b_ibt", "ctm_b_acno", "ctm_logo"): setattr(self, "%s" % col, ctl[self.sql.ctlmst_col.index(col)]) if "LETTERHEAD" in os.environ: self.ctm_logo = os.environ["LETTERHEAD"] if not self.ctm_logo or not os.path.exists(self.ctm_logo): self.ctm_logo = None self.batchHeader() if not self.bh.batno: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def batchHeader(self): self.bh = Batches(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"], multi="N", glint=self.glint) self.bh.doBatchHeader() if not self.bh.batno: return def doProcess(self): r1s = ( ("Monthly","M"), ("Quarterly","3"), ("Bi-Annually","6"), ("Annually","Y")) r2s = (("Yes", "Y"), ("No", "N")) fld = ( (("T",0,0,0),("IRB",r1s),0,"Frequency","", "M","N",self.doFreq,None,None,None), (("T",0,1,0),("IRB",r2s),1,"All Charges","", "N","N",self.doAll,None,None,None), (("T",0,2,0),"INa",9,"2nd Reference","", "","N",self.doRef2,None,None,None), (("T",0,3,0),("IRB",r2s),1,"Invoices","", "N","N",self.doInv,None,None,None)) tnd = ((self.doEnd,"y"),) txt = (self.doExit,) self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt, view=("N","P"), mail=("N","Y")) def doFreq(self, frt, pag, r, c, p, i, w): self.freq = w self.wher = [("dcm_cono", "=", self.opts["conum"]), ("dcm_freq", "=", self.freq), ("dcm_last", "<", self.bh.curdt)] data = self.sql.getRec("drsrcm", where=self.wher) if not data: return "No Valid Recurring Charges" if self.freq == "M": self.mths = 1 elif self.freq == "3": self.mths = 3 elif self.freq == "6": self.mths = 6 else: self.mths = 12 def doAll(self, frt, pag, r, c, p, i, w): self.allc = w def doRef2(self, frt, pag, r, c, p, i, w): self.ref2 = w def doInv(self, frt, pag, r, c, p, i, w): self.inv = w if self.inv == "N": self.df.loadEntry(frt, pag, p+2, data="") return "nd" def doEml(self, frt, pag, r, c, p, i, w): self.eml = w def doEnd(self): self.df.closeProcess() if self.allc == "N": recs = getSingleRecords(self.opts["mf"], "drsrcm", ("dcm_num", "dcm_desc"), where=self.wher) else: recs = self.sql.getRec("drsrcm", where=self.wher) if recs: if self.inv == "Y" and self.df.repeml[1] == "N": self.fpdf = MyFpdf(orientation="L", fmat="A4", name=self.__class__.__name__, head=128) for dcm in recs: num = dcm[self.sql.drsrcm_col.index("dcm_num")] desc = dcm[self.sql.drsrcm_col.index("dcm_desc")] day = dcm[self.sql.drsrcm_col.index("dcm_day")] if day == 30: self.trdt = mthendDate((self.bh.curdt * 100) + 1) else: self.trdt = (self.bh.curdt * 100) + day vat = dcm[self.sql.drsrcm_col.index("dcm_vat")] self.vatrte = getVatRate(self.sql, self.opts["conum"], vat, self.trdt) glac = dcm[self.sql.drsrcm_col.index("dcm_glac")] nxt = self.sql.getRec("drstrn", cols=["max(drt_ref1)"], where=[("drt_cono", "=", self.opts["conum"]), ("drt_ref1", "like", "RC%03i%s" % (num, "%"))], limit=1) if not nxt[0]: nxt = 0 else: nxt = int(nxt[0][5:]) tot_val = 0 tot_vat = 0 rec = self.sql.getRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", num), ("dct_start", "<=", self.bh.curdt), ("dct_end", ">=", self.bh.curdt)]) col = self.sql.drsrct_col for dct in rec: self.chain = dct[col.index("dct_chain")] self.acno = dct[col.index("dct_acno")] # Check for Redundancy chk = self.sql.getRec("drsmst", cols=["drm_stat"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)], limit=1) if chk[0] == "X": continue # Check for Valid Period charge = False start = dct[col.index("dct_start")] year = int(start / 100) month = start % 100 while start <= self.bh.curdt: if start == self.bh.curdt: charge = True break month += self.mths if month > 12: year += 1 month -= 12 start = (year * 100) + month if not charge: continue # Create Transactions nxt += 1 self.ref = "RC%03i%04i" % (num, nxt) self.detail = textFormat(dct[col.index("dct_detail")], 73) self.amnt = dct[col.index("dct_amnt")] self.vmnt = round(self.amnt * self.vatrte / 100, 2) self.tmnt = float(ASD(self.amnt) + ASD(self.vmnt)) tot_val = float(ASD(tot_val) + ASD(self.amnt)) tot_vat = float(ASD(tot_vat) + ASD(self.vmnt)) # Debtors (drstrn) self.sql.insRec("drstrn", data=[self.opts["conum"], self.chain, self.acno, 1, self.ref, self.bh.batno, self.trdt, self.ref2, self.tmnt, self.vmnt, self.bh.curdt, self.detail[0], vat, "Y", self.opts["capnm"], self.sysdtw, 0]) if self.inv == "Y": # Create Invoice self.doInvoice() # VAT (ctlvtf) amnt = float(ASD(0) - ASD(self.amnt)) vmnt = float(ASD(0) - ASD(self.vmnt)) data = [self.opts["conum"], vat, "O", self.bh.curdt, "D", 1, self.bh.batno, self.ref, self.trdt, self.acno, self.detail[0], amnt, vmnt, 0, self.opts["capnm"], self.sysdtw, 0] self.sql.insRec("ctlvtf", data=data) if self.glint == "Y": ref = "RC%07i" % num # Update Debtors Control amnt = float(ASD(tot_val) + ASD(tot_vat)) data = (self.opts["conum"], self.drsctl, self.bh.curdt, self.trdt, 1, ref, self.bh.batno, amnt, 0, desc, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # Update Sales Account amnt = float(ASD(0) - ASD(tot_val)) data = (self.opts["conum"], glac, self.bh.curdt, self.trdt, 1, ref, self.bh.batno, amnt, 0, desc, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) amnt = float(ASD(0) - ASD(tot_vat)) if amnt: # Update VAT Control data = (self.opts["conum"], self.vatctl, self.bh.curdt, self.trdt, 1, ref, self.bh.batno, amnt, 0, desc, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) # Update Recurring Charge (drsrcm) self.sql.updRec("drsrcm", cols=["dcm_last"], data=[self.bh.curdt], where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", num), ("dcm_freq", "=", self.freq)]) self.opts["mf"].dbm.commitDbase() if self.inv == "Y" and self.df.repeml[1] == "N": self.doPrint() self.opts["mf"].closeLoop() def doInvoice(self): if self.df.repeml[1] == "Y": self.fpdf = MyFpdf(orientation="L", fmat="A4", name=self.__class__.__name__, head=128) cw = self.fpdf.get_string_width("X") ld = self.fpdf.font[2] ica = CCD(self.tmnt, "SD", 13.2) iva = CCD(float(ASD(self.tmnt) - ASD(self.amnt)), "SD", 13.2) ivr = CCD(self.vatrte, "UD", 5.2) self.drawInvoice(cw, ld) row = 20 for detail in self.detail: row += 1 self.fpdf.drawText(x=22.2*cw, y=row*ld, txt=detail) self.fpdf.drawText(x=97*cw, y=row*ld, txt=ivr.disp) self.fpdf.drawText(x=103*cw, y=row*ld, txt=ica.disp) self.printTotals(cw, ld, ica, iva) if self.df.repeml[1] == "Y": self.doPrint() def drawInvoice(self, cw, ld): self.fpdf.add_page() self.fpdf.setFont("courier", "B", 16) self.fpdf.drawText(x=22*cw, y=1*ld, txt=self.ctm_name) self.fpdf.setFont("courier", "B", 14) self.fpdf.drawText(x=108*cw, y=2*ld, w=16, align="R", txt="Tax Invoice") self.fpdf.setFont("courier", "B", self.fpdf.font[1]) if self.ctm_logo: self.fpdf.image(self.ctm_logo, 45, 3, 138, 28) else: self.fpdf.drawText(x=22*cw, y=2.5*ld, txt=self.ctm_add1) self.fpdf.drawText(x=22*cw, y=3.5*ld, txt=self.ctm_add2) self.fpdf.drawText(x=22*cw, y=4.5*ld, txt=self.ctm_add3) self.fpdf.drawText(x=22*cw, y=5.5*ld, txt=self.ctm_pcode) self.fpdf.drawText(x=54*cw, y=2.5*ld, txt="RegNo: %s" % self.ctm_regno) self.fpdf.drawText(x=54*cw, y=3.5*ld, txt="TaxNo: %s" % self.ctm_taxno) self.fpdf.drawText(x=54*cw, y=4.5*ld, txt="TelNo: %s" % self.ctm_tel) self.fpdf.drawText(x=54*cw, y=5.5*ld, txt="FaxNo: %s" % self.ctm_fax) drm = self.sql.getRec("drsmst", where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", self.acno)], limit=1) col = self.sql.drsmst_col self.fpdf.drawText(x=22.5*cw, y=10.5*ld, txt=drm[col.index("drm_name")]) self.fpdf.drawText(x=22.5*cw, y=11.5*ld, txt=drm[col.index("drm_add1")]) self.fpdf.drawText(x=22.5*cw, y=12.5*ld, txt=drm[col.index("drm_add2")]) self.fpdf.drawText(x=22.5*cw, y=13.5*ld, txt=drm[col.index("drm_add3")]) self.fpdf.drawText(x=22.5*cw, y=14.5*ld, txt=drm[col.index("drm_pcod")]) if self.ctm_b_name: dat = "Name: %s" % self.ctm_b_name dat = "%s\nBranch: %s" % (dat, self.ctm_b_branch) dat = "%s\nCode: %s" % (dat, self.ctm_b_ibt) dat = "%s\nAccount: %s\n " % (dat, self.ctm_b_acno) self.fpdf.drawText(x=22.5*cw, y=37*ld, txt=dat, ctyp="M") self.emadd = CCD(drm[col.index("drm_acc_email")], "TX") # Tables r1 = { "margins": ((22.5, 53), (8, 9)), "repeat": (1, 1), "rows": [ [22, 8.5, [[32, 1.5, .8, "Charge To:", False]]], [22, 10, [[32, 5.5]]], [22, 16, [ [9, 1.5, .8, "Acc-Num", True], [20, 1.5, .8, "V.A.T. Number", True], [42, 1.5, .8, "Contact Person", True], [12, 1.5, .8, "Date", True], [11, 1.5, .8, "Inv-Number", True]]], [22, 17.5, [ [9, 1.5, 0, self.acno, True], [20, 1.5, 0, drm[col.index("drm_vatno")], True], [42, 1.5, 0, drm[col.index("drm_sls")]], [12, 1.5, 0, CCD(self.trdt, "D1", 10).disp, True], [11, 1.5, 0, "%10s" % self.ref]]], [22, 19, [ [74, 1.5, .8, "Description", False], [7, 1.5, .8, " Tax-%", False], [13, 1.5, .8, " Value", False]]], [22, 20.5, [ [74, 12.5], [7, 12.5], [13, 12.5]]], [22, 33, [ [11, 1.5, .8, "Taxable"], [12, 1.5], [12, 1.5, .8, "Non-Taxable"], [12, 1.5], [11, 1.5, .8, "Total Tax"], [11, 1.5], [12, 1.5, .8, "Total Value"], [13, 1.5]]]]} if self.ctm_b_name: r1["rows"].extend([ [22, 35, [[32, 1.5, .8, "Banking Details", False]]], [22, 36.5, [[32, 5.5]]]]) doDrawTable(self.fpdf, r1, cw=cw, ld=ld, font=False) def printTotals(self, cw, ld, ica, iva): tot = [0, 0, iva.work, ica.work] if iva.work: tot[0] = float(ASD(ica.work) - ASD(iva.work)) else: tot[1] = ica.work self.fpdf.drawText(x=32*cw, y=33.2*ld, txt=CCD(tot[0],"SD",13.2).disp) self.fpdf.drawText(x=56*cw, y=33.2*ld, txt=CCD(tot[1],"SD",13.2).disp) self.fpdf.drawText(x=78*cw, y=33.2*ld, txt=CCD(tot[2],"SD",13.2).disp) self.fpdf.drawText(x=103*cw, y=33.2*ld, txt=CCD(tot[3],"SD",13.2).disp) def doPrint(self): if not self.fpdf.page: return if self.df.repeml[1] == "Y": self.df.repeml[2] = self.emadd.work key = "%s_%s_%s" % (self.opts["conum"], self.chain, self.acno) else: key = "%s_all_all" % self.opts["conum"] pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"], self.__class__.__name__, key, ext="pdf") self.fpdf.output(pdfnam, "F") doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam, header="%s Invoice" % self.opts["conam"], repprt=self.df.repprt, fromad=self.fromad, repeml=self.df.repeml) def doExit(self): self.df.closeProcess() self.opts["mf"].closeLoop()
class 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 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 gl1060(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): # Create SQL Object self.sql = Sql(self.opts["mf"].dbm, [ "assgrp", "crsmst", "ctlctl", "ctlmst", "ctlvmf", "drsmst", "drschn", "genint", "genmst", "genrcc", "rtlprm" ], prog=self.__class__.__name__) if self.sql.error: return # Check for Intercompany Facility if not self.sql.getRec("ctlmst", cols=["count(*)"], where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]: self.incoac = False else: itg = self.sql.getRec("genint", cols=["cti_inco"], where=[("cti_cono", "=", self.opts["conum"]) ]) if itg: self.incoac = [self.opts["conum"]] [self.incoac.append(coy[0]) for coy in itg] else: self.incoac = False # self.gc = GetCtl(self.opts["mf"]) return True def mainProcess(self): ctl = { "stype": "R", "tables": ("ctlctl", "genmst"), "cols": (("ctl_code", "", 0, "Ctl-Code"), ("ctl_conacc", "", 0, "G/L-Num"), ("glm_desc", "", 30, "Description")), "where": [("ctl_cono", "=", self.opts["conum"]), ("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono", ), ("glm_acno=ctl_conacc", )], "index": 1 } rcc = { "stype": "R", "tables": ("genrcc", ), "cols": (("grc_memo", "", 0, "Code"), ("grc_desc1", "", 0, "Details"), ("grc_rtn", "", 0, "R"), ("grc_acoy", "", 0, "Coy"), ("grc_aacc", "", 0, "Acc-Num"), ("grc_acrs", "", 0, "Crs-Acc"), ("grc_achn", "", 0, "Chn"), ("grc_adrs", "", 0, "Drs-Acc"), ("grc_vat", "", 0, "V")), "where": [("grc_cono", "=", self.opts["conum"])], "whera": [["T", "grc_acno", 0]] } rct = { "stype": "R", "tables": ("genrct", ), "cols": (("grt_memo", "", 75, "Details"), ("grt_amount", "SD", 13.2, "Value")), "where": [("grt_cono", "=", self.opts["conum"]), ("grt_flag", "=", "N")], "whera": [["T", "grt_acno", 0, 0]], "group": "grt_memo", "order": "grt_memo", "comnd": self.doSameField } coy = { "stype": "R", "tables": ("ctlmst", ), "cols": (("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y")) } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "whera": [["T", "glm_cono", 7]] } chn = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "whera": [["T", "chm_cono", 7]] } self.crm = { "stype": "R", "tables": ("crsmst", ), "cols": (("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y"), ("crm_add1", "", 0, "Address Line 1")), "where": [("crm_stat", "<>", "X")], "whera": [["T", "crm_cono", 7]] } self.drm = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1")), "where": [("drm_stat", "<>", "X")], "whera": [["T", "drm_cono", 7], ["T", "drm_chain", 11]] } vat = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "Acc-Num"), ("vtm_desc", "", 0, "Description", "Y")), "whera": [["T", "vtm_cono", 7]] } r1s = (("Payment", "P"), ("Receipt", "R")) r2s = (("Oldest", "O"), ("Current", "C")) fld = [[("T", 0, 0, 0), "IUI", 7, "Bank Account", "", "", "Y", self.doAccNum, ctl, None, None], (("T", 0, 0, 0), "ONA", 30, ""), [("T", 0, 1, 0), "IUI", 5, "Memo Code", "Memo Code (Blank for Next)", "", "Y", self.doMemo, rcc, None, None], [("T", 0, 2, 0), "INA", 50, "Memo Desc Contains", "", "", "N", self.doDesc1, rct, self.doDelete, ("notblank", )], (("T", 0, 3, 0), "INA", 50, " and Contains", "Desc Also Contains", "", "N", self.doDesc2, rct, None, None), (("T", 0, 4, 0), "INA", 50, " and Contains", "Desc Also Contains", "", "N", self.doDesc3, rct, None, None), (("T", 0, 5, 0), ("IRB", r1s), 0, "Transaction Type", "", "P", "N", self.doTypCod, None, None, None), (("T", 0, 6, 0), "IUI", 7, "Allocation Company", "", self.opts["conum"], "N", self.doAllCoy, coy, None, ("notzero", )), (("T", 0, 6, 0), "ONA", 30, ""), (("T", 0, 7, 0), "IUI", 7, "Allocation Account", "", "", "N", self.doAllAcc, glm, None, ("notzero", )), (("T", 0, 7, 0), "ONA", 30, ""), [["T", 0, 8, 0], "IUI", 3, "Chn", "Chain Store Code", 0, "N", self.doDrsChn, chn, None, ("efld", )], (("T", 0, 8, 0), "ONA", 30, ""), [("T", 0, 9, 0), "INA", 7, "Acc-Num", "Account Number", "", "N", self.doCrsDrsAcc, self.crm, None, ("notblank", )], (("T", 0, 9, 0), "ONA", 30, ""), (("T", 0, 10, 0), ("IRB", r2s), 0, "Ageing Code", "", "O", "N", self.doCrsDrsAge, None, None, None, None, """ The Ageing Codes are as follows: Oldest - Automatically age against the oldest outstanding transactions. Current - Do not age the transaction. """), (("T", 0, 11, 0), "INA", 1, "Vat Code", "", "", "N", self.doVatCod, vat, None, None)] but = [("Cancel", None, self.doCancel, 0, ("T", 0, 4), ("T", 0, 1)), ("Quit", None, self.doExit, 1, None, None)] if "args" in self.opts: for f in (0, 2, 3): if f == 3: fld[f][4] += "(noesc)" else: fld[f][7] = None fld[f][8] = None fld[f][9] = None del but[0] tnd = ((self.doEnd, "y"), ) txt = (self.doExit, ) if "args" in self.opts: foc = False else: foc = True self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt, focus=foc) if "args" in self.opts: self.df.loadEntry("T", 0, 0, data=self.opts["args"][0]) self.doAccNum("T", 0, 0, 1, 0, 0, self.opts["args"][0]) self.df.loadEntry("T", 0, 2, data=0) self.doMemo("T", 0, 0, 3, 2, 2, 0) self.df.loadEntry("T", 0, 3, data=self.opts["args"][1][2]) self.df.focusField("T", 0, 4) def doAccNum(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec(tables=["ctlctl", "genmst"], cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w), ("ctl_cono=glm_cono", ), ("ctl_conacc=glm_acno", ), ("ctl_code", "like", "bank_%")], limit=1) if not acc: return "Invalid Bank Account" self.acno = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doSameField(self, frt, pag, r, c, p, i, w): self.df.loadEntry("T", 0, self.df.pos, data=w[0]) self.df.focusField("T", 0, self.df.col) def doMemo(self, frt, pag, r, c, p, i, w): if not w: w = self.sql.getRec("genrcc", cols=["max(grc_memo)"], where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno)], limit=1) if not w or not w[0]: self.memo = 1 else: self.memo = w[0] + 1 self.df.loadEntry(frt, pag, p, data=self.memo) else: self.memo = w self.old = self.sql.getRec("genrcc", where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno), ("grc_memo", "=", self.memo)], limit=1) if not self.old: self.new = "y" else: self.new = "n" col = self.sql.genrcc_col self.desc1 = self.old[col.index("grc_desc1")] self.desc2 = self.old[col.index("grc_desc2")] self.desc3 = self.old[col.index("grc_desc3")] self.opts["rtn"] = self.old[col.index("grc_rtn")] self.acoy = self.old[col.index("grc_acoy")] self.aacc = self.old[col.index("grc_aacc")] self.acrs = self.old[col.index("grc_acrs")] self.achn = self.old[col.index("grc_achn")] self.aage = self.old[col.index("grc_aage")] self.adrs = self.old[col.index("grc_adrs")] self.vat = self.old[col.index("grc_vat")] self.df.loadEntry(frt, pag, 3, data=self.desc1) self.df.loadEntry(frt, pag, 4, data=self.desc2) self.df.loadEntry(frt, pag, 5, data=self.desc3) self.df.loadEntry(frt, pag, 6, data=self.opts["rtn"]) self.df.loadEntry(frt, pag, 7, data=self.acoy) self.df.loadEntry(frt, pag, 8, data=self.getCoyName()) self.df.loadEntry(frt, pag, 9, data=self.aacc) self.df.loadEntry(frt, pag, 10, data=self.getAccDesc()) # Creditor and Debtor Details if self.acrs: self.crsdrs = "crs" self.df.loadEntry(frt, pag, 11, data=0) self.df.loadEntry(frt, pag, 12, data="") self.df.loadEntry(frt, pag, 13, data=self.acrs) self.df.loadEntry(frt, pag, 14, data=self.getCrsName()) self.df.loadEntry(frt, pag, 15, data=self.aage) elif self.adrs: self.crsdrs = "drs" self.df.loadEntry(frt, pag, 11, data=self.achn) if self.achn: self.df.loadEntry(frt, pag, 12, data=self.getChainName()) else: self.df.loadEntry(frt, pag, 12, data="") self.df.loadEntry(frt, pag, 13, data=self.adrs) self.df.loadEntry(frt, pag, 14, data=self.getDrsName()) self.df.loadEntry(frt, pag, 15, data=self.aage) else: self.crsdrs = None self.df.loadEntry(frt, pag, 11, data=0) self.df.loadEntry(frt, pag, 12, data="") self.df.loadEntry(frt, pag, 13, data="") self.df.loadEntry(frt, pag, 14, data="") self.df.loadEntry(frt, pag, 15, data="") # VAT Code self.df.loadEntry(frt, pag, 16, data=self.vat) def doDesc1(self, frt, pag, r, c, p, i, w): self.desc1 = w def doDesc2(self, frt, pag, r, c, p, i, w): self.desc2 = w if not self.desc2: self.desc3 = "" self.df.loadEntry(frt, pag, p + 1, data=self.desc3) if "args" in self.opts: if self.opts["args"][1][-1] < 0: self.opts["rtn"] = "P" else: self.opts["rtn"] = "R" self.df.loadEntry(frt, pag, p + 2, data=self.opts["rtn"]) return "sk2" return "sk1" def doDesc3(self, frt, pag, r, c, p, i, w): self.desc3 = w if "args" in self.opts: if self.opts["args"][1][-1] < 0: self.opts["rtn"] = "P" else: self.opts["rtn"] = "R" self.df.loadEntry(frt, pag, p + 1, data=self.opts["rtn"]) return "sk1" def doTypCod(self, frt, pag, r, c, p, i, w): self.opts["rtn"] = w if not self.incoac: self.acoy = self.opts["conum"] if self.doChkLoadCtls(): return "rf" else: self.df.loadEntry(frt, pag, p + 1, data=self.acoy) self.df.loadEntry(frt, pag, p + 2, data=self.getCoyName()) return "sk2" def doAllCoy(self, frt, pag, r, c, p, i, w): self.acoy = w name = self.getCoyName() if not name: return "Invalid Company Number" self.df.loadEntry(frt, pag, p + 1, data=name) return self.doChkLoadCtls() def doChkLoadCtls(self): # Check for Intercompany Records if self.acoy != self.opts["conum"]: acc = self.sql.getRec("genint", where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=", self.acoy)], limit=1) if not acc: return "Invalid Company, No Intercompany Record 1" acc = self.sql.getRec("genint", where=[("cti_cono", "=", self.acoy), ("cti_inco", "=", self.opts["conum"]) ], limit=1) if not acc: return "Invalid Company, No Intercompany Record 2" # Get Company Details ctlmst = self.gc.getCtl("ctlmst", self.acoy) if not ctlmst: return "rf" # Set Company VAT Default self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" # Check for Integrated Systems mod = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): mod.append(ctlmst["ctm_modules"][x:x + 2]) # Check for Control Records e.g. VAT and Discounts self.ctlctl = self.gc.getCtl("ctlctl", self.acoy) if not self.ctlctl: return "rf" ctls = ["vat_ctl"] # Load Crs Integration if mod.count("CR"): ctl = self.gc.getCtl("crsctl", self.acoy) if not ctl: return "rf" self.crs_gl = ctl["ctc_glint"] if self.crs_gl == "Y": ctls.extend(["crs_ctl", "dis_rec"]) else: self.crs_gl = "N" # Load Drs Integration and Chain Store Flag if mod.count("DR"): ctl = self.gc.getCtl("drsctl", self.acoy) if not ctl: return "rf" self.drs_gl = ctl["ctd_glint"] self.drs_ch = ctl["ctd_chain"] if self.drs_gl == "Y": ctls.extend(["drs_ctl", "dis_all"]) else: self.drs_gl = "N" if self.gc.chkRec(self.acoy, self.ctlctl, ctls): return "rf" def doAllAcc(self, frt, pag, r, c, p, i, w): if self.acoy == self.opts["conum"] and w == self.acno: return "This is the Bank Account Number" ctl = True self.crsdrs = False if self.crs_gl == "Y" and w == self.ctlctl["crs_ctl"]: self.crsdrs = "crs" self.df.topf[0][p + 4][8] = self.crm elif self.drs_gl == "Y" and w == self.ctlctl["drs_ctl"]: self.crsdrs = "drs" self.df.topf[0][p + 4][8] = self.drm if self.crsdrs: ctl = False chk = chkGenAcc(self.opts["mf"], self.acoy, w, ctl=ctl) if type(chk) is str: return chk self.aacc = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) if self.crsdrs: if self.crsdrs == "crs" or self.drs_ch == "N": self.achn = 0 self.df.topf[0][p + 2][1] = "OUI" self.df.loadEntry(frt, pag, p + 2, data=self.achn) self.df.loadEntry(frt, pag, p + 3, data="") return "sk3" elif self.crsdrs == "drs": self.df.topf[0][p + 2][1] = "IUI" return "sk1" else: self.acrs = "" self.achn = 0 self.adrs = "" self.aage = "" self.df.loadEntry(frt, pag, p + 2, data=0) self.df.loadEntry(frt, pag, p + 3, data="") self.df.loadEntry(frt, pag, p + 4, data="") self.df.loadEntry(frt, pag, p + 5, data="") self.df.loadEntry(frt, pag, p + 6, data="") if not self.df.t_work[pag][0][p + 7]: if chk[2]: self.df.loadEntry(frt, pag, p + 7, data=chk[2]) else: self.df.loadEntry(frt, pag, p + 7, data=self.taxdf) return "sk6" def doDrsChn(self, frt, pag, r, c, p, i, w): self.achn = w name = self.getChainName() if not name: return "Invalid Account Number" self.df.loadEntry(frt, pag, p + 1, data=name) def doCrsDrsAcc(self, frt, pag, r, c, p, i, w): if self.crsdrs == "crs": self.acrs = w name = self.getCrsName() else: self.adrs = w name = self.getDrsName() if not name: return "Invalid Account Number %s" % self.crsdrs.capitalize() if name[1] == "X": return "Invalid Account %s, Redundant" % self.crsdrs.capitalize() self.df.loadEntry(frt, pag, p + 1, data=name[0]) def doCrsDrsAge(self, frt, pag, r, c, p, i, w): self.aage = w self.vat = "N" self.df.loadEntry(frt, pag, p + 1, data=self.vat) return "sk1" def doVatCod(self, frt, pag, r, c, p, i, w): vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.acoy), ("vtm_code", "=", w)], limit=1) if not vat: return "Invalid VAT Code" self.vat = w def doDelete(self): self.sql.delRec("genrcc", where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno), ("grc_memo", "=", self.memo)]) def doEnd(self): data = [ self.opts["conum"], self.acno, self.memo, self.desc1, self.desc2, self.desc3, self.opts["rtn"], self.acoy, self.aacc ] if self.crsdrs: if self.crsdrs == "crs": data.extend([self.acrs, 0, "", self.aage, self.vat]) else: data.extend(["", self.achn, self.adrs, self.aage, self.vat]) else: data.extend(["", 0, "", "", self.vat]) if self.new == "y": self.sql.insRec("genrcc", data=data) elif data != self.old[:len(data)]: col = self.sql.genrcc_col data.append(self.old[col.index("grc_xflag")]) self.sql.updRec("genrcc", data=data, where=[("grc_cono", "=", self.opts["conum"]), ("grc_acno", "=", self.acno), ("grc_memo", "=", self.memo)]) if "args" in self.opts: self.doExit() else: for x in range(2, self.df.topq[0]): self.df.loadEntry("T", 0, x, data="") self.df.focusField("T", 0, 3) def getCoyName(self): coy = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", self.acoy)], limit=1) if coy: return coy[0] def getAccDesc(self): acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.acoy), ("glm_acno", "=", self.aacc)], limit=1) if acc: return acc[0] def getCrsName(self): acc = self.sql.getRec("crsmst", cols=["crm_name", "ctm_stat"], where=[("crm_cono", "=", self.acoy), ("crm_acno", "=", self.acrs)], limit=1) if acc: return acc def getChainName(self): acc = self.sql.getRec("drschn", cols=["chm_name"], where=[("chm_cono", "=", self.acoy), ("chm_chain", "=", self.achn)], limit=1) if acc: return acc[0] def getDrsName(self): acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"], where=[("drm_cono", "=", self.acoy), ("drm_chain", "=", self.achn), ("drm_acno", "=", self.adrs)], limit=1) if acc: return acc def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doExit(self): self.opts["mf"].dbm.commitDbase() self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()
class 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 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 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 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 dr1020(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.buildScreen() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql( self.opts["mf"].dbm, ["ctlvmf", "drschn", "drsmst", "drsrcm", "drsrct", "genmst"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" drsctl = self.gc.getCtl("drsctl", self.opts["conum"]) if not drsctl: return self.glint = drsctl["ctd_glint"] self.chains = drsctl["ctd_chain"] self.glac = 0 if self.glint == "Y": ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["drs_ctl", "vat_ctl", "dis_all"] if self.gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.s_per = int(self.opts["period"][1][0] / 100) self.e_per = int(self.opts["period"][2][0] / 100) return True def buildScreen(self): num_sel = { "stype": "R", "tables": ("drsrcm", ), "cols": (("dcm_num", "", 0, "Number"), ("dcm_desc", "", 0, "Description", "Y"), ("dcm_freq", "", 0, "F")), "where": [("dcm_cono", "=", self.opts["conum"])] } seq_sel = { "stype": "R", "tables": ("drsrct", ), "cols": (("dct_seq", "", 0, "Seq"), ("dct_chain", "", 0, "Chn"), ("dct_acno", "", 0, "Acc-Num"), ("dct_detail", "", 0, "Charge Details"), ("dct_amnt", "", 0, "Amount"), ("dct_start", "", 0, "Start"), ("dct_end", "", 0, "End")), "where": [("dct_cono", "=", self.opts["conum"])], "whera": (("T", "dct_num", 0), ) } chn_sel = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } drm_sel = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y")), "where": [("drm_cono", "=", self.opts["conum"]), ("drm_stat", "<>", "X")], "whera": (("C", "drm_chain", 1, 0), ) } glm_sel = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } vat_sel = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"), ("Annually", "Y")) fld = [ (("T",0,0,0),"IUI",3, "Number","Charge Number", "","Y",self.doNum,num_sel,None,None), (("T",0,1,0),"INA",30,"Description","", "","N",self.doDesc,None,self.doDelNum,("notblank",)), (("T",0,2,0),("IRB",r1s),0, "Frequency","", "M","N",self.doFreq,None,None,None), (("T",0,3,0),"IUI",2, "Day of the Month","Day of the Month", "","N",self.doDay,num_sel,None,("between",1,30),None, "Enter the day of the month when the entry must be raised. "\ "Use 30 to denote the last day of the month.")] if self.glint == "Y": fld.append( (("T", 0, 4, 0), "IUI", 7, "Charge Account", "G/L Account", "", "N", self.doGlAc, glm_sel, None, ("notzero", ))) fld.append((("T", 0, 4, 0), "ONA", 30, "")) nxt = 5 else: nxt = 4 fld.append( (("T", 0, nxt, 0), "IUA", 1, "VAT Code", "V.A.T. Code", self.taxdf, "N", self.doVat, vat_sel, None, ("notblank", ))) fld.append((("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i", "N", self.doSeq, seq_sel, None, ("notzero", ))) if self.chains == "Y": fld.append((("C", 0, 0, 0), "IUI", 3, "Chn", "Chain Store", "", "N", self.doChn, chn_sel, self.doDelSeq, ("efld", ))) else: self.chn = 0 fld.append((("C", 0, 0, 0), "OUI", 3, "Chn")) fld.append((("C", 0, 0, 1), "INA", 7, "Acc-Num", "Account Number", "", "N", self.doAcc, drm_sel, self.doDelSeq, ("efld", ))) fld.extend( ((("C", 0, 0, 2), "ONA", 30, "Name", "", "", "N", None, None, None, None), (("C", 0, 0, 3), "ITX", 30, "Charge-Details", "Charge Details", "", "N", self.doDetail, None, None, None), (("C", 0, 0, 4), "ISD", 13.2, "Excl-Value", "Period Exclusive Value", "", "N", self.doValue, None, None, ("efld", )), (("C", 0, 0, 5), "ID2", 7, "Start", "Starting Period", "", "N", self.doStart, None, None, ("efld", )), (("C", 0, 0, 6), "ID2", 7, "End", "Ending Period", "", "N", self.doEnd, None, None, ("efld", )))) but = (("All Entries", seq_sel, None, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("Re-Sequence", None, self.doReSeq, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("Abort Changes", None, self.doAbort, 0, ("C", 0, 1), ("T", 0, 1))) tnd = ((self.endTop, "y"), ) txt = (self.exitTop, ) cnd = ((self.endCol, "y"), ) cxt = (self.exitCol, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt) def doNum(self, frt, pag, r, c, p, i, w): if not w: num = self.sql.getRec("drsrcm", cols=["max(dcm_num)"], where=[("dcm_cono", "=", self.opts["conum"]) ], limit=1) if not num or not num[0]: self.num = 1 else: self.num = num[0] + 1 self.df.loadEntry(frt, pag, p, data=self.num) else: self.num = w self.rcm = self.sql.getRec("drsrcm", where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", self.num)], limit=1) if not self.rcm: if self.num == 999: return "Invalid Number (999), Reserved for Sales Invoices" self.new_num = "y" self.nxt = 1 else: d = self.sql.drsrcm_col self.new_num = "n" self.df.loadEntry(frt, pag, p + 1, data=self.rcm[d.index("dcm_desc")]) self.df.loadEntry(frt, pag, p + 2, data=self.rcm[d.index("dcm_freq")]) self.df.loadEntry(frt, pag, p + 3, data=self.rcm[d.index("dcm_day")]) if self.glint == "Y": self.df.loadEntry(frt, pag, p + 4, data=self.rcm[d.index("dcm_glac")]) self.df.loadEntry(frt, pag, p + 5, data=self.getAccount()) self.df.loadEntry(frt, pag, p + 6, data=self.rcm[d.index("dcm_vat")]) else: self.df.loadEntry(frt, pag, p + 4, data=self.rcm[d.index("dcm_vat")]) for x in range(2): wid = getattr(self.df, "B%s" % x) self.df.setWidget(wid, "disabled") if self.num == 999: return "nd" def getAccount(self): return self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", self.df.t_work[0][0][4])], limit=1)[0] def doDelNum(self): if self.new_num == "y": return self.sql.delRec("drsrcm", where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", self.num)]) try: self.sql.delRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.acc)]) except: pass def doDesc(self, frt, pag, r, c, p, i, w): self.desc = w def doFreq(self, frt, pag, r, c, p, i, w): self.freq = w if self.glint == "N": self.vcod = self.taxdf def doDay(self, frt, pag, r, c, p, i, w): self.day = w def doGlAc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w) if type(chk) is str: return chk self.glac = w self.df.loadEntry(frt, pag, p + 1, data=chk[0]) if not chk[2]: self.vcod = self.taxdf else: self.vcod = chk[2] self.df.topf[0][4][8] = self.vcod def doVat(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1) if not acc: return "Invalid VAT Code" self.vcod = w def endTop(self): data = [ self.opts["conum"], self.num, self.desc, self.freq, self.day, self.vcod, self.glac, 0 ] if self.new_num == "y": self.sql.insRec("drsrcm", data=data) self.df.loadEntry("C", 0, 0, data=1) self.df.focusField("C", 0, self.nxt) else: if data != self.rcm[:len(data)]: col = self.sql.drsrcm_col data.append(self.rcm[col.index("dcm_xflag")]) self.sql.updRec("drsrcm", data=data, where=[("dcm_cono", "=", self.opts["conum"]), ("dcm_num", "=", self.num)]) self.doReload() def exitTop(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doSeq(self, frt, pag, r, c, p, i, w): self.seq = w self.rct = self.sql.getRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("dct_seq", "=", self.seq)], limit=1) if not self.rct: self.new_seq = "y" else: self.new_seq = "n" col = self.sql.drsrct_col self.df.loadEntry(frt, pag, p + 1, data=self.rct[col.index("dct_chain")]) self.df.loadEntry(frt, pag, p + 2, data=self.rct[col.index("dct_acno")]) acc = self.sql.getRec("drsmst", cols=["drm_name"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.rct[col.index("dct_chain")]), ("drm_acno", "=", self.rct[col.index("dct_acno")])], limit=1) self.df.loadEntry(frt, pag, p + 3, data=acc[0]) self.df.loadEntry(frt, pag, p + 4, data=self.rct[col.index("dct_detail")]) self.df.loadEntry(frt, pag, p + 5, data=self.rct[col.index("dct_amnt")]) self.df.loadEntry(frt, pag, p + 6, data=self.rct[col.index("dct_start")]) self.df.loadEntry(frt, pag, p + 7, data=self.rct[col.index("dct_end")]) def doDelSeq(self): if self.new_seq == "y": return self.sql.delRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("dct_seq", "=", self.seq)]) self.doReload() def doChn(self, frt, pag, r, c, p, i, w): if w: acc = self.sql.getRec("drschn", where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", w)], limit=1) if not acc: return "Invalid Chain Store" self.chn = w def doAcc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chn), ("drm_acno", "=", w)], limit=1) if not acc: return "Invalid Account Number" if acc[1] == "X": return "Invalid Account, Redundant" self.acc = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doDetail(self, frt, pag, r, c, p, i, w): self.det = w def doValue(self, frt, pag, r, c, p, i, w): self.val = w def doStart(self, frt, pag, r, c, p, i, w): self.start = w def doEnd(self, frt, pag, r, c, p, i, w): if w < self.start: return "Invalid End Date, Before Start" self.end = w def endCol(self): data = [ self.opts["conum"], self.num, self.seq, self.chn, self.acc, self.det, self.val, self.start, self.end ] if self.new_seq == "y": self.sql.insRec("drsrct", data=data) elif data != self.rct[:len(data)]: col = self.sql.drsrct_col data.append(self.rct[col.index("dct_xflag")]) self.sql.updRec("drsrct", data=data, where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("dct_seq", "=", self.seq)]) self.doReload() def exitCol(self): self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doReSeq(self): recs = self.sql.getRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num)], order="dct_chain, dct_acno") self.sql.delRec("drsrct", where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num)]) seq = 0 for rec in recs: seq += 1 rec[2] = seq self.sql.insRec("drsrct", data=rec) self.doReload() def doAbort(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doReload(self): self.df.clearFrame("C", 0) last = (self.df.rows[0] - 1) * 8 trn = self.sql.getRec(tables=["drsrct", "drsmst"], cols=[ "dct_seq", "dct_chain", "dct_acno", "drm_name", "dct_detail", "dct_amnt", "dct_start", "dct_end" ], where=[("dct_cono", "=", self.opts["conum"]), ("dct_num", "=", self.num), ("drm_cono=dct_cono", ), ("drm_chain=dct_chain", ), ("drm_acno=dct_acno", )], order="dct_seq") if trn: for s, t in enumerate(trn): if s >= self.df.rows[0]: self.df.scrollScreen(0) p = last else: p = s * 8 self.df.loadEntry("C", 0, p, data=t[0]) self.df.loadEntry("C", 0, p + 1, data=t[1]) self.df.loadEntry("C", 0, p + 2, data=t[2]) self.df.loadEntry("C", 0, p + 3, data=t[3]) self.df.loadEntry("C", 0, p + 4, data=t[4]) self.df.loadEntry("C", 0, p + 5, data=t[5]) self.df.loadEntry("C", 0, p + 6, data=t[6]) self.df.loadEntry("C", 0, p + 7, data=t[7]) if p == last: self.df.scrollScreen(0) self.nxt = last + 1 else: self.nxt = p + 9 else: self.nxt = 1 self.df.focusField("C", 0, self.nxt)
class wgc310(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genmst", "wagrcv", "wagedc", "wagtf2"], prog=self.__class__.__name__) if self.sql.error: return self.gc = GetCtl(self.opts["mf"]) wagctl = self.gc.getCtl("wagctl", self.opts["conum"]) if not wagctl: return self.glint = wagctl["ctw_glint"] return True def mainProcess(self): ced = { "stype": "R", "tables": ("wagedc", ), "cols": (("ced_code", "", 0, "Cde"), ("ced_desc", "", 0, "Description", "Y")), "where": [("ced_cono", "=", self.opts["conum"])], "whera": [["T", "ced_type", 0]], "order": "ced_code" } bas = { "stype": "C", "titl": "Available Base Rates", "head": ("C", "Description"), "data": ((1, "X * Normal Rate of Pay * Factor"), (2, "Normal Pay * Factor"), (3, "Normal Pay * Factor / 100"), (4, "X * Daily Rate of Pay * Factor"), (5, "X * Hourly Rate of Pay * Factor"), (6, "U.I.F. Pay * Factor"), (7, "S.D.L. Pay * Factor")) } coy = { "stype": "R", "tables": ("ctlmst", ), "cols": (("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y")) } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } rcv = { "stype": "R", "tables": ("wagrcv", ), "cols": (("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details", "Y")) } r1s = (("Variable", "V"), ("Fixed", "F")) r2s = (("Amount", "A"), ("Rate", "R")) r3s = (("Salary", "S"), ("Commission", "C")) r4s = (("Amount", "A"), ("Rate", "R"), ("None", "N")) r5s = (("Yes", "Y"), ("No", "N"), ("Notional", "T"), ("One Time", "O"), ("Retrench", "R")) r6s = (("Yes", "Y"), ("No", "N")) tag = (("Detail-_A", None, ("T", 0, 0), ("T", 0, 1)), ("Detail-_B", None, ("T", 0, 0), ("T", 0, 1))) self.fld = ((("T", 0, 0, 0), "IUA", 1, "Type", "Earning/Deduction Type", "E", "N", self.doType, None, None, ("in", ("E", "D"))), (("T", 0, 0, 0), "IUI", 3, "Code", "", "", "N", self.doCode, ced, None, ("notzero", )), (("T", 0, 0, 0), "ONA", 30, "Description"), (("T", 1, 0, 0), "INA", 30, "Description", "", "", "N", self.doDesc, None, self.doDelete, ("notblank", )), (("T", 1, 1, 0), ("IRB", r1s), 0, "Type", "", "V", "N", None, None, None, None), (("T", 1, 2, 0), ("IRB", r2s), 0, "Employee Portion", "", "A", "N", self.doEmployeePortion, None, None, None), (("T", 1, 3, 0), "IUI", 3, " Base", "", "", "N", self.doEmployeeBase, bas, None, ("between", 0, 7)), (("T", 1, 4, 0), "IUD", 8.2, " Value", "", "", "N", self.doValue, None, None, ("efld", )), (("T", 1, 5, 0), "IUD", 8.2, " Limit", "", "", "N", self.doElim, None, None, ("efld", )), (("T", 1, 6, 0), "IUI", 3, " GL/Cono", "", "", "N", self.doEglco, coy, None, ("efld", )), (("T", 1, 6, 0), "IUI", 7, " GL/Acno", "", "", "N", self.doEglno, glm, None, ("efld", )), (("T", 1, 7, 0), ("IRB", r3s), 0, "Earnings Type", "", "S", "N", self.doEarnType, None, None, None), (("T", 1, 8, 0), ("IRB", r4s), 0, "Employer Portion", "", "N", "N", self.doEmployerPortion, None, None, None), (("T", 1, 9, 0), "IUI", 3, " Base", "Base", "", "N", self.doEmployerBase, bas, None, ("between", 0, 7)), (("T", 1, 10, 0), "IUD", 8.2, " Value", "", "", "N", None, None, None, ("efld", )), (("T", 1, 11, 0), "IUD", 8.2, " Limit", "", "", "N", self.doRlim, None, None, ("efld", )), (("T", 1, 12, 0), "IUI", 3, " GL/Cono", "", "", "N", self.doRglco, coy, None, ("efld", )), (("T", 1, 12, 0), "IUI", 7, " GL/Acno", "", "", "N", self.doRglno, glm, None, ("efld", )), (("T", 1, 13, 0), ("IRB", r5s), 0, "Tax Code", "", "N", "N", self.doTaxcode, None, None, None), (("T", 1, 14, 0), "IUD", 6.2, "Tax Portion", "", "", "N", self.doTaxportion, None, None, ("efld", )), (("T", 2, 0, 0), "IUI", 4, "Rec Of Rev Code", "", "", "N", self.doRcv, rcv, None, ("notzero", )), (("T", 2, 0, 0), "ONA", 30, ""), (("T", 2, 1, 0), ("IRB", r6s), 0, "Union Report", "", "N", "N", self.doUniRep, None, None, None), (("T", 2, 2, 0), ("IRB", r6s), 0, "Must Pay", "", "N", "N", None, None, None, None), (("T", 2, 3, 0), "IUI", 2, "Balance Number", "", "", "N", self.doBalNo, None, None, ("between", 0, 3)), (("T", 2, 4, 0), "IUD", 5.2, "Hourly Limit", "", "", "N", self.doLimit, None, None, ("efld", )), (("T", 2, 5, 0), ("IRB", r6s), 0, "Monthly Deduction", "", "N", "N", self.doMthly, None, None, None), (("T", 2, 6, 0), "IUD", 6.2, "UIF Percentage", "", "", "N", None, None, None, ("efld", )), (("T", 2, 7, 0), "IUD", 6.2, "SDL Percentage", "", "", "N", None, None, None, ("efld", ))) but = (("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 0)), ("Cancel", None, self.doCancel, 0, ("T", 1, 1), ("T", 0, 0)), ("Quit", None, self.doExit0, 1, None, None)) tnd = ((self.doEnd0, "N"), (self.doEnd1, "N"), (self.doEnd2, "Y")) txt = (self.doExit0, self.doExit1, self.doExit2) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, tags=tag, butt=but, tend=tnd, txit=txt) def doType(self, frt, pag, r, c, p, i, w): self.rtype = w if self.rtype == "E": self.df.topf[1][15][5] = "Y" else: self.df.topf[1][15][5] = "Y" def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.acc = self.sql.getRec("wagedc", where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", self.rtype), ("ced_code", "=", self.code)], limit=1) if not self.acc: self.new = True if self.rtype == "D" and self.code == 1: showInfo(self.opts["mf"].body, "PAYE", "This code is Reserved for PAYE Deductions") elif self.rtype == "D" and self.code == 2: showInfo(self.opts["mf"].body, "UIF", "This code is Reserved for UIF Deductions") else: self.new = False d = 3 self.df.loadEntry(frt, pag, p + 1, data=self.acc[d]) for pg in range(1, self.df.pgs + 1): for x in range(0, self.df.topq[pg]): if pg == 2 and x == 1: continue self.df.loadEntry("T", pg, x, data=self.acc[d]) if pg == 2 and not x: ror = self.sql.getRec("wagrcv", limit=1, cols=["rcv_desc"], where=[("rcv_code", "=", self.acc[d])]) if not ror: desc = "" else: desc = ror[0] self.df.loadEntry("T", 2, 1, data=desc) d = d + 1 def doDesc(self, frt, pag, r, c, p, i, w): self.df.loadEntry("T", 0, 2, data=self.df.t_disp[1][0][0]) if self.rtype == "E" and self.code < 6: self.df.loadEntry("T", 1, p + 1, data="V") self.df.loadEntry("T", 1, p + 2, data="R") if self.code == 5: self.df.loadEntry("T", 1, p + 3, data=4) else: self.df.loadEntry("T", 1, p + 3, data=1) if self.code in (1, 5): self.df.loadEntry("T", 1, p + 4, data=1) self.df.loadEntry("T", 1, p + 5, data=0) if self.glint != "Y": self.df.loadEntry("T", 1, p + 6, data=0) self.df.loadEntry("T", 1, p + 7, data=0) self.df.loadEntry("T", 1, p + 8, data="S") return "sk8" else: return "sk5" else: return "sk3" elif self.rtype == "D" and self.code in (1, 2): if self.code == 1: self.df.loadEntry("T", 1, 1, data="V") self.df.loadEntry("T", 1, 2, data="R") if self.glint != "Y": self.df.loadEntry("T", 1, p + 6, data=0) self.df.loadEntry("T", 1, p + 7, data=0) self.df.loadEntry("T", 1, p + 9, data="N") self.df.loadEntry("T", 1, p + 15, data="N") return "nd" return "sk5" elif self.code == 2: self.df.loadEntry("T", 1, 1, data="V") self.df.loadEntry("T", 1, 2, data="R") self.df.loadEntry("T", 1, 3, data=6) return "sk3" def doDelete(self): t = self.sql.getRec("wagtf2", cols=["count(*)"], where=[("wt2_cono", "=", self.opts["conum"]), ("wt2_type", "=", self.rtype), ("wt2_code", "=", self.code)], limit=1) if t[0]: return "Transactions Exist, Not Deleted" self.sql.delRec("wagedc", where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", self.rtype), ("ced_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doEmployeePortion(self, frt, pag, r, c, p, i, w): if w == "A": self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doEmployeeBase(self, frt, pag, r, c, p, i, w): if w > 7: return "Invalid Employee Base" def doValue(self, frt, pag, r, c, p, i, w): self.value = w if self.rtype == "E" and self.code < 6: self.df.loadEntry("T", 1, p + 1, data=0) if self.glint != "Y": self.df.loadEntry("T", 1, p + 2, data=0) self.df.loadEntry("T", 1, p + 3, data=0) self.df.loadEntry("T", 1, p + 4, data="S") return "sk3" else: return "sk1" def doElim(self, frt, pag, r, c, p, i, w): self.elim = w if self.glint != "Y": self.df.loadEntry("T", 1, p + 1, data=0) self.df.loadEntry("T", 1, p + 2, data=0) if self.rtype == "E": return "sk2" else: self.df.loadEntry("T", 1, p + 3, data="") return "sk3" def doEglco(self, frt, pag, r, c, p, i, w): if self.rtype == "E" and self.code < 6 and not w: # Use department code for integration self.eglco = w self.df.loadEntry("T", 1, p + 1, data=0) self.df.loadEntry("T", 1, p + 2, data="S") self.df.loadEntry("T", 1, p + 9, data="Y") self.df.loadEntry("T", 1, p + 10, data=100.00) return "sk10" if w: self.eglco = w else: self.eglco = self.opts["conum"] name = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", self.eglco)], limit=1) if not name: return "Invalid Company" def doEglno(self, frt, pag, r, c, p, i, w): if self.rtype == "D": ctl = self.gc.getCtl("ctlctl", self.eglco) if ctl and not self.gc.chkRec(self.eglco, ctl, ["wag_slc"]): sln = ctl["wag_slc"] else: sln = None else: sln = None if w and w != sln: chk = chkGenAcc(self.opts["mf"], self.eglco, w) if type(chk) is str: return chk self.eglno = w if self.rtype == "D": if self.code == 2: self.df.loadEntry(frt, pag, 9, data="R") self.df.loadEntry(frt, pag, 10, data=6) self.df.loadEntry(frt, pag, 11, data=self.value) self.df.loadEntry(frt, pag, 12, data=self.elim) self.df.loadEntry(frt, pag, 13, data=self.eglco) self.df.loadEntry(frt, pag, 14, data=self.eglno) return "sk7" else: return "sk1" if self.code < 6: self.df.loadEntry("T", 1, p + 1, data="S") self.df.loadEntry("T", 1, p + 8, data="Y") self.df.loadEntry("T", 1, p + 9, data=100.00) return "sk9" def doEarnType(self, frt, pag, r, c, p, i, w): if self.rtype == "E": return "sk6" def doEmployerPortion(self, frt, pag, r, c, p, i, w): if w == "N": for x in range(1, 6): self.df.loadEntry(frt, pag, p + x, data=0) return "sk5" if w == "A": self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doEmployerBase(self, frt, pag, r, c, p, i, w): if w > 7: return "Invalid Employer Base" def doRlim(self, frt, pag, r, c, p, i, w): if self.glint != "Y": return "sk2" def doRglco(self, frt, pag, r, c, p, i, w): if not w: w = self.opts["conum"] name = self.sql.getRec("ctlmst", cols=["ctm_name"], where=[("ctm_cono", "=", w)], limit=1) if not name: return "Invalid Company" self.rglco = w def doRglno(self, frt, pag, r, c, p, i, w): if w: chk = chkGenAcc(self.opts["mf"], self.rglco, w) if type(chk) is str: return chk def doTaxcode(self, frt, pag, r, c, p, i, w): if self.rtype == "D" and w not in ("Y", "T", "N"): return "Invalid Selection" if w == "N": self.df.loadEntry("T", pag, p + 1, data=0) return "sk1" if self.glint == "Y" and not self.eglno and w != "T": return "ff8|Invalid G/L Account Number" def doTaxportion(self, frt, pag, r, c, p, i, w): if not w: return "Invalid Tax Portion" def doRcv(self, frt, pag, r, c, p, i, w): if w == 4101: return "SITE Code Not Allowed" acc = self.sql.getRec("wagrcv", cols=["rcv_desc"], where=[("rcv_code", "=", w)], limit=1) if not acc: return "Invalid Rec of Rev Code" else: self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doUniRep(self, frt, pag, r, c, p, i, w): self.df.loadEntry(frt, pag, p + 1, data="N") if self.rtype == "E": if self.code in (1, 2, 3, 4, 5): self.df.loadEntry(frt, pag, p + 2, data=0) self.df.loadEntry(frt, pag, p + 3, data=0) self.df.loadEntry(frt, pag, p + 4, data="N") self.df.loadEntry(frt, pag, p + 5, data=100.00) return "sk5" return "sk4" return "sk1" def doBalNo(self, frt, pag, r, c, p, i, w): if self.rtype == "E": self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 2, data="N") self.df.loadEntry(frt, pag, p + 3, data="N") return "sk3" def doLimit(self, frt, pag, r, c, p, i, w): pass def doMthly(self, frt, pag, r, c, p, i, w): self.df.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doEnd0(self): self.df.focusField("T", 1, 1, clr=self.new) def doEnd1(self): self.df.selPage("Detail-B") self.df.focusField("T", 2, 1, clr=self.new) def doEnd2(self): dat = [self.opts["conum"]] for x in range(0, 2): dat.append(self.df.t_work[0][0][x]) for x in range(0, len(self.df.t_work[1][0])): dat.append(self.df.t_work[1][0][x]) for x in range(0, len(self.df.t_work[2][0])): if x in (0, 2, 3, 4, 5, 6, 7, 8): dat.append(self.df.t_work[2][0][x]) if self.new: self.sql.insRec("wagedc", data=dat) elif dat != self.acc[:len(dat)]: col = self.sql.wagedc_col dat.append(self.acc[col.index("ced_xflag")]) self.sql.updRec("wagedc", data=dat, where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=", self.rtype), ("ced_code", "=", self.code)]) self.opts["mf"].dbm.commitDbase() self.df.last[0] = [0, 0] self.df.selPage("Detail-A") self.df.focusField("T", 0, 1) def doAccept(self): if self.rtype == "D": frt, pag, col, mes = self.df.doCheckFields(("T", 0, None)) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14))) if not mes: if self.df.t_work[1][0][15] not in ("Y", "N", "T", "O", "R"): frt = "T" pag = 1 col = 15 mes = "Invalid Tax Code Selection" if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 1, (16, ))) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 2, (0, 2, 3, 4, 5, 6))) else: frt, pag, col, mes = self.df.doCheckFields(("T", 0, None)) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 8, 15, 16))) if not mes: frt, pag, col, mes = self.df.doCheckFields( ("T", 2, (0, 2, 3))) if mes: if pag > 0 and pag != self.df.pag: if frt == "T": self.df.last[pag][0] = col + 1 else: self.df.last[pag][1] = col + 1 self.df.selPage(self.df.tags[pag - 1][0]) self.df.focusField(frt, pag, (col + 1), err=mes) else: self.doEnd2() def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.focusField("T", 0, 1) def doExit0(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doExit1(self): self.df.focusField("T", 0, 1) def doExit2(self): self.df.selPage("Detail-A")
class 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 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 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 msy010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): if "args" in self.opts: self.final = self.opts["args"] self.doEnd() else: self.drawScreen() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): self.gc = GetCtl(self.opts["mf"]) ctlsys = self.gc.getCtl("ctlsys", self.opts["conum"]) if not ctlsys: return self.years = ctlsys["sys_years"] if self.years and self.years < 7: showError( self.opts["mf"].body, "History", """At least 7 years history should be retained. Please select Control --> System Record Maintenance and change the Years to Keep field""" ) return ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return tabs = ["ctlsys", "ctlynd", "ftable"] self.mod = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): self.mod.append(ctlmst["ctm_modules"][x:x + 2]) if "AR" in self.mod: tabs.append("assctl") if "CR" in self.mod: tabs.append("crsage") if "DR" in self.mod: tabs.append("drsage") if "GL" in self.mod: ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return if self.gc.chkRec(self.opts["conum"], ctlctl, ["ret_inc"]): return self.ri_acc = ctlctl["ret_inc"] tabs.extend(["genbal", "genmst", "gentrn"]) if "LN" in self.mod: tabs.append("lonctl") if "ML" in self.mod: tabs.append("memage") tabs.append("memctl") if "RC" in self.mod: tabs.append("rcactl") if "RT" in self.mod: tabs.append("rtlctl") if "WG" in self.mod: tabs.append("wagctl") self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) if self.sql.error: return t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] self.c_per = int(self.opts["period"][0]) self.start = self.opts["period"][1][0] self.end = self.opts["period"][2][0] self.cur = int(self.opts["period"][2][0] / 100) self.l_per = self.sql.getRec("ctlynd", cols=["max(cye_period)"], where=[("cye_cono", "=", self.opts["conum"])], limit=1)[0] self.last, self.oldf = self.sql.getRec( "ctlynd", cols=["cye_last", "cye_final"], where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", self.opts["period"][0])], limit=1)[:2] if self.oldf == "Y" and "args" not in self.opts: cf = PwdConfirm(self.opts["mf"], conum=0, system="MST", code="YearEnd") if cf.pwd and cf.flag == "ok": return True if not cf.pwd: showError(self.opts["mf"].body, "Year-End Error", "This Period Has Already Been Finalised") return return True def drawScreen(self): r1s = (("Yes", "Y"), ("No", "N")) fld = [ (("T", 0, 0, 0), "OD1", 10, "Starting Date", "", self.start, "N", None, None, None, None, ("efld", )), [("T", 0, 1, 0), "ID1", 10, "Ending Date ", "Ending Date", self.end, "N", self.doDate, None, None, None, ("efld", )], (("T", 0, 2, 0), ("IRB", r1s), 0, "Finalise", "", self.oldf, "N", self.doFinal, None, None, None, None, """Finalising a financial period prevents any further data capture for that period as well as any previous periods i.e. if you finalise a period all previous financial periods are also automatically finalised.""" ) ] if self.last: fld[1][1] = "OD1" self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=((self.doEnd, "y"), ), txit=(self.doExit, )) def doDate(self, frt, pag, r, c, p, i, w): if w <= self.start: return "Invalid Year End Date" self.end = w self.cur = int(w / 100) def doFinal(self, frt, pag, r, c, p, i, w): if w == "Y": if "AR" in self.mod: c = self.gc.getCtl("assctl", self.opts["conum"]) if not c: return "Missing Asset Control" if c["cta_glint"] == "Y" and c["cta_lastp"] < self.cur: return "Depreciation Has Not Been Raised for Assets" if "LN" in self.mod: c = self.gc.getCtl("lonctl", self.opts["conum"]) if not c: return "Missing Loans Control" lst = c["cln_last"] glt = c["cln_glint"] drt = c["cln_drte"] crt = c["cln_crte"] lst = c["cln_last"] if glt == "Y" and (drt or crt) and lst < self.end: return "Interest Has Not Been Raised for Loans" if "ML" in self.mod: c = self.gc.getCtl("memctl", self.opts["conum"]) if not c: return "Missing Members Control" if c["mcm_glint"] == "Y" and c["mcm_lme"] < self.end: return "A Month-End Has Not Been Completed for Members" if "RC" in self.mod: c = self.gc.getCtl("rcactl", self.opts["conum"]) if not c: return "Missing Rentals Control" if c["cte_glint"] == "Y" and c["cte_lme"] < self.end: return "A Month-End Has Not Been Completed for Rentals" if "RT" in self.mod: c = self.gc.getCtl("rtlctl", self.opts["conum"]) if not c: return "Missing Rentals Control" if c["ctr_glint"] == "Y" and c["ctr_lme"] < self.end: return "A Month-End Has Not Been Completed for Rentals" if "WG" in self.mod: c = self.gc.getCtl("wagctl", self.opts["conum"]) if not c: return "Missing Salaries Control" glt = c["ctw_glint"] rte = c["ctw_i_rate"] lst = c["ctw_i_date"] if glt == "Y" and rte and lst < self.end: return "Interest Has Not Been Raised for Staff Loans" self.final = w def doEnd(self): if "args" not in self.opts: self.df.closeProcess() pb = ProgressBar(self.opts["mf"].body, mxs=self.c_per, typ=("F", "Processing Periods")) for per in range(0, self.c_per + 1): if "args" not in self.opts: pb.displayProgress(per) chk = self.sql.getRec("ctlynd", cols=["cye_final"], where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", per)], limit=1) if self.oldf == "Y" or chk[0] != "Y": self.retinc = 0 self.doYearEnd(per) if "args" not in self.opts: pb.closeProgress() if self.years: self.doDropYears() self.opts["mf"].dbm.commitDbase() if "args" not in self.opts: self.doExit() def doYearEnd(self, per): self.sql.updRec("ctlynd", cols=["cye_last", "cye_final"], data=[self.sysdtw, self.final], where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", per)]) if per == self.c_per: start_c = self.start end_c = self.end if (per + 1) > self.l_per: newy = int(end_c / 10000) newm = (int(end_c / 100) % 100) + 1 if newm > 12: newy += 1 newm -= 12 news = (newy * 10000) + (newm * 100) + 1 newy = int(end_c / 10000) + 1 newm = int(end_c / 100) % 100 newe = (newy * 10000) + (newm * 100) + 1 newe = mthendDate(newe) self.sql.insRec( "ctlynd", data=[self.opts["conum"], (per + 1), news, newe, 0, "N"]) else: s, e, f = getPeriods(self.opts["mf"], self.opts["conum"], per) if s is None or e is None: return start_c = s.work end_c = e.work sp = int(start_c / 100) ep = int(end_c / 100) s, e, f = getPeriods(self.opts["mf"], self.opts["conum"], (per + 1)) start_n = s.work if "GL" not in self.mod: return self.sql.delRec("genbal", where=[("glo_cono", "=", self.opts["conum"]), ("glo_trdt", "=", start_n)]) gm = self.sql.getRec("genmst", cols=["glm_acno, glm_type"], where=[("glm_cono", "=", self.opts["conum"])]) if gm: for ac in gm: ov = self.sql.getRec("genbal", cols=["glo_cyr"], where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", ac[0]), ("glo_trdt", "=", start_c)], limit=1) if not ov: ov = CCD(0, "SD", 13.2) else: ov = CCD(ov[0], "SD", 13.2) cy = self.sql.getRec("gentrn", cols=["round(sum(glt_tramt), 2)"], where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", ac[0]), ("glt_curdt", "between", sp, ep)], limit=1) if not cy[0]: cy = CCD(0, "SD", 13.2) else: cy = CCD(cy[0], "SD", 13.2) bal = float(ASD(ov.work) + ASD(cy.work)) if ac[1] == "P": self.retinc = float(ASD(self.retinc) + ASD(bal)) bal = 0.00 self.sql.insRec("genbal", data=[self.opts["conum"], ac[0], start_n, bal]) ri_bal = self.sql.getRec("genbal", cols=["glo_cyr"], where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", self.ri_acc), ("glo_trdt", "=", start_n)], limit=1) if not ri_bal: self.sql.insRec("genbal", data=[ self.opts["conum"], self.ri_acc, start_n, self.retinc ]) else: bal = float(ASD(ri_bal[0]) + ASD(self.retinc)) self.sql.updRec("genbal", cols=["glo_cyr"], data=[bal], where=[("glo_cono", "=", self.opts["conum"]), ("glo_acno", "=", self.ri_acc), ("glo_trdt", "=", start_n)]) def doDropYears(self): """ TABLES is a list of tables to be actioned as follows: [tran_table, date_column, [amount columns], mfile_table] """ TABLES = [["asstrn", "ast_curdt", ["ast_amt1", "ast_amt2"], "assmst"], ["bkmtrn", "bkt_curdt", ["bkt_tramt"], "bkmmst"], ["chglog"], ["crspay", "cpt_date", []], ["crstrn", "crt_curdt", ["crt_tramt"], "crsmst"], ["ctlbat", "btm_curdt", []], ["ctllog"], ["ctlnot"], ["ctlvtf", "vtt_curdt", []], ["drstrn", "drt_curdt", ["drt_tramt"], "drsmst"], ["emllog"], ["genbal", "glo_trdt", []], ["genbud", "glb_curdt", []], ["gendtt", "gdt_curdt", []], ["genrct", "grt_date", []], ["gentrn", "glt_curdt", ["glt_tramt"], "genmst"], ["lontrn", "lnt_curdt", ["lnt_tramt"], "lonmf2"], ["memtrn", "mlt_curdt", ["mlt_tramt"], "memmst"], ["memtrs", "mst_trdt", []], ["rcaowt", "rot_curdt", ["rot_tramt"], "rcaowm"], ["rcatnt", "rtu_curdt", ["rtu_tramt"], "rcatnm"], ["rtltrn", "rtt_curdt", ["rtt_tramt"], "rtlmst"], ["slsiv1", "si1_date", []], ["strpom", "pom_date", []], ["strtrn", "stt_curdt", ["stt_qty", "stt_cost"], "strmf1"], ["wagltf", "wlt_curdt", ["wlt_amt"], "waglmf"], ["wagtf1", "wt1_date", []], ["wagtf2", "wt2_date", []]] ynds = self.sql.getRec("ctlynd", where=[("cye_cono", "=", self.opts["conum"])], order="cye_period") if len(ynds) <= self.years: return last = ynds[len(ynds) - (self.years + 1)] sdate = last[self.sql.ctlynd_col.index("cye_start")] edate = last[self.sql.ctlynd_col.index("cye_end")] etime = (edate * 10000) + 9999 emldt = "%04i-%02i-99 99:99" % (int(edate / 10000), (int(edate / 100) % 100)) ecurdt = int(edate / 100) count = 0 for ynd in ynds: if ynd[1] < last[1]: self.sql.delRec("ctlynd", where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", ynd[1])]) else: self.sql.updRec("ctlynd", cols=["cye_period"], data=[count], where=[("cye_cono", "=", self.opts["conum"]), ("cye_period", "=", ynd[1])]) count += 1 tables = self.sql.getRec("ftable", order="ft_tabl") ourtab = [] for tab in tables: ourtab.append(tab[0]) tabs = list(tabdic.keys()) if "args" not in self.opts: pb = ProgressBar(self.opts["mf"].body, typ=("G", "Dropping Periods Older Than %s Years" % self.years)) sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__) for tab in TABLES: if "args" not in self.opts: pb.displayProgress() if tab[0] not in ourtab: continue if tab[0] == "chglog": key = "%03i%s" % (self.opts["conum"], "%") sql.delRec(tab[0], where=[("chg_key", "like", key), ("chg_dte", "<=", etime)]) continue if tab[0] == "ctllog": sql.delRec(tab[0], where=[("clg_start", "<=", etime)]) continue if tab[0] == "ctlnot": sql.delRec(tab[0], where=[("not_cono", "=", self.opts["conum"]), ("not_date", "<=", edate)]) continue if tab[0] == "emllog": sql.delRec(tab[0], where=[("eml_dtt", "<=", emldt)]) continue ftt = self.sql.getRec("ftable", where=[("ft_tabl", "=", tab[0])]) pfxt = ftt[0][4].split("_")[0] coyt = None for k in ftt: for f in k[4:]: if f.count("_cono"): coyt = f break if coyt: break if coyt: whrt = [(coyt, "=", self.opts["conum"])] else: whrt = [] if tab[2]: ftm = self.sql.getRec("ftable", where=[("ft_tabl", "=", tab[3]), ("ft_seq=1", )], limit=1) pfxm = ftm[4].split("_")[0] keyt = [] keym = [] coym = None for c in ftm[4:]: if c: if c.count("_cono"): coym = c keym.append(c) t = c.replace(pfxm, pfxt) keyt.append(t) if coym: whrm = [(coym, "=", self.opts["conum"])] else: whrm = [] if not tab[2]: if tab[1].count("_curdt"): whrt.append((tab[1], "<=", ecurdt)) sql.delRec(tab[0], where=whrt) elif tab[0] == "crspay": whrt.extend([("cpt_date", "<=", edate), ("cpt_flag", "=", "Y")]) sql.delRec(tab[0], where=whrt) elif tab[0] == "drsrcm": whrt.append((tab[1], "<=", ecurdt)) recs = sql.getRec(tables=tab[0], where=whrt) for num, rec in enumerate(recs): if "args" not in self.opts and not num % 10: pb.displayProgress() sql.delRec(tab[0], where=[("dcm_cono", "=", rec[0]), ("dcm_num", "=", rec[1])]) sql.delRec("drsrct", where=[("dct_cono", "=", rec[0]), ("dct_num", "=", rec[1])]) elif tab[0] == "genbal": whrt.append((tab[1], "<=", sdate)) sql.delRec(tab[0], where=whrt) elif tab[0] == "genrct": whrt.append((tab[1], "<=", sdate)) sql.delRec(tab[0], where=whrt) elif tab[0] == "memtrs": whrt.append((tab[1], "<=", sdate)) sql.delRec(tab[0], where=whrt) elif tab[0] == "strpom": whrt.append((tab[1], "<=", edate)) recs = sql.getRec(tables=tab[0], where=whrt) for num, rec in enumerate(recs): if "args" not in self.opts and not num % 10: pb.displayProgress() sql.delRec(tab[0], where=[("pom_cono", "=", rec[0]), ("pom_ordno", "=", rec[1])]) sql.delRec("strpot", where=[("pot_cono", "=", rec[0]), ("pot_ordno", "=", rec[1])]) elif tab[0] == "slsiv1": whrt.append((tab[1], "<=", edate)) recs = sql.getRec(tables=tab[0], where=whrt) for num, rec in enumerate(recs): if "args" not in self.opts and not num % 10: pb.displayProgress() sql.delRec(tab[0], where=[("si1_cono", "=", rec[0]), ("si1_rtn", "=", rec[1]), ("si1_docno", "=", rec[2])]) sql.delRec("slsiv2", where=[("si2_cono", "=", rec[0]), ("si2_rtn", "=", rec[1]), ("si2_docno", "=", rec[2])]) sql.delRec("slsiv3", where=[("si3_cono", "=", rec[0]), ("si3_rtn", "=", rec[1]), ("si3_docno", "=", rec[2])]) elif tab[0] == "strpom": whrt.append((tab[1], "<=", edate)) recs = sql.getRec(tables=tab[0], where=whrt) for num, rec in enumerate(recs): if "args" not in self.opts and not num % 10: pb.displayProgress() sql.delRec(tab[0], where=[("pom_cono", "=", rec[0]), ("pom_ordno", "=", rec[1])]) sql.delRec("strpot", where=[("pot_cono", "=", rec[0]), ("pot_ordno", "=", rec[1])]) elif tab[0] == "wagtf1": whrt.append((tab[1], "<=", sdate)) sql.delRec(tab[0], where=whrt) elif tab[0] == "wagtf2": whrt.append((tab[1], "<=", sdate)) sql.delRec(tab[0], where=whrt) else: recs = sql.getRec(tables=tab[3], where=whrm) for num, rec in enumerate(recs): if "args" not in self.opts and not num % 10: pb.displayProgress() whr = copyList(whrt) for k in keyt: if not k.count("_cono"): dat = rec[getattr(sql, "%s_col" % tab[0]).index(k)] whr.append((k, '=', dat)) if tab[0] == "asstrn": whr.append(("ast_mtyp", "<>", 1)) col = ["ast_mtyp"] grp = "ast_cono, ast_group, ast_code, ast_mtyp" lim = 0 elif tab[0] == "rcatnt": col = ["rtu_cnum", "rtu_mtyp"] grp = "rtu_cono, rtu_owner, rtu_code, rtu_acno, "\ "rtu_cnum, rtu_mtyp" lim = 0 elif tab[0] == "rtltrn": col = ["rtt_cnum"] grp = "rtt_cono, rtt_code, rtt_acno, rtt_cnum" lim = 0 elif tab[0] == "strtrn": col = ["stt_loc"] grp = "stt_cono, stt_group, stt_code, stt_loc" lim = 0 elif tab[0] == "wagltf": mt = sql.getRec("wagltf", cols=["wlt_loan", "max(wlt_curdt)"], where=[("wlt_cono", "=", rec[0]), ("wlt_empno", "=", rec[1])], group="wlt_cono, wlt_empno, wlt_loan", order="wlt_cono, wlt_empno, wlt_loan") for m in mt: if m[1] >= ecurdt: continue b = sql.getRec("wagltf", cols=["sum(wlt_amt)"], where=[("wlt_cono", "=", rec[0]), ("wlt_empno", "=", rec[1]), ("wlt_loan", "=", m[0])], limit=1) if not b[0]: continue sql.delRec("waglmf", where=[("wlm_cono", "=", rec[0]), ("wlm_empno", "=", rec[1]), ("wlm_loan", "=", m[0])]) sql.delRec("wagltf", where=[("wlt_cono", "=", rec[0]), ("wlt_empno", "=", rec[1]), ("wlt_loan", "=", m[0])]) continue else: col = [] grp = None lim = 1 for c in tab[2]: col.append("sum(%s)" % c) whr.append((tab[1], "<=", ecurdt)) bals = sql.getRec(tables=tab[0], cols=col, where=whr, group=grp, order=grp, limit=lim) if not bals: continue sql.delRec(tab[0], where=whr) if tab[0] == "asstrn": from tartanWork import armvtp for bal in bals: # Create Transactions if not bal[1] and not bal[2]: continue data = rec[:3] data.extend([ 3, "Bal-Fwd", "Bal-Fwd", edate, bal[0], bal[1], bal[2], 0, ecurdt, "%s Brought Forward" % armvtp[bal[0] - 1][1], "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) elif tab[0] == "bkmtrn" and bals[0]: data = rec[:2] data.extend([ 5, "Bal-Fwd", "Bal-Fwd", edate, "", bals[0], 0, ecurdt, "Brought Forward", "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) elif tab[0] == "crstrn" and bals[0]: data = rec[:2] data.extend([ 3, "Bal-Fwd", "Bal-Fwd", edate, "", bals[0], 0, 0, ecurdt, self.sysdtw, "Y", bals[0], "Brought Forward", "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) # Re-Age Transactions doAutoAge(self.opts["mf"].dbm, "crs", rec[0], rec[1]) elif tab[0] == "drstrn" and bals[0]: data = rec[:3] data.extend([ 3, "Bal-Fwd", "Bal-Fwd", edate, "", bals[0], 0, ecurdt, "Brought Forward", "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) # Re-Age Transactions doAutoAge(self.opts["mf"].dbm, "drs", rec[0], rec[1], rec[2]) elif tab[0] == "gentrn" and bals[0]: continue elif tab[0] == "memtrn" and bals[0]: data = rec[:2] data.extend([ 3, "Bal-Fwd", "Bal-Fwd", edate, bals[0], 0, ecurdt, "", 0, "Brought Forward", "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) # Re-Age Transactions doAutoAge(self.opts["mf"].dbm, "mem", rec[0], rec[1]) elif tab[0] == "rcaowt" and bals[0]: data = rec[:2] data.extend([ 4, "Bal-Fwd", "Bal-Fwd", edate, bals[0], 0, ecurdt, "Brought Forward", "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) elif tab[0] == "rcatnt": from tartanWork import rcmvtp for bal in bals: # Create Transactions if not bal[2]: continue data = rec[:4] data.extend([ bal[0], 4, "Bal-Fwd", "Bal-Fwd", edate, bal[1], bal[2], 0, ecurdt, "%s Brought Forward" % rcmvtp[bal[1] - 1][1], "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) elif tab[0] == "rtltrn": for bal in bals: # Create Transactions if not bal[1]: continue data = rec[:3] data.extend([ bal[0], 4, "Bal-Fwd", "Bal-Fwd", edate, bal[1], 0, ecurdt, "Brought Forward", "", "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) elif tab[0] == "strtrn": for bal in bals: # Create Transactions if not bal[1] and not bal[2]: continue data = rec[:3] if bal[1] < 0: typ = 6 else: typ = 5 data.extend([ bal[0], edate, typ, "Bal-Fwd", "Bal-Fwd", "", bal[1], bal[2], 0, ecurdt, "Brought Forward", 0, "", "", "", 0, "", self.opts["capnm"], self.sysdtw, 0 ]) sql.insRec(tab[0], data=data) if "args" not in self.opts: pb.closeProgress() def doExit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop()