class arc310(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["assdep", "assgrp", "assmst", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
assctl = gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.glint = assctl["cta_glint"]
return True
def mainProcess(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])],
"order":
"glm_acno"
}
fld = [(("T", 0, 0, 0), "IUA", 3, "Asset Group", "", "", "N",
self.doGroup, grp, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N", None,
None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INa", 3, "Depreciation Code", "", "", "N",
self.doDepCode, dep, None, None),
(("T", 0, 2, 0), "ONA", 34, "")]
if self.glint == "Y":
fld.extend([(("T", 0, 3, 0), "IUI", 7, "Asset Account", "", "",
"N", self.doAsset, glm, None, ("notzero", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), "IUI", 7, "Accum Account", "", "",
"N", self.doAccum, glm, None, ("notzero", )),
(("T", 0, 4, 0), "ONA", 30, ""),
(("T", 0, 5, 0), "IUI", 7, "Expense Account", "", "",
"N", self.doExpense, glm, None, ("notzero", )),
(("T", 0, 5, 0), "ONA", 30, "")])
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=fld,
butt=but,
tend=tnd,
txit=txt)
def doGroup(self, frt, pag, r, c, p, i, w):
self.group = w
self.acc = self.sql.getRec("assgrp",
where=[("asg_cono", "=",
self.opts["conum"]),
("asg_group", "=", self.group)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.acc[2])
self.df.loadEntry(frt, pag, p + 2, data=self.acc[3])
dep = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", self.acc[3])],
limit=1)
if dep:
self.df.loadEntry(frt, pag, p + 3, data=dep[0])
if self.glint == "N":
return
self.df.loadEntry(frt, pag, p + 4, data=self.acc[4])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc[4])],
limit=1)
if des:
self.df.loadEntry("T", pag, p + 5, data=des[0])
self.df.loadEntry(frt, pag, p + 6, data=self.acc[5])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc[5])],
limit=1)
if des:
self.df.loadEntry("T", pag, p + 7, data=des[0])
self.df.loadEntry(frt, pag, p + 8, data=self.acc[6])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc[6])],
limit=1)
if des:
self.df.loadEntry("T", pag, p + 9, data=des[0])
def doDepCode(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
def doAsset(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", pag, p + 1, data=acc[0])
def doAccum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", pag, p + 1, data=acc[0])
def doExpense(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", pag, p + 1, data=acc[0])
def doDelete(self):
chk = self.sql.getRec("assmst",
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group)])
if chk:
return "Group in Use, Not Deleted"
self.sql.delRec("assgrp",
where=[("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if x == 3 or (self.glint == "Y" and x in (5, 7, 9)):
continue
data.append(self.df.t_work[0][0][x])
if self.glint == "N":
data.extend([0, 0, 0])
if self.new == "Y":
self.sql.insRec("assgrp", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.assgrp_col
data.append(self.acc[col.index("asg_xflag")])
self.sql.updRec("assgrp",
data=data,
where=[("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group)])
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()
self.opts["mf"].closeLoop()
class stc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"struoi",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
unm = {
"stype":
"R",
"tables": ("struoi", ),
"cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0,
"Description", "Y")),
"where": [("unm_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INA", 10, "Unit Of Issue", "", "", "N",
self.doUnit, unm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0)))
tnd = ((self.doEnd, "Y"), )
txt = (self.closeProcess, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doUnit(self, frt, pag, r, c, p, i, w):
self.uoi = w
self.old = self.sql.getRec("struoi",
where=[("unm_cono", "=",
self.opts["conum"]),
("unm_unit", "=", self.uoi)],
limit=1)
if not self.old:
self.new = "Y"
else:
self.new = "N"
desc = self.old[self.sql.struoi_col.index("unm_desc")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
def doDelete(self):
self.sql.delRec("struoi",
where=[("unm_cono", "=", self.opts["conum"]),
("unm_unit", "=", self.uoi)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("struoi", data=data)
elif data != self.old[:len(data)]:
col = self.sql.struoi_col
data.append(self.old[col.index("unm_xflag")])
self.sql.updRec("struoi",
data=data,
where=[("unm_cono", "=", self.opts["conum"]),
("unm_unit", "=", self.uoi)])
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 closeProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
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 rtc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["chglog", "genmst", "rtlprm", "rtlmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.glint = rtlctl["ctr_glint"]
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"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])],
"order":
"glm_acno"
}
self.fld = [(("T", 0, 0, 0), "INA", 7, "Premises Code", "Premises", "",
"N", self.doPrmCod, prm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 4, "Postal Code", "PCod", "", "N",
None, None, None, ("notblank", ))]
if self.glint == "Y":
self.fld.append(
(("T", 0, 6, 0), "IUI", 7, "Rental Account", "", "", "N",
self.doRental, glm, None, ("notzero", ), None,
"Rental Control Account in the General Ledger."))
self.fld.append((("T", 0, 6, 0), "ONA", 30, ""))
self.fld.append(
(("T", 0, 7, 0), "IUI", 7, "Income Account", "", "", "N",
self.doIncome, glm, None, ("notzero", ), None,
"Rental Income Account in the General Ledger."))
self.fld.append((("T", 0, 7, 0), "ONA", 30, ""))
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)
def doPrmCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("rtlprm",
where=[("rtp_cono", "=",
self.opts["conum"]),
("rtp_code", "=", self.code)],
limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
acc = copyList(self.old[:-1])
acc.append("")
acc.insert(8, "")
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=acc[x + 1])
if self.glint == "N":
return
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc[7])],
limit=1)
if des:
self.df.loadEntry("T", 0, 7, data=des[0])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc[9])],
limit=1)
if des:
self.df.loadEntry("T", 0, 9, data=des[0])
def doRental(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", 0, 7, data=acc[0])
def doIncome(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", 0, 9, data=acc[0])
def doDelete(self):
mst = self.sql.getRec("rtlmst",
cols=["count(*)"],
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code)],
limit=1)
if mst[0]:
return "Accounts Exist, Not Deleted"
self.sql.delRec("rtlprm",
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"rtlprm", "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):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if self.glint == "Y" and x in (7, 9):
continue
data.append(self.df.t_work[0][0][x])
if self.glint == "N":
data.extend([0, 0])
if self.new == "y":
self.sql.insRec("rtlprm", data=data)
elif data != self.old[:len(data)]:
col = self.sql.rtlprm_col
data.append(self.old[col.index("rtp_xflag")])
self.sql.updRec("rtlprm",
data=data,
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", self.code)])
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=[
"rtlprm", "U",
"%03i%-7s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
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()
self.opts["mf"].closeLoop()
class ms1020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["ctlsys", "ctlmst", "ctldep", "genmst", "wagmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
dept = ctlsys["sys_gl_dep"]
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.glint = "N"
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
if ctlmst["ctm_modules"][x:x + 2] in ("SL", "WG"):
dept = "Y"
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
self.glint = "N"
else:
self.glint = wagctl["ctw_glint"]
break
if dept == "N":
showError(self.opts["mf"].body, "Error",
"Departments have Not been Enabled")
return
if self.glint == "N":
self.co1 = 0
self.sy1 = 0
self.cm1 = 0
self.co2 = 0
self.sy2 = 0
self.cm2 = 0
else:
self.coys = self.sql.getRec("ctlmst", cols=["count(*)"],
limit=1)[0]
return True
def mainProcess(self):
dep = {
"stype": "R",
"tables": ("ctldep", ),
"cols":
(("dep_code", "", 0, "Cod"), ("dep_name", "", 0, "Name", "Y")),
"where": [("dep_cono", "=", self.opts["conum"])]
}
coy = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
self.fld = [(("T", 0, 0, 0), "IUI", 3, "Department", "Department Code",
"", "N", self.doDepartment, dep, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N",
self.doName, None, self.doDelete, ("notblank", ))]
if self.glint == "Y":
if self.coys == 1:
self.fld.append((("T", 0, 2, 0), "OUI", 7, "Debit Company"))
else:
self.fld.append(
(("T", 0, 2, 0), "IUI", 7, "Debit Company", "",
self.opts["conum"], "N", self.doCoy, coy, None, None))
self.fld.append((("T", 0, 2, 0), "ONA", 30, ""))
self.fld.extend([
(("T", 0, 3, 0), "IUI", 7, " Salary A/C", "", "", "N",
self.doSal, glm, None, ("notzero", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), "IUI", 7, " Commission A/C", "", "",
"N", self.doCom, glm, None, ("efld", )),
(("T", 0, 4, 0), "ONA", 30, "")
])
if self.coys == 1:
self.fld.append((("T", 0, 5, 0), "OUI", 7, "Credit Company"))
else:
self.fld.append(
(("T", 0, 5, 0), "IUI", 7, "Credit Company", "",
self.opts["conum"], "N", self.doCoy, coy, None, None))
self.fld.append((("T", 0, 5, 0), "ONA", 30, ""))
self.fld.extend([
(("T", 0, 6, 0), "IUI", 7, " Salary A/C", "", "", "N",
self.doSal, glm, None, ("notzero", )),
(("T", 0, 6, 0), "ONA", 30, ""),
(("T", 0, 7, 0), "IUI", 7, " Commission A/C", "", "",
"N", self.doCom, glm, None, ("efld", )),
(("T", 0, 7, 0), "ONA", 30, "")
])
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)
def doDepartment(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("ctldep",
where=[("dep_cono", "=",
self.opts["conum"]),
("dep_code", "=", self.code)],
limit=1)
if not self.old:
self.new = "Y"
else:
self.new = "N"
self.doLoadRec(self.old)
def doLoadRec(self, rec):
if not rec:
self.df.clearFrame("T", 0)
self.df.loadEntry("T", 0, 0, data=self.code)
return
for num, dat in enumerate(rec[2:-1]):
if num == 0:
seq = 1
self.df.loadEntry("T", 0, seq, data=dat)
if self.glint == "N":
return
seq += 1
elif num in (1, 4):
coy = dat
if not coy:
dat = ""
else:
nam = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", coy)],
limit=1)
self.df.loadEntry("T", 0, seq, data=coy)
self.df.loadEntry("T", 0, seq + 1, data=nam[0])
seq += 2
elif num in (2, 3, 5, 6):
if dat:
dsc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", coy),
("glm_acno", "=", dat)],
limit=1)
else:
dsc = [""]
self.df.loadEntry("T", 0, seq, data=dat)
self.df.loadEntry("T", 0, seq + 1, data=dsc[0])
seq += 2
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
if self.glint == "Y" and self.coys == 1:
self.co1 = self.opts["conum"]
self.co2 = self.opts["conum"]
self.df.loadEntry(frt, pag, p + 1, data=self.opts["conum"])
self.df.loadEntry(frt, pag, p + 2, data=self.opts["conam"])
return "sk2"
def doCoy(self, frt, pag, r, c, p, i, w):
coy = self.sql.getRec("ctlmst",
cols=["ctm_name "],
where=[("ctm_cono", "=", w)],
limit=1)
if not coy:
return "Invalid Company Number"
if p == 2:
self.co1 = w
else:
self.co2 = w
self.df.loadEntry(frt, pag, p + 1, coy[0])
def doSal(self, frt, pag, r, c, p, i, w):
if p == 4:
co = self.co1
else:
co = self.co2
chk = chkGenAcc(self.opts["mf"], co, w)
if type(chk) is str:
return chk
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
def doCom(self, frt, pag, r, c, p, i, w):
if w:
if p == 6:
co = self.co1
else:
co = self.co2
chk = chkGenAcc(self.opts["mf"], co, w)
if type(chk) is str:
return chk
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if p == 6 and self.coys == 1:
self.df.loadEntry(frt, pag, p + 2, data=self.opts["conum"])
self.df.loadEntry(frt, pag, p + 3, data=self.opts["conam"])
return "sk2"
def doDelete(self):
if self.glint == "Y":
chk = self.sql.getRec("wagmst",
where=[("wgm_dept", "=", self.code)])
if chk:
return "Department is in Use, Not Deleted"
self.sql.delRec("ctldep",
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for num, dat in enumerate(self.df.t_work[0][0]):
if num in (3, 5, 7, 9, 11, 13):
continue
data.append(dat)
if self.glint == "N":
data.extend([0, 0, 0, 0, 0, 0])
if self.new == "Y":
self.sql.insRec("ctldep", data=data)
elif data != self.old[:len(data)]:
col = self.sql.ctldep_col
data.append(self.old[col.index("dep_xflag")])
self.sql.updRec("ctldep",
data=data,
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", self.code)])
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()
self.opts["mf"].closeLoop()
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 st1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlvmf", "ctlrep", "drschn", "drsmst", "genmst", "slsiv1",
"slsiv2", "strgrp", "strloc", "strmf1", "strmf2", "strgmu",
"strcmu", "strprc", "strrcp", "struoi", "strtrn", "strpot",
"strvar", "slsiv3", "chglog"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
self.automu = strctl["cts_automu"]
self.drsctl = gc.getCtl("drsctl", self.opts["conum"], error=False)
if not self.drsctl:
self.chains = "N"
else:
self.chains = self.drsctl["ctd_chain"]
return True
def mainProcess(self):
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [],
"index":
1
}
loc = {
"stype":
"R",
"tables": ("strloc", ),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]
}
unm = {
"stype":
"R",
"tables": ("struoi", ),
"cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0,
"Description", "Y")),
"where": [("unm_cono", "=", self.opts["conum"])]
}
drc = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_stat", "<>", "X")]
drm["whera"] = [["T", "drm_chain", 10]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0), ("drm_stat", "<>", "X")]
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
tag = (("Basic-_A", None, ("T", 0, 0),
("T", 0, 1)), ("Basic-_B", None, ("T", 0, 0), ("T", 0, 1)),
("Recipes", self.doReadLoadRecipe, None, ("T", 0, 1)))
r1s = (("Normal", "N"), ("Recipe", "R"))
r2s = (("Average", "A"), ("Standard", "S"), ("None", "N"))
r3s = (("Manual", "M"), ("Automatic", "A"), ("Zero", "N"))
self.fld = [(("T", 0, 0, 0), "IUA", 3, "Group", "Product Group", "",
"Y", self.doGroup, gpm, None, ("notblank", )),
(("T", 0, 0, 0), "INA", 20, "Code", "Product Code", "",
"N", self.doCode, stm, None, ("notblank", )),
(("T", 0, 0, 0), "IUA", 1, "Loc", "Location", "1", "N",
self.doLoc, loc, None, ("notblank", )),
(("T", 0, 0, 0), "ONA", 30, ""),
(("T", 1, 0, 0), ("IRB", r1s), 0, "Type of Item", "", "N",
"N", self.doType, None, None, None),
(("T", 1, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 1, 2, 0), "INA", 10, "Unit of Issue", "", "", "N",
self.doUoi, unm, None, ("notblank", )),
(("T", 1, 2, 0), "ONA", 30, ""),
(("T", 1, 3, 0), ("IRB", r2s), 0, "Cost Price Indicator",
"", "A", "N", self.doValInd, None, None, None),
(("T", 1, 4, 0), "IUA", 1, "VAT Code", "", "", "N",
self.doVat, vtm, None, ("notblank", )),
(("T", 1, 4, 0), "ONA", 30, ""),
(("T", 1, 5, 0), "IUI", 3, "Exclusive Chainstore", "", "",
"N", self.doChnExcl, drc, None, ("efld", )),
(("T", 1, 5, 0), "ONA", 30, ""),
(("T", 1, 6, 0), "INA", 7, "Exclusive Account", "", "",
"N", self.doAccExcl, drm, None, ("efld", )),
(("T", 1, 6, 0), "ONA", 30, ""),
(("T", 1, 7, 0), "IUI", 7, "Sales Code", "", "", "N",
self.doSales, glm, None, ("efld", )),
(("T", 1, 7, 0), "ONA", 30, ""),
(("T", 1, 8, 0), "IUI", 7, "COS Code", "", "", "N",
self.doCos, glm, None, ("efld", )),
(("T", 1, 8, 0), "ONA", 30, ""),
(("T", 2, 0, 0), "IUA", 8, "Bin Number", "", "", "N", None,
None, self.doDelete, ("efld", )),
(("T", 2, 1, 0), ("IRB", r3s), 0, "Re-Order Indicator", "",
"A", "N", self.doReord, None, None, None),
(("T", 2, 2, 0), "IUI", 7, "Re-Order Level", "", "", "N",
None, None, None, ("efld", )),
(("T", 2, 3, 0), "IUI", 7, "Re-Order Quantity", "", "",
"N", None, None, None, ("efld", ))]
if self.automu in ("A", "L"):
self.fld.append(
(("T", 2, 4, 0), "IUD", 6.2, "Percentabge Markup Lv1", "", "",
"N", None, None, None, ("efld", )))
for x in range(1, self.plevs):
self.fld.append((("T", 2, 4, 0), "IUD", 6.2, "Lv%s" % (x + 1),
"", "", "N", None, None, None, ("efld", )))
self.fld.extend([(("C", 3, 0, 0), "INA", 3, "Grp", "Product Group",
"r", "N", self.doRecGrp, gpm, None, None),
(("C", 3, 0,
1), "INA", 20, "Product-Code", "Product Code", "",
"N", self.doRecCod, stm, None, None),
(("C", 3, 0, 2), "ONA", 30, "Description"),
(("C", 3, 0, 3), "IUD", 11.2, "Quantity", "", "", "N",
self.doRecQty, None, self.doDelRec, ("notzero", ))])
but = (("Edit", None, self.doEditor, 0, ("C", 3, 1), None),
("Accept", None, self.doAccept, 0, ("T", 0, 0), ("T", 0, 1)),
("Cancel", None, self.doCancel, 0, ("T", 0, 0),
("T", 0, 1)), ("Quit", None, self.doQuit, 1, None, None))
tnd = ((self.doEnd, "N"), (self.doEnd, "N"), (self.doEnd, "Y"), None)
txt = (self.doExit, self.doExit, self.doExit, self.doExit)
cnd = (None, None, None, (self.doEnd, "N"))
cxt = (None, None, None, self.doExit)
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.pag == 0 or not self.gtype:
return
if opts[0] == (1, 0) and not self.newcode:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doGroup(self, frt, pag, r, c, p, i, w):
self.grpacc = self.sql.getRec(
"strgrp",
cols=["gpm_vatcode", "gpm_sales", "gpm_costs"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not self.grpacc:
return "Invalid Group"
self.group = w
self.df.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]]
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.mups = [0, 0, 0, 0, 0]
self.old1 = self.sql.getRec("strmf1",
where=[("st1_cono", "=",
self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", w)],
limit=1)
if not self.old1:
self.newcode = True
self.gtype = None
elif self.old1[3] == "X":
return "Redundant Code"
else:
self.newcode = False
d = 3
for x in range(0, self.df.topq[1]):
if x in (3, 6, 8, 10, 12, 14):
continue
if x == 0:
self.gtype = self.old1[d]
self.df.loadEntry("T", 1, x, data=self.old1[d])
if x == 2:
get = self.getUoi(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 5:
get = self.getVat(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 7:
get = self.getChnExcl(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 9:
get = self.getAccExcl(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if self.glint == "Y" and x in (11, 13):
get = self.getGenDes(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
d += 1
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("T", 0, 2, data=self.loc)
err = self.checkLoc()
if err:
return err
return "sk1"
def doLoc(self, frt, pag, r, c, p, i, w):
if w == 0:
return "Invalid Location"
self.loc = w
err = self.checkLoc()
if err:
return err
def checkLoc(self):
acc = self.sql.getRec("strloc",
cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location Code"
else:
self.df.loadEntry("T", 0, 3, data=acc[0])
self.old2 = self.sql.getRec("strmf2",
where=[("st2_cono", "=",
self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not self.old2:
ok = askQuestion(self.opts["mf"].body, "New Location",
"This location does not exist for this product. " \
"Are you sure that you want to create it?")
if ok == "yes":
self.newloc = "Y"
else:
return "Rejected Location"
if not self.old2:
self.newloc = "Y"
else:
self.newloc = "N"
d = 3
for x in range(0, 4):
d = d + 1
self.df.loadEntry("T", 2, x, data=self.old2[d])
if self.automu in ("A", "L"):
for y in range(self.plevs):
mup = getMarkup(self.sql, self.opts["conum"], self.group,
self.code, self.loc, y + 1)
self.df.loadEntry("T", 2, 4 + y, data=mup)
self.mups[y] = mup
def doType(self, frt, pag, r, c, p, i, w):
self.gtype = w
if self.gtype == "R":
self.df.enableTag(2)
else:
self.df.disableTag(2)
def doUoi(self, frt, pag, r, c, p, i, w):
acc = self.getUoi(w)
if not acc:
return "Invalid UOI Record"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doValInd(self, frt, pag, r, c, p, i, w):
self.df.topf[1][5][5] = self.grpacc[0]
def doVat(self, frt, pag, r, c, p, i, w):
acc = self.getVat(w)
if not acc:
return "Invalid VAT Record"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if not self.drsctl:
self.chain = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
if self.glint == "N":
return "sk9"
else:
return "sk4"
def doChnExcl(self, frt, pag, r, c, p, i, w):
if w:
acc = self.getChnExcl(w)
if not acc:
return "Invalid Chainstore"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
self.chain = w
def doAccExcl(self, frt, pag, r, c, p, i, w):
if w:
acc = self.getAccExcl(w)
if not acc:
return "Invalid Debtors Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if self.glint == "N":
return "sk5"
if self.newcode:
self.df.loadEntry(frt, pag, p + 2, data=self.grpacc[1])
if self.grpacc[1]:
acc = self.getGenDes(self.grpacc[1])
if not acc:
return "Invalid Sales Code"
self.df.loadEntry(frt, pag, p + 3, data=acc[0])
self.df.loadEntry(frt, pag, p + 4, data=self.grpacc[2])
if self.grpacc[2]:
acc = self.getGenDes(self.grpacc[2])
if not acc:
return "Invalid C.O.S. Code"
self.df.loadEntry(frt, pag, p + 5, data=acc[0])
def doSales(self, frt, pag, r, c, p, i, w):
acc = self.getGenDes(w)
if not acc:
return "Invalid Sales Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doCos(self, frt, pag, r, c, p, i, w):
acc = self.getGenDes(w)
if not acc:
return "Invalid COS Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doReord(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data=0)
return "sk2"
def getUoi(self, dat):
acc = self.sql.getRec("struoi",
cols=["unm_desc"],
where=[("unm_cono", "=", self.opts["conum"]),
("unm_unit", "=", dat)],
limit=1)
return acc
def getVat(self, dat):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", dat)],
limit=1)
return acc
def getChnExcl(self, dat):
self.chain = dat
if dat:
acc = self.sql.getRec("drschn",
cols=["chm_name"],
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", dat)],
limit=1)
return acc
def getAccExcl(self, dat):
if dat:
acc = self.sql.getRec("drsmst",
cols=["drm_name"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", dat),
("drm_stat", "<>", "X")],
limit=1)
return acc
def getGenDes(self, dat):
if dat:
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", dat)],
limit=1)
return acc
def doRecGrp(self, frt, pag, r, c, p, i, w):
self.rgroup = w
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.df.topf[0][1][8]["whera"] = [["C", "st1_group", 0, 3]]
def doRecCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.rgroup),
("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] == "R":
return "Invalid Type (Recipe)"
self.df.loadEntry(frt, pag, p + 1, data=acc[1])
acc = self.sql.getRec("strmf2",
cols=["st2_bin"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.rgroup),
("st2_code", "=", w),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Code (2)"
self.rcode = w
acc = self.sql.getRec("strrcp",
cols=["srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)],
limit=1)
if acc:
self.newrec = "n"
self.df.loadEntry(frt, pag, p + 2, data=acc[0])
else:
self.newrec = "y"
def doRecQty(self, frt, pag, r, c, p, i, w):
self.rqty = w
def doEditor(self):
if self.df.pag != 3:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
# Display recipe items and allow editing of details
data = self.sql.getRec(
tables=["strrcp", "strmf1"],
cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code), ("srr_loc", "=", self.loc),
("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ),
("st1_code=srr_rcode", )])
if data:
titl = "Recipe Items"
head = ("Grp", "Product-Code", "Description", "Quantity")
lin = {
"stype": "C",
"titl": titl,
"head": head,
"typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 10.2)),
"data": data
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select a Product to Edit")
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.change = chg.selection
self.doChgChanges()
self.df.enableButtonsTags(state=state)
self.df.focusField("C", 3, self.df.col)
def doChgChanges(self):
tit = ("Change Items", )
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"])],
"whera": [],
"index":
1
}
fld = ((("T", 0, 0, 0), "INA", 3, "Group", "Product Group", "", "N",
self.doChgGrp, gpm, None, ('notblank', )),
(("T", 0, 1, 0), "INA", 20, "Code", "Product Code", "", "N",
self.doChgCod, stm, None,
('notblank', )), (("T", 0, 2, 0), "ONA", 30, "Description"),
(("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N",
self.doChgQty, None, None, ('notzero', )))
but = [["Delete", None, self.doChgDel, 1, None, None]]
self.cg = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=((self.doChgEnd, "n"), ),
txit=(self.doChgExit, ))
self.cg.loadEntry("T", 0, 0, data=self.change[0])
self.cg.loadEntry("T", 0, 1, data=self.change[1])
self.cg.loadEntry("T", 0, 2, data=self.change[2])
self.cg.loadEntry("T", 0, 3, data=self.change[3])
self.cg.focusField("T", 0, 1, clr=False)
self.cg.mstFrame.wait_window()
def doChgGrp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.rgroup = w
self.cg.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]]
def doChgCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.rgroup),
("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] != "N":
return "Invalid Type"
cnt = self.sql.getRec("strrcp",
cols=["count(*)"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.rgroup),
("srr_code", "=", w)],
limit=1)
if cnt[0]:
return "Product Already In Recipe"
self.rcode = w
self.cg.loadEntry("T", 0, 2, data=acc[1])
def doChgQty(self, frt, pag, r, c, p, i, w):
self.rqty = w
def doChgDel(self):
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.change[0]),
("srr_rcode", "=", self.change[1])])
self.doReadLoadRecipe()
self.doChgExit()
def doChgEnd(self):
self.sql.updRec("strrcp",
cols=["srr_rgroup", "srr_rcode", "srr_rqty"],
data=[self.rgroup, self.rcode, self.rqty],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.loc),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.change[0]),
("srr_rcode", "=", self.change[1])])
self.doReadLoadRecipe()
self.doChgExit()
def doChgExit(self):
self.cg.closeProcess()
def doDelete(self):
trn = self.sql.getRec("strpot",
cols=["count(*)"],
where=[("pot_cono", "=", self.opts["conum"]),
("pot_group", "=", self.group),
("pot_code", "=", self.code)],
limit=1)
if trn[0]:
return "Purchase Orders Exist, Not Deleted"
trn = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_group", "=", self.group),
("stt_code", "=", self.code),
("stt_loc", "=", self.loc)],
limit=1)
if trn[0]:
return "Stores Transactions Exist, Not Deleted"
trn = self.sql.getRec("slsiv2",
cols=["count(*)"],
where=[("si2_cono", "=", self.opts["conum"]),
("si2_group", "=", self.group),
("si2_code", "=", self.code),
("si2_loc", "=", self.loc)],
limit=1)
if trn[0]:
return "Sales-2 Transactions Exist, Not Deleted"
trn = self.sql.getRec("slsiv3",
cols=["count(*)"],
where=[("si3_cono", "=", self.opts["conum"]),
("si3_rgroup", "=", self.group),
("si3_rcode", "=", self.code)],
limit=1)
if trn[0]:
return "Sales-3 Transactions Exist, Not Deleted"
self.sql.delRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["strmf2", "D", "%03i%-3s%-20s%-1s" % \
(self.opts["conum"], self.group, self.code, self.loc), "", dte,
self.opts["capnm"], "", "", "", 0])
st2 = self.sql.getRec("strmf2",
cols=["count(*)"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code)],
limit=1)
if not st2[0]:
self.sql.delRec("strmf1",
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", self.code)])
self.sql.insRec("chglog", data=["strmf1", "D", "%03i%-3s%-20s" % \
(self.opts["conum"], self.group, self.code), "", dte,
self.opts["capnm"], "", "", "", 0])
# Other Files
self.sql.delRec("strcst",
where=[("stc_cono", "=", self.opts["conum"]),
("stc_group", "=", self.group),
("stc_code", "=", self.code),
("stc_loc", "=", self.loc)])
self.sql.delRec("strprc",
where=[("stp_cono", "=", self.opts["conum"]),
("stp_group", "=", self.group),
("stp_code", "=", self.code),
("stp_loc", "=", self.loc)])
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc)])
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.group),
("srr_rcode", "=", self.code)])
self.sql.delRec("strvar",
where=[("stv_cono", "=", self.opts["conum"]),
("stv_group", "=", self.group),
("stv_code", "=", self.code),
("stv_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doDelRec(self):
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)])
self.df.clearLine(2, focus=True)
def doEnd(self):
if self.df.frt == "T" and self.df.pag == 0:
if self.newcode:
self.df.focusField("T", 1, 1)
else:
if self.gtype == "R":
self.df.enableTag(2)
self.df.skip[1] = [1]
self.df.focusField("T", 1, 2, clr=False)
elif self.df.frt == "T" and self.df.pag == 1:
self.df.selPage("Basic-B")
elif self.df.frt == "T" and self.df.pag == 2:
if self.gtype == "R":
self.df.selPage("Recipes")
else:
self.doEnder()
elif self.df.frt == "C" and self.df.pag == 3:
data = [
self.opts["conum"], self.group, self.code, self.loc,
self.rgroup, self.rcode, self.rqty
]
if self.newrec == "y":
self.sql.insRec("strrcp", data=data)
self.df.advanceLine(3)
else:
whr = [("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)]
self.sql.updRec("strrcp", data=data, where=whr)
self.doReadLoadRecipe()
def doEnder(self):
data = [self.opts["conum"]]
for x in range(0, 2):
data.append(self.df.t_work[0][0][x])
for x in range(0, len(self.df.t_work[1][0])):
if x in (3, 6, 8, 10, 12, 14):
continue
data.append(self.df.t_work[1][0][x])
if self.newcode:
self.sql.insRec("strmf1", data=data)
elif data != self.old1[:len(data)]:
col = self.sql.strmf1_col
data.append(self.old1[col.index("st1_xflag")])
self.sql.updRec("strmf1",
data=data,
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old1):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"strmf1", "U",
"%03i%-3s%-20s" %
(self.opts["conum"], self.group, self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
data = [self.opts["conum"], self.group, self.code, self.loc]
for x in range(0, 4):
data.append(self.df.t_work[2][0][x])
if self.newloc == "Y":
self.sql.insRec("strmf2", data=data)
elif data != self.old2[:len(data)]:
col = self.sql.strmf2_col
data.append(self.old2[col.index("st2_xflag")])
self.sql.updRec("strmf2",
data=data,
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old2):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"strmf2", "U",
"%03i%-3s%-20s%-1s" %
(self.opts["conum"], self.group,
self.code, self.loc), col[num], dte,
self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.sql.delRec("strcmu",
where=[("smc_cono", "=", self.opts["conum"]),
("smc_group", "=", self.group),
("smc_code", "=", self.code),
("smc_loc", "=", self.loc)])
for num, mup in enumerate(self.df.t_work[2][0][4:]):
if mup and mup != self.mups[num]:
self.sql.insRec("strcmu",
data=[
self.opts["conum"], self.group, self.code,
self.loc, num + 1, mup
])
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doReadLoadRecipe(self):
self.df.clearFrame("C", 3)
self.df.focusField("C", 3, 1)
rec = self.sql.getRec(
tables=["strrcp", "strmf1"],
cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code), ("srr_loc", "=", self.loc),
("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ),
("st1_code=srr_rcode", )])
if rec:
mxs = (self.df.rows[3] - 1) * self.df.colq[3]
for l, r in enumerate(rec):
for i, d in enumerate(r):
c = l * self.df.colq[3]
if c > mxs:
c = mxs
self.df.loadEntry("C", 3, (c + i), data=d)
self.df.advanceLine(3)
def doExit(self):
if self.df.frt == "T" and self.df.pag == 0:
self.doQuit()
elif self.df.frt == "T" and self.df.pag == 1:
if self.newcode:
self.df.focusField("T", 1, 1)
else:
self.df.skip[1] = [1]
self.df.focusField("T", 1, 2, clr=False)
elif self.df.frt == "T" and self.df.pag == 2:
self.df.focusField("T", 2, 1)
elif self.df.frt == "C" and self.df.pag == 3:
if self.df.col == 1:
self.df.focusField("C", 3, 1)
else:
self.doEnder()
def doAccept(self):
ok = "yes"
for page in (1, 2):
frt, pag, col, err = self.df.doCheckFields(("T", page, None))
if err:
ok = "no"
if pag and pag != self.df.pag:
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col + 1), err=err)
break
if ok == "yes":
self.doEnder()
def doQuit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
class msc110(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["ctlsys", "ctlpwu", "chglog", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
if self.sql.error == ["genmst"]:
self.gl = False
else:
return
else:
self.gl = True
self.acc = self.sql.getRec("ctlsys", limit=1)
if not self.acc:
self.new = True
self.acc = [
0, "N", 0, 0, 0, "", 0, 0, 0, "", "", "N", "", "", "N", 0
]
else:
self.new = False
return True
def drawDialog(self):
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("None", "0"), ("STARTTLS", "1"), ("SSL/TLS", "2"))
r3s = (("None", "0"), ("Normal", "1"), ("Encrypted", "2"))
self.fld = (
(("T",0,0,0),"IUI",2,"Years to Keep History","",
self.acc[0],"N",self.doHist,None,None,None,None,
"The number of years that historical data must be kept, "\
"Use 0 for No Limit"),
(("T",0,1,0),("IRB",r1s),0,"Enforce Passwords","",
self.acc[1],"N",self.doMust,None,None,None),
(("T",0,2,0),"IUI",2,"Minimum Characters","",
self.acc[2],"N",None,None,None,None),
(("T",0,3,0),"IUI",2,"Maximum Life (Days)","",
self.acc[3],"N",None,None,None,None),
(("T",0,4,0),"IUI",3,"Backup History (Days)","",
self.acc[4],"N",None,None,None,None,None,
"0 for No Limit"),
(("T",0,5,0),"ITX",30,"SMTP Server","",
self.acc[5],"N",self.doSmtp,None,None,None),
(("T",0,6,0),("IRB",r2s),0,"SMTP Security","",
self.acc[6],"N",None,None,None,None),
(("T",0,7,0),("IRB",r3s),0,"SMTP Authentication","",
self.acc[7],"N",self.doAuth,None,None,None),
(("T",0,8,0),"IUI",4,"SMTP Port","",
self.acc[8],"N",None,None,None,None),
(("T",0,9,0),"ITX",20,"SMTP Username","",
self.acc[9],"N",self.doUsr,None,None,None),
(("T",0,10,0),"IHA",20,"SMTP Password","",
self.acc[10],"N",None,None,None,None),
(("T",0,11,0),("IRB",r1s),0,"SMS Service","",
self.acc[11],"N",self.doSms,None,None,None),
(("T",0,12,0),"ITX",20,"SMS Username","",
self.acc[12],"N",self.doSmsUsr,None,None,None),
(("T",0,13,0),"IHA",20,"SMS Password","",
self.acc[13],"N",self.doSmsPwd,None,None,None),
(("T",0,14,0),("IRB",r1s),0,"G/L Departments","",
self.acc[14],"N",self.doGlDept,None,None,None,None,
"G/L Account Numbers include Department Numbers"),
(("T",0,15,0),"IUI",1,"Number of Digits","",
self.acc[15],"N",None,None,None,None,None,
"The Number of Digits used for Department Numbers"))
but = (("Accept", None, self.doAccept, 0, (("T", 0, 1), ("T", 0, 6)),
("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,
focus=False)
for n, f in enumerate(self.acc):
self.df.loadEntry("T", 0, n, data=f)
self.df.focusField("T", 0, 1, clr=False)
def doHist(self, frt, pag, r, c, p, i, w):
if w and w < 5:
return "At least 5 Years of History should be kept"
def doMust(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data=0)
return "sk2"
def doSmtp(self, frt, pag, r, c, p, i, w):
if not w:
self.df.loadEntry(frt, pag, p + 1, data="0")
self.df.loadEntry(frt, pag, p + 2, data="0")
self.df.loadEntry(frt, pag, p + 3, data="")
self.df.loadEntry(frt, pag, p + 4, data="")
self.df.loadEntry(frt, pag, p + 5, data="")
return "sk5"
def doAuth(self, frt, pag, r, c, p, i, w):
if not int(w):
self.df.loadEntry(frt, pag, p + 1, 25)
self.df.loadEntry(frt, pag, p + 2, "")
self.df.loadEntry(frt, pag, p + 3, "")
return "sk3"
elif int(self.df.t_work[0][0][6]) == 1:
self.df.loadEntry(frt, pag, p + 1, 587)
elif int(self.df.t_work[0][0][6]) == 2:
self.df.loadEntry(frt, pag, p + 1, 465)
def doUsr(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid SMTP Name"
def doSms(self, frt, pag, r, c, p, i, w):
if w == "Y" and not chkMod("requests"):
showError(self.opts["mf"].body, "Error", "Missing requests Module")
w = "N"
self.df.loadEntry(frt, pag, p, data=w)
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data="")
if not self.gl:
self.df.loadEntry(frt, pag, p + 3, data="N")
self.df.loadEntry(frt, pag, p + 4, data=0)
return "sk4"
return "sk2"
def doSmsUsr(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid SMS User Name"
def doSmsPwd(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid SMS Password"
def doGlDept(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEnd(self):
svr = self.df.t_work[0][0][5]
if svr:
prt = self.df.t_work[0][0][8]
sec = self.df.t_work[0][0][6]
aut = self.df.t_work[0][0][7]
nam = self.df.t_work[0][0][9]
pwd = self.df.t_work[0][0][10]
chk = sendMail([svr, prt, sec, aut, nam, pwd],
"",
"",
"",
check=True,
err=self.opts["mf"].body,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
if not chk:
self.df.focusField("T", 0, 6)
return
tme = time.localtime()
data = copyList(self.df.t_work[0][0])
if self.new:
self.sql.insRec("ctlsys", data=data)
elif data != self.acc[:len(data)]:
self.sql.updRec("ctlsys", data=data)
dte = int("%04i%02i%02i%02i%02i%02i" % tme[:-3])
for num, dat in enumerate(self.acc):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"ctlsys", "U",
"%03i" % 0, self.sql.ctlsys_col[num],
dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
# Reset all password dates to current date (Temporary Fix)
dte = (tme[0] * 10000) + (tme[1] * 100) + tme[2]
self.sql.updRec("ctlpwu", cols=["usr_last"], data=[dte])
self.opts["mf"].dbm.commitDbase()
self.doExit()
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rc1020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["chglog", "rcaprm", "rcaowm", "rcatnm"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
own = {
"stype":
"R",
"tables": ("rcaowm", ),
"cols":
(("rom_acno", "", 0, "Own-Cod"), ("rom_name", "", 0, "Name", "Y")),
"where": [("rom_cono", "=", self.opts["conum"])]
}
prm = {
"stype":
"R",
"tables": ("rcaprm", ),
"cols": (("rcp_code", "", 0, "Prm-Code"), ("rcp_addr1", "", 0,
"Address-Line-1")),
"where": [("rcp_cono", "=", self.opts["conum"])],
"whera": [("T", "rcp_owner", 0, 0)]
}
self.fld = [(("T", 0, 0, 0), "INA", 7, "Owner Code", "Owner", "", "N",
self.doOwnCod, own, None, ("notblank", )),
(("T", 0, 0, 0), "ONA", 30, "Name"),
(("T", 0, 1, 0), "INA", 7, "Premises Code", "Premises", "",
"N", self.doPrmCod, prm, None, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("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", "PCod", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 7, 0), "IUD", 6.2, "Commission Rate", "C-Rate",
"", "N", None, None, None, ("efld", ))]
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)
def doOwnCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rcaowm",
cols=["rom_name"],
where=[("rom_cono", "=", self.opts["conum"]),
("rom_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Owner"
self.owner = w
self.name = acc[0]
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doPrmCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("rcaprm",
where=[("rcp_cono", "=",
self.opts["conum"]),
("rcp_owner", "=", self.owner),
("rcp_code", "=", self.code)],
limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
for num, dat in enumerate(self.old[2:-1]):
self.df.loadEntry(frt, pag, p + num, data=dat)
def doDelete(self):
mst = self.sql.getRec("rcatnm",
cols=["count(*)"],
where=[("rtn_cono", "=", self.opts["conum"]),
("rtn_code", "=", self.code)],
limit=1)
if mst[0]:
return "Accounts Exist, Not Deleted"
self.sql.delRec("rcaprm",
where=[("rcp_cono", "=", self.opts["conum"]),
("rcp_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["rcaprm", "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):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if x == 1:
continue
data.append(self.df.t_work[0][0][x])
if self.new == "y":
self.sql.insRec("rcaprm", data=data)
elif data != self.old[:len(data)]:
col = self.sql.rcaprm_col
data.append(self.old[col.index("rcp_xflag")])
self.sql.updRec("rcaprm",
data=data,
where=[("rcp_cono", "=", self.opts["conum"]),
("rcp_code", "=", self.code)])
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=[
"rcaprm", "U",
"%03i%-7s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
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()
self.opts["mf"].closeLoop()
class stc310(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "genmst", "strmf1",
"strgrp", "strgmu"], 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.plevs = strctl["cts_plevs"]
self.automu = strctl["cts_automu"]
return True
def mainProcess(self):
gpm = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
glm = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]}
self.fld = [
(("T",0,0,0),"IUA",3,"Product Group","",
"","N",self.doGroup,gpm,None,("notblank",)),
(("T",0,1,0),"INA",30,"Description","",
"","N",None,None,self.doDelete,("notblank",)),
(("T",0,2,0),"IUA",1,"Vat Code","",
"","N",self.doVat,vtm,None,("notblank",))]
row = 3
if self.glint == "Y":
self.fld.append((("T",0,3,0),"IUI",7,"Sales Account","",
"","N",self.doSales,glm,None,("notzero",)))
self.fld.append((("T",0,3,0),"ONA",30,""))
self.fld.append((("T",0,4,0),"IUI",7,"COS Account","",
"","N",self.doCos,glm,None,("notzero",)))
self.fld.append((("T",0,4,0),"ONA",30,""))
row = 5
if self.automu in ("A", "L"):
self.fld.append((("T",0,row,0),"IUD",5.1,"Mark-Up Lv1","",
"","N",None,None,None,("efld",)))
if self.plevs > 1:
for x in range(1, self.plevs):
self.fld.append((("T",0,row,0),"IUD",5.1,"Lv%s" % (x+1),"",
"","N",None,None,None,("efld",)))
but = (
("Accept",None,self.doAccept,0,("T",0,2),("T",0,0)),
("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0)))
tnd = ((self.doEnd,"Y"), )
txt = (self.doCloseProcess, )
self.df = TartanDialog(self.opts["mf"], eflds=self.fld,
butt=but, tend=tnd, txit=txt)
def doGroup(self, frt, pag, r, c, p, i, w):
self.group = w
self.acc = self.sql.getRec("strgrp", where=[("gpm_cono", "=",
self.opts["conum"]), ("gpm_group", "=", self.group)], limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
col = self.sql.strgrp_col
self.df.loadEntry(frt, pag, p+1,
data=self.acc[col.index("gpm_desc")])
self.df.loadEntry(frt, pag, p+2,
data=self.acc[col.index("gpm_vatcode")])
p = 3
if self.glint == "Y":
self.df.loadEntry(frt, pag, p,
data=self.acc[col.index("gpm_sales")])
des = self.getGenDesc(self.acc[col.index("gpm_sales")])
if not des:
self.df.loadEntry(frt, pag, p+1,
data="Invalid Sales Code")
else:
self.df.loadEntry(frt, pag, p+1,
data=des[0])
self.df.loadEntry(frt, pag, p+2,
data=self.acc[col.index("gpm_costs")])
des = self.getGenDesc(self.acc[col.index("gpm_costs")])
if not des:
self.df.loadEntry(frt, pag, p+3,
data="Invalid Costs Code")
else:
self.df.loadEntry(frt, pag, p+3,
data=des[0])
p = 7
if self.automu in ("A", "L"):
for lev in range(self.plevs):
mup = self.sql.getRec("strgmu", cols=["smg_markup"],
where=[("smg_cono", "=", self.opts["conum"]),
("smg_group", "=", self.group), ("smg_level",
"=", lev + 1)], limit=1)
if not mup:
mup = [0]
self.df.loadEntry(frt, pag, p+lev, data=mup[0])
def doVat(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=",
w)], limit=1)
if not vat:
return "Invalid VAT Code"
self.code = w
def doSales(self, frt, pag, r, c, p, i, w):
acc = self.getGenDesc(w)
if not acc:
return "Invalid Sales Code"
self.sales = w
self.df.loadEntry("T", 0, 4, data=acc[0])
def doCos(self, frt, pag, r, c, p, i, w):
acc = self.getGenDesc(w)
if not acc:
return "Invalid COS Code"
self.cos = w
self.df.loadEntry("T", 0, 6, data=acc[0])
def doDelete(self):
st1 = self.sql.getRec("strmf1", cols=["count(*)"],
where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=",
self.group)], limit=1)
if st1[0]:
return "Records Exist for this Group, Not Deleted"
self.sql.delRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", self.group)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if x == 7:
break
if self.glint == "Y":
# Account Names
if x in (4, 6):
continue
elif x == 3:
data.append(0)
data.append(0)
break
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("strgrp", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.strgrp_col
data.append(self.acc[col.index("gpm_xflag")])
self.sql.updRec("strgrp", data=data, where=[("gpm_cono",
"=", self.opts["conum"]), ("gpm_group", "=", self.group)])
self.sql.delRec("strgmu", where=[("smg_cono", "=", self.opts["conum"]),
("smg_group", "=", self.group)])
if self.automu in ("A", "L"):
for lvl, mup in enumerate(self.df.t_work[0][0][x:]):
if not mup:
continue
self.sql.insRec("strgmu", data=[self.opts["conum"],
self.group, lvl + 1, mup])
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 getGenDesc(self, acno):
return self.sql.getRec("genmst", cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=",
acno)], limit=1)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bkc510(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["chglog", "bkmcon", "bkmmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
bkmctl = gc.getCtl("bkmctl", self.opts["conum"])
if not bkmctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
con = {
"stype":
"R",
"tables": ("bkmcon", ),
"cols":
(("bkc_ccode", "", 0, "Code"), ("bkc_title", "", 0, "Title"),
("bkc_sname", "", 0, "Surname",
"Y"), ("bkc_names", "", 0, "Names", "F"), ("bkc_email", "", 0,
"Email Address"))
}
self.fld = ((("T", 0, 0, 0), "IUA", 7, "Code", "", "", "Y",
self.doCode, con, None, None),
(("T", 0, 1, 0), "ITX", 6, "Title", "", "", "N",
self.doTitle, None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "ITX", 30, "Surname", "", "", "N",
self.doSurname, None, None, ("notblank", )),
(("T", 0, 3, 0), "ITX", 30, "Names", "", "", "N",
self.doNames, None, None, ("notblank", )),
(("T", 0, 4, 0), "ITX", 30, "Address Line 1", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 5, 0), "ITX", 30, "Address Line 2",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 6, 0), "ITX", 30, "Address Line 3", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 7, 0), "ITX", 4, "Postal Code", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 8, 0), "ITX", 20, "Telephone Number", "", "",
"N", None, None, None,
("efld", )), (("T", 0, 9, 0), "ITX", 20, "Fax Number", "",
"", "N", None, None, None,
("efld", )), (("T", 0, 10, 0), "ITX", 20,
"Mobile Number", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 11, 0), "ITX", 30, "E-Mail Address", "", "", "N",
None, None, None,
("email", )), (("T", 0, 12, 0), "INA", 10, "V.A.T Number",
"", "", "N", None, None, None, ("efld", )))
but = (
("Import",None,self.doImport,0,("T",0,1),("T",0,2),
"Import Contact Details from a CSV or XLS File having "\
"the following fields: Code, Title, Surname, Names, "\
"Address Line1, Line2, Line3, Postal Code, Telephone Number, "\
"Fax Number, Mobile Number, Email Address, VAT Number"),
("Accept",None,self.doAccept,0,("T",0,2),("T",0,1)),
("Print", None, self.doPrint,0,("T",0,2),("T",0,1)),
("Quit", None, self.doExit,1,None,None))
tnd = ((self.doAccept, "N"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
def doClick(self, *opts):
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doCode(self, frt, pag, r, c, p, i, w):
self.ccode = w
if w:
self.oldcon = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_ccode", "=", w)],
limit=1)
if not self.oldcon:
return "Invalid Contact Code"
self.newcon = False
self.title = self.oldcon[self.sql.bkmcon_col.index("bkc_title")]
self.sname = self.oldcon[self.sql.bkmcon_col.index("bkc_sname")]
self.names = self.oldcon[self.sql.bkmcon_col.index("bkc_names")]
self.email = self.oldcon[self.sql.bkmcon_col.index("bkc_email")]
for num, dat in enumerate(self.oldcon[1:-1]):
self.df.loadEntry("T", 0, num, data=dat)
else:
self.newcon = True
self.acno = w
def doTitle(self, frt, pag, r, c, p, i, w):
self.title = w
def doSurname(self, frt, pag, r, c, p, i, w):
self.sname = w
def doNames(self, frt, pag, r, c, p, i, w):
self.names = w
def doEmail(self, frt, pag, r, c, p, i, w):
self.email = w
def doDelete(self):
chk = self.sql.getRec("bkmmst",
cols=["count(*)"],
where=[("bkm_cono", "=", self.opts["conum"]),
("bkm_ccode", "=", self.ccode)],
limit=1)
if chk[0]:
return "Bookings Exist, Not Deleted"
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("bkmcon",
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", self.ccode)])
self.sql.insRec("chglog",
data=[
"bkmcon", "D",
"%03i%-7s" % (self.opts["conum"], self.ccode), "",
dte, self.opts["capnm"], "", "", "", 0
])
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)
return
# Create/Update Record
if self.newcon:
self.ccode = self.genCode(self.sname)
self.df.loadEntry("T", 0, 0, data=self.ccode)
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
data = [self.opts["conum"]]
for x in range(len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.newcon:
self.sql.insRec("bkmcon", data=data)
elif data != self.oldcon[:len(data)]:
col = self.sql.bkmcon_col
data.append(self.oldcon[col.index("bkc_xflag")])
self.sql.updRec("bkmcon",
data=data,
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", self.ccode)])
for num, dat in enumerate(self.oldcon):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"bkmcon", "U",
"%03i%-7s" % (self.opts["conum"], self.ccode),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doImport(self):
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="bkmcon", impskp=["bkc_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Contacts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if not line[0]:
if not line[2]:
err = "Blank Code and Blank Surname"
break
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_sname", "=", line[2]),
("bkc_names", "=", line[3])],
limit=1)
if chk:
err = "%s: %s %s: %s\n\nAlready Exists" % (
fi.impcol[2][0], line[2], fi.impcol[3][0], line[3])
break
for _ in range(1, 100):
line[0] = self.genCode(line[2])
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_ccode", "=", line[0])],
limit=1)
if not chk:
break
else:
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_ccode", "=", line[0])],
limit=1)
if chk:
err = "%s: %s %s: %s\n\nAlready Exists" % (
fi.impcol[0][0], line[0], fi.impcol[2][0], line[2])
break
if not line[1]:
line[1] = "Ms"
if not line[2]:
err = "Blank Surname"
break
if not line[3]:
err = "Blank Names"
break
line.insert(0, self.opts["conum"])
self.sql.insRec("bkmcon", 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="bkmcon",
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", self.ccode)])
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 genCode(self, sname):
# Remove invalid characters
sname = sname.replace(" ", "")
for c in (" ", ".", ",", ";", ":", "'", '"'):
sname = sname.replace(c, "")
if len(sname) < 5:
sname = sname + ("0" * (5 - len(sname)))
ccod1 = ""
for c in range(0, 5):
ccod1 = (ccod1 + sname[c]).upper()
ccod1 = ccod1.strip()
text = "%s%0" + str((7 - len(ccod1))) + "d"
for x in range(1, 100):
ccod2 = text % (ccod1, x)
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", ccod2)],
limit=1)
if not chk:
break
return ccod2
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rc1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["ctlmst", "rcaowm", "rcaowt", "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):
own = {
"stype":
"R",
"tables": ("rcaowm", ),
"cols":
(("rom_acno", "", 0, "Acc-Num"), ("rom_name", "", 0, "Name", "Y")),
"where": [("rom_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INA", 7, "Account Number", "", "", "Y",
self.doOwner, own, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N", None,
None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 3",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 4, "Postal Code", "PCod", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 6, 0), "INA", 20, "Home Number", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 7, 0), "INA", 20, "Office Number",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 8, 0), "INA", 20, "Mobile Number", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 9, 0), "INA", 20, "Fax Number", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 10, 0), "ITX", 50, "E-Mail Address", "", "", "N",
None, None, None, ("email", )),
(("T", 0, 11, 0), "INA", 10, "VAT Number",
"VAT-Number", "", "N", None, None, None,
("efld", )), (("T", 0, 12, 0), "IUA", 1, "VAT Default",
"V", "", "N", None, None, None, ("efld", )),
(("T", 0, 13, 0), "INA", 20, "Bank Name", "Bank-Name", "",
"N", None, None, None,
("efld", )), (("T", 0, 14, 0), "IUI", 8, "Bank Branch",
"Bank-IBT", "", "N", None, None, None,
("efld", )), (("T", 0, 15, 0), "INA", 16,
"Bank Account",
"Bank-Account-Num", "", "N",
None, None, None, ("efld", )))
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)
def doOwner(self, frt, pag, r, c, p, i, w):
self.acno = w
self.oldm = self.sql.getRec("rcaowm",
where=[("rom_cono", "=",
self.opts["conum"]),
("rom_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)
else:
self.new = "n"
for num, fld in enumerate(self.oldm[1:-1]):
self.df.loadEntry(frt, pag, p + num, data=fld)
trn = self.sql.getRec("rcaowt",
cols=["count(*)"],
where=[("rot_cono", "=", self.opts["conum"]),
("rot_acno", "=", self.acno)],
limit=1)
if trn[0]:
self.trn = True
else:
self.trn = False
def doName(self, frt, pag, r, c, p, i, w):
pass
def doTelno(self, frt, pag, r, c, p, i, w):
pass
def doEmail(self, frt, pag, r, c, p, i, w):
pass
def doVatInd(self, frt, pag, r, c, p, i, w):
pass
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):
pass
def doPeriod(self, frt, pag, r, c, p, i, w):
pass
def doPayInd(self, frt, pag, r, c, p, i, w):
pass
def doAmount(self, frt, pag, r, c, p, i, w):
if self.new == "y":
self.df.loadEntry(frt, pag, p + 1, data="C")
def doStatus(self, frt, pag, r, c, p, i, w):
pass
def doDelete(self):
if self.trn:
return "Transactions Exist, Not Deleted"
self.sql.delRec("rcaowm",
where=[("rom_cono", "=", self.opts["conum"]),
("rom_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["rcaowm", "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):
datm = [self.opts["conum"]]
for num, fld in enumerate(self.df.t_work[0][0]):
datm.append(fld)
if self.new == "y":
self.sql.insRec("rcaowm", data=datm)
elif datm != self.oldm[:len(datm)]:
col = self.sql.rcaowm_col
datm.append(self.oldm[col.index("rom_xflag")])
self.sql.updRec("rcaowm",
data=datm,
where=[("rom_cono", "=", self.opts["conum"]),
("rom_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec(
"chglog",
data=[
"rcaowm", "U",
"%03i%-7s" % (self.opts["conum"], self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(datm[num]), "", 0
])
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()
self.opts["mf"].closeLoop()
class drc210(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"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
if drsctl["ctd_chain"] == "N":
showError(self.opts["mf"].body, "Error",
"Chain Stores are Not Enabled")
return
self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "drschn"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
chm = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Chn"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "IUI", 3, "Chn", "Chainstore Number", "",
"N", self.doChain, chm, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N", None,
None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 3",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 4, "Postal Code", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 6, 0), "INA", 20, "Telephone", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 7,
0), "INA", 20, "Fax", "", "", "N", None, None, None,
("efld", )), (("T", 0, 8, 0), "ITX", 50, "E-Mail Address",
"", "", "N", None, None, None, ("email", )),
(("T", 0, 9,
0), "INA", 30, "Contact", "", "", "N", None, None, None,
("efld", )), (("T", 0, 10, 0), "IUA", 1, "Vat Code", "",
"", "N", self.doVat, vtm, None,
("notblank", )), (("T", 0, 10, 0), "ONA",
30, ""))
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)
def doChain(self, frt, pag, r, c, p, i, w):
self.chain = w
self.acc = self.sql.getRec("drschn",
where=[("chm_cono", "=",
self.opts["conum"]),
("chm_chain", "=", self.chain)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
vat = self.sql.getRec(
"ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=",
self.acc[self.sql.drschn_col.index("chm_vatind")])],
limit=1)
if not vat:
txt = "Invalid Vat Record"
else:
txt = vat[0]
for x in range(0, self.df.topq[pag]):
if x == (self.df.topq[pag] - 1):
self.df.loadEntry(frt, pag, p + x, data=txt)
else:
self.df.loadEntry(frt, pag, p + x, data=self.acc[x + 1])
def doVat(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not vat:
return "Invalid Vat Record"
self.df.loadEntry(frt, pag, p + 1, data=vat[0])
def doDelete(self):
self.sql.delRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", self.chain)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dat = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if x == 11:
continue
dat.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("drschn", data=dat)
elif dat != self.acc[:len(dat)]:
col = self.sql.drschn_col
dat.append(self.acc[col.index("chm_xflag")])
self.sql.updRec("drschn",
data=dat,
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", self.chain)])
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()
self.opts["mf"].closeLoop()
class stc410(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"strloc",
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.locs = strctl["cts_locs"]
if self.locs == "N":
showError(self.opts["mf"].body, "Error",
"Multiple Locations Are Not Enabled")
return
return True
def mainProcess(self):
loc = {
"stype":
"R",
"tables": ("strloc", ),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "IUA", 1, "Location Code", "", "", "N",
self.doLoc, loc, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 2,
0), "INA", 30, "Address Line 1", "", "", "N", None, None,
None, None), (("T", 0, 3, 0), "INA", 30, "Address Line 2",
"", "", "N", None, None, None, None),
(("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None, None), (("T", 0, 5, 0), "INA", 30,
"Address Line 4", "", "", "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)))
tnd = ((self.doEnd, "Y"), )
txt = (self.doCloseProcess, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doLoc(self, frt, pag, r, c, p, i, w):
if w == "0":
return "Invalid Location"
self.loc = w
self.acc = self.sql.getRec("strloc",
where=[("srl_cono", "=",
self.opts["conum"]),
("srl_loc", "=", self.loc)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
for x in range(1, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=self.acc[x + 1])
def doDelete(self):
self.sql.delRec("strloc",
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("strloc", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.strloc_col
data.append(self.acc[col.index("srl_xflag")])
self.sql.updRec("strloc",
data=data,
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", self.loc)])
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 doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class crc110(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
mods = ctlmst["ctm_modules"]
self.genleg = False
for x in range(0, len(mods), 2):
if mods[x:x + 2] == "GL":
self.genleg = True
break
tabs = ["crsctl", "tplmst", "chglog"]
if self.genleg:
tabs.extend(["ctlctl", "genmst"])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.acc = self.sql.getRec("crsctl", where=[("ctc_cono", "=",
self.opts["conum"])], limit=1)
if not self.acc:
self.new = True
self.acc = [self.opts["conum"], "N", "E", "", 0, 0,
"remittance_advice", "", ""]
else:
self.new = False
if self.genleg:
self.ctl = [
["crs_ctl", "Creditors Control", 0],
["dis_rec", "Discount Received", 0]]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
for num, ctl in enumerate(self.ctl):
if ctl[0] in ctlctl:
self.ctl[num][2] = ctlctl[ctl[0]]
return True
def drawDialog(self):
ctl = {
"stype": "R",
"tables": ("ctlctl", "genmst"),
"cols": (
("ctl_code", "", 0, "Ctl-Code"),
("ctl_conacc", "", 0, "G/L-Num"),
("glm_desc", "", 30, "Description")),
"where": [
("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "like", "bank_%"),
("glm_cono=ctl_cono",),
("glm_acno=ctl_conacc",)],
"index": 1}
tpm = {
"stype": "R",
"tables": ("tplmst",),
"cols": (
("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"),
("tpm_type", "", 0, "T")),
"where": [
("tpm_type", "=", "R"),
("tpm_system", "=", "CRS")],
"order": "tpm_tname"}
r1s = (("Yes","Y"),("No","N"))
r2s = (("Exclusive","E"),("Inclusive","I"))
if self.genleg:
glm = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "G/L-Num"),
("glm_desc", "", 30, "Description")),
"where": [
("glm_cono", "=", self.opts["conum"])]}
fld = [
(("T",0,0,0),("IRB",r1s),0,"G/L Integration","",
self.acc[1],"N",self.doGlint,None,None,None),
(("T",0,1,0),"IUI",7,self.ctl[0][1],"",
self.ctl[0][2],"N",self.doGenAcc,glm,None,("efld",)),
(("T",0,1,0),"ONA",30,""),
(("T",0,2,0),"IUI",7,self.ctl[1][1],"",
self.ctl[1][2],"N",self.doGenAcc,glm,None,("efld",)),
(("T",0,2,0),"ONA",30,""),
(("T",0,3,0),("IRB",r2s),0,"G/L Input Method","",
self.acc[2],"N",None,None,None,None),
(("T",0,4,0),"INA",4,"Best Account Code","Best",
self.acc[3],"N",self.doBestAcc,None,None,("efld",)),
(("T",0,5,0),"IUI",2,"Best Account Type","BT",
self.acc[4],"N",None,None,None,("efld",)),
(("T",0,6,0),"IUI",7,"Bank Account Code","Bank-Ac",
self.acc[5],"N",self.doBankAcc,ctl,None,("efld",))]
seq = 7
else:
fld = []
seq = 0
fld.extend([
(("T",0,seq,0),"INA",20,"Remittance Template","",
self.acc[6],"N",self.doTplNam,tpm,None,("efld",)),
(("T",0,seq + 1,0),"ITX",50,"Email Address","",
self.acc[7],"N",None,None,None,("email",))])
but = (
("Accept",None,self.doAccept,0,("T",0,1),("T",0,0)),
("Quit",None,self.doExit,1,None,None))
tnd = ((self.doEnd,"Y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt)
if not self.new:
s = 0
for n, f in enumerate(self.acc[1:-1]):
if not self.genleg and n < 5:
continue
self.df.loadEntry("T", 0, s, data=f)
s += 1
if not n:
for c in self.ctl:
self.df.loadEntry("T", 0, s, data=c[2])
s += 1
self.df.loadEntry("T", 0, s, data=self.getDes(c[2]))
s += 1
self.df.focusField("T", 0, 1, clr=False)
def doGlint(self, frt, pag, r, c, p, i, w):
self.glint = w
if self.glint == "N":
for x in range(1, 5):
self.df.loadEntry(frt, pag, p+x, data="")
self.df.loadEntry(frt, pag, p+5, data="E")
return "sk5"
def doGenAcc(self, frt, pag, r, c, p, i, w):
des = self.getDes(w)
if not des:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p+1, data=des)
def getDes(self, acno):
acc = self.sql.getRec("genmst", cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acno)], limit=1)
if acc:
return acc[0]
else:
return ""
def doBestAcc(self, frt, pag, r, c, p, i, w):
if not w or self.glint == "N":
self.df.loadEntry(frt, pag, p+1, data="")
self.df.loadEntry(frt, pag, p+2, data=0)
return "sk2"
def doBankAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["genmst", "ctlctl"], cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w),
("ctl_code", "like", "bank_%"), ("ctl_cono=glm_cono",),
("ctl_conacc=glm_acno",)], limit=1)
if not acc:
return "Invalid Bank Account"
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst", where=[("tpm_tname", "=", w),
("tpm_type", "=", "R"), ("tpm_system", "=", "CRS")], limit=1)
if not acc:
return "Invalid Template"
def doEnd(self):
data = [self.opts["conum"]]
if not self.genleg:
data.extend(["N", "E", "", 0, 0])
for x, d in enumerate(self.df.t_work[0][0]):
if self.genleg and x < 9:
if x in (1, 3):
y = int((x - 1) / 2)
chk = self.sql.getRec("ctlctl", where=[("ctl_cono",
"=", self.opts["conum"]), ("ctl_code", "=",
self.ctl[y][0])], limit=1)
if chk:
self.sql.updRec("ctlctl", cols=["ctl_conacc"], data=[d],
where=[("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "=", self.ctl[y][0])])
else:
self.sql.insRec("ctlctl", data=[self.opts["conum"],
self.ctl[y][0], self.ctl[y][1], d, "", "N", "N"])
elif x in (2, 4):
continue
else:
data.append(d)
else:
data.append(d)
if self.new:
self.sql.insRec("crsctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.crsctl_col
data.append(self.acc[col.index("ctc_xflag")])
self.sql.updRec("crsctl", data=data, where=[("ctc_cono", "=",
self.opts["conum"])])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.acc):
if dat != data[num]:
self.sql.insRec("chglog", data=["crsctl", "U",
"%03i" % self.opts["conum"], col[num], dte,
self.opts["capnm"], str(dat), str(data[num]),
"", 0])
self.opts["mf"].dbm.commitDbase()
self.doExit()
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
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 wgc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"wagrcv",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
rcv = {
"stype": "R",
"tables": ("wagrcv", ),
"cols":
(("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details"))
}
self.fld = ((("T", 0, 0, 0), "IUI", 4, "Item Code", "", "", "N",
self.doCode, rcv, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 50, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )))
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)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec("wagrcv",
where=[("rcv_code", "=", self.code)],
limit=1)
if not acc:
self.new = "Y"
else:
self.new = "N"
for x in range(1, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=acc[x])
def doDelete(self):
self.sql.delRec("wagrcv", where=[("rcv_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dat = []
for x in range(0, len(self.df.t_work[0][0])):
dat.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("wagrcv", data=dat)
else:
self.sql.updRec("wagrcv",
data=dat,
where=[("rcv_code", "=", self.code)])
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()
self.opts["mf"].closeLoop()
class glc110(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlctl", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
# -------------------------------
# General Ledger Control Records
# -------------------------------
# Get Company Details
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
# Standard Controls
self.glctrl = [("bank_1", "Bank Control 1"),
("bank_2", "Bank Control 2"),
("bank_3", "Bank Control 3"),
("bank_4", "Bank Control 4"),
("bank_5", "Bank Control 5"),
("bank_6", "Bank Control 6"),
("bank_7", "Bank Control 7"),
("bank_8", "Bank Control 8"),
("bank_9", "Bank Control 9"),
("bank_10", "Bank Control 10"),
("p_cash", "Petty Cash Control"),
("crs_ctl", "Creditors Control"),
("drs_ctl", "Debtors Control"),
("ret_inc", "Retained Income"),
("vat_ctl", "VAT Control")]
# Check for Integrated Systems
mod = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
mod.append(ctlmst["ctm_modules"][x:x + 2])
# Load Systems Integration
if mod.count("AR"):
assctl = gc.getCtl("assctl", self.opts["conum"], error=False)
if assctl and assctl["cta_glint"] == "Y":
self.glctrl.extend([("ass_sls", "Sale of Assets")])
if mod.count("BK"):
bkmctl = gc.getCtl("bkmctl", self.opts["conum"], error=False)
if bkmctl and bkmctl["cbk_glint"] == "Y":
self.glctrl.extend([("bkm_ctl", "Bookings Control"),
("bkm_chq", "Cheques Received"),
("bkm_csh", "Cash Received"),
("bkm_ccg", "Cancellation Fee")])
if not mod.count("DR"):
self.glctrl.extend([("dis_all", "Discount Allowed")])
if mod.count("CR"):
crsctl = gc.getCtl("crsctl", self.opts["conum"], error=False)
if crsctl and crsctl["ctc_glint"] == "Y":
self.glctrl.extend([("dis_rec", "Discount Received")])
if mod.count("CS"):
cshctl = gc.getCtl("cshctl", self.opts["conum"], error=False)
if cshctl and cshctl["ccc_glint"] == "Y":
self.glctrl.extend([("csh_ctl", "Cash Control")])
if mod.count("DR"):
drsctl = gc.getCtl("drsctl", self.opts["conum"], error=False)
if drsctl and drsctl["ctd_glint"] == "Y":
self.glctrl.extend([("dis_all", "Discount Allowed")])
if mod.count("LN"):
lonctl = gc.getCtl("lonctl", self.opts["conum"], error=False)
if lonctl and lonctl["cln_glint"] == "Y":
self.glctrl.extend([("lon_ctl", "Loans Control"),
("int_pay", "Interest Paid"),
("int_rec", "Interest Received")])
if mod.count("ML"):
memctl = gc.getCtl("memctl", self.opts["conum"], error=False)
if memctl and memctl["mcm_glint"] == "Y":
self.glctrl.extend([("mem_ctl", "Members Control"),
("mem_pen", "Members Penalties")])
if mod.count("RC"):
rcactl = gc.getCtl("rcactl", self.opts["conum"], error=False)
if rcactl and rcactl["cte_glint"] == "Y":
self.glctrl.extend([("rca_com", "Commission Raised"),
("rca_dep", "Deposits Control"),
("rca_fee", "Contract Fees"),
("rca_own", "Owners Control"),
("rca_orx", "Owners Charges"),
("rca_tnt", "Tenants Control"),
("rca_trx", "Tenants Charges")])
if mod.count("ST"):
strctl = gc.getCtl("strctl", self.opts["conum"], error=False)
if strctl and strctl["cts_glint"] == "Y":
self.glctrl.extend([("stk_soh", "Stock on Hand"),
("stk_susp", "Stock Reconciliation")])
if mod.count("WG") or mod.count("SL"):
wagctl = gc.getCtl("wagctl", self.opts["conum"], error=False)
if wagctl and wagctl["ctw_glint"] == "Y":
self.glctrl.extend([("wag_ctl", "Salaries Control"),
("wag_slc", "Staff Loans Control"),
("wag_sli", "Staff Loans Interest")])
return True
def drawDialog(self):
ctl = {
"stype": "C",
"titl": "Select Control",
"head": ("Code", "Description"),
"typs": (("NA", 10), ("NA", 30)),
"data": self.glctrl
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
r1s = (("None", "N"), ("OFX", "O"), ("QIF", "Q"), ("S/Bank Online",
"S"))
r2s = (("None", "N"), ("CCYYMMDD", "A"), ("DDMMCCYY", "B"),
("MMDD(CC)YY", "C"))
fld = ((("T", 0, 0, 0), "INA", 10, "Code", "Control Code", "", "Y",
self.doCode, ctl, None, None), (("T", 0, 0, 25), "ONA", 30,
"Description"),
(("T", 0, 1, 0), "IUI", 7, "G/L Acc-Num", "G/L Account Number",
"", "N", self.doAccNum, glm, self.doDelete,
("notzero", )), (("T", 0, 1, 25), "ONA", 30, "Description"),
(("T", 0, 2, 0), "INA", 16, "Bank Account",
"Bank Account Number", "", "N", self.doImpBnk, None, None,
("efld", )), (("T", 0, 3, 0), ("IRB", r1s), 0, "Import Format",
"", "N", "N", self.doImpFmt, None, None, None),
(("T", 0, 4, 0), ("IRB", r2s), 0, "Date Format", "", "A", "N",
self.doDteFmt, None, None, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 3), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 3), ("T", 0, 0)),
("Print", None, self.doPrint, 0, ("T", 0, 1),
("T", 0, 2)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
d1 = ""
for ctl in self.glctrl:
if self.code in ctl:
d1 = ctl[1]
break
if not d1:
return "Invalid Control Code"
self.df.loadEntry(frt, pag, p + 1, data=d1)
self.acc = self.sql.getRec("ctlctl",
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = "y"
else:
self.new = "n"
col = self.sql.ctlctl_col
desc = self.readAcno(self.acc[col.index("ctl_conacc")])
if not desc:
desc = [""]
self.df.loadEntry(frt,
pag,
p + 2,
data=self.acc[col.index("ctl_conacc")])
self.df.loadEntry(frt, pag, p + 3, data=desc[0])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.acc[col.index("ctl_bankac")])
self.df.loadEntry(frt,
pag,
p + 5,
data=self.acc[col.index("ctl_impfmt")])
self.df.loadEntry(frt,
pag,
p + 6,
data=self.acc[col.index("ctl_dtefmt")])
def doDelete(self):
self.sql.delRec("ctlctl",
where=[("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccNum(self, frt, pag, r, c, p, i, w):
desc = self.readAcno(w)
if not desc:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=desc[0])
if self.code[:4] != "bank":
self.impfmt = "N"
self.bankac = ""
self.dtefmt = "N"
return "nd"
def readAcno(self, acno):
self.acno = acno
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acno)],
limit=1)
return acc
def doImpBnk(self, frt, pag, r, c, p, i, w):
self.bankac = w
if not self.bankac:
self.impfmt = "N"
self.dtefmt = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.impfmt)
self.df.loadEntry(frt, pag, p + 2, data=self.dtefmt)
return "sk2"
def doImpFmt(self, frt, pag, r, c, p, i, w):
self.impfmt = w
if self.impfmt == "N":
self.dtefmt = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.dtefmt)
return "nd"
self.df.loadEntry(frt, pag, p + 1, data="A")
def doDteFmt(self, frt, pag, r, c, p, i, w):
if w not in ("A", "B", "C"):
return "Invalid Date Format"
self.dtefmt = w
def doEnd(self):
data = [
self.opts["conum"], self.code, self.df.t_work[0][0][1], self.acno,
self.bankac, self.impfmt, self.dtefmt
]
if self.new == "y":
self.sql.insRec("ctlctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.ctlctl_col
data.append(self.acc[col.index("ctl_xflag")])
self.sql.updRec("ctlctl",
data=data,
where=[("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "=", self.code)])
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 doPrint(self):
table = ["ctlctl"]
heads = ["General Ledger Control Accounts"]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, "hide")
RepPrt(self.opts["mf"],
name="glc110",
tables=table,
heads=heads,
where=[("ctl_cono", "=", self.opts["conum"])],
order="ctl_code",
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bc1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "args" in self.opts:
self.tabcvt = False
self.gentab = False
self.newtab = True
self.tab = self.opts["args"]
self.df.loadEntry("T", 0, 0, data=self.tab)
self.df.topf[0][0][1] = "OUI"
self.df.topf[0][1][1] = "OUI"
self.df.focusField("T", 0, 2)
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", "bwlent", "bwlgme", "bwltab", "bwldrt", "bwlflm",
"bwlflt", "memmst", "memkon", "memadd", "memcat"
],
prog=self.__class__.__name__)
if self.sql.error:
if self.sql.error == ["memmst", "memkon"]:
self.memmst = False
else:
return
else:
self.memmst = True
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.mlint = bwlctl["ctb_mlint"]
self.samen = bwlctl["ctb_samen"]
self.mscat = bwlctl["ctb_mscat"]
self.mstart = bwlctl["ctb_mstart"]
self.fstart = bwlctl["ctb_fstart"]
self.nstart = bwlctl["ctb_nstart"]
self.dbase = bwlctl["ctb_dbase"]
self.order = bwlctl["ctb_order"]
self.mixed = bwlctl["ctb_mixed"]
self.fromad = bwlctl["ctb_emadd"]
self.keys = (("bwltab", "btb_cono", "btb_tab"), ("bwldrt", "bdt_cono",
"bdt_tab"),
("bwlent", "bce_cono", "bce_scod"), ("bwlflt", "bft_cono",
"bft_player"),
("bwlgme", "bcg_cono", "bcg_scod"), ("bwldrt", "bdt_cono",
"bdt_team1"),
("bwldrt", "bdt_cono",
"bdt_team2"), ("bwldrt", "bdt_cono", "bdt_team3"),
("bwlflt", "bft_cono", "bft_skip"), ("bwlgme", "bcg_cono",
"bcg_ocod"))
return True
def mainProcess(self):
tab = {
"stype":
"R",
"tables": ("bwltab", ),
"cols": [("btb_tab", "", 0, "Tab"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names"),
("btb_bsano", "", 0, "BSA-No")],
"where": [("btb_cono", "=", self.opts["conum"])],
"order":
"btb_surname"
}
if self.mlint == "N":
mlm = None
else:
tab["cols"].insert(3, ("btb_memno", "", 0, "Mem-No"))
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0,
"Mem-No"), ("mlm_oldno", "", 0,
"Old-No"), ("mlm_idnum", "", 0, "Identity-Numb"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names"
}
r1s = (("Male", "M"), ("Female", "F"))
if self.dbase == "R":
r2s = (("None", "0"), )
else:
r2s = (("Skip", "4"), ("Third", "3"), ("Second", "2"), ("Lead",
"1"))
fld = [(("T", 0, 0,
0), "I@btb_tab", 0, "", "", "", "Y", self.doTab, tab, None,
("efld", ), None, "Note: Tab numbers Must be Unique."),
[("T", 0, 1, 0), "I@btb_memno", 0, "", "", "", "N",
self.doMember, mlm, self.doDelete, ("efld", )],
(("T", 0, 2, 0), "I@btb_surname", 0, "", "", "", "N",
self.doSurname, None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "I@btb_names", 0, "", "", "", "N",
self.doNames, None, None, ("efld", )),
(("T", 0, 4, 0), ("IRB", r1s), 0, "Gender", "", "M", "N",
self.doGender, None, None, None),
(("T", 0, 5, 0), "I@btb_add1", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 6, 0), "I@btb_add2", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 7, 0), "I@btb_add3", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 8, 0), "I@btb_pcod", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 9, 0), "I@btb_home", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 10, 0), "I@btb_work", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 11, 0), "I@btb_cell", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 12, 0), "I@btb_mail", 0, "", "", "", "N",
self.doEmail, None, None, ("efld", )),
(("T", 0, 13, 0), ("IRB", r2s), 0, "Position - Primary", "",
"1", "N", self.doPos, None, self.doDelete, None),
(("T", 0, 14, 0), "I@btb_rate1", 0, "", "", "", "N",
self.doRate, None, None, ("efld", )),
(("T", 0, 15, 0), ("IRB", r2s), 0, "Position - Mixed", "", "1",
"N", self.doPos, None, None, None),
(("T", 0, 16, 0), "I@btb_rate2", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 17, 0), "I@btb_bsano", 0, "", "", "", "N", None, None,
None, ("efld", ))]
if self.mlint == "N":
fld[1] = [("T", 0, 1, 0), "O@btb_memno", 0, ""]
if self.mlint == "Y":
but = []
else:
but = [("Import", None, self.doImport, 0, ("T", 0, 1),
(("T", 0, 2), ("T", 0, 3)),
"Import Tabs and/or Ratings from a CSV or XLS File.")]
but.extend([("Accept", None, self.doEnd, 0, ("T", 0, 3), ("T", 0, 0),
"Accept All Fields and Continue"),
("Convert", None, self.doConvert, 0, ("T", 0, 3),
("T", 0, 4), "Convert a Visitor's Tab to a Member's Tab"),
("Print", None, self.doPrint, 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,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.col == 1:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doTab(self, frt, pag, r, c, p, i, w):
self.tab = w
self.newvis = False
self.tabcvt = False
self.tabchg = False
if not self.tab:
if self.mlint == "Y" and self.samen == "Y":
ok = askQuestion(self.opts["mf"].body,
"New Tab",
"Is this TAB for a Visitor",
default="no")
if ok == "no":
return "New Member, Please Create in Ledger"
self.newvis = True
self.gentab = True
self.newtab = True
else:
self.gentab = False
self.oldtab = self.sql.getRec("bwltab",
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_tab", "=", self.tab)],
limit=1)
if not self.oldtab:
self.newtab = True
else:
self.newtab = False
for num, fld in enumerate(self.oldtab[1:-1]):
if num == 2:
self.snam = fld
elif num == 3:
self.fnam = fld
elif num == 4:
self.gender = fld
elif num in (13, 15):
fld = str(fld)
if num == 13:
self.pos1 = fld
self.df.loadEntry(frt, pag, num, data=fld)
if self.tab and self.mlint == "Y":
if self.oldtab:
memno = self.oldtab[self.sql.bwltab_col.index("btb_memno")]
elif self.tab < self.nstart and self.samen == "Y":
memno = self.tab
else:
memno = 0
else:
memno = 0
if memno:
chk = self.doLoadMember(memno)
if chk:
return chk
if self.dbase == "R":
return "sk13"
return "sk12"
if self.newvis or self.tab >= self.nstart:
return "sk1"
def doMember(self, frt, pag, r, c, p, i, w):
if w:
if self.newtab or not self.oldtab[2]:
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_memno", "=", w)],
limit=1)
if chk:
return "Member Already Has a TAB"
chk = self.doLoadMember(w)
if chk:
return chk
if self.newtab and not self.tab:
chk = self.getNextTab()
if not chk:
return "Invalid Membership Number"
if self.dbase == "R":
return "sk12"
return "sk11"
elif self.tab and self.tab < self.nstart and self.mlint == "Y":
return "Invalid Membership Number"
def doLoadMember(self, memno):
# Check member
acc = self.sql.getRec("memmst",
cols=["mlm_surname", "mlm_names", "mlm_gender"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", memno)],
limit=1)
if not acc:
return "Member %s Does Not Exist" % memno
# Check category
if self.mscat:
cat = self.sql.getRec("memcat",
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", memno),
("mlc_type", "=", "C"),
("mlc_code", "=", self.mscat)],
limit=1)
if not cat:
return "Member %s is Not in the Bowls Category" % memno
self.snam = acc[0]
self.fnam = acc[1]
self.gender = acc[2]
self.df.loadEntry("T", 0, 1, data=memno)
self.df.loadEntry("T", 0, 2, data=self.snam)
self.df.loadEntry("T", 0, 3, data=self.fnam)
self.df.loadEntry("T", 0, 4, data=self.gender)
for typ in ("A", "P"):
ad = self.sql.getRec(
"memadd",
cols=["mla_add1", "mla_add2", "mla_add3", "mla_code"],
where=[("mla_cono", "=", self.opts["conum"]),
("mla_memno", "=", memno), ("mla_type", "=", typ)],
limit=1)
if ad:
break
if ad:
self.df.loadEntry("T", 0, 5, data=ad[0])
self.df.loadEntry("T", 0, 6, data=ad[1])
self.df.loadEntry("T", 0, 7, data=ad[2])
self.df.loadEntry("T", 0, 8, data=ad[3])
for num, cod in enumerate((1, 2, 3, 5)):
kk = self.sql.getRec("memkon",
cols=["mlk_detail"],
where=[("mlk_cono", "=", self.opts["conum"]),
("mlk_memno", "=", memno),
("mlk_code", "=", cod)],
limit=1)
if kk:
self.df.loadEntry("T", 0, num + 9, data=kk[0])
def doSurname(self, frt, pag, r, c, p, i, w):
self.sname = w
def doNames(self, frt, pag, r, c, p, i, w):
if self.newtab:
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_surname", "=", self.sname,
"and", "btb_names", "=", w)],
limit=1)
if chk:
tab = chk[self.sql.bwltab_col.index("btb_tab")]
self.doTab(frt, pag, 0, 1, 0, 0, tab)
return "ff3"
if self.mstart < self.fstart and self.tab >= self.fstart:
self.df.loadEntry(frt, pag, p + 1, data="F")
elif self.fstart < self.mstart and self.tab < self.mstart:
self.df.loadEntry(frt, pag, p + 1, data="F")
return
if self.sname != self.snam or w != self.fnam:
but = [("Amendment", "A"), ("Re-Issue", "R"), ("Neither", "N")]
ok = askChoice(self.opts["mf"].body,
"Name Change",
"Please Select the Reason for the Name Change",
butt=but,
default="Neither")
if ok == "N":
return "ff3"
if ok == "R":
self.tabchg = True
for x in range(1, 15):
self.df.clearEntry(frt, pag, c + x)
def doGender(self, frt, pag, r, c, p, i, w):
self.gender = w
if self.gentab:
chk = self.getNextTab()
if not chk:
return "ff2|Invalid Membership Number"
if self.tab < self.nstart:
if self.mstart < self.fstart:
if self.gender == "M" and self.tab >= self.fstart:
return "ff5|Invalid Gender for Tab Number"
elif self.gender == "F" and self.tab < self.fstart:
return "ff5|Invalid Gender for Tab Number"
else:
if self.gender == "F" and self.tab >= self.mstart:
return "ff5|Invalid Gender for Tab Number"
elif self.gender == "M" and self.tab < self.mstart:
return "ff5|Invalid Gender for Tab Number"
def doEmail(self, frt, pag, r, c, p, i, w):
if self.dbase in ("C", "P") and self.df.t_work[0][0][13] == "0":
self.df.t_work[0][0][13] = "1"
if self.dbase == "R":
self.pos1 = "0"
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
return "sk1"
def doPos(self, frt, pag, r, c, p, i, w):
if p == 13:
self.pos1 = w
self.df.loadEntry(frt, pag, p + 2, data=w)
if self.dbase == "P":
self.df.loadEntry(frt, pag, p + 1, data="")
if p == 13:
self.df.loadEntry(frt, pag, p + 3, data="")
if self.mixed == "N":
return "sk3"
else:
return "sk1"
def doRate(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p + 1, data=self.pos1)
self.df.loadEntry(frt, pag, p + 2, data=w)
if self.dbase == "R":
self.df.loadEntry(frt, pag, p + 1, data="")
if self.mixed == "N":
return "sk2"
else:
return "sk1"
if self.mixed == "N":
return "sk2"
def getNextTab(self):
if self.newvis:
ok = "yes"
else:
ok = askQuestion(self.opts["mf"].body,
"Type",
"Is this TAB for a Visitor",
default="no")
if ok == "no":
if self.samen == "Y":
return
if self.gender == "M":
start = self.mstart
if self.mstart < self.fstart:
last = self.fstart
else:
last = self.nstart
else:
start = self.fstart
if self.mstart < self.fstart:
last = self.nstart
else:
last = self.mstart
else:
start = self.nstart
last = 900000
self.tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])],
start=start,
last=last)
self.df.loadEntry("T", 0, 0, data=self.tab)
return True
def doDelete(self):
if self.newtab:
return
error = False
for key in self.keys:
if key[0] == "bwltab":
continue
chk = self.sql.getRec(tables=key[0],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.tab)],
limit=1)
if chk:
error = True
break
if error:
if self.tab < self.nstart:
# Member
ok = askQuestion(self.opts["mf"].body,
"Convert",
"Convert this Member to a Visitor",
default="yes")
if ok == "no":
return "Not Deleted nor Converted"
tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])
],
start=self.nstart,
last=900000)
for key in self.keys:
self.sql.updRec(key[0],
cols=[key[2]],
data=[tab],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.tab)])
else:
# Visitor
chk = self.sql.getRec("bwlent",
where=[("bce_cono", "=",
self.opts["conum"]),
("bce_scod", "=", self.tab)])
if chk:
return "There is History for this Player, Not Deleted"
self.sql.delRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
else:
self.sql.delRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
self.opts["mf"].dbm.commitDbase()
def doConvert(self):
titl = "Enter Member's Tab Number"
ent = SimpleDialog(parent=self.df.window,
title=titl,
cols=(("a", "Tab Number ", 6, "UI",
"Tab"), ))
ent.sframe.wait_window()
try:
self.merge = False
if self.gender == "M":
start = self.mstart
if self.mstart < self.fstart:
last = self.fstart - 1
else:
last = self.nstart - 1
else:
start = self.fstart
if self.mstart < self.fstart:
last = self.nstart - 1
else:
last = self.mstart - 1
tab = ent.data[0]
if not tab:
tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])
],
start=start,
last=last)
if tab < start or tab > last:
showInfo(self.opts["mf"].body, "Error",
"Invalid Tab Number for Gender")
raise Exception
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", tab)],
limit=1)
if chk:
ok = askQuestion(
self.opts["mf"].body, "Invalid",
"This Tab is Already Allocated, Do You Want to Merge?")
if ok == "no":
raise Exception
self.merge = True
self.tabcvt = True
self.old = self.tab
self.tab = tab
self.df.loadEntry(self.df.frt, self.df.pag, 0, data=self.tab)
self.df.focusField(self.df.frt, self.df.pag, 6)
except:
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")
if self.mlint == "Y":
self.colsd = [["Membership Number", "N", "btb_memno"]]
else:
self.colsd = []
self.colsd.extend([["Surname & Initials", "Y", "name"],
["Surname", "N", "btb_surname"],
["First Names", "N", "btb_names"],
["Gender", "N", "btb_gender"],
["Address", "N", "address"],
["Telephone - Home", "N", "btb_home"],
["Telephone - Work", "N", "btb_work"],
["Telephone - Cell", "N", "btb_cell"],
["Email Address", "N", "btb_mail"],
["Ratings", "N", "ratings"],
["BSA Number", "N", "btb_bsano"],
["Order", "T", "order"]])
r1s = (("Members", "M"), ("Guests", "G"), ("All", "A"))
r2s = (("Males", "M"), ("Females", "F"), ("All", "A"))
r3s = (("Yes", "Y"), ("No", "N"))
r4s = (("Tab", "T"), ("Surname", "S"), ("Rating", "R"))
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Tab Group", "", "M", "Y",
self.doCGroup, None, None, None),
(("T", 0, 1, 0), ("IRB", r2s), 0, "Gender", "", "A", "Y",
self.doCGender, None, None, None)]
idx = 1
for dat in self.colsd:
idx += 1
if dat == self.colsd[-1]:
rb = r4s
else:
rb = r3s
fld.append((("T", 0, idx, 0), ("IRB", rb), 0, dat[0], "", dat[1],
"N", self.doCField, None, None, None))
tnd = ((self.doCEnd, "Y"), )
txt = (self.doCExit, )
self.pr = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "Y"))
self.pr.mstFrame.wait_window()
if self.cols:
cols = []
dic = self.sql.bwltab_dic
for col in self.cols:
if col == "name":
cols.append(["name", "NA", 30, "Name"])
elif col == "address":
cols.append([
"btb_add1", dic["btb_add1"][2], dic["btb_add1"][3],
dic["btb_add1"][5]
])
cols.append([
"btb_add2", dic["btb_add2"][2], dic["btb_add2"][3],
dic["btb_add2"][5]
])
cols.append([
"btb_add3", dic["btb_add3"][2], dic["btb_add3"][3],
dic["btb_add3"][5]
])
cols.append([
"btb_pcod", dic["btb_pcod"][2], dic["btb_pcod"][3],
dic["btb_pcod"][5]
])
elif col == "ratings":
if self.dbase == "P":
cols.append([
"btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3],
dic["btb_pos1"][5]
])
cols.append([
"btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3],
dic["btb_pos2"][5]
])
elif self.dbase == "R":
cols.append([
"btb_rate1", dic["btb_rate1"][2],
dic["btb_rate1"][3], dic["btb_rate1"][5]
])
cols.append([
"btb_rate2", dic["btb_rate2"][2],
dic["btb_rate2"][3], dic["btb_rate2"][5]
])
else:
cols.append([
"btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3],
dic["btb_pos1"][5]
])
cols.append([
"btb_rate1", dic["btb_rate1"][2],
dic["btb_rate1"][3], dic["btb_rate1"][5]
])
cols.append([
"btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3],
dic["btb_pos2"][5]
])
cols.append([
"btb_rate2", dic["btb_rate2"][2],
dic["btb_rate2"][3], dic["btb_rate2"][5]
])
else:
cols.append([col, dic[col][2], dic[col][3], dic[col][5]])
whr = [("btb_cono", "=", self.opts["conum"])]
if self.cgroup == "M":
whr.append(("btb_tab", "<", self.nstart))
elif self.cgroup == "G":
whr.append(("btb_tab", ">=", self.nstart))
if self.cgender in ("F", "M"):
whr.append(("btb_gender", "=", self.cgender))
if self.odr == "T":
odr = "btb_tab"
elif self.odr == "S":
odr = "btb_surname, btb_names"
else:
odr = "btb_pos1 desc, btb_rate1 desc, btb_surname, btb_names"
recs = self.sql.getRec("bwltab", where=whr, order=odr)
data = []
btc = self.sql.bwltab_col
for rec in recs:
dat = []
for col in self.cols:
if col == "name":
snam = rec[btc.index("btb_surname")]
fnam = rec[btc.index("btb_names")]
if fnam:
fnam = fnam.split()
for num, nam in enumerate(fnam):
if not num:
init = nam[0].upper()
else:
init = "%s %s" % (init, nam[0].upper())
dat.append("%s, %s" % (snam, init))
else:
dat.append(snam)
elif col == "address":
dat.append(rec[btc.index("btb_add1")])
dat.append(rec[btc.index("btb_add2")])
dat.append(rec[btc.index("btb_add3")])
dat.append(rec[btc.index("btb_pcod")])
elif col == "ratings":
if self.dbase == "P":
dat.append(rec[btc.index("btb_pos1")])
dat.append(rec[btc.index("btb_pos2")])
elif self.dbase == "R":
dat.append(rec[btc.index("btb_rate1")])
dat.append(rec[btc.index("btb_rate2")])
else:
dat.append(rec[btc.index("btb_pos1")])
dat.append(rec[btc.index("btb_rate1")])
dat.append(rec[btc.index("btb_pos2")])
dat.append(rec[btc.index("btb_rate2")])
else:
dat.append(rec[btc.index(col)])
data.append(dat)
tit = "Tabs Lising for"
if self.cgroup == "A":
tit = "%s Members and Guests" % tit
elif self.cgroup == "M":
tit = "%s Members Only" % tit
else:
tit = "%s Guests Only" % tit
if self.cgender == "A":
tit = "%s (All Genders)" % tit
elif self.cgender == "M":
tit = "%s (Males Only)" % tit
else:
tit = "%s (Females Only)" % tit
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
conum=self.opts["conum"],
conam=self.opts["conam"],
heads=[tit],
ttype="D",
tables=data,
cols=cols,
repprt=self.pr.repprt,
repeml=self.pr.repeml,
fromad=self.fromad)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.window.focus_force()
self.df.focusField("T", 0, 1)
def doCGroup(self, frt, pag, r, c, p, i, w):
self.cgroup = w
def doCGender(self, frt, pag, r, c, p, i, w):
self.cgender = w
def doCField(self, frt, pag, r, c, p, i, w):
if self.mlint == "N":
idx = 2
else:
idx = 3
if p == idx and w == "Y":
self.pr.loadEntry(frt, pag, p + 1, data="N")
self.pr.loadEntry(frt, pag, p + 2, data="N")
return "sk2"
def doCEnd(self):
self.pr.closeProcess()
self.cols = ["btb_tab"]
if self.pr.repeml[0] == "N":
end = -2
else:
end = -4
for num, dat in enumerate(self.pr.t_work[0][0][2:end]):
if dat == "Y":
self.cols.append(self.colsd[num][2])
elif dat in ("T", "S", "R"):
self.odr = dat
def doCExit(self):
self.cols = []
self.pr.closeProcess()
def doEnd(self):
if self.tabcvt:
# Conversion to Member
for key in self.keys:
if key[0] == "bwltab" and self.merge:
self.sql.delRec(key[0],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.old)])
continue
self.sql.updRec(key[0],
cols=[key[2]],
data=[self.tab],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.old)])
# Continue
cols = []
for x in range(18):
cols.append(x)
if self.dbase == "R":
cols.remove(13)
cols.remove(15)
flds = ("T", 0, cols)
frt, pag, col, mes = self.df.doCheckFields(flds)
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
return
tabdat = [self.opts["conum"]] + self.df.t_work[0][0]
if self.newtab:
self.sql.insRec("bwltab", data=tabdat)
elif self.tabchg:
tabdat.append("")
self.doTabChg(tabdat)
elif tabdat != self.oldtab[:len(tabdat)]:
col = self.sql.bwltab_col
tabdat.append(self.oldtab[col.index("btb_xflag")])
self.sql.updRec("bwltab",
data=tabdat,
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldtab):
if dat != tabdat[num]:
self.sql.insRec(
"chglog",
data=[
"bwltab", "U",
"%03i%06s" % (self.opts["conum"], self.tab),
col[num], dte, self.opts["capnm"],
str(dat),
str(tabdat[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
if "args" in self.opts:
self.doExit()
else:
self.df.focusField("T", 0, 1)
def doTabChg(self, tabdat):
code = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])],
start=self.nstart,
last=900000)
tables = (("bwldrt", "bdt_cono", "bdt_tab", "bdt_team1", "bdt_team2",
"bdt_team3"), ("bwlent", "bce_cono", "bce_scod"),
("bwlflm", "bfm_cono", "bfm_captain"),
("bwlflt", "bft_cono", "bft_skip", "bft_player"),
("bwlgme", "bcg_cono", "bcg_scod",
"bcg_ocod"), ("bwltab", "btb_cono", "btb_tab"))
for tab in tables:
for col in tab[2:]:
self.sql.updRec(tab[0],
cols=[col],
data=[code],
where=[(tab[1], "=", self.opts["conum"]),
(col, "=", self.tab)])
self.sql.insRec("bwltab", data=tabdat)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Import Details", )
r1s = (("Ratings Only", "R"), ("All Fields", "A"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Details", "", "R", "N",
self.doImpDet, None, None, None), )
self.ip = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doImpEnd, "y"), ),
txit=(self.doImpExit, ))
self.ip.mstFrame.wait_window()
# Populate
if self.impdet is None:
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)
return
fi = FileImport(self.opts["mf"], imptab="bwltab", impskp=self.impskp)
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Ratings",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if self.mixed == "N":
line.extend([0, ""])
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", line[0])],
limit=1)
if not chk:
if self.impdet == "R":
err = "%s %s Does Not Exist" % (fi.impcol[0][0], line[0])
break
line.insert(0, self.opts["conum"])
if self.mlint == "N":
line.insert(2, 0)
self.sql.insRec("bwltab", data=line)
else:
tmp = ["btb_pos1", "btb_rate1", "btb_pos2", "btb_rate2"]
if self.impdet == "R":
cols = tmp
else:
cols = [
"btb_surname", "btb_names", "btb_gender", "btb_add1",
"btb_add2", "btb_add3", "btb_pcod", "btb_home",
"btb_work", "btb_cell", "btb_mail"
] + tmp + ["btb_bsano"]
self.sql.updRec("bwltab",
cols=cols,
data=line[1:],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", line[0])])
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.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doImpDet(self, frt, pag, r, c, p, i, w):
self.impdet = w
def doImpEnd(self):
self.impskp = ["btb_cono"]
if self.mlint == "N":
self.impskp.append("btb_memno")
if self.impdet == "R":
self.impskp.extend([
"btb_surname", "btb_names", "btb_gender", "btb_add1",
"btb_add2", "btb_add3", "btb_pcod", "btb_home", "btb_work",
"btb_cell", "btb_mail", "btb_bsano"
])
if self.mixed == "N":
self.impskp.extend(["btb_pos2", "btb_rate2"])
self.impskp.append("btb_xflag")
self.ip.closeProcess()
def doImpExit(self):
self.impdet = None
self.ip.closeProcess()
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class stc110(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
mods = ctlmst["ctm_modules"]
self.genleg = False
self.slspos = False
for x in range(0, len(mods), 2):
if mods[x:x + 2] == "GL":
self.genleg = True
elif mods[x:x + 2] == "PS":
self.slspos = True
tabs = [
"strctl", "strloc", "strgmu", "strcmu", "strprc", "tplmst",
"chglog"
]
if self.genleg:
tabs.extend(["ctlctl", "genmst"])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.acc = self.sql.getRec("strctl",
where=[("cts_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [
self.opts["conum"], "N", "N", 1, "N", "purchase_order", "", ""
]
else:
self.new = False
if self.genleg:
self.ctl = [["stk_soh", "Stock on Hand", 0],
["stk_susp", "Stock Reconciliation", 0]]
if self.slspos:
self.ctl.extend([["pos_cash", "Cash Takings", 0],
["pos_card", "Card Takings", 0],
["pos_vchr", "Vouchers", 0]])
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
for num, ctl in enumerate(self.ctl):
if ctl[0] in ctlctl:
self.ctl[num][2] = ctlctl[ctl[0]]
self.locs = self.acc[self.sql.strctl_col.index("cts_locs")]
return True
def drawDialog(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")),
"where": [("tpm_type", "=", "O"), ("tpm_system", "=", "STR")],
"order":
"tpm_tname"
}
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("No", "N"), ("Last Cost", "L"), ("Average Cost", "A"))
if self.genleg:
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30,
"Description")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "",
self.acc[1], "N", self.doGlint, None, None, None),
(("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "",
self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 1, 0), "ONA", 30, ""),
(("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "",
self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 2, 0), "ONA", 30, "")]
if self.slspos:
fld.extend([(("T", 0, 3,
0), "IUI", 7, self.ctl[2][1], "", self.ctl[2][2],
"N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4,
0), "IUI", 7, self.ctl[3][1], "", self.ctl[3][2],
"N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 4, 0), "ONA", 30, ""),
(("T", 0, 5,
0), "IUI", 7, self.ctl[4][1], "", self.ctl[4][2],
"N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 5, 0), "ONA", 30, "")])
seq = 6
else:
seq = 3
else:
fld = []
seq = 0
fld.extend([(("T", 0, seq, 0), ("IRB", r1s), 0, "Multiple Locations",
"", self.acc[2], "N", self.doLocs, None, None, None),
(("T", 0, seq + 1, 0), "IUI", 1, "Number of Price Levels",
"", self.acc[3], "N", None, None, None, ("between", 1,
5)),
(("T", 0, seq + 2, 0), ("IRB", r2s), 0, "Automatic Markup",
"", self.acc[4], "N", None, None, None, None, None,
"Calculate Selling Prices Based on Markup Percentages"),
(("T", 0, seq + 3, 0), "INA", 20, "Orders Template", "",
self.acc[5], "N", self.doTplNam, tpm, None, None),
(("T", 0, seq + 4, 0), "ITX", 50, "Email Address", "",
self.acc[6], "N", None, None, None, ("email", ))])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 1), ("T", 0, 0)),
("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if not self.new:
s = 0
for n, f in enumerate(self.acc[1:-1]):
if not self.genleg and not n:
continue
self.df.loadEntry("T", 0, s, data=f)
s += 1
if not n:
for c in self.ctl:
self.df.loadEntry("T", 0, s, data=c[2])
s += 1
self.df.loadEntry("T", 0, s, data=self.getDes(c[2]))
s += 1
self.df.focusField("T", 0, 1, clr=False)
def doGlint(self, frt, pag, r, c, p, i, w):
if self.slspos:
idx = 11
skp = "sk10"
else:
idx = 5
skp = "sk4"
if w == "N":
for x in range(1, idx):
self.df.loadEntry(frt, pag, p + x, data="")
return skp
def doGenAcc(self, frt, pag, r, c, p, i, w):
des = self.getDes(w)
if not des:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=des)
def getDes(self, acno):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acno)],
limit=1)
if acc:
return acc[0]
else:
return ""
def doLocs(self, frt, pag, r, c, p, i, w):
self.locs = w
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "O"),
("tpm_system", "=", "STR")],
limit=1)
if not acc:
return "Invalid Template Name"
def doEnd(self):
data = [self.opts["conum"]]
if not self.genleg:
data.append("N")
if self.genleg:
if self.slspos:
idx = 11
pos = (1, 3, 5, 7, 9)
else:
idx = 5
pos = (1, 3)
for x, d in enumerate(self.df.t_work[0][0]):
if x and self.genleg and x < idx:
if x in pos:
y = int((x - 1) / 2)
chk = self.sql.getRec("ctlctl",
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])],
limit=1)
if chk:
self.sql.updRec("ctlctl",
cols=["ctl_conacc"],
data=[d],
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])])
else:
self.sql.insRec("ctlctl",
data=[
self.opts["conum"], self.ctl[y][0],
self.ctl[y][1], d, "", "N", "N"
])
else:
continue
else:
data.append(d)
if self.new:
self.sql.insRec("strctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.strctl_col
data.append(self.acc[col.index("cts_xflag")])
self.sql.updRec("strctl",
data=data,
where=[("cts_cono", "=", self.opts["conum"])])
# Check and Fix Markup prices
plevs = data[self.sql.strctl_col.index("cts_plevs")]
automu = data[self.sql.strctl_col.index("cts_automu")]
if automu in ("A", "L"):
grps = self.sql.getRec("strgrp",
cols=["gpm_group"],
where=[("gpm_cono", "=",
self.opts["conum"])])
for grp in grps:
for lvl in range(1, plevs + 1):
self.sql.delRec("strcmu",
where=[("smc_cono", "=",
self.opts["conum"]),
("smc_group", "=", grp[0]),
("smc_level", "=", lvl),
("smc_markup", "=", 0)])
gmu = self.sql.getRec("strgmu",
cols=["smg_markup"],
where=[("smg_cono", "=",
self.opts["conum"]),
("smg_group", "=",
grp[0]),
("smg_level", "=", lvl)],
limit=1)
if gmu:
if not gmu[0]:
self.sql.delRec("strgmu",
where=[
("smg_cono", "=",
self.opts["conum"]),
("smg_group", "=", grp[0]),
("smg_level", "=", lvl)
])
self.sql.delRec("strcmu",
where=[("smc_cono", "=",
self.opts["conum"]),
("smc_group", "=", grp[0]),
("smc_level", "=", lvl),
("smc_markup", "=", gmu[0])
])
self.sql.delRec("strprc",
where=[("stp_cono", "=", self.opts["conum"])])
# Chglog
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.acc):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"strctl", "U",
"%03i" % self.opts["conum"], col[num],
dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if self.locs == "N":
acc = self.sql.getRec("strloc",
cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", "1")],
limit=1)
if not acc:
self.sql.insRec("strloc",
data=[
self.opts["conum"], "1",
"Location Number One", "", "", "", ""
])
self.opts["mf"].dbm.commitDbase()
self.doExit()
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class wg1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctldep", "chglog", "wagbal",
"wagcap", "wagcod", "wagedc", "wagmst", "wagtf1", "wagtf2",
"waglmf", "wagltf"], prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
wgm = {
"stype": "R",
"tables": ("wagmst",),
"cols": (
("wgm_empno", "", 0, "EmpNo"),
("wgm_sname", "", 0, "Surname", "Y"),
("wgm_fname", "", 0, "Names"),
("wgm_freq", "", 0, "F"),
("wgm_start", "", 0, "Start-Date"),
("wgm_term", "", 0, "Term-Date")),
"where": [("wgm_cono", "=", self.opts["conum"])]}
dep = {
"stype": "R",
"tables": ("ctldep",),
"cols": (
("dep_code", "", 0, "Dep"),
("dep_name", "", 0, "Name", "Y")),
"where": [("dep_cono", "=", self.opts["conum"])]}
wec = {
"stype": "R",
"tables": ("wagedc",),
"cols": (
("ced_code", "", 0, "Code"),
("ced_desc", "", 0, "Description", "Y")),
"where": [
("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "E")]}
wdc = {
"stype": "R",
"tables": ("wagedc",),
"cols": (
("ced_code", "", 0, "Code"),
("ced_desc", "", 0, "Description", "Y")),
"where": [
("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D")]}
r1s = (("Weekly","W"),("2xWeekly","F"),("Monthly ","M"))
r2s = (("Cash ","C"),("Cheque ","Q"),("Electronic","E"))
r3s = (("Yes","Y"),("No","N"))
r4s = (("Current","1"),("Transmission","2"),("Savings","3"))
fld = (
(("T",0,0,0),"IUI",5,"Emp-Num","Employee Number",
"","Y",self.doEmpNum,wgm,None,("notzero",)),
(("T",0,0,0),"IUI",3,"Department","",
"","N",self.doDept,dep,None,None),
(("T",0,0,0),"IUI",1,"Class","",
"","N",None,None,None,None),
(("T",1,0,0),"INA",30,"Surname","",
"","N",None,None,None,("notblank",)),
(("T",1,1,0),"INA",30,"Names","",
"","N",None,None,None,("notblank",)),
(("T",1,2,0),"ID1",10,"Date of Birth","",
"","N",self.doDOB,None,None,("efld",)),
(("T",1,3,0),"INA",13,"ID Number","",
"","N",self.doIdNo,None,None,("idno",)),
(("T",1,4,0),"INA",16,"Spouse Name","",
"","N",None,None,None,None),
(("T",1,5,0),"INA",13,"Spouse ID Number","",
"","N",self.doIdNo,None,None,("idno",)),
(("T",1,6,0),"INA",30,"Address Line 1","",
"","N",None,None,None,("notblank",)),
(("T",1,7,0),"INA",30,"Address Line 2","",
"","N",None,None,None,None),
(("T",1,8,0),"INA",30,"Address Line 3","",
"","N",None,None,None,None),
(("T",1,9,0),"INA",4,"Postal Code","",
"","N",None,None,None,("notblank",)),
(("T",1,10,0),"INA",16,"Telephone Number","",
"","N",None,None,None,None),
(("T",1,11,0),"ITX",50,"E-Mail Address","",
"","N",None,None,None,("email",)),
(("T",1,12,0),"ID1",10,"Start Date","",
"","N",None,None,None,("efld",)),
(("T",1,13,0),"IUD",10.2,"Salary/Rate","",
"","N",None,None,None,("efld",)),
(("T",1,14,0),("IRB",r1s),0,"Pay Freq","Pay Frequency",
"M","N",None,None,None,None),
(("T",1,15,0),("IRB",r2s),0,"Pay Type","",
"E","N",self.doPayTyp,None,None,None),
(("T",2,0,0),("IRB",r3s),0,"P.A.Y.E.","",
"Y","N",None,None,None,None),
(("T",2,1,0),"INA",16,"Tax Office","",
"","N",None,None,None,None),
(("T",2,2,0),"INA",10,"Tax Number","",
"","N",None,None,None,None),
(("T",2,3,0),"IUA",1,"Nature of Employee","",
"A","N",None,None,None,("notblank",)),
(("T",2,4,0),"IUI",9,"Reg Number","Registration Number",
"","N",None,None,None,None),
(("T",2,5,0),"IUA",1,"Voluntary Excess","",
"N","N",None,None,None,None),
(("T",2,6,0),"IUD",6.2,"Fixed Rate","",
"","N",None,None,None,None),
(("T",2,7,0),"INA",13,"Directive","",
"","N",None,None,None,None),
(("T",3,0,0),("IRB",r4s),0,"Account Type","Bank Account Type",
"1","N",None,None,None,None),
(("T",3,1,0),"INA",30,"Bank Name","",
"","N",self.doBankNam,None,None,None),
(("T",3,2,0),"IUI",8,"Branch Code","Bank Branch Code",
"","N",self.doBankBch,None,None,None),
(("T",3,3,0),"INA",16,"Account Number","Bank Account Number",
"","N",self.doBankAcc,None,None,None),
(("T",3,4,0),"INA",30,"Account Holder's Name","",
"","N",self.doHolderNam,None,None,None),
(("T",3,5,0),"IUI",1,"Holder's Relationship","",
"","N",self.doHolderRel,None,None,None),
(("C",4,0,0),"IUI",3,"Cod","Earnings Code",
"","N",self.doEarnCod,wec,None,("efld",)),
(("C",4,0,1),"ONA",30,"Description"),
(("C",4,0,2),"ISD",13.2,"Amnt/Rate","Amount or Rate",
"","N",self.doEarnAmt,None,self.doCodeDelete,("efld",)),
(("C",5,0,0),"IUI",3,"Cod","Deduction Code",
"","N",self.doDedCod,wdc,None,("efld",)),
(("C",5,0,1),"ONA",30,"Description"),
(("C",5,0,2),"ISD",13.2,"Amnt/Rate","Employees Amount or Rate",
"","N",self.doDedEAmt,None,self.doCodeDelete,("efld",)),
(("C",5,0,3),"ISD",13.2,"Amnt/Rate","Employers Amount or Rate",
"","N",self.doDedRAmt,None,None,("efld",)),
(("T",6,0,0),"ISD",13.2,"Balance-1","",
"","N",None,None,None,("efld",)),
(("T",6,1,0),"ISD",13.2,"Balance-2","",
"","N",None,None,None,("efld",)),
(("T",6,2,0),"ISD",13.2,"Balance-3","",
"","N",None,None,None,("efld",)))
tag = (
("General",None,("T",0,0),("T",0,1)),
("Tax",None,("T",0,0),("T",0,1)),
("Bank",None,("T",0,0),("T",0,1)),
("Earnings",None,("T",0,0),("T",0,1)),
("Deductions",None,("T",0,0),("T",0,1)),
("Balances",None,("T",0,0),("T",0,1)))
tnd = (
(self.doEnd, "n"),
(self.doEnd, "n"),
(self.doEnd, "n"),
(self.doEnd, "n"),
None,
None,
(self.doEnd, "y"))
txt = (
self.doExit,
self.doExit,
self.doExit,
self.doExit,
None,
None,
self.doExit)
cnd = (
None,
None,
None,
None,
(self.doEndEarn, "y"),
(self.doEndDed, "y"),
None)
cxt = (
None,
None,
None,
None,
self.doExit,
self.doExit,
None)
but = (
("Accept",None,self.doAccept,0,("T",0,2),("T",0,1)),
("Print",None,self.doPrint,0,("T",0,2),("T",0,0)),
("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0)),
("Quit",None,self.doCloseProcess,1,None,None))
row = [0,0,0,0,15,15,0]
self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag,
rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.pag == 0:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doEmpNum(self, frt, pag, r, c, p, i, w):
self.empno = w
self.oldm = self.sql.getRec("wagmst", where=[("wgm_cono", "=",
self.opts["conum"]), ("wgm_empno", "=", self.empno)], limit=1)
self.oldb = self.sql.getRec("wagbal", where=[("wbl_cono", "=",
self.opts["conum"]), ("wbl_empno", "=", self.empno)],
order="wbl_balno")
if not self.oldm:
self.new = True
self.term = 0
self.ptyp = ""
else:
self.new = False
self.term = self.oldm[len(self.oldm)-1]
d = 1
for pg in range(0, self.df.pgs):
for x in range(0, self.df.topq[pg]):
self.df.loadEntry("T", pg, x, data=self.oldm[d])
d = d + 1
self.ptyp = self.df.t_work[1][0][15]
self.doLoadEarnDed("E")
self.doLoadEarnDed("D")
if self.oldb:
for b in self.oldb:
self.df.loadEntry("T", 6, b[2]-1, data=b[3])
def doDept(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctldep", cols=["dep_name"],
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", w)], limit=1)
if not acc:
return "Invalid Department"
self.dept = w
def doDOB(self, frt, pag, r, c, p, i, w):
self.dob = w
def doIdNo(self, frt, pag, r, c, p, i, w):
if p == 6:
a = int(int(w) / 10000000)
b = int(self.dob % 1000000)
if a != b:
return "ID Number Does Not Agree with Birth Date"
def doPayTyp(self, frt, pag, r, c, p, i, w):
self.ptyp = w
def doBankNam(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Bank Name"
def doBankBch(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Branch"
def doBankAcc(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Account"
def doHolderNam(self, frt, pag, r, c, p, i, w):
self.holnam = w
def doHolderRel(self, frt, pag, r, c, p, i, w):
self.holrel = w
def doEnd(self):
if self.df.pag == 0:
self.df.focusField("T", 1, 1)
elif self.df.pag == 1:
self.df.selPage("Tax")
self.df.focusField("T", 2, 1)
elif self.df.pag == 2:
self.df.selPage("Bank")
self.df.focusField("T", 3, 1)
elif self.df.pag == 3:
self.df.selPage("Earnings")
elif self.df.pag == 6:
self.doAccept()
def doEarnCod(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("wagedc", cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=",
"E"), ("ced_code", "=", w)], limit=1)
if not desc:
return "Invalid Code"
self.code = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=",
self.empno), ("wcd_type", "=", "E"), ("wcd_code", "=", w)],
limit=1)
if not code:
self.ncod = "y"
else:
self.ncod = "n"
self.df.loadEntry(frt, pag, p+2, data=code[0])
def doEarnAmt(self, frt, pag, r, c, p, i, w):
self.eamt = w
self.ramt = 0
def doEndEarn(self):
self.doEndCode("E")
def doDedCod(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("wagedc", cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=",
"D"), ("ced_code", "=", w)], limit=1)
if not desc:
return "Invalid Code"
self.code = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=",
self.empno), ("wcd_type", "=", "D"), ("wcd_code", "=", w)],
limit=1)
if not code:
self.ncod = "y"
else:
self.ncod = "n"
self.df.loadEntry(frt, pag, p+2, data=code[0])
self.df.loadEntry(frt, pag, p+3, data=code[1])
def doDedEAmt(self, frt, pag, r, c, p, i, w):
self.eamt = w
def doDedRAmt(self, frt, pag, r, c, p, i, w):
self.ramt = w
def doEndDed(self):
self.doEndCode("D")
def doEndCode(self, rtype):
if self.ncod == "y":
self.sql.insRec("wagcod", data=[self.opts["conum"],
self.empno, rtype, self.code, self.eamt, self.ramt])
else:
self.sql.updRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
data=[self.eamt, self.ramt], where=[("wcd_cono", "=",
self.opts["conum"]), ("wcd_empno", "=", self.empno),
("wcd_type", "=", rtype), ("wcd_code", "=", self.code)])
self.doLoadEarnDed(rtype, focus=True)
def doLoadEarnDed(self, rtype, focus=False):
if rtype == "E":
pag = 4
else:
pag = 5
self.df.clearFrame("C", pag)
codes = self.sql.getRec(tables=["wagcod", "wagedc"], cols=["wcd_code",
"ced_desc", "wcd_eamt", "wcd_ramt"], where=[("wcd_cono", "=",
self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type",
"=", rtype), ("ced_cono = wcd_cono",), ("ced_type = wcd_type",),
("ced_code = wcd_code",)])
if not codes:
return
p = 0
for cod in codes:
for i, c in enumerate(cod):
if rtype == "E" and i == 3:
continue
self.df.loadEntry("C", pag, p, data=c)
p = p + 1
if focus:
self.df.focusField("C", pag, p+1)
else:
self.df.last[pag][1] = p + 1
def doCodeDelete(self):
if self.df.pag == 4:
rtype = "E"
else:
rtype = "D"
code = self.df.c_work[self.df.pag][self.df.row][self.df.idx-2]
self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno), ("wcd_type", "=", rtype),
("wcd_code", "=", code)])
self.doLoadEarnDed(rtype, focus=True)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields(("T",0,None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(("T",1,None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(("T",2,None))
if not mes and self.df.t_work[1][0][15] == "E":
frt, pag, col, mes = self.df.doCheckFields(("T",3,None))
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col+1
else:
self.df.last[pag][1] = col+1
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col+1), err=mes)
else:
data = [self.opts["conum"]]
for p in range(0, self.df.pgs):
for x in range(0, self.df.topq[p]):
data.append(self.df.t_work[p][0][x])
data.append(self.term)
if self.new:
self.sql.insRec("wagmst", data=data)
for b in range(3):
data = [self.opts["conum"], self.empno, b+1,
self.df.t_work[6][0][b], ""]
self.sql.insRec("wagbal", data=data)
else:
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
if data != self.oldm[:len(data)]:
col = self.sql.wagmst_col
data.append(self.oldm[col.index("wgm_xflag")])
self.sql.updRec("wagmst", data=data, where=[("wgm_cono",
"=", self.opts["conum"]), ("wgm_empno", "=",
self.empno)])
for num, dat in enumerate(self.oldm):
if dat != data[num]:
self.sql.insRec("chglog", data=["wagmst", "U",
"%03i%05i" % (self.opts["conum"], self.empno),
col[num], dte, self.opts["capnm"], str(dat),
str(data[num]), "", 0])
for n, b in enumerate(self.df.t_work[6][0]):
lvl = n + 1
data = [self.opts["conum"], self.empno, lvl, b]
whr = [
("wbl_cono", "=", self.opts["conum"]),
("wbl_empno", "=", self.empno),
("wbl_balno", "=", lvl)]
chk = self.sql.getRec("wagbal", where=whr, limit=1)
if not chk:
self.sql.insRec("wagbal", data=data)
continue
if data != self.oldb[n][:len(data)]:
col = self.sql.wagbal_col
data.append(self.oldb[n][col.index("wbl_xflag")])
self.sql.updRec("wagbal", data=data, where=whr)
for num, dat in enumerate(self.oldb[n]):
if dat != data[num]:
self.sql.insRec("chglog", data=["wagbal", "U",
"%03i%05i%i" % (self.opts["conum"],
self.empno, lvl), col[num], dte,
self.opts["capnm"], str(dat),
str(data[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("General")
self.df.focusField("T", 0, 1)
def doMainDelete(self):
t = self.sql.getRec("wagtf1", cols=["count(*)"],
where=[("wt1_cono", "=", self.opts["conum"]), ("wt1_empno", "=",
self.empno)], limit=1)
if t[0]:
return "Transactions 1 Exist, Not Deleted"
t = self.sql.getRec("wagtf2", cols=["count(*)"],
where=[("wt2_cono", "=", self.opts["conum"]), ("wt2_empno=%s", "=",
self.empno)], limit=1)
if t[0]:
return "Transactions 2 Exist, Not Deleted"
t = self.sql.getRec("wagltf", cols=["count(*)"],
where=[("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=",
self.empno)], limit=1)
if t[0]:
return "Loan Transactions Exist, Not Deleted"
self.sql.delRec("wagbal", where=[("wbl_cono", "=", self.opts["conum"]),
("wbl_empno", "=", self.empno)])
self.sql.delRec("wagcap", where=[("wcp_cono", "=", self.opts["conum"]),
("wcp_empno", "=", self.empno)])
self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno)])
self.sql.delRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)])
self.sql.delRec("wagmst", where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["wagmst", "D", "%03i%05i" %
(self.opts["conum"], self.empno), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doPrint(self):
tables = []
for pag in range(0, (self.df.pgs+1)):
for x in range(0, self.df.topq[pag]):
lin = []
lin.append(self.df.topf[pag][x][3])
lin.append(self.df.t_disp[pag][0][x])
tables.append(lin)
heads = ["Salaries and Wages File Maintenance"]
cols = [["a","NA",30.0,"Field Name"],
["b","NA",30.0,"Values"]]
state = self.df.disableButtonsTags()
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=tables,
heads=heads, cols=cols, conum=self.opts["conum"],
conam=self.opts["conam"], ttype="D")
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("General")
self.df.focusField("T", 0, 1)
def doExit(self):
if self.df.pag == 0:
self.doCloseProcess()
elif self.df.pag == 1:
self.df.focusField("T", 0, 3)
elif self.df.pag == 2:
self.df.selPage("General")
elif self.df.pag == 3:
self.df.selPage("Tax")
elif self.df.pag == 4:
self.df.selPage("Deductions")
elif self.df.pag == 5:
self.df.selPage("Balances")
def doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class wgc410(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"ctlmes",
prog=self.__class__.__name__)
if self.sql.error:
return
self.system = "WAG"
return True
def mainProcess(self):
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Mss"), ("mss_detail", "NA", 50,
"Details")),
"where": [("mss_system", "=", self.system)],
"order":
"mss_message"
}
self.fld = ((("T", 0, 0, 0), "IUI", 3, "Message Number", "", "", "N",
self.doMes, mss, None, ("notzero", )),
(("T", 0, 1, 0), "ITv", (30, 6), "Details", "", "", "N",
self.doDetail, None, self.doDelete, 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)
def doMes(self, frt, pag, r, c, p, i, w):
self.message = w
self.acc = self.sql.getRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)],
order="mss_message",
limit=1)
if not self.acc:
self.new = "Y"
self.df.loadEntry(frt, pag, p + 1, data="")
else:
self.new = "N"
self.detail = self.acc[self.sql.ctlmes_col.index("mss_detail")]
self.df.loadEntry(frt, pag, p + 1, data=self.detail)
def doDetail(self, frt, pag, r, c, p, i, w):
if len(w) > 150:
return "Invalid Message Length, Maximum 150 Characters"
def doDelete(self):
self.sql.delRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
wid, self.detail = self.df.getEntry("T", 0, 1)
if len(self.detail) > 150:
self.df.focusField(
"T",
0,
2,
err="Invalid Message Length, Maximum 150 Characters")
else:
data = [self.system, self.message, self.detail]
if self.new == "Y":
self.sql.insRec("ctlmes", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.ctlmes_col
data.append(self.acc[col.index("mss_xflag")])
self.sql.updRec("ctlmes",
data=data,
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
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()
self.opts["mf"].closeLoop()
class bs1010(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
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
tabs = ["bksmst", "bksown", "bksaut", "chglog"]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
bmf = {
"stype":
"R",
"tables": ("bksmst", "bksown"),
"cols":
(("bmf_stat", "", 0, "S"), ("bmf_code", "", 0, "Code"),
("bmf_titl", "", 0, "Title", "Y"), ("bmf_ownr", "", 0, "Ownr"),
("bof_fnam", "", 0, "Name"), ("bmf_mnth", "", 0, "Mth-Rec")),
"where": [("bmf_cono", "=", self.opts["conum"]),
("bof_cono=bmf_cono", ), ("bof_code=bmf_ownr", )],
"order":
"bmf_stat, bmf_titl",
"index":
1
}
amf = {
"stype":
"R",
"tables": ("bksaut", ),
"cols":
(("baf_code", "", 0, "Code"), ("baf_snam", "", 0, "Surname", "Y"),
("baf_fnam", "", 0, "Names")),
"order":
"baf_code"
}
omf = {
"stype":
"R",
"tables": ("bksown", ),
"cols":
(("bof_code", "", 0, "Code"), ("bof_snam", "", 0, "Surname", "Y"),
("bof_fnam", "", 0, "Names")),
"where": [("bof_cono", "=", self.opts["conum"])],
"order":
"bof_code"
}
r1s = (("Current", "C"), ("Removed", "X"))
fld = ((("T", 0, 0,
0), "IUI", 4, "Code", "", "", "Y", self.doCode, bmf, None,
("efld", )), (("T", 0, 1, 0), "ITX", 30, "Title", "", "", "N",
self.doTitle, None, None, ("notblank", )),
(("T", 0, 2, 0), "IUI", 4, "Author", "", "", "N", self.doAuthor,
amf, None, ("efld", )), (("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "IUI", 4, "Owner", "", "", "N", self.doOwner,
omf, None, ("efld", )), (("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4,
0), "ID2", 7, "Month", "", "", "N", self.doMonth, None, None,
("efld", )), (("T", 0, 5, 0), ("IRB", r1s), 0, "Status", "",
"C", "N", self.doStatus, None, None, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2),
(("T", 0, 0), ("T", 0, 1))), ("Exit", None, self.doExit, 0,
("T", 0, 1), None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
def doCode(self, frt, pag, r, c, p, i, w):
self.bcode = w
if not self.bcode:
ok = askQuestion(self.opts["mf"].body,
"New Book",
"Is This a New Book?",
default="no")
if ok == "no":
return "Invalid Code"
self.newbk = True
self.bcode = getNextCode(self.sql,
"bksmst",
"bmf_code",
start=1,
last=9999)
self.df.loadEntry(frt, pag, p, data=self.bcode)
else:
self.old = self.sql.getRec("bksmst",
where=[("bmf_cono", "=",
self.opts["conum"]),
("bmf_code", "=", self.bcode)],
limit=1)
if not self.old:
ok = askQuestion(self.opts["mf"].body,
"Code",
"Is This a Manual Code?",
default="no")
if ok == "no":
return "Invalid Code"
self.newbk = True
return
col = 0
self.newbk = False
for num, dat in enumerate(self.old[1:-1]):
self.df.loadEntry(frt, pag, col, data=dat)
if num == 2:
col += 1
self.df.loadEntry(frt, pag, col, data=self.getAuthor(dat))
elif num == 3:
col += 1
self.df.loadEntry(frt, pag, col, data=self.getOwner(dat))
col += 1
def doDelete(self):
self.sql.delRec("bksmst",
where=[("bmf_cono", "=", self.opts["conum"]),
("bmf_code", "=", self.bcode)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doTitle(self, frt, pag, r, c, p, i, w):
self.title = w
def doAuthor(self, frt, pag, r, c, p, i, w):
self.acode = w
if not self.acode:
ok = askQuestion(self.opts["mf"].body,
"New Author",
"Is This a New Author?",
default="no")
if ok == "no":
return "Invalid Code"
self.doNewAuthor()
if not self.aend:
return "rf"
self.df.loadEntry(frt, pag, p, data=self.acode)
acc = self.sql.getRec("bksaut",
where=[("baf_code", "=", self.acode)],
limit=1)
if not acc:
return "Invalid Code"
self.df.loadEntry(frt, pag, p + 1, data=self.getAuthor(self.acode))
def doNewAuthor(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Author's Details", )
fld = ((("T", 0, 0, 0), "ITX", 30, "Surname", "", "", "Y", None, None,
None, ("notblank", )), (("T", 0, 1, 0), "ITX", 30, "Names", "",
"", "Y", None, None, None, ("efld", )))
self.aa = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doAutEnd, "y"), ),
txit=(self.doAutExit, ))
self.aa.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doAutEnd(self):
self.aend = True
self.acode = getNextCode(self.sql,
"bksaut",
"baf_code",
start=1,
last=9999)
data = [self.acode, self.aa.t_work[0][0][0], self.aa.t_work[0][0][1]]
self.sql.insRec("bksaut", data=data)
self.aa.closeProcess()
def doAutExit(self):
self.aend = False
self.aa.closeProcess()
def getAuthor(self, code):
acc = self.sql.getRec("bksaut",
where=[("baf_code", "=", code)],
limit=1)
if acc:
return "%s, %s" % (acc[1], acc[2])
else:
return ""
def doOwner(self, frt, pag, r, c, p, i, w):
self.ocode = w
if not self.ocode:
ok = askQuestion(self.opts["mf"].body,
"New Member",
"Is This a New Member?",
default="no")
if ok == "no":
return "Invalid Code"
self.doNewOwner()
if not self.oend:
return "rf"
self.df.loadEntry(frt, pag, p, data=self.ocode)
acc = self.sql.getRec("bksown",
where=[("bof_cono", "=", self.opts["conum"]),
("bof_code", "=", self.ocode)],
limit=1)
if not acc:
return "Invalid Code"
self.df.loadEntry(frt, pag, p + 1, data=self.getOwner(self.ocode))
def doNewOwner(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Owner's Details", )
fld = ((("T", 0, 0, 0), "ITX", 30, "Surname", "", "", "Y", None, None,
None, ("notblank", )), (("T", 0, 1, 0), "ITX", 30, "Names", "",
"", "Y", None, None, None, ("efld", )))
self.oo = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doOwnEnd, "y"), ),
txit=(self.doOwnExit, ))
self.oo.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doOwnEnd(self):
self.oend = True
self.ocode = getNextCode(self.sql,
"bksown",
"bof_code",
start=1,
last=9999)
data = [
self.opts["conum"], self.acode, self.oo.t_work[0][0][0],
self.oo.t_work[0][0][1], "", "", "", "", "", "", "", ""
]
self.sql.insRec("bksown", data=data)
self.oo.closeProcess()
def doOwnExit(self):
self.oend = False
self.oo.closeProcess()
def getOwner(self, code):
acc = self.sql.getRec("bksown",
where=[("bof_cono", "=", self.opts["conum"]),
("bof_code", "=", code)],
limit=1)
if acc:
return "%s, %s" % (acc[2], acc[3])
else:
return ""
def doMonth(self, frt, pag, r, c, p, i, w):
self.month = w
def doStatus(self, frt, pag, r, c, p, i, w):
self.status = w
def doEnd(self):
data = [self.opts["conum"]]
for num, dat in enumerate(self.df.t_work[0][0]):
if num in (3, 5):
continue
data.append(dat)
if self.newbk:
self.sql.insRec("bksmst", data=data)
elif data != self.old[:len(data)]:
col = self.sql.bksmst_col
data.append(self.old[col.index("bmf_xflag")])
self.sql.updRec("bksmst",
data=data,
where=[("bmf_cono", "=", self.opts["conum"]),
("bmf_code", "=", self.bcode)])
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=[
"bksmst", "U",
"%03i%04i" % (self.opts["conum"], self.bcode),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class mlc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(
self.opts["mf"].dbm,
["chglog", "genmst", "memctc", "memcat", "memtrn", "memctp"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
memctl = gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
return True
def mainProcess(self):
cod = {
"stype":
"R",
"tables": ("memctc", ),
"cols": (("mcc_code", "", 0, "CD"), ("mcc_freq", "", 0, "F"),
("mcc_desc", "", 0, "Description", "Y"), ("mcc_rgrp", "",
0, "RG")),
"where": [("mcc_cono", "=", self.opts["conum"])],
"whera": [["T", "mcc_type", 0, 0]]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
prc = {
"stype":
"R",
"tables": ("memctp", ),
"cols":
(("mcp_date", "", 0, "CD"), ("mcp_penalty", "", 0, "P-Rte"),
("mcp_prorata", "", 0, "P"), ("mcp_rate_01", "", 0, "Month-01")),
"where": [("mcp_cono", "=", self.opts["conum"])],
"whera": [["T", "mcp_type", 0, 0], ["T", "mcp_code", 1, 0]],
"order":
"mcp_date"
}
r1s = (("Fees", "A"), ("Category", "B"), ("Sports", "C"),
("Debentures", "D"))
r2s = (("Annually", "A"), ("Monthly", "M"), ("Once Off", "O"),
("Never", "N"))
r3s = (("No", "N"), ("1M", "1"), ("3M", "3"), ("6M", "6"), ("Manual",
"M"))
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Category Type", "", "A", "Y",
self.doCatType, None, None, None),
(("T", 0, 1, 0), "I@mcc_code", 0, "", "", "", "N",
self.doCatCode, cod, None, ("notzero", )),
(("T", 0, 2, 0), "I@mcc_desc", 0, "", "", "", "N", self.doDesc,
None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "I@mcc_rgrp", 0, "", "", "", "N", self.doRgrp,
None, None, ("notblank", )),
(("T", 0, 4, 0), ("IRB", r2s), 0, "Frequency", "", "A", "N",
self.doCatFreq, None, None, None),
(("T", 0, 5, 0), "I@mcc_age_l", 0, "", "", "", "N",
self.doCatLimit, None, None, ("efld", )),
(("T", 0, 5,
0), "I@mcc_and_s", 0, "And Mship", "And Length of Service",
"", "N", self.doCatLimit, None, None, ("efld", )),
(("T", 0, 5,
0), "I@mcc_or_s", 0, "Or Mship", "Or Length of Service", "",
"N", self.doCatLimit, None, None, ("efld", )),
(("T", 0, 6, 0), "I@mcc_ncode", 0, "Next Code", "", "", "N",
self.doCatNcode, cod, None, None)]
idx = 7
if self.glint == "Y":
fld.extend([(("T", 0, idx, 0), "I@mcc_glac", 0, "", "", "", "N",
self.doGlac, glm, None, ("efld", )),
(("T", 0, idx, 0), "ONA", 30, "")])
idx += 1
fld.extend([(("T", 0, idx, 0), "I@mcp_date", 0, "", "", "", "N",
self.doDate, prc, None, ("efld", )),
(("T", 0, idx + 1, 0), "I@mcp_penalty", 0, "", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, idx + 2, 0), ("IRB", r3s), 0, "Pro-Rata",
"Pro-Rata", "N", "N", self.doProRata, None, None, None),
(("T", 0, idx + 3, 0), "I@mcp_rate_01", 0, "", "", "", "N",
self.doMonth, None, None, ("efld", )),
(("T", 0, idx + 3, 34, 46), "I@mcp_rate_02", 0, "", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, idx + 4, 0), "I@mcp_rate_03", 0, "", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, idx + 4, 34, 46), "I@mcp_rate_04", 0, "", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, idx + 5, 0), "I@mcp_rate_05", 0, "", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, idx + 5, 34, 46), "I@mcp_rate_06", 0, "", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, idx + 6, 0), "I@mcp_rate_07", 0, "", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, idx + 6, 34, 46), "I@mcp_rate_08", 0, "", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, idx + 7, 0), "I@mcp_rate_09", 0, "", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, idx + 7, 34, 46), "I@mcp_rate_10", 0, "", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, idx + 8, 0), "I@mcp_rate_11", 0, "", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, idx + 8, 34, 46), "I@mcp_rate_12", 0, "", "", "",
"N", None, None, None, ("efld", ))])
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=fld,
butt=but,
tend=tnd,
txit=txt)
def doCatType(self, frt, pag, r, c, p, i, w):
self.ctyp = w
def doCatCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.oldcat = self.sql.getRec("memctc",
where=[("mcc_cono", "=",
self.opts["conum"]),
("mcc_type", "=", self.ctyp),
("mcc_code", "=", self.code)],
limit=1)
if self.oldcat:
self.desc = self.oldcat[self.sql.memctc_col.index("mcc_desc")]
self.rgrp = self.oldcat[self.sql.memctc_col.index("mcc_rgrp")]
self.freq = self.oldcat[self.sql.memctc_col.index("mcc_freq")]
self.age_l = self.oldcat[self.sql.memctc_col.index("mcc_age_l")]
self.and_s = self.oldcat[self.sql.memctc_col.index("mcc_and_s")]
self.or_s = self.oldcat[self.sql.memctc_col.index("mcc_or_s")]
self.ncode = self.oldcat[self.sql.memctc_col.index("mcc_ncode")]
self.df.loadEntry(frt, pag, p + 1, data=self.desc)
self.df.loadEntry(frt, pag, p + 2, data=self.rgrp)
self.df.loadEntry(frt, pag, p + 3, data=self.freq)
self.df.loadEntry(frt, pag, p + 4, data=self.age_l)
self.df.loadEntry(frt, pag, p + 5, data=self.and_s)
self.df.loadEntry(frt, pag, p + 6, data=self.or_s)
self.df.loadEntry(frt, pag, p + 7, data=self.ncode)
if self.glint == "Y":
self.glno = self.oldcat[self.sql.memctc_col.index("mcc_glac")]
self.df.loadEntry(frt, pag, p + 8, data=self.glno)
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", self.glno)],
limit=1)
if des:
self.df.loadEntry("T", 0, p + 9, data=des[0])
idx = 11
else:
idx = 9
if self.freq == "N":
self.date = 0
self.oldprc = []
for x in range(idx, len(self.df.t_work[0][0])):
self.df.loadEntry("T", 0, x, data="")
else:
self.oldprc = self.sql.getRec("memctp",
where=[
("mcp_cono", "=",
self.opts["conum"]),
("mcp_type", "=", self.ctyp),
("mcp_code", "=", self.code)
],
order="mcp_date desc",
limit=1)
self.date = self.oldprc[self.sql.memctp_col.index("mcp_date")]
for n, d in enumerate(self.oldprc[3:-1]):
self.df.loadEntry("T", 0, idx + n, data=d)
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
if self.ctyp != "C":
self.rgrp = "NA"
return "sk1"
def doRgrp(self, frt, pag, r, c, p, i, w):
self.rgrp = w
def doCatFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
if self.freq == "N":
self.age_l = 0
self.and_s = 0
self.or_s = 0
self.ncode = 0
self.glno = 0
for x in range(p + 1, len(self.df.t_work[0][0])):
self.df.loadEntry("T", 0, x, data="")
return "nd"
if self.ctyp != "B":
self.age_l = 0
self.and_s = 0
self.or_s = 0
self.ncode = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data=0)
self.df.loadEntry(frt, pag, p + 3, data=0)
self.df.loadEntry(frt, pag, p + 4, data=0)
return "sk4"
def doCatLimit(self, frt, pag, r, c, p, i, w):
if p == 5:
self.age_l = w
elif p == 6:
self.and_s = w
else:
self.or_s = w
if not self.age_l and not self.and_s and not self.or_s:
self.ncode = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doCatNcode(self, frt, pag, r, c, p, i, w):
self.ncode = w
def doGlac(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.glno = w
self.df.loadEntry("T", 0, p + 1, data=acc[0])
def doDate(self, frt, pag, r, c, p, i, w):
self.date = w
if not self.oldcat:
self.oldprc = []
else:
self.oldprc = self.sql.getRec("memctp",
where=[("mcp_cono", "=",
self.opts["conum"]),
("mcp_code", "=", self.code),
("mcp_type", "=", self.ctyp),
("mcp_date", "=", self.date)],
limit=1)
if self.oldprc:
for n, d in enumerate(self.oldprc[4:-1]):
self.df.loadEntry(frt, pag, p + 1 + n, data=d)
else:
for n in range(14):
self.df.clearEntry(frt, pag, c + 1 + n)
def doProRata(self, frt, pag, r, c, p, i, w):
self.prorata = w
def doMonth(self, frt, pag, r, c, p, i, w):
if self.oldprc or self.prorata == "M":
return
if self.prorata == "N":
mths = [w] * 12
elif self.prorata == "1":
mths = [w]
for x in range(11, 0, -1):
mths = mths + [round(w / 12.0 * x, 0)]
elif self.prorata == "3":
mths = [w, w, w]
for x in range(3, 0, -1):
for _ in range(3):
mths = mths + [round(w / 4.0 * x, 0)]
elif self.prorata == "6":
mths = [w, w, w, w, w, w]
for x in range(6):
mths = mths + [round(w / 2.0, 0)]
for n, d in enumerate(mths):
self.df.loadEntry(frt, pag, p + n, data=d)
if self.prorata == "N":
return "sk11"
def doDelete(self):
mst = self.sql.getRec("memcat",
cols=["count(*)"],
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_type", "=", self.ctyp),
("mlc_code", "=", self.code)],
limit=1)
if mst[0]:
return "Code in Use (memcat), Not Deleted"
trn = self.sql.getRec("memtrn",
cols=["count(*)"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_ctyp", "=", self.ctyp),
("mlt_ccod", "=", self.code)],
limit=1)
if trn[0]:
return "Code in Use (memtrn), Not Deleted"
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("memctc",
where=[("mcc_cono", "=", self.opts["conum"]),
("mcc_type", "=", self.ctyp),
("mcc_code", "=", self.code)])
self.sql.insRec("chglog", data=["memctc", "D", "%03i%1s%02i" % \
(self.opts["conum"], self.ctyp, self.code), "", dte,
self.opts["capnm"], "", "", "", 0])
prc = self.sql.getRec("memctp",
cols=["mcp_date"],
where=[("mcp_cono", "=", self.opts["conum"]),
("mcp_type", "=", self.ctyp),
("mcp_code", "=", self.code)])
for date in prc:
self.sql.delRec("memctp",
where=[("mcp_cono", "=", self.opts["conum"]),
("mcp_code", "=", self.code),
("mcp_code", "=", self.code),
("mcp_date", "=", date)])
self.sql.insRec("chglog", data=["memctp", "D", "%03i%1s%02i%8s" % \
(self.opts["conum"], self.ctyp, self.code, date), "", dte,
self.opts["capnm"], "", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
data = [
self.opts["conum"], self.ctyp, self.code, self.desc, self.rgrp,
self.freq, self.age_l, self.and_s, self.or_s, self.ncode
]
if self.glint == "N":
data.append(0)
else:
data.append(self.glno)
if not self.oldcat:
self.sql.insRec("memctc", data=data)
elif data != self.oldcat[:len(data)]:
col = self.sql.memctc_col
data.append(self.oldcat[col.index("mcc_xflag")])
self.sql.updRec("memctc",
data=data,
where=[("mcc_cono", "=", self.opts["conum"]),
("mcc_type", "=", self.ctyp),
("mcc_code", "=", self.code)])
for num, dat in enumerate(self.oldcat):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"memctc", "U",
"%03i%1s%02i" %
(self.opts["conum"], self.ctyp, self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if self.freq != "N":
data = [self.opts["conum"], self.ctyp, self.code]
if self.glint == "Y":
idx = 11
else:
idx = 9
for x in range(idx, idx + 15):
data.append(self.df.t_work[0][0][x])
if not self.oldprc:
self.sql.insRec("memctp", data=data)
elif data != self.oldprc[:len(data)]:
col = self.sql.memctp_col
data.append(self.oldcat[col.index("mcp_xflag")])
self.sql.updRec("memctp",
data=data,
where=[("mcp_cono", "=", self.opts["conum"]),
("mcp_type", "=", self.ctyp),
("mcp_code", "=", self.code),
("mcp_date", "=", self.date)])
for num, dat in enumerate(self.oldprc):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"memctp", "U",
"%03i%1s%02i%8s" %
(self.opts["conum"], self.ctyp,
self.code, str(self.date)),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
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()
self.opts["mf"].closeLoop()
class gl1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
self.gldep = ctlsys["sys_gl_dep"]
self.gldig = ctlsys["sys_gl_dig"]
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
self.mods = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
self.mods.append(ctlmst["ctm_modules"][x:x + 2])
tabs = [
"ctlctl", "ctldep", "ctlvmf", "genmst", "genbal", "genbud",
"genrpt", "gentrn", "chglog"
]
if "CR" in self.mods:
tabs.append("crsctl")
if "DR" in self.mods:
tabs.append("drsctl")
if "ST" in self.mods:
tabs.extend(["strctl", "strloc"])
if "SI" in self.mods:
tabs.append("slsctl")
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("genmst",
cols=["count(*)"],
where=[("glm_cono", "=", self.opts["conum"])],
limit=1)
if chk[0]:
self.newgen = False
else:
self.newgen = True
if "args" in self.opts:
self.acno = None
return True
def mainProcess(self):
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vat = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "Acc-Num"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
r1s = (("Profit & Loss", "P"), ("Balance Sheet", "B"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = [(("T", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "Y",
self.doAccNum, glm, None, ("notzero", )),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Account Type", "", "P", "N",
self.doTypCod, None, self.doDelete, None),
(("T", 0, 2,
0), "INA", 30, "Description", "Account Description", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), ("IRB", r2s), 0, "Allow Postings", "", "Y",
"N", None, None, None, None),
[("T", 0, 4, 0), "IUA", 1, "Tax Default", "", "", "N",
self.doVatCod, vat, None, ("notblank", )]]
but = [
("Import",None,self.doImport,0,("T",0,1),("T",0,2),
"Import a Chart of Accounts from a CSV or XLS file "\
"having the following fields: Account Number, "\
"Account Type (P/B), Description, Direct Postings (Y/N), "\
"VAT Code"),
["Populate",None,self.doPopulate,0,("T",0,1),("T",0,2),
"Generate a Chart of Accounts with Accompanying Control "\
"Records and Financial Statement Report. This Only Applies "\
"to Unpopulated (NEW) Ledgers."],
("Accept",None,self.doAccept,0,(("T",0,2),("T",0,5)),
(("T",0,0),("T",0,1))),
("Cancel",None,self.doCancel,0,(("T",0,2),("T",0,5)),
(("T",0,0),("T",0,1))),
("Quit",None,self.doQuit,1,None,None,"",1,4)]
tnd = ((self.doEnd, "y"), )
txt = (self.doQuit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if not self.newgen:
self.df.butt[1][4] = None
self.df.butt[1][5] = None
self.df.setWidget(self.df.B1, state="disabled")
def doAccNum(self, frt, pag, r, c, p, i, w):
self.acno = w
self.old = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", self.acno)],
limit=1)
if not self.old:
self.new = True
if self.gldep == "Y":
err = self.doCheckDep(self.acno)
if err:
return err
elif "args" in self.opts:
showError(self.opts["mf"].body, "Error",
"Only a New Account is Allowed")
return "rf"
else:
self.new = False
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=self.old[x + 1])
def doTypCod(self, frt, pag, r, c, p, i, w):
if self.new:
if w == "P":
self.df.topf[pag][4][5] = self.taxdf
else:
self.df.topf[pag][4][5] = "N"
elif not self.df.topf[pag][4][5]:
self.df.topf[pag][4][5] = "N"
def doVatCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not acc:
return "Invalid VAT Code"
def doDelete(self):
t = self.sql.getRec("gentrn",
cols=["count(*)"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno)],
limit=1)
if t[0]:
return "Transactions Exist, Not Deleted"
self.sql.delRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acno)])
self.sql.delRec("genbal",
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acno)])
self.sql.delRec("genbud",
where=[("glb_cono", "=", self.opts["conum"]),
("glb_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"genmst", "D",
"%03i%07i" % (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.newgen:
self.df.butt[1][4] = None
self.df.butt[1][5] = None
data = [
self.opts["conum"], self.acno, self.df.t_work[0][0][1],
self.df.t_work[0][0][2], self.df.t_work[0][0][3],
self.df.t_work[0][0][4]
]
if self.new:
self.sql.insRec("genmst", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genmst_col
data.append(self.old[col.index("glm_xflag")])
self.sql.updRec("genmst",
data=data,
where=[("glm_cono", "=", self.opts["conum"]),
("glm_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=[
"genmst", "U",
"%03i%07i" % (self.opts["conum"], self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.B3, state="disabled")
if "args" in self.opts:
self.doQuit()
else:
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 doImport(self):
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="genmst", impskp=["glm_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Chart of Accounts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", line[0])],
limit=1)
if chk:
err = "%s %s Already Exists" % (fi.impcol[0][0], line[0])
break
if self.gldep == "Y":
err = self.doCheckDep(line[0])
if err:
break
if line[1] not in ("B", "P"):
err = "Invalid %s %s, Only B or P" % (fi.impcol[1][0], line[1])
break
if not line[2]:
err = "Blank Description"
break
if line[3] not in ("Y", "N"):
err = "Invalid %s %s" % (fi.impcol[3][0], line[3])
break
chk = self.sql.getRec("ctlvmf",
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", line[4])],
limit=1)
if not chk:
err = "%s %s Does Not Exist" % (fi.impcol[4][0], line[4])
break
line.insert(0, self.opts["conum"])
self.sql.insRec("genmst", 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 doCheckDep(self, acno):
dep = int(acno / (10**(7 - self.gldig)))
acc = int(acno % (10**(7 - self.gldig)))
if dep:
chk = self.sql.getRec("ctldep",
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", dep)],
limit=1)
if not chk:
return "Invalid Department Number (%s)" % dep
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc)],
limit=1)
if chk:
return "This Account Number (%s) is in Use" % acc
def doPopulate(self):
if not self.newgen:
showError(self.opts["mf"].body, "Populate Error",
"You Cannot Populate with Existing Accounts")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
if self.gldep == "Y":
showError(self.opts["mf"].body, "Populate Error",
"You Cannot Populate with Departments Enabled")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.igcrs = "N"
self.igdrs = "N"
self.igstr = "N"
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Integrate Subsiduary Ledgers", )
r1s = (("Yes", "Y"), ("No", "N"))
fld = []
col = 0
if "CR" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Creditor's Ledger",
"Creditor's Ledger", "N", "N", self.doIgCrs, None,
None, None, None))
col += 1
if "DR" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Debtor's Ledger",
"Debtor's Ledger", "N", "N", self.doIgDrs, None, None,
None, None))
col += 1
if "ST" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Stores's Ledger",
"Stores's Ledger", "N", "N", self.doIgStr, None, None,
None, None))
if fld:
self.ig = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doIgEnd, "y"), ),
txit=(self.doIgExit, ))
self.ig.mstFrame.wait_window()
if self.igexit:
self.doQuit()
return
sp = SplashScreen(self.opts["mf"].body,
"Populating Records\n\nPlease Wait ...")
# genmst
genmst = datdic["genmst"]
for dat in genmst:
dat.insert(0, self.opts["conum"])
dat.append("Y")
if dat[2] == "B":
dat.append("N")
else:
dat.append(self.taxdf)
self.sql.insRec("genmst", data=dat)
# genrpt
genrpt = datdic["genrpt"]
for dat in genrpt:
dat.insert(0, self.opts["conum"])
self.sql.insRec("genrpt", data=dat)
# ctlctl
crsctl = 0
drsctl = 0
stksoh = 0
ctlctl = datdic["ctlctl"]
for dat in ctlctl:
if dat[0] in ("crs_ctl", "dis_rec"):
if self.igcrs != "Y":
continue
if dat[0] == "crs_ctl":
crsctl = int(dat[2])
elif dat[0] in ("drs_ctl", "dis_all"):
if self.igdrs != "Y":
continue
if dat[0] == "drs_ctl":
drsctl = int(dat[2])
elif dat[0] in ("stk_soh", "stk_susp"):
if self.igstr != "Y":
continue
if dat[0] == "stk_soh":
stksoh = int(dat[2])
elif dat[0] in ("wag_ctl", "wag_slc", "wag_sli"):
continue
dat.insert(0, self.opts["conum"])
self.sql.insRec("ctlctl", data=dat)
if "CR" in self.mods:
chk = self.sql.getRec("crsctl",
where=[("ctc_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("crsctl",
data=[
self.opts["conum"], self.igcrs, "E", "", 0,
0, "remittance_advice", ""
])
else:
self.sql.updRec("crsctl",
cols=["ctc_glint"],
data=[self.igcrs],
where=[("ctc_cono", "=", self.opts["conum"])])
if self.igcrs == "Y" and crsctl:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", crsctl)])
if "DR" in self.mods:
chk = self.sql.getRec("drsctl",
where=[("ctd_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("drsctl",
data=[
self.opts["conum"], self.igdrs, "E", "N",
"statement_normal", "Y", ""
])
else:
self.sql.updRec("drsctl",
cols=["ctd_glint"],
data=[self.igdrs],
where=[("ctd_cono", "=", self.opts["conum"])])
if self.igdrs == "Y" and drsctl:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", drsctl)])
if "ST" in self.mods:
chk = self.sql.getRec("strctl",
where=[("cts_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("strctl",
data=[
self.opts["conum"], self.igstr, "N", 1,
"N", "purchase_order", ""
])
else:
self.sql.updRec("strctl",
cols=["cts_glint"],
data=[self.igstr],
where=[("cts_cono", "=", self.opts["conum"])])
chk = self.sql.getRec("strloc",
where=[("srl_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("strloc",
data=[
self.opts["conum"], "1",
"Location Number One", "", "", "", ""
])
if self.igstr == "Y" and stksoh:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", stksoh)])
if "SI" in self.mods:
chk = self.sql.getRec("slsctl",
where=[("ctv_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec(
"slsctl",
data=[self.opts["conum"], "Y", "Y", "sales_document", ""])
sp.closeSplash()
self.df.butt[1][4] = None
self.df.butt[1][5] = None
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 doIgCrs(self, frt, pag, r, c, p, i, w):
self.igcrs = w
def doIgDrs(self, frt, pag, r, c, p, i, w):
self.igdrs = w
def doIgStr(self, frt, pag, r, c, p, i, w):
self.igstr = w
def doIgEnd(self):
self.igexit = False
self.ig.closeProcess()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.focusField("T", 0, 1)
def doIgExit(self):
self.igexit = True
self.ig.closeProcess()
def doQuit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class wgc110(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
mods = ctlmst["ctm_modules"]
self.genleg = False
for x in range(0, len(mods), 2):
if mods[x:x + 2] == "GL":
self.genleg = True
break
tabs = ["wagctl", "tplmst", "chglog"]
if self.genleg:
tabs.extend(["ctlctl", "genmst"])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.acc = self.sql.getRec("wagctl",
where=[("ctw_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [
self.opts["conum"], "N", 0, "", "", 0, 0, 0, 0, "N", 0, 0, "",
61, "payslip", "", ""
]
else:
self.new = False
if self.genleg:
self.ctl = [["wag_ctl", "Salaries Control", 0],
["wag_slc", "Staff Loans Control", 0],
["wag_sli", "Staff Loans Interest", 0]]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
for num, ctl in enumerate(self.ctl):
if ctl[0] in ctlctl:
self.ctl[num][2] = ctlctl[ctl[0]]
return True
def drawDialog(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")),
"where": [("tpm_type", "=", "P"), ("tpm_system", "=", "WAG")],
"order":
"tpm_tname"
}
r1s = (("Yes", "Y"), ("No", "N"))
if self.genleg:
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30,
"Description")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "",
self.acc[1], "N", self.doGlint, None, None, None),
(("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "",
self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 1, 0), "ONA", 30, ""),
(("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "",
self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "IUI", 7, self.ctl[2][1], "",
self.ctl[2][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 3, 0), "ONA", 30, "")]
seq = 4
else:
fld = []
seq = 0
fld.extend([(("T", 0, seq, 0), "IUI", 10, "Registration Number", "",
self.acc[2], "N", None, None, None, ("notzero", )),
(("T", 0, seq + 1, 0), "INA", 10, "SDL Number", "",
self.acc[3], "N", None, None, None, ("notblank", )),
(("T", 0, seq + 2, 0), "INA", 10, "UIF Number", "",
self.acc[4], "N", None, None, None, ("notblank", )),
(("T", 0, seq + 3, 0), "IUI", 4, "Trade Number", "",
self.acc[5], "N", None, None, None, ("notzero", )),
(("T", 0, seq + 4, 0), "IUD", 6.2, "Daily Hours", "",
self.acc[6], "N", None, None, None, ("notzero", )),
(("T", 0, seq + 5, 0), "IUD", 6.2, "Weekly Hours", "",
self.acc[7], "N", self.doHrs, None, None, ("notzero", )),
(("T", 0, seq + 6, 0), "IUD", 6.2, "Monthly Hours", "",
self.acc[8], "N", None, None, None, ("notzero", )),
(("T", 0, seq + 7, 0), ("IRB",
r1s), 0, "Diplomatic Immunity", "",
self.acc[9], "N", None, None, None, None),
(("T", 0, seq + 8, 0), "IUD", 6.2, "S/L Interest Rate", "",
self.acc[10], "N", None, None, None, ("efld", )),
(("T", 0, seq + 9, 0), "Id1", 10, "Last Interest Date", "",
self.acc[11], "N", None, None, None, ("efld", )),
(("T", 0, seq + 10, 0), "INA", 4, "Best Account Code", "",
self.acc[12], "N", None, None, None, ("efld", )),
(("T", 0, seq + 11, 0), "IUI", 2, "Best Account Type", "",
self.acc[13], "N", None, None, None, ("efld", )),
(("T", 0, seq + 12, 0), "INA", 20, "Payslip Template", "",
self.acc[14], "N", self.doTplNam, tpm, None, ("efld", )),
(("T", 0, seq + 13, 0), "ITX", 50, "Email Address", "",
self.acc[15], "N", None, None, None, ("email", ))])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 1), ("T", 0, 0)),
("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if not self.new:
s = 0
for n, f in enumerate(self.acc[1:-1]):
if not self.genleg and not n:
continue
self.df.loadEntry("T", 0, s, data=f)
s += 1
if n == 0:
for c in self.ctl:
self.df.loadEntry("T", 0, s, data=c[2])
s += 1
self.df.loadEntry("T", 0, s, data=self.getDes(c[2]))
s += 1
self.df.focusField("T", 0, 1, clr=False)
def doHrs(self, frt, pag, r, c, p, i, w):
mhrs = round(w * 4.33333, 5)
self.df.loadEntry(frt, pag, p + 1, data=mhrs)
def doGlint(self, frt, pag, r, c, p, i, w):
if w == "N":
for x in range(1, 7):
self.df.loadEntry(frt, pag, p + x, data="")
return "sk6"
def doGenAcc(self, frt, pag, r, c, p, i, w):
des = self.getDes(w)
if not des:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=des)
def getDes(self, acno):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acno)],
limit=1)
if acc:
return acc[0]
else:
return ""
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "P"),
("tpm_system", "=", "WAG")],
limit=1)
if not acc:
return "Invalid Template Name"
def doEnd(self):
data = [self.opts["conum"]]
if not self.genleg:
data.append("N")
for x, d in enumerate(self.df.t_work[0][0]):
if self.genleg and x < 7:
if x in (1, 3, 5):
y = int((x - 1) / 2)
chk = self.sql.getRec("ctlctl",
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])],
limit=1)
if chk:
self.sql.updRec("ctlctl",
cols=["ctl_conacc"],
data=[d],
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])])
else:
self.sql.insRec("ctlctl",
data=[
self.opts["conum"], self.ctl[y][0],
self.ctl[y][1], d, "", "N", "N"
])
elif x in (2, 4, 6):
continue
else:
data.append(d)
else:
data.append(d)
if self.new:
self.sql.insRec("wagctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.wagctl_col
data.append(self.acc[col.index("ctw_xflag")])
self.sql.updRec("wagctl",
data=data,
where=[("ctw_cono", "=", self.opts["conum"])])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.acc):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"wagctl", "U",
"%03i" % self.opts["conum"], col[num],
dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.doExit()
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class drc410(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,
"drsdel",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
dlm = {
"stype":
"R",
"tables": ("drsdel", ),
"cols":
(("del_code", "", 0, "Del-Cod"), ("del_add1", "", 0, "Address"))
}
self.fld = [[("T", 0, 0, 0), "INa", 7, "Code", "Address Code", "", "N",
self.doCode, dlm, None, ("notblank", )],
(("T", 0, 1, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 4, 0), "INA", 30, "Address Line 4", "", "", "N",
None, None, None, ("efld", ))]
if "args" in self.opts:
self.fld[0][1] = "ONa"
self.fld[0][5] = self.opts["args"]
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)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.acc = self.sql.getRec("drsdel",
where=[("del_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=self.acc[x])
def doDelete(self):
self.sql.delRec("drsdel", where=[("del_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dat = []
for x in range(0, len(self.df.t_work[0][0])):
dat.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("drsdel", data=dat)
elif dat != self.acc[:len(dat)]:
col = self.sql.drsdel_col
dat.append(self.acc[col.index("del_xflag")])
self.sql.updRec("drsdel",
data=dat,
where=[("del_code", "=", self.code)])
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 drc310(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"ctlrep",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
rpm = {
"stype": "R",
"tables": ("ctlrep", ),
"cols":
(("rep_code", "", 0, "Rep"), ("rep_name", "", 0, "Name", "Y")),
"where": [("rep_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INa", 3, "Rep", "Rep Number", "", "N",
self.doRep, rpm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N", None,
None, self.doDelete, ("notblank", )))
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)
def doRep(self, frt, pag, r, c, p, i, w):
self.rep = w
self.acc = self.sql.getRec("ctlrep",
where=[("rep_cono", "=",
self.opts["conum"]),
("rep_code", "=", w)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
name = self.acc[self.sql.ctlrep_col.index("rep_name")]
self.df.loadEntry(frt, pag, p + 1, data=name)
def doDelete(self):
self.sql.delRec("ctlrep",
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=", self.rep)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("ctlrep", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.ctlrep_col
data.append(self.acc[col.index("rep_xflag")])
self.sql.updRec("ctlrep",
data=data,
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=", self.rep)])
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()
self.opts["mf"].closeLoop()
class ln1010(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", "lonmf1", "lonmf2"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
lonctl = gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
con = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols":
(("lm1_acno", "", 0, "Code"), ("lm1_name", "", 0, "Surname", "Y"),
("lm1_email", "", 0, "Email Address"))
}
if "args" in self.opts:
fld = [(("T", 0, 0, 0), "OUA", 7, "Account Code"),
(("T", 0, 1, 0), "ITX", 30, "Name", "", "", "N",
self.doName, None, None, ("notblank", ))]
self.newacc = True
self.acno = None
else:
fld = [(("T", 0, 0, 0), "IUA", 7, "Account Code", "", "", "Y",
self.doAcno, con, None, None),
(("T", 0, 1, 0), "ITX", 30, "Name", "", "", "N",
self.doName, None, self.doDelete, ("notblank", ))]
fld.extend([(("T", 0, 2, 0), "ITX", 30, "Address Line 1", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 3, 0), "ITX", 30, "Address Line 2", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 4, 0), "ITX", 30, "Address Line 3", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 5, 0), "ITX", 4, "Postal Code", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 6, 0), "ITX", 20, "Telephone Number", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, 7, 0), "ITX", 20, "Fax Number", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 8, 0), "ITX", 20, "Mobile Number", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 9, 0), "ITX", 30, "E-Mail Address", "", "", "N",
None, None, None, ("email", ))])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 1)),
("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doAccept, "N"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
def doClick(self, *opts):
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doAcno(self, frt, pag, r, c, p, i, w):
if w:
self.oldacc = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=",
self.opts["conum"]),
("lm1_acno", "=", w)],
limit=1)
if not self.oldacc:
return "Invalid Account Number"
self.acno = w
self.name = self.oldacc[self.sql.lonmf1_col.index("lm1_name")]
self.email = self.oldacc[self.sql.lonmf1_col.index("lm1_email")]
for num, dat in enumerate(self.oldacc[1:-1]):
self.df.loadEntry("T", 0, num, data=dat)
self.newacc = False
else:
yn = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Loan Account?",
default="no")
if yn == "no":
return "Invalid Account Number"
self.newacc = True
def doName(self, frt, pag, r, c, p, i, w):
if self.newacc:
chk = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_name", "=", w)],
limit=1)
if chk:
return "An Account With This Name Already Exists"
for seq in range(1, 100):
self.acno = genAccNum(w, seq)
chk = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=",
self.opts["conum"]),
("lm1_acno", "=", self.acno)],
limit=1)
if not chk:
break
self.df.loadEntry(frt, pag, p - 1, data=self.acno)
def doDelete(self):
chk = self.sql.getRec("lonmf2",
cols=["count(*)"],
where=[("lm2_cono", "=", self.opts["conum"]),
("lm2_acno", "=", self.acno)],
limit=1)
if chk[0]:
return "Loans Exist, Not Deleted"
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("lonmf1",
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_acno", "=", self.acno)])
self.sql.insRec("chglog",
data=[
"lonmf1", "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 doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
return
# Create/Update Record
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
data = [self.opts["conum"]]
for x in range(len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.newacc:
self.sql.insRec("lonmf1", data=data)
elif data != self.oldacc[:len(data)]:
col = self.sql.lonmf1_col
data.append(self.oldacc[col.index("lm1_xflag")])
self.sql.updRec("lonmf1",
data=data,
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_acno", "=", self.acno)])
for num, dat in enumerate(self.oldacc):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"lonmf1", "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.doExit()
else:
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class drc610(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["drsact", "drsmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
act = {
"stype":
"R",
"tables": ("drsact", ),
"cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0,
"Description", "Y"))
}
self.fld = ((("T", 0, 0,
0), "IUA", 3, "Code", "Business Activity Code", "", "N",
self.doAct, act, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )))
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)
def doAct(self, frt, pag, r, c, p, i, w):
self.code = w
self.acc = self.sql.getRec("drsact",
where=[("dac_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
desc = self.acc[self.sql.drsact_col.index("dac_desc")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
def doDelete(self):
acc = self.sql.getRec("drsmst",
cols=["count(*)"],
where=[("drm_bus_activity", "=", self.code)],
limit=1)
if acc[0]:
return "Code in Use, Not Deleted"
self.sql.delRec("drsact", where=[("dac_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = []
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("drsact", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.drsact_col
data.append(self.acc[col.index("dac_xflag")])
self.sql.updRec("drsact",
data=data,
where=[("dac_code", "=", self.code)])
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()
self.opts["mf"].closeLoop()
