class gl1050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for control record and departments
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
# Check for multiple companies
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genrpc", "genstr",
"gendtm", "genrpt"], prog=self.__class__.__name__)
if self.sql.error:
return
acc = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if acc[0] > 1:
self.coys = True
else:
self.coys = False
self.strm = 0
return True
def doProcess(self):
st1 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_strm", "", 0, "Str"),
("gls_desc", "", 0, "Description", "Y")),
"where": [("gls_cono", "=", self.opts["conum"])],
"group": "gls_strm, gls_desc"}
st2 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_seq", "", 0, "Seq"),
("gls_typ", "", 0, "T"),
("gls_cno", "", 0, "CN"),
("gls_con", "", 0, "C"),
("gls_rep", "", 0, "Rep"),
("gls_gen", "", 0, "G"),
("gls_val", "", 0, "V"),
("gls_det", "", 0, "Det"),
("gls_var", "", 0, "B"),
("gls_zer", "", 0, "Z"),
("gls_opt", "", 0, "O"),
("gls_num", "", 0, "N"),
("gls_prnt", "", 20, "Printer-Name"),
("gls_mail", "", 20, "E-Mail-Address")),
"where": [("gls_cono", "=", self.opts["conum"])],
"whera": (("T", "gls_strm", 0, 0),),
"comnd": self.doSelTyp}
typ = {
"stype": "C",
"title": "Available Types",
"head": ("C", "Description"),
"data": (
("S", "YTD Report"),
("H", "Last 3 Years YTD Report"),
("L", "MTD and YTD Report"),
("M", "Monthly Report"),
("C", "Customised Report"))}
rpc = {
"stype": "R",
"tables": ("genrpc",),
"cols": (
("glc_cusno", "", 0, "CN"),
("glc_head1", "", 0, "Heading-1"),
("glc_head2", "", 0, "Heading-2"),
("glc_head3", "", 0, "Heading-3"),
("glc_head4", "", 0, "Heading-4")),
"where": [("glc_cono", "=", self.opts["conum"])]}
rpt = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_seq", "=", 0)],
"group": "glr_cono, glr_repno, glr_type, glr_desc",
"index": 1}
con = {
"stype": "C",
"title": "Available Options",
"head": ("C", "Description"),
"data": (
("V", "Actuals"),
("B", "Budgets"),
("C", "Actuals and Budgets"),
("X", "Variance to Budget"),
("D", "Detail"))}
det = {
"stype": "R",
"tables": ("gendtm",),
"cols": (
("gdm_code", "", 0, "Cod"),
("gdm_desc", "", 0, "Description")),
"where": [("gdm_cono", "=", self.opts["conum"])]}
prts = getPrinters(wrkdir=self.opts["mf"].rcdic["wrkdir"])
prts.insert(1, "Export")
if "None" not in prts:
prts.append("None")
prt = {
"stype": "C",
"titl": "Select Required Printer",
"head": ("Name", "Description"),
"data": prts}
cts = ("V", "B", "C", "X", "D")
fld = (
(("T",0,0,0),"IUI",3,"Stream-Number","Stream Number",
0,"Y",self.doStr,st1,None,("notzero",)),
(("T",0,0,0),"INA",30,"Description","",
"","N",self.doDsc,None,self.doDelStr,("notblank",)),
(("C",0,0,0),"IUI",3,"Seq","Sequence Number",
"i","N",self.doSeq,st2,None,("efld",)),
(("C",0,0,1),"IUA",1,"T","Report Type",
"S","N",self.doTyp,typ,self.doDelLin,
("in",("S","H","L","M","C"))),
(("C",0,0,2),"IUI",2,"CN","Custom Number",
0,"N",self.doCus,rpc,None,("efld",)),
(("C",0,0,3),"IUA",1,"C","Consolidate (Y/N)",
"N","N",self.doCon,None,None,("in",("Y","N"))),
(("C",0,0,4),"IUI",3,"Rep","Report Number",
0,"N",self.doRep,rpt,None,("notzero",)),
(("C",0,0,5),"IUA",1,"G","General Report (Y/N)",
"N","N",self.doGen,None,None,("in",("Y","N"))),
(("C",0,0,6),"IUA",1,"V","Report Contents",
"V","N",self.doContent,con,None,("in",cts)),
(("C",0,0,7),"INa",2,"Cod","Details Code",
"","N",self.doCod,det,None,None),
(("C",0,0,8),"IUA",1,"V","Variance (B/P/N)",
"B","N",self.doVar,None,None,("in",("B","P","N"))),
(("C",0,0,9),"IUA",1,"Z","Ignore Zeros (Y/N)",
"Y","N",None,None,None,("in",("Y","N"))),
(("C",0,0,10),"IUA",1,"O","Print Options (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,11),"IUA",1,"N","Print Numbers (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,12),"ITX",30,"Printer Name","Printer-Name",
"Default","N",self.doPrt,prt,None,("in",prts)),
(("C",0,0,13),"ITX",30,"E-Mail Address","E-Mail-Address",
"","N",None,None,None,("email",)))
but = (
("Cancel",None,self.doCancel,0,("C",0,1),("T",0,1)),
("Quit",None,self.exitTops,1,None,None))
self.df = TartanDialog(self.opts["mf"], eflds=fld,
tend=((self.endTops,"n"),), txit=(self.exitTops,),
cend=((self.endData,"y"),), cxit=(self.exitData,), butt=but)
self.df.focusField("T", 0, 1)
def doStr(self, frt, pag, r, c, p, i, w):
self.strm = w
self.old = self.sql.getRec("genstr", where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm)], limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
self.desc = self.old[self.sql.genstr_col.index("gls_desc")]
self.df.loadEntry(frt, pag, p+1, self.desc)
def doDelStr(self):
if self.new == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
def doDsc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
dt = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm), ("gls_seq", "=",
self.seq)], limit=1)
if not dt:
self.newlin = "y"
else:
self.newlin = "n"
for n, d in enumerate(dt[3:-1]):
self.df.loadEntry(frt, pag, p+n, data=d)
def doTyp(self, frt, pag, r, c, p, i, w):
self.typ = w
if self.typ != "C":
self.cno = 0
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+2, data="N")
return "sk2"
return "sk1"
def doCus(self, frt, pag, r, c, p, i, w):
cn = self.sql.getRec("genrpc", where=[("glc_cono", "=",
self.opts["conum"]), ("glc_cusno", "=", w)], limit=1)
if not cn:
return "Invalid Custom Report Number"
self.cno = w
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+1, data="N")
return "sk1"
def doCon(self, frt, pag, r, c, p, i, w):
self.con = w
def doRep(self, frt, pag, r, c, p, i, w):
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_repno", "=", w)], limit=1)
if not rp:
return "No Such Report"
self.rep = w
def doGen(self, frt, pag, r, c, p, i, w):
if w == "Y":
c = 0
else:
c = self.opts["conum"]
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("glr_cono", "=", c), ("glr_repno", "=", self.rep)],
limit=1)
if not rp:
return "No Such Report"
self.gen = w
def doContent(self, frt, pag, r, c, p, i, w):
if w in ("B", "C", "X") and self.typ in ("S", "L", "C"):
return "Invalid Choice for this Report Type"
if w == "D":
return
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def doCod(self, frt, pag, r, c, p, i, w):
d = self.sql.getRec("gendtm", cols=["gdm_desc"],
where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=",
w)], limit=1)
if not d:
return "Invalid Detail Code"
def doVar(self, frt, pag, r, c, p, i, w):
if self.typ == "C" and w not in ("B", "P"):
return "Invalid Variance, Only B or P"
def doPrt(self, frt, pag, r, c, p, i, w):
if w == "Export":
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def endTops(self):
if self.new == "y":
self.df.focusField("C", 0, 1)
else:
self.doLoadLines()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def exitTops(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSelTyp(self, frt, pag, r, c, p, i, w):
self.newlin = "n"
self.seq = w[0]
self.typ = w[1]
self.cno = w[2]
self.con = w[3]
self.rep = w[4]
self.gen = w[5]
for x, d in enumerate(w):
self.df.loadEntry(frt, pag, p+x, data=d)
self.df.focusField(frt, pag, c+1)
def doDelLin(self):
if self.newlin == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm), ("gls_seq", "=", self.seq)])
self.doReSeq()
def endData(self):
data = [self.opts["conum"], self.strm, self.desc, self.seq, self.typ,
self.cno, self.con, self.rep, self.gen]
for x in range(6, 14):
data.append(self.df.c_work[self.df.pag][self.df.row][x])
if self.newlin == "y":
self.sql.insRec("genstr", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genstr_col
data.append(self.old[col.index("gls_xflag")])
self.sql.updRec("genstr", data=data, where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm),
("gls_seq", "=", self.seq)])
self.doLoadLines()
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doReSeq(self):
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
if not recs:
self.newlin = "y"
self.df.focusField("C", 0, 1)
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
for seq, acc in enumerate(recs):
acc[3] = seq
self.sql.insRec("genstr", data=acc)
self.doLoadLines()
def doLoadLines(self):
self.df.clearFrame("C", 0)
pos = 0
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
for row, rec in enumerate(recs):
for num, dat in enumerate(rec[3:-1]):
self.df.loadEntry("C", 0, pos, data=dat)
pos += 1
if pos == (self.df.rows[0] * self.df.colq[0]):
self.df.scrollScreen(0)
pos = pos - self.df.colq[0]
pos += 1
self.df.focusField("C", 0, pos)
class ms1040(object):
def __init__(self, **opts):
self.opts = opts
if "args" in opts:
self.code = opts["args"]
else:
self.code = None
if self.setVariables():
self.mainProcess()
if self.code:
self.df.doKeyPressed("T", 0, 0, self.code)
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", "ctlvrf", "ctlvtf",
"chglog"], prog=self.__class__.__name__)
if self.sql.error:
return
if not self.code:
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
if not ctlmst["ctm_taxno"]:
showError(self.opts["mf"].body, "Unregistered",
"The Company Record Does Not Have a V.A.T. Number")
return
return True
def mainProcess(self):
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y"),
("vtm_cat", "", 0, "C")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [("vtr_cono", "=", self.opts["conum"])],
"whera": [["T", "vtr_code", 0, 0]]}
vtt = {
"stype": "C",
"titl": "VAT Types",
"head": ("C", "Description"),
"data": [
["N", "None"],
["S", "Standard"],
["Z", "Zero Rated"],
["C", "Capital Item"],
["X", "Excluded Item"]]}
fld = (
(("T",0,0,0),"IUA",1,"V.A.T. Code","",
"","Y",self.doCode,vtm,None,("notblank",)),
(("T",0,1,0),"INA",30,"Description","",
"","N",self.doDesc,None,self.doDelete,("notblank",)),
(("T",0,2,0),"IUA",1,"Category","",
"S","N",self.doCat,vtt,None,("in", ("C","N","S","X","Z"))),
(("C",0,0,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doStart,vtr,None,("efld",)),
(("C",0,0,1),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doRate,None,None,("efld",)))
but = (
("Print",None,self.doPrint,0,("T",0,1),(("T",0,0),("T",0,2))),
("Add",None,self.doAdd,0,("T",0,0),None),
("Edit",None,self.doEdit,0,("T",0,0),None),
("Exit",None,self.doExit,0,("T",0,0),(("T",0,1),("C",0,1))))
tnd = ((self.doTEnd,"y"), )
txt = (self.doTExit, )
cnd = ((self.doCEnd,"y"), )
cxt = (self.doCExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, rows=(15,))
def doPrint(self):
hds = "V.A.T. Records"
col = [
["vtm_code", "UA", 1, "C"],
["vtm_desc", "NA", 30, "Description"],
["vtm_cat", "UA", 1, "T"],
["vtr_date", "d1", 10, "Start-Date"],
["vtr_rate", "UD", 6.2, "Rate"]]
recs = self.sql.getRec(tables=["ctlvmf", "ctlvrf"], cols=["vtm_code",
"vtm_desc", "vtm_cat", "vtr_date", "vtr_rate"], where=[("vtm_cono",
"=", self.opts["conum"]), ("vtr_cono=vtm_cono",),
("vtr_code=vtm_code",)], order="vtm_code, vtr_date")
code = None
data = copyList(recs)
for num, rec in enumerate(recs):
if rec[0] == code:
data[num][0] = ""
data[num][1] = ""
data[num][2] = ""
code = rec[0]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=data,
heads=[hds], ttype="D", cols=col, prtdia=(("Y","V"), ("Y","N")))
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 0, 1)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.oldm = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)], limit=1)
if not self.oldm:
self.newm = True
else:
self.newm = False
self.desc = self.oldm[self.sql.ctlvmf_col.index("vtm_desc")]
self.df.loadEntry(frt, pag, p+1, data=self.desc)
self.cat = self.oldm[self.sql.ctlvmf_col.index("vtm_cat")]
self.df.loadEntry(frt, pag, p+2, data=self.cat)
self.doLoadRates()
return "ff2"
def doDelete(self):
if self.df.frt == "T":
if self.doCheckTrn():
showError(self.opts["mf"].body, "Exists",
"Transactions Exist for this Code, Not Deleted")
return
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["ctlvmf", "D", "%03i%-1s" % \
(self.opts["conum"], self.code), "", dte, self.opts["capnm"],
"", "", "", 0])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doCat(self, frt, pag, r, c, p, i, w):
self.cat = w
def doTEnd(self):
self.edit = False
datm = [self.opts["conum"]]
datm.extend(self.df.t_work[0][0][:3])
if self.newm:
self.sql.insRec("ctlvmf", data=datm)
if self.cat in ("N", "X", "Z"):
newr = [self.opts["conum"], self.code, 0, 0]
self.sql.insRec("ctlvrf", data=newr)
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
else:
self.doButtons()
self.df.focusField("C", 0, 1)
elif self.cat in ("N", "X", "Z"):
self.df.focusField("T", 0, 1)
elif datm != self.oldm[:len(datm)]:
col = self.sql.ctlvmf_col
datm.append(self.oldm[col.index("vtm_xflag")])
self.sql.updRec("ctlvmf", data=datm, where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec("chglog", data=["ctlvmf",
"U", "%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datm[num]), "", 0])
self.doButtons()
self.opts["mf"].dbm.commitDbase()
def doTExit(self):
chks = ""
recs = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"])])
for rec in recs:
rte = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", rec[1])])
if not rte:
if rec[3] in ("N", "X", "Z"):
self.sql.insRec("ctlvrf", data=[rec[0], rec[1], 0, 0])
self.opts["mf"].dbm.commitDbase()
continue
chks = "%s\n%1s %-30s %1s" % (chks, rec[1], rec[2], rec[3])
if chks:
showError(self.opts["mf"].body, "Missing Rate Record", "The "\
"following VAT Codes do Not have Rate Records:\n%s\n\n"\
"You will Not be able to Exit until you either Create "\
"Rate Records or Delete these codes." % chks)
self.df.focusField("T", 0, 1)
else:
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doAdd(self):
for num, rec in enumerate(self.df.c_work[0]):
if not rec[0] and not rec[1]:
pos = (num * 2) + 1
self.df.focusField("C", 0, pos)
break
def doEdit(self):
self.edit = True
self.newr = False
tit = "Edit Rate"
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [
("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)]}
fld = (
(("T",0,0,0),"OUA",1,"V.A.T. Code"),
(("T",0,1,0),"ONA",30,"Description"),
(("T",0,2,0),"OUA",1,"Category"),
(("T",0,3,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doEStart,vtr,self.doEDelete,("efld",)),
(("T",0,4,0),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doERate,None,self.doEDelete,("notzero",)))
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.ed = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doEEnd,"n"),), txit=(self.doEExit,))
self.ed.loadEntry("T", 0, 0, data=self.code)
self.ed.loadEntry("T", 0, 1, data=self.desc)
self.ed.loadEntry("T", 0, 2, data=self.cat)
self.ed.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
if self.exit:
self.df.focusField("T", 0, 1)
else:
self.doExit()
def doEDelete(self):
self.exit = False
if self.ed.pos == 3:
if self.doCheckTrn():
return ("T", 0, 4, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
else:
if self.doCheckTrn(self.start):
return ("T", 0, 5, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
self.ed.closeProcess()
chk = self.sql.getRec("ctlvrf", cols=["count(*)"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], limit=1)
if not chk[0]:
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.exit = True
self.opts["mf"].dbm.commitDbase()
return "nf"
def doEStart(self, frt, pag, r, c, p, i, w):
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", w)], limit=1)
if not self.oldr:
return "Date Does Not Exist"
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist for Date, Editing Not Allowed.")
return "Invalid Date"
self.start = w
self.rate = self.oldr[3]
self.ed.loadEntry(frt, pag, p+1, data=self.rate)
def doERate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doEEnd(self):
self.ed.closeProcess()
self.doCEnd()
def doEExit(self):
self.ed.closeProcess()
def doStart(self, frt, pag, r, c, p, i, w):
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist On or After This Starting Date.")
return "Invalid Date"
self.start = w
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)], limit=1)
if not self.oldr:
self.newr = True
if self.cat in ("N", "X", "Z"):
if self.edit:
self.ed.loadEntry(frt, pag, p+1, data=0)
else:
self.df.loadEntry(frt, pag, p+1, data=0)
return "nd"
else:
self.newr = False
if self.edit:
self.ed.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
else:
self.df.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
def doRate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doCheckTrn(self, date=None):
where = [
("vtt_cono", "=", self.opts["conum"]),
("vtt_code", "=", self.code)]
if date:
where.append(("vtt_refdt", ">=", date))
return self.sql.getRec("ctlvtf", cols=["count(*)"],
where=where, limit=1)[0]
def doCEnd(self):
datr = [self.opts["conum"], self.code, self.start, self.rate]
if self.newr:
self.sql.insRec("ctlvrf", data=datr)
elif datr != self.oldr[:len(datr)]:
col = self.sql.ctlvrf_col
datr.append(self.oldr[col.index("vtr_xflag")])
self.sql.updRec("ctlvrf", data=datr, where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldr):
if dat != datr[num]:
self.sql.insRec("chglog", data=["ctlvrf", "U",
"%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datr[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
self.edit = False
self.doExit()
def doCExit(self):
self.edit = False
self.doExit()
def doLoadRates(self):
self.df.clearFrame("C", 0)
recs = self.sql.getRec("ctlvrf",
cols=["vtr_date", "vtr_rate"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], order="vtr_date")
for num, rec in enumerate(recs):
pos = (num * 2)
if pos > 27:
self.df.scrollScreen(0)
pos = 26
self.df.focusField("C", 0, pos + 1)
self.df.loadEntry("C", 0, pos, data=rec[0])
self.df.focusField("C", 0, pos + 2)
self.df.loadEntry("C", 0, pos + 1, data=rec[1], zero=True)
def doButtons(self):
self.df.setWidget(self.df.B1, "normal")
self.df.setWidget(self.df.B2, "normal")
self.df.setWidget(self.df.B3, "normal")
self.opts["mf"].window.focus_set()
def doExit(self):
self.df.setWidget(self.df.B3, "disabled")
self.df.focusField("T", 0, 1)
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 gl1020(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", "genmst", "genjlm", "genjlt"],
prog=self.__class__.__name__)
if self.sql.error:
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": ("genjlm", ),
"cols":
(("gjm_num", "", 0, "Number"), ("gjm_desc", "", 0, "Description",
"Y"), ("gjm_freq", "", 0, "Freq"),
("gjm_start", "", 0, "Start"), ("gjm_end", "", 0, "End")),
"where": [("gjm_cono", "=", self.opts["conum"])]
}
seq_sel = {
"stype":
"R",
"tables": ("genjlt", ),
"cols": (("gjt_seq", "", 0, "Seq"), ("gjt_acno", "", 0, "Acc-Num"),
("gjt_amnt", "", 0, "Amount")),
"where": [("gjt_cono", "=", self.opts["conum"])],
"whera": (("T", "gjt_num", 0), )
}
acc_sel = {
"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, "Number", "Journal Number", "", "Y",
self.doNum, num_sel, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
self.doDesc, None, self.doDelNum, ("notblank", )),
(("T", 0, 2, 0), "IUA", 1, "Frequency", "Frequency (M/3/6/Y)",
"", "N", self.doFreq, None, None, ("in", ("M", "3", "6",
"Y"))),
(("T", 0, 3, 0), "ID2", 7, "Starting Period", "", "", "N",
self.doStart, None, None,
("efld", )), (("T", 0, 3, 0), "ID2", 7, "Ending Period", "",
"", "N", self.doEnd, None, None, ("efld", )),
(("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i", "N",
self.doSeq, seq_sel, None, ("notzero", )),
(("C", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N",
self.doAcc, acc_sel, self.doDelSeq, ("efld", )),
(("C", 0, 0,
0), "ONA", 30, "Description", "", "", "N", None, None, None,
None), (("C", 0, 0, 0), "IUA", 1, "V", "V.A.T. Indicator", "",
"N", self.doVat, None, None, ("notblank", )),
(("C", 0, 0, 0), "ISD", 13.2, "Value", "Period Value", "", "N",
self.doValue, None, None, ("efld", )))
but = (("Show Entries", seq_sel, None, 0, ("C", 0, 1), ("C", 0, 2)),
("Show Total", None, self.doTotal, 0, ("C", 0, 1),
("C", 0, 2)), ("Abort Journal", 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):
self.num = w
self.old = self.sql.getRec("genjlm",
where=[("gjm_cono", "=",
self.opts["conum"]),
("gjm_num", "=", self.num)],
limit=1)
if not self.old:
self.new_num = "y"
self.nxtcol = 1
else:
d = self.sql.genjlm_col
self.new_num = "n"
self.df.loadEntry(frt,
pag,
p + 1,
data=self.old[d.index("gjm_desc")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.old[d.index("gjm_freq")])
self.df.loadEntry(frt,
pag,
p + 3,
data=self.old[d.index("gjm_start")])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.old[d.index("gjm_end")])
for x in range(3):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
def doDelNum(self):
if self.new_num == "y":
return
self.sql.delRec("genjlm",
where=[("gjm_cono", "=", self.opts["conum"]),
("gjm_num", "=", self.num)])
try:
self.sql.delRec("genjlt",
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.acc)])
except:
pass
self.opts["mf"].dbm.commitDbase()
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
def doStart(self, frt, pag, r, c, p, i, w):
if w < self.s_per or w > self.e_per:
return "Invalid Start Date"
self.start = w
def doEnd(self, frt, pag, r, c, p, i, w):
if w < self.start or w > self.e_per:
return "Invalid End Date"
self.end = w
def endTop(self):
data = [
self.opts["conum"], self.num, self.desc, self.freq, self.start,
self.end, 0
]
if self.new_num == "y":
self.sql.insRec("genjlm", data=data)
self.df.loadEntry("C", 0, 0, data=1)
else:
if data != self.old[:len(data)]:
col = self.sql.genjlm_col
data.append(self.old[col.index("gjm_xflag")])
self.sql.updRec("genjlm",
data=data,
where=[("gjm_cono", "=", self.opts["conum"]),
("gjm_num", "=", self.num)])
self.doReload()
self.df.focusField("C", 0, self.nxtcol)
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
self.seqdat = self.sql.getRec("genjlt",
where=[("gjt_cono", "=",
self.opts["conum"]),
("gjt_num", "=", self.num),
("gjt_seq", "=", self.seq)],
limit=1)
if not self.seqdat:
self.new_seq = "y"
else:
self.new_seq = "n"
col = self.sql.genjlt_col
acc = self.seqdat[col.index("gjt_acno")]
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc)],
limit=1)[0]
self.df.loadEntry(frt, pag, p + 1, data=acc)
self.df.loadEntry(frt, pag, p + 2, data=des)
self.df.loadEntry(frt,
pag,
p + 3,
data=self.seqdat[col.index("gjt_vatc")])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.seqdat[col.index("gjt_amnt")])
def doDelSeq(self):
if self.new_seq == "y":
return
self.sql.delRec("genjlt",
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num),
("gjt_seq", "=", self.seq)])
self.doReload()
self.df.focusField("C", 0, self.nxtcol)
def doAcc(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.acc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
self.df.loadEntry(frt, pag, p + 2, data=chk[2])
def doVat(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not vat:
return "Invalid VAT Code"
self.vat = w
def doValue(self, frt, pag, r, c, p, i, w):
self.val = w
def endCol(self):
data = [
self.opts["conum"], self.num, self.seq, self.acc, self.vat,
self.val
]
if self.new_seq == "y":
self.sql.insRec("genjlt", data=data)
else:
col = self.sql.genjlt_col
data.append(self.seqdat[col.index("gjt_xflag")])
self.sql.updRec("genjlt",
data=data,
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num),
("gjt_seq", "=", self.seq)])
self.doReload()
self.df.focusField("C", 0, self.nxtcol)
def exitCol(self):
tot = self.sql.getRec("genjlt",
cols=["count(*)", "round(sum(gjt_amnt), 2)"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num)],
limit=1)
if tot[0] and not tot[1]:
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
elif tot[1]:
self.df.focusField("C",
0,
self.df.col,
err="Debits Not Equal Credits")
else:
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
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) * 5
trn = self.sql.getRec(
tables=["genjlt", "genmst"],
cols=["gjt_seq", "gjt_acno", "glm_desc", "gjt_vatc", "gjt_amnt"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num), ("glm_cono=gjt_cono", ),
("glm_acno=gjt_acno", )],
order="gjt_seq")
if trn:
for s, t in enumerate(trn):
if s >= self.df.rows[0]:
self.df.scrollScreen(0)
p = last
else:
p = s * 5
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])
if p == last:
self.df.scrollScreen(0)
self.nxtcol = last + 1
else:
self.nxtcol = p + 6
def doTotal(self):
tot = self.sql.getRec("genjlt",
cols=["round(sum(gjt_amnt),2)"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num)],
limit=1)
if not tot[0]:
tot = CCD(0, "SD", 15.2)
else:
tot = CCD(tot[0], "SD", 15.2)
showInfo(self.opts["mf"].body, "Journal Total", tot.disp)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
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 tb1010(object):
def __init__(self, **opts):
self.opts = opts
self.opts["mf"].dbm.openDbase()
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ftable", "ffield"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def doProcess(self):
fft = {
"stype":
"R",
"tables": ("ftable", ),
"cols": (("ft_tabl", "", 0, "Table"), ("ft_desc", "", 0,
"Description", "Y")),
"where": [("ft_seq", "=", 1)]
}
ffl = {
"stype":
"R",
"tables": ("ffield", ),
"cols": (("ff_seq", "", 0, "Seq"), ("ff_name", "", 0, "Name"),
("ff_desc", "", 0, "Description", "Y"),
("ff_type", "", 0, "Tp"), ("ff_size", "", 0, "Size")),
"whera": (("T", "ff_tabl", 0, 0), ),
"index":
0
}
ffi = {
"stype":
"R",
"tables": ("ftable", ),
"cols":
(("ft_seq", "", 0, "Seq"), ("ft_type", "", 0,
"T"), ("ft_key0", "", 0, "Column-1"),
("ft_key1", "", 0, "Column-2"), ("ft_key2", "", 0, "Column-3"),
("ft_key3", "", 0, "Column-4"), ("ft_key4", "", 0, "Column-5"),
("ft_key4", "", 0, "Column-6"), ("ft_key4", "", 0, "Column-7")),
"whera": (("T", "ft_tabl", 0, 0), ),
"comnd":
self.doIdxCmd
}
typ = {
"stype": "C",
"titl": "Select the Required Data Type",
"head": ("Cd", "Description"),
"data": dattyp,
"index": 0
}
valtyp = []
for t in dattyp:
valtyp.append(t[0])
self.col = {
"stype": "C",
"titl": "Select the Required Column",
"head": ("Table", "Description"),
"data": []
}
fld = [(("T", 0, 0, 0), "INA", 20, "Table ", "Table Name", "", "Y",
self.doTable, fft, None, ("notin", ("", "ftable", "ffield"))),
(("T", 0, 0, 0), "INA", 30, " Description ", "Description", "",
"N", self.doDesc, None, None, None),
(("C", 1, 0, 0), "IUI", 3, "Seq", "Column Sequence", "i", "N",
self.doColSeq, ffl, None, ("between", 0, 999)),
(("C", 1, 0, 1), "INA", 20, "Column", "Column Name", "", "N",
None, None, None, ("notblank", )),
(("C", 1, 0, 2), "INA", 2, "Tp", "Data Type", "", "N", None,
typ, None, ("in", valtyp)),
(("C", 1, 0, 3), "IUD", 6.1, "Size", "Field Size", "", "N",
None, None, None, ("notzero", )),
(("C", 1, 0, 4), "INA", 30, "Description", "", "", "N", None,
None, None, None),
(("C", 1, 0, 5), "INA", 30, "Heading", "Report Heading", "",
"N", None, None, None, ("notblank", )),
(("C", 2, 0, 0), "IUI", 1, "S", "Sequence", "i", "N",
self.doIdxSeq, ffi, None, ("efld", )),
(("C", 2, 0, 1), "IUA", 1, "T", "Type (U/N)", "", "N", None,
None, None, ("in", ("U", "N"))),
(("C", 2, 0, 2), "INA", (14, 20), "Column-0", "", "", "N",
self.doIdxCol, self.col, None, ("notblank", )),
(("C", 2, 0, 3), "INA", (14, 20), "Column-1", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 4), "INA", (14, 20), "Column-2", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 5), "INA", (14, 20), "Column-3", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 6), "INA", (14, 20), "Column-4", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 7), "INA", (5, 20), "Col-5", "Column-5", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 8), "INA", (5, 20), "Col-6", "Column-6", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 9), "INA", (5, 20), "Col-7", "Column-7", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 10), "INA", (5, 20), "Col-8", "Column-8", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 11), "INA", (5, 20), "Col-9", "Column-9", "", "N",
self.doIdxCol, self.col, None, ("efld", ))]
tag = (("Columns", None, ("C", 1, 1), ("T", 0, 1)),
("Indexes", None, ("C", 1, 1), ("T", 0, 1)))
row = (0, 15, 5)
tnd = ((self.endTop, "y"), )
txt = (self.exitTop, )
cnd = ((None, "n"), (self.endPage1, "y"), (self.endPage2, "y"))
cxt = (None, self.exitPage1, self.exitPage2)
but = (("Print", None, self.doPrint, 0, ("T", 0, 2), ("T", 0, 1)),
("Cancel", None, self.doRestart, 0, ("T", 0, 2), ("T", 0, 1)))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
rows=row,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doTable(self, frt, pag, r, c, p, i, w):
self.tab = w
tab = self.sql.getRec("ftable",
cols=["ft_tabl", "ft_desc"],
where=[("ft_tabl", "=", w), ("ft_seq", "=", 1)],
limit=1)
if not tab:
self.new = "y"
else:
self.new = "n"
self.df.loadEntry(frt, pag, p + 1, data=tab[1])
yn = askQuestion(screen=self.opts["mf"].body, head="Table Exists",
mess="Changing This Record Could Result In Loss of Data, "\
"Are You Sure You Want to Continue?", default="no")
if yn == "no":
return yn
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def endTop(self):
self.fld = makeArray(6, 100, 1, "S")
self.idx = makeArray(12, 20, 1, "S")
if self.new == "n":
fld = self.sql.getRec("ffield",
where=[("ff_tabl", "=", self.tab)],
order="ff_seq")
for n, f in enumerate(fld):
self.fld[n] = f[1:]
idx = self.sql.getRec("ftable",
where=[("ft_tabl", "=", self.tab)],
order="ft_seq")
for n, f in enumerate(idx):
self.idx[n] = f[2:]
self.idx[n][0] = n
self.doPopulate("fld")
else:
self.df.focusField("C", 1, 1)
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doColSeq(self, frt, pag, r, c, p, i, w):
self.colseq = w
for n, s in enumerate(self.fld[self.colseq][1:]):
self.df.loadEntry("C", 1, p + n + 1, data=s)
def endPage1(self):
pos = int(self.df.col / self.df.colq[1]) - 1
self.fld[self.colseq] = copyList(self.df.c_work[1][pos])
self.doPopulate("fld")
def exitPage1(self):
self.createCols()
self.df.selPage("Indexes")
self.doPopulate("idx")
def createCols(self):
self.valcol = []
self.col["data"] = []
for fld in self.fld:
self.valcol.append(fld[1])
self.col["data"].append([fld[1], fld[4]])
def doIdxCmd(self, frt, pag, r, c, p, i, w):
idxseq = int(w[0]) - 1
self.doIdxSeq(frt, pag, r, c, p, i, idxseq)
self.df.focusField(frt, pag, c + 1)
def doIdxSeq(self, frt, pag, r, c, p, i, w):
self.idxseq = w
for n, s in enumerate(self.idx[self.idxseq][1:]):
self.df.loadEntry("C", 2, p + n + 1, data=s)
def doIdxCol(self, frt, pag, r, c, p, i, w):
if w and w not in self.valcol:
return "Invalid Column"
def endPage2(self):
pos = int(self.df.col / self.df.colq[2]) - 1
self.idx[self.idxseq] = copyList(self.df.c_work[2][pos])
self.doPopulate("idx")
def exitPage2(self):
if self.new == "y" and self.df.col == 1:
self.df.selPage("Columns")
else:
if self.tab in tabdic:
tabdic[self.tab]["fld"] = []
tabdic[self.tab]["idx"] = []
else:
tabdic[self.tab] = {"fld": [], "idx": []}
for dat in self.fld:
if dat == [""] * 6:
break
tabdic[self.tab]["fld"].append(dat)
for num, dat in enumerate(self.idx):
if dat == [""] * 12:
break
if num == 0:
dat.insert(0, self.df.t_work[0][0][1])
else:
dat.insert(0, "")
dat[1] = num + 1
fmt = '"%s",%s,"%s"'
ddd = dat[:3]
for n, d in enumerate(dat[3:]):
if d:
fmt += ',"%s"'
ddd.append(d)
fmt += "\n"
tabdic[self.tab]["idx"].append(ddd)
fle = os.path.join(getPrgPath(), "stdtab.py")
outf = open(fle, "w")
outf.write("""tabdic = {""")
tabs = list(tabdic.keys())
tabs.sort()
for tab in tabs:
outf.write("""
"%s": {""" % tab)
for key in ("fld", "idx"):
outf.write("""
"%s": [""" % key)
for fld in tabdic[tab][key]:
outf.write("""
%s""" % json.dumps(fld))
if fld == tabdic[tab][key][-1]:
outf.write("""]""")
else:
outf.write(""",""")
if key == "fld":
outf.write(""",""")
outf.write("""}""")
if tab != tabs[-1]:
outf.write(""",""")
outf.write("""}""")
outf.close()
self.doRestart()
def doPopulate(self, ftyp=None):
if ftyp == "fld":
self.df.clearFrame("C", 1)
for num, dat in enumerate(self.fld):
if dat == [""] * 6:
break
if num > 14:
self.df.scrollScreen(1)
pos = 14
else:
pos = num
self.df.focusField("C", 1, (pos * 6) + 1)
for n, c in enumerate(dat):
self.df.loadEntry("C", 1, (pos * 6) + n, data=c)
self.df.advanceLine(1)
return
self.df.clearFrame("C", 2)
for num, dat in enumerate(self.idx):
if dat == [""] * 12:
break
if num > 4:
self.df.scrollScreen(2)
pos = 4
else:
pos = num
self.df.focusField("C", 2, (pos * 12) + 1)
for n, c in enumerate(dat):
self.df.loadEntry("C", 2, (pos * 12) + n, data=c)
self.df.advanceLine(2)
self.df.focusField("C", 2, self.df.col)
def doRestart(self):
self.df.last[0] = [0, 0]
self.df.selPage("Columns")
self.df.focusField("T", 0, 1)
def doPrint(self):
state = self.df.disableButtonsTags()
cols = [["ff_seq", "UI", 3.0, "Seq"],
["ff_name", "NA", 20.0, "Field Name"],
["ff_type", "NA", 2.0, "Tp"], ["ff_size", "NA", 6.1, "Size"],
["ff_desc", "NA", 30.0, "Description"],
["ff_head", "NA", 20.0, "Heading"]]
whr = [("ff_tabl", "=", self.tab)]
RepPrt(self.opts["mf"],
name=self.tab + "_fld",
tables=["ffield"],
heads=[
"Table Fields for Table %s" % self.tab,
],
cols=cols,
where=whr)
cols = [["ft_desc", "NA", 30.0, "Table Description"],
["ft_seq", "UI", 2.0, "Sq"], ["ft_type", "NA", 1.0, "T"],
["ft_key0", "NA", 10.0, "1st-Key"],
["ft_key1", "NA", 10.0, "2nd-Key"],
["ft_key2", "NA", 10.0, "3rd-Key"],
["ft_key3", "NA", 10.0, "4th-Key"],
["ft_key4", "NA", 10.0, "5th-Key"],
["ft_key5", "NA", 10.0, "6th-Key"],
["ft_key6", "NA", 10.0, "7th-Key"],
["ft_key7", "NA", 10.0, "8th-Key"],
["ft_key8", "NA", 10.0, "9th-Key"],
["ft_key9", "NA", 10.0, "10th-Key"]]
whr = [("ft_tabl", "=", self.tab)]
RepPrt(self.opts["mf"],
name=self.tab + "_idx",
tables=["ftable"],
heads=[
"Table Keys for Table %s" % self.tab,
],
cols=cols,
where=whr)
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
