def grandTotal(self):
self.totind = "Y"
self.pageHeading()
tot = [0,0,0,0]
for x, t in enumerate(rttrtp):
qt = CCD(self.gqt[x], "SI", 8)
am = CCD(self.gam[x], "SD", 13.2)
vt = CCD(self.gvt[x], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-39s %s %s %s" % \
(t[1], qt.disp, am.disp, vt.disp))
else:
self.fpdf.drawText("%-26s %s %s %s" % \
(t[1], qt.disp, am.disp, vt.disp))
tot[0] = tot[0] + qt.work
tot[1] = float(ASD(tot[1]) + ASD(am.work))
tot[3] = float(ASD(tot[3]) + ASD(vt.work))
self.fpdf.drawText()
qt = CCD(tot[0], "SI", 8)
am = CCD(tot[1], "SD", 13.2)
vt = CCD(tot[3], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-39s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, vt.disp))
else:
self.fpdf.drawText("%-26s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, vt.disp))
self.fpdf.drawText()
def doGenInt(self, cono, amnt):
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.opts["conum"]),
("cti_inco", "=", cono)],
limit=1)
if not acc:
showError(
self.opts["mf"].body, "Inter Company Error",
"Invalid Account %s for Company %s in %s" %
(acc, cono, self.opts["conum"]))
return "err"
self.doGenTrn(self.opts["conum"], acc[0], amnt)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", cono),
("cti_inco", "=", self.opts["conum"])],
limit=1)
if not acc:
showError(
self.opts["mf"].body, "Inter Company Error",
"Invalid Account %s for Company %s in %s" %
(acc, self.opts["conum"], cono))
return "err"
amnt = float(ASD(0) - ASD(amnt))
self.doGenTrn(cono, acc[0], amnt)
def doTotal(self, tdc):
for c in self.form.total:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
if c == "total_payment":
line[tdc.index("tpd_text")] = self.pay
self.form.doDrawDetail(line)
if self.ptype == "E" and self.bestac:
value = int(round((self.pay * 100), 0))
self.export.write("%1s%4s%06u%-7s%019u%1s%1s%011u%-20s%10s"\
"%-15s%1s\r\n" % (2, self.bestac, self.bibt, self.acno,
int(self.bacc), "", "1", value, self.bname, "",
self.opts["conam"][:15], ""))
self.etotal = float(ASD(self.etotal) + ASD(self.pay))
# Create Payment and Ageing Transaction
p = float(ASD(0) - ASD(self.pay))
self.sql.insRec("crstrn",
data=[
self.opts["conum"], self.acno, 5, self.refno,
self.batno, self.paydtw, "", p, 0.0, 0.0,
self.curdt, 0, "", 0.0, "Electronic Payment",
"", "", self.opts["capnm"], self.sysdtw, 0
])
self.sql.insRec("crsage",
data=[
self.opts["conum"], self.acno, 5, self.refno,
self.curdt, 5, self.refno, p, 0
])
def printBody(self, wlt):
for trn in wlt:
dat = CCD(trn[0], "d1", 10)
bat = CCD(trn[3], "Na", 7)
typ = CCD(trn[1], "UI", 2)
ref = CCD(trn[2], "Na", 9)
per = CCD(trn[4], "UD", 7.2)
amt = CCD(trn[5], "SD", 13.2)
ded = CCD(trn[6], "SD", 13.2)
des = CCD(trn[7], "NA", 30)
if self.fdate and dat.work < self.fdate:
continue
if dat.work > self.ldate:
continue
if self.pglin > self.fpdf.lpp:
self.printHeader()
bal = CCD(self.obal, "SD", 13.2)
if bal.work:
mess = "%-69s%s%-30s" % ("", bal.disp, " Brought Forward")
self.fpdf.drawText(mess)
self.pglin += 1
self.obal = float(ASD(self.obal) + ASD(float(amt.work)))
bal = CCD(self.obal, "SD", 13.2)
mess = "%s %s %s %s %s %s %s %s %s" % \
(dat.disp, sltrtp[typ.work - 1][0], ref.disp, bat.disp,
per.disp, amt.disp, ded.disp, bal.disp, des.disp)
self.fpdf.drawText(mess)
self.pglin += 1
def doTrnMov(self, frt, pag, r, c, p, i, w):
if type(w) == list:
w = w[0] + 1
# Do some tests to see if not new again or already sold etc.
if w == 4 and self.opts["rtn"] != 3:
return "Depreciation Only Allowed with Journal Entries"
if self.opts["rtn"] == 1 and w not in (1, 2):
return "Invalid Choice For Payment"
if self.opts["rtn"] == 2 and w not in (5, ):
return "Invalid Choice For Receipt"
if w == 1 and self.buydt:
return "Asset Already Purchased"
if w in (2, 3, 4, 5) and self.seldt:
return "Asset Already Sold or Written Off"
if w in (2, 3, 4, 5) and not self.buydt:
return "Asset Not Yet Purchased"
self.df.loadEntry(frt, pag, p, data=w)
self.trnmov = w
if self.trnmov == 3:
bal = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)", "sum(ast_amt2)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
self.coyamt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 1, data=self.coyamt)
self.roramt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 2, data=self.roramt)
self.vatcode = ""
self.trnvat = 0
return "sk4"
def 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 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 updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
def printReport(self, recs):
self.pglin = 999
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
self.head = "%03u %-101s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
for seq, dat in enumerate(recs):
p.displayProgress(seq)
if p.quit:
break
self.acno, self.desc, acctot = self.getAccValues(dat)
trn = self.sql.getRec("gentrn", where=[("glt_cono", "=",
dat[0]), ("glt_acno", "=", dat[1]), ("glt_curdt", ">=",
self.sdate.work), ("glt_curdt", "<=", self.edate.work)],
order="glt_acno, glt_curdt, glt_trdt, glt_type, glt_refno, "\
"glt_batch")
if acctot or trn:
if self.pglin == 999 or self.pages == "Y":
self.pageHeading()
else:
self.newAccount()
if acctot:
w1 = CCD(acctot, "SD", 13.2)
self.fpdf.drawText("%-10s %-9s %-3s %-7s %-30s %-13s %-13s "\
"%-13s" % (self.sdate.disp + "-01", "", "", "",
"Opening Balance", "", "", w1.disp))
self.pglin += 1
for acc in trn:
trdt, refno, trtp, batch, amt, dbt, crt, detail, curdt, \
curmth = self.getTrnValues(acc)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
bf = CCD(acctot, "SD", 13.2)
if bf.work:
self.fpdf.drawText(
"%32s %-30s %27s %13s" %
("", "Brought Forward", "", bf.disp))
self.pglin += 1
acctot = float(ASD(acctot) + ASD(amt.work))
w1 = CCD(acctot, "SD", 13.2)
self.fpdf.drawText("%-10s %-9s %-3s %-7s %-30s %13s %13s %13s"\
% (trdt.disp, refno.disp, gltrtp[(trtp.work - 1)][0],
batch.disp, detail.disp, dbt.disp, crt.disp, w1.disp))
self.pglin += 1
if self.pages == "Y" and (acctot or trn):
self.pglin = 999
p.closeProgress()
if p.quit or not self.fpdf.page:
return
if "args" not in self.opts or "noprint" not in self.opts["args"]:
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,
repeml=self.df.repeml)
def updateTables(self):
# Stores Ledger Transaction
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte, 1,
self.grv, self.batno, self.odr, self.qty, self.tcost, 0,
self.curdt, self.desc, 0, "", "", "STR", self.trdis, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
if self.glint == "N":
return
# General Ledger Control Transaction (Stock On Hand)
data = [
self.opts["conum"], self.stk_soh, self.curdt, self.dte, 5,
self.grv, self.batno, self.tcost, 0, self.code, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Stock Suspense)
val = float(ASD(0) - ASD(self.tcost))
data = [
self.opts["conum"], self.stk_susp, self.curdt, self.dte, 5,
self.grv, self.batno, val, 0, self.code, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
def grandTotal(self):
costsd = ""
salesd = ""
proftd = ""
prperd = ""
mchart = ["T", "Grand Totals"]
for x in range(11,-1,-1):
c = CCD(self.ctots[x], "SL", 11)
s = CCD(self.stots[x], "SL", 11)
prf = float(ASD(s.work) - ASD(c.work))
prf = CCD(prf, "SL", 11)
if s.work == 0:
pcn = 0
else:
pcn = round((prf.work * 100.0 / s.work), 2)
pcn = CCD(pcn, "SD", 11.2)
self.ctots[x] = self.ctots[x] + c.work
self.stots[x] = self.stots[x] + s.work
costsd = costsd + c.disp
salesd = salesd + s.disp
proftd = proftd + prf.disp
prperd = prperd + pcn.disp
mchart.append(s.work)
self.mchart.append(mchart)
self.fpdf.drawText("%-3s %-6s %30s %s" % ("", "Totals", "Sales ",
salesd))
self.fpdf.drawText("%-34s %s %s" % ("", "Costs ", costsd))
self.fpdf.drawText("%-34s %s %s" % ("", "Profit", proftd))
self.fpdf.drawText("%-34s %s %s" % ("", "Prf-% ", prperd))
self.fpdf.underLine(txt=self.head)
self.fpdf.drawText()
def doDisPer(self, frt, pag, r, c, p, i, w):
self.trdis = w
udis = round((self.ucost * self.trdis / 100), 2)
tdis = round((self.tcost * self.trdis / 100), 2)
self.ucost = float(ASD(self.ucost) - ASD(udis))
self.tcost = float(ASD(self.tcost) - ASD(tdis))
self.df.loadEntry(frt, pag, p + 1, data=self.tcost)
def updateTables2(self):
val = float(ASD(0) - ASD(self.allamt))
# General Ledger Transaction (Allocation)
data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, val, 0.00, self.alldet, "", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany)
if self.allcoy != self.opts["conum"]:
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.opts["conum"]),
("cti_inco", "=", self.allcoy)],
limit=1)[0]
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, val, 0.00, self.alldet, "N", "",
0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.allcoy),
("cti_inco", "=", self.opts["conum"])
],
limit=1)[0]
val = float(ASD(0) - ASD(val))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, val, 0.00, self.alldet, "N", "",
0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
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 = [self.head + " %s" % self.sysdttm]
self.expheads.append("Loans's Ledger Audit Trail for Period "\
"%s to %s" % (self.sdatd, self.edatd))
self.expcolsh = [self.colsh]
self.expforms = self.forms
self.expdatas = []
self.gdrs = 0
self.gcrs = 0
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
p.closeProgress()
return
vals = self.getValues(dat)
if not vals:
continue
acno, loan, batch, trtp, trdt, ref, drs, crs, desc = vals
line = ["BODY", [trtp.work, batch.work, acno.work, loan.work,
ref.work, trdt.work, desc.work, drs.work, crs.work]]
self.expdatas.append(line)
self.gdrs = float(ASD(self.gdrs) + ASD(drs.work))
self.gcrs = float(ASD(self.gcrs) + ASD(crs.work))
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 endLon(self):
if self.opts["rtn"] == 4:
tramt = float(ASD(0.0) - ASD(self.lonamt))
else:
tramt = self.lonamt
self.othtot = float(ASD(self.othtot) - ASD(self.lonamt))
if self.newlon:
# Loans Rate
self.sql.insRec("lonrte",
data=[
self.allcoy, self.lonacc, self.lonnum,
self.trndat, self.newdri, self.newcri
])
# Loans Ledger Masterfile
self.sql.insRec("lonmf2",
data=[
self.allcoy, self.lonacc, self.lonnum,
self.londes, self.trndat, self.lonmth,
self.lonpay, 0
])
self.othrtn = 2
else:
self.othrtn = 3
# Loans Ledger Transaction
data = [
self.allcoy, self.lonacc, self.lonnum, self.bh.batno, self.othrtn,
self.trndat, self.trnref, tramt, self.curdt, self.alldet, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("lontrn", data=data)
if self.othtot:
self.df.loadEntry("T", self.lonpag, 0, data=self.othtot)
self.df.advanceLine(self.lonpag)
else:
self.othvar.set(False)
def getAccValues(self, data):
dic = self.sql.genmst_dic
acno = CCD(data[dic["glm_acno"][1]], "UI", 7)
desc = CCD(str(data[dic["glm_desc"][1]]), "NA", 30)
o = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", acno.work),
("glo_trdt", "=", self.opts["period"][1][0])
],
limit=1)
if o:
b = CCD(o[0], "SD", 13.2)
else:
b = CCD(0, "SD", 13.2)
ob = b.work
o = self.sql.getRec("gentrn",
cols=["round(sum(glt_tramt), 2)"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", acno.work),
("glt_curdt", ">=", self.s_per),
("glt_curdt", "<", self.sdate.work)],
limit=1)
if o and o[0]:
b = CCD(o[0], "SD", 13.2)
else:
b = CCD(0, "SD", 13.2)
acctot = float(ASD(ob) + ASD(b.work))
return (acno, desc, acctot)
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 doEarningCode(self, trtp, trn):
if not trtp:
self.fpdf.setFont(style="B")
self.fpdf.drawText("Income Sources")
self.fpdf.drawText("Code Description "\
" R/F-Ind Amount")
self.fpdf.setFont()
# Earning Codes 3601-3617, 3651-3667, 3701-3718, 3751-3768
# 3801-3816, 3851-3866, 3901-3922, 3951-3957
trtp = "E"
if trn[1] == 3601:
rfund = self.rfund
else:
rfund = "N"
if trn[1] == 3810:
trn[4] = round((trn[4] / 3), 2)
self.fpdf.drawText("%-4s %-50s %1s %9s" % \
(trn[1], trn[3], rfund, int(trn[4])))
self.emprec = '%s,%04i,%015i' % (self.emprec, trn[1], int(trn[4]))
self.totcode += trn[1]
if trn[1] in (3602, 3604, 3609, 3612, 3703, 3705, 3709, 3714):
# Non Taxable Income
self.totntax = self.totntax + int(trn[4])
else:
if trn[2] == "O":
# Annual Payment
self.totannp = self.totannp + int(trn[4])
if rfund == "Y":
# Retirement Funding
self.totyrfi = self.totyrfi + int(trn[4])
else:
self.totnrfi = self.totnrfi + int(trn[4])
self.totincm = self.totincm + int(trn[4])
self.totamnt = float(ASD(self.totamnt) + ASD(int(trn[4])))
return trtp
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 doDate(self, frt, pag, r, c, p, i, w):
self.date = w
rec = self.sql.getRec("cshana",
where=[("can_cono", "=", self.opts["conum"]),
("can_type", "=", "P"),
("can_date", "=", self.date)])
if rec and self.trtp == "P":
self.amend = True
for rr in rec:
self.etotal = float(ASD(self.etotal) + ASD(rr[7]))
self.df.loadEntry(frt, pag, p + 1, data=self.etotal)
rec = self.sql.getRec("cshana",
where=[("can_cono", "=", self.opts["conum"]),
("can_type", "=", "T"),
("can_date", "=", self.date)])
if rec and self.trtp == "T":
self.amend = True
for rr in rec:
self.itotal = float(ASD(self.itotal) + ASD(rr[7]))
self.df.loadEntry(frt, pag, p + 2, data=self.itotal)
self.rec = self.sql.getRec("cshcnt",
where=[("cct_cono", "=",
self.opts["conum"]),
("cct_type", "=", "T"),
("cct_date", "=", self.date)],
limit=1)
if self.rec and self.trtp == "C":
self.amend = True
if self.amend:
return "nc"
def printTrans(self):
whr = [
("wlt_cono", "=", self.opts["conum"]),
("wlt_empno", "=", self.empno),
("wlt_loan", "=", self.loan)]
odr = "wlt_trdt, wlt_type"
if self.history == "N":
whr.append(("wlt_curdt", ">=", int(self.opts["period"] / 100)))
recs = self.sql.getRec("wagltf", where=whr, order=odr)
for rec in recs:
trd = CCD(rec[self.sql.wagltf_col.index("wlt_trdt")], "D1", 10)
typ = CCD(rec[self.sql.wagltf_col.index("wlt_type")], "UI", 1)
ref = CCD(rec[self.sql.wagltf_col.index("wlt_ref")], "Na", 9)
bat = CCD(rec[self.sql.wagltf_col.index("wlt_batch")], "Na", 7)
rte = CCD(rec[self.sql.wagltf_col.index("wlt_per")], "UD", 6.2)
amt = CCD(rec[self.sql.wagltf_col.index("wlt_amt")], "SD", 13.2)
ded = CCD(rec[self.sql.wagltf_col.index("wlt_ded")], "SD", 13.2)
det = CCD(rec[self.sql.wagltf_col.index("wlt_desc")], "NA", 30)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.pageHeadingTrans()
self.acctot = float(ASD(self.acctot) + ASD(amt.work))
self.fpdf.drawText("%s %s %s %s %s %s %s %s" % (trd.disp,
sltrtp[(typ.work - 1)][0], ref.disp, bat.disp,
rte.disp, amt.disp, ded.disp, det.disp))
self.pglin += 1
self.fpdf.underLine(txt=self.head)
b = CCD(self.acctot, "SD", 13.2)
self.fpdf.drawText("%-39s %13s %13s %-30s" % \
("", b.disp, "", "Closing Balance"))
def doEditPage3(self):
titl = "Denominations"
data = []
for num, rec in enumerate(self.df.c_work[3]):
data.append([self.denoms[num][0], rec[0], rec[1]])
lin = {
"stype": "C",
"deco": True,
"titl": titl,
"head": ("Denom", "Qty", "Value"),
"typs": (("NA", 4), ("UI", 5), ("SD", 13.2)),
"data": data,
"retn": "I"
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select a Denomination to Edit")
chg = self.df.selChoice(lin)
self.df.enableButtonsTags(state=state)
if chg and chg.selection:
self.edit = self.df.col
qty, val = self.df.c_work[3][chg.selection[0]]
self.ctotal = float(ASD(self.ctotal) - ASD(val))
self.df.focusField("C", 3, (chg.selection[0] * 2) + 1)
else:
self.edit = None
self.df.focusField("C", 3, self.df.col)
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
self.head = "%03u %-77s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.btot = [0, 0]
self.pglin = 999
bc = self.sql.ctlbat_col
tc = self.sql.wagltf_col
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
self.rtyp = CCD(dat[bc.index("btm_rtyp")], "UI", 1)
self.batno = CCD(dat[bc.index("btm_batno")], "Na", 7)
self.curdt = CCD(dat[bc.index("btm_curdt")], "D2", 7)
self.multi = CCD(dat[bc.index("btm_multi")], "UA", 1)
self.trno = CCD(dat[bc.index("btm_trno")], "UI", 7)
self.trval = CCD(dat[bc.index("btm_trval")], "SD", 13.2)
whr = [
("wlt_cono", "=", self.opts["conum"]),
("wlt_type", "=", self.rtyp.work),
("wlt_batch", "=", self.batno.work),
("wlt_batind", "=", "N")]
odr = "wlt_seq"
trndat = self.sql.getRec("wagltf", where=whr, order=odr)
if not trndat:
continue
if self.pglin > self.fpdf.lpp:
self.pageHeading()
else:
self.batchHeading()
for trn in trndat:
empno = CCD(trn[tc.index("wlt_empno")], "UI", 5)
loan = CCD(trn[tc.index("wlt_loan")], "UI", 2)
trdt = CCD(trn[tc.index("wlt_trdt")], "D1", 10)
ref = CCD(trn[tc.index("wlt_ref")], "Na", 9)
amt = CCD(trn[tc.index("wlt_amt")], "SD", 13.2)
ded = CCD(trn[tc.index("wlt_ded")], "SD", 13.2)
per = CCD(trn[tc.index("wlt_per")], "UD", 6.2)
desc = CCD(trn[tc.index("wlt_desc")], "NA", 15)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.fpdf.drawText("%s %s %s %s %s %s %s %s" %
(empno.disp, loan.disp, trdt.disp, ref.disp,
per.disp, amt.disp, ded.disp, desc.disp))
self.btot[0] = self.btot[0] + 1
self.btot[1] = float(ASD(self.btot[1]) + ASD(amt.work))
self.pglin += 1
self.batchTotal()
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)
else:
showError(self.opts["mf"].body, "Batch Errors",
"No Batch Transactions")
def doBody(self, rtc, rtt, tdc):
text = self.form.sql.tpldet_col.index("tpd_text")
count = 0
bal = 0
for trans in rtt:
for cod in self.form.body:
if cod == "type_code":
c = "rtt_type"
else:
c = cod
d = "%s_C%02i" % (cod, count)
if cod == "type_code":
ttyp = trans[rtc.index(c)]
self.form.newdic[d][text] = rttrtp[ttyp - 1][0]
elif cod in ("line_debit", "line_credit"):
tramt = trans[rtc.index(c)]
bal = float(ASD(bal) + ASD(tramt))
self.form.newdic[d][text] = trans[rtc.index(c)]
elif c == "line_balance":
self.form.newdic[d][text] = bal
else:
self.form.newdic[d][text] = trans[rtc.index(c)]
self.form.doDrawDetail(self.form.newdic[d])
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 doGenTrn(self, cono, acno, amnt, edes=None):
if not edes:
edes = "Salaries and Wages"
batno = CCD("%03i%04i" % (self.opts["conum"], (self.curdt % 10000)),
"Na", 7)
refno = CCD(1, "Na", 9)
whr = [("glt_cono", "=", cono), ("glt_acno", "=", acno),
("glt_curdt", "=", self.curdt), ("glt_trdt", "=", self.rundt),
("glt_type", "=", 4), ("glt_refno", "=", refno.work),
("glt_batch", "=", batno.work), ("glt_desc", "=", edes)]
trn = self.sql.getRec("gentrn",
cols=["glt_seq", "glt_tramt"],
where=whr,
limit=1)
if not trn:
data = [
cono, acno, self.curdt, self.rundt, 4, refno.work, batno.work,
amnt, 0.00, edes, "", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
else:
newamt = float(ASD(trn[1]) + ASD(amnt))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[newamt],
where=[("glt_seq", "=", int(trn[0]))])
def endSln(self):
if self.opts["rtn"] == 4:
tramt = float(ASD(0.0) - ASD(self.slnamt))
else:
tramt = self.slnamt
self.othtot = float(ASD(self.othtot) - ASD(self.slnamt))
if self.newsln:
# Staff Loans Ledger Masterfile
self.sql.insRec("waglmf",
data=[
self.allcoy, self.empnum, self.slnnum,
self.slndes, self.slncod, self.newrte,
self.trndat, self.slnded
])
self.othrtn = 2
else:
self.othrtn = 3
# Staff Loans Ledger Transaction
data = [
self.allcoy, self.empnum, self.slnnum, self.bh.batno, self.othrtn,
self.trndat, self.trnref, tramt, tramt, self.slnded, self.newrte,
self.curdt, self.alldet, "", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("wagltf", data=data)
if self.othtot:
self.df.loadEntry("T", self.slnpag, 0, data=self.othtot)
self.df.advanceLine(self.slnpag)
else:
self.othvar.set(False)
def getValues(self, data):
grp = CCD(data[0], "UA", 3)
self.groupd = grp.disp
code = CCD(data[1], "NA", 20)
desc = CCD(data[2], "NA", 30)
uoi = CCD(data[3], "NA", 10)
whr = [("stt_cono", "=", self.opts["conum"]),
("stt_group", "=", grp.work), ("stt_code", "=", code.work)]
if self.loc:
whr.append(("stt_loc", "=", self.loc))
whr.append(("stt_curdt", "<=", self.curdt))
bal = self.sql.getRec(
"strtrn",
cols=["round(sum(stt_qty), 2)", "round(sum(stt_cost), 2)"],
where=whr,
limit=1)
if not bal[0]:
bal[0] = 0
if not bal[1]:
bal[1] = 0
qbal = CCD(bal[0], "SD", 12.2)
vbal = CCD(bal[1], "SD", 12.2)
if self.zero == "Y" and qbal.work == 0 and vbal.work == 0:
return
self.gtot = float(ASD(self.gtot) + ASD(vbal.work))
return (grp, code, desc, uoi, qbal, vbal)
def endPage2(self):
self.updateTables2()
if self.loan and self.loan == "other":
self.othtot = self.allamt
self.df.selPage("LON")
self.df.loadEntry("T", self.lonpag, 0, data=self.othtot)
self.df.focusField("C", self.lonpag, 1)
self.othvar.set(True)
self.df.mstFrame.wait_variable(self.othvar)
if self.cancel:
return
elif self.loan and self.loan == "staff":
self.othtot = self.allamt
self.df.selPage("SLN")
self.df.loadEntry("T", self.slnpag, 0, data=self.othtot)
self.df.focusField("C", self.slnpag, 1)
self.othvar.set(True)
self.df.mstFrame.wait_variable(self.othvar)
if self.cancel:
return
self.allocated = float(ASD(self.allocated) + ASD(self.allamt) + \
ASD(self.allvat))
if self.allocated == self.trnamt:
self.doCrsTrn()
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 doPoints(self, frt, pag, r, c, p, i, w):
if w and w % 1 not in (0.0, 0.5):
return "Invalid Decimal in Points"
if w > self.maxpts:
return "Invalid Points, Exceed Maximum"
if i == 3:
self.p_for = w
self.df.loadEntry(frt, pag, p + 1, data=self.opp)
chk = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.opp)], limit=1)
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 2, data=name)
if self.ponly == "Y":
self.s_for = w
return "sk3"
else:
return "sk2"
if not w:
self.p_agt = float(ASD(self.mpts) - ASD(self.p_for))
self.df.loadEntry(frt, pag, p, data=self.p_agt)
else:
self.p_agt = w
if self.ponly == "Y":
self.s_agt = self.p_agt
tot = float(ASD(self.p_for) + ASD(self.p_agt))
if tot != self.mpts:
return "Invalid Total Points (%s s/b %s)" % (tot, self.mpts)
def grandTotal(self):
self.totind = "Y"
self.pageHeading()
tot = [0, 0, 0, 0]
for x, t in enumerate(sltrtp):
qt = CCD(self.gqt[x], "SI", 8)
am = CCD(self.gam[x], "SD", 13.2)
dd = CCD(self.gdd[x], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-44s %s %s %s" % \
(t[1], qt.disp, am.disp, dd.disp))
else:
self.fpdf.drawText("%-30s %s %s %s" % \
(t[1], qt.disp, am.disp, dd.disp))
tot[0] = tot[0] + qt.work
tot[1] = float(ASD(tot[1]) + ASD(am.work))
tot[2] = float(ASD(tot[2]) + ASD(dd.work))
self.fpdf.drawText()
qt = CCD(tot[0], "SI", 8)
am = CCD(tot[1], "SD", 13.2)
dd = CCD(tot[2], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-44s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, dd.disp))
else:
self.fpdf.drawText("%-30s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, dd.disp))
self.fpdf.drawText()
