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 bc6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.oldtab = self.opts["args"][0]
self.newtab = self.opts["args"][1]
self.doProcess()
else:
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.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"))
tabs = []
for tab in self.tables:
if tab[0] not in tabs:
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
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"]
if self.mlint == "Y" and self.samen == "Y":
return
self.mstart = bwlctl["ctb_mstart"]
self.fstart = bwlctl["ctb_fstart"]
self.nstart = bwlctl["ctb_nstart"]
return True
def mainProcess(self):
tab = {
"stype":
"R",
"tables": ("bwltab", ),
"cols": (("btb_tab", "", 0, "Tab-No"),
("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "",
0, "Names")),
"where": [("btb_cono", "=", self.opts["conum"])],
"order":
"btb_tab"
}
fld = [(["T", 0, 0, 0], "I@btb_tab", 0, "Old Tab", "Old Tab Number",
"", "Y", self.doOldTab, tab, None, ("notzero", )),
(["T", 0, 0, 18], "ONA", 30, ""),
(["T", 0, 1, 0], "I@btb_tab", 0, "New Tab", "New Tab Number",
"", "Y", self.doNewTab, None, None, ("notzero", ))]
tnd = ((self.doProcess, "y"), )
txt = (self.doExit, )
but = [("Generate", None, self.doGenerate, 0, ("T", 0, 1), ("T", 0, 2),
"Auto Generate New Tab Numbers Based on Names and Gender")]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
butt=but)
def doOldTab(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab Number, Does Not exist"
self.oldtab = w
self.gender = acc[self.sql.bwltab_col.index("btb_gender")]
if acc[4]:
self.df.loadEntry(frt,
pag,
p + 1,
data="%s, %s" % (acc[3], acc[4].split()[0]))
else:
self.df.loadEntry(frt, pag, p + 1, data=acc[3])
def doNewTab(self, frt, pag, r, c, p, i, w):
if self.oldtab < self.nstart:
if self.mstart < self.fstart:
if self.gender == "M" and w >= self.fstart:
return "Invalid Male Tab Number"
elif self.gender == "F" and w < self.fstart:
return "Invalid Female Tab Number"
elif self.gender == "M" and w >= self.mstart:
return "Invalid Male Tab Number"
elif self.gender == "F" and w < self.mstart:
return "Invalid Female Tab Number"
elif w < self.nstart:
return "Invalid Non-Member Tab Number"
acc = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if acc:
return "Invalid Tab Number, Already Exists"
self.newtab = w
def doGenerate(self):
self.opts["mf"].updateStatus("")
but = (("Members", "M"), ("Non Members", "N"), ("All", "A"), ("None",
"X"))
ok = askChoice(self.opts["mf"].body, "ARE YOU SURE???",
"Are you Certain this is what you want To Do? This will "\
"Automatically Generate New Tab Numbers For Selected Range "\
"Based On Member's Names and Gender!", butt=but, default="None")
if ok == "X":
self.df.focusField("T", 0, 1)
return
self.df.closeProcess()
splash = SplashScreen(self.opts["mf"].body,
"Generating New Tab Numbers ... Please Wait")
# Create temporary tables
for ot in self.tables:
tt = "%s_temp" % ot[0]
self.sql.sqlRec("Create table %s as Select * from %s "\
"where %s = %s" % (tt, ot[0], ot[1], self.opts["conum"]))
self.sql.delRec(ot[0], where=[(ot[1], "=", self.opts["conum"])])
mem = self.sql.sqlRec("Select * from bwltab_temp where btb_cono = %s "\
"and btb_tab < %s order by btb_surname, btb_names" %
(self.opts["conum"], self.nstart))
non = self.sql.sqlRec("Select * from bwltab_temp where btb_cono = %s "\
"and btb_tab >= %s order by btb_surname, btb_names" %
(self.opts["conum"], self.nstart))
mstart = self.mstart
fstart = self.fstart
nstart = self.nstart
key = {}
for tab in mem:
otb = tab[self.sql.bwltab_col.index("btb_tab")]
if ok in ("A", "M"):
gdr = tab[self.sql.bwltab_col.index("btb_gender")]
if gdr == "M":
new = mstart
mstart += 1
else:
new = fstart
fstart += 1
key[otb] = new
else:
key[otb] = otb
for tab in non:
otb = tab[self.sql.bwltab_col.index("btb_tab")]
if ok in ("A", "N"):
key[otb] = nstart
nstart += 1
else:
key[otb] = otb
for ot in self.tables:
tt = "%s_temp" % ot[0]
cc = getattr(self.sql, "%s_col" % ot[0])
recs = self.sql.sqlRec("Select * from %s" % tt)
for rec in recs:
for k in ot[2:]:
c = rec[cc.index(k)]
if c not in key:
continue
rec[cc.index(k)] = key[c]
self.sql.insRec(ot[0], data=rec)
self.sql.sqlRec("Drop table %s" % tt)
self.opts["mf"].dbm.commitDbase(ask=True)
splash.closeSplash()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doProcess(self):
for tab in self.tables:
for x in range(len(tab[2:])):
whr = [(tab[1], "=", self.opts["conum"]),
(tab[x + 2], "=", self.oldtab)]
dat = [self.newtab]
col = [tab[x + 2]]
self.sql.updRec(tab[0], where=whr, data=dat, cols=col)
if "args" not in self.opts:
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
if "wait" not in self.opts:
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 gl1050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for control record and departments
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
# Check for multiple companies
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genrpc", "genstr",
"gendtm", "genrpt"], prog=self.__class__.__name__)
if self.sql.error:
return
acc = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if acc[0] > 1:
self.coys = True
else:
self.coys = False
self.strm = 0
return True
def doProcess(self):
st1 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_strm", "", 0, "Str"),
("gls_desc", "", 0, "Description", "Y")),
"where": [("gls_cono", "=", self.opts["conum"])],
"group": "gls_strm, gls_desc"}
st2 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_seq", "", 0, "Seq"),
("gls_typ", "", 0, "T"),
("gls_cno", "", 0, "CN"),
("gls_con", "", 0, "C"),
("gls_rep", "", 0, "Rep"),
("gls_gen", "", 0, "G"),
("gls_val", "", 0, "V"),
("gls_det", "", 0, "Det"),
("gls_var", "", 0, "B"),
("gls_zer", "", 0, "Z"),
("gls_opt", "", 0, "O"),
("gls_num", "", 0, "N"),
("gls_prnt", "", 20, "Printer-Name"),
("gls_mail", "", 20, "E-Mail-Address")),
"where": [("gls_cono", "=", self.opts["conum"])],
"whera": (("T", "gls_strm", 0, 0),),
"comnd": self.doSelTyp}
typ = {
"stype": "C",
"title": "Available Types",
"head": ("C", "Description"),
"data": (
("S", "YTD Report"),
("H", "Last 3 Years YTD Report"),
("L", "MTD and YTD Report"),
("M", "Monthly Report"),
("C", "Customised Report"))}
rpc = {
"stype": "R",
"tables": ("genrpc",),
"cols": (
("glc_cusno", "", 0, "CN"),
("glc_head1", "", 0, "Heading-1"),
("glc_head2", "", 0, "Heading-2"),
("glc_head3", "", 0, "Heading-3"),
("glc_head4", "", 0, "Heading-4")),
"where": [("glc_cono", "=", self.opts["conum"])]}
rpt = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_seq", "=", 0)],
"group": "glr_cono, glr_repno, glr_type, glr_desc",
"index": 1}
con = {
"stype": "C",
"title": "Available Options",
"head": ("C", "Description"),
"data": (
("V", "Actuals"),
("B", "Budgets"),
("C", "Actuals and Budgets"),
("X", "Variance to Budget"),
("D", "Detail"))}
det = {
"stype": "R",
"tables": ("gendtm",),
"cols": (
("gdm_code", "", 0, "Cod"),
("gdm_desc", "", 0, "Description")),
"where": [("gdm_cono", "=", self.opts["conum"])]}
prts = getPrinters(wrkdir=self.opts["mf"].rcdic["wrkdir"])
prts.insert(1, "Export")
if "None" not in prts:
prts.append("None")
prt = {
"stype": "C",
"titl": "Select Required Printer",
"head": ("Name", "Description"),
"data": prts}
cts = ("V", "B", "C", "X", "D")
fld = (
(("T",0,0,0),"IUI",3,"Stream-Number","Stream Number",
0,"Y",self.doStr,st1,None,("notzero",)),
(("T",0,0,0),"INA",30,"Description","",
"","N",self.doDsc,None,self.doDelStr,("notblank",)),
(("C",0,0,0),"IUI",3,"Seq","Sequence Number",
"i","N",self.doSeq,st2,None,("efld",)),
(("C",0,0,1),"IUA",1,"T","Report Type",
"S","N",self.doTyp,typ,self.doDelLin,
("in",("S","H","L","M","C"))),
(("C",0,0,2),"IUI",2,"CN","Custom Number",
0,"N",self.doCus,rpc,None,("efld",)),
(("C",0,0,3),"IUA",1,"C","Consolidate (Y/N)",
"N","N",self.doCon,None,None,("in",("Y","N"))),
(("C",0,0,4),"IUI",3,"Rep","Report Number",
0,"N",self.doRep,rpt,None,("notzero",)),
(("C",0,0,5),"IUA",1,"G","General Report (Y/N)",
"N","N",self.doGen,None,None,("in",("Y","N"))),
(("C",0,0,6),"IUA",1,"V","Report Contents",
"V","N",self.doContent,con,None,("in",cts)),
(("C",0,0,7),"INa",2,"Cod","Details Code",
"","N",self.doCod,det,None,None),
(("C",0,0,8),"IUA",1,"V","Variance (B/P/N)",
"B","N",self.doVar,None,None,("in",("B","P","N"))),
(("C",0,0,9),"IUA",1,"Z","Ignore Zeros (Y/N)",
"Y","N",None,None,None,("in",("Y","N"))),
(("C",0,0,10),"IUA",1,"O","Print Options (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,11),"IUA",1,"N","Print Numbers (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,12),"ITX",30,"Printer Name","Printer-Name",
"Default","N",self.doPrt,prt,None,("in",prts)),
(("C",0,0,13),"ITX",30,"E-Mail Address","E-Mail-Address",
"","N",None,None,None,("email",)))
but = (
("Cancel",None,self.doCancel,0,("C",0,1),("T",0,1)),
("Quit",None,self.exitTops,1,None,None))
self.df = TartanDialog(self.opts["mf"], eflds=fld,
tend=((self.endTops,"n"),), txit=(self.exitTops,),
cend=((self.endData,"y"),), cxit=(self.exitData,), butt=but)
self.df.focusField("T", 0, 1)
def doStr(self, frt, pag, r, c, p, i, w):
self.strm = w
self.old = self.sql.getRec("genstr", where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm)], limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
self.desc = self.old[self.sql.genstr_col.index("gls_desc")]
self.df.loadEntry(frt, pag, p+1, self.desc)
def doDelStr(self):
if self.new == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
def doDsc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
dt = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm), ("gls_seq", "=",
self.seq)], limit=1)
if not dt:
self.newlin = "y"
else:
self.newlin = "n"
for n, d in enumerate(dt[3:-1]):
self.df.loadEntry(frt, pag, p+n, data=d)
def doTyp(self, frt, pag, r, c, p, i, w):
self.typ = w
if self.typ != "C":
self.cno = 0
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+2, data="N")
return "sk2"
return "sk1"
def doCus(self, frt, pag, r, c, p, i, w):
cn = self.sql.getRec("genrpc", where=[("glc_cono", "=",
self.opts["conum"]), ("glc_cusno", "=", w)], limit=1)
if not cn:
return "Invalid Custom Report Number"
self.cno = w
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+1, data="N")
return "sk1"
def doCon(self, frt, pag, r, c, p, i, w):
self.con = w
def doRep(self, frt, pag, r, c, p, i, w):
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_repno", "=", w)], limit=1)
if not rp:
return "No Such Report"
self.rep = w
def doGen(self, frt, pag, r, c, p, i, w):
if w == "Y":
c = 0
else:
c = self.opts["conum"]
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("glr_cono", "=", c), ("glr_repno", "=", self.rep)],
limit=1)
if not rp:
return "No Such Report"
self.gen = w
def doContent(self, frt, pag, r, c, p, i, w):
if w in ("B", "C", "X") and self.typ in ("S", "L", "C"):
return "Invalid Choice for this Report Type"
if w == "D":
return
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def doCod(self, frt, pag, r, c, p, i, w):
d = self.sql.getRec("gendtm", cols=["gdm_desc"],
where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=",
w)], limit=1)
if not d:
return "Invalid Detail Code"
def doVar(self, frt, pag, r, c, p, i, w):
if self.typ == "C" and w not in ("B", "P"):
return "Invalid Variance, Only B or P"
def doPrt(self, frt, pag, r, c, p, i, w):
if w == "Export":
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def endTops(self):
if self.new == "y":
self.df.focusField("C", 0, 1)
else:
self.doLoadLines()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def exitTops(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSelTyp(self, frt, pag, r, c, p, i, w):
self.newlin = "n"
self.seq = w[0]
self.typ = w[1]
self.cno = w[2]
self.con = w[3]
self.rep = w[4]
self.gen = w[5]
for x, d in enumerate(w):
self.df.loadEntry(frt, pag, p+x, data=d)
self.df.focusField(frt, pag, c+1)
def doDelLin(self):
if self.newlin == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm), ("gls_seq", "=", self.seq)])
self.doReSeq()
def endData(self):
data = [self.opts["conum"], self.strm, self.desc, self.seq, self.typ,
self.cno, self.con, self.rep, self.gen]
for x in range(6, 14):
data.append(self.df.c_work[self.df.pag][self.df.row][x])
if self.newlin == "y":
self.sql.insRec("genstr", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genstr_col
data.append(self.old[col.index("gls_xflag")])
self.sql.updRec("genstr", data=data, where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm),
("gls_seq", "=", self.seq)])
self.doLoadLines()
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doReSeq(self):
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
if not recs:
self.newlin = "y"
self.df.focusField("C", 0, 1)
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
for seq, acc in enumerate(recs):
acc[3] = seq
self.sql.insRec("genstr", data=acc)
self.doLoadLines()
def doLoadLines(self):
self.df.clearFrame("C", 0)
pos = 0
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
for row, rec in enumerate(recs):
for num, dat in enumerate(rec[3:-1]):
self.df.loadEntry("C", 0, pos, data=dat)
pos += 1
if pos == (self.df.rows[0] * self.df.colq[0]):
self.df.scrollScreen(0)
pos = pos - self.df.colq[0]
pos += 1
self.df.focusField("C", 0, pos)
class arc110(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 = ["assctl", "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("assctl",
where=[("cta_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [self.opts["conum"], "N", "N", 0, "", ""]
else:
self.new = False
if self.genleg:
self.ctl = [["ass_sls", "Sale of Assets", 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):
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, "")]
seq = 2
else:
fld = []
seq = 0
fld.extend([(("T", 0, seq, 0), ("IRB", r1s), 0, "Receiver Dep", "",
self.acc[2], "N", None, None, None, None),
(("T", 0, seq + 1, 0), "Id2", 7, "Last Dep Period", "",
self.acc[3], "N", None, None, None, None),
(("T", 0, seq + 2, 0), "ITX", 50, "Email Address", "",
self.acc[4], "N", None, None, None, ("email", ))])
but = (("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 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]
return ""
def doGlint(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data="")
return "sk2"
def doGenAcc(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(frt, pag, p + 1, data=acc[0])
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 < 3:
if x in (1, ):
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, ):
continue
else:
data.append(d)
else:
data.append(d)
if self.new:
self.sql.insRec("assctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.assctl_col
data.append(self.acc[col.index("cta_xflag")])
self.sql.updRec("assctl",
data=data,
where=[("cta_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=[
"assctl", "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 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 ml2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] not in (1, 2, 3, 4):
showError(self.opts["mf"].body, "Control Error",
"Invalid Routine %s, Only 1-4 Are Allowed" % \
str(self.opts["rtn"]))
return
tabs = ["ctlvmf", "ctlvrf", "ctlvtf", "memmst", "memtrn"]
self.gc = GetCtl(self.opts["mf"])
memctl = self.gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.dis_all = ctlctl["dis_all"]
tabs.extend(["gentrn", "genmst"])
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"MEM",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.opts["rtn"] == 1:
self.glt = 1
elif self.opts["rtn"] == 2:
self.glt = 2
elif self.opts["rtn"] == 3:
self.glt = 4
elif self.opts["rtn"] == 4:
self.glt = 1
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def drawDialog(self):
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names",
"sort":
False
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N",
self.doMemAcc, mlm, None, ("notzero", )),
[("C", 1, 0, 1), "ONA", 10, "Name"],
(("C", 1, 0, 2), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doRefno, None, None, ("notblank", )),
(("C", 1, 0, 3), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 4), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("efld", ))]
if self.opts["rtn"] == 2:
fld[3][2] = 20
fld.extend([
(("C", 1, 0, 5), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, None, None,
"Discount Amount to be Added to the Transaction Amount."),
(("C", 1, 0, 6), "OSD", 13.2, "Total-Amount"),
(("C", 1, 0,
7), "INA", (20, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)
])
elif self.glint == "Y":
fld[3][2] = 24
fld.extend([
(("C", 1, 0, 5), "INA", 30, "Details", "Transaction Details",
"", "N", self.doTrnDet, None, None, None),
(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "",
"N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 19, "Description"),
(("C", 2, 0, 2), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode2, vtm, None, ("notblank", )),
(("C", 2, 0, 3), "ISD", 13.2, "All-Amt", "Allocation Amount",
"", "N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 4), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doAllVat, None, None, None),
(("C", 2, 0, 5), "INA", (26, 30), "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))
])
else:
fld[3][2] = 22
fld.extend([
(("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode1, vtm, None, ("notblank", )),
(("C", 1, 0, 7), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
(("C", 1, 0,
8), "INA", (20, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)
])
but = (
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",1),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",1),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",1),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",1),
("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] != 2 and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doMemAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memmst",
cols=["mlm_title", "mlm_initial", "mlm_surname"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", w)],
limit=1)
if not acc:
return "Invalid Member Number"
self.memno = w
self.name = "%s, %s %s" % (acc[2], acc[0], acc[1])
self.df.loadEntry("C", pag, p + 1, data=self.name)
def doRefno(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memtrn",
cols=["mlt_batch"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", w)],
limit=1)
if acc:
return "Transaction Already Exists"
self.refno = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if w > mthendDate(self.bh.curdt * 100):
return "Invalid Date, After Batch Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.glint == "Y" or self.opts["rtn"] == 2:
self.vatcode = "N"
self.vatamt = 0
def doVatCode1(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, self.vatamt)
if not self.vatamt:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.vatamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.vatamt = float(ASD(0) - ASD(w))
else:
self.vatamt = w
self.df.loadEntry(frt, pag, p, data=self.vatamt)
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.disamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.disamt = float(ASD(0) - ASD(w))
else:
self.disamt = w
self.df.loadEntry(frt, pag, p, data=self.disamt)
totamt = float(ASD(self.trnamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] != 2 and self.glint == "Y":
self.df.colf[2][5][5] = w
self.allocated = float(0.00)
def endPage1(self):
self.cancel = False
self.agecan = False
self.batupd = False
self.updateTables1()
if self.cancel:
return
else:
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] == 2 or self.glint == "N":
self.doMemTrn()
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.vatamt
if self.opts["rtn"] == 1: # Invoices
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 2: # Payment
if self.trnamt == 0:
recon = self.curdt
else:
recon = 0
self.vat = 0.00
self.dis = self.disamt
elif self.opts["rtn"] == 3: # Journal
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 4: # Credit Note
recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.dis = 0.00
if self.opts["rtn"] == 1:
self.ageloop = False
self.doAgeCurrent()
else:
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
if self.glint == "N":
return
# General Ledger Control Transaction (Members)
val = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.memctl, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, val, 0.00, self.trndet,
"N", "", recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Bank)
if self.opts["rtn"] == 2:
val = float(ASD(0) - ASD(self.amt))
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, val, 0.00,
self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.dis:
val = float(ASD(0) - ASD(self.dis))
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.refno, self.bh.batno, val,
0.00, self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="mem",
agetyp=atype,
agekey=[
self.opts["conum"], self.memno, self.opts["rtn"],
self.refno, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
if self.agevar.get():
self.agevar.set(False)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
if not chk[2]:
self.taxgl = self.taxdf
else:
self.taxgl = chk[2]
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
self.df.loadEntry("C", pag, p + 2, data=self.taxgl)
def doVatCode2(self, frt, pag, r, c, p, i, w):
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"], error=False)
if not ctlctl:
return "Missing ctlctl Record for Company"
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return "Missing or Invalid Control Record"
self.convat = ctlctl["vat_ctl"]
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if self.vatrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.allamt = round((allamt * 100 / (100 + self.vatrte)), 2)
self.df.loadEntry(frt, pag, p, data=self.allamt)
self.allvat = float(ASD(allamt) - ASD(self.allamt))
else:
self.allamt = w
self.allvat = round((self.allamt * self.vatrte / 100), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p + 2, data=self.name)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
self.allvat = float(ASD(0) - ASD(w))
elif self.allamt > 0 and w < 0:
self.allvat = float(ASD(0) - ASD(w))
else:
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.cancel = True
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
if self.glint == "Y":
self.df.clearFrame("C", 2)
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.selPage("Transaction")
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + \
ASD(self.allamt) + ASD(self.allvat))
if self.allocated == self.trnamt:
self.doMemTrn()
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1: # Invoices
self.credit()
elif self.opts["rtn"] == 3: # Journal Entry
self.credit()
elif self.opts["rtn"] == 4: # Credit Notes
self.debit()
def debit(self):
amt = self.allamt
vat = self.allvat
self.restDebitCredit(amt, vat)
def credit(self):
amt = float(ASD(0) - ASD(self.allamt))
vat = float(ASD(0) - ASD(self.allvat))
self.restDebitCredit(amt, vat)
def restDebitCredit(self, amt, vat):
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "O", self.curdt, "M",
self.glt, self.bh.batno, self.refno, self.trndat, self.memno,
self.alldet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Transaction (Expense)
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, amt, vat, self.alldet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if vat:
# General Ledger Control Transaction (V.A.T.)
data = (self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, vat, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
vat = float(ASD(0) - ASD(vat))
self.vat += vat
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def doMemTrn(self):
# Members Ledger Transaction
data = [
self.opts["conum"], self.memno, self.opts["rtn"], self.refno,
self.bh.batno, self.trndat, self.amt, self.vat, self.curdt, "", 0,
self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data)
if self.dis:
data = [
self.opts["conum"], self.memno, 6, self.refno, self.bh.batno,
self.trndat, self.dis, self.vat, self.curdt, "", 0,
self.trndet, self.vatcode, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data, unique="mlt_refno")
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
class 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 st6030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["strmf1", "strtrn", "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
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.curdt = int(self.sysdtw / 100)
return True
def dataHeader(self):
grp = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
self.stm = {
"stype": "R",
"tables": ("strmf1",),
"cols": (
("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [],
"whera": [["T", "st1_group", 0, 0]],
"index": 0}
fld = [
(("T",0,0,0),"INA",3,"Group","Product Group",
"","Y",self.doGroup,grp,None,("notblank",)),
(("T",0,1,0),"INA",20,"Code","Product Code",
"","N",self.doCode,self.stm,None,("notblank",)),
(("T",0,2,0),"ONA",30,"Description")]
but = (
("Generate",None,self.doGenerate,1,None,(("T",0,1),("T",0,2)),
"Mark zero items, which have been inactive, as redundant"),
("Create",None,self.doCreate,1,None,(("T",0,1),("T",0,2)),
"Mark a zero item as redundant"),
("Restore",None,self.doRestore,1,None,(("T",0,1),("T",0,2)),
"Mark a redundant item as normal"),
("Exit",None,self.exitPage,1,None,(("T",0,1),("T",0,2))))
tnd = ((self.endPage, "y"),)
txt = (self.exitPage,)
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, focus=False)
self.df.setWidget(self.df.B0, state="normal")
self.df.setWidget(self.df.B1, state="normal")
self.df.setWidget(self.df.B2, state="normal")
self.df.setWidget(self.df.B3, state="normal")
def doGenerate(self):
tit = "Generate Redundant Items"
fld = (
(("T",0,0,0),"IUI",3,"Months Inactive","",
24,"Y",self.doMonths,None,None,("efld",)),)
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.mt = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doMthEnd, "y"),), txit=(self.doMthExit,))
self.mt.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doMonths(self, frt, pag, r, c, p, i, w):
months = w
yr = int(self.curdt / 100)
mt = self.curdt % 100
for mth in range(months):
mt -= 1
if not mt:
mt = 12
yr -= 1
self.startp = (yr * 100) + mt
def doMthEnd(self):
self.mt.closeProcess()
whr = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "=", "N"),
("stt_cono=st1_cono",),
("stt_group=st1_group",),
("stt_code=st1_code",)]
accs = self.sql.getRec(tables=["strmf1", "strtrn"], cols=["st1_group",
"st1_code", "max(stt_curdt)", "sum(stt_qty)", "sum(stt_cost)"],
where=whr, order="st1_group, st1_code")
chgs = []
for acc in accs:
if acc[2] < self.startp and not acc[3] and not acc[4]:
chgs.append(acc[:2])
if not chgs:
showError(self.opts["mf"].body, "Processing Error",
"No Redundant Records")
else:
self.cnt = 0
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
p = ProgressBar(self.opts["mf"].body, mxs=len(chgs),
typ="Redundant Items")
for num, rec in enumerate(chgs):
p.displayProgress(num)
self.sql.updRec("strmf1", cols=["st1_type"], data=["X"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", rec[0]), ("st1_code", "=", rec[1])])
key = "%03i%-3s%-20s" % (self.opts["conum"], rec[0], rec[1])
self.sql.insRec("chglog", data=["strmf1", "U", key,
"st1_type", dte, self.opts["capnm"], "N", "X", "", 0])
p.closeProgress()
mess = """%s Items Will be Marked as Redundant.
Would you like to COMMIT these Changes?""" % len(chgs)
self.opts["mf"].dbm.commitDbase(ask=True, mess=mess)
def doMthExit(self):
self.mt.closeProcess()
def doCreate(self):
self.flag = "C"
self.stm["where"] = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")]
self.df.focusField("T", 0, 1)
def doRestore(self):
self.flag = "R"
self.stm["where"] = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "=", "X")]
self.df.focusField("T", 0, 1)
def doGroup(self, frt, pag, r, c, p, i, w):
if self.flag == "C":
chk = self.sql.getRec("strmf1", where=[("st1_cono",
"=", self.opts["conum"]), ("st1_group", "=", w),
("st1_type", "<>", "X")], limit=1)
else:
chk = self.sql.getRec("strmf1", where=[("st1_cono",
"=", self.opts["conum"]), ("st1_group", "=", w),
("st1_type", "=", "X")], limit=1)
if not chk:
return "Invalid Group"
self.grp = w
def doCode(self, frt, pag, r, c, p, i, w):
whr = [
("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", w)]
if self.flag == "C":
err = "Invalid, Not Normal"
whr.append(("st1_type", "=", "N"))
else:
err = "Invalid, Not Redundant"
whr.append(("st1_type", "=", "X"))
chk = self.sql.getRec("strmf1", where=whr, limit=1)
if not chk:
return err
if self.flag == "C":
qty = self.sql.getRec("strtrn", cols=["sum(stt_qty)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_group", "=", self.grp), ("stt_code", "=", w)],
limit=1)
if qty[0]:
return "Balance Exists"
self.cod = w
desc = chk[self.sql.strmf1_col.index("st1_desc")]
self.df.loadEntry(frt, pag, p+1, data=desc)
def endPage(self):
if self.flag == "C":
old = "N"
new = "X"
else:
old = "X"
new = "N"
self.sql.updRec("strmf1", cols=["st1_type"], data=[new],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp), ("st1_code", "=", self.cod)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
key = "%03i%-3s%-20s" % (self.opts["conum"], self.grp, self.cod)
self.sql.insRec("chglog", data=["strmf1", "U", key,
"st1_type", dte, self.opts["capnm"], old, new, "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("T", 0)
self.flag = ""
def exitPage(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class gl2010(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, ["ctlynd", "genmst", "genbal"],
prog=self.__class__.__name__)
if self.sql.error:
return
per = self.sql.getRec("ctlynd",
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", 0)],
limit=1)
if not per:
showError(
self.opts["mf"].body, "Period Error", """No Period 0!
Please Contact your Software Support and Quote this Message as this is a Serious Error!"""
)
return
self.start = per[self.sql.ctlynd_col.index("cye_start")]
return True
def drawDialog(self):
sel_acc = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
sel_all = {
"stype":
"R",
"tables": ("genbal", "genmst"),
"cols":
(("glo_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description"),
("glo_trdt", "", 0, "Date"), ("glo_cyr", "", 0, "Balance")),
"where": [("glo_cono", "=", self.opts["conum"]),
("glm_cono=glo_cono", ), ("glm_acno=glo_acno", ),
("glo_trdt", "=", self.start)]
}
fld = ((("C", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N",
self.doAcc, sel_acc, None, None), (("C", 0, 0, 1), "ONA", 30,
"Description"),
(("C", 0, 0, 2), "ISD", 13.2, "Balance", "Balance Value", "",
"N", self.doBal, None, None, None))
but = (("Import File", None, self.doImport, 0, ("C", 0, 1), ("C", 0,
2),
"Import Opening Balances from a CSV or XLS File."),
("All Entries", sel_all, None, 1, ("C", 0, 1), None,
"Display All Existing Balances"),
("Exit", None, self.exitData, 1, ("C", 0, 1), ("C", 0, 2)))
row = (20, )
self.df = TartanDialog(self.opts["mf"],
rows=row,
eflds=fld,
cend=((self.endData, "y"), ),
cxit=(self.exitData, ),
butt=but)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
impcol = [["Account Number", 0, "UI", 7],
["Opening Balance", 1, "SD", 13.2]]
fi = FileImport(self.opts["mf"], impcol=impcol)
err = None
for num, line in enumerate(fi.impdat):
if len(line) != 2:
err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \
(num + 1, 2, len(line))
break
self.acc = line[0]
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc)],
limit=1)
if not chk:
err = "Line %s: Invalid Account %s" % ((num + 1), self.acc)
break
self.bal = line[1]
self.old = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)],
limit=1)
if not self.old:
self.new_acc = "y"
else:
self.new_acc = "n"
self.endData(det=True)
if err:
showError(self.opts["mf"].body, "Import Error", err)
elif fi.impdat:
self.opts["mf"].dbm.commitDbase()
self.df.enableButtonsTags(state=state)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doAcc(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not desc:
return "Invalid Account Number"
self.acc = w
self.df.loadEntry(frt, pag, p + 1, data=desc[0])
self.old = self.sql.getRec("genbal",
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)],
limit=1)
if not self.old:
self.new_acc = "y"
else:
self.new_acc = "n"
bal = self.old[self.sql.genbal_col.index("glo_cyr")]
self.df.loadEntry(frt, pag, p + 2, data=bal)
def doBal(self, frt, pag, r, c, p, i, w):
self.bal = w
def endData(self, det=False):
data = [self.opts["conum"], self.acc, self.start, self.bal]
if self.new_acc == "y":
self.sql.insRec("genbal", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genbal_col
data.append(self.old[col.index("glo_xflag")])
self.sql.updRec("genbal",
data=data,
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)])
if det:
return
self.opts["mf"].dbm.commitDbase()
nxt = self.sql.getRec("genmst",
cols=["glm_acno"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", ">", self.acc)],
limit=1)
if nxt:
self.df.colf[0][0][5] = nxt[0]
else:
self.df.colf[0][0][5] = 0
self.df.advanceLine(0)
def exitData(self):
bals = self.sql.getRec("genbal",
cols=["sum(glo_cyr)"],
where=[("glo_cono", "=", self.opts["conum"]),
("glo_trdt", "=", self.start)],
limit=1)
if bals[0]:
diff = CCD(bals[0], "SD", 13.2)
showError(self.opts["mf"].body, "Out of Balance",
"Opening Balances Do Not Balance by %s" % diff.disp)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
else:
showInfo(
self.opts["mf"].body, "Year End",
"""A Year End for the Previous Period Must be Executed to Include These Opening Balances.
If the Current Period is 1 then the Year End for Period 0 must be Executed.""")
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ar2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
if self.opts["rtn"] not in (1, 2, 3):
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
self.gc = GetCtl(self.opts["mf"])
assctl = self.gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.glint = assctl["cta_glint"]
self.rordp = assctl["cta_rordp"]
tabs = [
"assgrp", "assmst", "assdep", "asstrn", "ctlvmf", "ctlvrf",
"ctlvtf", "genint", "genmst", "gentrn"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.glint == "Y":
# Check Sale of Asset Record
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, "ass_sls"):
return
self.slsac = ctlctl["ass_sls"]
# Check for VAT Control
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return
self.convat = ctlctl["vat_ctl"]
# Check All Group Control Records
errs = ("Group %s Has An Invalid", "Asset Control Account (%s)",
"Accumulated Depreciation Account (%s)",
"Depreciation Expense Account (%s)")
ass = self.sql.getRec(
"assgrp",
cols=["asg_group", "asg_assacc", "asg_depacc", "asg_expacc"],
where=[("asg_cono", "=", self.opts["conum"])])
for acc in ass:
for x in range(1, 4):
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", acc[x])],
limit=1)
if not chk:
mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x])
showError(self.opts["mf"].body, "Control Error", mess)
return
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"ASS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 2:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("assmst", ),
"cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0,
"Description", "Y")),
"where": [("asm_cono", "=", self.opts["conum"])],
"whera": [["C", "asm_group", 0, 1]]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
data = []
for x in range(1, (len(armvtp) + 1)):
data.append([x, armvtp[x - 1][1]])
mov = {
"stype": "C",
"titl": "Valid Types",
"head": ("C", "Description"),
"data": data
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N",
self.doAssGrp, grp, None, None),
(("C", 1, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "r", "N",
self.doAssCod, cod, None, ("notblank", )),
(("C", 1, 0, 2), "ONA", 13, "Description"),
(("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "IUI", 1, "M", "Movement Type", "r", "N",
self.doTrnMov, mov, None, ("in", (1, 2, 3, 4, 5))),
(("C", 1, 0, 6), "ISD", 13.2, "Company", "Company Amount", "",
"N", self.doCoyAmt, None, None, None),
(("C", 1, 0, 7), "ISD", 13.2, "Receiver", "Receiver Amount", "",
"N", self.doRorAmt, None, None, None),
(("C", 1, 0, 8), "IUA", 1, "V", "V.A.T Code", "C", "N",
self.doVatCod, vtm, None, ("notblank", )),
(("C", 1, 0, 9), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
(("C", 1, 0,
10), "INA", (13, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = (("Interrogate", None, self.queryAss, 0, ("C", 1, 1),
("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1)))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doAssGrp(self, frt, pag, r, c, p, i, w):
whr = [("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", w)]
acc = self.sql.getRec("assgrp", where=whr, limit=1)
if not acc:
return "Invalid Asset Group"
self.group = w
self.depcod = acc[self.sql.assgrp_col.index("asg_depcod")]
self.assacc = acc[self.sql.assgrp_col.index("asg_assacc")]
self.depacc = acc[self.sql.assgrp_col.index("asg_depacc")]
self.expacc = acc[self.sql.assgrp_col.index("asg_expacc")]
def doAssCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.buydt = 0
self.seldt = 0
col = ["asm_desc", "asm_depcod"]
whr = [("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group), ("asm_code", "=", self.code)]
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
ok = askQuestion(screen=self.opts["mf"].body,
head="New Asset",
mess="Asset does not exist, Create?")
if ok == "no":
return "Invalid Asset"
self.doNewAsset()
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
return "Asset Not Found"
self.new = "y"
else:
self.new = "n"
dep = self.sql.getRec("assdep",
cols=["asd_rate1r"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", acc[1])],
limit=1)
self.rate1r = dep[0]
col = ["ast_date"]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "=", 1)]
pur = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if pur:
self.buydt = pur[0]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "in", (3, 5))]
sel = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if sel:
self.seldt = sel[0]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
if self.new == "y":
self.trnmov = 1
self.df.loadEntry(frt, pag, p + 1, data=self.trnmov)
return "sk1"
def doTrnMov(self, frt, pag, r, c, p, i, w):
if type(w) == list:
w = w[0] + 1
# Do some tests to see if not new again or already sold etc.
if w == 4 and self.opts["rtn"] != 3:
return "Depreciation Only Allowed with Journal Entries"
if self.opts["rtn"] == 1 and w not in (1, 2):
return "Invalid Choice For Payment"
if self.opts["rtn"] == 2 and w not in (5, ):
return "Invalid Choice For Receipt"
if w == 1 and self.buydt:
return "Asset Already Purchased"
if w in (2, 3, 4, 5) and self.seldt:
return "Asset Already Sold or Written Off"
if w in (2, 3, 4, 5) and not self.buydt:
return "Asset Not Yet Purchased"
self.df.loadEntry(frt, pag, p, data=w)
self.trnmov = w
if self.trnmov == 3:
bal = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)", "sum(ast_amt2)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
self.coyamt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 1, data=self.coyamt)
self.roramt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 2, data=self.roramt)
self.vatcode = ""
self.trnvat = 0
return "sk4"
def doCoyAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.coyamt = w
if self.rordp == "N" or not self.rate1r or self.trnmov != 4:
self.roramt = 0
self.df.loadEntry(frt, pag, p + 1, data=self.roramt)
if self.trnmov == 4:
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 2, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 3, data=self.trnvat)
return "sk3"
return "sk1"
def doRorAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.roramt = w
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 1, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 2, data=self.trnvat)
return "sk2"
def doVatCod(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.trnvat = round((self.coyamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.trnvat)
if not self.trnvat:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.coyamt < 0 and w > 0:
self.trnvat = float(ASD(0) - ASD(w))
elif self.coyamt > 0 and w < 0:
self.trnvat = float(ASD(0) - ASD(w))
else:
self.trnvat = w
self.df.loadEntry(frt, pag, p, data=self.trnvat)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
self.df.colf[2][3][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if self.coyamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.glint == "N" or self.opts["rtn"] in (1, 2) or \
self.trnmov == 4:
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(1)
else:
self.coyamt = float(ASD(0) - ASD(self.coyamt))
self.df.loadEntry("T", 2, 0, data=self.coyamt)
self.df.selPage("Allocation")
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.coyamt
self.vat = self.trnvat
if self.trnmov == 4:
self.net = float(ASD(0) - ASD(self.coyamt))
self.ror = float(ASD(0) - ASD(self.roramt))
else:
self.net = self.ror = float(ASD(self.coyamt) - ASD(self.trnvat))
if self.opts["rtn"] == 1: # Payments
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
acc = self.assacc
self.glt = 2
elif self.opts["rtn"] == 2: # Receipts
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.net = float(ASD(0) - ASD(self.net))
acc = self.assacc
self.glt = 6
elif self.opts["rtn"] == 3: # Journal Entries
self.recon = 0
if self.trnmov == 4:
acc = self.depacc
else:
acc = self.assacc
self.glt = 4
# Asset Register Transaction
data = [
self.opts["conum"], self.group, self.code, self.opts["rtn"],
self.trnref, self.bh.batno, self.trndat, self.trnmov, self.net,
self.ror, self.vat, self.curdt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.vatcode:
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "I", self.curdt, "A",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.code, self.trndet, self.amt, self.vat, 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Asset or Depreciation Account
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, self.net, self.vat, self.trndet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.vat:
# General Ledger Control Transaction (V.A.T.)
data = [
self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.vat, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
self.amt = float(ASD(0) - ASD(self.amt))
if self.opts["rtn"] in (1, 2):
# General Ledger Control Transaction (Bank)
data = [
self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
elif self.trnmov == 4:
# General Ledger Expense Account (Depreciation)
data = [
self.opts["conum"], self.expacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.coyamt, self.vat,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.trnmov == 5:
# Sale of Asset
# Raise Depreciation
callModule(self.opts["mf"],
None,
"ar2030",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"],
args=(self.curdt, self.group, self.code))
# Generate Sale
amt = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
if amt[0]:
data = [
self.opts["conum"], self.slsac, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt[0], 0,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
data[1] = acc
data[7] = float(ASD(0) - ASD(amt[0]))
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int(int((self.df.last[1][1] - 1) / self.df.colq[1]))
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.coyamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
# General Ledger Transaction (Allocation)
amt = float(ASD(0) - ASD(self.allamt))
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt, 0.00, self.alldet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.coyamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.coyamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def doNewAsset(self):
tit = ("Create New Asset", )
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INA", 30, "Description", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 1, 0), "INa", 3, "Dep Code", "Depreciation Code",
self.depcod, "N", self.doDepCode, dep, None,
("notblank", )), (("T", 0, 1, 0), "ONA", 34, ""))
tnd = ((self.doNewEnd, "N"), )
txt = (self.doNewXit, )
state = self.df.disableButtonsTags()
self.na = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=self.fld,
tend=tnd,
txit=txt)
self.na.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doDepCode(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.na.loadEntry(frt, pag, p + 1, data=chk[0])
def doNewEnd(self):
dat = [self.opts["conum"], self.group, self.code]
for x in range(len(self.na.t_work[0][0]) - 1):
dat.append(self.na.t_work[0][0][x])
self.sql.insRec("assmst", data=dat)
self.doNewXit()
def doNewXit(self):
self.na.closeProcess()
def queryAss(self):
callModule(self.opts["mf"],
self.df,
"ar4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
class bkc210(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, ["bkmrtm", "bkmrtr", "bkmrtt"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def drawDialog(self):
brm = {
"stype": "R",
"tables": ("bkmrtm",),
"cols": (
("brm_code", "", 0, "Code"),
("brm_desc", "", 0, "Description"),
("brm_base", "", 0, "B")),
"where": [("brm_cono", "=", self.opts["conum"])],
"whera": [("T", "brm_type", 0, 0)],
"order": "brm_code"}
brr = {
"stype": "R",
"tables": ("bkmrtr",),
"cols": (
("brr_date", "", 0, "Start-Date"),
("brr_rate", "", 0, "Rte-Amount")),
"where": [("brr_cono", "=", self.opts["conum"])],
"whera": [("T", "brr_type", 0, 0), ("T", "brr_code", 1, 0)],
"order": "brr_date"}
r1s = (
("Accomodation","A"),
("Other","O"))
r2s = (
("/Unit/Person/Day","A"),
("/Unit/Person","B"),
("/Unit/Day","C"),
("/Unit","D"))
self.fld = (
(("T",0,0,0),("IRB",r1s),0,"Unit Type","",
"A","Y",self.doType,None,None,None),
(("T",0,1,0),"IUI",3,"Code","",
"","N",self.doCode,brm,None,None),
(("T",0,2,0),"ITX",30,"Description","",
"","N",None,None,self.doDelete,("notblank",)),
(("T",0,3,0),("IRB",r2s),0,"Rate Base","",
"A","N",self.doBase,None,None,None),
(("T",0,4,0),"Id1",10.2,"Starting Date","",
0,"N",self.doExpd,brr,None,("efld",)),
(("T",0,5,0),"IUD",10.2,"Rate Amount","",
0,"N",self.doRate,None,self.doDelete,("efld",)))
but = (("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 doType(self, frt, pag, r, c, p, i, w):
self.rtype = w
def doCode(self, frt, pag, r, c, p, i, w):
if not w:
acc = self.sql.getRec("bkmrtm", cols=["max(brm_code)"],
where=[("brm_cono", "=", self.opts["conum"]), ("brm_type",
"=", self.rtype)], limit=1)
if not acc[0]:
w = 1
else:
w = acc[0] + 1
self.df.loadEntry(frt, pag, p, data=w)
self.rcode = w
self.rtm = self.sql.getRec("bkmrtm", where=[("brm_cono", "=",
self.opts["conum"]), ("brm_type", "=", self.rtype), ("brm_code",
"=", self.rcode)], limit=1)
if not self.rtm:
self.newr = True
else:
self.newr = False
for num, dat in enumerate(self.rtm[3:-1]):
self.df.loadEntry(frt, pag, p+num+1, data=dat)
def doBase(self, frt, pag, r, c, p, i, w):
self.rbase = w
def doExpd(self, frt, pag, r, c, p, i, w):
self.newx = True
if not self.newr:
self.rtr = self.sql.getRec("bkmrtr", where=[("brr_cono",
"=", self.opts["conum"]), ("brr_type", "=", self.rtype),
("brr_code", "=", self.rcode), ("brr_date", "=", w)], limit=1)
if self.rtr:
self.newx = False
rate = self.rtr[self.sql.bkmrtr_col.index("brr_rate")]
self.df.loadEntry(frt, pag, p+1, data=rate)
self.date = w
def doRate(self, frt, pag, r, c, p, i, w):
self.rate = w
def doDelete(self):
if self.df.col == 6:
self.sql.delRec("bkmrtr", where=[("brr_cono", "=",
self.opts["conum"]), ("brr_type", "=", self.rtype),
("brr_code", "=", self.rcode), ("brr_date", "=", self.date)])
return
chk = self.sql.getRec("bkmrtt", where=[("brt_cono", "=",
self.opts["conum"]), ("brt_utype", "=", self.rtype), ("brt_rcode",
"=", self.rcode)])
if not chk:
# Rate has been used, do not delete master record only rates
self.sql.delRec("bkmrtm", where=[("brm_cono", "=",
self.opts["conum"]), ("brm_type", "=", self.rtype),
("brm_code", "=", self.rcode)])
self.sql.delRec("bkmrtr", where=[("brr_cono", "=", self.opts["conum"]),
("brr_type", "=", self.rtype), ("brr_code", "=", self.rcode)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
data.extend(self.df.t_work[0][0][:4])
if self.newr:
self.sql.insRec("bkmrtm", data=data)
elif data != self.rtm[:len(data)]:
col = self.sql.bkmrtm_col
data.append(self.rtm[col.index("brm_xflag")])
self.sql.updRec("bkmrtm", data=data, where=[("brm_cono", "=",
self.opts["conum"]), ("brm_type", "=", self.rtype),
("brm_code", "=", self.rcode)])
data = [self.opts["conum"]]
data.extend(self.df.t_work[0][0][:2])
data.extend(self.df.t_work[0][0][4:6])
if self.newx:
self.sql.insRec("bkmrtr", data=data)
elif data != self.rtr[:len(data)]:
col = self.sql.bkmrtr_col
data.append(self.rtr[col.index("brr_xflag")])
self.sql.updRec("bkmrtr", data=data, where=[("brr_cono",
"=", self.opts["conum"]), ("brr_type", "=", self.rtype),
("brr_code", "=", self.rcode), ("brr_date", "=", self.date)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class sc2030(object):
def __init__(self, **opts):
self.opts = opts
if "test" not in opts:
self.opts["test"] = None
if self.setVariables():
if self.opts["test"]:
self.doImport()
else:
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["scpcmp", "scpmem", "scpent", "scpgme"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.pair = 0
self.doimport = False
return True
def mainProcess(self):
com = {
"stype":
"R",
"tables": ("scpcmp", ),
"cols":
(("scp_ccod", "", 0, "CCD"), ("scp_name", "", 0, "Name", "Y"),
("scp_tsiz", "", 0, "S"), ("scp_fmat", "", 0, "F"),
("scp_nsec", "", 0, "NS"), ("scp_nent", "", 0, "NE")),
"where": [("scp_cono", "=", self.opts["conum"])]
}
self.sec = {
"stype": "C",
"titl": "Available Sections",
"head": ("Sec", "Club"),
"typs": (("Ua", 3), ("NA", 30)),
"data": []
}
self.skp = {
"stype":
"R",
"tables": ("scpmem", "scpgme"),
"cols": (("a", "UI", 6, "S-Code"), ("b", "NA", 30, "Name", "Y"),
("c", "UI", 6, "O-Code"), ("d", "NA", 30, "Name"),
("e", "UI", 3, "For"), ("f", "UI", 3, "Agt")),
"where": [],
"wtype":
"D"
}
tag = (("Results", None, ("T", 0, 0), ("T", 0, 1)), )
r1s = (("Main", "M"), ("Play-Offs", "P"))
fld = ((("T", 0, 0,
0), "I@scp_ccod", 0, "", "", "", "Y", self.doCmpCod, com,
None, ("notzero", )), (("T", 0, 0, 0), "O@scp_name", 0, ""),
(("T", 0, 1,
0), ("IRB", r1s), 0, "Type", "", "", "N", self.doCmpTyp, None,
None, None), (("T", 0, 2, 0), "I@scg_rnum", 0, "Round", "", "",
"N", self.doRndNum, None, None, ("notzero", )),
(("T", 1, 0, 0), "IUI", 2, "Section Number", "", "", "N",
self.doSecNum, None, None, ("notzero", )),
(("T", 1, 0, 0), "IUA", 1, "Sub-Section", "", "", "N",
self.doSubNum, None, None, ("in", ("A", "B"))),
(("C", 1, 0, 0), "I@scg_scod", 0, "", "", 0, "N", self.doSkpCod,
self.skp, None, ("notzero", )), (("C", 1, 0, 0), "ONA", 30,
"Skp-Name"),
(("C", 1, 0, 0), "I@scg_sfor", 0, "", "", "", "N", self.doShots,
None, None, ("efld", )), (("C", 1, 0, 0), "I@scg_ocod", 0, "",
"", 0, "N", self.doSkpCod, self.skp,
None, ("notzero", )),
(("C", 1, 0, 0), "ONA", 30,
"Opp-Name"), (("C", 1, 0, 0), "I@scg_sagt", 0, "", "", "", "N",
self.doShots, None, None, ("efld", )))
tnd = ((self.doTopEnd, "y"), (self.doTopEnd, "n"))
txt = (self.doTopExit, self.doTopExit)
cnd = (None, (self.doColEnd, "n"))
cxt = (None, self.doColExit)
but = (("Import Results", None, self.doImport, 0, ("T", 1, 1),
(("T", 1, 2), ("T", 1, 0))),
("Show Entries", None, self.doShow, 0, ("C", 1, 1), ("C", 1,
2)))
self.df = TartanDialog(self.opts["mf"],
tags=tag,
eflds=fld,
rows=(0, 16),
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("scpcmp",
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", w)],
limit=1)
if not com:
return "Invalid Competition Code"
if not com[2]:
return "Competiton Draw Not Yet Done"
chk = self.sql.getRec("scpent",
cols=["count(*)"],
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", w)],
limit=1)
if not chk[0]:
return "There are No Entries for this Competition"
self.ccod = w
self.name = com[self.sql.scpcmp_col.index("scp_name")]
self.fmat = com[self.sql.scpcmp_col.index("scp_fmat")]
self.nsec = com[self.sql.scpcmp_col.index("scp_nsec")]
self.nent = com[self.sql.scpcmp_col.index("scp_nent")]
self.ssub = com[self.sql.scpcmp_col.index("scp_subs")]
self.squa = com[self.sql.scpcmp_col.index("scp_qual")]
self.clup = com[self.sql.scpcmp_col.index("scp_clup")]
self.mrnds = com[self.sql.scpcmp_col.index("scp_mrnds")]
self.prnds = com[self.sql.scpcmp_col.index("scp_prnds")]
self.state = com[self.sql.scpcmp_col.index("scp_state")]
if not self.doimport:
self.df.loadEntry(frt, pag, p + 1, data=self.name)
self.byenum = 900000
if self.state < 3:
self.ctyp = "M"
self.lrnd = self.mrnds
if not self.doimport:
self.df.loadEntry(frt, pag, p + 2, data=self.ctyp)
return "sk2"
elif self.state == 6:
return "All Results Already Captured"
else:
self.ctyp = "P"
self.lrnd = self.prnds
if not self.doimport:
self.df.loadEntry(frt, pag, p + 2, data=self.ctyp)
def doCmpTyp(self, frt, pag, r, c, p, i, w):
self.ctyp = w
chk = self.sql.getRec(
"scpgme",
cols=["count(*)", "sum(scg_sfor)", "sum(scg_sagt)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P")],
limit=1)
if self.ctyp == "M":
if chk[0] and (chk[1] or chk[2]):
return "Play-Offs Already Started"
self.lrnd = self.mrnds
elif not chk[0]:
return "Play-Offs Draw Not Yet Done"
else:
self.lrnd = self.prnds
def doRndNum(self, frt, pag, r, c, p, i, w):
if self.ctyp == "M" and self.clup == "Y" and w > 1:
more = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_rnum", "=", w - 1),
("scg_ocod", "=", 0)],
limit=1)[0]
if more:
return "Closed-Up Draw, Round %s Results Missing" % (w - 1)
if w > self.lrnd:
return "Invalid Round, Exceeds Maximum (%s)" % self.lrnd
if w > 1:
chk = self.sql.getRec("scpgme",
cols=[
"scg_scod", "scg_ocod", "sum(scg_sfor)",
"sum(scg_sagt)"
],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w - 1)])
for s in chk:
if s[0] < 900000 and s[1] < 900000 and not s[2] and not s[3]:
return "Invalid Round, Previous Round Missing"
chk = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "<", w),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("(", "scg_sfor", "=", 0, "and",
"scg_sagt", "=", 0, ")")])
if chk:
return "Previous Round Not Yet Completely Captured"
chk = self.sql.getRec("scpgme",
cols=["sum(scg_sfor)", "sum(scg_sagt)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", ">", w)],
limit=1)
if chk[0] or chk[1]:
return "Invalid Round, Later Rounds Captured"
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)])[0]
if not chk:
ok = askQuestion(self.opts["mf"].body,
"Already Entered",
"""All Results for this Round Already Captured.
Would you Like to Recapture this Round?""",
default="no")
if ok == "no":
return "Already Captured"
if self.fmat == "K" or self.ctyp == "R":
if self.ctyp == "M" and w == self.mrnds:
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "R")])
else:
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w + 1)])
self.rnum = w
self.doimport = False
def doImport(self):
self.doimport = True
if self.opts["test"]:
self.ccod, self.rnum, impfle = self.opts["test"]
err = self.doCmpCod("T", 0, 0, 0, 0, 0, self.ccod)
if err:
print(err)
return
self.doGetOldWin()
impdlg = False
else:
impfle = None
impdlg = True
self.df.setWidget(self.df.mstFrame, state="hide")
cols = [["scg_snum", 0, "UI", 2], ["scg_subs", 1, "UA", 1],
["scg_scod", 2, "UI", 6], ["scg_ocod", 3, "UI", 6],
["scg_sfor", 4, "UI", 2], ["scg_sagt", 5, "UI", 2]]
fi = FileImport(self.opts["mf"],
impcol=cols,
impfle=impfle,
impdlg=impdlg)
if fi.impdat:
if not self.opts["test"]:
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Results",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
if not self.opts["test"]:
sp.displayProgress(num)
if not line[0]:
continue
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", line[0]), ("scg_subs", "=", line[1]),
("scg_rnum", "=", self.rnum)]
if self.clup == "Y":
self.newo = True
whr.append(("scg_scod", "in", (line[2], line[3])))
else:
self.newo = False
whr.append(("scg_scod", "=", line[2]))
whr.append(("scg_ocod", "=", line[3]))
chk = self.sql.getRec("scpgme", where=whr)
if not chk:
err = "Invalid Skip %s, Opponent %s" % (line[2], line[3])
break
if line[2] > 900000 or line[3] > 900000:
pass
elif not line[4] and not line[5]:
err = "Zero Results"
break
self.snum = line[0]
self.subs = line[1]
self.scod = line[2]
self.ocod = line[3]
self.sfor = line[4]
self.sagt = line[5]
self.doColEnd()
if not self.opts["test"]:
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.ierr = False
if self.ssub == "Y":
secs = int(self.nsec / 2)
else:
secs = self.nsec
for self.snum in range(1, secs + 1):
if self.ssub == "Y":
for self.subs in ("A", "B"):
self.doColExit()
if self.ierr:
break
if self.ierr:
break
else:
self.subs = ""
self.doColExit()
if self.ierr:
break
if not self.ierr:
self.opts["mf"].dbm.commitDbase()
self.doTopExit()
if not self.opts["test"]:
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField("T", 0, 1)
def doSecNum(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", w)],
limit=1)
if not chk:
return "Invalid Section Number"
self.snum = w
if self.ssub == "N" or self.ctyp == "P":
self.subs = ""
self.df.loadEntry(frt, pag, p + 1, data=self.subs)
self.doLoadSkips()
return "sk1"
def doSubNum(self, frt, pag, r, c, p, i, w):
self.subs = w
self.doLoadSkips()
def doTopEnd(self):
if self.df.pag == 0:
if self.ctyp == "P":
self.snum = 1
self.df.loadEntry("T", 1, 0, data=self.snum)
self.subs = ""
self.df.loadEntry("T", 1, 1, data=self.subs)
self.doLoadSkips()
self.df.focusField("C", 1, 1)
else:
self.doGetOldWin()
self.df.focusField("T", 1, 1)
else:
self.df.focusField("C", 1, 1)
def doLoadSkips(self):
col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"]
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum), ("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs), ("scg_ocod", "<", 900000)]
data = []
recs = self.sql.getRec("scpgme", cols=col, where=whr)
for rec in recs:
data.append((rec[0], self.getName(rec[0]), rec[1],
self.getName(rec[1]), rec[2], rec[3]))
self.skp["where"] = data
def doTopExit(self):
if not self.opts["test"] and self.df.pag == 0:
self.df.closeProcess()
self.opts["mf"].closeLoop()
else:
# Check all entries for round
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)[0]
if chk:
txt = "Not All the Results for Round %s Captured" % self.rnum
if self.opts["test"]:
self.opts["mf"].dbm.rollbackDbase()
return
txt = "%s\n\nDo You want to Exit and Lose All Results for "\
"this Round?" % txt
ok = askQuestion(self.opts["mf"].body,
"Missing Results",
txt,
default="no")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 1, 1)
return
if self.rnum == self.lrnd:
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "M"),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)[0]
if not chk:
# Update scpcmp if no missing entries
self.sql.updRec("scpcmp",
cols=["scp_state"],
data=[3],
where=[("scp_cono", "=",
self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
self.opts["mf"].dbm.commitDbase()
if not self.doimport:
if self.ctyp == "P":
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 0, 1)
def doSkpCod(self, frt, pag, r, c, p, i, w):
skp = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", w)],
limit=1)
if not skp:
return "Invalid Skip"
if skp[self.sql.scpgme_col.index("scg_ocod")] > 900000:
return "Skip has a Bye"
if i == 3:
if w == self.scod:
return "Playing Against Himself?"
if skp[self.sql.scpgme_col.index("scg_ocod")]:
return "Already Paired"
self.ocod = w
onam = self.getName(self.ocod)
self.df.loadEntry("C", 1, p + 1, data=onam)
self.df.loadEntry("C", 1, p + 2, data=0)
return
self.scod = w
snam = self.getName(w)
self.df.loadEntry("C", 1, p + 1, data=snam)
sfor = skp[self.sql.scpgme_col.index("scg_sfor")]
self.df.loadEntry("C", 1, p + 2, data=sfor)
self.ocod = skp[self.sql.scpgme_col.index("scg_ocod")]
if self.ocod:
self.newo = False
self.df.loadEntry("C", 1, p + 3, data=self.ocod)
onam = self.getName(self.ocod)
self.df.loadEntry("C", 1, p + 4, data=onam)
ofor = skp[self.sql.scpgme_col.index("scg_sagt")]
self.df.loadEntry("C", 1, p + 5, data=ofor)
else:
self.newo = True
def getName(self, code):
if code > 900000:
return "Bye"
nam = self.sql.getRec("scpmem",
cols=["scm_surname", "scm_names"],
where=[("scm_cono", "=", self.opts["conum"]),
("scm_scod", "=", code)],
limit=1)
return "%s, %s" % (nam[0], nam[1][0])
def doShots(self, frt, pag, r, c, p, i, w):
if i == 2:
self.sfor = w
if not self.newo:
return "sk2"
else:
self.sagt = w
def doPoints(self, frt, pag, r, c, p, i, w):
pass
def doColEnd(self):
if self.fmat == "K":
if self.newo:
self.sql.delRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.ocod)])
cols = ["scg_ocod"]
data = [self.ocod]
else:
cols = []
data = []
if self.clup == "Y":
cols.extend(["scg_sfor", "scg_sagt", "scg_pair"])
self.pair += 1
data.extend([self.sfor, self.sagt, self.pair])
else:
cols.extend(["scg_sfor", "scg_sagt"])
data.extend([self.sfor, self.sagt])
self.sql.updRec("scpgme",
cols=cols,
data=data,
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.scod)])
else:
if self.sfor == self.sagt:
pfor = .5
pagt = .5
elif self.sfor > self.sagt:
pfor = 1
pagt = 0
else:
pfor = 0
pagt = 1
self.sql.updRec("scpgme",
cols=["scg_sfor", "scg_sagt", "scg_pnts"],
data=[self.sfor, self.sagt, pfor],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.scod)])
self.sql.updRec("scpgme",
cols=["scg_sfor", "scg_sagt", "scg_pnts"],
data=[self.sagt, self.sfor, pagt],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.ocod)])
self.scod = 0
if not self.doimport:
self.doLoadSkips()
self.df.advanceLine(1)
def doShow(self):
cols = (("scod", "Skip", 6, "UI",
"N"), ("sname", "Name", 30, "NA",
"N"), ("sfor", "Shots", 5, "UI", "N"), ("ocod", "Oppt",
6, "UI", "N"),
("oname", "Name", 30, "NA", "N"), ("sagt", "Shots", 5, "UI",
"N"))
recs = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum)])
done = []
data = []
for rec in recs:
scod = rec[self.sql.scpgme_col.index("scg_scod")]
ocod = rec[self.sql.scpgme_col.index("scg_ocod")]
if scod in done or scod > 900000 or ocod in done or ocod > 900000:
continue
sfor = rec[self.sql.scpgme_col.index("scg_sfor")]
sagt = rec[self.sql.scpgme_col.index("scg_sagt")]
data.append((scod, self.getName(scod), sfor, ocod,
self.getName(ocod), sagt))
SelectChoice(self.opts["mf"].window, "Results", cols, data)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doColExit(self):
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("(", "scg_sfor", "=", 0, "and",
"scg_sagt", "=", 0, ")")],
limit=1)
if chk[0] and (self.clup == "N" or self.ctyp == "P" or \
(self.clup == "Y" and self.rnum > 1)):
# All results for section not yet entered
if self.doimport:
showError(self.opts["mf"].body, "Missing Results",
"Some Results are Missing, Please Check Import "\
"File and Retry")
self.opts["mf"].dbm.rollbackDbase()
self.ierr = True
return
ok = askQuestion(self.opts["mf"].body, "Missing Results",
"Some Result are Missing. Do You want to Exit and Lose "\
"the Results for this Section?")
if ok == "no":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.opts["mf"].dbm.rollbackDbase()
else:
chk = self.doUpdateTables()
if not self.doimport:
if chk == "continue":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
if chk == "abort":
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
if not self.doimport:
self.df.clearFrame("T", 1)
self.df.clearFrame("C", 1)
if self.ctyp == "P":
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 1, 1)
def doUpdateTables(self):
nrnd = self.rnum + 1
if self.fmat == "K" and self.clup == "Y" and self.ctyp == "M":
# Closed up draw (1st and maybe 2nd Round)
skps = self.sql.getRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum)])
byes = []
nums = {}
for skp in skps:
scod = skp[self.sql.scpgme_col.index("scg_scod")]
ocod = skp[self.sql.scpgme_col.index("scg_ocod")]
if not ocod:
byes.append(scod)
nums[scod] = skp
for skp in byes:
if self.opts["test"]:
ok = "B"
else:
ok = askChoice(self.opts["mf"].body, "Capture Error",
"The Results for Skip %s - %s is Missing. Did he/she "\
"Withdraw or have a Bye?" % (skp, self.getName(skp)),
butt=(("No", "N"), ("Withdraw", "W"), ("Bye", "B"),
("Abort", "A")), default="Bye")
if ok == "N":
return "continue"
if ok == "A":
return "abort"
if ok == "W":
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_scod", "=", skp)])
byes.remove(skp)
del nums[skp]
continue
for scod in nums:
rec = nums[scod]
scod = rec[self.sql.scpgme_col.index("scg_scod")]
ocod = rec[self.sql.scpgme_col.index("scg_ocod")]
sfor = rec[self.sql.scpgme_col.index("scg_sfor")]
sagt = rec[self.sql.scpgme_col.index("scg_sagt")]
where = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs), ("scg_rnum", "=", nrnd),
("scg_scod", "=", scod)]
if scod in byes:
self.byenum += 1
# Create bye
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[self.byenum],
where=where)
if nrnd < self.lrnd:
# Create next round record
rec[self.sql.scpgme_col.index("scg_rnum")] = nrnd
rec[self.sql.scpgme_col.index("scg_ocod")] = 0
rec[self.sql.scpgme_col.index("scg_sfor")] = 0
rec[self.sql.scpgme_col.index("scg_sagt")] = 0
rec[self.sql.scpgme_col.index("scg_seed")] = 0
rec[self.sql.scpgme_col.index("scg_pair")] = 0
if scod not in byes and sfor < sagt and ocod:
scod = ocod
rec[self.sql.scpgme_col.index("scg_scod")] = scod
chk = self.sql.getRec("scpgme", where=where, limit=1)
if not chk:
self.sql.insRec("scpgme", data=rec)
else:
self.sql.updRec("scpgme", data=rec, where=where)
else:
# Update playoff records
cod = self.snum + 700000
if sfor > sagt:
win = scod
else:
win = ocod
whr = where[:6]
whr[2] = ("scg_ctyp", "=", "P")
whr[3] = ("scg_snum", "=", 1)
whr[5] = ("scg_rnum", "=", 1)
whr.append(("scg_scod", "=", cod))
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win],
where=whr)
whr[6] = ("scg_ocod", "=", cod)
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win],
where=whr)
if (self.fmat == "K" and self.clup == "N") or self.ctyp == "P":
recs = self.sql.getRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_rnum", "=", self.rnum)],
order="scg_group, scg_pair")
group = 0
for num in range(0, len(recs), 2):
one = recs[num]
snum = one[self.sql.scpgme_col.index("scg_snum")]
subs = one[self.sql.scpgme_col.index("scg_subs")]
if group != one[self.sql.scpgme_col.index("scg_group")]:
group = one[self.sql.scpgme_col.index("scg_group")]
pair = 1
else:
pair += 1
cod1 = one[self.sql.scpgme_col.index("scg_scod")]
opp1 = one[self.sql.scpgme_col.index("scg_ocod")]
for1 = one[self.sql.scpgme_col.index("scg_sfor")]
agt1 = one[self.sql.scpgme_col.index("scg_sagt")]
if opp1 > 900000 or for1 > agt1:
win1 = cod1
else:
win1 = opp1
if len(recs[num:]) > 1:
two = recs[num + 1]
cod2 = two[self.sql.scpgme_col.index("scg_scod")]
opp2 = two[self.sql.scpgme_col.index("scg_ocod")]
for2 = two[self.sql.scpgme_col.index("scg_sfor")]
agt2 = two[self.sql.scpgme_col.index("scg_sagt")]
if opp2 > 900000 or for2 > agt2:
win2 = cod2
else:
win2 = opp2
else:
win2 = 0
# Create next round record
sgc = self.sql.scpgme_col
whr = [("scg_cono", "=", one[sgc.index("scg_cono")]),
("scg_ccod", "=", one[sgc.index("scg_ccod")]),
("scg_ctyp", "=", one[sgc.index("scg_ctyp")]),
("scg_snum", "=", one[sgc.index("scg_snum")]),
("scg_subs", "=", one[sgc.index("scg_subs")]),
("scg_rnum", "=", nrnd),
("scg_ktyp", "=", one[sgc.index("scg_ktyp")]),
("scg_scod", "=", win1)]
one[sgc.index("scg_rnum")] = nrnd
one[sgc.index("scg_scod")] = win1
one[sgc.index("scg_ocod")] = win2
one[sgc.index("scg_sfor")] = 0
one[sgc.index("scg_sagt")] = 0
one[sgc.index("scg_pnts")] = 0
one[sgc.index("scg_pair")] = pair
if not self.sql.getRec("scpgme", where=whr, limit=1):
self.sql.insRec("scpgme", data=one)
else:
self.sql.updRec("scpgme",
cols=["scg_ocod", "scg_pair"],
data=[win2, pair],
where=whr)
if self.rnum == self.lrnd and \
self.ctyp == "M" and self.nsec > 2:
# Create playoff records with winners codes
if not self.oldwin:
if subs == "B":
key = snum + 800000
else:
key = snum + 700000
else:
key = self.oldwin[snum]
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win1],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_scod", "=", key)])
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win1],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_ocod", "=", key)])
elif self.squa == "S" and self.rnum == self.lrnd:
# Update playoff records with winners codes
if self.ssub == "Y":
lsub = "B"
else:
lsub = ""
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs)]
if self.fmat == "K":
col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"]
whr.append(("scg_rnum", "=", self.lrnd))
rec = self.sql.getRec("scpgme", cols=col, where=whr, limit=1)
if rec[2] > rec[3]:
win = rec[0]
else:
win = rec[1]
else:
self.doGetNewWin(sect=self.snum, sub=self.subs)
win = self.newwin[self.snum]
if not self.oldwin:
if self.subs == "B":
key = self.snum + 800000
else:
key = self.snum + 700000
else:
key = self.oldwin[self.snum]
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_scod", "=", key)])
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_ocod", "=", key)])
if self.snum == self.nsec and self.subs == lsub:
self.sql.updRec("scpgme",
cols=["scg_ktyp"],
data=["M"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P")])
# Check if all results for the round are captured
chek = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)
if chek[0]:
return
if self.clup == "Y" and self.ctyp == "M" and nrnd == self.lrnd:
state = 3
elif self.rnum == self.lrnd:
if self.ctyp == "M":
state = 3
else:
state = 6
elif self.ctyp == "M":
state = 2
else:
state = 5
self.sql.updRec("scpcmp",
cols=["scp_state"],
data=[state],
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
def doGetOldWin(self):
self.oldwin = {}
if self.ctyp == "M" and self.rnum == self.lrnd:
recs = self.sql.getRec("scpgme",
cols=["scg_scod", "scg_ocod"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_snum", "=", 1)])
for rec in recs:
for cod in rec:
if cod < 900000:
sec = self.sql.getRec("scpgme",
cols=["scg_snum"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=",
self.ccod),
("scg_ctyp", "=", "M"),
("scg_scod", "=", cod)],
limit=1)
if sec:
self.oldwin[sec[0]] = cod
def doGetNewWin(self, sect=None, sub=""):
# Get Leaders
self.newwin = {}
if sect is None:
secs = []
for x in range(self.nsec):
secs.append(x + 1)
else:
secs = [sect]
for sec in secs:
col = [
"scg_scod", "sum(scg_pnts) as a",
"sum(scg_sfor - scg_sagt) as b",
"round(sum(scg_sfor) / sum(scg_sagt), 2) as c"
]
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "M"),
("scg_snum", "=", sec), ("scg_subs", "=", sub)]
grp = "scg_scod"
odr = "a desc, b desc, c desc"
rec = self.sql.getRec("scpgme",
cols=col,
where=whr,
group=grp,
order=odr,
limit=1)
self.newwin[sec] = rec[0]
class ln2030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"genmst", "gentrn", "lonctl", "lonmf1", "lonmf2", "lonrte",
"lontrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
lonctl = self.gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
self.glint = lonctl["cln_glint"]
self.drate = lonctl["cln_drte"]
self.crate = lonctl["cln_crte"]
self.lastd = lonctl["cln_last"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["lon_ctl"]):
return
self.glctl = (ctlctl["lon_ctl"], ctlctl["int_rec"],
ctlctl["int_pay"])
else:
self.glctl = None
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
lm1 = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols":
(("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")),
"where": [("lm1_cono", "=", self.opts["conum"])]
}
lm2 = {
"stype":
"R",
"tables": ("lonmf2", ),
"cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0,
"Description", "Y")),
"where": [("lm2_cono", "=", self.opts["conum"])],
"whera": [("C", "lm2_acno", 0, 0)]
}
dte = {
"stype":
"R",
"tables": ("lonrte", ),
"cols":
(("lrt_start", "", 0, "Start-Date"), ("lrt_drte", "", 0, "DRte-%"),
("lrt_crte", "", 0, "CRte-%")),
"where": [("lrt_cono", "=", self.opts["conum"])],
"whera": [("C", "lrt_acno", 0, 0), ("C", "lrt_loan", 2, 0)],
"order":
"lrt_start"
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "All Current Rates", "", "N",
"N", self.doAll, None, None,
None), (("T", 0, 1, 0), "ID1", 10, "Effective Date", "", "",
"N", self.doSdate, None, None, ("efld", )),
(("T", 0, 2, 0), "IUD", 6.2, "Debit Rate - Old", "",
self.drate, "N", self.doDRte, None, None, None),
(("T", 0, 2, 0), "IUD", 6.2, "New", "New Debit Rate", "", "N",
self.doDRte, None, None,
None), (("T", 0, 3, 0), "IUD", 6.2, "Credit Rate - Old", "",
self.crate, "N", self.doCRte, None, None, None),
(("T", 0, 3, 0), "IUD", 6.2, "New", "New Credit Rate", "", "N",
self.doCRte, None, None,
None), (("C", 0, 0, 0), "IUA", 7, "Acc-Num", "Account Number",
"", "N", self.doAcc, lm1, None, None),
(("C", 0, 0, 1), "ONA", 30,
"Name"), (("C", 0, 0, 2), "IUI", 2, "Ln", "Loan Number", "",
"N", self.doLon, lm2, None, None),
(("C", 0, 0, 3), "ONA", 30,
"Description"), (("C", 0, 0, 4), "ID1", 10, "Date", "", "",
"N", self.doSdate, dte, None, ("efld", )),
(("C", 0, 0, 5), "IUD", 6.2, "DRte-%", "Debit Rate", "", "N",
self.doDRte, None, None,
None), (("C", 0, 0, 6), "IUD", 6.2, "CRte-%", "Credit Rate",
"", "N", self.doCRte, None, None, None))
tnd = ((self.endPage, "y"), )
txt = (self.exitPage, )
cnd = ((self.endPage, "y"), )
cxt = (self.exitPage, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doAll(self, frt, pag, r, c, p, i, w):
self.allrte = w
if self.allrte == "N":
return "nd"
def doSdate(self, frt, pag, r, c, p, i, w):
if w <= self.lastd:
return "Invalid Date, Before Last Interest Raise Date"
self.sdate = w
self.curdt = int(w / 100)
self.chgrte = False
if self.allrte == "N":
chk = self.sql.getRec("lonrte",
where=[("lrt_cono", "=", self.opts["conum"]),
("lrt_acno", "=", self.acno),
("lrt_loan", "=", self.loan),
("lrt_start", "=", w)],
limit=1)
if chk:
self.df.loadEntry(frt, pag, p + 1, data=chk[4])
self.df.loadEntry(frt, pag, p + 2, data=chk[5])
ok = askQuestion(self.opts["mf"].body,
"Exists",
"""This Date "Already Exists.
Debit Rate: %s Credit Rate: %s
Changing It Could Cause Problems.
Would You Like to Continue?""" % (chk[4], chk[5]),
default="no")
if ok == "no":
return "rf"
self.chgrte = True
def doDRte(self, frt, pag, r, c, p, i, w):
if self.df.frt == "T" and p == 2:
self.oldd = w
else:
self.newd = w
def doCRte(self, frt, pag, r, c, p, i, w):
if self.df.frt == "T" and p == 4:
self.oldc = w
else:
self.newc = w
def doAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("lonmf1",
cols=["lm1_name"],
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.acno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
def doLon(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("lonmf2",
where=[("lm2_cono", "=", self.opts["conum"]),
("lm2_acno", "=", self.acno),
("lm2_loan", "=", w)],
limit=1)
if not acc:
return "Invalid Loan Number"
self.loan = w
desc = acc[self.sql.lonmf2_col.index("lm2_desc")]
self.start = acc[self.sql.lonmf2_col.index("lm2_start")]
self.pmths = acc[self.sql.lonmf2_col.index("lm2_pmths")]
if self.pmths:
return "Fixed Loan, Rate Change Not Allowed"
self.df.loadEntry("C", pag, p + 1, data=desc)
def endPage(self):
if self.df.frt == "T":
if self.allrte == "N":
self.df.focusField("C", 0, 1)
else:
self.updateTables()
self.opts["mf"].dbm.commitDbase(True)
self.exitPage()
else:
self.updateTables()
self.df.advanceLine(0)
def exitPage(self):
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase(True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def updateTables(self):
if self.allrte == "Y":
if self.oldd == self.drate and self.oldc == self.crate:
self.sql.updRec("lonctl",
cols=["cln_drte", "cln_crte"],
data=[self.newd, self.newc],
where=[("cln_cono", "=", self.opts["conum"])])
whr = [("lm2_cono", "=", self.opts["conum"]),
("lrt_cono=lm2_cono", ), ("lrt_acno=lm2_acno", ),
("lrt_loan=lm2_loan", ), ("lrt_drte", "=", self.oldd),
("lrt_crte", "=", self.oldc)]
recs = self.sql.getRec(tables=["lonmf2", "lonrte"],
cols=["lm2_acno", "lm2_loan", "lm2_pmths"],
where=whr,
group="lm2_acno, lm2_loan, lm2_pmths",
order="lm2_acno")
else:
recs = [[self.acno, self.loan, 0]]
for rec in recs:
if rec[2]:
# Fixed Period Loan, No Rate Changes Allowed
continue
# Loans Rate Record
if self.chgrte:
self.sql.updRec("lonrte",
cols=["lrt_drte", "lrt_crte"],
data=[self.newd, self.newc],
where=[("lrt_cono", "=", self.opts["conum"]),
("lrt_acno", "=", rec[0]),
("lrt_loan", "=", rec[1]),
("lrt_start", "=", self.sdate)])
else:
self.sql.insRec("lonrte",
data=[
self.opts["conum"], rec[0], rec[1],
self.sdate, self.newd, self.newc
])
class 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 glc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genmst", "genint"],
prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if chk[0] == 1:
showInfo(self.opts["mf"].body, "Intercompany",
"There is Only 1 Company Record")
return
return True
def mainProcess(self):
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy-Num"),
("ctm_name", "", 0, "Name", "Y")),
"where": [("ctm_cono", "!=", self.opts["conum"])]}
gl1 = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]}
gl2 = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"whera": [["T", "glm_cono", 0, 0]]}
data = self.sql.getRec(tables=["genint", "genmst"], cols=["cti_inco",
"glm_desc"], where=[("cti_cono", "=", self.opts["conum"]),
("glm_cono=cti_cono",), ("glm_acno=cti_acno",)], order="cti_inco")
self.gl3 = {
"stype": "C",
"titl": "Existing Companies",
"head": ("Coy","Name"),
"typs": (("UI", 3), ("NA", 30)),
"data": data}
fld = (
(("T",0,0,0,14),"IUI",3,"Coy-Num","Company Number",
"","Y",self.doCoyNum,coy,None,None),
(("T",0,0,17),"ONA",30,""),
(("T",0,1,0,10),"IUI",7,"Acc-Num-1","G/L Account Number",
"","N",self.doAccNum1,gl1,self.doDelete,("notzero",),None,
"The above company's account number in company %s." %
self.opts["conum"]),
(("T",0,1,17),"ONA",30,""),
(("T",0,2,0,10),"IUI",7,"Acc-Num-2","G/L Account Number",
"","N",self.doAccNum2,gl2,None,("notzero",),None,
"Company %s's account number in the above company." %
self.opts["conum"]),
(("T",0,2,17),"ONA",30,""))
but = (
("Show All",self.gl3,None,0,("T",0,1),("T",0,2)),
("Cancel",None,self.doCancel,0,("T",0,3),("T",0,1)),
("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 doCoyNum(self, frt, pag, r, c, p, i, w):
if w == 0:
return "Invalid Company Number"
if w == self.opts["conum"]:
return "Invalid Company, Same Company Not Allowed"
self.cono2 = w
acc = self.sql.getRec("ctlmst", cols=["ctm_name"],
where=[("ctm_cono", "=", self.cono2)], limit=1)
if not acc:
return "Invalid Company Number"
self.df.loadEntry(frt, pag, 1, data=acc[0])
self.acc1 = self.sql.getRec("genint", where=[("cti_cono",
"=", self.opts["conum"]), ("cti_inco", "=", self.cono2)], limit=1)
if not self.acc1:
self.new1 = "y"
else:
self.new1 = "n"
self.acno1 = self.acc1[self.sql.genint_col.index("cti_acno")]
desc = self.readAcno(self.opts["conum"], self.acno1)
self.df.loadEntry(frt, pag, 2, data=self.acno1)
self.df.loadEntry(frt, pag, 3, data=desc[0])
self.acc2 = self.sql.getRec("genint", where=[("cti_cono",
"=", self.cono2), ("cti_inco", "=", self.opts["conum"])], limit=1)
if not self.acc2:
self.new2 = "y"
else:
self.new2 = "n"
self.acno2 = self.acc2[self.sql.genint_col.index("cti_acno")]
desc = self.readAcno(self.cono2, self.acno2)
self.df.loadEntry(frt, pag, 4, data=self.acno2)
self.df.loadEntry(frt, pag, 5, data=desc[0])
def doDelete(self):
if self.new1 == "n":
self.sql.delRec("genint", where=[("cti_cono", "=",
self.opts["conum"]), ("cti_inco", "=", self.cono2)])
if self.new2 == "n":
self.sql.delRec("genint", where=[("cti_cono", "=", self.cono2),
("cti_inco", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccNum1(self, frt, pag, r, c, p, i, w):
desc = self.readAcno(self.opts["conum"], w)
if not desc:
return "Invalid Account Number"
self.acno1 = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
def doAccNum2(self, frt, pag, r, c, p, i, w):
desc = self.readAcno(self.cono2, w)
if not desc:
return "Invalid Account Number"
self.acno2 = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
def readAcno(self, cono, acno):
acc = self.sql.getRec("genmst", cols=["glm_desc"],
where=[("glm_cono", "=", cono), ("glm_acno", "=", acno)], limit=1)
return acc
def doEnd(self):
data1 = [self.opts["conum"], self.cono2, self.acno1]
data2 = [self.cono2, self.opts["conum"], self.acno2]
if self.new1 == "y":
self.sql.insRec("genint", data=data1)
elif data1 != self.acc1[:len(data1)]:
col = self.sql.genint_col
data1.append(self.acc1[col.index("cti_xflag")])
self.sql.updRec("genint", data=data1, where=[("cti_cono", "=",
self.opts["conum"]), ("cti_inco", "=", self.cono2)])
if self.new2 == "y":
self.sql.insRec("genint", data=data2)
elif data2 != self.acc2[:len(data2)]:
col = self.sql.genint_col
data2.append(self.acc2[col.index("cti_xflag")])
self.sql.updRec("genint", data=data2, where=[("cti_cono", "=",
self.cono2), ("cti_inco", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
data = self.sql.getRec(tables=["genint", "genmst"], cols=["cti_cono",
"glm_desc"], where=[("cti_cono", "=", self.opts["conum"]),
("glm_cono=cti_inco",)], order="cti_inco")
self.gl3["data"] = data
self.df.focusField("T", 0, 1)
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 gl4010(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,
["genmst", "genbal", "genbud", "gentrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2])
self.i_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
df = self.e_per - self.i_per - 87
if df > 12:
self.d_per = df - 12
yr = int(self.i_per / 100)
mt = int(self.i_per % 100)
for _ in range(self.d_per):
mt += 1
if mt > 12:
mt -= 12
yr += 1
self.s_per = (yr * 100) + mt
else:
self.d_per = 0
self.s_per = self.i_per
self.d_pyr = 0
if self.opts["period"][0]:
s, e, f = getPeriods(self.opts["mf"], self.opts["conum"],
(self.opts["period"][0] - 1))
if (s, e, f) == (None, None, None):
return
self.s_lyr = s.work
self.i_pyr = int(s.work / 100)
self.e_pyr = int(e.work / 100)
df = self.e_pyr - self.i_pyr - 87
if df > 12:
self.d_pyr = df - 12
yr = int(self.i_pyr / 100)
mt = self.i_pyr % 100
for _ in range(self.d_pyr):
mt += 1
if mt > 12:
mt -= 12
yr += 1
self.s_pyr = (yr * 100) + mt
else:
self.s_pyr = self.i_pyr
self.trnper = 0
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"General Ledger Interrogation (%s)" %
self.__class__.__name__)
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, 7), "IUI", 7, "Acc-Num", "Account Number", "",
"N", self.doAccNum, glm, None, None), (("T", 0, 0, 0), "ONA",
30, "Description"),
(("T", 0, 0, 0), "OUA", 1, "Type"), (("T", 0, 0, 0), "OUA", 1,
"Indicator"),
(("C", 1, 0, 0), "OSD", 13.2, "Actual", "", "", "N", None, None,
None, None, ("Months", 14)), (("C", 1, 0, 1), "OSD", 13.2,
"Budget"),
(("C", 1, 0, 2), "OSD", 13.2,
"Variance"), (("C", 1, 0, 3), "OSD", 13.2, "Last-Year"),
(("T", 2, 0, 0), "Id2", 7, "Period (YYYYMM)",
"Financial Period (0=All)", self.trnper, "Y", self.doPeriod,
None, None, None))
tag = (("Balances", self.doBals, ("T", 0, 2), ("T", 0, 1)),
("Transactions", self.doTrans1, ("T", 0, 2), ("T", 0, 1)))
but = (("Clear", None, self.doClear, 0, ("T", 0, 0), ("T", 0, 1)),
("Notes", None, self.doNotes, 0, ("T", 0, 0), ("T", 0, 1)),
("Print", None, self.doPrint, 1, ("T", 0, 0),
("T", 0, 1)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doTopEnd, "N"), None, (self.doTrans2, "N"))
txt = (self.doExit, None, self.doExit)
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
tags=tag,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
mon = self.s_per % 100
yer = int(self.s_per / 100)
for x in range(14):
if x == 0:
txt = "Opening Balance"
self.df.colLabel[1][x].configure(text=txt)
elif x == 13:
txt = "Closing Balance"
self.df.colLabel[1][x].configure(text=txt)
else:
nam = mthnam[mon][1]
nam = nam + (" " * (11 - len(nam))) + str(yer)
self.df.colLabel[1][x].configure(text=nam)
if x not in (0, 13):
mon = mon + 1
if mon > 12:
mon = mon - 12
yer = yer + 1
txt = "Closing Balance"
self.df.colLabel[1][13].configure(text=txt)
def doAccNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc", "glm_type", "glm_ind"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account"
self.acno = w
self.desc = acc[0]
for x in range(1, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=acc[x - 1])
if self.opts["period"][0]:
gp = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acno),
("glo_trdt", "=", self.s_lyr)])
gc = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acno),
("glo_trdt", "=",
self.opts["period"][1][0])])
gt = self.sql.getRec("gentrn",
cols=["glt_type", "glt_curdt", "glt_tramt"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_curdt", "between", self.i_per,
self.e_per)])
gb = self.sql.getRec("genbud",
cols=["glb_curdt", "glb_tramt"],
where=[("glb_cono", "=", self.opts["conum"]),
("glb_acno", "=", self.acno),
("glb_curdt", "between", self.i_per,
self.e_per)])
if self.opts["period"][0]:
gl = self.sql.getRec("gentrn",
cols=["glt_curdt", "glt_tramt"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_curdt", "between", self.i_pyr,
self.e_pyr)])
act = [0] * 14
bud = [0] * 14
lyr = [0] * 14
adc = []
adl = []
if self.d_per:
# Current period more than 12 months
sy = sy = int(self.i_per / 100)
sm = self.i_per % 100
for _ in range(self.d_per):
adc.append(sm)
sm += 1
if sm > 12:
sy += 1
sm = 1
elif self.d_pyr:
# Previous period more than 12 months
sy = sy = int(self.i_pyr / 100)
sm = self.i_pyr % 100
for _ in range(self.d_pyr):
adl.append(sm)
sm += 1
if sm > 12:
sy += 1
sm = 1
if gc:
self.obal = gc[0][0]
act[0] = float(ASD(act[0]) + ASD(self.obal))
act[13] = float(ASD(act[13]) + ASD(self.obal))
if self.opts["period"][0] and gp:
lyr[0] = float(ASD(lyr[0]) + ASD(float(gp[0][0])))
lyr[13] = float(ASD(lyr[13]) + ASD(float(gp[0][0])))
else:
self.obal = 0
yre = self.e_per % 100
if gt:
for x, t in enumerate(gt):
cyr = int(t[1] / 100)
mon = t[1] % 100
if adc and cyr == sy and mon in adc:
col = 1
else:
col = mon - yre
if col <= 0:
col = col + 12
act[col] = float(ASD(act[col]) + ASD(float(t[2])))
act[13] = float(ASD(act[13]) + ASD(float(t[2])))
if gb:
for x, t in enumerate(gb):
mon = int(str(t[0])[4:6])
col = mon - yre
if col <= 0:
col = col + 12
bud[col] = float(ASD(bud[col]) + ASD(float(t[1])))
bud[13] = float(ASD(bud[13]) + ASD(float(t[1])))
if self.opts["period"][0] and gl:
for x, t in enumerate(gl):
cyr = int(t[0] / 100)
mon = t[0] % 100
if adl and cyr == sy and mon in adl:
col = 1
else:
col = mon - yre
if col <= 0:
col = col + 12
lyr[col] = float(ASD(lyr[col]) + ASD(float(t[1])))
lyr[13] = float(ASD(lyr[13]) + ASD(float(t[1])))
p = 0
for x in range(14):
i = 0
self.df.loadEntry("C", 1, p, data=act[x])
p = p + 1
i = i + 1
self.df.loadEntry("C", 1, p, data=bud[x])
p = p + 1
i = i + 1
data = float(ASD(bud[x]) - ASD(act[x]))
self.df.loadEntry("C", 1, p, data=data)
p = p + 1
i = i + 1
self.df.loadEntry("C", 1, p, data=lyr[x])
p = p + 1
self.df.last[0] = [0, 0]
self.opts["mf"].updateStatus("")
def doBals(self):
self.opts["mf"].updateStatus("")
def doTrans1(self):
self.df.focusField("T", 2, 1)
def doTrans2(self):
tit = "Transactions for Account: %s - %s" % (self.acno, self.desc)
gtt = ["gentrn"]
gtc = (("glt_trdt", "", 0,
" Date"), ("glt_refno", "", 0, "Reference",
"Y"), ("glt_type", ("XX", gltrtp), 3, "Typ"),
("glt_batch", "", 0, "Batch"), ("glt_tramt", "", 0,
" Debit"),
("glt_tramt", "", 0, " Credit"), ("balance", "SD", 13.2,
" Balance"),
("glt_desc", "", 0, "Remarks"), ("glt_seq", "", 0, "Sequence"))
mthno, acctot = self.getObal()
if mthno.work == 0:
d = self.opts["period"][1][0]
else:
d = (self.trnper * 100) + 1
if acctot:
if acctot < 0:
dr = 0
cr = acctot
else:
dr = acctot
cr = 0
data = [[d, "B/Fwd", 4, "", dr, cr, acctot, "Opening Balance", 0]]
else:
data = []
trn = self.getTrans()
if trn:
col = self.sql.gentrn_col
for rec in trn:
acctot = float(ASD(acctot) + ASD(rec[col.index("glt_tramt")]))
if rec[col.index("glt_tramt")] < 0:
dr = 0
cr = rec[col.index("glt_tramt")]
else:
dr = rec[col.index("glt_tramt")]
cr = 0
data.append([
rec[col.index("glt_trdt")], rec[col.index("glt_refno")],
rec[col.index("glt_type")], rec[col.index("glt_batch")],
dr, cr, acctot, rec[col.index("glt_desc")],
rec[col.index("glt_seq")]
])
state = self.df.disableButtonsTags()
while True:
rec = SRec(self.opts["mf"],
screen=self.df.nb.Page2,
title=tit,
tables=gtt,
cols=gtc,
where=data,
wtype="D",
sort=False)
# Display all transaction details
if rec.selection:
self.df.setWidget(self.df.mstFrame, state="hide")
whr = [("glt_seq", "=", rec.selection[8])]
TabPrt(self.opts["mf"], tabs="gentrn", where=whr, pdia=False)
self.df.setWidget(self.df.mstFrame, state="show")
else:
break
self.df.enableButtonsTags(state=state)
self.doTrans1()
def doNotes(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
NotesCreate(self.opts["mf"], self.opts["conum"], self.opts["conam"],
self.opts["capnm"], "GEN", self.acno)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doTopEnd(self):
self.df.last[0] = [0, 0]
self.df.setWidget(self.df.topEntry[0][0], state="disabled")
def doClear(self):
self.df.selPage("Balances")
self.df.focusField("T", 0, 1)
def doPrint(self):
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Printer/Email Selection", )
r1s = (("Info", "I"), ("Trans", "T"))
fld = ((("T", 0, 1, 0), ("IRB", r1s), 0, "Selection", "", "I", "N",
self.doPrtSel, None, None, None),
(("T", 0, 2,
0), "Id2", 7, "Period (YYYYMM)", "Financial Period (0=All)",
self.trnper, "Y", self.doPeriod, None, None, None))
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("Y", "V"),
mail=("Y", "N"))
self.pr.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField("T", 2, 1)
def doPrtSel(self, frt, pag, r, c, p, i, w):
self.sel = w
for x in (2, 3):
if bool(self.sel == "I"):
self.pr.setWidget(self.pr.topEntry[0][2][x][0], state="hide")
else:
self.pr.setWidget(self.pr.topEntry[0][2][x][0], state="show")
if self.sel == "I":
return "sk1"
def doPrtEnd(self):
self.pr.closeProcess()
self.head = "%03u %-99s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.pgnum = 0
self.pglin = 999
self.num = self.df.t_disp[0][0][0]
self.dsc = self.df.t_disp[0][0][1]
atype = self.df.t_disp[0][0][2]
ind = self.df.t_disp[0][0][3]
if self.pr.t_work[0][0][0] == "I":
self.pageHeading()
self.fpdf.drawText("%-8s %-12s %-6s %-35s %-6s %-7s %-11s %s" % \
("Acc No:", self.num, "Desc:", self.dsc, "Type:", atype,
"Indicator:", ind))
self.fpdf.drawText()
self.fpdf.drawText("%-21s %-20s %-18s %-19s %-18s" % \
("", "Actual", "Budget", "Variance", "Last Year"))
self.fpdf.drawText()
m = self.s_per % 100
for x in range(14):
if x == 0:
mon = "Opening"
elif x == 13:
mon = "Closing"
else:
mon = mthnam[m][1]
m = m + 1
if m > 12:
m = m - 12
act = self.df.c_disp[1][x][0]
bud = self.df.c_disp[1][x][1]
var = self.df.c_disp[1][x][2]
lyr = self.df.c_disp[1][x][3]
self.fpdf.drawText("%-15s %-20s %-20s %-20s %-20s" %
(mon, act, bud, var, lyr))
if x in (0, 12):
self.fpdf.drawText()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.pr.repprt,
repeml=self.pr.repeml)
else:
trn = self.getTrans()
if trn:
heads = ["General Ledger Interrogation as at %s" % self.sysdtd]
mthno, acctot = self.getObal()
if mthno.work == 0:
x = "(For all months)"
d = self.opts["period"][1][0]
else:
x = "(For month " + mthno.disp + ")"
d = (self.trnper * 100) + 1
heads.append("Account %s %s %s" % (self.num, self.dsc, x))
cols = [["glt_trdt", "D1", 10, " Date"],
["glt_refno", "Na", 9, "Reference"],
["glt_type", "NA", 3, "Typ"],
["glt_batch", "Na", 7, "BatchNo"],
["debit", "SD", 13.2, " Debit "],
["credit", "SD", 13.2, " Credit "],
["balance", "SD", 13.2, " Balance "],
["glt_desc", "NA", 30, "Remarks"]]
if acctot:
if acctot < 0:
dr = 0
cr = acctot
else:
dr = acctot
cr = 0
data = [(d, "B/Fwd", "", "", dr, cr, acctot,
"Opening Balance")]
else:
data = []
col = self.sql.gentrn_col
for num, rec in enumerate(trn):
trdt = rec[col.index("glt_trdt")]
refno = rec[col.index("glt_refno")]
trtp = gltrtp[(rec[col.index("glt_type")]) - 1][0]
batch = rec[col.index("glt_batch")]
tramt = rec[col.index("glt_tramt")]
if tramt < 0:
debit = 0
credit = tramt
else:
debit = tramt
credit = 0
detail = rec[col.index("glt_desc")]
acctot = float(ASD(acctot) + ASD(tramt))
data.append((trdt, refno, trtp, batch, debit, credit,
acctot, detail))
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
conum=self.opts["conum"],
conam=self.opts["conam"],
tables=data,
heads=heads,
cols=cols,
ttype="D",
repprt=self.pr.repprt,
repeml=self.pr.repeml)
def doPrtExit(self):
self.pr.closeProcess()
def doPeriod(self, frt, pag, r, c, p, i, w):
if w != 0 and (w < self.i_per or w > self.e_per):
return "Invalid Period"
self.trnper = w
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.pgnum += 1
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-34s %-10s %51s %5s" % \
("General Ledger Interrogation as at", self.sysdtd,
"Page", self.pgnum))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 4
def getObal(self):
acbal = self.obal
if self.trnper:
o = self.sql.getRec("gentrn",
cols=["round(sum(glt_tramt), 2)"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_curdt", ">=", self.i_per),
("glt_curdt", "<", self.trnper)],
limit=1)
if o[0]:
acbal = float(ASD(acbal) + ASD(o[0]))
mthno = CCD(self.trnper % 100, "UI", 2.0)
return mthno, acbal
def getTrans(self):
odr = "glt_acno, glt_curdt, glt_trdt, glt_type, glt_refno, glt_batch"
if not self.trnper:
whr = [("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_curdt", "between", self.i_per, self.e_per)]
else:
whr = [("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_curdt", "=", self.trnper)]
return self.sql.getRec("gentrn", where=whr, order=odr)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class wg2030(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,
"wagmst",
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"),
("wgm_fname", "", 0, "Names"), ("wgm_start", "", 0, "Start-Date"),
("wgm_term", "", 0, "Term-Date")),
"where": [("wgm_cono", "=", self.opts["conum"]),
("wgm_term", "=", 0)]
}
fld = ((("T", 0, 0, 0), "I@wgm_empno", 7, "", "", "", "Y",
self.doEmpNo, wgm, None, None),
(("T", 0, 1, 0), "O@wgm_sname", 0, "", "", "", "N", None, None,
None, None), (("T", 0, 2, 0), "O@wgm_fname", 0, "", "", "",
"N", None, None, None, None),
(("T", 0, 3, 0), "ID1", 10, "Termination Date", "", "", "N",
self.doTermDate, None, None, ("efld", )))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt)
def doEmpNo(self, frt, pag, r, c, p, i, w):
self.emp = self.sql.getRec(
"wagmst",
cols=["wgm_sname", "wgm_fname", "wgm_start", "wgm_term"],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", w)],
limit=1)
if not self.emp:
return "Invalid Employee"
if self.emp[3]:
return "Employment Already Terminated"
self.empno = w
self.df.loadEntry(frt, pag, 1, data=self.emp[0])
self.df.loadEntry(frt, pag, 2, data=self.emp[1])
def doTermDate(self, frt, pag, r, c, p, i, w):
if w <= self.emp[2]:
return "Invalid Termination Date"
self.term = w
def doEnd(self):
self.sql.updRec("wagmst",
cols=["wgm_term"],
data=[self.term],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class cr3080(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"])
crsctl = gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sql = Sql(self.opts["mf"].dbm, [
"ctlctl", "ctlmst", "crsctl", "crsmst", "crstrn", "crsage",
"gentrn", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
self.glint = crsctl["ctc_glint"]
self.bestac = crsctl["ctc_bestac"]
self.besttp = crsctl["ctc_besttp"]
self.bankac = crsctl["ctc_bankac"]
self.tplnam = crsctl["ctc_tplnam"]
self.fromad = crsctl["ctc_emadd"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if gc.chkRec(self.opts["conum"], ctlctl, ["crs_ctl"]):
return
self.crsctl = ctlctl["crs_ctl"]
acc = self.sql.getRec("crstrn",
cols=["max(crt_ref1)"],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_type", "=", 5),
("crt_ref1", "like", "EFT______")],
limit=1)
try:
self.cats = int(acc[0][3:])
self.refs = int(acc[0][3:]) + 1
except:
self.cats = 0
self.refs = 1
self.etotal = 0
return True
def mainProcess(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "R"), ("tpm_system", "=", "CRS")],
"order":
"tpm_tname"
}
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")]
}
r1s = (("Yes", "Y"), ("Range", "R"), ("Singles", "S"))
r2s = (("Yes", "Y"), ("No", "N"))
r3s = (("Number", "N"), ("Name", "M"), ("Postal Code", "P"))
r4s = (("Monthly", "M"), ("Daily", "D"))
fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.tplnam,
"Y", self.doTplNam, tpm, None, None),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Whole File", "", "S", "Y",
self.doWhole, None, None, None), [["T", 0, 2, 0], "INA", 7,
"From Account", "", "", "Y",
self.doAcc, crm, None, None],
[["T", 0, 3, 0], "INA", 7, "To Account", "", "", "Y",
self.doAcc, crm, None,
None], (("T", 0, 4, 0), ("IRB", r3s), 0, "Sort Order", "", "N",
"Y", self.doSort, None, None, None),
(("T", 0, 5, 0), ("IRB", r4s), 0, "Terms Base", "", "M", "Y",
self.doFrequency, None, None,
None), (("T", 0, 6, 0), ("IRB", r2s), 0, "Exceptions", "", "N",
"Y", self.doExcepts, None, None, None),
(("T", 0, 7, 0), "ID1", 10, "Due Date", "", self.sysdtw, "Y",
self.doDuedat, None, None, ("efld", )),
(("T", 0, 8, 0), "ID1", 10, "Payment Date", "", self.sysdtw,
"Y", self.doPaydat, None, None, ("efld", )))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("B", "Y"))
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 Name"
self.tname = w
def doWhole(self, frt, pag, r, c, p, i, w):
self.whole = w
if self.whole in ("Y", "S"):
self.sacc = ""
self.eacc = ""
self.df.loadEntry("T", 0, p + 1, data=self.sacc)
self.df.loadEntry("T", 0, p + 2, data=self.eacc)
return "sk2"
def doAcc(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("crsmst",
cols=["crm_name", "crm_stat"],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not chk:
return "Invalid Creditors Account"
if not chk[1] == "X":
return "Invalid Account, Redundant"
if c == 3:
self.sacc = w
else:
self.eacc = w
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
def doFrequency(self, frt, pag, r, c, p, i, w):
self.freq = w
def doExcepts(self, frt, pag, r, c, p, i, w):
self.excepts = w
def doDuedat(self, frt, pag, r, c, p, i, w):
self.duedtw = w
self.duedtd = self.df.t_disp[pag][0][p]
def doPaydat(self, frt, pag, r, c, p, i, w):
self.paydtw = w
self.paydtd = self.df.t_disp[pag][0][p]
self.curdt = int(self.paydtw / 100)
self.batno = "E%s" % self.curdt
def doEnd(self):
self.df.closeProcess()
if self.excepts == "Y":
self.doExceptions()
self.emadd = self.df.repeml[2]
if self.bestac:
self.export = open(
os.path.join(
self.opts["mf"].rcdic["wrkdir"],
"best%03d_%s.txt" % (self.opts["conum"], self.paydtw)),
"w")
# Header for BEST
self.export.write("%1s%4s%-40s%8s%1s%8s%-15s%1s%2s%1s%9s%2s%4s"\
"\r\n" % ("*", self.bestac, self.opts["conam"], self.paydtw,
"Y", "", "CREDITORS EFT", "+", self.besttp, 0, "", "01",
"LIVE"))
else:
self.export = None
if self.whole == "S":
recs = getSingleRecords(self.opts["mf"],
"crsmst", ("crm_acno", "crm_name"),
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_termsb", "=", self.freq),
("crm_pyind", "<>", "N"),
("crm_stat", "<>", "X")])
else:
if not self.eacc:
self.eacc = "zzzzzzz"
whr = [("crm_cono", "=", self.opts["conum"]),
("crm_acno", "between", self.sacc, self.eacc),
("crm_termsb", "=", self.freq), ("crm_pyind", "<>", "N"),
("crm_stat", "<>", "X")]
if self.sort == "N":
odr = "crm_acno"
elif self.sort == "M":
odr = "crm_name"
else:
odr = "crm_pcod"
recs = self.sql.getRec("crsmst", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Error",
"No Accounts Selected")
if recs:
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
for num, rec in enumerate(recs):
p.displayProgress(num)
if p.quit:
self.opts["mf"].dbm.rollbackDbase()
break
self.doProcess(rec)
p.closeProgress()
if p.quit or not self.form.page:
pass
elif self.df.repeml[1] == "N" or self.emadd:
self.df.repeml[2] = self.emadd
self.doPrint()
if self.bestac:
# Trailer for BEST
value = int(round((self.etotal * 100), 0))
self.export.write("%1s%4s%1s%30s%013u%47s\r\n" % \
(2, self.bestac, "T", "", value, ""))
self.export.close()
if self.glint == "Y" and self.etotal:
# Create total transactions in GL
data = [
self.opts["conum"], self.crsctl, self.curdt,
self.paydtw, 2, self.refno, self.batno, self.etotal,
0.0,
"Payment EFT%06i to EFT%06i" % (self.refs, self.cats),
"", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
data[1] = self.bankac
data[7] = float(ASD(0) - ASD(self.etotal))
self.sql.insRec("gentrn", data=data)
self.opts["mf"].dbm.commitDbase(
ask=True,
mess="""Would you like to commit all elecronic payments?
If you decide to do this, you must remember to upload the BEST file to the Bank otherwise you are NOT going to Reconcile!""",
default="no")
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doExceptions(self):
crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols":
(("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")),
"where": [("crm_cono", "=", self.opts["conum"]),
("crm_termsb", "=", self.freq), ("crm_stat", "<>", "X")]
}
crt = {
"stype":
"R",
"tables": ("crstrn", ),
"cols":
(("crt_ref1", "", 0, "Reference", "Y"), ("crt_type",
("XX", crtrtp), 3, "Typ"),
("crt_trdt", "", 0, "Date"), ("crt_tramt", "", 0, " Amount"),
("paid", "SD", 13.2,
" Paid"), ("balance", "SD", 13.2,
" Balance"), ("crt_paydt", "", 0, "Pay-Date"),
("crt_payind", "", 0, "I"), ("crt_payamt", "", 0, " Pay-Amnt")),
"wtype":
"D",
"where": [],
"order":
"crt_ref1"
}
types = []
for x in range(1, len(crtrtp) + 1):
types.append((x, crtrtp[x - 1][1]))
typ = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("C", "Type"),
"data": types
}
fld = ((("T", 0, 0,
0), "I@crm_acno", 0, "", "", "", "N", self.doExAcNo, crm,
None, ("notblank", )), (("T", 0, 0, 0), "O@crm_name", 0, ""),
(("C", 0, 0, 1), "I@crt_type", 0, "", "", "", "N",
self.doExTrnTyp, typ, None, ("in", (1, 2, 3, 4, 5))),
(("C", 0, 0, 0), "I@crt_ref1", 0, "", "", "", "N",
self.doExTrnRef, crt, None, ("notblank", )),
(("C", 0, 0, 2), "O@crt_trdt", 0, ""), (("C", 0, 0, 3), "OSD",
13.2, "Balance"),
(("C", 0, 0, 4), "I@crt_payind", 0, "", "", "", "N",
self.doExInd, None, None, ("in", ("Y", "N"))),
(("C", 0, 0, 5), "I@crt_paydt", 0, "", "", "", "N",
self.doExDte, None, None,
("efld", )), (("C", 0, 0, 6), "I@crt_payamt", 0, "", "", "",
"N", self.doExAmt, None, None, ("efld", )))
tnd = ((self.doExEndTop, "n"), )
txt = (self.doExExitTop, )
cnd = ((self.doExEndCol, "y"), )
cxt = (self.doExExitCol, )
self.ex = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
self.ex.mstFrame.wait_window()
def doExAcNo(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(
"crsmst",
cols=["crm_name", "crm_termsb", "crm_pyind", "crm_stat"],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] != self.freq:
return "Invalid Terms Base"
if acc[2] == "N":
return "Invalid Payment Indicator"
if acc[3] == "X":
return "Invalid Account, Redundant"
self.exacc = w
self.ex.loadEntry(frt, pag, p + 1, data=acc[0])
def doExEndTop(self):
self.ex.focusField("C", 0, 1)
def doExExitTop(self):
self.opts["mf"].dbm.commitDbase(
ask=True, mess="Would you like to commit these exceptions?")
self.ex.closeProcess()
def doExTrnTyp(self, frt, pag, r, c, p, i, w):
self.extyp = w
data = []
# Build the data for the F1 choice selection
col, dat = getTrn(self.opts["mf"].dbm,
"crs",
whr=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.exacc),
("crt_type", "=", w)],
zer="N")
if dat:
cols = ("crt_ref1", "crt_type", "crt_trdt", "crt_tramt", "paid",
"balance", "crt_paydt", "crt_payind", "crt_payamt")
for d in dat:
rec = []
for cc in cols:
rec.append(d[col.index(cc)])
data.append(rec)
self.ex.colf[0][1][8]["where"] = data
def doExTrnRef(self, frt, pag, r, c, p, i, w):
col = ["crt_trdt", "balance", "crt_payind", "crt_paydt", "crt_payamt"]
whr = [("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.exacc), ("crt_type", "=", self.extyp),
("crt_ref1", "=", w)]
c, d = getTrn(self.opts["mf"].dbm, "crs", whr=whr, lim=1)
if not d:
return "Invalid Transaction Number"
if not d[0][c.index("balance")]:
return "Transaction Has No Balance"
self.exref = w
self.exdte = d[0][c.index("crt_paydt")]
self.examt = d[0][c.index("crt_payamt")]
for pos, fld in enumerate(col):
self.ex.loadEntry(frt, pag, p + 1 + pos, data=d[0][c.index(fld)])
def doExInd(self, frt, pag, r, c, p, i, w):
self.exind = w
if self.exind == "N":
return "nd"
def doExDte(self, frt, pag, r, c, p, i, w):
self.exdte = w
def doExAmt(self, frt, pag, r, c, p, i, w):
self.examt = w
def doExEndCol(self):
# Update Transaction"
self.sql.updRec("crstrn",
cols=["crt_payind", "crt_paydt", "crt_payamt"],
data=[self.exind, self.exdte, self.examt],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.exacc),
("crt_type", "=", self.extyp),
("crt_ref1", "=", self.exref)])
self.ex.advanceLine(0)
def doExExitCol(self):
self.ex.focusField("T", 0, 1)
def doLoadStatic(self):
cmc = self.sql.ctlmst_col
ctm = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])],
limit=1)
for fld in cmc:
dat = ctm[cmc.index(fld)]
if fld in self.form.tptp:
if fld == "ctm_logo":
self.form.letterhead(cmc, ctm, fld, dat)
continue
self.form.tptp[fld][1] = dat
if "letterhead" in self.form.tptp:
self.form.letterhead(cmc, ctm, "letterhead", None)
self.form.document_date(self.duedtd)
def doProcess(self, crm):
cmc = self.sql.crsmst_col
tdc = self.form.sql.tpldet_col
self.acno = crm[cmc.index("crm_acno")]
eml = crm[cmc.index("crm_acc_email")]
self.form.account_details("crm", cmc, crm, 1)
for col in cmc:
d = "%s_C00" % col
if d in self.form.newdic:
dat = crm[cmc.index(col)]
self.form.newdic[d][tdc.index("tpd_text")] = dat
jon = "cra_curdt <= %s" % self.curdt
whr = [("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.acno), ("crt_payind", "=", "Y"),
("crt_paydt", "<=", self.duedtw)]
ctc, crt = getTrn(self.opts["mf"].dbm,
"crs",
jon=jon,
whr=whr,
zer="N")
if not crt:
return
bal = 0
self.pay = 0
for d in crt:
if d[ctc.index("balance")] < 0:
d[ctc.index("crt_payamt")] = d[ctc.index("balance")]
bal = float(ASD(bal) + ASD(d[ctc.index("balance")]))
self.pay = float(ASD(self.pay) + ASD(d[ctc.index("crt_payamt")]))
if self.pay > bal:
self.pay = bal
if self.pay > 0:
self.bname = crm[cmc.index("crm_bname")]
self.bibt = crm[cmc.index("crm_bibt")]
self.bacc = crm[cmc.index("crm_bacc")]
if self.bname and self.bibt and self.bacc:
self.ptype = "E" # Electronic
test = False
while not test:
self.cats += 1
self.refno = "EFT%06i" % self.cats
# Check if Reference Number Already Exists
chk = self.sql.getRec("crstrn",
where=[("crt_cono", "=",
self.opts["conum"]),
("crt_acno", "=", self.acno),
("crt_type", "=", 5),
("crt_ref1", "=", self.refno)
])
if not chk:
test = True
else:
self.ptype = "C" # Cheque
self.doBody(ctc, crt, tdc)
self.doTotal(tdc)
self.doTail(tdc)
if self.df.repeml[1] == "Y" and not self.emadd:
self.df.repeml[2] = eml
self.doPrint()
def doPrint(self):
if self.df.repeml[1] == "Y" and not self.emadd:
key = "%s_%s" % (self.opts["conum"], self.acno)
else:
key = "%s_all" % self.opts["conum"]
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
key,
ext="pdf")
self.form.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header="%s Remittance Advice" % self.opts["conam"],
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
if self.df.repeml[1] == "Y":
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
def doBody(self, ctc, crt, tdc):
page = 0
count = 0
text = self.form.sql.tpldet_col.index("tpd_text")
for trans in crt:
trbal = trans[ctc.index("balance")]
payamt = trans[ctc.index("crt_payamt")]
if payamt > trbal:
payamt = trbal
trans[ctc.index("balance")] = payamt
if not count:
page += 1
count = self.doHeader(page)
if count == self.form.maxlines:
page = self.doCfwd(page)
count = self.doHeader(page)
for cod in self.form.body:
if cod == "type_code":
c = "crt_type"
elif cod == "line_paid":
c = "paid"
elif cod == "line_balance":
c = "balance"
else:
c = cod
d = "%s_C%02i" % (cod, count)
if cod == "type_code":
ttyp = trans[ctc.index(c)]
self.form.newdic[d][text] = crtrtp[ttyp - 1][0]
else:
self.form.newdic[d][text] = trans[ctc.index(c)]
self.form.doDrawDetail(self.form.newdic[d])
if self.ptype == "E" and self.bestac:
trtp = trans[ctc.index("crt_type")]
ref1 = trans[ctc.index("crt_ref1")]
# Create Ageing Transaction
self.sql.insRec("crsage",
data=[
self.opts["conum"], self.acno, trtp, ref1,
self.curdt, 5, self.refno, payamt, 0
])
count += 1
for x in range(count, self.form.maxlines):
for cod in self.form.body:
d = "%s_C%02i" % (cod, x)
self.form.newdic[d][tdc.index("tpd_text")] = "BLANK"
self.form.doDrawDetail(self.form.newdic[d])
def doHeader(self, page):
tdc = self.form.sql.tpldet_col
self.form.add_page()
for key in self.form.newkey:
nl = copyList(self.form.newdic[key])
if nl[tdc.index("tpd_place")] != "A":
continue
if nl[tdc.index("tpd_detseq")] == "crm_acno_C00":
nl[tdc.index("tpd_text")] = self.acno
elif nl[tdc.index("tpd_detseq")] == "page_number_C00":
nl[tdc.index("tpd_text")] = str(page)
self.form.doDrawDetail(nl)
return 0
def doCfwd(self, page):
if "carried_forward" in self.form.tptp:
tdc = self.form.sql.tpldet_col
line = copyList(self.form.cfwd)
line[tdc.index("tpd_text")] = "Continued on Page %i" % (page + 1)
self.form.doDrawDetail(line)
return page + 1
def doTotal(self, tdc):
for c in self.form.total:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
if c == "total_payment":
line[tdc.index("tpd_text")] = self.pay
self.form.doDrawDetail(line)
if self.ptype == "E" and self.bestac:
value = int(round((self.pay * 100), 0))
self.export.write("%1s%4s%06u%-7s%019u%1s%1s%011u%-20s%10s"\
"%-15s%1s\r\n" % (2, self.bestac, self.bibt, self.acno,
int(self.bacc), "", "1", value, self.bname, "",
self.opts["conam"][:15], ""))
self.etotal = float(ASD(self.etotal) + ASD(self.pay))
# Create Payment and Ageing Transaction
p = float(ASD(0) - ASD(self.pay))
self.sql.insRec("crstrn",
data=[
self.opts["conum"], self.acno, 5, self.refno,
self.batno, self.paydtw, "", p, 0.0, 0.0,
self.curdt, 0, "", 0.0, "Electronic Payment",
"", "", self.opts["capnm"], self.sysdtw, 0
])
self.sql.insRec("crsage",
data=[
self.opts["conum"], self.acno, 5, self.refno,
self.curdt, 5, self.refno, p, 0
])
def doTail(self, tdc):
for c in self.form.tail:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
if c == "eft_message" and self.ptype == "E" and self.bestac:
line[tdc.index("tpd_text")] = "ELECTRONIC TRANSFER AT %s "\
"REFERENCE %s" % (self.paydtd, self.refno)
self.form.doDrawDetail(line)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class ml2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] != 5:
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
tabs = ["ctlvmf", "memmst", "memtrn"]
self.gc = GetCtl(self.opts["mf"])
memctl = self.gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.dis_all = ctlctl["dis_all"]
tabs.extend(["genmst", "gentrn"])
# Setup SQL Object
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"MEM",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
self.glt = 4
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def drawDialog(self):
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names",
"sort":
False
}
tag = (("Deposit", None, None, None, False), ("Allocation", None, None,
None, False))
fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One",
"i", "Y", self.doRefno, None, None, ("efld", )),
(("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 3), "INA", 30, "Details", "Deposit Details", "",
"N", self.doTrnDet, None, None,
None), (("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", 2, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N",
self.doMemAcc, mlm, None, ("notblank", )), (("C", 2, 0, 1),
"ONA", 30, "Name"),
(("C", 2, 0, 2), "ISD", 13.2, "Receipt", "Receipt Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, ("efld", ), None,
"Discount Amount to be Added to the Receipt Amount."),
(("C", 2, 0, 4), "OSD", 13.2, "Total-Amount"))
but = (
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",1),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",1),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",1),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",1),
("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1))
txt = (None, None, None)
cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")]
cxt = [None, self.exitPage1, self.exitPage2]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doRefno(self, frt, pag, r, c, p, i, w):
if not w:
trns = self.sql.getRec("memtrn",
cols=["mlt_refno"],
where=[("mlt_cono", "=",
self.opts["conum"]),
("mlt_refno", "like", "R________")],
order="mlt_refno desc")
auto = False
for trn in trns:
try:
w = "R%08i" % (int(trn[0][1:]) + 1)
auto = True
break
except:
pass
if not auto:
w = "R00000001"
self.df.loadEntry(frt, pag, p, data=w)
chk = self.sql.getRec("memtrn",
cols=["mlt_memno"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", w)])
if chk:
return "A Transaction with this Number Already Exists"
self.refno = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
self.allocated = float(0.00)
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
self.agecan = False
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.glint == "Y":
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doMemAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memmst",
cols=["mlm_title", "mlm_initial", "mlm_surname"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", w)],
limit=1)
if not acc:
return "Invalid Member Number"
self.memno = w
self.name = "%s, %s %s" % (acc[2], acc[0], acc[1])
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.allref = self.refno
while self.sql.getRec("memtrn",
cols=["mlt_batch"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", self.allref)]):
self.doGetAnotherRef()
def doGetAnotherRef(self):
tit = ("Duplicate Reference Number", )
fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref,
"N", None, None, None, None),
(("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N",
self.doRefNew, None, None, ("notblank", )))
tnd = ((self.doRefEnd, "n"), )
txt = (self.doRefExit, )
state = self.df.disableButtonsTags()
self.tf = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=tnd,
txit=txt)
self.tf.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doRefExit(self):
self.tf.focusField("T", 0, 2)
def doRefNew(self, frt, pag, r, c, p, i, w):
self.allref = w
def doRefEnd(self):
self.tf.closeProcess()
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
ok = self.checkSign()
elif self.allamt > 0 and w < 0:
ok = self.checkSign()
else:
ok = "yes"
if ok != "yes":
return "Invalid Discount Amount (Sign Error)"
self.disamt = w
totamt = float(ASD(self.allamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def checkSign(self):
return askQuestion(self.opts["mf"].body, "Check Sign",
"The Sign of the Discount Amount is not the same as the Sign "\
"of the Receipt Amount, Is This Correct?")
def endPage2(self):
self.amt = float(ASD(0) - ASD(self.allamt))
self.dis = float(ASD(0) - ASD(self.disamt))
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(0, 5):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
# Members Ledger Transaction
data = [
self.opts["conum"], self.memno, self.opts["rtn"], self.allref,
self.bh.batno, self.trndat, self.amt, 0.00, self.curdt, "", 0,
self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data)
if self.dis:
data = [
self.opts["conum"], self.memno, 6, self.allref, self.bh.batno,
self.trndat, self.dis, 0.00, self.curdt, "", 0, self.trndet,
"", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data, unique="mlt_refno")
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.glint == "Y":
# General Ledger Control Transaction (Members)
amt = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.memctl, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.disamt:
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.allref, self.bh.batno,
self.disamt, 0.00, self.trndet, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="mem",
agetyp=atype,
agekey=[
self.opts["conum"], self.memno, self.opts["rtn"],
self.allref, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
self.agevar.set(False)
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
class bc2070(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, ["bwlcmp", "bwltab", "bwlent",
"bwltyp", "bwlpts", "bwlgme"], prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
bcp = {
"stype": "R",
"tables": ("bwlcmp",),
"cols": (
("bcm_code", "", 0, "Cod"),
("bcm_name", "", 0, "Name", "Y"),
("bcm_date", "", 0, "Date")),
"where": [("bcm_cono", "=", self.opts["conum"])]}
gme = {
"stype": "R",
"tables": ("bwlgme",),
"cols": (
("bcg_game", "", 0, "GC"),
("bcg_type", "", 0, "T"),
("bcg_date", "", 0, "Date")),
"where": [("bcg_cono", "=", self.opts["conum"])],
"whera": [("T", "bcg_ccod", 0, 0)],
"group": "bcg_game"}
skp = {
"stype": "R",
"tables": ("bwlent", "bwltab", "bwlgme"),
"cols": (
("btb_tab", "", 0, "Cod"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names"),
("bcg_rink", "", 0, "RK")),
"where": [
("bce_cono", "=", self.opts["conum"]),
("btb_cono=bce_cono",),
("btb_tab=bce_scod",),
("bcg_cono=bce_cono",),
("bcg_scod=bce_scod",),
("bcg_ocod<900000",),
("bcg_sfor=0 and bcg_sagt=0",)],
"whera": [
("T", "bce_ccod", 0, 0),
("T", "bcg_ccod", 0, 0),
("T", "bcg_game", 2, 0)],
"order": "bcg_rink"}
fld = (
(("T",0,0,0),"I@bcm_code",0,"","",
"","Y",self.doCmpCod,bcp,None,("notzero",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,0,0),"I@bcg_game",0,"Game Number","",
"","N",self.doGamCod,gme,None,("efld",)),
(("T",0,0,0),"IUI",2,"Ends Completed","",
0,"N",self.doEndsFin,None,None,("efld",)),
(("C",0,0,0),"I@bcg_scod",0,"","",
"","N",self.doSkpCod,skp,None,("efld",)),
(("C",0,0,0),"ONA",30,"Skp-Name"),
(("C",0,0,0),"I@bcg_sfor",0,"","",
"","N",self.doShots,None,None,("efld",)),
(("C",0,0,0),"I@bcg_points",0,"","",
"","N",self.doPoints,None,None,("efld",)),
(("C",0,0,0),"O@bcg_ocod",0,""),
(("C",0,0,0),"ONA",30,"Opp-Name"),
(("C",0,0,0),"I@bcg_sagt",0,"","",
"","N",self.doShots,None,None,("efld",)),
(("C",0,0,0),"I@bcg_points",0,"","",
"","N",self.doPoints,None,None,("efld",)))
but = (("Quit",None,self.doQuit,1,None,None),)
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
cnd = ((self.doEnd,"y"),)
cxt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
rows=(19,), eflds=fld, butt=but, tend=tnd, txit=txt,
cend=cnd, cxit=cxt)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("bwlcmp", cols=["bcm_name", "bcm_type"],
where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=",
w)], limit=1)
if not com:
return "Invalid Competition Code"
self.ccod = w
self.code = com[1]
self.df.loadEntry(frt, pag, p + 1, data=com[0])
if not self.code:
bwltyp = [self.opts["conum"], 0, "KO", "K", 1, 0, 21,
"N", 0, "N", "", 0, 0, "N", "N", ""]
else:
bwltyp = self.sql.getRec("bwltyp", where=[("bct_cono", "=",
self.opts["conum"]), ("bct_code", "=", com[1])], limit=1)
self.cfmat = bwltyp[self.sql.bwltyp_col.index("bct_cfmat")]
self.groups = bwltyp[self.sql.bwltyp_col.index("bct_groups")]
self.grgame = bwltyp[self.sql.bwltyp_col.index("bct_grgame")]
if self.cfmat == "R":
games = self.sql.getRec("bwlgme", cols=["count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=", 1)],
group="bcg_group")
self.games = 0
for gme in games:
if gme[0] > self.games:
self.games = gme[0]
self.games -= 1
elif self.cfmat in ("D", "K"):
totskp = self.sql.getRec("bwlent", cols=["count(*)"],
where=[("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod)], limit=1)[0]
pwrs = 2
self.games = 1
while pwrs < totskp:
self.games += 1
pwrs = pwrs * 2
else:
self.games = bwltyp[self.sql.bwltyp_col.index("bct_games")]
self.ends = bwltyp[self.sql.bwltyp_col.index("bct_ends")]
chk = self.sql.getRec("bwlgme", cols=["bcg_game",
"sum(bcg_sfor)", "sum(bcg_sagt)", "sum(bcg_points)"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=",
self.ccod), ("bcg_aflag", "in", ("", "D"))],
group="bcg_game", order="bcg_game")
for game in chk:
self.gcod = game[0]
if not game[1] and not game[2] and not game[3]:
self.df.loadEntry(frt, pag, p + 2, data=self.gcod)
break
self.df.loadEntry(frt, pag, p + 3, data=self.ends)
def doGamCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("bwlgme", cols=["bcg_aflag",
"sum(bcg_ocod)"], where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=", w)],
group="bcg_aflag")
if not chk:
return "Invalid Game Number"
for ck in chk:
if not ck[0] and not ck[1]:
return "Invalid Game Number, Not Yet Drawn"
if w != self.games:
col = [
"bcg_game",
"bcg_type",
"sum(bcg_ocod)",
"sum(bcg_sfor)",
"sum(bcg_points)"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", ">", w)]
drwn = self.sql.getRec("bwlgme", cols=col, where=whr,
group="bcg_game, bcg_type", order="bcg_game")
drawn = []
for n, d in enumerate(drwn):
if d[1] == "S" and d[2]:
if d[3] or d[4]:
drawn = "X"
break
drawn.append(d[0])
if drawn == "X":
showError(self.opts["mf"].body, "Error",
"Results Have Already Been Captured for Game %s" % d[0])
return "Completed SvS Game %s" % d[0]
elif drawn:
if len(drawn) == 1:
text = "Game %s" % drawn[0]
plural = "Draw"
word = "Has"
else:
text = "Games"
for d in drawn:
text += " %s" % d
plural = "Draws"
word = "Have"
ok = askQuestion(self.opts["mf"].body, head="Draw Done",
mess="""Strength v Strength %s %s Been Drawn.
Do You Want to Delete the %s and Alter This Game's Results?
You Will Then Have to Re-Print Reports and Re-Draw %s.
If You Continue and Have Not Made a Backup You Will Not be Able to Restore.
Do You Still Want to Continue?""" % (text, word, plural, text), default="no")
if ok == "no":
return "rf"
col = ["bcg_date", "bcg_ocod", "bcg_rink"]
dat = [0, 0, ""]
if self.groups == "Y" and w == self.grgame:
col.append("bcg_group")
dat.append(0)
col.extend(["bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"])
dat.extend([0, 0, 0, 0, 0, 0, ""])
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "in", tuple(drawn))]
self.sql.updRec("bwlgme", cols=col, data=dat, where=whr)
self.opts["mf"].dbm.commitDbase()
elif chk[0] in ("A", "S"):
return "Invalid Game Number, Abandoned or Skipped"
self.gcod = w
gtyp = self.sql.getRec("bwlgme", cols=["bcg_type"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod",
"=", self.ccod), ("bcg_game", "=", w)], limit=1)[0]
bwlpts = self.sql.getRec("bwlpts", where=[("bcp_cono",
"=", self.opts["conum"]), ("bcp_code", "=", self.code),
("bcp_ptyp", "=", gtyp)], limit=1)
if not bwlpts:
bwlpts = [self.opts["conum"], 0, "D", "N", 0, "N",
0, 0, 1, "N", 0, 0, ""]
self.skins = bwlpts[self.sql.bwlpts_col.index("bcp_skins")]
self.sends = bwlpts[self.sql.bwlpts_col.index("bcp_sends")]
self.ponly = bwlpts[self.sql.bwlpts_col.index("bcp_p_only")]
self.epts = bwlpts[self.sql.bwlpts_col.index("bcp_e_points")]
self.spts = bwlpts[self.sql.bwlpts_col.index("bcp_s_points")]
self.gpts = bwlpts[self.sql.bwlpts_col.index("bcp_g_points")]
self.bpts = bwlpts[self.sql.bwlpts_col.index("bcp_bonus")]
dif = bwlpts[self.sql.bwlpts_col.index("bcp_win_by")]
self.win_by = [dif, dif * -1]
dif = bwlpts[self.sql.bwlpts_col.index("bcp_lose_by")]
self.lose_by = [dif, dif * -1]
def doEndsFin(self, frt, pag, r, c, p, i, w):
self.bonus = self.bpts
if w != self.ends:
if not w:
but = (("Exit",1),("Skipped",2),("Abandoned",3))
ok = askChoice(self.opts["mf"].body, head="Zero Ends",
mess="No Ends Completed, Choose Option", butt=but)
if ok == 1:
return "rf"
elif ok == 2:
self.sql.updRec("bwlgme", cols=["bcg_aflag"], data=["S"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=",
self.gcod)])
elif ok == 3:
self.sql.updRec("bwlgme", cols=["bcg_ocod", "bcg_rink",
"bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"], data=[0, "", 0, 0, 0, 0, 0, 0, "A"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=",
self.gcod)])
self.opts["mf"].dbm.commitDbase()
return "xt"
ok = askQuestion(self.opts["mf"].body, head="Shortened",
mess="Was This Game Shortened?", default="no")
if ok == "no":
return "rf"
if self.bonus == "Y":
ok = askQuestion(self.opts["mf"].body, head="Bonus Points",
mess="Must Bonus Points Still be Awarded?", default="no")
if ok == "no":
self.bonus = "N"
self.totpts = (w * self.epts) + self.gpts
if self.skins == "Y":
self.totpts = self.totpts + (int(w / self.sends) * self.spts)
if self.bonus == "Y":
self.maxpts = float(ASD(self.totpts) + ASD(1))
else:
self.maxpts = self.totpts
def doSkpCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=["btb_surname",
"btb_names", "bcg_ocod", "bcg_sfor", "bcg_sagt",
"bcg_points"], where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w), ("bcg_game",
"=", self.gcod), ("btb_tab=bcg_scod",)], limit=1)
if not chk:
return "Invalid Skip Code"
if chk[3] or chk[4] or chk[5]:
ok = askQuestion(self.opts["mf"].body, head="Already Entered",
mess="""This Card Has Already Been Entered, Re-Enter?
Shots For: %s
Shots Against: %s
Points: %s""" % (chk[3], chk[4], chk[5]),
default="no")
if ok == "no":
return "rf"
self.reenter = True
else:
self.reenter = False
self.skp = w
self.opp = chk[2]
if self.opp > 900000:
return "This Skip Had a Bye"
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 1, data=name)
if self.ponly == "N":
self.df.loadEntry(frt, pag, p + 2, data=chk[3])
self.df.loadEntry(frt, pag, p + 3, data=chk[5])
self.df.loadEntry(frt, pag, p + 4, data=self.opp)
if self.cfmat in ("D", "K"):
opp = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.opp)], limit=1)
chk = opp + [chk[4], chk[3], 0]
else:
chk = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=["btb_surname", "btb_names", "bcg_sfor",
"bcg_sagt", "bcg_points"], where=[("bcg_cono",
"=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.opp), ("bcg_game", "=", self.gcod),
("btb_tab=bcg_scod",)], limit=1)
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 5, data=name)
if self.ponly == "N":
self.df.loadEntry(frt, pag, p + 6, data=chk[2])
self.df.loadEntry(frt, pag, p + 7, data=chk[4])
if self.ponly == "Y":
self.mpts = self.totpts
return "sk2"
def doShots(self, frt, pag, r, c, p, i, w):
if i == 2:
self.s_for = w
if self.cfmat in ("D", "K", "R"):
self.p_for = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
if not self.s_for or (not self.totpts and self.bonus != "Y"):
self.p_for = w
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
else:
self.s_agt = w
if self.cfmat in ("D", "K"):
self.p_agt = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
if self.cfmat == "R":
if self.s_for == self.s_agt:
self.p_for = self.p_agt = .5
elif self.s_for > self.s_agt:
self.p_for = 1
self.p_agt = 0
else:
self.p_for = 0
self.p_agt = 1
self.df.loadEntry(frt, pag, p - 3, data=self.p_for)
self.df.loadEntry(frt, pag, p + 1, data=self.p_agt)
return "sk1"
if not self.s_agt or (not self.totpts and self.bonus != "Y"):
self.p_agt = w
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
self.mpts = self.totpts
if self.bonus == "N":
return
diff = float(ASD(self.s_for) - ASD(self.s_agt))
if not diff:
return
if diff > self.win_by[0] or diff < self.win_by[1]:
self.mpts = float(ASD(self.mpts) + ASD(1))
elif diff < self.lose_by[0] and diff > self.lose_by[1]:
self.mpts = float(ASD(self.mpts) + ASD(1))
def doPoints(self, frt, pag, r, c, p, i, w):
if w and w % 1 not in (0.0, 0.5):
return "Invalid Decimal in Points"
if w > self.maxpts:
return "Invalid Points, Exceed Maximum"
if i == 3:
self.p_for = w
self.df.loadEntry(frt, pag, p + 1, data=self.opp)
chk = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.opp)], limit=1)
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 2, data=name)
if self.ponly == "Y":
self.s_for = w
return "sk3"
else:
return "sk2"
if not w:
self.p_agt = float(ASD(self.mpts) - ASD(self.p_for))
self.df.loadEntry(frt, pag, p, data=self.p_agt)
else:
self.p_agt = w
if self.ponly == "Y":
self.s_agt = self.p_agt
tot = float(ASD(self.p_for) + ASD(self.p_agt))
if tot != self.mpts:
return "Invalid Total Points (%s s/b %s)" % (tot, self.mpts)
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
self.doLoadCards()
else:
if self.ponly == "Y" and not self.p_for and not self.p_agt:
aflag = "S"
elif self.ponly == "N" and not self.s_for and not self.s_agt:
aflag = "S"
else:
aflag = ""
col = [
"bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod)]
w = whr[:]
w.append(("bcg_scod", "=", self.skp))
self.sql.updRec("bwlgme", cols=col, data=[self.s_for, self.s_agt,
self.p_for, self.s_for, self.s_agt, self.p_for, aflag],
where=w)
if self.cfmat not in ("D", "K"):
w = whr[:]
w.append(("bcg_scod", "=", self.opp))
self.sql.updRec("bwlgme", cols=col, data=[self.s_agt,
self.s_for, self.p_agt, self.s_agt, self.s_for,
self.p_agt, aflag], where=w)
self.opts["mf"].dbm.commitDbase()
if self.reenter:
self.doLoadCards()
else:
self.df.advanceLine(0)
def doLoadCards(self):
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod)]
if self.ponly == "Y":
whr.append(("bcg_points", ">", 0))
else:
whr.append(("(", "bcg_sfor", ">", 0, "or",
"bcg_sagt", ">", 0, ")"))
recs = self.sql.getRec("bwlgme", cols=["bcg_scod", "bcg_ocod"],
where=whr, order="bcg_scod")
if not recs:
return
self.df.clearFrame("C", 0)
self.df.focusField("C", 0, 1)
skips = []
seq = 0
for rec in recs:
if rec[0] in skips:
continue
skips.extend(rec)
col = [
"btb_surname", "btb_names",
"bcg_sfor", "bcg_sagt", "bcg_points"]
skp = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=col, where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[0]),
("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)], limit=1)
idx = seq * 8
self.df.loadEntry("C", 0, idx, data=rec[0])
if skp[1]:
name = "%s, %s" % tuple(skp[:2])
else:
name = skp[0]
self.df.loadEntry("C", 0, idx + 1, data=name)
self.df.loadEntry("C", 0, idx + 2, data=skp[2])
self.df.loadEntry("C", 0, idx + 3, data=skp[4])
if self.cfmat in ("D", "K"):
tab = self.sql.getRec("bwltab", cols=col[:2],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", rec[1])], limit=1)
opp = tab + [skp[3], skp[4], 0]
else:
opp = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=col, where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[1]),
("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)],
limit=1)
self.df.loadEntry("C", 0, idx + 4, data=rec[1])
if opp[1]:
name = "%s, %s" % tuple(opp[:2])
else:
name = opp[0]
self.df.loadEntry("C", 0, idx + 5, data=name)
self.df.loadEntry("C", 0, idx + 6, data=opp[2])
self.df.loadEntry("C", 0, idx + 7, data=opp[4])
self.df.advanceLine(0)
if seq < 17:
seq += 1
def doExit(self):
if self.df.frt == "C" and self.df.col != 1:
chk = self.sql.getRec("bwlgme", where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game",
"=", self.gcod), ("bcg_aflag", "in", ("", "D"))])
for c in chk:
scod = c[self.sql.bwlgme_col.index("bcg_scod")]
ocod = c[self.sql.bwlgme_col.index("bcg_ocod")]
if scod > 900000 or ocod > 900000:
continue
if self.ponly == "Y":
fors = c[self.sql.bwlgme_col.index("bcg_points")]
agts = self.sql.getRec("bwlgme",
cols=["bcg_points"], where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod), ("bcg_scod",
"=", ocod)], limit=1)[0]
else:
fors = c[self.sql.bwlgme_col.index("bcg_sfor")]
agts = c[self.sql.bwlgme_col.index("bcg_sagt")]
if not fors and not agts:
self.df.focusField(self.df.frt, self.df.pag, self.df.col,
err="Missing Score Card for Skips %s and %s" % (scod,
ocod))
return
if self.cfmat in ("D", "K") and self.gcod != self.games:
# Delete Next Round's Records
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod)]
w = whr[:]
w.append(("bcg_game", ">", self.gcod))
self.sql.delRec("bwlgme", where=w)
# Create Next Round's Records
whr.append(("bcg_game", "=", self.gcod))
odr = "bcg_group, bcg_pair, bcg_scod"
g = self.sql.bwlgme_col
for grp in range(1, 3):
w = whr[:]
w.append(("bcg_group", "=", grp))
recs = self.sql.getRec("bwlgme", where=w, order=odr)
for num in range(0, len(recs), 2):
pair = int(num / 2) + 1
rec1 = copyList(recs[num])
if len(recs) == 1:
w = whr[:]
w.append(("bcg_group", "=", 2))
rec2 = self.sql.getRec("bwlgme", where=w,
order=odr, limit=1)
grp = 2
else:
rec2 = copyList(recs[num + 1])
skp1 = rec1[g.index("bcg_scod")]
opp1 = rec1[g.index("bcg_ocod")]
for1 = rec1[g.index("bcg_sfor")]
agt1 = rec1[g.index("bcg_sagt")]
skp2 = rec2[g.index("bcg_scod")]
opp2 = rec2[g.index("bcg_ocod")]
for2 = rec2[g.index("bcg_sfor")]
agt2 = rec2[g.index("bcg_sagt")]
if opp1 > 900000:
pl1 = skp1
elif for1 > agt1:
pl1 = skp1
else:
pl1 = opp1
if opp2 > 900000:
pl2 = skp2
elif for2 > agt2:
pl2 = skp2
else:
pl2 = opp2
dat = [self.opts["conum"], self.ccod, pl1,
self.gcod + 1, "D", 0, pl2, "", grp, 0,
0, 0.0, 0, 0, 0.0, "", 0, pair]
self.sql.insRec("bwlgme", data=dat)
if len(recs) == 1:
break
self.opts["mf"].dbm.commitDbase()
if self.cfmat in ("D", "K"):
callModule(self.opts["mf"], self.df, "bc2050",
coy=[self.opts["conum"], self.opts["conam"]],
args=self.ccod)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doQuit(self, event=None):
col = ["count(*)"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod),
("bcg_scod", "<", 900000),
("bcg_ocod", "<", 900000),
("bcg_sfor=0 and bcg_sagt=0",)]
chk = self.sql.getRec("bwlgme", cols=col, where=whr, limit=1)
if chk[0]:
ok = askQuestion(self.opts["mf"].body, "Quit Capture",
"Are You Sure that you would like to Quit before "\
"capturing All Results?", default="no")
if ok == "no":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ar2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.gc = GetCtl(self.opts["mf"])
assctl = self.gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.rordp = assctl["cta_rordp"]
tabs = ["assgrp", "assmst", "assdep", "asstrn"]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.dend = projectDate(self.opts["period"][1][0], -1)
self.todat = 0
self.imports = False
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("assmst", ),
"cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0,
"Description", "Y")),
"where": [("asm_cono", "=", self.opts["conum"])],
"whera": [["C", "asm_group", 0, 0]]
}
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
self.fld = [(("T", 0, 0, 0), "ID1", 10, "Take-on Date", "", self.dend,
"N", self.doTakeOnDate, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N",
self.doAssGrp, grp, None, None),
(("C", 0, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "",
"N", self.doAssCod, cod, None, ("notblank", )),
(("C", 0, 0, 2), "INA", 30, "Description", "Description",
"", "N", self.doDesc, None, None, ("notblank", )),
(("C", 0, 0, 3), "INa", 3, "Dep", "Depreciation Code", "",
"N", self.doDepCode, dep, None, ("notblank", )),
(("C", 0, 0, 4), "ONA", 10, "Dp-Details"),
(("C", 0, 0, 5), "ID1", 10, "Purch-Date", "Purchase Date",
0, "N", self.doPurDat, None, None, ("efld", )),
(("C", 0, 0, 6), "IUD", 10.2, "Cost", "Original Cost", 0,
"N", self.doCost, None, None, ("notzero", )),
(("C", 0, 0,
7), "IUD", 10.2, "Coy-Dep", "Company Depreciation", 0,
"N", self.doCDep, None, None, ("efld", ))]
if self.rordp == "Y":
self.fld.append((("C", 0, 0, 8), "IUD", 10.2, "Rec-Dep",
"Receiver Depreciation", 0, "N", self.doRDep,
None, None, ("efld", )))
tnd = [[self.endPage, "y"]]
txt = (self.exitPage, )
cnd = [[self.endPage, "y"]]
cxt = (self.exitPage, )
but = ((("Import File",None,self.doImport,0,("T",0,0),("C",0,2),
"Import a CSV or XLS File having the following fields: "\
"Asset Group, Code, Description, Depreciation Code, "\
"Purchase Date, Original Cost, Company Depeciation and "\
"Receiver Depreciation if applicable"),))
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
rows=(15, ),
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doTakeOnDate(self, frt, pag, r, c, p, i, w):
if w < self.dend:
return "Invalid Date, Too Far in the Past"
self.todat = w
def doAssGrp(self, frt, pag, r, c, p, i, w):
self.group = w
col = ["asg_depcod"]
whr = [("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group)]
acc = self.sql.getRec("assgrp", cols=col, where=whr, limit=1)
if not acc:
return "Invalid Asset Group"
self.depcod = acc[0]
def doImport(self):
self.df.closeProcess()
self.imports = True
impcol = []
for num, fld in enumerate(self.fld[1:]):
if fld[0][3] == 4:
continue
if num > 4:
num -= 1
impcol.append([fld[4], num, fld[1][1:], fld[2]])
fi = FileImport(self.opts["mf"], impcol=impcol)
err = False
for row, data in enumerate(fi.impdat):
funcs = [
"doAssGrp", "doAssCod", "doDesc", "doDepCode", "doPurDat",
"doCost", "doCDep"
]
if self.rordp == "Y":
funcs.append("doRDep")
for col, func in enumerate(funcs):
err = getattr(self, "%s" % func)("", 0, 0, 0, 0, 0, data[col])
if err:
showError(
self.opts["mf"].body, "Import Error",
"""Row %s Column %s - %s - %s
Please Correct the Import File and Try Again.""" % (row, col, data[col], err))
break
if err:
break
self.endPage()
if err:
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
def doAssCod(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec("assmst",
cols=["asm_desc"],
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group),
("asm_code", "=", w)],
limit=1)
if acc:
ok = askQuestion(screen=self.opts["mf"].body,
head="Asset Exists",
mess="""Asset already exists, Replace?
Please Note that if you decide to Replace the Asset, the Original Asset will be Deleted along with any History which may exist.""",
default="no")
if ok == "no":
return "Invalid Asset"
self.sql.delRec("assmst",
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group),
("asm_code", "=", self.code)])
self.sql.delRec("asstrn",
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)])
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=self.depcod)
def doDepCode(self, frt, pag, r, c, p, i, w):
col = ["asd_rate1r", "asd_desc"]
chk = self.sql.getRec("assdep",
cols=col,
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.rate1r = chk[0]
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=chk[1])
def doPurDat(self, frt, pag, r, c, p, i, w):
if w > self.todat:
return "Invalid Date, After Financial Period"
self.purdat = w
def doCost(self, frt, pag, r, c, p, i, w):
self.ccst = w
if self.rordp == "Y":
self.rcst = w
else:
self.rcst = 0
def doCDep(self, frt, pag, r, c, p, i, w):
self.cdep = float(ASD(0) - ASD(w))
if self.rordp == "N":
self.rdep = 0
return
if not self.rate1r:
self.rdep = 0
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=self.rdep)
return "sk1"
def doRDep(self, frt, pag, r, c, p, i, w):
self.rdep = float(ASD(0) - ASD(w))
def endPage(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
return
data = [
self.opts["conum"], self.group, self.code, self.desc, self.depcod
]
self.sql.insRec("assmst", data=data)
data = [
self.opts["conum"], self.group, self.code, 3, "Take-On", "Take-On",
self.purdat, 1, self.ccst, self.rcst, 0,
int(self.purdat / 100), "Original Cost", "", "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.cdep or self.rdep:
data = [
self.opts["conum"], self.group, self.code, 3, "Take-On",
"Take-On", self.todat, 4, self.cdep, self.rdep, 0,
int(self.todat / 100), "Accumulated Depreciation", "", "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if not self.imports:
self.df.advanceLine(0)
def exitPage(self):
self.df.closeProcess()
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
class dr6020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in opts:
self.curdt = opts["args"][0]
for self.chain, self.acno in opts["args"][1]:
self.doReAgeAuto()
self.opts["mf"].dbm.commitDbase()
else:
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["drsmst", "drschn", "drstrn", "drsage"],
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]
self.curdt = int(self.sysdtw / 100)
if "args" not in self.opts:
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def dataHeader(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", )}
if self.chains == "Y":
drm["cols"] = (("drm_chain", "", 0, "Chn"), ("drm_acno", "", 0,
"Acc-Num"),
("drm_name", "", 0, "Name",
"Y"), ("drm_add1", "", 0, "Address Line 1"))
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_stat", "<>", "X")]
drm["whera"] = [["T", "drm_chain", 0]]
else:
drm["cols"] = (("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0,
"Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0), ("drm_stat", "<>", "X")]
fld = [[["T", 0, 0, 0], "ID2", 7, "Period", "Current Financial Period",
self.curdt, "Y", self.doCurdt, None, None, ("efld", )],
[["T", 0, 1, 0], "INA", 7, "Acc-Num", "Account Number", "", "N",
self.doAccno, drm, None, ("notblank", )],
[["T", 0, 1, 0], "ONA", 30, "Name"]]
if self.chains == "Y":
fld.insert(1, [["T", 0, 0, 0], "IUI", 3, "Chain", "Chain Store",
"", "N", self.doChain, drc, None, ("efld", )])
else:
self.chain = 0
tnd = ((self.endTop, "n"), )
txt = (self.exitTop, )
self.but = (("Normal", None, self.doReAgeNormal, 0, None, None,
"Only Show Unallocated Transactions"),
("History", None, self.doReAgeHistory, 0, None, None,
"Show All Transactions, Including Already Allocated"),
("Automatic", None, self.doReAgeAuto, 0, None, None,
"Automatically Re-Age the Account Based on Date"))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
butt=self.but)
def doCurdt(self, frt, pag, r, c, p, i, w):
self.curdt = w
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
cols=["chm_chain"],
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doAccno(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.acno = w
self.key = None
self.df.loadEntry("T", pag, p + 1, data=acc[0])
self.opts["mf"].updateStatus("Select Routine")
for b in range(3):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
if self.key in ("normal", "history"):
return "nd"
elif self.key == "cancel":
return "nc"
def doReAgeNormal(self):
self.key = "normal"
self.doReAge()
def doReAgeHistory(self):
self.key = "history"
self.doReAge()
def doReAge(self):
self.opts["mf"].updateStatus("")
for b in range(3):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "disabled")
col = [
"drt_trdt", "drt_ref1", "drt_type", "drt_tramt", "paid", "balance"
]
whr = [("drt_cono", "=", self.opts["conum"]),
("drt_chain", "=", self.chain), ("drt_acno", "=", self.acno)]
if self.key == "normal":
dtc, recs = getTrn(self.opts["mf"].dbm, "drs", whr=whr, zer="N")
else:
dtc, recs = getTrn(self.opts["mf"].dbm, "drs", whr=whr)
if recs:
data = []
for rec in recs:
dat = []
for c in col:
dat.append(rec[dtc.index(c)])
data.append(dat)
age = AgeTrans(self.opts["mf"], "drs", data, 0, xits=False)
if not age.ccl and age.data:
if age.total.work:
while not age.ccl:
age.doAllocate()
if age.ccl or not age.total.work:
break
if age.ccl:
self.key = "cancel"
age.data = []
for tr in age.data:
if tr[6]:
w = copyList(whr)
w.extend([("drt_type", "=", tr[2]),
("drt_ref1", "=", tr[1])])
self.sql.insRec("drsage",
data=[
self.opts["conum"], self.chain,
self.acno, tr[2], tr[1],
self.curdt, tr[2], tr[1], tr[6], 0
])
else:
self.key = "cancel"
self.agevar.set(False)
def doReAgeAuto(self):
self.key = "normal"
if "args" not in self.opts:
for b in range(3):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Re-Ageing .... Please Wait!")
self.df.setWidget(self.df.mstFrame, state="hide")
txt = "Re-Allocating ... Please Wait"
pb = ProgressBar(self.opts["mf"].body, typ=("G", txt))
doAutoAge(self.opts["mf"].dbm,
"drs",
self.opts["conum"],
chain=self.chain,
acno=self.acno,
pbar=pb)
pb.closeProgress()
self.df.setWidget(self.df.mstFrame, state="show")
self.agevar.set(False)
else:
doAutoAge(self.opts["mf"].dbm,
"drs",
self.opts["conum"],
chain=self.chain,
acno=self.acno,
pbar=None)
def endTop(self):
self.df.clearEntry("T", 0, 2)
self.df.clearEntry("T", 0, 3)
if self.chains == "Y":
self.df.clearEntry("T", 0, 4)
self.df.focusField("T", 0, 2)
def exitTop(self):
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bc2060(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
t = time.localtime()
self.today = ((t[0] * 10000) + (t[1] * 100) + t[2])
self.sql = Sql(self.opts["mf"].dbm,
["bwlcmp", "bwltab", "bwlgme", "bwltyp", "bwlent"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
com = {
"stype":
"R",
"tables": ("bwlcmp", ),
"cols":
(("bcm_code", "", 0, "Cod"), ("bcm_name", "", 0, "Name", "Y"),
("bcm_date", "", 0, "Date")),
"where": [("bcm_cono", "=", self.opts["conum"])]
}
skp = {
"stype":
"R",
"tables": ("bwltab", "bwlgme"),
"cols":
(("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname",
"Y"), ("btb_names", "", 0, "Names"),
("bcg_rink", "", 0, "RK"), ("bcg_ocod", "", 0, "Opp")),
"where": [("btb_cono", "=", self.opts["conum"]),
("bcg_cono=btb_cono", ), ("bcg_scod=btb_tab", )],
"whera": [("T", "bcg_ccod", 0, 0), ("T", "bcg_game", 2, 0)],
"group":
"btb_tab",
"order":
"btb_tab"
}
fld = (
(("T",0,0,0),"I@bcm_code",0,"","",
"","Y",self.doCmpCod,com,None,("notzero",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,1,0),"I@bcg_game",0,"Game Number","",
1,"N",self.doGame,None,None,("efld",)),
(("T",0,1,0),"I@bcg_date",0,"Date","",
self.today,"N",self.doDate,None,None,("efld",)),
(("T",0,2,0),"IUA",30,"Greens","Greens (A,B,C)",
"","N",self.doGreens,None,None,("efld",),None,"Available "\
"Greens in the format A,B or A,B345 showing Green Code and "\
"Rinks. If the Rinks are Not Entered they will Default to 6."),
(("C",0,0,0),"I@bcg_scod",0,"","",
"","N",self.doSkpCod,skp,None,("notzero",)),
(("C",0,0,0),"ONA",30,"Skp-Name"),
(("C",0,0,0),"I@bcg_ocod",0,"","",
"","N",self.doOppCod,skp,None,("notzero",)),
(("C",0,0,0),"ONA",30,"Opp-Name"),
(("C",0,0,0),"I@bcg_rink",0,"","",
"","N",self.doRink,None,None,("notblank",)))
but = (("Quit", None, self.doQuit, 1, None, None), )
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
cnd = ((self.doEnd, "y"), )
cxt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("bwlcmp",
cols=["bcm_name", "bcm_date", "bcm_type"],
where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_code", "=", w)],
limit=1)
if not com:
return "Invalid Competition Code"
name, self.sdat, ctyp = com
self.df.loadEntry(frt, pag, p + 1, data=name)
chk = self.sql.getRec("bwltyp",
cols=["bct_cfmat"],
where=[("bct_cono", "=", self.opts["conum"]),
("bct_code", "=", ctyp)],
limit=1)
if chk[0] in ("D", "K", "R"):
return "Knockout and R/Robin Draws Cannot be Changed"
chk = self.sql.getRec("bwlgme",
cols=[
"bcg_game", "bcg_date", "bcg_aflag",
"sum(bcg_ocod)", "sum(bcg_sfor)"
],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", w)],
group="bcg_game, bcg_date, bcg_aflag")
self.ccod = w
self.game = 0
self.draws = {}
self.manual = False
for ck in chk:
if ck[2] == "A" or ck[4]:
continue
if ck[4]:
continue
if ck[2] in ("", "D", "S") and ck[3]:
self.draws[ck[0]] = ck[1:]
if not self.draws:
ok = askQuestion(self.opts["mf"].body, "Manual Draw",
"Is this the First Game and is it going to be a "\
"Manual Draw?", default="no")
if ok == "no":
return "rf"
self.manual = True
self.game = 1
self.df.loadEntry(frt, pag, p + 2, data=self.game)
self.totskp = self.sql.getRec("bwlent",
cols=["count(*)"],
where=[("bce_cono", "=",
self.opts["conum"]),
("bce_ccod", "=", self.ccod)],
limit=1)[0]
return "sk2"
def doGame(self, frt, pag, r, c, p, i, w):
if w not in self.draws:
return "Invalid Game Number"
self.game = w
self.date = self.draws[w][0]
self.df.loadEntry(frt, pag, p + 1, data=self.date)
self.totskp = self.sql.getRec("bwlent",
cols=["count(*)"],
where=[("bce_cono", "=",
self.opts["conum"]),
("bce_ccod", "=", self.ccod)],
limit=1)[0]
def doDate(self, frt, pag, r, c, p, i, w):
if w < self.today or w < self.sdat:
return "Invalid Date, in the Past or Before the Starting Date"
self.date = w
def doGreens(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid Greens"
self.rinks = []
rinks = 0
grns = w.split(",")
for gr in grns:
if len(gr) == 1:
for x in range(1, 7):
self.rinks.append("%s%s" % (gr[0], x))
rinks += 6
elif len(gr) == 2 and gr[1] == "7":
for x in range(1, 8):
self.rinks.append("%s%s" % (gr[0], x))
rinks += 7
else:
for rk in gr[1:]:
self.rinks.append("%s%s" % (gr[0], rk))
rinks += 1
if int(self.totskp / 2) > rinks:
return "Not Enough Rinks"
def doSkpCod(self, frt, pag, r, c, p, i, w):
skp = self.sql.getRec(
tables=["bwlgme", "bwltab"],
cols=["btb_surname", "btb_names", "bcg_ocod", "bcg_rink"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w),
("bcg_game", "=", self.game), ("btb_cono=bcg_cono", ),
("btb_tab=bcg_scod", )],
limit=1)
if not skp:
return "Invalid Skip Code"
self.skip = w
self.old_opp = skp[2]
self.old_rink = skp[3]
if skp[1]:
name = "%s, %s" % tuple(skp[:2])
else:
name = skp[0]
self.df.loadEntry(frt, pag, p + 1, data=name)
if self.old_opp:
self.df.loadEntry(frt, pag, p + 2, data=self.old_opp)
opp = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", skp[2])],
limit=1)
if opp[1]:
name = "%s, %s" % tuple(opp[:2])
else:
name = opp[0]
self.df.loadEntry(frt, pag, p + 3, data=name)
if self.old_rink:
self.df.loadEntry(frt, pag, p + 4, data=self.old_rink)
def doOppCod(self, frt, pag, r, c, p, i, w):
opp = self.sql.getRec(
tables=["bwlgme", "bwltab"],
cols=["btb_surname", "btb_names", "bcg_ocod", "bcg_rink"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w),
("bcg_game", "=", self.game), ("btb_cono=bcg_cono", ),
("btb_tab=bcg_scod", )],
limit=1)
if not opp:
return "Invalid Opponents Code"
self.new_opp = w
self.chg_skp = opp[2]
if opp[1]:
name = "%s, %s" % tuple(opp[:2])
else:
name = opp[0]
self.df.loadEntry(frt, pag, p + 1, data=name)
def doRink(self, frt, pag, r, c, p, i, w):
if w not in self.rinks:
return "Invalid Rink"
self.new_rink = w
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
else:
self.df.advanceLine(0)
self.sql.updRec("bwlgme",
cols=["bcg_date", "bcg_ocod", "bcg_rink"],
data=[self.date, self.new_opp, self.new_rink],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.skip),
("bcg_game", "=", self.game)])
self.sql.updRec("bwlgme",
cols=["bcg_date", "bcg_ocod", "bcg_rink"],
data=[self.date, self.skip, self.new_rink],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.new_opp),
("bcg_game", "=", self.game)])
def doExit(self):
if self.df.frt == "C":
chk = self.sql.getRec("bwlgme",
cols=["bcg_ocod", "count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game)],
group="bcg_ocod",
order="bcg_ocod")
for c in chk:
if c[0] and c[1] != 1:
skp = self.sql.getRec("bwlgme",
cols=["bcg_scod"],
where=[("bcg_cono", "=",
self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game),
("bcg_ocod", "=", c[0])],
order="bcg_scod")
err = "Opponent %s is Drawn Against %s Skips\n" % tuple(c)
for s in skp:
err = err + "\nSkip %s" % s[0]
skp = self.sql.sqlRec("Select bce_scod from bwlent where "\
"bce_ccod = %s and bce_scod not in (select bcg_ocod "\
"from bwlgme where bcg_ccod = %s and bcg_game = %s)" %
(self.ccod, self.ccod, self.game))
err = err + "\n\nSkips Without Opponents\n"
for s in skp:
err = err + "\nSkip %s" % s[0]
showError(self.opts["mf"].body, "Skip Error", err)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
chk = self.sql.getRec("bwlgme",
cols=["bcg_rink", "count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game)],
group="bcg_rink",
order="bcg_rink")
for c in chk:
if c[1] != 2:
skp = self.sql.getRec("bwlgme",
cols=["bcg_scod", "bcg_ocod"],
where=[("bcg_cono", "=",
self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game),
("bcg_rink", "=", c[0])],
group="bcg_scod, bcg_ocod, bcg_rink",
order="bcg_scod")
skps = []
for s in skp:
if [s[1], s[0]] not in skps:
skps.append(s)
err = "Rink %s Shows %s time(s)\n" % (c[0], int(c[1] / 2))
for s in skps:
err = err + "\nSkip %2s Opp %2s" % (s[0], s[1])
rnk = self.sql.getRec("bwlgme",
cols=["bcg_rink", "count(*)"],
where=[("bcg_cono", "=",
self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game)],
group="bcg_rink",
order="bcg_rink")
rnks = []
for r in rnk:
rnks.append(r[0])
mis = ""
for r in self.rinks:
if r not in rnks:
if not mis:
mis = r
else:
mis = "%s, %s" % (mis, r)
err = err + "\n\nAvailable Rink(s)\n\n%s" % mis
showError(self.opts["mf"].body, "Rink Error", err)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doQuit(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.closeProcess()
self.opts["mf"].closeLoop()
class dr2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] != 2:
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
# Setup SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "ctlvmf", "drschn", "drsmst", "drstrn", "genint",
"genmst", "gentrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst",
cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])],
limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
#
self.gc = GetCtl(self.opts["mf"])
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.chains = drsctl["ctd_chain"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.drsctl = ctlctl["drs_ctl"]
self.dis_all = ctlctl["dis_all"]
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.allcoy = self.opts["conum"]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.chains == "N":
self.chain = 0
self.glt = 6
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"DRS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
drc = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"])]
drm["whera"] = [["C", "drm_chain", 0, 1]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
coy = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))
}
viw = {
"stype":
"R",
"tables": ("drstrn", ),
"cols": (("drt_chain", "", 0, ""), ("drt_acno", "", 0, ""),
("drt_ref1", "", 0, ""), ("drt_trdt", "", 0, ""),
("drt_tramt", "", 0, ""), ("drt_taxamt", "", 0, "")),
"where": [("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_batch", "=", self.bh.batno)],
"order":
"drt_seq"
}
tag = (("Deposit", None, None, None, False), ("Allocation", None, None,
None, False))
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One",
"i", "Y", self.doRef1, None, None, ("efld", )),
(("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 3), "INA", (30), "Details", "Deposit Details", "",
"N", self.doTrnDet, None, None, None),
(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
[("C", 2, 0, 0), "OUI", 3, "Coy", "Company Number",
self.opts["conum"], "N", self.doCoyNum, coy, None,
("notzero", )],
[("C", 2, 0, 1), "IUI", 3, "Chn", "Chain Store", "r", "N",
self.doChain, drc, None, ("efld", )],
(("C", 2, 0, 2), "INA", 7, "Acc-Num", "Account Number", "r",
"N", self.doDrsAcc, drm, None, ("notblank", )),
(("C", 2, 0, 3), "ONA", 30, "Name"),
(("C", 2, 0, 4), "ISD", 13.2, "Receipt", "Receipt Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 5), "ISD", 13.2, "Discount", "Discount Amount", "",
"N", self.doDisAmt, None, None, ("efld", ), None,
"Discount Amount to be Added to the Receipt Amount"),
(("C", 2, 0, 6), "OSD", 13.2, "Total-Amount")]
if self.glint == "Y" and self.incoac:
fld[7][1] = "IUI"
if self.chains == "N":
fld[8][1] = "OUI"
but = [("View Entries", viw, None, 1, ("C", 2, 3), ("C", 2, 4),
"View Batch Transactions", 1),
("Interrogate", None, self.queryDrs, 0, ("C", 2, 3),
("C", 2, 0), "Interrogate Debtors Accounts", 1),
("Maintain", None, self.maintainDrs, 0, ("C", 2, 3),
("C", 2, 4), "Maintain Debtors Accounts", 1),
("Canc_el", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1), "", 1)]
else:
but = [("View Entries", viw, None, 0, ("C", 2, 3), ("C", 2, 4),
"View Batch Transactions", 1),
("Interrogate", None, self.queryDrs, 0, ("C", 2, 2),
("C", 2, 0), "Interrogate Debtors Accounts", 1),
("Maintain", None, self.maintainDrs, 0, ("C", 2, 2),
("C", 2, 3), "Maintain Debtors Accounts", 1),
("Canc_el", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1), "", 1)]
but.extend((
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",2),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions, Including Already Allocated",2),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",2),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",2)))
txt = (None, None, None)
cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")]
cxt = [None, self.exitPage1, self.exitPage2]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doRef1(self, frt, pag, r, c, p, i, w):
if not w:
trns = self.sql.getRec("drstrn",
cols=["drt_ref1"],
where=[("drt_cono", "=",
self.opts["conum"]),
("drt_ref1", "like", "R________")],
order="drt_ref1 desc")
auto = False
for trn in trns:
try:
w = "R%08i" % (int(trn[0][1:]) + 1)
auto = True
break
except:
pass
if not auto:
w = "R00000001"
self.df.loadEntry(frt, pag, p, data=w)
chk = self.sql.getRec("drstrn",
cols=["drt_acno"],
where=[("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_ref1", "=", w)])
if chk:
return "A Transaction with this Reference Already Exists"
self.ref1 = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
self.allocated = float(0.00)
def endPage1(self):
self.agecan = False
self.batupd = False
self.updateTables1()
self.updateBatch()
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.glint == "Y":
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not acc:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", w),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.allcoy = w
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
cols=["chm_chain"],
where=[("chm_cono", "=", self.allcoy),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doDrsAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.allcoy),
("drm_chain", "=", self.chain),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.dracno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.allref = self.ref1
while self.sql.getRec("drstrn",
cols=["drt_batch"],
where=[("drt_cono", "=", self.allcoy),
("drt_chain", "=", self.chain),
("drt_acno", "=", self.dracno),
("drt_type", "=", self.opts["rtn"]),
("drt_ref1", "=", self.allref)]):
self.doGetAnotherRef()
def doGetAnotherRef(self):
tit = ("Duplicate Reference Number", )
fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref,
"N", None, None, None, None),
(("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N",
self.doRefNew, None, None, ("notblank", )))
tnd = ((self.doRefEnd, "n"), )
txt = (self.doRefExit, )
state = self.df.disableButtonsTags()
self.tf = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=tnd,
txit=txt)
self.tf.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doRefExit(self):
self.tf.focusField("T", 0, 2)
def doRefNew(self, frt, pag, r, c, p, i, w):
self.allref = w
def doRefEnd(self):
self.tf.closeProcess()
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
ok = self.checkSign()
elif self.allamt > 0 and w < 0:
ok = self.checkSign()
else:
ok = "yes"
if ok != "yes":
return "Invalid Discount Amount (Sign Error)"
self.disamt = w
totamt = float(ASD(self.allamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def checkSign(self):
return askQuestion(self.opts["mf"].body, "Check Sign",
"The Sign of the Discount Amount is not the same "\
"as the Sign of the Receipt Amount, Is This Correct?")
def endPage2(self):
self.amt = float(ASD(0) - ASD(self.allamt))
self.dis = float(ASD(0) - ASD(self.disamt))
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
# Debtors Ledger Transaction
data = [
self.allcoy, self.chain, self.dracno, self.opts["rtn"],
self.allref, self.bh.batno, self.trndat, "", self.amt, 0.00,
self.curdt, self.trndet, "", "N", self.opts["capnm"], self.sysdtw,
0
]
self.sql.insRec("drstrn", data=data)
if self.dis:
data = [
self.allcoy, self.chain, self.dracno, 6, self.allref,
self.bh.batno, self.trndat, "", self.dis, 0.00, self.curdt,
self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("drstrn", data=data)
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.glint == "Y":
# General Ledger Control Transaction (Debtors)
amt = float(ASD(self.amt) + ASD(self.dis))
data = (self.allcoy, self.drsctl, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.disamt:
data = (self.allcoy, self.dis_all, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, self.disamt,
0.00, self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany)
if self.allcoy != self.opts["conum"]:
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=",
self.opts["conum"]),
("cti_inco", "=", self.allcoy)],
limit=1)[0]
data = (self.opts["conum"], acc, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.allcoy),
("cti_inco", "=",
self.opts["conum"])],
limit=1)[0]
amt = float(ASD(0) - ASD(self.amt))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.allref, self.bh.batno, amt, 0.00, self.trndet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="drs",
agetyp=atype,
agekey=[
self.allcoy, self.chain, self.dracno,
self.opts["rtn"], self.allref, self.curdt, self.amt,
self.dis
])
self.agecan = age.cancel
self.agevar.set(False)
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryDrs(self):
callModule(self.opts["mf"],
self.df,
"dr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def maintainDrs(self):
callModule(self.opts["mf"],
self.df,
"dr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class ms1040(object):
def __init__(self, **opts):
self.opts = opts
if "args" in opts:
self.code = opts["args"]
else:
self.code = None
if self.setVariables():
self.mainProcess()
if self.code:
self.df.doKeyPressed("T", 0, 0, self.code)
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "ctlvrf", "ctlvtf",
"chglog"], prog=self.__class__.__name__)
if self.sql.error:
return
if not self.code:
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
if not ctlmst["ctm_taxno"]:
showError(self.opts["mf"].body, "Unregistered",
"The Company Record Does Not Have a V.A.T. Number")
return
return True
def mainProcess(self):
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y"),
("vtm_cat", "", 0, "C")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [("vtr_cono", "=", self.opts["conum"])],
"whera": [["T", "vtr_code", 0, 0]]}
vtt = {
"stype": "C",
"titl": "VAT Types",
"head": ("C", "Description"),
"data": [
["N", "None"],
["S", "Standard"],
["Z", "Zero Rated"],
["C", "Capital Item"],
["X", "Excluded Item"]]}
fld = (
(("T",0,0,0),"IUA",1,"V.A.T. Code","",
"","Y",self.doCode,vtm,None,("notblank",)),
(("T",0,1,0),"INA",30,"Description","",
"","N",self.doDesc,None,self.doDelete,("notblank",)),
(("T",0,2,0),"IUA",1,"Category","",
"S","N",self.doCat,vtt,None,("in", ("C","N","S","X","Z"))),
(("C",0,0,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doStart,vtr,None,("efld",)),
(("C",0,0,1),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doRate,None,None,("efld",)))
but = (
("Print",None,self.doPrint,0,("T",0,1),(("T",0,0),("T",0,2))),
("Add",None,self.doAdd,0,("T",0,0),None),
("Edit",None,self.doEdit,0,("T",0,0),None),
("Exit",None,self.doExit,0,("T",0,0),(("T",0,1),("C",0,1))))
tnd = ((self.doTEnd,"y"), )
txt = (self.doTExit, )
cnd = ((self.doCEnd,"y"), )
cxt = (self.doCExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, rows=(15,))
def doPrint(self):
hds = "V.A.T. Records"
col = [
["vtm_code", "UA", 1, "C"],
["vtm_desc", "NA", 30, "Description"],
["vtm_cat", "UA", 1, "T"],
["vtr_date", "d1", 10, "Start-Date"],
["vtr_rate", "UD", 6.2, "Rate"]]
recs = self.sql.getRec(tables=["ctlvmf", "ctlvrf"], cols=["vtm_code",
"vtm_desc", "vtm_cat", "vtr_date", "vtr_rate"], where=[("vtm_cono",
"=", self.opts["conum"]), ("vtr_cono=vtm_cono",),
("vtr_code=vtm_code",)], order="vtm_code, vtr_date")
code = None
data = copyList(recs)
for num, rec in enumerate(recs):
if rec[0] == code:
data[num][0] = ""
data[num][1] = ""
data[num][2] = ""
code = rec[0]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=data,
heads=[hds], ttype="D", cols=col, prtdia=(("Y","V"), ("Y","N")))
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 0, 1)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.oldm = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)], limit=1)
if not self.oldm:
self.newm = True
else:
self.newm = False
self.desc = self.oldm[self.sql.ctlvmf_col.index("vtm_desc")]
self.df.loadEntry(frt, pag, p+1, data=self.desc)
self.cat = self.oldm[self.sql.ctlvmf_col.index("vtm_cat")]
self.df.loadEntry(frt, pag, p+2, data=self.cat)
self.doLoadRates()
return "ff2"
def doDelete(self):
if self.df.frt == "T":
if self.doCheckTrn():
showError(self.opts["mf"].body, "Exists",
"Transactions Exist for this Code, Not Deleted")
return
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["ctlvmf", "D", "%03i%-1s" % \
(self.opts["conum"], self.code), "", dte, self.opts["capnm"],
"", "", "", 0])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doCat(self, frt, pag, r, c, p, i, w):
self.cat = w
def doTEnd(self):
self.edit = False
datm = [self.opts["conum"]]
datm.extend(self.df.t_work[0][0][:3])
if self.newm:
self.sql.insRec("ctlvmf", data=datm)
if self.cat in ("N", "X", "Z"):
newr = [self.opts["conum"], self.code, 0, 0]
self.sql.insRec("ctlvrf", data=newr)
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
else:
self.doButtons()
self.df.focusField("C", 0, 1)
elif self.cat in ("N", "X", "Z"):
self.df.focusField("T", 0, 1)
elif datm != self.oldm[:len(datm)]:
col = self.sql.ctlvmf_col
datm.append(self.oldm[col.index("vtm_xflag")])
self.sql.updRec("ctlvmf", data=datm, where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec("chglog", data=["ctlvmf",
"U", "%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datm[num]), "", 0])
self.doButtons()
self.opts["mf"].dbm.commitDbase()
def doTExit(self):
chks = ""
recs = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"])])
for rec in recs:
rte = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", rec[1])])
if not rte:
if rec[3] in ("N", "X", "Z"):
self.sql.insRec("ctlvrf", data=[rec[0], rec[1], 0, 0])
self.opts["mf"].dbm.commitDbase()
continue
chks = "%s\n%1s %-30s %1s" % (chks, rec[1], rec[2], rec[3])
if chks:
showError(self.opts["mf"].body, "Missing Rate Record", "The "\
"following VAT Codes do Not have Rate Records:\n%s\n\n"\
"You will Not be able to Exit until you either Create "\
"Rate Records or Delete these codes." % chks)
self.df.focusField("T", 0, 1)
else:
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doAdd(self):
for num, rec in enumerate(self.df.c_work[0]):
if not rec[0] and not rec[1]:
pos = (num * 2) + 1
self.df.focusField("C", 0, pos)
break
def doEdit(self):
self.edit = True
self.newr = False
tit = "Edit Rate"
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [
("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)]}
fld = (
(("T",0,0,0),"OUA",1,"V.A.T. Code"),
(("T",0,1,0),"ONA",30,"Description"),
(("T",0,2,0),"OUA",1,"Category"),
(("T",0,3,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doEStart,vtr,self.doEDelete,("efld",)),
(("T",0,4,0),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doERate,None,self.doEDelete,("notzero",)))
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.ed = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doEEnd,"n"),), txit=(self.doEExit,))
self.ed.loadEntry("T", 0, 0, data=self.code)
self.ed.loadEntry("T", 0, 1, data=self.desc)
self.ed.loadEntry("T", 0, 2, data=self.cat)
self.ed.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
if self.exit:
self.df.focusField("T", 0, 1)
else:
self.doExit()
def doEDelete(self):
self.exit = False
if self.ed.pos == 3:
if self.doCheckTrn():
return ("T", 0, 4, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
else:
if self.doCheckTrn(self.start):
return ("T", 0, 5, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
self.ed.closeProcess()
chk = self.sql.getRec("ctlvrf", cols=["count(*)"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], limit=1)
if not chk[0]:
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.exit = True
self.opts["mf"].dbm.commitDbase()
return "nf"
def doEStart(self, frt, pag, r, c, p, i, w):
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", w)], limit=1)
if not self.oldr:
return "Date Does Not Exist"
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist for Date, Editing Not Allowed.")
return "Invalid Date"
self.start = w
self.rate = self.oldr[3]
self.ed.loadEntry(frt, pag, p+1, data=self.rate)
def doERate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doEEnd(self):
self.ed.closeProcess()
self.doCEnd()
def doEExit(self):
self.ed.closeProcess()
def doStart(self, frt, pag, r, c, p, i, w):
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist On or After This Starting Date.")
return "Invalid Date"
self.start = w
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)], limit=1)
if not self.oldr:
self.newr = True
if self.cat in ("N", "X", "Z"):
if self.edit:
self.ed.loadEntry(frt, pag, p+1, data=0)
else:
self.df.loadEntry(frt, pag, p+1, data=0)
return "nd"
else:
self.newr = False
if self.edit:
self.ed.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
else:
self.df.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
def doRate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doCheckTrn(self, date=None):
where = [
("vtt_cono", "=", self.opts["conum"]),
("vtt_code", "=", self.code)]
if date:
where.append(("vtt_refdt", ">=", date))
return self.sql.getRec("ctlvtf", cols=["count(*)"],
where=where, limit=1)[0]
def doCEnd(self):
datr = [self.opts["conum"], self.code, self.start, self.rate]
if self.newr:
self.sql.insRec("ctlvrf", data=datr)
elif datr != self.oldr[:len(datr)]:
col = self.sql.ctlvrf_col
datr.append(self.oldr[col.index("vtr_xflag")])
self.sql.updRec("ctlvrf", data=datr, where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldr):
if dat != datr[num]:
self.sql.insRec("chglog", data=["ctlvrf", "U",
"%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datr[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
self.edit = False
self.doExit()
def doCExit(self):
self.edit = False
self.doExit()
def doLoadRates(self):
self.df.clearFrame("C", 0)
recs = self.sql.getRec("ctlvrf",
cols=["vtr_date", "vtr_rate"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], order="vtr_date")
for num, rec in enumerate(recs):
pos = (num * 2)
if pos > 27:
self.df.scrollScreen(0)
pos = 26
self.df.focusField("C", 0, pos + 1)
self.df.loadEntry("C", 0, pos, data=rec[0])
self.df.focusField("C", 0, pos + 2)
self.df.loadEntry("C", 0, pos + 1, data=rec[1], zero=True)
def doButtons(self):
self.df.setWidget(self.df.B1, "normal")
self.df.setWidget(self.df.B2, "normal")
self.df.setWidget(self.df.B3, "normal")
self.opts["mf"].window.focus_set()
def doExit(self):
self.df.setWidget(self.df.B3, "disabled")
self.df.focusField("T", 0, 1)
class 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 cr4010(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, ["crsmst", "crstrn", "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.fromad = crsctl["ctc_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.curdt = int(self.sysdtw / 100)
self.paidup = "N"
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Creditors Interrogation (%s)" % self.__class__.__name__)
crm = {
"stype": "R",
"tables": ("crsmst",),
"cols": (
("crm_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")),
"where": [("crm_cono", "=", self.opts["conum"])]}
tag = (
("Basic-_A", self.doTagSelect, ("T",0,2), ("T",0,1)),
("Basic-_B", self.doTagSelect, ("T",0,2), ("T",0,1)),
("Balances", self.doTagSelect, ("T",0,2), ("T",0,1)),
("History", self.doTagSelect, ("T",0,2), ("T",0,1)),
("Trans", self.doTrans1, ("T",0,2), ("T",0,1)),
("Orders", self.doOrders, ("T",0,2), ("T",0,1)))
r1s = (("No","N"),("Yes","Y"))
fld = (
(("T",0,0,0),"INA",7,"Acc-Num","Account Number",
"","N",self.doAccNum,crm,None,None),
(("T",0,0,0),"ONA",30,"Name"),
(("T",1,0,0),"ONA",30,"Address Line 1"),
(("T",1,1,0),"ONA",30,"Address Line 2"),
(("T",1,2,0),"ONA",30,"Address Line 3"),
(("T",1,3,0),"ONA",4,"Postal Code"),
(("T",1,4,0),"ONA",20,"Telephone"),
(("T",1,5,0),"ONA",20,"Fax"),
(("T",1,6,0),"ONA",30,"Manager"),
(("T",1,6,0),"OTX",30,"E-Mail"),
(("T",1,7,0),"ONA",30,"Accounts"),
(("T",1,7,0),"OTX",30,"E-Mail"),
(("T",1,8,0),"ONA",30,"Orders"),
(("T",1,8,0),"OTX",30,"E-Mail"),
(("T",1,9,0),"Od1",10,"Date Opened"),
(("T",1,10,0),"ONA",10,"V.A.T. Number"),
(("T",2,0,0),"OUA",1,"Terms Base"),
(("T",2,1,0),"OUI",2,"Statement Day"),
(("T",2,2,0),"OUI",3,"Terms"),
(("T",2,3,0),"OUI",5,"Credit Limit"),
(("T",2,4,0),"OUD",5.2,"Trade Discount"),
(("T",2,5,0),"OUD",5.2,"Settlement Discount"),
(("T",2,6,0),"OUA",1,"Payment Indicator"),
(("T",2,7,0),"OUA",20,"Bank Name"),
(("T",2,8,0),"OUI",8,"Bank Branch"),
(("T",2,9,0),"OUA",16,"Bank Account"),
(("T",2,10,0),"OUI",7,"G/L Account"),
(("T",2,11,0),"OUA",1,"Status"),
(("T",3,0,0),"Od1",10,"Date Last Purchased"),
(("T",3,1,0),"Od1",10,"Date Last Paid"),
(("T",3,2,0),"OSD",13.2,"Total Balance"),
(("T",3,3,0),"OSD",13.2,"Current"),
(("T",3,4,0),"OSD",13.2,"30 Days"),
(("T",3,5,0),"OSD",13.2,"60 Days"),
(("T",3,6,0),"OSD",13.2,"90 Days"),
(("T",3,7,0),"OSD",13.2,"120 Days"),
(("C",4,0,0),"OSD",13.2,"Purchases","","","N",
None,None,None,None,("Months",13)),
(("C",4,0,1),"OSD",13.2,"Payments"),
(("T",5,0,0),("IRB",r1s),0,"History", "",
"N","N",self.doTrans2,None,None,None))
but = (
("Clear",None,self.doClear,0,("T",0,0),("T",0,1)),
("Notes",None,self.doNotes,0,("T",0,0),("T",0,1)),
("Print",None,self.doPrint,0,("T",0,0),("T",0,1)),
("Quit",None,self.doExit,1,None,None))
tnd = ((self.doEndTop, "N"), None, None, None, None, None)
txt = (self.doExit, None, None, None, None, self.doExit)
self.df = TartanDialog(self.opts["mf"], title=self.tit, tags=tag,
eflds=fld, butt=but, tend=tnd, txit=txt)
yer = int(self.sysdtw / 10000)
mon = int((self.sysdtw % 10000) / 100)
self.hist_tit = []
for x in range(1, 14):
if x == 13:
txt = "Last 12 Month Total"
self.df.colLabel[4][x-1].configure(text=txt)
self.hist_tit.append(txt)
else:
nam = mthnam[mon][1]
nam = nam + (" " * (15-len(nam))) + str(yer)
self.df.colLabel[4][x-1].configure(text=nam)
self.hist_tit.append(nam)
if x != 13:
mon = mon - 1
if mon == 0:
mon = mon + 12
yer = yer - 1
def doAccNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crsmst", where=[("crm_cono", "=",
self.opts["conum"]), ("crm_acno", "=", w)], limit=1)
if not acc:
return "Invalid Account Number"
self.acno = w
self.name = acc[self.sql.crsmst_col.index("crm_name")]
self.df.loadEntry("T",0, 1, data=self.name)
seq = 3
for x in range(0, self.df.topq[1]):
self.df.loadEntry("T", 1, x, data=acc[seq])
seq += 1
for x in range(0, self.df.topq[2]):
self.df.loadEntry("T", 2, x, data=acc[seq])
seq += 1
self.loadBalances()
self.opts["mf"].updateStatus("")
def doEndTop(self):
self.df.last[0] = [0, 0]
self.df.setWidget(self.df.topEntry[0][0], state="disabled")
def loadBalances(self):
bals = Balances(self.opts["mf"], "CRS", self.opts["conum"],
int(self.sysdtw / 100), (self.acno,))
obal, tbal, ages = bals.doAllBals()
this, hist = bals.doCrsDrsHist()
self.purch = hist[0]
self.pays = hist[1]
last = self.sql.getRec("crstrn", cols=["max(crt_trdt)"],
where=[("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=",
self.acno), ("crt_type", "=", 1)], limit=1)
if not last or not last[0]:
lastpurd = 0
else:
lastpurd = last[0]
last = self.sql.getRec("crstrn", cols=["max(crt_trdt)"],
where=[("crt_cono", "=", self.opts["conum"]), ("crt_acno", "=",
self.acno), ("crt_type", "=", 5)], limit=1)
if not last or not last[0]:
lastpayd = 0
else:
lastpayd = last[0]
for x in range(0, 8):
if x == 0:
data = lastpurd
elif x == 1:
data = lastpayd
elif x == 2:
data = tbal
else:
data = ages[x-3]
self.df.loadEntry("T", 3, x, data=data)
p = 0
for x in range(0, 13):
i = 0
self.df.loadEntry("C", 4, p, data=self.purch[x])
p = p + 1
i = i + 1
pay = float(ASD(0) - ASD(self.pays[x]))
self.df.loadEntry("C", 4, p, data=pay)
p = p + 1
i = i + 1
def doTagSelect(self):
self.opts["mf"].updateStatus("")
def doTrans1(self):
self.df.focusField("T", 5, 1)
def doTrans2(self, frt, pag, r, c, p, i, w):
self.paidup = w
whr = [
("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.acno)]
if self.paidup == "Y":
col, recs = getTrn(self.opts["mf"].dbm, "crs", whr=whr)
else:
col, recs = getTrn(self.opts["mf"].dbm, "crs", dte=self.curdt,
whr=whr)
if recs:
data = []
for dat in recs:
data.append([
dat[col.index("crt_trdt")],
dat[col.index("crt_curdt")],
dat[col.index("crt_batch")],
dat[col.index("crt_type")],
dat[col.index("crt_ref1")],
dat[col.index("crt_tramt")],
dat[col.index("paid")],
dat[col.index("balance")],
dat[col.index("crt_desc")]])
tit = "Transactions for Account: %s - %s" % (self.acno, self.name)
col = (
("crt_trdt", "Date", 10, "D1", "N"),
("crt_curdt", "Curr-Dt", 7, "D2", "N"),
("crt_batch", "Batch", 7, "Na", "N"),
("crt_type", "Typ", 3, ("XX", crtrtp), "N"),
("crt_ref1", "Reference", 9, "Na", "Y"),
("crt_tramt", "Amount", 13.2, "SD", "N"),
("alloc", "Allocated", 13.2, "SD", "N"),
("balan", "Balance", 13.2, "SD", "N"),
("crt_desc", "Details", 30, "NA", "N"))
state = self.df.disableButtonsTags()
while True:
rec = SelectChoice(self.df.nb.Page4, tit, col, data)
# Display all transaction details
if rec.selection:
self.df.setWidget(self.df.mstFrame, state="hide")
whr = [
("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.acno),
("crt_type", "=", rec.selection[4]),
("crt_ref1", "=", rec.selection[5])]
TabPrt(self.opts["mf"], tabs="crstrn", where=whr,
pdia=False)
self.df.setWidget(self.df.mstFrame, state="show")
else:
break
self.df.enableButtonsTags(state=state)
self.doTrans1()
def doOrders(self):
col = self.sql.strpom_col
whr = [
("pom_cono", "=", self.opts["conum"]),
("pom_acno", "=", self.acno),
("pom_delno", "<>", "cancel"),
("pom_deldt", "=", 0)]
recs = self.sql.getRec("strpom", where=whr, order="pom_date")
if recs:
data = []
for dat in recs:
data.append([
dat[col.index("pom_date")],
dat[col.index("pom_ordno")],
dat[col.index("pom_cusord")],
dat[col.index("pom_jobnum")],
dat[col.index("pom_contact")]])
tit = "Orders for Account: %s - %s" % (self.acno, self.name)
col = (
("pom_date", " Date", 10, "D1", "N"),
("pom_ordno", "Doc-Numbr", 9, "UI", "N"),
("pom_cusord", "Cust-Ord-Num", 15, "Na"),
("pom_jobnum", "Job-Num", 7, "Na"),
("pom_contact", "Contact", 30, "NA"))
state = self.df.disableButtonsTags()
while True:
rec = SelectChoice(self.df.nb.Page6, tit, col, data)
# Attempt to display the document
if rec.selection:
self.df.setWidget(self.df.mstFrame, state="hide")
try:
doc = int(rec.selection[2])
PrintOrder(self.opts["mf"], self.opts["conum"],
self.opts["conam"], doc, repprt=["N", "V",
"view"], copy="y")
except:
pass
self.df.setWidget(self.df.mstFrame, state="show")
else:
break
self.df.enableButtonsTags(state=state)
def doNotes(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
NotesCreate(self.opts["mf"], self.opts["conum"], self.opts["conam"],
self.opts["capnm"], "CRS", self.acno)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doClear(self):
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doPrint(self):
mess = "Select the Required Print Option."
butt = (
("Information", "I"),
("Transactions", "T"),
("Both", "B"),
("None", "N"))
self.doPrintOption(askChoice(self.opts["mf"].body, "Print Options",
mess, butt=butt))
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrintOption(self, opt):
if opt == "N":
return
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
if opt in ("I", "B"):
table = "crsmst"
whr = [
("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.acno)]
rp = TabPrt(self.opts["mf"], self.opts["conum"], self.opts["conam"],
name=self.__class__.__name__, tabs=table, where=whr,
keys=[self.acno])
repprt = rp.repprt
repeml = rp.repeml
xits = rp.xits
else:
repprt = None
repeml = None
xits = False
if opt in ("T", "B") and not xits:
heads = ["Creditor's Transactions",
"Account: %s Name: %s" % (self.acno, self.name)]
whr = [
("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.acno)]
if self.paidup == "Y":
col, recs = getTrn(self.opts["mf"].dbm, "crs", whr=whr)
else:
col, recs = getTrn(self.opts["mf"].dbm, "crs",
dte=self.curdt, whr=whr)
cols = []
data = []
dic = self.sql.crstrn_dic
for num, rec in enumerate(recs):
dat = []
for nam in ["crt_ref1", "crt_trdt", "crt_type",
"crt_tramt", "paid", "balance", "crt_desc"]:
if not num:
if nam == "paid":
cols.append(["paid", "SD", 13.2, "Paid"])
elif nam == "balance":
cols.append(["balance", "SD", 13.2, "Balance"])
else:
cols.append([nam, dic[nam][2], dic[nam][3],
dic[nam][5]])
dat.append(rec[col.index(nam)])
data.append(dat)
if repprt:
prtdia = False
else:
prtdia = (("Y","V"),("Y","N"))
rp = RepPrt(self.opts["mf"], conum=self.opts["conum"],
conam=self.opts["conam"], name=self.__class__.__name__,
ttype="D", tables=data, heads=heads, cols=cols,
trtp=["crt_type", crtrtp], prtdia=prtdia, repprt=repprt,
repeml=repeml, fromad=self.fromad)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class ml6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["memmst", "memtrn", "memage"],
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.curdt = int(self.sysdtw / 100)
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def dataHeader(self):
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names",
"sort":
False
}
fld = ((("T", 0, 0, 0), "IUI", 6, "Mem-No", "Member Number", "", "Y",
self.doMemNo, mlm, None, ("notblank", )),
(("T", 0, 0, 0), "ONA", 30, "Member"))
tnd = ((self.endTop, "n"), )
txt = (self.exitTop, )
self.but = (("Normal", None, self.doReAgeNormal, 0, None, None,
"Only Show Unallocated Transactions"),
("History", None, self.doReAgeHistory, 0, None, None,
"Show All Transactions, Including Already Allocated"))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
butt=self.but)
def doMemNo(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memmst",
cols=["mlm_title", "mlm_initial", "mlm_surname"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", w)],
limit=1)
if not acc:
return "Invalid Member Number"
self.memno = w
self.key = None
name = "%s, %s %s" % (acc[2], acc[0], acc[1])
self.df.loadEntry(frt, pag, p + 1, data=name)
self.opts["mf"].updateStatus("Select Routine")
for b in range(2):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
if self.key in ("normal", "history"):
return "nd"
elif self.key == "cancel":
return "nc"
def doReAgeNormal(self):
self.key = "normal"
self.doReAge()
def doReAgeHistory(self):
self.key = "history"
self.doReAge()
def doReAge(self):
self.opts["mf"].updateStatus("")
for b in range(2):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "disabled")
col = [
"mlt_trdt", "mlt_refno", "mlt_type", "mlt_tramt", "paid", "balance"
]
whr = [("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno)]
if self.key == "normal":
dtc, recs = getTrn(self.opts["mf"].dbm, "mem", whr=whr, zer="N")
else:
dtc, recs = getTrn(self.opts["mf"].dbm, "mem", whr=whr)
if recs:
data = []
for rec in recs:
dat = []
for c in col:
dat.append(rec[dtc.index(c)])
data.append(dat)
age = AgeTrans(self.opts["mf"], "mem", data, 0, xits=False)
if not age.ccl and age.data:
if age.total.work:
while not age.ccl:
age.doAllocate()
if age.ccl or not age.total.work:
break
if age.ccl:
self.key = "cancel"
age.data = []
for tr in age.data:
if tr[6]:
w = copyList(whr)
w.extend([("mlt_type", "=", tr[2]),
("mlt_refno", "=", tr[1])])
self.sql.insRec("memage",
data=[
self.opts["conum"], self.memno,
tr[2], tr[1], self.curdt, tr[2],
tr[1], tr[6], 0
])
else:
self.key = "cancel"
self.agevar.set(False)
def endTop(self):
self.df.focusField("T", 0, 1)
def exitTop(self):
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
class sl4010(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, ["ctlynd", "wagmst", "waglmf",
"wagltf"], prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2])
# Get the current period starting date
period = self.sql.getRec("ctlynd", cols=["max(cye_period)"],
where=[("cye_cono", "=", self.opts["conum"])], limit=1)[0]
self.opts["period"] = getPeriods(self.opts["mf"], self.opts["conum"],
period)[0].work
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Staff Loans Interrogation (%s)" % self.__class__.__name__)
wgm = {
"stype": "R",
"tables": ("waglmf", "wagmst"),
"cols": (
("wlm_empno", "", 0, "EmpNo"),
("wgm_sname", "", 0, "Surname", "Y"),
("wgm_fname", "", 0, "Names")),
"where": [
("wlm_cono", "=", self.opts["conum"]),
("wgm_cono=wlm_cono",),
("wgm_empno=wlm_empno",)],
"group": "wlm_empno"}
lnm = {
"stype": "R",
"tables": ("waglmf",),
"cols": (
("wlm_empno", "", 0, "EmpNo"),
("wlm_loan", "", 0, "Ln"),
("wlm_desc", "", 0, "Description", "Y")),
"where": [("wlm_cono", "=", self.opts["conum"])],
"whera": [["T", "wlm_empno", 0, 0]],
"order": "wlm_empno, wlm_loan",
"index": 1}
r1s = (("Yes", "Y"), ("No", "N"))
tag = (
("General", self.doGeneral, ("T",0,0), ("T",0,1)),
("Trans", self.doTrans1, ("T",0,0), ("T",0,1)))
fld = (
(("T",0,0,0),"IUI",5,"Emp-Num","Employee Number",
"","N",self.doEmp,wgm,None,("notzero",)),
(("T",0,0,0),"ONA",40,"Name"),
(("T",0,1,0),"IUI",5,"Loan-Num","Loan Number",
"","N",self.doLoan,lnm,None,("notzero",)),
(("T",0,1,0),"ONA",40,"Desc"),
(("T",1,0,0),"OUI",3,"Deduction Code"),
(("T",1,1,0),"OUD",6.2,"Interest Percentage"),
(("T",1,2,0),"OD1",10,"Start Date"),
(("T",1,3,0),"OSD",13.2,"Deduction Amount"),
(("T",1,4,0),"OSD",13.2,"Total Advances"),
(("T",1,5,0),"OSD",13.2,"Total Interest"),
(("T",1,6,0),"OSD",13.2,"Total Repayments"),
(("T",1,7,0),"OSD",13.2,"Total Adjustments"),
(("T",1,8,0),"OSD",13.2,"Balance"),
(("T",1,9,0),"Od1",10,"Last Interest Raised"),
(("T",1,10,0),"Od1",10,"Last Payment Received"),
(("T",2,0,0),("IRB",r1s),0,"History","",
"Y","Y",self.doTrans2,None,None,None))
tnd = ((self.doEndTop,"N"), None, None)
txt = (self.doExit, None, None)
cnd = (None, None, None)
cxt = (None, None, None)
but = (
("Clear",None,self.doClear,0,("T",0,0),("T",0,1)),
("Print",None,self.doPrint,0,("T",0,0),("T",0,1)),
("Quit",None,self.doExit,1,None,None))
self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld,
tags=tag, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but)
def doEmp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("wagmst", cols=["wgm_sname",
"wgm_fname"], where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", w)], limit=1)
if not acc:
return "Invalid Employee Number"
self.empno = w
self.name = "%s, %s" % (acc[0], acc[1])
self.history = "Y"
self.df.loadEntry("T", pag, p+1, data=self.name)
def doLoan(self, frt, pag, r, c, p, i, w):
lmc = self.sql.waglmf_col
rec = self.sql.getRec("waglmf", where=[("wlm_cono", "=",
self.opts["conum"]), ("wlm_empno", "=", self.empno),
("wlm_loan", "=", w)], limit=1)
if not rec:
return "Invalid Loan Number"
self.loan = w
self.desc = rec[lmc.index("wlm_desc")]
self.df.loadEntry("T", pag, p+1, data=self.desc)
self.df.loadEntry("T", 1, 0, data=rec[lmc.index("wlm_code")])
self.df.loadEntry("T", 1, 1, data=rec[lmc.index("wlm_rate")])
self.df.loadEntry("T", 1, 2, data=rec[lmc.index("wlm_start")])
self.df.loadEntry("T", 1, 3, data=rec[lmc.index("wlm_repay")])
# Raise Interest
LoanInterest("S", self.opts["mf"].dbm, rec, update="Y",
curdt=int(self.sysdtw / 100), tdate=self.sysdtw, refno="Pending")
# Get Balances
self.lon = 0.0
self.imt = 0.0
self.pay = 0.0
self.adj = 0.0
self.bal = 0.0
self.idt = 0
self.pdt = 0
whr = [
("wlt_cono", "=", self.opts["conum"]),
("wlt_empno", "=", self.empno),
("wlt_loan", "=", self.loan)]
odr = "wlt_trdt, wlt_type"
self.wlt = self.sql.getRec("wagltf", where=whr, order=odr)
if self.wlt:
col = self.sql.wagltf_col
for rec in self.wlt:
dat = CCD(rec[col.index("wlt_trdt")], "d1", 10)
typ = CCD(rec[col.index("wlt_type")], "UI", 2)
amt = CCD(rec[col.index("wlt_amt")], "SD",13.2)
self.bal = float(ASD(self.bal) + ASD(amt.work))
if typ.work == 1:
self.idt = dat.work
self.imt = float(ASD(self.imt) + ASD(amt.work))
elif typ.work in (2, 3):
self.lon = float(ASD(self.lon) + ASD(amt.work))
elif typ.work == 4:
self.pay = float(ASD(self.pay) + ASD(amt.work))
self.pdt = dat.work
elif typ.work == 5:
self.adj = float(ASD(self.adj) + ASD(amt.work))
# Load Balances
self.df.loadEntry("T", 1, 4, data=self.lon)
self.df.loadEntry("T", 1, 5, data=self.imt)
self.df.loadEntry("T", 1, 6, data=self.pay)
self.df.loadEntry("T", 1, 7, data=self.adj)
self.df.loadEntry("T", 1, 8, data=self.bal)
self.df.loadEntry("T", 1, 9, data=self.idt)
self.df.loadEntry("T", 1, 10, data=self.pdt)
self.opts["mf"].updateStatus("")
def doHist(self, frt, pag, r, c, p, i, w):
self.history = w
def doEndTop(self):
self.df.last[0] = [0, 0]
self.df.setWidget(self.df.topEntry[0][0], state="disabled")
def loadBalances(self):
whr = [
("wlt_cono", "=", self.opts["conum"]),
("wlt_empno", "=", self.empno),
("wlt_loan", "=", self.loan)]
odr = "wlt_trdt, wlt_type"
self.wlt = self.sql.getRec("wagltf", where=whr, order=odr)
if self.wlt:
for rec in self.wlt:
dat = CCD(rec[self.sql.wagltf_col.index("wlt_trdt")], "d1", 10)
typ = CCD(rec[self.sql.wagltf_col.index("wlt_type")], "UI", 2)
amt = CCD(rec[self.sql.wagltf_col.index("wlt_amt")], "SD",13.2)
self.bal = float(ASD(self.bal) + ASD(amt.work))
self.cap = float(ASD(self.cap) + ASD(amt.work))
if typ.work == 1:
if dat.work >= self.opts["period"] and \
dat.work >= self.df.t_work[1][0][3]:
self.cap = float(ASD(self.cap) - ASD(amt.work))
self.due = float(ASD(self.due) + ASD(amt.work))
self.imt = float(ASD(self.imt) + ASD(amt.work))
self.idt = dat.work
elif typ.work in (2, 3):
self.lon = float(ASD(self.lon) + ASD(amt.work))
elif typ.work == 4:
self.pay = float(ASD(self.pay) + ASD(amt.work))
self.pdt = dat.work
elif typ.work == 5:
self.adj = float(ASD(self.adj) + ASD(amt.work))
def doGeneral(self):
self.opts["mf"].updateStatus("")
def doTrans1(self):
self.df.focusField("T", 2, 1)
def doTrans2(self, frt, pag, r, c, p, i, w):
self.history = w
tit = "Transactions for Loan: %s %s - %s" % \
(self.empno, self.name, self.desc)
tab = ["wagltf"]
col = (("wlt_trdt", "", 0, " Date"),
("wlt_batch", "", 0, "Batch"),
("wlt_type", ("XX", sltrtp), 3, "Typ"),
("wlt_ref", "", 0, "Reference", "Y"),
("wlt_per", "", 0, " Int-%"),
("wlt_amt", "", 0, " Amount"),
("wlt_ded", "", 0, " Deduction"),
("wlt_desc", "", 0, "Remarks"))
whr = [
("wlt_cono", "=", self.opts["conum"]),
("wlt_empno", "=", self.empno),
("wlt_loan", "=", self.loan)]
if self.history == "N":
whr.append(("wlt_curdt", ">=", int(self.opts["period"] / 100)))
odr = "wlt_trdt, wlt_type, wlt_ref"
state = self.df.disableButtonsTags()
SRec(self.opts["mf"], screen=self.df.nb.Page2, title=tit, tables=tab,
cols=col, where=whr, order=odr)
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 2, 1)
def doClear(self):
self.df.selPage("General")
self.df.focusField("T", 0, 1)
def doPrint(self):
mess = "Select the Required Print Option."
butt = (
("Information", "I"),
("Transactions", "T"),
("Both", "B"),
("None", "N"))
self.doPrintOption(askChoice(self.opts["mf"].body, "Print Options",
mess, butt=butt))
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrintOption(self, opt):
print(opt)
if opt == "N":
return
self.head = "%03u %-93s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.pglin = 999
if opt != "T":
self.pageHeading()
self.printInfo()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
if opt == "I":
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"])
elif opt == "B":
if not self.wlt:
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"])
else:
self.acctot = 0.0
self.pageHeading()
self.pageHeadingTrans()
self.printTrans()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"])
elif opt == "T":
if self.wlt:
self.acctot = 0.0
self.pageHeading()
self.pageHeadingTrans()
self.printTrans()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=["N", "V", "view"])
def printInfo(self):
self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "",
self.df.topf[0][0][3], self.df.t_disp[0][0][0]))
self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "",
self.df.topf[0][1][3], self.df.t_disp[0][0][1]))
self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "",
self.df.topf[0][2][3], self.df.t_disp[0][0][2]))
self.fpdf.drawText()
for x in range(0, len(self.df.topf[1])):
self.fpdf.drawText("%-5s %-20s %-25s %s" % ("", "",
self.df.topf[1][x][3], self.df.t_disp[1][0][x]))
self.fpdf.drawText()
def printTrans(self):
whr = [
("wlt_cono", "=", self.opts["conum"]),
("wlt_empno", "=", self.empno),
("wlt_loan", "=", self.loan)]
odr = "wlt_trdt, wlt_type"
if self.history == "N":
whr.append(("wlt_curdt", ">=", int(self.opts["period"] / 100)))
recs = self.sql.getRec("wagltf", where=whr, order=odr)
for rec in recs:
trd = CCD(rec[self.sql.wagltf_col.index("wlt_trdt")], "D1", 10)
typ = CCD(rec[self.sql.wagltf_col.index("wlt_type")], "UI", 1)
ref = CCD(rec[self.sql.wagltf_col.index("wlt_ref")], "Na", 9)
bat = CCD(rec[self.sql.wagltf_col.index("wlt_batch")], "Na", 7)
rte = CCD(rec[self.sql.wagltf_col.index("wlt_per")], "UD", 6.2)
amt = CCD(rec[self.sql.wagltf_col.index("wlt_amt")], "SD", 13.2)
ded = CCD(rec[self.sql.wagltf_col.index("wlt_ded")], "SD", 13.2)
det = CCD(rec[self.sql.wagltf_col.index("wlt_desc")], "NA", 30)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.pageHeadingTrans()
self.acctot = float(ASD(self.acctot) + ASD(amt.work))
self.fpdf.drawText("%s %s %s %s %s %s %s %s" % (trd.disp,
sltrtp[(typ.work - 1)][0], ref.disp, bat.disp,
rte.disp, amt.disp, ded.disp, det.disp))
self.pglin += 1
self.fpdf.underLine(txt=self.head)
b = CCD(self.acctot, "SD", 13.2)
self.fpdf.drawText("%-39s %13s %13s %-30s" % \
("", b.disp, "", "Closing Balance"))
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("Staff Loans Interrogation as at %s" % self.sysdtd)
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 3
def pageHeadingTrans(self):
self.fpdf.setFont(style="B")
text = "%-8s %5s %-4s %s" % (self.df.topf[0][0][3],
self.df.t_disp[0][0][0], self.df.topf[0][1][3],
self.df.t_disp[0][0][1])
self.fpdf.drawText(text)
text = "%-8s %5s %-4s %s" % (self.df.topf[0][2][3],
self.df.t_disp[0][0][2], self.df.topf[0][3][3],
self.df.t_disp[0][0][3])
self.fpdf.drawText(text)
self.fpdf.drawText()
self.fpdf.drawText("%-10s %-3s %-9s %-7s %6s %12s %12s %-30s" % \
(" Date", "Typ", "Reference", "Batch", "Int%",
" Amount", " Deduction", "Remarks"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 7
b = CCD(self.acctot, "SD", 13.2)
if self.acctot != 0:
self.fpdf.drawText("%-39s %13s %13s %-30s" % \
("", b.disp, "", "Brought Forward"))
self.pglin += 1
def doExit(self):
try:
self.opts["mf"].dbm.rollbackDbase()
except:
pass
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
