class rt1010(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,
["ctlmst", "rtlprm", "rtlmst", "rtlcon", "rtltrn", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
return True
def mainProcess(self):
prm = {
"stype":
"R",
"tables": ("rtlprm", ),
"cols": (("rtp_code", "", 0, "Prm-Code"), ("rtp_desc", "", 0,
"Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]
}
acc = {
"stype":
"R",
"tables": ("rtlmst", ),
"cols":
(("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")),
"where": [("rtm_cono", "=", self.opts["conum"])],
"whera": (("T", "rtm_code", 0, 0), )
}
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "A"))
r2s = (("Current", "C"), ("Expired", "X"))
self.fld = ((("T", 0, 0, 0), "INA", 7, "Premises Code", "", "", "Y",
self.doPremises, prm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 7, "Account Code", "", "", "N",
self.doAccount, acc, None, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Tenant Name", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 2",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 6, 0), "INA", 4, "Postal Code", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 7, 0), "INA", 20, "Telephone Number", "", "",
"N", None, None, None,
("efld", )), (("T", 0, 8, 0), "ITX", 50, "E-Mail Address",
"", "", "N", None, None, None, ("email", )),
(("T", 0, 9, 0), "IUA", 1, "VAT Indicator", "", self.taxdf,
"N", None, None, None,
("notblank", )), (("T", 0, 10, 0), "INA", 10,
"VAT Number", "", "", "N",
self.doVatNum, None, None, ("efld", )),
(("T", 0, 11, 0), ("IRB", r1s), 0, "Payment Frequency", "",
"M", "N", None, None, None,
None), (("T", 0, 12, 0), "ID1", 10, "Start Date", "", "",
"N", self.doStart, None, None,
("notzero", )), (("T", 0, 13, 0), "IUI", 3,
"Number of Periods", "", "", "N",
None, None, None, ("notzero", )),
(("T", 0, 14, 0), "IUD", 12.2, "Rental Amount", "", "",
"N", self.doAmount, None, None,
("notzero", )), (("T", 0, 15,
0), ("IRB", r2s), 0, "Status", "", "",
"N", None, None, None, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
if "args" in self.opts:
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][0])
self.df.doKeyPressed("T", 0, 1, data=self.opts["args"][1])
def doPremises(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlprm",
cols=["rtp_desc"],
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Premises"
self.code = w
col = ["rtc_payind", "rtc_start", "rtc_period"]
whr = [("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code), ("rtc_status", "=", "C")]
chk = self.sql.getRec("rtlcon",
cols=col,
where=whr,
order="rtc_start desc")
if not chk:
self.end = 0
return
freq, start, period = chk[0]
if freq == "M":
self.end = CCD(projectDate(start, period, "months"), "D1", 10)
elif freq == "3":
self.end = CCD(projectDate(start, period * 3, "months"), "D1", 10)
elif freq == "6":
self.end = CCD(projectDate(start, period * 6, "months"), "D1", 10)
else:
self.end = CCD(projectDate(start, period, "years"), "D1", 10)
def doAccount(self, frt, pag, r, c, p, i, w):
self.acno = w
self.oldm = self.sql.getRec("rtlmst",
where=[("rtm_cono", "=",
self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", self.acno)],
limit=1)
if not self.oldm:
self.new = "y"
for num in range(2, self.df.topq[0]):
self.df.clearEntry(frt, pag, num + 1)
con = self.sql.getRec("rtlcon",
cols=["count(*)"],
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)],
limit=1)
if not con[0]:
self.cnum = 1
else:
self.cnum = con[0] + 1
else:
self.new = "n"
for num, fld in enumerate(self.oldm[2:]):
self.df.loadEntry(frt, pag, p + num, data=fld)
self.oldc = self.sql.getRec("rtlcon",
where=[("rtc_cono", "=",
self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)],
order="rtc_cnum")
self.cnum = self.oldc[-1:][0][3]
for num, fld in enumerate(self.oldc[-1:][0][4:-1]):
self.df.loadEntry(frt, pag, num + 11, data=fld)
trn = self.sql.getRec("rtltrn",
cols=["count(*)"],
where=[("rtt_cono", "=", self.opts["conum"]),
("rtt_code", "=", self.code),
("rtt_acno", "=", self.acno)],
limit=1)
if trn[0]:
self.trn = True
else:
self.trn = False
def doVatNum(self, frt, pag, r, c, p, i, w):
if self.new == "n" and self.trn:
return "sk1"
def doStart(self, frt, pag, r, c, p, i, w):
if self.new == "y" and self.end and w < self.end.work:
return "Premises Already Let till %s" % self.end.disp
def doAmount(self, frt, pag, r, c, p, i, w):
if self.new == "y":
self.df.loadEntry(frt, pag, p + 1, data="C")
def doDelete(self):
if self.trn:
return "Transactions Exist, Not Deleted"
self.sql.delRec("rtlmst",
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", self.acno)])
self.sql.delRec("rtlcon",
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"rtlmst", "D",
"%03i%-7s" % (self.opts["conum"], self.code), "",
dte, self.opts["capnm"], "", "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
datm = [self.opts["conum"]]
datc = [self.opts["conum"], self.code, self.acno, self.cnum]
for num, fld in enumerate(self.df.t_work[0][0]):
if num < 11:
datm.append(fld)
if num > 10:
datc.append(fld)
if self.new == "y":
self.sql.insRec("rtlmst", data=datm)
self.sql.insRec("rtlcon", data=datc)
else:
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
if datm != self.oldm[:len(datm)]:
col = self.sql.rtlmst_col
datm.append(self.oldm[col.index("rtm_xflag")])
self.sql.updRec("rtlmst",
data=datm,
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", self.acno)])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec(
"chglog",
data=[
"rtlmst", "U",
"%03i%-7s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(datm[num]), "", 0
])
if datc != self.oldc[-1:][0][:len(datc)]:
col = self.sql.rtlcon_col
datc.append(self.oldc[col.index("rtc_xflag")])
self.sql.updRec("rtlcon",
data=datc,
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno),
("rtc_cnum", "=", self.cnum)])
for num, dat in enumerate(self.oldc[-1:][0]):
if dat != datc[num]:
self.sql.insRec("chglog",
data=[
"rtlcon", "U",
"%03i%-7s%-7s%03i" %
(self.opts["conum"], self.code,
self.acno, self.cnum), col[num],
dte, self.opts["capnm"],
str(dat),
str(datc[num]), "", 0
])
if "args" in self.opts:
self.doExit()
else:
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class wg2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["wagedc", "wagmst", "wagcap", "wagcod"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.m_hrs = wagctl["ctw_m_hrs"]
self.w_hrs = wagctl["ctw_w_hrs"]
self.d_hrs = wagctl["ctw_d_hrs"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.edit = None
return True
def dataHeader(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "Emp-Num"),
("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0,
"First Names")),
"where": [("wgm_cono", "=", self.opts["conum"]),
("wgm_term", "=", 0)]
}
wed = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_code", "", 0, "Code"), ("ced_desc", "", 0,
"Description", "Y")),
"where": [("ced_cono", "=", self.opts["conum"])],
"whera": [["C", "ced_type", 4, 0]]
}
fld = ((("C", 0, 0, 0), "IUI", 5, "EmpNo", "Employee Number", "r", "N",
self.doEmpno, wgm, None, ("efld", )), (("C", 0, 0, 1), "ONA",
40, "Name"),
(("C", 0, 0, 2), "OUI", 3,
"Dep"), (("C", 0, 0, 3), "IUI", 5, "JobNo", "Job Number", "r",
"N", None, None, None, ("efld", )),
(("C", 0, 0, 4), "IUA", 1, "T", "Earnings/Deduction/NoPay", "r",
"N", self.doType, None, None, ("in", ("E", "D"))),
(("C", 0, 0, 5), "IUI", 3, "Cde", "Code Number", "", "N",
self.doCode, wed, None, ("efld", )), (("C", 0, 0, 6), "ONA",
20, "Description"),
(("C", 0, 0, 7), "IUA", 1, "P", "Pay (Y or N)", "Y", "N",
self.doPay, None, None, ("in", ("Y", "N"))), [
("C", 0, 0, 8), "ISD", 13.2, "Amount", "", "", "N",
self.doAmt, None, None, None
])
but = (("Edit", None, self.editData, 0, ("C", 0, 1), ("C", 0, 2)),
("Interrogate", None, self.queryWag, 0, ("C", 0, 1), ("C", 0,
2)))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
cend=((self.endData, "y"), ),
cxit=(self.exitData, ))
def doEmpno(self, frt, pag, r, c, p, i, w):
rec = self.sql.getRec("wagmst",
cols=[
"wgm_sname", "wgm_fname", "wgm_dept",
"wgm_freq", "wgm_term"
],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", w)],
limit=1)
if not rec:
return "Invalid Employee Number"
elif rec[4]:
return "Employment Terminated"
self.empno = w
name = "%s, %s" % (rec[0], rec[1].split()[0])
self.df.loadEntry(frt, pag, p + 1, data=name)
self.df.loadEntry(frt, pag, p + 2, data=rec[2])
self.freq = rec[3]
def doType(self, frt, pag, r, c, p, i, w):
self.rtyp = w
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
rec = self.readWagedc()
if not rec:
return "Invalid Code"
chk = self.sql.getRec("wagcap",
where=[("wcp_cono", "=", self.opts["conum"]),
("wcp_empno", "=", self.empno),
("wcp_type", "=", self.rtyp),
("wcp_code", "=", self.code)])
if chk:
if self.rtyp == "E":
txt = "Earnings"
else:
txt = "Deduction"
ok = askQuestion(self.df.mstFrame, head="Duplicate",
mess="An Entry for this %s Code Already Exists "\
"for this Employee.\n\nIs This Correct?" % txt)
if ok == "no":
return "rf"
self.df.loadEntry(frt, pag, p + 1, rec[0])
if self.rtyp == "E" and self.code == 1:
std = self.sql.getRec("wagcod",
cols=["wcd_eamt"],
where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno),
("wcd_type", "=", "E"),
("wcd_code", "=", self.code)],
limit=1)
if std and std[0]:
hrs = std[0]
elif self.freq == "M":
hrs = self.m_hrs
elif self.freq == "W":
hrs = self.w_hrs
elif self.freq == "D":
hrs = self.d_hrs
else:
hrs = self.m_hrs
self.df.colf[0][8][5] = hrs
else:
self.df.colf[0][8][5] = ""
def doPay(self, frt, pag, r, c, p, i, w):
pass
def doAmt(self, frt, pag, r, c, p, i, w):
self.xrow = r
def readWagedc(self):
rec = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", self.rtyp),
("ced_code", "=", self.code)],
limit=1)
if not rec:
return None
else:
return rec
def endData(self):
r = self.xrow
data = [
self.opts["conum"], self.empno, self.df.c_work[0][r][2],
self.df.c_work[0][r][3], self.df.c_work[0][r][4],
self.df.c_work[0][r][5], self.df.c_work[0][r][7],
self.df.c_work[0][r][8], "N", self.opts["capnm"], self.sysdtw
]
if self.edit:
data.append(self.edit)
self.sql.updRec("wagcap",
data=data,
where=[("wcp_seq", "=", self.edit)])
self.edit = None
else:
data.append(0)
self.sql.insRec("wagcap", data=data)
self.df.advanceLine(0)
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.closeProcess()
self.opts["mf"].closeLoop()
def editData(self):
# Display captured items and allow editing
col = [
"wcp_empno", "wgm_sname", "wcp_dept", "wcp_job", "wcp_type",
"wcp_code", "ced_desc", "wcp_ind", "wcp_amt", "wcp_seq"
]
whr = [("wcp_cono", "=", self.opts["conum"]), ("wcp_paid", "=", "N"),
("wgm_cono=wcp_cono", ), ("wgm_empno=wcp_empno", ),
("ced_cono=wcp_cono", ), ("ced_type=wcp_type", ),
("ced_code=wcp_code", )]
data = self.sql.getRec(tables=["wagcap", "wagmst", "wagedc"],
cols=col,
where=whr,
order="wcp_empno")
if not data:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
titl = "Captured Items"
head = ("EmpNo", "Surname", "Dep", "JobNo", "T", "Cod", "Description",
"I", "Amount", "Sequence")
lin = {
"stype":
"C",
"titl":
titl,
"head":
head,
"typs": [("UI", 5), ("NA", 30), ("UI", 3), ("UI", 5), ("UA", 1),
("UI", 3), ("NA", 20), ("UA", 1), ("SD", 13.2),
("UI", 10)],
"data":
data,
"butt": [("Delete", self.doDelete, True)]
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select an Item to Edit")
chg = SChoice(self.opts["mf"],
deco=True,
titl=lin["titl"],
head=lin["head"],
data=lin["data"],
typs=lin["typs"],
mode="S",
retn="D",
butt=lin["butt"],
scrn=self.df.mstFrame)
self.df.enableButtonsTags(state=state)
if chg and chg.selection:
for num, fld in enumerate(chg.selection):
if num in (0, 3, 4, 5):
self.df.doKeyPressed("C", 0, self.df.pos, fld)
elif num == (len(chg.selection) - 1):
self.edit = int(fld)
else:
self.df.loadEntry(self.df.frt, self.df.pag, num, data=fld)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doDelete(self, args):
self.sql.delRec("wagcap", where=[("wcp_seq", "=", args[-1:][0])])
def queryWag(self):
callModule(self.opts["mf"],
self.df,
"wg4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class dr1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmes", "ctlrep", "chglog", "ctlnot", "slsiv1", "drsact",
"drschn", "drsdel", "drsmst", "drstrn", "drstyp"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.chains = drsctl["ctd_chain"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
drc = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"])]
drm["whera"] = [["T", "drm_chain", 0]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
dlm = {
"stype":
"R",
"tables": ("drsdel", ),
"cols": (("del_code", "", 0, "Del-Cod"), ("del_add1", "", 0,
"Address", "Y"))
}
rpm = {
"stype": "R",
"tables": ("ctlrep", ),
"cols":
(("rep_code", "", 0, "Rep"), ("rep_name", "", 0, "Name", "Y")),
"where": [("rep_cono", "=", self.opts["conum"])]
}
act = {
"stype":
"R",
"tables": ("drsact", ),
"cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0,
"Description", "Y"))
}
typ = {
"stype":
"R",
"tables": ("drstyp", ),
"cols": (("dtp_code", "", 0, "Cod"), ("dtp_desc", "", 0,
"Description", "Y"))
}
msi = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details", "Y")),
"where": [("mss_system", "=", "INV")]
}
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details", "Y")),
"where": [("mss_system", "=", "STA")]
}
tag = (("Basic-_A", None, ("T", 1, 1), ("T", 0, 1)),
("Basic-_B", None, ("T", 1, 1), ("T", 0, 1)))
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("New", "N"), ("Good", "G"), ("Fair", "F"), ("Poor", "P"),
("Bad", "B"))
self.fld = [
[("T",0,0,0),"IUI",3,"Chain Store","",
"","Y",self.doChain,drc,None,("efld",)],
[("T",0,0,14),"INA",7,"Acc-Num","Account Number",
"","N",self.doAcno,drm,None,("efld",),None,
"To Automatically Generate Account Numbers for "\
"New Accounts enter a Blank Account Number."],
(("T",0,0,30),"INA",30,"Name","",
"","N",self.doName,None,self.doDelete,("notblank",)),
[("T",0,0,0),"INA",7,"Acc-Num","Account Number",
"","Y",self.doAcno,drm,None,("efld",),None,
"To Automatically Generate Account Numbers for "\
"New Accounts enter a Blank Account Number."],
(("T",0,0,14),"INA",30,"Name","",
"","N",self.doName,None,self.doDelete,("notblank",)),
(("T",1,0,0),"INA",30,"Address Line 1","",
"","N",None,None,None,("notblank",)),
(("T",1,1,0),"INA",30,"Address Line 2","",
"","N",None,None,None,("efld",)),
(("T",1,2,0),"INA",30,"Address Line 3","",
"","N",None,None,None,("efld",)),
(("T",1,3,0),"INA",4,"Postal Code","",
"","N",None,None,None,("efld",)),
(("T",1,4,0),"INA",20,"Telephone","",
"","N",None,None,None,("efld",)),
(("T",1,5,0),"INA",20,"Fax","",
"","N",None,None,None,("efld",)),
(("T",1,6,0),"INA",30,"Manager","Manager's Name",
"","N",None,None,None,("efld",)),
(("T",1,6,47),"ITX",30,"E-Mail","Manager's E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,7,0),"INA",30,"Accounts","Accounts Contact",
"","N",None,None,None,("efld",)),
(("T",1,7,47),"ITX",30,"E-Mail","Accounts E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,8,0),"INA",30,"Sales","Sales Contact",
"","N",None,None,None,("efld",)),
(("T",1,8,47),"ITX",30,"E-Mail","Sales E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,9,0),"Id1",10,"Date Opened","Date Account Opened",
self.sysdtw,"N",None,None,None,("efld",)),
(("T",1,10,0),"Id1",10,"Date Registered","",
"","N",None,None,None,("efld",)),
(("T",1,11,0),"INA",10,"V.A.T Number","",
"","N",None,None,None,("efld",)),
(("T",1,12,0),"INa",7,"Delivery Code","",
"","N",self.doDelivery,dlm,None,("efld",)),
(("T",1,13,0),"INa",3,"Rep Code","",
"","N",self.doRep,rpm,None,("efld",)),
(("T",1,13,20),"ONA",26,""),
(("T",1,14,0),"IUA",3,"Business Activity","",
"","N",self.doBusAct,act,None,("efld",)),
(("T",1,14,20),"ONA",26,""),
(("T",1,15,0),"IUA",3,"Business Type","",
"","N",self.doBusTyp,typ,None,("efld",)),
(("T",1,15,20),"ONA",26,""),
(("T",2,0,0),"IUI",1,"Price Level","",
"","N",None,None,None,("efld",)),
(("T",2,1,0),"IUD",5.2,"Discount Percentage","",
"","N",None,None,None,("efld",)),
(("T",2,2,0),"IUD",5.2,"Interest Percentage","",
"","N",None,None,None,("efld",)),
(("T",2,3,0),"IUI",3,"Referral Terms","",
"","N",None,None,None,("efld",)),
(("T",2,4,0),"IUI",3,"Rejected Terms","",
"","N",None,None,None,("efld",)),
(("T",2,5,0),"IUI",5,"Credit Limit","",
"","N",None,None,None,("efld",)),
(("T",2,6,0),("IRB",r1s),0,"Stop Indicator","",
"N","N",None,None,None,None),
(("T",2,7,0),"IUI",3,"Invoice Message","",
"","N",self.doImes,msi,None,("efld",)),
(("T",2,7,22),"ONA",50,""),
(("T",2,8,0),"IUI",3,"Statement Message","",
"","N",self.doSmes,mss,None,("efld",)),
(("T",2,8,22),"ONA",50,""),
(("T",2,9,0),("IRB",r2s),0,"Credit Rating","",
"N","N",None,None,None,None)]
but = (("Import", None, self.doImport, 0, ("T", 0, 1), ("T", 0, 2),
"Import Account Details from a CSV or XLS File."),
("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 1)),
("Print", None, self.doPrint, 0, ("T", 1, 1), ("T", 0, 1)),
("Cancel", None, self.doCancel, 0, ("T", 1, 1),
("T", 0, 1)), ("Quit", None, self.doExit1, 1, None, None))
tnd = ((self.doEnd1, "N"), (self.doEnd2, "N"), (self.doAccept, "Y"))
txt = (self.doExit1, self.doExit2, self.doExit3)
if self.chains == "Y":
del self.fld[3]
del self.fld[3]
else:
del self.fld[0]
del self.fld[0]
del self.fld[0]
self.chain = 0
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
if "args" in self.opts:
if self.chains == "Y":
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][0])
self.df.doKeyPressed("T", 0, 1, data=self.opts["args"][1])
else:
self.chain = self.opts["args"][0]
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][1])
def doClick(self, *opts):
if self.df.pag == 0:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", self.chain)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doAcno(self, frt, pag, r, c, p, i, w):
self.acno = w
if self.acno:
self.old = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)],
limit=1)
if not self.acno or not self.old:
ok = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if ok == "no":
return "Invalid Account Number"
pw = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="DRS",
code="NewAcc")
if pw.flag == "no":
if "args" in self.opts:
return "xt"
else:
return "New Account Creation is Not Allowed"
self.new = True
elif self.old[self.sql.drsmst_col.index("drm_stat")] == "X":
return "Invalid Account, Redundant"
else:
self.new = False
self.df.loadEntry("T", pag, p + 1, data=self.old[3])
d = 4
for pg in range(1, self.df.pgs + 1):
for x in range(0, self.df.topq[pg]):
if pg == 1 and x in (17, 19, 21):
continue
if pg == 2 and x in (8, 10):
continue
if pg == 2 and x == 11 and not self.old[d]:
data = "N"
else:
data = self.old[d]
self.df.loadEntry("T", pg, x, data=data)
d += 1
self.loadRep()
self.loadAct()
self.loadTyp()
self.loadInvMess()
self.loadStaMess()
def loadRep(self):
acc = self.sql.getRec("ctlrep",
cols=["rep_name"],
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=",
self.df.t_work[1][0][16])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 17, data=acc[0])
def loadAct(self):
acc = self.sql.getRec("drsact",
cols=["dac_desc"],
where=[("dac_code", "=",
self.df.t_work[1][0][18])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 19, data=acc[0])
def loadTyp(self):
acc = self.sql.getRec("drstyp",
cols=["dtp_desc"],
where=[("dtp_code", "=",
self.df.t_work[1][0][20])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 21, data=acc[0])
def loadInvMess(self):
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "INV"),
("mss_message", "=",
self.df.t_work[2][0][7])],
limit=1)
if acc:
self.df.loadEntry("T", 2, 8, data=acc[0])
def loadStaMess(self):
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "STA"),
("mss_message", "=",
self.df.t_work[2][0][9])],
limit=1)
if acc:
self.df.loadEntry("T", 2, 10, data=acc[0])
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
if self.new and not self.acno:
for x in range(1, 100):
self.acno = genAccNum(self.name, x, 7)
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)],
limit=1)
if not chk:
break
self.df.loadEntry("T", 0, 0, data=self.acno)
def doDelivery(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
ok = askQuestion(self.opts["mf"].body, head="Delivery Address",
mess="This Delivery Address Does Not Exist, Would "\
"You Like to Create It Now?", default="no")
if ok == "no":
return "rf"
callModule(self.opts["mf"],
self.df,
"drc410",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=None,
args=w)
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
return "rf"
def doRep(self, frt, pag, r, c, p, i, w):
if 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 Rep"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doBusAct(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsact",
cols=["dac_desc"],
where=[("dac_code", "=", w)],
limit=1)
if not acc:
return "Invalid Business Activity"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doBusTyp(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drstyp",
cols=["dtp_desc"],
where=[("dtp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Business Type"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doImes(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "INV"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Invoice Message"
self.df.loadEntry("T", 2, p + 1, data=acc[0])
def doSmes(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "STA"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Statement Message"
self.df.loadEntry("T", 2, p + 1, data=acc[0])
def doDelete(self):
trs = self.sql.getRec("drstrn",
cols=["count(*)"],
where=[("drt_cono", "=", self.opts["conum"]),
("drt_chain", "=", self.chain),
("drt_acno", "=", self.acno)],
limit=1)
if trs[0]:
return "%s Transactions Exist, Not Deleted" % trs[0]
iv1 = self.sql.getRec("slsiv1",
cols=["count(*)"],
where=[("si1_cono", "=", self.opts["conum"]),
("si1_chain", "=", self.chain),
("si1_acno", "=", self.acno)],
limit=1)
if iv1[0]:
return "%s Sales Document Exists, Not Deleted" % iv1[0]
key = "%03i%s" % (self.chain, self.acno)
nte = self.sql.getRec("ctlnot",
cols=["count(*)"],
where=[("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "DRS"),
("not_key", "=", key)],
limit=1)
if nte[0]:
return "%s Notes Exist, Not Deleted" % nte[0]
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
self.sql.insRec("chglog", data=["drsmst", "D", "%03i%03i%-7s" % \
(self.opts["conum"], self.chain, self.acno), "", dte,
self.opts["capnm"], "", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd1(self):
self.df.focusField("T", 1, 1, clr=self.new)
def doEnd2(self):
self.df.selPage("Basic-B")
self.df.focusField("T", 2, 1, clr=self.new)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col + 1
else:
self.df.last[pag][1] = col + 1
self.df.selPage(self.df.tags[pag - 1][0])
else:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
data = [self.opts["conum"], self.chain]
if self.chains == "Y":
f = 1
else:
f = 0
for x in range(f, f + 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 (17, 19, 21):
continue
data.append(self.df.t_work[1][0][x])
for x in range(0, len(self.df.t_work[2][0])):
if x in (8, 10):
continue
data.append(self.df.t_work[2][0][x])
if self.new:
data.extend(["N", ""])
self.sql.insRec("drsmst", data=data)
else:
col = self.sql.drsmst_col
data.append(self.old[col.index("drm_stat")])
data.append(self.old[col.index("drm_xflag")])
if data != self.old:
self.sql.updRec("drsmst",
data=data,
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" %
time.localtime()[:-3])
for num, dat in enumerate(self.old):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"drsmst", "U",
"%03i%03i%-7s" % (self.opts["conum"],
self.chain, self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if "args" in self.opts:
self.doExit1()
else:
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doImport(self):
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="drsmst", impskp=["drm_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Debtor's Accounts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if not line[1]:
if not line[2]:
err = "Blank Account Number and Blank Name"
break
for x in range(1, 100):
line[1] = genAccNum(line[2], x, 7)
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", line[0]),
("drm_acno", "=", line[1])],
limit=1)
if not chk:
break
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", line[0]),
("drm_acno", "=", line[1])],
limit=1)
if chk:
err = "%s %s %s %s Already Exists" % (fi.impcol[0][0], line[0],
fi.impcol[1][0], line[1])
break
if not line[2]:
err = "Blank Name"
break
if not line[15]:
line[15] = self.sysdtw
if not line[28]:
line[28] = "N"
if not line[31]:
line[31] = "N"
line.insert(0, self.opts["conum"])
self.sql.insRec("drsmst", data=line)
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
TabPrt(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
name=self.__class__.__name__,
tabs="drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doExit1(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doExit2(self):
self.df.focusField("T", 0, 1)
def doExit3(self):
self.df.selPage("Basic-A")
class cr1010(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,
["chglog", "ctlnot", "crsmst", "crstrn", "genmst", "strpom"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
crsctl = gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
self.glint = crsctl["ctc_glint"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols":
(("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")),
"where": [("crm_cono", "=", self.opts["conum"]),
("crm_stat", "<>", "X")]
}
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", 1, 1), ("T", 0, 1)),
("Basic-_B", None, ("T", 1, 1), ("T", 0, 1)))
r1s = (("Monthly", "M"), ("Daily", "D"))
r2s = (("Yes", "Y"), ("No", "N"))
self.fld = [
(("T",0,0,0),"INA",7,"Acc-Num","Account Number",
"","Y",self.doAcno,crm,None,("efld",),None,
"To Automatically Generate Account Numbers for "\
"New Accounts enter a Blank Account Number."),
(("T",0,0,0),"INA",30,"Name","",
"","N",self.doName,None,self.doDelete,("notblank",)),
(("T",1,0,0),"INA",30,"Address Line 1","",
"","N",None,None,None,("notblank",)),
(("T",1,1,0),"INA",30,"Address Line 2","",
"","N",None,None,None,("efld",)),
(("T",1,2,0),"INA",30,"Address Line 3","",
"","N",None,None,None,("efld",)),
(("T",1,3,0),"INA",4,"Postal Code","",
"","N",None,None,None,("efld",)),
(("T",1,4,0),"INA",20,"Telephone Number","",
"","N",None,None,None,("efld",)),
(("T",1,5,0),"INA",20,"Fax Number","",
"","N",None,None,None,("efld",)),
(("T",1,6,0),"INA",30,"Manager's Name","",
"","N",None,None,None,("efld",)),
(("T",1,6,0),"ITX",30,"E-Mail","Manager's E-Mail",
"","N",None,None,None,("email",)),
(("T",1,7,0),"INA",30,"Account's Contact","Account's Contact Name",
"","N",None,None,None,("efld",)),
(("T",1,7,0),"ITX",30,"E-Mail","Account's E-Mail",
"","N",None,None,None,("email",)),
(("T",1,8,0),"INA",30,"Order's Contact","Order's Contact Name",
"","N",None,None,None,("efld",)),
(("T",1,8,0),"ITX",30,"E-Mail","Order's E-Mail",
"","N",None,None,None,("email",)),
(("T",1,9,0),"Id1",10,"Date Account Opened","",
self.sysdtw,"N",None,None,None,("efld",)),
(("T",1,10,0),"INA",10,"V.A.T Number","",
"","N",None,None,None,("efld",)),
(("T",2,0,0),("IRB",r1s),0,"Terms Base","",
"M","N",self.doTermsBase,None,None,None),
(("T",2,1,0),"IUI",2,"Statement Day","",
"","N",None,None,None,("between",1,30)),
(("T",2,2,0),"IUI",3,"Terms","",
"","N",None,None,None,("between",0,90)),
(("T",2,3,0),"IUI",7,"Credit Limit","",
"","N",None,None,None,("efld",)),
(("T",2,4,0),"IUD",5.2,"Trade Discount","",
"","N",None,None,None,("efld",)),
(("T",2,5,0),"IUD",5.2,"Settlement Discount",
"Settlement Discount","","N",None,None,None,("efld",)),
(("T",2,6,0),("IRB",r2s),0,"Payment Indicator","",
"Y","N",None,None,None,None),
(("T",2,7,0),"INA",20,"Bank Name","",
"","N",None,None,None,("efld",)),
(("T",2,8,0),"IUI",8,"Bank Branch","",
"","N",None,None,None,("efld",)),
(("T",2,9,0),"INA",16,"Bank Account","",
"","N",None,None,None,("efld",))]
if self.glint == "Y":
self.fld.append((("T", 2, 10, 0), "IUI", 7, "G/L Account Number",
"G/L Account Number", "", "N", self.doGlac, glm,
None, ("efld", )))
else:
self.fld.append((("T", 2, 10, 0), "OUI", 7, "G/L Account Number"))
but = (("Import", None, self.doImport, 0, ("T", 0, 1), ("T", 0, 2),
"Import Account Details from a CSV or XLS File."),
("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 1)),
("Print", None, self.doPrint, 0, ("T", 0, 2), ("T", 2, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 2, 0)), ("Quit", None, self.doQuit, 1, None, None))
tnd = ((self.doEnd, "N"), (self.doEnd, "N"), (self.doAccept, "Y"))
txt = (self.doExit, self.doExit, self.doExit)
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
if "args" in self.opts:
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"])
def doClick(self, *opts):
if self.df.pag == 0:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doAcno(self, frt, pag, r, c, p, i, w):
self.acno = w
if self.acno:
self.old = self.sql.getRec("crsmst",
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_acno", "=", self.acno)],
limit=1)
if not self.acno or not self.old:
ok = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if ok == "no":
return "Invalid Account Number"
pw = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="CRS",
code="NewAcc")
if pw.flag == "no":
if "args" in self.opts:
return "xt"
else:
return "New Account Creation is Not Allowed"
self.new = True
elif self.old[self.sql.crsmst_col.index("crm_stat")] == "X":
return "Invalid Account, Redundant"
else:
self.new = False
self.df.loadEntry("T", pag, p + 1, data=self.old[2])
d = 3
for pge in range(1, self.df.pgs + 1):
for x in range(0, self.df.topq[pge]):
self.df.loadEntry("T", pge, x, data=self.old[d])
d = d + 1
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
if self.new and not self.acno:
for x in range(1, 100):
self.acno = genAccNum(self.name, x, 7)
chk = self.sql.getRec("crsmst",
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_acno", "=", self.acno)],
limit=1)
if not chk:
break
self.df.loadEntry("T", 0, 0, data=self.acno)
def doTermsBase(self, frt, pag, r, c, p, i, w):
if w == "D":
self.df.loadEntry(frt, pag, p + 1, 0)
return "sk1"
def doGlac(self, frt, pag, r, c, p, i, w):
if w:
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
def doDelete(self):
trs = self.sql.getRec("crstrn",
cols=["count(*)"],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.acno)],
limit=1)
if trs[0]:
return "%s Transactions Exist, Not Deleted" % trs[0]
pom = self.sql.getRec("strpom",
cols=["count(*)"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_acno", "=", self.acno)],
limit=1)
if pom[0]:
return "%s Purchase Order Exists, Not Deleted" % pom[0]
nte = self.sql.getRec("ctlnot",
cols=["count(*)"],
where=[("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "CRS"),
("not_key", "=", self.acno)],
limit=1)
if nte[0]:
return "%s Notes Exist, Not Deleted" % nte[0]
self.sql.delRec("crsmst",
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["crsmst", "D", "%03i%-7s" % \
(self.opts["conum"], self.acno), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
if self.df.pag == 0:
self.df.focusField("T", 1, 1, clr=self.new)
elif self.df.pag == 1:
self.df.selPage("Basic-B")
self.df.focusField("T", 2, 1, clr=self.new)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col + 1
else:
self.df.last[pag][1] = col + 1
self.df.selPage(self.df.tags[pag - 1][0])
else:
self.df.focusField(frt, pag, (col + 1), err=mes)
return
data = [self.opts["conum"]]
for x in range(0, 3):
for y in range(0, len(self.df.t_work[x][0])):
data.append(self.df.t_work[x][0][y])
if self.new:
data.extend(["N", ""])
self.sql.insRec("crsmst", data=data)
else:
col = self.sql.crsmst_col
data.append(self.old[col.index("crm_stat")])
data.append(self.old[col.index("crm_xflag")])
if data != self.old[:len(data)]:
self.sql.updRec("crsmst",
data=data,
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"crsmst", "U",
"%03i%-7s" % (self.opts["conum"], self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if "args" in self.opts:
self.doQuit()
else:
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
TabPrt(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
name=self.__class__.__name__,
tabs="crsmst",
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.acno)])
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doImport(self):
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="crsmst", impskp=["crm_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Creditor's Accounts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if not line[0]:
if not line[1]:
err = "Blank Account Number and Blank Name"
break
for x in range(1, 100):
line[0] = genAccNum(line[1], x, 7)
chk = self.sql.getRec("crsmst",
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_acno", "=", line[0])],
limit=1)
if not chk:
break
chk = self.sql.getRec("crsmst",
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", line[0])],
limit=1)
if chk:
err = "%s %s Already Exists" % (fi.impcol[0][0], line[0])
break
if not line[1]:
err = "Blank Name"
break
if not line[14]:
line[14] = self.sysdtw
if not line[16]:
line[16] = "M"
if not line[17]:
line[17] = 30
if not line[18]:
line[18] = 30
if not line[22]:
line[22] = "Y"
if self.glint and line[26]:
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", line[26])],
limit=1)
if not chk:
err = "Invalid General Ledger Account"
break
line.insert(0, self.opts["conum"])
self.sql.insRec("crsmst", data=line)
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doExit(self):
if self.df.pag == 0:
self.doQuit()
elif self.df.pag == 1:
self.df.focusField("T", 0, 1)
else:
self.df.selPage("Basic-A")
def doQuit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class gl1030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
self.dep = ctlsys["sys_gl_dep"]
self.dig = ctlsys["sys_gl_dig"]
self.sql = Sql(self.opts["mf"].dbm, ["genmst", "genrpt"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.genrpt_fd = self.sql.genrpt_dic
self.genrpt_cl = self.sql.genrpt_col
self.pags = ["","Q","H","L","G","S","T","U","C","P"]
self.head = ["glr_desc", "glr_high", "glr_ffeed", "glr_ignore"]
self.ledger = [
"glr_from", "glr_to", "glr_high", "glr_obal", "glr_accum",
"glr_print", "glr_norm", "glr_acbal", "glr_ignore",
"glr_store", "glr_snum1", "glr_acstr"]
self.group = [
"glr_group", "glr_desc", "glr_from", "glr_to", "glr_high",
"glr_obal", "glr_accum", "glr_print", "glr_norm", "glr_acbal",
"glr_ignore", "glr_store", "glr_snum1", "glr_acstr", "glr_label"]
self.store = [
"glr_desc", "glr_high", "glr_print", "glr_norm", "glr_acbal",
"glr_clear", "glr_snum1", "glr_strper"]
self.total = [
"glr_desc", "glr_high", "glr_total", "glr_print", "glr_norm",
"glr_clear", "glr_store", "glr_snum1", "glr_acstr", "glr_label"]
self.uline = ["glr_high", "glr_uline"]
self.calc = [
"glr_desc", "glr_high", "glr_cbase", "glr_ctype", "glr_snum2",
"glr_camnt", "glr_snum3"]
self.percent = ["glr_desc", "glr_high", "glr_snum1", "glr_snum2"]
return True
def mainProcess(self):
data = [
("H","Heading"),
("L","Ledger Accounts"),
("G","Group of Accounts"),
("S","Stored Amount"),
("T","Total"),
("U","Underline"),
("C","Calculation"),
("P","Percentage")]
typ = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("T", "Description"),
"data": data}
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Description", "Y")),
"order": "ctm_cono"}
glr = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", "=", 0)],
"whera": (("T", "glr_cono", 0, 0),),
"order": "glr_cono, glr_repno",
"index": 1}
gls = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_seq", "", 0, "Seq"),
("glr_type", "", 0, "T"),
("glr_group", "", 0, "Grp"),
("glr_from", "", 0, "From-Ac"),
("glr_to", "", 0, " To-Ac"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", ">", 0)],
"whera": (("T", "glr_cono", 0, 0),("T", "glr_repno", 1, 0))}
self.glm = {
"stype": "C",
"titl": "Account Numbers",
"head": ("Number", "Description"),
"data": []}
ryn = (("Yes","Y"),("No","N"))
rys = (("Yes","Y"),("No","N"),("Debit","+"),("Credit","-"))
rns = (("Positive","P"),("Negative","N"))
ras = (("Add","A"),("Subtract","S"))
rat = (("Add","A"),("Subtract","S"),("Ignore","I"))
rcb = (("Percentage","P"),("Amount","A"),("Store","S"))
rct = (("Plus","+"),("Minus","-"),("Multiply","*"),("Divide","/"))
rsd = (("Single","S"),("Double","D"),("Blank","B"))
pts = (
"Accumulate Month Values",
"Add, Subtract or Ignore",
"Calculation Base",
"Calculation Type",
"Clear Stored Value",
"Clear Total",
"Highlight",
"Ignore Account Type",
"Include Opening Balance",
"Normal Sign",
"Percentage of Stored Value",
"Print Values",
"Store Amount",
"Add or Subtract")
tag = [
("Sequence",None,None,None,False),
("Heading",None,None,None,False),
("Ledger",None,None,None,False),
("Group",None,None,None,False),
("Stored",None,None,None,False),
("Total",None,None,None,False),
("Uline",None,None,None,False),
("Calc",None,None,None,False),
("Percent",None,None,None,False)]
fld = (
(("T",0,0,0),"IUI",3,"Company","Company Number, 0=All",
self.opts["conum"],"Y",self.doCoyNum,coy,None,
("in", (self.opts["conum"], 0))),
(("T",0,0,0),"IUI",3,"Report","Report Number",
"","N",self.doRepNum,glr,None,("notzero",)),
(("T",0,0,0),"IUA",1,"Type","Report Type (B, P, O)",
"P","N",self.doRepTyp,None,self.doDelRpt,
("in", ("O","P","B"))),
(("T",0,0,0),"INA",30,"Heading","Report Heading",
"","N",None,None,None,("notblank",)),
(("T",1,0,0),"IUD",7.2,"Seq-Num","Sequence Number",
"","N",self.doSeqNum,gls,None,("efld",)),
(("T",1,1,0),"IUA",1,"Sequence Type","",
"","N",self.doSeqType,typ,self.doDelSeq,
("in",("H","L","G","T","S","U","P","C"))),
(("T",2,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",2,1,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",2,2,0),("IRB",ryn),0,"New Page","New Page (Y/N)",
"N","N",None,None,None,None),
(("T",2,3,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",3,0,0),"IUI",7,"From Account","From Account Number",
"","N",self.doAcno,self.glm,None,("notzero",)),
(("T",3,1,0),"IUI",7,"To Account","To Account Number",
"","N",self.doAcno,self.glm,None,("efld",)),
(("T",3,2,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",3,3,0),("IRB",ryn),0,pts[8],"",
"Y","N",None,None,None,None),
(("T",3,4,0),("IRB",ryn),0,pts[0],"",
"N","N",None,None,None,None),
(("T",3,5,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",3,6,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",3,7,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",3,8,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",3,9,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",3,10,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",3,11,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",4,0,0),"IUI",3,"Group Number","",
"","N",self.doGrpNum,None,None,("efld",)),
(("T",4,1,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",4,2,0),"IUI",7,"From Account","From Account Number",
"","N",self.doAcno,self.glm,None,("notzero",)),
(("T",4,3,0),"IUI",7,"To Account","To Account Number",
"","N",self.doAcno,self.glm,None,("efld",)),
(("T",4,4,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",4,5,0),("IRB",ryn),0,pts[8],"",
"Y","N",None,None,None,None),
(("T",4,6,0),("IRB",ryn),0,pts[0],"",
"N","N",None,None,None,None),
(("T",4,7,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",4,8,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",4,9,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",4,10,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",4,11,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",4,12,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",4,13,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",4,14,0),"INA",10,"Chart Label","",
"","N",None,None,None,None),
(("T",5,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",5,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",5,2,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",5,3,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",5,4,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",5,5,0),("IRB",ryn),0,pts[4],"",
"N","N",None,None,None,None),
(("T",5,6,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",5,7,0),"IUD",6.2,pts[10],"",
0,"N",None,None,None,("notzero",)),
(("T",6,0,0),"INA",30,"Description","",
"","N",None,None,None,("efld",)),
(("T",6,1,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",6,2,0),"IUI",1,"Total Level","",
"","N",None,None,None,("between",1,9)),
(("T",6,3,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",6,4,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",6,5,0),("IRB",ryn),0,pts[5],"",
"Y","N",None,None,None,None),
(("T",6,6,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",6,7,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",6,8,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",6,9,0),"INA",10,"Chart Label","",
"","N",None,None,None,None),
(("T",7,0,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",7,1,0),("IRB",rsd),0,"Underline Type","",
"S","N",None,None,None,None),
(("T",8,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",8,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",8,2,0),("IRB",rcb),0,pts[2],"",
"A","N",self.doPAS,None,None,None),
(("T",8,3,0),("IRB",rct),0,pts[3],"",
"+","N",None,None,None,None),
(("T",8,4,0),"IUI",2,"Storage Number (Base)","",
"","N",self.doStore1,None,None,("notzero",)),
(("T",8,5,0),"ISD",13.2,"Amount","Percent/Amount",
"","N",self.doAmount,None,None,("efld",)),
(("T",8,6,0),"IUI",2,"Storage Number (Calc)","",
"","N",None,None,None,("efld",)),
(("T",9,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",9,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",9,2,0),"IUI",2,"Storage Number (Base)","",
"","N",None,None,None,("notzero",)),
(("T",9,3,0),"IUI",2,"Storage Number (Calc)","",
"","N",None,None,None,("notzero",)))
tnd = (
(self.doT0End,"y"), (self.doT1End,"n"), (self.doT2End,"y"),
(self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"),
(self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"),
(self.doT2End,"y"))
txt = (
self.doT0Exit, self.doT1Exit, self.doT2Exit, self.doT2Exit,
self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit,
self.doT2Exit, self.doT2Exit)
but = (
("Import",None,self.doImpRpt,0,("T",0,1),("T",0,2)),
("Export",None,self.doExpRpt,0,("T",0,3),(("T",0,2),("T",0,4))),
("Copy",None,self.doCpyRpt,0,("T",0,3),(("T",0,2),("T",0,4))),
("Re-Sequence",None,self.doReSeq,0,("T",1,1),("T",1,2),None,1),
("Preview",None,self.doPreview,0,("T",1,1),("T",1,2),None,1),
("Print",None,self.doPrint,0,("T",1,1),("T",1,2),None,1))
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt, tags=tag, butt=but)
def doCoyNum(self, frt, pag, r, c, p, i, w):
self.selcoy = w
if self.selcoy == 0:
acc = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], group="glm_acno, glm_desc", order="glm_acno")
else:
acc = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], where=[("glm_cono", "=", self.selcoy)],
group="glm_acno, glm_desc", order="glm_acno")
if self.dep == "Y":
dep = {}
chs = 10 ** (7 - self.dig)
for a in acc:
dep[a[0] % chs] = a[1]
acc = []
for a in dep:
acc.append([a, dep[a]])
acc.sort()
self.glm["data"] = acc
def doRepNum(self, frt, pag, r, c, p, i, w):
self.repno = w
rep = self.doReadRep(self.selcoy, self.repno, 0)
if not rep:
self.newrep = True
self.df.setWidget(self.df.B1, "normal")
else:
self.newrep = False
self.df.setWidget(self.df.B1, "disabled")
self.df.loadEntry(frt, pag, p+1, data=rep[3])
self.df.loadEntry(frt, pag, p+2, data=rep[4])
def doRepTyp(self, frt, pag, r, c, p, i, w):
self.df.setWidget(self.df.B1, "disabled")
def doImpRpt(self):
self.df.setWidget(self.df.B0, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
sel = FileDialog(parent=self.opts["mf"].body, title="Import File",
initd=self.opts["mf"].rcdic["wrkdir"], ftype=[("Report", "*.rpt")])
nam = sel.askopenfilename()
err = None
if nam:
fle = open(nam, "r")
for num, line in enumerate(fle):
dat = line.split("|")
if not num:
if dat[0] != "genrpt":
err = "This File Does Not Contain a Valid Format"
break
chk = self.sql.getRec("genrpt",
where=[("glr_cono", "=", dat[1]), ("glr_repno", "=",
dat[2]), ("glr_seq", "=", 0)], limit=1)
if chk:
ok = askQuestion(self.opts["mf"].body, "Replace?",
"This Report Already Exists, Would you like "\
"to Replace It?")
if ok == "yes":
self.sql.delRec("genrpt", where=[("glr_cono", "=",
dat[1]), ("glr_repno", "=", dat[2])])
else:
err = "Report Already Exists"
break
self.sql.insRec("genrpt", data=dat[1:])
else:
self.sql.insRec(dat[0], data=dat[1:])
if not err:
self.opts["mf"].dbm.commitDbase(ask=True)
else:
showError(self.opts["mf"].body, "Invalid Import", err)
self.df.setWidget(self.df.mstFrame, "show")
self.df.focusField("T", 0, 1)
def doExpRpt(self):
fle = open(os.path.join(self.opts["mf"].rcdic["wrkdir"],
"C%s_R%s.rpt" % (self.selcoy, self.repno)), "w")
rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq")
for lin in rpt:
mes = "genrpt"
for dat in lin:
mes = "%s|%s" % (mes, str(dat))
fle.write("%s\n" % mes)
fle.close()
self.df.focusField("T", 0, 1)
def doCpyRpt(self):
if not self.newrep:
showError(self.opts["mf"].body, "Invalid Copy Request",
"You can only Copy a report when Creating a New report, "\
"not when Changing an Existing report!")
self.df.focusField("T", 0, 3)
return
tit = ("Copy Existing Report Layout",)
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Name", "Y"))}
glr = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", "=", 0)],
"whera": (("T", "glr_cono", 0, 0),),
"index": 1}
fld = (
(("T",0,0,0),"IUI",3,"Company Number","",
"","N",self.doCpyCoy,coy,None,None),
(("T",0,1,0),"IUI",3,"Report Number","",
"","N",self.doRptNum,glr,None,None))
state = self.df.disableButtonsTags()
self.cp = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doCpyEnd, "n"),), txit=(self.doCpyExit,))
self.cp.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 0, 1)
def doCpyCoy(self, frt, pag, r, c, p, i, w):
self.cpycoy = w
def doRptNum(self, frt, pag, r, c, p, i, w):
self.cpynum = w
def doCpyEnd(self):
rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.cpycoy), ("glr_repno", "=", self.cpynum)])
if rpt:
for rec in rpt:
rec[0] = self.selcoy
rec[1] = self.repno
self.sql.insRec("genrpt", data=rec)
self.opts["mf"].dbm.commitDbase()
self.doCpyCloseProcess()
def doCpyExit(self):
self.doCpyCloseProcess()
def doCpyCloseProcess(self):
self.cp.closeProcess()
def doDelRpt(self):
self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doT0End(self):
rtype = self.df.t_work[0][0][2]
desc = self.df.t_work[0][0][3]
if self.newrep:
data = [self.selcoy, self.repno, 0, rtype, desc]
for x in range(5, len(self.genrpt_cl)):
if self.genrpt_fd[self.genrpt_cl[x]][2][1] in ("A", "a"):
data.append("")
else:
data.append(0)
self.sql.insRec("genrpt", data=data)
else:
self.sql.updRec("genrpt", cols=["glr_type", "glr_desc"],
data=[rtype, desc], where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno), ("glr_seq", "=", 0)])
self.df.selPage("Sequence")
self.df.focusField("T", 1, 1)
def doReSeq(self):
whr = [("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)]
recs = self.sql.getRec("genrpt", where=whr, order="glr_seq")
self.sql.delRec("genrpt", where=whr)
for seq, rec in enumerate(recs):
rec = list(rec)
rec[2] = float(seq)
self.sql.insRec("genrpt", data=rec)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPreview(self):
self.cols = [
("a", "Seq-Num", 7.2, "UD"),
("b", "T", 1, "UA"),
("c", "Grp", 3, "Na"),
("d", "Lvl", 3, "Na"),
("e", "Acc-Num", 7, "Na"),
("f", "Description", 30, "NA")]
self.data = []
self.newp = []
recs = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq")
pgp = 0
lsq = 0
rpc = self.sql.genrpt_col
for num, rec in enumerate(recs):
seq = rec[rpc.index("glr_seq")]
rtp = rec[rpc.index("glr_type")]
if rtp in ("B", "P", "O"):
self.titl = rec[rpc.index("glr_desc")]
continue
des = rec[rpc.index("glr_desc")]
prt = rec[rpc.index("glr_print")]
if prt == "N":
continue
if rtp == "H":
if rec[rpc.index("glr_ffeed")] == "Y":
self.data.append((seq, "N", "", "", "",
"---------- New Page ----------"))
elif lsq:
ptp = recs[lsq][rpc.index("glr_type")]
utp = recs[lsq][rpc.index("glr_uline")]
if ptp == "H" or (ptp == "U" and utp == "B"):
pass
else:
self.data.append((seq, "", "", "", "", ""))
self.data.append((seq, rtp, "", "", "", des))
self.data.append((seq, "", "", "", "", ""))
elif rtp == "L":
frm = rec[rpc.index("glr_from")]
too = rec[rpc.index("glr_to")]
whr = [("glm_cono", "=", self.selcoy)]
if too:
whr.append(("glm_acno", "between", frm, too))
else:
whr.append(("glm_acno", "=", frm))
accs = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], where=whr, order="glm_acno")
for acc in accs:
self.data.append((seq, rtp, "", "", acc[0], acc[1]))
elif rtp == "G":
grp = rec[rpc.index("glr_group")]
if not pgp or grp != pgp:
self.data.append((seq, rtp, grp, "", "", des))
pgp = grp
elif rtp == "T":
tot = rec[rpc.index("glr_total")]
self.data.append((seq, rtp, "", tot, "", des))
elif rtp == "S":
self.data.append((seq, rtp, "", "", "", des))
elif rtp == "U":
utp = rec[rpc.index("glr_uline")]
if utp == "B":
des = ""
elif utp == "S":
des = "-" * 30
else:
des = "=" * 30
self.data.append((seq, rtp, "", "", "", des))
else:
continue
lsq = num
self.pprt = False
self.sc = SelectChoice(self.opts["mf"].window, self.titl, self.cols,
self.data, sort=False, butt=(("Print", self.doPrePrt),))
if self.pprt:
cols = []
for col in self.cols:
cols.append([col[0], col[3], col[2], col[1], "y"])
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, "hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__,
tables=self.data, heads=[self.titl], cols=cols, ttype="D",
prtdia=(("Y","V"),("Y","N")))
self.df.setWidget(self.df.mstFrame, "show")
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 1, 1)
elif self.sc.selection:
self.df.doKeyPressed("T", 1, 0, self.sc.selection[1])
self.df.doKeyPressed("T", 1, 1, self.sc.selection[2])
else:
self.df.focusField("T", 1, 1)
def doPrePrt(self):
self.pprt = True
def doPrint(self):
table = ["genrpt"]
heads = ["General Ledger Report %s Layout" % self.repno]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, "hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=table,
heads=heads, where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno)], order="glr_seq asc",
prtdia=(("Y","V"), ("Y","N")))
self.df.setWidget(self.df.mstFrame, "show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSeqNum(self, frt, pag, r, c, p, i, w):
if not w:
acc = self.sql.getRec("genrpt", cols=["max(glr_seq)"],
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno)], limit=1)
if not acc:
w = 1
else:
w = int(acc[0] + 1)
self.df.loadEntry(frt, pag, i, data=w)
self.seqno = w
self.seq = self.doReadRep(self.selcoy, self.repno, self.seqno)
if not self.seq:
self.newseq = "y"
else:
self.newseq = "n"
self.df.loadEntry(frt, pag, p+1, data=self.seq[3])
def doSeqType(self, frt, pag, r, c, p, i, w):
self.stype = w
if self.newseq == "y":
return
if self.stype == self.seq[3]:
return
yn = askQuestion(self.opts["mf"].body, "Change Type?",
"Change the Type?", default="no")
if yn == "no":
return "No Change"
self.newseq = "c"
def doDelSeq(self):
if self.newseq == "y":
showError(self.opts["mf"].body, "Invalid Delete Request",
"You can only delete Existing report lines.")
return
self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno), ("glr_seq", "=", self.seqno)])
self.df.clearFrame("T", 1)
self.df.focusField("T", 1, 1)
return "nf"
def doT1End(self):
for x in range(2, 10):
self.df.clearFrame("T", x)
pag = self.pags.index(self.stype)
if self.newseq == "n":
cl = self.genrpt_cl
fld = self.doLoadTypes()
for x, f in enumerate(fld):
data = self.seq[cl.index(f)]
self.df.loadEntry("T", pag, x, data=data)
self.df.selPage(self.df.tags[pag - 1][0])
def doAcno(self, frt, pag, r, c, p, i, w):
if w:
if pag == 3 and p == 1 and w < self.df.t_work[pag][0][0]:
return "To Account Less Than From Account"
if pag == 4 and p == 3 and w < self.df.t_work[pag][0][2]:
return "To Account Less Than From Account"
found = False
for acc in self.glm["data"]:
if w == acc[0]:
found = True
if not found:
return "Invalid Account Number"
def doStore(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p+1, data=0)
self.df.loadEntry(frt, pag, p+2, data="")
return "sk2"
def doGrpNum(self, frt, pag, r, c, p, i, w):
if not w:
gno = self.sql.getRec("genrpt", cols=["max(glr_group)"],
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno), ("glr_type", "=", "G")], limit=1)
self.gno = gno[0] + 1
self.df.loadEntry(frt, pag, p, data=self.gno)
else:
self.gno = w
col = ["glr_desc", "glr_high", "glr_obal", "glr_accum",
"glr_print", "glr_norm", "glr_acbal", "glr_ignore",
"glr_store", "glr_snum1", "glr_acstr", "glr_label"]
grp = ""
for cc in col:
grp = "%s%s," % (grp, cc)
grp = grp[:-1]
self.grp = self.sql.getRec("genrpt", cols=col,
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno), ("glr_group", "=", self.gno)], group=grp)
if self.grp:
for n, f in enumerate(col):
data = self.grp[0][n]
self.df.loadEntry("T", pag, self.group.index(f), data=data)
def doPAS(self, frt, pag, r, c, p, i, w):
self.pas = w
if self.pas == "P":
self.df.loadEntry(frt, pag, p+1, data="*")
return "sk1"
def doStore1(self, frt, pag, r, c, p, i, w):
if self.pas == "S":
self.df.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doAmount(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doT2End(self):
ff = self.doLoadTypes()
data = [self.selcoy, self.repno, self.seqno, self.stype]
for nm, cl in enumerate(self.genrpt_cl):
if nm < 4:
continue
if cl in ff:
data.append(self.df.t_work[self.pags.index(self.stype)]
[0][ff.index(cl)])
elif self.genrpt_fd[cl][2][1] in ("A", "a"):
data.append("")
else:
data.append(0)
data.append("")
if self.newseq in ("c", "n"):
self.doDelSeq()
self.sql.insRec("genrpt", data=data)
if self.stype == "G" and self.grp:
grp = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno), ("glr_group",
"=", self.gno)], order="glr_seq")
for g in grp:
if g[2] == self.seqno:
continue
data[2] = g[2]
data[8] = g[8]
data[9] = g[9]
data[29] = g[29]
self.sql.updRec("genrpt", data=data, where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno), ("glr_group",
"=", self.gno), ("glr_seq", "=", g[2])])
self.doT2Exit()
if self.newseq == "y":
self.df.loadEntry("T", 1, 0, data=(self.seqno + 1))
else:
self.df.clearEntry("T", 1, 1)
self.df.clearEntry("T", 1, 2)
self.df.focusField("T", 1, 1)
def doLoadTypes(self):
if self.stype == "H":
fld = self.head
elif self.stype == "L":
fld = self.ledger
elif self.stype == "G":
fld = self.group
elif self.stype == "S":
fld = self.store
elif self.stype == "T":
fld = self.total
elif self.stype == "U":
fld = self.uline
elif self.stype == "C":
fld = self.calc
elif self.stype == "P":
fld = self.percent
return fld
def doT0Exit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doT1Exit(self):
# Check for duplicate group numbers
errmess = """Group Number %s at Sequence Line %s is Duplicated or is Not Contiguous i.e. All Group Lines Must Follow One Another!
Please Delete, or Correct This Line!"""
seq = self.sql.getRec("genrpt", cols=["glr_type", "glr_seq",
"glr_group"], where=[("glr_cono", "=", self.selcoy), ("glr_repno",
"=", self.repno)], order="glr_seq")
gp = []
lg = 0
for t, s, g in seq:
if t == "G":
if not lg and g in gp:
showError(
self.opts["mf"].body, "Group Error", errmess % (g, s))
self.df.loadEntry("T", 1, 0, data=s)
self.df.focusField("T", 1, 1)
return
if lg and lg != g:
if g in gp:
showError(self.opts["mf"].body, "Group Error",
errmess % (g, s))
self.df.loadEntry("T", 1, 0, data=s)
self.df.focusField("T", 1, 1)
return
lg = g
gp.append(g)
continue
if not lg:
lg = g
gp.append(g)
continue
else:
lg = 0
self.opts["mf"].dbm.commitDbase(ask=True, mess="Save All Changes?")
self.df.focusField("T", 0, 1)
def doT2Exit(self):
self.df.selPage("Sequence")
def doReadRep(self, coy, rep, seq):
rep = self.sql.getRec("genrpt", where=[("glr_cono", "=", coy),
("glr_repno", "=", rep), ("glr_seq", "=", seq)], limit=1)
return rep
class st2030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.exit = False
self.setPrinter()
if not self.exit:
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"genmst", "gentrn", "strgrp", "strmf1", "strmf2", "strtrn",
"strrcp"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.stk_soh = ctlctl["stk_soh"]
self.stk_susp = ctlctl["stk_susp"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if self.locs == "N":
self.loc = "1"
self.glnum = 0
return True
def setPrinter(self):
tit = ("Printer Selection", )
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=[],
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "P"))
self.opts["mf"].startLoop()
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.pr.closeProcess()
self.opts["mf"].closeLoop()
def dataHeader(self):
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [["C", "st1_group", 0, 0]],
"order":
"st1_group, st1_code",
"index":
1
}
stl = {
"stype":
"R",
"tables": ("strloc", "strmf2"),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Location", "Y")),
"where": [("srl_cono", "=", self.opts["conum"]),
("srl_loc=st2_loc", ), ("st2_cono=srl_cono", )],
"whera": [["C", "st2_group", 0], ["C", "st2_code", 1]],
"order":
"srl_loc",
"index":
0
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N",
self.doIss, None, None, ("notblank", )),
(("T", 0, 0, 0), "ID1", 10, "Date", "Issue Date", self.sysdtw,
"N", self.doDte, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "N",
self.doGroup, gpm, None, ("notblank", )),
[("C", 0, 0, 1), "INA", 20, "Product Code", "", "", "N",
self.doCode, stm, None, ("notblank", )],
(("C", 0, 0, 2), "ONA", 5, "U.O.I"),
(("C", 0, 0, 3), "IUA", 1, "L", "Location", "r", "N",
self.doLoc, stl, None, ("notblank", )),
(("C", 0, 0, 4), "ISD", 9.2, "Quantity", "", "", "N",
self.doQty, None, None, ("notzero", )),
(("C", 0, 0, 5), "OUD", 9.2, "Unit-Cost"),
(("C", 0, 0, 6), "OSD", 9.2, "Value")]
if self.glint == "Y":
fld.append(
(("C", 0, 0, 7), "IUI", 7, "G/L-Acc", "G/L Account Number",
self.stk_susp, "N", self.doGenAcc, glm, None, None))
fld.append((("C", 0, 0, 8), "ONA", 10, "Desc"))
fld.append((("C",0,0,9),"INA",(20,30),"Details","Transaction "\
"Details","","N",self.doTrnDet,None,None,None))
row = (15, )
tnd = ((self.endPage0, "n"), )
txt = (self.exitPage0, )
cnd = ((self.endPage1, "y"), )
cxt = (self.exitPage1, )
but = (("Reprint", None, self.doReprint, 0, ("T", 0, 1), None), )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
rows=row,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doIss(self, frt, pag, r, c, p, i, w):
self.iss = w
def doDte(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.dte = w
self.ddt = self.df.t_disp[pag][0][p]
self.curdt = int(self.dte / 100)
self.batno = "S%s" % self.curdt
def doGroup(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.group = w
def doCode(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_desc", "st1_type", "st1_uoi"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", w),
("st1_type", "<>", "X")],
limit=1)
if not acc:
return "Invalid or Redundant Code"
self.code = w
self.desc = acc[0]
self.gtype = acc[1]
self.df.loadEntry(frt, pag, p + 1, data=acc[2])
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("C", pag, p + 2, data=self.loc)
no = self.checkLoc()
if no:
return no
else:
return "sk2"
def doLoc(self, frt, pag, r, c, p, i, w):
self.loc = w
no = self.checkLoc()
if no:
return no
def checkLoc(self):
acc = self.sql.getRec("strmf2",
cols=["st2_bin"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location For This Product"
def doQty(self, frt, pag, r, c, p, i, w):
self.quant = w
if self.gtype == "R" and self.doRecipe():
return "ff2"
if self.extractCost():
return "rf"
self.df.loadEntry("C", pag, p + 1, data=self.ucost)
self.df.loadEntry("C", pag, p + 2, data=self.tcost)
def doRecipe(self):
self.recipe = self.sql.getRec("strrcp",
where=[("srr_cono", "=",
self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc)],
order="srr_rgroup, srr_rcode")
if not self.recipe:
err = "Invalid Recipe, No Items"
showError(self.opts["mf"].body, "Recipe Error", err)
return err
else:
return self.doRecChg()
def doRecChg(self):
# Display recipe items and allow editing of quantities etc.
data = []
for num, item in enumerate(self.recipe):
st1 = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", item[4]),
("st1_code", "=", item[5])],
limit=1)
err = False
if not st1:
err = "Invalid Stock Record in Recipe"
elif st1[0] == "X":
err = "Redundant Stock Record in Recipe"
if err:
showError(
self.opts["mf"].body, "Recipe Error", """%s!
Group: %s
Code: %s""" % (err, item[4], item[5]))
return err
data.append([num, item[4], item[5], st1[1], item[6]])
titl = "Recipe Items"
head = ("Seq", "Grp", "Product-Code", "Description", "Quantity")
lin = {
"stype": "C",
"titl": titl,
"head": head,
"typs": [("UI", 2), ("NA", 3), ("NA", 20), ("NA", 30),
("SD", 11.2)],
"data": data
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus(
"Select a Product to Edit or Exit to Continue")
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.recchg = chg.selection
self.doRecChanges()
self.doRecChg()
else:
self.df.enableButtonsTags(state=state)
def doRecChanges(self):
tit = ("Change Items", )
fld = ((("T", 0, 0, 0), "ONA", 3,
"Group"), (("T", 0, 1, 0), "ONA", 20,
"Code"), (("T", 0, 2, 0), "ONA", 30, "Description"),
(("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N",
self.doRecQty, None, None, ('notzero', )))
but = (("Delete", None, self.doRecDel, 1, None, None), )
self.rp = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=((self.doRecEnd, "n"), ),
txit=(self.doRecExit, ))
self.rp.loadEntry("T", 0, 0, data=self.recchg[1])
self.rp.loadEntry("T", 0, 1, data=self.recchg[2])
self.rp.loadEntry("T", 0, 2, data=self.recchg[3])
self.rp.loadEntry("T", 0, 3, data=self.recchg[4])
self.rp.focusField("T", 0, 4, clr=False)
self.rp.mstFrame.wait_window()
def doRecQty(self, frt, pag, r, c, p, i, w):
self.recqty = w
def doRecDel(self):
del self.recipe[int(self.recchg[0])]
self.doRecExit()
def doRecEnd(self):
self.recipe[int(self.recchg[0])][6] = self.recqty
self.doRecExit()
def doRecExit(self):
self.rp.closeProcess()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.glnum = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doTrnDet(self, frt, pag, r, c, p, i, w):
if not w:
self.trndet = self.desc
else:
self.trndet = w
def endPage0(self):
self.df.focusField("C", 0, 1)
def endPage1(self):
self.updateTables()
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitPage1(self):
if self.df.col != 1:
self.doPrintDoc(self.pr.repprt)
self.df.focusField("T", 0, 1)
def extractCost(self):
self.ucost = 0
self.tcost = 0
if self.gtype == "R":
for item in self.recipe:
quant = item[6] * self.quant
tcost = self.doCalCost(item[4], item[5], quant)
if tcost is None:
return "error"
self.tcost = float(ASD(self.tcost) + ASD(tcost))
else:
tcost = self.doCalCost(self.group, self.code, self.quant)
if tcost is None:
return "error"
self.tcost = tcost
self.ucost = round(self.tcost / self.quant, 2)
def updateTables(self):
if self.gtype == "R":
# Issue individual items
for item in self.recipe:
acc = self.sql.getRec("strmf1",
cols=["st1_desc"],
where=[("st1_cono", "=", item[0]),
("st1_group", "=", item[4]),
("st1_code", "=", item[5])],
limit=1)
if acc:
des = acc[0]
else:
des = "Unknown Description"
qty = item[6] * self.quant
tcost = self.doCalCost(item[4], item[5], qty, chk=False)
qty = float(ASD(0) - ASD(qty))
val = float(ASD(0) - ASD(tcost))
data = [
self.opts["conum"], item[4], item[5], self.loc, self.dte,
6, self.iss, self.batno, self.glnum, qty, val, 0,
self.curdt, des, 0, "", "", "STR", 0, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# Receive recipe item
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte,
5, self.iss, self.batno, self.glnum, self.quant, self.tcost, 0,
self.curdt, self.desc, 0, "", "", "STR", 0, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# Stores Ledger Transaction
qty = float(ASD(0) - ASD(self.quant))
val = float(ASD(0) - ASD(self.tcost))
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte, 2,
self.iss, self.batno, self.glnum, qty, val, 0, self.curdt,
self.desc, 0, "", "", "STR", 0, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
if self.glint == "N":
return
col = self.sql.gentrn_col
# General Ledger Control Transaction (Stock On Hand)
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.stk_soh),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.dte),
("glt_type", "=", 4),
("glt_refno", "=", self.iss),
("glt_batch", "=", self.batno)],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(val))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.stk_soh, self.curdt,
self.dte, 4, self.iss, self.batno, val, 0,
self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0
])
# General Ledger Transaction (Expense)
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.glnum),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.dte),
("glt_type", "=", 4),
("glt_refno", "=", self.iss),
("glt_batch", "=", self.batno)],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(self.tcost))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.glnum, self.curdt,
self.dte, 4, self.iss, self.batno, self.tcost,
0, self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0
])
def doCalCost(self, grp, code, qty, chk=True):
# Calculate cost price
icost, tcost, bal = getCost(self.sql,
self.opts["conum"],
grp,
code,
loc=self.loc,
qty=qty,
tot=True,
bal=True)
if chk and qty > bal[0]:
acc = self.sql.getRec("strmf1",
cols=["st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", grp),
("st1_code", "=", code)],
limit=1)
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="ExQty",
product=(grp, code, acc[0]))
if cf.flag == "no":
return
return tcost
def doReprint(self):
tit = ("Reprint Documents", )
data = self.sql.getRec("strtrn",
cols=["stt_ref1", "stt_trdt"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2)],
group="stt_ref1, stt_trdt",
order="stt_trdt, stt_ref1")
iss = {
"stype":
"R",
"tables": ("strtrn", ),
"cols": (("stt_ref1", "", 0, "Reference"), ("stt_trdt", "", 0,
"Date", "Y")),
"wtype":
"D",
"where":
data,
"screen":
self.opts["mf"].body,
"comnd":
self.doSelRec
}
isd = {
"stype": "R",
"tables": ("strtrn", ),
"cols": (("stt_trdt", "", 0, "Date"), ),
"where": [("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2)],
"whera": (("T", "stt_ref1", 0, 0), ),
"group": "stt_trdt",
"order": "stt_trdt",
"screen": self.opts["mf"].body
}
fld = ((("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N",
self.doRepIss, iss, None, ("notblank", )),
(("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N",
self.doRepDte, isd, None, ("notzero", )))
state = self.df.disableButtonsTags()
self.tx = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doRepEnd, "n"), ),
txit=(self.doRepExit, ),
view=("N", "V"),
mail=("Y", "N"))
self.tx.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSelRec(self, frt, pag, r, c, p, i, w):
self.tx.doKeyPressed(frt, pag, p, w[0])
self.tx.doKeyPressed(frt, pag, p + 1, w[1])
def doRepIss(self, frt, pag, r, c, p, i, w):
self.iss = w
def doRepDte(self, frt, pag, r, c, p, i, w):
self.dte = w
self.ddt = self.df.t_disp[pag][0][p]
acc = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2),
("stt_ref1", "=", self.iss),
("stt_trdt", "=", self.dte)],
limit=1)
if not acc[0]:
return "No Document Found"
def doRepEnd(self):
self.tx.closeProcess()
self.doPrintDoc(self.tx.repprt)
def doRepExit(self):
self.tx.closeProcess()
def doPrintDoc(self, repprt):
hds = [
"Goods Issued Notes",
"GIN Number: %s GIN Date: %s" % (self.iss, self.ddt)
]
tab = ["strmf1", "strtrn"]
col = [["stt_group", "UA", 3, "Grp", "y"],
["stt_code", "NA", 20, "Product-Code", "y"],
["stt_desc", "NA", 40, "Description", "y"],
["stt_loc", "UA", 1, "L", "y"],
["stt_qty", "SD", 11.2, "Quantity", "y", "y"],
["stt_cost", "SD", 11.2, "Price", "y", "y"]]
gtt = ["stt_cost"]
whr = [("stt_cono", "=", self.opts["conum"]),
("stt_type", "in", (2, 6)), ("stt_ref1", "=", self.iss),
("stt_trdt", "=", self.dte), ("st1_cono=stt_cono", ),
("st1_group=stt_group", ), ("st1_code=stt_code", ),
("st1_type", "<>", "R")]
odr = "stt_seq"
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"],
conum=self.opts["conum"],
conam=self.opts["conam"],
name=self.__class__.__name__,
tables=tab,
heads=hds,
cols=col,
gtots=gtt,
where=whr,
order=odr,
repprt=repprt)
self.df.setWidget(self.df.mstFrame, state="show")
class st2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.exit = False
self.setPrinter()
if not self.exit:
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"gentrn", "strgrp", "strmf1", "strmf2", "strgmu", "strcmu",
"strtrn", "strpom"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
self.fromad = strctl["cts_emadd"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.stk_soh = ctlctl["stk_soh"]
self.stk_susp = ctlctl["stk_susp"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if self.locs == "N":
self.loc = "1"
return True
def setPrinter(self):
tit = ("Printer Selection", )
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=[],
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "P"),
mail=("N", "Y"))
self.opts["mf"].startLoop()
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.pr.closeProcess()
self.opts["mf"].closeLoop()
def dataHeader(self):
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "not", "in", ("R", "X")),
("st1_value_ind", "<>", "N")],
"whera": [["C", "st1_group", 0, 0]],
"order":
"st1_group, st1_code",
"index":
1
}
stl = {
"stype":
"R",
"tables": ("strloc", "strmf2"),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Location", "Y")),
"where": [("srl_cono", "=", self.opts["conum"]),
("srl_loc=st2_loc", ), ("st2_cono=srl_cono", )],
"whera": [["C", "st2_group", 0], ["C", "st2_code", 1]],
"order":
"st2_loc",
"index":
0
}
fld = [(("T", 0, 0, 0), "INa", 9, "GRN Number", "", "", "Y",
self.doGrv, None, None, ("notblank", )),
(("T", 0, 0, 0), "ID1", 10, "Date", "GRN Date", self.sysdtw,
"N", self.doDte, None, None, ("efld", )),
(("T", 0, 0, 0), "INa", 7, "Order Number", "", "", "N",
self.doOrd, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "r", "Y",
self.doGroup, gpm, None, ("notblank", )),
(("C", 0, 0, 1), "INA", (15, 20), "Product Code", "", "", "N",
self.doCode, stm, None, ("notblank", )),
(("C", 0, 0, 2), "ONA", 15, "Description"),
(("C", 0, 0, 3), "ONA", 5, "U.O.I"),
[("C", 0, 0, 4), "IUA", 1, "L", "Location", "r", "N",
self.doLoc, stl, None, ("notblank", )],
(("C", 0, 0, 5), "ISD", 9.2, "Quantity", "", "", "N",
self.doQty, None, None, ("notzero", )),
(("C", 0, 0, 6), "IUD", 9.2, "Unit-Cost", "Unit Cost Price", "",
"N", self.doUcost, None, None, ("notzero", )),
(("C", 0, 0, 7), "IUD", 5.2, "Dis-%", "Discount Percentage", "",
"N", self.doDisPer, None, None, ("efld", )),
(("C", 0, 0, 8), "OSD", 9.2, "Value")]
tnd = ((self.endPage0, "n"), )
txt = (self.exitPage0, )
cnd = ((self.endPage1, "y"), )
cxt = (self.exitPage1, )
but = (("Import", None, self.doImport, 0, ("C", 0, 1), (("T", 0, 1),
("C", 0, 2)),
"Import Stock from a CSV or XLS File"),
("StrQuery", None, self.doQuery, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0, 2))), ("Reprint", None, self.doReprint,
0, ("T", 0, 1), None),
("Cancel", None, self.doCancel, 0, ("C", 0, 1), (("T", 0, 1),
("C", 0, 0))))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doGrv(self, frt, pag, r, c, p, i, w):
self.grv = w
self.cancel = False
def doDte(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.dte = w
self.dtw = self.df.t_disp[0][0][i]
self.curdt = int(self.dte / 100)
self.batno = "S%s" % self.curdt
def doOrd(self, frt, pag, r, c, p, i, w):
self.odr = w
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
if self.locs == "Y":
impcol = [["Location", 0, "UA", 1]]
fld = [(("T",0,0,0),("IRB",(("Yes","Y"),("No","N"))),0,
"Create Items","","N","N",self.doAllLoc,None,None,None,None,
"Create Item in this location if it is a Valid item, i.e. "\
"Already exists in another location")]
else:
impcol = []
fld = []
self.allloc = "N"
impcol.extend([["Group", 1, "UA", 3], ["Code", 2, "NA", 20],
["Quantity", 3, "UD", 10.2],
["Item Cost", 4, "UD", 10.2]])
fi = FileImport(self.opts["mf"], impcol=impcol, impfld=fld)
self.trdis = 0
err = None
for num, line in enumerate(fi.impdat):
if len(line) != len(impcol):
err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \
(num + 1, len(impcol), len(line))
break
if self.locs == "Y":
loc = line[0]
idx = 1
else:
loc = "1"
idx = 0
self.loc = loc.work
self.group = line[idx]
self.code = line[idx + 1]
st1 = self.sql.getRec("strmf1",
where=[("st1_group", "=", self.group),
("st1_code", "=", self.code),
("st1_type", "<>", "X")],
limit=1)
err = False
if not st1:
err = "Line %s: Invalid Group %s or Code %s" % (
(num + 1), self.group, self.code)
elif st1[self.sql.strmf1_col.index("st1_type")] == "R":
err = "Line %s: Invalid Code (Recipe Item)" % (num + 1)
elif st1[self.sql.strmf1_col.index("st1_type")] == "X":
err = "Line %s: Invalid Code (Redundant" % (num + 1)
elif st1[self.sql.strmf1_col.index("st1_type")] == "N":
err = "Line %s: Invalid Code (Value Indicator)" % (num + 1)
if err:
break
self.desc = st1[self.sql.strmf1_col.index("st1_desc")]
st2 = self.sql.getRec("strmf2",
where=[("st2_loc", "=", self.loc),
("st2_group", "=", self.group),
("st2_code", "=", self.code)],
limit=1)
if not st2 and self.allloc == "Y":
st2 = self.sql.getRec("strmf2",
where=[("st2_loc", "=", "1"),
("st2_group", "=", self.group),
("st2_code", "=", self.code)],
limit=1)
if st2:
st2[self.sql.strmf2_col.index("st2_loc")] = self.loc
st2[self.sql.strmf2_col.index("st2_bin")] = ""
st2[self.sql.strmf2_col.index("st2_reord_ind")] = "A"
st2[self.sql.strmf2_col.index("st2_reord_level")] = 0
st2[self.sql.strmf2_col.index("st2_reord_qty")] = 0
self.sql.insRec("strmf2", data=st2)
if not st2:
err = "Line %s: Invalid Location %s" % ((num + 1), self.loc)
break
self.qty = line[idx + 2]
self.tcost = round((self.qty * line[idx + 3]), 2)
self.usell = 0.00
self.updateTables()
if err:
showError(self.opts["mf"].body, "Import Error", err)
elif fi.impdat:
self.opts["mf"].dbm.commitDbase()
self.df.enableButtonsTags(state=state)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doAllLoc(self, obj, w):
self.allloc = w
def doGroup(self, frt, pag, r, c, p, i, w):
self.group = w
acc = self.sql.getRec("strgrp",
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec(
"strmf1",
cols=["st1_type", "st1_desc", "st1_uoi", "st1_value_ind"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group), ("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] == "R":
return "Invalid Code (Recipe Item)"
if acc[0] == "X":
return "Invalid Code (Redundant"
if acc[3] == "N":
return "Invalid Code (Value Indicator)"
self.desc = acc[1]
self.uoi = acc[2]
self.df.loadEntry("C", pag, p + 1, data=self.desc)
self.df.loadEntry("C", pag, p + 2, data=self.uoi)
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("C", pag, p + 3, data=self.loc)
no = self.checkLoc()
if no:
return no
return "sk3"
def doLoc(self, frt, pag, r, c, p, i, w):
self.loc = w
no = self.checkLoc()
if no:
return no
def checkLoc(self):
acc = self.sql.getRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location For This Product"
def doQty(self, frt, pag, r, c, p, i, w):
self.qty = w
# Last Cost Price
lcost = getCost(self.sql,
self.opts["conum"],
self.group,
self.code,
loc=self.loc,
qty=1,
ind="L")
self.df.loadEntry(frt, pag, p + 1, data=lcost)
def doUcost(self, frt, pag, r, c, p, i, w):
self.ucost = w
self.tcost = round((self.qty * self.ucost), 2)
def doDisPer(self, frt, pag, r, c, p, i, w):
self.trdis = w
udis = round((self.ucost * self.trdis / 100), 2)
tdis = round((self.tcost * self.trdis / 100), 2)
self.ucost = float(ASD(self.ucost) - ASD(udis))
self.tcost = float(ASD(self.tcost) - ASD(tdis))
self.df.loadEntry(frt, pag, p + 1, data=self.tcost)
def endPage0(self):
self.df.focusField("C", 0, 1)
def endPage1(self):
self.updateTables()
self.df.advanceLine(0)
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitPage1(self):
if not self.cancel and self.df.col != 1:
self.opts["mf"].dbm.commitDbase()
self.doPrintDoc(self.pr.repprt, self.pr.repeml)
else:
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doCancel(self):
ok = askQuestion(
self.opts["mf"].body,
"Cancel",
"Are You Sure that you want to Cancel this Goods Received Note?",
default="no")
if ok == "yes":
self.cancel = True
self.exitPage1()
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def updateTables(self):
# Stores Ledger Transaction
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte, 1,
self.grv, self.batno, self.odr, self.qty, self.tcost, 0,
self.curdt, self.desc, 0, "", "", "STR", self.trdis, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
if self.glint == "N":
return
# General Ledger Control Transaction (Stock On Hand)
data = [
self.opts["conum"], self.stk_soh, self.curdt, self.dte, 5,
self.grv, self.batno, self.tcost, 0, self.code, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Stock Suspense)
val = float(ASD(0) - ASD(self.tcost))
data = [
self.opts["conum"], self.stk_susp, self.curdt, self.dte, 5,
self.grv, self.batno, val, 0, self.code, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
def doReprint(self):
tit = ("Reprint Documents", )
dat = self.sql.getRec(
"strtrn",
cols=["stt_loc", "stt_trdt", "stt_ref1", "stt_ref2"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1)],
group="stt_loc, stt_trdt, stt_ref1, stt_ref2",
order="stt_trdt, stt_ref1")
data = []
for d in dat:
try:
# Exclude purchase orders
doc = int(d[2])
chk = self.sql.getRec("strpom",
where=[("pom_cono", "=",
self.opts["conum"]),
("pom_ordno", "=", doc),
("pom_loc", "=", d[0]),
("pom_date", "=", d[1])])
if chk:
continue
except:
pass
data.append([d[2], d[1], d[3]])
grv = {
"stype":
"R",
"tables": ("strtrn", "strpom"),
"cols":
(("stt_ref1", "", 0, "Reference", "Y"),
("stt_trdt", "", 0, "Date"), ("stt_ref2", "", 0, "Order-Num")),
"wtype":
"D",
"where":
data,
"screen":
self.opts["mf"].body,
"comnd":
self.doSelRec
}
grd = {
"stype": "R",
"tables": ("strtrn", ),
"cols":
(("stt_trdt", "", 0, "Date"), ("stt_ref2", "", 0, "Order-Num")),
"where": [("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1)],
"whera": (("T", "stt_ref1", 0, 0), ),
"group": "stt_trdt",
"order": "stt_trdt"
}
fld = ((("T", 0, 0, 0), "INa", 9, "GRN Number", "", "", "N",
self.doRepGrv, grv, None, ("notblank", )),
(("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N",
self.doRepDte, grd, None, ("notzero", )))
state = self.df.disableButtonsTags()
self.tx = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doRepEnd, "n"), ),
txit=(self.doRepExit, ),
view=("Y", "V"),
mail=("Y", "N"))
self.tx.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSelRec(self, frt, pag, r, c, p, i, w):
self.tx.doKeyPressed(frt, pag, p, w[0])
self.tx.doKeyPressed(frt, pag, p + 1, w[1])
def doRepGrv(self, frt, pag, r, c, p, i, w):
self.grv = w
acc = self.sql.getRec("strtrn",
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1),
("stt_ref1", "=", w)])
if not acc:
return "Invalid GRN Number"
if len(acc) == 1:
self.dte = acc[0][self.sql.strtrn_col.index("stt_trdt")]
self.tx.loadEntry(frt, pag, p + 1, data=self.dte)
self.dtw = self.tx.t_disp[0][0][i + 1]
return "sk1"
def doRepDte(self, frt, pag, r, c, p, i, w):
self.dte = w
self.dtw = self.tx.t_disp[0][0][i]
acc = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1),
("stt_ref1", "=", self.grv),
("stt_trdt", "=", self.dte)],
limit=1)
if not acc[0]:
return "No Document Found"
def doRepEnd(self):
self.tx.closeProcess()
self.doPrintDoc(self.tx.repprt, self.tx.repeml)
def doRepExit(self):
self.tx.closeProcess()
def doPrintDoc(self, repprt, repeml):
hds = [
"Goods Received Notes",
"GRN Number: %s GRN Date: %s" % (self.grv, self.dtw)
]
col = [["stt_group", "UA", 3, "Grp", "y"],
["stt_code", "NA", 20, "Product-Code", "y"],
["stt_desc", "NA", 40, "Description", "y"],
["stt_loc", "UA", 1, "L", "y"],
["stt_qty", "SD", 11.2, "Quantity", "y"],
["stt_cost", "SD", 11.2, "Price", "y"]]
gtt = ["stt_cost"]
whr = [("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 1),
("stt_ref1", "=", self.grv), ("stt_trdt", "=", self.dte)]
odr = "stt_seq"
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"],
conum=self.opts["conum"],
conam=self.opts["conam"],
name=self.__class__.__name__,
tables=["strtrn"],
heads=hds,
cols=col,
gtots=gtt,
where=whr,
order=odr,
repprt=repprt,
repeml=repeml,
fromad=self.fromad)
self.df.setWidget(self.df.mstFrame, state="show")
def doQuery(self):
callModule(self.opts["mf"],
self.df,
"st4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
class bc1040(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "args" not in self.opts:
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, ["bwltyp", "bwlpts", "bwlcmp"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
typ = {
"stype":
"R",
"tables": ("bwltyp", ),
"cols":
(("bct_code", "", 0, "Cod"), ("bct_desc", "", 0, "Description",
"Y"), ("bct_cfmat", "", 0, "F")),
"where": [("bct_cono", "=", self.opts["conum"])]
}
r1s = (("Tournament", "T"), ("K/Out (D)", "D"), ("K/Out (N)", "K"),
("R/Robin", "R"), ("Teams", "X"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),"I@bct_code",0,"","",
0,"Y",self.doTypCod,typ,None,("efld",)),
(("T",0,1,0),"I@bct_desc",0,"","",
"","N",self.doDesc,None,self.doDelete,("notblank",)),
(("T",0,2,0),("IRB",r1s),0,"Competition Format","",
"T","N",self.doCFmat,None,None,None,None,
"""Select the Competition Format as follows:
Tournament: The default format for tournaments.
K/Out (D): This is for all Drawn Knockout Competitions.
K/Out (N): This is for Normal Knockout Competitions.
R/Robin: This is for Round Robin Competitions.
Teams: This is for Team Competitions e.g. Club V Club.
"""),
(("T",0,3,0),"I@bct_tsize",0,"","",
4,"N",self.doTSize,None,None,("notzero",)),
(("T",0,4,0),"I@bct_games",0,"","",
0,"N",self.doGames,None,None,("notzero",)),
(("T",0,5,0),"I@bct_ends",0,"","",
21,"N",self.doEnds,None,None,("notzero",)),
(("T",0,6,0),("IRB",r2s),0,"Groups by Position","",
"N","N",self.doGroups,None,None,None,None,
"Yes means that teams will be split into Groups after "\
"a certain number of games based on position. No means "\
"that teams will not be split into groups"),
(("T",0,7,0),"I@bct_grgame",0,"","",
0,"N",self.doGrGame,None,None,("efld",)),
(("T",0,8,0),("IRB",r2s),0,"Adjust Scores","",
"N","N",self.doAdjust,None,None,None,None,
"Whether or Not to Modify the Scores of Groups, Other "\
"than Group A, when the Teams are Split into Groups."),
(("T",0,9,0),"I@bct_expunge",0,"","",
"","N",None,None,None,("efld",),None,
"These Comma Separated Game Scores will be Cleared when "\
"Teams are Split into Groups."),
(("T",0,10,0),"I@bct_percent",0,"","",
100,"N",None,None,None,("efld",),None,
"This is the Percentage of the Remaining Game Scores which "\
"Will be Retained when Teams are Split into Groups."),
(("T",0,11,0),"I@bct_drawn",0,"","",
1,"N",self.doDrawn,None,None,("efld",)),
(("T",0,12,0),("IRB",r2s),0,"Strict S v S",
"Strict Strength v Strength",
"N","N",self.doSvS,None,None,None,None,
"Yes means that teams could play against each other, again, "\
"in ANY game. No means that teams could only play against "\
"each other, again, in the FINAL game."),
(("T",0,13,0),("IRB",r2s),0,"Different Drawn Games Scoring","",
"N","N",self.doDiff,None,None,None,None,
"Yes means that Drawn Games have a Different Scoring Format "\
"from Strength V Strength Games."))
but = (("Print", None, self.doPrint, 0, ("T", 0, 2), None),
("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if "args" in self.opts:
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"])
self.df.topf[0][0][1] = "OUI"
self.df.mstFrame.wait_window()
def doTypCod(self, frt, pag, r, c, p, i, w):
if not w:
self.ctype = getNextCode(self.sql,
"bwltyp",
"bct_code",
where=[("bct_cono", "=",
self.opts["conum"])],
last=99)
self.df.loadEntry(frt, pag, p, data=self.ctype)
else:
self.ctype = w
self.old = self.sql.getRec("bwltyp",
where=[("bct_cono", "=",
self.opts["conum"]),
("bct_code", "=", self.ctype)],
limit=1)
if not self.old:
self.newtyp = True
else:
self.newtyp = False
self.cdesc = self.old[self.sql.bwltyp_col.index("bct_desc")]
self.cfmat = self.old[self.sql.bwltyp_col.index("bct_cfmat")]
self.tsize = self.old[self.sql.bwltyp_col.index("bct_tsize")]
self.ends = self.old[self.sql.bwltyp_col.index("bct_ends")]
self.groups = self.old[self.sql.bwltyp_col.index("bct_groups")]
self.adjust = self.old[self.sql.bwltyp_col.index("bct_adjust")]
for num, fld in enumerate(self.old[1:-1]):
self.df.loadEntry(frt, pag, num, data=fld)
chk = self.sql.getRec("bwlcmp",
where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_type", "=", self.ctype)],
limit=1)
if chk:
self.exist = True
else:
self.exist = False
def doDelete(self):
if self.newtyp:
return
if self.exist:
return "There are Competitions Using this Type, Not Deleted"
self.sql.delRec("bwltyp",
where=[("bct_cono", "=", self.opts["conum"]),
("bct_code", "=", self.ctype)])
self.sql.delRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype)])
self.opts["mf"].dbm.commitDbase()
def doDesc(self, frt, pag, r, c, p, i, w):
if self.exist:
ok = askQuestion(self.opts["mf"].body,
"Games exist",
"""There are Competitions Using this Type.
Changes Could Adversely Affect them.
Are you Sure this is what you Want to Do?""",
default="no")
if ok == "no":
return "ff1"
def doCFmat(self, frt, pag, r, c, p, i, w):
self.cfmat = w
def doTSize(self, frt, pag, r, c, p, i, w):
if self.cfmat == "D" and w not in (2, 3):
return "Invalid Team Size"
self.tsize = w
if self.cfmat in ("D", "K", "R"):
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doGames(self, frt, pag, r, c, p, i, w):
self.games = w
def doEnds(self, frt, pag, r, c, p, i, w):
self.ends = w
if self.cfmat in ("D", "K", "R", "X"):
if self.cfmat in ("D", "K", "R"):
defaults = ["N", 0, "N", "", 0, 0, "N", "N"]
else:
defaults = ["N", 0, "N", "", 0, self.games, "N", "N"]
for num, dat in enumerate(defaults):
self.df.loadEntry("T", 0, p + num + 1, data=dat)
self.pdiff = "N"
return "nd"
def doGroups(self, frt, pag, r, c, p, i, w):
self.groups = w
if self.groups == "N":
self.adjust = "N"
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data=self.adjust)
self.df.loadEntry(frt, pag, p + 3, data="")
self.df.loadEntry(frt, pag, p + 4, data="")
return "sk4"
def doGrGame(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid Game Number"
def doAdjust(self, frt, pag, r, c, p, i, w):
self.adjust = w
if self.adjust == "N":
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data=0)
return "sk2"
def doDrawn(self, frt, pag, r, c, p, i, w):
self.drawn = w
if self.drawn == self.games:
# All drawn games
self.pdiff = "N"
self.df.loadEntry(frt, pag, p + 1, data="N")
self.df.loadEntry(frt, pag, p + 2, data="N")
return "sk2"
def doSvS(self, frt, pag, r, c, p, i, w):
if not self.drawn:
self.pdiff = "N"
self.df.loadEntry(frt, pag, p + 1, data="N")
return "sk1"
def doDiff(self, frt, pag, r, c, p, i, w):
self.pdiff = w
def doEnd(self):
data = [self.opts["conum"]] + self.df.t_work[0][0]
if self.newtyp:
self.sql.insRec("bwltyp", data=data)
elif data != self.old[:len(data)]:
col = self.sql.bwltyp_col
data.append(self.old[col.index("bct_xflag")])
self.sql.updRec("bwltyp",
data=data,
where=[("bct_cono", "=", self.opts["conum"]),
("bct_code", "=", self.ctype)])
self.perr = False
if self.cfmat in ("D", "K", "R"):
if self.newtyp:
self.sql.insRec("bwlpts",
data=[
self.opts["conum"], self.ctype, "D", "N",
0, "N", 0, 0, 1, "N", 0, 0
])
else:
self.df.setWidget(self.df.mstFrame, state="hide")
if self.pdiff == "Y":
self.doPtsFmt("D")
if not self.perr:
if self.pdiff == "Y":
self.doPtsFmt("S")
else:
self.doPtsFmt("B")
self.df.setWidget(self.df.mstFrame, state="show")
if self.perr:
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
else:
self.opts["mf"].dbm.commitDbase()
if "args" in self.opts:
self.doExit()
else:
self.df.focusField("T", 0, 1)
def doPtsFmt(self, flag=None):
self.flag = flag
if flag == "D":
txt = "Points Format for Drawn Games"
elif flag == "S":
txt = "Points Format for SvS Games"
else:
txt = "Points Format"
tit = (txt, )
r1s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Skins","",
"N","N",self.doSkins,None,None,None),
(("T",0,1,0),"I@bcp_sends",0,"","",
0,"N",self.doEndsPerSkin,None,None,("efld",)),
(("T",0,2,0),("IRB",r1s),0,"Points Only","",
"N","N",self.doOnly,None,None,None,None,
"Yes means that No Shots are to be captured and that only "\
"Points will be used to determine positions. No means that "\
"Shots and Points are to be captured and used to determine "\
"positions."),
(("T",0,3,0),"I@bcp_e_points",0,"","",
0,"N",self.doPoints,None,None,("efld",)),
(("T",0,4,0),"I@bcp_s_points",0,"","",
0,"N",None,None,None,("efld",)),
(("T",0,5,0),"I@bcp_g_points",0,"","",
0,"N",None,None,None,("efld",)),
(("T",0,6,0),("IRB",r1s),0,"Bonus Points","",
"N","N",self.doBonus,None,None,None),
(("T",0,7,0),"I@bcp_win_by",0,"","",
0,"N",None,None,None,("efld",)),
(("T",0,8,0),"I@bcp_lose_by",0,"","",
0,"N",None,None,None,("efld",)))
but = (("Quit", None, self.doPExit, 1, None, None), )
tnd = ((self.doPEnd, "y"), )
txt = (self.doPExit, )
self.pf = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if self.flag in ("D", "S"):
ptyp = self.flag
else:
ptyp = "D"
acc = self.sql.getRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype),
("bcp_ptyp", "=", ptyp)],
limit=1)
if acc:
self.newpts = False
for num, dat in enumerate(acc[3:-1]):
self.pf.loadEntry("T", 0, num, data=dat)
else:
self.newpts = True
self.pf.focusField("T", 0, 1, clr=False)
self.pf.mstFrame.wait_window()
def doSkins(self, frt, pag, r, c, p, i, w):
self.skins = w
if self.skins == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEndsPerSkin(self, frt, pag, r, c, p, i, w):
if self.ends % w:
return "Invalid Ends per Skin, Not Divisible"
def doOnly(self, frt, pag, r, c, p, i, w):
self.ponly = w
def doPoints(self, frt, pag, r, c, p, i, w):
if self.skins == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doBonus(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 "nd"
def doPEnd(self):
self.pf.closeProcess()
data = [self.opts["conum"], self.ctype, ""]
data.extend(self.pf.t_work[0][0])
if self.flag == "B":
if not self.newpts:
self.sql.delRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype)])
data[2] = "D"
self.sql.insRec("bwlpts", data=data)
data[2] = "S"
self.sql.insRec("bwlpts", data=data)
else:
if not self.newpts:
self.sql.delRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype),
("bcp_ptyp", "=", self.flag)])
data[2] = self.flag
self.sql.insRec("bwlpts", data=data)
def doPExit(self):
self.perr = True
self.pf.closeProcess()
def doPrint(self):
if not self.newtyp:
callModule(self.opts["mf"],
None,
"bc3080",
coy=[self.opts["conum"], self.opts["conam"]],
args=[self.ctype, self.cdesc])
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doExit(self):
self.df.closeProcess()
if "args" not in self.opts:
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
