class wgc310(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", "wagrcv", "wagedc", "wagtf2"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
wagctl = self.gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.glint = wagctl["ctw_glint"]
return True
def mainProcess(self):
ced = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_code", "", 0, "Cde"), ("ced_desc", "", 0,
"Description", "Y")),
"where": [("ced_cono", "=", self.opts["conum"])],
"whera": [["T", "ced_type", 0]],
"order":
"ced_code"
}
bas = {
"stype":
"C",
"titl":
"Available Base Rates",
"head": ("C", "Description"),
"data":
((1, "X * Normal Rate of Pay * Factor"),
(2, "Normal Pay * Factor"), (3, "Normal Pay * Factor / 100"),
(4, "X * Daily Rate of Pay * Factor"),
(5, "X * Hourly Rate of Pay * Factor"),
(6, "U.I.F. Pay * Factor"), (7, "S.D.L. Pay * Factor"))
}
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"])]
}
rcv = {
"stype":
"R",
"tables": ("wagrcv", ),
"cols":
(("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details", "Y"))
}
r1s = (("Variable", "V"), ("Fixed", "F"))
r2s = (("Amount", "A"), ("Rate", "R"))
r3s = (("Salary", "S"), ("Commission", "C"))
r4s = (("Amount", "A"), ("Rate", "R"), ("None", "N"))
r5s = (("Yes", "Y"), ("No", "N"), ("Notional", "T"), ("One Time", "O"),
("Retrench", "R"))
r6s = (("Yes", "Y"), ("No", "N"))
tag = (("Detail-_A", None, ("T", 0, 0), ("T", 0, 1)),
("Detail-_B", None, ("T", 0, 0), ("T", 0, 1)))
self.fld = ((("T", 0, 0,
0), "IUA", 1, "Type", "Earning/Deduction Type", "E", "N",
self.doType, None, None, ("in", ("E", "D"))),
(("T", 0, 0, 0), "IUI", 3, "Code", "", "", "N",
self.doCode, ced, None, ("notzero", )),
(("T", 0, 0, 0), "ONA", 30, "Description"),
(("T", 1, 0, 0), "INA", 30, "Description", "", "", "N",
self.doDesc, None, self.doDelete,
("notblank", )), (("T", 1, 1, 0), ("IRB", r1s), 0, "Type",
"", "V", "N", None, None, None, None),
(("T", 1, 2, 0), ("IRB", r2s), 0, "Employee Portion", "",
"A", "N", self.doEmployeePortion, None, None, None),
(("T", 1, 3, 0), "IUI", 3, " Base", "", "", "N",
self.doEmployeeBase, bas, None,
("between", 0,
7)), (("T", 1, 4, 0), "IUD", 8.2, " Value", "",
"", "N", self.doValue, None, None, ("efld", )),
(("T", 1, 5, 0), "IUD", 8.2, " Limit", "", "", "N",
self.doElim, None, None, ("efld", )),
(("T", 1, 6, 0), "IUI", 3, " GL/Cono", "", "", "N",
self.doEglco, coy, None,
("efld", )), (("T", 1, 6,
0), "IUI", 7, " GL/Acno", "", "",
"N", self.doEglno, glm, None, ("efld", )),
(("T", 1, 7, 0), ("IRB", r3s), 0, "Earnings Type", "", "S",
"N", self.doEarnType, None, None,
None), (("T", 1, 8,
0), ("IRB", r4s), 0, "Employer Portion", "", "N",
"N", self.doEmployerPortion, None, None, None),
(("T", 1, 9, 0), "IUI", 3, " Base", "Base", "",
"N", self.doEmployerBase, bas, None,
("between", 0,
7)), (("T", 1, 10, 0), "IUD", 8.2, " Value", "",
"", "N", None, None, None,
("efld", )), (("T", 1, 11, 0), "IUD", 8.2,
" Limit", "", "", "N",
self.doRlim, None, None, ("efld", )),
(("T", 1, 12, 0), "IUI", 3, " GL/Cono", "", "",
"N", self.doRglco, coy, None,
("efld", )), (("T", 1, 12,
0), "IUI", 7, " GL/Acno", "", "",
"N", self.doRglno, glm, None, ("efld", )),
(("T", 1, 13, 0), ("IRB", r5s), 0, "Tax Code", "", "N",
"N", self.doTaxcode, None, None,
None), (("T", 1, 14, 0), "IUD", 6.2, "Tax Portion", "",
"", "N", self.doTaxportion, None, None,
("efld", )), (("T", 2,
0, 0), "IUI", 4, "Rec Of Rev Code",
"", "", "N", self.doRcv, rcv, None,
("notzero", )), (("T", 2, 0, 0),
"ONA", 30, ""),
(("T", 2, 1, 0), ("IRB", r6s), 0, "Union Report", "", "N",
"N", self.doUniRep, None, None,
None), (("T", 2, 2, 0), ("IRB", r6s), 0, "Must Pay", "",
"N", "N", None, None, None, None),
(("T", 2, 3, 0), "IUI", 2, "Balance Number", "", "", "N",
self.doBalNo, None, None,
("between", 0,
3)), (("T", 2, 4, 0), "IUD", 5.2, "Hourly Limit", "", "",
"N", self.doLimit, None, None, ("efld", )),
(("T", 2, 5, 0), ("IRB", r6s), 0, "Monthly Deduction", "",
"N", "N", self.doMthly, None, None,
None), (("T", 2, 6, 0), "IUD", 6.2, "UIF Percentage", "",
"", "N", None, None, None,
("efld", )), (("T", 2, 7, 0), "IUD", 6.2,
"SDL Percentage", "", "", "N", None,
None, None, ("efld", )))
but = (("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 1, 1),
("T", 0, 0)), ("Quit", None, self.doExit0, 1, None, None))
tnd = ((self.doEnd0, "N"), (self.doEnd1, "N"), (self.doEnd2, "Y"))
txt = (self.doExit0, self.doExit1, self.doExit2)
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt)
def doType(self, frt, pag, r, c, p, i, w):
self.rtype = w
if self.rtype == "E":
self.df.topf[1][15][5] = "Y"
else:
self.df.topf[1][15][5] = "Y"
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.acc = self.sql.getRec("wagedc",
where=[("ced_cono", "=",
self.opts["conum"]),
("ced_type", "=", self.rtype),
("ced_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = True
if self.rtype == "D" and self.code == 1:
showInfo(self.opts["mf"].body, "PAYE",
"This code is Reserved for PAYE Deductions")
elif self.rtype == "D" and self.code == 2:
showInfo(self.opts["mf"].body, "UIF",
"This code is Reserved for UIF Deductions")
else:
self.new = False
d = 3
self.df.loadEntry(frt, pag, p + 1, data=self.acc[d])
for pg in range(1, self.df.pgs + 1):
for x in range(0, self.df.topq[pg]):
if pg == 2 and x == 1:
continue
self.df.loadEntry("T", pg, x, data=self.acc[d])
if pg == 2 and not x:
ror = self.sql.getRec("wagrcv",
limit=1,
cols=["rcv_desc"],
where=[("rcv_code", "=",
self.acc[d])])
if not ror:
desc = ""
else:
desc = ror[0]
self.df.loadEntry("T", 2, 1, data=desc)
d = d + 1
def doDesc(self, frt, pag, r, c, p, i, w):
self.df.loadEntry("T", 0, 2, data=self.df.t_disp[1][0][0])
if self.rtype == "E" and self.code < 6:
self.df.loadEntry("T", 1, p + 1, data="V")
self.df.loadEntry("T", 1, p + 2, data="R")
if self.code == 5:
self.df.loadEntry("T", 1, p + 3, data=4)
else:
self.df.loadEntry("T", 1, p + 3, data=1)
if self.code in (1, 5):
self.df.loadEntry("T", 1, p + 4, data=1)
self.df.loadEntry("T", 1, p + 5, data=0)
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 6, data=0)
self.df.loadEntry("T", 1, p + 7, data=0)
self.df.loadEntry("T", 1, p + 8, data="S")
return "sk8"
else:
return "sk5"
else:
return "sk3"
elif self.rtype == "D" and self.code in (1, 2):
if self.code == 1:
self.df.loadEntry("T", 1, 1, data="V")
self.df.loadEntry("T", 1, 2, data="R")
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 6, data=0)
self.df.loadEntry("T", 1, p + 7, data=0)
self.df.loadEntry("T", 1, p + 9, data="N")
self.df.loadEntry("T", 1, p + 15, data="N")
return "nd"
return "sk5"
elif self.code == 2:
self.df.loadEntry("T", 1, 1, data="V")
self.df.loadEntry("T", 1, 2, data="R")
self.df.loadEntry("T", 1, 3, data=6)
return "sk3"
def doDelete(self):
t = self.sql.getRec("wagtf2",
cols=["count(*)"],
where=[("wt2_cono", "=", self.opts["conum"]),
("wt2_type", "=", self.rtype),
("wt2_code", "=", self.code)],
limit=1)
if t[0]:
return "Transactions Exist, Not Deleted"
self.sql.delRec("wagedc",
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", self.rtype),
("ced_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEmployeePortion(self, frt, pag, r, c, p, i, w):
if w == "A":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEmployeeBase(self, frt, pag, r, c, p, i, w):
if w > 7:
return "Invalid Employee Base"
def doValue(self, frt, pag, r, c, p, i, w):
self.value = w
if self.rtype == "E" and self.code < 6:
self.df.loadEntry("T", 1, p + 1, data=0)
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 2, data=0)
self.df.loadEntry("T", 1, p + 3, data=0)
self.df.loadEntry("T", 1, p + 4, data="S")
return "sk3"
else:
return "sk1"
def doElim(self, frt, pag, r, c, p, i, w):
self.elim = w
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 1, data=0)
self.df.loadEntry("T", 1, p + 2, data=0)
if self.rtype == "E":
return "sk2"
else:
self.df.loadEntry("T", 1, p + 3, data="")
return "sk3"
def doEglco(self, frt, pag, r, c, p, i, w):
if self.rtype == "E" and self.code < 6 and not w:
# Use department code for integration
self.eglco = w
self.df.loadEntry("T", 1, p + 1, data=0)
self.df.loadEntry("T", 1, p + 2, data="S")
self.df.loadEntry("T", 1, p + 9, data="Y")
self.df.loadEntry("T", 1, p + 10, data=100.00)
return "sk10"
if w:
self.eglco = w
else:
self.eglco = self.opts["conum"]
name = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", self.eglco)],
limit=1)
if not name:
return "Invalid Company"
def doEglno(self, frt, pag, r, c, p, i, w):
if self.rtype == "D":
ctl = self.gc.getCtl("ctlctl", self.eglco)
if ctl and not self.gc.chkRec(self.eglco, ctl, ["wag_slc"]):
sln = ctl["wag_slc"]
else:
sln = None
else:
sln = None
if w and w != sln:
chk = chkGenAcc(self.opts["mf"], self.eglco, w)
if type(chk) is str:
return chk
self.eglno = w
if self.rtype == "D":
if self.code == 2:
self.df.loadEntry(frt, pag, 9, data="R")
self.df.loadEntry(frt, pag, 10, data=6)
self.df.loadEntry(frt, pag, 11, data=self.value)
self.df.loadEntry(frt, pag, 12, data=self.elim)
self.df.loadEntry(frt, pag, 13, data=self.eglco)
self.df.loadEntry(frt, pag, 14, data=self.eglno)
return "sk7"
else:
return "sk1"
if self.code < 6:
self.df.loadEntry("T", 1, p + 1, data="S")
self.df.loadEntry("T", 1, p + 8, data="Y")
self.df.loadEntry("T", 1, p + 9, data=100.00)
return "sk9"
def doEarnType(self, frt, pag, r, c, p, i, w):
if self.rtype == "E":
return "sk6"
def doEmployerPortion(self, frt, pag, r, c, p, i, w):
if w == "N":
for x in range(1, 6):
self.df.loadEntry(frt, pag, p + x, data=0)
return "sk5"
if w == "A":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEmployerBase(self, frt, pag, r, c, p, i, w):
if w > 7:
return "Invalid Employer Base"
def doRlim(self, frt, pag, r, c, p, i, w):
if self.glint != "Y":
return "sk2"
def doRglco(self, frt, pag, r, c, p, i, w):
if not w:
w = self.opts["conum"]
name = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not name:
return "Invalid Company"
self.rglco = w
def doRglno(self, frt, pag, r, c, p, i, w):
if w:
chk = chkGenAcc(self.opts["mf"], self.rglco, w)
if type(chk) is str:
return chk
def doTaxcode(self, frt, pag, r, c, p, i, w):
if self.rtype == "D" and w not in ("Y", "T", "N"):
return "Invalid Selection"
if w == "N":
self.df.loadEntry("T", pag, p + 1, data=0)
return "sk1"
if self.glint == "Y" and not self.eglno and w != "T":
return "ff8|Invalid G/L Account Number"
def doTaxportion(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid Tax Portion"
def doRcv(self, frt, pag, r, c, p, i, w):
if w == 4101:
return "SITE Code Not Allowed"
acc = self.sql.getRec("wagrcv",
cols=["rcv_desc"],
where=[("rcv_code", "=", w)],
limit=1)
if not acc:
return "Invalid Rec of Rev Code"
else:
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doUniRep(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p + 1, data="N")
if self.rtype == "E":
if self.code in (1, 2, 3, 4, 5):
self.df.loadEntry(frt, pag, p + 2, data=0)
self.df.loadEntry(frt, pag, p + 3, data=0)
self.df.loadEntry(frt, pag, p + 4, data="N")
self.df.loadEntry(frt, pag, p + 5, data=100.00)
return "sk5"
return "sk4"
return "sk1"
def doBalNo(self, frt, pag, r, c, p, i, w):
if self.rtype == "E":
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data="N")
self.df.loadEntry(frt, pag, p + 3, data="N")
return "sk3"
def doLimit(self, frt, pag, r, c, p, i, w):
pass
def doMthly(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEnd0(self):
self.df.focusField("T", 1, 1, clr=self.new)
def doEnd1(self):
self.df.selPage("Detail-B")
self.df.focusField("T", 2, 1, clr=self.new)
def doEnd2(self):
dat = [self.opts["conum"]]
for x in range(0, 2):
dat.append(self.df.t_work[0][0][x])
for x in range(0, len(self.df.t_work[1][0])):
dat.append(self.df.t_work[1][0][x])
for x in range(0, len(self.df.t_work[2][0])):
if x in (0, 2, 3, 4, 5, 6, 7, 8):
dat.append(self.df.t_work[2][0][x])
if self.new:
self.sql.insRec("wagedc", data=dat)
elif dat != self.acc[:len(dat)]:
col = self.sql.wagedc_col
dat.append(self.acc[col.index("ced_xflag")])
self.sql.updRec("wagedc",
data=dat,
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", self.rtype),
("ced_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Detail-A")
self.df.focusField("T", 0, 1)
def doAccept(self):
if self.rtype == "D":
frt, pag, col, mes = self.df.doCheckFields(("T", 0, None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14)))
if not mes:
if self.df.t_work[1][0][15] not in ("Y", "N", "T", "O",
"R"):
frt = "T"
pag = 1
col = 15
mes = "Invalid Tax Code Selection"
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 1, (16, )))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 2, (0, 2, 3, 4, 5, 6)))
else:
frt, pag, col, mes = self.df.doCheckFields(("T", 0, None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 8, 15, 16)))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 2, (0, 2, 3)))
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col + 1
else:
self.df.last[pag][1] = col + 1
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.doEnd2()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doExit1(self):
self.df.focusField("T", 0, 1)
def doExit2(self):
self.df.selPage("Detail-A")
class gl2050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Company Record
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
# Check and Load VAT Control
self.ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not self.ctlctl:
return
if self.gc.chkRec(self.opts["conum"], self.ctlctl, ["vat_ctl"]):
return
self.convat = self.ctlctl["vat_ctl"]
# Set Batch Indicator
self.batind = "Y"
# Create SQL Object
tabs = [
"ctlctl", "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint",
"genjlm", "genjlt", "genmst", "gentrn", "assgrp", "rtlprm"
]
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"],
"GEN",
self.opts["rtn"],
multi="Y")
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2])
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][1][0] / 100)
return True
def doProcess(self):
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "Y"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Frequency", "", "M", "N",
self.doFreq, None, None, None),
(("T", 0, 1, 0), ("IRB", r2s), 9, "All Journals", "", "N", "N",
self.doAllJnl, None, None, None),
(("T", 0, 2, 0), ("IRB", r2s), 1, "All Periods", "", "N", "N",
self.doAllPer, None, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt)
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
self.wher = [("gjm_cono", "=", self.opts["conum"]),
("gjm_freq", "=", self.freq),
("gjm_start", "<=", self.bh.curdt),
("gjm_end", ">=", self.bh.curdt),
("gjm_last", "<", self.bh.curdt)]
data = self.sql.getRec("genjlm",
cols=["gjm_num", "gjm_desc"],
where=self.wher)
if not data:
return "No Valid Standard Journals"
if self.freq == "M":
self.mths = 1
elif self.freq == "3":
self.mths = 3
elif self.freq == "6":
self.mths = 6
else:
self.mths = 12
def doAllJnl(self, frt, pag, r, c, p, i, w):
self.alljnl = w
def doAllPer(self, frt, pag, r, c, p, i, w):
self.allper = w
def doEnd(self):
self.df.closeProcess()
if self.alljnl == "N":
recs = getSingleRecords(self.opts["mf"],
"genjlm", ("gjm_num", "gjm_desc"),
where=self.wher)
else:
recs = self.sql.getRec("genjlm", where=self.wher)
if not recs:
self.opts["mf"].closeLoop()
return
for gjm in recs:
self.trnref = gjm[self.sql.genjlm_col.index("gjm_num")]
self.trndet = gjm[self.sql.genjlm_col.index("gjm_desc")]
start = gjm[self.sql.genjlm_col.index("gjm_start")]
last = gjm[self.sql.genjlm_col.index("gjm_last")]
dates = []
while start <= self.bh.curdt:
if start < self.s_per or start <= last:
pass
elif self.allper == "N" and start == self.bh.curdt:
dates.append(start)
elif self.allper == "Y" and start <= self.bh.curdt:
dates.append(start)
start = self.nextPeriod(start)
for self.curdt in dates:
self.trndat = mthendDate((self.curdt * 100))
data = self.sql.getRec(
"genjlt",
cols=["gjt_acno", "gjt_amnt", "gjt_vatc"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.trnref),
("gjt_amnt", "<>", 0)])
if not data:
continue
for tran in data:
self.acno = tran[0]
self.trnamt = tran[1]
self.vatcod = tran[2]
vrte = getVatRate(self.sql, self.opts["conum"],
self.vatcod, self.trndat)
if vrte is None:
vrte = 0.0
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.updateTables()
self.updateBatch()
self.sql.updRec("genjlm",
cols=["gjm_last"],
data=[self.curdt],
where=[("gjm_cono", "=", self.opts["conum"]),
("gjm_num", "=", self.trnref),
("gjm_freq", "=", self.freq)])
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
def nextPeriod(self, period):
yy = int(period / 100)
mm = (period % 100) + self.mths
if mm > 12:
yy += 1
mm -= 12
return (yy * 100) + mm
def updateTables(self):
amt = float(ASD(self.trnamt) - ASD(self.vatamt))
data = (self.opts["conum"], self.acno, self.curdt, self.trndat,
self.opts["rtn"], self.trnref, self.bh.batno, amt, self.vatamt,
self.trndet, self.vatcod, self.batind, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.vatcod:
if self.vatamt:
data = (self.opts["conum"], self.convat, self.curdt,
self.trndat, self.opts["rtn"], self.trnref,
self.bh.batno, self.vatamt, 0.00, self.trndet,
self.vatcod, self.batind, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if amt < 0:
vtyp = "O"
else:
vtyp = "I"
data = (self.opts["conum"], self.vatcod, vtyp, self.curdt, "G",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.acno, self.trndet, amt, self.vatamt, 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
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.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ml3070(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, [
"ctlnot", "ctlvrf", "memctc", "memctk", "memcto", "memctp",
"memmst", "memcat", "memadd", "memkon", "memtrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
memctl = gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.ldays = memctl["mcm_ldays"]
self.fromad = memctl["mcm_emadd"]
t = time.localtime()
self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2]
self.colsd = {
0: ["Membership Number", "Y", ["Mem-No", "UI", 6]],
1: ["Status", "N", ["Status", "NA", 10]],
2: ["Status Date", "N", ["State-Date", "D1", 10]],
3: ["Surname/Title/Initials", "Y", ["Name", "TX", 30]],
4: ["Surname", "N", ["Surname", "TX", 30]],
5: ["Title", "N", ["Title", "TX", 6]],
6: ["First Names", "N", ["First-Names", "TX", 30]],
7: ["Gender", "N", ["G", "UA", 1]],
8: ["Date of Birth", "N", ["Birth-Date", "D1", 10]],
9: ["Age", "N", ["Age", "UI", 3]],
10: ["Identity Number", "N", ["ID-Number", "UI", 13]],
11: ["Entry Date", "N", ["Entry-Date", "d1", 10]],
12: ["Entry Years", "N", ["YR", "UI", 2]],
13: ["Payment Plan", "N", ["P", "UA", 1]],
14: ["Active Category", "N", ["Active-Category", "TX", 30]],
15: ["Telephone - Home", "Y", ["Home-Telephone", "TX", 20]],
16: ["Telephone - Work", "Y", ["Work-Telephone", "TX", 20]],
17: ["Mobile Number", "Y", ["Mobile-Number", "TX", 20]],
18: ["Email Address 1", "Y", ["Email-Address-1", "TX", 30]],
19: ["Email Address 2", "N", ["Email-Address-2", "TX", 30]],
20: ["Address - Postal", "N", ["Postal-Address", "TX", 120]],
21: ["Address - Street", "N", ["Street-Address", "TX", 120]],
22: ["Category Notes", "N", ["Category-Notes", "TX", 50]],
23: ["Proposer", "N", ["Proposer", "TX", 20], ["YR", "UI", 2]],
24: ["Seconder", "N", ["Seconder", "TX", 20], ["YR", "UI", 2]],
25: ["Account Balance", "N", ["Balance", "SD", 13.2]],
26: ["Sports Categories", "N"],
27: ["Last Note", "N", ["Last-Text-Note", "TX", 30]],
28: ["Nationality", "N", ["Nationality", "TX", 30]],
29: ["Occupation", "N", ["Occupation", "TX", 30]]
}
rgp = self.sql.getRec("memctc",
cols=["mcc_rgrp"],
where=[("mcc_cono", "=", self.opts["conum"]),
("mcc_type", "=", "C")],
group="mcc_rgrp",
order="mcc_rgrp")
self.rgrps = []
for g in rgp:
self.rgrps.append(g[0])
self.colsd[26].append([g[0], "UA", 2])
self.padcol = [0, 0, 0, 0, 0, 0, 0]
self.sadcol = [0, 0, 0, 0, 0, 0, 0]
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Members Ledger Master Listing (%s)" %
self.__class__.__name__)
rgp = {"stype": "C", "head": ("RG", ), "data": self.rgrps, "retn": "D"}
cod = {
"stype":
"R",
"tables": ("memctc", ),
"cols": (("mcc_code", "", 0, "Cd"), ("mcc_desc", "", 0,
"Description", "Y")),
"where": [("mcc_cono", "=", self.opts["conum"])],
"whera": [("T", "mcc_type", 2, 0)],
"order":
"mcc_code",
"size": (400, 600)
}
r1s = (("All", "A"), ("Main", "B"), ("Sports", "C"), ("Debentures",
"D"))
r2s = (("All", "Z"), ("Active", "A"), ("Deceased", "D"),
("Inactive", "I"), ("Resigned", "R"), ("Suspended",
"S"), ("Defaulted", "X"))
r3s = (("All", "A"), ("Male", "M"), ("Female", "F"))
r4s = (("Number", "N"), ("Surname", "M"))
fld = ((("T", 0, 0, 0), "ID1", 10, "Report Date", "", self.sysdt, "Y",
self.doDate, None, None, ("efld", )),
(("T", 0, 1, 0), ("IRB", r2s), 0, "Status", "", "A", "Y",
self.doStat, None, None, None),
(("T", 0, 2, 0), ("IRB",
r1s), 0, "Category", "", "A", "Y", self.doCat,
None, None, None), (("T", 0, 3, 0), "IUA", 2, "Report Group",
"", 0, "Y", self.doRgrp, rgp, None, None),
(("T", 0, 3, 0), "IUI", 2, "Code", "", 0, "Y", self.doCod, cod,
None, None), (("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), ("IRB", r3s), 0, "Gender", "", "A", "Y",
self.doGender, None, None,
None), (("T", 0, 5, 0), ("IRB", r4s), 0, "Sort Order", "", "N",
"Y", self.doSort, None, None, None),
(("T", 0, 6, 0), "Id1", 10, "From Entry", "From Entry Date", 0,
"Y", self.doEFrom, None, None, ("efld", )),
(("T", 0, 7, 0), "ID1", 10, "To Entry", "To Entry Date", 0,
"Y", self.doETo, None, None, ("efld", )),
(("T", 0, 8, 0), "Id1", 10, "From Status", "From Status Date",
0, "Y", self.doSFrom, None, None,
("efld", )), (("T", 0, 9, 0), "ID1", 10, "To Status",
"To Status Date", 0, "Y", self.doSTo, None, None,
("efld", )))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "N"))
def doDate(self, frt, pag, r, c, p, i, w):
self.repdt = w
self.repdtd = self.df.t_disp[pag][r][i]
self.df.topf[0][9][5] = self.repdt
self.df.topf[0][11][5] = self.repdt
def doStat(self, frt, pag, r, c, p, i, w):
self.state = w
def doCat(self, frt, pag, r, c, p, i, w):
if w == "A":
self.cat = ""
self.rgp = ""
self.cod = ""
self.df.loadEntry(frt,
pag,
p + 3,
data="All Categories and Sections")
return "sk2"
self.cat = w
if self.cat not in ("C", "D"):
self.rgp = ""
return "sk1"
def doRgrp(self, frt, pag, r, c, p, i, w):
if w and w not in self.rgrps:
return "Invalid Report Group"
self.rgp = w
if self.rgp:
self.cod = 0
return "sk2"
def doCod(self, frt, pag, r, c, p, i, w):
self.codchk = self.sql.getRec("memctc",
cols=["mcc_desc"],
where=[("mcc_cono", "=",
self.opts["conum"]),
("mcc_type", "=", self.cat),
("mcc_code", "=", w)],
limit=1)
if not self.codchk:
return "Invalid Category Code"
self.cod = w
self.df.loadEntry(frt, pag, p + 1, data=self.codchk[0])
def doGender(self, frt, pag, r, c, p, i, w):
self.gender = w
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
def doEFrom(self, frt, pag, r, c, p, i, w):
self.estart = w
self.estartd = self.df.t_disp[pag][r][i]
def doETo(self, frt, pag, r, c, p, i, w):
self.eend = w
self.eendd = self.df.t_disp[pag][r][i]
if self.state == "A":
self.sstart = 0
self.send = 0
return "sk2"
def doSFrom(self, frt, pag, r, c, p, i, w):
self.sstart = w
self.sstartd = self.df.t_disp[pag][r][i]
def doSTo(self, frt, pag, r, c, p, i, w):
self.send = w
self.sendd = self.df.t_disp[pag][r][i]
def doEnd(self):
self.df.closeProcess()
self.doChooseFields()
if self.cnums:
# Member's masterfile
tab = ["memmst"]
col = self.sql.memmst_col
whr = [("mlm_cono", "=", self.opts["conum"])]
if self.gender != "A":
whr.append(("mlm_gender", "=", self.gender))
if self.state != "Z":
whr.append(("mlm_state", "=", self.state))
if self.estart:
whr.append(("mlm_entry", ">=", self.estart))
if self.eend:
whr.append(("mlm_entry", "<=", self.eend))
if self.sstart:
if self.state == "R" and self.cat:
pass
else:
whr.append(("mlm_sdate", ">=", self.sstart))
if self.send:
if self.state == "R" and self.cat:
pass
else:
whr.append(("mlm_sdate", "<=", self.send))
if self.cat:
tab.append("memcat")
whr.append(("mlc_cono=mlm_cono", ))
whr.append(("mlc_memno=mlm_memno", ))
whr.append(("mlc_type", "=", self.cat))
if self.cod:
whr.append(("mlc_code", "=", self.cod))
if self.rgp:
tab.append("memctc")
whr.append(("mcc_cono=mlc_cono", ))
whr.append(("mcc_type=mlc_type", ))
whr.append(("mcc_code=mlc_code", ))
whr.append(("mcc_rgrp", "=", self.rgp))
if self.state == "A":
whr.append(("mlc_end", "=", 0))
elif self.state == "R":
whr.append(("(", "mlm_state", "=", "R", "and", "mlm_sdate",
"between", self.sstart, self.send, "or",
"mlm_state", "=", "A", "and", "mlc_end",
"between", self.sstart, self.send, ")"))
grp = col[0]
for c in col[1:]:
grp = "%s, %s" % (grp, c)
else:
grp = None
if self.sort == "N":
odr = "mlm_memno"
else:
odr = "mlm_surname"
recs = self.sql.getRec(tables=tab,
cols=col,
where=whr,
group=grp,
order=odr)
if not recs:
showError(self.opts["mf"].body, "Selection Error",
"No Accounts Selected")
else:
self.printReport(recs)
self.opts["mf"].closeLoop()
def printReport(self, recs):
data = []
typ = "Generating the Report ... Please Wait"
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), typ=typ, esc=True)
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
data.append(self.getValues(dat))
p.closeProgress()
if not p.quit:
head = ["Member's Master Report as at %s" % self.repdtd]
colsh = []
for n1 in self.cnums:
for n2, d2 in enumerate(self.colsd[n1][2:]):
if n1 in (20, 21) and self.df.repprt[2] == "export":
if n1 == 20:
prefix = "P"
col = copyList(self.padcol)
else:
prefix = "S"
col = copyList(self.sadcol)
colsh.append(("name1%s_%s" % (n1, n2), "NA", col[0],
"%s-Address-Line-1" % prefix, "y"))
colsh.append(("name2%s_%s" % (n1, n2), "NA", col[1],
"%s-Address-Line-2" % prefix, "y"))
colsh.append(("name3%s_%s" % (n1, n2), "NA", col[2],
"%s-Address-Line-3" % prefix, "y"))
colsh.append(("name4%s_%s" % (n1, n2), "NA", col[3],
"%s-City" % prefix, "y"))
colsh.append(("name5%s_%s" % (n1, n2), "NA", col[4],
"%s-Code" % prefix, "y"))
colsh.append(("name6%s_%s" % (n1, n2), "NA", col[5],
"%s-Region" % prefix, "y"))
colsh.append(("name7%s_%s" % (n1, n2), "NA", col[6],
"%s-Country" % prefix, "y"))
else:
colsh.append(
("name%s_%s" % (n1, n2), d2[1], d2[2], d2[0], "y"))
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
heads=head,
tables=data,
cols=colsh,
opts=self.getDes(),
ttype="D",
conum=self.opts["conum"],
conam=self.opts["conam"],
repprt=self.df.repprt,
repeml=self.df.repeml,
fromad=self.fromad,
pbar="P")
def doChooseFields(self):
r1s = (("Yes", "Y"), ("No", "N"))
fld = []
idx = 0
for num in range(0, len(self.colsd), 2):
des = self.colsd[num][0]
dft = self.colsd[num][1]
fld.append((("T", 0, idx, 0, 27), ("IRB", r1s), 0, des, des, dft,
"N", self.doCField, None, None, None))
if (num + 1) == len(self.colsd):
continue
des = " %s" % self.colsd[num + 1][0]
dft = self.colsd[num + 1][1]
fld.append((("T", 0, idx, 40, 67), ("IRB", r1s), 0, des, des, dft,
"N", self.doCField, None, None, None))
idx += 1
tnd = ((self.doCEnd, "Y"), )
txt = (self.doCExit, )
self.cf = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt)
self.cf.mstFrame.wait_window()
def doCField(self, frt, pag, r, c, p, i, w):
mxs = 0
for n, x in enumerate(self.cf.t_work[pag][0]):
if x == "Y":
for y in self.colsd[n][2:]:
if mxs:
mxs += 1
mxs += y[2]
if mxs > 210 and self.df.repprt[2] != "export":
return "Maximum Print Width Exceeded"
if p == 3 and w == "Y":
self.cf.loadEntry(frt, pag, p + 1, data="N")
self.cf.loadEntry(frt, pag, p + 2, data="N")
self.cf.loadEntry(frt, pag, p + 3, data="N")
return "sk3"
def doCEnd(self):
self.cf.closeProcess()
self.cnums = []
for n1, d1 in enumerate(self.cf.t_work[0][0]):
if d1 == "Y":
self.cnums.append(n1)
def doCExit(self):
self.cnums = []
self.cf.closeProcess()
def getDes(self):
if self.state == "Z":
des = "All Statuses"
elif self.state == "A":
des = "Active Members"
elif self.state == "D":
des = "Deceased Members"
elif self.state == "I":
des = "Inactive Members"
elif self.state == "R":
des = "Resigned Members"
elif self.state == "S":
des = "Suspended Members"
elif self.state == "X":
des = "Defaulted Members"
if self.gender == "M":
des = "%s (Male)" % des
elif self.gender == "F":
des = "%s (Female)" % des
if self.cat in ("", "A"):
des = "%s for All Categories and Sections" % des
elif self.cat == "B":
des = "%s for Main Category" % des
elif self.cat == "C":
des = "%s for Sports Category" % des
elif self.cat == "D":
des = "%s for Debenture Category" % des
if self.cat and self.rgp:
des = "%s: Report Group %s" % (des, self.rgp)
if self.cod:
des = "%s: %s" % (des, self.codchk[0])
else:
des = "%s: All Sections" % des
elif self.cat and self.cod:
des = "%s: %s" % (des, self.codchk[0])
elif self.cat:
des = "%s: All Sections" % des
if self.estart:
des = "%s who Joined Between %s and %s" % (des, self.estartd,
self.eendd)
else:
des = "%s who Joined On or Before %s" % (des, self.eendd)
return des
def getValues(self, data):
col = self.sql.memmst_col
# Membership Number
self.memno = data[col.index("mlm_memno")]
# Title
tit = data[col.index("mlm_title")]
# Surname
sur = data[col.index("mlm_surname")]
# First Names
nam = data[col.index("mlm_names")]
# Initials
ini = data[col.index("mlm_initial")]
# Combined Name
sti = "%s, %s %s" % (sur, tit, ini)
# Gender
gen = data[col.index("mlm_gender")]
# Date of Birth
dob = data[col.index("mlm_dob")]
# Age
if dob:
age = dateDiff(dob, self.repdt, "years")
else:
age = 0
# Identity Number
idn = data[col.index("mlm_idnum")]
# Entry Date
doe = data[col.index("mlm_entry")]
# Payment Plan
pay = data[col.index("mlm_payplan")]
# Entry Years
if doe:
yrs = dateDiff(doe, self.repdt, "years")
else:
yrs = 0
# Status
if data[col.index("mlm_state")] == "A":
sta = "Active"
elif data[col.index("mlm_state")] == "D":
sta = "Deceased"
elif data[col.index("mlm_state")] == "I":
sta = "Inactive"
elif data[col.index("mlm_state")] == "R":
sta = "Resigned"
elif data[col.index("mlm_state")] == "S":
sta = "Suspended"
elif data[col.index("mlm_state")] == "X":
sta = "Defaulted"
# Status Date
sdt = data[col.index("mlm_sdate")]
# Proposer
prp = self.sql.getRec("memmst",
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=",
data[col.index("mlm_proposer")])],
limit=1)
if not prp:
prn = "Unknown"
pry = 0
else:
prn = "%s, %s %s" % (prp[col.index("mlm_surname")],
prp[col.index("mlm_title")],
prp[col.index("mlm_initial")])
if prp[col.index("mlm_entry")]:
pry = dateDiff(prp[col.index("mlm_entry")], self.repdt,
"years")
else:
pry = 0
# Seconder
sec = self.sql.getRec("memmst",
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=",
data[col.index("mlm_seconder")])],
limit=1)
if not sec:
sen = "Unknown"
sey = 0
else:
sen = "%s, %s %s" % (sec[col.index("mlm_surname")],
sec[col.index("mlm_title")],
sec[col.index("mlm_initial")])
if sec[col.index("mlm_entry")]:
sey = dateDiff(sec[col.index("mlm_entry")], self.repdt,
"years")
else:
sey = 0
# Postal Address
rcp = self.sql.getRec("memadd",
where=[("mla_cono", "=", self.opts["conum"]),
("mla_memno", "=", self.memno),
("mla_type", "=", "P")],
limit=1)
if not rcp:
rcp = [
self.opts["conum"], self.memno, "P", "", "", "", "", "", "", ""
]
if self.df.repprt[2] == "export":
pad = rcp[3:]
for x in range(3, len(rcp)):
if self.padcol[x - 3] < len(rcp[x]):
self.padcol[x - 3] = len(rcp[x])
else:
pad = rcp[3]
if rcp[4]:
pad = "%s, %s" % (pad, rcp[4])
if rcp[5]:
pad = "%s, %s" % (pad, rcp[5])
if rcp[7]:
pad = "%s, %s" % (pad, rcp[7])
# Street Address
rcs = self.sql.getRec("memadd",
where=[("mla_cono", "=", self.opts["conum"]),
("mla_memno", "=", self.memno),
("mla_type", "=", "R")],
limit=1)
if not rcs:
rcs = [
self.opts["conum"], self.memno, "R", "", "", "", "", "", "", ""
]
if self.df.repprt[2] == "export":
sad = rcs[3:]
for x in range(3, len(rcs)):
if self.sadcol[x - 3] < len(rcs[x]):
self.sadcol[x - 3] = len(rcs[x])
else:
sad = rcs[3]
if rcs[4]:
sad = "%s, %s" % (sad, rcs[4])
if rcs[5]:
sad = "%s, %s" % (sad, rcs[5])
if rcs[7]:
sad = "%s, %s" % (sad, rcs[7])
# Active Category
whr = [("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", self.memno), ("mlc_type", "=", "B"),
("mcc_cono=mlc_cono", ), ("mcc_type=mlc_type", ),
("mcc_code=mlc_code", )]
cat = self.sql.getRec(tables=["memcat", "memctc"],
cols=["mcc_desc"],
where=whr,
limit=1)
if cat:
cat = cat[0]
else:
cat = "Unknown Category"
# Contact Details
kon = self.sql.getRec(tables=["memctk", "memkon"],
cols=["mck_type", "mlk_detail"],
where=[("mlk_cono", "=", self.opts["conum"]),
("mlk_memno", "=", self.memno),
("mck_code=mlk_code", )])
# Home Tel
htl = ""
# Work Tel
wtl = ""
# Mobile
cel = ""
# Email
em1 = ""
em2 = ""
for k in kon:
if k[0] == "H" and not htl:
htl = k[1]
if k[0] == "W" and not wtl:
wtl = k[1]
if k[0] == "M" and not cel:
cel = k[1]
if k[0] == "E":
if not em1:
em1 = k[1]
else:
em2 = k[1]
nat = countries[data[col.index("mlm_nation")]]
if nat:
nat = nat[1]
else:
nat = "Unknown"
occ = self.sql.getRec("memcto",
cols=["mco_desc"],
where=[("mco_code", "=",
data[col.index("mlm_occup")])],
limit=1)
if occ:
occ = occ[0]
else:
occ = "Unknown"
if 22 in self.cnums:
# Category Notes
if self.cat == "C" or (self.cat == "D" and self.cod):
nte = self.sql.getRec("memcat",
cols=["mlc_note"],
where=[("mlc_cono", "=",
self.opts["conum"]),
("mlc_memno", "=", self.memno),
("mlc_type", "=", self.cat),
("mlc_code", "=", self.cod)],
limit=1)
if not nte:
nte = [""]
elif self.cat == "D":
chk = self.sql.getRec("memcat",
cols=["mlc_note"],
where=[("mlc_cono", "=",
self.opts["conum"]),
("mlc_memno", "=", self.memno),
("mlc_type", "=", self.cat)])
if not chk:
nte = ["Unknown"]
else:
nte = ""
for n in chk:
if not n[0]:
continue
if not nte:
nte = n[0]
else:
nte = "%s, %s" % (nte, n[0])
if nte:
nte = [nte]
else:
nte = ["Unknown"]
else:
nte = [""]
nte = nte[0]
if 25 in self.cnums:
# Account Balance
if sta == "Active":
self.raiseExtraTrans()
bal = self.sql.getRec("memtrn",
cols=["sum(mlt_tramt)"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno)],
limit=1)
if not bal:
bal = 0
else:
bal = bal[0]
self.opts["mf"].dbm.rollbackDbase()
if 26 in self.cnums:
# Sports Categories
col = ["mcc_rgrp"]
whr = [("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", self.memno), ("mlc_type", "=", "C"),
("mlc_end", "=", 0), ("mcc_cono=mlc_cono", ),
("mcc_type=mlc_type", ), ("mcc_code=mlc_code", )]
spc = self.sql.getRec(tables=["memcat", "memctc"],
cols=col,
where=whr)
chk = []
for s in spc:
chk.append(s[0])
asc = []
for g in self.rgrps:
if g in chk:
asc.append(g)
else:
asc.append(" ")
val = []
if 0 in self.cnums:
val.append(self.memno)
if 1 in self.cnums:
val.append(sta)
if 2 in self.cnums:
val.append(sdt)
if 3 in self.cnums:
val.append(sti)
if 4 in self.cnums:
val.append(sur)
if 5 in self.cnums:
val.append(tit)
if 6 in self.cnums:
val.append(nam)
if 7 in self.cnums:
val.append(gen)
if 8 in self.cnums:
val.append(dob)
if 9 in self.cnums:
val.append(age)
if 10 in self.cnums:
val.append(idn)
if 11 in self.cnums:
val.append(doe)
if 12 in self.cnums:
val.append(yrs)
if 13 in self.cnums:
val.append(pay)
if 14 in self.cnums:
val.append(cat)
if 15 in self.cnums:
val.append(htl)
if 16 in self.cnums:
val.append(wtl)
if 17 in self.cnums:
val.append(cel)
if 18 in self.cnums:
val.append(em1)
if 19 in self.cnums:
val.append(em2)
if 20 in self.cnums:
if self.df.repprt[2] == "export":
val.extend(pad)
else:
val.append(pad)
if 21 in self.cnums:
if self.df.repprt[2] == "export":
val.extend(sad)
else:
val.append(sad)
if 22 in self.cnums:
val.append(nte)
if 23 in self.cnums:
val.append(prn)
val.append(pry)
if 24 in self.cnums:
val.append(sen)
val.append(sey)
if 25 in self.cnums:
val.append(bal)
if 26 in self.cnums:
val.extend(asc)
if 27 in self.cnums:
nte = self.sql.getRec("ctlnot",
cols=["not_desc"],
where=[("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "MEM"),
("not_key", "=", str(self.memno))],
order="not_seq desc",
limit=1)
if nte:
val.append(nte[0])
else:
val.append("")
if 28 in self.cnums:
val.append(nat)
if 29 in self.cnums:
val.append(occ)
return val
def getCode(self, desc):
a = desc.split()
if len(a) == 1:
return "%s " % a[0][0].capitalize()
if a[1] == "-":
return "%s%s" % (a[0][0].capitalize(), a[2][0].capitalize())
return "%s%s" % (a[0][0].capitalize(), a[1][0].capitalize())
def raiseExtraTrans(self):
self.tme = mthendDate(self.repdt)
if int(self.tme / 100) == int(self.opts["period"][2][0] / 100):
self.ynd = True
else:
self.ynd = False
yy = int(self.tme / 10000)
mm = (int(self.tme / 100) % 100) + 1
while mm > 12:
yy += 1
mm -= 12
self.nxtdt = (yy * 10000) + (mm * 100) + 1
self.refno = 0
if self.ynd:
data = doChkCatChg(self.opts["mf"], self.opts["conum"], self.memno,
self.nxtdt)
if data:
self.doRaiseCharge("B",
data[0],
data[1],
data[3],
data[4],
data[5],
skip=True)
self.sql.delRec("memcat",
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", self.memno),
("mlc_type", "=", "B"),
("mlc_code", "=", data[0])])
self.sql.insRec("memcat",
data=[
self.opts["conum"], self.memno, "B",
data[7], "", self.nxtdt, 0, 0
])
cols = [
"mlc_type", "mlc_code", "mcc_desc", "mcc_freq", "mlc_start",
"mlc_end", "mlc_last"
]
wher = [("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", self.memno), ("mlc_start", ">", 0),
("mlc_start", "<=", self.nxtdt), ("mcc_cono=mlc_cono", ),
("mcc_type=mlc_type", ), ("mcc_code=mlc_code", ),
("mcc_freq", "<>", "N")]
cats = self.sql.getRec(tables=["memcat", "memctc"],
cols=cols,
where=wher,
order="mlc_type, mlc_code")
for ctyp, code, desc, freq, start, end, last in cats:
if start > self.nxtdt:
# Not yet Started
continue
if last and end and end < self.nxtdt:
# Ended
continue
if last and freq == "O":
# Once Off
continue
if last and last > self.opts["period"][2][0]:
# Already Raised for Next Period in Advance
continue
if not self.ynd and last and freq == "A" and \
last >= self.opts["period"][1][0] and \
last <= self.opts["period"][2][0]:
# Already Raised in Financial Period
continue
self.doRaiseCharge(ctyp, code, start, last, freq, desc)
def doRaiseCharge(self, ctyp, code, start, last, freq, desc, skip=False):
if freq == "O":
dte = True
nxt = False
else:
dte = False
nxt = bool(self.ynd or freq == "M")
if not last:
if dateDiff(start, self.tme, "days") > self.ldays:
dte = True
else:
nxt = True
if dte:
trdt = start
amt = self.doGetCharge(ctyp, code, trdt)
if amt:
self.doUpdateTables(ctyp, code, desc, trdt, amt)
if not skip and nxt:
trdt = self.nxtdt
amt = self.doGetCharge(ctyp, code, trdt)
if amt:
self.doUpdateTables(ctyp, code, desc, trdt, amt)
if dte or (not skip and nxt):
self.sql.updRec("memcat",
cols=["mlc_last"],
data=[trdt],
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", self.memno),
("mlc_type", "=", ctyp),
("mlc_code", "=", code)])
def doGetCharge(self, ctyp, code, date):
prc = self.sql.getRec("memctp",
where=[("mcp_cono", "=", self.opts["conum"]),
("mcp_type", "=", ctyp),
("mcp_code", "=", code),
("mcp_date", "<=", date)],
order="mcp_date desc",
limit=1)
if not prc:
# No Price
return
if prc[5] == "N" or (self.ynd and date == self.nxtdt):
# Not Pro Rata or End of Financial Year
amt = CCD(prc[6], "UD", 12.2).work
else:
# Extract Pro Rata Rate
mths = 17 - dateDiff(date, self.opts["period"][2][0], "months")
if mths < 1:
mths = 12
amt = CCD(prc[mths], "UD", 12.2).work
if not amt:
# No Charge
return
else:
return amt
def doUpdateTables(self, ctyp, code, desc, trdt, amt):
batch = "PROFORM"
self.refno += 1
refno = "PF%07i" % self.refno
curdt = int(trdt / 100)
# VAT Rate and Amount
vrte = getVatRate(self.sql, self.opts["conum"], self.taxdf, trdt)
if vrte is None:
vrte = 0.0
vat = CCD(round(((amt * vrte) / 114), 2), "UD", 12.2).work
# Members Ledger Transaction (memtrn)
self.sql.insRec("memtrn",
data=[
self.opts["conum"], self.memno, 1, refno, batch,
trdt, amt, vat, curdt, ctyp, code, desc,
self.taxdf, "", self.opts["capnm"], self.sysdt, 0
],
unique="mlt_refno")
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bkc510(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["chglog", "bkmcon", "bkmmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
bkmctl = gc.getCtl("bkmctl", self.opts["conum"])
if not bkmctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
con = {
"stype":
"R",
"tables": ("bkmcon", ),
"cols":
(("bkc_ccode", "", 0, "Code"), ("bkc_title", "", 0, "Title"),
("bkc_sname", "", 0, "Surname",
"Y"), ("bkc_names", "", 0, "Names", "F"), ("bkc_email", "", 0,
"Email Address"))
}
self.fld = ((("T", 0, 0, 0), "IUA", 7, "Code", "", "", "Y",
self.doCode, con, None, None),
(("T", 0, 1, 0), "ITX", 6, "Title", "", "", "N",
self.doTitle, None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "ITX", 30, "Surname", "", "", "N",
self.doSurname, None, None, ("notblank", )),
(("T", 0, 3, 0), "ITX", 30, "Names", "", "", "N",
self.doNames, None, None, ("notblank", )),
(("T", 0, 4, 0), "ITX", 30, "Address Line 1", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 5, 0), "ITX", 30, "Address Line 2",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 6, 0), "ITX", 30, "Address Line 3", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 7, 0), "ITX", 4, "Postal Code", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 8, 0), "ITX", 20, "Telephone Number", "", "",
"N", None, None, None,
("efld", )), (("T", 0, 9, 0), "ITX", 20, "Fax Number", "",
"", "N", None, None, None,
("efld", )), (("T", 0, 10, 0), "ITX", 20,
"Mobile Number", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 11, 0), "ITX", 30, "E-Mail Address", "", "", "N",
None, None, None,
("email", )), (("T", 0, 12, 0), "INA", 10, "V.A.T Number",
"", "", "N", None, None, None, ("efld", )))
but = (
("Import",None,self.doImport,0,("T",0,1),("T",0,2),
"Import Contact Details from a CSV or XLS File having "\
"the following fields: Code, Title, Surname, Names, "\
"Address Line1, Line2, Line3, Postal Code, Telephone Number, "\
"Fax Number, Mobile Number, Email Address, VAT Number"),
("Accept",None,self.doAccept,0,("T",0,2),("T",0,1)),
("Print", None, self.doPrint,0,("T",0,2),("T",0,1)),
("Quit", None, self.doExit,1,None,None))
tnd = ((self.doAccept, "N"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
def doClick(self, *opts):
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doCode(self, frt, pag, r, c, p, i, w):
self.ccode = w
if w:
self.oldcon = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_ccode", "=", w)],
limit=1)
if not self.oldcon:
return "Invalid Contact Code"
self.newcon = False
self.title = self.oldcon[self.sql.bkmcon_col.index("bkc_title")]
self.sname = self.oldcon[self.sql.bkmcon_col.index("bkc_sname")]
self.names = self.oldcon[self.sql.bkmcon_col.index("bkc_names")]
self.email = self.oldcon[self.sql.bkmcon_col.index("bkc_email")]
for num, dat in enumerate(self.oldcon[1:-1]):
self.df.loadEntry("T", 0, num, data=dat)
else:
self.newcon = True
self.acno = w
def doTitle(self, frt, pag, r, c, p, i, w):
self.title = w
def doSurname(self, frt, pag, r, c, p, i, w):
self.sname = w
def doNames(self, frt, pag, r, c, p, i, w):
self.names = w
def doEmail(self, frt, pag, r, c, p, i, w):
self.email = w
def doDelete(self):
chk = self.sql.getRec("bkmmst",
cols=["count(*)"],
where=[("bkm_cono", "=", self.opts["conum"]),
("bkm_ccode", "=", self.ccode)],
limit=1)
if chk[0]:
return "Bookings Exist, Not Deleted"
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("bkmcon",
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", self.ccode)])
self.sql.insRec("chglog",
data=[
"bkmcon", "D",
"%03i%-7s" % (self.opts["conum"], self.ccode), "",
dte, self.opts["capnm"], "", "", "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
return
# Create/Update Record
if self.newcon:
self.ccode = self.genCode(self.sname)
self.df.loadEntry("T", 0, 0, data=self.ccode)
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
data = [self.opts["conum"]]
for x in range(len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.newcon:
self.sql.insRec("bkmcon", data=data)
elif data != self.oldcon[:len(data)]:
col = self.sql.bkmcon_col
data.append(self.oldcon[col.index("bkc_xflag")])
self.sql.updRec("bkmcon",
data=data,
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", self.ccode)])
for num, dat in enumerate(self.oldcon):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"bkmcon", "U",
"%03i%-7s" % (self.opts["conum"], self.ccode),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doImport(self):
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="bkmcon", impskp=["bkc_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Contacts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if not line[0]:
if not line[2]:
err = "Blank Code and Blank Surname"
break
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_sname", "=", line[2]),
("bkc_names", "=", line[3])],
limit=1)
if chk:
err = "%s: %s %s: %s\n\nAlready Exists" % (
fi.impcol[2][0], line[2], fi.impcol[3][0], line[3])
break
for _ in range(1, 100):
line[0] = self.genCode(line[2])
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_ccode", "=", line[0])],
limit=1)
if not chk:
break
else:
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=",
self.opts["conum"]),
("bkc_ccode", "=", line[0])],
limit=1)
if chk:
err = "%s: %s %s: %s\n\nAlready Exists" % (
fi.impcol[0][0], line[0], fi.impcol[2][0], line[2])
break
if not line[1]:
line[1] = "Ms"
if not line[2]:
err = "Blank Surname"
break
if not line[3]:
err = "Blank Names"
break
line.insert(0, self.opts["conum"])
self.sql.insRec("bkmcon", data=line)
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
TabPrt(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
name=self.__class__.__name__,
tabs="bkmcon",
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", self.ccode)])
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def genCode(self, sname):
# Remove invalid characters
sname = sname.replace(" ", "")
for c in (" ", ".", ",", ";", ":", "'", '"'):
sname = sname.replace(c, "")
if len(sname) < 5:
sname = sname + ("0" * (5 - len(sname)))
ccod1 = ""
for c in range(0, 5):
ccod1 = (ccod1 + sname[c]).upper()
ccod1 = ccod1.strip()
text = "%s%0" + str((7 - len(ccod1))) + "d"
for x in range(1, 100):
ccod2 = text % (ccod1, x)
chk = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", ccod2)],
limit=1)
if not chk:
break
return ccod2
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bkc110(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 = ["bkmctl", "tplmst", "chglog"]
if self.genleg:
tabs.extend(["ctlctl", "genmst"])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.acc = self.sql.getRec("bkmctl",
where=[("cbk_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [
self.opts["conum"], "N", "booking_form", "booking_invoice",
"booking_statement", "", "", ""
]
else:
self.new = False
if self.genleg:
self.ctl = [["bkm_ctl", "Bookings Control", 0],
["bkm_chq", "Cheques Received", 0],
["bkm_csh", "Cash Received", 0],
["bkm_ccg", "Cancellation Fee", 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):
tpb = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")),
"where": [("tpm_type", "=", "B"), ("tpm_system", "=", "BKM")],
"order":
"tpm_tname"
}
tpi = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")),
"where": [("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")],
"order":
"tpm_tname"
}
tps = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")),
"where": [("tpm_type", "=", "S"), ("tpm_system", "=", "BKM")],
"order":
"tpm_tname"
}
trm = {"stype": "F", "types": "fle"}
r1s = (("Yes", "Y"), ("No", "N"))
if self.genleg:
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30,
"Description")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "",
self.acc[1], "N", self.doGlint, None, None, None),
(("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "",
self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 1, 0), "ONA", 30, ""),
(("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "",
self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "IUI", 7, self.ctl[2][1], "",
self.ctl[2][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), "IUI", 7, self.ctl[3][1], "",
self.ctl[3][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 4, 0), "ONA", 30, "")]
seq = 5
else:
fld = []
seq = 0
fld.extend([(("T", 0, seq, 0), "INA", 20, "Booking Template", "",
self.acc[2], "N", self.doBkgTpl, tpb, None, None),
(("T", 0, seq + 1, 0), "INA", 20, "Invoice Template", "",
self.acc[3], "N", self.doInvTpl, tpi, None, None),
(("T", 0, seq + 2, 0), "INA", 20, "Statement Template", "",
self.acc[4], "N", self.doStaTpl, tps, None, None),
(("T", 0, seq + 3, 0), "ITX", 50, "Terms and Conditions",
"", self.acc[5], "N", None, trm, None, ("fle", "blank")),
(("T", 0, seq + 4, 0), "ITX", 50, "Email Address", "",
self.acc[6], "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 doGlint(self, frt, pag, r, c, p, i, w):
self.glint = w
if self.glint == "N":
for x in range(1, 9):
self.df.loadEntry(frt, pag, p + x, data="")
return "sk8"
def doGenAcc(self, frt, pag, r, c, p, i, w):
des = self.getDes(w)
if not des:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=des)
def getDes(self, acno):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acno)],
limit=1)
if acc:
return acc[0]
else:
return ""
def doBkgTpl(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "B"),
("tpm_system", "=", "BKM")],
limit=1)
if not acc:
return "Invalid Template Name"
def doInvTpl(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "I"),
("tpm_system", "=", "BKM")],
limit=1)
if not acc:
return "Invalid Template Name"
def doStaTpl(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "S"),
("tpm_system", "=", "BKM")],
limit=1)
if not acc:
return "Invalid Template Name"
def doEnd(self):
data = [self.opts["conum"]]
if not self.genleg:
data.append("N")
for x, d in enumerate(self.df.t_work[0][0]):
if self.genleg and x < 9:
if x in (1, 3, 5, 7):
y = int((x - 1) / 2)
chk = self.sql.getRec("ctlctl",
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])],
limit=1)
if chk:
self.sql.updRec("ctlctl",
cols=["ctl_conacc"],
data=[d],
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])])
else:
self.sql.insRec("ctlctl",
data=[
self.opts["conum"], self.ctl[y][0],
self.ctl[y][1], d, "", "N", "N"
])
elif x in (2, 4, 6, 8):
continue
else:
data.append(d)
else:
data.append(d)
if self.new:
self.sql.insRec("bkmctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.bkmctl_col
data.append(self.acc[col.index("cbk_xflag")])
self.sql.updRec("bkmctl",
data=data,
where=[("cbk_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=[
"bkmctl", "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 rc1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["ctlmst", "rcaowm", "rcaowt", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
return True
def mainProcess(self):
own = {
"stype":
"R",
"tables": ("rcaowm", ),
"cols":
(("rom_acno", "", 0, "Acc-Num"), ("rom_name", "", 0, "Name", "Y")),
"where": [("rom_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INA", 7, "Account Number", "", "", "Y",
self.doOwner, own, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N", None,
None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 3",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 4, "Postal Code", "PCod", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 6, 0), "INA", 20, "Home Number", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 7, 0), "INA", 20, "Office Number",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 8, 0), "INA", 20, "Mobile Number", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 9, 0), "INA", 20, "Fax Number", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 10, 0), "ITX", 50, "E-Mail Address", "", "", "N",
None, None, None, ("email", )),
(("T", 0, 11, 0), "INA", 10, "VAT Number",
"VAT-Number", "", "N", None, None, None,
("efld", )), (("T", 0, 12, 0), "IUA", 1, "VAT Default",
"V", "", "N", None, None, None, ("efld", )),
(("T", 0, 13, 0), "INA", 20, "Bank Name", "Bank-Name", "",
"N", None, None, None,
("efld", )), (("T", 0, 14, 0), "IUI", 8, "Bank Branch",
"Bank-IBT", "", "N", None, None, None,
("efld", )), (("T", 0, 15, 0), "INA", 16,
"Bank Account",
"Bank-Account-Num", "", "N",
None, None, None, ("efld", )))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doOwner(self, frt, pag, r, c, p, i, w):
self.acno = w
self.oldm = self.sql.getRec("rcaowm",
where=[("rom_cono", "=",
self.opts["conum"]),
("rom_acno", "=", self.acno)],
limit=1)
if not self.oldm:
self.new = "y"
for num in range(2, self.df.topq[0]):
self.df.clearEntry(frt, pag, num + 1)
else:
self.new = "n"
for num, fld in enumerate(self.oldm[1:-1]):
self.df.loadEntry(frt, pag, p + num, data=fld)
trn = self.sql.getRec("rcaowt",
cols=["count(*)"],
where=[("rot_cono", "=", self.opts["conum"]),
("rot_acno", "=", self.acno)],
limit=1)
if trn[0]:
self.trn = True
else:
self.trn = False
def doName(self, frt, pag, r, c, p, i, w):
pass
def doTelno(self, frt, pag, r, c, p, i, w):
pass
def doEmail(self, frt, pag, r, c, p, i, w):
pass
def doVatInd(self, frt, pag, r, c, p, i, w):
pass
def doVatNum(self, frt, pag, r, c, p, i, w):
if self.new == "n" and self.trn:
return "sk1"
def doStart(self, frt, pag, r, c, p, i, w):
pass
def doPeriod(self, frt, pag, r, c, p, i, w):
pass
def doPayInd(self, frt, pag, r, c, p, i, w):
pass
def doAmount(self, frt, pag, r, c, p, i, w):
if self.new == "y":
self.df.loadEntry(frt, pag, p + 1, data="C")
def doStatus(self, frt, pag, r, c, p, i, w):
pass
def doDelete(self):
if self.trn:
return "Transactions Exist, Not Deleted"
self.sql.delRec("rcaowm",
where=[("rom_cono", "=", self.opts["conum"]),
("rom_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["rcaowm", "D", "%03i%-7s" % \
(self.opts["conum"], self.acno), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
datm = [self.opts["conum"]]
for num, fld in enumerate(self.df.t_work[0][0]):
datm.append(fld)
if self.new == "y":
self.sql.insRec("rcaowm", data=datm)
elif datm != self.oldm[:len(datm)]:
col = self.sql.rcaowm_col
datm.append(self.oldm[col.index("rom_xflag")])
self.sql.updRec("rcaowm",
data=datm,
where=[("rom_cono", "=", self.opts["conum"]),
("rom_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec(
"chglog",
data=[
"rcaowm", "U",
"%03i%-7s" % (self.opts["conum"], self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(datm[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class stc310(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "genmst", "strmf1",
"strgrp", "strgmu"], prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.plevs = strctl["cts_plevs"]
self.automu = strctl["cts_automu"]
return True
def mainProcess(self):
gpm = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
glm = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]}
self.fld = [
(("T",0,0,0),"IUA",3,"Product Group","",
"","N",self.doGroup,gpm,None,("notblank",)),
(("T",0,1,0),"INA",30,"Description","",
"","N",None,None,self.doDelete,("notblank",)),
(("T",0,2,0),"IUA",1,"Vat Code","",
"","N",self.doVat,vtm,None,("notblank",))]
row = 3
if self.glint == "Y":
self.fld.append((("T",0,3,0),"IUI",7,"Sales Account","",
"","N",self.doSales,glm,None,("notzero",)))
self.fld.append((("T",0,3,0),"ONA",30,""))
self.fld.append((("T",0,4,0),"IUI",7,"COS Account","",
"","N",self.doCos,glm,None,("notzero",)))
self.fld.append((("T",0,4,0),"ONA",30,""))
row = 5
if self.automu in ("A", "L"):
self.fld.append((("T",0,row,0),"IUD",5.1,"Mark-Up Lv1","",
"","N",None,None,None,("efld",)))
if self.plevs > 1:
for x in range(1, self.plevs):
self.fld.append((("T",0,row,0),"IUD",5.1,"Lv%s" % (x+1),"",
"","N",None,None,None,("efld",)))
but = (
("Accept",None,self.doAccept,0,("T",0,2),("T",0,0)),
("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0)))
tnd = ((self.doEnd,"Y"), )
txt = (self.doCloseProcess, )
self.df = TartanDialog(self.opts["mf"], eflds=self.fld,
butt=but, tend=tnd, txit=txt)
def doGroup(self, frt, pag, r, c, p, i, w):
self.group = w
self.acc = self.sql.getRec("strgrp", where=[("gpm_cono", "=",
self.opts["conum"]), ("gpm_group", "=", self.group)], limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
col = self.sql.strgrp_col
self.df.loadEntry(frt, pag, p+1,
data=self.acc[col.index("gpm_desc")])
self.df.loadEntry(frt, pag, p+2,
data=self.acc[col.index("gpm_vatcode")])
p = 3
if self.glint == "Y":
self.df.loadEntry(frt, pag, p,
data=self.acc[col.index("gpm_sales")])
des = self.getGenDesc(self.acc[col.index("gpm_sales")])
if not des:
self.df.loadEntry(frt, pag, p+1,
data="Invalid Sales Code")
else:
self.df.loadEntry(frt, pag, p+1,
data=des[0])
self.df.loadEntry(frt, pag, p+2,
data=self.acc[col.index("gpm_costs")])
des = self.getGenDesc(self.acc[col.index("gpm_costs")])
if not des:
self.df.loadEntry(frt, pag, p+3,
data="Invalid Costs Code")
else:
self.df.loadEntry(frt, pag, p+3,
data=des[0])
p = 7
if self.automu in ("A", "L"):
for lev in range(self.plevs):
mup = self.sql.getRec("strgmu", cols=["smg_markup"],
where=[("smg_cono", "=", self.opts["conum"]),
("smg_group", "=", self.group), ("smg_level",
"=", lev + 1)], limit=1)
if not mup:
mup = [0]
self.df.loadEntry(frt, pag, p+lev, data=mup[0])
def doVat(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf", cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]), ("vtm_code", "=",
w)], limit=1)
if not vat:
return "Invalid VAT Code"
self.code = w
def doSales(self, frt, pag, r, c, p, i, w):
acc = self.getGenDesc(w)
if not acc:
return "Invalid Sales Code"
self.sales = w
self.df.loadEntry("T", 0, 4, data=acc[0])
def doCos(self, frt, pag, r, c, p, i, w):
acc = self.getGenDesc(w)
if not acc:
return "Invalid COS Code"
self.cos = w
self.df.loadEntry("T", 0, 6, data=acc[0])
def doDelete(self):
st1 = self.sql.getRec("strmf1", cols=["count(*)"],
where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=",
self.group)], limit=1)
if st1[0]:
return "Records Exist for this Group, Not Deleted"
self.sql.delRec("strgrp", where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", self.group)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if x == 7:
break
if self.glint == "Y":
# Account Names
if x in (4, 6):
continue
elif x == 3:
data.append(0)
data.append(0)
break
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("strgrp", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.strgrp_col
data.append(self.acc[col.index("gpm_xflag")])
self.sql.updRec("strgrp", data=data, where=[("gpm_cono",
"=", self.opts["conum"]), ("gpm_group", "=", self.group)])
self.sql.delRec("strgmu", where=[("smg_cono", "=", self.opts["conum"]),
("smg_group", "=", self.group)])
if self.automu in ("A", "L"):
for lvl, mup in enumerate(self.df.t_work[0][0][x:]):
if not mup:
continue
self.sql.insRec("strgmu", data=[self.opts["conum"],
self.group, lvl + 1, mup])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col+1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def getGenDesc(self, acno):
return self.sql.getRec("genmst", cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=",
acno)], limit=1)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class drc510(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"ctlmes",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols":
(("mss_system", "", 0, "Sys"), ("mss_message", "", 0, "Mss"),
("mss_detail", "NA", 50, "Details")),
"where": [],
"index":
1
}
r1s = (("Invoice", "I"), ("Statement", "S"), ("Conditions", "C"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Message Type", "", "I", "Y",
self.doType, None, None, None),
(("T", 0, 1, 0), "IUI", 3, "Message Number", "", "", "N",
self.doMes, mss, None, ("notzero", )),
(("T", 0, 2, 0), "ITv", (30, 6), "Details", "", "", "N",
self.doDetail, None, self.doDelete, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 3), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 3),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
def doType(self, frt, pag, r, c, p, i, w):
if w == "I":
self.system = "INV"
elif w == "S":
self.system = "STA"
else:
self.system = "CON"
self.df.loadEntry(frt, pag, p + 1, data=1)
self.doMes(frt, pag, r, c + 1, p + 1, i + 1, 1)
return "sk1"
self.df.topf[pag][1][8]["where"] = [("mss_system", "=", self.system)]
def doMes(self, frt, pag, r, c, p, i, w):
self.message = w
self.acc = self.sql.getRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)],
order="mss_message",
limit=1)
if not self.acc:
self.new = "Y"
self.df.loadEntry(frt, pag, p + 1, data="")
else:
self.new = "N"
self.detail = self.acc[2]
self.df.loadEntry(frt, pag, p + 1, data=self.detail)
def doDetail(self, frt, pag, r, c, p, i, w):
if len(w) > 150:
return "Invalid Message Length, Maximum 150 Characters"
def doDelete(self):
self.sql.delRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
wid, self.detail = self.df.getEntry("T", 0, 2)
if len(self.detail) > 150:
self.df.focusField(
"T",
0,
3,
err="Invalid Message Length, Maximum 150 Characters")
else:
data = [self.system, self.message, self.detail]
if self.new == "Y":
self.sql.insRec("ctlmes", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.ctlmes_col
data.append(self.acc[col.index("mss_xflag")])
self.sql.updRec("ctlmes",
data=data,
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class msy020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawScreen()
self.opts["mf"].startLoop()
def setVariables(self):
if self.opts["period"][0] == 0:
showError(self.opts["mf"].body, "Year-End Error",
"Period 0 Cannot be Changed, Change Period 1 Instead!")
return
self.sql = Sql(self.opts["mf"].dbm, "ctlynd",
prog=self.__class__.__name__)
if self.sql.error:
return
self.pers = self.sql.getRec("ctlynd", where=[("cye_cono", "=",
self.opts["conum"]), ("cye_period", ">=", self.opts["period"][0])],
order="cye_period")
if self.pers[0][self.sql.ctlynd_col.index("cye_final")] == "Y":
showError(self.opts["mf"].body, "Year-End Error",
"This Period Has Already Been Finalised")
return
self.s_per = self.pers[0][self.sql.ctlynd_col.index("cye_start")]
self.e_per = self.pers[0][self.sql.ctlynd_col.index("cye_end")]
self.m_per = self.getEndDate(self.s_per)
self.l_per = self.pers[-1][self.sql.ctlynd_col.index("cye_period")]
if self.opts["period"][0] == 1 and self.l_per > 1:
showError(self.opts["mf"].body, "Year-End Error",
"Period 1 Cannot be Changed as Periods > 1 Exist!")
return
return True
def getEndDate(self, date):
yr = int(date / 10000) + 1
mt = (int(date / 100) % 100) - 1
if not mt:
yr -= 1
mt = 12
return mthendDate(((yr * 10000) + (mt * 100) + 1))
def getStartDate(self, date):
yr = int(date / 10000)
mt = (int(date / 100) % 100) + 1
if mt > 12:
yr += 1
mt = 1
return ((yr * 10000) + (mt * 100) + 1)
def drawScreen(self):
fld = [
[("T",0,0,0),"I@cye_start",0,"","",
self.s_per,"N",self.doStartPer,None,None,("efld",)],
(("T",0,1,0),"I@cye_end",0,"","",
self.e_per,"N",self.doEndPer,None,None,("efld",))]
if self.opts["period"][0] != 1:
fld[0][1] = "O@cye_start"
fld[0][7] = None
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt, focus=True)
if self.opts["period"][0] != 1:
self.df.loadEntry("T", 0, 0, data=self.s_per)
def doStartPer(self, frt, pag, r, c, p, i, w):
y = int(w / 10000) - 1
m = int((w % 10000) / 100)
if m == 2:
if not y % 4:
d = 29
else:
d = 28
else:
d = w % 100
self.s0 = (y*10000) + (m*100) + d
self.s_per = w
def doEndPer(self, frt, pag, r, c, p, i, w):
if w <= self.s_per:
return "Invalid Date, Before Start"
if int(w / 100) - int(self.s_per / 100) - 87 > 15:
return "Invalid Date, More than 15 Months"
y = int(w / 10000) - 1
m = int((w % 10000) / 100)
if m == 2:
if not y % 4:
d = 29
else:
d = 28
else:
d = w % 100
self.e0 = (y*10000) + (m*100) + d
self.e_per = w
def doEnd(self):
self.df.closeProcess()
if self.opts["period"][0] == 1:
self.sql.updRec("ctlynd", cols=["cye_start", "cye_end"],
data=[self.s0, self.e0], where=[("cye_cono", "=",
self.opts["conum"]), ("cye_period", "=", 0)])
for per in self.pers:
num = per[self.sql.ctlynd_col.index("cye_period")]
if num == self.opts["period"][0]:
self.start = self.s_per
self.end = self.e_per
else:
self.start = self.getStartDate(self.end)
self.end = self.getEndDate(self.start)
self.sql.updRec("ctlynd", cols=["cye_start", "cye_end"],
data=[self.start, self.end], where=[("cye_cono", "=",
self.opts["conum"]), ("cye_period", "=", num)])
spl = SplashScreen(self.opts["mf"].body,
text="Running Year End Routine for Period %s" % num)
per = getPeriods(self.opts["mf"], self.opts["conum"], num - 1)
per = (num - 1, (per[0].work, per[0].disp), (per[1].work, per[1].disp))
callModule(self.opts["mf"], None, "msy010", coy=(self.opts["conum"],
self.opts["conam"]), period=per, user=self.opts["capnm"], args="N")
spl.closeSplash()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class tdc110(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, ["telgrp", "telmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("telgrp", ),
"cols": [("tdg_group", "", 0, "Code"),
("tdg_desc", "", 0, "Description")],
"order":
"tdg_desc"
}
self.fld = ((("T", 0, 0, 0), "I@tdg_group", 0, "", "", "", "N",
self.doGroup, grp, None, ("notblank", )),
(("T", 0, 1, 0), "I@tdg_desc", 0, "", "", "", "N", None,
None, self.doDelete, ("notblank", )))
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 doGroup(self, frt, pag, r, c, p, i, w):
self.group = w
self.acc = self.sql.getRec("telgrp",
where=[("tdg_group", "=", self.group)],
limit=1)
if not self.acc:
self.new = True
else:
self.new = False
des = self.acc[self.sql.telgrp_col.index("tdg_desc")]
self.df.loadEntry(frt, pag, p + 1, data=des)
def doDelete(self):
chk = self.sql.getRec("telmst",
cols=["tdm_group"],
where=[("tdm_group", "<>", "")])
if chk:
err = None
for c in chk:
d = c[0].split(",")
if self.group in d:
err = "Group In Use, Not Deleted"
if err:
return err
self.sql.delRec("telgrp", where=[("tdg_group", "=", self.group)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = []
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new:
self.sql.insRec("telgrp", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.telgrp_col
data.append(self.acc[col.index("tdg_xflag")])
self.sql.updRec("telgrp",
data=data,
where=[("tdg_group", "=", self.group)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bcc210(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", "bwlclb", "bwlflo"],
prog=self.__class__.__name__)
if self.sql.error:
return
acc = self.sql.getRec("bwlclb", where=[("bcc_code", "=",
self.opts["conum"])], limit=1)
if not acc:
self.sql.insRec("bwlclb", data=[self.opts["conum"],
self.opts["conam"]])
self.opts["mf"].dbm.commitDbase()
return True
def mainProcess(self):
clb = {
"stype": "R",
"tables": ("bwlclb",),
"cols": (
("bcc_code", "", 0, "Cod"),
("bcc_name", "", 0, "Name", "Y")),
"order": "bcc_name"}
fld = (
(("T",0,0,0),"I@bcc_code",0,"","",
"","Y",self.doClbCod,clb,None,("efld",)),
(("T",0,1,0),"I@bcc_name",0,"","",
"","N",self.doName,None,self.doDelete,("notblank",)))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt)
def doClbCod(self, frt, pag, r, c, p, i, w):
if not w:
self.club = getNextCode(self.sql, "bwlclb", "bcc_code", last=999)
self.df.loadEntry(frt, pag, p, data=self.club)
else:
self.club = w
self.old = self.sql.getRec("bwlclb", where=[("bcc_code", "=",
self.club)], limit=1)
if not self.old:
self.newclb = True
else:
self.newclb = False
for num, fld in enumerate(self.old[:-1]):
self.df.loadEntry(frt, pag, num, data=fld)
def doName(self, frt, pag, r, c, p, i, w):
if self.newclb:
chk = self.sql.getRec("bwlclb", where=[("bcc_name", "ilike", w)])
if chk:
return "A Club with this Name Already Exists"
def doDelete(self):
if self.newclb:
return
if self.club == self.opts["conum"]:
return "Cannot Delete Own Club"
error = False
for tab in (("bwlflo", "bfo_cono", "bfo_club"),):
chk = self.sql.getRec(tables=tab[0], where=[(tab[1], "=",
self.opts["conum"]), (tab[2], "=", self.club)], limit=1)
if chk:
error = True
break
if error:
return "There are Entries for this Club, Not Deleted"
self.sql.delRec("bwlclb", where=[("bcc_code", "=", self.club)])
self.opts["mf"].dbm.commitDbase()
def doEnd(self):
data = self.df.t_work[0][0][:]
if self.newclb:
self.sql.insRec("bwlclb", data=data)
elif data != self.old[:len(data)]:
col = self.sql.bwlclb_col
data.append(self.old[col.index("bcc_xflag")])
self.sql.updRec("bwlclb", data=data, where=[("bcc_code", "=",
self.club)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ln2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
lonctl = gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
glint = lonctl["cln_glint"]
tab = ["lonctl", "lonmf2", "lontrn"]
if glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["lon_ctl", "int_rec", "int_pay"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.glctl = (
ctlctl["lon_ctl"], ctlctl["int_rec"], ctlctl["int_pay"])
tab.append("gentrn")
else:
self.glctl = None
self.sql = Sql(self.opts["mf"].dbm, tables=tab,
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
yr = int(self.sysdtw / 10000)
mt = (int(self.sysdtw / 100) % 100) - 1
self.lme = mthendDate((yr * 10000) + (mt * 100) + 1)
return True
def dataHeader(self):
fld = (
(("T",0,0,0),"ID1",10,"Transaction Date","",
self.lme,"N",self.doTrdate,None,None,None),)
tnd = ((self.endPage0, "y"),)
txt = (self.exitPage0,)
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt)
def doTrdate(self, frt, pag, r, c, p, i, w):
self.trdate = 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(w):
return "Invalid Date, Not a Month End"
def endPage0(self):
self.df.closeProcess()
recs = self.sql.getRec("lonmf2", where=[("lm2_cono", "=",
self.opts["conum"]), ("lm2_start", "<", self.trdate)],
order="lm2_acno, lm2_loan")
p = ProgressBar(self.opts["mf"].body, mxs=len(recs))
for num, lonmf2 in enumerate(recs):
p.displayProgress(num)
batch = "L%s" % int(self.trdate / 100)
LoanInterest("L", self.opts["mf"].dbm, lonmf2, update="Y",
tdate=self.trdate, batch=batch, curdt=int(self.trdate / 100),
refno=True, glctl=self.glctl, capnm=self.opts["capnm"])
p.closeProgress()
self.sql.updRec("lonctl", cols=["cln_last"], data=[self.trdate],
where=[("cln_cono", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class mlc310(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"ctlmes",
prog=self.__class__.__name__)
if self.sql.error:
return
self.system = "MEM"
return True
def mainProcess(self):
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Mss"), ("mss_detail", "NA", 50,
"Details")),
"where": [("mss_system", "=", self.system)],
"order":
"mss_message"
}
self.fld = ((("T", 0, 0, 0), "IUI", 3, "Message Number", "", "", "N",
self.doMes, mss, None, ("notzero", )),
(("T", 0, 1, 0), "ITv", (30, 6), "Details", "", "", "N",
self.doDetail, None, self.doDelete, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doMes(self, frt, pag, r, c, p, i, w):
self.message = w
self.oldm = self.sql.getRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)],
order="mss_message",
limit=1)
if not self.oldm:
self.new = "Y"
self.df.loadEntry(frt, pag, p + 1, data="")
else:
self.new = "N"
self.detail = self.oldm[self.sql.ctlmes_col.index("mss_detail")]
self.df.loadEntry(frt, pag, p + 1, data=self.detail)
def doDetail(self, frt, pag, r, c, p, i, w):
if len(w) > 150:
return "Invalid Message Length, Maximum 150 Characters"
def doDelete(self):
self.sql.delRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
wid, self.detail = self.df.getEntry("T", 0, 1)
if len(self.detail) > 150:
self.df.focusField(
"T",
0,
2,
err="Invalid Message Length, Maximum 150 Characters")
else:
data = [self.system, self.message, self.detail]
if self.new == "Y":
self.sql.insRec("ctlmes", data=data)
elif data != self.oldm[:len(data)]:
col = self.sql.ctlmes_col
data.append(self.oldm[col.index("mss_xflag")])
self.sql.updRec("ctlmes",
data=data,
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class si6010(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, ["drsmst", "slsiv1"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
iv1 = {
"stype":
"R",
"tables": ("drsmst", "slsiv1"),
"cols":
(("si1_docno", "", 0, "Inv-Numbr"),
("si1_date", "", 0, "Invoice-Dt"), ("si1_chain", "", 0, "Chn"),
("si1_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name"),
("si1_cus_ord", "", 0, "Cust-Ord-Num")),
"where": [("si1_cono", "=", self.opts["conum"]),
("si1_rtn", "=", "I"), ("si1_invno", "<>", "cancel"),
("drm_cono=si1_cono", ), ("drm_chain=si1_chain", ),
("drm_acno=si1_acno", )],
"order":
"si1_docno"
}
fld = ((("T", 0, 0, 0), "IUI", 9, "Invoice Number", "", "", "Y",
self.doInvNum, iv1, None, ("notzero", )),
(("T", 0, 1, 0), "O@si1_date", 0,
""), (("T", 0, 2, 0), "O@si1_chain", 0,
""), (("T", 0, 3, 0), "O@si1_acno", 0,
""), (("T", 0, 4, 0), "O@drm_name", 0, ""),
(("T", 0, 5, 0), "I@si1_cus_ord", 0, "", "", "", "N",
self.doNewOrd, None, None, ("efld", )))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt)
def doInvNum(self, frt, pag, r, c, p, i, w):
whr = [("si1_cono", "=", self.opts["conum"]), ("si1_rtn", "=", "I"),
("si1_docno", "=", w), ("drm_cono=si1_cono", ),
("drm_chain=si1_chain", ), ("drm_acno=si1_acno", )]
acc = self.sql.getRec(tables=["slsiv1", "drsmst"],
cols=[
"si1_date", "si1_chain", "si1_acno",
"drm_name", "si1_cus_ord"
],
where=whr,
limit=1)
if not acc:
return "Invalid Invoice Number"
self.invno = w
for n, a in enumerate(acc):
self.df.loadEntry(frt, pag, p + 1 + n, data=a)
def doNewOrd(self, frt, pag, r, c, p, i, w):
self.ordno = w
def doEnd(self):
self.sql.updRec("slsiv1",
cols=["si1_cus_ord"],
data=[self.ordno],
where=[("si1_cono", "=", self.opts["conum"]),
("si1_rtn", "=", "I"),
("si1_docno", "=", self.invno)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class gl1030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
self.dep = ctlsys["sys_gl_dep"]
self.dig = ctlsys["sys_gl_dig"]
self.sql = Sql(self.opts["mf"].dbm, ["genmst", "genrpt"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.genrpt_fd = self.sql.genrpt_dic
self.genrpt_cl = self.sql.genrpt_col
self.pags = ["","Q","H","L","G","S","T","U","C","P"]
self.head = ["glr_desc", "glr_high", "glr_ffeed", "glr_ignore"]
self.ledger = [
"glr_from", "glr_to", "glr_high", "glr_obal", "glr_accum",
"glr_print", "glr_norm", "glr_acbal", "glr_ignore",
"glr_store", "glr_snum1", "glr_acstr"]
self.group = [
"glr_group", "glr_desc", "glr_from", "glr_to", "glr_high",
"glr_obal", "glr_accum", "glr_print", "glr_norm", "glr_acbal",
"glr_ignore", "glr_store", "glr_snum1", "glr_acstr", "glr_label"]
self.store = [
"glr_desc", "glr_high", "glr_print", "glr_norm", "glr_acbal",
"glr_clear", "glr_snum1", "glr_strper"]
self.total = [
"glr_desc", "glr_high", "glr_total", "glr_print", "glr_norm",
"glr_clear", "glr_store", "glr_snum1", "glr_acstr", "glr_label"]
self.uline = ["glr_high", "glr_uline"]
self.calc = [
"glr_desc", "glr_high", "glr_cbase", "glr_ctype", "glr_snum2",
"glr_camnt", "glr_snum3"]
self.percent = ["glr_desc", "glr_high", "glr_snum1", "glr_snum2"]
return True
def mainProcess(self):
data = [
("H","Heading"),
("L","Ledger Accounts"),
("G","Group of Accounts"),
("S","Stored Amount"),
("T","Total"),
("U","Underline"),
("C","Calculation"),
("P","Percentage")]
typ = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("T", "Description"),
"data": data}
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Description", "Y")),
"order": "ctm_cono"}
glr = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", "=", 0)],
"whera": (("T", "glr_cono", 0, 0),),
"order": "glr_cono, glr_repno",
"index": 1}
gls = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_seq", "", 0, "Seq"),
("glr_type", "", 0, "T"),
("glr_group", "", 0, "Grp"),
("glr_from", "", 0, "From-Ac"),
("glr_to", "", 0, " To-Ac"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", ">", 0)],
"whera": (("T", "glr_cono", 0, 0),("T", "glr_repno", 1, 0))}
self.glm = {
"stype": "C",
"titl": "Account Numbers",
"head": ("Number", "Description"),
"data": []}
ryn = (("Yes","Y"),("No","N"))
rys = (("Yes","Y"),("No","N"),("Debit","+"),("Credit","-"))
rns = (("Positive","P"),("Negative","N"))
ras = (("Add","A"),("Subtract","S"))
rat = (("Add","A"),("Subtract","S"),("Ignore","I"))
rcb = (("Percentage","P"),("Amount","A"),("Store","S"))
rct = (("Plus","+"),("Minus","-"),("Multiply","*"),("Divide","/"))
rsd = (("Single","S"),("Double","D"),("Blank","B"))
pts = (
"Accumulate Month Values",
"Add, Subtract or Ignore",
"Calculation Base",
"Calculation Type",
"Clear Stored Value",
"Clear Total",
"Highlight",
"Ignore Account Type",
"Include Opening Balance",
"Normal Sign",
"Percentage of Stored Value",
"Print Values",
"Store Amount",
"Add or Subtract")
tag = [
("Sequence",None,None,None,False),
("Heading",None,None,None,False),
("Ledger",None,None,None,False),
("Group",None,None,None,False),
("Stored",None,None,None,False),
("Total",None,None,None,False),
("Uline",None,None,None,False),
("Calc",None,None,None,False),
("Percent",None,None,None,False)]
fld = (
(("T",0,0,0),"IUI",3,"Company","Company Number, 0=All",
self.opts["conum"],"Y",self.doCoyNum,coy,None,
("in", (self.opts["conum"], 0))),
(("T",0,0,0),"IUI",3,"Report","Report Number",
"","N",self.doRepNum,glr,None,("notzero",)),
(("T",0,0,0),"IUA",1,"Type","Report Type (B, P, O)",
"P","N",self.doRepTyp,None,self.doDelRpt,
("in", ("O","P","B"))),
(("T",0,0,0),"INA",30,"Heading","Report Heading",
"","N",None,None,None,("notblank",)),
(("T",1,0,0),"IUD",7.2,"Seq-Num","Sequence Number",
"","N",self.doSeqNum,gls,None,("efld",)),
(("T",1,1,0),"IUA",1,"Sequence Type","",
"","N",self.doSeqType,typ,self.doDelSeq,
("in",("H","L","G","T","S","U","P","C"))),
(("T",2,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",2,1,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",2,2,0),("IRB",ryn),0,"New Page","New Page (Y/N)",
"N","N",None,None,None,None),
(("T",2,3,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",3,0,0),"IUI",7,"From Account","From Account Number",
"","N",self.doAcno,self.glm,None,("notzero",)),
(("T",3,1,0),"IUI",7,"To Account","To Account Number",
"","N",self.doAcno,self.glm,None,("efld",)),
(("T",3,2,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",3,3,0),("IRB",ryn),0,pts[8],"",
"Y","N",None,None,None,None),
(("T",3,4,0),("IRB",ryn),0,pts[0],"",
"N","N",None,None,None,None),
(("T",3,5,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",3,6,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",3,7,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",3,8,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",3,9,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",3,10,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",3,11,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",4,0,0),"IUI",3,"Group Number","",
"","N",self.doGrpNum,None,None,("efld",)),
(("T",4,1,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",4,2,0),"IUI",7,"From Account","From Account Number",
"","N",self.doAcno,self.glm,None,("notzero",)),
(("T",4,3,0),"IUI",7,"To Account","To Account Number",
"","N",self.doAcno,self.glm,None,("efld",)),
(("T",4,4,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",4,5,0),("IRB",ryn),0,pts[8],"",
"Y","N",None,None,None,None),
(("T",4,6,0),("IRB",ryn),0,pts[0],"",
"N","N",None,None,None,None),
(("T",4,7,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",4,8,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",4,9,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",4,10,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",4,11,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",4,12,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",4,13,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",4,14,0),"INA",10,"Chart Label","",
"","N",None,None,None,None),
(("T",5,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",5,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",5,2,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",5,3,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",5,4,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",5,5,0),("IRB",ryn),0,pts[4],"",
"N","N",None,None,None,None),
(("T",5,6,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",5,7,0),"IUD",6.2,pts[10],"",
0,"N",None,None,None,("notzero",)),
(("T",6,0,0),"INA",30,"Description","",
"","N",None,None,None,("efld",)),
(("T",6,1,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",6,2,0),"IUI",1,"Total Level","",
"","N",None,None,None,("between",1,9)),
(("T",6,3,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",6,4,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",6,5,0),("IRB",ryn),0,pts[5],"",
"Y","N",None,None,None,None),
(("T",6,6,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",6,7,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",6,8,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",6,9,0),"INA",10,"Chart Label","",
"","N",None,None,None,None),
(("T",7,0,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",7,1,0),("IRB",rsd),0,"Underline Type","",
"S","N",None,None,None,None),
(("T",8,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",8,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",8,2,0),("IRB",rcb),0,pts[2],"",
"A","N",self.doPAS,None,None,None),
(("T",8,3,0),("IRB",rct),0,pts[3],"",
"+","N",None,None,None,None),
(("T",8,4,0),"IUI",2,"Storage Number (Base)","",
"","N",self.doStore1,None,None,("notzero",)),
(("T",8,5,0),"ISD",13.2,"Amount","Percent/Amount",
"","N",self.doAmount,None,None,("efld",)),
(("T",8,6,0),"IUI",2,"Storage Number (Calc)","",
"","N",None,None,None,("efld",)),
(("T",9,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",9,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",9,2,0),"IUI",2,"Storage Number (Base)","",
"","N",None,None,None,("notzero",)),
(("T",9,3,0),"IUI",2,"Storage Number (Calc)","",
"","N",None,None,None,("notzero",)))
tnd = (
(self.doT0End,"y"), (self.doT1End,"n"), (self.doT2End,"y"),
(self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"),
(self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"),
(self.doT2End,"y"))
txt = (
self.doT0Exit, self.doT1Exit, self.doT2Exit, self.doT2Exit,
self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit,
self.doT2Exit, self.doT2Exit)
but = (
("Import",None,self.doImpRpt,0,("T",0,1),("T",0,2)),
("Export",None,self.doExpRpt,0,("T",0,3),(("T",0,2),("T",0,4))),
("Copy",None,self.doCpyRpt,0,("T",0,3),(("T",0,2),("T",0,4))),
("Re-Sequence",None,self.doReSeq,0,("T",1,1),("T",1,2),None,1),
("Preview",None,self.doPreview,0,("T",1,1),("T",1,2),None,1),
("Print",None,self.doPrint,0,("T",1,1),("T",1,2),None,1))
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt, tags=tag, butt=but)
def doCoyNum(self, frt, pag, r, c, p, i, w):
self.selcoy = w
if self.selcoy == 0:
acc = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], group="glm_acno, glm_desc", order="glm_acno")
else:
acc = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], where=[("glm_cono", "=", self.selcoy)],
group="glm_acno, glm_desc", order="glm_acno")
if self.dep == "Y":
dep = {}
chs = 10 ** (7 - self.dig)
for a in acc:
dep[a[0] % chs] = a[1]
acc = []
for a in dep:
acc.append([a, dep[a]])
acc.sort()
self.glm["data"] = acc
def doRepNum(self, frt, pag, r, c, p, i, w):
self.repno = w
rep = self.doReadRep(self.selcoy, self.repno, 0)
if not rep:
self.newrep = True
self.df.setWidget(self.df.B1, "normal")
else:
self.newrep = False
self.df.setWidget(self.df.B1, "disabled")
self.df.loadEntry(frt, pag, p+1, data=rep[3])
self.df.loadEntry(frt, pag, p+2, data=rep[4])
def doRepTyp(self, frt, pag, r, c, p, i, w):
self.df.setWidget(self.df.B1, "disabled")
def doImpRpt(self):
self.df.setWidget(self.df.B0, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
sel = FileDialog(parent=self.opts["mf"].body, title="Import File",
initd=self.opts["mf"].rcdic["wrkdir"], ftype=[("Report", "*.rpt")])
nam = sel.askopenfilename()
err = None
if nam:
fle = open(nam, "r")
for num, line in enumerate(fle):
dat = line.split("|")
if not num:
if dat[0] != "genrpt":
err = "This File Does Not Contain a Valid Format"
break
chk = self.sql.getRec("genrpt",
where=[("glr_cono", "=", dat[1]), ("glr_repno", "=",
dat[2]), ("glr_seq", "=", 0)], limit=1)
if chk:
ok = askQuestion(self.opts["mf"].body, "Replace?",
"This Report Already Exists, Would you like "\
"to Replace It?")
if ok == "yes":
self.sql.delRec("genrpt", where=[("glr_cono", "=",
dat[1]), ("glr_repno", "=", dat[2])])
else:
err = "Report Already Exists"
break
self.sql.insRec("genrpt", data=dat[1:])
else:
self.sql.insRec(dat[0], data=dat[1:])
if not err:
self.opts["mf"].dbm.commitDbase(ask=True)
else:
showError(self.opts["mf"].body, "Invalid Import", err)
self.df.setWidget(self.df.mstFrame, "show")
self.df.focusField("T", 0, 1)
def doExpRpt(self):
fle = open(os.path.join(self.opts["mf"].rcdic["wrkdir"],
"C%s_R%s.rpt" % (self.selcoy, self.repno)), "w")
rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq")
for lin in rpt:
mes = "genrpt"
for dat in lin:
mes = "%s|%s" % (mes, str(dat))
fle.write("%s\n" % mes)
fle.close()
self.df.focusField("T", 0, 1)
def doCpyRpt(self):
if not self.newrep:
showError(self.opts["mf"].body, "Invalid Copy Request",
"You can only Copy a report when Creating a New report, "\
"not when Changing an Existing report!")
self.df.focusField("T", 0, 3)
return
tit = ("Copy Existing Report Layout",)
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Name", "Y"))}
glr = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", "=", 0)],
"whera": (("T", "glr_cono", 0, 0),),
"index": 1}
fld = (
(("T",0,0,0),"IUI",3,"Company Number","",
"","N",self.doCpyCoy,coy,None,None),
(("T",0,1,0),"IUI",3,"Report Number","",
"","N",self.doRptNum,glr,None,None))
state = self.df.disableButtonsTags()
self.cp = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doCpyEnd, "n"),), txit=(self.doCpyExit,))
self.cp.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 0, 1)
def doCpyCoy(self, frt, pag, r, c, p, i, w):
self.cpycoy = w
def doRptNum(self, frt, pag, r, c, p, i, w):
self.cpynum = w
def doCpyEnd(self):
rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.cpycoy), ("glr_repno", "=", self.cpynum)])
if rpt:
for rec in rpt:
rec[0] = self.selcoy
rec[1] = self.repno
self.sql.insRec("genrpt", data=rec)
self.opts["mf"].dbm.commitDbase()
self.doCpyCloseProcess()
def doCpyExit(self):
self.doCpyCloseProcess()
def doCpyCloseProcess(self):
self.cp.closeProcess()
def doDelRpt(self):
self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doT0End(self):
rtype = self.df.t_work[0][0][2]
desc = self.df.t_work[0][0][3]
if self.newrep:
data = [self.selcoy, self.repno, 0, rtype, desc]
for x in range(5, len(self.genrpt_cl)):
if self.genrpt_fd[self.genrpt_cl[x]][2][1] in ("A", "a"):
data.append("")
else:
data.append(0)
self.sql.insRec("genrpt", data=data)
else:
self.sql.updRec("genrpt", cols=["glr_type", "glr_desc"],
data=[rtype, desc], where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno), ("glr_seq", "=", 0)])
self.df.selPage("Sequence")
self.df.focusField("T", 1, 1)
def doReSeq(self):
whr = [("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)]
recs = self.sql.getRec("genrpt", where=whr, order="glr_seq")
self.sql.delRec("genrpt", where=whr)
for seq, rec in enumerate(recs):
rec = list(rec)
rec[2] = float(seq)
self.sql.insRec("genrpt", data=rec)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPreview(self):
self.cols = [
("a", "Seq-Num", 7.2, "UD"),
("b", "T", 1, "UA"),
("c", "Grp", 3, "Na"),
("d", "Lvl", 3, "Na"),
("e", "Acc-Num", 7, "Na"),
("f", "Description", 30, "NA")]
self.data = []
self.newp = []
recs = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq")
pgp = 0
lsq = 0
rpc = self.sql.genrpt_col
for num, rec in enumerate(recs):
seq = rec[rpc.index("glr_seq")]
rtp = rec[rpc.index("glr_type")]
if rtp in ("B", "P", "O"):
self.titl = rec[rpc.index("glr_desc")]
continue
des = rec[rpc.index("glr_desc")]
prt = rec[rpc.index("glr_print")]
if prt == "N":
continue
if rtp == "H":
if rec[rpc.index("glr_ffeed")] == "Y":
self.data.append((seq, "N", "", "", "",
"---------- New Page ----------"))
elif lsq:
ptp = recs[lsq][rpc.index("glr_type")]
utp = recs[lsq][rpc.index("glr_uline")]
if ptp == "H" or (ptp == "U" and utp == "B"):
pass
else:
self.data.append((seq, "", "", "", "", ""))
self.data.append((seq, rtp, "", "", "", des))
self.data.append((seq, "", "", "", "", ""))
elif rtp == "L":
frm = rec[rpc.index("glr_from")]
too = rec[rpc.index("glr_to")]
whr = [("glm_cono", "=", self.selcoy)]
if too:
whr.append(("glm_acno", "between", frm, too))
else:
whr.append(("glm_acno", "=", frm))
accs = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], where=whr, order="glm_acno")
for acc in accs:
self.data.append((seq, rtp, "", "", acc[0], acc[1]))
elif rtp == "G":
grp = rec[rpc.index("glr_group")]
if not pgp or grp != pgp:
self.data.append((seq, rtp, grp, "", "", des))
pgp = grp
elif rtp == "T":
tot = rec[rpc.index("glr_total")]
self.data.append((seq, rtp, "", tot, "", des))
elif rtp == "S":
self.data.append((seq, rtp, "", "", "", des))
elif rtp == "U":
utp = rec[rpc.index("glr_uline")]
if utp == "B":
des = ""
elif utp == "S":
des = "-" * 30
else:
des = "=" * 30
self.data.append((seq, rtp, "", "", "", des))
else:
continue
lsq = num
self.pprt = False
self.sc = SelectChoice(self.opts["mf"].window, self.titl, self.cols,
self.data, sort=False, butt=(("Print", self.doPrePrt),))
if self.pprt:
cols = []
for col in self.cols:
cols.append([col[0], col[3], col[2], col[1], "y"])
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, "hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__,
tables=self.data, heads=[self.titl], cols=cols, ttype="D",
prtdia=(("Y","V"),("Y","N")))
self.df.setWidget(self.df.mstFrame, "show")
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 1, 1)
elif self.sc.selection:
self.df.doKeyPressed("T", 1, 0, self.sc.selection[1])
self.df.doKeyPressed("T", 1, 1, self.sc.selection[2])
else:
self.df.focusField("T", 1, 1)
def doPrePrt(self):
self.pprt = True
def doPrint(self):
table = ["genrpt"]
heads = ["General Ledger Report %s Layout" % self.repno]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, "hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=table,
heads=heads, where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno)], order="glr_seq asc",
prtdia=(("Y","V"), ("Y","N")))
self.df.setWidget(self.df.mstFrame, "show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSeqNum(self, frt, pag, r, c, p, i, w):
if not w:
acc = self.sql.getRec("genrpt", cols=["max(glr_seq)"],
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno)], limit=1)
if not acc:
w = 1
else:
w = int(acc[0] + 1)
self.df.loadEntry(frt, pag, i, data=w)
self.seqno = w
self.seq = self.doReadRep(self.selcoy, self.repno, self.seqno)
if not self.seq:
self.newseq = "y"
else:
self.newseq = "n"
self.df.loadEntry(frt, pag, p+1, data=self.seq[3])
def doSeqType(self, frt, pag, r, c, p, i, w):
self.stype = w
if self.newseq == "y":
return
if self.stype == self.seq[3]:
return
yn = askQuestion(self.opts["mf"].body, "Change Type?",
"Change the Type?", default="no")
if yn == "no":
return "No Change"
self.newseq = "c"
def doDelSeq(self):
if self.newseq == "y":
showError(self.opts["mf"].body, "Invalid Delete Request",
"You can only delete Existing report lines.")
return
self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno), ("glr_seq", "=", self.seqno)])
self.df.clearFrame("T", 1)
self.df.focusField("T", 1, 1)
return "nf"
def doT1End(self):
for x in range(2, 10):
self.df.clearFrame("T", x)
pag = self.pags.index(self.stype)
if self.newseq == "n":
cl = self.genrpt_cl
fld = self.doLoadTypes()
for x, f in enumerate(fld):
data = self.seq[cl.index(f)]
self.df.loadEntry("T", pag, x, data=data)
self.df.selPage(self.df.tags[pag - 1][0])
def doAcno(self, frt, pag, r, c, p, i, w):
if w:
if pag == 3 and p == 1 and w < self.df.t_work[pag][0][0]:
return "To Account Less Than From Account"
if pag == 4 and p == 3 and w < self.df.t_work[pag][0][2]:
return "To Account Less Than From Account"
found = False
for acc in self.glm["data"]:
if w == acc[0]:
found = True
if not found:
return "Invalid Account Number"
def doStore(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p+1, data=0)
self.df.loadEntry(frt, pag, p+2, data="")
return "sk2"
def doGrpNum(self, frt, pag, r, c, p, i, w):
if not w:
gno = self.sql.getRec("genrpt", cols=["max(glr_group)"],
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno), ("glr_type", "=", "G")], limit=1)
self.gno = gno[0] + 1
self.df.loadEntry(frt, pag, p, data=self.gno)
else:
self.gno = w
col = ["glr_desc", "glr_high", "glr_obal", "glr_accum",
"glr_print", "glr_norm", "glr_acbal", "glr_ignore",
"glr_store", "glr_snum1", "glr_acstr", "glr_label"]
grp = ""
for cc in col:
grp = "%s%s," % (grp, cc)
grp = grp[:-1]
self.grp = self.sql.getRec("genrpt", cols=col,
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno), ("glr_group", "=", self.gno)], group=grp)
if self.grp:
for n, f in enumerate(col):
data = self.grp[0][n]
self.df.loadEntry("T", pag, self.group.index(f), data=data)
def doPAS(self, frt, pag, r, c, p, i, w):
self.pas = w
if self.pas == "P":
self.df.loadEntry(frt, pag, p+1, data="*")
return "sk1"
def doStore1(self, frt, pag, r, c, p, i, w):
if self.pas == "S":
self.df.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doAmount(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doT2End(self):
ff = self.doLoadTypes()
data = [self.selcoy, self.repno, self.seqno, self.stype]
for nm, cl in enumerate(self.genrpt_cl):
if nm < 4:
continue
if cl in ff:
data.append(self.df.t_work[self.pags.index(self.stype)]
[0][ff.index(cl)])
elif self.genrpt_fd[cl][2][1] in ("A", "a"):
data.append("")
else:
data.append(0)
data.append("")
if self.newseq in ("c", "n"):
self.doDelSeq()
self.sql.insRec("genrpt", data=data)
if self.stype == "G" and self.grp:
grp = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno), ("glr_group",
"=", self.gno)], order="glr_seq")
for g in grp:
if g[2] == self.seqno:
continue
data[2] = g[2]
data[8] = g[8]
data[9] = g[9]
data[29] = g[29]
self.sql.updRec("genrpt", data=data, where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno), ("glr_group",
"=", self.gno), ("glr_seq", "=", g[2])])
self.doT2Exit()
if self.newseq == "y":
self.df.loadEntry("T", 1, 0, data=(self.seqno + 1))
else:
self.df.clearEntry("T", 1, 1)
self.df.clearEntry("T", 1, 2)
self.df.focusField("T", 1, 1)
def doLoadTypes(self):
if self.stype == "H":
fld = self.head
elif self.stype == "L":
fld = self.ledger
elif self.stype == "G":
fld = self.group
elif self.stype == "S":
fld = self.store
elif self.stype == "T":
fld = self.total
elif self.stype == "U":
fld = self.uline
elif self.stype == "C":
fld = self.calc
elif self.stype == "P":
fld = self.percent
return fld
def doT0Exit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doT1Exit(self):
# Check for duplicate group numbers
errmess = """Group Number %s at Sequence Line %s is Duplicated or is Not Contiguous i.e. All Group Lines Must Follow One Another!
Please Delete, or Correct This Line!"""
seq = self.sql.getRec("genrpt", cols=["glr_type", "glr_seq",
"glr_group"], where=[("glr_cono", "=", self.selcoy), ("glr_repno",
"=", self.repno)], order="glr_seq")
gp = []
lg = 0
for t, s, g in seq:
if t == "G":
if not lg and g in gp:
showError(
self.opts["mf"].body, "Group Error", errmess % (g, s))
self.df.loadEntry("T", 1, 0, data=s)
self.df.focusField("T", 1, 1)
return
if lg and lg != g:
if g in gp:
showError(self.opts["mf"].body, "Group Error",
errmess % (g, s))
self.df.loadEntry("T", 1, 0, data=s)
self.df.focusField("T", 1, 1)
return
lg = g
gp.append(g)
continue
if not lg:
lg = g
gp.append(g)
continue
else:
lg = 0
self.opts["mf"].dbm.commitDbase(ask=True, mess="Save All Changes?")
self.df.focusField("T", 0, 1)
def doT2Exit(self):
self.df.selPage("Sequence")
def doReadRep(self, coy, rep, seq):
rep = self.sql.getRec("genrpt", where=[("glr_cono", "=", coy),
("glr_repno", "=", rep), ("glr_seq", "=", seq)], limit=1)
return rep
class st2030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.exit = False
self.setPrinter()
if not self.exit:
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"genmst", "gentrn", "strgrp", "strmf1", "strmf2", "strtrn",
"strrcp"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.stk_soh = ctlctl["stk_soh"]
self.stk_susp = ctlctl["stk_susp"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if self.locs == "N":
self.loc = "1"
self.glnum = 0
return True
def setPrinter(self):
tit = ("Printer Selection", )
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=[],
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "P"))
self.opts["mf"].startLoop()
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.pr.closeProcess()
self.opts["mf"].closeLoop()
def dataHeader(self):
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [["C", "st1_group", 0, 0]],
"order":
"st1_group, st1_code",
"index":
1
}
stl = {
"stype":
"R",
"tables": ("strloc", "strmf2"),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Location", "Y")),
"where": [("srl_cono", "=", self.opts["conum"]),
("srl_loc=st2_loc", ), ("st2_cono=srl_cono", )],
"whera": [["C", "st2_group", 0], ["C", "st2_code", 1]],
"order":
"srl_loc",
"index":
0
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N",
self.doIss, None, None, ("notblank", )),
(("T", 0, 0, 0), "ID1", 10, "Date", "Issue Date", self.sysdtw,
"N", self.doDte, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "N",
self.doGroup, gpm, None, ("notblank", )),
[("C", 0, 0, 1), "INA", 20, "Product Code", "", "", "N",
self.doCode, stm, None, ("notblank", )],
(("C", 0, 0, 2), "ONA", 5, "U.O.I"),
(("C", 0, 0, 3), "IUA", 1, "L", "Location", "r", "N",
self.doLoc, stl, None, ("notblank", )),
(("C", 0, 0, 4), "ISD", 9.2, "Quantity", "", "", "N",
self.doQty, None, None, ("notzero", )),
(("C", 0, 0, 5), "OUD", 9.2, "Unit-Cost"),
(("C", 0, 0, 6), "OSD", 9.2, "Value")]
if self.glint == "Y":
fld.append(
(("C", 0, 0, 7), "IUI", 7, "G/L-Acc", "G/L Account Number",
self.stk_susp, "N", self.doGenAcc, glm, None, None))
fld.append((("C", 0, 0, 8), "ONA", 10, "Desc"))
fld.append((("C",0,0,9),"INA",(20,30),"Details","Transaction "\
"Details","","N",self.doTrnDet,None,None,None))
row = (15, )
tnd = ((self.endPage0, "n"), )
txt = (self.exitPage0, )
cnd = ((self.endPage1, "y"), )
cxt = (self.exitPage1, )
but = (("Reprint", None, self.doReprint, 0, ("T", 0, 1), None), )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
rows=row,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doIss(self, frt, pag, r, c, p, i, w):
self.iss = w
def doDte(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.dte = w
self.ddt = self.df.t_disp[pag][0][p]
self.curdt = int(self.dte / 100)
self.batno = "S%s" % self.curdt
def doGroup(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.group = w
def doCode(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_desc", "st1_type", "st1_uoi"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", w),
("st1_type", "<>", "X")],
limit=1)
if not acc:
return "Invalid or Redundant Code"
self.code = w
self.desc = acc[0]
self.gtype = acc[1]
self.df.loadEntry(frt, pag, p + 1, data=acc[2])
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("C", pag, p + 2, data=self.loc)
no = self.checkLoc()
if no:
return no
else:
return "sk2"
def doLoc(self, frt, pag, r, c, p, i, w):
self.loc = w
no = self.checkLoc()
if no:
return no
def checkLoc(self):
acc = self.sql.getRec("strmf2",
cols=["st2_bin"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location For This Product"
def doQty(self, frt, pag, r, c, p, i, w):
self.quant = w
if self.gtype == "R" and self.doRecipe():
return "ff2"
if self.extractCost():
return "rf"
self.df.loadEntry("C", pag, p + 1, data=self.ucost)
self.df.loadEntry("C", pag, p + 2, data=self.tcost)
def doRecipe(self):
self.recipe = self.sql.getRec("strrcp",
where=[("srr_cono", "=",
self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc)],
order="srr_rgroup, srr_rcode")
if not self.recipe:
err = "Invalid Recipe, No Items"
showError(self.opts["mf"].body, "Recipe Error", err)
return err
else:
return self.doRecChg()
def doRecChg(self):
# Display recipe items and allow editing of quantities etc.
data = []
for num, item in enumerate(self.recipe):
st1 = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", item[4]),
("st1_code", "=", item[5])],
limit=1)
err = False
if not st1:
err = "Invalid Stock Record in Recipe"
elif st1[0] == "X":
err = "Redundant Stock Record in Recipe"
if err:
showError(
self.opts["mf"].body, "Recipe Error", """%s!
Group: %s
Code: %s""" % (err, item[4], item[5]))
return err
data.append([num, item[4], item[5], st1[1], item[6]])
titl = "Recipe Items"
head = ("Seq", "Grp", "Product-Code", "Description", "Quantity")
lin = {
"stype": "C",
"titl": titl,
"head": head,
"typs": [("UI", 2), ("NA", 3), ("NA", 20), ("NA", 30),
("SD", 11.2)],
"data": data
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus(
"Select a Product to Edit or Exit to Continue")
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.recchg = chg.selection
self.doRecChanges()
self.doRecChg()
else:
self.df.enableButtonsTags(state=state)
def doRecChanges(self):
tit = ("Change Items", )
fld = ((("T", 0, 0, 0), "ONA", 3,
"Group"), (("T", 0, 1, 0), "ONA", 20,
"Code"), (("T", 0, 2, 0), "ONA", 30, "Description"),
(("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N",
self.doRecQty, None, None, ('notzero', )))
but = (("Delete", None, self.doRecDel, 1, None, None), )
self.rp = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=((self.doRecEnd, "n"), ),
txit=(self.doRecExit, ))
self.rp.loadEntry("T", 0, 0, data=self.recchg[1])
self.rp.loadEntry("T", 0, 1, data=self.recchg[2])
self.rp.loadEntry("T", 0, 2, data=self.recchg[3])
self.rp.loadEntry("T", 0, 3, data=self.recchg[4])
self.rp.focusField("T", 0, 4, clr=False)
self.rp.mstFrame.wait_window()
def doRecQty(self, frt, pag, r, c, p, i, w):
self.recqty = w
def doRecDel(self):
del self.recipe[int(self.recchg[0])]
self.doRecExit()
def doRecEnd(self):
self.recipe[int(self.recchg[0])][6] = self.recqty
self.doRecExit()
def doRecExit(self):
self.rp.closeProcess()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.glnum = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doTrnDet(self, frt, pag, r, c, p, i, w):
if not w:
self.trndet = self.desc
else:
self.trndet = w
def endPage0(self):
self.df.focusField("C", 0, 1)
def endPage1(self):
self.updateTables()
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitPage1(self):
if self.df.col != 1:
self.doPrintDoc(self.pr.repprt)
self.df.focusField("T", 0, 1)
def extractCost(self):
self.ucost = 0
self.tcost = 0
if self.gtype == "R":
for item in self.recipe:
quant = item[6] * self.quant
tcost = self.doCalCost(item[4], item[5], quant)
if tcost is None:
return "error"
self.tcost = float(ASD(self.tcost) + ASD(tcost))
else:
tcost = self.doCalCost(self.group, self.code, self.quant)
if tcost is None:
return "error"
self.tcost = tcost
self.ucost = round(self.tcost / self.quant, 2)
def updateTables(self):
if self.gtype == "R":
# Issue individual items
for item in self.recipe:
acc = self.sql.getRec("strmf1",
cols=["st1_desc"],
where=[("st1_cono", "=", item[0]),
("st1_group", "=", item[4]),
("st1_code", "=", item[5])],
limit=1)
if acc:
des = acc[0]
else:
des = "Unknown Description"
qty = item[6] * self.quant
tcost = self.doCalCost(item[4], item[5], qty, chk=False)
qty = float(ASD(0) - ASD(qty))
val = float(ASD(0) - ASD(tcost))
data = [
self.opts["conum"], item[4], item[5], self.loc, self.dte,
6, self.iss, self.batno, self.glnum, qty, val, 0,
self.curdt, des, 0, "", "", "STR", 0, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# Receive recipe item
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte,
5, self.iss, self.batno, self.glnum, self.quant, self.tcost, 0,
self.curdt, self.desc, 0, "", "", "STR", 0, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# Stores Ledger Transaction
qty = float(ASD(0) - ASD(self.quant))
val = float(ASD(0) - ASD(self.tcost))
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte, 2,
self.iss, self.batno, self.glnum, qty, val, 0, self.curdt,
self.desc, 0, "", "", "STR", 0, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
if self.glint == "N":
return
col = self.sql.gentrn_col
# General Ledger Control Transaction (Stock On Hand)
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.stk_soh),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.dte),
("glt_type", "=", 4),
("glt_refno", "=", self.iss),
("glt_batch", "=", self.batno)],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(val))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.stk_soh, self.curdt,
self.dte, 4, self.iss, self.batno, val, 0,
self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0
])
# General Ledger Transaction (Expense)
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.glnum),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.dte),
("glt_type", "=", 4),
("glt_refno", "=", self.iss),
("glt_batch", "=", self.batno)],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(self.tcost))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.glnum, self.curdt,
self.dte, 4, self.iss, self.batno, self.tcost,
0, self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0
])
def doCalCost(self, grp, code, qty, chk=True):
# Calculate cost price
icost, tcost, bal = getCost(self.sql,
self.opts["conum"],
grp,
code,
loc=self.loc,
qty=qty,
tot=True,
bal=True)
if chk and qty > bal[0]:
acc = self.sql.getRec("strmf1",
cols=["st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", grp),
("st1_code", "=", code)],
limit=1)
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="ExQty",
product=(grp, code, acc[0]))
if cf.flag == "no":
return
return tcost
def doReprint(self):
tit = ("Reprint Documents", )
data = self.sql.getRec("strtrn",
cols=["stt_ref1", "stt_trdt"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2)],
group="stt_ref1, stt_trdt",
order="stt_trdt, stt_ref1")
iss = {
"stype":
"R",
"tables": ("strtrn", ),
"cols": (("stt_ref1", "", 0, "Reference"), ("stt_trdt", "", 0,
"Date", "Y")),
"wtype":
"D",
"where":
data,
"screen":
self.opts["mf"].body,
"comnd":
self.doSelRec
}
isd = {
"stype": "R",
"tables": ("strtrn", ),
"cols": (("stt_trdt", "", 0, "Date"), ),
"where": [("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2)],
"whera": (("T", "stt_ref1", 0, 0), ),
"group": "stt_trdt",
"order": "stt_trdt",
"screen": self.opts["mf"].body
}
fld = ((("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N",
self.doRepIss, iss, None, ("notblank", )),
(("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N",
self.doRepDte, isd, None, ("notzero", )))
state = self.df.disableButtonsTags()
self.tx = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doRepEnd, "n"), ),
txit=(self.doRepExit, ),
view=("N", "V"),
mail=("Y", "N"))
self.tx.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSelRec(self, frt, pag, r, c, p, i, w):
self.tx.doKeyPressed(frt, pag, p, w[0])
self.tx.doKeyPressed(frt, pag, p + 1, w[1])
def doRepIss(self, frt, pag, r, c, p, i, w):
self.iss = w
def doRepDte(self, frt, pag, r, c, p, i, w):
self.dte = w
self.ddt = self.df.t_disp[pag][0][p]
acc = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2),
("stt_ref1", "=", self.iss),
("stt_trdt", "=", self.dte)],
limit=1)
if not acc[0]:
return "No Document Found"
def doRepEnd(self):
self.tx.closeProcess()
self.doPrintDoc(self.tx.repprt)
def doRepExit(self):
self.tx.closeProcess()
def doPrintDoc(self, repprt):
hds = [
"Goods Issued Notes",
"GIN Number: %s GIN Date: %s" % (self.iss, self.ddt)
]
tab = ["strmf1", "strtrn"]
col = [["stt_group", "UA", 3, "Grp", "y"],
["stt_code", "NA", 20, "Product-Code", "y"],
["stt_desc", "NA", 40, "Description", "y"],
["stt_loc", "UA", 1, "L", "y"],
["stt_qty", "SD", 11.2, "Quantity", "y", "y"],
["stt_cost", "SD", 11.2, "Price", "y", "y"]]
gtt = ["stt_cost"]
whr = [("stt_cono", "=", self.opts["conum"]),
("stt_type", "in", (2, 6)), ("stt_ref1", "=", self.iss),
("stt_trdt", "=", self.dte), ("st1_cono=stt_cono", ),
("st1_group=stt_group", ), ("st1_code=stt_code", ),
("st1_type", "<>", "R")]
odr = "stt_seq"
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"],
conum=self.opts["conum"],
conam=self.opts["conam"],
name=self.__class__.__name__,
tables=tab,
heads=hds,
cols=col,
gtots=gtt,
where=whr,
order=odr,
repprt=repprt)
self.df.setWidget(self.df.mstFrame, state="show")
class bkc310(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
self.taxdf = ctlmst["ctm_taxdf"]
bkmctl = gc.getCtl("bkmctl", self.opts["conum"])
if not bkmctl:
return
self.glint = bkmctl["cbk_glint"]
self.sql = Sql(
self.opts["mf"].dbm,
["ctlvmf", "genmst", "bkmmst", "bkmunm", "bkmrtm", "bkmrtt"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def drawDialog(self):
unm = {
"stype":
"R",
"tables": ("bkmunm", ),
"cols": [("bum_code", "", 0, "Code"),
("bum_desc", "", 0, "Description"),
("bum_room", "", 0, "Rms"), ("bum_maxg", "", 0, "Qty"),
("bum_dflt", "", 0, "Rte")],
"where": [("bum_cono", "=", self.opts["conum"])],
"whera": (("T", "bum_btyp", 0, 0), ),
"order":
"bum_btyp, bum_code"
}
if self.glint == "Y":
unm["cols"].append(("bum_slsa", "", 0, "Acc-Num"))
rte = {
"stype":
"R",
"tables": ("bkmrtm", ),
"cols":
(("brm_code", "", 0, "Cod"), ("brm_desc", "", 0, "Description"),
("brm_base", "", 0, "B")),
"where": [],
"order":
"brm_type, brm_code"
}
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"])]
}
r1s = (("Accomodation", "A"), ("Other", "O"))
self.fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Booking Type", "", "A",
"N", self.doBtype, None, None, None),
(("T", 0, 1, 0), "IUA", 6, "Unit Code", "", "", "N",
self.doUcode, unm, None, ("notblank", )),
(("T", 0, 2, 0), "ITX", 30, "Description", "", "", "N",
self.doUDesc, None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "IUI", 3, "Number of Rooms", "", 0, "N",
self.doURooms, None, None, ("efld", )),
(("T", 0, 4, 0), "IUI", 3, "Total Capacity", "", 0, "N",
None, None, None, ("notzero", )),
(("T", 0, 5, 0), "IUI", 3, "Default Rate", "", 0, "N",
self.doUrate, rte, None, ("notzero", )),
(("T", 0, 6, 0), "IUA", 1, "V.A.T. Code", "", self.taxdf,
"N", self.doVat, vtm, None, ("notblank", ))]
if self.glint == "Y":
self.fld.extend([(("T", 0, 7, 0), "IUI", 7, "Sales Account", "",
"", "N", self.doSales, glm, None, ("notzero", )),
(("T", 0, 7, 0), "ONA", 30, "")])
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 doBtype(self, frt, pag, r, c, p, i, w):
self.btyp = w
self.df.topf[0][5][8]["where"] = [("brm_cono", "=",
self.opts["conum"]),
("brm_type", "=", self.btyp)]
def doUcode(self, frt, pag, r, c, p, i, w):
self.ucod = w
self.unm = self.sql.getRec("bkmunm",
where=[("bum_cono", "=",
self.opts["conum"]),
("bum_btyp", "=", self.btyp),
("bum_code", "=", self.ucod)],
limit=1)
if not self.unm:
self.new = True
else:
self.new = False
des = self.unm[self.sql.bkmunm_col.index("bum_desc")]
rms = self.unm[self.sql.bkmunm_col.index("bum_room")]
qty = self.unm[self.sql.bkmunm_col.index("bum_maxg")]
vcd = self.unm[self.sql.bkmunm_col.index("bum_vatc")]
dfr = self.unm[self.sql.bkmunm_col.index("bum_dflt")]
sls = self.unm[self.sql.bkmunm_col.index("bum_slsa")]
self.df.loadEntry(frt, pag, p + 1, data=des)
self.df.loadEntry(frt, pag, p + 2, data=rms)
self.df.loadEntry(frt, pag, p + 3, data=qty)
self.df.loadEntry(frt, pag, p + 4, data=dfr)
self.df.loadEntry(frt, pag, p + 5, data=vcd)
if self.glint == "Y":
self.df.loadEntry(frt, pag, p + 6, data=sls)
des = self.getGenDesc(sls)
if not des:
self.df.loadEntry(frt,
pag,
p + 7,
data="Invalid Sales Code")
else:
self.df.loadEntry(frt, pag, p + 7, data=des[0])
def doUDesc(self, frt, pag, r, c, p, i, w):
self.udes = w
if self.btyp == "O":
self.urms = 0
self.df.loadEntry(frt, pag, p + 1, data=self.urms)
return "sk1"
def doURooms(self, frt, pag, r, c, p, i, w):
if self.btyp == "A" and not w:
return "Invalid Number of Rooms"
self.urms = w
def doUrate(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bkmrtm",
where=[("brm_cono", "=", self.opts["conum"]),
("brm_type", "=", self.btyp),
("brm_code", "=", w)],
limit=1)
if not acc:
return "Invalid Rate Code"
def doVat(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not vat:
return "Invalid VAT Code"
def doSales(self, frt, pag, r, c, p, i, w):
acc = self.getGenDesc(w)
if not acc:
return "Invalid Sales Code"
self.sales = w
self.df.loadEntry("T", 0, p + 1, data=acc[0])
def getGenDesc(self, acno):
return self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acno)],
limit=1)
def doDelete(self):
chk = self.sql.getRec("bkmrtt",
where=[("brt_cono", "=", self.opts["conum"]),
("brt_utype", "=", self.btyp),
("brt_ucode", "=", self.ucod)])
if chk:
return "Unit Used, Not Deleted"
self.sql.delRec("bkmunm",
where=[("bum_cono", "=", self.opts["conum"]),
("bum_btyp", "=", self.btyp),
("bum_code", "=", self.ucod)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if self.glint == "Y" and x == 8:
continue
data.append(self.df.t_work[0][0][x])
if self.glint == "N":
data.append(0)
if self.new:
self.sql.insRec("bkmunm", data=data)
elif data != self.unm[:len(data)]:
col = self.sql.bkmunm_col
data.append(self.unm[col.index("bum_xflag")])
self.sql.updRec("bkmunm",
data=data,
where=[("bum_cono", "=", self.opts["conum"]),
("bum_btyp", "=", self.btyp),
("bum_code", "=", self.ucod)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class lnc110(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 = ["lonctl", "tplmst", "chglog"]
if self.genleg:
tabs.extend(["ctlctl", "genmst"])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.acc = self.sql.getRec("lonctl",
where=[("cln_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [
self.opts["conum"], "N", "D", "A", "A", 0, 0, 0,
"statement_loan", "", ""
]
else:
self.new = False
if self.genleg:
self.ctl = [["lon_ctl", "Loans Control", 0],
["int_rec", "Interest Received", 0],
["int_pay", "Interest Paid", 0]]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
for num, ctl in enumerate(self.ctl):
if ctl[0] in ctlctl:
self.ctl[num][2] = ctlctl[ctl[0]]
return True
def drawDialog(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")),
"where": [("tpm_type", "=", "S"), ("tpm_system", "=", "LON")],
"order":
"tpm_tname"
}
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("Daily", "D"), ("Monthly", "M"))
r3s = (("Anniversary", "A"), ("Financial", "F"))
r4s = (("Annual", "A"), ("Bi-Annual", "B"))
if self.genleg:
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30,
"Description")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "",
self.acc[1], "N", self.doGlint, None, None, None),
(("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "",
self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 1, 0), "ONA", 30, ""),
(("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "",
self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "IUI", 7, self.ctl[2][1], "",
self.ctl[2][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 3, 0), "ONA", 30, "")]
seq = 4
else:
fld = []
seq = 0
fld.extend([
(("T", 0, seq, 0), ("IRB", r2s), 0, "Interest Method", "",
self.acc[2], "N", None, None, None, None),
(("T", 0, seq + 1, 0), ("IRB", r3s), 0, "Capitalisation Base", "",
self.acc[3], "N", None, None, None, None),
(("T", 0, seq + 2, 0), ("IRB", r4s), 0, "Capitalisation Freq", "",
self.acc[4], "N", None, None, None, None),
(("T", 0, seq + 3, 0), "IUD", 6.2, "Debit Rate", "", self.acc[5],
"N", None, None, None, ("efld", )),
(("T", 0, seq + 4, 0), "IUD", 6.2, "Credit Rate", "", self.acc[6],
"N", None, None, None, ("efld", )),
(("T", 0, seq + 5, 0), "Id1", 10.0, "Last Interest Date", "",
self.acc[7], "N", None, None, None, ("efld", )),
(("T", 0, seq + 6, 0), "INA", 20, "Statement Template", "",
self.acc[8], "N", self.doTplNam, tpm, None, ("efld", )),
(("T", 0, seq + 7, 0), "ITX", 50, "Email Address", "", self.acc[9],
"N", None, None, None, ("email", ))
])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 1), ("T", 0, 0)),
("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if not self.new:
s = 0
for n, f in enumerate(self.acc[1:-1]):
if not self.genleg and not n:
continue
self.df.loadEntry("T", 0, s, data=f)
s += 1
if n == 0:
for c in self.ctl:
self.df.loadEntry("T", 0, s, data=c[2])
s += 1
self.df.loadEntry("T", 0, s, data=self.getDes(c[2]))
s += 1
self.df.focusField("T", 0, 1, clr=False)
def doGlint(self, frt, pag, r, c, p, i, w):
if w == "N":
for x in range(1, 7):
self.df.loadEntry(frt, pag, p + x, data="")
return "sk6"
def doGenAcc(self, frt, pag, r, c, p, i, w):
des = self.getDes(w)
if not des:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=des)
def getDes(self, acno):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acno)],
limit=1)
if acc:
return acc[0]
else:
return ""
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "S"),
("tpm_system", "=", "LON")],
limit=1)
if not acc:
return "Invalid Template"
def doEnd(self):
data = [self.opts["conum"]]
if not self.genleg:
data.append("N")
for x, d in enumerate(self.df.t_work[0][0]):
if self.genleg and x < 7:
if x in (1, 3, 5):
y = int((x - 1) / 2)
chk = self.sql.getRec("ctlctl",
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])],
limit=1)
if chk:
self.sql.updRec("ctlctl",
cols=["ctl_conacc"],
data=[d],
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])])
else:
self.sql.insRec("ctlctl",
data=[
self.opts["conum"], self.ctl[y][0],
self.ctl[y][1], d, "", "N", "N"
])
elif x in (2, 4, 6):
continue
else:
data.append(d)
else:
data.append(d)
if self.new:
self.sql.insRec("lonctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.lonctl_col
data.append(self.acc[col.index("cln_xflag")])
self.sql.updRec("lonctl",
data=data,
where=[("cln_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=[
"lonctl", "U",
"%03i" % self.opts["conum"], col[num],
dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.doExit()
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bk2010(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,
tables=[
"bkmmst", "bkmcon", "bkmrtt", "bkmtrn", "bkmunm",
"ctlmst", "ctlvtf", "gentrn", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctl = gc.getCtl("ctlmst", self.opts["conum"])
if not ctl:
return
for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3",
"ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_taxdf",
"ctm_tel", "ctm_fax", "ctm_b_name", "ctm_b_ibt",
"ctm_b_acno", "ctm_logo"):
setattr(self, "%s" % col, ctl[col])
if self.ctm_logo and "LETTERHEAD" in os.environ:
self.ctm_logo = os.environ["LETTERHEAD"]
if not self.ctm_logo or not os.path.exists(self.ctm_logo):
self.ctm_logo = None
bkmctl = gc.getCtl("bkmctl", self.opts["conum"])
if not bkmctl:
return
self.glint = bkmctl["cbk_glint"]
self.tplnam = bkmctl["cbk_invtpl"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["vat_ctl", "bkm_ctl"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.vatctl = ctlctl["vat_ctl"]
self.bkmctl = ctlctl["bkm_ctl"]
t = time.localtime()
self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2])
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Booking Invoices (%s)" % self.__class__.__name__)
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "I"), ("tpm_system", "=", "BKM")],
"order":
"tpm_tname"
}
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("Singles", "S"), ("All", "A"))
fld = ((("T", 0, 0, 0), "Id1", 10, "Starting Date", "", 0, "Y",
self.doSDate, None, None, ("efld", )),
(("T", 0, 1, 0), "ID1", 10, "Ending Date", "", self.sysdtw, "Y",
self.doEDate, None, None, ("efld", )),
(("T", 0, 2, 0), ("IRB", r1s), 0, "Include Queries", "", "N",
"Y", self.doBkmQry, None, None,
None), (("T", 0, 3, 0), ("IRB", r2s), 0, "Bookings", "", "S",
"Y", self.doBkmDoc, None, None, None),
(("T", 0, 4, 0), "INA", 20, "Template Name", "", self.tplnam,
"N", self.doTplNam, tpm, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("N", "Y"))
def doSDate(self, frt, pag, r, c, p, i, w):
self.sdate = w
def doEDate(self, frt, pag, r, c, p, i, w):
self.edate = w
def doBkmQry(self, frt, pag, r, c, p, i, w):
self.bkmqry = w
def doBkmDoc(self, frt, pag, r, c, p, i, w):
self.bkmdoc = w
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "I"),
("tpm_system", "=", "BKM")],
limit=1)
if not acc:
return "Invalid Template Name"
self.tname = w
def doEnd(self):
self.df.closeProcess()
tab = ["bkmmst", "bkmcon", "bkmrtt"]
col = ["bkm_number", "bkc_sname", "bkc_names", "bkm_arrive"]
whr = [("bkm_cono", "=", self.opts["conum"])]
if self.bkmqry == "N":
whr.append(("bkm_state", "in", ("C", "S")))
else:
whr.append(("bkm_state", "in", ("C", "Q", "S")))
whr.extend([("bkm_arrive", "between", self.sdate, self.edate),
("bkc_cono=bkm_cono", ), ("bkc_ccode=bkm_ccode", ),
("brt_cono=bkm_cono", ), ("brt_number=bkm_number", ),
("brt_invno", "=", 0)])
grp = "bkm_number, bkm_arrive, bkm_ccode, bkc_sname, bkc_names"
odr = "bkm_arrive, bkm_ccode"
dic = {}
for c in col:
for t in tab:
d = getattr(self.sql, "%s_dic" % t)
if c in d:
dic[c] = d[c]
if self.bkmdoc == "S":
recs = self.sql.getRec(tables=tab,
cols=col,
where=whr,
group=grp,
order=odr)
recs = getSingleRecords(self.opts["mf"],
tab,
col,
dic=dic,
where=recs,
ttype="D")
else:
recs = self.sql.getRec(tables=tab,
cols=col,
where=whr,
group=grp,
order=odr)
docs = []
for rec in recs:
# Raise the Invoice
bkno = rec[0]
trdt = rec[3]
incamt = 0
vatamt = 0
curdt = int(trdt / 100)
batno = "B%s" % curdt
gls = {}
trns = self.sql.getRec("bkmrtt",
where=[("brt_cono", "=",
self.opts["conum"]),
("brt_number", "=", bkno),
("brt_invno", "=", 0)])
if not trns:
continue
invno = self.getRef(bkno)
for trn in trns:
utyp = trn[self.sql.bkmrtt_col.index("brt_utype")]
ucod = trn[self.sql.bkmrtt_col.index("brt_ucode")]
rcod = trn[self.sql.bkmrtt_col.index("brt_rcode")]
rbas = trn[self.sql.bkmrtt_col.index("brt_rbase")]
quan = trn[self.sql.bkmrtt_col.index("brt_quant")]
rate = trn[self.sql.bkmrtt_col.index("brt_arate")]
days = trn[self.sql.bkmrtt_col.index("brt_bdays")]
umst = self.sql.getRec("bkmunm",
where=[("bum_cono", "=",
self.opts["conum"]),
("bum_btyp", "=", utyp),
("bum_code", "=", ucod)],
limit=1)
vatc = umst[self.sql.bkmunm_col.index("bum_vatc")]
if not vatc:
vatc = self.ctm_taxdf
vrte = getVatRate(self.sql, self.opts["conum"], vatc, trdt)
if vrte is None:
vrte = 0.0
if rbas == "A":
inca = quan * days * rate
elif rbas == "B":
inca = quan * rate
elif rbas == "C":
inca = days * rate
else:
inca = rate
vata = round(inca * vrte / (100 + vrte), 2)
exca = float(ASD(inca) - ASD(vata))
incamt = float(ASD(incamt) + ASD(inca))
vatamt = float(ASD(vatamt) - ASD(vata))
if self.glint == "Y":
slsa = umst[self.sql.bkmunm_col.index("bum_slsa")]
if slsa not in gls:
gls[slsa] = [0, 0, vatc]
gls[slsa][0] = float(ASD(gls[slsa][0]) - ASD(exca))
gls[slsa][1] = float(ASD(gls[slsa][1]) - ASD(vata))
data = [
self.opts["conum"], bkno, 2, invno, batno, trdt, inca,
vata, curdt,
"Booking %s-%s Raised" % (utyp, ucod), vatc, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("bkmtrn", data=data)
self.sql.updRec("bkmrtt",
cols=["brt_vrate", "brt_invno", "brt_invdt"],
data=[vrte, invno, trdt],
where=[("brt_cono", "=", self.opts["conum"]),
("brt_number", "=", bkno),
("brt_utype", "=", utyp),
("brt_ucode", "=", ucod),
("brt_rcode", "=", rcod)])
if vata:
exc = float(ASD(0) - ASD(exca))
vat = float(ASD(0) - ASD(vata))
data = [
self.opts["conum"], vatc, "O", curdt, "B", 1, batno,
invno, trdt, bkno,
"Booking %s" % bkno, exc, vat, 0, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("ctlvtf", data=data)
if self.glint == "Y":
data = [
self.opts["conum"], self.bkmctl, curdt, trdt, 1, invno,
batno, incamt, 0,
"Booking %s" % bkno, "", "", 0, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
for acc in gls:
data = [
self.opts["conum"], acc, curdt, trdt, 1, invno, batno,
gls[acc][0], gls[acc][1],
"Booking %s" % bkno, gls[acc][2], "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if gls[acc][1]:
data = [
self.opts["conum"], self.vatctl, curdt, trdt, 1,
invno, batno, gls[acc][1], 0,
"Booking %s" % bkno, "", "", 0, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if invno not in docs:
docs.append(invno)
self.opts["mf"].dbm.commitDbase()
if docs:
PrintBookingInvoice(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
"I",
docs,
tname=self.tname,
repprt=self.df.repprt,
repeml=self.df.repeml,
copy="O")
self.doExit()
def getRef(self, bkno):
rec = self.sql.getRec("bkmtrn",
cols=["max(bkt_refno)"],
where=[("bkt_cono", "=", self.opts["conum"]),
("bkt_number", "=", bkno),
("bkt_refno", "like",
"%7s%s" % (bkno, "%"))],
limit=1)
if not rec or not rec[0]:
num = 1
else:
num = int(rec[0][-2:]) + 1
return "%7s%02i" % (bkno, num)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class drc610(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["drsact", "drsmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
act = {
"stype":
"R",
"tables": ("drsact", ),
"cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0,
"Description", "Y"))
}
self.fld = ((("T", 0, 0,
0), "IUA", 3, "Code", "Business Activity Code", "", "N",
self.doAct, act, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doAct(self, frt, pag, r, c, p, i, w):
self.code = w
self.acc = self.sql.getRec("drsact",
where=[("dac_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
desc = self.acc[self.sql.drsact_col.index("dac_desc")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
def doDelete(self):
acc = self.sql.getRec("drsmst",
cols=["count(*)"],
where=[("drm_bus_activity", "=", self.code)],
limit=1)
if acc[0]:
return "Code in Use, Not Deleted"
self.sql.delRec("drsact", where=[("dac_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = []
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("drsact", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.drsact_col
data.append(self.acc[col.index("dac_xflag")])
self.sql.updRec("drsact",
data=data,
where=[("dac_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bc6030(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", "bwlent", "bwlgme",
"bwlrnd", "bwltyp", "bwlpts", "bwlfls", "bwlflm", "bwlflt",
"bwlflo"], prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.today = ((t[0] * 10000) + (t[1] * 100) + t[2])
return True
def mainProcess(self):
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("No", "N"), ("All", "A"), ("Unplayed", "U"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Tabs-Inn","",
"N","Y",self.doTabs,None,None,None),
(("T",0,1,0),("IRB",r1s),0,"League","",
"N","N",self.doLeague,None,None,None),
(("T",0,2,0),("IRB",r2s),0,"Competition Entries","",
"N","N",self.doComps,None,None,None),
(("T",0,3,0),("IRB",r1s),0,"Competition Types","",
"N","N",self.doTypes,None,None,None))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt)
def doTabs(self, frt, pag, r, c, p, i, w):
self.tabs = w
def doLeague(self, frt, pag, r, c, p, i, w):
self.league = w
def doComps(self, frt, pag, r, c, p, i, w):
self.comps = w
def doTypes(self, frt, pag, r, c, p, i, w):
self.types = w
def doEnd(self):
self.df.closeProcess()
if self.tabs == "Y":
self.sql.delRec("bwldrm", where=[("bdm_cono", "=",
self.opts["conum"])])
self.sql.delRec("bwldrt", where=[("bdt_cono", "=",
self.opts["conum"])])
if self.league == "Y":
self.sql.delRec("bwlfls", where=[("bfs_cono", "=",
self.opts["conum"])])
self.sql.delRec("bwlflm", where=[("bfm_cono", "=",
self.opts["conum"])])
self.sql.delRec("bwlflt", where=[("bft_cono", "=",
self.opts["conum"])])
self.sql.delRec("bwlflo", where=[("bfo_cono", "=",
self.opts["conum"])])
delc = []
delt = []
if self.comps in ("A", "U"):
tabs = [
("bwlcmp", "bcm_cono", "bcm_code"),
("bwlcmp", "bcm_cono", "bcm_poff"),
("bwlent", "bce_cono", "bce_ccod"),
("bwlgme", "bcg_cono", "bcg_ccod"),
("bwlrnd", "bcr_cono", "bcr_ccod")]
whr = [("bcm_cono", "=", self.opts["conum"])]
if self.comps == "U":
whr.append(("bcm_date", "<=", self.today))
comps = self.sql.getRec("bwlcmp", cols=["bcm_code"],
where=whr, order="bcm_code")
if self.comps == "A":
for comp in comps:
delc.append(comp[0])
elif self.comps == "U":
col = ["sum(bcg_sfor)", "sum(bcg_sagt)",
"sum(bcg_points)"]
for comp in comps:
chk = self.sql.getRec("bwlgme", cols=col,
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", comp[0])], limit=1)
if not chk:
delc.append(comp[0])
continue
if not chk[0] and not chk[1] and not chk[2]:
delc.append(comp[0])
if delc:
for tab in tabs:
whr = [(tab[1], "=", self.opts["conum"])]
if self.comps == "U":
whr.append((tab[2], "in", delc))
self.sql.delRec(tab[0], where=whr)
if self.comps == "U":
# Renumber competitions
comps = self.sql.getRec("bwlcmp", where=[("bcm_cono",
"=", self.opts["conum"])], order="bcm_code")
self.sql.delRec("bwlcmp", where=[("bcm_cono", "=",
self.opts["conum"])])
for num, dat in enumerate(comps):
ccod = num + 1
nrec = dat[:]
nrec[1] = ccod
self.sql.insRec("bwlcmp", data=nrec)
for tab in tabs[1:]:
self.sql.updRec(tab[0], cols=[tab[2]], data=[ccod],
where=[(tab[1], "=", self.opts["conum"]),
(tab[2], "=", dat[1])])
if self.types == "Y":
typs = self.sql.getRec("bwltyp", cols=["bct_code"],
where=[("bct_cono", "=", self.opts["conum"])])
for typ in typs:
cnt = self.sql.getRec("bwlcmp", cols=["count(*)"],
where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_type", "=", typ[0])], limit=1)
if not cnt[0]:
delt.append(typ[0])
self.sql.delRec("bwltyp", where=[("bct_cono",
"=", self.opts["conum"]), ("bct_code",
"=", typ[0])])
self.sql.delRec("bwlpts", where=[("bcp_cono",
"=", self.opts["conum"]), ("bcp_code",
"=", typ[0])])
# Renumber types
types = self.sql.getRec("bwltyp", where=[("bct_cono",
"=", self.opts["conum"])], order="bct_code")
self.sql.delRec("bwltyp", where=[("bct_cono", "=",
self.opts["conum"])])
for num, dat in enumerate(types):
ctyp = num + 1
nrec = dat[:]
nrec[1] = ctyp
self.sql.insRec("bwltyp", data=nrec)
self.sql.updRec("bwlpts", cols=["bcp_code"],
data=[ctyp], where=[("bcp_cono", "=",
self.opts["conum"]), ("bcp_code", "=", dat[1])])
self.sql.updRec("bwlcmp", cols=["bcm_type"],
data=[ctyp], where=[("bcm_cono", "=",
self.opts["conum"]), ("bcm_type", "=", dat[1])])
if self.types == "Y" and delt:
mess = "Delete (%s) Types" % len(delt)
else:
mess = ""
if self.comps in ("A", "U") and delc:
mess = "%s\nDelete (%s) Competitions" % (mess, len(delc))
if delt or delc:
self.opts["mf"].dbm.commitDbase(ask=True, mess=mess)
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bc2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.nstart = bwlctl["ctb_nstart"]
self.fromad = bwlctl["ctb_emadd"]
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "bwlclb", "bwlflf", "bwlflm", "bwlflo", "bwltab",
"bwlfls", "bwlflt"
],
prog=self.__class__.__name__)
if self.sql.error:
return
acc = self.sql.getRec("bwlclb",
where=[("bcc_code", "=", self.opts["conum"])])
if not acc:
self.sql.insRec("bwlclb",
data=[self.opts["conum"], self.opts["conam"]])
self.opts["mf"].dbm.commitDbase()
self.reprint = False
self.fmat = 0
self.date = 0
self.skip = 0
return True
def mainProcess(self):
fmt = {
"stype":
"R",
"tables": ("bwlflf", ),
"cols": (("bff_code", "", 0, "Cod"), ("bff_desc", "", 0,
"Description", "Y")),
"where": [("bff_cono", "=", self.opts["conum"])]
}
sid = {
"stype":
"R",
"tables": ("bwlfls", ),
"cols":
(("bfs_code", "", 0, "Cod"), ("bfs_desc", "", 0, "Description",
"Y"), ("bfs_division", "", 0, "DV")),
"where": [("bfs_cono", "=", self.opts["conum"]),
("bfs_active", "=", "Y")],
"whera": [("T", "bfs_fmat", 0, 0)],
"order":
"bfs_desc"
}
opp = {
"stype":
"R",
"tables": ("bwlflo", ),
"cols": (("bfo_code", "", 0, "Cod"), ("bfo_desc", "", 0,
"Description", "Y")),
"where": [("bfo_cono", "=", self.opts["conum"])],
"whera": [("T", "bfo_fmat", 0, 0)],
"order":
"bfo_desc"
}
self.plr = {
"stype":
"R",
"tables": ("bwltab", ),
"cols":
(("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names")),
"where": [],
"order":
"btb_surname, btb_names"
}
r1s = (("Fixture", "F"), ("Practice", "P"))
fld = ((("T", 0, 0, 0), "I@bfm_fmat", 0, "", "", "", "Y", self.doFmat,
fmt, None, ("efld", )), (("T", 0, 0, 0), "ONA", 30, ""),
(("T", 0, 1,
0), ("IRB", r1s), 0, "Type", "", "F", "N", self.doType, None,
None, None), (("T", 0, 2, 0), "I@bfm_date", 0, "", "", "", "N",
self.doDate, None, None, ("efld", )),
(("T", 0, 3, 0), "I@bfm_round", 0, "", "", "", "N",
self.doRound, None, None, ("notzero", )),
(("T", 0, 4, 0), "I@bfm_team", 0, "", "", "", "N", self.doSide,
sid, None, None), (("T", 0, 4, 0), "ONA", 20, ""),
(("T", 0, 5, 0), "I@bfm_opps", 0, "", "", "", "N", self.doOpp,
opp, None, None), (("T", 0, 5, 0), "ONA", 30, ""),
(("T", 0, 6, 0), "I@bfm_venue", 0, "Venue (H/A/Name)", "", "",
"N", self.doVenue, None, None,
("efld", )), (("T", 0, 7, 0), "IUD", 5.2, "Meeting Time", "",
"", "N", self.doMTime, None, None, ("efld", )),
(("T", 0, 7, 0), "INA", 20, " At (H/A/Name)", "", "H", "N",
self.doMPlace, None, None,
("efld", )), (("T", 0, 8, 0), "I@bfm_captain", 0, "", "", "",
"N", self.doCaptain, self.plr, None,
("notzero", )), (("T", 0, 8, 0), "ONA", 30, ""),
(("C", 0, 0, 1), "I@bft_skip", 0, "Skp", "", "", "N",
self.doSkip, self.plr, None,
("notzero", )), (("C", 0, 0, 2), "ONA", 20,
""), (("C", 0, 0, 3), "I@bft_player", 0,
"3rd", "", "", "N", self.doPlayer,
self.plr, None, ("notzero", )),
(("C", 0, 0, 4), "ONA", 20,
""), (("C", 0, 0, 5), "I@bft_player", 0, "2nd", "", "", "N",
self.doPlayer, self.plr, None,
("notzero", )), (("C", 0, 0, 6), "ONA", 20, ""),
(("C", 0, 0, 7), "I@bft_player", 0, "1st", "", "", "N",
self.doPlayer, self.plr, None, ("notzero", )), (("C", 0, 0, 8),
"ONA", 20, ""))
but = (("Quit", None, self.doQuit, 1, None, None), )
tnd = ((self.doEnd, "n"), )
txt = (self.doExit, )
cnd = ((self.doEnd, "n"), )
cxt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
rows=[3],
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doFmat(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlflf",
where=[("bff_cono", "=", self.opts["conum"]),
("bff_code", "=", w)],
limit=1)
if not acc:
return "Invalid Format"
self.fmat = w
self.fdes = acc[self.sql.bwlflf_col.index("bff_desc")].upper()
self.plr["where"] = [("btb_cono", "=", self.opts["conum"]),
("btb_tab", "<", self.nstart)]
gndr = acc[self.sql.bwlflf_col.index("bff_gender")]
if gndr in ("F", "M"):
self.plr["where"].append(("btb_gender", "=", gndr))
self.assess = acc[self.sql.bwlflf_col.index("bff_assess")]
self.df.loadEntry(frt, pag, p + 1, data=self.fdes)
def doType(self, frt, pag, r, c, p, i, w):
self.ftyp = w
def doDate(self, frt, pag, r, c, p, i, w):
self.date = w
self.disp = "%i %s %i" % (w % 100, mthnam[int(w / 100) % 100][1],
int(w / 10000))
acc = self.sql.getRec("bwlflt",
cols=["sum(bft_shotsf)"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date)],
limit=1)
self.reprint = False
if acc[0]:
self.reprint = True
return "xt"
if acc[0] == 0:
# Edit
acc = self.sql.getRec("bwlflm",
cols=["bfm_round"],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date)],
limit=1)
self.rnd = acc[0]
else:
# New
acc = self.sql.getRec("bwlflm",
cols=["max(bfm_date)", "max(bfm_round)"],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp)],
limit=1)
if not acc[0] or dateDiff(acc[0], self.date, ptype="months") > 6:
self.rnd = 1
else:
self.rnd = acc[1] + 1
self.df.loadEntry(frt, pag, p + 1, data=self.rnd)
def doRound(self, frt, pag, r, c, p, i, w):
if w != self.rnd:
ok = askQuestion(self.opts["mf"].body,
"Round Change",
"The Round Has Been Changed, Please Confirm",
default="no")
if ok == "no":
return "Invalid Round Number"
self.sql.updRec("bwlflm",
cols=["bfm_round"],
data=[w],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date)])
self.rnd = w
def doSide(self, frt, pag, r, c, p, i, w):
if not w:
if askQuestion(self.opts["mf"].body, "New Side",
"Do You Want to Enter a New Side") == "yes":
w = self.enterNewSide()
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("bwlfls",
cols=["bfs_desc", "bfs_number"],
where=[("bfs_cono", "=", self.opts["conum"]),
("bfs_fmat", "=", self.fmat),
("bfs_code", "=", w),
("bfs_active", "=", "Y")],
limit=1)
if not acc:
return "Invalid Side"
self.team = w
self.qty = acc[1]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
acc = self.sql.getRec(tables=["bwlflm", "bwlfls", "bwlflo", "bwltab"],
cols=[
"bfo_code", "bfo_desc", "bfm_venue",
"bfm_mtime", "bfm_mplace", "bfm_captain",
"btb_surname", "btb_names"
],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_date", "=", self.date),
("bfm_team", "=", self.team),
("bfs_cono=bfm_cono", ),
("bfs_fmat=bfm_fmat", ),
("bfs_code=bfm_team", ),
("bfo_cono=bfm_cono", ),
("bfo_fmat=bfm_fmat", ),
("bfo_code=bfm_opps", ),
("btb_cono=bfm_cono", ),
("btb_tab=bfm_captain", )],
limit=1)
if acc:
self.opp = acc[0]
self.venue = acc[2]
self.mtime = acc[3]
self.mplace = acc[4]
self.captain = acc[5]
for x in range(6):
self.df.loadEntry(frt, pag, p + x + 2, data=acc[x])
self.df.loadEntry(frt,
pag,
p + 8,
data=self.getName(acc[6], acc[7]))
self.loadPlayers()
else:
for x in range(c + 2, c + 9):
self.df.clearEntry("T", 0, x)
self.df.clearFrame("C", 0)
# Get previous captain
acc = self.sql.getRec(
tables=["bwlflm", "bwltab"],
cols=["bfm_captain", "btb_surname", "btb_names"],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_team", "=", self.team), ("btb_cono=bfm_cono", ),
("btb_tab=bfm_captain", )],
order="bfm_date desc",
limit=1)
if acc:
self.df.loadEntry("T", 0, 12, data=acc[0])
self.df.loadEntry("T",
0,
13,
data=self.getName(acc[1], acc[2]))
# Get previous team members
col = ["bft_date", "bft_player", "btb_surname", "btb_names"]
odr = "bft_date desc, bft_skip, bft_position"
acc = self.sql.getRec(tables=["bwlflt", "bwltab"],
cols=col,
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_team", "=", self.team),
("btb_cono=bft_cono", ),
("btb_tab=bft_player", )],
order=odr)
if acc:
date = acc[0][0]
for num, data in enumerate(acc):
if data[0] != date:
break
pos = num * 2
self.df.loadEntry("C", 0, pos, data=data[1])
self.df.loadEntry("C",
0,
pos + 1,
data=self.getName(data[2], data[3]))
def doOpp(self, frt, pag, r, c, p, i, w):
if not w:
if askQuestion(self.opts["mf"].body, "New Opponent",
"Do You Want to Enter a New Opponent") == "yes":
w = self.enterNewOpp()
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("bwlflm",
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_date", "=", self.date),
("bfm_opps", "=", w),
("bfm_team", "<>", self.team)],
limit=1)
if acc:
return "Invalid Opposition, Already Selected"
acc = self.sql.getRec("bwlflo",
cols=["bfo_desc"],
where=[("bfo_cono", "=", self.opts["conum"]),
("bfo_fmat", "=", self.fmat),
("bfo_code", "=", w)],
limit=1)
if not acc:
return "Invalid Opposition"
self.opp = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def loadPlayers(self):
acc = self.sql.getRec(tables=["bwlflt", "bwltab"],
cols=["bft_player", "btb_surname", "btb_names"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_team", "=", self.team),
("btb_cono=bft_cono", ),
("btb_tab=bft_player", )],
order="bft_skip, bft_position")
if acc:
for num, name in enumerate(acc):
pos = num * 2
self.df.loadEntry("C", 0, pos, data=name[0])
self.df.loadEntry("C",
0,
pos + 1,
data=self.getName(name[1], name[2]))
def doVenue(self, frt, pag, r, c, p, i, w):
w = w.strip()
if len(w.strip()) == 1:
w = w.upper()
if w not in ("A", "H"):
return "Invalid Venue"
self.venue = w
self.df.loadEntry(frt, pag, p, data=self.venue)
if not self.df.t_work[0][0][p + 1]:
if self.venue == "H":
self.df.loadEntry(frt, pag, p + 1, data=1.30)
else:
self.df.loadEntry(frt, pag, p + 1, data=1.15)
def doMTime(self, frt, pag, r, c, p, i, w):
self.mtime = w
def doMPlace(self, frt, pag, r, c, p, i, w):
w = w.strip()
if len(w.strip()) == 1:
w = w.upper()
if w not in ("A", "H"):
return "Invalid Place"
self.mplace = w
self.df.loadEntry(frt, pag, p, data=self.mplace)
def doCaptain(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab"
self.captain = w
self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1]))
def doSkip(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab"
self.skip = w
self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1]))
def doPlayer(self, frt, pag, r, c, p, i, w):
if w == self.skip:
return "Invalid Player, This is the Skip"
acc = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab"
self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1]))
def enterNewSide(self):
tit = ("New Side", )
lge = (("Main", "M"), ("Friendly", "F"))
fld = ((("T", 0, 0, 0), "I@bfs_desc", 0, "", "", "", "N", None, None,
None, ("notblank", )), (("T", 0, 1, 0), ("IRB",
lge), 0, "League", "",
"M", "N", None, None, None, None),
(("T", 0, 2,
0), "I@bfs_division", 0, "", "", "", "N", None, None, None,
("notblank", )), (("T", 0, 3, 0), "I@bfs_number", 0, "", "",
"", "N", None, None, None, ("notzero", )))
state = self.df.disableButtonsTags()
self.new = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doSideEnd, "y"), ),
txit=(self.doSideExit, ))
self.new.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return self.team
def doSideEnd(self):
team = self.sql.getRec("bwlfls",
cols=["max(bfs_code)"],
where=[("bfs_cono", "=", self.opts["conum"]),
("bfs_fmat", "=", self.fmat)],
limit=1)
if not team[0]:
self.team = 1
else:
self.team = team[0] + 1
self.sql.insRec("bwlfls",
data=[self.opts["conum"], self.fmat, self.team] +
self.new.t_work[0][0] + ["Y"])
self.opts["mf"].dbm.commitDbase()
self.new.closeProcess()
def doSideExit(self):
self.team = 0
self.new.closeProcess()
def enterNewOpp(self):
tit = ("New Opponent", )
clb = {
"stype": "R",
"tables": ("bwlclb", ),
"cols":
(("bcc_code", "", 0, "Cod"), ("bcc_name", "", 0, "Name", "Y"))
}
fld = ((("T", 0, 0, 0), "I@bcc_code", 0, "", "", "", "N",
self.doClubCode, clb, None, ("efld", )),
(("T", 0, 0, 0), "I@bcc_name", 0, "", "", "", "N",
self.doClubDesc, None, None, ("notblank", )),
(("T", 0, 1, 0), "I@bfo_desc", 0, "", "", "", "N", None, None,
None, ("notblank", )))
state = self.df.disableButtonsTags()
self.nop = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doOppEnd, "y"), ),
txit=(self.doOppExit, ))
self.nop.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return self.opp
def doClubCode(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlclb", where=[("bcc_code", "=", w)], limit=1)
if acc:
self.nop.loadEntry(frt, pag, p + 1, data=acc[1])
return "sk1"
def doClubDesc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlclb", where=[("bcc_name", "=", w)], limit=1)
if acc:
self.nop.loadEntry(frt, pag, p - 1, data=acc[0])
else:
self.club = getNextCode(self.sql, "bwlclb", "bcc_code", last=999)
self.nop.loadEntry(frt, pag, p - 1, data=self.club)
self.sql.insRec("bwlclb", data=[self.club, w])
self.opts["mf"].dbm.commitDbase()
def doOppEnd(self):
opp = self.sql.getRec("bwlflo",
where=[("bfo_cono", "=", self.opts["conum"]),
("bfo_fmat", "=", self.fmat),
("bfo_desc", "=",
self.nop.t_work[0][0][2])],
limit=1)
if opp:
self.opp = opp[1]
else:
opp = self.sql.getRec("bwlflo",
cols=["max(bfo_code)"],
where=[("bfo_cono", "=", self.opts["conum"]),
("bfo_fmat", "=", self.fmat)],
limit=1)
if not opp[0]:
self.opp = 1
else:
self.opp = opp[0] + 1
self.sql.insRec("bwlflo",
data=[
self.opts["conum"], self.fmat, self.opp,
self.nop.t_work[0][0][0],
self.nop.t_work[0][0][2]
])
self.opts["mf"].dbm.commitDbase()
self.nop.closeProcess()
def doOppExit(self):
self.opp = 0
self.nop.closeProcess()
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
elif self.df.row == (self.qty - 1):
self.doUpdate()
else:
self.df.advanceLine(0)
def doUpdate(self):
self.sql.delRec("bwlflm",
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date),
("bfm_team", "=", self.team)])
self.sql.insRec("bwlflm",
data=[
self.opts["conum"], self.fmat, self.ftyp,
self.date, self.rnd, self.team, self.opp,
self.venue, self.mtime, self.mplace, self.captain
])
self.sql.delRec("bwlflt",
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_team", "=", self.team)])
for x in range(self.qty):
for y in range(4):
data = [
self.opts["conum"], self.fmat, self.ftyp, self.date,
self.team, self.df.c_work[0][x][0],
self.df.c_work[0][x][y * 2], y + 1, 0, 0, 0, 0, 0, 0, 0, ""
]
acc = self.sql.getRec("bwlflt",
where=[("bft_cono", "=", data[0]),
("bft_fmat", "=", data[1]),
("bft_type", "=", data[2]),
("bft_date", "=", data[3]),
("bft_team", "=", data[4]),
("bft_player", "=", data[6])],
limit=1)
if acc:
showError(
self.opts["mf"].body, "Duplicate",
"Player Code %s is Entered More than Once" % data[6])
self.df.focusField("C", 0, 1)
self.opts["mf"].dbm.rollbackDbase()
return
self.sql.insRec("bwlflt", data=data)
for x in range(6, 15):
self.df.clearEntry("T", 0, x)
self.df.clearFrame("C", 0)
self.df.skip = [[1, 2, 3, 4, 5]]
self.df.focusField("T", 0, 6)
def doExit(self):
if self.df.frt == "C":
self.df.focusField("C", 0, self.df.col)
return
if not self.fmat or not self.date:
self.df.closeProcess()
self.opts["mf"].closeLoop()
return
plrs = {}
acc = self.sql.getRec(
"bwlflt",
cols=["bft_player", "bft_team", "bft_skip", "bft_position"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp),
("bft_date", "=", self.date)],
order="bft_player")
for a in acc:
if a[0] in plrs:
showError(
self.opts["mf"].body, "Duplicate",
"Player Code %s is in Team Codes %s and %s" %
(a[0], plrs[a[0]][0], a[1]))
self.df.focusField("T", 0, 6)
return
else:
plrs[a[0]] = [a[1], a[2], a[3]]
self.df.closeProcess()
if not self.reprint:
self.opts["mf"].dbm.commitDbase()
ok = askQuestion(self.opts["mf"].body, "Print",
"Do You Want to View/Print the Selections")
if ok == "yes":
self.doPrintSelection()
self.opts["mf"].closeLoop()
def doPrintSelection(self):
fld = ((("T", 0, 0, 0), "INA", 70, "Note-Line-1", "", "", "N", None,
None, None, ("efld", )),
(("T", 0, 1, 0), "INA", 70, "Note-Line-2", "", "", "N", None,
None, None, ("efld", )))
self.pr = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
tend=((self.doPrint, "y"), ),
txit=None,
view=("N", "V"),
mail=("Y", "N"))
self.pr.mstFrame.wait_window()
def doPrint(self):
self.pr.closeProcess()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
"select_%s" % self.date,
ext="pdf")
fpdf = MyFpdf(name=self.__class__.__name__, head=90)
cw = fpdf.get_string_width("X") # character width
ld = 4.5 # line depth
fm = {
"margins": ((10, 80), (5, 12.5)), # left, right, top, bottom
"repeat": (1, 5), # repeat across and below
"rows": ( # x, y, w, h, fill, text, qty
(10, 5, 80, 1.5, .8),
(10, 6.5, ((10, 1.5, .9, ("Skip", "Third", "Second", "Lead")),
(23, 1.5), (23, 1.5), (24, 1.5)), 4), (10, 12.5, 80,
1.5))
}
ff = {
"margins": ((10, 80), ((5, 15))), # left, right, top, bottom
"repeat": (1, 3), # repeat across and below
"rows": ( # x, y, w, h, fill, text, qty
(10, 5, 80, 2, .8), (10, 7, ((10, 2, .9, ("Skip", "Third",
"Second", "Lead")),
(70, 2)), 4), (10, 15, 80, 2))
}
for div in ("Main", "Friendly"):
whr = [("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date)]
if div == "Main":
ppad = 1
rr = fm
if self.ftyp == "P":
ftyp = "PRACTICE"
else:
ftyp = "FIXTURE"
h1 = "TEAMS FOR %s %s - %s %s %s" % (
self.fdes, ftyp, self.date % 100, mthnam[int(
self.date / 100) % 100][1], int(self.date / 10000))
whr.append(("bfs_league", "=", "M"))
else:
ppad = 1.5
rr = ff
h1 = "TEAMS FOR %s FRIENDLY - %s %s %s" % (
self.fdes, self.date % 100, mthnam[int(
self.date / 100) % 100][1], int(self.date / 10000))
whr.append(("bfs_league", "=", "F"))
whr.extend([("bfs_cono=bfm_cono", ), ("bfs_fmat=bfm_fmat", ),
("bfs_code=bfm_team", ), ("bfo_cono=bfm_cono", ),
("bfo_fmat=bfm_fmat", ), ("bfo_code=bfm_opps", ),
("bcc_code=bfo_club", )])
games = self.sql.getRec(
tables=["bwlflm", "bwlfls", "bwlflo", "bwlclb"],
cols=[
"bfm_round", "bfm_team", "bfs_desc", "bfo_desc",
"bfm_venue", "bfm_mtime", "bfm_mplace", "bfm_captain",
"bcc_name", "bfs_number"
],
where=whr,
order="bfm_team")
if not games:
continue
fpdf.add_page()
if games[0][0] == 0:
h1 = h1.replace("FIXTURE", "PRACTICE")
totp = 0
for game in games:
if totp < game[9]:
totp = game[9] * 4
# Draw headings
fpdf.drawText(x=0,
y=1 * ld,
w=90 * cw,
align="C",
txt=h1,
font=("helvetica", "B", 18))
fpdf.setFont("helvetica", "B", 12)
# Draw table
last, table = doDrawTable(fpdf, rr, ppad, spad=2, cw=cw, ld=ld)
# Fill Form
tc = []
pl = []
fpdf.setFont("helvetica", "B", 12)
for x, game in enumerate(games):
tc.append(game[7])
if game[4].strip().upper() == "H":
text = "%s vs %s at %s" % (game[2], game[3],
self.opts["conam"])
elif game[4].strip().upper() == "A":
text = "%s vs %s at %s" % (game[2], game[3], game[8])
else:
text = "%s vs %s at %s" % (game[2], game[3], game[4])
pos = table[0][1][x] + .5
fpdf.drawText(x=0, y=pos * ld, w=90 * cw, align="C", txt=text)
pos = table[-1][1][x] + .5
if game[6].strip().upper() in ("H", "A"):
text = "Meet at the Club at %5.2f" % game[5]
else:
text = "Meet at %s at %5.2f" % (game[6], game[5])
fpdf.drawText(x=0, y=pos * ld, w=90 * cw, align="C", txt=text)
plrs = self.sql.getRec(
tables=["bwlflt", "bwltab"],
cols=["btb_tab", "btb_surname", "btb_names"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_team", "=", game[1]), ("btb_cono=bft_cono", ),
("btb_tab=bft_player", )],
order="bft_team, bft_skip, bft_position")
while len(plrs) < totp:
plrs.append(["", "", ""])
pl.extend(plrs)
fpdf.setFont("helvetica", "", 12)
col = len(rr["rows"][1][2])
cnt = 0
for p in pl:
if p == ["", "", ""]:
continue
pn = self.getName(p[1], p[2])
if p[0] in tc:
pn = "%s (C)" % pn
x = table[(int((cnt % totp) / 4) + 2)][0][0] + 1
y = table[(
(cnt -
(int(cnt / 4) * 4)) * col) + 2][1][int(cnt / totp)] + .5
fpdf.drawText(x=x * cw, y=y * ld, txt=pn)
cnt += 1
# Draw trailer
fpdf.setFont("helvetica", "B", 14)
txt = """Please tick your names on the right hand side to indicate availability. If unavailable please inform skips and skips to inform selectors."""
if self.assess == "Y":
txt = """%s
Captains (C) are responsible to distribute and return assessment forms, completed and initialled, to a selector.""" % txt
txt = """%s
%s
%s""" % (txt, self.pr.t_work[0][0][0], self.pr.t_work[0][0][1])
fpdf.drawText(x=10.0 * cw, y=(last + 3) * ld, txt=txt, ctyp="M")
fpdf.output(pdfnam, "F")
head = "Match Selections for %s" % self.disp
doPrinter(mf=self.opts["mf"],
header=head,
pdfnam=pdfnam,
repprt=self.pr.repprt,
fromad=self.fromad,
repeml=self.pr.repeml)
def getName(self, snam, fnam):
if fnam:
return "%s, %s" % (snam.upper(), fnam.split()[0][0].upper())
else:
return snam.upper()
def doQuit(self):
self.df.closeProcess()
self.opts["mf"].dbm.rollbackDbase()
self.opts["mf"].closeLoop()
class bc3100(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", "bwlgme", "bwltab",
"bwltyp", "bwlpts", "bwlent"], 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.fromad = bwlctl["ctb_emadd"]
return True
def mainProcess(self):
com = {
"stype": "R",
"tables": ("bwlcmp",),
"cols": (
("bcm_code", "", 0, "Cod"),
("bcm_name", "", 0, "Name", "Y")),
"where": [("bcm_cono", "=", self.opts["conum"])]}
gme = {
"stype": "R",
"tables": ("bwlgme",),
"cols": (("bcg_game", "", 0, "GC"),),
"where": [("bcg_cono", "=", self.opts["conum"])],
"whera": [("T", "bcg_ccod", 0, 0)],
"group": "bcg_game"}
r1s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),"I@bcm_code",0,"","",
0,"N",self.doCmpCod,com,None,None),
(("T",0,0,0),"ONA",30,""),
(("T",0,1,0),"IUI",2,"Last Game","",
0,"N",self.doLstGam,gme,None,("efld",)),
(("T",0,2,0),("IRB",r1s),0,"Game Report","",
"N","N",self.doGamRep,None,None,None),
(("T",0,3,0),("IRB",r1s),0,"Session Prizes","",
"N","N",self.doSesPrz,None,None,None),
(("T",0,4,0),("IRB",r1s),0,"Session Prizes by Group","",
"N","N",self.doSesGrp,None,None,None))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt, view=("N","V"), mail=("B","N"))
def doCmpCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("bwlcmp", where=[("bcm_cono", "=",
self.opts["conum"]), ("bcm_code", "=", w)], limit=1)
if not chk:
return "Invalid Competition Code"
self.ccod = w
self.cdes = chk[self.sql.bwlcmp_col.index("bcm_name")]
self.ctyp = chk[self.sql.bwlcmp_col.index("bcm_type")]
self.poff = chk[self.sql.bwlcmp_col.index("bcm_poff")]
chk = self.sql.getRec("bwltyp", where=[("bct_cono", "=",
self.opts["conum"]), ("bct_code", "=", self.ctyp)], limit=1)
self.cfmat = chk[self.sql.bwltyp_col.index("bct_cfmat")]
self.tsize = chk[self.sql.bwltyp_col.index("bct_tsize")]
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"):
self.games = self.sql.getRec("bwlgme", cols=["count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=", 1)],
limit=1)[0] - 1
else:
self.games = chk[self.sql.bwltyp_col.index("bct_games")]
self.groups = chk[self.sql.bwltyp_col.index("bct_groups")]
self.grgame = chk[self.sql.bwltyp_col.index("bct_grgame")]
col = ["bcg_game", "bcg_aflag", "sum(bcg_sfor)",
"sum(bcg_sagt)", "sum(bcg_points)"]
game = self.sql.getRec("bwlgme", cols=col, where=[("bcg_cono",
"=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod)],
group="bcg_game, bcg_aflag", order="bcg_game")
self.lgame = 0
for g in game:
if not g[1] and not g[2] and not g[3] and not g[4]:
break
self.lgame = g[0]
if not self.lgame:
return "Knockout or No Completed Games"
self.df.loadEntry(frt, pag, p+1, data=self.cdes)
self.df.loadEntry(frt, pag, p+2, data=self.lgame)
def doLstGam(self, frt, pag, r, c, p, i, w):
if not w:
chk = self.sql.getRec("bwlgme", cols=["bcg_game",
"sum(bcg_points)"], where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod)],
group="bcg_game", order="bcg_game")
game = 0
for g in chk:
if g[1]:
game = g[0]
else:
break
if not game:
return "No Completed Games"
self.df.loadEntry(frt, pag, p, data=game)
else:
game = w
chk = self.sql.getRec("bwlgme", cols=["count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod",
"=", self.ccod), ("bcg_game", "=", game), ("bcg_aflag",
"=", "A")], group="bcg_aflag", limit=1)
if chk and chk[0]:
return "Game Abandoned"
chk = self.sql.getRec("bwlgme", where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game",
"=", game), ("bcg_aflag", "in", ("", "D"))])
if not chk:
return "Invalid Game Number"
ptyp = chk[0][self.sql.bwlgme_col.index("bcg_type")]
pts = self.sql.getRec("bwlpts", where=[("bcp_cono",
"=", self.opts["conum"]), ("bcp_code", "=", self.ctyp),
("bcp_ptyp", "=", ptyp)], limit=1)
self.ponly = pts[self.sql.bwlpts_col.index("bcp_p_only")]
non = []
for ck in chk:
scod = ck[self.sql.bwlgme_col.index("bcg_scod")]
ocod = ck[self.sql.bwlgme_col.index("bcg_ocod")]
if scod > 900000 or ocod > 900000:
continue
if self.ponly == "Y":
fors = ck[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", "=", game), ("bcg_scod", "=", ocod)],
limit=1)[0]
else:
fors = ck[self.sql.bwlgme_col.index("bcg_sfor")]
agts = ck[self.sql.bwlgme_col.index("bcg_sagt")]
if not fors and not agts:
if scod not in non:
non.append(scod)
if non:
return "%s Result(s) Not Yet Entered" % int(len(non) / 2)
self.pgame = w
if self.pgame == 1:
self.gamrep = "N"
self.df.loadEntry(frt, pag, p+1, data=self.gamrep)
if self.pgame < self.games:
self.sesp = "N"
self.sesg = "N"
self.df.loadEntry(frt, pag, p+1, data=self.sesp)
self.df.loadEntry(frt, pag, p+2, data=self.sesg)
return "sk3"
return "sk1"
if self.cfmat in ("D", "K", "R") or self.pgame < self.lgame:
self.df.topf[0][3][5] = "N"
else:
self.df.topf[0][3][5] = "Y"
def doGamRep(self, frt, pag, r, c, p, i, w):
self.gamrep = w
if self.cfmat in ("D", "K", "R") or self.pgame < self.lgame:
self.sesp = "N"
self.sesg = "N"
self.df.loadEntry(frt, pag, p+1, data=self.sesp)
self.df.loadEntry(frt, pag, p+2, data=self.sesg)
return "sk2"
def doSesPrz(self, frt, pag, r, c, p, i, w):
self.sesp = w
if self.sesp == "N" or self.groups == "N":
self.sesg = "N"
self.df.loadEntry(frt, pag, p+1, data=self.sesg)
return "sk1"
def doSesGrp(self, frt, pag, r, c, p, i, w):
self.sesg = w
def doEnd(self):
self.df.closeProcess()
chk = self.sql.getRec("bwlgme", cols=["bcg_group", "bcg_scod"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=",
self.ccod), ("bcg_game", "=", self.pgame)], order="bcg_group")
if chk[0][0] and self.cfmat == "R":
groups = "Y"
else:
groups = self.groups
self.grps = {}
for rec in chk:
if rec[0] not in self.grps:
self.grps[rec[0]] = [[rec[1]], [], []]
else:
self.grps[rec[0]][0].append(rec[1])
self.keys = list(self.grps.keys())
self.keys.sort()
self.fpdf = MyFpdf(name=self.__class__.__name__, head=65)
self.lastg = None
for g in self.keys:
self.pageHeading()
if self.gamrep == "Y":
self.doReport("G", g)
if g == 0 and len(chk) > 20:
self.pageHeading()
self.doReport("M", g)
if self.pgame == self.games:
# Enter Prizes
for key in self.keys:
if self.cfmat == "R" and groups == "Y":
self.grps[key][1] = 0
else:
self.doPrizes(key)
# Match Winners & Summary
self.gqty = len(self.keys)
self.wins = {}
self.allp = []
self.swin = []
self.where = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "<=", self.pgame),
("btb_cono=bcg_cono",),
("btb_tab=bcg_scod",)]
for grp in range(self.gqty):
if groups == "Y":
gcod = grp + 1
else:
gcod = grp
whr = copyList(self.where)
whr.append(("bcg_group", "=", gcod))
col = [
"bcg_scod", "btb_surname", "btb_names",
"sum(bcg_a_sfor) as sfor",
"sum(bcg_a_sagt) as sagt",
"sum(bcg_a_sfor - bcg_a_sagt) as agg",
"sum(bcg_a_points) as pts"]
recs = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col,
where=whr, group="bcg_scod, btb_surname, btb_names",
order="pts desc, agg desc, sagt asc")
if not recs:
continue
self.wins[gcod] = []
for x in range(self.grps[gcod][1]):
self.allp.append(recs[x][0])
if recs[x][2]:
nam = "%s, %s" % (recs[x][1], recs[x][2].split()[0])
else:
nam = recs[x][1]
self.wins[gcod].append(nam)
if self.cfmat == "R" and groups == "Y":
self.swin.append(self.grps[gcod][0][0])
if self.sesp == "Y":
self.pageHeading("S")
self.doSesWin()
else:
for grp in self.wins:
if self.wins[grp]:
self.pageHeading("S")
break
self.doMatchWin()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, "report", ext="pdf")
self.fpdf.output(pdfnam, "F")
if self.df.repeml[1] == "Y":
if not self.df.repeml[2]:
col = ["btb_mail"]
whr = [
("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod),
("btb_cono=bce_cono",),
("btb_tab=bce_scod",),
("btb_mail", "<>", "")]
recs = self.sql.getRec(tables=["bwlent", "bwltab"], cols=col,
where=whr)
self.df.repeml[2] = []
for rec in recs:
self.df.repeml[2].append(rec[0])
head = "%s - Results after game %s" % (self.cdes, self.pgame)
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam,
header=head, repprt=self.df.repprt, fromad=self.fromad,
repeml=self.df.repeml)
if self.pgame == self.lgame and self.cfmat == "R" and \
groups == "Y" and not self.poff:
ok = askQuestion(self.opts["mf"].body, "Play-Offs",
"Must a Play-Off Draw be Created and/or Printed?",
default="yes")
if ok == "yes":
self.doSecEnd()
self.opts["mf"].closeLoop()
def doReport(self, rtyp, grp):
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("btb_tab=bcg_scod",)]
col = ["bcg_scod", "btb_surname", "btb_names"]
if rtyp == "G":
whr.extend([
("bcg_scod", "in", self.grps[grp][0]),
("bcg_game", "=", self.pgame)])
col.extend([
"sum(bcg_sfor) as sfor",
"sum(bcg_sagt) as sagt",
"sum(bcg_sfor - bcg_sagt) as agg",
"sum(bcg_points) as pts"])
else:
whr.extend([
("bcg_scod", "in", self.grps[grp][0]),
("bcg_game", "<=", self.pgame)])
if self.pgame <= self.grgame:
col.extend([
"sum(bcg_sfor) as sfor",
"sum(bcg_sagt) as sagt",
"sum(bcg_sfor - bcg_sagt) as agg",
"sum(bcg_points) as pts"])
else:
col.extend([
"sum(bcg_a_sfor) as sfor",
"sum(bcg_a_sagt) as sagt",
"sum(bcg_a_sfor - bcg_a_sagt) as agg",
"sum(bcg_a_points) as pts"])
recs = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col,
where=whr, group="btb_tab, btb_surname, btb_names",
order="pts desc, agg desc, sagt asc")
if not recs:
return
self.groupHeading(rtyp, grp)
if self.cfmat == "X":
tms = {"H": [0, 0, 0, 0], "V": [0, 0, 0, 0]}
for num, (scod,snam,fnam,sfor,sagt,agg,pts) in enumerate(recs):
if fnam:
nam = "%s, %s" % (snam.upper(), fnam.split()[0].upper())
else:
nam = snam.upper()
a = CCD(num+1, "UI", 3)
b = CCD(nam, "NA", 30)
c = CCD(sfor, "SD", 7.1)
d = CCD(sagt, "SD", 7.1)
e = CCD(agg, "SD", 7.1)
f = CCD(pts, "SD", 7.1)
self.printLine(a.disp, b.disp, c.disp, d.disp, e.disp, f.disp)
if self.cfmat == "X":
tm = self.sql.getRec("bwlent", cols=["bce_tcod"],
where=[("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod), ("bce_scod", "=", scod)],
limit=1)
tms[tm[0]][0] = float(ASD(tms[tm[0]][0]) + ASD(c.work))
tms[tm[0]][1] = float(ASD(tms[tm[0]][1]) + ASD(d.work))
tms[tm[0]][2] = float(ASD(tms[tm[0]][2]) + ASD(e.work))
tms[tm[0]][3] = float(ASD(tms[tm[0]][3]) + ASD(f.work))
self.pglin += 1
if self.cfmat == "X":
cwth = self.fpdf.cwth
self.fpdf.drawText()
self.fpdf.drawText("Match Summary", font=["courier", "B", 18])
self.fpdf.setFont(style="B")
self.fpdf.drawText()
self.fpdf.drawText("Home", w=cwth * 32, border="TLRB",
align="C", fill=1, ln=0)
self.fpdf.drawText("Visitors", w=cwth * 32, border="TLRB",
align="C", fill=1, ln=1)
x = self.fpdf.get_x()
y = self.fpdf.get_y()
for tm in ("H", "V"):
self.fpdf.drawText("+For", x=x, y=y, w=cwth * 8, h=8,
border="TLRB", align="C", fill=1)
val = CCD(tms[tm][0], "SD", 7.1)
self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8,
border="TLRB", align="C", fill=0)
x += (cwth * 8)
self.fpdf.drawText("-Agt", x=x, y=y, w=cwth * 8, h=8,
border="TLRB", align="C", fill=1)
val = CCD(tms[tm][1], "SD", 7.1)
self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8,
border="TLRB", align="C", fill=0)
x += (cwth * 8)
self.fpdf.drawText("=Dif", x=x, y=y, w=cwth * 8, h=8,
border="TLRB", align="C", fill=1)
val = CCD(tms[tm][2], "SD", 7.1)
self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8,
border="TLRB", align="C", fill=0)
x += (cwth * 8)
self.fpdf.drawText("Pts", x=x, y=y, w=cwth * 8, h=8,
border="TLRB", align="C", fill=1)
val = CCD(tms[tm][3], "SD", 7.1)
self.fpdf.drawText(val.disp, x=x, w=cwth * 8, h=8,
border="TLRB", align="C", fill=0)
x += (cwth * 8)
def doSesWin(self):
# Session Winners
sess = {}
for gme in range(1, self.games + 1):
col = [
"bcg_scod", "btb_surname", "btb_names",
"sum(bcg_sfor) as sfor",
"sum(bcg_sagt) as sagt",
"sum(bcg_sfor - bcg_sagt) as agg",
"sum(bcg_points) as pts"]
whr = copyList(self.where)
whr.append(("bcg_game", "=", gme))
grp = "bcg_scod, btb_surname, btb_names"
odr = "pts desc, agg desc, sagt asc"
if self.sesg == "Y" and gme > self.grgame:
col.append("bcg_group")
grp = "bcg_group, %s" % grp
odr = "bcg_group, %s" % odr
recs = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=col, where=whr, group=grp, order=odr)
done = None
for rec in recs:
if len(rec) == 7:
gpc = 0
else:
gpc = rec[7]
if gpc == done:
continue
ign = False
if self.ponly == "Y" and not rec[6]:
break
if self.ponly == "N" and (not rec[3] and not rec[4]):
break
for grp in range(self.gqty):
if rec[0] in self.allp:
ign = True
break
if not ign:
self.allp.append(rec[0])
if gme not in sess:
sess[gme] = {}
if rec[2]:
nam = "%s, %s" % (rec[1], rec[2].split()[0])
else:
nam = rec[1]
sess[gme][gpc] = nam
done = gpc
mess = "Session Winners"
self.fpdf.setFont(style="B", size=14)
self.fpdf.drawText(mess, align="C", border="TLRB", fill=1)
self.fpdf.drawText("Ses", w=12, border="TLRB", fill=1, ln=0)
if self.sesg == "Y":
self.fpdf.drawText("Grp", w=12, border="TLRB", fill=1, ln=0)
self.fpdf.drawText("Name", border="TLRB", fill=1)
self.fpdf.setFont()
for gme in range(1, self.games + 1):
stxt = str("%3s" % gme)
if gme not in sess:
self.fpdf.drawText(stxt, w=12, border="TLRB", ln=0)
if self.sesg == "Y":
self.fpdf.drawText("", w=12, border="TLRB", ln=0)
self.fpdf.drawText("* No Valid Winner or Abandoned *",
border="TLRB")
continue
grps = list(sess[gme].keys())
grps.sort()
for grp in grps:
gtxt = "%3s" % chr(64 + grp)
self.fpdf.drawText(stxt, w=12, border="TLRB", ln=0)
if self.sesg == "Y":
self.fpdf.drawText(gtxt, w=12, border="TLRB", ln=0)
self.fpdf.drawText(sess[gme][grp], border="TLRB")
self.fpdf.drawText()
def doMatchWin(self):
for num, gcod in enumerate(self.keys):
if self.wins[gcod]:
if gcod:
if self.cfmat == "R":
mess = "Match Winners - Section %s" % chr(64 + gcod)
else:
mess = "Match Winners - Group %s" % chr(64 + gcod)
else:
mess = "Match Winners"
self.fpdf.setFont(style="B", size=14)
self.fpdf.drawText(mess, align="C", border="TLRB", fill=1)
self.fpdf.drawText("Pos", w=12, border="TLRB", fill=1,
ln=0)
self.fpdf.drawText("Name", border="TLRB", fill=1)
self.fpdf.setFont()
for n, s in enumerate(self.wins[gcod]):
ptxt = "%3s" % (n + 1)
self.fpdf.drawText(ptxt, w=12, border="TLRB", ln=0)
self.fpdf.drawText(s, border="TLRB")
if not num % 2:
ly = self.fpdf.get_y()
if num % 2 and self.fpdf.get_y() > ly:
ly = self.fpdf.get_y()
self.fpdf.drawText()
place = ["1st", "2nd", "3rd"]
for x in range(4, 21):
place.append("%sth" % x)
if self.tsize == 2:
ppos = ("Skip", "Lead")
elif self.tsize == 3:
ppos = ("Skip", "Second", "Lead")
elif self.tsize == 4:
ppos = ("Skip", "Third", "Second", "Lead")
for gcod in self.keys:
if not self.grps[gcod][2]:
continue
for num, skp in enumerate(self.wins[gcod]):
self.fpdf.add_page()
self.fpdf.setFont(style="B", size=24)
self.fpdf.drawText(self.cdes, h=10, align="C")
self.fpdf.drawText()
self.fpdf.setFont(style="B", size=18)
if gcod:
self.fpdf.drawText("GROUP %s" % chr(64 + gcod),
h=10, align="C")
self.fpdf.drawText()
self.fpdf.drawText("%s Prize R%s - %s" % (place[num],
self.grps[gcod][2][num], skp), h=10, align="C")
self.fpdf.setFont(style="B", size=16)
for pos in ppos:
self.fpdf.drawText()
self.fpdf.drawText()
self.fpdf.drawText("%s's Name" % pos, w=50, h=8,
border="TLRB", ln=0, fill=1)
self.fpdf.drawText("", h=8, border="TLRB")
self.fpdf.drawText("Bank Name", w=50, h=8,
border="TLRB", ln=0, fill=1)
self.fpdf.drawText("", h=8, border="TLRB")
self.fpdf.drawText("Branch Name", w=50, h=8,
border="TLRB", ln=0, fill=1)
self.fpdf.drawText("", h=8, border="TLRB")
self.fpdf.drawText("Branch Code", w=50, h=8,
border="TLRB", ln=0, fill=1)
self.fpdf.drawText("", h=8, border="TLRB")
self.fpdf.drawText("Account Number", w=50, h=8,
border="TLRB", ln=0, fill=1)
self.fpdf.drawText("", h=8, border="TLRB")
self.fpdf.drawText()
self.fpdf.setFont(style="B", size=18)
self.fpdf.drawText("Congratulations and Well Done!", h=10,
align="C")
def pageHeading(self, htyp=None):
self.fpdf.add_page()
head = "%s - %s" % (self.opts["conam"], self.cdes)
self.fpdf.drawText(head, font=["courier", "B", 18], align="C")
if htyp == "S":
self.fpdf.drawText()
self.fpdf.drawText("Match Summary", font=["courier", "B", 16],
align="C")
self.fpdf.drawText()
self.pglin = 4
else:
self.pglin = 1
def groupHeading(self, rtyp, group):
self.fpdf.drawText(font=["courier", "B", 18], align="C")
if rtyp == "G":
head = "Results for Game Number: %s" % self.pgame
else:
head = "Match Standings After Game Number: %s" % self.pgame
if group:
if self.cfmat == "R":
head += " for Section: %s" % chr(64 + group)
else:
head += " for Group: %s" % chr(64 + group)
self.fpdf.drawText(head, font=["courier", "B", 16], align="C")
self.fpdf.drawText()
self.fpdf.setFont(style="B")
self.printLine("Pos", "%-30s" % "Name", " +For ", " -Agt ",
" =Dif ", " Pts ", fill=1)
self.fpdf.setFont()
self.pglin += 4
def printLine(self, a, b, c, d, e, f, fill=0):
x = 10
w = self.fpdf.get_string_width("X"*len(a)) + 1
self.fpdf.drawText(a, x=x, w=w, border="TLB", fill=fill, ln=0)
x += w
w = self.fpdf.get_string_width("X"*len(b)) + 1
self.fpdf.drawText(b, x=x, w=w, border="TLB", fill=fill, ln=0)
x += w
w = self.fpdf.get_string_width("X"*len(c)) + 1
self.fpdf.drawText(c, x=x, w=w, border="TLB", fill=fill, ln=0)
x += w
w = self.fpdf.get_string_width("X"*len(d)) + 1
self.fpdf.drawText(d, x=x, w=w, border="TLB", fill=fill, ln=0)
x += w
w = self.fpdf.get_string_width("X"*len(e)) + 1
self.fpdf.drawText(e, x=x, w=w, border="TLB", fill=fill, ln=0)
x += w
w = self.fpdf.get_string_width("X"*len(f)) + 1
self.fpdf.drawText(f, x=x, w=w, border="TLRB", fill=fill)
def doPrizes(self, grp):
self.przgrp = grp
if grp:
if self.cfmat == "R":
tit = "Prizes for Section %s" % chr(64 + grp)
else:
tit = "Prizes for Group %s" % chr(64 + grp)
else:
tit = "Prizes for Match"
r1s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),"IUI",2,"Number of Prizes","",
3,"N",self.doPrzNum,None,None,("efld",)),
(("T",0,1,0),("IRB",r1s),0,"EFT Forms","",
"N","N",self.doPrzEft,None,None,None),
(("T",0,2,0),"IUI",5,"1st Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,3,0),"IUI",5,"2nd Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,4,0),"IUI",5,"3rd Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,5,0),"IUI",5,"4th Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,6,0),"IUI",5,"5th Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,7,0),"IUI",5,"6th Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,8,0),"IUI",5,"7th Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,9,0),"IUI",5,"8th Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,10,0),"IUI",5,"9th Prize","",
0,"N",self.doPrzAmt,None,None,None),
(("T",0,11,0),"IUI",5,"10th Prize","",
0,"N",self.doPrzAmt,None,None,None))
tnd = ((self.doPrzEnd,"n"),)
self.pz = TartanDialog(self.opts["mf"], tops=True, title=tit,
eflds=fld, tend=tnd, txit=None)
for x in range(10):
self.pz.setWidget(self.pz.topLabel[0][2+x], state="hide")
self.pz.setWidget(self.pz.topEntry[0][2+x], state="hide")
self.pz.mstFrame.wait_window()
def doPrzNum(self, frt, pag, r, c, p, i, w):
if not w and self.cfmat != "R":
ok = askQuestion(self.opts["mf"].body, "Prizes",
"Are You Sure that there are No Prizes?", default="no")
if ok == "no":
return "Invalid Number od Prizes"
self.prznum = w
if not self.prznum:
self.przeft = []
self.pz.loadEntry(frt, pag, p+1, data="N")
return "nd"
def doPrzEft(self, frt, pag, r, c, p, i, w):
if w == "N":
self.przeft = []
return "nd"
self.przeft = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for x in range(self.prznum):
self.pz.setWidget(self.pz.topLabel[0][2+x], state="show")
self.pz.setWidget(self.pz.topEntry[0][2+x], state="show")
for x in range(self.prznum, 10):
self.pz.setWidget(self.pz.topLabel[0][2+x], state="hide")
self.pz.setWidget(self.pz.topEntry[0][2+x], state="hide")
def doPrzAmt(self, frt, pag, r, c, p, i, w):
self.przeft[p-2] = w
if p == self.prznum + 1:
return "nd"
def doPrzEnd(self):
self.grps[self.przgrp][1] = self.prznum
self.grps[self.przgrp][2] = self.przeft
self.pz.closeProcess()
def doSecEnd(self):
ccod = getNextCode(self.sql, "bwlcmp", "bcm_code",
where=[("bcm_cono", "=", self.opts["conum"])], last=999)
self.sql.updRec("bwlcmp", cols=["bcm_poff"], data=[ccod],
where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_code", "=", self.ccod)])
cdes = self.cdes + " Play-Off"
t = time.localtime()
cdte = ((t[0] * 10000) + (t[1] * 100) + t[2])
self.sql.insRec("bwlcmp", data=[self.opts["conum"],
ccod, cdes, cdte, 0, ""])
for skp in self.swin:
self.sql.insRec("bwlent", data=[self.opts["conum"],
ccod, skp, 0, "Y", ""])
callModule(self.opts["mf"], self.df, "bc2050", coy=[self.opts["conum"],
self.opts["conam"]], args=ccod)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class arc310(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["assdep", "assgrp", "assmst", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
assctl = gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.glint = assctl["cta_glint"]
return True
def mainProcess(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])],
"order":
"glm_acno"
}
fld = [(("T", 0, 0, 0), "IUA", 3, "Asset Group", "", "", "N",
self.doGroup, grp, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N", None,
None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INa", 3, "Depreciation Code", "", "", "N",
self.doDepCode, dep, None, None),
(("T", 0, 2, 0), "ONA", 34, "")]
if self.glint == "Y":
fld.extend([(("T", 0, 3, 0), "IUI", 7, "Asset Account", "", "",
"N", self.doAsset, glm, None, ("notzero", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), "IUI", 7, "Accum Account", "", "",
"N", self.doAccum, glm, None, ("notzero", )),
(("T", 0, 4, 0), "ONA", 30, ""),
(("T", 0, 5, 0), "IUI", 7, "Expense Account", "", "",
"N", self.doExpense, glm, None, ("notzero", )),
(("T", 0, 5, 0), "ONA", 30, "")])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
def doGroup(self, frt, pag, r, c, p, i, w):
self.group = w
self.acc = self.sql.getRec("assgrp",
where=[("asg_cono", "=",
self.opts["conum"]),
("asg_group", "=", self.group)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.acc[2])
self.df.loadEntry(frt, pag, p + 2, data=self.acc[3])
dep = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", self.acc[3])],
limit=1)
if dep:
self.df.loadEntry(frt, pag, p + 3, data=dep[0])
if self.glint == "N":
return
self.df.loadEntry(frt, pag, p + 4, data=self.acc[4])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc[4])],
limit=1)
if des:
self.df.loadEntry("T", pag, p + 5, data=des[0])
self.df.loadEntry(frt, pag, p + 6, data=self.acc[5])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc[5])],
limit=1)
if des:
self.df.loadEntry("T", pag, p + 7, data=des[0])
self.df.loadEntry(frt, pag, p + 8, data=self.acc[6])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc[6])],
limit=1)
if des:
self.df.loadEntry("T", pag, p + 9, data=des[0])
def doDepCode(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
def doAsset(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", pag, p + 1, data=acc[0])
def doAccum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", pag, p + 1, data=acc[0])
def doExpense(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", pag, p + 1, data=acc[0])
def doDelete(self):
chk = self.sql.getRec("assmst",
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group)])
if chk:
return "Group in Use, Not Deleted"
self.sql.delRec("assgrp",
where=[("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if x == 3 or (self.glint == "Y" and x in (5, 7, 9)):
continue
data.append(self.df.t_work[0][0][x])
if self.glint == "N":
data.extend([0, 0, 0])
if self.new == "Y":
self.sql.insRec("assgrp", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.assgrp_col
data.append(self.acc[col.index("asg_xflag")])
self.sql.updRec("assgrp",
data=data,
where=[("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ms1030(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", "ctlpwr"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.pwd = ""
return True
def mainProcess(self):
sss = []
self.sys_data = []
for ctl in pwctrl:
if ctl[0] not in sss:
sss.append(ctl[0])
for s in sss:
self.sys_data.append([s, allsys[s][0]])
self.sys_data.sort()
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Num"),
("ctm_name", "", 0, "Name", "Y")),
"extra": ((0, "All Companies"),)}
sys = {
"stype": "C",
"titl": "Select the System",
"head": ("SYS", "Description"),
"data": self.sys_data}
self.ctl = {
"stype": "C",
"titl": "Available Control Codes",
"head": ("Sys","Code","Description"),
"data": pwctrl,
"index": 1,
"retn": "D"}
pwd = {
"stype": "R",
"tables": ("ctlpwr",),
"cols": (
("pwd_code", "", 0, "Code"),
("pwd_desc", "", 0, "Description", "Y")),
"whera": [["T", "pwd_cono", 0], ["T", "pwd_sys", 1]]}
fld = (
(("T",0,0,0),"IUI",3,"Company","",
"","Y",self.doCompany,coy,None,None),
(("T",0,1,0),"IUA",3,"System","",
"","N",self.doSystem,sys,None,("notblank",)),
(("T",0,2,0),"INA",20,"Code","",
"","N",self.doCode,pwd,None,("notblank",)),
(("T",0,3,0),"ONA",50,"Description"),
(("T",0,4,0),"IHA",30,"Password","",
"","N",self.doPwd,None,self.doDelete,None))
but = (
("Show All",self.ctl,None,0,("T",0,1),("T",0,0)),
("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0)),
("Quit",None,self.doExit,1,None,None))
tnd = ((self.doEnd,"y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but,
tend=tnd, txit=txt)
def doCompany(self, frt, pag, r, c, p, i, w):
if w:
nam = self.sql.getRec("ctlmst", where=[("ctm_cono", "=",
w)], limit=1)
if not nam:
return "Invalid Company Number"
self.coy = w
self.sys = None
def doSystem(self, frt, pag, r, c, p, i, w):
d1 = ""
for sys in self.sys_data:
if w in sys:
d1 = sys[1]
break
if not d1:
return "Invalid System Code"
if w == "MST" and self.coy:
return "Company Invalid with MST Code"
self.sys = w
self.mod_data = []
for mod in pwctrl:
if self.sys == mod[0]:
self.mod_data.append(mod)
self.ctl["data"] = self.mod_data
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.desc = ""
for cod in self.mod_data:
if self.code in cod:
self.desc = cod[2]
break
if not self.desc:
return "Invalid Password Code"
self.df.loadEntry(frt, pag, p+1, data=self.desc)
acc = self.sql.getRec("ctlpwr", cols=["pwd_desc", "pwd_pass"],
where=[("pwd_cono", "=", self.coy), ("pwd_sys", "=", self.sys),
("pwd_code", "=", self.code)], limit=1)
if not acc:
self.new = "y"
else:
self.new = "n"
self.df.loadEntry(frt, pag, p+2, data=b64Convert("decode", acc[1]))
def doPwd(self, frt, pag, r, c, p, i, w):
self.pwd = w
def doEnd(self):
if self.pwd:
pwd = b64Convert("encode", self.pwd)
if self.new == "y":
self.sql.insRec("ctlpwr", data=[self.coy, self.sys, self.code,
self.desc, pwd])
else:
self.sql.updRec("ctlpwr", cols=["pwd_desc", "pwd_pass"],
data=[self.desc, pwd], where=[("pwd_cono", "=", self.coy),
("pwd_sys", "=", self.sys), ("pwd_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
elif self.new == "n":
self.doDelete()
def doDelete(self):
self.sql.delRec("ctlpwr", where=[("pwd_cono", "=", self.coy),
("pwd_sys", "=", self.sys), ("pwd_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
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 stc410(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"strloc",
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.locs = strctl["cts_locs"]
if self.locs == "N":
showError(self.opts["mf"].body, "Error",
"Multiple Locations Are Not Enabled")
return
return True
def mainProcess(self):
loc = {
"stype":
"R",
"tables": ("strloc", ),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "IUA", 1, "Location Code", "", "", "N",
self.doLoc, loc, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 2,
0), "INA", 30, "Address Line 1", "", "", "N", None, None,
None, None), (("T", 0, 3, 0), "INA", 30, "Address Line 2",
"", "", "N", None, None, None, None),
(("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None, None), (("T", 0, 5, 0), "INA", 30,
"Address Line 4", "", "", "N",
None, None, None, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 0)))
tnd = ((self.doEnd, "Y"), )
txt = (self.doCloseProcess, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doLoc(self, frt, pag, r, c, p, i, w):
if w == "0":
return "Invalid Location"
self.loc = w
self.acc = self.sql.getRec("strloc",
where=[("srl_cono", "=",
self.opts["conum"]),
("srl_loc", "=", self.loc)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
for x in range(1, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=self.acc[x + 1])
def doDelete(self):
self.sql.delRec("strloc",
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("strloc", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.strloc_col
data.append(self.acc[col.index("srl_xflag")])
self.sql.updRec("strloc",
data=data,
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class msc110(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["ctlsys", "ctlpwu", "chglog", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
if self.sql.error == ["genmst"]:
self.gl = False
else:
return
else:
self.gl = True
self.acc = self.sql.getRec("ctlsys", limit=1)
if not self.acc:
self.new = True
self.acc = [
0, "N", 0, 0, 0, "", 0, 0, 0, "", "", "N", "", "", "N", 0
]
else:
self.new = False
return True
def drawDialog(self):
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("None", "0"), ("STARTTLS", "1"), ("SSL/TLS", "2"))
r3s = (("None", "0"), ("Normal", "1"), ("Encrypted", "2"))
self.fld = (
(("T",0,0,0),"IUI",2,"Years to Keep History","",
self.acc[0],"N",self.doHist,None,None,None,None,
"The number of years that historical data must be kept, "\
"Use 0 for No Limit"),
(("T",0,1,0),("IRB",r1s),0,"Enforce Passwords","",
self.acc[1],"N",self.doMust,None,None,None),
(("T",0,2,0),"IUI",2,"Minimum Characters","",
self.acc[2],"N",None,None,None,None),
(("T",0,3,0),"IUI",2,"Maximum Life (Days)","",
self.acc[3],"N",None,None,None,None),
(("T",0,4,0),"IUI",3,"Backup History (Days)","",
self.acc[4],"N",None,None,None,None,None,
"0 for No Limit"),
(("T",0,5,0),"ITX",30,"SMTP Server","",
self.acc[5],"N",self.doSmtp,None,None,None),
(("T",0,6,0),("IRB",r2s),0,"SMTP Security","",
self.acc[6],"N",None,None,None,None),
(("T",0,7,0),("IRB",r3s),0,"SMTP Authentication","",
self.acc[7],"N",self.doAuth,None,None,None),
(("T",0,8,0),"IUI",4,"SMTP Port","",
self.acc[8],"N",None,None,None,None),
(("T",0,9,0),"ITX",20,"SMTP Username","",
self.acc[9],"N",self.doUsr,None,None,None),
(("T",0,10,0),"IHA",20,"SMTP Password","",
self.acc[10],"N",None,None,None,None),
(("T",0,11,0),("IRB",r1s),0,"SMS Service","",
self.acc[11],"N",self.doSms,None,None,None),
(("T",0,12,0),"ITX",20,"SMS Username","",
self.acc[12],"N",self.doSmsUsr,None,None,None),
(("T",0,13,0),"IHA",20,"SMS Password","",
self.acc[13],"N",self.doSmsPwd,None,None,None),
(("T",0,14,0),("IRB",r1s),0,"G/L Departments","",
self.acc[14],"N",self.doGlDept,None,None,None,None,
"G/L Account Numbers include Department Numbers"),
(("T",0,15,0),"IUI",1,"Number of Digits","",
self.acc[15],"N",None,None,None,None,None,
"The Number of Digits used for Department Numbers"))
but = (("Accept", None, self.doAccept, 0, (("T", 0, 1), ("T", 0, 6)),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt,
focus=False)
for n, f in enumerate(self.acc):
self.df.loadEntry("T", 0, n, data=f)
self.df.focusField("T", 0, 1, clr=False)
def doHist(self, frt, pag, r, c, p, i, w):
if w and w < 5:
return "At least 5 Years of History should be kept"
def doMust(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data=0)
return "sk2"
def doSmtp(self, frt, pag, r, c, p, i, w):
if not w:
self.df.loadEntry(frt, pag, p + 1, data="0")
self.df.loadEntry(frt, pag, p + 2, data="0")
self.df.loadEntry(frt, pag, p + 3, data="")
self.df.loadEntry(frt, pag, p + 4, data="")
self.df.loadEntry(frt, pag, p + 5, data="")
return "sk5"
def doAuth(self, frt, pag, r, c, p, i, w):
if not int(w):
self.df.loadEntry(frt, pag, p + 1, 25)
self.df.loadEntry(frt, pag, p + 2, "")
self.df.loadEntry(frt, pag, p + 3, "")
return "sk3"
elif int(self.df.t_work[0][0][6]) == 1:
self.df.loadEntry(frt, pag, p + 1, 587)
elif int(self.df.t_work[0][0][6]) == 2:
self.df.loadEntry(frt, pag, p + 1, 465)
def doUsr(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid SMTP Name"
def doSms(self, frt, pag, r, c, p, i, w):
if w == "Y" and not chkMod("requests"):
showError(self.opts["mf"].body, "Error", "Missing requests Module")
w = "N"
self.df.loadEntry(frt, pag, p, data=w)
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data="")
if not self.gl:
self.df.loadEntry(frt, pag, p + 3, data="N")
self.df.loadEntry(frt, pag, p + 4, data=0)
return "sk4"
return "sk2"
def doSmsUsr(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid SMS User Name"
def doSmsPwd(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid SMS Password"
def doGlDept(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEnd(self):
svr = self.df.t_work[0][0][5]
if svr:
prt = self.df.t_work[0][0][8]
sec = self.df.t_work[0][0][6]
aut = self.df.t_work[0][0][7]
nam = self.df.t_work[0][0][9]
pwd = self.df.t_work[0][0][10]
chk = sendMail([svr, prt, sec, aut, nam, pwd],
"",
"",
"",
check=True,
err=self.opts["mf"].body,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
if not chk:
self.df.focusField("T", 0, 6)
return
tme = time.localtime()
data = copyList(self.df.t_work[0][0])
if self.new:
self.sql.insRec("ctlsys", data=data)
elif data != self.acc[:len(data)]:
self.sql.updRec("ctlsys", data=data)
dte = int("%04i%02i%02i%02i%02i%02i" % tme[:-3])
for num, dat in enumerate(self.acc):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"ctlsys", "U",
"%03i" % 0, self.sql.ctlsys_col[num],
dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
# Reset all password dates to current date (Temporary Fix)
dte = (tme[0] * 10000) + (tme[1] * 100) + tme[2]
self.sql.updRec("ctlpwu", cols=["usr_last"], data=[dte])
self.opts["mf"].dbm.commitDbase()
self.doExit()
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class drc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
if drsctl["ctd_chain"] == "N":
showError(self.opts["mf"].body, "Error",
"Chain Stores are Not Enabled")
return
self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "drschn"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
chm = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Chn"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "IUI", 3, "Chn", "Chainstore Number", "",
"N", self.doChain, chm, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N", None,
None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 3",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 4, "Postal Code", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 6, 0), "INA", 20, "Telephone", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 7,
0), "INA", 20, "Fax", "", "", "N", None, None, None,
("efld", )), (("T", 0, 8, 0), "ITX", 50, "E-Mail Address",
"", "", "N", None, None, None, ("email", )),
(("T", 0, 9,
0), "INA", 30, "Contact", "", "", "N", None, None, None,
("efld", )), (("T", 0, 10, 0), "IUA", 1, "Vat Code", "",
"", "N", self.doVat, vtm, None,
("notblank", )), (("T", 0, 10, 0), "ONA",
30, ""))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doChain(self, frt, pag, r, c, p, i, w):
self.chain = w
self.acc = self.sql.getRec("drschn",
where=[("chm_cono", "=",
self.opts["conum"]),
("chm_chain", "=", self.chain)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
vat = self.sql.getRec(
"ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=",
self.acc[self.sql.drschn_col.index("chm_vatind")])],
limit=1)
if not vat:
txt = "Invalid Vat Record"
else:
txt = vat[0]
for x in range(0, self.df.topq[pag]):
if x == (self.df.topq[pag] - 1):
self.df.loadEntry(frt, pag, p + x, data=txt)
else:
self.df.loadEntry(frt, pag, p + x, data=self.acc[x + 1])
def doVat(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not vat:
return "Invalid Vat Record"
self.df.loadEntry(frt, pag, p + 1, data=vat[0])
def doDelete(self):
self.sql.delRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", self.chain)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dat = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if x == 11:
continue
dat.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("drschn", data=dat)
elif dat != self.acc[:len(dat)]:
col = self.sql.drschn_col
dat.append(self.acc[col.index("chm_xflag")])
self.sql.updRec("drschn",
data=dat,
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", self.chain)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rcc310(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, ["rcaint", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def drawDialog(self):
dat = {
"stype":
"R",
"tables": ("rcaint", ),
"cols":
(("rci_date", "", 0, "Date-Chg"), ("rci_prime", "", 0, "Prime"),
("rci_bankr", "", 0, "BankR"), ("rci_admin", "", 0, "Admin")),
"where": [("rci_cono", "=", self.opts["conum"])],
"order":
"rci_date"
}
self.fld = ((("T", 0, 0, 0), "ID1", 10, "Date of Change", "", 0, "N",
self.doDate, dat, None, ("efld", )),
(("T", 0, 1, 0), "IUD", 5.2, "Prime Rate", "", 0, "N",
None, None, self.doDelete, ("notzero", )),
(("T", 0, 2, 0), "IUD", 5.2, "Bank Rate", "", 0, "N", None,
None, None, ("notzero", )),
(("T", 0, 3, 0), "IUD", 5.2, "Comm Rate", "", 0, "N", None,
None, None, ("efld", )))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
but = (("_Import File",None,self.doImport,0,("T", 0, 1),("T", 0, 2),
"Import a File with the Correct Format i.e. Date, Prime Rate, "\
"Bank Rate, Fee Rate"),)
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tend=tnd,
txit=txt,
butt=but)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Interest File Import", )
fle = {
"stype": "F",
"types": "fle",
"ftype": (("CSV & XLS Files", "*.[c,x][s,l][v,s]"), )
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "IFF", 50, "File Name", "", "", "N",
self.doImpFle, fle, None, ("file", )),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Delete Existing", "", "N",
"N", self.doImpDel, None, None, None))
tnd = ((self.doImpEnd, "n"), )
txt = (self.doImpExit, )
self.ip = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
tend=tnd,
txit=txt)
self.ip.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doImpFle(self, frt, pag, r, c, p, i, w):
self.impfle = w
def doImpDel(self, frt, pag, r, c, p, i, w):
self.impdel = w
def doImpEnd(self):
self.ip.closeProcess()
if self.impdel == "Y":
self.sql.delRec("rcaint",
where=[("rci_cono", "=", self.opts["conum"])])
impcol = [["Date", 0, "D1", 10], ["Prime Rate", 1, "UD", 5.2],
["Bank Rate", 2, "UD", 5.2], ["Fee Rate", 3, "UD", 5.2]]
fi = FileImport(self.opts["mf"], impfle=self.impfle, impcol=impcol)
err = None
for num, line in enumerate(fi.impdat):
if len(line) != len(impcol):
err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \
(num + 1, len(impcol), len(line))
break
date = CCD(line[0], "D1", 10)
prime = CCD(line[1], "UD", 5.2)
bank = CCD(line[2], "UD", 5.2)
fees = CCD(line[3], "UD", 5.2)
chk = self.sql.getRec("rcaint",
where=[("rci_cono", "=", self.opts["conum"]),
("rci_date", "=", date.work)])
if chk:
err = "Line %s: A Record for Date, %s, Already Exists" % \
(num + 1, date.disp)
break
self.sql.insRec("rcaint",
data=[
self.opts["conum"], date.work, prime.work,
bank.work, fees.work
])
if err:
showError(self.opts["mf"].body, "Import Error", err)
else:
self.opts["mf"].dbm.commitDbase(
ask=True,
mess="Would you like to COMMIT All Imported Interest Rates?")
def doImpExit(self):
self.ip.closeProcess()
def doDate(self, frt, pag, r, c, p, i, w):
self.date = w
self.acc = self.sql.getRec("rcaint",
where=[("rci_cono", "=",
self.opts["conum"]),
("rci_date", "=", self.date)],
limit=1)
if self.acc:
self.new = False
for n, f in enumerate(self.acc[1:-1]):
self.df.loadEntry("T", 0, n, data=f)
else:
self.new = True
def doDelete(self):
self.sql.delRec("rcaint",
where=[("rci_cono", "=", self.opts["conum"]),
("rci_date", "=", self.date)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["rcaint", "D", "%03i%8s" % \
(self.opts["conum"], self.date), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new:
self.sql.insRec("rcaint", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.rcaint_col
data.append(self.acc[col.index("rci_xflag")])
self.sql.updRec("rcaint",
data=data,
where=[("rci_cono", "=", self.opts["conum"]),
("rci_date", "=", self.date)])
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=[
"rcaint", "U",
"%03i%8s" % (self.opts["conum"], self.date),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rcc110(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 = ["rcactl", "tplmst", "chglog"]
if self.genleg:
tabs.extend(["ctlctl", "genmst"])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.acc = self.sql.getRec("rcactl",
where=[("cte_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [
self.opts["conum"], "N", 0, 0, "statement_owner",
"statement_tenant", "", ""
]
else:
self.new = False
if self.genleg:
self.ctl = [["rca_com", "Commission Raised", 0],
["rca_dep", "Deposits Control", 0],
["rca_fee", "Contract Fees", 0],
["rca_own", "Owners Control", 0],
["rca_orx", "Owners Charges", 0],
["rca_tnt", "Tenants Control", 0],
["rca_trx", "Tenants Charges", 0]]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
for num, ctl in enumerate(self.ctl):
if ctl[0] in ctlctl:
self.ctl[num][2] = ctlctl[ctl[0]]
return True
def drawDialog(self):
ctl = {
"stype":
"R",
"tables": ("ctlctl", "genmst"),
"cols":
(("ctl_code", "", 0, "Ctl-Code"), ("ctl_conacc", "", 0, "G/L-Num"),
("glm_desc", "", 30, "Description")),
"where": [("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono", ),
("glm_acno=ctl_conacc", )],
"index":
1
}
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"),
("tpm_title", "", 0, "Title"), ("tpm_type", "", 0, "T")),
"where": [("tpm_type", "=", "R"), ("tpm_system", "=", "RCA")],
"order":
"tpm_tname"
}
r1s = (("Yes", "Y"), ("No", "N"))
if self.genleg:
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "G/L-Num"), ("glm_desc", "", 30,
"Description")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "",
self.acc[1], "N", self.doGlint, None, None, None),
(("T", 0, 1, 0), "IUI", 7, self.ctl[0][1], "",
self.ctl[0][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 1, 0), "ONA", 30, ""),
(("T", 0, 2, 0), "IUI", 7, self.ctl[1][1], "",
self.ctl[1][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "IUI", 7, self.ctl[2][1], "",
self.ctl[2][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), "IUI", 7, self.ctl[3][1], "",
self.ctl[3][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 4, 0), "ONA", 30, ""),
(("T", 0, 5, 0), "IUI", 7, self.ctl[4][1], "",
self.ctl[4][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 5, 0), "ONA", 30, ""),
(("T", 0, 6, 0), "IUI", 7, self.ctl[5][1], "",
self.ctl[5][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 6, 0), "ONA", 30, ""),
(("T", 0, 7, 0), "IUI", 7, self.ctl[6][1], "",
self.ctl[6][2], "N", self.doGenAcc, glm, None, ("efld", )),
(("T", 0, 7, 0), "ONA", 30, ""),
(("T", 0, 8, 0), "IUI", 7, "Bank Account", "", self.acc[2],
"N", self.doGlbnk, ctl, None, ("efld", ))]
seq = 9
else:
fld = []
seq = 0
fld.extend([(("T", 0, seq, 0), "ID1", 10, "Last Month End", "",
self.acc[3], "N", None, None, None, ("efld", )),
(("T", 0, seq + 1, 0), "INA", 20, "Owner Template", "",
self.acc[4], "N", self.doTplNam, tpm, None, None),
(("T", 0, seq + 2, 0), "INA", 20, "Tenant Template", "",
self.acc[5], "N", self.doTplNam, tpm, None, None),
(("T", 0, seq + 3, 0), "ITX", 50, "Email Address", "",
self.acc[6], "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 n < 2:
continue
self.df.loadEntry("T", 0, s, data=f)
s += 1
if not n:
for c in self.ctl:
self.df.loadEntry("T", 0, s, data=c[2])
s += 1
self.df.loadEntry("T", 0, s, data=self.getDes(c[2]))
s += 1
self.df.focusField("T", 0, 1, clr=False)
def doGlint(self, frt, pag, r, c, p, i, w):
if w == "N":
for x in range(1, 16):
self.df.loadEntry(frt, pag, p + x, data="")
return "sk15"
def doGenAcc(self, frt, pag, r, c, p, i, w):
des = self.getDes(w)
if not des:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=des)
def getDes(self, acno):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acno)],
limit=1)
if acc:
return acc[0]
else:
return ""
def doGlbnk(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["ctlctl", "genmst"],
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w),
("ctl_cono=glm_cono", ),
("ctl_conacc=glm_acno", ),
("ctl_code", "like", "bank_%")],
limit=1)
if not acc:
return "Invalid Bank Account Number"
def doTplNam(self, frt, pag, r, c, p, i, w):
if c == 18:
typ = "O"
else:
typ = "T"
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "S"),
("tpm_system", "=", "RCA"),
("tpm_sttp", "=", typ)],
limit=1)
if not acc:
return "Invalid Template Name"
def doEnd(self):
data = [self.opts["conum"]]
if not self.genleg:
data.extend(["N", 0])
for x, d in enumerate(self.df.t_work[0][0]):
if self.genleg and x < 16:
if x in (1, 3, 5, 7, 9, 11, 13):
y = int((x - 1) / 2)
chk = self.sql.getRec("ctlctl",
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])],
limit=1)
if chk:
self.sql.updRec("ctlctl",
cols=["ctl_conacc"],
data=[d],
where=[("ctl_cono", "=",
self.opts["conum"]),
("ctl_code", "=",
self.ctl[y][0])])
else:
self.sql.insRec("ctlctl",
data=[
self.opts["conum"], self.ctl[y][0],
self.ctl[y][1], d, "", "N", "N"
])
elif x in (2, 4, 6, 8, 10, 12, 14):
continue
else:
data.append(d)
else:
data.append(d)
if self.new:
self.sql.insRec("rcactl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.rcactl_col
data.append(self.acc[col.index("cte_xflag")])
self.sql.updRec("rcactl",
data=data,
where=[("cte_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=[
"rcactl", "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()
