class st1010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() if "wait" in self.opts: self.df.mstFrame.wait_window() else: self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "ctlvmf", "ctlrep", "drschn", "drsmst", "genmst", "slsiv1", "slsiv2", "strgrp", "strloc", "strmf1", "strmf2", "strgmu", "strcmu", "strprc", "strrcp", "struoi", "strtrn", "strpot", "strvar", "slsiv3", "chglog" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] self.automu = strctl["cts_automu"] self.drsctl = gc.getCtl("drsctl", self.opts["conum"], error=False) if not self.drsctl: self.chains = "N" else: self.chains = self.drsctl["ctd_chain"] return True def mainProcess(self): gpm = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } stm = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "X")], "whera": [], "index": 1 } loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } unm = { "stype": "R", "tables": ("struoi", ), "cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0, "Description", "Y")), "where": [("unm_cono", "=", self.opts["conum"])] } drc = { "stype": "R", "tables": ("drschn", ), "cols": (("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")), "where": [("chm_cono", "=", self.opts["conum"])] } drm = { "stype": "R", "tables": ("drsmst", ), "cols": (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"), ("drm_add1", "", 0, "Address Line 1")) } if self.chains == "Y": drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_stat", "<>", "X")] drm["whera"] = [["T", "drm_chain", 10]] else: drm["where"] = [("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", 0), ("drm_stat", "<>", "X")] vtm = { "stype": "R", "tables": ("ctlvmf", ), "cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0, "Description", "Y")), "where": [("vtm_cono", "=", self.opts["conum"])] } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } tag = (("Basic-_A", None, ("T", 0, 0), ("T", 0, 1)), ("Basic-_B", None, ("T", 0, 0), ("T", 0, 1)), ("Recipes", self.doReadLoadRecipe, None, ("T", 0, 1))) r1s = (("Normal", "N"), ("Recipe", "R")) r2s = (("Average", "A"), ("Standard", "S"), ("None", "N")) r3s = (("Manual", "M"), ("Automatic", "A"), ("Zero", "N")) self.fld = [(("T", 0, 0, 0), "IUA", 3, "Group", "Product Group", "", "Y", self.doGroup, gpm, None, ("notblank", )), (("T", 0, 0, 0), "INA", 20, "Code", "Product Code", "", "N", self.doCode, stm, None, ("notblank", )), (("T", 0, 0, 0), "IUA", 1, "Loc", "Location", "1", "N", self.doLoc, loc, None, ("notblank", )), (("T", 0, 0, 0), "ONA", 30, ""), (("T", 1, 0, 0), ("IRB", r1s), 0, "Type of Item", "", "N", "N", self.doType, None, None, None), (("T", 1, 1, 0), "INA", 30, "Description", "", "", "N", None, None, self.doDelete, ("notblank", )), (("T", 1, 2, 0), "INA", 10, "Unit of Issue", "", "", "N", self.doUoi, unm, None, ("notblank", )), (("T", 1, 2, 0), "ONA", 30, ""), (("T", 1, 3, 0), ("IRB", r2s), 0, "Cost Price Indicator", "", "A", "N", self.doValInd, None, None, None), (("T", 1, 4, 0), "IUA", 1, "VAT Code", "", "", "N", self.doVat, vtm, None, ("notblank", )), (("T", 1, 4, 0), "ONA", 30, ""), (("T", 1, 5, 0), "IUI", 3, "Exclusive Chainstore", "", "", "N", self.doChnExcl, drc, None, ("efld", )), (("T", 1, 5, 0), "ONA", 30, ""), (("T", 1, 6, 0), "INA", 7, "Exclusive Account", "", "", "N", self.doAccExcl, drm, None, ("efld", )), (("T", 1, 6, 0), "ONA", 30, ""), (("T", 1, 7, 0), "IUI", 7, "Sales Code", "", "", "N", self.doSales, glm, None, ("efld", )), (("T", 1, 7, 0), "ONA", 30, ""), (("T", 1, 8, 0), "IUI", 7, "COS Code", "", "", "N", self.doCos, glm, None, ("efld", )), (("T", 1, 8, 0), "ONA", 30, ""), (("T", 2, 0, 0), "IUA", 8, "Bin Number", "", "", "N", None, None, self.doDelete, ("efld", )), (("T", 2, 1, 0), ("IRB", r3s), 0, "Re-Order Indicator", "", "A", "N", self.doReord, None, None, None), (("T", 2, 2, 0), "IUI", 7, "Re-Order Level", "", "", "N", None, None, None, ("efld", )), (("T", 2, 3, 0), "IUI", 7, "Re-Order Quantity", "", "", "N", None, None, None, ("efld", ))] if self.automu in ("A", "L"): self.fld.append( (("T", 2, 4, 0), "IUD", 6.2, "Percentabge Markup Lv1", "", "", "N", None, None, None, ("efld", ))) for x in range(1, self.plevs): self.fld.append((("T", 2, 4, 0), "IUD", 6.2, "Lv%s" % (x + 1), "", "", "N", None, None, None, ("efld", ))) self.fld.extend([(("C", 3, 0, 0), "INA", 3, "Grp", "Product Group", "r", "N", self.doRecGrp, gpm, None, None), (("C", 3, 0, 1), "INA", 20, "Product-Code", "Product Code", "", "N", self.doRecCod, stm, None, None), (("C", 3, 0, 2), "ONA", 30, "Description"), (("C", 3, 0, 3), "IUD", 11.2, "Quantity", "", "", "N", self.doRecQty, None, self.doDelRec, ("notzero", ))]) but = (("Edit", None, self.doEditor, 0, ("C", 3, 1), None), ("Accept", None, self.doAccept, 0, ("T", 0, 0), ("T", 0, 1)), ("Cancel", None, self.doCancel, 0, ("T", 0, 0), ("T", 0, 1)), ("Quit", None, self.doQuit, 1, None, None)) tnd = ((self.doEnd, "N"), (self.doEnd, "N"), (self.doEnd, "Y"), None) txt = (self.doExit, self.doExit, self.doExit, self.doExit) cnd = (None, None, None, (self.doEnd, "N")) cxt = (None, None, None, self.doExit) self.df = TartanDialog(self.opts["mf"], eflds=self.fld, tags=tag, butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, clicks=self.doClick) def doClick(self, *opts): if self.df.pag == 0 or not self.gtype: return if opts[0] == (1, 0) and not self.newcode: return self.df.focusField("T", opts[0][0], opts[0][1] + 1) def doGroup(self, frt, pag, r, c, p, i, w): self.grpacc = self.sql.getRec( "strgrp", cols=["gpm_vatcode", "gpm_sales", "gpm_costs"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not self.grpacc: return "Invalid Group" self.group = w self.df.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]] def doCode(self, frt, pag, r, c, p, i, w): self.code = w self.mups = [0, 0, 0, 0, 0] self.old1 = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", w)], limit=1) if not self.old1: self.newcode = True self.gtype = None elif self.old1[3] == "X": return "Redundant Code" else: self.newcode = False d = 3 for x in range(0, self.df.topq[1]): if x in (3, 6, 8, 10, 12, 14): continue if x == 0: self.gtype = self.old1[d] self.df.loadEntry("T", 1, x, data=self.old1[d]) if x == 2: get = self.getUoi(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 5: get = self.getVat(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 7: get = self.getChnExcl(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if x == 9: get = self.getAccExcl(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) if self.glint == "Y" and x in (11, 13): get = self.getGenDes(self.old1[d]) if get: self.df.loadEntry("T", 1, x + 1, data=get[0]) d += 1 if self.locs == "N": self.loc = "1" self.df.loadEntry("T", 0, 2, data=self.loc) err = self.checkLoc() if err: return err return "sk1" def doLoc(self, frt, pag, r, c, p, i, w): if w == 0: return "Invalid Location" self.loc = w err = self.checkLoc() if err: return err def checkLoc(self): acc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Location Code" else: self.df.loadEntry("T", 0, 3, data=acc[0]) self.old2 = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)], limit=1) if not self.old2: ok = askQuestion(self.opts["mf"].body, "New Location", "This location does not exist for this product. " \ "Are you sure that you want to create it?") if ok == "yes": self.newloc = "Y" else: return "Rejected Location" if not self.old2: self.newloc = "Y" else: self.newloc = "N" d = 3 for x in range(0, 4): d = d + 1 self.df.loadEntry("T", 2, x, data=self.old2[d]) if self.automu in ("A", "L"): for y in range(self.plevs): mup = getMarkup(self.sql, self.opts["conum"], self.group, self.code, self.loc, y + 1) self.df.loadEntry("T", 2, 4 + y, data=mup) self.mups[y] = mup def doType(self, frt, pag, r, c, p, i, w): self.gtype = w if self.gtype == "R": self.df.enableTag(2) else: self.df.disableTag(2) def doUoi(self, frt, pag, r, c, p, i, w): acc = self.getUoi(w) if not acc: return "Invalid UOI Record" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doValInd(self, frt, pag, r, c, p, i, w): self.df.topf[1][5][5] = self.grpacc[0] def doVat(self, frt, pag, r, c, p, i, w): acc = self.getVat(w) if not acc: return "Invalid VAT Record" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if not self.drsctl: self.chain = 0 self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 1, data="") self.df.loadEntry(frt, pag, p + 1, data="") if self.glint == "N": return "sk9" else: return "sk4" def doChnExcl(self, frt, pag, r, c, p, i, w): if w: acc = self.getChnExcl(w) if not acc: return "Invalid Chainstore" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) self.chain = w def doAccExcl(self, frt, pag, r, c, p, i, w): if w: acc = self.getAccExcl(w) if not acc: return "Invalid Debtors Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) if self.glint == "N": return "sk5" if self.newcode: self.df.loadEntry(frt, pag, p + 2, data=self.grpacc[1]) if self.grpacc[1]: acc = self.getGenDes(self.grpacc[1]) if not acc: return "Invalid Sales Code" self.df.loadEntry(frt, pag, p + 3, data=acc[0]) self.df.loadEntry(frt, pag, p + 4, data=self.grpacc[2]) if self.grpacc[2]: acc = self.getGenDes(self.grpacc[2]) if not acc: return "Invalid C.O.S. Code" self.df.loadEntry(frt, pag, p + 5, data=acc[0]) def doSales(self, frt, pag, r, c, p, i, w): acc = self.getGenDes(w) if not acc: return "Invalid Sales Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doCos(self, frt, pag, r, c, p, i, w): acc = self.getGenDes(w) if not acc: return "Invalid COS Account" self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doReord(self, frt, pag, r, c, p, i, w): if w == "N": self.df.loadEntry(frt, pag, p + 1, data=0) self.df.loadEntry(frt, pag, p + 2, data=0) return "sk2" def getUoi(self, dat): acc = self.sql.getRec("struoi", cols=["unm_desc"], where=[("unm_cono", "=", self.opts["conum"]), ("unm_unit", "=", dat)], limit=1) return acc def getVat(self, dat): acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=", dat)], limit=1) return acc def getChnExcl(self, dat): self.chain = dat if dat: acc = self.sql.getRec("drschn", cols=["chm_name"], where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain", "=", dat)], limit=1) return acc def getAccExcl(self, dat): if dat: acc = self.sql.getRec("drsmst", cols=["drm_name"], where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno", "=", dat), ("drm_stat", "<>", "X")], limit=1) return acc def getGenDes(self, dat): if dat: acc = self.sql.getRec("genmst", cols=["glm_desc"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", dat)], limit=1) return acc def doRecGrp(self, frt, pag, r, c, p, i, w): self.rgroup = w acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.df.topf[0][1][8]["whera"] = [["C", "st1_group", 0, 3]] def doRecCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.rgroup), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] == "R": return "Invalid Type (Recipe)" self.df.loadEntry(frt, pag, p + 1, data=acc[1]) acc = self.sql.getRec("strmf2", cols=["st2_bin"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.rgroup), ("st2_code", "=", w), ("st2_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Code (2)" self.rcode = w acc = self.sql.getRec("strrcp", cols=["srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)], limit=1) if acc: self.newrec = "n" self.df.loadEntry(frt, pag, p + 2, data=acc[0]) else: self.newrec = "y" def doRecQty(self, frt, pag, r, c, p, i, w): self.rqty = w def doEditor(self): if self.df.pag != 3: self.df.focusField(self.df.frt, self.df.pag, self.df.col) return # Display recipe items and allow editing of details data = self.sql.getRec( tables=["strrcp", "strmf1"], cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ), ("st1_code=srr_rcode", )]) if data: titl = "Recipe Items" head = ("Grp", "Product-Code", "Description", "Quantity") lin = { "stype": "C", "titl": titl, "head": head, "typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 10.2)), "data": data } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Product to Edit") chg = self.df.selChoice(lin) if chg and chg.selection: self.change = chg.selection self.doChgChanges() self.df.enableButtonsTags(state=state) self.df.focusField("C", 3, self.df.col) def doChgChanges(self): tit = ("Change Items", ) gpm = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } stm = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"])], "whera": [], "index": 1 } fld = ((("T", 0, 0, 0), "INA", 3, "Group", "Product Group", "", "N", self.doChgGrp, gpm, None, ('notblank', )), (("T", 0, 1, 0), "INA", 20, "Code", "Product Code", "", "N", self.doChgCod, stm, None, ('notblank', )), (("T", 0, 2, 0), "ONA", 30, "Description"), (("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N", self.doChgQty, None, None, ('notzero', ))) but = [["Delete", None, self.doChgDel, 1, None, None]] self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doChgEnd, "n"), ), txit=(self.doChgExit, )) self.cg.loadEntry("T", 0, 0, data=self.change[0]) self.cg.loadEntry("T", 0, 1, data=self.change[1]) self.cg.loadEntry("T", 0, 2, data=self.change[2]) self.cg.loadEntry("T", 0, 3, data=self.change[3]) self.cg.focusField("T", 0, 1, clr=False) self.cg.mstFrame.wait_window() def doChgGrp(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.rgroup = w self.cg.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]] def doChgCod(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.rgroup), ("st1_code", "=", w)], limit=1) if not acc: return "Invalid Code" if acc[0] != "N": return "Invalid Type" cnt = self.sql.getRec("strrcp", cols=["count(*)"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.rgroup), ("srr_code", "=", w)], limit=1) if cnt[0]: return "Product Already In Recipe" self.rcode = w self.cg.loadEntry("T", 0, 2, data=acc[1]) def doChgQty(self, frt, pag, r, c, p, i, w): self.rqty = w def doChgDel(self): self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.change[0]), ("srr_rcode", "=", self.change[1])]) self.doReadLoadRecipe() self.doChgExit() def doChgEnd(self): self.sql.updRec("strrcp", cols=["srr_rgroup", "srr_rcode", "srr_rqty"], data=[self.rgroup, self.rcode, self.rqty], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.loc), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.change[0]), ("srr_rcode", "=", self.change[1])]) self.doReadLoadRecipe() self.doChgExit() def doChgExit(self): self.cg.closeProcess() def doDelete(self): trn = self.sql.getRec("strpot", cols=["count(*)"], where=[("pot_cono", "=", self.opts["conum"]), ("pot_group", "=", self.group), ("pot_code", "=", self.code)], limit=1) if trn[0]: return "Purchase Orders Exist, Not Deleted" trn = self.sql.getRec("strtrn", cols=["count(*)"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_group", "=", self.group), ("stt_code", "=", self.code), ("stt_loc", "=", self.loc)], limit=1) if trn[0]: return "Stores Transactions Exist, Not Deleted" trn = self.sql.getRec("slsiv2", cols=["count(*)"], where=[("si2_cono", "=", self.opts["conum"]), ("si2_group", "=", self.group), ("si2_code", "=", self.code), ("si2_loc", "=", self.loc)], limit=1) if trn[0]: return "Sales-2 Transactions Exist, Not Deleted" trn = self.sql.getRec("slsiv3", cols=["count(*)"], where=[("si3_cono", "=", self.opts["conum"]), ("si3_rgroup", "=", self.group), ("si3_rcode", "=", self.code)], limit=1) if trn[0]: return "Sales-3 Transactions Exist, Not Deleted" self.sql.delRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) self.sql.insRec("chglog", data=["strmf2", "D", "%03i%-3s%-20s%-1s" % \ (self.opts["conum"], self.group, self.code, self.loc), "", dte, self.opts["capnm"], "", "", "", 0]) st2 = self.sql.getRec("strmf2", cols=["count(*)"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code)], limit=1) if not st2[0]: self.sql.delRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", self.code)]) self.sql.insRec("chglog", data=["strmf1", "D", "%03i%-3s%-20s" % \ (self.opts["conum"], self.group, self.code), "", dte, self.opts["capnm"], "", "", "", 0]) # Other Files self.sql.delRec("strcst", where=[("stc_cono", "=", self.opts["conum"]), ("stc_group", "=", self.group), ("stc_code", "=", self.code), ("stc_loc", "=", self.loc)]) self.sql.delRec("strprc", where=[("stp_cono", "=", self.opts["conum"]), ("stp_group", "=", self.group), ("stp_code", "=", self.code), ("stp_loc", "=", self.loc)]) self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc)]) self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.group), ("srr_rcode", "=", self.code)]) self.sql.delRec("strvar", where=[("stv_cono", "=", self.opts["conum"]), ("stv_group", "=", self.group), ("stv_code", "=", self.code), ("stv_loc", "=", self.loc)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1) def doDelRec(self): self.sql.delRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)]) self.df.clearLine(2, focus=True) def doEnd(self): if self.df.frt == "T" and self.df.pag == 0: if self.newcode: self.df.focusField("T", 1, 1) else: if self.gtype == "R": self.df.enableTag(2) self.df.skip[1] = [1] self.df.focusField("T", 1, 2, clr=False) elif self.df.frt == "T" and self.df.pag == 1: self.df.selPage("Basic-B") elif self.df.frt == "T" and self.df.pag == 2: if self.gtype == "R": self.df.selPage("Recipes") else: self.doEnder() elif self.df.frt == "C" and self.df.pag == 3: data = [ self.opts["conum"], self.group, self.code, self.loc, self.rgroup, self.rcode, self.rqty ] if self.newrec == "y": self.sql.insRec("strrcp", data=data) self.df.advanceLine(3) else: whr = [("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("srr_rgroup", "=", self.rgroup), ("srr_rcode", "=", self.rcode)] self.sql.updRec("strrcp", data=data, where=whr) self.doReadLoadRecipe() def doEnder(self): data = [self.opts["conum"]] for x in range(0, 2): data.append(self.df.t_work[0][0][x]) for x in range(0, len(self.df.t_work[1][0])): if x in (3, 6, 8, 10, 12, 14): continue data.append(self.df.t_work[1][0][x]) if self.newcode: self.sql.insRec("strmf1", data=data) elif data != self.old1[:len(data)]: col = self.sql.strmf1_col data.append(self.old1[col.index("st1_xflag")]) self.sql.updRec("strmf1", data=data, where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", self.code)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old1): if dat != data[num]: self.sql.insRec( "chglog", data=[ "strmf1", "U", "%03i%-3s%-20s" % (self.opts["conum"], self.group, self.code), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) data = [self.opts["conum"], self.group, self.code, self.loc] for x in range(0, 4): data.append(self.df.t_work[2][0][x]) if self.newloc == "Y": self.sql.insRec("strmf2", data=data) elif data != self.old2[:len(data)]: col = self.sql.strmf2_col data.append(self.old2[col.index("st2_xflag")]) self.sql.updRec("strmf2", data=data, where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)]) dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3]) for num, dat in enumerate(self.old2): if dat != data[num]: self.sql.insRec("chglog", data=[ "strmf2", "U", "%03i%-3s%-20s%-1s" % (self.opts["conum"], self.group, self.code, self.loc), col[num], dte, self.opts["capnm"], str(dat), str(data[num]), "", 0 ]) self.sql.delRec("strcmu", where=[("smc_cono", "=", self.opts["conum"]), ("smc_group", "=", self.group), ("smc_code", "=", self.code), ("smc_loc", "=", self.loc)]) for num, mup in enumerate(self.df.t_work[2][0][4:]): if mup and mup != self.mups[num]: self.sql.insRec("strcmu", data=[ self.opts["conum"], self.group, self.code, self.loc, num + 1, mup ]) self.opts["mf"].dbm.commitDbase() self.df.selPage("Basic-A") self.df.focusField("T", 0, 1) def doReadLoadRecipe(self): self.df.clearFrame("C", 3) self.df.focusField("C", 3, 1) rec = self.sql.getRec( tables=["strrcp", "strmf1"], cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"], where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc), ("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ), ("st1_code=srr_rcode", )]) if rec: mxs = (self.df.rows[3] - 1) * self.df.colq[3] for l, r in enumerate(rec): for i, d in enumerate(r): c = l * self.df.colq[3] if c > mxs: c = mxs self.df.loadEntry("C", 3, (c + i), data=d) self.df.advanceLine(3) def doExit(self): if self.df.frt == "T" and self.df.pag == 0: self.doQuit() elif self.df.frt == "T" and self.df.pag == 1: if self.newcode: self.df.focusField("T", 1, 1) else: self.df.skip[1] = [1] self.df.focusField("T", 1, 2, clr=False) elif self.df.frt == "T" and self.df.pag == 2: self.df.focusField("T", 2, 1) elif self.df.frt == "C" and self.df.pag == 3: if self.df.col == 1: self.df.focusField("C", 3, 1) else: self.doEnder() def doAccept(self): ok = "yes" for page in (1, 2): frt, pag, col, err = self.df.doCheckFields(("T", page, None)) if err: ok = "no" if pag and pag != self.df.pag: self.df.selPage(self.df.tags[pag - 1][0]) self.df.focusField(frt, pag, (col + 1), err=err) break if ok == "yes": self.doEnder() def doQuit(self): self.df.closeProcess() if "wait" not in self.opts: self.opts["mf"].closeLoop() def doCancel(self): self.opts["mf"].dbm.rollbackDbase() self.df.selPage("Basic-A") self.df.focusField("T", 0, 1)
class cs2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return self.taxdf = ctlmst["ctm_taxdf"] if not self.taxdf: self.taxdf = "N" cshctl = gc.getCtl("cshctl", self.opts["conum"]) if not cshctl: return self.glint = cshctl["ccc_glint"] if self.glint == "Y": tabs = ["genmst"] else: tabs = ["cshmst"] tabs.extend(["cshana", "cshcnt"]) self.sql = Sql(self.opts["mf"].dbm, tables=tabs, prog=self.__class__.__name__) if self.sql.error: return if self.glint == "Y": self.ctl = [["csh_ctl", "Cash Control", 0]] ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return for num, ctl in enumerate(self.ctl): if ctl[0] in ctlctl: self.ctl[num][2] = ctlctl[ctl[0]] t = time.localtime() self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2]) self.denoms = (("R200", 200), ("R100", 100), ("R50", 50), ("R20", 20), ("R10", 10), ("R5", 5), ("R2", 2), ("R1", 1), ("C50", .5), ("C20", .2), ("C10", .1), ("C5", .05), ("C2", .02), ("C1", .01)) return True def mainProcess(self): tag = (("Expenses", None, None, None, False), ("Income", None, None, None, False), ("Cash", None, None, None, False)) dte = { "stype": "R", "tables": ("cshcnt", ), "cols": (("cct_date", "", 0, "Date"), ), "where": [("cct_cono", "=", self.opts["conum"])], "group": "cct_date" } if self.glint == "Y": self.cod = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])], "order": "glm_acno" } else: self.cod = { "stype": "R", "tables": ("cshmst", ), "cols": (("ccm_acno", "", 0, "Acc-Num"), ("ccm_desc", "", 0, "Description", "Y")), "where": [("ccm_cono", "=", self.opts["conum"])], "order": "ccm_acno" } des = { "stype": "R", "tables": ("cshana", ), "cols": (("can_desc", "", 0, "Description", "Y"), ("can_vatcod", "", 0, "V")), "where": [("can_cono", "=", self.opts["conum"])], "whera": (("C", "can_code", 1, 1), ), "group": "can_desc", "order": "can_desc" } r1s = (("Expenses", "P"), ("Income", "T"), ("Cash", "C")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Type", "", "P", "N", self.doType, None, None, None), (("T", 0, 1, 0), "I@cct_date", 0, "", "", self.sysdtw, "N", self.doDate, dte, None, ("efld", )), (("T", 0, 2, 0), "OSD", 13.2, "Expenses Total"), (("T", 0, 3, 0), "OSD", 13.2, "Income Total"), (("T", 0, 4, 0), "OSD", 13.2, "Cash Total"), (("C", 1, 0, 0), "I@can_trdt", 0, "", "", "", "N", None, None, None, ("efld", )), (("C", 1, 1, 0), "I@can_code", 0, "", "", "", "N", self.doCode, self.cod, None, None), (("C", 1, 2, 0), "I@can_desc", 0, "", "", "", "N", self.doDesc, des, None, ("notblank", )), (("C", 1, 3, 0), "I@can_vatcod", 0, "", "", "N", "N", self.doVCode, None, None, ("notblank", )), (("C", 1, 4, 0), "I@can_incamt", 0, "", "", "", "N", self.doIncAmt, None, None, ("efld", )), (("C", 1, 5, 0), "I@can_vatamt", 0, "", "", "", "N", None, None, None, ("efld", )), (("C", 2, 0, 0), "I@can_trdt", 0, "", "", "", "N", None, None, None, ("efld", )), (("C", 2, 1, 0), "I@can_code", 0, "", "", "", "N", self.doCode, self.cod, None, None), (("C", 2, 2, 0), "I@can_desc", 0, "", "", "", "N", self.doDesc, des, None, ("notblank", )), (("C", 2, 3, 0), "I@can_vatcod", 0, "", "", "N", "N", self.doVCode, None, None, ("notblank", )), (("C", 2, 4, 0), "I@can_incamt", 0, "", "", "", "N", self.doIncAmt, None, None, ("efld", )), (("C", 2, 5, 0), "I@can_vatamt", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 3, 0, 0), "ISD", 13.2, "Cheques", "", "", "N", self.doCheq, None, None, ("efld", )), (("C", 3, 0, 0), "IUI", 5, "Quant", "Quantity", 0, "N", self.doQty, None, None, None, ("Denomination", 14)), (("C", 3, 1, 0), "OSD", 13.2, "Value", "", "", "N", None, None, None, ("efld", ))) tnd = ((self.doTopEnd, "y"), None, None, (self.doTopEnd, "n")) txt = (self.doTopExit, None, None, None) cnd = (None, (self.doColEnd, "y"), (self.doColEnd, "y"), (self.doColEnd, "n")) cxt = (None, self.doColExit, self.doColExit, self.doColExit) but = (("Accept", None, self.doColExit, 0, (("C", 1, 1), ("C", 2, 1)), (("C", 1, 2), ("C", 2, 2))), ("Edit", None, self.doEdit, 0, (("C", 1, 1), ("C", 2, 1)), (("C", 1, 2), ("C", 2, 2))), ("Quit", None, self.doQuit, 0, ("T", 0, 0), ("T", 0, 1))) self.df = TartanDialog(self.opts["mf"], tags=tag, eflds=fld, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but, focus=False) for x in range(14): self.df.colLabel[3][x].configure(text=self.denoms[x][0]) self.df.focusField("T", 0, 1) def doType(self, frt, pag, r, c, p, i, w): self.trtp = w self.edit = None self.amend = False self.loader = False self.etotal = 0 self.itotal = 0 self.ctotal = 0 def doDate(self, frt, pag, r, c, p, i, w): self.date = w rec = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", "P"), ("can_date", "=", self.date)]) if rec and self.trtp == "P": self.amend = True for rr in rec: self.etotal = float(ASD(self.etotal) + ASD(rr[7])) self.df.loadEntry(frt, pag, p + 1, data=self.etotal) rec = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", "T"), ("can_date", "=", self.date)]) if rec and self.trtp == "T": self.amend = True for rr in rec: self.itotal = float(ASD(self.itotal) + ASD(rr[7])) self.df.loadEntry(frt, pag, p + 2, data=self.itotal) self.rec = self.sql.getRec("cshcnt", where=[("cct_cono", "=", self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date", "=", self.date)], limit=1) if self.rec and self.trtp == "C": self.amend = True if self.amend: return "nc" def doCode(self, frt, pag, r, c, p, i, w): if self.glint == "N" and not w: ok = askQuestion(self.opts["mf"].body, "Code Maintenance", "Do You Want to Add or Edit Codes?", default="no") if ok == "no": return "rf" w = callModule(self.opts["mf"], self.df, "cs1010", coy=[self.opts["conum"], self.opts["conam"]], user=self.opts["capnm"], args=True, ret="acno") self.df.loadEntry(frt, pag, p, data=w) if self.glint == "Y": acc = self.sql.getRec("genmst", cols=["glm_desc", "glm_vat"], where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w)], limit=1) else: acc = self.sql.getRec("cshmst", cols=["ccm_desc", "ccm_vat"], where=[("ccm_cono", "=", self.opts["conum"]), ("ccm_acno", "=", w)], limit=1) if not acc: return "Invalid Code" self.code = w self.vcod = acc[1] self.df.loadEntry(frt, pag, p + 1, data=acc[0]) def doDesc(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("cshana", cols=["can_vatcod"], where=[("can_cono", "=", self.opts["conum"]), ("can_code", "=", self.code), ("can_desc", "=", w)], order="can_date desc", limit=1) if acc: self.df.loadEntry(frt, pag, p + 1, data=acc[0]) else: self.df.loadEntry(frt, pag, p + 1, data=self.vcod) def doVCode(self, frt, pag, r, c, p, i, w): self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.date) if self.vatrte is None: ask = askQuestion(self.opts["mf"].body, "New Code", "Code Does Not Exist, Create a New Code?", default="no") if ask == "no": return "Invalid VAT Code" w = callModule(self.opts["mf"], self.df, "ms1040", coy=[self.opts["conum"], self.opts["conam"]], user=self.opts["capnm"], args=w, ret="code") self.df.loadEntry(frt, pag, p, data=w) self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.date) if self.vatrte is None: return "Invalid VAT Code" def doIncAmt(self, frt, pag, r, c, p, i, w): self.iamt = w if self.vatrte: vat = self.iamt * self.vatrte / float(ASD(100) + ASD(self.vatrte)) self.df.loadEntry(frt, pag, p + 1, data=round(vat, 2)) else: self.df.loadEntry(frt, pag, p + 1, data=0) if not self.loader: return "sk1" def doCheq(self, frt, pag, r, c, p, i, w): self.ctotal = w self.df.loadEntry("T", 0, 4, data=self.ctotal) def doQty(self, frt, pag, r, c, p, i, w): val = w * self.denoms[int(p / 2)][1] self.df.loadEntry(frt, pag, p + 1, val) self.ctotal = float(ASD(self.ctotal) + ASD(val)) self.df.loadEntry("T", 0, 4, data=self.ctotal) def doEdit(self): if self.df.pag in (1, 2): self.doEditPage12() else: self.doEditPage3() def doEditPage12(self): ana = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", self.trtp), ("can_date", "=", self.date)]) data = [] for rec in ana: dat = [] for n, d in enumerate(rec): if n in (0, 1, 2, 9): continue dat.append(d) data.append(dat) titl = "Analysis" head = ("Date", "Code", "Description", "V", "Inc-Amount", "VAT-Amount", "Seq") lin = { "stype": "C", "titl": titl, "head": head, "typs": (("D1", 10), ("UI", 7), ("NA", 30), ("UA", 1), ("SD", 13.2), ("SD", 13.2), ("UA", 1), ("US", 10)), "data": data } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Line to Edit") chg = self.df.selChoice(lin) if chg and chg.selection: self.edit = self.sql.getRec("cshana", where=[("can_seq", "=", chg.selection[-1])], limit=1) self.doChgChanges() else: self.edit = None self.doLoadAnalysis() self.df.enableButtonsTags(state=state) def doChgChanges(self): tit = ("Change Line", ) fld = ((("T", 0, 0, 0), "I@can_trdt", 10, "", "", "", "N", self.doChgDate, None, None, ("efld", )), (("T", 0, 1, 0), "I@can_code", 0, "", "", "", "N", None, self.cod, None, None), (("T", 0, 2, 0), "I@can_desc", 0, "", "", "", "N", None, None, None, ("efld", )), (("T", 0, 3, 0), "I@can_vatcod", 0, "", "", "", "N", self.doChgVCode, None, None, ("efld", )), (("T", 0, 4, 0), "I@can_incamt", 0, "", "", "", "N", self.doChgIncAmt, None, None, ("efld", )), (("T", 0, 5, 0), "I@can_vatamt", 0, "", "", "", "N", None, None, None, ("efld", ))) but = [["Delete", None, self.doChgDel, 1, None, None]] self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doChgEnd, "n"), ), txit=(self.doChgExit, ), focus=False) for num, dat in enumerate(self.edit[3:9]): self.cg.loadEntry("T", 0, num, data=dat) self.cg.focusField("T", 0, 1, clr=False) self.cg.mstFrame.wait_window() def doChgDate(self, frt, pag, r, c, p, i, w): self.chgdte = w def doChgVCode(self, frt, pag, r, c, p, i, w): self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.chgdte) if self.vatrte is None: return "Invalid VAT Code" def doChgIncAmt(self, frt, pag, r, c, p, i, w): self.iamt = w if self.vatrte: vat = self.iamt * self.vatrte / float(ASD(100) + ASD(self.vatrte)) self.cg.loadEntry(frt, pag, p + 1, data=round(vat, 2)) else: self.cg.loadEntry(frt, pag, p + 1, data=0) return "sk1" def doChgDel(self): self.sql.delRec("cshana", data=self.edit) self.doChgExit() def doChgEnd(self): self.sql.delRec("cshana", data=self.edit) for num, fld in enumerate(self.cg.t_work[0][0]): self.edit[num + 3] = fld self.sql.insRec("cshana", data=self.edit) self.opts["mf"].dbm.commitDbase() self.doChgExit() def doChgExit(self): self.cg.closeProcess() def doEditPage3(self): titl = "Denominations" data = [] for num, rec in enumerate(self.df.c_work[3]): data.append([self.denoms[num][0], rec[0], rec[1]]) lin = { "stype": "C", "deco": True, "titl": titl, "head": ("Denom", "Qty", "Value"), "typs": (("NA", 4), ("UI", 5), ("SD", 13.2)), "data": data, "retn": "I" } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus("Select a Denomination to Edit") chg = self.df.selChoice(lin) self.df.enableButtonsTags(state=state) if chg and chg.selection: self.edit = self.df.col qty, val = self.df.c_work[3][chg.selection[0]] self.ctotal = float(ASD(self.ctotal) - ASD(val)) self.df.focusField("C", 3, (chg.selection[0] * 2) + 1) else: self.edit = None self.df.focusField("C", 3, self.df.col) def doTopEnd(self): if self.df.pag == 0: if self.trtp == "P": self.df.selPage("Expenses") if self.amend: self.doLoadAnalysis() else: self.df.focusField("C", 1, 1) elif self.trtp == "T": self.df.selPage("Income") if self.amend: self.doLoadAnalysis() else: self.df.focusField("C", 2, 1) else: self.df.selPage("Cash") if not self.amend: self.df.focusField("T", 3, 1) else: self.doLoadCash() elif self.df.pag == 3: self.df.focusField("C", 3, 1) def doColEnd(self): if self.trtp in ("P", "T"): if self.trtp == "P": data = [self.opts["conum"], self.trtp, self.date] data.extend(self.df.c_work[1][self.df.row]) data.append("N") self.sql.insRec("cshana", data=data) self.etotal = float(ASD(self.etotal) + ASD(self.iamt)) self.df.loadEntry("T", 0, 2, data=self.etotal) self.df.advanceLine(1) else: data = [self.opts["conum"], self.trtp, self.date] data.extend(self.df.c_work[2][self.df.row]) data.append("N") self.sql.insRec("cshana", data=data) self.itotal = float(ASD(self.itotal) + ASD(self.iamt)) self.df.loadEntry("T", 0, 3, data=self.itotal) self.df.advanceLine(2) else: if self.df.col == 28: ask = askQuestion(self.opts["mf"].body, "Accept", "Accept All Entries") if ask == "yes": data = [self.opts["conum"], "T", self.date] data.append(self.df.t_work[3][0][0]) for x in range(14): data.append(self.df.c_work[3][x][0]) if self.amend: self.sql.delRec("cshcnt", where=[("cct_cono", "=", self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date", "=", self.date)]) self.sql.insRec("cshcnt", data=data) self.opts["mf"].dbm.commitDbase() self.doRestart() else: self.df.focusField("T", 3, 1, clr=False) elif self.edit: col = self.edit self.edit = None self.df.focusField("C", 3, col) else: self.df.advanceLine(self.df.pag) def doLoadCash(self): self.df.doInvoke(["T", 3, 1, self.doCheq], self.rec[3]) for num, qty in enumerate(self.rec[4:-1]): col = (num * 2) + 1 self.df.doInvoke(["C", 3, col, self.doQty], qty) def doLoadAnalysis(self): self.loader = True total = 0 if self.trtp == "P": pag = 1 else: pag = 2 self.df.clearFrame("C", pag) ana = self.sql.getRec("cshana", where=[("can_cono", "=", self.opts["conum"]), ("can_type", "=", self.trtp), ("can_date", "=", self.date)], order="can_seq") if not ana: self.df.focusField("C", pag, 1) else: for num, rec in enumerate(ana): if num > 14: num = 14 for pos, dat in enumerate(rec[3:9]): col = (num * 6) + pos + 1 if pos == 3: self.df.doInvoke(["C", pag, col, self.doVCode], dat) elif pos == 4: self.df.doInvoke(["C", pag, col, self.doIncAmt], dat) else: self.df.doInvoke(["C", pag, col, "rt"], dat) total = float(ASD(total) + ASD(self.iamt)) self.df.advanceLine(pag) if self.trtp == "P": self.etotal = total self.df.loadEntry("T", 0, 2, data=self.etotal) else: self.itotal = total self.df.loadEntry("T", 0, 3, data=self.itotal) self.loader = False def doQuit(self): self.opts["mf"].dbm.rollbackDbase() self.doRestart() def doTopExit(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doColExit(self): if self.df.pag != 3: self.opts["mf"].dbm.commitDbase() self.doRestart() elif self.df.pos: self.df.loadEntry("C", 3, self.df.pos, data=self.df.c_work[3][self.df.row][self.df.idx]) r = self.df.row - 1 c = self.df.col - 2 self.ctotal = float( ASD(self.ctotal) - ASD(self.df.c_work[3][r][1])) self.df.focusField("C", 3, c) def doRestart(self): self.df.clearFrame("C", 1) self.df.clearFrame("C", 2) self.df.clearFrame("T", 3) self.df.clearFrame("C", 3) self.df.selPage("Expenses") self.df.focusField("T", 0, 1, clr=True)
class st2010(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.exit = False self.selectPrinter() if not self.exit: self.mainProcess() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "ctlmst", "ctlmes", "ctlvrf", "ctlrep", "crsmst", "gentrn", "strgrp", "strloc", "strmf1", "strmf2", "strpom", "strpot", "strtrn", "strgmu", "strcmu", "tplmst" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) ctlmst = gc.getCtl("ctlmst", self.opts["conum"]) if not ctlmst: return mods = [] for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2): mods.append(ctlmst["ctm_modules"][x:x + 2]) if "CR" not in mods: showError( self.opts["mf"].body, "System Error", "This module requires you to have a Creditor's Activated") return strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.stgl = strctl["cts_glint"] self.locs = strctl["cts_locs"] self.plevs = strctl["cts_plevs"] self.dtpl = strctl["cts_tplnam"] if self.stgl == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["stk_soh", "stk_susp"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.soh = ctlctl["stk_soh"] self.ssp = ctlctl["stk_susp"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] return True def selectPrinter(self): tit = ("Printer Selection", ) tpm = { "stype": "R", "tables": ("tplmst", ), "cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0, "Title", "Y")), "where": [("tpm_type", "=", "O"), ("tpm_system", "=", "STR")], "order": "tpm_tname" } fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.dtpl, "N", self.doTplNam, tpm, None, None), (("T", 0, 1, 0), "ID1", 10, "Order Date", "", self.sysdtw, "N", self.doOrdDate, None, None, ("efld", ))) self.pr = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=fld, tend=((self.doPrtEnd, "y"), ), txit=(self.doPrtExit, ), view=("N", "P"), mail=("N", "Y", "Y")) self.opts["mf"].startLoop() def doTplNam(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w), ("tpm_type", "=", "O"), ("tpm_system", "=", "STR")], limit=1) if not acc: return "Invalid Template Name" self.tname = w def doOrdDate(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not In Financial Period" self.trdt = w self.trdd = self.pr.t_disp[0][0][1] self.curdt = int(self.trdt / 100) self.batch = "S%s" % self.curdt def doPrtEnd(self): self.doPrtClose() def doPrtExit(self): self.exit = True self.doPrtClose() def doPrtClose(self): self.pr.closeProcess() self.opts["mf"].closeLoop() def mainProcess(self): doc = { "stype": "R", "tables": ("strpom", "crsmst"), "cols": (("pom_ordno", "", 0, "Ord-Num"), ("pom_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")), "where": [("pom_cono", "=", self.opts["conum"]), ("crm_cono=pom_cono", ), ("crm_acno=pom_acno", ), ("pom_delno", "=", "")] } loc = { "stype": "R", "tables": ("strloc", ), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")), "where": [("srl_cono", "=", self.opts["conum"])] } crm = { "stype": "R", "tables": ("crsmst", ), "cols": [("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")], "where": [("crm_cono", "=", self.opts["conum"]), ("crm_stat", "<>", "X")], "index": 0 } odr = { "stype": "R", "tables": ("ctlrep", ), "cols": [("rep_code", "", 0, "Ord"), ("rep_name", "", 0, "Name", "Y")], "where": [("rep_cono", "=", self.opts["conum"])], "index": 0 } grp = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } cod = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_code", "", 0, "Product-Code"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "not", "in", ("R", "X")), ("st1_value_ind", "<>", "N")], "whera": [("C", "st1_group", 0)], "order": "st1_group, st1_code" } r1s = (("New", "N"), ("Amend", "A"), ("Receive", "R"), ("Cancel", "C")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Action", "", "N", "Y", self.doActTyp, None, None, None), (("T", 0, 1, 0), "IUI", 9, "Ord-No", "Order Number", "", "N", self.doOrdNum, doc, None, ("notblank", )), (("T", 0, 2, 0), "IUA", 1, "Loc", "Location Code", "1", "N", self.doLoc, loc, None, None), (("T", 0, 2, 0), "ONA", 30, ""), (("T", 0, 3, 0), "INA", 7, "Acc-No", "Account Number", "", "N", self.doCrsAcc, crm, None, None), (("T", 0, 3, 0), "ONA", 30, ""), (("T", 0, 4, 0), "INa", 3, "Ord-By", "Ordered By", "", "N", self.doOrdBy, odr, None, None), (("T", 0, 4, 0), "ONA", 30, ""), (("T", 0, 5, 0), "INa", 7, "Del-No", "Delivery Note Number", "", "N", self.doDelNum, None, None, ("notblank", )), (("T", 0, 5, 0), "ID1", 10, "Date", "Delivery Date", self.trdt, "N", self.doDelDate, None, None, ("efld", )), (("C", 0, 0, 0), "INA", 3, "Grp", "Product Group", "", "Y", self.doGrp, grp, None, None), (("C", 0, 0, 1), "INA", 20, "Product-Code", "", "", "N", self.doCod, cod, None, None), (("C", 0, 0, 2), "INA", (20, 30), "Description", "", "", "N", self.doDes, None, None, None), (("C", 0, 0, 3), "ISD", 11.2, "Quantity", "", 1, "N", self.doQty, None, None, ("notzero", )), (("C", 0, 0, 4), "IUA", 1, "V", "V.A.T. Code", "I", "N", self.doVat, None, None, ("notblank", )), (("C", 0, 0, 5), "IUD", 10.2, "Price", "Exclusive Price", "", "N", self.doPri, None, None, None), (("C", 0, 0, 6), "IUD", 6.2, "Dis-%", "Trade Discount", "", "N", self.doDis, None, None, None), (("C", 0, 0, 7), "OSD", 10.2, "Value")) self.row = (15, ) self.but = (("Cancel", None, self.doCancel, 1, ("C", 0, 1), ("T", 0, 1)), ("DelAdd", None, self.doDelAdd, 1, ("C", 0, 1), ("T", 0, 1)), ("Ribbon", None, self.doRibbon, 1, ("C", 0, 1), ("T", 0, 1)), ("Message", None, self.doMessag, 1, ("C", 0, 1), ("T", 0, 1)), ("Edit", None, self.doEdit, 0, ("C", 0, 1), ("C", 0, 2)), ("Reprint", None, self.doReprnt, 0, ("T", 0, 1), ("T", 0, 2)), ("CrsMaint", None, self.doCrsMaint, 0, ("T", 0, 5), ("T", 0, 6)), ("CrsQuery", None, self.doCrsQuery, 1, None, None), ("StrMaint", None, self.doStrMaint, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2))), ("StrQuery", None, self.doStkQuery, 1, None, None), ("Exit", None, self.doTopExit, 0, ("T", 0, 1), (("T", 0, 2), ("T", 0, 3), ("T", 0, 5)), "Exit Purchase Orders"), ("Accept", None, self.doAccept, 0, ("C", 0, 1), (("T", 0, 1), ("C", 0, 2)))) tnd = ((self.doTopEnd, "n"), ) txt = (self.doTopExit, ) cnd = ((self.doColEnd, "n"), ) cxt = (None, ) self.df = TartanDialog(self.opts["mf"], eflds=fld, rows=self.row, butt=self.but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, vport=True) def doActTyp(self, frt, pag, r, c, p, i, w): # Initialise Action Variables self.acttyp = w # Initialise Variables self.dnum = "" self.onum = "" self.jnum = "" self.dadd = "" self.cnam = "" self.vatn = "" self.ribbon = None ctl = self.sql.getRec("ctlmst", where=[("ctm_cono", "=", self.opts["conum"])], limit=1) self.deladd = [ ctl[self.sql.ctlmst_col.index("ctm_sadd1")], ctl[self.sql.ctlmst_col.index("ctm_sadd2")], ctl[self.sql.ctlmst_col.index("ctm_sadd3")], ctl[self.sql.ctlmst_col.index("ctm_spcode")] ] self.message = "" for x in (1, 2, 3): if self.acttyp == "R": self.df.butt[x][1] = 0 self.df.butt[x][2] = None else: self.df.butt[x][1] = 1 self.df.butt[x][2] = ["C", 0, 1] if self.acttyp == "N": # Location default if self.locs == "N": self.loc = "1" self.df.loadEntry(frt, pag, p + 2, data=self.loc) self.df.loadEntry(frt, pag, p + 3, data="Location One") return "sk3" return "sk1" def doOrdNum(self, frt, pag, r, c, p, i, w): strpom = self.sql.getRec("strpom", where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", w)], limit=1) if not strpom: return "Invalid Document" if strpom[self.sql.strpom_col.index("pom_delno")] == "cancel": if self.acttyp == "C": return "Already Cancelled" ok = askQuestion( self.opts["mf"].body, "Cancelled", "This order was Cancelled.\n\nDo you want to Reinstate It?", default="no") if ok == "no": return "Order Cancelled" self.sql.updRec("strpom", cols=["pom_delno"], data=[""], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", w)]) strpom[self.sql.strpom_col.index("pom_delno")] = "" elif strpom[self.sql.strpom_col.index("pom_delno")]: return "Order Already Received" self.ordno = CCD(w, "UI", 9.0).work self.othno = CCD(w, "Na", 9.0).work self.loc = strpom[self.sql.strpom_col.index("pom_loc")] self.acno = strpom[self.sql.strpom_col.index("pom_acno")] self.cnam = strpom[self.sql.strpom_col.index("pom_contact")] self.vatn = strpom[self.sql.strpom_col.index("pom_vatno")] self.ordby = strpom[self.sql.strpom_col.index("pom_ordby")] self.ribbon = ["", "", self.cnam, self.vatn] self.df.loadEntry(frt, pag, p + 1, data=self.loc) self.doLoc(frt, pag, r, c + 1, p + 1, i + 1, self.loc) self.df.loadEntry(frt, pag, p + 3, data=self.acno) self.doCrsAcc(frt, pag, r, c + 3, p + 3, i + 3, self.acno) self.df.loadEntry(frt, pag, p + 5, data=self.ordby) self.doOrdBy(frt, pag, r, c + 5, p + 5, i + 5, self.ordby) if self.acttyp == "R": return "sk6" else: return "nd" def doLoc(self, frt, pag, r, c, p, i, w): desc = self.sql.getRec("strloc", cols=["srl_desc"], where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)], limit=1) if not desc: return "Invalid Location" self.loc = w self.df.loadEntry(frt, pag, p + 1, data=desc[0]) def doCrsAcc(self, frt, pag, r, c, p, i, w): self.crsmst = self.sql.getRec("crsmst", where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)], limit=1) if not self.crsmst: return "Invalid Account" if self.crsmst[self.sql.crsmst_col.index("crm_stat")] == "X": return "Invalid Account, Redundant" self.acno = w self.name = self.crsmst[self.sql.crsmst_col.index("crm_name")] self.df.loadEntry(frt, pag, p + 1, data=self.name) def doOrdBy(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("ctlrep", cols=["rep_name"], where=[("rep_cono", "=", self.opts["conum"]), ("rep_code", "=", w)], limit=1) if not acc: return "Invalid Code" self.ordby = w self.df.loadEntry(frt, pag, p + 1, data=acc[0]) return "sk3" def doDelNum(self, frt, pag, r, c, p, i, w): self.delno = w def doDelDate(self, frt, pag, r, c, p, i, w): self.deldt = w def doTopEnd(self): if self.acttyp == "N": # Get and Display Next Document Number ordno = self.sql.getRec("strpom", cols=["max(pom_ordno)"], where=[("pom_cono", "=", self.opts["conum"])], limit=1) if not ordno[0]: self.ordno = CCD(1, "UI", 9).work self.othno = CCD(1, "Na", 9).work else: self.ordno = CCD((int(ordno[0]) + 1), "UI", 9).work self.othno = CCD((int(ordno[0]) + 1), "Na", 9).work self.df.loadEntry(self.df.frt, self.df.pag, 1, data=self.ordno) # Create Document Transaction (Head) self.dad1, self.dad2, self.dad3, self.dad4 = "", "", "", "" data = [ self.opts["conum"], self.ordno, self.loc, self.trdt, self.acno, self.dad1, self.dad2, self.dad3, self.dad4, "", "", "", "", self.ordby, "", "", 0, self.opts["capnm"], self.sysdtw ] # Write and Commit Header self.sql.insRec("strpom", data=data) self.opts["mf"].dbm.commitDbase() # Clear Totals self.doClearTots() elif self.acttyp == "C": self.doReadLoadStr() ok = askQuestion(self.opts["mf"].body, "Cancel", "Are You Sure This Order Must be Cancelled?", default="no") if ok == "yes": # Print Cancellation self.df.setWidget(self.df.mstFrame, state="hide") PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.ordno, tname=self.tname, repprt=self.pr.repprt, repeml=self.pr.repeml, copy=self.acttyp.lower()) self.df.setWidget(self.df.mstFrame, state="show") # Update Deletetion self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno)]) self.opts["mf"].dbm.commitDbase() # Clear totals and focus self.doClearTots() self.df.focusField("T", 0, 1) else: self.doReadLoadStr() self.amend = False def doReadLoadStr(self): self.doClearTots() data = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if not data: return for seq, line in enumerate(data): self.doExtData(line) if seq >= self.row[0]: self.df.scrollScreen(0) pos = (self.row[0] - 1) * 9 else: pos = seq * 9 # Load Values self.df.loadEntry("C", 0, pos, data=self.grp) self.df.loadEntry("C", 0, pos + 1, data=self.code) self.df.loadEntry("C", 0, pos + 2, data=self.desc) self.df.loadEntry("C", 0, pos + 3, data=self.qty) self.df.loadEntry("C", 0, pos + 5, data=self.vatcod) self.df.loadEntry("C", 0, pos + 6, data=self.price) self.df.loadEntry("C", 0, pos + 7, data=self.disrat) self.df.loadEntry("C", 0, pos + 8, data=self.excamt) self.vattot = float(ASD(self.vattot) + ASD(self.vatamt)) self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt)) self.inctot = float(ASD(self.inctot) + ASD(self.incamt)) if seq >= (self.row[0] - 1): self.df.scrollScreen(0) else: self.df.focusField("C", 0, pos + 10) self.df.setViewPort("O", self.inctot) def doTopExit(self): self.df.closeProcess() self.opts["mf"].closeLoop() def doClearTots(self): self.vattot = 0 self.ordtot = 0 self.inctot = 0 self.df.clearFrame("C", 0) self.df.focusField("C", 0, 1) self.df.setViewPort(None, 0) def doGrp(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group Code" self.grp = w def doCod(self, frt, pag, r, c, p, i, w): strmf1 = self.sql.getRec("strmf1", where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.grp), ("st1_code", "=", w)], limit=1) if not strmf1: return "Invalid Code" if strmf1[self.sql.strmf1_col.index("st1_type")] == "R": return "Invalid Code (Recipe)" if strmf1[self.sql.strmf1_col.index("st1_type")] == "X": return "Invalid Code (Redundant)" if strmf1[self.sql.strmf1_col.index("st1_value_ind")] == "N": return "Invalid Code (Value Indicator)" self.vatcod = strmf1[self.sql.strmf1_col.index("st1_vatcode")] strmf2 = self.sql.getRec("strmf2", where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.grp), ("st2_code", "=", w), ("st2_loc", "=", self.loc)], limit=1) if not strmf2: return "Invalid Location" odt = self.sql.getRec("strpot", cols=["count(*)"], where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", self.grp), ("pot_code", "=", w)], limit=1) if odt[0]: return "This Item is Already On This Order" odq = self.sql.getRec(tables=["strpom", "strpot"], cols=["sum(pot_qty)"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_loc", "=", self.loc), ("pom_delno", "=", ""), ("pot_cono", "=", self.opts["conum"]), ("pot_ordno=pom_ordno", ), ("pot_group", "=", self.grp), ("pot_code", "=", w)], limit=1) if odq[0]: state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="DupOrd", desc="%s of this Item is Already On Order" % odq[0]) self.df.enableButtonsTags(state=state) if cf.flag == "no": return "rf" self.code = w desc = strmf1[self.sql.strmf1_col.index("st1_desc")] self.uoi = strmf1[self.sql.strmf1_col.index("st1_uoi")] self.df.loadEntry(frt, pag, p + 1, data=desc) def doDes(self, frt, pag, r, c, p, i, w): self.desc = w def doQty(self, frt, pag, r, c, p, i, w): self.qty = w self.df.loadEntry(frt, pag, p + 1, data=self.vatcod) def doVat(self, frt, pag, r, c, p, i, w): self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trdt) if self.vatrte is None: return "Invalid V.A.T Code" self.vatcod = w # Last Cost Price lcost = getCost(self.sql, self.opts["conum"], self.grp, self.code, loc=self.loc, qty=1, ind="L") self.df.loadEntry(frt, pag, p + 1, data=lcost) def doPri(self, frt, pag, r, c, p, i, w): self.price = w self.inc = round((self.price * (self.vatrte + 100.0) / 100.0), 4) self.exc = round((self.price * 1), 2) dis = self.crsmst[self.sql.crsmst_col.index("crm_trdis")] self.df.loadEntry(frt, pag, p + 1, data=dis) def doDis(self, frt, pag, r, c, p, i, w): self.disrat = w dis = float(ASD(100) - ASD(self.disrat)) self.excamt = round((self.qty * self.exc * dis / 100.0), 2) self.incamt = round((self.qty * self.inc * dis / 100.0), 2) self.vatamt = float(ASD(self.incamt) - ASD(self.excamt)) self.df.loadEntry(frt, pag, p + 1, data=self.excamt) self.vattot = float(ASD(self.vattot) + ASD(self.vatamt)) self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt)) self.inctot = float(ASD(self.inctot) + ASD(self.incamt)) self.df.setViewPort("O", self.inctot) def doColEnd(self): # Create Purchase Order Transaction (Body) data = [ self.opts["conum"], self.ordno, self.grp, self.code, self.uoi, self.desc, self.qty, self.price, self.disrat, self.vatcod, self.vatrte, self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strpot", data=data) if self.acttyp == "A": self.amend = True self.df.advanceLine(0) def doCrsQuery(self): callModule(self.opts["mf"], self.df, "cr4010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) def doStkQuery(self): callModule(self.opts["mf"], self.df, "st4010", coy=(self.opts["conum"], self.opts["conam"]), period=self.opts["period"], user=self.opts["capnm"]) def doDelAdd(self): tit = ("Delivery Address", ) fld = ((("T", 0, 0, 0), "INA", 30, "Address-1", "Address Line 1", "", "N", None, None, None, None), (("T", 0, 1, 0), "INA", 30, "Address-2", "Address Line 2", "", "N", None, None, None, None), (("T", 0, 2, 0), "INA", 30, "Address-3", "Address Line 3", "", "N", None, None, None, None), (("T", 0, 3, 0), "INA", 30, "Address-4", "Address Line 4", "", "N", None, None, None, None)) state = self.df.disableButtonsTags() self.da = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doDelEnd, "n"), ), txit=(self.doDelExit, ), focus=False) for x in range(0, len(self.deladd)): self.da.loadEntry("T", 0, 0 + x, data=self.deladd[x]) self.da.focusField("T", 0, 1, clr=False) self.da.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doDelEnd(self): self.deladd = [] for x in range(0, self.da.topq[0]): self.deladd.append(self.da.t_work[0][0][x]) self.doDelExit() def doDelExit(self): self.da.closeProcess() def doMessag(self): tit = ("Order Message", ) cod = { "stype": "R", "tables": ("ctlmes", ), "cols": [("mss_message", "", 0, "Cod"), ("mss_detail", "", 60, "Details")], "where": [("mss_system", "=", "STR")], "screen": self.df.mstFrame } fld = ((("T", 0, 0, 0), "IUI", 3, "Message Code", "", "", "N", self.doMesCod, cod, None, None), (("T", 0, 1, 0), "ITv", (30, 6), "Message", "", self.message, "N", None, None, None, None)) but = (("Accept", None, self.doMesEnd, 0, ("T", 0, 1), ("T", 0, 0)), ) state = self.df.disableButtonsTags() self.mg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doMesEnd, "n"), ), txit=(self.doMesExit, ), butt=but) self.mg.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doMesCod(self, frt, pag, r, c, p, i, w): if w: mess = self.sql.getRec("ctlmes", where=[("mss_system", "=", "STR"), ("mss_message", "=", w)], limit=1) if not mess: return "Invalid Message Code" self.message = mess[self.sql.ctlmse_col.index("mss_detail")] self.mg.loadEntry(frt, pag, p + 1, data=self.message) def doMesEnd(self): wid, self.message = self.mg.getEntry("T", 0, 1) self.doMesExit() def doMesExit(self): self.mg.closeProcess() def doEdit(self): # Display document items and allow editing of desc, qty and price recs = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if recs: data = [] for l in recs: qty = CCD(l[self.sql.strpot_col.index("pot_qty")], "SD", 11.2) prc = CCD(l[self.sql.strpot_col.index("pot_price")], "UD", 10.2) dis = CCD(l[self.sql.strpot_col.index("pot_disper")], "UD", 6.2) data.append([ l[self.sql.strpot_col.index("pot_group")], l[self.sql.strpot_col.index("pot_code")], l[self.sql.strpot_col.index("pot_desc")], qty.disp, l[self.sql.strpot_col.index("pot_vatcod")], prc.disp, dis.disp ]) head = ("Grp", "Product-Code", "Description", "Quantity", "V", "Price", "Disc-%") lin = { "stype": "C", "head": head, "typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 11.2), ("UA", 1), ("UD", 10.2), ("UD", 6.2)), "data": data } state = self.df.disableButtonsTags() chg = self.df.selChoice(lin) if chg and chg.selection: self.change = chg.selection self.doChanges() self.df.enableButtonsTags(state=state) self.df.focusField("C", 0, self.df.col) def doChanges(self): tit = ("Change Items", ) fld = ((("T", 0, 1, 0), "ONA", 3, "Group"), (("T", 0, 2, 0), "ONA", 20, "Code"), (("T", 0, 3, 0), "INA", 30, "Description", "", "", "N", self.doChgDes, None, None, ("notblank", )), (("T", 0, 4, 0), "ISD", 11.2, "Quantity", "", "", "N", self.doChgQty, None, None, ("notzero", )), (("T", 0, 5, 0), "IUD", 10.2, "Selling Price", "", "", "N", self.doChgPrc, None, None, ("notzero", )), (("T", 0, 6, 0), "IUD", 6.2, "Discount Percent", "", "", "N", self.doChgDis, None, None, ("efld", ))) but = (("Delete", None, self.doChgDel, 1, None, None), ) tnd = ((self.doChgEnd, "n"), ) txt = (self.doChgExit, ) self.cg = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=tnd, txit=txt) self.cg.loadEntry("T", 0, 0, data=self.change[0]) self.cg.loadEntry("T", 0, 1, data=self.change[1]) self.cg.loadEntry("T", 0, 2, data=self.change[2]) self.cg.loadEntry("T", 0, 3, data=self.change[3]) self.cg.loadEntry("T", 0, 4, data=self.change[5]) self.cg.loadEntry("T", 0, 5, data=self.change[6]) self.cg.focusField("T", 0, 3, clr=False) self.cg.mstFrame.wait_window() def doChgDes(self, frt, pag, r, c, p, i, w): self.desc = w def doChgQty(self, frt, pag, r, c, p, i, w): self.qty = w def doChgPrc(self, frt, pag, r, c, p, i, w): self.price = w def doChgDis(self, frt, pag, r, c, p, i, w): self.disrat = w def doChgDel(self): grp = self.change[0] cod = self.change[1] self.sql.delRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", grp), ("pot_code", "=", cod)]) if self.acttyp == "A": self.amend = True self.doChgExit(loader=True) def doChgEnd(self): grp = self.change[0] cod = self.change[1] col = ["pot_desc", "pot_qty", "pot_price", "pot_disper"] dat = [self.desc, self.qty, self.price, self.disrat] whr = [("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno), ("pot_group", "=", grp), ("pot_code", "=", cod)] self.sql.updRec("strpot", cols=col, data=dat, where=whr) if self.acttyp == "A": self.amend = True self.doChgExit(loader=True) def doChgExit(self, loader=False): self.cg.closeProcess() if loader: self.doReadLoadStr() def doReprnt(self): tit = ("Reprint Orders", ) odr = { "stype": "R", "tables": ("strpom", "crsmst"), "cols": [("pom_ordno", "", 0, "Doc-Num"), ("pom_date", "", 0, "Date"), ("pom_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")], "where": [("pom_cono", "=", self.opts["conum"]), ("pom_cono=crm_cono", ), ("pom_acno=crm_acno", )], "screen": self.opts["mf"].body } r1s = (("Copies", "C"), ("Originals", "O")) fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Document Mode", "", "C", "N", self.doMode, None, None, None), (("T", 0, 1, 0), "IUI", 9, "From Number", "From Document Number", "", "N", self.doOrd, odr, None, ("notzero", )), [("T", 0, 2, 0), "IUI", 9, "To Number", "To Document Number", "", "N", None, odr, None, ("notzero", )]) state = self.df.disableButtonsTags() self.rp = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doReprntEnd, "n"), ), txit=(self.doReprntExit, ), view=("N", "V"), mail=("B", "Y")) self.rp.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doMode(self, frt, pag, r, c, p, i, w): if w == "C": self.copy = "y" else: self.copy = "n" def doOrd(self, frt, pag, r, c, p, i, w): self.rp.topf[pag][2][5] = w def doReprntEnd(self): self.rp.closeProcess() self.df.setWidget(self.df.mstFrame, state="hide") frm = self.rp.t_work[0][0][1] if not self.rp.t_work[0][0][2]: to = frm else: to = self.rp.t_work[0][0][2] odr = self.sql.getRec("strpom", cols=["pom_ordno"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", ">=", frm), ("pom_ordno", "<=", to)]) if odr: PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], odr, tname=self.tname, repprt=self.rp.repprt, repeml=self.rp.repeml, copy=self.copy) self.df.setWidget(self.df.mstFrame, state="show") def doReprntExit(self): self.rp.closeProcess() def doCrsMaint(self): state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="NewCrs") if cf.flag == "yes": callModule(self.opts["mf"], self.df, "cr1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doStrMaint(self): state = self.df.disableButtonsTags() cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="NewStr") if cf.flag == "yes": callModule(self.opts["mf"], self.df, "st1010", coy=(self.opts["conum"], self.opts["conam"]), period=None, user=self.opts["capnm"]) self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doAccept(self): self.df.setWidget(self.df.B11, "disabled") if self.df.col == 1: self.doCancel() else: # Update Tables self.doUpdateTables() # Commit Transaction self.opts["mf"].dbm.commitDbase() # Print Document if self.acttyp == "N" or (self.acttyp == "A" and self.amend): self.df.setWidget(self.df.mstFrame, state="hide") PrintOrder(self.opts["mf"], self.opts["conum"], self.opts["conam"], self.ordno, tname=self.tname, repprt=self.pr.repprt, repeml=self.pr.repeml, copy=self.acttyp.lower()) self.df.setWidget(self.df.mstFrame, state="show") self.df.focusField("T", 0, 1) def doRibbon(self): tit = ("Ribbon Line", ) fld = ((("T", 0, 0, 0), "INA", 30, "Customer Order", "", self.cnam, "N", None, None, None, None), (("T", 0, 1, 0), "INA", 30, "Job Number", "", self.cnam, "N", None, None, None, None), (("T", 0, 2, 0), "INA", 30, "Contact Person", "", self.cnam, "N", None, None, None, None), (("T", 0, 3, 0), "INA", 10, "VAT Number", "", self.vatn, "N", self.doVatNum, None, None, None)) state = self.df.disableButtonsTags() self.rb = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doRibEnd, "n"), ), txit=(self.doRibExit, ), focus=False) if self.ribbon: self.rb.loadEntry("T", 0, 0, data=self.ribbon[0]) self.rb.loadEntry("T", 0, 1, data=self.ribbon[1]) self.rb.loadEntry("T", 0, 2, data=self.ribbon[2]) self.rb.loadEntry("T", 0, 3, data=self.ribbon[3]) self.rb.focusField("T", 0, 1) self.rb.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doVatNum(self, frt, pag, r, c, p, i, w): if self.ordtot >= 1000.00 and not w: return "Invalid VAT Number" def doRibEnd(self): self.ribbon = [] for x in range(0, self.rb.topq[0]): self.ribbon.append(self.rb.t_work[0][0][x]) self.doRibExit() def doRibExit(self): self.rb.closeProcess() def doUpdateTables(self): # Update strpom with ribbon, delivery and message details whr = [("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)] if self.ribbon: self.sql.updRec( "strpom", cols=["pom_cusord", "pom_jobnum", "pom_contact", "pom_vatno"], data=[ self.ribbon[0], self.ribbon[1], self.ribbon[2], self.ribbon[3] ], where=whr) if not self.vatn: self.sql.updRec("crsmst", cols=["crm_vatno"], data=[self.ribbon[1]], where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", self.acno)]) if self.deladd: self.sql.updRec( "strpom", cols=["pom_add1", "pom_add2", "pom_add3", "pom_add4"], data=[ self.deladd[0], self.deladd[1], self.deladd[2], self.deladd[3] ], where=whr) if self.message: self.sql.updRec("strpom", cols=["pom_mess"], data=[self.message], where=whr) if self.acttyp != "R": return # Receipt of Order # Create Stores Transactions and update strpot lines trn = self.sql.getRec("strpot", where=[("pot_cono", "=", self.opts["conum"]), ("pot_ordno", "=", self.ordno)], order="pot_group, pot_code") if not trn: return for line in trn: self.doExtData(line) curdt = int(self.deldt / 100) # Update strpom record self.sql.updRec("strpom", cols=["pom_delno", "pom_deldt"], data=[self.delno, self.deldt], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno)]) # Write strtrn record data = [ self.opts["conum"], self.grp, self.code, self.loc, self.deldt, 1, self.othno, self.batch, self.delno, self.qty, self.excamt, 0, curdt, self.name, 0, self.acno, "", "STR", self.disrat, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) # If Integrated Create GL Transaction (SOH and Recon Accounts) if self.stgl == "Y" and self.excamt: # Stock on Hand Control data = (self.opts["conum"], self.soh, curdt, self.deldt, 5, self.othno, self.batch, self.excamt, 0, self.name, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) cst = float(ASD(0) - ASD(self.excamt)) # Stock Reconciliation Control data = (self.opts["conum"], self.ssp, curdt, self.deldt, 5, self.othno, self.batch, cst, 0, self.name, "", "", 0, self.opts["capnm"], self.sysdtw, 0) self.sql.insRec("gentrn", data=data) def doExtData(self, line): self.grp = line[self.sql.strpot_col.index("pot_group")] self.code = line[self.sql.strpot_col.index("pot_code")] self.uoi = line[self.sql.strpot_col.index("pot_uoi")] self.desc = line[self.sql.strpot_col.index("pot_desc")] self.qty = line[self.sql.strpot_col.index("pot_qty")] self.price = line[self.sql.strpot_col.index("pot_price")] self.disrat = line[self.sql.strpot_col.index("pot_disper")] self.vatcod = line[self.sql.strpot_col.index("pot_vatcod")] self.vatrte = line[self.sql.strpot_col.index("pot_vatrat")] # Calculate Values rat = float(ASD(100) + ASD(self.vatrte)) inc = round((self.price * rat / 100.0), 4) exc = round((self.price * 1), 2) dis = float(ASD(100) - ASD(self.disrat)) self.excamt = round((self.qty * exc * dis / 100.0), 2) self.incamt = round((self.qty * inc * dis / 100.0), 2) self.vatamt = float(ASD(self.incamt) - ASD(self.excamt)) def doCancel(self): self.opts["mf"].dbm.rollbackDbase() if self.acttyp == "N": self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"], where=[("pom_cono", "=", self.opts["conum"]), ("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)]) self.opts["mf"].dbm.commitDbase() self.df.focusField("T", 0, 1)
class st2030(object): def __init__(self, **opts): self.opts = opts if self.setVariables(): self.exit = False self.setPrinter() if not self.exit: self.dataHeader() self.opts["mf"].startLoop() def setVariables(self): self.sql = Sql(self.opts["mf"].dbm, [ "genmst", "gentrn", "strgrp", "strmf1", "strmf2", "strtrn", "strrcp" ], prog=self.__class__.__name__) if self.sql.error: return gc = GetCtl(self.opts["mf"]) strctl = gc.getCtl("strctl", self.opts["conum"]) if not strctl: return self.glint = strctl["cts_glint"] self.locs = strctl["cts_locs"] if self.glint == "Y": ctlctl = gc.getCtl("ctlctl", self.opts["conum"]) if not ctlctl: return ctls = ["stk_soh", "stk_susp"] if gc.chkRec(self.opts["conum"], ctlctl, ctls): return self.stk_soh = ctlctl["stk_soh"] self.stk_susp = ctlctl["stk_susp"] t = time.localtime() self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2] if self.locs == "N": self.loc = "1" self.glnum = 0 return True def setPrinter(self): tit = ("Printer Selection", ) self.pr = TartanDialog(self.opts["mf"], tops=True, title=tit, eflds=[], tend=((self.doPrtEnd, "y"), ), txit=(self.doPrtExit, ), view=("N", "P")) self.opts["mf"].startLoop() def doPrtEnd(self): self.doPrtClose() def doPrtExit(self): self.exit = True self.doPrtClose() def doPrtClose(self): self.pr.closeProcess() self.opts["mf"].closeLoop() def dataHeader(self): gpm = { "stype": "R", "tables": ("strgrp", ), "cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0, "Description", "Y")), "where": [("gpm_cono", "=", self.opts["conum"])] } stm = { "stype": "R", "tables": ("strmf1", ), "cols": (("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"), ("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description", "Y")), "where": [("st1_cono", "=", self.opts["conum"]), ("st1_type", "<>", "X")], "whera": [["C", "st1_group", 0, 0]], "order": "st1_group, st1_code", "index": 1 } stl = { "stype": "R", "tables": ("strloc", "strmf2"), "cols": (("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Location", "Y")), "where": [("srl_cono", "=", self.opts["conum"]), ("srl_loc=st2_loc", ), ("st2_cono=srl_cono", )], "whera": [["C", "st2_group", 0], ["C", "st2_code", 1]], "order": "srl_loc", "index": 0 } glm = { "stype": "R", "tables": ("genmst", ), "cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0, "Description", "Y")), "where": [("glm_cono", "=", self.opts["conum"])] } fld = [(("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N", self.doIss, None, None, ("notblank", )), (("T", 0, 0, 0), "ID1", 10, "Date", "Issue Date", self.sysdtw, "N", self.doDte, None, None, ("efld", )), (("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "N", self.doGroup, gpm, None, ("notblank", )), [("C", 0, 0, 1), "INA", 20, "Product Code", "", "", "N", self.doCode, stm, None, ("notblank", )], (("C", 0, 0, 2), "ONA", 5, "U.O.I"), (("C", 0, 0, 3), "IUA", 1, "L", "Location", "r", "N", self.doLoc, stl, None, ("notblank", )), (("C", 0, 0, 4), "ISD", 9.2, "Quantity", "", "", "N", self.doQty, None, None, ("notzero", )), (("C", 0, 0, 5), "OUD", 9.2, "Unit-Cost"), (("C", 0, 0, 6), "OSD", 9.2, "Value")] if self.glint == "Y": fld.append( (("C", 0, 0, 7), "IUI", 7, "G/L-Acc", "G/L Account Number", self.stk_susp, "N", self.doGenAcc, glm, None, None)) fld.append((("C", 0, 0, 8), "ONA", 10, "Desc")) fld.append((("C",0,0,9),"INA",(20,30),"Details","Transaction "\ "Details","","N",self.doTrnDet,None,None,None)) row = (15, ) tnd = ((self.endPage0, "n"), ) txt = (self.exitPage0, ) cnd = ((self.endPage1, "y"), ) cxt = (self.exitPage1, ) but = (("Reprint", None, self.doReprint, 0, ("T", 0, 1), None), ) self.df = TartanDialog(self.opts["mf"], eflds=fld, rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but) def doIss(self, frt, pag, r, c, p, i, w): self.iss = w def doDte(self, frt, pag, r, c, p, i, w): if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]: return "Invalid Date, Not in Financial Period" self.dte = w self.ddt = self.df.t_disp[pag][0][p] self.curdt = int(self.dte / 100) self.batno = "S%s" % self.curdt def doGroup(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strgrp", cols=["gpm_desc"], where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group", "=", w)], limit=1) if not acc: return "Invalid Group" self.group = w def doCode(self, frt, pag, r, c, p, i, w): acc = self.sql.getRec("strmf1", cols=["st1_desc", "st1_type", "st1_uoi"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", self.group), ("st1_code", "=", w), ("st1_type", "<>", "X")], limit=1) if not acc: return "Invalid or Redundant Code" self.code = w self.desc = acc[0] self.gtype = acc[1] self.df.loadEntry(frt, pag, p + 1, data=acc[2]) if self.locs == "N": self.loc = "1" self.df.loadEntry("C", pag, p + 2, data=self.loc) no = self.checkLoc() if no: return no else: return "sk2" def doLoc(self, frt, pag, r, c, p, i, w): self.loc = w no = self.checkLoc() if no: return no def checkLoc(self): acc = self.sql.getRec("strmf2", cols=["st2_bin"], where=[("st2_cono", "=", self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code", "=", self.code), ("st2_loc", "=", self.loc)], limit=1) if not acc: return "Invalid Location For This Product" def doQty(self, frt, pag, r, c, p, i, w): self.quant = w if self.gtype == "R" and self.doRecipe(): return "ff2" if self.extractCost(): return "rf" self.df.loadEntry("C", pag, p + 1, data=self.ucost) self.df.loadEntry("C", pag, p + 2, data=self.tcost) def doRecipe(self): self.recipe = self.sql.getRec("strrcp", where=[("srr_cono", "=", self.opts["conum"]), ("srr_group", "=", self.group), ("srr_code", "=", self.code), ("srr_loc", "=", self.loc)], order="srr_rgroup, srr_rcode") if not self.recipe: err = "Invalid Recipe, No Items" showError(self.opts["mf"].body, "Recipe Error", err) return err else: return self.doRecChg() def doRecChg(self): # Display recipe items and allow editing of quantities etc. data = [] for num, item in enumerate(self.recipe): st1 = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", item[4]), ("st1_code", "=", item[5])], limit=1) err = False if not st1: err = "Invalid Stock Record in Recipe" elif st1[0] == "X": err = "Redundant Stock Record in Recipe" if err: showError( self.opts["mf"].body, "Recipe Error", """%s! Group: %s Code: %s""" % (err, item[4], item[5])) return err data.append([num, item[4], item[5], st1[1], item[6]]) titl = "Recipe Items" head = ("Seq", "Grp", "Product-Code", "Description", "Quantity") lin = { "stype": "C", "titl": titl, "head": head, "typs": [("UI", 2), ("NA", 3), ("NA", 20), ("NA", 30), ("SD", 11.2)], "data": data } state = self.df.disableButtonsTags() self.opts["mf"].updateStatus( "Select a Product to Edit or Exit to Continue") chg = self.df.selChoice(lin) if chg and chg.selection: self.recchg = chg.selection self.doRecChanges() self.doRecChg() else: self.df.enableButtonsTags(state=state) def doRecChanges(self): tit = ("Change Items", ) fld = ((("T", 0, 0, 0), "ONA", 3, "Group"), (("T", 0, 1, 0), "ONA", 20, "Code"), (("T", 0, 2, 0), "ONA", 30, "Description"), (("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N", self.doRecQty, None, None, ('notzero', ))) but = (("Delete", None, self.doRecDel, 1, None, None), ) self.rp = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, butt=but, tend=((self.doRecEnd, "n"), ), txit=(self.doRecExit, )) self.rp.loadEntry("T", 0, 0, data=self.recchg[1]) self.rp.loadEntry("T", 0, 1, data=self.recchg[2]) self.rp.loadEntry("T", 0, 2, data=self.recchg[3]) self.rp.loadEntry("T", 0, 3, data=self.recchg[4]) self.rp.focusField("T", 0, 4, clr=False) self.rp.mstFrame.wait_window() def doRecQty(self, frt, pag, r, c, p, i, w): self.recqty = w def doRecDel(self): del self.recipe[int(self.recchg[0])] self.doRecExit() def doRecEnd(self): self.recipe[int(self.recchg[0])][6] = self.recqty self.doRecExit() def doRecExit(self): self.rp.closeProcess() def doGenAcc(self, frt, pag, r, c, p, i, w): chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w) if type(chk) is str: return chk self.glnum = w self.df.loadEntry("C", pag, p + 1, data=chk[0]) def doTrnDet(self, frt, pag, r, c, p, i, w): if not w: self.trndet = self.desc else: self.trndet = w def endPage0(self): self.df.focusField("C", 0, 1) def endPage1(self): self.updateTables() self.opts["mf"].dbm.commitDbase() self.df.advanceLine(0) def exitPage0(self): self.df.closeProcess() self.opts["mf"].closeLoop() def exitPage1(self): if self.df.col != 1: self.doPrintDoc(self.pr.repprt) self.df.focusField("T", 0, 1) def extractCost(self): self.ucost = 0 self.tcost = 0 if self.gtype == "R": for item in self.recipe: quant = item[6] * self.quant tcost = self.doCalCost(item[4], item[5], quant) if tcost is None: return "error" self.tcost = float(ASD(self.tcost) + ASD(tcost)) else: tcost = self.doCalCost(self.group, self.code, self.quant) if tcost is None: return "error" self.tcost = tcost self.ucost = round(self.tcost / self.quant, 2) def updateTables(self): if self.gtype == "R": # Issue individual items for item in self.recipe: acc = self.sql.getRec("strmf1", cols=["st1_desc"], where=[("st1_cono", "=", item[0]), ("st1_group", "=", item[4]), ("st1_code", "=", item[5])], limit=1) if acc: des = acc[0] else: des = "Unknown Description" qty = item[6] * self.quant tcost = self.doCalCost(item[4], item[5], qty, chk=False) qty = float(ASD(0) - ASD(qty)) val = float(ASD(0) - ASD(tcost)) data = [ self.opts["conum"], item[4], item[5], self.loc, self.dte, 6, self.iss, self.batno, self.glnum, qty, val, 0, self.curdt, des, 0, "", "", "STR", 0, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) # Receive recipe item data = [ self.opts["conum"], self.group, self.code, self.loc, self.dte, 5, self.iss, self.batno, self.glnum, self.quant, self.tcost, 0, self.curdt, self.desc, 0, "", "", "STR", 0, "", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) # Stores Ledger Transaction qty = float(ASD(0) - ASD(self.quant)) val = float(ASD(0) - ASD(self.tcost)) data = [ self.opts["conum"], self.group, self.code, self.loc, self.dte, 2, self.iss, self.batno, self.glnum, qty, val, 0, self.curdt, self.desc, 0, "", "", "STR", 0, "N", self.opts["capnm"], self.sysdtw, 0 ] self.sql.insRec("strtrn", data=data) if self.glint == "N": return col = self.sql.gentrn_col # General Ledger Control Transaction (Stock On Hand) acc = self.sql.getRec("gentrn", where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.stk_soh), ("glt_curdt", "=", self.curdt), ("glt_trdt", "=", self.dte), ("glt_type", "=", 4), ("glt_refno", "=", self.iss), ("glt_batch", "=", self.batno)], limit=1) if acc: amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(val)) self.sql.updRec("gentrn", cols=["glt_tramt"], data=[amnt], where=[("glt_seq", "=", acc[col.index("glt_seq")]) ]) else: self.sql.insRec("gentrn", data=[ self.opts["conum"], self.stk_soh, self.curdt, self.dte, 4, self.iss, self.batno, val, 0, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ]) # General Ledger Transaction (Expense) acc = self.sql.getRec("gentrn", where=[("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", self.glnum), ("glt_curdt", "=", self.curdt), ("glt_trdt", "=", self.dte), ("glt_type", "=", 4), ("glt_refno", "=", self.iss), ("glt_batch", "=", self.batno)], limit=1) if acc: amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(self.tcost)) self.sql.updRec("gentrn", cols=["glt_tramt"], data=[amnt], where=[("glt_seq", "=", acc[col.index("glt_seq")]) ]) else: self.sql.insRec("gentrn", data=[ self.opts["conum"], self.glnum, self.curdt, self.dte, 4, self.iss, self.batno, self.tcost, 0, self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0 ]) def doCalCost(self, grp, code, qty, chk=True): # Calculate cost price icost, tcost, bal = getCost(self.sql, self.opts["conum"], grp, code, loc=self.loc, qty=qty, tot=True, bal=True) if chk and qty > bal[0]: acc = self.sql.getRec("strmf1", cols=["st1_desc"], where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=", grp), ("st1_code", "=", code)], limit=1) cf = PwdConfirm(self.opts["mf"], conum=self.opts["conum"], system="STR", code="ExQty", product=(grp, code, acc[0])) if cf.flag == "no": return return tcost def doReprint(self): tit = ("Reprint Documents", ) data = self.sql.getRec("strtrn", cols=["stt_ref1", "stt_trdt"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 2)], group="stt_ref1, stt_trdt", order="stt_trdt, stt_ref1") iss = { "stype": "R", "tables": ("strtrn", ), "cols": (("stt_ref1", "", 0, "Reference"), ("stt_trdt", "", 0, "Date", "Y")), "wtype": "D", "where": data, "screen": self.opts["mf"].body, "comnd": self.doSelRec } isd = { "stype": "R", "tables": ("strtrn", ), "cols": (("stt_trdt", "", 0, "Date"), ), "where": [("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 2)], "whera": (("T", "stt_ref1", 0, 0), ), "group": "stt_trdt", "order": "stt_trdt", "screen": self.opts["mf"].body } fld = ((("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N", self.doRepIss, iss, None, ("notblank", )), (("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N", self.doRepDte, isd, None, ("notzero", ))) state = self.df.disableButtonsTags() self.tx = TartanDialog(self.opts["mf"], title=tit, tops=True, eflds=fld, tend=((self.doRepEnd, "n"), ), txit=(self.doRepExit, ), view=("N", "V"), mail=("Y", "N")) self.tx.mstFrame.wait_window() self.df.enableButtonsTags(state=state) self.df.focusField(self.df.frt, self.df.pag, self.df.col) def doSelRec(self, frt, pag, r, c, p, i, w): self.tx.doKeyPressed(frt, pag, p, w[0]) self.tx.doKeyPressed(frt, pag, p + 1, w[1]) def doRepIss(self, frt, pag, r, c, p, i, w): self.iss = w def doRepDte(self, frt, pag, r, c, p, i, w): self.dte = w self.ddt = self.df.t_disp[pag][0][p] acc = self.sql.getRec("strtrn", cols=["count(*)"], where=[("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 2), ("stt_ref1", "=", self.iss), ("stt_trdt", "=", self.dte)], limit=1) if not acc[0]: return "No Document Found" def doRepEnd(self): self.tx.closeProcess() self.doPrintDoc(self.tx.repprt) def doRepExit(self): self.tx.closeProcess() def doPrintDoc(self, repprt): hds = [ "Goods Issued Notes", "GIN Number: %s GIN Date: %s" % (self.iss, self.ddt) ] tab = ["strmf1", "strtrn"] col = [["stt_group", "UA", 3, "Grp", "y"], ["stt_code", "NA", 20, "Product-Code", "y"], ["stt_desc", "NA", 40, "Description", "y"], ["stt_loc", "UA", 1, "L", "y"], ["stt_qty", "SD", 11.2, "Quantity", "y", "y"], ["stt_cost", "SD", 11.2, "Price", "y", "y"]] gtt = ["stt_cost"] whr = [("stt_cono", "=", self.opts["conum"]), ("stt_type", "in", (2, 6)), ("stt_ref1", "=", self.iss), ("stt_trdt", "=", self.dte), ("st1_cono=stt_cono", ), ("st1_group=stt_group", ), ("st1_code=stt_code", ), ("st1_type", "<>", "R")] odr = "stt_seq" self.df.setWidget(self.df.mstFrame, state="hide") RepPrt(self.opts["mf"], conum=self.opts["conum"], conam=self.opts["conam"], name=self.__class__.__name__, tables=tab, heads=hds, cols=col, gtots=gtt, where=whr, order=odr, repprt=repprt) self.df.setWidget(self.df.mstFrame, state="show")