class ln3030(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, ["lonmf1", "lonmf2", "lontrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
lonctl = gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
self.fromad = lonctl["cln_emadd"]
t = time.localtime()
self.curdt = int(((t[0] * 10000) + (t[1] * 100) + t[2]) / 100)
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Loans Balances Listing (%s)" % self.__class__.__name__)
r1s = (("Number", "N"), ("Name", "M"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "ID2", 7, "Reporting Period", "", self.curdt,
"Y", self.doDate, None, None,
("efld", )), (("T", 0, 1, 0), ("IRB", r1s), 1, "Sort Order",
"", "N", "Y", self.doSort, None, None, None),
(("T", 0, 2, 0), ("IRB", r2s), 1, "Include Zero Balances", "",
"N", "Y", self.doZero, None, None, None),
(("T", 0, 3, 0), ("IRB", r2s), 1, "Include Pending Interest",
"", "N", "Y", self.doPend, None, 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=("Y", "N"))
def doDate(self, frt, pag, r, c, p, i, w):
self.curdt = w
self.cdte = self.df.t_disp[pag][0][i]
self.date = mthendDate(w * 100)
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
def doZero(self, frt, pag, r, c, p, i, w):
self.zero = w
def doPend(self, frt, pag, r, c, p, i, w):
self.pend = w
def doEnd(self):
self.df.closeProcess()
if self.sort == "N":
odr = "lm1_acno"
else:
odr = "lm1_name"
lm1 = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=", self.opts["conum"])],
order=odr)
if not lm1:
showError(self.opts["mf"].body, "Loans Error", "No Loans Selected")
else:
self.printReport(lm1)
self.closeProcess()
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
if self.pend == "Y":
self.head = "%03u %-118s" % (self.opts["conum"],
self.opts["conam"])
else:
self.head = "%03u %-90s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
ltot = 0
itot = 0
ntot = 0
self.pglin = 999
for num, rec in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
acc = CCD(rec[self.sql.lonmf1_col.index("lm1_acno")], "UA", 7)
nam = CCD(rec[self.sql.lonmf1_col.index("lm1_name")], "NA", 28)
lm2 = self.sql.getRec("lonmf2",
where=[("lm2_cono", "=", self.opts["conum"]),
("lm2_acno", "=", acc.work)],
order="lm2_loan")
for dat in lm2:
lon = CCD(dat[self.sql.lonmf2_col.index("lm2_loan")], "UI", 2)
des = CCD(dat[self.sql.lonmf2_col.index("lm2_desc")], "NA", 30)
dte = CCD(dat[self.sql.lonmf2_col.index("lm2_start")], "d1",
10)
col = ["sum(lnt_tramt)"]
whr = [("lnt_cono", "=", self.opts["conum"]),
("lnt_acno", "=", acc.work),
("lnt_loan", "=", lon.work),
("lnt_curdt", "<=", self.curdt)]
lbal = self.sql.getRec("lontrn", cols=col, where=whr, limit=1)
lbal = CCD(lbal[0], "SD", 13.2)
if self.zero == "N" and not lbal.work:
continue
if self.pglin > self.fpdf.lpp:
self.pageHeading()
ltot = float(ASD(ltot) + ASD(lbal.work))
if self.pend == "Y":
LoanInterest("L",
self.opts["mf"].dbm,
dat,
update="Y",
tdate=self.date,
batch="Pending",
curdt=self.curdt)
nbal = self.sql.getRec("lontrn",
cols=col,
where=whr,
limit=1)
nbal = CCD(nbal[0], "SD", 13.2)
ntot = float(ASD(ntot) + ASD(nbal.work))
ibal = CCD(nbal.work - lbal.work, "SD", 13.2)
itot = float(ASD(itot) + ASD(ibal.work))
self.fpdf.drawText(
"%s %s %s %s %s %s %s %s" %
(acc.disp, nam.disp, lon.disp, des.disp, dte.disp,
lbal.disp, ibal.disp, nbal.disp))
else:
self.fpdf.drawText("%s %s %s %s %s %s" %
(acc.disp, nam.disp, lon.disp, des.disp,
dte.disp, lbal.disp))
self.pglin += 1
p.closeProgress()
if self.fpdf.page and not p.quit:
self.fpdf.underLine(txt=self.head)
ltot = CCD(ltot, "SD", 13.2)
if self.pend == "Y":
itot = CCD(itot, "SD", 13.2)
ntot = CCD(ntot, "SD", 13.2)
self.fpdf.drawText(
"%8s%-74s%13s %13s %13s" %
("", "Totals", ltot.disp, itot.disp, ntot.disp))
else:
self.fpdf.drawText("%8s%-74s%13s" % ("", "Totals", ltot.disp))
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
txt = "%-29s %-7s" % ("Loans Balances Listing as at", self.cdte)
self.fpdf.drawText(txt=txt)
self.fpdf.drawText()
self.fpdf.drawText("%s %s %s %s)" % \
("(Options: Sort:", self.sort, "Include-Zero-Bal:", self.zero))
self.fpdf.drawText()
txt = "%-7s %-28s %-2s %-30s %-10s" % \
("Acc-Num", "Name", "Ln", "Description", "Start-Date")
if self.pend == "Y":
txt = "%s %13s %13s %13s" % \
(txt, "Ledger-Bal ", "Interest ", "Balance ")
else:
txt = "%s %13s" % (txt, "Balance ")
self.fpdf.drawText(txt=txt)
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 8
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class wg1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctldep", "chglog", "wagbal",
"wagcap", "wagcod", "wagedc", "wagmst", "wagtf1", "wagtf2",
"waglmf", "wagltf"], prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
wgm = {
"stype": "R",
"tables": ("wagmst",),
"cols": (
("wgm_empno", "", 0, "EmpNo"),
("wgm_sname", "", 0, "Surname", "Y"),
("wgm_fname", "", 0, "Names"),
("wgm_freq", "", 0, "F"),
("wgm_start", "", 0, "Start-Date"),
("wgm_term", "", 0, "Term-Date")),
"where": [("wgm_cono", "=", self.opts["conum"])]}
dep = {
"stype": "R",
"tables": ("ctldep",),
"cols": (
("dep_code", "", 0, "Dep"),
("dep_name", "", 0, "Name", "Y")),
"where": [("dep_cono", "=", self.opts["conum"])]}
wec = {
"stype": "R",
"tables": ("wagedc",),
"cols": (
("ced_code", "", 0, "Code"),
("ced_desc", "", 0, "Description", "Y")),
"where": [
("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "E")]}
wdc = {
"stype": "R",
"tables": ("wagedc",),
"cols": (
("ced_code", "", 0, "Code"),
("ced_desc", "", 0, "Description", "Y")),
"where": [
("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D")]}
r1s = (("Weekly","W"),("2xWeekly","F"),("Monthly ","M"))
r2s = (("Cash ","C"),("Cheque ","Q"),("Electronic","E"))
r3s = (("Yes","Y"),("No","N"))
r4s = (("Current","1"),("Transmission","2"),("Savings","3"))
fld = (
(("T",0,0,0),"IUI",5,"Emp-Num","Employee Number",
"","Y",self.doEmpNum,wgm,None,("notzero",)),
(("T",0,0,0),"IUI",3,"Department","",
"","N",self.doDept,dep,None,None),
(("T",0,0,0),"IUI",1,"Class","",
"","N",None,None,None,None),
(("T",1,0,0),"INA",30,"Surname","",
"","N",None,None,None,("notblank",)),
(("T",1,1,0),"INA",30,"Names","",
"","N",None,None,None,("notblank",)),
(("T",1,2,0),"ID1",10,"Date of Birth","",
"","N",self.doDOB,None,None,("efld",)),
(("T",1,3,0),"INA",13,"ID Number","",
"","N",self.doIdNo,None,None,("idno",)),
(("T",1,4,0),"INA",16,"Spouse Name","",
"","N",None,None,None,None),
(("T",1,5,0),"INA",13,"Spouse ID Number","",
"","N",self.doIdNo,None,None,("idno",)),
(("T",1,6,0),"INA",30,"Address Line 1","",
"","N",None,None,None,("notblank",)),
(("T",1,7,0),"INA",30,"Address Line 2","",
"","N",None,None,None,None),
(("T",1,8,0),"INA",30,"Address Line 3","",
"","N",None,None,None,None),
(("T",1,9,0),"INA",4,"Postal Code","",
"","N",None,None,None,("notblank",)),
(("T",1,10,0),"INA",16,"Telephone Number","",
"","N",None,None,None,None),
(("T",1,11,0),"ITX",50,"E-Mail Address","",
"","N",None,None,None,("email",)),
(("T",1,12,0),"ID1",10,"Start Date","",
"","N",None,None,None,("efld",)),
(("T",1,13,0),"IUD",10.2,"Salary/Rate","",
"","N",None,None,None,("efld",)),
(("T",1,14,0),("IRB",r1s),0,"Pay Freq","Pay Frequency",
"M","N",None,None,None,None),
(("T",1,15,0),("IRB",r2s),0,"Pay Type","",
"E","N",self.doPayTyp,None,None,None),
(("T",2,0,0),("IRB",r3s),0,"P.A.Y.E.","",
"Y","N",None,None,None,None),
(("T",2,1,0),"INA",16,"Tax Office","",
"","N",None,None,None,None),
(("T",2,2,0),"INA",10,"Tax Number","",
"","N",None,None,None,None),
(("T",2,3,0),"IUA",1,"Nature of Employee","",
"A","N",None,None,None,("notblank",)),
(("T",2,4,0),"IUI",9,"Reg Number","Registration Number",
"","N",None,None,None,None),
(("T",2,5,0),"IUA",1,"Voluntary Excess","",
"N","N",None,None,None,None),
(("T",2,6,0),"IUD",6.2,"Fixed Rate","",
"","N",None,None,None,None),
(("T",2,7,0),"INA",13,"Directive","",
"","N",None,None,None,None),
(("T",3,0,0),("IRB",r4s),0,"Account Type","Bank Account Type",
"1","N",None,None,None,None),
(("T",3,1,0),"INA",30,"Bank Name","",
"","N",self.doBankNam,None,None,None),
(("T",3,2,0),"IUI",8,"Branch Code","Bank Branch Code",
"","N",self.doBankBch,None,None,None),
(("T",3,3,0),"INA",16,"Account Number","Bank Account Number",
"","N",self.doBankAcc,None,None,None),
(("T",3,4,0),"INA",30,"Account Holder's Name","",
"","N",self.doHolderNam,None,None,None),
(("T",3,5,0),"IUI",1,"Holder's Relationship","",
"","N",self.doHolderRel,None,None,None),
(("C",4,0,0),"IUI",3,"Cod","Earnings Code",
"","N",self.doEarnCod,wec,None,("efld",)),
(("C",4,0,1),"ONA",30,"Description"),
(("C",4,0,2),"ISD",13.2,"Amnt/Rate","Amount or Rate",
"","N",self.doEarnAmt,None,self.doCodeDelete,("efld",)),
(("C",5,0,0),"IUI",3,"Cod","Deduction Code",
"","N",self.doDedCod,wdc,None,("efld",)),
(("C",5,0,1),"ONA",30,"Description"),
(("C",5,0,2),"ISD",13.2,"Amnt/Rate","Employees Amount or Rate",
"","N",self.doDedEAmt,None,self.doCodeDelete,("efld",)),
(("C",5,0,3),"ISD",13.2,"Amnt/Rate","Employers Amount or Rate",
"","N",self.doDedRAmt,None,None,("efld",)),
(("T",6,0,0),"ISD",13.2,"Balance-1","",
"","N",None,None,None,("efld",)),
(("T",6,1,0),"ISD",13.2,"Balance-2","",
"","N",None,None,None,("efld",)),
(("T",6,2,0),"ISD",13.2,"Balance-3","",
"","N",None,None,None,("efld",)))
tag = (
("General",None,("T",0,0),("T",0,1)),
("Tax",None,("T",0,0),("T",0,1)),
("Bank",None,("T",0,0),("T",0,1)),
("Earnings",None,("T",0,0),("T",0,1)),
("Deductions",None,("T",0,0),("T",0,1)),
("Balances",None,("T",0,0),("T",0,1)))
tnd = (
(self.doEnd, "n"),
(self.doEnd, "n"),
(self.doEnd, "n"),
(self.doEnd, "n"),
None,
None,
(self.doEnd, "y"))
txt = (
self.doExit,
self.doExit,
self.doExit,
self.doExit,
None,
None,
self.doExit)
cnd = (
None,
None,
None,
None,
(self.doEndEarn, "y"),
(self.doEndDed, "y"),
None)
cxt = (
None,
None,
None,
None,
self.doExit,
self.doExit,
None)
but = (
("Accept",None,self.doAccept,0,("T",0,2),("T",0,1)),
("Print",None,self.doPrint,0,("T",0,2),("T",0,0)),
("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0)),
("Quit",None,self.doCloseProcess,1,None,None))
row = [0,0,0,0,15,15,0]
self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag,
rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.pag == 0:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doEmpNum(self, frt, pag, r, c, p, i, w):
self.empno = w
self.oldm = self.sql.getRec("wagmst", where=[("wgm_cono", "=",
self.opts["conum"]), ("wgm_empno", "=", self.empno)], limit=1)
self.oldb = self.sql.getRec("wagbal", where=[("wbl_cono", "=",
self.opts["conum"]), ("wbl_empno", "=", self.empno)],
order="wbl_balno")
if not self.oldm:
self.new = True
self.term = 0
self.ptyp = ""
else:
self.new = False
self.term = self.oldm[len(self.oldm)-1]
d = 1
for pg in range(0, self.df.pgs):
for x in range(0, self.df.topq[pg]):
self.df.loadEntry("T", pg, x, data=self.oldm[d])
d = d + 1
self.ptyp = self.df.t_work[1][0][15]
self.doLoadEarnDed("E")
self.doLoadEarnDed("D")
if self.oldb:
for b in self.oldb:
self.df.loadEntry("T", 6, b[2]-1, data=b[3])
def doDept(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctldep", cols=["dep_name"],
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", w)], limit=1)
if not acc:
return "Invalid Department"
self.dept = w
def doDOB(self, frt, pag, r, c, p, i, w):
self.dob = w
def doIdNo(self, frt, pag, r, c, p, i, w):
if p == 6:
a = int(int(w) / 10000000)
b = int(self.dob % 1000000)
if a != b:
return "ID Number Does Not Agree with Birth Date"
def doPayTyp(self, frt, pag, r, c, p, i, w):
self.ptyp = w
def doBankNam(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Bank Name"
def doBankBch(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Branch"
def doBankAcc(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Account"
def doHolderNam(self, frt, pag, r, c, p, i, w):
self.holnam = w
def doHolderRel(self, frt, pag, r, c, p, i, w):
self.holrel = w
def doEnd(self):
if self.df.pag == 0:
self.df.focusField("T", 1, 1)
elif self.df.pag == 1:
self.df.selPage("Tax")
self.df.focusField("T", 2, 1)
elif self.df.pag == 2:
self.df.selPage("Bank")
self.df.focusField("T", 3, 1)
elif self.df.pag == 3:
self.df.selPage("Earnings")
elif self.df.pag == 6:
self.doAccept()
def doEarnCod(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("wagedc", cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=",
"E"), ("ced_code", "=", w)], limit=1)
if not desc:
return "Invalid Code"
self.code = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=",
self.empno), ("wcd_type", "=", "E"), ("wcd_code", "=", w)],
limit=1)
if not code:
self.ncod = "y"
else:
self.ncod = "n"
self.df.loadEntry(frt, pag, p+2, data=code[0])
def doEarnAmt(self, frt, pag, r, c, p, i, w):
self.eamt = w
self.ramt = 0
def doEndEarn(self):
self.doEndCode("E")
def doDedCod(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("wagedc", cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=",
"D"), ("ced_code", "=", w)], limit=1)
if not desc:
return "Invalid Code"
self.code = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=",
self.empno), ("wcd_type", "=", "D"), ("wcd_code", "=", w)],
limit=1)
if not code:
self.ncod = "y"
else:
self.ncod = "n"
self.df.loadEntry(frt, pag, p+2, data=code[0])
self.df.loadEntry(frt, pag, p+3, data=code[1])
def doDedEAmt(self, frt, pag, r, c, p, i, w):
self.eamt = w
def doDedRAmt(self, frt, pag, r, c, p, i, w):
self.ramt = w
def doEndDed(self):
self.doEndCode("D")
def doEndCode(self, rtype):
if self.ncod == "y":
self.sql.insRec("wagcod", data=[self.opts["conum"],
self.empno, rtype, self.code, self.eamt, self.ramt])
else:
self.sql.updRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
data=[self.eamt, self.ramt], where=[("wcd_cono", "=",
self.opts["conum"]), ("wcd_empno", "=", self.empno),
("wcd_type", "=", rtype), ("wcd_code", "=", self.code)])
self.doLoadEarnDed(rtype, focus=True)
def doLoadEarnDed(self, rtype, focus=False):
if rtype == "E":
pag = 4
else:
pag = 5
self.df.clearFrame("C", pag)
codes = self.sql.getRec(tables=["wagcod", "wagedc"], cols=["wcd_code",
"ced_desc", "wcd_eamt", "wcd_ramt"], where=[("wcd_cono", "=",
self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type",
"=", rtype), ("ced_cono = wcd_cono",), ("ced_type = wcd_type",),
("ced_code = wcd_code",)])
if not codes:
return
p = 0
for cod in codes:
for i, c in enumerate(cod):
if rtype == "E" and i == 3:
continue
self.df.loadEntry("C", pag, p, data=c)
p = p + 1
if focus:
self.df.focusField("C", pag, p+1)
else:
self.df.last[pag][1] = p + 1
def doCodeDelete(self):
if self.df.pag == 4:
rtype = "E"
else:
rtype = "D"
code = self.df.c_work[self.df.pag][self.df.row][self.df.idx-2]
self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno), ("wcd_type", "=", rtype),
("wcd_code", "=", code)])
self.doLoadEarnDed(rtype, focus=True)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields(("T",0,None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(("T",1,None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(("T",2,None))
if not mes and self.df.t_work[1][0][15] == "E":
frt, pag, col, mes = self.df.doCheckFields(("T",3,None))
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col+1
else:
self.df.last[pag][1] = col+1
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col+1), err=mes)
else:
data = [self.opts["conum"]]
for p in range(0, self.df.pgs):
for x in range(0, self.df.topq[p]):
data.append(self.df.t_work[p][0][x])
data.append(self.term)
if self.new:
self.sql.insRec("wagmst", data=data)
for b in range(3):
data = [self.opts["conum"], self.empno, b+1,
self.df.t_work[6][0][b], ""]
self.sql.insRec("wagbal", data=data)
else:
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
if data != self.oldm[:len(data)]:
col = self.sql.wagmst_col
data.append(self.oldm[col.index("wgm_xflag")])
self.sql.updRec("wagmst", data=data, where=[("wgm_cono",
"=", self.opts["conum"]), ("wgm_empno", "=",
self.empno)])
for num, dat in enumerate(self.oldm):
if dat != data[num]:
self.sql.insRec("chglog", data=["wagmst", "U",
"%03i%05i" % (self.opts["conum"], self.empno),
col[num], dte, self.opts["capnm"], str(dat),
str(data[num]), "", 0])
for n, b in enumerate(self.df.t_work[6][0]):
lvl = n + 1
data = [self.opts["conum"], self.empno, lvl, b]
whr = [
("wbl_cono", "=", self.opts["conum"]),
("wbl_empno", "=", self.empno),
("wbl_balno", "=", lvl)]
chk = self.sql.getRec("wagbal", where=whr, limit=1)
if not chk:
self.sql.insRec("wagbal", data=data)
continue
if data != self.oldb[n][:len(data)]:
col = self.sql.wagbal_col
data.append(self.oldb[n][col.index("wbl_xflag")])
self.sql.updRec("wagbal", data=data, where=whr)
for num, dat in enumerate(self.oldb[n]):
if dat != data[num]:
self.sql.insRec("chglog", data=["wagbal", "U",
"%03i%05i%i" % (self.opts["conum"],
self.empno, lvl), col[num], dte,
self.opts["capnm"], str(dat),
str(data[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("General")
self.df.focusField("T", 0, 1)
def doMainDelete(self):
t = self.sql.getRec("wagtf1", cols=["count(*)"],
where=[("wt1_cono", "=", self.opts["conum"]), ("wt1_empno", "=",
self.empno)], limit=1)
if t[0]:
return "Transactions 1 Exist, Not Deleted"
t = self.sql.getRec("wagtf2", cols=["count(*)"],
where=[("wt2_cono", "=", self.opts["conum"]), ("wt2_empno=%s", "=",
self.empno)], limit=1)
if t[0]:
return "Transactions 2 Exist, Not Deleted"
t = self.sql.getRec("wagltf", cols=["count(*)"],
where=[("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=",
self.empno)], limit=1)
if t[0]:
return "Loan Transactions Exist, Not Deleted"
self.sql.delRec("wagbal", where=[("wbl_cono", "=", self.opts["conum"]),
("wbl_empno", "=", self.empno)])
self.sql.delRec("wagcap", where=[("wcp_cono", "=", self.opts["conum"]),
("wcp_empno", "=", self.empno)])
self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno)])
self.sql.delRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)])
self.sql.delRec("wagmst", where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["wagmst", "D", "%03i%05i" %
(self.opts["conum"], self.empno), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doPrint(self):
tables = []
for pag in range(0, (self.df.pgs+1)):
for x in range(0, self.df.topq[pag]):
lin = []
lin.append(self.df.topf[pag][x][3])
lin.append(self.df.t_disp[pag][0][x])
tables.append(lin)
heads = ["Salaries and Wages File Maintenance"]
cols = [["a","NA",30.0,"Field Name"],
["b","NA",30.0,"Values"]]
state = self.df.disableButtonsTags()
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=tables,
heads=heads, cols=cols, conum=self.opts["conum"],
conam=self.opts["conam"], ttype="D")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.selPage("General")
self.df.focusField("T", 0, 1)
def doExit(self):
if self.df.pag == 0:
self.doCloseProcess()
elif self.df.pag == 1:
self.df.focusField("T", 0, 3)
elif self.df.pag == 2:
self.df.selPage("General")
elif self.df.pag == 3:
self.df.selPage("Tax")
elif self.df.pag == 4:
self.df.selPage("Deductions")
elif self.df.pag == 5:
self.df.selPage("Balances")
def doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class st3110(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, ["ctlvrf", "strgrp", "strloc",
"strprc", "strmf1", "strmf2", "strtrn"],
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"]
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"]),
"Print Stores Labels (%s)" % self.__class__.__name__)
loc = {
"stype": "R",
"tables": ("strloc",),
"cols": (
("srl_loc", "", 0, "L"),
("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]}
gpm = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
stm = {
"stype": "R",
"tables": ("strmf1",),
"cols": (
("st1_group", "", 0, "Grp"),
("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [["T", "st1_group", 2, 0]],
"index": 1}
lab = {
"stype": "C",
"head": ("Codes",),
"data": list(labels.keys())}
r1s = (("Normal", "N"), ("Recipes", "R"))
r2s = (("Average", "A"), ("Standard", "S"), ("All", "B"))
r3s = (("No", "N"), ("Yes", "Y"))
fld = [
(("T",0,0,0),"ID1",10,"Reporting Date","",
self.sysdtw,"Y",self.doDate,None,None,("efld",)),
[("T",0,1,0),"IUA",1,"Location","",
0,"Y",self.doLoc,loc,None,None],
(("T",0,2,0),"IUA",3,"Product Group","",
"","Y",self.doGrp,gpm,None,None),
(("T",0,3,0),"INA",20,"Product Code","",
"","Y",self.doCode,stm,None,None),
(("T",0,4,0),("IRB",r1s),0,"Item Types","",
"N","Y",self.doTypes,None,None,None),
(("T",0,5,0),("IRB",r2s),0,"Value Indicator","",
"A","Y",self.doValInd,None,None,None),
(("T",0,6,0),("IRB",r3s),0,"Include Out of Stock ","",
"N","Y",self.doOuts,None,None,None),
(("T",0,7,0),"IUA",10,"Cost Price Code","",
"","Y",self.doCCode,None,None,None),
(("T",0,8,0),"IUA",5,"Avery A4 Code","",
"L7159","Y",self.doAvery,lab,None,("in",labels)),
(("T",0,9,0),"IUI",2,"First Label Row","",
1,"Y",self.doRow,None,None,("notzero",)),
(("T",0,10,0),"IUI",2,"First Label Column","",
1,"Y",self.doCol,None,None,("notzero",))]
if self.locs == "N":
fld[1][1] = "OUA"
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"))
def doDate(self, frt, pag, r, c, p, i, w):
self.date = w
if self.locs == "N":
self.loc = "1"
self.df.loadEntry(frt, pag, p+1, data=self.loc)
return "sk1"
def doLoc(self, frt, pag, r, c, p, i, w):
self.loc = w
if self.loc:
acc = self.sql.getRec("strloc", cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=",
self.loc)], limit=1)
if not acc:
return "Invalid Location Code"
def doGrp(self, frt, pag, r, c, p, i, w):
self.grp = w
if self.grp:
acc = self.sql.getRec("strgrp", cols=["gpm_group"],
where=[("gpm_cono", "=", self.opts["conum"]), ("gpm_group",
"=", w)], limit=1)
if not acc:
return "Invalid Group"
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
if self.code:
acc = self.sql.getRec("strmf1", cols=["st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]), ("st1_group",
"=", self.grp), ("st1_code", "=", w), ("st1_type", "<>", "X")],
limit=1)
if not acc:
return "Invalid or Redundant Code"
def doTypes(self, frt, pag, r, c, p, i, w):
self.types = w
def doValInd(self, frt, pag, r, c, p, i, w):
self.valind = w
def doOuts(self, frt, pag, r, c, p, i, w):
self.outs = w
def doCCode(self, frt, pag, r, c, p, i, w):
self.ccode = w
if self.ccode:
spl = w.split()
if len(spl) != 1 or len(spl[0]) != 10:
return "Must Have 10 Valid Characters"
def doAvery(self, frt, pag, r, c, p, i, w):
self.label = w
def doRow(self, frt, pag, r, c, p, i, w):
if w > labels[self.label]["NY"]:
return "Out of Range"
self.srow = w
def doCol(self, frt, pag, r, c, p, i, w):
if w > labels[self.label]["NX"]:
return "Out of Range"
self.scol = w
def doEnd(self):
self.df.closeProcess()
self.prnt = False
whr = [("st1_cono", "=", self.opts["conum"])]
if self.grp:
whr.append(("st1_group", "=", self.grp))
if self.code:
whr.append(("st1_code", "=", self.code))
whr.append(("st1_type", "=", self.types))
if self.valind in ("A", "S"):
whr.append(("st1_value_ind", "=", self.valind))
if self.loc:
whr.append(("st2_loc", "=", self.loc))
whr.extend([
("st2_cono=st1_cono",),
("st2_group=st1_group",),
("st2_code=st1_code",)])
rec = self.sql.getRec(tables=["strmf1", "strmf2"], cols=["st2_loc",
"st2_group", "st2_code", "st1_desc", "st1_value_ind",
"st1_vatcode"], where=whr, order="st2_group, st2_code, st2_loc")
if not rec:
showError(self.opts["mf"].body, "Error", "No Records Selected")
else:
self.fpdf = TartanLabel(self.label, posY=self.srow, posX=self.scol)
self.fpdf.add_page()
p = ProgressBar(self.opts["mf"].body, mxs=len(rec), esc=True)
for num, dat in enumerate(rec):
p.displayProgress(num)
if p.quit:
break
self.doProcess(dat)
p.closeProgress()
if self.fpdf.page and not p.quit:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=self.df.repprt)
self.closeProcess()
def doProcess(self, dat):
loc, group, code, desc, valind, vatcod = dat
icost, bal = getCost(self.sql, self.opts["conum"], group, code,
loc=loc, qty=1, ind="I", bal=True)
if self.outs == "N" and not bal[0]:
return
if self.ccode:
# Calculate cost price code
cost = CCD(int(icost * 100), "UI", 9)
ncost = " " * (9 - len(str(cost.work)))
for x in str(cost.work):
ncost = ncost + self.ccode[int(x)]
lab = "%-30s %13s" % (self.df.t_disp[0][0][0], ncost)
else:
lab = "%-30s" % self.df.t_disp[0][0][0]
####################################################################
lab = "%s\n%s %s %s" % (lab, loc, group, code)
lab = "%s\n%s\n" % (lab, desc)
prc = getSell(self.sql, self.opts["conum"], group, code, loc)
price1 = CCD(prc, "UD", 9.2)
vrte = getVatRate(self.sql, self.opts["conum"], vatcod, self.date)
if vrte is None:
vrte = CCD(0, "UD", 9.2)
else:
vrte = CCD(vrte, "UD", 9.2)
price2 = CCD(round((price1.work * float(ASD(100) + \
ASD(vrte.work)) / 100.0), 2), "OUD", 9.2)
lab = "%s\n%s %s %s" % (lab, vatcod, price1.disp, price2.disp)
self.fpdf.add_label(lab)
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class st1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlvmf", "ctlrep", "drschn", "drsmst", "genmst", "slsiv1",
"slsiv2", "strgrp", "strloc", "strmf1", "strmf2", "strgmu",
"strcmu", "strprc", "strrcp", "struoi", "strtrn", "strpot",
"strvar", "slsiv3", "chglog"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
self.automu = strctl["cts_automu"]
self.drsctl = gc.getCtl("drsctl", self.opts["conum"], error=False)
if not self.drsctl:
self.chains = "N"
else:
self.chains = self.drsctl["ctd_chain"]
return True
def mainProcess(self):
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [],
"index":
1
}
loc = {
"stype":
"R",
"tables": ("strloc", ),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]
}
unm = {
"stype":
"R",
"tables": ("struoi", ),
"cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0,
"Description", "Y")),
"where": [("unm_cono", "=", self.opts["conum"])]
}
drc = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_stat", "<>", "X")]
drm["whera"] = [["T", "drm_chain", 10]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0), ("drm_stat", "<>", "X")]
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
tag = (("Basic-_A", None, ("T", 0, 0),
("T", 0, 1)), ("Basic-_B", None, ("T", 0, 0), ("T", 0, 1)),
("Recipes", self.doReadLoadRecipe, None, ("T", 0, 1)))
r1s = (("Normal", "N"), ("Recipe", "R"))
r2s = (("Average", "A"), ("Standard", "S"), ("None", "N"))
r3s = (("Manual", "M"), ("Automatic", "A"), ("Zero", "N"))
self.fld = [(("T", 0, 0, 0), "IUA", 3, "Group", "Product Group", "",
"Y", self.doGroup, gpm, None, ("notblank", )),
(("T", 0, 0, 0), "INA", 20, "Code", "Product Code", "",
"N", self.doCode, stm, None, ("notblank", )),
(("T", 0, 0, 0), "IUA", 1, "Loc", "Location", "1", "N",
self.doLoc, loc, None, ("notblank", )),
(("T", 0, 0, 0), "ONA", 30, ""),
(("T", 1, 0, 0), ("IRB", r1s), 0, "Type of Item", "", "N",
"N", self.doType, None, None, None),
(("T", 1, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 1, 2, 0), "INA", 10, "Unit of Issue", "", "", "N",
self.doUoi, unm, None, ("notblank", )),
(("T", 1, 2, 0), "ONA", 30, ""),
(("T", 1, 3, 0), ("IRB", r2s), 0, "Cost Price Indicator",
"", "A", "N", self.doValInd, None, None, None),
(("T", 1, 4, 0), "IUA", 1, "VAT Code", "", "", "N",
self.doVat, vtm, None, ("notblank", )),
(("T", 1, 4, 0), "ONA", 30, ""),
(("T", 1, 5, 0), "IUI", 3, "Exclusive Chainstore", "", "",
"N", self.doChnExcl, drc, None, ("efld", )),
(("T", 1, 5, 0), "ONA", 30, ""),
(("T", 1, 6, 0), "INA", 7, "Exclusive Account", "", "",
"N", self.doAccExcl, drm, None, ("efld", )),
(("T", 1, 6, 0), "ONA", 30, ""),
(("T", 1, 7, 0), "IUI", 7, "Sales Code", "", "", "N",
self.doSales, glm, None, ("efld", )),
(("T", 1, 7, 0), "ONA", 30, ""),
(("T", 1, 8, 0), "IUI", 7, "COS Code", "", "", "N",
self.doCos, glm, None, ("efld", )),
(("T", 1, 8, 0), "ONA", 30, ""),
(("T", 2, 0, 0), "IUA", 8, "Bin Number", "", "", "N", None,
None, self.doDelete, ("efld", )),
(("T", 2, 1, 0), ("IRB", r3s), 0, "Re-Order Indicator", "",
"A", "N", self.doReord, None, None, None),
(("T", 2, 2, 0), "IUI", 7, "Re-Order Level", "", "", "N",
None, None, None, ("efld", )),
(("T", 2, 3, 0), "IUI", 7, "Re-Order Quantity", "", "",
"N", None, None, None, ("efld", ))]
if self.automu in ("A", "L"):
self.fld.append(
(("T", 2, 4, 0), "IUD", 6.2, "Percentabge Markup Lv1", "", "",
"N", None, None, None, ("efld", )))
for x in range(1, self.plevs):
self.fld.append((("T", 2, 4, 0), "IUD", 6.2, "Lv%s" % (x + 1),
"", "", "N", None, None, None, ("efld", )))
self.fld.extend([(("C", 3, 0, 0), "INA", 3, "Grp", "Product Group",
"r", "N", self.doRecGrp, gpm, None, None),
(("C", 3, 0,
1), "INA", 20, "Product-Code", "Product Code", "",
"N", self.doRecCod, stm, None, None),
(("C", 3, 0, 2), "ONA", 30, "Description"),
(("C", 3, 0, 3), "IUD", 11.2, "Quantity", "", "", "N",
self.doRecQty, None, self.doDelRec, ("notzero", ))])
but = (("Edit", None, self.doEditor, 0, ("C", 3, 1), None),
("Accept", None, self.doAccept, 0, ("T", 0, 0), ("T", 0, 1)),
("Cancel", None, self.doCancel, 0, ("T", 0, 0),
("T", 0, 1)), ("Quit", None, self.doQuit, 1, None, None))
tnd = ((self.doEnd, "N"), (self.doEnd, "N"), (self.doEnd, "Y"), None)
txt = (self.doExit, self.doExit, self.doExit, self.doExit)
cnd = (None, None, None, (self.doEnd, "N"))
cxt = (None, None, None, self.doExit)
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.pag == 0 or not self.gtype:
return
if opts[0] == (1, 0) and not self.newcode:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doGroup(self, frt, pag, r, c, p, i, w):
self.grpacc = self.sql.getRec(
"strgrp",
cols=["gpm_vatcode", "gpm_sales", "gpm_costs"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not self.grpacc:
return "Invalid Group"
self.group = w
self.df.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]]
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.mups = [0, 0, 0, 0, 0]
self.old1 = self.sql.getRec("strmf1",
where=[("st1_cono", "=",
self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", w)],
limit=1)
if not self.old1:
self.newcode = True
self.gtype = None
elif self.old1[3] == "X":
return "Redundant Code"
else:
self.newcode = False
d = 3
for x in range(0, self.df.topq[1]):
if x in (3, 6, 8, 10, 12, 14):
continue
if x == 0:
self.gtype = self.old1[d]
self.df.loadEntry("T", 1, x, data=self.old1[d])
if x == 2:
get = self.getUoi(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 5:
get = self.getVat(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 7:
get = self.getChnExcl(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 9:
get = self.getAccExcl(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if self.glint == "Y" and x in (11, 13):
get = self.getGenDes(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
d += 1
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("T", 0, 2, data=self.loc)
err = self.checkLoc()
if err:
return err
return "sk1"
def doLoc(self, frt, pag, r, c, p, i, w):
if w == 0:
return "Invalid Location"
self.loc = w
err = self.checkLoc()
if err:
return err
def checkLoc(self):
acc = self.sql.getRec("strloc",
cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location Code"
else:
self.df.loadEntry("T", 0, 3, data=acc[0])
self.old2 = self.sql.getRec("strmf2",
where=[("st2_cono", "=",
self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not self.old2:
ok = askQuestion(self.opts["mf"].body, "New Location",
"This location does not exist for this product. " \
"Are you sure that you want to create it?")
if ok == "yes":
self.newloc = "Y"
else:
return "Rejected Location"
if not self.old2:
self.newloc = "Y"
else:
self.newloc = "N"
d = 3
for x in range(0, 4):
d = d + 1
self.df.loadEntry("T", 2, x, data=self.old2[d])
if self.automu in ("A", "L"):
for y in range(self.plevs):
mup = getMarkup(self.sql, self.opts["conum"], self.group,
self.code, self.loc, y + 1)
self.df.loadEntry("T", 2, 4 + y, data=mup)
self.mups[y] = mup
def doType(self, frt, pag, r, c, p, i, w):
self.gtype = w
if self.gtype == "R":
self.df.enableTag(2)
else:
self.df.disableTag(2)
def doUoi(self, frt, pag, r, c, p, i, w):
acc = self.getUoi(w)
if not acc:
return "Invalid UOI Record"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doValInd(self, frt, pag, r, c, p, i, w):
self.df.topf[1][5][5] = self.grpacc[0]
def doVat(self, frt, pag, r, c, p, i, w):
acc = self.getVat(w)
if not acc:
return "Invalid VAT Record"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if not self.drsctl:
self.chain = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
if self.glint == "N":
return "sk9"
else:
return "sk4"
def doChnExcl(self, frt, pag, r, c, p, i, w):
if w:
acc = self.getChnExcl(w)
if not acc:
return "Invalid Chainstore"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
self.chain = w
def doAccExcl(self, frt, pag, r, c, p, i, w):
if w:
acc = self.getAccExcl(w)
if not acc:
return "Invalid Debtors Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if self.glint == "N":
return "sk5"
if self.newcode:
self.df.loadEntry(frt, pag, p + 2, data=self.grpacc[1])
if self.grpacc[1]:
acc = self.getGenDes(self.grpacc[1])
if not acc:
return "Invalid Sales Code"
self.df.loadEntry(frt, pag, p + 3, data=acc[0])
self.df.loadEntry(frt, pag, p + 4, data=self.grpacc[2])
if self.grpacc[2]:
acc = self.getGenDes(self.grpacc[2])
if not acc:
return "Invalid C.O.S. Code"
self.df.loadEntry(frt, pag, p + 5, data=acc[0])
def doSales(self, frt, pag, r, c, p, i, w):
acc = self.getGenDes(w)
if not acc:
return "Invalid Sales Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doCos(self, frt, pag, r, c, p, i, w):
acc = self.getGenDes(w)
if not acc:
return "Invalid COS Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doReord(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data=0)
return "sk2"
def getUoi(self, dat):
acc = self.sql.getRec("struoi",
cols=["unm_desc"],
where=[("unm_cono", "=", self.opts["conum"]),
("unm_unit", "=", dat)],
limit=1)
return acc
def getVat(self, dat):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", dat)],
limit=1)
return acc
def getChnExcl(self, dat):
self.chain = dat
if dat:
acc = self.sql.getRec("drschn",
cols=["chm_name"],
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", dat)],
limit=1)
return acc
def getAccExcl(self, dat):
if dat:
acc = self.sql.getRec("drsmst",
cols=["drm_name"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", dat),
("drm_stat", "<>", "X")],
limit=1)
return acc
def getGenDes(self, dat):
if dat:
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", dat)],
limit=1)
return acc
def doRecGrp(self, frt, pag, r, c, p, i, w):
self.rgroup = w
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.df.topf[0][1][8]["whera"] = [["C", "st1_group", 0, 3]]
def doRecCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.rgroup),
("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] == "R":
return "Invalid Type (Recipe)"
self.df.loadEntry(frt, pag, p + 1, data=acc[1])
acc = self.sql.getRec("strmf2",
cols=["st2_bin"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.rgroup),
("st2_code", "=", w),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Code (2)"
self.rcode = w
acc = self.sql.getRec("strrcp",
cols=["srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)],
limit=1)
if acc:
self.newrec = "n"
self.df.loadEntry(frt, pag, p + 2, data=acc[0])
else:
self.newrec = "y"
def doRecQty(self, frt, pag, r, c, p, i, w):
self.rqty = w
def doEditor(self):
if self.df.pag != 3:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
# Display recipe items and allow editing of details
data = self.sql.getRec(
tables=["strrcp", "strmf1"],
cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code), ("srr_loc", "=", self.loc),
("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ),
("st1_code=srr_rcode", )])
if data:
titl = "Recipe Items"
head = ("Grp", "Product-Code", "Description", "Quantity")
lin = {
"stype": "C",
"titl": titl,
"head": head,
"typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 10.2)),
"data": data
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select a Product to Edit")
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.change = chg.selection
self.doChgChanges()
self.df.enableButtonsTags(state=state)
self.df.focusField("C", 3, self.df.col)
def doChgChanges(self):
tit = ("Change Items", )
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"])],
"whera": [],
"index":
1
}
fld = ((("T", 0, 0, 0), "INA", 3, "Group", "Product Group", "", "N",
self.doChgGrp, gpm, None, ('notblank', )),
(("T", 0, 1, 0), "INA", 20, "Code", "Product Code", "", "N",
self.doChgCod, stm, None,
('notblank', )), (("T", 0, 2, 0), "ONA", 30, "Description"),
(("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N",
self.doChgQty, None, None, ('notzero', )))
but = [["Delete", None, self.doChgDel, 1, None, None]]
self.cg = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=((self.doChgEnd, "n"), ),
txit=(self.doChgExit, ))
self.cg.loadEntry("T", 0, 0, data=self.change[0])
self.cg.loadEntry("T", 0, 1, data=self.change[1])
self.cg.loadEntry("T", 0, 2, data=self.change[2])
self.cg.loadEntry("T", 0, 3, data=self.change[3])
self.cg.focusField("T", 0, 1, clr=False)
self.cg.mstFrame.wait_window()
def doChgGrp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.rgroup = w
self.cg.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]]
def doChgCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.rgroup),
("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] != "N":
return "Invalid Type"
cnt = self.sql.getRec("strrcp",
cols=["count(*)"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.rgroup),
("srr_code", "=", w)],
limit=1)
if cnt[0]:
return "Product Already In Recipe"
self.rcode = w
self.cg.loadEntry("T", 0, 2, data=acc[1])
def doChgQty(self, frt, pag, r, c, p, i, w):
self.rqty = w
def doChgDel(self):
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.change[0]),
("srr_rcode", "=", self.change[1])])
self.doReadLoadRecipe()
self.doChgExit()
def doChgEnd(self):
self.sql.updRec("strrcp",
cols=["srr_rgroup", "srr_rcode", "srr_rqty"],
data=[self.rgroup, self.rcode, self.rqty],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.loc),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.change[0]),
("srr_rcode", "=", self.change[1])])
self.doReadLoadRecipe()
self.doChgExit()
def doChgExit(self):
self.cg.closeProcess()
def doDelete(self):
trn = self.sql.getRec("strpot",
cols=["count(*)"],
where=[("pot_cono", "=", self.opts["conum"]),
("pot_group", "=", self.group),
("pot_code", "=", self.code)],
limit=1)
if trn[0]:
return "Purchase Orders Exist, Not Deleted"
trn = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_group", "=", self.group),
("stt_code", "=", self.code),
("stt_loc", "=", self.loc)],
limit=1)
if trn[0]:
return "Stores Transactions Exist, Not Deleted"
trn = self.sql.getRec("slsiv2",
cols=["count(*)"],
where=[("si2_cono", "=", self.opts["conum"]),
("si2_group", "=", self.group),
("si2_code", "=", self.code),
("si2_loc", "=", self.loc)],
limit=1)
if trn[0]:
return "Sales-2 Transactions Exist, Not Deleted"
trn = self.sql.getRec("slsiv3",
cols=["count(*)"],
where=[("si3_cono", "=", self.opts["conum"]),
("si3_rgroup", "=", self.group),
("si3_rcode", "=", self.code)],
limit=1)
if trn[0]:
return "Sales-3 Transactions Exist, Not Deleted"
self.sql.delRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["strmf2", "D", "%03i%-3s%-20s%-1s" % \
(self.opts["conum"], self.group, self.code, self.loc), "", dte,
self.opts["capnm"], "", "", "", 0])
st2 = self.sql.getRec("strmf2",
cols=["count(*)"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code)],
limit=1)
if not st2[0]:
self.sql.delRec("strmf1",
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", self.code)])
self.sql.insRec("chglog", data=["strmf1", "D", "%03i%-3s%-20s" % \
(self.opts["conum"], self.group, self.code), "", dte,
self.opts["capnm"], "", "", "", 0])
# Other Files
self.sql.delRec("strcst",
where=[("stc_cono", "=", self.opts["conum"]),
("stc_group", "=", self.group),
("stc_code", "=", self.code),
("stc_loc", "=", self.loc)])
self.sql.delRec("strprc",
where=[("stp_cono", "=", self.opts["conum"]),
("stp_group", "=", self.group),
("stp_code", "=", self.code),
("stp_loc", "=", self.loc)])
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc)])
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.group),
("srr_rcode", "=", self.code)])
self.sql.delRec("strvar",
where=[("stv_cono", "=", self.opts["conum"]),
("stv_group", "=", self.group),
("stv_code", "=", self.code),
("stv_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doDelRec(self):
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)])
self.df.clearLine(2, focus=True)
def doEnd(self):
if self.df.frt == "T" and self.df.pag == 0:
if self.newcode:
self.df.focusField("T", 1, 1)
else:
if self.gtype == "R":
self.df.enableTag(2)
self.df.skip[1] = [1]
self.df.focusField("T", 1, 2, clr=False)
elif self.df.frt == "T" and self.df.pag == 1:
self.df.selPage("Basic-B")
elif self.df.frt == "T" and self.df.pag == 2:
if self.gtype == "R":
self.df.selPage("Recipes")
else:
self.doEnder()
elif self.df.frt == "C" and self.df.pag == 3:
data = [
self.opts["conum"], self.group, self.code, self.loc,
self.rgroup, self.rcode, self.rqty
]
if self.newrec == "y":
self.sql.insRec("strrcp", data=data)
self.df.advanceLine(3)
else:
whr = [("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)]
self.sql.updRec("strrcp", data=data, where=whr)
self.doReadLoadRecipe()
def doEnder(self):
data = [self.opts["conum"]]
for x in range(0, 2):
data.append(self.df.t_work[0][0][x])
for x in range(0, len(self.df.t_work[1][0])):
if x in (3, 6, 8, 10, 12, 14):
continue
data.append(self.df.t_work[1][0][x])
if self.newcode:
self.sql.insRec("strmf1", data=data)
elif data != self.old1[:len(data)]:
col = self.sql.strmf1_col
data.append(self.old1[col.index("st1_xflag")])
self.sql.updRec("strmf1",
data=data,
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old1):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"strmf1", "U",
"%03i%-3s%-20s" %
(self.opts["conum"], self.group, self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
data = [self.opts["conum"], self.group, self.code, self.loc]
for x in range(0, 4):
data.append(self.df.t_work[2][0][x])
if self.newloc == "Y":
self.sql.insRec("strmf2", data=data)
elif data != self.old2[:len(data)]:
col = self.sql.strmf2_col
data.append(self.old2[col.index("st2_xflag")])
self.sql.updRec("strmf2",
data=data,
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old2):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"strmf2", "U",
"%03i%-3s%-20s%-1s" %
(self.opts["conum"], self.group,
self.code, self.loc), col[num], dte,
self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.sql.delRec("strcmu",
where=[("smc_cono", "=", self.opts["conum"]),
("smc_group", "=", self.group),
("smc_code", "=", self.code),
("smc_loc", "=", self.loc)])
for num, mup in enumerate(self.df.t_work[2][0][4:]):
if mup and mup != self.mups[num]:
self.sql.insRec("strcmu",
data=[
self.opts["conum"], self.group, self.code,
self.loc, num + 1, mup
])
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doReadLoadRecipe(self):
self.df.clearFrame("C", 3)
self.df.focusField("C", 3, 1)
rec = self.sql.getRec(
tables=["strrcp", "strmf1"],
cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code), ("srr_loc", "=", self.loc),
("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ),
("st1_code=srr_rcode", )])
if rec:
mxs = (self.df.rows[3] - 1) * self.df.colq[3]
for l, r in enumerate(rec):
for i, d in enumerate(r):
c = l * self.df.colq[3]
if c > mxs:
c = mxs
self.df.loadEntry("C", 3, (c + i), data=d)
self.df.advanceLine(3)
def doExit(self):
if self.df.frt == "T" and self.df.pag == 0:
self.doQuit()
elif self.df.frt == "T" and self.df.pag == 1:
if self.newcode:
self.df.focusField("T", 1, 1)
else:
self.df.skip[1] = [1]
self.df.focusField("T", 1, 2, clr=False)
elif self.df.frt == "T" and self.df.pag == 2:
self.df.focusField("T", 2, 1)
elif self.df.frt == "C" and self.df.pag == 3:
if self.df.col == 1:
self.df.focusField("C", 3, 1)
else:
self.doEnder()
def doAccept(self):
ok = "yes"
for page in (1, 2):
frt, pag, col, err = self.df.doCheckFields(("T", page, None))
if err:
ok = "no"
if pag and pag != self.df.pag:
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col + 1), err=err)
break
if ok == "yes":
self.doEnder()
def doQuit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
class rt4010(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,
["rtlprm", "rtlmst", "rtlcon", "rtltrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2])
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Rental Ledger Interrogation (%s)" %
self.__class__.__name__)
prm = {
"stype":
"R",
"tables": ("rtlprm", ),
"cols": (("rtp_code", "", 0, "Prm-Code"), ("rtp_desc", "", 0,
"Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]
}
acc = {
"stype":
"R",
"tables": ("rtlmst", ),
"cols":
(("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")),
"where": [("rtm_cono", "=", self.opts["conum"])],
"whera": (("T", "rtm_code", 0, 0), )
}
seq = {
"stype":
"R",
"tables": ("rtlcon", ),
"cols":
(("rtc_cnum", "", 0, "Acc-Num"), ("rtc_payind", "", 0, "F"),
("rtc_start", "", 0, "Start-Date"), ("rtc_period", "", 0, "Per")),
"where": [("rtc_cono", "=", self.opts["conum"])],
"whera": [["T", "rtc_code", 0, 0], ["T", "rtc_acno", 1, 0]]
}
tag = (("Premises", self.doTagSelect, ("T", 0, 0), ("T", 0, 1)),
("Tenant", self.doTagSelect, ("T", 0, 0), ("T", 0, 1)),
("Balances", self.doTagSelect, ("T", 0, 0), ("T", 0, 1)),
("Transactions", self.doTrans1, ("T", 0, 0), ("T", 0, 1)))
fld = ((("T", 0, 0, 0), "INA", 7, "Premises", "Premises Code", "", "Y",
self.doPremises, prm, None, ("notblank", )),
(("T", 0, 0, 0), "INA", 7, "Account", "Account Code", "", "N",
self.doAccount, acc, None,
("notblank", )), (("T", 0, 0, 0), "ONA", 30, "Name"),
(("T", 1, 0, 0), "ONA", 30,
"Description"), (("T", 1, 1, 0), "ONA", 30, "Address-1"),
(("T", 1, 2, 0), "ONA", 30,
"Address-2"), (("T", 1, 3, 0), "ONA", 30, "Address-3"),
(("T", 1, 4, 0), "ONA", 4,
"Postal Code"), (("T", 2, 0, 0), "ONA", 30, "Address-1"),
(("T", 2, 1, 0), "ONA", 30,
"Address-2"), (("T", 2, 2, 0), "ONA", 30, "Address-3"),
(("T", 2, 3, 0), "ONA", 4,
"Postal Code"), (("T", 2, 4, 0), "ONA", 20,
"Telephone Number"), (("T", 2, 5, 0), "OTX",
50, "E-Mail Address"),
(("T", 2, 6, 0), "OUA", 1,
"VAT Indicator"), (("T", 2, 7, 0), "ONA", 10, "VAT Number"),
(("T", 2, 8, 0), "OUA", 1,
"Payment Frequency"), (("T", 2, 9, 0), "OD1", 10,
"Start Date"), (("T", 2, 10, 0), "OUI",
3, "Number of Periods"),
(("T", 2, 11, 0), "OUD", 12.2,
"Rental Amount"), (("T", 2, 12, 0), "OUA", 1, "Status"),
(("C", 3, 0, 0), "OSD", 13.2, "Value", "", "", "N", None, None,
None, None, ("Details", 5)), (("T", 4, 0, 0), "IUI", 3,
"Sequence Number", "", "N", "N",
self.doTrans2, seq, None, None))
but = (("Clear", None, self.doClear, 0, ("T", 0, 0), ("T", 0, 1)),
("Notes", None, self.doNotes, 0, ("T", 0, 0), ("T", 0, 1)),
("Print", None, self.doPrint, 0, ("T", 0, 0),
("T", 0, 1)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEndTop, "N"), None, None, None, None)
txt = (self.doExit, None, None, None, self.doExit)
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
tags=tag,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
self.df.colLabel[3][0].configure(text="Rentals ")
self.df.colLabel[3][1].configure(text="Receipts")
self.df.colLabel[3][2].configure(text="Payments")
self.df.colLabel[3][3].configure(text="Journals")
self.df.colLabel[3][4].configure(text="Balance ")
def doPremises(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlprm",
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Premises"
self.code = w
for num, fld in enumerate(acc):
if num < 2 or num > 6:
continue
self.df.loadEntry("T", 1, (num - 2), data=fld)
def doAccount(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlmst",
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account"
self.acno = w
self.name = acc[self.sql.rtlmst_col.index("rtm_name")]
con = self.sql.getRec("rtlcon",
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)],
order="rtc_cnum")
if not con:
return "Invalid Contract"
self.df.loadEntry(frt, pag, p + 1, data=acc[3])
for num, fld in enumerate(acc[4:]):
self.df.loadEntry("T", 2, num, data=fld)
self.cnum = con[-1:][0][3]
self.df.topf[4][0][5] = self.cnum
for num, fld in enumerate(con[-1:][0][4:-1]):
self.df.loadEntry("T", 2, num + 8, data=fld)
self.loadBalances()
self.opts["mf"].updateStatus("")
def doEndTop(self):
self.df.last[0] = [0, 0]
self.df.setWidget(self.df.topEntry[0][0], state="disabled")
def loadBalances(self):
rtl = 0
rec = 0
pmt = 0
jnl = 0
bal = self.sql.getRec("rtltrn",
cols=["rtt_type", "round(sum(rtt_tramt), 2)"],
where=[("rtt_cono", "=", self.opts["conum"]),
("rtt_code", "=", self.code),
("rtt_acno", "=", self.acno)],
group="rtt_type",
order="rtt_type")
if bal:
for a in bal:
if a[0] == 1:
rtl = a[1]
if a[0] == 2:
rec = a[1]
if a[0] == 3:
pmt = a[1]
if a[0] == 4:
jnl = a[1]
bal = float(ASD(rtl) + ASD(rec) + ASD(pmt) + ASD(jnl))
self.df.loadEntry("C", 3, 0, data=rtl)
self.df.loadEntry("C", 3, 1, data=rec)
self.df.loadEntry("C", 3, 2, data=pmt)
self.df.loadEntry("C", 3, 3, data=jnl)
self.df.loadEntry("C", 3, 4, data=bal)
self.trn = self.sql.getRec("rtltrn",
where=[("rtt_cono", "=",
self.opts["conum"]),
("rtt_code", "=", self.code),
("rtt_acno", "=", self.acno)],
order="rtt_trdt, rtt_type")
def doTagSelect(self):
self.opts["mf"].updateStatus("")
def doTrans1(self):
self.df.focusField("T", 4, 1)
def doTrans2(self, frt, pag, r, c, p, i, w):
tit = "Transactions for Account: %s %s - %s" % \
(self.code, self.acno, self.name)
tab = ["rtltrn"]
col = (("rtt_trdt", "", 0, " Date"), ("rtt_curdt", "", 0, "Curr-Dt"),
("rtt_batch", "", 0,
"Batch"), ("rtt_type", ("XX", rttrtp), 3,
"Typ"), ("rtt_refno", "", 0, "Reference",
"Y"), ("rtt_tramt", "", 0, " Amount"),
("rtt_taxamt", "", 0, " VAT-Amount"), ("rtt_desc", "", 0,
"Details"))
whr = [("rtt_cono", "=", self.opts["conum"]),
("rtt_code", "=", self.code), ("rtt_acno", "=", self.acno)]
if w:
whr.append(("rtt_cnum", "=", w))
odr = "rtt_trdt, rtt_type"
state = self.df.disableButtonsTags()
SRec(self.opts["mf"],
screen=self.df.nb.Page2,
title=tit,
tables=tab,
cols=col,
where=whr,
order=odr)
self.df.enableButtonsTags(state=state)
self.doTrans1()
def doNotes(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
NotesCreate(self.opts["mf"], self.opts["conum"], self.opts["conam"],
self.opts["capnm"], "RTL",
"%7s%s" % (self.code, self.acno))
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doClear(self):
self.df.selPage("Premises")
self.df.focusField("T", 0, 1)
def doPrint(self):
mess = "Select the Required Print Option."
butt = (("Information", "I"), ("Transactions", "T"), ("Both", "B"),
("None", "N"))
self.doPrintOption(
askChoice(self.opts["mf"].body, "Print Options", mess, butt=butt))
if self.df.topq[self.df.pag]:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrintOption(self, opt):
if opt == "N":
return
self.head = "%03u %-101s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.pglin = 999
if opt != "T":
self.pageHeading()
self.printInfo()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
if opt == "I":
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=["N", "V", "view"])
elif opt == "B":
if not self.trn:
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=["N", "V", "view"])
else:
self.pageHeading()
self.pageHeadingTrans()
self.printTrans()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=["N", "V", "view"])
elif opt == "T":
if self.trn:
self.pageHeading()
self.pageHeadingTrans()
self.printTrans()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=["N", "V", "view"])
def printInfo(self):
for x in range(0, len(self.df.topf[0])):
self.fpdf.drawText(
"%-26s%-25s %s" %
("", self.df.topf[0][x][3], self.df.t_disp[0][0][x]))
self.fpdf.drawText()
for x in range(0, len(self.df.topf[1])):
self.fpdf.drawText(
"%-26s%-25s %s" %
("", self.df.topf[1][x][3], self.df.t_disp[1][0][x]))
self.fpdf.drawText()
for x in range(0, len(self.df.topf[2])):
self.fpdf.drawText(
"%-26s%-25s %s" %
("", self.df.topf[2][x][3], self.df.t_disp[2][0][x]))
self.fpdf.drawText()
self.pglin += 3 + len(self.df.topf[3])
self.fpdf.setFont(style="B")
self.fpdf.drawText("%26s%-34s %13s" % ("", "Details", "Amount "))
self.fpdf.drawText("%26s%s" % ("", self.fpdf.suc * 48))
self.fpdf.setFont()
desc = ("Rentals ", "Receipts", "Payments", "Journals", "Balance ")
for n, d in enumerate(self.df.c_disp[3]):
self.fpdf.drawText("%26s%-34s %13s" % ("", desc[n], d[0]))
def printTrans(self):
col = self.sql.rtltrn_col
bal = 0
for ct in self.trn:
trdt = CCD(ct[col.index("rtt_trdt")], "D1", 10)
refno = CCD(ct[col.index("rtt_refno")], "Na", 9)
trtp = CCD(ct[col.index("rtt_type")], "UI", 1)
batch = CCD(ct[col.index("rtt_batch")], "Na", 7)
desc = CCD(ct[col.index("rtt_desc")], "NA", 30)
tramt = ct[col.index("rtt_tramt")]
if tramt < 0:
debit = CCD(0, "SD", 13.2)
credit = CCD(tramt, "SD", 13.2)
else:
debit = CCD(tramt, "SD", 13.2)
credit = CCD(0, "SD", 13.2)
bal = float(ASD(bal) + ASD(tramt))
tot = CCD(bal, "SD", 13.2)
taxamt = CCD(ct[col.index("rtt_taxamt")], "SD", 13.2)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.pageHeadingTrans()
self.fpdf.drawText(
"%s %s %s %s %s %s %s %s %s" %
(trdt.disp, refno.disp, rttrtp[(trtp.work - 1)][0], batch.disp,
desc.disp, debit.disp, credit.disp, tot.disp, taxamt.disp))
self.pglin += 1
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-34s %-10s" % \
("Rentals Ledger Interrogation as at", self.sysdtd))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 6
def pageHeadingTrans(self):
self.fpdf.drawText(
"%-16s %s %s %s %s %s %s %s %s" %
("", self.df.topf[0][0][3], self.df.t_disp[0][0][0], "",
self.df.topf[0][1][3], self.df.t_disp[0][0][1], "",
self.df.topf[0][2][3], self.df.t_disp[0][0][2]))
self.fpdf.drawText()
self.fpdf.setFont(style="B")
self.fpdf.drawText("%-10s %-9s %-3s %-7s %-30s %-13s %-13s %-13s" % \
(" Date", "Reference", "Typ", "Batch", "Remarks",
" Debit", " Credit", " Balance"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 8
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class cr6020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in opts:
self.curdt = opts["args"][0]
for self.acno in opts["args"][1]:
self.doReAgeAuto()
self.opts["mf"].dbm.commitDbase()
else:
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["crsmst", "crstrn", "crsage"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
crsctl = gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.curdt = int(self.sysdtw / 100)
if "args" not in self.opts:
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def dataHeader(self):
crm = {
"stype": "R",
"tables": ("crsmst",),
"cols": (
("crm_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")),
"where": [
("crm_cono", "=", self.opts["conum"]),
("crm_stat", "<>", "X")]}
fld = [
[["T",0,0,0],"ID2",7,"Period","Current Financial Period",
self.curdt,"N",self.doCurdt,None,None,("efld",)],
[["T",0,1,0],"INA",7,"Acc-Num","Account Number",
"","N",self.doAccno,crm,None,("notblank",)],
[["T",0,1,0],"ONA",30,"Name"]]
tnd = ((self.endTop, "n"),)
txt = (self.exitTop,)
self.but = (
("Normal", None, self.doReAgeNormal, 0, None, None,
"Only Show Unallocated Transactions"),
("History", None, self.doReAgeHistory, 0, None, None,
"Show All Transactions, Including Already Allocated"),
("Automatic", None, self.doReAgeAuto, 0, None, None,
"Automatically Re-Age the Account Based on Date"))
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt, butt=self.but)
def doCurdt(self, frt, pag, r, c, p, i, w):
self.curdt = w
def doAccno(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crsmst", cols=["crm_name", "crm_stat"],
where=[("crm_cono", "=", self.opts["conum"]), ("crm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.acno = w
self.key = None
self.df.loadEntry("T", pag, p+1, data=acc[0])
self.opts["mf"].updateStatus("Select Routine")
for b in range(3):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
if self.key in ("normal", "history"):
return "nd"
elif self.key == "cancel":
return "nc"
def doReAgeNormal(self):
self.key = "normal"
self.doReAge()
def doReAgeHistory(self):
self.key = "history"
self.doReAge()
def doReAge(self):
self.opts["mf"].updateStatus("")
for b in range(3):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "disabled")
col = ["crt_trdt","crt_ref1","crt_type","crt_tramt","paid","balance"]
whr = [
("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.acno)]
if self.key == "normal":
dtc, recs = getTrn(self.opts["mf"].dbm, "crs", whr=whr, zer="N")
else:
dtc, recs = getTrn(self.opts["mf"].dbm, "crs", whr=whr)
if recs:
data = []
for rec in recs:
dat = []
for c in col:
dat.append(rec[dtc.index(c)])
data.append(dat)
age = AgeTrans(self.opts["mf"], "crs", data, 0, xits=False)
if not age.ccl and age.data:
if age.total.work:
while not age.ccl:
age.doAllocate()
if age.ccl or not age.total.work:
break
if age.ccl:
self.key = "cancel"
age.data = []
for tr in age.data:
if tr[6]:
w = copyList(whr)
w.extend([("crt_type", "=", tr[2]),
("crt_ref1", "=", tr[1])])
self.sql.insRec("crsage", data=[self.opts["conum"],
self.acno, tr[2], tr[1], self.curdt, tr[2], tr[1],
tr[6], 0])
else:
self.key = "cancel"
self.agevar.set(False)
def doReAgeAuto(self):
self.key = "normal"
if "args" not in self.opts:
for b in range(3):
wid = getattr(self.df, "B%s" % b)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Re-Ageing .... Please Wait!")
self.df.setWidget(self.df.mstFrame, state="hide")
txt = "Re-Allocating ... Please Wait"
pb = ProgressBar(self.opts["mf"].body, typ=("G", txt))
doAutoAge(self.opts["mf"].dbm, "crs", self.opts["conum"],
acno=self.acno, pbar=pb)
pb.closeProgress()
self.df.setWidget(self.df.mstFrame, state="show")
self.agevar.set(False)
else:
doAutoAge(self.opts["mf"].dbm, "crs", self.opts["conum"],
acno=self.acno, pbar=None)
def endTop(self):
self.df.clearEntry("T", 0, 2)
self.df.clearEntry("T", 0, 3)
self.df.focusField("T", 0, 2)
def exitTop(self):
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
class st3050(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, ["strgrp", "strmf1", "strloc",
"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.locs = strctl["cts_locs"]
self.fromad = strctl["cts_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2])
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Stores Recipe Listing (%s)" % self.__class__.__name__)
loc = {
"stype": "R",
"tables": ("strloc",),
"cols": (
("srl_loc", "", 0, "L"),
("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]}
grp = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
r1s = (("Yes","Y"), ("Singles", "S"))
r2s = (("Yes","Y"), ("No","N"))
if self.locs == "N":
self.loc = "1"
fld = []
else:
fld = [[("T",0,0,0),"IUA",1,"Location","",
"1","Y",self.doLoc,loc,None,("notblank",)]]
fld.extend([
(("T",0,1,0),"IUA",3,"Product Group","",
"","Y",self.doGroup,grp,None,None),
(("T",0,2,0),("IRB",r1s),0,"Whole File","",
"S","Y",self.doWhole,None,None,None),
(("T",0,3,0),("IRB",r2s),0,"Recipe per Page","Recipe per Page",
"N","Y",self.doPage,None,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=("Y","N"))
def doLoc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strloc", cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)],
limit=1)
if not acc:
return "Invalid Location"
self.loc = w
def doGroup(self, frt, pag, r, c, p, i, w):
if not w:
self.group = ""
else:
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 doWhole(self, frt, pag, r, c, p, i, w):
self.whole = w
def doPage(self, frt, pag, r, c, p, i, w):
self.page = w
def doEnd(self):
self.df.closeProcess()
if not self.group:
self.sgrp = ""
self.egrp = "zzz"
else:
self.sgrp = self.group
self.egrp = self.group
whr = [
("st1_cono", "=", self.opts["conum"]),
("st1_group", ">=", self.sgrp),
("st1_group", "<=", self.egrp),
("st1_type", "=", "R")]
odr = "st1_group, st1_code"
if self.whole == "S":
recs = getSingleRecords(self.opts["mf"], "strmf1",
("st1_group", "st1_code", "st1_desc"), where=whr, order=odr)
else:
recs = self.sql.getRec("strmf1", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Processing Error",
"No Records Selected")
else:
self.printReport(recs)
self.closeProcess()
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
self.head = "%03u %-71s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
oldrec = ""
self.pglin = 999
st1 = self.sql.strmf1_col
srr = self.sql.strrcp_col
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
grp = CCD(dat[st1.index("st1_group")], "UA", 3)
cod = CCD(dat[st1.index("st1_code")], "NA", 20)
dsc = CCD(dat[st1.index("st1_desc")], "NA", 30)
whr = [
("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", grp.work),
("srr_code", "=", cod.work)]
if self.locs == "Y":
whr.append(("srr_loc", "=", self.loc))
odr = "srr_rgroup, srr_rcode"
rec = self.sql.getRec("strrcp", where=whr, order=odr)
if not rec:
continue
newrec = "%s%s" % (grp.work, cod.work)
if oldrec and newrec != oldrec:
self.pageHeading(grp, cod, dsc, chg=True)
for z in rec:
if self.pglin > self.fpdf.lpp:
self.pageHeading(grp, cod, dsc)
gp = CCD(z[srr.index("srr_rgroup")], "UA", 3)
cd = CCD(z[srr.index("srr_rcode")], "NA", 20)
qt = CCD(z[srr.index("srr_rqty")], "UD", 11.2)
dd = self.sql.getRec("strmf1", cols=["st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]), ("st1_group",
"=", gp.work), ("st1_code", "=", cd.work)], limit=1)
if dd:
dc = dd[0]
else:
dc = ""
self.fpdf.drawText("%s %s %-38s %s" % (gp.disp, cd.disp, dc,
qt.disp))
self.pglin += 1
oldrec = newrec
p.closeProgress()
if self.fpdf.page and not p.quit:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
def pageHeading(self, grp, cod, dsc, chg=False):
if self.page == "N" and chg and self.pglin < (self.fpdf.lpp - 10):
self.fpdf.drawText()
self.fpdf.drawText()
self.fpdf.setFont(style="B")
self.pglin += 2
else:
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-19s %-10s" % ("Stock Recipes as at",
self.sysdtd))
self.fpdf.drawText()
self.pglin = 4
if self.locs == "Y":
self.fpdf.drawText("%-5s %s %-4s %s %-8s %s %s" %
("Group", grp.disp, "Code", cod.disp, dsc.disp,
"Loc", self.loc))
else:
self.fpdf.drawText("%-5s %s %-4s %s %s" % ("Group", grp.disp,
"Code", cod.disp, dsc.disp))
self.fpdf.drawText()
self.fpdf.drawText("%-3s %-20s %-38s %11s" % ("Grp", "Product-Code",
"Description", "Quantity"))
self.fpdf.underLine(txt=self.head)
self.pglin += 4
self.fpdf.setFont()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class sl2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(
self.opts["mf"].dbm,
["genmst", "gentrn", "wagedc", "wagmst", "waglmf", "wagltf"],
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"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["wag_slc"]):
return
self.slnctl = ctlctl["wag_slc"]
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"SLN",
2,
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0,
"Surname", "Y")),
"where": [("wgm_cono", "=", self.opts["conum"])]
}
ced = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"),
("ced_desc", "", 0, "Description", "Y")),
"where": [("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D")],
"index":
1
}
fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2,
"Value"), (("C", 0, 0, 0), "IUI", 5, "EmpNo",
"Employee Number", "", "N", self.doEmpno, wgm, None,
None), (("C", 0, 0, 1), "ONA", 20,
"Name"), (("C", 0, 0, 2), "OUI", 2, "Ln"),
(("C", 0, 0,
3), "INA", 15, "Description", "", "", "N", self.doDesc, None,
None, None), (("C", 0, 0, 4), "ID1", 10, "Date", "", "", "N",
self.doSdate, None, None, None),
(("C", 0, 0, 5), "INa", 9, "Ref-No", "Reference Number", "",
"N", self.doRef, None, None, ("notblank", )),
(("C", 0, 0, 6), "IUI", 3, "Cde", "Deduction Code", "", "N",
self.doCode, ced, None, ("notzero", )),
(("C", 0, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate", "", "N",
self.doInt, None, None,
None), (("C", 0, 0, 8), "IUD", 12.2, "Loan-Amt", "Loan Amount",
"", "N", self.doAmt, None, None, ("notzero", )),
(("C", 0, 0, 9), "IUD", 12.2, "Ded-Amt", "Deduction Amount", "",
"N", self.doDed, None, None, ("efld", )))
but = (("Interrogate", None, self.querySln, 0, ("C", 0, 1), ("C", 0,
2)), )
cnd = ((self.endPage, "y"), )
cxt = (self.exitPage, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
cend=cnd,
cxit=cxt)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 0, 1)
def doEmpno(self, frt, pag, r, c, p, i, w):
self.empno = w
acc = self.sql.getRec("wagmst",
cols=["wgm_sname", "wgm_fname"],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.name = "%s, %s" % (acc[0], acc[1].split()[0])
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.loan = getNextCode(self.sql,
"waglmf",
"wlm_loan",
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)],
start=1,
last=9999999)
self.df.loadEntry("C", pag, p + 2, data=self.loan)
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doSdate(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.sdate = w
def doRef(self, frt, pag, r, c, p, i, w):
self.ref = w
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
desc = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D"),
("ced_code", "=", w)],
limit=1)
if not desc:
return "Invalid Code"
def doInt(self, frt, pag, r, c, p, i, w):
self.rte = w
def doAmt(self, frt, pag, r, c, p, i, w):
self.amt = w
def doDed(self, frt, pag, r, c, p, i, w):
self.ded = w
def endPage(self):
self.updateTables()
self.updateBatch()
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
def exitPage(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def updateTables(self):
if self.bh.multi == "Y":
curdt = int(self.sdate / 100)
else:
curdt = self.bh.curdt
self.sql.insRec("waglmf",
data=[
self.opts["conum"], self.empno, self.loan,
self.desc, self.code, self.rte, self.sdate,
self.ded
])
self.sql.insRec("wagltf",
data=[
self.opts["conum"], self.empno, self.loan,
self.bh.batno, 2, self.sdate, self.ref, self.amt,
self.amt, self.ded, self.rte, curdt, self.desc,
"N", self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Staff Loans Control Account
data = (self.opts["conum"], self.slnctl, curdt, self.sdate, 2,
self.ref, self.bh.batno, self.amt, 0.00, self.name, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
amt = float(ASD(0) - ASD(self.amt))
# General Ledger Bank Account
data = (self.opts["conum"], self.bh.acc, curdt, self.sdate, 2,
self.ref, self.bh.batno, amt, 0.00,
"Staff Loan - %s" % self.name, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def updateBatch(self):
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.amt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def querySln(self):
callModule(self.opts["mf"],
self.df,
"sl4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class rt3030(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, ["rtlmst", "rtltrn", "rtlcon"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.fromad = rtlctl["ctr_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2])
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Rentals Ledger Master Listing (%s)" %
self.__class__.__name__)
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("All", "Y"), ("Current", "C"), ("Arrears", "A"),
("Expiring", "E"), ("Expired", "X"))
fld = ((("T", 0, 0, 0), "ID1", 10, "Report Date", "", self.sysdtw, "Y",
self.doDate, None, None, ("efld", )),
(("T", 0, 1, 0), ("IRB", r2s), 0, "Contracts",
"Contracts to Print", "Y", "Y", self.doType, None, None,
None), (("T", 0, 2, 0), "IUI", 2, "Months to Expiry", "", 1,
"Y", self.doMonths, None, None, ("notzero", )),
(("T", 0, 3, 0), ("IRB", r1s), 0, "Consolidate", "", "N", "Y",
self.doCons, None, 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=("Y", "N"))
def doDate(self, frt, pag, r, c, p, i, w):
self.date = w
self.datd = self.df.t_disp[0][0][0]
def doType(self, frt, pag, r, c, p, i, w):
self.styp = w
if self.styp != "E":
self.months = 0
if self.styp != "Y":
self.cons = "N"
return "sk2"
return "sk1"
def doMonths(self, frt, pag, r, c, p, i, w):
self.months = w
if self.styp != "Y":
self.cons = "N"
return "sk1"
def doCons(self, frt, pag, r, c, p, i, w):
self.cons = w
def doEnd(self):
self.df.closeProcess()
odr = "rtc_code, rtc_acno, rtc_cnum"
whr = [("rtc_cono", "=", self.opts["conum"]),
("rtc_start", "<=", self.date)]
if self.styp in ("C", "X"):
whr.append(("rtc_status", "=", self.styp))
if self.cons == "Y":
recs = []
cols = ["rtc_code", "rtc_acno", "max(rtc_cnum)"]
accs = self.sql.getRec("rtlcon",
cols=cols,
where=whr,
group="rtc_code, rtc_acno",
order="rtc_code, rtc_acno")
for acc in accs:
w = copyList(whr)
w.append(("rtc_code", "=", acc[0]))
w.append(("rtc_acno", "=", acc[1]))
w.append(("rtc_cnum", "=", acc[2]))
rec = self.sql.getRec("rtlcon", where=w, limit=1)
recs.append(rec)
else:
recs = self.sql.getRec("rtlcon", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Selection Error",
"No Records Selected")
else:
self.printReport(recs)
self.closeProcess()
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
self.head = "%03u %-145s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.pglin = 999
mst = self.sql.rtlmst_col
con = self.sql.rtlcon_col
self.tots = [0, 0, 0, 0, 0]
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
code = CCD(dat[con.index("rtc_code")], "NA", 7)
acno = CCD(dat[con.index("rtc_acno")], "NA", 7)
cnum = CCD(dat[con.index("rtc_cnum")], "UI", 3)
freq = CCD(dat[con.index("rtc_payind")], "UA", 1)
strt = CCD(dat[con.index("rtc_start")], "D1", 10)
prds = CCD(dat[con.index("rtc_period")], "UI", 3)
stat = CCD(dat[con.index("rtc_status")], "UA", 1)
if self.styp != "X":
curdt = int(self.date / 100)
if self.months:
yy = int(curdt / 100)
mm = (curdt % 100) + self.months
while mm > 12:
yy += 1
mm -= 12
curdt = (yy * 100) + mm
if freq.work == "M":
mths = 1 * prds.work
elif freq.work == "3":
mths = 3 * prds.work
elif freq.work == "6":
mths = 6 * prds.work
else:
mths = 12 * prds.work
yy = int(strt.work / 10000)
mm = int((strt.work % 10000) / 100) + mths - 1
while mm < 1:
yy -= 1
mm += 12
while mm > 12:
yy += 1
mm -= 12
chkmth = copyList(mthnam)
if mm == 2:
if not yy % 4:
chkmth[2][2] = 29
else:
chkmth[2][2] = 28
exdt = CCD(((yy * 10000) + (mm * 100) + chkmth[mm][2]), "D1",
10)
if self.styp == "E" and int(exdt.work / 100) > curdt:
continue
else:
exdt = CCD(0, "d1", 10)
acc = self.sql.getRec("rtlmst",
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", code.work),
("rtm_acno", "=", acno.work)],
limit=1)
name = CCD(acc[mst.index("rtm_name")], "NA", 30)
if self.cons == "Y":
trn = self.sql.getRec(
"rtltrn",
cols=["rtt_type", "round(sum(rtt_tramt), 2)"],
where=[("rtt_cono", "=", self.opts["conum"]),
("rtt_code", "=", code.work),
("rtt_acno", "=", acno.work),
("rtt_trdt", "<=", self.date)],
group="rtt_type")
else:
trn = self.sql.getRec(
"rtltrn",
cols=["rtt_type", "round(sum(rtt_tramt), 2)"],
where=[("rtt_cono", "=", self.opts["conum"]),
("rtt_code", "=", code.work),
("rtt_acno", "=", acno.work),
("rtt_cnum", "=", cnum.work),
("rtt_trdt", "<=", self.date)],
group="rtt_type")
rtl = CCD(0, "SD", 13.2)
rec = CCD(0, "SD", 13.2)
pmt = CCD(0, "SD", 13.2)
jnl = CCD(0, "SD", 13.2)
if trn:
for t in trn:
if t[0] == 1:
rtl = CCD(t[1], "SD", 13.2)
elif t[0] == 2:
rec = CCD(t[1], "SD", 13.2)
elif t[0] == 3:
pmt = CCD(t[1], "SD", 13.2)
elif t[0] == 4:
jnl = CCD(t[1], "SD", 13.2)
bal = float(ASD(rtl.work) + ASD(rec.work) + ASD(pmt.work) + \
ASD(jnl.work))
bal = CCD(bal, "SD", 13.2)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.fpdf.drawText("%s %s %s %s %s %s %s %s %s %s %s %s %s %s" % \
(code.disp, acno.disp, cnum.disp, name.disp, freq.disp,
strt.disp, prds.disp, exdt.disp, stat.disp, rtl.disp,
rec.disp, pmt.disp, jnl.disp, bal.disp))
self.tots[0] = float(ASD(self.tots[0]) + ASD(rtl.work))
self.tots[1] = float(ASD(self.tots[1]) + ASD(rec.work))
self.tots[2] = float(ASD(self.tots[2]) + ASD(pmt.work))
self.tots[3] = float(ASD(self.tots[3]) + ASD(jnl.work))
self.tots[4] = float(ASD(self.tots[4]) + ASD(bal.work))
self.pglin += 1
t = []
for x in range(5):
t.append(CCD(self.tots[x], "SD", 13.2).disp)
self.fpdf.underLine(txt=self.head)
self.fpdf.drawText("%19s %-30s %29s %-13s %-13s %-13s %-13s %-13s" % \
("", "Grand Totals", "", t[0], t[1], t[2], t[3], t[4]))
p.closeProgress()
if self.fpdf.page and not p.quit:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
self.closeProcess()
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-34s %-10s" % ("Rentals Ledger Master "\
"Report as at", self.datd))
self.fpdf.drawText()
opts = "%-14s %-1s" % ("(Options: Type", self.styp)
if self.styp == "E":
opts = "%s %-6s %-2s)" % \
(opts, "Months", self.months)
elif self.cons == "Y":
opts = "%s %-12s %-1s)" % \
(opts, "Consolidated", self.cons)
else:
opts = "%s)" % opts
self.fpdf.drawText(opts)
self.fpdf.drawText()
self.fpdf.drawText("%-7s %-7s %-3s %-30s %-1s %-10s %-3s %-10s %-1s "\
"%-13s %-13s %-13s %-13s %-13s" % ("Prm-Cod", "Acc-Num", "Seq",
"Name", "F", "Start-Date", "Per", "Expir-Date", "S",
" Rentals ", " Receipts ", " Payments ",
" Journals ", " Balance "))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 8
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class bk3010(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, ["bkmmst", "bkmcon", "bkmtrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
mc = GetCtl(self.opts["mf"])
bkmctl = mc.getCtl("bkmctl", self.opts["conum"])
if not bkmctl:
return
self.fromad = bkmctl["cbk_emadd"]
t = time.localtime()
self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2])
return True
def mainProcess(self):
tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Deposits Due")
r1s = (("No","N"), ("Yes","Y"))
r2s = (("Arrival","A"), ("Due","D"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Expired Only","",
"N","Y",self.doExpired,None,None,None),
(("T",0,1,0),("IRB",r2s),0,"Order","",
"A","Y",self.doOrder,None,None,None))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
if "args" in self.opts:
tops = self.opts["args"]
else:
tops = False
self.df = TartanDialog(self.opts["mf"], tops=tops, title=tit,
eflds=fld, tend=tnd, txit=txt, view=("Y","V"), mail=("Y","N"))
def doExpired(self, frt, pag, r, c, p, i, w):
self.expired = w
def doOrder(self, frt, pag, r, c, p, i, w):
self.order = w
def doEnd(self):
self.df.closeProcess()
tab = ["bkmmst"]
col = [
"bkm_number",
"bkm_group",
"bkm_ccode",
"bkm_arrive",
"bkm_depart",
"bkm_stddep",
"bkm_stddte",
"bkm_grpdep",
"bkm_grpdte",
"bkm_state"]
whr = [
("bkm_cono", "=", self.opts["conum"]),
("bkm_state", "in", ("C", "Q"))]
if self.order == "A":
odr = "bkm_arrive, bkm_ccode"
else:
odr = "bkm_stddte, bkm_grpdte, bkm_ccode"
recs = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr)
self.fpdf = MyFpdf(name=self.__class__.__name__, head=80, auto=True)
self.fpdf.header = self.pageHeading
self.fpdf.add_page()
newrec = []
for rec in recs:
if not rec[5] and not rec[7]:
continue
num = CCD(rec[0], "UI", 6)
trn = self.sql.getRec("bkmtrn", where=[("bkt_cono", "=",
self.opts["conum"]), ("bkt_number", "=", num.work)])
inv = False
bal = 0.0
for tr in trn:
typ = tr[self.sql.bkmtrn_col.index("bkt_type")]
amt = tr[self.sql.bkmtrn_col.index("bkt_tramt")]
bal = float(ASD(bal) + ASD(amt))
if typ == 2:
inv = True
if inv:
continue
dp1 = float(ASD(rec[5]) + ASD(bal))
dt1 = rec[6]
if dp1 > 0:
dp2 = rec[7]
dt2 = rec[8]
elif rec[7]:
dp2 = float(ASD(rec[7]) + ASD(dp1))
dt2 = rec[8]
dp1 = 0
else:
dp1 = 0
dp2 = 0
dt2 = 0
if self.expired == "Y":
if dp1 and dt1 > self.sysdtw:
continue
if not dp1 and dp2 and dt2 > self.sysdtw:
continue
elif dp1 <= 0 and dp2 <= 0:
continue
if dp1 and dp1 > 0:
b = CCD(dt1, "D1", 10).disp
if dp2:
b = "%s\n%s" % (b, CCD(dt2, "D1", 10).disp)
elif dp2 and dp2 > 0:
b = CCD(dt2, "D1", 10).disp
else:
continue
con = self.sql.getRec("bkmcon", where=[("bkc_cono", "=",
self.opts["conum"]), ("bkc_ccode", "=", rec[2])], limit=1)
snam = con[self.sql.bkmcon_col.index("bkc_sname")]
fnam = con[self.sql.bkmcon_col.index("bkc_names")]
if fnam:
c = "%s %s" % (fnam.split()[0], snam)
else:
c = snam
l = 8
if rec[1]:
c = "%s\n%s" % (c, rec[1])
l = 16
d = CCD(rec[3], "D1", 10).disp
e = CCD(rec[4], "D1", 10).disp
if dp1:
f = CCD(dp1, "UD", 10.2).disp
if dp2:
f = "%s\n%s" % (f, CCD(dp2, "UD", 10.2).disp)
l = 16
else:
f = CCD(dp2, "UD", 10.2).disp
newrec.append([num.disp, b, c, d, e, f])
if newrec:
if self.order == "D":
newrec = sorted(newrec, key=itemgetter(1))
for rec in newrec:
if self.fpdf.get_y() + l > 260:
self.fpdf.add_page()
self.printLine(rec[0], rec[1], rec[2], rec[3], rec[4], rec[5])
if self.fpdf.page:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
header=self.head, pdfnam=pdfnam, repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def pageHeading(self):
cd1 = "%-30s" % self.opts["conam"]
self.fpdf.drawText(cd1, x=7, font=["courier", "B", 24])
self.fpdf.drawText(font=["courier", "B", 14])
if self.expired == "N":
cd2 = "Deposits Due Report"
else:
cd2 = "Deposits Expired Report"
self.head = "%s - %s" % (cd1, cd2)
self.fpdf.drawText(cd2, x=7, font=["courier", "B", 16])
self.fpdf.drawText(font=["courier", "B", 14])
self.printLine("Number", " Due-Date ", "%-20s" % "Name & Group",
" Arrive ", " Depart ", " Amount", fill=1)
def printLine(self, a, b, c, d, e, f, fill=0):
ft = ["courier", "B", 13]
self.fpdf.set_font(ft[0], ft[1], ft[2])
c, cq = self.getLines(c, self.fpdf.get_string_width("X"*21))
f, fq = self.getLines(f, self.fpdf.get_string_width("X"*11))
if cq > fq:
ch = 8
h = cq * 8
fh = int(h / fq)
elif fq > cq:
fh = 8
h = fq * 8
ch = int(h / cq)
else:
h = cq * 8
ch = fh = 8
if cq > 1 or fq > 1:
ctyp = "M"
else:
ctyp = "S"
# Booking number
x = 7
y = self.fpdf.get_y()
w = self.fpdf.get_string_width("X"*7)
self.fpdf.drawText(a, x=x, y=y, w=w, h=h, border="TLB",
fill=fill, ctyp=ctyp, font=ft)
# Name and group
x += w
w = self.fpdf.get_string_width("X"*21)
self.fpdf.drawText(c, x=x, y=y, w=w, h=ch, border="TLB",
fill=fill, ctyp=ctyp, font=ft)
# Arrival date
x += w
w = self.fpdf.get_string_width("X"*11)
self.fpdf.drawText(d, x=x, y=y, w=w, h=h, border="TLB",
fill=fill, ctyp=ctyp, font=ft)
# Departure date
x += w
w = self.fpdf.get_string_width("X"*11)
self.fpdf.drawText(e, x=x, y=y, w=w, h=h, border="TLB",
fill=fill, ctyp=ctyp, font=ft)
# Deposit due date
x += w
w = self.fpdf.get_string_width("X"*11)
self.fpdf.drawText(b, x=x, y=y, w=0, h=fh, border="TLB",
fill=fill, ctyp=ctyp, font=ft)
# Deposit amount
x += w
w = self.fpdf.get_string_width("X"*11)
self.fpdf.drawText(f, x=x, y=y, w=w, h=fh, border="TLRB",
fill=fill, ctyp=ctyp, font=ft)
def getLines(self, t, w):
tmp = t.split("\n")
nam = self.fpdf.multi_cell(w, 8, tmp[0], split_only=True)
t = nam[0]
q = 1
for n in nam[1:]:
t = "%s\n%s" % (t, n)
q += 1
if len(tmp) > 1:
nam = self.fpdf.multi_cell(w, 8, tmp[1], split_only=True)
for n in nam:
t = "%s\n%s" % (t, n)
q += 1
return t, q
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class bc1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "args" in self.opts:
self.tabcvt = False
self.gentab = False
self.newtab = True
self.tab = self.opts["args"]
self.df.loadEntry("T", 0, 0, data=self.tab)
self.df.topf[0][0][1] = "OUI"
self.df.topf[0][1][1] = "OUI"
self.df.focusField("T", 0, 2)
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"chglog", "bwlent", "bwlgme", "bwltab", "bwldrt", "bwlflm",
"bwlflt", "memmst", "memkon", "memadd", "memcat"
],
prog=self.__class__.__name__)
if self.sql.error:
if self.sql.error == ["memmst", "memkon"]:
self.memmst = False
else:
return
else:
self.memmst = True
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.mlint = bwlctl["ctb_mlint"]
self.samen = bwlctl["ctb_samen"]
self.mscat = bwlctl["ctb_mscat"]
self.mstart = bwlctl["ctb_mstart"]
self.fstart = bwlctl["ctb_fstart"]
self.nstart = bwlctl["ctb_nstart"]
self.dbase = bwlctl["ctb_dbase"]
self.order = bwlctl["ctb_order"]
self.mixed = bwlctl["ctb_mixed"]
self.fromad = bwlctl["ctb_emadd"]
self.keys = (("bwltab", "btb_cono", "btb_tab"), ("bwldrt", "bdt_cono",
"bdt_tab"),
("bwlent", "bce_cono", "bce_scod"), ("bwlflt", "bft_cono",
"bft_player"),
("bwlgme", "bcg_cono", "bcg_scod"), ("bwldrt", "bdt_cono",
"bdt_team1"),
("bwldrt", "bdt_cono",
"bdt_team2"), ("bwldrt", "bdt_cono", "bdt_team3"),
("bwlflt", "bft_cono", "bft_skip"), ("bwlgme", "bcg_cono",
"bcg_ocod"))
return True
def mainProcess(self):
tab = {
"stype":
"R",
"tables": ("bwltab", ),
"cols": [("btb_tab", "", 0, "Tab"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names"),
("btb_bsano", "", 0, "BSA-No")],
"where": [("btb_cono", "=", self.opts["conum"])],
"order":
"btb_surname"
}
if self.mlint == "N":
mlm = None
else:
tab["cols"].insert(3, ("btb_memno", "", 0, "Mem-No"))
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0,
"Mem-No"), ("mlm_oldno", "", 0,
"Old-No"), ("mlm_idnum", "", 0, "Identity-Numb"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names"
}
r1s = (("Male", "M"), ("Female", "F"))
if self.dbase == "R":
r2s = (("None", "0"), )
else:
r2s = (("Skip", "4"), ("Third", "3"), ("Second", "2"), ("Lead",
"1"))
fld = [(("T", 0, 0,
0), "I@btb_tab", 0, "", "", "", "Y", self.doTab, tab, None,
("efld", ), None, "Note: Tab numbers Must be Unique."),
[("T", 0, 1, 0), "I@btb_memno", 0, "", "", "", "N",
self.doMember, mlm, self.doDelete, ("efld", )],
(("T", 0, 2, 0), "I@btb_surname", 0, "", "", "", "N",
self.doSurname, None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "I@btb_names", 0, "", "", "", "N",
self.doNames, None, None, ("efld", )),
(("T", 0, 4, 0), ("IRB", r1s), 0, "Gender", "", "M", "N",
self.doGender, None, None, None),
(("T", 0, 5, 0), "I@btb_add1", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 6, 0), "I@btb_add2", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 7, 0), "I@btb_add3", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 8, 0), "I@btb_pcod", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 9, 0), "I@btb_home", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 10, 0), "I@btb_work", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 11, 0), "I@btb_cell", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 12, 0), "I@btb_mail", 0, "", "", "", "N",
self.doEmail, None, None, ("efld", )),
(("T", 0, 13, 0), ("IRB", r2s), 0, "Position - Primary", "",
"1", "N", self.doPos, None, self.doDelete, None),
(("T", 0, 14, 0), "I@btb_rate1", 0, "", "", "", "N",
self.doRate, None, None, ("efld", )),
(("T", 0, 15, 0), ("IRB", r2s), 0, "Position - Mixed", "", "1",
"N", self.doPos, None, None, None),
(("T", 0, 16, 0), "I@btb_rate2", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 17, 0), "I@btb_bsano", 0, "", "", "", "N", None, None,
None, ("efld", ))]
if self.mlint == "N":
fld[1] = [("T", 0, 1, 0), "O@btb_memno", 0, ""]
if self.mlint == "Y":
but = []
else:
but = [("Import", None, self.doImport, 0, ("T", 0, 1),
(("T", 0, 2), ("T", 0, 3)),
"Import Tabs and/or Ratings from a CSV or XLS File.")]
but.extend([("Accept", None, self.doEnd, 0, ("T", 0, 3), ("T", 0, 0),
"Accept All Fields and Continue"),
("Convert", None, self.doConvert, 0, ("T", 0, 3),
("T", 0, 4), "Convert a Visitor's Tab to a Member's Tab"),
("Print", None, self.doPrint, 1, None, None)])
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.col == 1:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doTab(self, frt, pag, r, c, p, i, w):
self.tab = w
self.newvis = False
self.tabcvt = False
self.tabchg = False
if not self.tab:
if self.mlint == "Y" and self.samen == "Y":
ok = askQuestion(self.opts["mf"].body,
"New Tab",
"Is this TAB for a Visitor",
default="no")
if ok == "no":
return "New Member, Please Create in Ledger"
self.newvis = True
self.gentab = True
self.newtab = True
else:
self.gentab = False
self.oldtab = self.sql.getRec("bwltab",
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_tab", "=", self.tab)],
limit=1)
if not self.oldtab:
self.newtab = True
else:
self.newtab = False
for num, fld in enumerate(self.oldtab[1:-1]):
if num == 2:
self.snam = fld
elif num == 3:
self.fnam = fld
elif num == 4:
self.gender = fld
elif num in (13, 15):
fld = str(fld)
if num == 13:
self.pos1 = fld
self.df.loadEntry(frt, pag, num, data=fld)
if self.tab and self.mlint == "Y":
if self.oldtab:
memno = self.oldtab[self.sql.bwltab_col.index("btb_memno")]
elif self.tab < self.nstart and self.samen == "Y":
memno = self.tab
else:
memno = 0
else:
memno = 0
if memno:
chk = self.doLoadMember(memno)
if chk:
return chk
if self.dbase == "R":
return "sk13"
return "sk12"
if self.newvis or self.tab >= self.nstart:
return "sk1"
def doMember(self, frt, pag, r, c, p, i, w):
if w:
if self.newtab or not self.oldtab[2]:
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_memno", "=", w)],
limit=1)
if chk:
return "Member Already Has a TAB"
chk = self.doLoadMember(w)
if chk:
return chk
if self.newtab and not self.tab:
chk = self.getNextTab()
if not chk:
return "Invalid Membership Number"
if self.dbase == "R":
return "sk12"
return "sk11"
elif self.tab and self.tab < self.nstart and self.mlint == "Y":
return "Invalid Membership Number"
def doLoadMember(self, memno):
# Check member
acc = self.sql.getRec("memmst",
cols=["mlm_surname", "mlm_names", "mlm_gender"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", memno)],
limit=1)
if not acc:
return "Member %s Does Not Exist" % memno
# Check category
if self.mscat:
cat = self.sql.getRec("memcat",
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", memno),
("mlc_type", "=", "C"),
("mlc_code", "=", self.mscat)],
limit=1)
if not cat:
return "Member %s is Not in the Bowls Category" % memno
self.snam = acc[0]
self.fnam = acc[1]
self.gender = acc[2]
self.df.loadEntry("T", 0, 1, data=memno)
self.df.loadEntry("T", 0, 2, data=self.snam)
self.df.loadEntry("T", 0, 3, data=self.fnam)
self.df.loadEntry("T", 0, 4, data=self.gender)
for typ in ("A", "P"):
ad = self.sql.getRec(
"memadd",
cols=["mla_add1", "mla_add2", "mla_add3", "mla_code"],
where=[("mla_cono", "=", self.opts["conum"]),
("mla_memno", "=", memno), ("mla_type", "=", typ)],
limit=1)
if ad:
break
if ad:
self.df.loadEntry("T", 0, 5, data=ad[0])
self.df.loadEntry("T", 0, 6, data=ad[1])
self.df.loadEntry("T", 0, 7, data=ad[2])
self.df.loadEntry("T", 0, 8, data=ad[3])
for num, cod in enumerate((1, 2, 3, 5)):
kk = self.sql.getRec("memkon",
cols=["mlk_detail"],
where=[("mlk_cono", "=", self.opts["conum"]),
("mlk_memno", "=", memno),
("mlk_code", "=", cod)],
limit=1)
if kk:
self.df.loadEntry("T", 0, num + 9, data=kk[0])
def doSurname(self, frt, pag, r, c, p, i, w):
self.sname = w
def doNames(self, frt, pag, r, c, p, i, w):
if self.newtab:
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_surname", "=", self.sname,
"and", "btb_names", "=", w)],
limit=1)
if chk:
tab = chk[self.sql.bwltab_col.index("btb_tab")]
self.doTab(frt, pag, 0, 1, 0, 0, tab)
return "ff3"
if self.mstart < self.fstart and self.tab >= self.fstart:
self.df.loadEntry(frt, pag, p + 1, data="F")
elif self.fstart < self.mstart and self.tab < self.mstart:
self.df.loadEntry(frt, pag, p + 1, data="F")
return
if self.sname != self.snam or w != self.fnam:
but = [("Amendment", "A"), ("Re-Issue", "R"), ("Neither", "N")]
ok = askChoice(self.opts["mf"].body,
"Name Change",
"Please Select the Reason for the Name Change",
butt=but,
default="Neither")
if ok == "N":
return "ff3"
if ok == "R":
self.tabchg = True
for x in range(1, 15):
self.df.clearEntry(frt, pag, c + x)
def doGender(self, frt, pag, r, c, p, i, w):
self.gender = w
if self.gentab:
chk = self.getNextTab()
if not chk:
return "ff2|Invalid Membership Number"
if self.tab < self.nstart:
if self.mstart < self.fstart:
if self.gender == "M" and self.tab >= self.fstart:
return "ff5|Invalid Gender for Tab Number"
elif self.gender == "F" and self.tab < self.fstart:
return "ff5|Invalid Gender for Tab Number"
else:
if self.gender == "F" and self.tab >= self.mstart:
return "ff5|Invalid Gender for Tab Number"
elif self.gender == "M" and self.tab < self.mstart:
return "ff5|Invalid Gender for Tab Number"
def doEmail(self, frt, pag, r, c, p, i, w):
if self.dbase in ("C", "P") and self.df.t_work[0][0][13] == "0":
self.df.t_work[0][0][13] = "1"
if self.dbase == "R":
self.pos1 = "0"
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
return "sk1"
def doPos(self, frt, pag, r, c, p, i, w):
if p == 13:
self.pos1 = w
self.df.loadEntry(frt, pag, p + 2, data=w)
if self.dbase == "P":
self.df.loadEntry(frt, pag, p + 1, data="")
if p == 13:
self.df.loadEntry(frt, pag, p + 3, data="")
if self.mixed == "N":
return "sk3"
else:
return "sk1"
def doRate(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p + 1, data=self.pos1)
self.df.loadEntry(frt, pag, p + 2, data=w)
if self.dbase == "R":
self.df.loadEntry(frt, pag, p + 1, data="")
if self.mixed == "N":
return "sk2"
else:
return "sk1"
if self.mixed == "N":
return "sk2"
def getNextTab(self):
if self.newvis:
ok = "yes"
else:
ok = askQuestion(self.opts["mf"].body,
"Type",
"Is this TAB for a Visitor",
default="no")
if ok == "no":
if self.samen == "Y":
return
if self.gender == "M":
start = self.mstart
if self.mstart < self.fstart:
last = self.fstart
else:
last = self.nstart
else:
start = self.fstart
if self.mstart < self.fstart:
last = self.nstart
else:
last = self.mstart
else:
start = self.nstart
last = 900000
self.tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])],
start=start,
last=last)
self.df.loadEntry("T", 0, 0, data=self.tab)
return True
def doDelete(self):
if self.newtab:
return
error = False
for key in self.keys:
if key[0] == "bwltab":
continue
chk = self.sql.getRec(tables=key[0],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.tab)],
limit=1)
if chk:
error = True
break
if error:
if self.tab < self.nstart:
# Member
ok = askQuestion(self.opts["mf"].body,
"Convert",
"Convert this Member to a Visitor",
default="yes")
if ok == "no":
return "Not Deleted nor Converted"
tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])
],
start=self.nstart,
last=900000)
for key in self.keys:
self.sql.updRec(key[0],
cols=[key[2]],
data=[tab],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.tab)])
else:
# Visitor
chk = self.sql.getRec("bwlent",
where=[("bce_cono", "=",
self.opts["conum"]),
("bce_scod", "=", self.tab)])
if chk:
return "There is History for this Player, Not Deleted"
self.sql.delRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
else:
self.sql.delRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
self.opts["mf"].dbm.commitDbase()
def doConvert(self):
titl = "Enter Member's Tab Number"
ent = SimpleDialog(parent=self.df.window,
title=titl,
cols=(("a", "Tab Number ", 6, "UI",
"Tab"), ))
ent.sframe.wait_window()
try:
self.merge = False
if self.gender == "M":
start = self.mstart
if self.mstart < self.fstart:
last = self.fstart - 1
else:
last = self.nstart - 1
else:
start = self.fstart
if self.mstart < self.fstart:
last = self.nstart - 1
else:
last = self.mstart - 1
tab = ent.data[0]
if not tab:
tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])
],
start=start,
last=last)
if tab < start or tab > last:
showInfo(self.opts["mf"].body, "Error",
"Invalid Tab Number for Gender")
raise Exception
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", tab)],
limit=1)
if chk:
ok = askQuestion(
self.opts["mf"].body, "Invalid",
"This Tab is Already Allocated, Do You Want to Merge?")
if ok == "no":
raise Exception
self.merge = True
self.tabcvt = True
self.old = self.tab
self.tab = tab
self.df.loadEntry(self.df.frt, self.df.pag, 0, data=self.tab)
self.df.focusField(self.df.frt, self.df.pag, 6)
except:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
if self.mlint == "Y":
self.colsd = [["Membership Number", "N", "btb_memno"]]
else:
self.colsd = []
self.colsd.extend([["Surname & Initials", "Y", "name"],
["Surname", "N", "btb_surname"],
["First Names", "N", "btb_names"],
["Gender", "N", "btb_gender"],
["Address", "N", "address"],
["Telephone - Home", "N", "btb_home"],
["Telephone - Work", "N", "btb_work"],
["Telephone - Cell", "N", "btb_cell"],
["Email Address", "N", "btb_mail"],
["Ratings", "N", "ratings"],
["BSA Number", "N", "btb_bsano"],
["Order", "T", "order"]])
r1s = (("Members", "M"), ("Guests", "G"), ("All", "A"))
r2s = (("Males", "M"), ("Females", "F"), ("All", "A"))
r3s = (("Yes", "Y"), ("No", "N"))
r4s = (("Tab", "T"), ("Surname", "S"), ("Rating", "R"))
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Tab Group", "", "M", "Y",
self.doCGroup, None, None, None),
(("T", 0, 1, 0), ("IRB", r2s), 0, "Gender", "", "A", "Y",
self.doCGender, None, None, None)]
idx = 1
for dat in self.colsd:
idx += 1
if dat == self.colsd[-1]:
rb = r4s
else:
rb = r3s
fld.append((("T", 0, idx, 0), ("IRB", rb), 0, dat[0], "", dat[1],
"N", self.doCField, None, None, None))
tnd = ((self.doCEnd, "Y"), )
txt = (self.doCExit, )
self.pr = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "Y"))
self.pr.mstFrame.wait_window()
if self.cols:
cols = []
dic = self.sql.bwltab_dic
for col in self.cols:
if col == "name":
cols.append(["name", "NA", 30, "Name"])
elif col == "address":
cols.append([
"btb_add1", dic["btb_add1"][2], dic["btb_add1"][3],
dic["btb_add1"][5]
])
cols.append([
"btb_add2", dic["btb_add2"][2], dic["btb_add2"][3],
dic["btb_add2"][5]
])
cols.append([
"btb_add3", dic["btb_add3"][2], dic["btb_add3"][3],
dic["btb_add3"][5]
])
cols.append([
"btb_pcod", dic["btb_pcod"][2], dic["btb_pcod"][3],
dic["btb_pcod"][5]
])
elif col == "ratings":
if self.dbase == "P":
cols.append([
"btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3],
dic["btb_pos1"][5]
])
cols.append([
"btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3],
dic["btb_pos2"][5]
])
elif self.dbase == "R":
cols.append([
"btb_rate1", dic["btb_rate1"][2],
dic["btb_rate1"][3], dic["btb_rate1"][5]
])
cols.append([
"btb_rate2", dic["btb_rate2"][2],
dic["btb_rate2"][3], dic["btb_rate2"][5]
])
else:
cols.append([
"btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3],
dic["btb_pos1"][5]
])
cols.append([
"btb_rate1", dic["btb_rate1"][2],
dic["btb_rate1"][3], dic["btb_rate1"][5]
])
cols.append([
"btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3],
dic["btb_pos2"][5]
])
cols.append([
"btb_rate2", dic["btb_rate2"][2],
dic["btb_rate2"][3], dic["btb_rate2"][5]
])
else:
cols.append([col, dic[col][2], dic[col][3], dic[col][5]])
whr = [("btb_cono", "=", self.opts["conum"])]
if self.cgroup == "M":
whr.append(("btb_tab", "<", self.nstart))
elif self.cgroup == "G":
whr.append(("btb_tab", ">=", self.nstart))
if self.cgender in ("F", "M"):
whr.append(("btb_gender", "=", self.cgender))
if self.odr == "T":
odr = "btb_tab"
elif self.odr == "S":
odr = "btb_surname, btb_names"
else:
odr = "btb_pos1 desc, btb_rate1 desc, btb_surname, btb_names"
recs = self.sql.getRec("bwltab", where=whr, order=odr)
data = []
btc = self.sql.bwltab_col
for rec in recs:
dat = []
for col in self.cols:
if col == "name":
snam = rec[btc.index("btb_surname")]
fnam = rec[btc.index("btb_names")]
if fnam:
fnam = fnam.split()
for num, nam in enumerate(fnam):
if not num:
init = nam[0].upper()
else:
init = "%s %s" % (init, nam[0].upper())
dat.append("%s, %s" % (snam, init))
else:
dat.append(snam)
elif col == "address":
dat.append(rec[btc.index("btb_add1")])
dat.append(rec[btc.index("btb_add2")])
dat.append(rec[btc.index("btb_add3")])
dat.append(rec[btc.index("btb_pcod")])
elif col == "ratings":
if self.dbase == "P":
dat.append(rec[btc.index("btb_pos1")])
dat.append(rec[btc.index("btb_pos2")])
elif self.dbase == "R":
dat.append(rec[btc.index("btb_rate1")])
dat.append(rec[btc.index("btb_rate2")])
else:
dat.append(rec[btc.index("btb_pos1")])
dat.append(rec[btc.index("btb_rate1")])
dat.append(rec[btc.index("btb_pos2")])
dat.append(rec[btc.index("btb_rate2")])
else:
dat.append(rec[btc.index(col)])
data.append(dat)
tit = "Tabs Lising for"
if self.cgroup == "A":
tit = "%s Members and Guests" % tit
elif self.cgroup == "M":
tit = "%s Members Only" % tit
else:
tit = "%s Guests Only" % tit
if self.cgender == "A":
tit = "%s (All Genders)" % tit
elif self.cgender == "M":
tit = "%s (Males Only)" % tit
else:
tit = "%s (Females Only)" % tit
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
conum=self.opts["conum"],
conam=self.opts["conam"],
heads=[tit],
ttype="D",
tables=data,
cols=cols,
repprt=self.pr.repprt,
repeml=self.pr.repeml,
fromad=self.fromad)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.window.focus_force()
self.df.focusField("T", 0, 1)
def doCGroup(self, frt, pag, r, c, p, i, w):
self.cgroup = w
def doCGender(self, frt, pag, r, c, p, i, w):
self.cgender = w
def doCField(self, frt, pag, r, c, p, i, w):
if self.mlint == "N":
idx = 2
else:
idx = 3
if p == idx and w == "Y":
self.pr.loadEntry(frt, pag, p + 1, data="N")
self.pr.loadEntry(frt, pag, p + 2, data="N")
return "sk2"
def doCEnd(self):
self.pr.closeProcess()
self.cols = ["btb_tab"]
if self.pr.repeml[0] == "N":
end = -2
else:
end = -4
for num, dat in enumerate(self.pr.t_work[0][0][2:end]):
if dat == "Y":
self.cols.append(self.colsd[num][2])
elif dat in ("T", "S", "R"):
self.odr = dat
def doCExit(self):
self.cols = []
self.pr.closeProcess()
def doEnd(self):
if self.tabcvt:
# Conversion to Member
for key in self.keys:
if key[0] == "bwltab" and self.merge:
self.sql.delRec(key[0],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.old)])
continue
self.sql.updRec(key[0],
cols=[key[2]],
data=[self.tab],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.old)])
# Continue
cols = []
for x in range(18):
cols.append(x)
if self.dbase == "R":
cols.remove(13)
cols.remove(15)
flds = ("T", 0, cols)
frt, pag, col, mes = self.df.doCheckFields(flds)
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
return
tabdat = [self.opts["conum"]] + self.df.t_work[0][0]
if self.newtab:
self.sql.insRec("bwltab", data=tabdat)
elif self.tabchg:
tabdat.append("")
self.doTabChg(tabdat)
elif tabdat != self.oldtab[:len(tabdat)]:
col = self.sql.bwltab_col
tabdat.append(self.oldtab[col.index("btb_xflag")])
self.sql.updRec("bwltab",
data=tabdat,
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldtab):
if dat != tabdat[num]:
self.sql.insRec(
"chglog",
data=[
"bwltab", "U",
"%03i%06s" % (self.opts["conum"], self.tab),
col[num], dte, self.opts["capnm"],
str(dat),
str(tabdat[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
if "args" in self.opts:
self.doExit()
else:
self.df.focusField("T", 0, 1)
def doTabChg(self, tabdat):
code = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])],
start=self.nstart,
last=900000)
tables = (("bwldrt", "bdt_cono", "bdt_tab", "bdt_team1", "bdt_team2",
"bdt_team3"), ("bwlent", "bce_cono", "bce_scod"),
("bwlflm", "bfm_cono", "bfm_captain"),
("bwlflt", "bft_cono", "bft_skip", "bft_player"),
("bwlgme", "bcg_cono", "bcg_scod",
"bcg_ocod"), ("bwltab", "btb_cono", "btb_tab"))
for tab in tables:
for col in tab[2:]:
self.sql.updRec(tab[0],
cols=[col],
data=[code],
where=[(tab[1], "=", self.opts["conum"]),
(col, "=", self.tab)])
self.sql.insRec("bwltab", data=tabdat)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Import Details", )
r1s = (("Ratings Only", "R"), ("All Fields", "A"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Details", "", "R", "N",
self.doImpDet, None, None, None), )
self.ip = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doImpEnd, "y"), ),
txit=(self.doImpExit, ))
self.ip.mstFrame.wait_window()
# Populate
if self.impdet is None:
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
fi = FileImport(self.opts["mf"], imptab="bwltab", impskp=self.impskp)
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Ratings",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if self.mixed == "N":
line.extend([0, ""])
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", line[0])],
limit=1)
if not chk:
if self.impdet == "R":
err = "%s %s Does Not Exist" % (fi.impcol[0][0], line[0])
break
line.insert(0, self.opts["conum"])
if self.mlint == "N":
line.insert(2, 0)
self.sql.insRec("bwltab", data=line)
else:
tmp = ["btb_pos1", "btb_rate1", "btb_pos2", "btb_rate2"]
if self.impdet == "R":
cols = tmp
else:
cols = [
"btb_surname", "btb_names", "btb_gender", "btb_add1",
"btb_add2", "btb_add3", "btb_pcod", "btb_home",
"btb_work", "btb_cell", "btb_mail"
] + tmp + ["btb_bsano"]
self.sql.updRec("bwltab",
cols=cols,
data=line[1:],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", line[0])])
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doImpDet(self, frt, pag, r, c, p, i, w):
self.impdet = w
def doImpEnd(self):
self.impskp = ["btb_cono"]
if self.mlint == "N":
self.impskp.append("btb_memno")
if self.impdet == "R":
self.impskp.extend([
"btb_surname", "btb_names", "btb_gender", "btb_add1",
"btb_add2", "btb_add3", "btb_pcod", "btb_home", "btb_work",
"btb_cell", "btb_mail", "btb_bsano"
])
if self.mixed == "N":
self.impskp.extend(["btb_pos2", "btb_rate2"])
self.impskp.append("btb_xflag")
self.ip.closeProcess()
def doImpExit(self):
self.impdet = None
self.ip.closeProcess()
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class rt6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.tables = (
("ctlnot", "not_key"),
("ctlvtf", "vtt_cono", "vtt_acno", "vtt_styp"),
("rtlmst", "rtm_cono", "rtm_code", "rtm_acno"),
("rtlcon", "rtc_cono", "rtc_code", "rtc_acno"),
("rtltrn", "rtt_cono", "rtt_code", "rtt_acno"))
tabs = ["rtlprm"]
for tab in self.tables:
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
return True
def mainProcess(self):
prm = {
"stype": "R",
"tables": ("rtlprm",),
"cols": (
("rtp_code", "", 0, "Cod"),
("rtp_desc", "", 0, "Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]}
rtm = {
"stype": "R",
"tables": ("rtlmst",),
"cols": [
("rtm_code", "", 0, "Cod"),
("rtm_acno", "", 0, "Acc-Num"),
("rtm_name", "", 0, "Name", "Y")],
"where": [("rtm_cono", "=", self.opts["conum"])],
"whera": [["T", "rtm_code", 0]],
"index": 1}
fld = [
(("T",0,0,0),"IRW",7,"Old Code","Old Premises Code",
"","Y",self.doOldCod,prm,None,("notblank",)),
(("T",0,0,0),"O@rtp_desc",0,""),
(("T",0,1,0),"IRW",7,"Old Account","Old Account Number",
"","Y",self.doOldAcc,rtm,None,("notblank",)),
(("T",0,1,0),"O@rtm_name",0,""),
(("T",0,2,0),"I@rtp_code",0,"New Code","New Premises Code",
"","Y",self.doNewCod,prm,None,("notblank",)),
(("T",0,2,0),"O@rtp_desc",0,""),
(("T",0,3,0),"I@rtm_acno",0,"New Account","New Account Number",
"","Y",self.doNewAcc,None,None,("notblank",))]
tnd = ((self.doProcess,"y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt)
def doOldCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlprm", cols=["rtp_desc"],
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", w)], limit=1)
if not acc:
return "Invalid Premises Number, Does Not exist"
self.oldprm = w
self.df.loadEntry(frt, pag, p+1, data=acc[0])
def doOldAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlmst", cols=["rtm_name"],
where=[("rtm_cono", "=", self.opts["conum"]), ("rtm_code",
"=", self.oldprm), ("rtm_acno", "=", w)], limit=1)
if not acc:
return "Invalid Account Number, Does Not exist"
self.oldacc = w
self.oldnot = "%7s%s" % (self.oldprm, self.oldacc)
self.df.loadEntry(frt, pag, p+1, data=acc[0])
def doNewCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlprm", cols=["rtp_desc"],
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", w)], limit=1)
if not acc:
return "Invalid Premises Number, Does Not exist"
self.newprm = w
self.df.loadEntry(frt, pag, p+1, data=acc[0])
def doNewAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlmst", where=[("rtm_cono", "=",
self.opts["conum"]), ("rtm_code", "=", self.newprm), ("rtm_acno",
"=", w)], limit=1)
if acc:
return "Invalid Account Number, Already Exists"
self.newacc = w
self.newnot = "%7s%s" % (self.newprm, w)
def doProcess(self, focus=True):
for tab in self.tables:
if tab[0] == "ctlnot":
whr = [
("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "RTL"),
(tab[1], "=", self.oldnot)]
dat = [self.newnot]
col = [tab[1]]
elif tab[0] == "ctlvtf":
whr = [
(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldacc),
(tab[3], "=", "R")]
dat = [self.newacc]
col = [tab[2]]
else:
whr = [
(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldprm),
(tab[3], "=", self.oldacc)]
dat = [self.newprm, self.newacc]
col = [tab[2], tab[3]]
self.sql.updRec(tab[0], where=whr, data=dat, cols=col)
if focus:
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
class dr1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmes", "ctlrep", "chglog", "ctlnot", "slsiv1", "drsact",
"drschn", "drsdel", "drsmst", "drstrn", "drstyp"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.chains = drsctl["ctd_chain"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
drc = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"])]
drm["whera"] = [["T", "drm_chain", 0]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
dlm = {
"stype":
"R",
"tables": ("drsdel", ),
"cols": (("del_code", "", 0, "Del-Cod"), ("del_add1", "", 0,
"Address", "Y"))
}
rpm = {
"stype": "R",
"tables": ("ctlrep", ),
"cols":
(("rep_code", "", 0, "Rep"), ("rep_name", "", 0, "Name", "Y")),
"where": [("rep_cono", "=", self.opts["conum"])]
}
act = {
"stype":
"R",
"tables": ("drsact", ),
"cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0,
"Description", "Y"))
}
typ = {
"stype":
"R",
"tables": ("drstyp", ),
"cols": (("dtp_code", "", 0, "Cod"), ("dtp_desc", "", 0,
"Description", "Y"))
}
msi = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details", "Y")),
"where": [("mss_system", "=", "INV")]
}
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details", "Y")),
"where": [("mss_system", "=", "STA")]
}
tag = (("Basic-_A", None, ("T", 1, 1), ("T", 0, 1)),
("Basic-_B", None, ("T", 1, 1), ("T", 0, 1)))
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("New", "N"), ("Good", "G"), ("Fair", "F"), ("Poor", "P"),
("Bad", "B"))
self.fld = [
[("T",0,0,0),"IUI",3,"Chain Store","",
"","Y",self.doChain,drc,None,("efld",)],
[("T",0,0,14),"INA",7,"Acc-Num","Account Number",
"","N",self.doAcno,drm,None,("efld",),None,
"To Automatically Generate Account Numbers for "\
"New Accounts enter a Blank Account Number."],
(("T",0,0,30),"INA",30,"Name","",
"","N",self.doName,None,self.doDelete,("notblank",)),
[("T",0,0,0),"INA",7,"Acc-Num","Account Number",
"","Y",self.doAcno,drm,None,("efld",),None,
"To Automatically Generate Account Numbers for "\
"New Accounts enter a Blank Account Number."],
(("T",0,0,14),"INA",30,"Name","",
"","N",self.doName,None,self.doDelete,("notblank",)),
(("T",1,0,0),"INA",30,"Address Line 1","",
"","N",None,None,None,("notblank",)),
(("T",1,1,0),"INA",30,"Address Line 2","",
"","N",None,None,None,("efld",)),
(("T",1,2,0),"INA",30,"Address Line 3","",
"","N",None,None,None,("efld",)),
(("T",1,3,0),"INA",4,"Postal Code","",
"","N",None,None,None,("efld",)),
(("T",1,4,0),"INA",20,"Telephone","",
"","N",None,None,None,("efld",)),
(("T",1,5,0),"INA",20,"Fax","",
"","N",None,None,None,("efld",)),
(("T",1,6,0),"INA",30,"Manager","Manager's Name",
"","N",None,None,None,("efld",)),
(("T",1,6,47),"ITX",30,"E-Mail","Manager's E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,7,0),"INA",30,"Accounts","Accounts Contact",
"","N",None,None,None,("efld",)),
(("T",1,7,47),"ITX",30,"E-Mail","Accounts E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,8,0),"INA",30,"Sales","Sales Contact",
"","N",None,None,None,("efld",)),
(("T",1,8,47),"ITX",30,"E-Mail","Sales E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,9,0),"Id1",10,"Date Opened","Date Account Opened",
self.sysdtw,"N",None,None,None,("efld",)),
(("T",1,10,0),"Id1",10,"Date Registered","",
"","N",None,None,None,("efld",)),
(("T",1,11,0),"INA",10,"V.A.T Number","",
"","N",None,None,None,("efld",)),
(("T",1,12,0),"INa",7,"Delivery Code","",
"","N",self.doDelivery,dlm,None,("efld",)),
(("T",1,13,0),"INa",3,"Rep Code","",
"","N",self.doRep,rpm,None,("efld",)),
(("T",1,13,20),"ONA",26,""),
(("T",1,14,0),"IUA",3,"Business Activity","",
"","N",self.doBusAct,act,None,("efld",)),
(("T",1,14,20),"ONA",26,""),
(("T",1,15,0),"IUA",3,"Business Type","",
"","N",self.doBusTyp,typ,None,("efld",)),
(("T",1,15,20),"ONA",26,""),
(("T",2,0,0),"IUI",1,"Price Level","",
"","N",None,None,None,("efld",)),
(("T",2,1,0),"IUD",5.2,"Discount Percentage","",
"","N",None,None,None,("efld",)),
(("T",2,2,0),"IUD",5.2,"Interest Percentage","",
"","N",None,None,None,("efld",)),
(("T",2,3,0),"IUI",3,"Referral Terms","",
"","N",None,None,None,("efld",)),
(("T",2,4,0),"IUI",3,"Rejected Terms","",
"","N",None,None,None,("efld",)),
(("T",2,5,0),"IUI",5,"Credit Limit","",
"","N",None,None,None,("efld",)),
(("T",2,6,0),("IRB",r1s),0,"Stop Indicator","",
"N","N",None,None,None,None),
(("T",2,7,0),"IUI",3,"Invoice Message","",
"","N",self.doImes,msi,None,("efld",)),
(("T",2,7,22),"ONA",50,""),
(("T",2,8,0),"IUI",3,"Statement Message","",
"","N",self.doSmes,mss,None,("efld",)),
(("T",2,8,22),"ONA",50,""),
(("T",2,9,0),("IRB",r2s),0,"Credit Rating","",
"N","N",None,None,None,None)]
but = (("Import", None, self.doImport, 0, ("T", 0, 1), ("T", 0, 2),
"Import Account Details from a CSV or XLS File."),
("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 1)),
("Print", None, self.doPrint, 0, ("T", 1, 1), ("T", 0, 1)),
("Cancel", None, self.doCancel, 0, ("T", 1, 1),
("T", 0, 1)), ("Quit", None, self.doExit1, 1, None, None))
tnd = ((self.doEnd1, "N"), (self.doEnd2, "N"), (self.doAccept, "Y"))
txt = (self.doExit1, self.doExit2, self.doExit3)
if self.chains == "Y":
del self.fld[3]
del self.fld[3]
else:
del self.fld[0]
del self.fld[0]
del self.fld[0]
self.chain = 0
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
if "args" in self.opts:
if self.chains == "Y":
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][0])
self.df.doKeyPressed("T", 0, 1, data=self.opts["args"][1])
else:
self.chain = self.opts["args"][0]
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][1])
def doClick(self, *opts):
if self.df.pag == 0:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", self.chain)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doAcno(self, frt, pag, r, c, p, i, w):
self.acno = w
if self.acno:
self.old = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)],
limit=1)
if not self.acno or not self.old:
ok = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if ok == "no":
return "Invalid Account Number"
pw = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="DRS",
code="NewAcc")
if pw.flag == "no":
if "args" in self.opts:
return "xt"
else:
return "New Account Creation is Not Allowed"
self.new = True
elif self.old[self.sql.drsmst_col.index("drm_stat")] == "X":
return "Invalid Account, Redundant"
else:
self.new = False
self.df.loadEntry("T", pag, p + 1, data=self.old[3])
d = 4
for pg in range(1, self.df.pgs + 1):
for x in range(0, self.df.topq[pg]):
if pg == 1 and x in (17, 19, 21):
continue
if pg == 2 and x in (8, 10):
continue
if pg == 2 and x == 11 and not self.old[d]:
data = "N"
else:
data = self.old[d]
self.df.loadEntry("T", pg, x, data=data)
d += 1
self.loadRep()
self.loadAct()
self.loadTyp()
self.loadInvMess()
self.loadStaMess()
def loadRep(self):
acc = self.sql.getRec("ctlrep",
cols=["rep_name"],
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=",
self.df.t_work[1][0][16])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 17, data=acc[0])
def loadAct(self):
acc = self.sql.getRec("drsact",
cols=["dac_desc"],
where=[("dac_code", "=",
self.df.t_work[1][0][18])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 19, data=acc[0])
def loadTyp(self):
acc = self.sql.getRec("drstyp",
cols=["dtp_desc"],
where=[("dtp_code", "=",
self.df.t_work[1][0][20])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 21, data=acc[0])
def loadInvMess(self):
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "INV"),
("mss_message", "=",
self.df.t_work[2][0][7])],
limit=1)
if acc:
self.df.loadEntry("T", 2, 8, data=acc[0])
def loadStaMess(self):
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "STA"),
("mss_message", "=",
self.df.t_work[2][0][9])],
limit=1)
if acc:
self.df.loadEntry("T", 2, 10, data=acc[0])
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
if self.new and not self.acno:
for x in range(1, 100):
self.acno = genAccNum(self.name, x, 7)
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)],
limit=1)
if not chk:
break
self.df.loadEntry("T", 0, 0, data=self.acno)
def doDelivery(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
ok = askQuestion(self.opts["mf"].body, head="Delivery Address",
mess="This Delivery Address Does Not Exist, Would "\
"You Like to Create It Now?", default="no")
if ok == "no":
return "rf"
callModule(self.opts["mf"],
self.df,
"drc410",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=None,
args=w)
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
return "rf"
def doRep(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlrep",
cols=["rep_name"],
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=", w)],
limit=1)
if not acc:
return "Invalid Rep"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doBusAct(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsact",
cols=["dac_desc"],
where=[("dac_code", "=", w)],
limit=1)
if not acc:
return "Invalid Business Activity"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doBusTyp(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drstyp",
cols=["dtp_desc"],
where=[("dtp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Business Type"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doImes(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "INV"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Invoice Message"
self.df.loadEntry("T", 2, p + 1, data=acc[0])
def doSmes(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "STA"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Statement Message"
self.df.loadEntry("T", 2, p + 1, data=acc[0])
def doDelete(self):
trs = self.sql.getRec("drstrn",
cols=["count(*)"],
where=[("drt_cono", "=", self.opts["conum"]),
("drt_chain", "=", self.chain),
("drt_acno", "=", self.acno)],
limit=1)
if trs[0]:
return "%s Transactions Exist, Not Deleted" % trs[0]
iv1 = self.sql.getRec("slsiv1",
cols=["count(*)"],
where=[("si1_cono", "=", self.opts["conum"]),
("si1_chain", "=", self.chain),
("si1_acno", "=", self.acno)],
limit=1)
if iv1[0]:
return "%s Sales Document Exists, Not Deleted" % iv1[0]
key = "%03i%s" % (self.chain, self.acno)
nte = self.sql.getRec("ctlnot",
cols=["count(*)"],
where=[("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "DRS"),
("not_key", "=", key)],
limit=1)
if nte[0]:
return "%s Notes Exist, Not Deleted" % nte[0]
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
self.sql.insRec("chglog", data=["drsmst", "D", "%03i%03i%-7s" % \
(self.opts["conum"], self.chain, self.acno), "", dte,
self.opts["capnm"], "", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd1(self):
self.df.focusField("T", 1, 1, clr=self.new)
def doEnd2(self):
self.df.selPage("Basic-B")
self.df.focusField("T", 2, 1, clr=self.new)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col + 1
else:
self.df.last[pag][1] = col + 1
self.df.selPage(self.df.tags[pag - 1][0])
else:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
data = [self.opts["conum"], self.chain]
if self.chains == "Y":
f = 1
else:
f = 0
for x in range(f, f + 2):
data.append(self.df.t_work[0][0][x])
for x in range(0, len(self.df.t_work[1][0])):
if x in (17, 19, 21):
continue
data.append(self.df.t_work[1][0][x])
for x in range(0, len(self.df.t_work[2][0])):
if x in (8, 10):
continue
data.append(self.df.t_work[2][0][x])
if self.new:
data.extend(["N", ""])
self.sql.insRec("drsmst", data=data)
else:
col = self.sql.drsmst_col
data.append(self.old[col.index("drm_stat")])
data.append(self.old[col.index("drm_xflag")])
if data != self.old:
self.sql.updRec("drsmst",
data=data,
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" %
time.localtime()[:-3])
for num, dat in enumerate(self.old):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"drsmst", "U",
"%03i%03i%-7s" % (self.opts["conum"],
self.chain, self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if "args" in self.opts:
self.doExit1()
else:
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doImport(self):
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="drsmst", impskp=["drm_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Debtor's Accounts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if not line[1]:
if not line[2]:
err = "Blank Account Number and Blank Name"
break
for x in range(1, 100):
line[1] = genAccNum(line[2], x, 7)
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", line[0]),
("drm_acno", "=", line[1])],
limit=1)
if not chk:
break
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", line[0]),
("drm_acno", "=", line[1])],
limit=1)
if chk:
err = "%s %s %s %s Already Exists" % (fi.impcol[0][0], line[0],
fi.impcol[1][0], line[1])
break
if not line[2]:
err = "Blank Name"
break
if not line[15]:
line[15] = self.sysdtw
if not line[28]:
line[28] = "N"
if not line[31]:
line[31] = "N"
line.insert(0, self.opts["conum"])
self.sql.insRec("drsmst", data=line)
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
TabPrt(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
name=self.__class__.__name__,
tabs="drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doExit1(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doExit2(self):
self.df.focusField("T", 0, 1)
def doExit3(self):
self.df.selPage("Basic-A")
class wgc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"wagrcv",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
rcv = {
"stype": "R",
"tables": ("wagrcv", ),
"cols":
(("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details"))
}
self.fld = ((("T", 0, 0, 0), "IUI", 4, "Item Code", "", "", "N",
self.doCode, rcv, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 50, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec("wagrcv",
where=[("rcv_code", "=", self.code)],
limit=1)
if not acc:
self.new = "Y"
else:
self.new = "N"
for x in range(1, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=acc[x])
def doDelete(self):
self.sql.delRec("wagrcv", where=[("rcv_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dat = []
for x in range(0, len(self.df.t_work[0][0])):
dat.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("wagrcv", data=dat)
else:
self.sql.updRec("wagrcv",
data=dat,
where=[("rcv_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bkc410(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="bkmlet",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
r1s = (("Query", "Q"), ("Confirm", "C"), ("Settle", "S"), ("Cancel",
"X"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Letter Type", "", "Q", "Y",
self.doType, None, None, None),
(("T", 0, 1, 0), "ITV", (80, 10), "Body", "", "", "N", None,
None, None, ("notblank", )))
but = (("Save", None, self.doSave, 0, ("T", 0, 2), ("T", 0, 1)),
("Quit", None, self.doQuit, 1, None, ("T", 0, 1)))
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):
self.ltyp = w
self.let = self.sql.getRec("bkmlet",
where=[("bkl_cono", "=",
self.opts["conum"]),
("bkl_code", "=", self.ltyp)],
limit=1)
if not self.let:
self.lnew = True
else:
self.lnew = False
self.df.loadEntry(
frt,
pag,
p + 1,
data=self.let[self.sql.bkmlet_col.index("bkl_body")])
def doSave(self):
self.df.loadEntry("T", 0, 1, data=self.df.getEntry("T", 0, 1)[1])
self.doEnd()
def doEnd(self):
data = [self.opts["conum"], self.ltyp, self.df.t_work[0][0][1]]
if self.lnew:
self.sql.insRec("bkmlet", data=data)
elif data != self.let[:len(data)]:
col = self.sql.bkmlet_col
data.append(self.let[col.index("bkl_xflag")])
self.sql.updRec("bkmlet",
data=data,
where=[("bkl_cono", "=", self.opts["conum"]),
("bkl_code", "=", self.ltyp)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doQuit(self):
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class st6040(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, ["crsmst", "strloc", "strpom",
"strpot"], 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"]
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"]),
"Purchase Order Cancellations (%s)" % self.__class__.__name__)
loc = {
"stype": "R",
"tables": ("strloc",),
"cols": (
("srl_loc", "", 0, "L"),
("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]}
orm = {
"stype": "R",
"tables": ("strpom",),
"cols": (
("pom_ordno", "", 0, "OrderNo"),
("pom_acno", "", 0, "Crs-Num"),
("pom_date", "", 0, "Order-Date")),
"where": [
("pom_cono", "=", self.opts["conum"]),
("pom_delno", "=", "")],
"whera": [("T", "pom_loc", 0)],
"order": "pom_ordno"}
if self.locs == "N":
self.locw = "1"
fld = [
(("T",0,0,0),"OUA",1,"Location")]
else:
fld = [
(("T",0,0,0),"IUA",1,"Location","",
"1","Y",self.doLoc,loc,None,None)]
fld.extend([
(("T",0,1,0),"Id1",10,"Orders Older Than","",
"","Y",self.doOld,orm,None,None),
(("T",0,2,0),"IUI",9,"From Order Number","",
"","Y",self.doOrd,orm,None,None),
(("T",0,3,0),"IUI",9,"To Order Number","",
"","Y",self.doOrd,orm,None,None)])
tnd = ((self.doEnd,"y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld,
tend=tnd, txit=txt)
if self.locs == "N":
self.df.loadEntry("T", 0, 0, data=self.locw)
def doLoc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strloc", cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", w)], limit=1)
if not acc:
return "Invalid Location"
self.locw = w
def doOld(self, frt, pag, r, c, p, i, w):
self.oldr = w
if self.oldr:
self.df.loadEntry(frt, pag, p+1, data="")
self.df.loadEntry(frt, pag, p+2, data="")
return "nd"
def doOrd(self, frt, pag, r, c, p, i, w):
if p == 3 and w < self.ord1:
return "Invalid, Last Order less than First Order"
acc = self.sql.getRec("strpom", where=[("pom_cono", "=",
self.opts["conum"]), ("pom_ordno", "=", w), ("pom_loc", "=",
self.locw), ("pom_delno", "=", "")], limit=1)
if not acc:
return "Invalid Order Number"
if p == 2:
self.ord1 = w
else:
self.ord2 = w
def doEnd(self):
self.df.closeProcess()
if self.oldr:
whr = [
("pom_cono", "=", self.opts["conum"]),
("pom_loc", "=", self.locw),
("pom_date", "<", self.oldr),
("pom_delno", "<>", "cancel"),
("pom_deldt", "=", 0)]
else:
whr = [
("pom_cono", "=", self.opts["conum"]),
("pom_loc", "=", self.locw),
("pom_ordno", ">=", self.ord1),
("pom_ordno", "<=", self.ord2),
("pom_delno", "<>", "cancel"),
("pom_deldt", "=", 0)]
self.sql.updRec("strpom", cols=["pom_delno"], data=["cancel"],
where=whr)
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bs3010(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, ["bksmst", "bksaut", "bksown"],
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.curdt = time.strftime("%Y-%m", t)
self.image = os.path.join(self.opts["mf"].rcdic["wrkdir"], "books.png")
if not os.path.exists(self.image):
getImage("books", fle=self.image)
if not os.path.exists(self.image):
self.image = None
return True
def mainProcess(self):
lst = {
"stype": "R",
"tables": ("bksmst", ),
"cols": (("bmf_mnth", "", 0, "Month"), ),
"where": [("bmf_cono", "=", self.opts["conum"])],
"group": "bmf_mnth",
"order": "bmf_mnth"
}
r1s = (("All", "A"), ("Current", "C"), ("Removed", "R"))
r2s = (("Title", "T"), ("Date", "D"), ("Author", "A"), ("Owner", "O"))
fld = ((("T", 0, 0, 0), "ID2", 7, "Last Meeting", "", "", "N",
self.doLast, lst, None, ("efld", )),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Status", "", "A", "N",
self.doStatus, None, None, None),
(("T", 0, 2, 0), ("IRB", r2s), 0, "Order", "", "T", "N",
self.doOrder, 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", "Y"))
def doLast(self, frt, pag, r, c, p, i, w):
self.last = w
self.new = False
def doStatus(self, frt, pag, r, c, p, i, w):
self.status = w
def doOrder(self, frt, pag, r, c, p, i, w):
self.order = w
def doEnd(self):
self.df.closeProcess()
if self.df.repeml[1] == "Y":
if not self.df.repeml[2]:
owns = self.sql.getRec("bksown",
cols=["bof_mail"],
where=[("bof_mail", "<>", ""),
("bof_stat", "=", "C")])
adds = None
for own in owns:
if not adds:
adds = own[0]
else:
adds = "%s,%s" % (adds, own[0])
self.df.repeml[2] = adds
if not self.df.repeml[3]:
self.df.repeml[3] = """Dear Member
Attached please find the latest list of books.
All books which came onto the list at the last meeting are highlighted and, if available, a precis will be printed at the end.
Thanks and Regards.
"""
tab = ["bksmst", "bksaut", "bksown"]
col = [
"bmf_stat", "bmf_titl", "bmf_code", "baf_snam", "baf_fnam",
"bmf_mnth", "bof_fnam", "bof_snam"
]
odr = ""
if self.status == "C":
whr = [("bmf_stat", "=", "C")]
elif self.status == "R":
whr = [("bmf_stat", "=", "X")]
else:
whr = []
odr = "bmf_stat"
whr.extend([("baf_code=bmf_auth", ), ("bof_code=bmf_ownr", )])
if self.order == "T":
if odr:
odr = "%s, bmf_titl" % odr
else:
odr = "bmf_titl"
elif self.order == "D":
if odr:
odr = "%s, bmf_mnth, bmf_titl" % odr
else:
odr = "bmf_mnth, bmf_titl"
elif self.order == "A":
if odr:
odr = "%s, baf_snam, baf_fnam, bmf_titl" % odr
else:
odr = "baf_snam, baf_fnam, bmf_titl"
elif self.order == "O":
if odr:
odr = "%s, bmf_ownr, bmf_titl" % odr
else:
odr = "bmf_ownr, bmf_titl"
recs = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Selection Error",
"No Records Selected")
self.opts["mf"].closeLoop()
return
self.fpdf = MyFpdf(name="bs3010", head=90, auto=True)
self.fpdf.header = self.pageHeading
self.stat = recs[0][0]
self.fpdf.add_page()
new = []
for rec in recs:
stat = CCD(rec[0], "UA", 1).disp
if stat != self.stat:
self.stat = stat
self.fpdf.add_page()
titl = CCD(rec[1], "NA", 30).disp
code = CCD(rec[2], "UI", 4).disp
auth = CCD("%s, %s" % (rec[3], rec[4]), "NA", 30).disp
mnth = CCD(rec[5], "D2", 7).disp
ownr = CCD("%s %s" % (rec[6], rec[7][0]), "NA", 12).disp
if rec[5] < self.last:
fill = 0
else:
new.append([auth, titl])
fill = 1
self.fpdf.drawText("%1s %30s %4s %30s %7s %10s" %
(stat, titl, code, auth, mnth, ownr),
h=5,
fill=fill)
if new:
sp = SplashScreen(
self.opts["mf"].body,
"Preparing Summary of New Books ... Please Wait")
self.new = True
self.fpdf.add_page()
for book in new:
try:
if self.fpdf.get_y() > 260:
self.fpdf.add_page()
desc = self.getDesc(book)
if desc:
w = self.fpdf.cwth * 9
desc = desc.rstrip().encode("latin-1",
"ignore").decode(
"latin-1", "ignore")
self.fpdf.drawText(w=w, txt="Title: ", font="B", ln=0)
self.fpdf.drawText(txt=book[1].rstrip(), font="I")
self.fpdf.drawText(w=w, txt="Author: ", font="B", ln=0)
self.fpdf.drawText(txt=book[0].rstrip(), font="I")
self.fpdf.drawText(w=w,
txt="Details: ",
font="B",
ln=0)
self.fpdf.drawText(txt=desc, font="I", ctyp="M")
if book != new[-1]:
self.fpdf.drawText()
except:
pass
sp.closeSplash()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
head = "Book List as at %s" % (self.curdt)
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=head,
repprt=self.df.repprt,
repeml=self.df.repeml)
self.opts["mf"].closeLoop()
def pageHeading(self, new=False):
self.fpdf.setFont("Arial", "B", 15)
x = self.fpdf.get_x()
if self.image:
self.fpdf.image(self.image, 11, 10, 15, 20)
self.fpdf.image(self.image, 185, 10, 15, 20)
self.fpdf.cell(20)
self.fpdf.set_x(x)
self.fpdf.cell(0, 10, self.opts["conam"], "TLR", 1, "C")
if self.new:
txt = "Summary of New Books"
elif self.stat == "C":
txt = "Current Books as at %s" % self.curdt
else:
txt = "Removed Books as at %s" % self.curdt
self.fpdf.cell(0, 10, txt, "LRB", 1, "C")
self.fpdf.ln(8)
self.fpdf.setFont(style="B")
if not self.new:
self.fpdf.cell(
0, 5, "%-1s %-30s %-4s %-30s %-7s %-12s" %
("S", "Title", "Code", "Author", "Mth-Rec", "Owner"), "B")
self.fpdf.ln(5)
def getDesc(self, book):
auth = book[0].strip().lower()
titl = book[1].strip().lower().replace(",", "")
if titl[:4] == "the ":
titl = titl[4:]
elif titl[-4:] == " the":
titl = titl[:-4]
get = requests.get("https://www.googleapis.com/books/v1/volumes?q="\
"{intitle:'%s'+inauthor:'%s'" % (titl, auth), timeout=5)
if get.status_code == 200 and get.json()["totalItems"]:
ok = False
for item in get.json()["items"]:
tita = titl.lower().\
replace("the ","").replace(", the", "")
titb = item["volumeInfo"]["title"].lower().\
replace("the ","").replace(", the", "")
if titb.count(tita):
if "description" in item["volumeInfo"]:
ok = True
break
if ok:
return item["volumeInfo"]["description"]
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ml3120(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, "memsta",
prog=self.__class__.__name__)
if self.sql.error:
return
self.desc = {
"A": ["Active",0,0,0,0,0,0,0,0,0,0,0,0],
"D": ["Deceased",0,0,0,0,0,0,0,0,0,0,0,0],
"I": ["Inactive",0,0,0,0,0,0,0,0,0,0,0,0],
"R": ["Resigned",0,0,0,0,0,0,0,0,0,0,0,0],
"S": ["Suspended",0,0,0,0,0,0,0,0,0,0,0,0],
"X": ["Defaulted",0,0,0,0,0,0,0,0,0,0,0,0]}
return True
def mainProcess(self):
fld = (
(("T",0,0,0),"ID2",7,"Starting Period","",
"","N",self.doStartPer,None,None,None),
(("T",0,1,0),"ID2",7,"Ending Period","",
"","N",self.doEndPer,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 doStartPer(self, frt, pag, r, c, p, i, w):
self.sdate = (w * 100) + 1
y = int(w / 100)
m = (w % 100) + 11
if m > 12:
y += 1
m -= 12
self.df.loadEntry(frt, pag, p+1, ((y * 100) + m))
def doEndPer(self, frt, pag, r, c, p, i, w):
self.edate = mthendDate((w * 100) + 1)
if dateDiff(self.sdate, self.edate, "months") > 11:
return "More than 12 month period"
def doEnd(self):
self.df.closeProcess()
rec = self.sql.getRec("memsta", cols=["mls_status",
"mls_date/100 as date", "count(*)"], where=[("mls_date",
"between", self.sdate, self.edate)], group="mls_status, date")
num = 1
lookup = {}
mth = int(self.sdate / 100) % 100
end = int(self.edate / 100) % 100
lookup[mth] = num
while mth != end:
mth += 1
if mth > 12:
mth = 1
num += 1
lookup[mth] = num
for r in rec:
mth = r[1] % 100
self.desc[r[0]][lookup[mth]] = r[2]
achart = []
for s in self.desc:
achart.append([s] + self.desc[s])
CreateChart(self.opts["mf"], self.opts["conum"], self.opts["conam"],
[int(self.sdate / 100), int(self.edate / 100)],
[[self.opts["conam"], "Status Summary"], "Count"], achart, achart)
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rtc110(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, ["rtlctl", "tplmst", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.acc = self.sql.getRec("rtlctl",
where=[("ctr_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [self.opts["conum"], "N", 0, "statement_rental", "", ""]
else:
self.new = False
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", "=", "RTL")],
"order":
"tpm_tname"
}
r1s = (("Yes", "Y"), ("No", "N"))
self.fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "G/L Integration", "",
self.acc[1], "N", None, None, None,
None), (("T", 0, 1, 0), "ID1", 10, "Last Month End", "",
self.acc[2], "N", None, None, None, ("efld", )),
(("T", 0, 2, 0), "INA", 20, "Statement Template", "",
self.acc[3], "N", self.doTplNam, tpm, None, None),
(("T", 0, 3, 0), "ITX", 50, "Email Address", "",
self.acc[4], "N", None, None, None, ("email", )))
but = (("Quit", None, self.doExit, 1, None, None), )
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
if not self.new:
for n, f in enumerate(self.acc[1:-1]):
self.df.loadEntry("T", 0, n, data=f)
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "S"),
("tpm_system", "=", "RTL")],
limit=1)
if not acc:
return "Invalid Template Name"
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("rtlctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.rtlctl_col
data.append(self.acc[col.index("ctr_xflag")])
self.sql.updRec("rtlctl",
data=data,
where=[("ctr_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=[
"rtlctl", "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 tb3010(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, ["ftable", "ffield"],
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.head = "Tartan Systems"
return True
def mainProcess(self):
dats = [["ALL", "All Systems"]]
syss = list(allsys.keys())
syss.sort()
for s in syss:
dats.append((s, allsys[s][0]))
syss.append("ALL")
sts = {
"stype": "C",
"titl": "Select the Required System",
"head": ("COD", "System"),
"data": dats
}
r1s = (("All", "A"), ("System", "S"), ("Singles", "X"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Tables", "", "X", "Y",
self.doTab, None, None, None),
(("T", 0, 1, 0), "IUA", 3, "System", "", "ALL", "Y", self.doSys,
sts, None, ("in", syss)))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("Y", "N"))
def doTab(self, frt, pag, r, c, p, i, w):
self.seltab = w
if self.seltab != "S":
self.sys = None
return "sk1"
def doSys(self, frt, pag, r, c, p, i, w):
if w == "MST":
self.sys = "ctl"
else:
self.sys = w
def doEnd(self):
self.df.closeProcess()
self.printReport()
self.opts["mf"].closeLoop()
def printReport(self):
if self.seltab == "X":
tabs = getSingleRecords(self.opts["mf"],
"ftable", ("ft_tabl", "ft_desc"),
where=[("ft_seq", "=", 1)])
else:
whr = [("ft_seq", "=", 1)]
if self.seltab == "S":
whr.append(("ft_tabl", "like", self.sys.lower() + "%"))
tabs = self.sql.getRec("ftable",
cols=["ft_tabl", "ft_desc"],
where=whr,
order="ft_tabl")
if not tabs:
return
self.fpdf = MyFpdf(name=self.__class__.__name__, head=80)
self.pgnum = 0
p = ProgressBar(self.opts["mf"].body, mxs=len(tabs), esc=True)
for num, tab in enumerate(tabs):
p.displayProgress(num)
if p.quit:
break
recs = self.sql.getRec("ffield",
where=[("ff_tabl", "=", tab[0])],
order="ff_seq")
if not recs:
continue
self.doHeading("F", tab[0])
for rec in recs:
a = CCD(rec[1], "UI", 3).disp
b = CCD(rec[2], "NA", 20).disp
c = CCD(rec[3], "NA", 2).disp
d = CCD(rec[4], "UD", 6.1).disp
e = CCD(rec[5], "NA", 30).disp
f = CCD(rec[6], "NA", 30).disp
self.fpdf.drawText("%3s %-20s %2s %6s %-30s %-30s" % \
(a, b, c, d, e, f))
recs = self.sql.getRec("ftable",
where=[("ft_tabl", "=", tab[0])],
order="ft_seq")
if not recs:
continue
self.doHeading("I", tab[0])
for rec in recs:
a = CCD(rec[1], "NA", 20).disp
b = CCD(rec[2], "UI", 1).disp
c = CCD(rec[3], "NA", 1).disp
d = CCD(rec[4], "NA", 10).disp
e = CCD(rec[5], "NA", 10).disp
f = CCD(rec[6], "NA", 10).disp
g = CCD(rec[7], "NA", 10).disp
h = CCD(rec[8], "NA", 10).disp
i = CCD(rec[9], "NA", 10).disp
j = CCD(rec[10], "NA", 10).disp
self.fpdf.drawText("%-20s %2s %1s %-10s %-10s %-10s %-10s "\
"%-10s %-10s %-10s" % (a, b, c, d, e, f, g, h, i, j))
p.closeProgress()
if self.fpdf.page and not p.quit:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
0,
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=1,
pdfnam=pdfnam,
header="Table Fields and Indexes",
repprt=self.df.repprt,
repeml=self.df.repeml)
def doHeading(self, htyp, table):
self.fpdf.setFont(style="B")
if htyp == "F":
self.fpdf.add_page()
self.pgnum += 1
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-90s %-5s %5s" % ("Table Fields for "\
"Table %s" % table, "Page", self.pgnum))
head = "%3s %-20s %2s %6s %-30s %-30s" % (
"Seq", "Field Name", "Tp", "Size", "Description", "Heading")
else:
self.fpdf.drawText()
self.fpdf.drawText("Table Indexes for Table %s" % table)
head = "%-20s %2s %1s %-10s %-10s %-10s %-10s %-10s %-10s "\
"%-10s" % ("Table Description", "Sq", "T", "1st-Col",
"2nd-Col", "3rd-Col", "4th-Col", "5th-Col", "6th-Col",
"7th-Col")
self.fpdf.drawText()
self.fpdf.drawText(head)
self.fpdf.underLine(head)
self.fpdf.setFont()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class cp1010:
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.mods = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
self.mods.append(ctlmst["ctm_modules"][x:x+2])
tabs = ["ctlmst", "ctlynd", "ctlvtf", "ctlbat", "asstrn", "bkmtrn",
"crstrn", "crsage", "drstrn", "drsage", "gentrn", "lontrn",
"memtrn", "memage", "rcaowt", "rcatnt", "rtltrn", "wagltf"]
self.syss = {
"ASS": ["assctl", "cta_glint", [0, 2, 6, 4, 4],
[["ast_cono", "ast_type", "ast_batch", "ast_curdt"]]],
"BKM": ["bkmctl", "cbk_glint", [0, 0, 1, 6, 2, 4, 1, 6],
[["bkt_cono", "bkt_type", "bkt_batch", "bkt_curdt"]]],
"CRS": ["crsctl", "ctc_glint", [0, 5, 6, 4, 5, 2, 2],
[["crt_cono", "crt_type", "crt_batch", "crt_curdt"]],
["crt_ref1", "cra_cono", "cra_curdt", "cra_atyp", "cra_aref"]],
"DRS": ["drsctl", "ctd_glint", [0, 1, 6, 4, 1, 2, 6],
[["drt_cono", "drt_type", "drt_batch", "drt_curdt"]],
["drt_ref1", "dra_cono", "dra_curdt", "dra_atyp", "dra_aref"]],
"GEN": [],
"LON": ["lonctl", "cln_glint", [0, 2, 6, 4, 4],
[["lnt_cono", "lnt_type", "lnt_batch", "lnt_curdt"]]],
"MEM": ["memctl", "mcm_glint", [0, 1, 2, 4, 1, 6, 6],
[["mlt_cono", "mlt_type", "mlt_batch", "mlt_curdt"]],
["mlt_refno", "mta_cono", "mta_curdt", "mta_atyp", "mta_aref"]],
"RCA": ["rcactl", "cte_glint", [0, 1, 6, 2, 4], [
["rot_cono", "rot_type", "rot_batch", "rot_curdt"],
["rtu_cono", "rtu_type", "rtu_batch", "rtu_curdt"]]],
"RTL": ["rtlctl", "ctr_glint", [0, 1, 6, 2, 4],
[["rtt_cono", "rtt_type", "rtt_batch", "rtt_curdt"]]],
"SLN": ["wagctl", "ctw_glint", [0, 4, 2, 2, 6, 4],
[["wlt_cono", "wlt_type", "wlt_batch", "wlt_curdt"]]]}
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=__name__)
if self.sql.error:
return
self.i_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
return True
def mainProcess(self):
tit = "Change Batch Current Period"
data = []
for ss in allsys:
if ss not in self.syss:
continue
if allsys[ss][1] not in self.mods:
continue
data.append((ss, allsys[ss][0]))
data.sort()
sss = {
"stype": "C",
"titl": "Systems",
"head": ["COD", "Description"],
"data": data}
self.ttt = {
"stype": "C",
"titl": "Batch Types",
"head": ["BT", "Description"],
"data": []}
self.bat = {
"stype": "R",
"tables": ("ctlbat",),
"cols": (
("btm_batno", "", 0, "Bat-Num"),
("btm_curdt", "", 0, "Cur-Dte")),
"where": [
("btm_cono", "=", self.opts["conum"]),
("btm_curdt", "between", self.i_per, self.e_per)],
"whera": (
("T", "btm_styp", 0, 0),
("T", "btm_rtyp", 2, 0)),
"order": "btm_curdt, btm_batno"}
fld = (
(("T",0,0,0),"IUA",3,"System Code","",
"","N",self.doSysCod,sss,None,("notblank",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,1,0),"IUI",2,"Transaction Type","",
"","N",self.doTrnTyp,self.ttt,None,("notzero",)),
(("T",0,1,0),"ONA",30,""),
(("T",0,2,0),"INa",7,"Batch Number","",
"","N",self.doBatNum,self.bat,None,("notblank",)),
(("T",0,3,0),"OD2",7,"Captured Period"),
(("T",0,4,0),"ID2",7,"Change to Period","",
"","N",self.doNewPer,None,None,("efld",)))
but = (("Exit", None, self.doExit, 0, ("T",0,1), ("T",0,0)),)
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False, title=tit,
eflds=fld, butt=but, tend=tnd, txit=txt)
def doSysCod(self, frt, pag, r, c, p, i, w):
if w not in self.syss:
return "Invalid System"
if allsys[w][1] not in self.mods:
return "Invalid System"
self.syscod = w
self.ttt["data"] = []
exec("from tartanWork import %strtp as trtp" % allsys[w][1].lower())
setattr(self, "trtp", locals()["trtp"])
for n, t in enumerate(self.trtp):
self.ttt["data"].append((n+1, t[1]))
self.df.loadEntry(frt, pag, p+1, data=allsys[self.syscod][0])
def doTrnTyp(self, frt, pag, r, c, p, i, w):
if (w < 1 or w > len(self.trtp)):
return "Invalid Type"
self.battyp = w
rtn = self.trtp[w-1][1]
self.df.loadEntry(frt, pag, p+1, data=rtn)
def doBatNum(self, frt, pag, r, c, p, i, w):
self.batnum = w
self.btm = [
("btm_cono", "=", self.opts["conum"]),
("btm_styp", "=", self.syscod),
("btm_rtyp", "=", self.battyp),
("btm_batno", "=", self.batnum)]
chk = self.sql.getRec("ctlbat", cols=["btm_curdt"], where=self.btm,
limit=1)
if not chk:
return "Invalid Batch(B)"
per = self.doChkPer(chk[0])
if per:
return per
self.oldper = chk[0]
self.df.loadEntry(frt, pag, p+1, data=self.oldper)
def doNewPer(self, frt, pag, r, c, p, i, w):
per = self.doChkPer(w)
if per:
return per
self.newper = w
def doChkPer(self, per):
if per < self.i_per or per > self.e_per:
return "Invalid Period(P)"
whr = (
("cye_cono", "=", self.opts["conum"]),
("cye_start", ">=", per),
("cye_end", "<=", per))
chk = self.sql.getRec("ctlynd", cols=["cye_final"], where=whr, limit=1)
if chk and chk[0] == "Y":
return "Invalid Period(F)"
def doEnd(self):
self.sql.updRec("ctlbat", cols=["btm_curdt"], data=[self.newper],
where=self.btm)
if self.syscod == "GEN":
if self.battyp not in list(range(1, 8)):
raise Exception
if self.battyp == 7:
gltyp = (2, 6)
else:
gltyp = (self.battyp,)
glint = "N"
else:
ctl = self.syss[self.syscod]
glint = self.gc.getCtl(ctl[0], self.opts["conum"])[ctl[1]]
if glint == "Y":
gltyp = (ctl[2][self.battyp],)
sqv = [
("vtt_cono", "=", self.opts["conum"]),
("vtt_curdt", "=", self.oldper),
("vtt_styp", "=", self.syscod[0])]
if self.syscod == "GEN":
sqv.append(("vtt_ttyp", "in", gltyp))
else:
sqv.append(("vtt_ttyp", "=", self.battyp))
sqv.append(("vtt_batch", "=", self.batnum))
self.sql.updRec("ctlvtf", cols=["vtt_curdt"], data=[self.newper],
where=sqv)
if self.syscod == "GEN" or glint == "Y":
sqt = [
("glt_cono", "=", self.opts["conum"]),
("glt_curdt", "=", self.oldper),
("glt_type", "in", gltyp),
("glt_batch", "=", self.batnum)]
tmp = sqt[:]
tmp.append(("glt_recon", "=", self.oldper))
self.sql.updRec("gentrn", cols=["glt_recon"], data=[self.newper],
where=tmp)
self.sql.updRec("gentrn", cols=["glt_curdt"], data=[self.newper],
where=sqt)
if self.syscod == "GEN":
codes = list(self.syss.keys())
else:
codes = [self.syscod]
for syscod in codes:
if syscod == "GEN":
continue
ctl = self.syss[syscod]
if self.syscod == "GEN":
trtyp = []
for cod in gltyp:
trtyp.append(self.syss[syscod][2].index(cod))
else:
trtyp = (self.battyp,)
if syscod == "RCA":
tabs = ["rcaowt", "rcatnt"]
elif syscod == "SLN":
tabs = ["wagltf"]
else:
tabs = ["%strn" % syscod.lower()]
for seq, tab in enumerate(tabs):
sqt = [
(ctl[3][seq][0], "=", self.opts["conum"]),
(ctl[3][seq][1], "in", trtyp),
(ctl[3][seq][2], "=", self.batnum),
(ctl[3][seq][3], "=", self.oldper)]
if syscod in ("CRS", "DRS", "MEM"):
recs = self.sql.getRec(tab, cols=[ctl[4][0]], where=sqt)
self.sql.updRec(tab, cols=[ctl[3][seq][3]],
data=[self.newper], where=sqt)
if syscod in ("CRS", "DRS", "MEM"):
tab = "%sage" % syscod.lower()
for rec in recs:
sqa = (
(ctl[4][1], "=", self.opts["conum"]),
(ctl[4][2], "=", self.oldper),
(ctl[4][3], "in", trtyp),
(ctl[4][4], "=", rec[0]))
self.sql.updRec("%sage" % syscod.lower(), cols=[ctl[4][2]],
data=[self.newper], where=sqa)
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bsc210(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, ["bksaut", "bksmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
clb = {
"stype": "R",
"tables": ("bksaut",),
"cols": (
("baf_code", "", 0, "Cod"),
("baf_snam", "", 0, "Surname", "Y"),
("baf_fnam", "", 0, "Names")),
"order": "baf_snam"}
fld = (
(("T",0,0,0),"I@baf_code",0,"","",
"","Y",self.doCode,clb,None,("efld",)),
(("T",0,1,0),"I@baf_snam",0,"","",
"","N",self.doSnam,None,self.doDelete,("notblank",)),
(("T",0,2,0),"I@baf_fnam",0,"","",
"","N",self.doFnam,None,None,("efld",)))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt)
def doCode(self, frt, pag, r, c, p, i, w):
if not w:
self.author = getNextCode(self.sql, "bksaut", "baf_code", last=999)
self.df.loadEntry(frt, pag, p, data=self.author)
else:
self.author = w
self.old = self.sql.getRec("bksaut", where=[("baf_code", "=",
self.author)], limit=1)
if not self.old:
self.newaut = True
else:
self.newaut = False
for num, fld in enumerate(self.old[:-1]):
self.df.loadEntry(frt, pag, num, data=fld)
def doDelete(self):
chk = self.sql.getRec("bksmst", where=[("bmf_auth",
"=", self.author)], limit=1)
if chk:
showError(self.opts["mf"].body, "Error", "Author in Use")
return
self.sql.delRec("bksaut", where=[("baf_code", "=", self.author)])
self.opts["mf"].dbm.commitDbase()
def doSnam(self, frt, pag, r, c, p, i, w):
self.snam = w
def doFnam(self, frt, pag, r, c, p, i, w):
if self.newaut:
chk = self.sql.getRec("bksaut", where=[("baf_snam",
"=", self.snam), ("baf_fnam", "=", w)], limit=1)
if chk:
return "An Author with this Name Already Exists"
def doEnd(self):
data = self.df.t_work[0][0][:]
if self.newaut:
self.sql.insRec("bksaut", data=data)
elif data != self.old[:len(data)]:
col = self.sql.bksaut_col
data.append(self.old[col.index("baf_xflag")])
self.sql.updRec("bksaut", data=data, where=[("baf_code", "=",
self.author)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bk3030(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, 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, 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"]
self.fromad = bkmctl["cbk_emadd"]
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 Arrivals Listing (%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 = (("Weekdays","D"), ("Weekend","E"), ("Range", "R"))
r2s = (("Yes","Y"), ("No","N"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Period","",
"D","Y",self.doPeriod,None,None,None),
(("T",0,1,0),"ID1",10,"Starting Date","",
0,"N",self.doStartDate,None,None,("efld",)),
(("T",0,2,0),"ID1",10,"Ending Date","",
0,"N",self.doEndDate,None,None,("efld",)),
(("T",0,3,0),("IRB",r2s),0,"Include Queries","",
"N","Y",self.doQuery,None,None,None),
(("T",0,4,0),("IRB",r2s),0,"Housekeeping Report","",
"Y","Y",self.doHkRpt,None,None,None),
(("T",0,5,0),("IRB",r2s),0,"Generate Invoices","",
"Y","Y",self.doGenInv,None,None,None),
(("T",0,6,0),("IRB",r2s),0,"Print Invoices","",
"Y","Y",self.doPrtInv,None,None,None),
(("T",0,7,0),"INA",20,"Template Name","",
self.tplnam,"N",self.doTplNam,tpm,None,None))
tnd = ((self.doEnd,"y"), )
txt = (self.doExit, )
if "args" in self.opts:
tops = self.opts["args"]
else:
tops = False
self.df = TartanDialog(self.opts["mf"], tops=tops, title=self.tit,
eflds=fld, tend=tnd, txit=txt, view=("N","P"), mail=("Y","N"))
def doPeriod(self, frt, pag, r, c, p, i, w):
self.period = w
if self.period in ("D", "E"):
self.start = self.getStart()
self.df.loadEntry(frt, pag, p+1, data=self.start)
def doStartDate(self, frt, pag, r, c, p, i, w):
self.start = w
if self.period in ("D", "E"):
if self.getStart(self.start):
return "Invalid Start Date"
if self.period == "D":
self.end = projectDate(self.start, 3)
else:
self.end = projectDate(self.start, 2)
self.df.loadEntry(frt, pag, p+1, data=self.end)
return "sk1"
def getStart(self, date=None):
if self.period == "D":
chk = 0
else:
chk = 4
if date:
year = int(date / 10000)
month = int(date / 100) % 100
day = date % 100
if datetime.date(year, month, day).weekday() != chk:
return True
else:
date = projectDate(self.sysdtw, -1)
dte = 99
while dte != chk:
date = projectDate(date, 1)
year = int(date / 10000)
month = int(date / 100) % 100
day = date % 100
dte = datetime.date(year, month, day).weekday()
return date
def doEndDate(self, frt, pag, r, c, p, i, w):
if w < self.start:
return "Invalid End Date, Before Start Date"
days = dateDiff(self.start, w, ptype="days")
if days > 7:
return "Range More Than 7 Days"
self.end = w
def doQuery(self, frt, pag, r, c, p, i, w):
self.query = w
def doHkRpt(self, frt, pag, r, c, p, i, w):
self.house = w
def doGenInv(self, frt, pag, r, c, p, i, w):
self.geninv = w
if self.geninv == "N":
self.prtinv = "N"
self.df.loadEntry(frt, pag, p+1, data=self.prtinv)
return "sk2"
def doPrtInv(self, frt, pag, r, c, p, i, w):
self.prtinv = w
if self.prtinv == "N":
return "sk1"
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()
# Headings and Mail subject
self.cdes = "%-30s" % self.opts["conam"]
start = self.getDate(self.start)
end = self.getDate(projectDate(self.end, 1))
if self.period == "D":
self.hdes = "Arrivals for Weekdays %s to %s" % (start, end)
elif self.period == "E":
self.hdes = "Arrivals for Weekend %s to %s" % (start, end)
else:
self.hdes = "Arrivals for Period %s to %s" % (start, end)
self.fpdf = MyFpdf(name=self.__class__.__name__, head=80, auto=True)
self.fpdf.header = self.pageHeading
self.rtyp = "A"
self.doArrival()
if self.house == "Y":
self.rtyp = "H"
self.hdes = self.hdes.replace("Arrivals", "Units")
if self.fpdf.page:
self.fpdf.add_page()
self.doHKeeping()
if self.fpdf.page:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
subj = "%s - %s" % (self.cdes, self.hdes)
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=subj, repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
if self.prtinv == "Y" and self.docs:
# Print Invoice
self.docs.sort()
PrintBookingInvoice(self.opts["mf"], self.opts["conum"],
self.opts["conam"], "I", self.docs, tname=self.tname,
repprt=self.df.repprt, repeml=self.df.repeml)
# Print Statement
self.book.sort()
callModule(self.opts["mf"], None, "bk3070",
coy=(self.opts["conum"], self.opts["conam"]),
args=[self.book, self.df.repprt, self.df.repeml])
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doArrival(self):
state = ["C", "S"]
if self.query == "Y":
state.append("Q")
recs = self.sql.getRec("bkmmst", where=[("bkm_cono", "=",
self.opts["conum"]), ("bkm_state", "in", tuple(state))],
order="bkm_ccode")
self.book = []
self.docs = []
last = 0
for rec in recs:
number = rec[self.sql.bkmmst_col.index("bkm_number")]
ccode = rec[self.sql.bkmmst_col.index("bkm_ccode")]
btype = rec[self.sql.bkmmst_col.index("bkm_btype")]
arrive = rec[self.sql.bkmmst_col.index("bkm_arrive")]
depart = rec[self.sql.bkmmst_col.index("bkm_depart")]
if btype == "A":
if depart <= self.start or arrive > self.end:
continue
elif depart < self.start or arrive > self.end:
continue
if self.geninv == "Y":
self.doRaiseInvoice(number, arrive)
con = self.sql.getRec("bkmcon", where=[("bkc_cono", "=",
self.opts["conum"]), ("bkc_ccode", "=", ccode)], limit=1)
sname = con[self.sql.bkmcon_col.index("bkc_sname")].strip()
names = con[self.sql.bkmcon_col.index("bkc_names")].strip()
if names:
name = "%s %s (%s)" % (names.split()[0], sname, number)
else:
name = "%s (%s)" % (sname, number)
bal = self.sql.getRec("bkmtrn", cols=["sum(bkt_tramt)"],
where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number",
"=", number)], limit=1)
rtts = self.sql.getRec("bkmrtt", cols=["brt_udesc",
"brt_uroom", "sum(brt_quant)"], where=[("brt_cono", "=",
self.opts["conum"]), ("brt_number", "=", number)],
group="brt_utype, brt_ucode, brt_udesc, brt_uroom",
order="brt_utype, brt_ucode, brt_uroom")
if not rtts:
continue
units = []
unt = None
for rtt in rtts:
if rtt[1]:
if not unt:
unt = ["%s - R%s" % (rtt[0], rtt[1]), rtt[2]]
else:
unt = ["%s & R%s" % (unt[0], rtt[1]), rtt[2]]
else:
unt = (rtt[0], rtt[2])
units.append(unt)
namq = len(wrap(name, break_long_words=False, width=25))
untq = 0
for unit in units:
untq += len(wrap(unit[0], break_long_words=False, width=25))
if namq and untq > namq:
hh = [(untq * 8.0) / namq, 8, untq * 8]
elif untq and namq > untq:
hh = [8, (namq * 8.0) / untq, namq * 8]
elif namq:
hh = [8, 8, namq * 8]
else:
hh = [8, 8, untq * 8]
if not self.fpdf.page or self.fpdf.get_y() + hh[0] > 280:
self.fpdf.add_page()
oldnm = None
for unit in units:
if name == oldnm:
name = ""
else:
oldnm = name
if arrive >= self.start:
yr = int(arrive / 10000)
mt = int(arrive / 100) % 100
dy = arrive % 100
d = datetime.date(yr, mt, dy)
arr = d.strftime("%a")
else:
arr = "<--"
if btype == "A":
td = projectDate(depart, -1)
else:
td = depart
if td <= self.end:
yr = int(depart / 10000)
mt = int(depart / 100) % 100
dy = depart % 100
e = datetime.date(yr, mt, dy)
dep = e.strftime("%a")
else:
dep = "-->"
if last != number and bal[0]:
amt = CCD(bal[0], "SD", 13.2).disp
else:
amt = CCD(0, "SD", 13.2).disp
self.printLine(name, unit[0], unit[1], arr, dep, amt, hh)
last = number
self.opts["mf"].dbm.commitDbase()
def doHKeeping(self):
recs = self.sql.getRec("bkmunm", cols=["bum_btyp", "bum_code",
"bum_desc"], where=[("bum_cono", "=", self.opts["conum"]),
("bum_room", "<>", 999)], order="bum_btyp, bum_code")
for rec in recs:
col = ["bkm_number", "bkm_btype", "bkm_group", "bkc_sname",
"bkc_names", "bkm_arrive", "bkm_depart", "sum(brt_quant)"]
state = ["C", "S"]
if self.query == "Y":
state.append("Q")
bks = self.sql.getRec(tables=["bkmmst", "bkmrtt", "bkmcon"],
cols=col, where=[("bkm_cono", "=", self.opts["conum"]),
("bkm_state", "in", tuple(state)), ("brt_cono=bkm_cono",),
("brt_number=bkm_number",), ("brt_utype", "=", rec[0]),
("brt_ucode", "=", rec[1]), ("bkc_cono=bkm_cono",),
("bkc_ccode=bkm_ccode",)], order="bkm_arrive, bkc_sname")
qty = ""
arr = ""
dep = ""
amt = ""
totq = 0
lines = []
hh = [8, 8, 8]
for bk in bks:
number = bk[0]
btype = bk[1]
if bk[2]:
name = bk[2]
elif bk[4]:
name = "%s %s" % (bk[4].split()[0], bk[3])
else:
name = bk[3]
name = "%s\n(%s)" % (name.strip(), number)
arrive = bk[5]
depart = bk[6]
if btype == "A":
if depart <= self.start or arrive > self.end:
continue
elif depart < self.start or arrive > self.end:
continue
if arrive >= self.start:
yr = int(arrive / 10000)
mt = int(arrive / 100) % 100
dy = arrive % 100
dt = datetime.date(yr, mt, dy)
arrive = dt.strftime("%a")
else:
arrive = "<--"
if btype == "A":
td = projectDate(depart, -1)
else:
td = depart
if td <= self.end:
yr = int(depart / 10000)
mt = int(depart / 100) % 100
dy = depart % 100
dt = datetime.date(yr, mt, dy)
depart = dt.strftime("%a")
else:
depart = "-->"
rms = self.sql.getRec("bkmrtt",
cols=["brt_uroom"],
where=[
("brt_cono", "=", self.opts["conum"]),
("brt_number", "=", number),
("brt_utype", "=", rec[0]),
("brt_ucode", "=", rec[1])],
order="brt_uroom")
rm = False
for r in rms:
if not r[0]:
continue
if not rm:
name = "%s - R%s" % (name, r[0])
rm = True
else:
name = "%s & R%s" % (name, r[0])
quant = bk[7]
bal = self.sql.getRec("bkmtrn", cols=["sum(bkt_tramt)"],
where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number",
"=", number)], limit=1)
namq = len(wrap(name, break_long_words=False, width=25))
totq += namq
hh[2] = namq * 8
qty = CCD(quant, "UI", 3).disp
arr = CCD(arrive, "NA", 3).disp
dep = CCD(depart, "NA", 3).disp
amt = CCD(bal[0], "SD", 13.2).disp
lines.append([name, qty, arr, dep, amt, copyList(hh)])
if not self.fpdf.page or self.fpdf.get_y() + (totq * 8) > 280:
self.fpdf.add_page()
untq = len(wrap(rec[2], break_long_words=False, width=25))
if not lines:
hh[1] = hh[2] = 8.0 * untq
self.y = self.fpdf.get_y()
self.printLine(rec[2], "", "", "", "", "", hh)
self.fpdf.set_y(self.y)
self.printLine(None, "", "", "", "", "", hh)
else:
if untq > totq:
hh[1] = hh[2] = (untq * 8.0) / totq
elif totq > untq:
hh[0] = (totq * 8.0) / untq
else:
hh[2] = totq * 8
self.y = self.fpdf.get_y()
self.printLine(rec[2], "", "", "", "", "", hh)
self.fpdf.set_y(self.y)
for l in lines:
self.printLine(None, l[0], l[1], l[2], l[3], l[4], l[5])
def doRaiseInvoice(self, number, trdt):
# Raise the Invoice
incamt = 0
vatamt = 0
curdt = int(trdt / 100)
batno = "B%s" % curdt
gls = {}
recs = self.sql.getRec("bkmrtt", where=[("brt_cono",
"=", self.opts["conum"]), ("brt_number", "=", number),
("brt_invno", "=", 0)])
if not recs:
return
invno = self.getRef(number)
self.docs.append(invno)
if number not in self.book:
self.book.append(number)
for rec in recs:
utyp = rec[self.sql.bkmrtt_col.index("brt_utype")]
ucod = rec[self.sql.bkmrtt_col.index("brt_ucode")]
rcod = rec[self.sql.bkmrtt_col.index("brt_rcode")]
rbas = rec[self.sql.bkmrtt_col.index("brt_rbase")]
quan = rec[self.sql.bkmrtt_col.index("brt_quant")]
rate = rec[self.sql.bkmrtt_col.index("brt_arate")]
days = rec[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"], number, 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_invno", "brt_invdt",
"brt_vrate"], data=[invno, trdt, vrte],
where=[("brt_cono", "=", self.opts["conum"]),
("brt_number", "=", number), ("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, number, "Booking %s" % number, 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" % number, "", "", 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" % number,
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" % number,
"", "", 0, self.opts["capnm"], self.sysdtw, 0]
self.sql.insRec("gentrn", data=data)
return True
def getRef(self, number):
rec = self.sql.getRec("bkmtrn", cols=["max(bkt_refno)"],
where=[("bkt_cono", "=", self.opts["conum"]), ("bkt_number",
"=", number), ("bkt_refno", "like", "%7s%s" % (number, "%"))],
limit=1)
if not rec or not rec[0]:
num = 1
else:
num = int(rec[0][-2:]) + 1
return "%7s%02i" % (number, num)
def pageHeading(self):
self.fpdf.drawText(self.cdes, x=7, font=["courier", "B", 24])
self.fpdf.drawText(font=["courier", "B", 14])
self.fpdf.drawText(self.hdes, x=7, font=["courier", "B", 16])
if self.query == "Y":
ides = "Queries Included"
else:
ides = "Queries Not Included"
if self.rtyp == "A":
if self.geninv == "Y":
ides = "%s, Invoices Generated" % ides
else:
ides = "%s, Invoices Not Generated" % ides
self.fpdf.drawText()
self.fpdf.drawText(ides, x=7, font=["courier", "B", 16])
if self.rtyp == "A":
self.fpdf.drawText(font=["courier", "B", 12])
self.printLine("%-25s" % "Name or Group",
"%-25s" % "Unit Description", "Qty", "Arr",
"Dep", " Balance ", (8, 8, 8), fill=1)
else:
self.fpdf.drawText(font=["courier", "B", 12])
self.printLine("%-25s" % "Unit Description",
"%-25s" % "Name or Group", "Qty", "Arr",
"Dep", " Balance ", (8, 8, 8), fill=1)
def getDate(self, date):
if type(date) == str:
date = int(date.replace("-", ""))
yy = int(date / 10000)
mm = int(date / 100) % 100
dd = date % 100
return "%s %s %s" % (dd, mthnam[mm][1], yy)
def printLine(self, a, b, c, d, e, f, hh, bdr="TLB", fill=0):
if self.rtyp == "H" and a is None:
if hh[2] > 8:
ctyp = "M"
else:
ctyp = "S"
elif hh[0] > 8 or hh[1] > 8 or hh[2] > 8:
ctyp = "M"
else:
ctyp = "S"
ft = ["courier", "B", 12]
self.fpdf.set_font(ft[0], ft[1], ft[2])
w = self.fpdf.get_string_width("X" * 26)
x = 7
y = self.fpdf.get_y()
if a:
self.fpdf.drawText(a, x=x, y=y, w=w, h=hh[0], border=bdr,
fill=fill, ctyp=ctyp, font=ft)
if self.rtyp == "H" and not fill:
return
x += w
w = self.fpdf.get_string_width("X" * 26)
self.fpdf.drawText(b, x=x, y=y, w=w, h=hh[1], border=bdr,
fill=fill, ctyp=ctyp, font=ft)
x += w
w = self.fpdf.get_string_width("X" * 4) + 1
h = self.fpdf.get_y() - y
if self.rtyp == "A":
self.fpdf.drawText(c, x=x, y=y, w=w, h=h, border=bdr,
align="R", fill=fill, font=ft)
else:
self.fpdf.drawText(c, x=x, y=y, w=w, h=hh[2], border=bdr,
align="R", fill=fill, ctyp=ctyp, font=ft)
ly = self.fpdf.get_y()
if a or self.rtyp == "H":
x += w
w = self.fpdf.get_string_width("X" * 4)
if self.rtyp == "A":
self.fpdf.drawText(d, x=x, y=y, w=w, h=hh[2], border=bdr,
fill=fill, font=ft)
else:
self.fpdf.drawText(d, x=x, y=y, w=w, h=hh[2], border=bdr,
fill=fill, ctyp=ctyp, font=ft)
x += w
w = self.fpdf.get_string_width("X" * 4)
if self.rtyp == "A":
self.fpdf.drawText(e, x=x, y=y, w=w, h=hh[2], border=bdr,
fill=fill, font=ft)
else:
self.fpdf.drawText(e, x=x, y=y, w=w, h=hh[2], border=bdr,
fill=fill, ctyp=ctyp, font=ft)
x += w
w = self.fpdf.get_string_width("X" * 14)
if self.rtyp == "A":
self.fpdf.drawText(f, x=x, y=y, w=w, h=hh[2], border="TLRB",
fill=fill, font=ft)
else:
self.fpdf.drawText(f, x=x, y=y, w=w, h=hh[2], border="TLRB",
fill=fill, ctyp=ctyp, font=ft)
self.fpdf.set_y(ly)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class gl6060(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, ["ctlctl", "genmst", "genrct"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Delete Imported Bank Statements (%s)" %
self.__class__.__name__)
glm = {
"stype":
"R",
"tables": ("ctlctl", "genmst"),
"cols": (("ctl_conacc", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono", ),
("glm_acno=ctl_conacc", )]
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "IUI", 7, "Bank Account", "", "", "Y",
self.doBankAcc, glm, None, ("efld", )),
(("T", 0, 1,
0), "Id1", 10, "From Date", "From Date (0 for Beginning)", 0,
"Y", self.doFrom, None, None, ("efld", )),
(("T", 0, 2, 0), "Id1", 10, "To Date", "To Date (0 for End)",
0, "Y", self.doTo, None, None, ("efld", )),
(("T", 0, 3, 0), ("IRB", r1s), 0, "Unallocated Only", "", "Y",
"Y", self.doUnall, None, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt)
def doBankAcc(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"
self.acnow = w
self.acnod = self.df.t_disp[pag][r][p]
self.name = acc[0]
def doFrom(self, frt, pag, r, c, p, i, w):
self.start = w
def doTo(self, frt, pag, r, c, p, i, w):
if w and self.start and w < self.start:
return "Invalid Date, Earlier than From Date"
self.to = w
def doUnall(self, frt, pag, r, c, p, i, w):
self.unall = w
def doEnd(self):
self.df.closeProcess()
whr = [("grt_cono", "=", self.opts["conum"]),
("grt_acno", "=", self.acnow)]
if self.start:
whr.append(("grt_date", ">=", self.start))
if self.to:
whr.append(("grt_date", "<=", self.to))
if self.unall == "Y":
whr.append(("grt_flag", "=", "N"))
cnt = self.sql.getRec("genrct", cols=["count(*)"], where=whr, limit=1)
self.sql.delRec("genrct", where=whr)
self.opts["mf"].dbm.commitDbase(
ask=True,
mess="A Total of %s Records were Deleted" % cnt[0],
default="no")
self.closeProcess()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class ms3040(object):
def __init__(self, **opts):
self.opts = opts
self.setVariables()
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
def mainProcess(self):
tab = {
"stype": "R",
"tables": ("chglog", ),
"cols": (("chg_tab", "", 0, "Table Name", "TabNam"), ),
"group": "chg_tab",
"order": "chg_tab"
}
usr = {
"stype": "R",
"tables": ("chglog", ),
"cols":
(("chg_usr", "", 0, "User Login name", "User-Login-Name"), ),
"group": "chg_usr",
"order": "chg_usr"
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "Id1", 10, "Date From", "", 0, "N",
self.doDate, None, None, ("efld", )),
(("T", 0, 1, 0), "ID1", 10, "Date To", "", self.sysdtw, "N",
self.doDate, None, None,
("efld", )), (("T", 0, 2, 0), "INA", 6, "Table Name", "", "",
"N", self.doTable, tab, None, ("efld", )),
(("T", 0, 2, 0), "ONA", 30,
""), (("T", 0, 3, 0), ("IRB", r1s), 0, "Order By Table", "",
"Y", "N", self.doOrder, None, None, None),
(("T", 0, 4, 0), "INA", 20, "User Login", "", "", "N",
self.doUser, usr, None, ("efld", )), (("T", 0, 4, 0), "ONA",
30, ""))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "N"))
def doDate(self, frt, pag, r, c, p, i, w):
if p == 0:
self.frm = CCD(w, "d1", 10)
elif w < self.frm.work:
return "Invalid Date, Less than Start Date"
else:
self.too = CCD(w, "D1", 10)
def doTable(self, frt, pag, r, c, p, i, w):
self.table = w
if self.table:
if self.table not in tabdic:
return "Invalid Table Name"
self.tname = tabdic[w]["idx"][0][0]
self.df.loadEntry(frt, pag, p + 1, data=self.tname)
def doUser(self, frt, pag, r, c, p, i, w):
self.user = w
if self.user:
acc = self.sql.getRec("chglog",
cols=["usr_fnam"],
where=[("usr_name", "=", self.user)],
limit=1)
if not acc:
return "Invalid User Login"
self.tname = acc[0]
self.df.loadEntry(frt, pag, p + 1, data=self.tname)
def doOrder(self, frt, pag, r, c, p, i, w):
self.byusr = w
def doEnd(self):
self.df.closeProcess()
if not self.frm.work:
frm = "Beginning"
else:
frm = self.frm.disp
hds = "Changes Log Report from %s to %s" % (frm, self.too.disp)
col = [("chg_tab", "NA", 6.0, "TabNam"), ("chg_act", "UA", 1.0, "A"),
("chg_key", "NA", 30.0, "Record-Key"),
("chg_col", "NA", 20.0, "Column-Name"),
("chg_old", "TX", 50.0, "Old-Details"),
("chg_new", "TX", 50.0, "New-Details"),
("chg_dte", "TS", 19.0, "Date-&-Time-Changed"),
("chg_usr", "NA", 20.0, "User-Login")]
whr = [("chg_dte", ">=", str(self.frm.work * 1000000)),
("chg_dte", "<=", str((self.too.work * 1000000) + 999999))]
if self.byusr == "Y":
odr = "chg_tab, chg_dte desc"
else:
odr = "chg_dte desc"
if self.table:
whr.append(("chg_tab", "=", self.table))
if self.user:
whr.append(("chg_usr", "=", self.user))
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
tables=["chglog"],
heads=[hds],
cols=col,
where=whr,
order=odr,
repprt=self.df.repprt,
repeml=self.df.repeml)
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class gl1060(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):
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"assgrp", "crsmst", "ctlctl", "ctlmst", "ctlvmf", "drsmst",
"drschn", "genint", "genmst", "genrcc", "rtlprm"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst",
cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])],
limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
#
self.gc = GetCtl(self.opts["mf"])
return True
def mainProcess(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
}
rcc = {
"stype":
"R",
"tables": ("genrcc", ),
"cols":
(("grc_memo", "", 0, "Code"), ("grc_desc1", "", 0, "Details"),
("grc_rtn", "", 0, "R"), ("grc_acoy", "", 0, "Coy"),
("grc_aacc", "", 0, "Acc-Num"), ("grc_acrs", "", 0, "Crs-Acc"),
("grc_achn", "", 0, "Chn"), ("grc_adrs", "", 0,
"Drs-Acc"), ("grc_vat", "", 0, "V")),
"where": [("grc_cono", "=", self.opts["conum"])],
"whera": [["T", "grc_acno", 0]]
}
rct = {
"stype":
"R",
"tables": ("genrct", ),
"cols": (("grt_memo", "", 75, "Details"), ("grt_amount", "SD",
13.2, "Value")),
"where": [("grt_cono", "=", self.opts["conum"]),
("grt_flag", "=", "N")],
"whera": [["T", "grt_acno", 0, 0]],
"group":
"grt_memo",
"order":
"grt_memo",
"comnd":
self.doSameField
}
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")),
"whera": [["T", "glm_cono", 7]]
}
chn = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"whera": [["T", "chm_cono", 7]]
}
self.crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols":
(("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y"),
("crm_add1", "", 0, "Address Line 1")),
"where": [("crm_stat", "<>", "X")],
"whera": [["T", "crm_cono", 7]]
}
self.drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1")),
"where": [("drm_stat", "<>", "X")],
"whera": [["T", "drm_cono", 7], ["T", "drm_chain", 11]]
}
vat = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "Acc-Num"), ("vtm_desc", "", 0,
"Description", "Y")),
"whera": [["T", "vtm_cono", 7]]
}
r1s = (("Payment", "P"), ("Receipt", "R"))
r2s = (("Oldest", "O"), ("Current", "C"))
fld = [[("T", 0, 0, 0), "IUI", 7, "Bank Account", "", "",
"Y", self.doAccNum, ctl, None, None],
(("T", 0, 0, 0), "ONA", 30, ""),
[("T", 0, 1, 0), "IUI", 5, "Memo Code",
"Memo Code (Blank for Next)", "", "Y", self.doMemo, rcc, None,
None],
[("T", 0, 2, 0), "INA", 50, "Memo Desc Contains", "", "", "N",
self.doDesc1, rct, self.doDelete, ("notblank", )],
(("T", 0, 3, 0), "INA", 50, " and Contains",
"Desc Also Contains", "", "N", self.doDesc2, rct, None, None),
(("T", 0, 4, 0), "INA", 50, " and Contains",
"Desc Also Contains", "", "N", self.doDesc3, rct, None, None),
(("T", 0, 5, 0), ("IRB", r1s), 0, "Transaction Type", "", "P",
"N", self.doTypCod, None, None, None),
(("T", 0, 6,
0), "IUI", 7, "Allocation Company", "", self.opts["conum"],
"N", self.doAllCoy, coy, None, ("notzero", )),
(("T", 0, 6, 0), "ONA", 30, ""),
(("T", 0, 7, 0), "IUI", 7, "Allocation Account", "", "", "N",
self.doAllAcc, glm, None, ("notzero", )),
(("T", 0, 7, 0), "ONA", 30, ""),
[["T", 0, 8, 0], "IUI", 3, "Chn", "Chain Store Code", 0, "N",
self.doDrsChn, chn, None, ("efld", )],
(("T", 0, 8, 0), "ONA", 30, ""),
[("T", 0, 9, 0), "INA", 7, "Acc-Num", "Account Number", "", "N",
self.doCrsDrsAcc, self.crm, None, ("notblank", )],
(("T", 0, 9, 0), "ONA", 30, ""),
(("T", 0, 10, 0), ("IRB", r2s), 0, "Ageing Code", "", "O", "N",
self.doCrsDrsAge, None, None, None, None, """
The Ageing Codes are as follows:
Oldest - Automatically age against the oldest outstanding transactions.
Current - Do not age the transaction.
"""),
(("T", 0, 11, 0), "INA", 1, "Vat Code", "", "", "N",
self.doVatCod, vat, None, None)]
but = [("Cancel", None, self.doCancel, 0, ("T", 0, 4), ("T", 0, 1)),
("Quit", None, self.doExit, 1, None, None)]
if "args" in self.opts:
for f in (0, 2, 3):
if f == 3:
fld[f][4] += "(noesc)"
else:
fld[f][7] = None
fld[f][8] = None
fld[f][9] = None
del but[0]
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
if "args" in self.opts:
foc = False
else:
foc = True
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
focus=foc)
if "args" in self.opts:
self.df.loadEntry("T", 0, 0, data=self.opts["args"][0])
self.doAccNum("T", 0, 0, 1, 0, 0, self.opts["args"][0])
self.df.loadEntry("T", 0, 2, data=0)
self.doMemo("T", 0, 0, 3, 2, 2, 0)
self.df.loadEntry("T", 0, 3, data=self.opts["args"][1][2])
self.df.focusField("T", 0, 4)
def doAccNum(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"
self.acno = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doSameField(self, frt, pag, r, c, p, i, w):
self.df.loadEntry("T", 0, self.df.pos, data=w[0])
self.df.focusField("T", 0, self.df.col)
def doMemo(self, frt, pag, r, c, p, i, w):
if not w:
w = self.sql.getRec("genrcc",
cols=["max(grc_memo)"],
where=[("grc_cono", "=", self.opts["conum"]),
("grc_acno", "=", self.acno)],
limit=1)
if not w or not w[0]:
self.memo = 1
else:
self.memo = w[0] + 1
self.df.loadEntry(frt, pag, p, data=self.memo)
else:
self.memo = w
self.old = self.sql.getRec("genrcc",
where=[("grc_cono", "=",
self.opts["conum"]),
("grc_acno", "=", self.acno),
("grc_memo", "=", self.memo)],
limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
col = self.sql.genrcc_col
self.desc1 = self.old[col.index("grc_desc1")]
self.desc2 = self.old[col.index("grc_desc2")]
self.desc3 = self.old[col.index("grc_desc3")]
self.opts["rtn"] = self.old[col.index("grc_rtn")]
self.acoy = self.old[col.index("grc_acoy")]
self.aacc = self.old[col.index("grc_aacc")]
self.acrs = self.old[col.index("grc_acrs")]
self.achn = self.old[col.index("grc_achn")]
self.aage = self.old[col.index("grc_aage")]
self.adrs = self.old[col.index("grc_adrs")]
self.vat = self.old[col.index("grc_vat")]
self.df.loadEntry(frt, pag, 3, data=self.desc1)
self.df.loadEntry(frt, pag, 4, data=self.desc2)
self.df.loadEntry(frt, pag, 5, data=self.desc3)
self.df.loadEntry(frt, pag, 6, data=self.opts["rtn"])
self.df.loadEntry(frt, pag, 7, data=self.acoy)
self.df.loadEntry(frt, pag, 8, data=self.getCoyName())
self.df.loadEntry(frt, pag, 9, data=self.aacc)
self.df.loadEntry(frt, pag, 10, data=self.getAccDesc())
# Creditor and Debtor Details
if self.acrs:
self.crsdrs = "crs"
self.df.loadEntry(frt, pag, 11, data=0)
self.df.loadEntry(frt, pag, 12, data="")
self.df.loadEntry(frt, pag, 13, data=self.acrs)
self.df.loadEntry(frt, pag, 14, data=self.getCrsName())
self.df.loadEntry(frt, pag, 15, data=self.aage)
elif self.adrs:
self.crsdrs = "drs"
self.df.loadEntry(frt, pag, 11, data=self.achn)
if self.achn:
self.df.loadEntry(frt, pag, 12, data=self.getChainName())
else:
self.df.loadEntry(frt, pag, 12, data="")
self.df.loadEntry(frt, pag, 13, data=self.adrs)
self.df.loadEntry(frt, pag, 14, data=self.getDrsName())
self.df.loadEntry(frt, pag, 15, data=self.aage)
else:
self.crsdrs = None
self.df.loadEntry(frt, pag, 11, data=0)
self.df.loadEntry(frt, pag, 12, data="")
self.df.loadEntry(frt, pag, 13, data="")
self.df.loadEntry(frt, pag, 14, data="")
self.df.loadEntry(frt, pag, 15, data="")
# VAT Code
self.df.loadEntry(frt, pag, 16, data=self.vat)
def doDesc1(self, frt, pag, r, c, p, i, w):
self.desc1 = w
def doDesc2(self, frt, pag, r, c, p, i, w):
self.desc2 = w
if not self.desc2:
self.desc3 = ""
self.df.loadEntry(frt, pag, p + 1, data=self.desc3)
if "args" in self.opts:
if self.opts["args"][1][-1] < 0:
self.opts["rtn"] = "P"
else:
self.opts["rtn"] = "R"
self.df.loadEntry(frt, pag, p + 2, data=self.opts["rtn"])
return "sk2"
return "sk1"
def doDesc3(self, frt, pag, r, c, p, i, w):
self.desc3 = w
if "args" in self.opts:
if self.opts["args"][1][-1] < 0:
self.opts["rtn"] = "P"
else:
self.opts["rtn"] = "R"
self.df.loadEntry(frt, pag, p + 1, data=self.opts["rtn"])
return "sk1"
def doTypCod(self, frt, pag, r, c, p, i, w):
self.opts["rtn"] = w
if not self.incoac:
self.acoy = self.opts["conum"]
if self.doChkLoadCtls():
return "rf"
else:
self.df.loadEntry(frt, pag, p + 1, data=self.acoy)
self.df.loadEntry(frt, pag, p + 2, data=self.getCoyName())
return "sk2"
def doAllCoy(self, frt, pag, r, c, p, i, w):
self.acoy = w
name = self.getCoyName()
if not name:
return "Invalid Company Number"
self.df.loadEntry(frt, pag, p + 1, data=name)
return self.doChkLoadCtls()
def doChkLoadCtls(self):
# Check for Intercompany Records
if self.acoy != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", self.opts["conum"]),
("cti_inco", "=", self.acoy)],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 1"
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", self.acoy),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
# Get Company Details
ctlmst = self.gc.getCtl("ctlmst", self.acoy)
if not ctlmst:
return "rf"
# Set Company VAT Default
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
# Check for Integrated Systems
mod = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
mod.append(ctlmst["ctm_modules"][x:x + 2])
# Check for Control Records e.g. VAT and Discounts
self.ctlctl = self.gc.getCtl("ctlctl", self.acoy)
if not self.ctlctl:
return "rf"
ctls = ["vat_ctl"]
# Load Crs Integration
if mod.count("CR"):
ctl = self.gc.getCtl("crsctl", self.acoy)
if not ctl:
return "rf"
self.crs_gl = ctl["ctc_glint"]
if self.crs_gl == "Y":
ctls.extend(["crs_ctl", "dis_rec"])
else:
self.crs_gl = "N"
# Load Drs Integration and Chain Store Flag
if mod.count("DR"):
ctl = self.gc.getCtl("drsctl", self.acoy)
if not ctl:
return "rf"
self.drs_gl = ctl["ctd_glint"]
self.drs_ch = ctl["ctd_chain"]
if self.drs_gl == "Y":
ctls.extend(["drs_ctl", "dis_all"])
else:
self.drs_gl = "N"
if self.gc.chkRec(self.acoy, self.ctlctl, ctls):
return "rf"
def doAllAcc(self, frt, pag, r, c, p, i, w):
if self.acoy == self.opts["conum"] and w == self.acno:
return "This is the Bank Account Number"
ctl = True
self.crsdrs = False
if self.crs_gl == "Y" and w == self.ctlctl["crs_ctl"]:
self.crsdrs = "crs"
self.df.topf[0][p + 4][8] = self.crm
elif self.drs_gl == "Y" and w == self.ctlctl["drs_ctl"]:
self.crsdrs = "drs"
self.df.topf[0][p + 4][8] = self.drm
if self.crsdrs:
ctl = False
chk = chkGenAcc(self.opts["mf"], self.acoy, w, ctl=ctl)
if type(chk) is str:
return chk
self.aacc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if self.crsdrs:
if self.crsdrs == "crs" or self.drs_ch == "N":
self.achn = 0
self.df.topf[0][p + 2][1] = "OUI"
self.df.loadEntry(frt, pag, p + 2, data=self.achn)
self.df.loadEntry(frt, pag, p + 3, data="")
return "sk3"
elif self.crsdrs == "drs":
self.df.topf[0][p + 2][1] = "IUI"
return "sk1"
else:
self.acrs = ""
self.achn = 0
self.adrs = ""
self.aage = ""
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="")
self.df.loadEntry(frt, pag, p + 6, data="")
if not self.df.t_work[pag][0][p + 7]:
if chk[2]:
self.df.loadEntry(frt, pag, p + 7, data=chk[2])
else:
self.df.loadEntry(frt, pag, p + 7, data=self.taxdf)
return "sk6"
def doDrsChn(self, frt, pag, r, c, p, i, w):
self.achn = w
name = self.getChainName()
if not name:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=name)
def doCrsDrsAcc(self, frt, pag, r, c, p, i, w):
if self.crsdrs == "crs":
self.acrs = w
name = self.getCrsName()
else:
self.adrs = w
name = self.getDrsName()
if not name:
return "Invalid Account Number %s" % self.crsdrs.capitalize()
if name[1] == "X":
return "Invalid Account %s, Redundant" % self.crsdrs.capitalize()
self.df.loadEntry(frt, pag, p + 1, data=name[0])
def doCrsDrsAge(self, frt, pag, r, c, p, i, w):
self.aage = w
self.vat = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.vat)
return "sk1"
def doVatCod(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.acoy),
("vtm_code", "=", w)],
limit=1)
if not vat:
return "Invalid VAT Code"
self.vat = w
def doDelete(self):
self.sql.delRec("genrcc",
where=[("grc_cono", "=", self.opts["conum"]),
("grc_acno", "=", self.acno),
("grc_memo", "=", self.memo)])
def doEnd(self):
data = [
self.opts["conum"], self.acno, self.memo, self.desc1, self.desc2,
self.desc3, self.opts["rtn"], self.acoy, self.aacc
]
if self.crsdrs:
if self.crsdrs == "crs":
data.extend([self.acrs, 0, "", self.aage, self.vat])
else:
data.extend(["", self.achn, self.adrs, self.aage, self.vat])
else:
data.extend(["", 0, "", "", self.vat])
if self.new == "y":
self.sql.insRec("genrcc", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genrcc_col
data.append(self.old[col.index("grc_xflag")])
self.sql.updRec("genrcc",
data=data,
where=[("grc_cono", "=", self.opts["conum"]),
("grc_acno", "=", self.acno),
("grc_memo", "=", self.memo)])
if "args" in self.opts:
self.doExit()
else:
for x in range(2, self.df.topq[0]):
self.df.loadEntry("T", 0, x, data="")
self.df.focusField("T", 0, 3)
def getCoyName(self):
coy = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", self.acoy)],
limit=1)
if coy:
return coy[0]
def getAccDesc(self):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.acoy),
("glm_acno", "=", self.aacc)],
limit=1)
if acc:
return acc[0]
def getCrsName(self):
acc = self.sql.getRec("crsmst",
cols=["crm_name", "ctm_stat"],
where=[("crm_cono", "=", self.acoy),
("crm_acno", "=", self.acrs)],
limit=1)
if acc:
return acc
def getChainName(self):
acc = self.sql.getRec("drschn",
cols=["chm_name"],
where=[("chm_cono", "=", self.acoy),
("chm_chain", "=", self.achn)],
limit=1)
if acc:
return acc[0]
def getDrsName(self):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.acoy),
("drm_chain", "=", self.achn),
("drm_acno", "=", self.adrs)],
limit=1)
if acc:
return acc
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.opts["mf"].dbm.commitDbase()
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class rtc210(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["chglog", "genmst", "rtlprm", "rtlmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.glint = rtlctl["ctr_glint"]
return True
def mainProcess(self):
prm = {
"stype":
"R",
"tables": ("rtlprm", ),
"cols": (("rtp_code", "", 0, "Prm-Code"), ("rtp_desc", "", 0,
"Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])],
"order":
"glm_acno"
}
self.fld = [(("T", 0, 0, 0), "INA", 7, "Premises Code", "Premises", "",
"N", self.doPrmCod, prm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 4, "Postal Code", "PCod", "", "N",
None, None, None, ("notblank", ))]
if self.glint == "Y":
self.fld.append(
(("T", 0, 6, 0), "IUI", 7, "Rental Account", "", "", "N",
self.doRental, glm, None, ("notzero", ), None,
"Rental Control Account in the General Ledger."))
self.fld.append((("T", 0, 6, 0), "ONA", 30, ""))
self.fld.append(
(("T", 0, 7, 0), "IUI", 7, "Income Account", "", "", "N",
self.doIncome, glm, None, ("notzero", ), None,
"Rental Income Account in the General Ledger."))
self.fld.append((("T", 0, 7, 0), "ONA", 30, ""))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doPrmCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("rtlprm",
where=[("rtp_cono", "=",
self.opts["conum"]),
("rtp_code", "=", self.code)],
limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
acc = copyList(self.old[:-1])
acc.append("")
acc.insert(8, "")
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=acc[x + 1])
if self.glint == "N":
return
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc[7])],
limit=1)
if des:
self.df.loadEntry("T", 0, 7, data=des[0])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc[9])],
limit=1)
if des:
self.df.loadEntry("T", 0, 9, data=des[0])
def doRental(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", 0, 7, data=acc[0])
def doIncome(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", 0, 9, data=acc[0])
def doDelete(self):
mst = self.sql.getRec("rtlmst",
cols=["count(*)"],
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code)],
limit=1)
if mst[0]:
return "Accounts Exist, Not Deleted"
self.sql.delRec("rtlprm",
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"rtlprm", "D",
"%03i%-7s" % (self.opts["conum"], self.code), "",
dte, self.opts["capnm"], "", "", "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if self.glint == "Y" and x in (7, 9):
continue
data.append(self.df.t_work[0][0][x])
if self.glint == "N":
data.extend([0, 0])
if self.new == "y":
self.sql.insRec("rtlprm", data=data)
elif data != self.old[:len(data)]:
col = self.sql.rtlprm_col
data.append(self.old[col.index("rtp_xflag")])
self.sql.updRec("rtlprm",
data=data,
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"rtlprm", "U",
"%03i%-7s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bk3020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.sper = int(self.opts["period"][1][0] / 100)
self.eper = int(self.opts["period"][2][0] / 100)
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Bookings Manager Audit Trail (%s)" %
self.__class__.__name__)
self.sql = Sql(self.opts["mf"].dbm,
["ctlmst", "bkmmst", "bkmtrn", "bkmcon"],
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
self.fromad = bkmctl["cbk_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdttm = "(Printed on: %i/%02i/%02i at %02i:%02i) %6s" % (
t[0], t[1], t[2], t[3], t[4], self.__class__.__name__)
self.colsh = [
"TP", "BatchNo", "Book-Num", "Name", "Reference", "Date", "Debits",
"Credits", "Tax-Amount", "T", "Remarks"
]
self.forms = [("UI", 2, False, False, True), ("Na", 7),
("NA", 8, False, False, True), ("NA", 30), ("Na", 9),
("D1", 10), ("SD", 13.2), ("SD", 13.2), ("SD", 13.2),
("UA", 1), ("NA", 30)]
self.gqt = [0] * (len(bktrtp) + 1)
self.gdr = [0] * (len(bktrtp) + 1)
self.gcr = [0] * (len(bktrtp) + 1)
self.gvt = [0] * (len(bktrtp) + 1)
self.totind = "N"
return True
def mainProcess(self):
data = ["All Types"]
for typ in bktrtp:
data.append(typ[1])
btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"}
btm = {
"stype":
"R",
"tables": ("bkmtrn", ),
"cols": (("bkt_batch", "", 0,
"Bat-Num"), ("bkt_type", ("xx", bktrtp), 20, "Type"),
("bkt_curdt", "", 0, "Cur-Dat")),
"where": [],
"group":
"bkt_batch, bkt_type, bkt_curdt",
"order":
"bkt_type, bkt_curdt, bkt_batch"
}
r1s = (("Financial", "F"), ("Capture", "C"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Period Type", "", "F", "Y",
self.doPtyp, None, None, None),
(("T", 0, 1, 0), "Id2", 7, "Starting Period", "", self.sper,
"Y", self.doStartPer, None, None, ("efld", )),
(("T", 0, 2, 0), "Id2", 7, "Ending Period", "", self.eper, "Y",
self.doEndPer, None, None, ("efld", )),
(("T", 0, 3, 0), "Id1", 10, "Starting Date", "", self.sysdtw,
"Y", self.doStartDat, None, None, ("efld", )),
(("T", 0, 4, 0), "Id1", 10, "Ending Date", "", self.sysdtw, "Y",
self.doEndDat, None, None, ("efld", )),
(("T", 0, 5, 0), "IUI", 1, "Type", "Transaction Type", "", "Y",
self.doBatTyp, btt, None, None),
(("T", 0, 6, 0), "INa", 7, "Batch Number", "", "", "Y",
self.doBatNum, btm, None, None),
(("T", 0, 7, 0), ("IRB", r2s), 0, "Totals Only", "", "Y", "Y",
self.doTots, None, 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=("Y", "V"),
mail=("Y", "N"))
def doPtyp(self, frt, pag, r, c, p, i, w):
self.ptyp = w
if self.ptyp == "C":
return "sk2"
def doStartPer(self, frt, pag, r, c, p, i, w):
if not w:
w = self.sper
elif w < self.sper or w > self.eper:
return "Invalid Period"
self.sperw = w
self.df.loadEntry(frt, pag, p, data=self.sperw)
self.sperd = self.df.t_disp[pag][0][i]
def doEndPer(self, frt, pag, r, c, p, i, w):
if not w:
w = self.eper
elif w < self.sperw or w > self.eper:
return "Invalid Period"
self.eperw = w
self.df.loadEntry(frt, pag, p, self.eperw)
self.eperd = self.df.t_disp[pag][0][i]
return "sk2"
def doStartDat(self, frt, pag, r, c, p, i, w):
self.sdatw = w
self.df.loadEntry(frt, pag, p, data=self.sdatw)
self.sperd = self.df.t_disp[pag][0][i]
def doEndDat(self, frt, pag, r, c, p, i, w):
if w < self.sdatw:
return "Invalid Date"
self.edatw = w
self.df.loadEntry(frt, pag, p, self.edatw)
self.eperd = self.df.t_disp[pag][0][i]
def doBatTyp(self, frt, pag, r, c, p, i, w):
if w > len(bktrtp):
return "Invalid Batch Type"
self.btyp = w
self.whr = [("bkt_cono", "=", self.opts["conum"])]
if self.ptyp == "F":
self.whr.append(("bkt_curdt", "between", self.sperw, self.eperw))
else:
self.whr.append(("bkt_capdt", "between", self.sdatw, self.edatw))
if self.btyp:
self.whr.append(("bkt_type", "=", self.btyp))
self.df.topf[pag][i + 1][8]["where"] = self.whr
def doBatNum(self, frt, pag, r, c, p, i, w):
self.batch = w
if self.batch:
self.whr.append(("bkt_batch", "=", self.batch))
def doTots(self, frt, pag, r, c, p, i, w):
self.totsonly = w
mx = len(self.df.topEntry[0][8])
if self.totsonly == "Y":
if mx > 3:
self.df.setWidget(self.df.topEntry[0][8][3][0], state="hide")
if mx > 4:
self.df.setWidget(self.df.topEntry[0][8][4][0], state="hide")
else:
if mx > 3:
self.df.setWidget(self.df.topEntry[0][8][3][0], state="show")
if mx > 4:
self.df.setWidget(self.df.topEntry[0][8][4][0], state="show")
def doEnd(self):
self.df.closeProcess()
recs = self.getRecords()
if recs:
if self.df.repprt[2] == "export":
self.exportReport(recs)
else:
self.printReport(recs)
self.closeProcess()
def getRecords(self):
col = [
"bkt_number", "bkt_date", "bkt_type", "bkt_refno", "bkt_batch",
"bkt_tramt", "bkt_taxamt", "bkt_desc", "bkt_taxind", "bkc_sname",
"bkc_names"
]
self.whr.extend([("bkm_cono=bkt_cono", ), ("bkm_number=bkt_number", ),
("bkc_cono=bkt_cono", ), ("bkc_ccode=bkm_ccode", )])
odr = "bkt_type, bkt_batch, bkt_date, bkt_refno"
recs = self.sql.getRec(tables=["bkmtrn", "bkmmst", "bkmcon"],
cols=col,
where=self.whr,
order=odr)
if not recs:
showError(self.opts["mf"].body, "Transaction Error",
"No Transactions Selected")
else:
return recs
def exportReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
expnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"])
self.expheads = [
"%03u %-30s %s" %
(self.opts["conum"], self.opts["conam"], self.sysdttm)
]
self.expheads.append("Bookings Manager Audit Trail for Period "\
"%s to %s" % (self.sperd, self.eperd))
self.expcolsh = [self.colsh]
self.expforms = self.forms
self.expdatas = []
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
p.closeProgress()
return
bkmno, trdt, trtp, refno, batch, debit, credit, taxamt, \
detail, taxind, name = self.getValues(dat)
line = [
"BODY",
[
trtp.work, batch.work, bkmno.work, name.work, refno.work,
trdt.work, debit.work, credit.work, taxamt.work,
taxind.work, detail.work
]
]
self.expdatas.append(line)
p.closeProgress()
self.grandTotal()
doWriteExport(xtype=self.df.repprt[1],
name=expnam,
heads=self.expheads,
colsh=self.expcolsh,
forms=self.expforms,
datas=self.expdatas,
rcdic=self.opts["mf"].rcdic)
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
if self.totsonly == "Y":
self.head = "%03u %-87s" % (self.opts["conum"], self.opts["conam"])
else:
self.head = "%03u %-133s" % (self.opts["conum"],
self.opts["conam"])
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.bqty = 0
self.bdrs = 0
self.bcrs = 0
self.bvat = 0
self.tqty = 0
self.tdrs = 0
self.tcrs = 0
self.tvat = 0
self.trtp = 0
self.pglin = 999
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
bkmno, trdt, trtp, refno, batch, debit, credit, taxamt, \
detail, taxind, name = self.getValues(dat)
if not self.trtp:
self.trtp = trtp.work
self.batch = batch.work
if trtp.work != self.trtp:
self.batchTotal()
self.typeTotal()
self.trtp = trtp.work
self.batch = batch.work
self.pglin = 999
if batch.work != self.batch:
self.batchTotal()
self.batch = batch.work
if self.totsonly != "Y":
self.typeHeading()
if self.pglin > self.fpdf.lpp:
self.pageHeading()
if self.totsonly != "Y":
self.fpdf.drawText(
"%s %s %s %s %s %s %s %s %s" %
(bkmno.disp, name.disp, refno.disp, trdt.disp, debit.disp,
credit.disp, taxamt.disp, taxind.disp, detail.disp))
self.pglin += 1
# Batch Totals
self.bqty += 1
self.bdrs = float(ASD(self.bdrs) + ASD(debit.work))
self.bcrs = float(ASD(self.bcrs) + ASD(credit.work))
self.bvat = float(ASD(self.bvat) + ASD(taxamt.work))
# Type Totals
self.tqty += 1
self.tdrs = float(ASD(self.tdrs) + ASD(debit.work))
self.tcrs = float(ASD(self.tcrs) + ASD(credit.work))
self.tvat = float(ASD(self.tvat) + ASD(taxamt.work))
p.closeProgress()
if self.fpdf.page and not p.quit:
self.batchTotal()
self.typeTotal()
self.grandTotal()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
def getValues(self, data):
bkmno = CCD(data[0], "UI", 7)
trdt = CCD(data[1], "D1", 10)
trtp = CCD(data[2], "UI", 2)
refno = CCD(data[3], "Na", 9)
batch = CCD(data[4], "Na", 7)
if data[5] < 0:
debit = CCD(0, "SD", 13.2)
credit = CCD(data[5], "SD", 13.2)
else:
debit = CCD(data[5], "SD", 13.2)
credit = CCD(0, "SD", 13.2)
taxamt = CCD(data[6], "SD", 13.2)
detail = CCD(data[7], "NA", 30)
taxind = CCD(data[8], "NA", 1)
name = CCD("%s, %s" % (data[9], data[10]), "NA", 30)
self.gqt[trtp.work - 1] += 1
self.gdr[trtp.work - 1] = float(ASD(self.gdr[trtp.work - 1]) + \
ASD(debit.work))
self.gcr[trtp.work - 1] = float(ASD(self.gcr[trtp.work - 1]) + \
ASD(credit.work))
self.gvt[trtp.work - 1] = float(ASD(self.gvt[trtp.work - 1]) + \
ASD(taxamt.work))
return (bkmno, trdt, trtp, refno, batch, debit, credit, taxamt, detail,
taxind, name)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-38s %-7s %2s %-40s" % \
("Bookings Manager Audit Trail for Period",
self.sperd, "to", self.eperd))
else:
self.fpdf.drawText("%-38s %-7s %2s %-86s" % \
("Bookings Manager Audit Trail for Period",
self.sperd, "to", self.eperd))
self.fpdf.drawText()
self.pglin = 4
if self.totind == "N":
self.typeHeading()
else:
self.fpdf.drawText("%-14s" % "Totals Summary")
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-27s%-8s %-13s %-13s %-13s %-13s" % \
("Document Type", "Quantity", " Debits",
" Credits", " Difference", " V.A.T."))
else:
self.fpdf.drawText("%-33s%-8s %-13s %-13s %-13s %-13s" % \
("Document Type", "Quantity", " Debits",
" Credits", " Difference", " V.A.T."))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def typeHeading(self):
if self.totsonly != "Y":
batch = self.batch
else:
batch = "Various"
if self.fpdf.lpp - self.pglin < 7:
self.pageHeading()
return
self.fpdf.setFont(style="B")
self.fpdf.drawText("%-7s %7s %-10s %3s" % \
("Batch", batch, " Type", bktrtp[self.trtp - 1][1]))
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-36s %-13s %-13s %-13s %-13s" % \
("Details", " Debits", " Credits", " Difference",
" V.A.T."))
else:
self.fpdf.drawText("%-7s %-30s %-9s %-10s %-13s %-13s %-13s "\
"%-1s %-30s" % ("Booking", "Name", "Reference",
" Date", " Debits", " Credits", " Tax-Amount",
"T", "Remarks"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def batchTotal(self):
j = CCD(self.bdrs, "SD", 13.2)
k = CCD(self.bcrs, "SD", 13.2)
l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 13.2)
m = CCD(self.bvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-36s %13s %13s %13s %13s" % \
("Batch " + self.batch + " Totals", j.disp,
k.disp, l.disp, m.disp))
self.pglin += 1
else:
self.fpdf.drawText()
self.fpdf.drawText("%-7s %-51s %13s %13s %13s" %
(" ", "Batch " + self.batch + " Totals", j.disp,
k.disp, m.disp))
self.fpdf.drawText()
self.pglin += 3
self.bqty = 0
self.bcrs = 0
self.bdrs = 0
self.bvat = 0
def typeTotal(self):
j = CCD(self.tdrs, "SD", 13.2)
k = CCD(self.tcrs, "SD", 13.2)
l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 13.2)
m = CCD(self.tvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText()
self.fpdf.drawText("%-36s %13s %13s %13s %13s" % \
("Type Totals", j.disp, k.disp, l.disp, m.disp))
self.pglin += 2
else:
self.fpdf.drawText("%-7s %-51s %13s %13s %13s" % \
(" ", "Type-Totals", j.disp, k.disp, m.disp))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
self.tqty = 0
self.tcrs = 0
self.tdrs = 0
self.tvat = 0
def grandTotal(self):
tot = [0, 0, 0, 0, 0]
if self.df.repprt[2] == "export":
for x, t in enumerate(bktrtp):
tot[0] = float(ASD(tot[0]) + ASD(self.gdr[x]))
tot[1] = float(ASD(tot[1]) + ASD(self.gcr[x]))
tot[2] = float(ASD(tot[2]) + ASD(self.gvt[x]))
self.expdatas.append(["ULINES"])
self.expdatas.append([
"TOTAL",
[
"", "", "", "", "Grand Totals", "", "", tot[0], tot[1],
tot[2], ""
]
])
self.expdatas.append(["ULINED"])
return
self.totind = "Y"
self.pageHeading()
for x, t in enumerate(bktrtp):
qt = CCD(self.gqt[x], "SI", 8)
dr = CCD(self.gdr[x], "SD", 13.2)
cr = CCD(self.gcr[x], "SD", 13.2)
df = float(ASD(dr.work) + ASD(cr.work))
df = CCD(df, "SD", 13.2)
vt = CCD(self.gvt[x], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-27s %s %s %s %s %s" % \
(t[1], qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
else:
self.fpdf.drawText("%-33s %s %s %s %s %s" % \
(t[1], qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
tot[0] = tot[0] + qt.work
tot[1] = float(ASD(tot[1]) + ASD(dr.work))
tot[2] = float(ASD(tot[2]) + ASD(cr.work))
tot[3] = float(ASD(tot[3]) + ASD(df.work))
tot[4] = float(ASD(tot[4]) + ASD(vt.work))
self.fpdf.drawText()
qt = CCD(tot[0], "SI", 8)
dr = CCD(tot[1], "SD", 13.2)
cr = CCD(tot[2], "SD", 13.2)
df = CCD(tot[3], "SD", 13.2)
vt = CCD(tot[4], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-27s %s %s %s %s %s" % \
("Grand Totals", qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
else:
self.fpdf.drawText("%-33s %s %s %s %s %s" % \
("Grand Totals", qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
self.fpdf.drawText()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class rt2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
tabs = [
"ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint", "genmst",
"gentrn", "rtlprm", "rtlmst", "rtlcon", "rtltrn"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.opts["rtn"] not in (2, 3, 4):
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
self.gc = GetCtl(self.opts["mf"])
rtlctl = self.gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.glint = rtlctl["ctr_glint"]
if self.glint == "Y":
# Check All Premises Control Records
errs = ("Premises %s Has An Invalid",
"Rental Control Account (%s)",
"Rental Income Account (%s)")
ass = self.sql.getRec(
"rtlprm",
cols=["rtp_code", "rtp_rtlacc", "rtp_incacc"],
where=[("rtp_cono", "=", self.opts["conum"])])
for acc in ass:
for x in range(1, 3):
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", acc[x])],
limit=1)
if not chk:
mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x])
showError(self.opts["mf"].body, "Control Error", mess)
return
# Check for VAT Control
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return
self.convat = ctlctl["vat_ctl"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"RTL",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 2:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
return True
def drawDialog(self):
prm = {
"stype":
"R",
"tables": ("rtlprm", ),
"cols": (("rtp_code", "", 0, "Prm-Cod"), ("rtp_desc", "", 0,
"Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]
}
mst = {
"stype":
"R",
"tables": ("rtlmst", ),
"cols":
(("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")),
"where": [("rtm_cono", "=", self.opts["conum"])],
"whera": [["C", "rtm_code", 0, 1]]
}
con = {
"stype":
"R",
"tables": ("rtlcon", ),
"cols":
(("rtc_cnum", "", 0, "Acc-Num"), ("rtc_payind", "", 0, "F"),
("rtc_start", "", 0, "Start-Date"), ("rtc_period", "", 0, "Per")),
"where": [("rtc_cono", "=", self.opts["conum"])],
"whera": [["C", "rtc_code", 0, 1], ["C", "rtc_acno", 1, 1]]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INA", 7, "Prm-Cod", "Premises Code", "r", "N",
self.doPrmCod, prm, None, None),
(("C", 1, 0, 1), "INA", 7, "Acc-Num", "Account Number", "r",
"N", self.doAccNum, mst, None, None),
(("C", 1, 0, 2), "IUI", 3, "Seq", "Contract Sequence", "", "N",
self.doConSeq, con, None, None),
(("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number", "i",
"N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, None),
(("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", "", "N",
self.doVatCod, vtm, None, ("notblank", )),
(("C", 1, 0, 7), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
[("C", 1, 0, 8), "INA", 30, "Details", "Transaction Details",
"", "N", self.doTrnDet, None, None, None]]
if self.opts["rtn"] not in (2, 3) and self.glint == "Y":
fld[10][2] = (22, 30)
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = (("Interrogate", None, self.queryRtl, 0, ("C", 1, 1),
("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1)))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (2, 3) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doPrmCod(self, frt, pag, r, c, p, i, w):
whr = [("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", w)]
acc = self.sql.getRec("rtlprm", where=whr, limit=1)
if not acc:
return "Invalid Premises Code"
self.code = w
self.rtlacc = acc[self.sql.rtlprm_col.index("rtp_rtlacc")]
def doAccNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlmst",
cols=["rtm_name", "rtm_vatind"],
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.acno = w
con = self.sql.getRec("rtlcon",
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)],
order="rtc_cnum")
if not con:
return "No Valid Contracts"
self.cnum = con[-1:][0][3]
self.df.colf[1][2][5] = self.cnum
if self.opts["rtn"] == 4:
self.df.colf[1][6][5] = acc[1]
else:
self.df.colf[1][6][5] = "N"
def doConSeq(self, frt, pag, r, c, p, i, w):
con = self.sql.getRec("rtlcon",
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno),
("rtc_cnum", "=", w)],
order="rtc_cnum")
if not con:
return "Invalid Contract Sequence"
self.cnum = w
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.opts["rtn"] in (2, 3):
self.vatcode = ""
self.trnvat = 0
return "sk2"
def doVatCod(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.trnvat = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.trnvat)
if not self.trnvat:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.trnvat = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.trnvat = float(ASD(0) - ASD(w))
else:
self.trnvat = w
self.df.loadEntry(frt, pag, p, data=self.trnvat)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (2, 3) and self.glint == "Y":
self.df.colf[2][3][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] in (2, 3) or self.glint == "N":
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.trnamt = float(ASD(self.trnamt) - ASD(self.trnvat))
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.selPage("Allocation")
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.trnvat
if self.opts["rtn"] == 2: # Receipts
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.glt = 6
elif self.opts["rtn"] == 3: # Payments
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.glt = 2
elif self.opts["rtn"] == 4: # Journal Entries
self.recon = 0
self.glt = 4
# Rental Ledger Transaction
data = [
self.opts["conum"], self.code, self.acno, self.cnum,
self.opts["rtn"], self.trnref, self.bh.batno, self.trndat,
self.amt, self.vat, self.curdt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("rtltrn", data=data)
if self.vatcode:
# VAT Transaction (ctlvtf)
exc = float(ASD(0) - ASD(self.amt) + ASD(self.vat))
vat = float(ASD(0) - ASD(self.vat))
data = (self.opts["conum"], self.vatcode, "O", self.curdt, "R",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.code, self.trndet, exc, vat, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Rental Account
data = (self.opts["conum"], self.rtlacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, self.vat,
self.trndet, self.vatcode, "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
self.trnamt = float(ASD(0) - ASD(self.amt))
self.trnvat = float(ASD(0) - ASD(self.vat))
if self.vatcode and self.trnvat:
# General Ledger Control Transaction (V.A.T.)
data = (self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.trnvat, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
if self.opts["rtn"] in (2, 3):
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
# General Ledger Transaction (Source)
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.allamt, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryRtl(self):
callModule(self.opts["mf"],
self.df,
"rt4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class bk3070(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.doEnd()
else:
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
bkmctl = gc.getCtl("bkmctl", self.opts["conum"])
if not bkmctl:
return
self.stpl = bkmctl["cbk_statpl"]
self.fromad = bkmctl["cbk_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = CCD(self.sysdtw, "D1", 10).disp
self.sql = Sql(self.opts["mf"].dbm,
["ctlmst", "bkmcon", "bkmmst", "bkmtrn", "tplmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "S"), ("tpm_system", "=", "BKM")],
"order":
"tpm_tname"
}
bkm = {
"stype":
"R",
"tables": ("bkmmst", "bkmcon"),
"cols": (("bkm_number", "", 0, "Booking"),
("bkc_sname", "", 0, "Surname", "Y"), ("bkc_names", "", 0,
"Names", "F")),
"where":
(("bkm_cono", "=", self.opts["conum"]), ("bkm_state", "<>", "X"),
("bkc_cono=bkm_cono", ), ("bkc_ccode=bkm_ccode", ))
}
r1s = (("Yes", "Y"), ("Range", "R"), ("Singles", "S"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.stpl, "Y",
self.doTplNam, tpm, None, None),
(("T", 0, 1,
0), ("IRB", r1s), 0, "Whole File", "", "Y", "N", self.doWhole,
None, None, None), (("T", 0, 2, 0), "IUI", 7, "From Booking",
"", "", "N", self.doAcc, bkm, None, None),
(("T", 0, 3, 0), "IUI", 7, "To Booking", "", "", "N",
self.doAcc, bkm, None, None),
(("T", 0, 4, 0), ("IRB", r2s), 0, "Include Cancellations", "",
"Y", "N", self.doCancel, None, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("B", "Y"))
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "S"),
("tpm_system", "=", "BKM")],
limit=1)
if not acc:
return "Invalid Template Name"
self.tname = w
def doWhole(self, frt, pag, r, c, p, i, w):
self.whole = w
if self.whole in ("Y", "S"):
self.snum = 0
self.enum = 0
self.df.loadEntry("T", 0, p + 1, data="")
self.df.loadEntry("T", 0, p + 2, data="")
return "sk2"
def doAcc(self, frt, pag, r, c, p, i, w):
if p == 2:
self.snum = w
else:
self.enum = w
chk = self.sql.getRec("bkmmst",
where=[("bkm_cono", "=", self.opts["conum"]),
("bkm_number", "=", w)],
limit=1)
if not chk:
return "Invalid Booking Number"
if p == 2:
self.df.loadEntry(frt, pag, p + 1, data=self.snum)
def doCancel(self, frt, pag, r, c, p, i, w):
self.cancel = w
def doEnd(self):
if "args" in self.opts:
self.cancel = "Y"
self.tname = self.stpl
self.whole = "A"
self.snum = 0
self.enum = 0
if len(self.opts["args"]) == 1:
self.repprt = ["N", "V", "view"]
self.repeml = ["N", "N", "", "", "Y"]
else:
self.repprt = self.opts["args"][1]
self.repeml = self.opts["args"][2]
else:
self.df.closeProcess()
self.repprt = self.df.repprt
self.repeml = self.df.repeml
if not self.enum:
self.enum = 9999999
self.emadd = self.repeml[2]
tab = ["bkmmst"]
whr = [("bkm_cono", "=", self.opts["conum"])]
if self.cancel == "N":
whr.append(("bkm_state", "<>", "X"))
odr = "bkm_number"
if self.whole == "A":
if type(self.opts["args"][0]) == int:
whr.append(("bkm_number", "=", self.opts["args"][0]))
else:
whr.append(("bkm_number", "in", self.opts["args"][0]))
recs = self.sql.getRec("bkmmst", where=whr, order=odr)
elif self.whole == "S":
tab.append("bkmcon")
col = ["bkm_number", "bkc_sname", "bkc_names"]
whr.extend([("bkc_cono=bkm_cono", ), ("bkc_ccode=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]
data = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr)
data = getSingleRecords(self.opts["mf"],
tab,
col,
dic=dic,
where=data,
ttype="D")
recs = []
for dat in data:
acc = self.sql.getRec("bkmmst",
where=[("bkm_cono", "=",
self.opts["conum"]),
("bkm_number", "=", dat[0])])
recs.append(acc[0])
else:
if self.whole == "R":
whr.extend([("bkm_number", ">=", self.snum),
("bkm_number", "<=", self.enum)])
recs = self.sql.getRec("bkmmst", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Error", "No Bookings Selected")
else:
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
for num, rec in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
self.doProcess(rec)
p.closeProgress()
if p.quit or not self.form.page:
pass
elif self.repeml[1] == "N" or self.emadd:
self.repeml[2] = self.emadd
self.doPrint()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doLoadStatic(self):
cmc = self.sql.ctlmst_col
ctm = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])],
limit=1)
for fld in cmc:
dat = ctm[cmc.index(fld)]
if fld in self.form.tptp:
if fld == "ctm_logo":
self.form.letterhead(cmc, ctm, fld, dat)
continue
self.form.tptp[fld][1] = dat
if "letterhead" in self.form.tptp:
self.form.letterhead(cmc, ctm, "letterhead", None)
self.form.document_date(self.sysdtd)
self.form.bank_details(cmc, ctm, 0)
def doProcess(self, bkm):
bmc = self.sql.bkmmst_col
ccc = self.sql.bkmcon_col
btc = self.sql.bkmtrn_col
tdc = self.form.sql.tpldet_col
self.num = bkm[bmc.index("bkm_number")]
self.cod = bkm[bmc.index("bkm_ccode")]
con = self.sql.getRec("bkmcon",
where=[("bkc_cono", "=", self.opts["conum"]),
("bkc_ccode", "=", self.cod)],
limit=1)
eml = con[self.sql.bkmcon_col.index("bkc_email")]
if "contact_details" in self.form.tptp:
dat = "%s %s %s" % (con[ccc.index("bkc_title")],
con[ccc.index("bkc_names")],
con[ccc.index("bkc_sname")])
if bkm[bmc.index("bkm_group")]:
dat = "%s\n%s" % (dat, bkm[bmc.index("bkm_group")][:40])
for fld in ("addr1", "addr2", "addr3", "pcode"):
dat = "%1s\n%s" % (dat, con[ccc.index("bkc_%s" % fld)])
self.form.newdic["contact_details_C00"][tdc.index(
"tpd_text")] = dat
for col in bmc:
d = "%s_C00" % col
if d in self.form.newdic:
dat = bkm[bmc.index(col)]
self.form.newdic[d][tdc.index("tpd_text")] = dat
bkt = self.sql.getRec("bkmtrn",
where=[("bkt_cono", "=", self.opts["conum"]),
("bkt_number", "=", self.num)],
order="bkt_date, bkt_refno")
if not bkt:
return
self.doBody(btc, bkt, tdc)
self.doTotal(tdc)
self.doTail()
if self.repeml[1] == "Y" and not self.emadd:
self.repeml[2] = eml
self.doPrint()
def doPrint(self):
if self.repeml[1] == "Y" and not self.emadd:
key = "%s_%s" % (self.opts["conum"], self.num)
else:
key = "%s_all" % self.opts["conum"]
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
key,
ext="pdf")
self.form.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header="%s Statement at %s" %
(self.opts["conam"], self.sysdtd),
repprt=self.repprt,
fromad=self.fromad,
repeml=self.repeml)
if self.repeml[1] == "Y":
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
def doBody(self, btc, bkt, tdc):
page = 0
count = 0
self.tbal = 0
for trans in bkt:
if not count:
page += 1
count = self.doHeader(page)
if count == self.form.maxlines:
page = self.doCfwd(page)
count = self.doHeader(page)
ldic = {}
for cod in self.form.body:
if cod in ("type_code", "line_paid", "line_balance"):
continue
if cod == "bkt_desc":
des = self.form.doSplitText("bkt_desc_C00",
trans[btc.index(cod)])
if len(des) > 1 and not des[-1]:
del des[-1]
else:
ldic[cod] = CCD(trans[btc.index(cod)],
self.form.tptp[cod][0][1],
self.form.tptp[cod][0][2])
ldic["line_paid"] = 0
ldic["line_balance"] = ldic["bkt_tramt"].work
self.tbal = float(ASD(self.tbal) + ASD(ldic["bkt_tramt"].work))
for n, l in enumerate(des):
if count == self.form.maxlines:
page = self.doCfwd(page)
count = self.doHeader(page)
if n == 0 and len(des) == 1:
include = copyList(self.form.body)
elif n == 0:
include = ("bkt_date", "bkt_refno", "type_code")
elif n + 1 == len(des):
include = copyList(self.form.body)
include.remove("bkt_date")
include.remove("bkt_refno")
include.remove("type_code")
else:
include = []
for code in self.form.body:
seq = "%s_C%02i" % (code, count)
if code == "bkt_desc":
data = l
elif code in include:
if code == "type_code":
data = bktrtp[trans[btc.index("bkt_type")] - 1][0]
else:
data = ldic[code].work
else:
data = "BLANK"
self.form.newdic[seq][tdc.index("tpd_text")] = data
self.form.doDrawDetail(self.form.newdic[seq])
count += 1
for x in range(count, self.form.maxlines):
for cod in self.form.body:
d = "%s_C%02i" % (cod, x)
self.form.newdic[d][tdc.index("tpd_text")] = "BLANK"
self.form.doDrawDetail(self.form.newdic[d])
def doHeader(self, page):
self.form.add_page()
tdc = self.form.sql.tpldet_col
for key in self.form.newkey:
nl = copyList(self.form.newdic[key])
if nl[tdc.index("tpd_place")] != "A":
continue
if nl[tdc.index("tpd_detseq")] == "bkm_number_C00":
nl[tdc.index("tpd_text")] = self.num
elif nl[tdc.index("tpd_detseq")] == "page_number_C00":
nl[tdc.index("tpd_text")] = str(page)
self.form.doDrawDetail(nl)
return 0
def doCfwd(self, page):
if "carried_forward" in self.form.tptp:
tdc = self.form.sql.tpldet_col
line = copyList(self.form.cfwd)
line[tdc.index("tpd_text")] = "Continued on Page %i" % (page + 1)
self.form.doDrawDetail(line)
return page + 1
def doTotal(self, tdc):
for c in self.form.total:
if c != "total_balance":
continue
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
line[tdc.index("tpd_text")] = self.tbal
self.form.doDrawDetail(line)
def doTail(self):
for c in self.form.tail:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[d])
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
