class sl2020(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", "wagmst", "waglmf", "wagltf"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.col = self.sql.waglmf_col
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.glint = wagctl["ctw_glint"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["wag_slc", "wag_sli"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.glctls = (ctlctl["wag_slc"], ctlctl["wag_sli"])
else:
self.glctls = None
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"SLN",
5,
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
def dataHeader(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"),
("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0,
"Names")),
"where": [("wgm_cono", "=", self.opts["conum"])]
}
lnm = {
"stype":
"R",
"tables": ("waglmf", ),
"cols": (("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0,
"Description", "Y")),
"where": [("wlm_cono", "=", self.opts["conum"])],
"whera": (("C", "wlm_empno", 0), ),
"index":
0
}
typ = {
"stype":
"C",
"titl":
"Transaction Types",
"head": ("C", "Description"),
"data": ((1, "Interest Adjustment"), (3, "Further Advance"),
(4, "Loan Repayment"), (5, "Loan Adjustment")),
"index":
0
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUI", 5, "EmpNo", "Employee Number", "", "N",
self.doEmp, wgm, None, None),
(("C", 1, 0, 1), "ONA", 10, "Name"),
(("C", 1, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N",
self.doLoan, lnm, None, ("notzero", )),
(("C", 1, 0, 3), "ONA", 10, "Descript", "Description", "", "N",
None, None, None, None),
(("C", 1, 0, 4), "ID1", 10, "Trans-Date", "Transaction Date",
self.sysdtw, "N", self.doTrdate, None, None, None),
(("C", 1, 0, 5), "IUI", 1, "T", "Transaction Type", "", "N",
self.doTyp, typ, None, ("in", (1, 3, 4, 5))),
(("C", 1, 0, 6), "INa", 9, "Reference", "Reference Number", "i",
"N", self.doRef, None, None, ("notblank", )),
(("C", 1, 0, 7), "IUD", 6.2, "Intr-%", "New Interest Rate", "",
"N", self.doPer, None, None, None),
(("C", 1, 0, 8), "ISD", 13.2, "Interest",
"Interest (Adds to interest raised)", "", "Y", self.doInt,
None, None, ("notzero", )),
(("C", 1, 0, 9), "ISD", 13.2, "Amount",
"Amount (Adds to advances or payments)", "", "Y", self.doPay,
None, None, ("notzero", )),
(("C", 1, 0, 10), "IUD", 9.2, "Deduct",
"Deduction Amount (New total deduction)", "", "Y", self.doDed,
None, None, ("efld", ))]
if self.glint == "Y":
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = [("Interrogate", None, self.querySln, 0, ("C", 1, 1), ("C", 1,
2))]
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.glint == "Y":
but.append(
("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1)))
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 doEmp(self, frt, pag, r, c, p, i, w):
self.empno = w
acc = self.sql.getRec("wagmst",
cols=["wgm_sname"],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
chk = self.sql.getRec("waglmf",
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)])
if len(chk) == 1:
self.acc = chk[0]
self.loan = self.acc[self.col.index("wlm_loan")]
desc = self.acc[self.col.index("wlm_desc")]
self.df.loadEntry("C", pag, p + 2, data=self.loan)
self.df.loadEntry("C", pag, p + 3, data=desc)
return "sk3"
def doLoan(self, frt, pag, r, c, p, i, w):
self.loan = w
self.acc = self.sql.getRec("waglmf",
where=[("wlm_cono", "=",
self.opts["conum"]),
("wlm_empno", "=", self.empno),
("wlm_loan", "=", self.loan)],
limit=1)
if not self.acc:
return "Invalid Loan Number"
desc = self.acc[self.col.index("wlm_desc")]
self.df.loadEntry("C", pag, p + 1, data=desc)
def doTrdate(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.trdate = w
def doTyp(self, frt, pag, r, c, p, i, w):
self.typ = w
def doRef(self, frt, pag, r, c, p, i, w):
self.ref = w
per = self.acc[self.col.index("wlm_rate")]
self.df.loadEntry("C", pag, p + 1, data=per)
def doPer(self, frt, pag, r, c, p, i, w):
self.per = w
if self.typ in (3, 4, 5):
self.intp = 0
return "sk1"
def doInt(self, frt, pag, r, c, p, i, w):
self.intp = w
self.pay = 0
self.ded = 0
return "sk2"
def doPay(self, frt, pag, r, c, p, i, w):
self.pay = w
amt = self.acc[self.col.index("wlm_repay")]
self.df.loadEntry("C", pag, p + 1, data=amt)
def doDed(self, frt, pag, r, c, p, i, w):
self.ded = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if not self.val:
self.df.advanceLine(1)
elif self.typ == 1 or self.glint == "N":
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.val)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trdate / 100)
else:
self.curdt = self.bh.curdt
if self.typ == 1:
self.glt = 4
desc = "Interest Adj"
self.val = self.intp
ded = self.acc[self.col.index("wlm_repay")]
cap = 0.00
elif self.typ == 3:
self.glt = 2
desc = "Advance"
self.val = self.pay
ded = self.ded
cap = self.val
elif self.typ == 4:
self.glt = 6
desc = "Repayment"
self.val = float(ASD(0) - ASD(self.pay))
ded = self.ded
cap = 0.00
elif self.typ == 5:
self.glt = 4
desc = "Adjustment"
self.val = self.pay
ded = self.ded
cap = 0.00
self.sql.updRec("waglmf",
cols=["wlm_rate", "wlm_repay"],
data=[self.per, ded],
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno),
("wlm_loan", "=", self.loan)])
self.sql.insRec("wagltf",
data=[
self.opts["conum"], self.empno, self.loan,
self.bh.batno, self.typ, self.trdate, self.ref,
self.val, cap, ded, self.per, self.curdt, desc,
"N", self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Staff Loans Control Account
data = (self.opts["conum"], self.glctls[0], self.curdt, self.trdate,
self.glt, self.ref, self.bh.batno, self.val, 0.00, self.name,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
self.val = float(ASD(0) - ASD(self.val))
if self.typ == 1:
# General Ledger Interest Received
data = (self.opts["conum"], self.glctls[1], self.curdt,
self.trdate, self.glt, self.ref, self.bh.batno, self.val,
0.00, "Staff Loan - %s" % self.name, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def 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.val) - 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.val:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.val) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
# General Ledger Transaction (Source)
data = (self.opts["conum"], self.genacc, self.curdt, self.trdate,
self.glt, self.ref, 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.val))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.val))
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 ml2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] not in (1, 2, 3, 4):
showError(self.opts["mf"].body, "Control Error",
"Invalid Routine %s, Only 1-4 Are Allowed" % \
str(self.opts["rtn"]))
return
tabs = ["ctlvmf", "ctlvrf", "ctlvtf", "memmst", "memtrn"]
self.gc = GetCtl(self.opts["mf"])
memctl = self.gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.dis_all = ctlctl["dis_all"]
tabs.extend(["gentrn", "genmst"])
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"MEM",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.opts["rtn"] == 1:
self.glt = 1
elif self.opts["rtn"] == 2:
self.glt = 2
elif self.opts["rtn"] == 3:
self.glt = 4
elif self.opts["rtn"] == 4:
self.glt = 1
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def drawDialog(self):
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names",
"sort":
False
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N",
self.doMemAcc, mlm, None, ("notzero", )),
[("C", 1, 0, 1), "ONA", 10, "Name"],
(("C", 1, 0, 2), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doRefno, None, None, ("notblank", )),
(("C", 1, 0, 3), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 4), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("efld", ))]
if self.opts["rtn"] == 2:
fld[3][2] = 20
fld.extend([
(("C", 1, 0, 5), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, None, None,
"Discount Amount to be Added to the Transaction Amount."),
(("C", 1, 0, 6), "OSD", 13.2, "Total-Amount"),
(("C", 1, 0,
7), "INA", (20, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)
])
elif self.glint == "Y":
fld[3][2] = 24
fld.extend([
(("C", 1, 0, 5), "INA", 30, "Details", "Transaction Details",
"", "N", self.doTrnDet, None, None, None),
(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "",
"N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 19, "Description"),
(("C", 2, 0, 2), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode2, vtm, None, ("notblank", )),
(("C", 2, 0, 3), "ISD", 13.2, "All-Amt", "Allocation Amount",
"", "N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 4), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doAllVat, None, None, None),
(("C", 2, 0, 5), "INA", (26, 30), "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))
])
else:
fld[3][2] = 22
fld.extend([
(("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode1, vtm, None, ("notblank", )),
(("C", 1, 0, 7), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
(("C", 1, 0,
8), "INA", (20, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)
])
but = (
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",1),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",1),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",1),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",1),
("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] != 2 and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doMemAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memmst",
cols=["mlm_title", "mlm_initial", "mlm_surname"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", w)],
limit=1)
if not acc:
return "Invalid Member Number"
self.memno = w
self.name = "%s, %s %s" % (acc[2], acc[0], acc[1])
self.df.loadEntry("C", pag, p + 1, data=self.name)
def doRefno(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memtrn",
cols=["mlt_batch"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", w)],
limit=1)
if acc:
return "Transaction Already Exists"
self.refno = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if w > mthendDate(self.bh.curdt * 100):
return "Invalid Date, After Batch Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.glint == "Y" or self.opts["rtn"] == 2:
self.vatcode = "N"
self.vatamt = 0
def doVatCode1(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, self.vatamt)
if not self.vatamt:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.vatamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.vatamt = float(ASD(0) - ASD(w))
else:
self.vatamt = w
self.df.loadEntry(frt, pag, p, data=self.vatamt)
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.disamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.disamt = float(ASD(0) - ASD(w))
else:
self.disamt = w
self.df.loadEntry(frt, pag, p, data=self.disamt)
totamt = float(ASD(self.trnamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] != 2 and self.glint == "Y":
self.df.colf[2][5][5] = w
self.allocated = float(0.00)
def endPage1(self):
self.cancel = False
self.agecan = False
self.batupd = False
self.updateTables1()
if self.cancel:
return
else:
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] == 2 or self.glint == "N":
self.doMemTrn()
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.vatamt
if self.opts["rtn"] == 1: # Invoices
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 2: # Payment
if self.trnamt == 0:
recon = self.curdt
else:
recon = 0
self.vat = 0.00
self.dis = self.disamt
elif self.opts["rtn"] == 3: # Journal
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 4: # Credit Note
recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.dis = 0.00
if self.opts["rtn"] == 1:
self.ageloop = False
self.doAgeCurrent()
else:
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
if self.glint == "N":
return
# General Ledger Control Transaction (Members)
val = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.memctl, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, val, 0.00, self.trndet,
"N", "", recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Bank)
if self.opts["rtn"] == 2:
val = float(ASD(0) - ASD(self.amt))
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, val, 0.00,
self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.dis:
val = float(ASD(0) - ASD(self.dis))
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.refno, self.bh.batno, val,
0.00, self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="mem",
agetyp=atype,
agekey=[
self.opts["conum"], self.memno, self.opts["rtn"],
self.refno, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
if self.agevar.get():
self.agevar.set(False)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
if not chk[2]:
self.taxgl = self.taxdf
else:
self.taxgl = chk[2]
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
self.df.loadEntry("C", pag, p + 2, data=self.taxgl)
def doVatCode2(self, frt, pag, r, c, p, i, w):
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"], error=False)
if not ctlctl:
return "Missing ctlctl Record for Company"
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return "Missing or Invalid Control Record"
self.convat = ctlctl["vat_ctl"]
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if self.vatrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.allamt = round((allamt * 100 / (100 + self.vatrte)), 2)
self.df.loadEntry(frt, pag, p, data=self.allamt)
self.allvat = float(ASD(allamt) - ASD(self.allamt))
else:
self.allamt = w
self.allvat = round((self.allamt * self.vatrte / 100), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p + 2, data=self.name)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
self.allvat = float(ASD(0) - ASD(w))
elif self.allamt > 0 and w < 0:
self.allvat = float(ASD(0) - ASD(w))
else:
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.cancel = True
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
if self.glint == "Y":
self.df.clearFrame("C", 2)
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.selPage("Transaction")
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + \
ASD(self.allamt) + ASD(self.allvat))
if self.allocated == self.trnamt:
self.doMemTrn()
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1: # Invoices
self.credit()
elif self.opts["rtn"] == 3: # Journal Entry
self.credit()
elif self.opts["rtn"] == 4: # Credit Notes
self.debit()
def debit(self):
amt = self.allamt
vat = self.allvat
self.restDebitCredit(amt, vat)
def credit(self):
amt = float(ASD(0) - ASD(self.allamt))
vat = float(ASD(0) - ASD(self.allvat))
self.restDebitCredit(amt, vat)
def restDebitCredit(self, amt, vat):
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "O", self.curdt, "M",
self.glt, self.bh.batno, self.refno, self.trndat, self.memno,
self.alldet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Transaction (Expense)
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, amt, vat, self.alldet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if vat:
# General Ledger Control Transaction (V.A.T.)
data = (self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, vat, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
vat = float(ASD(0) - ASD(vat))
self.vat += vat
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def doMemTrn(self):
# Members Ledger Transaction
data = [
self.opts["conum"], self.memno, self.opts["rtn"], self.refno,
self.bh.batno, self.trndat, self.amt, self.vat, self.curdt, "", 0,
self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data)
if self.dis:
data = [
self.opts["conum"], self.memno, 6, self.refno, self.bh.batno,
self.trndat, self.dis, self.vat, self.curdt, "", 0,
self.trndet, self.vatcode, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data, unique="mlt_refno")
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
class gl1050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for control record and departments
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
# Check for multiple companies
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genrpc", "genstr",
"gendtm", "genrpt"], prog=self.__class__.__name__)
if self.sql.error:
return
acc = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if acc[0] > 1:
self.coys = True
else:
self.coys = False
self.strm = 0
return True
def doProcess(self):
st1 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_strm", "", 0, "Str"),
("gls_desc", "", 0, "Description", "Y")),
"where": [("gls_cono", "=", self.opts["conum"])],
"group": "gls_strm, gls_desc"}
st2 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_seq", "", 0, "Seq"),
("gls_typ", "", 0, "T"),
("gls_cno", "", 0, "CN"),
("gls_con", "", 0, "C"),
("gls_rep", "", 0, "Rep"),
("gls_gen", "", 0, "G"),
("gls_val", "", 0, "V"),
("gls_det", "", 0, "Det"),
("gls_var", "", 0, "B"),
("gls_zer", "", 0, "Z"),
("gls_opt", "", 0, "O"),
("gls_num", "", 0, "N"),
("gls_prnt", "", 20, "Printer-Name"),
("gls_mail", "", 20, "E-Mail-Address")),
"where": [("gls_cono", "=", self.opts["conum"])],
"whera": (("T", "gls_strm", 0, 0),),
"comnd": self.doSelTyp}
typ = {
"stype": "C",
"title": "Available Types",
"head": ("C", "Description"),
"data": (
("S", "YTD Report"),
("H", "Last 3 Years YTD Report"),
("L", "MTD and YTD Report"),
("M", "Monthly Report"),
("C", "Customised Report"))}
rpc = {
"stype": "R",
"tables": ("genrpc",),
"cols": (
("glc_cusno", "", 0, "CN"),
("glc_head1", "", 0, "Heading-1"),
("glc_head2", "", 0, "Heading-2"),
("glc_head3", "", 0, "Heading-3"),
("glc_head4", "", 0, "Heading-4")),
"where": [("glc_cono", "=", self.opts["conum"])]}
rpt = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_seq", "=", 0)],
"group": "glr_cono, glr_repno, glr_type, glr_desc",
"index": 1}
con = {
"stype": "C",
"title": "Available Options",
"head": ("C", "Description"),
"data": (
("V", "Actuals"),
("B", "Budgets"),
("C", "Actuals and Budgets"),
("X", "Variance to Budget"),
("D", "Detail"))}
det = {
"stype": "R",
"tables": ("gendtm",),
"cols": (
("gdm_code", "", 0, "Cod"),
("gdm_desc", "", 0, "Description")),
"where": [("gdm_cono", "=", self.opts["conum"])]}
prts = getPrinters(wrkdir=self.opts["mf"].rcdic["wrkdir"])
prts.insert(1, "Export")
if "None" not in prts:
prts.append("None")
prt = {
"stype": "C",
"titl": "Select Required Printer",
"head": ("Name", "Description"),
"data": prts}
cts = ("V", "B", "C", "X", "D")
fld = (
(("T",0,0,0),"IUI",3,"Stream-Number","Stream Number",
0,"Y",self.doStr,st1,None,("notzero",)),
(("T",0,0,0),"INA",30,"Description","",
"","N",self.doDsc,None,self.doDelStr,("notblank",)),
(("C",0,0,0),"IUI",3,"Seq","Sequence Number",
"i","N",self.doSeq,st2,None,("efld",)),
(("C",0,0,1),"IUA",1,"T","Report Type",
"S","N",self.doTyp,typ,self.doDelLin,
("in",("S","H","L","M","C"))),
(("C",0,0,2),"IUI",2,"CN","Custom Number",
0,"N",self.doCus,rpc,None,("efld",)),
(("C",0,0,3),"IUA",1,"C","Consolidate (Y/N)",
"N","N",self.doCon,None,None,("in",("Y","N"))),
(("C",0,0,4),"IUI",3,"Rep","Report Number",
0,"N",self.doRep,rpt,None,("notzero",)),
(("C",0,0,5),"IUA",1,"G","General Report (Y/N)",
"N","N",self.doGen,None,None,("in",("Y","N"))),
(("C",0,0,6),"IUA",1,"V","Report Contents",
"V","N",self.doContent,con,None,("in",cts)),
(("C",0,0,7),"INa",2,"Cod","Details Code",
"","N",self.doCod,det,None,None),
(("C",0,0,8),"IUA",1,"V","Variance (B/P/N)",
"B","N",self.doVar,None,None,("in",("B","P","N"))),
(("C",0,0,9),"IUA",1,"Z","Ignore Zeros (Y/N)",
"Y","N",None,None,None,("in",("Y","N"))),
(("C",0,0,10),"IUA",1,"O","Print Options (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,11),"IUA",1,"N","Print Numbers (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,12),"ITX",30,"Printer Name","Printer-Name",
"Default","N",self.doPrt,prt,None,("in",prts)),
(("C",0,0,13),"ITX",30,"E-Mail Address","E-Mail-Address",
"","N",None,None,None,("email",)))
but = (
("Cancel",None,self.doCancel,0,("C",0,1),("T",0,1)),
("Quit",None,self.exitTops,1,None,None))
self.df = TartanDialog(self.opts["mf"], eflds=fld,
tend=((self.endTops,"n"),), txit=(self.exitTops,),
cend=((self.endData,"y"),), cxit=(self.exitData,), butt=but)
self.df.focusField("T", 0, 1)
def doStr(self, frt, pag, r, c, p, i, w):
self.strm = w
self.old = self.sql.getRec("genstr", where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm)], limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
self.desc = self.old[self.sql.genstr_col.index("gls_desc")]
self.df.loadEntry(frt, pag, p+1, self.desc)
def doDelStr(self):
if self.new == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
def doDsc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
dt = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm), ("gls_seq", "=",
self.seq)], limit=1)
if not dt:
self.newlin = "y"
else:
self.newlin = "n"
for n, d in enumerate(dt[3:-1]):
self.df.loadEntry(frt, pag, p+n, data=d)
def doTyp(self, frt, pag, r, c, p, i, w):
self.typ = w
if self.typ != "C":
self.cno = 0
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+2, data="N")
return "sk2"
return "sk1"
def doCus(self, frt, pag, r, c, p, i, w):
cn = self.sql.getRec("genrpc", where=[("glc_cono", "=",
self.opts["conum"]), ("glc_cusno", "=", w)], limit=1)
if not cn:
return "Invalid Custom Report Number"
self.cno = w
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+1, data="N")
return "sk1"
def doCon(self, frt, pag, r, c, p, i, w):
self.con = w
def doRep(self, frt, pag, r, c, p, i, w):
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_repno", "=", w)], limit=1)
if not rp:
return "No Such Report"
self.rep = w
def doGen(self, frt, pag, r, c, p, i, w):
if w == "Y":
c = 0
else:
c = self.opts["conum"]
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("glr_cono", "=", c), ("glr_repno", "=", self.rep)],
limit=1)
if not rp:
return "No Such Report"
self.gen = w
def doContent(self, frt, pag, r, c, p, i, w):
if w in ("B", "C", "X") and self.typ in ("S", "L", "C"):
return "Invalid Choice for this Report Type"
if w == "D":
return
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def doCod(self, frt, pag, r, c, p, i, w):
d = self.sql.getRec("gendtm", cols=["gdm_desc"],
where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=",
w)], limit=1)
if not d:
return "Invalid Detail Code"
def doVar(self, frt, pag, r, c, p, i, w):
if self.typ == "C" and w not in ("B", "P"):
return "Invalid Variance, Only B or P"
def doPrt(self, frt, pag, r, c, p, i, w):
if w == "Export":
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def endTops(self):
if self.new == "y":
self.df.focusField("C", 0, 1)
else:
self.doLoadLines()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def exitTops(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSelTyp(self, frt, pag, r, c, p, i, w):
self.newlin = "n"
self.seq = w[0]
self.typ = w[1]
self.cno = w[2]
self.con = w[3]
self.rep = w[4]
self.gen = w[5]
for x, d in enumerate(w):
self.df.loadEntry(frt, pag, p+x, data=d)
self.df.focusField(frt, pag, c+1)
def doDelLin(self):
if self.newlin == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm), ("gls_seq", "=", self.seq)])
self.doReSeq()
def endData(self):
data = [self.opts["conum"], self.strm, self.desc, self.seq, self.typ,
self.cno, self.con, self.rep, self.gen]
for x in range(6, 14):
data.append(self.df.c_work[self.df.pag][self.df.row][x])
if self.newlin == "y":
self.sql.insRec("genstr", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genstr_col
data.append(self.old[col.index("gls_xflag")])
self.sql.updRec("genstr", data=data, where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm),
("gls_seq", "=", self.seq)])
self.doLoadLines()
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doReSeq(self):
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
if not recs:
self.newlin = "y"
self.df.focusField("C", 0, 1)
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
for seq, acc in enumerate(recs):
acc[3] = seq
self.sql.insRec("genstr", data=acc)
self.doLoadLines()
def doLoadLines(self):
self.df.clearFrame("C", 0)
pos = 0
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
for row, rec in enumerate(recs):
for num, dat in enumerate(rec[3:-1]):
self.df.loadEntry("C", 0, pos, data=dat)
pos += 1
if pos == (self.df.rows[0] * self.df.colq[0]):
self.df.scrollScreen(0)
pos = pos - self.df.colq[0]
pos += 1
self.df.focusField("C", 0, pos)
class ar2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
if self.opts["rtn"] not in (1, 2, 3):
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
self.gc = GetCtl(self.opts["mf"])
assctl = self.gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.glint = assctl["cta_glint"]
self.rordp = assctl["cta_rordp"]
tabs = [
"assgrp", "assmst", "assdep", "asstrn", "ctlvmf", "ctlvrf",
"ctlvtf", "genint", "genmst", "gentrn"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.glint == "Y":
# Check Sale of Asset Record
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, "ass_sls"):
return
self.slsac = ctlctl["ass_sls"]
# Check for VAT Control
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return
self.convat = ctlctl["vat_ctl"]
# Check All Group Control Records
errs = ("Group %s Has An Invalid", "Asset Control Account (%s)",
"Accumulated Depreciation Account (%s)",
"Depreciation Expense Account (%s)")
ass = self.sql.getRec(
"assgrp",
cols=["asg_group", "asg_assacc", "asg_depacc", "asg_expacc"],
where=[("asg_cono", "=", self.opts["conum"])])
for acc in ass:
for x in range(1, 4):
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", acc[x])],
limit=1)
if not chk:
mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x])
showError(self.opts["mf"].body, "Control Error", mess)
return
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"ASS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 2:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("assmst", ),
"cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0,
"Description", "Y")),
"where": [("asm_cono", "=", self.opts["conum"])],
"whera": [["C", "asm_group", 0, 1]]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
data = []
for x in range(1, (len(armvtp) + 1)):
data.append([x, armvtp[x - 1][1]])
mov = {
"stype": "C",
"titl": "Valid Types",
"head": ("C", "Description"),
"data": data
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N",
self.doAssGrp, grp, None, None),
(("C", 1, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "r", "N",
self.doAssCod, cod, None, ("notblank", )),
(("C", 1, 0, 2), "ONA", 13, "Description"),
(("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "IUI", 1, "M", "Movement Type", "r", "N",
self.doTrnMov, mov, None, ("in", (1, 2, 3, 4, 5))),
(("C", 1, 0, 6), "ISD", 13.2, "Company", "Company Amount", "",
"N", self.doCoyAmt, None, None, None),
(("C", 1, 0, 7), "ISD", 13.2, "Receiver", "Receiver Amount", "",
"N", self.doRorAmt, None, None, None),
(("C", 1, 0, 8), "IUA", 1, "V", "V.A.T Code", "C", "N",
self.doVatCod, vtm, None, ("notblank", )),
(("C", 1, 0, 9), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
(("C", 1, 0,
10), "INA", (13, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = (("Interrogate", None, self.queryAss, 0, ("C", 1, 1),
("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1)))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doAssGrp(self, frt, pag, r, c, p, i, w):
whr = [("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", w)]
acc = self.sql.getRec("assgrp", where=whr, limit=1)
if not acc:
return "Invalid Asset Group"
self.group = w
self.depcod = acc[self.sql.assgrp_col.index("asg_depcod")]
self.assacc = acc[self.sql.assgrp_col.index("asg_assacc")]
self.depacc = acc[self.sql.assgrp_col.index("asg_depacc")]
self.expacc = acc[self.sql.assgrp_col.index("asg_expacc")]
def doAssCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.buydt = 0
self.seldt = 0
col = ["asm_desc", "asm_depcod"]
whr = [("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group), ("asm_code", "=", self.code)]
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
ok = askQuestion(screen=self.opts["mf"].body,
head="New Asset",
mess="Asset does not exist, Create?")
if ok == "no":
return "Invalid Asset"
self.doNewAsset()
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
return "Asset Not Found"
self.new = "y"
else:
self.new = "n"
dep = self.sql.getRec("assdep",
cols=["asd_rate1r"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", acc[1])],
limit=1)
self.rate1r = dep[0]
col = ["ast_date"]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "=", 1)]
pur = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if pur:
self.buydt = pur[0]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "in", (3, 5))]
sel = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if sel:
self.seldt = sel[0]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
if self.new == "y":
self.trnmov = 1
self.df.loadEntry(frt, pag, p + 1, data=self.trnmov)
return "sk1"
def doTrnMov(self, frt, pag, r, c, p, i, w):
if type(w) == list:
w = w[0] + 1
# Do some tests to see if not new again or already sold etc.
if w == 4 and self.opts["rtn"] != 3:
return "Depreciation Only Allowed with Journal Entries"
if self.opts["rtn"] == 1 and w not in (1, 2):
return "Invalid Choice For Payment"
if self.opts["rtn"] == 2 and w not in (5, ):
return "Invalid Choice For Receipt"
if w == 1 and self.buydt:
return "Asset Already Purchased"
if w in (2, 3, 4, 5) and self.seldt:
return "Asset Already Sold or Written Off"
if w in (2, 3, 4, 5) and not self.buydt:
return "Asset Not Yet Purchased"
self.df.loadEntry(frt, pag, p, data=w)
self.trnmov = w
if self.trnmov == 3:
bal = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)", "sum(ast_amt2)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
self.coyamt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 1, data=self.coyamt)
self.roramt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 2, data=self.roramt)
self.vatcode = ""
self.trnvat = 0
return "sk4"
def doCoyAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.coyamt = w
if self.rordp == "N" or not self.rate1r or self.trnmov != 4:
self.roramt = 0
self.df.loadEntry(frt, pag, p + 1, data=self.roramt)
if self.trnmov == 4:
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 2, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 3, data=self.trnvat)
return "sk3"
return "sk1"
def doRorAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.roramt = w
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 1, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 2, data=self.trnvat)
return "sk2"
def doVatCod(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.trnvat = round((self.coyamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.trnvat)
if not self.trnvat:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.coyamt < 0 and w > 0:
self.trnvat = float(ASD(0) - ASD(w))
elif self.coyamt > 0 and w < 0:
self.trnvat = float(ASD(0) - ASD(w))
else:
self.trnvat = w
self.df.loadEntry(frt, pag, p, data=self.trnvat)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
self.df.colf[2][3][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if self.coyamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.glint == "N" or self.opts["rtn"] in (1, 2) or \
self.trnmov == 4:
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(1)
else:
self.coyamt = float(ASD(0) - ASD(self.coyamt))
self.df.loadEntry("T", 2, 0, data=self.coyamt)
self.df.selPage("Allocation")
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.coyamt
self.vat = self.trnvat
if self.trnmov == 4:
self.net = float(ASD(0) - ASD(self.coyamt))
self.ror = float(ASD(0) - ASD(self.roramt))
else:
self.net = self.ror = float(ASD(self.coyamt) - ASD(self.trnvat))
if self.opts["rtn"] == 1: # Payments
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
acc = self.assacc
self.glt = 2
elif self.opts["rtn"] == 2: # Receipts
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.net = float(ASD(0) - ASD(self.net))
acc = self.assacc
self.glt = 6
elif self.opts["rtn"] == 3: # Journal Entries
self.recon = 0
if self.trnmov == 4:
acc = self.depacc
else:
acc = self.assacc
self.glt = 4
# Asset Register Transaction
data = [
self.opts["conum"], self.group, self.code, self.opts["rtn"],
self.trnref, self.bh.batno, self.trndat, self.trnmov, self.net,
self.ror, self.vat, self.curdt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.vatcode:
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "I", self.curdt, "A",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.code, self.trndet, self.amt, self.vat, 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Asset or Depreciation Account
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, self.net, self.vat, self.trndet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.vat:
# General Ledger Control Transaction (V.A.T.)
data = [
self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.vat, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
self.amt = float(ASD(0) - ASD(self.amt))
if self.opts["rtn"] in (1, 2):
# General Ledger Control Transaction (Bank)
data = [
self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
elif self.trnmov == 4:
# General Ledger Expense Account (Depreciation)
data = [
self.opts["conum"], self.expacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.coyamt, self.vat,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.trnmov == 5:
# Sale of Asset
# Raise Depreciation
callModule(self.opts["mf"],
None,
"ar2030",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"],
args=(self.curdt, self.group, self.code))
# Generate Sale
amt = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
if amt[0]:
data = [
self.opts["conum"], self.slsac, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt[0], 0,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
data[1] = acc
data[7] = float(ASD(0) - ASD(amt[0]))
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int(int((self.df.last[1][1] - 1) / self.df.colq[1]))
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.coyamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
# General Ledger Transaction (Allocation)
amt = float(ASD(0) - ASD(self.allamt))
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt, 0.00, self.alldet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.coyamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.coyamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def doNewAsset(self):
tit = ("Create New Asset", )
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INA", 30, "Description", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 1, 0), "INa", 3, "Dep Code", "Depreciation Code",
self.depcod, "N", self.doDepCode, dep, None,
("notblank", )), (("T", 0, 1, 0), "ONA", 34, ""))
tnd = ((self.doNewEnd, "N"), )
txt = (self.doNewXit, )
state = self.df.disableButtonsTags()
self.na = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=self.fld,
tend=tnd,
txit=txt)
self.na.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doDepCode(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.na.loadEntry(frt, pag, p + 1, data=chk[0])
def doNewEnd(self):
dat = [self.opts["conum"], self.group, self.code]
for x in range(len(self.na.t_work[0][0]) - 1):
dat.append(self.na.t_work[0][0][x])
self.sql.insRec("assmst", data=dat)
self.doNewXit()
def doNewXit(self):
self.na.closeProcess()
def queryAss(self):
callModule(self.opts["mf"],
self.df,
"ar4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
class ml2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] != 5:
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
tabs = ["ctlvmf", "memmst", "memtrn"]
self.gc = GetCtl(self.opts["mf"])
memctl = self.gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.dis_all = ctlctl["dis_all"]
tabs.extend(["genmst", "gentrn"])
# Setup SQL Object
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"MEM",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
self.glt = 4
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def drawDialog(self):
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names",
"sort":
False
}
tag = (("Deposit", None, None, None, False), ("Allocation", None, None,
None, False))
fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One",
"i", "Y", self.doRefno, None, None, ("efld", )),
(("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 3), "INA", 30, "Details", "Deposit Details", "",
"N", self.doTrnDet, None, None,
None), (("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", 2, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N",
self.doMemAcc, mlm, None, ("notblank", )), (("C", 2, 0, 1),
"ONA", 30, "Name"),
(("C", 2, 0, 2), "ISD", 13.2, "Receipt", "Receipt Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, ("efld", ), None,
"Discount Amount to be Added to the Receipt Amount."),
(("C", 2, 0, 4), "OSD", 13.2, "Total-Amount"))
but = (
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",1),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",1),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",1),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",1),
("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1))
txt = (None, None, None)
cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")]
cxt = [None, self.exitPage1, self.exitPage2]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doRefno(self, frt, pag, r, c, p, i, w):
if not w:
trns = self.sql.getRec("memtrn",
cols=["mlt_refno"],
where=[("mlt_cono", "=",
self.opts["conum"]),
("mlt_refno", "like", "R________")],
order="mlt_refno desc")
auto = False
for trn in trns:
try:
w = "R%08i" % (int(trn[0][1:]) + 1)
auto = True
break
except:
pass
if not auto:
w = "R00000001"
self.df.loadEntry(frt, pag, p, data=w)
chk = self.sql.getRec("memtrn",
cols=["mlt_memno"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", w)])
if chk:
return "A Transaction with this Number Already Exists"
self.refno = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
self.allocated = float(0.00)
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
self.agecan = False
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.glint == "Y":
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doMemAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memmst",
cols=["mlm_title", "mlm_initial", "mlm_surname"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", w)],
limit=1)
if not acc:
return "Invalid Member Number"
self.memno = w
self.name = "%s, %s %s" % (acc[2], acc[0], acc[1])
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.allref = self.refno
while self.sql.getRec("memtrn",
cols=["mlt_batch"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", self.allref)]):
self.doGetAnotherRef()
def doGetAnotherRef(self):
tit = ("Duplicate Reference Number", )
fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref,
"N", None, None, None, None),
(("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N",
self.doRefNew, None, None, ("notblank", )))
tnd = ((self.doRefEnd, "n"), )
txt = (self.doRefExit, )
state = self.df.disableButtonsTags()
self.tf = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=tnd,
txit=txt)
self.tf.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doRefExit(self):
self.tf.focusField("T", 0, 2)
def doRefNew(self, frt, pag, r, c, p, i, w):
self.allref = w
def doRefEnd(self):
self.tf.closeProcess()
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
ok = self.checkSign()
elif self.allamt > 0 and w < 0:
ok = self.checkSign()
else:
ok = "yes"
if ok != "yes":
return "Invalid Discount Amount (Sign Error)"
self.disamt = w
totamt = float(ASD(self.allamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def checkSign(self):
return askQuestion(self.opts["mf"].body, "Check Sign",
"The Sign of the Discount Amount is not the same as the Sign "\
"of the Receipt Amount, Is This Correct?")
def endPage2(self):
self.amt = float(ASD(0) - ASD(self.allamt))
self.dis = float(ASD(0) - ASD(self.disamt))
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(0, 5):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
# Members Ledger Transaction
data = [
self.opts["conum"], self.memno, self.opts["rtn"], self.allref,
self.bh.batno, self.trndat, self.amt, 0.00, self.curdt, "", 0,
self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data)
if self.dis:
data = [
self.opts["conum"], self.memno, 6, self.allref, self.bh.batno,
self.trndat, self.dis, 0.00, self.curdt, "", 0, self.trndet,
"", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data, unique="mlt_refno")
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.glint == "Y":
# General Ledger Control Transaction (Members)
amt = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.memctl, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.disamt:
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.allref, self.bh.batno,
self.disamt, 0.00, self.trndet, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="mem",
agetyp=atype,
agekey=[
self.opts["conum"], self.memno, self.opts["rtn"],
self.allref, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
self.agevar.set(False)
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
class 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 ms1020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["ctlsys", "ctlmst", "ctldep", "genmst", "wagmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
dept = ctlsys["sys_gl_dep"]
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.glint = "N"
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
if ctlmst["ctm_modules"][x:x + 2] in ("SL", "WG"):
dept = "Y"
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
self.glint = "N"
else:
self.glint = wagctl["ctw_glint"]
break
if dept == "N":
showError(self.opts["mf"].body, "Error",
"Departments have Not been Enabled")
return
if self.glint == "N":
self.co1 = 0
self.sy1 = 0
self.cm1 = 0
self.co2 = 0
self.sy2 = 0
self.cm2 = 0
else:
self.coys = self.sql.getRec("ctlmst", cols=["count(*)"],
limit=1)[0]
return True
def mainProcess(self):
dep = {
"stype": "R",
"tables": ("ctldep", ),
"cols":
(("dep_code", "", 0, "Cod"), ("dep_name", "", 0, "Name", "Y")),
"where": [("dep_cono", "=", self.opts["conum"])]
}
coy = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
self.fld = [(("T", 0, 0, 0), "IUI", 3, "Department", "Department Code",
"", "N", self.doDepartment, dep, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N",
self.doName, None, self.doDelete, ("notblank", ))]
if self.glint == "Y":
if self.coys == 1:
self.fld.append((("T", 0, 2, 0), "OUI", 7, "Debit Company"))
else:
self.fld.append(
(("T", 0, 2, 0), "IUI", 7, "Debit Company", "",
self.opts["conum"], "N", self.doCoy, coy, None, None))
self.fld.append((("T", 0, 2, 0), "ONA", 30, ""))
self.fld.extend([
(("T", 0, 3, 0), "IUI", 7, " Salary A/C", "", "", "N",
self.doSal, glm, None, ("notzero", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), "IUI", 7, " Commission A/C", "", "",
"N", self.doCom, glm, None, ("efld", )),
(("T", 0, 4, 0), "ONA", 30, "")
])
if self.coys == 1:
self.fld.append((("T", 0, 5, 0), "OUI", 7, "Credit Company"))
else:
self.fld.append(
(("T", 0, 5, 0), "IUI", 7, "Credit Company", "",
self.opts["conum"], "N", self.doCoy, coy, None, None))
self.fld.append((("T", 0, 5, 0), "ONA", 30, ""))
self.fld.extend([
(("T", 0, 6, 0), "IUI", 7, " Salary A/C", "", "", "N",
self.doSal, glm, None, ("notzero", )),
(("T", 0, 6, 0), "ONA", 30, ""),
(("T", 0, 7, 0), "IUI", 7, " Commission A/C", "", "",
"N", self.doCom, glm, None, ("efld", )),
(("T", 0, 7, 0), "ONA", 30, "")
])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doDepartment(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("ctldep",
where=[("dep_cono", "=",
self.opts["conum"]),
("dep_code", "=", self.code)],
limit=1)
if not self.old:
self.new = "Y"
else:
self.new = "N"
self.doLoadRec(self.old)
def doLoadRec(self, rec):
if not rec:
self.df.clearFrame("T", 0)
self.df.loadEntry("T", 0, 0, data=self.code)
return
for num, dat in enumerate(rec[2:-1]):
if num == 0:
seq = 1
self.df.loadEntry("T", 0, seq, data=dat)
if self.glint == "N":
return
seq += 1
elif num in (1, 4):
coy = dat
if not coy:
dat = ""
else:
nam = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", coy)],
limit=1)
self.df.loadEntry("T", 0, seq, data=coy)
self.df.loadEntry("T", 0, seq + 1, data=nam[0])
seq += 2
elif num in (2, 3, 5, 6):
if dat:
dsc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", coy),
("glm_acno", "=", dat)],
limit=1)
else:
dsc = [""]
self.df.loadEntry("T", 0, seq, data=dat)
self.df.loadEntry("T", 0, seq + 1, data=dsc[0])
seq += 2
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
if self.glint == "Y" and self.coys == 1:
self.co1 = self.opts["conum"]
self.co2 = self.opts["conum"]
self.df.loadEntry(frt, pag, p + 1, data=self.opts["conum"])
self.df.loadEntry(frt, pag, p + 2, data=self.opts["conam"])
return "sk2"
def doCoy(self, frt, pag, r, c, p, i, w):
coy = self.sql.getRec("ctlmst",
cols=["ctm_name "],
where=[("ctm_cono", "=", w)],
limit=1)
if not coy:
return "Invalid Company Number"
if p == 2:
self.co1 = w
else:
self.co2 = w
self.df.loadEntry(frt, pag, p + 1, coy[0])
def doSal(self, frt, pag, r, c, p, i, w):
if p == 4:
co = self.co1
else:
co = self.co2
chk = chkGenAcc(self.opts["mf"], co, w)
if type(chk) is str:
return chk
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
def doCom(self, frt, pag, r, c, p, i, w):
if w:
if p == 6:
co = self.co1
else:
co = self.co2
chk = chkGenAcc(self.opts["mf"], co, w)
if type(chk) is str:
return chk
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if p == 6 and self.coys == 1:
self.df.loadEntry(frt, pag, p + 2, data=self.opts["conum"])
self.df.loadEntry(frt, pag, p + 3, data=self.opts["conam"])
return "sk2"
def doDelete(self):
if self.glint == "Y":
chk = self.sql.getRec("wagmst",
where=[("wgm_dept", "=", self.code)])
if chk:
return "Department is in Use, Not Deleted"
self.sql.delRec("ctldep",
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for num, dat in enumerate(self.df.t_work[0][0]):
if num in (3, 5, 7, 9, 11, 13):
continue
data.append(dat)
if self.glint == "N":
data.extend([0, 0, 0, 0, 0, 0])
if self.new == "Y":
self.sql.insRec("ctldep", data=data)
elif data != self.old[:len(data)]:
col = self.sql.ctldep_col
data.append(self.old[col.index("dep_xflag")])
self.sql.updRec("ctldep",
data=data,
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rc2010(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", "genmst", "gentrn",
"rcaowm", "rcaowt", "rcaprm", "rcatnm", "rcacon", "rcatnt"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
rcactl = gc.getCtl("rcactl", self.opts["conum"])
if not rcactl:
return
self.glint = rcactl["cte_glint"]
self.ch1 = ((rcactl["cte_lme"] // 100) * 100) + 1
self.ch2 = projectDate(self.ch1, 2, typ="months")
if self.glint == "Y":
self.glbnk = rcactl["cte_glbnk"]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = [
"rca_com", "rca_dep", "rca_fee", "rca_orx", "rca_own",
"rca_tnt", "rca_trx", "vat_ctl"
]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.rcacom = ctlctl["rca_com"]
self.rcadep = ctlctl["rca_dep"]
self.rcafee = ctlctl["rca_fee"]
self.rcaorx = ctlctl["rca_orx"]
self.rcaown = ctlctl["rca_own"]
self.rcatnt = ctlctl["rca_tnt"]
self.rcatrx = ctlctl["rca_trx"]
self.convat = ctlctl["vat_ctl"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.batno = "R%04i%02i" % (t[0], t[1])
return True
def drawDialog(self):
# Transaction Types
typ = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("C", "Type"),
"data": []
}
# Movement Types
data = []
for x in range(1, len(rcmvtp) + 1):
data.append((x, rcmvtp[x - 1][1]))
mov = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("C", "Type"),
"data": data
}
# Premises
prm = {
"stype":
"R",
"tables": ("rcaprm", "rcaowm"),
"cols":
(("rcp_owner", "", 0, "Owner"), ("rom_name", "", 0, "Owner"),
("rcp_code", "", 0, "Prm-Cod"), ("rcp_addr1", "", 0,
"Address-Line-1")),
"where": [("rcp_cono", "=", self.opts["conum"]),
("rom_cono=rcp_cono", ), ("rom_acno=rcp_owner", )],
"index":
2
}
# Tenant
tnm = {
"stype":
"R",
"tables": ("rcatnm", ),
"cols": (("rtn_acno", "", 0, "Acc-Num"), ("rtn_name", "", 0,
"Description", "Y")),
"where": [("rtn_cono", "=", self.opts["conum"])],
"whera": [("T", "rtn_owner", 0, 1)]
}
# Contract
con = {
"stype":
"R",
"tables": ("rcacon", ),
"cols": (("rcc_cnum", "", 0, "Seq"), ("rcc_payind", "", 0, "F"),
("rcc_start", "", 0, "Start-Date"),
("rcc_period", "", 0, "Per"), ("rcc_status", "", 0, "S")),
"where": [("rcc_cono", "=", self.opts["conum"])],
"whera": [("T", "rcc_owner", 0, 1), ("T", "rcc_code", 0, 0),
("T", "rcc_acno", 0, 2)]
}
# VAT Records
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
tag = (
(
"Owner",
None,
(("T", 2, 1), ("C", 2, 1)), # On
(("C", 1, 1), ("T", 2, 2), ("C", 2, 2))), # Off
(
"Tenant",
None,
("C", 1, 1), # On
(("C", 1, 2), ("T", 2, 1), ("C", 2, 1))), # Off
("Allocation", self.doAllocation, None, None))
fld = [
(("T", 0, 0, 0), "INA", 7, "Prm-Cod", "Premises Code", "", "Y",
self.doPrmCod, prm, None, None),
(("T", 0, 0, 0), "ONA", 30, "Description"),
(("T", 1, 0, 0), "ONA", 7, "Acc-Num"),
(("T", 1, 0, 0), "ONA", 30, "Name"),
(("T", 1, 0, 0), "OSD", 11.2, "Payable"),
(("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number", "i",
"Y", self.doOwnRef, None, None, ("notblank", )),
(("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r", "N",
self.doOwnDat, None, None, ("efld", )),
(("C", 1, 0, 2), "IUI", 1, "T", "Transaction Type", "r", "N",
self.doOwnTyp, typ, None, ("notzero", )),
(("C", 1, 0, 3), "ISD", 11.2, "Amount", "Transaction Amount", "",
"N", self.doOwnAmt, None, None, None),
(("C", 1, 0, 4), "IUA", 1, "V", "V.A.T Code", "N", "N",
self.doOwnCod, vtm, None, ("efld", )),
(("C", 1, 0, 5), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N",
self.doOwnVat, None, None, None),
(("C", 1, 0, 6), "INA", 47, "Details", "Transaction Details", "",
"N", self.doOwnDet, None, None, None),
(("T", 2, 0, 0), "INA", 7, "Acc-Num", "Account Number", "", "Y",
self.doAccNum, tnm, None, None),
(("T", 2, 0, 0), "ONA", 30, "Name"),
(("T", 2, 0, 0), "IUI", 3, "Seq", "Contract Number", "", "N",
self.doConSeq, con, None, None),
(("T", 2, 0, 0), "OSD", 11.2, "Balance"),
(("C", 2, 0, 0), "INa", 9, "Reference", "Reference Number", "i",
"Y", self.doTntRef, None, None, ("notblank", )),
(("C", 2, 0, 1), "ID1", 10, "Date", "Transaction Date", "r", "N",
self.doTntDat, None, None, ("efld", )),
(("C", 2, 0, 2), "IUI", 1, "T", "Transaction Type", "r", "N",
self.doTntTyp, typ, None, ("notzero", )),
(("C", 2, 0, 3), "ISD", 11.2, "Amount", "Transaction Amount", "",
"N", self.doTntAmt, None, None, None),
(("C", 2, 0, 4), "INA", (60, 30), "Details", "Transaction Details",
"", "N", self.doTntDet, None, None, None),
(("T", 3, 0, 0), "OSD", 11.2, "Rentals "),
(("T", 3, 0, 0), "OSD", 11.2, "Deposit "),
(("T", 3, 0, 0), "OSD", 11.2, "Fees "),
(("T", 3, 1, 0), "OSD", 11.2, "Services (O)"),
(("T", 3, 1, 0), "OSD", 11.2, "Services (A)"),
(("T", 3, 1, 0), "OSD", 11.2, "Repairs "),
(("T", 3, 2, 0), "OSD", 11.2, "Allocation"),
(("C", 3, 0, 0), "IUI", 1, "M", "Movement Type", "", "Y",
self.doAllMov, mov, None, ("between", 1, 6)),
(("C", 3, 0, 1), "ISD", 11.2, "Amount", "Allocation Amount", "",
"N", self.doAllAmt, None, None, None),
(("C", 3, 0, 2), "IUA", 1, "V", "V.A.T Code", "N", "N",
self.doAllCod, vtm, None, ("efld", )),
(("C", 3, 0, 3), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N",
self.doAllVat, None, None, None),
(("C", 3, 0, 4), "INA", (50, 30), "Details", "Transaction Details",
"", "N", self.doAllDet, None, None, None)
]
row = [0, 4, 4, 10]
tnd = [(self.endPage, "y"), (self.endPage, "y"), (self.endPage, "y"),
(self.endPage, "y")]
txt = [self.exitPage, self.exitPage, self.exitPage, self.exitPage]
cnd = [(None, "n"), (self.endPage, "y"), (self.endPage, "y"),
(self.endPage, "y")]
cxt = [None, self.exitPage, self.exitPage, self.exitPage]
but = (("Notes", None, self.allNotes, 0, ("T", 0, 0), ("T", 0, 1)),
("Statement", None, self.allStmnt, 0,
(("C", 1, 1), ("C", 2, 1)), (("T", 0, 1), ("T", 2, 1))),
("Cancel", None, self.doAllCancel, 0, ("C", 3, 1), ("C", 2, 1)))
self.df = TartanDialog(self.opts["mf"],
tags=tag,
eflds=fld,
rows=row,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doPrmCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(
"rcaprm",
cols=["rcp_desc", "rcp_owner", "rcp_crate", "rcp_addr1"],
where=[("rcp_cono", "=", self.opts["conum"]),
("rcp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Premises Code"
self.code = w
desc, self.owner, self.crate, addr1 = acc
if desc:
self.df.loadEntry(frt, pag, p + 1, data=desc)
else:
self.df.loadEntry(frt, pag, p + 1, data=addr1)
acc = self.sql.getRec("rcaowm",
cols=["rom_name", "rom_vatdf"],
where=[("rom_cono", "=", self.opts["conum"]),
("rom_acno", "=", self.owner)],
limit=1)
if not acc:
return "Missing Owner Record (%s)" % self.owner
self.df.loadEntry("T", 1, 0, data=self.owner)
self.df.loadEntry("T", 1, 1, data=acc[0])
self.vatdf = acc[1]
self.acno = None
def doAccNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rcatnm",
cols=["rtn_name"],
where=[("rtn_cono", "=", self.opts["conum"]),
("rtn_owner", "=", self.owner),
("rtn_code", "=", self.code),
("rtn_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.acno = w
self.name = acc[0]
self.df.loadEntry(frt, pag, p + 1, data=self.name)
con = self.sql.getRec("rcacon",
where=[("rcc_cono", "=", self.opts["conum"]),
("rcc_owner", "=", self.owner),
("rcc_code", "=", self.code),
("rcc_acno", "=", self.acno)],
order="rcc_cnum")
if not con:
return "No Valid Contracts"
self.cnum = con[-1:][0][self.sql.rcacon_col.index("rcc_cnum")]
self.df.topf[2][2][5] = self.cnum
def doConSeq(self, frt, pag, r, c, p, i, w):
con = self.sql.getRec("rcacon",
where=[("rcc_cono", "=", self.opts["conum"]),
("rcc_code", "=", self.code),
("rcc_acno", "=", self.acno),
("rcc_cnum", "=", w)],
order="rcc_cnum")
if not con:
return "Invalid Contract Sequence"
self.cnum = w
self.showTenantBalance()
def doOwnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doOwnDat(self, frt, pag, r, c, p, i, w):
if w < self.ch1 or w > self.ch2:
ov = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="RCA",
code="DateOver")
if ov.flag == "no":
return "Invalid Date (< %s or > %s)" % (self.ch1, self.ch2)
self.trndat = w
data = []
for x in range(2, len(rctrtp) + 1):
data.append((x, rctrtp[x - 1][1]))
self.df.colf[1][2][8]["data"] = data
def doOwnTyp(self, frt, pag, r, c, p, i, w):
if w not in (2, 3, 4):
return "Invalid Transaction Type"
self.trntyp = w
def doOwnAmt(self, frt, pag, r, c, p, i, w):
if self.trntyp == 3 and w > self.due:
op = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="RCA",
code="Overpaid")
if op.flag == "no":
return "Overpaid"
self.trnamt = w
# Ignore VAT at this stage
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 1, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 2, data=self.trnvat)
return "sk2"
def doOwnCod(self, frt, pag, r, c, p, i, w):
pass
# 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 doOwnVat(self, frt, pag, r, c, p, i, w):
pass
# 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 doOwnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
def doTntRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doTntDat(self, frt, pag, r, c, p, i, w):
if w < self.ch1 or w > self.ch2:
ov = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="RCA",
code="DateOver")
if ov.flag == "no":
return "Invalid Date (< %s or > %s)" % (self.ch1, self.ch2)
self.trndat = w
data = []
for x in range(1, len(rctrtp) + 1):
data.append((x, rctrtp[x - 1][1]))
self.df.colf[2][2][8]["data"] = data
def doTntTyp(self, frt, pag, r, c, p, i, w):
if w not in (1, 2, 3, 4):
return "Invalid Transaction Type"
self.trntyp = w
def doTntAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.trntyp == 1:
# Rental Raised
self.vatcode = self.vatdf
vrte = getVatRate(self.sql, self.opts["conum"], self.vatcode,
self.trndat)
if vrte is None:
vrte = 0.0
self.trnvat = round((w * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data="Rental Raised")
else:
# Ignore VAT at this stage
self.vatcode = ""
self.trnvat = 0
def doTntDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
def doAllocation(self):
self.df.setWidget(self.df.B1, state="normal")
def doAllMov(self, frt, pag, r, c, p, i, w):
if w == 2 and self.trntyp not in (2, 3):
return "Deposits Only Allowed for Receipts and Payments"
self.allmov = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if not w:
self.allamt = float(ASD(self.trnamt) - ASD(self.alltot))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
if self.allmov == 2:
# Deposit
self.allcod = ""
self.df.loadEntry(frt, pag, p + 1, data=self.allcod)
self.allvat = 0
self.df.loadEntry(frt, pag, p + 2, data=self.allvat)
return "sk2"
if self.trntyp in (2, 3):
# Receipt or Payment
self.df.loadEntry(frt, pag, p + 1, self.vatdf)
if self.trntyp == 4 and self.allmov == 3:
# Journal Fee
self.df.loadEntry(frt, pag, p + 1, self.taxdf)
else:
self.allcod = ""
self.allvat = 0
def doAllCod(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.allcod = w
self.allvat = round((self.allamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p + 2, data=self.trndet)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
self.allvat = float(ASD(0) - ASD(w))
elif self.allamt > 0 and w < 0:
self.allvat = float(ASD(0) - ASD(w))
else:
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p + 1, data=self.trndet)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
def doAllCancel(self):
self.allocs = []
self.df.clearFrame("C", 3)
self.df.setWidget(self.df.B1, state="disabled")
self.df.selPage("Tenant")
self.df.clearLine(2, int((self.df.last[2][1] - 1) / self.df.colq[2]),
"Y")
def endPage(self):
if self.df.frt == "T" and self.df.pag == 0:
self.df.focusField("C", 1, 1)
elif self.df.frt == "C" and self.df.pag == 1:
# Owners
self.updateTables()
self.df.advanceLine(self.df.pag)
elif self.df.frt == "T" and self.df.pag == 2:
self.df.focusField("C", 2, 1)
elif self.df.frt == "C" and self.df.pag == 2:
# Tenants
self.allocs = []
self.alltot = 0.0
if self.trntyp == 1:
self.movtyp = 1
self.updateTables()
self.df.advanceLine(self.df.pag)
else:
self.df.selPage("Allocation")
dpp = 0.0
acc = self.sql.getRec("rcacon",
cols=["rcc_deposit"],
where=[("rcc_cono", "=",
self.opts["conum"]),
("rcc_owner", "=", self.owner),
("rcc_code", "=", self.code),
("rcc_acno", "=", self.acno)],
order="rcc_cnum")
if acc:
dpo = acc[-1:][0][0]
else:
dpo = 0.0
dat = self.sql.getRec(
"rcatnt",
cols=["rtu_mtyp", "round(sum(rtu_tramt), 2)"],
where=[("rtu_cono", "=", self.opts["conum"]),
("rtu_owner", "=", self.owner),
("rtu_code", "=", self.code),
("rtu_acno", "=", self.acno)],
group="rtu_mtyp",
order="rtu_mtyp")
if dat:
for d in dat:
if d[0] == 2:
dpp = d[1]
else:
self.df.loadEntry("T", 3, d[0] - 1, data=d[1])
dpo = float(ASD(dpo) + ASD(dpp))
if dpo:
self.df.loadEntry("T", 3, 1, data=dpo)
self.df.loadEntry("T", 3, 6, data=self.trnamt)
self.df.focusField("C", 3, 1)
else:
# Allocations
self.allocs.append(
[self.allmov, self.allamt, self.allcod, self.allvat])
self.alltot = float(ASD(self.alltot) + ASD(self.allamt))
bal = float(ASD(self.trnamt) - ASD(self.alltot))
if bal:
pos = self.allmov - 1
if self.trntyp == 2:
a = float(
ASD(self.df.t_work[3][0][pos]) - ASD(self.allamt))
else:
a = float(
ASD(self.df.t_work[3][0][pos]) + ASD(self.allamt))
self.df.loadEntry("T", 3, pos, data=a)
self.df.loadEntry("T", 3, 6, data=bal)
self.df.advanceLine(3)
else:
for line in self.allocs:
self.movtyp, self.trnamt, self.vatcode, self.trnvat = line
self.updateTables()
self.df.clearFrame("C", 3)
self.df.selPage("Tenant")
self.df.advanceLine(2)
self.showOwnerTrans()
if self.acno:
self.showTenantTrans()
def showOwnerTrans(self):
whr = [("rot_cono", "=", self.opts["conum"]),
("rot_acno", "=", self.owner)]
tot = self.sql.getRec("rcaowt",
cols=["round(sum(rot_tramt),2)"],
where=[("rot_cono", "=", self.opts["conum"]),
("rot_acno", "=", self.owner)],
limit=1)
if not tot or not tot[0]:
self.due = 0
else:
self.due = float(ASD(0) - ASD(tot[0]))
arr = self.sql.getRec("rcatnt",
cols=["round(sum(rtu_tramt),2)"],
where=[("rtu_cono", "=", self.opts["conum"]),
("rtu_owner", "=", self.owner),
("rtu_mtyp", "in", (1, 4))],
limit=1)
if arr and arr[0]:
self.due = float(ASD(self.due) - ASD(arr[0]))
self.df.loadEntry("T", 1, 2, data=self.due)
tab = ["rcaowt"]
col = [
"rot_trdt", "rot_type", "rot_refno", "rot_desc", "rot_tramt",
"rot_taxamt"
]
whr = [("rot_cono", "=", self.opts["conum"]),
("rot_acno", "=", self.owner)]
odr = "rot_trdt, rot_type, rot_refno"
dat = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr)
data = []
bals = 0
for d in dat:
bals = float(ASD(bals) + ASD(d[4]))
data.append(d + [bals])
col = (("rot_trdt", "Trans-Date", 10, "D1",
"N"), ("rot_type", "Typ", 3, ("XX", rctrtp),
"N"), ("rot_refno", "Reference", 9, "Na",
"N"), ("rot_desc", "Details", 39, "NA", "N"),
("rot_tramt", "Amount", 11.2, "SD",
"N"), ("rot_taxamt", "VAT-Amount", 11.2, "SD",
"N"), ("balance", "Balance", 15.2, "SD", "N"))
try:
self.otrn.closeProcess()
except:
pass
self.otrn = SelectChoice(self.df.topPage1,
None,
col,
data,
wait=False,
neww=False,
butt=False,
sort=False,
live=False,
modal=False,
lines=9)
def showTenantTrans(self):
tab = ["rcatnt"]
col = [
"rtu_trdt", "rtu_type", "rtu_refno", "rtu_desc", "rtu_mtyp",
"rtu_tramt", "rtu_taxamt"
]
whr = [("rtu_cono", "=", self.opts["conum"]),
("rtu_owner", "=", self.owner), ("rtu_code", "=", self.code),
("rtu_acno", "=", self.acno)]
odr = "rtu_trdt, rtu_type, rtu_refno, rtu_mtyp"
dat = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr)
data = []
bals = 0
for d in dat:
bals = float(ASD(bals) + ASD(d[5]))
data.append(d + [bals])
col = (("rtu_trdt", "Trans-Date", 10, "D1",
"N"), ("rtu_type", "Typ", 3, ("XX", rctrtp),
"N"), ("rtu_refno", "Reference", 9, "Na",
"N"), ("rtu_desc", "Details", 35, "NA", "N"),
("rtu_mtyp", "Mov", 3, ("XX", rcmvtp),
"N"), ("rtu_tramt", "Amount", 11.2, "SD",
"N"), ("rtu_taxamt", "VAT-Amount", 11.2, "SD",
"N"), ("balance", "Balance", 15.2, "SD", "N"))
try:
self.ttrn.closeProcess()
except:
pass
self.ttrn = SelectChoice(self.df.topPage2,
None,
col,
data,
wait=False,
neww=False,
butt=False,
sort=False,
live=False,
modal=False,
lines=9)
def showTenantBalance(self):
bal = self.sql.getRec("rcatnt",
cols=["round(sum(rtu_tramt),2)"],
where=[("rtu_cono", "=", self.opts["conum"]),
("rtu_owner", "=", self.owner),
("rtu_code", "=", self.code),
("rtu_acno", "=", self.acno),
("rtu_cnum", "=", self.cnum),
("rtu_mtyp", "<>", 2)],
limit=1)
self.df.loadEntry("T", 2, 3, data=bal[0])
def updateTables(self):
curdt = int(self.trndat / 100)
amt = self.trnamt
vat = self.trnvat
if self.trntyp in (1, 4):
# Rental and Journal
gltyp = 4
elif self.trntyp == 2:
# Receipt
gltyp = 6
bnk = amt
amt = float(ASD(0) - ASD(amt))
vat = float(ASD(0) - ASD(vat))
elif self.trntyp == 3:
# Payment
gltyp = 2
bnk = float(ASD(0) - ASD(amt))
if self.df.pag == 1:
# Owners Transaction
accod = self.owner
data = [
self.opts["conum"], self.owner, self.trntyp, self.trnref,
self.batno, self.trndat, amt, vat, curdt, self.trndet,
self.vatcode, "", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("rcaowt", data=data)
if self.glint == "Y":
# General Ledger Transaction for Owner Control
gld = "%7s %s" % (self.owner, self.trndet[:22])
data = [
self.opts["conum"], self.rcaown, curdt, self.trndat, gltyp,
self.trnref, self.batno, amt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
else:
# Tenants Transaction
accod = self.code
data = [
self.opts["conum"], self.owner, self.code, self.acno,
self.cnum, self.trntyp, self.trnref, self.batno, self.trndat,
self.movtyp, amt, vat, curdt, self.trndet, self.vatcode, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("rcatnt", data=data)
if self.glint == "Y":
gld = "%7s %7s %7s" % (self.owner, self.code, self.acno)
if self.df.pag == 3 and self.movtyp == 2:
# General Ledger Transaction for Deposit Control
acc = self.rcadep
else:
# General Ledger Transaction for Tenant Control
acc = self.rcatnt
data = [
self.opts["conum"], acc, curdt, self.trndat, gltyp,
self.trnref, self.batno, amt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
self.showTenantBalance()
if self.trntyp in (2, 3):
if self.glint == "Y":
# General Ledger Transaction for Bank Account
data = [
self.opts["conum"], self.glbnk, curdt, self.trndat, gltyp,
self.trnref, self.batno, bnk, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
return
if self.df.pag == 1 and self.df.pag == 1:
# Owners Journal Entries (Unallocated)
if self.glint == "Y":
amt = float(ASD(0) - ASD(amt))
data = [
self.opts["conum"], self.rcaorx, curdt, self.trndat, gltyp,
self.trnref, self.batno, amt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
return
if self.df.pag == 2 and self.movtyp == 1:
# Rental and Commission Raised
rta = float(ASD(0) - ASD(amt))
rtv = float(ASD(0) - ASD(vat))
des = "Rental on %s Premises" % self.code
data = [
self.opts["conum"], self.owner, self.trntyp, self.trnref,
self.batno, self.trndat, rta, rtv, curdt, des, self.vatcode,
"", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("rcaowt", data=data)
if self.glint == "Y":
# General Ledger Transaction for Owner Control
gld = "%7s Rental on %7s" % (self.owner, self.code)
data = [
self.opts["conum"], self.rcaown, curdt, self.trndat, gltyp,
self.trnref, self.batno, rta, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.crate:
# If there is a Commission Rate on the Premises Record
cma = float(ASD(0) - ASD(round((rta * self.crate / 100.0), 2)))
vrte = getVatRate(self.sql, self.opts["conum"], self.taxdf,
self.trndat)
if vrte is None:
vrte = 0.0
cmv = round((cma * vrte / 100.0), 2)
cmt = float(ASD(cma) + ASD(cmv))
cma = float(ASD(0) - ASD(cma))
tax = float(ASD(0) - ASD(cmv))
des = "Commission @ %3.5s%s Inclusive" % (self.crate, "%")
data = [
self.opts["conum"], self.owner, 4, self.trnref, self.batno,
self.trndat, cmt, cmv, curdt, des, self.vatdf, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("rcaowt", data=data)
if self.glint == "Y":
# Update Owner Control
gld = "%7s Commission Raised" % self.owner
data = [
self.opts["conum"], self.rcaown, curdt, self.trndat,
gltyp, self.trnref, self.batno, cmt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
# Update Commission Account
data = [
self.opts["conum"], self.rcacom, curdt, self.trndat,
gltyp, self.trnref, self.batno, cma, tax, gld, "", "",
0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.taxdf:
# VAT Transaction (ctlvtf)
data = [
self.opts["conum"], self.taxdf, "O", curdt, "R",
self.trntyp, self.batno, self.trnref, self.trndat,
self.acno, self.name, cma, tax, 0, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("ctlvtf", data=data)
if self.glint == "Y" and tax:
# Update VAT Control
data = [
self.opts["conum"], self.convat, curdt,
self.trndat, gltyp, self.trnref, self.batno, tax,
0, gld, "", "", 0, self.opts["capnm"], self.sysdtw,
0
]
self.sql.insRec("gentrn", data=data)
return
if self.df.pag == 3 and self.movtyp == 3:
# Contract Fees
amt = float(ASD(0) - ASD(amt) + ASD(vat))
vat = float(ASD(0) - ASD(vat))
if self.glint == "Y":
# Update Contract Fee Account
data = [
self.opts["conum"], self.rcafee, curdt, self.trndat, gltyp,
self.trnref, self.batno, amt, vat, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.taxdf:
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "O", curdt, "R",
self.trntyp, self.batno, self.trnref, self.trndat,
accod, self.trndet, amt, vat, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "Y":
# Update VAT Control
data = [
self.opts["conum"], self.convat, curdt, self.trndat,
gltyp, self.trnref, self.batno, vat, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
return
if self.df.pag == 3 and self.movtyp == 4:
# Services - Owner Recovery
rta = float(ASD(0) - ASD(amt))
rtv = float(ASD(0) - ASD(vat))
des = "Services Recovery on %s" % self.code
data = [
self.opts["conum"], self.owner, self.trntyp, self.trnref,
self.batno, self.trndat, rta, rtv, curdt, des, self.vatcode,
"", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("rcaowt", data=data)
if self.glint == "Y":
# General Ledger Transaction for Owner Control
gld = "%7s Services Recovery" % self.owner
data = [
self.opts["conum"], self.rcaown, curdt, self.trndat, gltyp,
self.trnref, self.batno, rta, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
return
# Tenants Journal Entries (Unallocated)
if self.glint == "Y":
amt = float(ASD(0) - ASD(amt))
data = [
self.opts["conum"], self.rcatrx, curdt, self.trndat, gltyp,
self.trnref, self.batno, amt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
def exitPage(self):
if self.df.frt == "T" and self.df.pag == 0:
self.df.closeProcess()
self.opts["mf"].closeLoop()
elif self.df.frt == "C" and self.df.pag == 3:
self.df.focusField("C", 3, self.df.col)
else:
self.opts["mf"].dbm.commitDbase(ask=True)
try:
self.otrn.closeProcess()
except:
pass
try:
self.ttrn.closeProcess()
except:
pass
self.df.selPage("Owner")
self.df.focusField("T", 0, 1)
def allNotes(self):
if self.df.frt == "C":
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
if self.df.pag == 1:
key = "%s" % self.owner
else:
key = "%7s%7s%s" % (self.owner, self.code, self.acno)
NotesCreate(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["capnm"],
"RCA",
key,
commit=False)
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 allStmnt(self):
if self.df.frt == "C" and self.df.pag == 1:
self.sargs = [self.owner]
self.repModule("rc3050")
elif self.df.frt == "C" and self.df.pag == 2:
self.sargs = [self.owner, self.code, self.acno]
self.repModule("rc3060")
else:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def repModule(self, mod):
self.exit = False
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Date and Printer Selection", )
fld = ((("T", 0, 0, 0), "ID1", 10, "Statement Date", "", self.sysdtw,
"N", self.doPrtDate, None, None, ("efld", )), )
self.st = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "V"),
mail=("B", "Y"))
self.st.mstFrame.wait_window()
if not self.exit:
self.sargs.extend(
[self.stdtw, self.stdtd, self.st.repprt, self.st.repeml])
popt = {
"mf": self.opts["mf"],
"conum": self.opts["conum"],
"conam": self.opts["conam"],
"capnm": self.opts["capnm"],
"args": self.sargs
}
runModule(mod, **popt)
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 doPrtDate(self, frt, pag, r, c, p, i, w):
self.stdtw = w
self.stdtd = self.st.t_disp[0][0][0]
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.st.closeProcess()
class bc2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.nstart = bwlctl["ctb_nstart"]
self.fromad = bwlctl["ctb_emadd"]
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "bwlclb", "bwlflf", "bwlflm", "bwlflo", "bwltab",
"bwlfls", "bwlflt"
],
prog=self.__class__.__name__)
if self.sql.error:
return
acc = self.sql.getRec("bwlclb",
where=[("bcc_code", "=", self.opts["conum"])])
if not acc:
self.sql.insRec("bwlclb",
data=[self.opts["conum"], self.opts["conam"]])
self.opts["mf"].dbm.commitDbase()
self.reprint = False
self.fmat = 0
self.date = 0
self.skip = 0
return True
def mainProcess(self):
fmt = {
"stype":
"R",
"tables": ("bwlflf", ),
"cols": (("bff_code", "", 0, "Cod"), ("bff_desc", "", 0,
"Description", "Y")),
"where": [("bff_cono", "=", self.opts["conum"])]
}
sid = {
"stype":
"R",
"tables": ("bwlfls", ),
"cols":
(("bfs_code", "", 0, "Cod"), ("bfs_desc", "", 0, "Description",
"Y"), ("bfs_division", "", 0, "DV")),
"where": [("bfs_cono", "=", self.opts["conum"]),
("bfs_active", "=", "Y")],
"whera": [("T", "bfs_fmat", 0, 0)],
"order":
"bfs_desc"
}
opp = {
"stype":
"R",
"tables": ("bwlflo", ),
"cols": (("bfo_code", "", 0, "Cod"), ("bfo_desc", "", 0,
"Description", "Y")),
"where": [("bfo_cono", "=", self.opts["conum"])],
"whera": [("T", "bfo_fmat", 0, 0)],
"order":
"bfo_desc"
}
self.plr = {
"stype":
"R",
"tables": ("bwltab", ),
"cols":
(("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names")),
"where": [],
"order":
"btb_surname, btb_names"
}
r1s = (("Fixture", "F"), ("Practice", "P"))
fld = ((("T", 0, 0, 0), "I@bfm_fmat", 0, "", "", "", "Y", self.doFmat,
fmt, None, ("efld", )), (("T", 0, 0, 0), "ONA", 30, ""),
(("T", 0, 1,
0), ("IRB", r1s), 0, "Type", "", "F", "N", self.doType, None,
None, None), (("T", 0, 2, 0), "I@bfm_date", 0, "", "", "", "N",
self.doDate, None, None, ("efld", )),
(("T", 0, 3, 0), "I@bfm_round", 0, "", "", "", "N",
self.doRound, None, None, ("notzero", )),
(("T", 0, 4, 0), "I@bfm_team", 0, "", "", "", "N", self.doSide,
sid, None, None), (("T", 0, 4, 0), "ONA", 20, ""),
(("T", 0, 5, 0), "I@bfm_opps", 0, "", "", "", "N", self.doOpp,
opp, None, None), (("T", 0, 5, 0), "ONA", 30, ""),
(("T", 0, 6, 0), "I@bfm_venue", 0, "Venue (H/A/Name)", "", "",
"N", self.doVenue, None, None,
("efld", )), (("T", 0, 7, 0), "IUD", 5.2, "Meeting Time", "",
"", "N", self.doMTime, None, None, ("efld", )),
(("T", 0, 7, 0), "INA", 20, " At (H/A/Name)", "", "H", "N",
self.doMPlace, None, None,
("efld", )), (("T", 0, 8, 0), "I@bfm_captain", 0, "", "", "",
"N", self.doCaptain, self.plr, None,
("notzero", )), (("T", 0, 8, 0), "ONA", 30, ""),
(("C", 0, 0, 1), "I@bft_skip", 0, "Skp", "", "", "N",
self.doSkip, self.plr, None,
("notzero", )), (("C", 0, 0, 2), "ONA", 20,
""), (("C", 0, 0, 3), "I@bft_player", 0,
"3rd", "", "", "N", self.doPlayer,
self.plr, None, ("notzero", )),
(("C", 0, 0, 4), "ONA", 20,
""), (("C", 0, 0, 5), "I@bft_player", 0, "2nd", "", "", "N",
self.doPlayer, self.plr, None,
("notzero", )), (("C", 0, 0, 6), "ONA", 20, ""),
(("C", 0, 0, 7), "I@bft_player", 0, "1st", "", "", "N",
self.doPlayer, self.plr, None, ("notzero", )), (("C", 0, 0, 8),
"ONA", 20, ""))
but = (("Quit", None, self.doQuit, 1, None, None), )
tnd = ((self.doEnd, "n"), )
txt = (self.doExit, )
cnd = ((self.doEnd, "n"), )
cxt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
rows=[3],
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doFmat(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlflf",
where=[("bff_cono", "=", self.opts["conum"]),
("bff_code", "=", w)],
limit=1)
if not acc:
return "Invalid Format"
self.fmat = w
self.fdes = acc[self.sql.bwlflf_col.index("bff_desc")].upper()
self.plr["where"] = [("btb_cono", "=", self.opts["conum"]),
("btb_tab", "<", self.nstart)]
gndr = acc[self.sql.bwlflf_col.index("bff_gender")]
if gndr in ("F", "M"):
self.plr["where"].append(("btb_gender", "=", gndr))
self.assess = acc[self.sql.bwlflf_col.index("bff_assess")]
self.df.loadEntry(frt, pag, p + 1, data=self.fdes)
def doType(self, frt, pag, r, c, p, i, w):
self.ftyp = w
def doDate(self, frt, pag, r, c, p, i, w):
self.date = w
self.disp = "%i %s %i" % (w % 100, mthnam[int(w / 100) % 100][1],
int(w / 10000))
acc = self.sql.getRec("bwlflt",
cols=["sum(bft_shotsf)"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date)],
limit=1)
self.reprint = False
if acc[0]:
self.reprint = True
return "xt"
if acc[0] == 0:
# Edit
acc = self.sql.getRec("bwlflm",
cols=["bfm_round"],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date)],
limit=1)
self.rnd = acc[0]
else:
# New
acc = self.sql.getRec("bwlflm",
cols=["max(bfm_date)", "max(bfm_round)"],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp)],
limit=1)
if not acc[0] or dateDiff(acc[0], self.date, ptype="months") > 6:
self.rnd = 1
else:
self.rnd = acc[1] + 1
self.df.loadEntry(frt, pag, p + 1, data=self.rnd)
def doRound(self, frt, pag, r, c, p, i, w):
if w != self.rnd:
ok = askQuestion(self.opts["mf"].body,
"Round Change",
"The Round Has Been Changed, Please Confirm",
default="no")
if ok == "no":
return "Invalid Round Number"
self.sql.updRec("bwlflm",
cols=["bfm_round"],
data=[w],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date)])
self.rnd = w
def doSide(self, frt, pag, r, c, p, i, w):
if not w:
if askQuestion(self.opts["mf"].body, "New Side",
"Do You Want to Enter a New Side") == "yes":
w = self.enterNewSide()
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("bwlfls",
cols=["bfs_desc", "bfs_number"],
where=[("bfs_cono", "=", self.opts["conum"]),
("bfs_fmat", "=", self.fmat),
("bfs_code", "=", w),
("bfs_active", "=", "Y")],
limit=1)
if not acc:
return "Invalid Side"
self.team = w
self.qty = acc[1]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
acc = self.sql.getRec(tables=["bwlflm", "bwlfls", "bwlflo", "bwltab"],
cols=[
"bfo_code", "bfo_desc", "bfm_venue",
"bfm_mtime", "bfm_mplace", "bfm_captain",
"btb_surname", "btb_names"
],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_date", "=", self.date),
("bfm_team", "=", self.team),
("bfs_cono=bfm_cono", ),
("bfs_fmat=bfm_fmat", ),
("bfs_code=bfm_team", ),
("bfo_cono=bfm_cono", ),
("bfo_fmat=bfm_fmat", ),
("bfo_code=bfm_opps", ),
("btb_cono=bfm_cono", ),
("btb_tab=bfm_captain", )],
limit=1)
if acc:
self.opp = acc[0]
self.venue = acc[2]
self.mtime = acc[3]
self.mplace = acc[4]
self.captain = acc[5]
for x in range(6):
self.df.loadEntry(frt, pag, p + x + 2, data=acc[x])
self.df.loadEntry(frt,
pag,
p + 8,
data=self.getName(acc[6], acc[7]))
self.loadPlayers()
else:
for x in range(c + 2, c + 9):
self.df.clearEntry("T", 0, x)
self.df.clearFrame("C", 0)
# Get previous captain
acc = self.sql.getRec(
tables=["bwlflm", "bwltab"],
cols=["bfm_captain", "btb_surname", "btb_names"],
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_team", "=", self.team), ("btb_cono=bfm_cono", ),
("btb_tab=bfm_captain", )],
order="bfm_date desc",
limit=1)
if acc:
self.df.loadEntry("T", 0, 12, data=acc[0])
self.df.loadEntry("T",
0,
13,
data=self.getName(acc[1], acc[2]))
# Get previous team members
col = ["bft_date", "bft_player", "btb_surname", "btb_names"]
odr = "bft_date desc, bft_skip, bft_position"
acc = self.sql.getRec(tables=["bwlflt", "bwltab"],
cols=col,
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_team", "=", self.team),
("btb_cono=bft_cono", ),
("btb_tab=bft_player", )],
order=odr)
if acc:
date = acc[0][0]
for num, data in enumerate(acc):
if data[0] != date:
break
pos = num * 2
self.df.loadEntry("C", 0, pos, data=data[1])
self.df.loadEntry("C",
0,
pos + 1,
data=self.getName(data[2], data[3]))
def doOpp(self, frt, pag, r, c, p, i, w):
if not w:
if askQuestion(self.opts["mf"].body, "New Opponent",
"Do You Want to Enter a New Opponent") == "yes":
w = self.enterNewOpp()
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("bwlflm",
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_date", "=", self.date),
("bfm_opps", "=", w),
("bfm_team", "<>", self.team)],
limit=1)
if acc:
return "Invalid Opposition, Already Selected"
acc = self.sql.getRec("bwlflo",
cols=["bfo_desc"],
where=[("bfo_cono", "=", self.opts["conum"]),
("bfo_fmat", "=", self.fmat),
("bfo_code", "=", w)],
limit=1)
if not acc:
return "Invalid Opposition"
self.opp = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def loadPlayers(self):
acc = self.sql.getRec(tables=["bwlflt", "bwltab"],
cols=["bft_player", "btb_surname", "btb_names"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_team", "=", self.team),
("btb_cono=bft_cono", ),
("btb_tab=bft_player", )],
order="bft_skip, bft_position")
if acc:
for num, name in enumerate(acc):
pos = num * 2
self.df.loadEntry("C", 0, pos, data=name[0])
self.df.loadEntry("C",
0,
pos + 1,
data=self.getName(name[1], name[2]))
def doVenue(self, frt, pag, r, c, p, i, w):
w = w.strip()
if len(w.strip()) == 1:
w = w.upper()
if w not in ("A", "H"):
return "Invalid Venue"
self.venue = w
self.df.loadEntry(frt, pag, p, data=self.venue)
if not self.df.t_work[0][0][p + 1]:
if self.venue == "H":
self.df.loadEntry(frt, pag, p + 1, data=1.30)
else:
self.df.loadEntry(frt, pag, p + 1, data=1.15)
def doMTime(self, frt, pag, r, c, p, i, w):
self.mtime = w
def doMPlace(self, frt, pag, r, c, p, i, w):
w = w.strip()
if len(w.strip()) == 1:
w = w.upper()
if w not in ("A", "H"):
return "Invalid Place"
self.mplace = w
self.df.loadEntry(frt, pag, p, data=self.mplace)
def doCaptain(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab"
self.captain = w
self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1]))
def doSkip(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab"
self.skip = w
self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1]))
def doPlayer(self, frt, pag, r, c, p, i, w):
if w == self.skip:
return "Invalid Player, This is the Skip"
acc = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab"
self.df.loadEntry(frt, pag, p + 1, data=self.getName(acc[0], acc[1]))
def enterNewSide(self):
tit = ("New Side", )
lge = (("Main", "M"), ("Friendly", "F"))
fld = ((("T", 0, 0, 0), "I@bfs_desc", 0, "", "", "", "N", None, None,
None, ("notblank", )), (("T", 0, 1, 0), ("IRB",
lge), 0, "League", "",
"M", "N", None, None, None, None),
(("T", 0, 2,
0), "I@bfs_division", 0, "", "", "", "N", None, None, None,
("notblank", )), (("T", 0, 3, 0), "I@bfs_number", 0, "", "",
"", "N", None, None, None, ("notzero", )))
state = self.df.disableButtonsTags()
self.new = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doSideEnd, "y"), ),
txit=(self.doSideExit, ))
self.new.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return self.team
def doSideEnd(self):
team = self.sql.getRec("bwlfls",
cols=["max(bfs_code)"],
where=[("bfs_cono", "=", self.opts["conum"]),
("bfs_fmat", "=", self.fmat)],
limit=1)
if not team[0]:
self.team = 1
else:
self.team = team[0] + 1
self.sql.insRec("bwlfls",
data=[self.opts["conum"], self.fmat, self.team] +
self.new.t_work[0][0] + ["Y"])
self.opts["mf"].dbm.commitDbase()
self.new.closeProcess()
def doSideExit(self):
self.team = 0
self.new.closeProcess()
def enterNewOpp(self):
tit = ("New Opponent", )
clb = {
"stype": "R",
"tables": ("bwlclb", ),
"cols":
(("bcc_code", "", 0, "Cod"), ("bcc_name", "", 0, "Name", "Y"))
}
fld = ((("T", 0, 0, 0), "I@bcc_code", 0, "", "", "", "N",
self.doClubCode, clb, None, ("efld", )),
(("T", 0, 0, 0), "I@bcc_name", 0, "", "", "", "N",
self.doClubDesc, None, None, ("notblank", )),
(("T", 0, 1, 0), "I@bfo_desc", 0, "", "", "", "N", None, None,
None, ("notblank", )))
state = self.df.disableButtonsTags()
self.nop = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doOppEnd, "y"), ),
txit=(self.doOppExit, ))
self.nop.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return self.opp
def doClubCode(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlclb", where=[("bcc_code", "=", w)], limit=1)
if acc:
self.nop.loadEntry(frt, pag, p + 1, data=acc[1])
return "sk1"
def doClubDesc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlclb", where=[("bcc_name", "=", w)], limit=1)
if acc:
self.nop.loadEntry(frt, pag, p - 1, data=acc[0])
else:
self.club = getNextCode(self.sql, "bwlclb", "bcc_code", last=999)
self.nop.loadEntry(frt, pag, p - 1, data=self.club)
self.sql.insRec("bwlclb", data=[self.club, w])
self.opts["mf"].dbm.commitDbase()
def doOppEnd(self):
opp = self.sql.getRec("bwlflo",
where=[("bfo_cono", "=", self.opts["conum"]),
("bfo_fmat", "=", self.fmat),
("bfo_desc", "=",
self.nop.t_work[0][0][2])],
limit=1)
if opp:
self.opp = opp[1]
else:
opp = self.sql.getRec("bwlflo",
cols=["max(bfo_code)"],
where=[("bfo_cono", "=", self.opts["conum"]),
("bfo_fmat", "=", self.fmat)],
limit=1)
if not opp[0]:
self.opp = 1
else:
self.opp = opp[0] + 1
self.sql.insRec("bwlflo",
data=[
self.opts["conum"], self.fmat, self.opp,
self.nop.t_work[0][0][0],
self.nop.t_work[0][0][2]
])
self.opts["mf"].dbm.commitDbase()
self.nop.closeProcess()
def doOppExit(self):
self.opp = 0
self.nop.closeProcess()
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
elif self.df.row == (self.qty - 1):
self.doUpdate()
else:
self.df.advanceLine(0)
def doUpdate(self):
self.sql.delRec("bwlflm",
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date),
("bfm_team", "=", self.team)])
self.sql.insRec("bwlflm",
data=[
self.opts["conum"], self.fmat, self.ftyp,
self.date, self.rnd, self.team, self.opp,
self.venue, self.mtime, self.mplace, self.captain
])
self.sql.delRec("bwlflt",
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_team", "=", self.team)])
for x in range(self.qty):
for y in range(4):
data = [
self.opts["conum"], self.fmat, self.ftyp, self.date,
self.team, self.df.c_work[0][x][0],
self.df.c_work[0][x][y * 2], y + 1, 0, 0, 0, 0, 0, 0, 0, ""
]
acc = self.sql.getRec("bwlflt",
where=[("bft_cono", "=", data[0]),
("bft_fmat", "=", data[1]),
("bft_type", "=", data[2]),
("bft_date", "=", data[3]),
("bft_team", "=", data[4]),
("bft_player", "=", data[6])],
limit=1)
if acc:
showError(
self.opts["mf"].body, "Duplicate",
"Player Code %s is Entered More than Once" % data[6])
self.df.focusField("C", 0, 1)
self.opts["mf"].dbm.rollbackDbase()
return
self.sql.insRec("bwlflt", data=data)
for x in range(6, 15):
self.df.clearEntry("T", 0, x)
self.df.clearFrame("C", 0)
self.df.skip = [[1, 2, 3, 4, 5]]
self.df.focusField("T", 0, 6)
def doExit(self):
if self.df.frt == "C":
self.df.focusField("C", 0, self.df.col)
return
if not self.fmat or not self.date:
self.df.closeProcess()
self.opts["mf"].closeLoop()
return
plrs = {}
acc = self.sql.getRec(
"bwlflt",
cols=["bft_player", "bft_team", "bft_skip", "bft_position"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat), ("bft_type", "=", self.ftyp),
("bft_date", "=", self.date)],
order="bft_player")
for a in acc:
if a[0] in plrs:
showError(
self.opts["mf"].body, "Duplicate",
"Player Code %s is in Team Codes %s and %s" %
(a[0], plrs[a[0]][0], a[1]))
self.df.focusField("T", 0, 6)
return
else:
plrs[a[0]] = [a[1], a[2], a[3]]
self.df.closeProcess()
if not self.reprint:
self.opts["mf"].dbm.commitDbase()
ok = askQuestion(self.opts["mf"].body, "Print",
"Do You Want to View/Print the Selections")
if ok == "yes":
self.doPrintSelection()
self.opts["mf"].closeLoop()
def doPrintSelection(self):
fld = ((("T", 0, 0, 0), "INA", 70, "Note-Line-1", "", "", "N", None,
None, None, ("efld", )),
(("T", 0, 1, 0), "INA", 70, "Note-Line-2", "", "", "N", None,
None, None, ("efld", )))
self.pr = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
tend=((self.doPrint, "y"), ),
txit=None,
view=("N", "V"),
mail=("Y", "N"))
self.pr.mstFrame.wait_window()
def doPrint(self):
self.pr.closeProcess()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
"select_%s" % self.date,
ext="pdf")
fpdf = MyFpdf(name=self.__class__.__name__, head=90)
cw = fpdf.get_string_width("X") # character width
ld = 4.5 # line depth
fm = {
"margins": ((10, 80), (5, 12.5)), # left, right, top, bottom
"repeat": (1, 5), # repeat across and below
"rows": ( # x, y, w, h, fill, text, qty
(10, 5, 80, 1.5, .8),
(10, 6.5, ((10, 1.5, .9, ("Skip", "Third", "Second", "Lead")),
(23, 1.5), (23, 1.5), (24, 1.5)), 4), (10, 12.5, 80,
1.5))
}
ff = {
"margins": ((10, 80), ((5, 15))), # left, right, top, bottom
"repeat": (1, 3), # repeat across and below
"rows": ( # x, y, w, h, fill, text, qty
(10, 5, 80, 2, .8), (10, 7, ((10, 2, .9, ("Skip", "Third",
"Second", "Lead")),
(70, 2)), 4), (10, 15, 80, 2))
}
for div in ("Main", "Friendly"):
whr = [("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date)]
if div == "Main":
ppad = 1
rr = fm
if self.ftyp == "P":
ftyp = "PRACTICE"
else:
ftyp = "FIXTURE"
h1 = "TEAMS FOR %s %s - %s %s %s" % (
self.fdes, ftyp, self.date % 100, mthnam[int(
self.date / 100) % 100][1], int(self.date / 10000))
whr.append(("bfs_league", "=", "M"))
else:
ppad = 1.5
rr = ff
h1 = "TEAMS FOR %s FRIENDLY - %s %s %s" % (
self.fdes, self.date % 100, mthnam[int(
self.date / 100) % 100][1], int(self.date / 10000))
whr.append(("bfs_league", "=", "F"))
whr.extend([("bfs_cono=bfm_cono", ), ("bfs_fmat=bfm_fmat", ),
("bfs_code=bfm_team", ), ("bfo_cono=bfm_cono", ),
("bfo_fmat=bfm_fmat", ), ("bfo_code=bfm_opps", ),
("bcc_code=bfo_club", )])
games = self.sql.getRec(
tables=["bwlflm", "bwlfls", "bwlflo", "bwlclb"],
cols=[
"bfm_round", "bfm_team", "bfs_desc", "bfo_desc",
"bfm_venue", "bfm_mtime", "bfm_mplace", "bfm_captain",
"bcc_name", "bfs_number"
],
where=whr,
order="bfm_team")
if not games:
continue
fpdf.add_page()
if games[0][0] == 0:
h1 = h1.replace("FIXTURE", "PRACTICE")
totp = 0
for game in games:
if totp < game[9]:
totp = game[9] * 4
# Draw headings
fpdf.drawText(x=0,
y=1 * ld,
w=90 * cw,
align="C",
txt=h1,
font=("helvetica", "B", 18))
fpdf.setFont("helvetica", "B", 12)
# Draw table
last, table = doDrawTable(fpdf, rr, ppad, spad=2, cw=cw, ld=ld)
# Fill Form
tc = []
pl = []
fpdf.setFont("helvetica", "B", 12)
for x, game in enumerate(games):
tc.append(game[7])
if game[4].strip().upper() == "H":
text = "%s vs %s at %s" % (game[2], game[3],
self.opts["conam"])
elif game[4].strip().upper() == "A":
text = "%s vs %s at %s" % (game[2], game[3], game[8])
else:
text = "%s vs %s at %s" % (game[2], game[3], game[4])
pos = table[0][1][x] + .5
fpdf.drawText(x=0, y=pos * ld, w=90 * cw, align="C", txt=text)
pos = table[-1][1][x] + .5
if game[6].strip().upper() in ("H", "A"):
text = "Meet at the Club at %5.2f" % game[5]
else:
text = "Meet at %s at %5.2f" % (game[6], game[5])
fpdf.drawText(x=0, y=pos * ld, w=90 * cw, align="C", txt=text)
plrs = self.sql.getRec(
tables=["bwlflt", "bwltab"],
cols=["btb_tab", "btb_surname", "btb_names"],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_team", "=", game[1]), ("btb_cono=bft_cono", ),
("btb_tab=bft_player", )],
order="bft_team, bft_skip, bft_position")
while len(plrs) < totp:
plrs.append(["", "", ""])
pl.extend(plrs)
fpdf.setFont("helvetica", "", 12)
col = len(rr["rows"][1][2])
cnt = 0
for p in pl:
if p == ["", "", ""]:
continue
pn = self.getName(p[1], p[2])
if p[0] in tc:
pn = "%s (C)" % pn
x = table[(int((cnt % totp) / 4) + 2)][0][0] + 1
y = table[(
(cnt -
(int(cnt / 4) * 4)) * col) + 2][1][int(cnt / totp)] + .5
fpdf.drawText(x=x * cw, y=y * ld, txt=pn)
cnt += 1
# Draw trailer
fpdf.setFont("helvetica", "B", 14)
txt = """Please tick your names on the right hand side to indicate availability. If unavailable please inform skips and skips to inform selectors."""
if self.assess == "Y":
txt = """%s
Captains (C) are responsible to distribute and return assessment forms, completed and initialled, to a selector.""" % txt
txt = """%s
%s
%s""" % (txt, self.pr.t_work[0][0][0], self.pr.t_work[0][0][1])
fpdf.drawText(x=10.0 * cw, y=(last + 3) * ld, txt=txt, ctyp="M")
fpdf.output(pdfnam, "F")
head = "Match Selections for %s" % self.disp
doPrinter(mf=self.opts["mf"],
header=head,
pdfnam=pdfnam,
repprt=self.pr.repprt,
fromad=self.fromad,
repeml=self.pr.repeml)
def getName(self, snam, fnam):
if fnam:
return "%s, %s" % (snam.upper(), fnam.split()[0][0].upper())
else:
return snam.upper()
def doQuit(self):
self.df.closeProcess()
self.opts["mf"].dbm.rollbackDbase()
self.opts["mf"].closeLoop()
class gl1020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.buildScreen()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["ctlvmf", "genmst", "genjlm", "genjlt"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
return True
def buildScreen(self):
num_sel = {
"stype":
"R",
"tables": ("genjlm", ),
"cols":
(("gjm_num", "", 0, "Number"), ("gjm_desc", "", 0, "Description",
"Y"), ("gjm_freq", "", 0, "Freq"),
("gjm_start", "", 0, "Start"), ("gjm_end", "", 0, "End")),
"where": [("gjm_cono", "=", self.opts["conum"])]
}
seq_sel = {
"stype":
"R",
"tables": ("genjlt", ),
"cols": (("gjt_seq", "", 0, "Seq"), ("gjt_acno", "", 0, "Acc-Num"),
("gjt_amnt", "", 0, "Amount")),
"where": [("gjt_cono", "=", self.opts["conum"])],
"whera": (("T", "gjt_num", 0), )
}
acc_sel = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = ((("T", 0, 0, 0), "INa", 9, "Number", "Journal Number", "", "Y",
self.doNum, num_sel, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
self.doDesc, None, self.doDelNum, ("notblank", )),
(("T", 0, 2, 0), "IUA", 1, "Frequency", "Frequency (M/3/6/Y)",
"", "N", self.doFreq, None, None, ("in", ("M", "3", "6",
"Y"))),
(("T", 0, 3, 0), "ID2", 7, "Starting Period", "", "", "N",
self.doStart, None, None,
("efld", )), (("T", 0, 3, 0), "ID2", 7, "Ending Period", "",
"", "N", self.doEnd, None, None, ("efld", )),
(("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i", "N",
self.doSeq, seq_sel, None, ("notzero", )),
(("C", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N",
self.doAcc, acc_sel, self.doDelSeq, ("efld", )),
(("C", 0, 0,
0), "ONA", 30, "Description", "", "", "N", None, None, None,
None), (("C", 0, 0, 0), "IUA", 1, "V", "V.A.T. Indicator", "",
"N", self.doVat, None, None, ("notblank", )),
(("C", 0, 0, 0), "ISD", 13.2, "Value", "Period Value", "", "N",
self.doValue, None, None, ("efld", )))
but = (("Show Entries", seq_sel, None, 0, ("C", 0, 1), ("C", 0, 2)),
("Show Total", None, self.doTotal, 0, ("C", 0, 1),
("C", 0, 2)), ("Abort Journal", None, self.doAbort, 0,
("C", 0, 1), ("T", 0, 1)))
tnd = ((self.endTop, "y"), )
txt = (self.exitTop, )
cnd = ((self.endCol, "y"), )
cxt = (self.exitCol, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doNum(self, frt, pag, r, c, p, i, w):
self.num = w
self.old = self.sql.getRec("genjlm",
where=[("gjm_cono", "=",
self.opts["conum"]),
("gjm_num", "=", self.num)],
limit=1)
if not self.old:
self.new_num = "y"
self.nxtcol = 1
else:
d = self.sql.genjlm_col
self.new_num = "n"
self.df.loadEntry(frt,
pag,
p + 1,
data=self.old[d.index("gjm_desc")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.old[d.index("gjm_freq")])
self.df.loadEntry(frt,
pag,
p + 3,
data=self.old[d.index("gjm_start")])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.old[d.index("gjm_end")])
for x in range(3):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
def doDelNum(self):
if self.new_num == "y":
return
self.sql.delRec("genjlm",
where=[("gjm_cono", "=", self.opts["conum"]),
("gjm_num", "=", self.num)])
try:
self.sql.delRec("genjlt",
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.acc)])
except:
pass
self.opts["mf"].dbm.commitDbase()
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
def doStart(self, frt, pag, r, c, p, i, w):
if w < self.s_per or w > self.e_per:
return "Invalid Start Date"
self.start = w
def doEnd(self, frt, pag, r, c, p, i, w):
if w < self.start or w > self.e_per:
return "Invalid End Date"
self.end = w
def endTop(self):
data = [
self.opts["conum"], self.num, self.desc, self.freq, self.start,
self.end, 0
]
if self.new_num == "y":
self.sql.insRec("genjlm", data=data)
self.df.loadEntry("C", 0, 0, data=1)
else:
if data != self.old[:len(data)]:
col = self.sql.genjlm_col
data.append(self.old[col.index("gjm_xflag")])
self.sql.updRec("genjlm",
data=data,
where=[("gjm_cono", "=", self.opts["conum"]),
("gjm_num", "=", self.num)])
self.doReload()
self.df.focusField("C", 0, self.nxtcol)
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
self.seqdat = self.sql.getRec("genjlt",
where=[("gjt_cono", "=",
self.opts["conum"]),
("gjt_num", "=", self.num),
("gjt_seq", "=", self.seq)],
limit=1)
if not self.seqdat:
self.new_seq = "y"
else:
self.new_seq = "n"
col = self.sql.genjlt_col
acc = self.seqdat[col.index("gjt_acno")]
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc)],
limit=1)[0]
self.df.loadEntry(frt, pag, p + 1, data=acc)
self.df.loadEntry(frt, pag, p + 2, data=des)
self.df.loadEntry(frt,
pag,
p + 3,
data=self.seqdat[col.index("gjt_vatc")])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.seqdat[col.index("gjt_amnt")])
def doDelSeq(self):
if self.new_seq == "y":
return
self.sql.delRec("genjlt",
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num),
("gjt_seq", "=", self.seq)])
self.doReload()
self.df.focusField("C", 0, self.nxtcol)
def doAcc(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.acc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
self.df.loadEntry(frt, pag, p + 2, data=chk[2])
def doVat(self, frt, pag, r, c, p, i, w):
vat = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not vat:
return "Invalid VAT Code"
self.vat = w
def doValue(self, frt, pag, r, c, p, i, w):
self.val = w
def endCol(self):
data = [
self.opts["conum"], self.num, self.seq, self.acc, self.vat,
self.val
]
if self.new_seq == "y":
self.sql.insRec("genjlt", data=data)
else:
col = self.sql.genjlt_col
data.append(self.seqdat[col.index("gjt_xflag")])
self.sql.updRec("genjlt",
data=data,
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num),
("gjt_seq", "=", self.seq)])
self.doReload()
self.df.focusField("C", 0, self.nxtcol)
def exitCol(self):
tot = self.sql.getRec("genjlt",
cols=["count(*)", "round(sum(gjt_amnt), 2)"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num)],
limit=1)
if tot[0] and not tot[1]:
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
elif tot[1]:
self.df.focusField("C",
0,
self.df.col,
err="Debits Not Equal Credits")
else:
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doAbort(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doReload(self):
self.df.clearFrame("C", 0)
last = (self.df.rows[0] - 1) * 5
trn = self.sql.getRec(
tables=["genjlt", "genmst"],
cols=["gjt_seq", "gjt_acno", "glm_desc", "gjt_vatc", "gjt_amnt"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num), ("glm_cono=gjt_cono", ),
("glm_acno=gjt_acno", )],
order="gjt_seq")
if trn:
for s, t in enumerate(trn):
if s >= self.df.rows[0]:
self.df.scrollScreen(0)
p = last
else:
p = s * 5
self.df.loadEntry("C", 0, p, data=t[0])
self.df.loadEntry("C", 0, p + 1, data=t[1])
self.df.loadEntry("C", 0, p + 2, data=t[2])
self.df.loadEntry("C", 0, p + 3, data=t[3])
self.df.loadEntry("C", 0, p + 4, data=t[4])
if p == last:
self.df.scrollScreen(0)
self.nxtcol = last + 1
else:
self.nxtcol = p + 6
def doTotal(self):
tot = self.sql.getRec("genjlt",
cols=["round(sum(gjt_amnt),2)"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.num)],
limit=1)
if not tot[0]:
tot = CCD(0, "SD", 15.2)
else:
tot = CCD(tot[0], "SD", 15.2)
showInfo(self.opts["mf"].body, "Journal Total", tot.disp)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
class ln2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "lonmf1", "lonmf2", "lonrte", "lontrn", "genint",
"genmst", "gentrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst",
cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])],
limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
self.gc = GetCtl(self.opts["mf"])
lonctl = self.gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
self.glint = lonctl["cln_glint"]
self.drte = lonctl["cln_drte"]
self.crte = lonctl["cln_crte"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["lon_ctl", "int_rec", "int_pay"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.lonctl = ctlctl["lon_ctl"]
self.intrec = ctlctl["int_rec"]
self.intpay = ctlctl["int_pay"]
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.allcoy = self.opts["conum"]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"LON",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 4:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
lm1 = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols":
(("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")),
"where": [("lm1_cono", "=", self.opts["conum"])]
}
lm2 = {
"stype":
"R",
"tables": ("lonmf2", ),
"cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0,
"Description", "Y")),
"where": [("lm2_cono", "=", self.opts["conum"])],
"whera": [("C", "lm2_acno", 0)]
}
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": [["C", "glm_cono", 0, 2]]
}
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, "Acc-Num", "Account Code", "", "Y",
self.doLonAcc, lm1, None, ("efld", )),
(("C", 1, 0, 1), "ONA", 10, "Name"),
(("C", 1, 0, 2), "IUI", 2, "LN", "Loan Number", "", "N",
self.doLonNum, lm2, None, ("efld", )),
(("C", 1, 0, 3), "ITX", (12, 30), "Description", "", "", "N",
self.doLonDes, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 6), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 7), "IUD", 6.2, "DRte-%", "Debit Rate", self.drte,
"N", self.doLonDrt, None, None, None),
(("C", 1, 0, 8), "IUD", 6.2, "CRte-%", "Credit Rate", self.crte,
"N", self.doLonCrt, None, None, None),
(("C", 1, 0, 9), "IUI", 3, "Mth", "Period in Months", "", "N",
self.doLonMth, None, None, ("efld", )),
(("C", 1, 0, 10), "OUD", 12.2, "Repay-Amt"),
(("C", 1, 0, 11), "INA", 30, "Details", "Loan Details", "", "N",
self.doTrnDet, None, None, None)]
if self.opts["rtn"] == 3 and self.glint == "Y":
fld.extend([(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
[("C", 2, 0, 0), "IUI", 3, "Coy", "Company Number",
self.opts["conum"], "N", self.doCoyNum, coy, None,
None],
(("C", 2, 0, 1), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 2), "ONA", 19, "Description"),
(("C", 2, 0,
4), "ISD", 13.2, "All-Amount", "Allocation Amount",
"", "N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 6), "INA", 30, "Allocation Details", "",
"", "N", self.doAllDet, None, None, ("notblank", ))])
if not self.incoac:
fld[15][1] = "OUI"
but = [("Interrogate", None, self.querySln, 0, ("C", 1, 1), ("C", 1,
2))]
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] == 3 and self.glint == "Y":
but.append(
("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1)))
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 doLonAcc(self, frt, pag, r, c, p, i, w):
newacc = False
if not w and self.opts["rtn"] in (1, 2, 3):
yn = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if yn == "no":
return "Invalid Account Number"
newacc = True
w = callModule(self.opts["mf"],
self.df,
"ln1010",
coy=(self.opts["conum"], self.opts["conam"]),
user=self.opts["capnm"],
args="auto",
ret="acno")
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("lonmf1",
cols=["lm1_name"],
where=[("lm1_cono", "=", self.allcoy),
("lm1_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.lonacc = w
self.name = acc[0]
self.df.loadEntry(frt, pag, p + 1, data=self.name)
if newacc:
self.lonnum = 1
self.newlon = True
self.df.loadEntry(frt, pag, p + 2, data=self.lonnum)
return "sk2"
def doLonNum(self, frt, pag, r, c, p, i, w):
self.newlon = False
if not w and self.opts["rtn"] in (1, 2, 3):
ok = askQuestion(self.opts["mf"].body,
head="New Loan",
mess="Is This a New Loan?",
default="no")
if ok == "yes":
self.newlon = True
self.lonnum = getNextCode(self.sql,
"lonmf2",
"lm2_loan",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc)
],
start=1,
last=9999999)
self.df.loadEntry(frt, pag, p, data=self.lonnum)
else:
return "Invalid Loan Number"
else:
self.lonmf2 = self.sql.getRec("lonmf2",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc),
("lm2_loan", "=", w)
],
limit=1)
if not self.lonmf2:
return "Invalid Loan Number"
self.lonnum = w
self.londes = self.lonmf2[self.sql.lonmf2_col.index("lm2_desc")]
self.londat = self.lonmf2[self.sql.lonmf2_col.index("lm2_start")]
self.lonmth = self.lonmf2[self.sql.lonmf2_col.index("lm2_pmths")]
self.lonpay = self.lonmf2[self.sql.lonmf2_col.index("lm2_repay")]
if self.opts["rtn"] in (1, 3) and self.lonmth:
showError(
self.opts["mf"].body, "Fixed Loan",
"""This is a Fixed Period Loan.
Please Create a New Loan for this Account.""")
return "Invalid Loan Number"
self.df.loadEntry(frt, pag, p + 1, data=self.londes)
return "sk1"
def doLonDes(self, frt, pag, r, c, p, i, w):
self.londes = 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 doTrnRef(self, frt, pag, r, c, p, i, w):
self.refno = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if not self.newlon:
self.londrt = 0
self.loncrt = 0
self.lonmth = 0
self.lonpay = 0
if self.opts["rtn"] in (1, 2):
return "nd"
else:
return "sk4"
def doLonDrt(self, frt, pag, r, c, p, i, w):
self.londrt = w
def doLonCrt(self, frt, pag, r, c, p, i, w):
self.loncrt = w
def doLonMth(self, frt, pag, r, c, p, i, w):
self.lonmth = w
if self.lonmth:
rte = (self.londrt / 1200.0)
self.lonpay = round(
((self.trnamt * rte) * ((1 + rte)**w)) / (((1 + rte)**w) - 1),
2)
else:
self.lonpay = 0
self.df.loadEntry(frt, pag, p + 1, data=self.lonpay)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.glint == "Y" and self.opts["rtn"] == 3:
self.df.colf[2][4][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if not self.val:
self.df.advanceLine(1)
elif self.opts["rtn"] in (1, 2, 4) or self.glint == "N":
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
self.df.loadEntry("T", 2, 0, data=self.val)
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
if self.opts["rtn"] == 1:
self.glt = 2
desc = "Loan Advance"
self.val = self.trnamt
elif self.opts["rtn"] == 2:
self.glt = 6
desc = "Loan Repayment"
self.val = float(ASD(0) - ASD(self.trnamt))
elif self.opts["rtn"] == 3:
self.glt = 4
desc = self.trndet
self.val = self.trnamt
elif self.opts["rtn"] == 4:
self.glt = 4
desc = self.trndet
self.val = self.trnamt
if self.newlon:
# Loans Masterfile
self.sql.insRec("lonmf2",
data=[
self.opts["conum"], self.lonacc, self.lonnum,
self.londes, self.trndat, self.lonmth,
self.lonpay, 0
])
# Loans Rate File
self.sql.insRec("lonrte",
data=[
self.opts["conum"], self.lonacc, self.lonnum,
self.trndat, self.londrt, self.loncrt
])
# Loans Transaction File
self.sql.insRec("lontrn",
data=[
self.opts["conum"], self.lonacc, self.lonnum,
self.bh.batno, self.opts["rtn"], self.trndat,
self.refno, self.val, self.curdt, desc, "N",
self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Loans Control Account
data = (self.opts["conum"], self.lonctl, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, self.val, 0.00, self.name,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.opts["rtn"] in (1, 2, 4):
# General Ledger Bank or Interest
self.val = float(ASD(0) - ASD(self.val))
if self.opts["rtn"] in (1, 2):
ctl = self.bh.acc
elif self.val < 0:
ctl = self.intrec
else:
ctl = self.intpay
data = (self.opts["conum"], ctl, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, self.val, 0.00,
"Loan - %s" % self.name, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not acc:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", w),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.allcoy = w
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.allcoy, w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.val) - 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.val:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.val) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
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 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.val))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.val))
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,
"ln4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class dr1020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.buildScreen()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(
self.opts["mf"].dbm,
["ctlvmf", "drschn", "drsmst", "drsrcm", "drsrct", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.chains = drsctl["ctd_chain"]
self.glac = 0
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
return True
def buildScreen(self):
num_sel = {
"stype":
"R",
"tables": ("drsrcm", ),
"cols":
(("dcm_num", "", 0, "Number"), ("dcm_desc", "", 0, "Description",
"Y"), ("dcm_freq", "", 0, "F")),
"where": [("dcm_cono", "=", self.opts["conum"])]
}
seq_sel = {
"stype":
"R",
"tables": ("drsrct", ),
"cols":
(("dct_seq", "", 0, "Seq"), ("dct_chain", "", 0, "Chn"),
("dct_acno", "", 0,
"Acc-Num"), ("dct_detail", "", 0,
"Charge Details"), ("dct_amnt", "", 0, "Amount"),
("dct_start", "", 0, "Start"), ("dct_end", "", 0, "End")),
"where": [("dct_cono", "=", self.opts["conum"])],
"whera": (("T", "dct_num", 0), )
}
chn_sel = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm_sel = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y")),
"where": [("drm_cono", "=", self.opts["conum"]),
("drm_stat", "<>", "X")],
"whera": (("C", "drm_chain", 1, 0), )
}
glm_sel = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vat_sel = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "Y"))
fld = [
(("T",0,0,0),"IUI",3, "Number","Charge Number",
"","Y",self.doNum,num_sel,None,None),
(("T",0,1,0),"INA",30,"Description","",
"","N",self.doDesc,None,self.doDelNum,("notblank",)),
(("T",0,2,0),("IRB",r1s),0, "Frequency","",
"M","N",self.doFreq,None,None,None),
(("T",0,3,0),"IUI",2, "Day of the Month","Day of the Month",
"","N",self.doDay,num_sel,None,("between",1,30),None,
"Enter the day of the month when the entry must be raised. "\
"Use 30 to denote the last day of the month.")]
if self.glint == "Y":
fld.append(
(("T", 0, 4, 0), "IUI", 7, "Charge Account", "G/L Account", "",
"N", self.doGlAc, glm_sel, None, ("notzero", )))
fld.append((("T", 0, 4, 0), "ONA", 30, ""))
nxt = 5
else:
nxt = 4
fld.append(
(("T", 0, nxt, 0), "IUA", 1, "VAT Code", "V.A.T. Code", self.taxdf,
"N", self.doVat, vat_sel, None, ("notblank", )))
fld.append((("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i",
"N", self.doSeq, seq_sel, None, ("notzero", )))
if self.chains == "Y":
fld.append((("C", 0, 0, 0), "IUI", 3, "Chn", "Chain Store", "",
"N", self.doChn, chn_sel, self.doDelSeq, ("efld", )))
else:
self.chn = 0
fld.append((("C", 0, 0, 0), "OUI", 3, "Chn"))
fld.append((("C", 0, 0, 1), "INA", 7, "Acc-Num", "Account Number", "",
"N", self.doAcc, drm_sel, self.doDelSeq, ("efld", )))
fld.extend(
((("C", 0, 0, 2), "ONA", 30, "Name", "", "", "N", None, None, None,
None), (("C", 0, 0, 3), "ITX", 30, "Charge-Details",
"Charge Details", "", "N", self.doDetail, None, None,
None), (("C", 0, 0, 4), "ISD", 13.2, "Excl-Value",
"Period Exclusive Value", "", "N", self.doValue,
None, None, ("efld", )),
(("C", 0, 0, 5), "ID2", 7, "Start", "Starting Period", "", "N",
self.doStart, None, None, ("efld", )),
(("C", 0, 0, 6), "ID2", 7, "End", "Ending Period", "", "N",
self.doEnd, None, None, ("efld", ))))
but = (("All Entries", seq_sel, None, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0,
2))), ("Re-Sequence", None, self.doReSeq, 0,
("C", 0, 1), (("T", 0, 1), ("C", 0, 2))),
("Abort Changes", None, self.doAbort, 0, ("C", 0, 1), ("T", 0,
1)))
tnd = ((self.endTop, "y"), )
txt = (self.exitTop, )
cnd = ((self.endCol, "y"), )
cxt = (self.exitCol, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doNum(self, frt, pag, r, c, p, i, w):
if not w:
num = self.sql.getRec("drsrcm",
cols=["max(dcm_num)"],
where=[("dcm_cono", "=", self.opts["conum"])
],
limit=1)
if not num or not num[0]:
self.num = 1
else:
self.num = num[0] + 1
self.df.loadEntry(frt, pag, p, data=self.num)
else:
self.num = w
self.rcm = self.sql.getRec("drsrcm",
where=[("dcm_cono", "=",
self.opts["conum"]),
("dcm_num", "=", self.num)],
limit=1)
if not self.rcm:
if self.num == 999:
return "Invalid Number (999), Reserved for Sales Invoices"
self.new_num = "y"
self.nxt = 1
else:
d = self.sql.drsrcm_col
self.new_num = "n"
self.df.loadEntry(frt,
pag,
p + 1,
data=self.rcm[d.index("dcm_desc")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.rcm[d.index("dcm_freq")])
self.df.loadEntry(frt,
pag,
p + 3,
data=self.rcm[d.index("dcm_day")])
if self.glint == "Y":
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rcm[d.index("dcm_glac")])
self.df.loadEntry(frt, pag, p + 5, data=self.getAccount())
self.df.loadEntry(frt,
pag,
p + 6,
data=self.rcm[d.index("dcm_vat")])
else:
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rcm[d.index("dcm_vat")])
for x in range(2):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
if self.num == 999:
return "nd"
def getAccount(self):
return self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=",
self.df.t_work[0][0][4])],
limit=1)[0]
def doDelNum(self):
if self.new_num == "y":
return
self.sql.delRec("drsrcm",
where=[("dcm_cono", "=", self.opts["conum"]),
("dcm_num", "=", self.num)])
try:
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.acc)])
except:
pass
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
if self.glint == "N":
self.vcod = self.taxdf
def doDay(self, frt, pag, r, c, p, i, w):
self.day = w
def doGlAc(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.glac = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if not chk[2]:
self.vcod = self.taxdf
else:
self.vcod = chk[2]
self.df.topf[0][4][8] = self.vcod
def doVat(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not acc:
return "Invalid VAT Code"
self.vcod = w
def endTop(self):
data = [
self.opts["conum"], self.num, self.desc, self.freq, self.day,
self.vcod, self.glac, 0
]
if self.new_num == "y":
self.sql.insRec("drsrcm", data=data)
self.df.loadEntry("C", 0, 0, data=1)
self.df.focusField("C", 0, self.nxt)
else:
if data != self.rcm[:len(data)]:
col = self.sql.drsrcm_col
data.append(self.rcm[col.index("dcm_xflag")])
self.sql.updRec("drsrcm",
data=data,
where=[("dcm_cono", "=", self.opts["conum"]),
("dcm_num", "=", self.num)])
self.doReload()
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
self.rct = self.sql.getRec("drsrct",
where=[("dct_cono", "=",
self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)],
limit=1)
if not self.rct:
self.new_seq = "y"
else:
self.new_seq = "n"
col = self.sql.drsrct_col
self.df.loadEntry(frt,
pag,
p + 1,
data=self.rct[col.index("dct_chain")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.rct[col.index("dct_acno")])
acc = self.sql.getRec("drsmst",
cols=["drm_name"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=",
self.rct[col.index("dct_chain")]),
("drm_acno", "=",
self.rct[col.index("dct_acno")])],
limit=1)
self.df.loadEntry(frt, pag, p + 3, data=acc[0])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rct[col.index("dct_detail")])
self.df.loadEntry(frt,
pag,
p + 5,
data=self.rct[col.index("dct_amnt")])
self.df.loadEntry(frt,
pag,
p + 6,
data=self.rct[col.index("dct_start")])
self.df.loadEntry(frt,
pag,
p + 7,
data=self.rct[col.index("dct_end")])
def doDelSeq(self):
if self.new_seq == "y":
return
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)])
self.doReload()
def doChn(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chn = w
def doAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chn),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.acc = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doDetail(self, frt, pag, r, c, p, i, w):
self.det = w
def doValue(self, frt, pag, r, c, p, i, w):
self.val = w
def doStart(self, frt, pag, r, c, p, i, w):
self.start = w
def doEnd(self, frt, pag, r, c, p, i, w):
if w < self.start:
return "Invalid End Date, Before Start"
self.end = w
def endCol(self):
data = [
self.opts["conum"], self.num, self.seq, self.chn, self.acc,
self.det, self.val, self.start, self.end
]
if self.new_seq == "y":
self.sql.insRec("drsrct", data=data)
elif data != self.rct[:len(data)]:
col = self.sql.drsrct_col
data.append(self.rct[col.index("dct_xflag")])
self.sql.updRec("drsrct",
data=data,
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)])
self.doReload()
def exitCol(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doReSeq(self):
recs = self.sql.getRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num)],
order="dct_chain, dct_acno")
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num)])
seq = 0
for rec in recs:
seq += 1
rec[2] = seq
self.sql.insRec("drsrct", data=rec)
self.doReload()
def doAbort(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doReload(self):
self.df.clearFrame("C", 0)
last = (self.df.rows[0] - 1) * 8
trn = self.sql.getRec(tables=["drsrct", "drsmst"],
cols=[
"dct_seq", "dct_chain", "dct_acno",
"drm_name", "dct_detail", "dct_amnt",
"dct_start", "dct_end"
],
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("drm_cono=dct_cono", ),
("drm_chain=dct_chain", ),
("drm_acno=dct_acno", )],
order="dct_seq")
if trn:
for s, t in enumerate(trn):
if s >= self.df.rows[0]:
self.df.scrollScreen(0)
p = last
else:
p = s * 8
self.df.loadEntry("C", 0, p, data=t[0])
self.df.loadEntry("C", 0, p + 1, data=t[1])
self.df.loadEntry("C", 0, p + 2, data=t[2])
self.df.loadEntry("C", 0, p + 3, data=t[3])
self.df.loadEntry("C", 0, p + 4, data=t[4])
self.df.loadEntry("C", 0, p + 5, data=t[5])
self.df.loadEntry("C", 0, p + 6, data=t[6])
self.df.loadEntry("C", 0, p + 7, data=t[7])
if p == last:
self.df.scrollScreen(0)
self.nxt = last + 1
else:
self.nxt = p + 9
else:
self.nxt = 1
self.df.focusField("C", 0, self.nxt)
class dr2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] not in (1, 3, 4, 5):
showError(self.opts["mf"].body, "Control Error",
"Invalid Routine %s, Only 1, 3, 4 and 5 Are Allowed" % \
str(self.opts["rtn"]))
return
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlvmf", "ctlvrf",
"ctlvtf", "drschn", "drsmst", "drstrn", "genint", "genmst",
"gentrn"], prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst", cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint", cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
self.gc = GetCtl(self.opts["mf"])
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.glinp = drsctl["ctd_glinp"]
self.chains = drsctl["ctd_chain"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.drsctl = ctlctl["drs_ctl"]
self.dis_all = ctlctl["dis_all"]
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.allcoy = self.opts["conum"]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.chains == "N":
self.chain = 0
if self.opts["rtn"] == 1:
self.glt = 1
elif self.opts["rtn"] == 3:
self.glt = 4
elif self.opts["rtn"] == 4:
self.glt = 1
elif self.opts["rtn"] == 5:
self.glt = 2
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"], self.opts["conum"],
self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 4:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
drc = {
"stype": "R",
"tables": ("drschn",),
"cols": (
("chm_chain", "", 0, "Num"),
("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]}
drm = {
"stype": "R",
"tables": ("drsmst",),
"cols": (
("drm_acno", "", 0, "Acc-Num"),
("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"])]
drm["whera"] = [["C", "drm_chain", 0, 1]]
else:
drm["where"] = [
("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Name", "Y"))}
glm = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"whera": [["C", "glm_cono", 0, 2]]}
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
viw = {
"stype": "R",
"tables": ("drstrn",),
"cols": (
("drt_chain", "", 0, ""),
("drt_acno", "", 0, ""),
("drt_ref1", "", 0, ""),
("drt_trdt", "", 0, ""),
("drt_tramt", "", 0, ""),
("drt_taxamt", "", 0, "")),
"where": [
("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_batch", "=", self.bh.batno)],
"order": "drt_seq"}
fld = [
(("T",0,0,0),"OUI",9,"Batch %s Quantity" % self.bh.batno),
(("T",0,0,0),"OSD",13.2,"Value"),
[("C",1,0,0),"IUI",3,"Chn","Chain Store",
"r","Y",self.doChain,drc,None,("efld",)],
[("C",1,0,1),"INA",7,"Acc-Num","Account Number",
"r","N",self.doDrsAcc,drm,None,("notblank",)],
[("C",1,0,2),"ONA",10,"Name"],
(("C",1,0,3),"INa",9,"Reference","Reference Number One",
"i","N",self.doRef1,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,("efld",))]
if self.opts["rtn"] == 5:
fld[4][2] = 20
fld.extend([
[["C",1,0,6],"ISD",13.2,"Discount",
"Discount Amount","","N",self.doDisAmt,None,None,None,None,
"Discout Amount to be Added to the Transaction Amount"],
[["C",1,0,7],"OSD",13.2,"Total-Amount"],
[["C",1,0,8],"INA",(20,30),"Details","Transaction Details",
"","N",self.doTrnDet,None,None,None]])
elif self.glint == "Y":
if self.glinp == "E":
tx1 = "Exc-Amount"
tx2 = "Exclusive Amount"
else:
tx1 = "Inc-Amount"
tx2 = "Inclusive Amount"
fld[4][2] = 24
fld.extend([
[["C",1,0,6],"INA",30,"Details","Transaction Details",
"","N",self.doTrnDet,None,None,None],
[("T",2,0,0),"OSD",13.2,"Unallocated Balance"],
[("C",2,0,0),"IUI",3,"Coy","Company Number",
self.opts["conum"],"N",self.doCoyNum,coy,None,None],
(("C",2,0,1),"IUI",7,"Acc-Num","Account Number",
"","N",self.doGenAcc,glm,None,None),
(("C",2,0,2),"ONA",19,"Description"),
(("C",2,0,3),"IUA",1,"V","V.A.T Code",
self.taxdf,"N",self.doVatCode2,vtm,None,("notblank",)),
(("C",2,0,4),"ISD",13.2,tx1,tx2,
"","N",self.doAllAmt,None,None,("efld",)),
(("C",2,0,5),"ISD",13.2,"V.A.T","V.A.T Amount",
"","N",self.doAllVat,None,None,None),
[("C",2,0,6),"INA",(26,30),"Details","",
"","N",self.doAllDet,None,None,("notblank",)]])
if not self.incoac:
fld[10][1] = "OUI"
else:
fld[4][2] = 22
fld.extend([
(("C",1,0,6),"IUA",1,"V","V.A.T Code",
self.taxdf,"N",self.doVatCode1,vtm,None,("notblank",)),
(("C",1,0,7),"ISD",13.2,"V.A.T","V.A.T Amount",
"","N",self.doVatAmt,None,None,None),
[["C",1,0,8],"INA",(20,30),"Details","Transaction Details",
"","N",self.doTrnDet,None,None,None]])
if self.chains == "N":
fld[2][1] = "OUI"
idx = 2
else:
idx = 1
but = (
("Interrogate",None,self.queryDrs,0,("C",1,idx),("C",1,idx+1),
"Interrogate Debtors Records",1),
("View Entries",viw,None,0,("C",1,idx),("C",1,idx+1),
"View Batch Transactions",1),
("Maintain",None,self.maintainDrs,0,("C",1,idx),("C",1,idx+1),
"Maintain Debtors Records",1),
("Canc_el",None,self.doCancel,0,("C",2,1),("C",1,1),
"Cancel the Entry",1),
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",2),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",2),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",2),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",2))
tag = [("Transaction", None, None, None, False)]
cnd = [(None,"n"), (self.endPage1,"y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] != 5 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 doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn", cols=["chm_chain"],
where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain",
"=", w)], limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doDrsAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=",
self.chain), ("drm_acno", "=", w)], limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.dracno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p+1, data=self.name)
def doRef1(self, frt, pag, r, c, p, i, w):
self.ref1 = w
acc = self.sql.getRec("drstrn", cols=["drt_batch"],
where=[("drt_cono", "=", self.opts["conum"]), ("drt_chain", "=",
self.chain), ("drt_acno", "=", self.dracno), ("drt_type", "=",
self.opts["rtn"]), ("drt_ref1", "=", self.ref1)], limit=1)
if acc:
return "Transaction Already Exists"
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.glint == "Y" or self.opts["rtn"] == 5:
self.vatcode = "N"
self.vatamt = 0
def doVatCode1(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p+1, self.vatamt)
if not self.vatamt:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.vatamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.vatamt = float(ASD(0) - ASD(w))
else:
self.vatamt = w
self.df.loadEntry(frt, pag, p, data=self.vatamt)
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.disamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.disamt = float(ASD(0) - ASD(w))
else:
self.disamt = w
self.df.loadEntry(frt, pag, p, data=self.disamt)
totamt = float(ASD(self.trnamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p+1, data=totamt)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] != 5 and self.glint == "Y":
self.df.colf[2][6][5] = w
self.allocated = float(0.00)
def endPage1(self):
self.cancel = False
self.agecan = False
self.batupd = False
self.updateTables1()
if self.cancel:
return
else:
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] == 5 or self.glint == "N":
self.doDrsTrn()
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.vatamt
if self.opts["rtn"] == 1: # Invoices
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 3: # Journals
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 4: # Credit Notes
recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.dis = 0.00
elif self.opts["rtn"] == 5: # Payments
if self.trnamt == 0:
recon = self.curdt
else:
recon = 0
self.vat = 0.00
self.dis = self.disamt
if self.opts["rtn"] == 1:
self.doAgeCurrent()
else:
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(4, 8):
if self.opts["rtn"] == 3 and x == 6:
continue
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B4, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
if self.glint == "N":
return
# General Ledger Control Transaction (Debtors)
val = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.drsctl, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet,
"N", "", recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Bank)
if self.opts["rtn"] == 5:
val = float(ASD(0) - ASD(self.amt))
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet,
"N", "", recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.dis:
val = float(ASD(0) - ASD(self.dis))
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.ref1, self.bh.batno, val,
0.00, self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"], system="drs", agetyp=atype,
agekey=[self.opts["conum"], self.chain, self.dracno,
self.opts["rtn"], self.ref1, self.curdt, self.amt,
self.dis])
self.agecan = age.cancel
if self.agevar.get():
self.agevar.set(False)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlmst", cols=["ctm_name"],
where=[("ctm_cono", "=", w)], limit=1)
if not acc:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint", where=[("cti_cono", "=",
w), ("cti_inco", "=", self.opts["conum"])], limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.allcoy = w
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.allcoy, w)
if type(chk) is str:
return chk
if not chk[2]:
self.taxgl = self.taxdf
else:
self.taxgl = chk[2]
self.genacc = w
self.df.loadEntry("C", pag, p+1, chk[0])
self.df.loadEntry("C", pag, p+2, data=self.taxgl)
def doVatCode2(self, frt, pag, r, c, p, i, w):
ctlctl = self.gc.getCtl("ctlctl", self.allcoy, error=False)
if not ctlctl:
return "Missing ctlctl Record for Company"
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return "Missing or Invalid Control Record"
self.convat = ctlctl["vat_ctl"]
self.vatrte = getVatRate(self.sql, self.allcoy, w, self.trndat)
if self.vatrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if not w:
incamt = float(ASD(self.trnamt) - ASD(self.allocated))
elif self.glinp == "E":
incamt = round((w * (100 + self.vatrte) / 100), 2)
else:
incamt = w
self.allamt = round((incamt * 100 / (100 + self.vatrte)), 2)
self.allvat = float(ASD(incamt) - ASD(self.allamt))
if self.glinp == "E":
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.df.loadEntry(frt, pag, p, data=incamt)
self.df.loadEntry(frt, pag, p+1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p+2, data=self.name)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if (self.allamt < 0 and w > 0) or (self.allamt > 0 and w < 0):
w = float(ASD(0) - ASD(w))
if self.glinp == "I" and w != self.allvat:
self.allamt = float(ASD(self.allamt) + ASD(self.allvat) - ASD(w))
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p+1, data=self.name)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(self.opts["mf"].body, head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.cancel = True
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
if self.glint == "Y" and self.opts["rtn"] != 5:
self.df.clearFrame("C", 2)
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.selPage("Transaction")
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + \
ASD(self.allamt) + ASD(self.allvat))
if self.allocated == self.trnamt:
self.doDrsTrn()
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1: # Invoices
self.credit()
elif self.opts["rtn"] == 3: # Journals
self.credit()
elif self.opts["rtn"] == 4: # Credit Notes
self.debit()
def debit(self):
amt = self.allamt
vat = self.allvat
self.restDebitCredit(amt, vat)
def credit(self):
amt = float(ASD(0) - ASD(self.allamt))
vat = float(ASD(0) - ASD(self.allvat))
self.restDebitCredit(amt, vat)
def restDebitCredit(self, amt, vat):
# VAT Transaction (ctlvtf)
data = (self.allcoy, self.vatcode, "O", self.curdt, "D",
self.opts["rtn"], self.bh.batno, self.ref1, self.trndat,
self.dracno, self.alldet, amt, vat, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Transaction (Allocation)
data = (self.allcoy, self.genacc, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, amt, vat, self.alldet,
self.vatcode, "", 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]
val = float(ASD(amt) + ASD(vat))
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.ref1, 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(amt) - ASD(vat))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.ref1, self.bh.batno, val, 0.00, self.alldet, "N",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if vat:
# General Ledger Control Transaction (V.A.T.)
data = (self.allcoy, self.convat, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, vat, 0.00, self.alldet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
self.vat = float(ASD(self.vat) + ASD(vat))
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def doDrsTrn(self):
# Debtors Ledger Transaction
data = [self.opts["conum"], self.chain, self.dracno, self.opts["rtn"],
self.ref1, 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("drstrn", data=data)
if not self.dis:
return
data = [self.opts["conum"], self.chain, self.dracno, 6, self.ref1,
self.bh.batno, self.trndat, "", self.dis, self.vat, self.curdt,
self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0]
self.sql.insRec("drstrn", data=data)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryDrs(self):
callModule(self.opts["mf"], self.df, "dr4010", coy=(self.opts["conum"],
self.opts["conam"]), period=None, user=self.opts["capnm"])
def maintainDrs(self):
callModule(self.opts["mf"], self.df, "dr1010", coy=(self.opts["conum"],
self.opts["conam"]), period=None, user=self.opts["capnm"])
class gl1040(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.buildScreen()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["gendtm", "gendtt"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.sper = int(self.opts["period"][1][0] / 100)
self.eper = int(self.opts["period"][2][0] / 100)
return True
def buildScreen(self):
cod_sel = {
"stype":
"R",
"tables": ("gendtm", ),
"cols": (("gdm_code", "", 0, "Cod"), ("gdm_desc", "", 0,
"Description", "Y")),
"where": [("gdm_cono", "=", self.opts["conum"])]
}
per_sel = {
"stype":
"R",
"tables": ("gendtt", ),
"cols":
(("gdt_curdt", "", 0, "Period"), ("gdt_value", "", 0, "Value")),
"where": [("gdt_cono", "=", self.opts["conum"]),
("gdt_curdt", "between", self.sper, self.eper)],
"whera": (("T", "gdt_code", 0), )
}
fld = ((("T", 0, 0, 0, 4), "INa", 2, "Code", "", "", "Y", self.doCode,
cod_sel, None, ("notblank", )),
(("T", 0, 0, 0), "INA", 30, "Description", "", "", "N",
self.doDesc, None, self.doDelCode, ("notblank", )),
(("C", 0, 0, 0), "ID2", 7, "Period", "Financial Period", "p",
"N", self.doPeriod, per_sel, None,
None), (("C", 0, 0, 1), "ISD", 13.2, "Value", "Period Value",
"", "N", self.doValue, None, self.doDelPeriod, None))
row = (17, )
but = (("Cancel", None, self.doCancel, 0, ("C", 0, 1), ("T", 0, 1)),
("Quit", None, self.exitTops, 1, None, None))
txt = (self.exitTops, )
tnd = ((self.endTops, "y"), )
cnd = ((self.endData, "y"), )
cxt = (self.exitData, )
self.df = TartanDialog(self.opts["mf"],
sc=None,
eflds=fld,
rows=row,
butt=but,
tend=tnd,
cend=cnd,
txit=txt,
cxit=cxt)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.oldm = self.sql.getRec("gendtm",
where=[("gdm_cono", "=",
self.opts["conum"]),
("gdm_code", "=", self.code)],
limit=1)
if not self.oldm:
self.newcod = True
else:
self.newcod = False
desc = self.oldm[self.sql.gendtm_col.index("gdm_desc")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
self.loadPeriods(focus=False)
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doDelCode(self):
self.sql.delRec("gendtm",
where=[("gdm_cono", "=", self.opts["conum"]),
("gdm_code", "=", self.code)])
self.sql.delRec("gendtt",
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code)])
self.exitData()
def endTops(self):
data = [self.opts["conum"], self.code, self.desc]
if self.newcod:
self.sql.insRec("gendtm", data=data)
self.df.focusField("C", 0, 1)
else:
if data != self.oldm[:len(data)]:
col = self.sql.gendtm_col
data.append(self.oldm[col.index("gdm_xflag")])
self.sql.updRec("gendtm",
data=data,
where=[("gdm_cono", "=", self.opts["conum"]),
("gdm_code", "=", self.code)])
self.df.focusField("C", 0, self.col)
def doPeriod(self, frt, pag, r, c, p, i, w):
if w < self.sper or w > self.eper:
return "Invalid Period"
self.per = w
self.oldt = self.sql.getRec("gendtt",
where=[("gdt_cono", "=",
self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "=", self.per)],
limit=1)
if not self.oldt:
self.newper = "y"
else:
self.newper = "n"
val = self.oldt[self.sql.gendtt_col.index("gdt_value")]
self.df.loadEntry(frt, pag, p + 1, data=val)
def doDelPeriod(self):
if self.newper == "y":
return
self.sql.delRec("gendtt",
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "=", self.per)])
self.loadPeriods()
def doValue(self, frt, pag, r, c, p, i, w):
self.val = w
def endData(self):
data = [self.opts["conum"], self.code, self.per, self.val]
if self.newper == "y":
self.sql.insRec("gendtt", data=data)
elif data != self.oldt[:len(data)]:
col = self.sql.gendtt_col
data.append(self.oldt[col.index("gdt_xflag")])
self.sql.updRec("gendtt",
data=data,
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "=", self.per)])
self.loadPeriods()
def loadPeriods(self, focus=True):
self.df.clearFrame("C", 0)
pers = self.sql.getRec("gendtt",
cols=["gdt_curdt", "gdt_value"],
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "between", self.sper,
self.eper)])
if pers:
for num, per in enumerate(pers):
p = (num * 2)
self.df.loadEntry("C", 0, p, data=per[0])
self.df.loadEntry("C", 0, p + 1, data=per[1])
self.col = p + 3
else:
self.col = 1
if focus:
self.df.focusField("C", 0, self.col)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def exitTops(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
class cr2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] not in (1, 2, 3, 4, 5):
showError(self.opts["mf"].body, "Control Error",
"Invalid Routine %s, Only 1 - 5 Are Allowed" % \
str(self.opts["rtn"]))
return
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "crsmst", "crstrn",
"genint", "genmst", "gentrn", "lonmf1", "lonmf2", "lonrte",
"lontrn", "wagedc", "wagmst", "waglmf", "wagltf"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Company record
self.gc = GetCtl(self.opts["mf"])
self.allcoy = self.opts["conum"]
self.allnam = self.opts["conam"]
ctlmst = self.gc.getCtl("ctlmst", self.allcoy)
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
# 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:
rec = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if rec:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in rec]
else:
self.incoac = False
# Get Enabled Modules
self.lonmod = False
self.lonpag = None
self.slnmod = False
self.slnpag = None
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
if ctlmst["ctm_modules"][x:x + 2] == "LN":
self.lonmod = True
elif ctlmst["ctm_modules"][x:x + 2] == "SL":
self.slnmod = True
# Rest of Controls
crsctl = self.gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
self.glint = crsctl["ctc_glint"]
self.glinp = crsctl["ctc_glinp"]
if self.glint == "Y":
self.ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not self.ctlctl:
return
ctls = ["crs_ctl", "vat_ctl", "dis_rec"]
if self.gc.chkRec(self.opts["conum"], self.ctlctl, ctls):
return
self.crsctl = self.ctlctl["crs_ctl"]
self.disrec = self.ctlctl["dis_rec"]
# Batch Header
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if self.opts["rtn"] == 1:
self.glt = 5
elif self.opts["rtn"] == 2:
self.glt = 6
elif self.opts["rtn"] == 3:
self.glt = 4
elif self.opts["rtn"] == 4:
self.glt = 5
elif self.opts["rtn"] == 5:
self.glt = 2
self.agevar = tk.BooleanVar()
self.othvar = tk.BooleanVar()
self.agevar.set(False)
self.othvar.set(False)
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"CRS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
def drawDialog(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")]
}
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": [("C", "glm_cono", 0, 2)]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
if self.opts["rtn"] in (1, 4) and self.lonmod:
lm1 = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols": (("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0,
"Name", "Y")),
"whera": [("C", "lm1_cono", 0, 2)]
}
lm2 = {
"stype":
"R",
"tables": ("lonmf2", ),
"cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0,
"Description", "Y")),
"whera": [("C", "lm2_cono", 0, 2), ("C", "lm2_acno", 0)]
}
if self.opts["rtn"] in (1, 4) and self.slnmod:
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0,
"Surname", "Y"),
("wgm_fname", "", 0, "Names")),
"whera": [("C", "wgm_cono", 0, 2)]
}
lnm = {
"stype":
"R",
"tables": ("waglmf", ),
"cols": (("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0,
"Description", "Y")),
"where": [("wlm_cono", "=", self.opts["conum"])],
"whera": [("C", "wgm_cono", 0, 2), ("C", "wlm_empno", 0)]
}
ced = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"),
("ced_desc", "", 0, "Description", "Y")),
"where": [("ced_type", "=", "D")],
"whera": [("C", "wgm_cono", 0, 2)],
"index":
1
}
viw = {
"stype":
"R",
"tables": ("crstrn", ),
"cols": (("crt_acno", "", 0, ""), ("crt_ref1", "", 0, ""),
("crt_trdt", "", 0, ""), ("crt_tramt", "", 0,
""), ("crt_taxamt", "", 0, "")),
"where": [("crt_cono", "=", self.opts["conum"]),
("crt_type", "=", self.opts["rtn"]),
("crt_batch", "=", self.bh.batno)],
"order":
"crt_seq",
"comnd":
self.doView
}
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, "Acc-Num", "Account Number", "r",
"Y", self.doCrsAcc, crm, None, None),
[("C", 1, 0, 1), "ONA", 10, "Name"],
(("C", 1, 0, 2), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doRef1, None, None, ("notblank", )),
(("C", 1, 0, 3), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 4), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, None)]
if self.opts["rtn"] in (2, 5):
fld[3][2] = 22
fld.extend([
(("C", 1, 0, 5), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, None, None,
"Discount Amount to be Added to the Transaction Amount."),
(("C", 1, 0, 6), "OSD", 13.2, "Total-Amount"),
[("C", 1, 0, 7), "INA", (22, 30), "Details",
"Transaction Details", "", "N", self.doTrnDet, None, None,
None]
])
elif self.glint == "Y":
if self.glinp == "E":
tx1 = "Exc-Amount"
tx2 = "Exclusive Amount"
else:
tx1 = "Inc-Amount"
tx2 = "Inclusive Amount"
fld[3][2] = 30
fld.extend([(("C", 1, 0, 5), "INA", (27, 30), "Details",
"Transaction Details", "", "N", self.doTrnDet, None,
None, None),
[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
[("C", 2, 0, 0), "IUI", 3, "Coy", "Company Number",
self.opts["conum"], "N", self.doCoyNum, coy, None,
None],
(("C", 2, 0, 1), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 2), "ONA", 19, "Description"),
(("C", 2, 0, 3), "IUA", 1, "V", "V.A.T Code", "", "N",
self.doVatCode2, vtm, None, ("notblank", )),
(("C", 2, 0, 4), "ISD", 13.2, tx1, tx2, "", "N",
self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 5), "ISD", 13.2, "V.A.T", "V.A.T Amount",
"", "N", self.doAllVat, None, None, None),
(("C", 2, 0, 6), "INA", (26, 30), "Details", "",
"", "N", self.doAllDet, None, None, ("notblank", ))])
if not self.incoac:
fld[9][1] = "OUI"
nxt = 3
if self.opts["rtn"] in (1, 4) and self.lonmod:
fld.extend([
(("T", nxt, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", nxt, 0, 0), "IUA", 7, "Acc-Num", "Account Number",
0, "N", self.doLonAcc, lm1, None, None),
(("C", nxt, 0, 1), "ONA", 30, "Name"),
(("C", nxt, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N",
self.doLonNum, lm2, None, None),
(("C", nxt, 0, 3), "INA", 30, "Description", "", "", "N",
self.doLonDes, None, None, ("notblank", )),
(("C", nxt, 0, 4), "ISD", 13.2, "Amount", "", "", "N",
self.doLonAmt, None, None, ("efld", )),
(("C", nxt, 0, 5), "IUD", 6.2, "DRte-%", "Debit Rate", "",
"N", self.doLonDri, None, None, None),
(("C", nxt, 0, 6), "IUD", 6.2, "CRte-%", "Credit Rate", "",
"N", self.doLonDri, None, None, None),
(("C", nxt, 0, 7), "IUI", 3, "Mth", "Period in Months", "",
"N", self.doLonMth, None, None, ("efld", )),
(("C", nxt, 0, 8), "OUD", 12.2, "Repayment")
])
self.lonpag = nxt
nxt += 1
if self.opts["rtn"] in (1, 4) and self.slnmod:
fld.extend([
(("T", nxt, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", nxt, 0, 0), "IUI", 5, "EmpNo", "Employee Number", 0,
"N", self.doEmpNum, wgm, None, None),
(("C", nxt, 0, 1), "ONA", 20, "Name"),
(("C", nxt, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N",
self.doSlnNum, lnm, None, None),
(("C", nxt, 0, 3), "INA", 20, "Description", "", "", "N",
self.doSlnDes, None, None, ("notblank", )),
(("C", nxt, 0, 4), "ISD", 13.2, "Amount", "", "", "N",
self.doSlnAmt, None, None, ("efld", )),
(("C", nxt, 0, 5), "IUI", 3, "Cde", "Deduction Code", "",
"N", self.doSlnCod, ced, None, ("efld", )),
(("C", nxt, 0, 6), "ONA", 20, "Description"),
(("C", nxt, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate",
"", "N", self.doSlnInt, None, None, None),
(("C", nxt, 0,
8), "IUD", 13.2, "Ded-Amt", "Deduction Amount", "", "N",
self.doSlnDed, None, None, ("efld", ))
])
self.slnpag = nxt
else:
fld[3][2] = 20
fld.extend([(("C", 1, 0,
5), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode1, vtm, None, ("notblank", )),
(("C", 1, 0, 6), "ISD", 13.2, "V.A.T", "V.A.T Amount",
"", "N", self.doVatAmt, None, None, None),
[("C", 1, 0, 7), "INA", (18, 30), "Details",
"Transaction Details", "", "N", self.doTrnDet, None,
None, None]])
but = (
("Interrogate",None,self.queryCrs,0,("C",1,1),("C",1,2),
"Interrogate Creditors Records",1),
("View Entries",viw,None,0,("C",1,1),("C",1,2),
"View Batch Transactions",1),
("Maintain",None,self.maintainCrs,0,("C",1,1),("C",1,2),
"Maintain Creditors Records",1),
("Canc_el",None,self.doCancel,0,("C",2,1),("C",1,1),
"Cancel the Entry",1),
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",2),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",2),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated Transaction",2),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",2))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (2, 5) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
if self.opts["rtn"] in (1, 4) and self.lonmod:
tag.append(("LON", None, None, None, False))
cnd.append((self.endLon, "y"))
cxt.append(self.exitLon)
if self.opts["rtn"] in (1, 4) and self.slnmod:
tag.append(("SLN", None, None, None, False))
cnd.append((self.endSln, "y"))
cxt.append(self.exitSln)
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 doView(self, *event):
self.df.focusField("C", 1, 1)
def doCrsAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crsmst",
cols=[
"crm_name", "crm_terms", "crm_vatno",
"crm_termsb", "crm_stday", "crm_pydis",
"crm_glac", "crm_stat"
],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[7] == "X":
return "Invalid Account, Redundant"
self.cracno = w
self.name = acc[0]
self.term = acc[1]
self.vatn = acc[2]
self.base = acc[3]
self.stdt = acc[4]
self.pdis = acc[5]
self.glac = acc[6]
self.popv = False
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doRef1(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crstrn",
cols=["crt_batch"],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.cracno),
("crt_type", "=", self.opts["rtn"]),
("crt_ref1", "=", w)],
limit=1)
if acc:
return "Transaction Already Exists"
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.glint == "Y" or self.opts["rtn"] in (2, 5):
self.vatcode = "N"
self.vatamt = 0
if self.opts["rtn"] not in (2, 5) and self.glint == "N":
if not self.vatn:
self.df.loadEntry(frt, pag, p + 1, data="N")
else:
self.df.loadEntry(frt, pag, p + 1, data=self.taxdf)
def doVatCode1(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
if vrte and not self.vatn:
ok = askQuestion(self.opts["mf"].window, "VAT Number",
"This Account Does Not Have a VAT Number.\n\nMust "\
"it be Populated?", default="yes")
if ok == "yes":
self.vatn = w
self.popv = True
self.vatcode = w
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.vatamt)
if not self.vatamt:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.vatamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.vatamt = float(ASD(0) - ASD(w))
else:
self.vatamt = w
self.df.loadEntry(frt, pag, p, data=self.vatamt)
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.disamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.disamt = float(ASD(0) - ASD(w))
else:
self.disamt = w
self.df.loadEntry(frt, pag, p, data=self.disamt)
totamt = float(ASD(self.trnamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (2, 5) and self.glint == "Y":
self.df.colf[2][6][5] = w
self.allocated = float(0.00)
def endPage1(self):
self.cancel = False
self.agecan = False
self.batupd = False
self.updateTables1()
if self.cancel:
return
else:
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] in (2, 5) or self.glint == "N":
self.doCrsTrn()
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.vatamt
if self.opts["rtn"] == 1: # Invoices
self.recon = 0
self.dis = 0.00
self.per = self.pdis
elif self.opts["rtn"] == 2: # Receipts
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.vat = 0.00
self.dis = self.disamt
self.per = 0.00
elif self.opts["rtn"] == 3: # Journals
self.recon = 0
self.dis = 0.00
self.per = 0.00
elif self.opts["rtn"] == 4: # Credit Notes
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.dis = 0.00
self.per = self.pdis
elif self.opts["rtn"] == 5: # Payments
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = 0.00
self.dis = float(ASD(0) - ASD(self.disamt))
self.per = 0.00
if self.opts["rtn"] == 1:
self.doAgeCurrent()
else:
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(4, 8):
if self.opts["rtn"] == 3 and x == 6:
continue
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B4, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
if self.glint == "N":
return
# General Ledger Control Transaction (Creditors)
val = float(ASD(0) - ASD(self.amt) - ASD(self.dis))
data = (self.opts["conum"], self.crsctl, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, val, 0.00, self.trndet,
"N", "", self.recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Bank)
if self.opts["rtn"] in (2, 5):
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.dis:
data = (self.opts["conum"], self.disrec, self.curdt,
self.trndat, self.glt, self.trnref, self.bh.batno,
self.dis, 0.00, self.trndet, "N", "", self.recon,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="crs",
agetyp=atype,
agekey=[
self.opts["conum"], self.cracno, self.opts["rtn"],
self.trnref, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
if self.agevar.get():
self.agevar.set(False)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
nam = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not nam:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", w),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.ctlctl = self.gc.getCtl("ctlctl", w)
if not self.ctlctl:
return "rf"
self.allcoy = w
self.allnam = nam[0]
self.df.loadEntry(frt, pag, p + 1, data=self.glac)
def doGenAcc(self, frt, pag, r, c, p, i, w):
ctl = True
self.loan = False
if "lon_ctl" in self.ctlctl and w == self.ctlctl["lon_ctl"]:
self.loan = "other"
elif "wag_slc" in self.ctlctl and w == self.ctlctl["wag_slc"]:
self.loan = "staff"
if self.loan:
ctl = False
chk = chkGenAcc(self.opts["mf"], self.allcoy, w, ctl=ctl)
if type(chk) is str:
return chk
if not self.vatn:
self.taxgl = "N"
elif not chk[2]:
self.taxgl = self.taxdf
else:
self.taxgl = chk[2]
self.genacc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
self.df.loadEntry(frt, pag, p + 2, data=self.taxgl)
def doVatCode2(self, frt, pag, r, c, p, i, w):
ctlctl = self.gc.getCtl("ctlctl", self.allcoy, error=False)
if not ctlctl:
return "Missing ctlctl Record for Company"
if self.gc.chkRec(self.allcoy, ctlctl, ["vat_ctl"]):
return "Missing or Invalid Control Record"
self.convat = ctlctl["vat_ctl"]
self.vatrte = getVatRate(self.sql, self.allcoy, w, self.trndat)
if self.vatrte is None:
return "Invalid V.A.T Code"
if self.vatrte and not self.vatn:
ok = askQuestion(self.opts["mf"].window, "VAT Number",
"This Account Does Not Have a VAT Number.\n\nMust "\
"it be Populated?", default="yes")
if ok == "yes":
self.vatn = w
self.popv = True
self.vatcode = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if not w:
incamt = float(ASD(self.trnamt) - ASD(self.allocated))
elif self.glinp == "E":
incamt = round((w * (100 + self.vatrte) / 100), 2)
else:
incamt = w
self.allamt = round((incamt * 100 / (100 + self.vatrte)), 2)
self.allvat = float(ASD(incamt) - ASD(self.allamt))
if self.glinp == "E":
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.df.loadEntry(frt, pag, p, data=incamt)
self.df.loadEntry(frt, pag, p + 1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p + 2, data=self.name)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if (self.allamt < 0 and w > 0) or (self.allamt > 0 and w < 0):
w = float(ASD(0) - ASD(w))
if self.glinp == "I" and w != self.allvat:
self.allamt = float(ASD(self.allamt) + ASD(self.allvat) - ASD(w))
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.cancel = True
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
for pg in range(self.df.pgs, 1, -1):
self.df.clearFrame("C", pg)
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)
if self.othvar.get():
self.othvar.set(False)
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 updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1: # Invoices
self.debit()
elif self.opts["rtn"] == 3: # Journals
self.debit()
elif self.opts["rtn"] == 4: # Credit Notes
self.credit()
def debit(self):
amt = self.allamt
vat = self.allvat
self.restDebitCredit(amt, vat)
def credit(self):
amt = float(ASD(0) - ASD(self.allamt))
vat = float(ASD(0) - ASD(self.allvat))
self.restDebitCredit(amt, vat)
def restDebitCredit(self, amt, vat):
# VAT Transaction (ctlvtf)
data = (self.allcoy, self.vatcode, "I", self.curdt, "C",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.cracno, self.alldet, amt, vat, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Transaction (Expense)
data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, amt, vat, self.alldet,
self.vatcode, "", 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]
val = float(ASD(amt) + ASD(vat))
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.trnref, 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(amt) - ASD(vat))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, val, 0.00, self.alldet, "N",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if vat:
# General Ledger Control Transaction (V.A.T.)
data = (self.allcoy, self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, vat, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
self.vat = float(ASD(self.vat) + ASD(vat))
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def doCrsTrn(self):
# Creditors Master File
if self.popv:
self.sql.updRec("crsmst",
cols=["crm_vatno"],
data=["Unknown"],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.cracno)])
# Creditors Ledger Transaction
paydt = paymentDate(self.base, self.stdt, self.term, self.trndat)
data = [
self.opts["conum"], self.cracno, self.opts["rtn"], self.trnref,
self.bh.batno, self.trndat, "", self.amt, self.vat, self.per,
self.curdt, paydt, "Y", self.amt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("crstrn", data=data)
if not self.dis:
return
data = [
self.opts["conum"], self.cracno, 6, self.trnref, self.bh.batno,
self.trndat, "", self.dis, self.vat, 0, self.curdt, paydt, "Y",
self.dis, self.trndet, self.vatcode, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("crstrn", data=data)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.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 queryCrs(self):
callModule(self.opts["mf"],
self.df,
"cr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def maintainCrs(self):
callModule(self.opts["mf"],
self.df,
"cr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def doLonAcc(self, frt, pag, r, c, p, i, w):
newacc = False
if not w and self.opts["rtn"] == 1:
yn = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if yn == "no":
return "Invalid Account Number"
newacc = True
w = callModule(self.opts["mf"],
self.df,
"ln1010",
coy=(self.allcoy, self.allnam),
user=self.opts["capnm"],
args="auto",
ret="acno")
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("lonmf1",
cols=["lm1_name"],
where=[("lm1_cono", "=", self.allcoy),
("lm1_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.lonacc = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if newacc:
self.lonnum = 1
self.newlon = True
self.df.loadEntry(frt, pag, p + 2, data=self.lonnum)
return "sk2"
def doLonNum(self, frt, pag, r, c, p, i, w):
if not w and self.opts["rtn"] == 1:
ok = askQuestion(self.opts["mf"].body,
head="New Loan",
mess="Is This a New Loan?",
default="no")
if ok == "yes":
self.newlon = True
self.lonnum = getNextCode(self.sql,
"lonmf2",
"lm2_loan",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc)
],
start=1,
last=9999999)
self.df.loadEntry(frt, pag, p, data=self.lonnum)
else:
return "Invalid Loan Number"
else:
self.lonmf2 = self.sql.getRec("lonmf2",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc),
("lm2_loan", "=", w)
],
limit=1)
if not self.lonmf2:
return "Invalid Loan Number"
self.lonnum = w
self.newlon = False
self.londes = self.lonmf2[self.sql.lonmf2_col.index("lm2_desc")]
self.londat = self.lonmf2[self.sql.lonmf2_col.index("lm2_start")]
self.lonmth = self.lonmf2[self.sql.lonmf2_col.index("lm2_pmths")]
self.lonpay = self.lonmf2[self.sql.lonmf2_col.index("lm2_repay")]
if self.lonmth:
return "Invalid Entry, Fixed Loan"
self.df.loadEntry(frt, pag, p + 1, data=self.londes)
return "sk1"
def doLonDes(self, frt, pag, r, c, p, i, w):
self.londes = w
def doLonAmt(self, frt, pag, r, c, p, i, w):
self.lonamt = w
if not self.lonamt:
self.lonamt = self.othtot
self.df.loadEntry(frt, pag, p, data=self.lonamt)
if not self.newlon:
self.newdri = 0
return "nd"
def doLonDri(self, frt, pag, r, c, p, i, w):
self.newdri = w
def doLonCri(self, frt, pag, r, c, p, i, w):
self.newcri = w
def doLonMth(self, frt, pag, r, c, p, i, w):
self.lonmth = w
if self.lonmth:
rte = (self.newdri / 1200.0)
self.lonpay = round(
((self.lonamt * rte) * ((1 + rte)**w)) / (((1 + rte)**w) - 1),
2)
else:
self.lonpay = 0
self.df.loadEntry(frt, pag, p + 1, data=self.lonpay)
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 exitLon(self):
self.df.focusField("C", self.lonpag, self.df.col)
def doEmpNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("wagmst",
cols=["wgm_sname", "wgm_fname"],
where=[("wgm_cono", "=", self.allcoy),
("wgm_empno", "=", w)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.empnum = w
empnam = "%s, %s" % (acc[0], acc[1].split()[0])
self.df.loadEntry(frt, pag, p + 1, data=empnam)
def doSlnNum(self, frt, pag, r, c, p, i, w):
if not w and self.opts["rtn"] == 1:
ok = askQuestion(self.opts["mf"].body,
head="New Loan",
mess="Is This a New Loan?",
default="no")
if ok == "yes":
self.newsln = True
self.slnnum = getNextCode(self.sql,
"waglmf",
"wlm_loan",
where=[
("wlm_cono", "=", self.allcoy),
("wlm_empno", "=", self.empnum)
],
start=1,
last=9999999)
self.df.loadEntry(frt, pag, p, data=self.slnnum)
else:
return "Invalid Loan Number"
else:
acc = self.sql.getRec("waglmf",
where=[("wlm_cono", "=", self.allcoy),
("wlm_empno", "=", self.empnum),
("wlm_loan", "=", w)],
limit=1)
if not acc:
return "Invalid Loan Number"
self.slnnum = w
self.newsln = False
self.slndes = acc[self.sql.waglmf_col.index("wlm_desc")]
self.slncod = acc[self.sql.waglmf_col.index("wlm_code")]
self.slnrte = acc[self.sql.waglmf_col.index("wlm_rate")]
self.slndat = acc[self.sql.waglmf_col.index("wlm_start")]
self.slnded = acc[self.sql.waglmf_col.index("wlm_repay")]
self.df.loadEntry(frt, pag, p + 1, data=self.slndes)
return "sk1"
def doSlnDes(self, frt, pag, r, c, p, i, w):
self.slndes = w
def doSlnAmt(self, frt, pag, r, c, p, i, w):
self.slnamt = w
if not self.slnamt:
self.slnamt = self.othtot
self.df.loadEntry(frt, pag, p, data=self.slnamt)
if not self.newsln:
self.df.loadEntry(frt, pag, p + 1, data=self.slncod)
def doSlnCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=", self.allcoy),
("ced_type", "=", "D"),
("ced_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
self.slncod = w
if not self.newsln:
self.newrte = 0
self.slnded = 0
return "nd"
def doSlnInt(self, frt, pag, r, c, p, i, w):
self.newrte = w
if not self.newsln:
self.df.loadEntry(frt, pag, p + 2, data=self.slnded)
def doSlnDed(self, frt, pag, r, c, p, i, w):
self.slnded = w
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 exitSln(self):
self.df.focusField("C", self.slnpag, self.df.col)
class gl1030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
self.dep = ctlsys["sys_gl_dep"]
self.dig = ctlsys["sys_gl_dig"]
self.sql = Sql(self.opts["mf"].dbm, ["genmst", "genrpt"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.genrpt_fd = self.sql.genrpt_dic
self.genrpt_cl = self.sql.genrpt_col
self.pags = ["","Q","H","L","G","S","T","U","C","P"]
self.head = ["glr_desc", "glr_high", "glr_ffeed", "glr_ignore"]
self.ledger = [
"glr_from", "glr_to", "glr_high", "glr_obal", "glr_accum",
"glr_print", "glr_norm", "glr_acbal", "glr_ignore",
"glr_store", "glr_snum1", "glr_acstr"]
self.group = [
"glr_group", "glr_desc", "glr_from", "glr_to", "glr_high",
"glr_obal", "glr_accum", "glr_print", "glr_norm", "glr_acbal",
"glr_ignore", "glr_store", "glr_snum1", "glr_acstr", "glr_label"]
self.store = [
"glr_desc", "glr_high", "glr_print", "glr_norm", "glr_acbal",
"glr_clear", "glr_snum1", "glr_strper"]
self.total = [
"glr_desc", "glr_high", "glr_total", "glr_print", "glr_norm",
"glr_clear", "glr_store", "glr_snum1", "glr_acstr", "glr_label"]
self.uline = ["glr_high", "glr_uline"]
self.calc = [
"glr_desc", "glr_high", "glr_cbase", "glr_ctype", "glr_snum2",
"glr_camnt", "glr_snum3"]
self.percent = ["glr_desc", "glr_high", "glr_snum1", "glr_snum2"]
return True
def mainProcess(self):
data = [
("H","Heading"),
("L","Ledger Accounts"),
("G","Group of Accounts"),
("S","Stored Amount"),
("T","Total"),
("U","Underline"),
("C","Calculation"),
("P","Percentage")]
typ = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("T", "Description"),
"data": data}
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Description", "Y")),
"order": "ctm_cono"}
glr = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", "=", 0)],
"whera": (("T", "glr_cono", 0, 0),),
"order": "glr_cono, glr_repno",
"index": 1}
gls = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_seq", "", 0, "Seq"),
("glr_type", "", 0, "T"),
("glr_group", "", 0, "Grp"),
("glr_from", "", 0, "From-Ac"),
("glr_to", "", 0, " To-Ac"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", ">", 0)],
"whera": (("T", "glr_cono", 0, 0),("T", "glr_repno", 1, 0))}
self.glm = {
"stype": "C",
"titl": "Account Numbers",
"head": ("Number", "Description"),
"data": []}
ryn = (("Yes","Y"),("No","N"))
rys = (("Yes","Y"),("No","N"),("Debit","+"),("Credit","-"))
rns = (("Positive","P"),("Negative","N"))
ras = (("Add","A"),("Subtract","S"))
rat = (("Add","A"),("Subtract","S"),("Ignore","I"))
rcb = (("Percentage","P"),("Amount","A"),("Store","S"))
rct = (("Plus","+"),("Minus","-"),("Multiply","*"),("Divide","/"))
rsd = (("Single","S"),("Double","D"),("Blank","B"))
pts = (
"Accumulate Month Values",
"Add, Subtract or Ignore",
"Calculation Base",
"Calculation Type",
"Clear Stored Value",
"Clear Total",
"Highlight",
"Ignore Account Type",
"Include Opening Balance",
"Normal Sign",
"Percentage of Stored Value",
"Print Values",
"Store Amount",
"Add or Subtract")
tag = [
("Sequence",None,None,None,False),
("Heading",None,None,None,False),
("Ledger",None,None,None,False),
("Group",None,None,None,False),
("Stored",None,None,None,False),
("Total",None,None,None,False),
("Uline",None,None,None,False),
("Calc",None,None,None,False),
("Percent",None,None,None,False)]
fld = (
(("T",0,0,0),"IUI",3,"Company","Company Number, 0=All",
self.opts["conum"],"Y",self.doCoyNum,coy,None,
("in", (self.opts["conum"], 0))),
(("T",0,0,0),"IUI",3,"Report","Report Number",
"","N",self.doRepNum,glr,None,("notzero",)),
(("T",0,0,0),"IUA",1,"Type","Report Type (B, P, O)",
"P","N",self.doRepTyp,None,self.doDelRpt,
("in", ("O","P","B"))),
(("T",0,0,0),"INA",30,"Heading","Report Heading",
"","N",None,None,None,("notblank",)),
(("T",1,0,0),"IUD",7.2,"Seq-Num","Sequence Number",
"","N",self.doSeqNum,gls,None,("efld",)),
(("T",1,1,0),"IUA",1,"Sequence Type","",
"","N",self.doSeqType,typ,self.doDelSeq,
("in",("H","L","G","T","S","U","P","C"))),
(("T",2,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",2,1,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",2,2,0),("IRB",ryn),0,"New Page","New Page (Y/N)",
"N","N",None,None,None,None),
(("T",2,3,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",3,0,0),"IUI",7,"From Account","From Account Number",
"","N",self.doAcno,self.glm,None,("notzero",)),
(("T",3,1,0),"IUI",7,"To Account","To Account Number",
"","N",self.doAcno,self.glm,None,("efld",)),
(("T",3,2,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",3,3,0),("IRB",ryn),0,pts[8],"",
"Y","N",None,None,None,None),
(("T",3,4,0),("IRB",ryn),0,pts[0],"",
"N","N",None,None,None,None),
(("T",3,5,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",3,6,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",3,7,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",3,8,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",3,9,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",3,10,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",3,11,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",4,0,0),"IUI",3,"Group Number","",
"","N",self.doGrpNum,None,None,("efld",)),
(("T",4,1,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",4,2,0),"IUI",7,"From Account","From Account Number",
"","N",self.doAcno,self.glm,None,("notzero",)),
(("T",4,3,0),"IUI",7,"To Account","To Account Number",
"","N",self.doAcno,self.glm,None,("efld",)),
(("T",4,4,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",4,5,0),("IRB",ryn),0,pts[8],"",
"Y","N",None,None,None,None),
(("T",4,6,0),("IRB",ryn),0,pts[0],"",
"N","N",None,None,None,None),
(("T",4,7,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",4,8,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",4,9,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",4,10,0),("IRB",ryn),0,pts[7],"",
"N","N",None,None,None,None),
(("T",4,11,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",4,12,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",4,13,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",4,14,0),"INA",10,"Chart Label","",
"","N",None,None,None,None),
(("T",5,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",5,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",5,2,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",5,3,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",5,4,0),("IRB",rat),0,pts[1],"",
"A","N",None,None,None,None),
(("T",5,5,0),("IRB",ryn),0,pts[4],"",
"N","N",None,None,None,None),
(("T",5,6,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",5,7,0),"IUD",6.2,pts[10],"",
0,"N",None,None,None,("notzero",)),
(("T",6,0,0),"INA",30,"Description","",
"","N",None,None,None,("efld",)),
(("T",6,1,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",6,2,0),"IUI",1,"Total Level","",
"","N",None,None,None,("between",1,9)),
(("T",6,3,0),("IRB",rys),0,pts[11],"",
"Y","N",None,None,None,None),
(("T",6,4,0),("IRB",rns),0,pts[9],"",
"P","N",None,None,None,None),
(("T",6,5,0),("IRB",ryn),0,pts[5],"",
"Y","N",None,None,None,None),
(("T",6,6,0),("IRB",ryn),0,pts[12],"",
"N","N",self.doStore,None,None,None),
(("T",6,7,0),"IUI",2,"Storage Number","",
"","N",None,None,None,("notzero",)),
(("T",6,8,0),("IRB",ras),0,pts[13],"",
"A","N",None,None,None,None),
(("T",6,9,0),"INA",10,"Chart Label","",
"","N",None,None,None,None),
(("T",7,0,0),("IRB",ryn),0,pts[6],"",
"Y","N",None,None,None,None),
(("T",7,1,0),("IRB",rsd),0,"Underline Type","",
"S","N",None,None,None,None),
(("T",8,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",8,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",8,2,0),("IRB",rcb),0,pts[2],"",
"A","N",self.doPAS,None,None,None),
(("T",8,3,0),("IRB",rct),0,pts[3],"",
"+","N",None,None,None,None),
(("T",8,4,0),"IUI",2,"Storage Number (Base)","",
"","N",self.doStore1,None,None,("notzero",)),
(("T",8,5,0),"ISD",13.2,"Amount","Percent/Amount",
"","N",self.doAmount,None,None,("efld",)),
(("T",8,6,0),"IUI",2,"Storage Number (Calc)","",
"","N",None,None,None,("efld",)),
(("T",9,0,0),"INA",30,"Description","",
"","N",None,None,None,("notblank",)),
(("T",9,1,0),("IRB",ryn),0,pts[6],"",
"N","N",None,None,None,None),
(("T",9,2,0),"IUI",2,"Storage Number (Base)","",
"","N",None,None,None,("notzero",)),
(("T",9,3,0),"IUI",2,"Storage Number (Calc)","",
"","N",None,None,None,("notzero",)))
tnd = (
(self.doT0End,"y"), (self.doT1End,"n"), (self.doT2End,"y"),
(self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"),
(self.doT2End,"y"), (self.doT2End,"y"), (self.doT2End,"y"),
(self.doT2End,"y"))
txt = (
self.doT0Exit, self.doT1Exit, self.doT2Exit, self.doT2Exit,
self.doT2Exit, self.doT2Exit, self.doT2Exit, self.doT2Exit,
self.doT2Exit, self.doT2Exit)
but = (
("Import",None,self.doImpRpt,0,("T",0,1),("T",0,2)),
("Export",None,self.doExpRpt,0,("T",0,3),(("T",0,2),("T",0,4))),
("Copy",None,self.doCpyRpt,0,("T",0,3),(("T",0,2),("T",0,4))),
("Re-Sequence",None,self.doReSeq,0,("T",1,1),("T",1,2),None,1),
("Preview",None,self.doPreview,0,("T",1,1),("T",1,2),None,1),
("Print",None,self.doPrint,0,("T",1,1),("T",1,2),None,1))
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt, tags=tag, butt=but)
def doCoyNum(self, frt, pag, r, c, p, i, w):
self.selcoy = w
if self.selcoy == 0:
acc = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], group="glm_acno, glm_desc", order="glm_acno")
else:
acc = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], where=[("glm_cono", "=", self.selcoy)],
group="glm_acno, glm_desc", order="glm_acno")
if self.dep == "Y":
dep = {}
chs = 10 ** (7 - self.dig)
for a in acc:
dep[a[0] % chs] = a[1]
acc = []
for a in dep:
acc.append([a, dep[a]])
acc.sort()
self.glm["data"] = acc
def doRepNum(self, frt, pag, r, c, p, i, w):
self.repno = w
rep = self.doReadRep(self.selcoy, self.repno, 0)
if not rep:
self.newrep = True
self.df.setWidget(self.df.B1, "normal")
else:
self.newrep = False
self.df.setWidget(self.df.B1, "disabled")
self.df.loadEntry(frt, pag, p+1, data=rep[3])
self.df.loadEntry(frt, pag, p+2, data=rep[4])
def doRepTyp(self, frt, pag, r, c, p, i, w):
self.df.setWidget(self.df.B1, "disabled")
def doImpRpt(self):
self.df.setWidget(self.df.B0, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
sel = FileDialog(parent=self.opts["mf"].body, title="Import File",
initd=self.opts["mf"].rcdic["wrkdir"], ftype=[("Report", "*.rpt")])
nam = sel.askopenfilename()
err = None
if nam:
fle = open(nam, "r")
for num, line in enumerate(fle):
dat = line.split("|")
if not num:
if dat[0] != "genrpt":
err = "This File Does Not Contain a Valid Format"
break
chk = self.sql.getRec("genrpt",
where=[("glr_cono", "=", dat[1]), ("glr_repno", "=",
dat[2]), ("glr_seq", "=", 0)], limit=1)
if chk:
ok = askQuestion(self.opts["mf"].body, "Replace?",
"This Report Already Exists, Would you like "\
"to Replace It?")
if ok == "yes":
self.sql.delRec("genrpt", where=[("glr_cono", "=",
dat[1]), ("glr_repno", "=", dat[2])])
else:
err = "Report Already Exists"
break
self.sql.insRec("genrpt", data=dat[1:])
else:
self.sql.insRec(dat[0], data=dat[1:])
if not err:
self.opts["mf"].dbm.commitDbase(ask=True)
else:
showError(self.opts["mf"].body, "Invalid Import", err)
self.df.setWidget(self.df.mstFrame, "show")
self.df.focusField("T", 0, 1)
def doExpRpt(self):
fle = open(os.path.join(self.opts["mf"].rcdic["wrkdir"],
"C%s_R%s.rpt" % (self.selcoy, self.repno)), "w")
rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq")
for lin in rpt:
mes = "genrpt"
for dat in lin:
mes = "%s|%s" % (mes, str(dat))
fle.write("%s\n" % mes)
fle.close()
self.df.focusField("T", 0, 1)
def doCpyRpt(self):
if not self.newrep:
showError(self.opts["mf"].body, "Invalid Copy Request",
"You can only Copy a report when Creating a New report, "\
"not when Changing an Existing report!")
self.df.focusField("T", 0, 3)
return
tit = ("Copy Existing Report Layout",)
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Name", "Y"))}
glr = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("glr_seq", "=", 0)],
"whera": (("T", "glr_cono", 0, 0),),
"index": 1}
fld = (
(("T",0,0,0),"IUI",3,"Company Number","",
"","N",self.doCpyCoy,coy,None,None),
(("T",0,1,0),"IUI",3,"Report Number","",
"","N",self.doRptNum,glr,None,None))
state = self.df.disableButtonsTags()
self.cp = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doCpyEnd, "n"),), txit=(self.doCpyExit,))
self.cp.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 0, 1)
def doCpyCoy(self, frt, pag, r, c, p, i, w):
self.cpycoy = w
def doRptNum(self, frt, pag, r, c, p, i, w):
self.cpynum = w
def doCpyEnd(self):
rpt = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.cpycoy), ("glr_repno", "=", self.cpynum)])
if rpt:
for rec in rpt:
rec[0] = self.selcoy
rec[1] = self.repno
self.sql.insRec("genrpt", data=rec)
self.opts["mf"].dbm.commitDbase()
self.doCpyCloseProcess()
def doCpyExit(self):
self.doCpyCloseProcess()
def doCpyCloseProcess(self):
self.cp.closeProcess()
def doDelRpt(self):
self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doT0End(self):
rtype = self.df.t_work[0][0][2]
desc = self.df.t_work[0][0][3]
if self.newrep:
data = [self.selcoy, self.repno, 0, rtype, desc]
for x in range(5, len(self.genrpt_cl)):
if self.genrpt_fd[self.genrpt_cl[x]][2][1] in ("A", "a"):
data.append("")
else:
data.append(0)
self.sql.insRec("genrpt", data=data)
else:
self.sql.updRec("genrpt", cols=["glr_type", "glr_desc"],
data=[rtype, desc], where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno), ("glr_seq", "=", 0)])
self.df.selPage("Sequence")
self.df.focusField("T", 1, 1)
def doReSeq(self):
whr = [("glr_cono", "=", self.selcoy), ("glr_repno", "=", self.repno)]
recs = self.sql.getRec("genrpt", where=whr, order="glr_seq")
self.sql.delRec("genrpt", where=whr)
for seq, rec in enumerate(recs):
rec = list(rec)
rec[2] = float(seq)
self.sql.insRec("genrpt", data=rec)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPreview(self):
self.cols = [
("a", "Seq-Num", 7.2, "UD"),
("b", "T", 1, "UA"),
("c", "Grp", 3, "Na"),
("d", "Lvl", 3, "Na"),
("e", "Acc-Num", 7, "Na"),
("f", "Description", 30, "NA")]
self.data = []
self.newp = []
recs = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno)], order="glr_seq")
pgp = 0
lsq = 0
rpc = self.sql.genrpt_col
for num, rec in enumerate(recs):
seq = rec[rpc.index("glr_seq")]
rtp = rec[rpc.index("glr_type")]
if rtp in ("B", "P", "O"):
self.titl = rec[rpc.index("glr_desc")]
continue
des = rec[rpc.index("glr_desc")]
prt = rec[rpc.index("glr_print")]
if prt == "N":
continue
if rtp == "H":
if rec[rpc.index("glr_ffeed")] == "Y":
self.data.append((seq, "N", "", "", "",
"---------- New Page ----------"))
elif lsq:
ptp = recs[lsq][rpc.index("glr_type")]
utp = recs[lsq][rpc.index("glr_uline")]
if ptp == "H" or (ptp == "U" and utp == "B"):
pass
else:
self.data.append((seq, "", "", "", "", ""))
self.data.append((seq, rtp, "", "", "", des))
self.data.append((seq, "", "", "", "", ""))
elif rtp == "L":
frm = rec[rpc.index("glr_from")]
too = rec[rpc.index("glr_to")]
whr = [("glm_cono", "=", self.selcoy)]
if too:
whr.append(("glm_acno", "between", frm, too))
else:
whr.append(("glm_acno", "=", frm))
accs = self.sql.getRec("genmst", cols=["glm_acno",
"glm_desc"], where=whr, order="glm_acno")
for acc in accs:
self.data.append((seq, rtp, "", "", acc[0], acc[1]))
elif rtp == "G":
grp = rec[rpc.index("glr_group")]
if not pgp or grp != pgp:
self.data.append((seq, rtp, grp, "", "", des))
pgp = grp
elif rtp == "T":
tot = rec[rpc.index("glr_total")]
self.data.append((seq, rtp, "", tot, "", des))
elif rtp == "S":
self.data.append((seq, rtp, "", "", "", des))
elif rtp == "U":
utp = rec[rpc.index("glr_uline")]
if utp == "B":
des = ""
elif utp == "S":
des = "-" * 30
else:
des = "=" * 30
self.data.append((seq, rtp, "", "", "", des))
else:
continue
lsq = num
self.pprt = False
self.sc = SelectChoice(self.opts["mf"].window, self.titl, self.cols,
self.data, sort=False, butt=(("Print", self.doPrePrt),))
if self.pprt:
cols = []
for col in self.cols:
cols.append([col[0], col[3], col[2], col[1], "y"])
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, "hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__,
tables=self.data, heads=[self.titl], cols=cols, ttype="D",
prtdia=(("Y","V"),("Y","N")))
self.df.setWidget(self.df.mstFrame, "show")
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 1, 1)
elif self.sc.selection:
self.df.doKeyPressed("T", 1, 0, self.sc.selection[1])
self.df.doKeyPressed("T", 1, 1, self.sc.selection[2])
else:
self.df.focusField("T", 1, 1)
def doPrePrt(self):
self.pprt = True
def doPrint(self):
table = ["genrpt"]
heads = ["General Ledger Report %s Layout" % self.repno]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, "hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=table,
heads=heads, where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno)], order="glr_seq asc",
prtdia=(("Y","V"), ("Y","N")))
self.df.setWidget(self.df.mstFrame, "show")
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSeqNum(self, frt, pag, r, c, p, i, w):
if not w:
acc = self.sql.getRec("genrpt", cols=["max(glr_seq)"],
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno)], limit=1)
if not acc:
w = 1
else:
w = int(acc[0] + 1)
self.df.loadEntry(frt, pag, i, data=w)
self.seqno = w
self.seq = self.doReadRep(self.selcoy, self.repno, self.seqno)
if not self.seq:
self.newseq = "y"
else:
self.newseq = "n"
self.df.loadEntry(frt, pag, p+1, data=self.seq[3])
def doSeqType(self, frt, pag, r, c, p, i, w):
self.stype = w
if self.newseq == "y":
return
if self.stype == self.seq[3]:
return
yn = askQuestion(self.opts["mf"].body, "Change Type?",
"Change the Type?", default="no")
if yn == "no":
return "No Change"
self.newseq = "c"
def doDelSeq(self):
if self.newseq == "y":
showError(self.opts["mf"].body, "Invalid Delete Request",
"You can only delete Existing report lines.")
return
self.sql.delRec("genrpt", where=[("glr_cono", "=", self.selcoy),
("glr_repno", "=", self.repno), ("glr_seq", "=", self.seqno)])
self.df.clearFrame("T", 1)
self.df.focusField("T", 1, 1)
return "nf"
def doT1End(self):
for x in range(2, 10):
self.df.clearFrame("T", x)
pag = self.pags.index(self.stype)
if self.newseq == "n":
cl = self.genrpt_cl
fld = self.doLoadTypes()
for x, f in enumerate(fld):
data = self.seq[cl.index(f)]
self.df.loadEntry("T", pag, x, data=data)
self.df.selPage(self.df.tags[pag - 1][0])
def doAcno(self, frt, pag, r, c, p, i, w):
if w:
if pag == 3 and p == 1 and w < self.df.t_work[pag][0][0]:
return "To Account Less Than From Account"
if pag == 4 and p == 3 and w < self.df.t_work[pag][0][2]:
return "To Account Less Than From Account"
found = False
for acc in self.glm["data"]:
if w == acc[0]:
found = True
if not found:
return "Invalid Account Number"
def doStore(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p+1, data=0)
self.df.loadEntry(frt, pag, p+2, data="")
return "sk2"
def doGrpNum(self, frt, pag, r, c, p, i, w):
if not w:
gno = self.sql.getRec("genrpt", cols=["max(glr_group)"],
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno), ("glr_type", "=", "G")], limit=1)
self.gno = gno[0] + 1
self.df.loadEntry(frt, pag, p, data=self.gno)
else:
self.gno = w
col = ["glr_desc", "glr_high", "glr_obal", "glr_accum",
"glr_print", "glr_norm", "glr_acbal", "glr_ignore",
"glr_store", "glr_snum1", "glr_acstr", "glr_label"]
grp = ""
for cc in col:
grp = "%s%s," % (grp, cc)
grp = grp[:-1]
self.grp = self.sql.getRec("genrpt", cols=col,
where=[("glr_cono", "=", self.selcoy), ("glr_repno", "=",
self.repno), ("glr_group", "=", self.gno)], group=grp)
if self.grp:
for n, f in enumerate(col):
data = self.grp[0][n]
self.df.loadEntry("T", pag, self.group.index(f), data=data)
def doPAS(self, frt, pag, r, c, p, i, w):
self.pas = w
if self.pas == "P":
self.df.loadEntry(frt, pag, p+1, data="*")
return "sk1"
def doStore1(self, frt, pag, r, c, p, i, w):
if self.pas == "S":
self.df.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doAmount(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doT2End(self):
ff = self.doLoadTypes()
data = [self.selcoy, self.repno, self.seqno, self.stype]
for nm, cl in enumerate(self.genrpt_cl):
if nm < 4:
continue
if cl in ff:
data.append(self.df.t_work[self.pags.index(self.stype)]
[0][ff.index(cl)])
elif self.genrpt_fd[cl][2][1] in ("A", "a"):
data.append("")
else:
data.append(0)
data.append("")
if self.newseq in ("c", "n"):
self.doDelSeq()
self.sql.insRec("genrpt", data=data)
if self.stype == "G" and self.grp:
grp = self.sql.getRec("genrpt", where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno), ("glr_group",
"=", self.gno)], order="glr_seq")
for g in grp:
if g[2] == self.seqno:
continue
data[2] = g[2]
data[8] = g[8]
data[9] = g[9]
data[29] = g[29]
self.sql.updRec("genrpt", data=data, where=[("glr_cono", "=",
self.selcoy), ("glr_repno", "=", self.repno), ("glr_group",
"=", self.gno), ("glr_seq", "=", g[2])])
self.doT2Exit()
if self.newseq == "y":
self.df.loadEntry("T", 1, 0, data=(self.seqno + 1))
else:
self.df.clearEntry("T", 1, 1)
self.df.clearEntry("T", 1, 2)
self.df.focusField("T", 1, 1)
def doLoadTypes(self):
if self.stype == "H":
fld = self.head
elif self.stype == "L":
fld = self.ledger
elif self.stype == "G":
fld = self.group
elif self.stype == "S":
fld = self.store
elif self.stype == "T":
fld = self.total
elif self.stype == "U":
fld = self.uline
elif self.stype == "C":
fld = self.calc
elif self.stype == "P":
fld = self.percent
return fld
def doT0Exit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doT1Exit(self):
# Check for duplicate group numbers
errmess = """Group Number %s at Sequence Line %s is Duplicated or is Not Contiguous i.e. All Group Lines Must Follow One Another!
Please Delete, or Correct This Line!"""
seq = self.sql.getRec("genrpt", cols=["glr_type", "glr_seq",
"glr_group"], where=[("glr_cono", "=", self.selcoy), ("glr_repno",
"=", self.repno)], order="glr_seq")
gp = []
lg = 0
for t, s, g in seq:
if t == "G":
if not lg and g in gp:
showError(
self.opts["mf"].body, "Group Error", errmess % (g, s))
self.df.loadEntry("T", 1, 0, data=s)
self.df.focusField("T", 1, 1)
return
if lg and lg != g:
if g in gp:
showError(self.opts["mf"].body, "Group Error",
errmess % (g, s))
self.df.loadEntry("T", 1, 0, data=s)
self.df.focusField("T", 1, 1)
return
lg = g
gp.append(g)
continue
if not lg:
lg = g
gp.append(g)
continue
else:
lg = 0
self.opts["mf"].dbm.commitDbase(ask=True, mess="Save All Changes?")
self.df.focusField("T", 0, 1)
def doT2Exit(self):
self.df.selPage("Sequence")
def doReadRep(self, coy, rep, seq):
rep = self.sql.getRec("genrpt", where=[("glr_cono", "=", coy),
("glr_repno", "=", rep), ("glr_seq", "=", seq)], limit=1)
return rep
class 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 wg4010(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,
["wagmst", "wagedc", "wagcod", "wagbal", "wagtf1", "wagtf2"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = "%i/%02i/%02i" % (t[0], t[1], t[2])
if t[1] < 3:
self.taxyr = t[0]
else:
self.taxyr = t[0] + 1
self.startb = self.startt = (((self.taxyr - 1) * 10000) + 301)
if not self.taxyr % 4:
self.endb = self.endt = ((self.taxyr * 10000) + 229)
else:
self.endb = self.endt = ((self.taxyr * 10000) + 228)
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Salaries/Wages Interrogation (%s)" %
self.__class__.__name__)
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols":
(("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0, "Surname"),
("wgm_fname", "", 0, "Names")),
"where": [("wgm_cono", "=", self.opts["conum"])]
}
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"))
tag = (("General", self.doTagSelect, ("T", 0, 2), ("T", 0, 1)),
("Tax", self.doTagSelect, ("T", 0, 2), ("T", 0, 1)),
("Bank", self.doTagSelect, ("T", 0, 2),
("T", 0, 1)), ("Earnings", self.doTagSelect, ("T", 0, 2),
("T", 0, 1)), ("Deductions", self.doTagSelect,
("T", 0, 2), ("T", 0, 1)),
("Balances", self.doTagSelect, ("T", 0, 2),
("T", 0, 1)), ("Progs", self.doTaxYear, ("T", 0, 2),
("T", 0, 1)), ("Trans", self.doTaxYear,
("T", 0, 2), ("T", 0, 1)))
fld = ((("T", 0, 0, 0), "IUI", 5, "Emp-Num", "Employee Number", "",
"Y", self.doEmpno, wgm, None,
("notzero", )), (("T", 0, 0, 0), "OUI", 1, "Department"),
(("T", 0, 0, 0), "OUI", 1,
"Class"), (("T", 1, 0, 0), "ONA", 30,
"Surname"), (("T", 1, 1, 0), "ONA", 30, "Names"),
(("T", 1, 2, 0), "OD1", 10,
"Date of Birth"), (("T", 1, 3, 0), "ONA", 13, "ID Number"),
(("T", 1, 4, 0), "ONA", 16,
"Spouse Name"), (("T", 1, 5, 0), "ONA", 13,
"Spouse ID Number"), (("T", 1, 6, 0), "ONA",
30, "Address Line 1"),
(("T", 1, 7, 0), "ONA", 30, "Address Line 2"),
(("T", 1, 8, 0), "ONA", 30,
"Address Line 3"), (("T", 1, 9, 0), "ONA", 4,
"Postal Code"), (("T", 1, 10, 0), "ONA",
16, "Telephone Number"),
(("T", 1, 11, 0), "OTX", 50,
"E-Mail Address"), (("T", 1, 12, 0), "OD1", 10, "Start Date"),
(("T", 1, 13, 0), "Od1", 10,
"Term Date"), (("T", 1, 14, 0), "OUD", 13.2, "Salary"),
(("T", 1, 15, 0), ("ORB", r1s), 1,
"Pay Freq"), (("T", 1, 16, 0), ("ORB", r2s), 1,
"Pay Type"), (("T", 2, 0, 0), ("ORB", r3s), 1,
"P.A.Y.E."),
(("T", 2, 1, 0), "ONA", 16,
"Tax Office"), (("T", 2, 2, 0), "ONA", 10,
"Tax Number"), (("T", 2, 3, 0), "OUA", 1,
"Nature of Employee"),
(("T", 2, 4, 0), "OUI", 9,
"Reg Number"), (("T", 2, 5, 0), "OUA", 1,
"Voluntary Excess"), (("T", 2, 6, 0), "OUD",
6.2, "Fixed Rate"),
(("T", 2, 7, 0), "ONA", 13,
"Directive"), (("T", 3, 0, 0), ("ORB", r4s), 0,
"Account Type"), (("T", 3, 1, 0), "ONA", 30,
"Bank Name"),
(("T", 3, 2, 0), "OUI", 8,
"Branch Code"), (("T", 3, 3, 0), "ONA", 16,
"Account Number"), (("T", 3, 4, 0), "ONA", 30,
"Holder's Name"),
(("T", 3, 5, 0), "OUI", 1,
"Holder's Relationship"), (("C", 4, 0, 0), "OUI", 3,
"Cod"), (("C", 4, 0, 1), "ONA", 30,
"Description"),
(("C", 4, 0, 2), "OSD", 13.2,
"Amnt/Rate"), (("C", 5, 0, 0), "OUI", 3,
"Cod"), (("C", 5, 0, 1), "ONA", 30,
"Description"), (("C", 5, 0, 2), "OSD",
13.2, "Employee"),
(("C", 5, 0, 3), "OSD", 13.2,
"Employer"), (("T", 6, 0, 0), "OSD", 13.2,
"Balance-1"), (("T", 6, 1, 0), "OSD", 13.2,
"Balance-2"), (("T", 6, 2,
0), "OSD", 13.2,
"Balance-3"),
(("T", 7, 0, 0), "IUI", 4, "Tax Year", "Tax Year", self.taxyr,
"N", self.doBals, None, None,
None), (("C", 7, 0, 0), "OUA", 1,
"T"), (("C", 7, 0, 1), "OUI", 3,
"Cod"), (("C", 7, 0, 2), "ONA", 30,
"Description"), (("C", 7, 0, 3), "OSD",
13.2, "Hours"),
(("C", 7, 0, 4), "OSD", 13.2,
"Value"), (("T", 8, 0, 0), "IUI", 4, "Tax Year", "Tax Year",
self.taxyr, "N", self.doTrans, None, None, None))
tnd = (None, None, None, None, None, None, None, None, None)
txt = (self.doExit, None, None, None, None, None, None, None,
self.doExit)
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))
row = [0, 0, 0, 0, 15, 15, 0, 15, 0]
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tags=tag,
rows=row,
tend=tnd,
txit=txt,
butt=but)
def doEmpno(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("wagmst",
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", w)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.empno = w
self.sname = acc[4]
self.fname = acc[5]
acc.insert(17, acc.pop()) # Termination Date
self.df.loadEntry("T", 0, 1, data=acc[2]) # Department
self.df.loadEntry("T", 0, 2, data=acc[3]) # Class
d = 4
for pg in range(1, 4):
for x in range(0, self.df.topq[pg]):
self.df.loadEntry("T", pg, x, data=acc[d])
d = d + 1
self.loadDetail()
self.opts["mf"].updateStatus("")
def loadDetail(self):
ear = self.sql.getRec(
tables=["wagcod", "wagedc"],
cols=["wcd_type", "wcd_code", "ced_desc", "wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno), ("wcd_type", "=", "E"),
("ced_cono=wcd_cono", ), ("ced_type=wcd_type", ),
("ced_code=wcd_code", )],
order="wcd_code")
p = 0
for e in ear:
for y in range(1, 4):
self.df.loadEntry("C", 4, p, data=e[y])
p += 1
ded = self.sql.getRec(
tables=["wagcod", "wagedc"],
cols=["wcd_type", "wcd_code", "ced_desc", "wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno), ("wcd_type", "=", "D"),
("ced_cono=wcd_cono", ), ("ced_type=wcd_type", ),
("ced_code=wcd_code", )],
order="wcd_code")
p = 0
for d in ded:
for y in range(1, 5):
self.df.loadEntry("C", 5, p, data=d[y])
p += 1
bal = self.sql.getRec("wagbal",
where=[("wbl_cono", "=", self.opts["conum"]),
("wbl_empno", "=", self.empno)])
if bal:
for b in bal:
self.df.loadEntry("T", 6, (b[2] - 1), data=b[3])
def doTagSelect(self):
self.opts["mf"].updateStatus("")
def doBals(self, frt, pag, r, c, p, i, w):
self.startb = (((w - 1) * 10000) + 301)
if not w % 4:
self.endb = ((w * 10000) + 229)
else:
self.endb = ((w * 10000) + 228)
wt2 = self.sql.getRec("wagtf2",
cols=[
"wt2_type", "wt2_code",
"round(sum(wt2_hrs),2)",
"round(sum(wt2_eamt),2)"
],
where=[("wt2_cono", "=", self.opts["conum"]),
("wt2_empno", "=", self.empno),
("wt2_date", "between", self.startb,
self.endb)],
group="wt2_type, wt2_code",
order="wt2_type desc, wt2_code")
if wt2:
for num, line in enumerate(wt2):
typ = CCD(line[0], "UA", 1.0)
cod = CCD(line[1], "UI", 3.0)
det = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=",
self.opts["conum"]),
("ced_type", "=", typ.work),
("ced_code", "=", cod.work)],
limit=1)
if not det:
des = "Unknown"
else:
des = det[0]
self.df.loadEntry("C", pag, (num * 5), data=typ.work)
self.df.loadEntry("C", pag, (num * 5) + 1, data=cod.work)
self.df.loadEntry("C", pag, (num * 5) + 2, data=des)
if line[2]:
self.df.loadEntry("C", pag, (num * 5) + 3, data=line[2])
self.df.loadEntry("C", pag, (num * 5) + 4, data=line[3])
def doTrans(self, frt, pag, r, c, p, i, w):
self.startt = (((w - 1) * 10000) + 301)
if not w % 4:
self.endt = ((w * 10000) + 229)
else:
self.endt = ((w * 10000) + 228)
tit = "Transactions for Employee: %s - %s %s" % \
(self.empno, self.fname, self.sname)
tab = ["wagtf1"]
wcp = (("wt1_date", "", 0, "Date"), ("wt1_page", "", 0, "Number"),
("wt1_nhrs", "", 13.2, "Norm-Hrs"), ("wt1_npay", "", 13.2,
"Norm-Pay"),
("wt1_taxbl", "", 13.2, "Tx-Pay"), ("wt1_notax", "", 13.2,
"Non-Tx-Pay"),
("wt1_taxdd", "", 13.2, "Tx-Ded"), ("wt1_nondd", "", 13.2,
"Non-Tx-Ded"))
whr = [("wt1_cono", "=", self.opts["conum"]),
("wt1_empno", "=", self.empno),
("wt1_date", "between", self.startt, self.endt)]
odr = "wt1_date"
state = self.df.disableButtonsTags()
SRec(self.opts["mf"],
screen=self.df.nb.Page7,
title=tit,
tables=tab,
cols=wcp,
where=whr,
order=odr)
self.df.enableButtonsTags(state=state)
self.doTaxYear()
def doTaxYear(self):
if self.df.pag == 7:
self.df.clearFrame("C", 7)
self.df.focusField("T", 7, 1)
else:
self.df.focusField("T", 8, 1)
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"], "WAG", self.empno)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doClear(self):
self.df.selPage("General")
self.df.focusField("T", 0, 1)
def doPrint(self):
mess = "Select the Required Print Option."
butt = (("Information", "I"), ("Transactions", "T"), ("Both", "B"),
("None", "N"))
self.doPrintOption(
askChoice(self.opts["mf"].body, "Print Options", mess, butt=butt))
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrintOption(self, opt):
if opt == "N":
return
self.head = "%03u %-110s" % (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":
self.wagtrn = self.doGetTrans()
if not self.wagtrn:
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":
self.wagtrn = self.doGetTrans()
if self.wagtrn:
self.pageHeading()
self.pageHeadingTrans()
self.printTrans()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=["N", "V", "view"])
def printInfo(self):
self.fpdf.drawText("%15s %-25s %s" % \
("", self.df.topf[0][0][3], self.df.t_disp[0][0][0]))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
# General Screen
for x in range(0, len(self.df.topf[1])):
self.fpdf.drawText("%15s %-25s %s" % \
("", self.df.topf[1][x][3], self.df.t_disp[1][0][x]))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
# Tax Screen
for x in range(0, len(self.df.topf[2])):
self.fpdf.drawText("%15s %-25s %s" % \
("", self.df.topf[2][x][3], self.df.t_disp[2][0][x]))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
# Bank Details Screen
if self.df.t_work[1][0][15] == "E":
for x in range(0, len(self.df.topf[3])):
self.fpdf.drawText("%15s %-25s %s" % \
("", self.df.topf[3][x][3], self.df.t_disp[3][0][x]))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
# Balances Screen
self.pglin += 1
for x in range(0, len(self.df.topf[6])):
self.fpdf.drawText("%15s %-25s %s" % \
("", self.df.topf[6][x][3], self.df.t_disp[6][0][x]))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
# Earnings and Deductions Screen
self.fpdf.drawText("%15s %29s" % ("", "Earnings and Deductions Codes"))
self.pglin += 1
self.fpdf.drawText("%15s %29s" % ("", self.fpdf.suc * 29))
self.pglin += 1
self.fpdf.drawText("%15s %-3s %-1s %-30s %12s %12s " % \
("", "Cod", "T", "Description", "Employee", "Employer"))
self.pglin += 1
self.fpdf.drawText("%15s %s" % ("", self.fpdf.suc * 63))
self.pglin += 1
for x in range(0, len(self.df.colf[4])):
if self.df.c_work[4][x][0] not in ("", 0):
self.fpdf.drawText("%15s %s %s %s %12s" % \
("", self.df.c_disp[4][x][0], "E",
self.df.c_disp[4][x][1], self.df.c_disp[4][x][2]))
self.pglin += 1
for x in range(0, len(self.df.colf[5])):
if self.df.c_work[5][x][0] not in ("", 0):
self.fpdf.drawText("%15s %s %s %s %12s %12s" % \
("", self.df.c_disp[5][x][0], "D",
self.df.c_disp[5][x][1], self.df.c_disp[5][x][2],
self.df.c_disp[5][x][3]))
self.pglin += 1
# Progressive Balances Screen
if self.startb is None or self.endb is None:
pass
else:
self.fpdf.drawText()
self.pglin += 1
s = CCD(self.startb, "D1", 10.0)
e = CCD(self.endb, "D1", 10.0)
self.fpdf.drawText("%15s %-25s %10s %2s %10s" % \
("", "Progressive Balances from", s.disp, "to", e.disp))
self.pglin += 1
self.fpdf.drawText("%15s %s" % ("", self.fpdf.suc * 50))
self.pglin += 1
self.fpdf.drawText("%15s %-3s %-1s %-30s %12s %12s " % \
("", "Cod", "T", "Description", "Hours", "Value"))
self.pglin += 1
self.fpdf.drawText("%15s %s" % ("", self.fpdf.suc * 63))
self.pglin += 1
for x in range(0, len(self.df.colf[7])):
if self.df.c_work[7][x][0]:
if self.df.c_work[7][x][3]:
hr = self.df.c_disp[7][x][3]
else:
hr = " "
self.fpdf.drawText(
"%15s %s %s %s %12s %12s" %
("", self.df.c_disp[7][x][0], self.df.c_disp[7][x][1],
self.df.c_disp[7][x][2], hr, self.df.c_disp[7][x][4]))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
def doGetTrans(self):
if self.startt is None or self.endt is None:
return
wagtrn = self.sql.getRec("wagtf1",
cols=[
"wt1_date", "wt1_page", "wt1_nhrs",
"wt1_npay", "wt1_taxbl", "wt1_notax",
"wt1_taxdd, wt1_nondd"
],
where=[("wt1_cono", "=", self.opts["conum"]),
("wt1_empno", "=", self.empno),
("wt1_date", "between", self.startt,
self.endt)],
order="wt1_date")
return wagtrn
def printTrans(self):
for x in range(0, len(self.wagtrn)):
date = CCD(self.wagtrn[x][0], "D1", 10)
page = CCD(self.wagtrn[x][1], "UI", 5)
nhrs = CCD(self.wagtrn[x][2], "SD", 13.2)
npay = CCD(self.wagtrn[x][3], "SD", 13.2)
taxbl = CCD(self.wagtrn[x][4], "SD", 13.2)
notax = CCD(self.wagtrn[x][5], "SD", 13.2)
taxdd = CCD(self.wagtrn[x][6], "SD", 13.2)
nondd = CCD(self.wagtrn[x][7], "SD", 13.2)
if self.pglin > self.fpdf.lpp:
self.pageHeading()
self.pageHeadingTrans()
net = CCD((float(ASD(taxbl.work) + ASD(notax.work) - \
ASD(taxdd.work) - ASD(nondd.work))), "OSD", 13.2)
self.fpdf.drawText(
"%s %s %s %s %s %s %s %s %s" %
(date.disp, page.disp, nhrs.disp, npay.disp, taxbl.disp,
notax.disp, taxdd.disp, nondd.disp, net.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("%-38s %-10s" % \
("Salaries and Wages Interrogation as at", self.sysdtd))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 6
def pageHeadingTrans(self):
self.fpdf.setFont(style="B")
self.fpdf.drawText()
self.fpdf.drawText("%8s Emp-Num: %5s Surname: %s Names: %s" % \
("", self.empno, self.df.t_disp[1][0][0], self.df.t_disp[1][0][1]))
self.fpdf.drawText()
s = CCD(self.startt, "D1", 10.0)
e = CCD(self.endt, "D1", 10.0)
self.fpdf.drawText("%8s %-17s %10s %2s %10s" % \
("", "Transactions from", s.disp, "to", e.disp))
self.fpdf.drawText()
self.fpdf.drawText(
"%-10s %5s %12s %12s %12s %12s %12s %12s %12s" %
(" Date", "Page", "Norm-Hrs", "Norm-Pay", "Taxbl-Pay",
"Non-Taxbl", "Tax-D-Ded", "Non-D-Ded", "Net-Pay"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin = 10
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
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 pw1010(object):
def __init__(self, **opts):
self.opts = opts
if not CRYPT:
showError(self.opts["mf"].body, "Missing Module",
"Either the CRYPT or PARAMIKO module is Missing")
else:
self.setVariables()
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.saltchrs = "abcdefghijklmnopqrstuvwxyz"\
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"\
"0123456789./"
self.server = self.opts["mf"].rcdic["dbhost"]
self.client = None
random.seed()
def mainProcess(self):
tit = ("User Administration",)
r1s = (("Mail", "M"), ("Client", "C"))
fld = (
(("T",1,0,0),"ITX",50,"Server","",
self.server,"N",self.doServer,None,None,("notblank",)),
(("T",1,1,0),"ITX",20,"Admin Name","",
"root","N",self.doAdmNam,None,None,("notblank",)),
(("T",1,1,0),"IHA",20,"Password","",
"","N",self.doAdmPwd,None,None,("notblank",)),
(("T",2,0,0),"ITX",50,"User Name","",
"","N",self.doUsrNam,None,None,("notblank",)),
(("T",2,1,0),("IRB",r1s),0,"Type of Account","",
"M","N",self.doUsrTyp,None,None,None),
(("T",2,2,0),"IHA",20,"New Password","",
"","N",self.doNewPwd,None,None,("notblank",)),
(("T",2,3,0),"IHA",20,"Check Password","",
"","N",self.doCheckPwd,None,None,("notblank",)))
but = (
("New",None,self.doNew,0,None,None),
("Amend",None,self.doAmend,0,None,None),
("Delete",None,self.doDelete,0,None,None),
("Quit",None,self.doQuit,0,None,None))
tag = (("Server",None,None,None), ("Accounts",None,None,None))
tnd = (None, (self.doEnd,"n"), (self.doEnd,"y"))
txt = (None, self.doExit, self.doExit)
self.df = TartanDialog(self.opts["mf"], tops=True, title=tit, tags=tag,
eflds=fld, butt=but, tend=tnd, txit=txt, focus=True)
def doNew(self):
self.opt = "N"
self.df.focusField("T", 2, 1)
def doAmend(self):
self.opt = "A"
self.df.focusField("T", 2, 1)
def doDelete(self):
self.opt = "D"
self.df.focusField("T", 2, 1)
def doServer(self, frt, pag, r, c, p, i, w):
self.server = w
def doAdmNam(self, frt, pag, r, c, p, i, w):
self.admnam = w
def doAdmPwd(self, frt, pag, r, c, p, i, w):
self.admpwd = w
try:
self.client = paramiko.SSHClient()
self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.client.connect(self.server, username=self.admnam,
password=self.admpwd)
except:
showError(self.opts["mf"].body, "SSH Error",
"Cannot Open the Connection")
return "ff1"
def doUsrNam(self, frt, pag, r, c, p, i, w):
self.usrnam = w
self.usrpwd = None
for x in range(4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, state="disabled")
if self.opt == "A":
return "sk1"
if self.opt == "D":
return "nd"
def doUsrTyp(self, frt, pag, r, c, p, i, w):
self.usrtyp = w
def doNewPwd(self, frt, pag, r, c, p, i, w):
self.usrpwd = w
def doCheckPwd(self, frt, pag, r, c, p, i, w):
if w != self.usrpwd:
return "Passwords Do Not Agree"
self.usrpwd = crypt.crypt(w, random.choice(self.saltchrs) +
random.choice(self.saltchrs))
def doEnd(self):
if self.df.pag == 1:
self.df.selPage("Accounts")
for x in range(4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, state="normal")
self.opts["mf"].updateStatus("Click the Required Option Button")
self.df.setWidget(self.df.topEntry[2][0], state="disabled")
return
if self.opt == "A":
cmd = ["usermod -p %s %s" % (self.usrpwd, self.usrnam)]
elif self.opt == "D":
ask = askQuestion(self.opts["mf"].body, "Remove Directory",
"Must the User's Home Directory Also be Deleted", default="no")
if ask == "yes":
cmd = ["userdel -r %s" % self.usrnam]
else:
cmd = ["userdel %s" % self.usrnam]
elif self.opt == "N":
cmd = [
"useradd -g users -m %s -p %s" % (self.usrnam, self.usrpwd)]
if self.usrtyp == "M":
cmd.extend([
"cp -r /etc/skel/Maildir /home/%s/" % self.usrnam,
"maildirmake /home/%s/.maildir" % self.usrnam,
"chown -R %s:users /home/%s" % (self.usrnam, self.usrnam),
"chmod -R 700 /home/%s/Maildir" % self.usrnam])
err = self.executeCommand(cmd)
if err:
showError(self.opts["mf"].body, "SSH Error", err)
self.doExit()
def executeCommand(self, cmd):
err = ""
for c in cmd:
try:
chan = self.client.get_transport().open_session()
chan.get_pty()
try:
if self.admnam != "root":
chan.exec_command("sudo %s\n" % c)
if chan.recv(4096).count("password"):
chan.send("%s\n" % self.admpwd)
else:
chan.exec_command("%s\n" % c)
except:
err = "%s\n%s" % (err,
"ERROR: Failed to Run Command %s" % c)
chan.close()
except:
err = "Failed to Open a Channel to the Server"
return err
def doExit(self):
if self.df.pag == 2:
self.df.clearFrame("T", 2)
for x in range(4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, state="normal")
self.opts["mf"].updateStatus("Click the Required Option Button")
self.df.setWidget(self.df.topEntry[2][0], state="disabled")
return
self.doQuit()
def doQuit(self):
if self.client:
self.client.close()
self.df.closeProcess()
self.opts["mf"].closeLoop()
class sc2030(object):
def __init__(self, **opts):
self.opts = opts
if "test" not in opts:
self.opts["test"] = None
if self.setVariables():
if self.opts["test"]:
self.doImport()
else:
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["scpcmp", "scpmem", "scpent", "scpgme"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.pair = 0
self.doimport = False
return True
def mainProcess(self):
com = {
"stype":
"R",
"tables": ("scpcmp", ),
"cols":
(("scp_ccod", "", 0, "CCD"), ("scp_name", "", 0, "Name", "Y"),
("scp_tsiz", "", 0, "S"), ("scp_fmat", "", 0, "F"),
("scp_nsec", "", 0, "NS"), ("scp_nent", "", 0, "NE")),
"where": [("scp_cono", "=", self.opts["conum"])]
}
self.sec = {
"stype": "C",
"titl": "Available Sections",
"head": ("Sec", "Club"),
"typs": (("Ua", 3), ("NA", 30)),
"data": []
}
self.skp = {
"stype":
"R",
"tables": ("scpmem", "scpgme"),
"cols": (("a", "UI", 6, "S-Code"), ("b", "NA", 30, "Name", "Y"),
("c", "UI", 6, "O-Code"), ("d", "NA", 30, "Name"),
("e", "UI", 3, "For"), ("f", "UI", 3, "Agt")),
"where": [],
"wtype":
"D"
}
tag = (("Results", None, ("T", 0, 0), ("T", 0, 1)), )
r1s = (("Main", "M"), ("Play-Offs", "P"))
fld = ((("T", 0, 0,
0), "I@scp_ccod", 0, "", "", "", "Y", self.doCmpCod, com,
None, ("notzero", )), (("T", 0, 0, 0), "O@scp_name", 0, ""),
(("T", 0, 1,
0), ("IRB", r1s), 0, "Type", "", "", "N", self.doCmpTyp, None,
None, None), (("T", 0, 2, 0), "I@scg_rnum", 0, "Round", "", "",
"N", self.doRndNum, None, None, ("notzero", )),
(("T", 1, 0, 0), "IUI", 2, "Section Number", "", "", "N",
self.doSecNum, None, None, ("notzero", )),
(("T", 1, 0, 0), "IUA", 1, "Sub-Section", "", "", "N",
self.doSubNum, None, None, ("in", ("A", "B"))),
(("C", 1, 0, 0), "I@scg_scod", 0, "", "", 0, "N", self.doSkpCod,
self.skp, None, ("notzero", )), (("C", 1, 0, 0), "ONA", 30,
"Skp-Name"),
(("C", 1, 0, 0), "I@scg_sfor", 0, "", "", "", "N", self.doShots,
None, None, ("efld", )), (("C", 1, 0, 0), "I@scg_ocod", 0, "",
"", 0, "N", self.doSkpCod, self.skp,
None, ("notzero", )),
(("C", 1, 0, 0), "ONA", 30,
"Opp-Name"), (("C", 1, 0, 0), "I@scg_sagt", 0, "", "", "", "N",
self.doShots, None, None, ("efld", )))
tnd = ((self.doTopEnd, "y"), (self.doTopEnd, "n"))
txt = (self.doTopExit, self.doTopExit)
cnd = (None, (self.doColEnd, "n"))
cxt = (None, self.doColExit)
but = (("Import Results", None, self.doImport, 0, ("T", 1, 1),
(("T", 1, 2), ("T", 1, 0))),
("Show Entries", None, self.doShow, 0, ("C", 1, 1), ("C", 1,
2)))
self.df = TartanDialog(self.opts["mf"],
tags=tag,
eflds=fld,
rows=(0, 16),
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("scpcmp",
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", w)],
limit=1)
if not com:
return "Invalid Competition Code"
if not com[2]:
return "Competiton Draw Not Yet Done"
chk = self.sql.getRec("scpent",
cols=["count(*)"],
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", w)],
limit=1)
if not chk[0]:
return "There are No Entries for this Competition"
self.ccod = w
self.name = com[self.sql.scpcmp_col.index("scp_name")]
self.fmat = com[self.sql.scpcmp_col.index("scp_fmat")]
self.nsec = com[self.sql.scpcmp_col.index("scp_nsec")]
self.nent = com[self.sql.scpcmp_col.index("scp_nent")]
self.ssub = com[self.sql.scpcmp_col.index("scp_subs")]
self.squa = com[self.sql.scpcmp_col.index("scp_qual")]
self.clup = com[self.sql.scpcmp_col.index("scp_clup")]
self.mrnds = com[self.sql.scpcmp_col.index("scp_mrnds")]
self.prnds = com[self.sql.scpcmp_col.index("scp_prnds")]
self.state = com[self.sql.scpcmp_col.index("scp_state")]
if not self.doimport:
self.df.loadEntry(frt, pag, p + 1, data=self.name)
self.byenum = 900000
if self.state < 3:
self.ctyp = "M"
self.lrnd = self.mrnds
if not self.doimport:
self.df.loadEntry(frt, pag, p + 2, data=self.ctyp)
return "sk2"
elif self.state == 6:
return "All Results Already Captured"
else:
self.ctyp = "P"
self.lrnd = self.prnds
if not self.doimport:
self.df.loadEntry(frt, pag, p + 2, data=self.ctyp)
def doCmpTyp(self, frt, pag, r, c, p, i, w):
self.ctyp = w
chk = self.sql.getRec(
"scpgme",
cols=["count(*)", "sum(scg_sfor)", "sum(scg_sagt)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P")],
limit=1)
if self.ctyp == "M":
if chk[0] and (chk[1] or chk[2]):
return "Play-Offs Already Started"
self.lrnd = self.mrnds
elif not chk[0]:
return "Play-Offs Draw Not Yet Done"
else:
self.lrnd = self.prnds
def doRndNum(self, frt, pag, r, c, p, i, w):
if self.ctyp == "M" and self.clup == "Y" and w > 1:
more = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_rnum", "=", w - 1),
("scg_ocod", "=", 0)],
limit=1)[0]
if more:
return "Closed-Up Draw, Round %s Results Missing" % (w - 1)
if w > self.lrnd:
return "Invalid Round, Exceeds Maximum (%s)" % self.lrnd
if w > 1:
chk = self.sql.getRec("scpgme",
cols=[
"scg_scod", "scg_ocod", "sum(scg_sfor)",
"sum(scg_sagt)"
],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w - 1)])
for s in chk:
if s[0] < 900000 and s[1] < 900000 and not s[2] and not s[3]:
return "Invalid Round, Previous Round Missing"
chk = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "<", w),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("(", "scg_sfor", "=", 0, "and",
"scg_sagt", "=", 0, ")")])
if chk:
return "Previous Round Not Yet Completely Captured"
chk = self.sql.getRec("scpgme",
cols=["sum(scg_sfor)", "sum(scg_sagt)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", ">", w)],
limit=1)
if chk[0] or chk[1]:
return "Invalid Round, Later Rounds Captured"
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)])[0]
if not chk:
ok = askQuestion(self.opts["mf"].body,
"Already Entered",
"""All Results for this Round Already Captured.
Would you Like to Recapture this Round?""",
default="no")
if ok == "no":
return "Already Captured"
if self.fmat == "K" or self.ctyp == "R":
if self.ctyp == "M" and w == self.mrnds:
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "R")])
else:
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w + 1)])
self.rnum = w
self.doimport = False
def doImport(self):
self.doimport = True
if self.opts["test"]:
self.ccod, self.rnum, impfle = self.opts["test"]
err = self.doCmpCod("T", 0, 0, 0, 0, 0, self.ccod)
if err:
print(err)
return
self.doGetOldWin()
impdlg = False
else:
impfle = None
impdlg = True
self.df.setWidget(self.df.mstFrame, state="hide")
cols = [["scg_snum", 0, "UI", 2], ["scg_subs", 1, "UA", 1],
["scg_scod", 2, "UI", 6], ["scg_ocod", 3, "UI", 6],
["scg_sfor", 4, "UI", 2], ["scg_sagt", 5, "UI", 2]]
fi = FileImport(self.opts["mf"],
impcol=cols,
impfle=impfle,
impdlg=impdlg)
if fi.impdat:
if not self.opts["test"]:
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Results",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
if not self.opts["test"]:
sp.displayProgress(num)
if not line[0]:
continue
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", line[0]), ("scg_subs", "=", line[1]),
("scg_rnum", "=", self.rnum)]
if self.clup == "Y":
self.newo = True
whr.append(("scg_scod", "in", (line[2], line[3])))
else:
self.newo = False
whr.append(("scg_scod", "=", line[2]))
whr.append(("scg_ocod", "=", line[3]))
chk = self.sql.getRec("scpgme", where=whr)
if not chk:
err = "Invalid Skip %s, Opponent %s" % (line[2], line[3])
break
if line[2] > 900000 or line[3] > 900000:
pass
elif not line[4] and not line[5]:
err = "Zero Results"
break
self.snum = line[0]
self.subs = line[1]
self.scod = line[2]
self.ocod = line[3]
self.sfor = line[4]
self.sagt = line[5]
self.doColEnd()
if not self.opts["test"]:
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.ierr = False
if self.ssub == "Y":
secs = int(self.nsec / 2)
else:
secs = self.nsec
for self.snum in range(1, secs + 1):
if self.ssub == "Y":
for self.subs in ("A", "B"):
self.doColExit()
if self.ierr:
break
if self.ierr:
break
else:
self.subs = ""
self.doColExit()
if self.ierr:
break
if not self.ierr:
self.opts["mf"].dbm.commitDbase()
self.doTopExit()
if not self.opts["test"]:
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField("T", 0, 1)
def doSecNum(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", w)],
limit=1)
if not chk:
return "Invalid Section Number"
self.snum = w
if self.ssub == "N" or self.ctyp == "P":
self.subs = ""
self.df.loadEntry(frt, pag, p + 1, data=self.subs)
self.doLoadSkips()
return "sk1"
def doSubNum(self, frt, pag, r, c, p, i, w):
self.subs = w
self.doLoadSkips()
def doTopEnd(self):
if self.df.pag == 0:
if self.ctyp == "P":
self.snum = 1
self.df.loadEntry("T", 1, 0, data=self.snum)
self.subs = ""
self.df.loadEntry("T", 1, 1, data=self.subs)
self.doLoadSkips()
self.df.focusField("C", 1, 1)
else:
self.doGetOldWin()
self.df.focusField("T", 1, 1)
else:
self.df.focusField("C", 1, 1)
def doLoadSkips(self):
col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"]
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum), ("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs), ("scg_ocod", "<", 900000)]
data = []
recs = self.sql.getRec("scpgme", cols=col, where=whr)
for rec in recs:
data.append((rec[0], self.getName(rec[0]), rec[1],
self.getName(rec[1]), rec[2], rec[3]))
self.skp["where"] = data
def doTopExit(self):
if not self.opts["test"] and self.df.pag == 0:
self.df.closeProcess()
self.opts["mf"].closeLoop()
else:
# Check all entries for round
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)[0]
if chk:
txt = "Not All the Results for Round %s Captured" % self.rnum
if self.opts["test"]:
self.opts["mf"].dbm.rollbackDbase()
return
txt = "%s\n\nDo You want to Exit and Lose All Results for "\
"this Round?" % txt
ok = askQuestion(self.opts["mf"].body,
"Missing Results",
txt,
default="no")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 1, 1)
return
if self.rnum == self.lrnd:
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "M"),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)[0]
if not chk:
# Update scpcmp if no missing entries
self.sql.updRec("scpcmp",
cols=["scp_state"],
data=[3],
where=[("scp_cono", "=",
self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
self.opts["mf"].dbm.commitDbase()
if not self.doimport:
if self.ctyp == "P":
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 0, 1)
def doSkpCod(self, frt, pag, r, c, p, i, w):
skp = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", w)],
limit=1)
if not skp:
return "Invalid Skip"
if skp[self.sql.scpgme_col.index("scg_ocod")] > 900000:
return "Skip has a Bye"
if i == 3:
if w == self.scod:
return "Playing Against Himself?"
if skp[self.sql.scpgme_col.index("scg_ocod")]:
return "Already Paired"
self.ocod = w
onam = self.getName(self.ocod)
self.df.loadEntry("C", 1, p + 1, data=onam)
self.df.loadEntry("C", 1, p + 2, data=0)
return
self.scod = w
snam = self.getName(w)
self.df.loadEntry("C", 1, p + 1, data=snam)
sfor = skp[self.sql.scpgme_col.index("scg_sfor")]
self.df.loadEntry("C", 1, p + 2, data=sfor)
self.ocod = skp[self.sql.scpgme_col.index("scg_ocod")]
if self.ocod:
self.newo = False
self.df.loadEntry("C", 1, p + 3, data=self.ocod)
onam = self.getName(self.ocod)
self.df.loadEntry("C", 1, p + 4, data=onam)
ofor = skp[self.sql.scpgme_col.index("scg_sagt")]
self.df.loadEntry("C", 1, p + 5, data=ofor)
else:
self.newo = True
def getName(self, code):
if code > 900000:
return "Bye"
nam = self.sql.getRec("scpmem",
cols=["scm_surname", "scm_names"],
where=[("scm_cono", "=", self.opts["conum"]),
("scm_scod", "=", code)],
limit=1)
return "%s, %s" % (nam[0], nam[1][0])
def doShots(self, frt, pag, r, c, p, i, w):
if i == 2:
self.sfor = w
if not self.newo:
return "sk2"
else:
self.sagt = w
def doPoints(self, frt, pag, r, c, p, i, w):
pass
def doColEnd(self):
if self.fmat == "K":
if self.newo:
self.sql.delRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.ocod)])
cols = ["scg_ocod"]
data = [self.ocod]
else:
cols = []
data = []
if self.clup == "Y":
cols.extend(["scg_sfor", "scg_sagt", "scg_pair"])
self.pair += 1
data.extend([self.sfor, self.sagt, self.pair])
else:
cols.extend(["scg_sfor", "scg_sagt"])
data.extend([self.sfor, self.sagt])
self.sql.updRec("scpgme",
cols=cols,
data=data,
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.scod)])
else:
if self.sfor == self.sagt:
pfor = .5
pagt = .5
elif self.sfor > self.sagt:
pfor = 1
pagt = 0
else:
pfor = 0
pagt = 1
self.sql.updRec("scpgme",
cols=["scg_sfor", "scg_sagt", "scg_pnts"],
data=[self.sfor, self.sagt, pfor],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.scod)])
self.sql.updRec("scpgme",
cols=["scg_sfor", "scg_sagt", "scg_pnts"],
data=[self.sagt, self.sfor, pagt],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.ocod)])
self.scod = 0
if not self.doimport:
self.doLoadSkips()
self.df.advanceLine(1)
def doShow(self):
cols = (("scod", "Skip", 6, "UI",
"N"), ("sname", "Name", 30, "NA",
"N"), ("sfor", "Shots", 5, "UI", "N"), ("ocod", "Oppt",
6, "UI", "N"),
("oname", "Name", 30, "NA", "N"), ("sagt", "Shots", 5, "UI",
"N"))
recs = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum)])
done = []
data = []
for rec in recs:
scod = rec[self.sql.scpgme_col.index("scg_scod")]
ocod = rec[self.sql.scpgme_col.index("scg_ocod")]
if scod in done or scod > 900000 or ocod in done or ocod > 900000:
continue
sfor = rec[self.sql.scpgme_col.index("scg_sfor")]
sagt = rec[self.sql.scpgme_col.index("scg_sagt")]
data.append((scod, self.getName(scod), sfor, ocod,
self.getName(ocod), sagt))
SelectChoice(self.opts["mf"].window, "Results", cols, data)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doColExit(self):
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("(", "scg_sfor", "=", 0, "and",
"scg_sagt", "=", 0, ")")],
limit=1)
if chk[0] and (self.clup == "N" or self.ctyp == "P" or \
(self.clup == "Y" and self.rnum > 1)):
# All results for section not yet entered
if self.doimport:
showError(self.opts["mf"].body, "Missing Results",
"Some Results are Missing, Please Check Import "\
"File and Retry")
self.opts["mf"].dbm.rollbackDbase()
self.ierr = True
return
ok = askQuestion(self.opts["mf"].body, "Missing Results",
"Some Result are Missing. Do You want to Exit and Lose "\
"the Results for this Section?")
if ok == "no":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.opts["mf"].dbm.rollbackDbase()
else:
chk = self.doUpdateTables()
if not self.doimport:
if chk == "continue":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
if chk == "abort":
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
if not self.doimport:
self.df.clearFrame("T", 1)
self.df.clearFrame("C", 1)
if self.ctyp == "P":
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 1, 1)
def doUpdateTables(self):
nrnd = self.rnum + 1
if self.fmat == "K" and self.clup == "Y" and self.ctyp == "M":
# Closed up draw (1st and maybe 2nd Round)
skps = self.sql.getRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum)])
byes = []
nums = {}
for skp in skps:
scod = skp[self.sql.scpgme_col.index("scg_scod")]
ocod = skp[self.sql.scpgme_col.index("scg_ocod")]
if not ocod:
byes.append(scod)
nums[scod] = skp
for skp in byes:
if self.opts["test"]:
ok = "B"
else:
ok = askChoice(self.opts["mf"].body, "Capture Error",
"The Results for Skip %s - %s is Missing. Did he/she "\
"Withdraw or have a Bye?" % (skp, self.getName(skp)),
butt=(("No", "N"), ("Withdraw", "W"), ("Bye", "B"),
("Abort", "A")), default="Bye")
if ok == "N":
return "continue"
if ok == "A":
return "abort"
if ok == "W":
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_scod", "=", skp)])
byes.remove(skp)
del nums[skp]
continue
for scod in nums:
rec = nums[scod]
scod = rec[self.sql.scpgme_col.index("scg_scod")]
ocod = rec[self.sql.scpgme_col.index("scg_ocod")]
sfor = rec[self.sql.scpgme_col.index("scg_sfor")]
sagt = rec[self.sql.scpgme_col.index("scg_sagt")]
where = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs), ("scg_rnum", "=", nrnd),
("scg_scod", "=", scod)]
if scod in byes:
self.byenum += 1
# Create bye
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[self.byenum],
where=where)
if nrnd < self.lrnd:
# Create next round record
rec[self.sql.scpgme_col.index("scg_rnum")] = nrnd
rec[self.sql.scpgme_col.index("scg_ocod")] = 0
rec[self.sql.scpgme_col.index("scg_sfor")] = 0
rec[self.sql.scpgme_col.index("scg_sagt")] = 0
rec[self.sql.scpgme_col.index("scg_seed")] = 0
rec[self.sql.scpgme_col.index("scg_pair")] = 0
if scod not in byes and sfor < sagt and ocod:
scod = ocod
rec[self.sql.scpgme_col.index("scg_scod")] = scod
chk = self.sql.getRec("scpgme", where=where, limit=1)
if not chk:
self.sql.insRec("scpgme", data=rec)
else:
self.sql.updRec("scpgme", data=rec, where=where)
else:
# Update playoff records
cod = self.snum + 700000
if sfor > sagt:
win = scod
else:
win = ocod
whr = where[:6]
whr[2] = ("scg_ctyp", "=", "P")
whr[3] = ("scg_snum", "=", 1)
whr[5] = ("scg_rnum", "=", 1)
whr.append(("scg_scod", "=", cod))
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win],
where=whr)
whr[6] = ("scg_ocod", "=", cod)
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win],
where=whr)
if (self.fmat == "K" and self.clup == "N") or self.ctyp == "P":
recs = self.sql.getRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_rnum", "=", self.rnum)],
order="scg_group, scg_pair")
group = 0
for num in range(0, len(recs), 2):
one = recs[num]
snum = one[self.sql.scpgme_col.index("scg_snum")]
subs = one[self.sql.scpgme_col.index("scg_subs")]
if group != one[self.sql.scpgme_col.index("scg_group")]:
group = one[self.sql.scpgme_col.index("scg_group")]
pair = 1
else:
pair += 1
cod1 = one[self.sql.scpgme_col.index("scg_scod")]
opp1 = one[self.sql.scpgme_col.index("scg_ocod")]
for1 = one[self.sql.scpgme_col.index("scg_sfor")]
agt1 = one[self.sql.scpgme_col.index("scg_sagt")]
if opp1 > 900000 or for1 > agt1:
win1 = cod1
else:
win1 = opp1
if len(recs[num:]) > 1:
two = recs[num + 1]
cod2 = two[self.sql.scpgme_col.index("scg_scod")]
opp2 = two[self.sql.scpgme_col.index("scg_ocod")]
for2 = two[self.sql.scpgme_col.index("scg_sfor")]
agt2 = two[self.sql.scpgme_col.index("scg_sagt")]
if opp2 > 900000 or for2 > agt2:
win2 = cod2
else:
win2 = opp2
else:
win2 = 0
# Create next round record
sgc = self.sql.scpgme_col
whr = [("scg_cono", "=", one[sgc.index("scg_cono")]),
("scg_ccod", "=", one[sgc.index("scg_ccod")]),
("scg_ctyp", "=", one[sgc.index("scg_ctyp")]),
("scg_snum", "=", one[sgc.index("scg_snum")]),
("scg_subs", "=", one[sgc.index("scg_subs")]),
("scg_rnum", "=", nrnd),
("scg_ktyp", "=", one[sgc.index("scg_ktyp")]),
("scg_scod", "=", win1)]
one[sgc.index("scg_rnum")] = nrnd
one[sgc.index("scg_scod")] = win1
one[sgc.index("scg_ocod")] = win2
one[sgc.index("scg_sfor")] = 0
one[sgc.index("scg_sagt")] = 0
one[sgc.index("scg_pnts")] = 0
one[sgc.index("scg_pair")] = pair
if not self.sql.getRec("scpgme", where=whr, limit=1):
self.sql.insRec("scpgme", data=one)
else:
self.sql.updRec("scpgme",
cols=["scg_ocod", "scg_pair"],
data=[win2, pair],
where=whr)
if self.rnum == self.lrnd and \
self.ctyp == "M" and self.nsec > 2:
# Create playoff records with winners codes
if not self.oldwin:
if subs == "B":
key = snum + 800000
else:
key = snum + 700000
else:
key = self.oldwin[snum]
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win1],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_scod", "=", key)])
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win1],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_ocod", "=", key)])
elif self.squa == "S" and self.rnum == self.lrnd:
# Update playoff records with winners codes
if self.ssub == "Y":
lsub = "B"
else:
lsub = ""
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs)]
if self.fmat == "K":
col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"]
whr.append(("scg_rnum", "=", self.lrnd))
rec = self.sql.getRec("scpgme", cols=col, where=whr, limit=1)
if rec[2] > rec[3]:
win = rec[0]
else:
win = rec[1]
else:
self.doGetNewWin(sect=self.snum, sub=self.subs)
win = self.newwin[self.snum]
if not self.oldwin:
if self.subs == "B":
key = self.snum + 800000
else:
key = self.snum + 700000
else:
key = self.oldwin[self.snum]
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_scod", "=", key)])
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_ocod", "=", key)])
if self.snum == self.nsec and self.subs == lsub:
self.sql.updRec("scpgme",
cols=["scg_ktyp"],
data=["M"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P")])
# Check if all results for the round are captured
chek = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)
if chek[0]:
return
if self.clup == "Y" and self.ctyp == "M" and nrnd == self.lrnd:
state = 3
elif self.rnum == self.lrnd:
if self.ctyp == "M":
state = 3
else:
state = 6
elif self.ctyp == "M":
state = 2
else:
state = 5
self.sql.updRec("scpcmp",
cols=["scp_state"],
data=[state],
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
def doGetOldWin(self):
self.oldwin = {}
if self.ctyp == "M" and self.rnum == self.lrnd:
recs = self.sql.getRec("scpgme",
cols=["scg_scod", "scg_ocod"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_snum", "=", 1)])
for rec in recs:
for cod in rec:
if cod < 900000:
sec = self.sql.getRec("scpgme",
cols=["scg_snum"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=",
self.ccod),
("scg_ctyp", "=", "M"),
("scg_scod", "=", cod)],
limit=1)
if sec:
self.oldwin[sec[0]] = cod
def doGetNewWin(self, sect=None, sub=""):
# Get Leaders
self.newwin = {}
if sect is None:
secs = []
for x in range(self.nsec):
secs.append(x + 1)
else:
secs = [sect]
for sec in secs:
col = [
"scg_scod", "sum(scg_pnts) as a",
"sum(scg_sfor - scg_sagt) as b",
"round(sum(scg_sfor) / sum(scg_sagt), 2) as c"
]
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "M"),
("scg_snum", "=", sec), ("scg_subs", "=", sub)]
grp = "scg_scod"
odr = "a desc, b desc, c desc"
rec = self.sql.getRec("scpgme",
cols=col,
where=whr,
group=grp,
order=odr,
limit=1)
self.newwin[sec] = rec[0]
class sc2010(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, [
"scpcmp", "scpmem", "scpclb", "scpsec", "scprnd", "scpent",
"scpgme"
],
prog=self.__class__.__name__)
if self.sql.error:
return
self.img = None
self.newent = False
return True
def mainProcess(self):
com = {
"stype":
"R",
"tables": ("scpcmp", ),
"cols":
(("scp_ccod", "", 0, "Cod"), ("scp_name", "", 0, "Name", "Y"),
("scp_tsiz", "", 0, "S"), ("scp_fmat", "", 0, "F")),
"where": [("scp_cono", "=", self.opts["conum"])]
}
fmt = {
"stype": "C",
"titl": "Select the Required Format",
"head": ("C", "Format"),
"data": [("R", "Round Robin"), ("K", "Knockout")]
}
log = {"stype": "F", "types": "fle", "ftype": (("Image", "*"), )}
sk1 = {
"stype":
"R",
"tables": ("scpmem", ),
"cols":
(("scm_scod", "", 0, "Cod"), ("scm_surname", "", 0, "Surname",
"Y"), ("scm_names", "", 0, "Names")),
"where": [("scm_cono", "=", self.opts["conum"])],
"order":
"scm_surname"
}
sk2 = {
"stype":
"R",
"tables": ("scpent", "scpmem"),
"cols":
(("scm_scod", "", 0, "Cod"), ("scm_surname", "", 0, "Surname",
"Y"), ("scm_names", "", 0, "Names")),
"where": [("scm_cono", "=", self.opts["conum"]),
("scm_scod=sce_scod", )],
"whera": [("T", "sce_ccod", 0, 0)],
"order":
"scm_surname",
"butt": [("Delete", self.doDelete, True),
("Print All", self.doPrint)]
}
r1s = (("Male", "M"), ("Female", "F"), ("Both", "B"))
r2s = (("Fours", "4"), ("Trips", "3"), ("Pairs", "2"), ("Singles",
"1"))
r3s = (("Knockout", "K"), ("Round-Robin", "R"))
fld = ((("T", 0, 0, 0), "I@scp_ccod", 0, "Code", "Competition Code",
"", "Y", self.doCmpCod, com, None, ("efld", )),
(("T", 0, 0, 0), "I@scp_name", 0, "Name", "Competition Name",
"", "N", self.doCmpNam, None, None, ("notblank", )),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Gender", "", "M", "N",
self.doCmpSex, None, None,
None), (("T", 0, 2, 0), ("IRB", r2s), 0, "Team Size", "", "4",
"N", self.doCmpSiz, None, None,
None), (("T", 0, 3, 0), ("IRB", r3s), 0, "Format", "",
"K", "N", self.doCmpTyp, fmt, None, None),
(("T", 0, 4, 0), "I@scp_logo", 0, "Logo", "Sponsor's Logo", "",
"N", self.doCmpLogo, log, None, ("fle", "blank")),
(("C", 0, 0, 0), "I@scm_scod", 0, "Skip ", "", "", "Y",
self.doSkpCod, sk1, None, ("efld", )), (("C", 0, 0, 1), "ONA",
30, "Name"),
(("C", 0, 0, 2), "I@scm_scod", 0, "Lead ", "", "", "n",
self.doSkpCod, sk1, None, ("efld", )), (("C", 0, 0, 3), "ONA",
30, "Name"))
but = (("Entered Players", sk2, None, 0, ("C", 0, 1), ("T", 0, 1)), )
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
cnd = ((self.doEnd, "n"), )
cxt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doCmpCod(self, frt, pag, r, c, p, i, w):
self.skips = []
self.parts = []
nxtcod = getNextCode(self.sql,
"scpcmp",
"scp_ccod",
where=[("scp_cono", "=", self.opts["conum"])],
last=999)
if not w or w > nxtcod:
self.ccod = nxtcod
self.df.loadEntry(frt, pag, p, data=self.ccod)
else:
self.ccod = w
self.old = self.sql.getRec("scpcmp",
where=[("scp_cono", "=",
self.opts["conum"]),
("scp_ccod", "=", self.ccod)],
limit=1)
if not self.old:
ok = askQuestion(self.opts["mf"].body,
head="New Competition",
mess="Is This a New Competition?",
default="no")
if ok == "no":
return "rf"
self.newcmp = True
else:
state = self.old[self.sql.scpcmp_col.index("scp_state")]
if state > 1:
return "This Competition Has Already Started"
if state == 1:
ok = askQuestion(self.opts["mf"].window,
"Already Drawn",
"""This Competition Has Already Been Drawn.
Do You Want to Modify and Redraw It?""",
default="no")
if ok == "no":
return "rf"
self.sql.updRec("scpcmp",
cols=["scp_state"],
data=[0],
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
self.sql.delRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod)])
self.sql.delRec("scprnd",
where=[("scr_cono", "=", self.opts["conum"]),
("scr_ccod", "=", self.ccod)])
self.sql.delRec("scpsec",
where=[("scs_cono", "=", self.opts["conum"]),
("scs_ccod", "=", self.ccod)])
self.newcmp = False
self.cmpnam = self.old[self.sql.scpcmp_col.index("scp_name")]
self.tsex = self.old[self.sql.scpcmp_col.index("scp_tsex")]
self.tsiz = self.old[self.sql.scpcmp_col.index("scp_tsiz")]
self.fmat = self.old[self.sql.scpcmp_col.index("scp_fmat")]
self.logo = self.old[self.sql.scpcmp_col.index("scp_logo")]
self.df.loadEntry(frt, pag, p + 1, data=self.cmpnam)
self.df.loadEntry(frt, pag, p + 2, data=str(self.tsex))
self.df.loadEntry(frt, pag, p + 3, data=str(self.tsiz))
self.df.loadEntry(frt, pag, p + 4, data=self.fmat)
self.df.loadEntry(frt, pag, p + 5, data=self.logo)
def doCmpNam(self, frt, pag, r, c, p, i, w):
self.cmpnam = w
def doCmpSex(self, frt, pag, r, c, p, i, w):
self.tsex = w
def doCmpSiz(self, frt, pag, r, c, p, i, w):
self.tsiz = int(w)
def doCmpTyp(self, frt, pag, r, c, p, i, w):
self.fmat = w
def doCmpLogo(self, frt, pag, r, c, p, i, w):
if w and not os.path.isfile(w):
return "Invalid Logo Path"
self.logo = w
try:
if self.img:
self.img.destroyImage()
self.img = ShowImage(self.df.topPage0,
self.logo,
wrkdir=self.opts["mf"].rcdic["wrkdir"],
msiz=100)
except:
pass
def doSkpCod(self, frt, pag, r, c, p, i, w):
if not w:
ok = askQuestion(self.opts["mf"].body,
head="New Player",
mess="Is This a New Player?",
default="yes")
if ok == "no":
return "Invalid Code"
cod = getNextCode(self.sql,
"scpmem",
"scm_scod",
where=[("scm_cono", "=", self.opts["conum"])],
last=899999)
callModule(self.opts["mf"],
self.df,
"sc1010",
coy=[self.opts["conum"], self.opts["conam"]],
args=(cod, ))
self.df.loadEntry(frt, pag, p, data=cod)
else:
cod = w
if i == 0:
if cod in self.parts:
return "Invalid Skip, Already a Partner"
self.skips.append(cod)
self.scod = cod
else:
if cod in self.skips:
return "Invalid Partner, Already a Skip"
self.parts.append(cod)
self.pcod = cod
chk = self.sql.getRec("scpmem",
cols=["scm_surname", "scm_names", "scm_gender"],
where=[("scm_cono", "=", self.opts["conum"]),
("scm_scod", "=", cod)],
limit=1)
if not chk:
return "Invalid Player Code"
if self.tsex in ("M", "F") and chk[2] != self.tsex:
return "Invalid Gender"
self.df.loadEntry(frt, pag, p + 1, data=self.getName(chk=chk))
if i == 0:
ent = self.sql.getRec("scpent",
cols=["sce_pcod"],
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", self.ccod),
("sce_scod", "=", self.scod)],
limit=1)
if ent:
self.newent = False
if ent[0]:
ptr = self.sql.getRec("scpmem",
cols=["scm_surname", "scm_names"],
where=[("scm_cono", "=",
self.opts["conum"]),
("scm_scod", "=", ent[0])],
limit=1)
self.df.loadEntry(frt, pag, p + 2, data=ent[0])
self.df.loadEntry(frt,
pag,
p + 3,
data=self.getName(chk=ptr))
else:
self.newent = True
if self.tsiz != 2:
self.pcod = 0
return "sk3"
def getName(self, scod=None, chk=None):
if scod:
chk = self.sql.getRec(
"scpmem",
cols=["scm_surname", "scm_names", "scm_gender"],
where=[("scm_cono", "=", self.opts["conum"]),
("scm_scod", "=", scod)],
limit=1)
name = "%s," % chk[0]
init = chk[1].split()
for i in init:
name = "%s %s" % (name, i.upper())
return name
def doDelete(self, args=None):
self.scod = args[1]
self.sql.delRec("scpent",
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", self.ccod),
("sce_scod", "=", self.scod)])
self.sql.delRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_scod", "=", self.scod)])
self.loadButton()
self.doLoadEntries()
def doEnd(self):
if self.df.frt == "T":
data = [self.opts["conum"]] + self.df.t_work[0][0] + \
[0,0,"","","",0,0,""]
if self.newcmp:
self.sql.insRec("scpcmp", data=data)
elif data != self.old[:len(data)]:
col = self.sql.scpcmp_col
data.append(self.old[col.index("scp_xflag")])
self.sql.updRec("scpcmp",
data=data,
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
self.loadButton()
if self.newcmp:
self.df.focusField("C", 0, 1)
else:
self.doLoadEntries()
else:
if self.newent:
self.sql.insRec(
"scpent",
data=[self.opts["conum"], self.ccod, self.scod, self.pcod])
self.df.advanceLine(0)
else:
self.sql.updRec("scpent",
cols=["sce_scod", "sce_pcod"],
data=[self.scod, self.pcod],
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", self.ccod),
("sce_scod", "=", self.scod)])
self.doLoadEntries()
self.loadButton()
def doLoadEntries(self):
self.skips = []
ents = self.sql.getRec("scpent",
cols=["sce_scod", "sce_pcod"],
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", self.ccod)])
self.df.clearFrame("C", 0)
self.df.focusField("C", 0, 1)
for num, ent in enumerate(ents):
self.skips.append(ent[0])
self.df.loadEntry("C", 0, self.df.pos, data=ent[0])
self.df.loadEntry("C",
0,
self.df.pos + 1,
data=self.getName(ent[0]))
if ent[1]:
self.parts.append(ent[1])
self.df.loadEntry("C", 0, self.df.pos + 2, data=ent[1])
self.df.loadEntry("C",
0,
self.df.pos + 3,
data=self.getName(ent[1]))
self.df.advanceLine(0)
def loadButton(self):
rec = self.sql.getRec("scpent",
cols=["count(*)"],
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", self.ccod)],
limit=1)
self.df.B0.setLabel("Entered Players (%s)" % int(rec[0]), udl=0)
def doPrint(self):
self.df.setWidget(self.df.mstFrame, state="hide")
hdr = ["Skips Entered for the %s" % self.cmpnam]
tab = ["scpent", "scpmem"]
col = [
"scm_scod", "scm_surname", "scm_names", "scm_phone",
["scm_email", "TX", 30, "Email-Address"]
]
whr = [("sce_ccod", "=", self.ccod), ("scm_scod=sce_scod", )]
odr = "scm_surname"
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
heads=hdr,
tables=tab,
cols=col,
where=whr,
order=odr,
prtdia=(("Y", "V"), ("Y", "N")))
self.df.setWidget(self.df.mstFrame, state="show")
def doExit(self):
if self.df.frt == "C":
chk = self.sql.getRec("scpent",
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", self.ccod)])
if chk:
self.opts["mf"].dbm.commitDbase()
else:
self.opts["mf"].dbm.rollbackDbase()
self.df.closeProcess()
self.opts["mf"].closeLoop()
class st6030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["strmf1", "strtrn", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.curdt = int(self.sysdtw / 100)
return True
def dataHeader(self):
grp = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
self.stm = {
"stype": "R",
"tables": ("strmf1",),
"cols": (
("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [],
"whera": [["T", "st1_group", 0, 0]],
"index": 0}
fld = [
(("T",0,0,0),"INA",3,"Group","Product Group",
"","Y",self.doGroup,grp,None,("notblank",)),
(("T",0,1,0),"INA",20,"Code","Product Code",
"","N",self.doCode,self.stm,None,("notblank",)),
(("T",0,2,0),"ONA",30,"Description")]
but = (
("Generate",None,self.doGenerate,1,None,(("T",0,1),("T",0,2)),
"Mark zero items, which have been inactive, as redundant"),
("Create",None,self.doCreate,1,None,(("T",0,1),("T",0,2)),
"Mark a zero item as redundant"),
("Restore",None,self.doRestore,1,None,(("T",0,1),("T",0,2)),
"Mark a redundant item as normal"),
("Exit",None,self.exitPage,1,None,(("T",0,1),("T",0,2))))
tnd = ((self.endPage, "y"),)
txt = (self.exitPage,)
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, focus=False)
self.df.setWidget(self.df.B0, state="normal")
self.df.setWidget(self.df.B1, state="normal")
self.df.setWidget(self.df.B2, state="normal")
self.df.setWidget(self.df.B3, state="normal")
def doGenerate(self):
tit = "Generate Redundant Items"
fld = (
(("T",0,0,0),"IUI",3,"Months Inactive","",
24,"Y",self.doMonths,None,None,("efld",)),)
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.mt = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doMthEnd, "y"),), txit=(self.doMthExit,))
self.mt.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doMonths(self, frt, pag, r, c, p, i, w):
months = w
yr = int(self.curdt / 100)
mt = self.curdt % 100
for mth in range(months):
mt -= 1
if not mt:
mt = 12
yr -= 1
self.startp = (yr * 100) + mt
def doMthEnd(self):
self.mt.closeProcess()
whr = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "=", "N"),
("stt_cono=st1_cono",),
("stt_group=st1_group",),
("stt_code=st1_code",)]
accs = self.sql.getRec(tables=["strmf1", "strtrn"], cols=["st1_group",
"st1_code", "max(stt_curdt)", "sum(stt_qty)", "sum(stt_cost)"],
where=whr, order="st1_group, st1_code")
chgs = []
for acc in accs:
if acc[2] < self.startp and not acc[3] and not acc[4]:
chgs.append(acc[:2])
if not chgs:
showError(self.opts["mf"].body, "Processing Error",
"No Redundant Records")
else:
self.cnt = 0
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
p = ProgressBar(self.opts["mf"].body, mxs=len(chgs),
typ="Redundant Items")
for num, rec in enumerate(chgs):
p.displayProgress(num)
self.sql.updRec("strmf1", cols=["st1_type"], data=["X"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", rec[0]), ("st1_code", "=", rec[1])])
key = "%03i%-3s%-20s" % (self.opts["conum"], rec[0], rec[1])
self.sql.insRec("chglog", data=["strmf1", "U", key,
"st1_type", dte, self.opts["capnm"], "N", "X", "", 0])
p.closeProgress()
mess = """%s Items Will be Marked as Redundant.
Would you like to COMMIT these Changes?""" % len(chgs)
self.opts["mf"].dbm.commitDbase(ask=True, mess=mess)
def doMthExit(self):
self.mt.closeProcess()
def doCreate(self):
self.flag = "C"
self.stm["where"] = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")]
self.df.focusField("T", 0, 1)
def doRestore(self):
self.flag = "R"
self.stm["where"] = [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "=", "X")]
self.df.focusField("T", 0, 1)
def doGroup(self, frt, pag, r, c, p, i, w):
if self.flag == "C":
chk = self.sql.getRec("strmf1", where=[("st1_cono",
"=", self.opts["conum"]), ("st1_group", "=", w),
("st1_type", "<>", "X")], limit=1)
else:
chk = self.sql.getRec("strmf1", where=[("st1_cono",
"=", self.opts["conum"]), ("st1_group", "=", w),
("st1_type", "=", "X")], limit=1)
if not chk:
return "Invalid Group"
self.grp = w
def doCode(self, frt, pag, r, c, p, i, w):
whr = [
("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", w)]
if self.flag == "C":
err = "Invalid, Not Normal"
whr.append(("st1_type", "=", "N"))
else:
err = "Invalid, Not Redundant"
whr.append(("st1_type", "=", "X"))
chk = self.sql.getRec("strmf1", where=whr, limit=1)
if not chk:
return err
if self.flag == "C":
qty = self.sql.getRec("strtrn", cols=["sum(stt_qty)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_group", "=", self.grp), ("stt_code", "=", w)],
limit=1)
if qty[0]:
return "Balance Exists"
self.cod = w
desc = chk[self.sql.strmf1_col.index("st1_desc")]
self.df.loadEntry(frt, pag, p+1, data=desc)
def endPage(self):
if self.flag == "C":
old = "N"
new = "X"
else:
old = "X"
new = "N"
self.sql.updRec("strmf1", cols=["st1_type"], data=[new],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp), ("st1_code", "=", self.cod)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
key = "%03i%-3s%-20s" % (self.opts["conum"], self.grp, self.cod)
self.sql.insRec("chglog", data=["strmf1", "U", key,
"st1_type", dte, self.opts["capnm"], old, new, "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("T", 0)
self.flag = ""
def exitPage(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class cr6030(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, ["crsmst", "crstrn", "chglog"],
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)
return True
def dataHeader(self):
self.crm = {
"stype": "R",
"tables": ("crsmst",),
"cols": [
("crm_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")],
"where": [],
"index": 0}
fld = [
(("T",0,0,0),"INA",7,"Acc-Num","Account Number",
"","N",self.doAcno,self.crm,None,("notblank",)),
(("T",0,1,0),"ONA",30,"Name")]
but = (
("Generate",None,self.doGenerate,1,None,(("T",0,1),("T",0,2)),
"Mark zero items, which have been inactive, as redundant"),
("Create",None,self.doCreate,1,None,(("T",0,1),("T",0,2)),
"Mark a zero item as redundant"),
("Restore",None,self.doRestore,1,None,(("T",0,1),("T",0,2)),
"Mark a redundant item as normal"),
("Exit",None,self.exitPage,1,None,(("T",0,1),("T",0,2))))
tnd = ((self.endPage, "y"),)
txt = (self.exitPage,)
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, focus=False)
self.df.setWidget(self.df.B0, state="normal")
self.df.setWidget(self.df.B1, state="normal")
self.df.setWidget(self.df.B2, state="normal")
self.df.setWidget(self.df.B3, state="normal")
def doGenerate(self):
tit = "Generate Redundant Accounts"
fld = (
(("T",0,0,0),"IUI",2,"Months Inactive","",
24,"Y",self.doMonths,None,None,("efld",)),)
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.mt = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doMthEnd, "y"),), txit=(self.doMthExit,))
self.mt.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doMonths(self, frt, pag, r, c, p, i, w):
months = w
yr = int(self.curdt / 100)
mt = self.curdt % 100
for mth in range(months):
mt -= 1
if not mt:
mt = 12
yr -= 1
self.startp = (yr * 100) + mt
def doMthEnd(self):
self.mt.closeProcess()
whr = [
("crm_cono", "=", self.opts["conum"]),
("crm_stat", "=", "N")]
msts = self.sql.getRec("crsmst", cols=["crm_acno",
"crm_opened"], where=whr, order="crm_acno")
chgs = []
for mst in msts:
whr = [
("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", mst[0])]
rec = self.sql.getRec("crstrn", cols=["max(crt_curdt)",
"sum(crt_tramt)"], where=whr, limit=1)
if rec[0] and rec[0] < self.startp and not rec[1]:
chgs.append(mst[0])
elif not rec[0] and int(mst[1] / 100) < self.startp:
chgs.append(mst[0])
if not chgs:
showError(self.opts["mf"].body, "Processing Error",
"No New Redundant Accounts")
else:
self.cnt = 0
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
p = ProgressBar(self.opts["mf"].body, mxs=len(chgs),
typ="Flagging Redundant Accounts")
for num, rec in enumerate(chgs):
p.displayProgress(num)
self.sql.updRec("crsmst", cols=["crm_stat"], data=["X"],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", rec)])
key = "%03i%-7s" % (self.opts["conum"], rec)
self.sql.insRec("chglog", data=["crsmst", "U", key,
"crm_stat", dte, self.opts["capnm"], "N", "X", "", 0])
p.closeProgress()
mess = """%s Accounts Will be Flagged as Redundant.
Would you like to COMMIT these Changes?""" % len(chgs)
self.opts["mf"].dbm.commitDbase(ask=True, mess=mess, default="no")
def doMthExit(self):
self.mt.closeProcess()
def doCreate(self):
self.flag = "C"
self.crm["where"] = [
("crm_cono", "=", self.opts["conum"]),
("crm_stat", "<>", "X")]
self.df.focusField("T", 0, 1)
def doRestore(self):
self.flag = "R"
self.crm["where"] = [
("crm_cono", "=", self.opts["conum"]),
("crm_stat", "=", "X")]
self.df.focusField("T", 0, 1)
def doAcno(self, frt, pag, r, c, p, i, w):
if self.flag == "C":
typ = "<>"
else:
typ = "="
chk = self.sql.getRec("crsmst", where=[("crm_cono",
"=", self.opts["conum"]), ("crm_acno", "=", w),
("crm_stat", typ, "X")], limit=1)
if not chk:
return "Invalid Code"
if self.flag == "C":
bal = self.sql.getRec("crstrn", cols=["sum(crt_tramt)"],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", w)], limit=1)
if bal[0]:
return "Balance Exists"
self.acno = w
name = chk[self.sql.crsmst_col.index("crm_name")]
self.df.loadEntry(frt, pag, p+1, data=name)
def endPage(self):
if self.flag == "C":
old = "N"
new = "X"
else:
old = "X"
new = "N"
self.sql.updRec("crsmst", cols=["crm_stat"], data=[new],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
key = "%03i%-7s" % (self.opts["conum"], self.acno)
self.sql.insRec("chglog", data=["crsmst", "U", key, "crm_stat",
dte, self.opts["capnm"], old, new, 0])
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("T", 0)
self.flag = ""
def exitPage(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ms1040(object):
def __init__(self, **opts):
self.opts = opts
if "args" in opts:
self.code = opts["args"]
else:
self.code = None
if self.setVariables():
self.mainProcess()
if self.code:
self.df.doKeyPressed("T", 0, 0, self.code)
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlvmf", "ctlvrf", "ctlvtf",
"chglog"], prog=self.__class__.__name__)
if self.sql.error:
return
if not self.code:
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
if not ctlmst["ctm_taxno"]:
showError(self.opts["mf"].body, "Unregistered",
"The Company Record Does Not Have a V.A.T. Number")
return
return True
def mainProcess(self):
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y"),
("vtm_cat", "", 0, "C")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [("vtr_cono", "=", self.opts["conum"])],
"whera": [["T", "vtr_code", 0, 0]]}
vtt = {
"stype": "C",
"titl": "VAT Types",
"head": ("C", "Description"),
"data": [
["N", "None"],
["S", "Standard"],
["Z", "Zero Rated"],
["C", "Capital Item"],
["X", "Excluded Item"]]}
fld = (
(("T",0,0,0),"IUA",1,"V.A.T. Code","",
"","Y",self.doCode,vtm,None,("notblank",)),
(("T",0,1,0),"INA",30,"Description","",
"","N",self.doDesc,None,self.doDelete,("notblank",)),
(("T",0,2,0),"IUA",1,"Category","",
"S","N",self.doCat,vtt,None,("in", ("C","N","S","X","Z"))),
(("C",0,0,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doStart,vtr,None,("efld",)),
(("C",0,0,1),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doRate,None,None,("efld",)))
but = (
("Print",None,self.doPrint,0,("T",0,1),(("T",0,0),("T",0,2))),
("Add",None,self.doAdd,0,("T",0,0),None),
("Edit",None,self.doEdit,0,("T",0,0),None),
("Exit",None,self.doExit,0,("T",0,0),(("T",0,1),("C",0,1))))
tnd = ((self.doTEnd,"y"), )
txt = (self.doTExit, )
cnd = ((self.doCEnd,"y"), )
cxt = (self.doCExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, rows=(15,))
def doPrint(self):
hds = "V.A.T. Records"
col = [
["vtm_code", "UA", 1, "C"],
["vtm_desc", "NA", 30, "Description"],
["vtm_cat", "UA", 1, "T"],
["vtr_date", "d1", 10, "Start-Date"],
["vtr_rate", "UD", 6.2, "Rate"]]
recs = self.sql.getRec(tables=["ctlvmf", "ctlvrf"], cols=["vtm_code",
"vtm_desc", "vtm_cat", "vtr_date", "vtr_rate"], where=[("vtm_cono",
"=", self.opts["conum"]), ("vtr_cono=vtm_cono",),
("vtr_code=vtm_code",)], order="vtm_code, vtr_date")
code = None
data = copyList(recs)
for num, rec in enumerate(recs):
if rec[0] == code:
data[num][0] = ""
data[num][1] = ""
data[num][2] = ""
code = rec[0]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=data,
heads=[hds], ttype="D", cols=col, prtdia=(("Y","V"), ("Y","N")))
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 0, 1)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.oldm = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)], limit=1)
if not self.oldm:
self.newm = True
else:
self.newm = False
self.desc = self.oldm[self.sql.ctlvmf_col.index("vtm_desc")]
self.df.loadEntry(frt, pag, p+1, data=self.desc)
self.cat = self.oldm[self.sql.ctlvmf_col.index("vtm_cat")]
self.df.loadEntry(frt, pag, p+2, data=self.cat)
self.doLoadRates()
return "ff2"
def doDelete(self):
if self.df.frt == "T":
if self.doCheckTrn():
showError(self.opts["mf"].body, "Exists",
"Transactions Exist for this Code, Not Deleted")
return
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["ctlvmf", "D", "%03i%-1s" % \
(self.opts["conum"], self.code), "", dte, self.opts["capnm"],
"", "", "", 0])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doCat(self, frt, pag, r, c, p, i, w):
self.cat = w
def doTEnd(self):
self.edit = False
datm = [self.opts["conum"]]
datm.extend(self.df.t_work[0][0][:3])
if self.newm:
self.sql.insRec("ctlvmf", data=datm)
if self.cat in ("N", "X", "Z"):
newr = [self.opts["conum"], self.code, 0, 0]
self.sql.insRec("ctlvrf", data=newr)
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
else:
self.doButtons()
self.df.focusField("C", 0, 1)
elif self.cat in ("N", "X", "Z"):
self.df.focusField("T", 0, 1)
elif datm != self.oldm[:len(datm)]:
col = self.sql.ctlvmf_col
datm.append(self.oldm[col.index("vtm_xflag")])
self.sql.updRec("ctlvmf", data=datm, where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec("chglog", data=["ctlvmf",
"U", "%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datm[num]), "", 0])
self.doButtons()
self.opts["mf"].dbm.commitDbase()
def doTExit(self):
chks = ""
recs = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"])])
for rec in recs:
rte = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", rec[1])])
if not rte:
if rec[3] in ("N", "X", "Z"):
self.sql.insRec("ctlvrf", data=[rec[0], rec[1], 0, 0])
self.opts["mf"].dbm.commitDbase()
continue
chks = "%s\n%1s %-30s %1s" % (chks, rec[1], rec[2], rec[3])
if chks:
showError(self.opts["mf"].body, "Missing Rate Record", "The "\
"following VAT Codes do Not have Rate Records:\n%s\n\n"\
"You will Not be able to Exit until you either Create "\
"Rate Records or Delete these codes." % chks)
self.df.focusField("T", 0, 1)
else:
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doAdd(self):
for num, rec in enumerate(self.df.c_work[0]):
if not rec[0] and not rec[1]:
pos = (num * 2) + 1
self.df.focusField("C", 0, pos)
break
def doEdit(self):
self.edit = True
self.newr = False
tit = "Edit Rate"
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [
("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)]}
fld = (
(("T",0,0,0),"OUA",1,"V.A.T. Code"),
(("T",0,1,0),"ONA",30,"Description"),
(("T",0,2,0),"OUA",1,"Category"),
(("T",0,3,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doEStart,vtr,self.doEDelete,("efld",)),
(("T",0,4,0),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doERate,None,self.doEDelete,("notzero",)))
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.ed = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doEEnd,"n"),), txit=(self.doEExit,))
self.ed.loadEntry("T", 0, 0, data=self.code)
self.ed.loadEntry("T", 0, 1, data=self.desc)
self.ed.loadEntry("T", 0, 2, data=self.cat)
self.ed.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
if self.exit:
self.df.focusField("T", 0, 1)
else:
self.doExit()
def doEDelete(self):
self.exit = False
if self.ed.pos == 3:
if self.doCheckTrn():
return ("T", 0, 4, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
else:
if self.doCheckTrn(self.start):
return ("T", 0, 5, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
self.ed.closeProcess()
chk = self.sql.getRec("ctlvrf", cols=["count(*)"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], limit=1)
if not chk[0]:
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.exit = True
self.opts["mf"].dbm.commitDbase()
return "nf"
def doEStart(self, frt, pag, r, c, p, i, w):
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", w)], limit=1)
if not self.oldr:
return "Date Does Not Exist"
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist for Date, Editing Not Allowed.")
return "Invalid Date"
self.start = w
self.rate = self.oldr[3]
self.ed.loadEntry(frt, pag, p+1, data=self.rate)
def doERate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doEEnd(self):
self.ed.closeProcess()
self.doCEnd()
def doEExit(self):
self.ed.closeProcess()
def doStart(self, frt, pag, r, c, p, i, w):
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist On or After This Starting Date.")
return "Invalid Date"
self.start = w
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)], limit=1)
if not self.oldr:
self.newr = True
if self.cat in ("N", "X", "Z"):
if self.edit:
self.ed.loadEntry(frt, pag, p+1, data=0)
else:
self.df.loadEntry(frt, pag, p+1, data=0)
return "nd"
else:
self.newr = False
if self.edit:
self.ed.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
else:
self.df.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
def doRate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doCheckTrn(self, date=None):
where = [
("vtt_cono", "=", self.opts["conum"]),
("vtt_code", "=", self.code)]
if date:
where.append(("vtt_refdt", ">=", date))
return self.sql.getRec("ctlvtf", cols=["count(*)"],
where=where, limit=1)[0]
def doCEnd(self):
datr = [self.opts["conum"], self.code, self.start, self.rate]
if self.newr:
self.sql.insRec("ctlvrf", data=datr)
elif datr != self.oldr[:len(datr)]:
col = self.sql.ctlvrf_col
datr.append(self.oldr[col.index("vtr_xflag")])
self.sql.updRec("ctlvrf", data=datr, where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldr):
if dat != datr[num]:
self.sql.insRec("chglog", data=["ctlvrf", "U",
"%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datr[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
self.edit = False
self.doExit()
def doCExit(self):
self.edit = False
self.doExit()
def doLoadRates(self):
self.df.clearFrame("C", 0)
recs = self.sql.getRec("ctlvrf",
cols=["vtr_date", "vtr_rate"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], order="vtr_date")
for num, rec in enumerate(recs):
pos = (num * 2)
if pos > 27:
self.df.scrollScreen(0)
pos = 26
self.df.focusField("C", 0, pos + 1)
self.df.loadEntry("C", 0, pos, data=rec[0])
self.df.focusField("C", 0, pos + 2)
self.df.loadEntry("C", 0, pos + 1, data=rec[1], zero=True)
def doButtons(self):
self.df.setWidget(self.df.B1, "normal")
self.df.setWidget(self.df.B2, "normal")
self.df.setWidget(self.df.B3, "normal")
self.opts["mf"].window.focus_set()
def doExit(self):
self.df.setWidget(self.df.B3, "disabled")
self.df.focusField("T", 0, 1)
class cs2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
cshctl = gc.getCtl("cshctl", self.opts["conum"])
if not cshctl:
return
self.glint = cshctl["ccc_glint"]
if self.glint == "Y":
tabs = ["genmst"]
else:
tabs = ["cshmst"]
tabs.extend(["cshana", "cshcnt"])
self.sql = Sql(self.opts["mf"].dbm,
tables=tabs,
prog=self.__class__.__name__)
if self.sql.error:
return
if self.glint == "Y":
self.ctl = [["csh_ctl", "Cash Control", 0]]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
for num, ctl in enumerate(self.ctl):
if ctl[0] in ctlctl:
self.ctl[num][2] = ctlctl[ctl[0]]
t = time.localtime()
self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2])
self.denoms = (("R200", 200), ("R100", 100), ("R50", 50), ("R20", 20),
("R10", 10), ("R5", 5), ("R2", 2), ("R1", 1),
("C50", .5), ("C20", .2), ("C10", .1), ("C5", .05),
("C2", .02), ("C1", .01))
return True
def mainProcess(self):
tag = (("Expenses", None, None, None, False),
("Income", None, None, None, False), ("Cash", None, None, None,
False))
dte = {
"stype": "R",
"tables": ("cshcnt", ),
"cols": (("cct_date", "", 0, "Date"), ),
"where": [("cct_cono", "=", self.opts["conum"])],
"group": "cct_date"
}
if self.glint == "Y":
self.cod = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])],
"order":
"glm_acno"
}
else:
self.cod = {
"stype":
"R",
"tables": ("cshmst", ),
"cols": (("ccm_acno", "", 0, "Acc-Num"), ("ccm_desc", "", 0,
"Description", "Y")),
"where": [("ccm_cono", "=", self.opts["conum"])],
"order":
"ccm_acno"
}
des = {
"stype":
"R",
"tables": ("cshana", ),
"cols": (("can_desc", "", 0, "Description", "Y"), ("can_vatcod",
"", 0, "V")),
"where": [("can_cono", "=", self.opts["conum"])],
"whera": (("C", "can_code", 1, 1), ),
"group":
"can_desc",
"order":
"can_desc"
}
r1s = (("Expenses", "P"), ("Income", "T"), ("Cash", "C"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Type", "", "P", "N",
self.doType, None, None, None),
(("T", 0, 1, 0), "I@cct_date", 0, "", "", self.sysdtw, "N",
self.doDate, dte, None, ("efld", )), (("T", 0, 2, 0), "OSD",
13.2, "Expenses Total"),
(("T", 0, 3, 0), "OSD", 13.2,
"Income Total"), (("T", 0, 4, 0), "OSD", 13.2, "Cash Total"),
(("C", 1, 0, 0), "I@can_trdt", 0, "", "", "", "N", None, None,
None, ("efld", )), (("C", 1, 1,
0), "I@can_code", 0, "", "", "", "N",
self.doCode, self.cod, None, None),
(("C", 1, 2, 0), "I@can_desc", 0, "", "", "", "N", self.doDesc,
des, None, ("notblank", )), (("C", 1, 3, 0), "I@can_vatcod", 0,
"", "", "N", "N", self.doVCode,
None, None, ("notblank", )),
(("C", 1, 4, 0), "I@can_incamt", 0, "", "", "", "N",
self.doIncAmt, None, None,
("efld", )), (("C", 1, 5, 0), "I@can_vatamt", 0, "", "", "",
"N", None, None, None, ("efld", )),
(("C", 2, 0, 0), "I@can_trdt", 0, "", "", "", "N", None, None,
None, ("efld", )), (("C", 2, 1, 0), "I@can_code", 0, "", "",
"", "N", self.doCode, self.cod, None,
None), (("C", 2, 2, 0), "I@can_desc", 0,
"", "", "", "N", self.doDesc, des,
None, ("notblank", )),
(("C", 2, 3, 0), "I@can_vatcod", 0, "", "", "N", "N",
self.doVCode, None, None,
("notblank", )), (("C", 2, 4, 0), "I@can_incamt", 0, "", "",
"", "N", self.doIncAmt, None, None,
("efld", )), (("C", 2, 5, 0), "I@can_vatamt",
0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 3, 0, 0), "ISD", 13.2, "Cheques", "", "", "N",
self.doCheq, None, None,
("efld", )), (("C", 3, 0, 0), "IUI", 5, "Quant", "Quantity", 0,
"N", self.doQty, None, None, None,
("Denomination",
14)), (("C", 3, 1, 0), "OSD", 13.2, "Value", "",
"", "N", None, None, None, ("efld", )))
tnd = ((self.doTopEnd, "y"), None, None, (self.doTopEnd, "n"))
txt = (self.doTopExit, None, None, None)
cnd = (None, (self.doColEnd, "y"), (self.doColEnd, "y"),
(self.doColEnd, "n"))
cxt = (None, self.doColExit, self.doColExit, self.doColExit)
but = (("Accept", None, self.doColExit, 0, (("C", 1, 1), ("C", 2, 1)),
(("C", 1, 2), ("C", 2, 2))),
("Edit", None, self.doEdit, 0, (("C", 1, 1), ("C", 2, 1)),
(("C", 1, 2), ("C", 2, 2))), ("Quit", None, self.doQuit, 0,
("T", 0, 0), ("T", 0, 1)))
self.df = TartanDialog(self.opts["mf"],
tags=tag,
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but,
focus=False)
for x in range(14):
self.df.colLabel[3][x].configure(text=self.denoms[x][0])
self.df.focusField("T", 0, 1)
def doType(self, frt, pag, r, c, p, i, w):
self.trtp = w
self.edit = None
self.amend = False
self.loader = False
self.etotal = 0
self.itotal = 0
self.ctotal = 0
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 doCode(self, frt, pag, r, c, p, i, w):
if self.glint == "N" and not w:
ok = askQuestion(self.opts["mf"].body,
"Code Maintenance",
"Do You Want to Add or Edit Codes?",
default="no")
if ok == "no":
return "rf"
w = callModule(self.opts["mf"],
self.df,
"cs1010",
coy=[self.opts["conum"], self.opts["conam"]],
user=self.opts["capnm"],
args=True,
ret="acno")
self.df.loadEntry(frt, pag, p, data=w)
if self.glint == "Y":
acc = self.sql.getRec("genmst",
cols=["glm_desc", "glm_vat"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
else:
acc = self.sql.getRec("cshmst",
cols=["ccm_desc", "ccm_vat"],
where=[("ccm_cono", "=", self.opts["conum"]),
("ccm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
self.code = w
self.vcod = acc[1]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doDesc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("cshana",
cols=["can_vatcod"],
where=[("can_cono", "=", self.opts["conum"]),
("can_code", "=", self.code),
("can_desc", "=", w)],
order="can_date desc",
limit=1)
if acc:
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
else:
self.df.loadEntry(frt, pag, p + 1, data=self.vcod)
def doVCode(self, frt, pag, r, c, p, i, w):
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.date)
if self.vatrte is None:
ask = askQuestion(self.opts["mf"].body,
"New Code",
"Code Does Not Exist, Create a New Code?",
default="no")
if ask == "no":
return "Invalid VAT Code"
w = callModule(self.opts["mf"],
self.df,
"ms1040",
coy=[self.opts["conum"], self.opts["conam"]],
user=self.opts["capnm"],
args=w,
ret="code")
self.df.loadEntry(frt, pag, p, data=w)
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.date)
if self.vatrte is None:
return "Invalid VAT Code"
def doIncAmt(self, frt, pag, r, c, p, i, w):
self.iamt = w
if self.vatrte:
vat = self.iamt * self.vatrte / float(ASD(100) + ASD(self.vatrte))
self.df.loadEntry(frt, pag, p + 1, data=round(vat, 2))
else:
self.df.loadEntry(frt, pag, p + 1, data=0)
if not self.loader:
return "sk1"
def doCheq(self, frt, pag, r, c, p, i, w):
self.ctotal = w
self.df.loadEntry("T", 0, 4, data=self.ctotal)
def doQty(self, frt, pag, r, c, p, i, w):
val = w * self.denoms[int(p / 2)][1]
self.df.loadEntry(frt, pag, p + 1, val)
self.ctotal = float(ASD(self.ctotal) + ASD(val))
self.df.loadEntry("T", 0, 4, data=self.ctotal)
def doEdit(self):
if self.df.pag in (1, 2):
self.doEditPage12()
else:
self.doEditPage3()
def doEditPage12(self):
ana = self.sql.getRec("cshana",
where=[("can_cono", "=", self.opts["conum"]),
("can_type", "=", self.trtp),
("can_date", "=", self.date)])
data = []
for rec in ana:
dat = []
for n, d in enumerate(rec):
if n in (0, 1, 2, 9):
continue
dat.append(d)
data.append(dat)
titl = "Analysis"
head = ("Date", "Code", "Description", "V", "Inc-Amount", "VAT-Amount",
"Seq")
lin = {
"stype":
"C",
"titl":
titl,
"head":
head,
"typs": (("D1", 10), ("UI", 7), ("NA", 30), ("UA", 1),
("SD", 13.2), ("SD", 13.2), ("UA", 1), ("US", 10)),
"data":
data
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select a Line to Edit")
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.edit = self.sql.getRec("cshana",
where=[("can_seq", "=",
chg.selection[-1])],
limit=1)
self.doChgChanges()
else:
self.edit = None
self.doLoadAnalysis()
self.df.enableButtonsTags(state=state)
def doChgChanges(self):
tit = ("Change Line", )
fld = ((("T", 0, 0,
0), "I@can_trdt", 10, "", "", "", "N", self.doChgDate, None,
None, ("efld", )), (("T", 0, 1, 0), "I@can_code", 0, "", "",
"", "N", None, self.cod, None, None),
(("T", 0, 2, 0), "I@can_desc", 0, "", "", "", "N", None, None,
None, ("efld", )), (("T", 0, 3,
0), "I@can_vatcod", 0, "", "", "", "N",
self.doChgVCode, None, None, ("efld", )),
(("T", 0, 4, 0), "I@can_incamt", 0, "", "", "", "N",
self.doChgIncAmt, None, None,
("efld", )), (("T", 0, 5, 0), "I@can_vatamt", 0, "", "", "",
"N", None, None, None, ("efld", )))
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, ),
focus=False)
for num, dat in enumerate(self.edit[3:9]):
self.cg.loadEntry("T", 0, num, data=dat)
self.cg.focusField("T", 0, 1, clr=False)
self.cg.mstFrame.wait_window()
def doChgDate(self, frt, pag, r, c, p, i, w):
self.chgdte = w
def doChgVCode(self, frt, pag, r, c, p, i, w):
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.chgdte)
if self.vatrte is None:
return "Invalid VAT Code"
def doChgIncAmt(self, frt, pag, r, c, p, i, w):
self.iamt = w
if self.vatrte:
vat = self.iamt * self.vatrte / float(ASD(100) + ASD(self.vatrte))
self.cg.loadEntry(frt, pag, p + 1, data=round(vat, 2))
else:
self.cg.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doChgDel(self):
self.sql.delRec("cshana", data=self.edit)
self.doChgExit()
def doChgEnd(self):
self.sql.delRec("cshana", data=self.edit)
for num, fld in enumerate(self.cg.t_work[0][0]):
self.edit[num + 3] = fld
self.sql.insRec("cshana", data=self.edit)
self.opts["mf"].dbm.commitDbase()
self.doChgExit()
def doChgExit(self):
self.cg.closeProcess()
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 doTopEnd(self):
if self.df.pag == 0:
if self.trtp == "P":
self.df.selPage("Expenses")
if self.amend:
self.doLoadAnalysis()
else:
self.df.focusField("C", 1, 1)
elif self.trtp == "T":
self.df.selPage("Income")
if self.amend:
self.doLoadAnalysis()
else:
self.df.focusField("C", 2, 1)
else:
self.df.selPage("Cash")
if not self.amend:
self.df.focusField("T", 3, 1)
else:
self.doLoadCash()
elif self.df.pag == 3:
self.df.focusField("C", 3, 1)
def doColEnd(self):
if self.trtp in ("P", "T"):
if self.trtp == "P":
data = [self.opts["conum"], self.trtp, self.date]
data.extend(self.df.c_work[1][self.df.row])
data.append("N")
self.sql.insRec("cshana", data=data)
self.etotal = float(ASD(self.etotal) + ASD(self.iamt))
self.df.loadEntry("T", 0, 2, data=self.etotal)
self.df.advanceLine(1)
else:
data = [self.opts["conum"], self.trtp, self.date]
data.extend(self.df.c_work[2][self.df.row])
data.append("N")
self.sql.insRec("cshana", data=data)
self.itotal = float(ASD(self.itotal) + ASD(self.iamt))
self.df.loadEntry("T", 0, 3, data=self.itotal)
self.df.advanceLine(2)
else:
if self.df.col == 28:
ask = askQuestion(self.opts["mf"].body, "Accept",
"Accept All Entries")
if ask == "yes":
data = [self.opts["conum"], "T", self.date]
data.append(self.df.t_work[3][0][0])
for x in range(14):
data.append(self.df.c_work[3][x][0])
if self.amend:
self.sql.delRec("cshcnt",
where=[("cct_cono", "=",
self.opts["conum"]),
("cct_type", "=", "T"),
("cct_date", "=", self.date)])
self.sql.insRec("cshcnt", data=data)
self.opts["mf"].dbm.commitDbase()
self.doRestart()
else:
self.df.focusField("T", 3, 1, clr=False)
elif self.edit:
col = self.edit
self.edit = None
self.df.focusField("C", 3, col)
else:
self.df.advanceLine(self.df.pag)
def doLoadCash(self):
self.df.doInvoke(["T", 3, 1, self.doCheq], self.rec[3])
for num, qty in enumerate(self.rec[4:-1]):
col = (num * 2) + 1
self.df.doInvoke(["C", 3, col, self.doQty], qty)
def doLoadAnalysis(self):
self.loader = True
total = 0
if self.trtp == "P":
pag = 1
else:
pag = 2
self.df.clearFrame("C", pag)
ana = self.sql.getRec("cshana",
where=[("can_cono", "=", self.opts["conum"]),
("can_type", "=", self.trtp),
("can_date", "=", self.date)],
order="can_seq")
if not ana:
self.df.focusField("C", pag, 1)
else:
for num, rec in enumerate(ana):
if num > 14:
num = 14
for pos, dat in enumerate(rec[3:9]):
col = (num * 6) + pos + 1
if pos == 3:
self.df.doInvoke(["C", pag, col, self.doVCode], dat)
elif pos == 4:
self.df.doInvoke(["C", pag, col, self.doIncAmt], dat)
else:
self.df.doInvoke(["C", pag, col, "rt"], dat)
total = float(ASD(total) + ASD(self.iamt))
self.df.advanceLine(pag)
if self.trtp == "P":
self.etotal = total
self.df.loadEntry("T", 0, 2, data=self.etotal)
else:
self.itotal = total
self.df.loadEntry("T", 0, 3, data=self.itotal)
self.loader = False
def doQuit(self):
self.opts["mf"].dbm.rollbackDbase()
self.doRestart()
def doTopExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doColExit(self):
if self.df.pag != 3:
self.opts["mf"].dbm.commitDbase()
self.doRestart()
elif self.df.pos:
self.df.loadEntry("C",
3,
self.df.pos,
data=self.df.c_work[3][self.df.row][self.df.idx])
r = self.df.row - 1
c = self.df.col - 2
self.ctotal = float(
ASD(self.ctotal) - ASD(self.df.c_work[3][r][1]))
self.df.focusField("C", 3, c)
def doRestart(self):
self.df.clearFrame("C", 1)
self.df.clearFrame("C", 2)
self.df.clearFrame("T", 3)
self.df.clearFrame("C", 3)
self.df.selPage("Expenses")
self.df.focusField("T", 0, 1, clr=True)
class bc2070(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["bwlcmp", "bwltab", "bwlent",
"bwltyp", "bwlpts", "bwlgme"], prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
bcp = {
"stype": "R",
"tables": ("bwlcmp",),
"cols": (
("bcm_code", "", 0, "Cod"),
("bcm_name", "", 0, "Name", "Y"),
("bcm_date", "", 0, "Date")),
"where": [("bcm_cono", "=", self.opts["conum"])]}
gme = {
"stype": "R",
"tables": ("bwlgme",),
"cols": (
("bcg_game", "", 0, "GC"),
("bcg_type", "", 0, "T"),
("bcg_date", "", 0, "Date")),
"where": [("bcg_cono", "=", self.opts["conum"])],
"whera": [("T", "bcg_ccod", 0, 0)],
"group": "bcg_game"}
skp = {
"stype": "R",
"tables": ("bwlent", "bwltab", "bwlgme"),
"cols": (
("btb_tab", "", 0, "Cod"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names"),
("bcg_rink", "", 0, "RK")),
"where": [
("bce_cono", "=", self.opts["conum"]),
("btb_cono=bce_cono",),
("btb_tab=bce_scod",),
("bcg_cono=bce_cono",),
("bcg_scod=bce_scod",),
("bcg_ocod<900000",),
("bcg_sfor=0 and bcg_sagt=0",)],
"whera": [
("T", "bce_ccod", 0, 0),
("T", "bcg_ccod", 0, 0),
("T", "bcg_game", 2, 0)],
"order": "bcg_rink"}
fld = (
(("T",0,0,0),"I@bcm_code",0,"","",
"","Y",self.doCmpCod,bcp,None,("notzero",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,0,0),"I@bcg_game",0,"Game Number","",
"","N",self.doGamCod,gme,None,("efld",)),
(("T",0,0,0),"IUI",2,"Ends Completed","",
0,"N",self.doEndsFin,None,None,("efld",)),
(("C",0,0,0),"I@bcg_scod",0,"","",
"","N",self.doSkpCod,skp,None,("efld",)),
(("C",0,0,0),"ONA",30,"Skp-Name"),
(("C",0,0,0),"I@bcg_sfor",0,"","",
"","N",self.doShots,None,None,("efld",)),
(("C",0,0,0),"I@bcg_points",0,"","",
"","N",self.doPoints,None,None,("efld",)),
(("C",0,0,0),"O@bcg_ocod",0,""),
(("C",0,0,0),"ONA",30,"Opp-Name"),
(("C",0,0,0),"I@bcg_sagt",0,"","",
"","N",self.doShots,None,None,("efld",)),
(("C",0,0,0),"I@bcg_points",0,"","",
"","N",self.doPoints,None,None,("efld",)))
but = (("Quit",None,self.doQuit,1,None,None),)
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
cnd = ((self.doEnd,"y"),)
cxt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
rows=(19,), eflds=fld, butt=but, tend=tnd, txit=txt,
cend=cnd, cxit=cxt)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("bwlcmp", cols=["bcm_name", "bcm_type"],
where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=",
w)], limit=1)
if not com:
return "Invalid Competition Code"
self.ccod = w
self.code = com[1]
self.df.loadEntry(frt, pag, p + 1, data=com[0])
if not self.code:
bwltyp = [self.opts["conum"], 0, "KO", "K", 1, 0, 21,
"N", 0, "N", "", 0, 0, "N", "N", ""]
else:
bwltyp = self.sql.getRec("bwltyp", where=[("bct_cono", "=",
self.opts["conum"]), ("bct_code", "=", com[1])], limit=1)
self.cfmat = bwltyp[self.sql.bwltyp_col.index("bct_cfmat")]
self.groups = bwltyp[self.sql.bwltyp_col.index("bct_groups")]
self.grgame = bwltyp[self.sql.bwltyp_col.index("bct_grgame")]
if self.cfmat == "R":
games = self.sql.getRec("bwlgme", cols=["count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=", 1)],
group="bcg_group")
self.games = 0
for gme in games:
if gme[0] > self.games:
self.games = gme[0]
self.games -= 1
elif self.cfmat in ("D", "K"):
totskp = self.sql.getRec("bwlent", cols=["count(*)"],
where=[("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod)], limit=1)[0]
pwrs = 2
self.games = 1
while pwrs < totskp:
self.games += 1
pwrs = pwrs * 2
else:
self.games = bwltyp[self.sql.bwltyp_col.index("bct_games")]
self.ends = bwltyp[self.sql.bwltyp_col.index("bct_ends")]
chk = self.sql.getRec("bwlgme", cols=["bcg_game",
"sum(bcg_sfor)", "sum(bcg_sagt)", "sum(bcg_points)"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=",
self.ccod), ("bcg_aflag", "in", ("", "D"))],
group="bcg_game", order="bcg_game")
for game in chk:
self.gcod = game[0]
if not game[1] and not game[2] and not game[3]:
self.df.loadEntry(frt, pag, p + 2, data=self.gcod)
break
self.df.loadEntry(frt, pag, p + 3, data=self.ends)
def doGamCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("bwlgme", cols=["bcg_aflag",
"sum(bcg_ocod)"], where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=", w)],
group="bcg_aflag")
if not chk:
return "Invalid Game Number"
for ck in chk:
if not ck[0] and not ck[1]:
return "Invalid Game Number, Not Yet Drawn"
if w != self.games:
col = [
"bcg_game",
"bcg_type",
"sum(bcg_ocod)",
"sum(bcg_sfor)",
"sum(bcg_points)"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", ">", w)]
drwn = self.sql.getRec("bwlgme", cols=col, where=whr,
group="bcg_game, bcg_type", order="bcg_game")
drawn = []
for n, d in enumerate(drwn):
if d[1] == "S" and d[2]:
if d[3] or d[4]:
drawn = "X"
break
drawn.append(d[0])
if drawn == "X":
showError(self.opts["mf"].body, "Error",
"Results Have Already Been Captured for Game %s" % d[0])
return "Completed SvS Game %s" % d[0]
elif drawn:
if len(drawn) == 1:
text = "Game %s" % drawn[0]
plural = "Draw"
word = "Has"
else:
text = "Games"
for d in drawn:
text += " %s" % d
plural = "Draws"
word = "Have"
ok = askQuestion(self.opts["mf"].body, head="Draw Done",
mess="""Strength v Strength %s %s Been Drawn.
Do You Want to Delete the %s and Alter This Game's Results?
You Will Then Have to Re-Print Reports and Re-Draw %s.
If You Continue and Have Not Made a Backup You Will Not be Able to Restore.
Do You Still Want to Continue?""" % (text, word, plural, text), default="no")
if ok == "no":
return "rf"
col = ["bcg_date", "bcg_ocod", "bcg_rink"]
dat = [0, 0, ""]
if self.groups == "Y" and w == self.grgame:
col.append("bcg_group")
dat.append(0)
col.extend(["bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"])
dat.extend([0, 0, 0, 0, 0, 0, ""])
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "in", tuple(drawn))]
self.sql.updRec("bwlgme", cols=col, data=dat, where=whr)
self.opts["mf"].dbm.commitDbase()
elif chk[0] in ("A", "S"):
return "Invalid Game Number, Abandoned or Skipped"
self.gcod = w
gtyp = self.sql.getRec("bwlgme", cols=["bcg_type"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod",
"=", self.ccod), ("bcg_game", "=", w)], limit=1)[0]
bwlpts = self.sql.getRec("bwlpts", where=[("bcp_cono",
"=", self.opts["conum"]), ("bcp_code", "=", self.code),
("bcp_ptyp", "=", gtyp)], limit=1)
if not bwlpts:
bwlpts = [self.opts["conum"], 0, "D", "N", 0, "N",
0, 0, 1, "N", 0, 0, ""]
self.skins = bwlpts[self.sql.bwlpts_col.index("bcp_skins")]
self.sends = bwlpts[self.sql.bwlpts_col.index("bcp_sends")]
self.ponly = bwlpts[self.sql.bwlpts_col.index("bcp_p_only")]
self.epts = bwlpts[self.sql.bwlpts_col.index("bcp_e_points")]
self.spts = bwlpts[self.sql.bwlpts_col.index("bcp_s_points")]
self.gpts = bwlpts[self.sql.bwlpts_col.index("bcp_g_points")]
self.bpts = bwlpts[self.sql.bwlpts_col.index("bcp_bonus")]
dif = bwlpts[self.sql.bwlpts_col.index("bcp_win_by")]
self.win_by = [dif, dif * -1]
dif = bwlpts[self.sql.bwlpts_col.index("bcp_lose_by")]
self.lose_by = [dif, dif * -1]
def doEndsFin(self, frt, pag, r, c, p, i, w):
self.bonus = self.bpts
if w != self.ends:
if not w:
but = (("Exit",1),("Skipped",2),("Abandoned",3))
ok = askChoice(self.opts["mf"].body, head="Zero Ends",
mess="No Ends Completed, Choose Option", butt=but)
if ok == 1:
return "rf"
elif ok == 2:
self.sql.updRec("bwlgme", cols=["bcg_aflag"], data=["S"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=",
self.gcod)])
elif ok == 3:
self.sql.updRec("bwlgme", cols=["bcg_ocod", "bcg_rink",
"bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"], data=[0, "", 0, 0, 0, 0, 0, 0, "A"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=",
self.gcod)])
self.opts["mf"].dbm.commitDbase()
return "xt"
ok = askQuestion(self.opts["mf"].body, head="Shortened",
mess="Was This Game Shortened?", default="no")
if ok == "no":
return "rf"
if self.bonus == "Y":
ok = askQuestion(self.opts["mf"].body, head="Bonus Points",
mess="Must Bonus Points Still be Awarded?", default="no")
if ok == "no":
self.bonus = "N"
self.totpts = (w * self.epts) + self.gpts
if self.skins == "Y":
self.totpts = self.totpts + (int(w / self.sends) * self.spts)
if self.bonus == "Y":
self.maxpts = float(ASD(self.totpts) + ASD(1))
else:
self.maxpts = self.totpts
def doSkpCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=["btb_surname",
"btb_names", "bcg_ocod", "bcg_sfor", "bcg_sagt",
"bcg_points"], where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w), ("bcg_game",
"=", self.gcod), ("btb_tab=bcg_scod",)], limit=1)
if not chk:
return "Invalid Skip Code"
if chk[3] or chk[4] or chk[5]:
ok = askQuestion(self.opts["mf"].body, head="Already Entered",
mess="""This Card Has Already Been Entered, Re-Enter?
Shots For: %s
Shots Against: %s
Points: %s""" % (chk[3], chk[4], chk[5]),
default="no")
if ok == "no":
return "rf"
self.reenter = True
else:
self.reenter = False
self.skp = w
self.opp = chk[2]
if self.opp > 900000:
return "This Skip Had a Bye"
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 1, data=name)
if self.ponly == "N":
self.df.loadEntry(frt, pag, p + 2, data=chk[3])
self.df.loadEntry(frt, pag, p + 3, data=chk[5])
self.df.loadEntry(frt, pag, p + 4, data=self.opp)
if self.cfmat in ("D", "K"):
opp = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.opp)], limit=1)
chk = opp + [chk[4], chk[3], 0]
else:
chk = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=["btb_surname", "btb_names", "bcg_sfor",
"bcg_sagt", "bcg_points"], where=[("bcg_cono",
"=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.opp), ("bcg_game", "=", self.gcod),
("btb_tab=bcg_scod",)], limit=1)
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 5, data=name)
if self.ponly == "N":
self.df.loadEntry(frt, pag, p + 6, data=chk[2])
self.df.loadEntry(frt, pag, p + 7, data=chk[4])
if self.ponly == "Y":
self.mpts = self.totpts
return "sk2"
def doShots(self, frt, pag, r, c, p, i, w):
if i == 2:
self.s_for = w
if self.cfmat in ("D", "K", "R"):
self.p_for = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
if not self.s_for or (not self.totpts and self.bonus != "Y"):
self.p_for = w
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
else:
self.s_agt = w
if self.cfmat in ("D", "K"):
self.p_agt = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
if self.cfmat == "R":
if self.s_for == self.s_agt:
self.p_for = self.p_agt = .5
elif self.s_for > self.s_agt:
self.p_for = 1
self.p_agt = 0
else:
self.p_for = 0
self.p_agt = 1
self.df.loadEntry(frt, pag, p - 3, data=self.p_for)
self.df.loadEntry(frt, pag, p + 1, data=self.p_agt)
return "sk1"
if not self.s_agt or (not self.totpts and self.bonus != "Y"):
self.p_agt = w
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
self.mpts = self.totpts
if self.bonus == "N":
return
diff = float(ASD(self.s_for) - ASD(self.s_agt))
if not diff:
return
if diff > self.win_by[0] or diff < self.win_by[1]:
self.mpts = float(ASD(self.mpts) + ASD(1))
elif diff < self.lose_by[0] and diff > self.lose_by[1]:
self.mpts = float(ASD(self.mpts) + ASD(1))
def doPoints(self, frt, pag, r, c, p, i, w):
if w and w % 1 not in (0.0, 0.5):
return "Invalid Decimal in Points"
if w > self.maxpts:
return "Invalid Points, Exceed Maximum"
if i == 3:
self.p_for = w
self.df.loadEntry(frt, pag, p + 1, data=self.opp)
chk = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.opp)], limit=1)
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 2, data=name)
if self.ponly == "Y":
self.s_for = w
return "sk3"
else:
return "sk2"
if not w:
self.p_agt = float(ASD(self.mpts) - ASD(self.p_for))
self.df.loadEntry(frt, pag, p, data=self.p_agt)
else:
self.p_agt = w
if self.ponly == "Y":
self.s_agt = self.p_agt
tot = float(ASD(self.p_for) + ASD(self.p_agt))
if tot != self.mpts:
return "Invalid Total Points (%s s/b %s)" % (tot, self.mpts)
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
self.doLoadCards()
else:
if self.ponly == "Y" and not self.p_for and not self.p_agt:
aflag = "S"
elif self.ponly == "N" and not self.s_for and not self.s_agt:
aflag = "S"
else:
aflag = ""
col = [
"bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod)]
w = whr[:]
w.append(("bcg_scod", "=", self.skp))
self.sql.updRec("bwlgme", cols=col, data=[self.s_for, self.s_agt,
self.p_for, self.s_for, self.s_agt, self.p_for, aflag],
where=w)
if self.cfmat not in ("D", "K"):
w = whr[:]
w.append(("bcg_scod", "=", self.opp))
self.sql.updRec("bwlgme", cols=col, data=[self.s_agt,
self.s_for, self.p_agt, self.s_agt, self.s_for,
self.p_agt, aflag], where=w)
self.opts["mf"].dbm.commitDbase()
if self.reenter:
self.doLoadCards()
else:
self.df.advanceLine(0)
def doLoadCards(self):
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod)]
if self.ponly == "Y":
whr.append(("bcg_points", ">", 0))
else:
whr.append(("(", "bcg_sfor", ">", 0, "or",
"bcg_sagt", ">", 0, ")"))
recs = self.sql.getRec("bwlgme", cols=["bcg_scod", "bcg_ocod"],
where=whr, order="bcg_scod")
if not recs:
return
self.df.clearFrame("C", 0)
self.df.focusField("C", 0, 1)
skips = []
seq = 0
for rec in recs:
if rec[0] in skips:
continue
skips.extend(rec)
col = [
"btb_surname", "btb_names",
"bcg_sfor", "bcg_sagt", "bcg_points"]
skp = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=col, where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[0]),
("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)], limit=1)
idx = seq * 8
self.df.loadEntry("C", 0, idx, data=rec[0])
if skp[1]:
name = "%s, %s" % tuple(skp[:2])
else:
name = skp[0]
self.df.loadEntry("C", 0, idx + 1, data=name)
self.df.loadEntry("C", 0, idx + 2, data=skp[2])
self.df.loadEntry("C", 0, idx + 3, data=skp[4])
if self.cfmat in ("D", "K"):
tab = self.sql.getRec("bwltab", cols=col[:2],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", rec[1])], limit=1)
opp = tab + [skp[3], skp[4], 0]
else:
opp = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=col, where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[1]),
("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)],
limit=1)
self.df.loadEntry("C", 0, idx + 4, data=rec[1])
if opp[1]:
name = "%s, %s" % tuple(opp[:2])
else:
name = opp[0]
self.df.loadEntry("C", 0, idx + 5, data=name)
self.df.loadEntry("C", 0, idx + 6, data=opp[2])
self.df.loadEntry("C", 0, idx + 7, data=opp[4])
self.df.advanceLine(0)
if seq < 17:
seq += 1
def doExit(self):
if self.df.frt == "C" and self.df.col != 1:
chk = self.sql.getRec("bwlgme", where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game",
"=", self.gcod), ("bcg_aflag", "in", ("", "D"))])
for c in chk:
scod = c[self.sql.bwlgme_col.index("bcg_scod")]
ocod = c[self.sql.bwlgme_col.index("bcg_ocod")]
if scod > 900000 or ocod > 900000:
continue
if self.ponly == "Y":
fors = c[self.sql.bwlgme_col.index("bcg_points")]
agts = self.sql.getRec("bwlgme",
cols=["bcg_points"], where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod), ("bcg_scod",
"=", ocod)], limit=1)[0]
else:
fors = c[self.sql.bwlgme_col.index("bcg_sfor")]
agts = c[self.sql.bwlgme_col.index("bcg_sagt")]
if not fors and not agts:
self.df.focusField(self.df.frt, self.df.pag, self.df.col,
err="Missing Score Card for Skips %s and %s" % (scod,
ocod))
return
if self.cfmat in ("D", "K") and self.gcod != self.games:
# Delete Next Round's Records
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod)]
w = whr[:]
w.append(("bcg_game", ">", self.gcod))
self.sql.delRec("bwlgme", where=w)
# Create Next Round's Records
whr.append(("bcg_game", "=", self.gcod))
odr = "bcg_group, bcg_pair, bcg_scod"
g = self.sql.bwlgme_col
for grp in range(1, 3):
w = whr[:]
w.append(("bcg_group", "=", grp))
recs = self.sql.getRec("bwlgme", where=w, order=odr)
for num in range(0, len(recs), 2):
pair = int(num / 2) + 1
rec1 = copyList(recs[num])
if len(recs) == 1:
w = whr[:]
w.append(("bcg_group", "=", 2))
rec2 = self.sql.getRec("bwlgme", where=w,
order=odr, limit=1)
grp = 2
else:
rec2 = copyList(recs[num + 1])
skp1 = rec1[g.index("bcg_scod")]
opp1 = rec1[g.index("bcg_ocod")]
for1 = rec1[g.index("bcg_sfor")]
agt1 = rec1[g.index("bcg_sagt")]
skp2 = rec2[g.index("bcg_scod")]
opp2 = rec2[g.index("bcg_ocod")]
for2 = rec2[g.index("bcg_sfor")]
agt2 = rec2[g.index("bcg_sagt")]
if opp1 > 900000:
pl1 = skp1
elif for1 > agt1:
pl1 = skp1
else:
pl1 = opp1
if opp2 > 900000:
pl2 = skp2
elif for2 > agt2:
pl2 = skp2
else:
pl2 = opp2
dat = [self.opts["conum"], self.ccod, pl1,
self.gcod + 1, "D", 0, pl2, "", grp, 0,
0, 0.0, 0, 0, 0.0, "", 0, pair]
self.sql.insRec("bwlgme", data=dat)
if len(recs) == 1:
break
self.opts["mf"].dbm.commitDbase()
if self.cfmat in ("D", "K"):
callModule(self.opts["mf"], self.df, "bc2050",
coy=[self.opts["conum"], self.opts["conam"]],
args=self.ccod)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doQuit(self, event=None):
col = ["count(*)"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod),
("bcg_scod", "<", 900000),
("bcg_ocod", "<", 900000),
("bcg_sfor=0 and bcg_sagt=0",)]
chk = self.sql.getRec("bwlgme", cols=col, where=whr, limit=1)
if chk[0]:
ok = askQuestion(self.opts["mf"].body, "Quit Capture",
"Are You Sure that you would like to Quit before "\
"capturing All Results?", default="no")
if ok == "no":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.df.closeProcess()
self.opts["mf"].closeLoop()
class st2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.exit = False
self.selectPrinter()
if not self.exit:
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "ctlmes", "ctlvrf", "ctlrep", "crsmst", "gentrn",
"strgrp", "strloc", "strmf1", "strmf2", "strpom", "strpot",
"strtrn", "strgmu", "strcmu", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
mods = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
mods.append(ctlmst["ctm_modules"][x:x + 2])
if "CR" not in mods:
showError(
self.opts["mf"].body, "System Error",
"This module requires you to have a Creditor's Activated")
return
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.stgl = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
self.dtpl = strctl["cts_tplnam"]
if self.stgl == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.soh = ctlctl["stk_soh"]
self.ssp = ctlctl["stk_susp"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def selectPrinter(self):
tit = ("Printer Selection", )
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "O"), ("tpm_system", "=", "STR")],
"order":
"tpm_tname"
}
fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.dtpl, "N",
self.doTplNam, tpm, None, None),
(("T", 0, 1, 0), "ID1", 10, "Order Date", "", self.sysdtw, "N",
self.doOrdDate, None, None, ("efld", )))
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "P"),
mail=("N", "Y", "Y"))
self.opts["mf"].startLoop()
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "O"),
("tpm_system", "=", "STR")],
limit=1)
if not acc:
return "Invalid Template Name"
self.tname = w
def doOrdDate(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not In Financial Period"
self.trdt = w
self.trdd = self.pr.t_disp[0][0][1]
self.curdt = int(self.trdt / 100)
self.batch = "S%s" % self.curdt
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.pr.closeProcess()
self.opts["mf"].closeLoop()
def mainProcess(self):
doc = {
"stype":
"R",
"tables": ("strpom", "crsmst"),
"cols":
(("pom_ordno", "", 0, "Ord-Num"), ("pom_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")),
"where": [("pom_cono", "=", self.opts["conum"]),
("crm_cono=pom_cono", ), ("crm_acno=pom_acno", ),
("pom_delno", "=", "")]
}
loc = {
"stype":
"R",
"tables": ("strloc", ),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]
}
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")],
"index":
0
}
odr = {
"stype": "R",
"tables": ("ctlrep", ),
"cols": [("rep_code", "", 0, "Ord"),
("rep_name", "", 0, "Name", "Y")],
"where": [("rep_cono", "=", self.opts["conum"])],
"index": 0
}
grp = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("strmf1", ),
"cols": (("st1_code", "", 0, "Product-Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "not", "in", ("R", "X")),
("st1_value_ind", "<>", "N")],
"whera": [("C", "st1_group", 0)],
"order":
"st1_group, st1_code"
}
r1s = (("New", "N"), ("Amend", "A"), ("Receive", "R"), ("Cancel", "C"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Action", "", "N", "Y",
self.doActTyp, None, None,
None), (("T", 0, 1, 0), "IUI", 9, "Ord-No", "Order Number", "",
"N", self.doOrdNum, doc, None, ("notblank", )),
(("T", 0, 2, 0), "IUA", 1, "Loc", "Location Code", "1", "N",
self.doLoc, loc, None, None), (("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "INA", 7, "Acc-No", "Account Number", "", "N",
self.doCrsAcc, crm, None, None), (("T", 0, 3, 0), "ONA", 30,
""),
(("T", 0, 4, 0), "INa", 3, "Ord-By", "Ordered By", "", "N",
self.doOrdBy, odr, None, None), (("T", 0, 4, 0), "ONA", 30,
""),
(("T", 0, 5, 0), "INa", 7, "Del-No", "Delivery Note Number", "",
"N", self.doDelNum, None, None, ("notblank", )),
(("T", 0, 5, 0), "ID1", 10, "Date", "Delivery Date", self.trdt,
"N", self.doDelDate, None, None,
("efld", )), (("C", 0, 0, 0), "INA", 3, "Grp", "Product Group",
"", "Y", self.doGrp, grp, None, None),
(("C", 0, 0, 1), "INA", 20, "Product-Code", "", "", "N",
self.doCod, cod, None,
None), (("C", 0, 0, 2), "INA", (20, 30), "Description", "", "",
"N", self.doDes, None, None,
None), (("C", 0, 0, 3), "ISD", 11.2, "Quantity", "", 1,
"N", self.doQty, None, None, ("notzero", )),
(("C", 0, 0, 4), "IUA", 1, "V", "V.A.T. Code", "I", "N",
self.doVat, None, None, ("notblank", )),
(("C", 0, 0, 5), "IUD", 10.2, "Price", "Exclusive Price", "",
"N", self.doPri, None, None,
None), (("C", 0, 0, 6), "IUD", 6.2, "Dis-%", "Trade Discount",
"", "N", self.doDis, None, None,
None), (("C", 0, 0, 7), "OSD", 10.2, "Value"))
self.row = (15, )
self.but = (("Cancel", None, self.doCancel, 1, ("C", 0, 1),
("T", 0, 1)), ("DelAdd", None, self.doDelAdd, 1,
("C", 0, 1), ("T", 0, 1)),
("Ribbon", None, self.doRibbon, 1, ("C", 0, 1),
("T", 0, 1)), ("Message", None, self.doMessag, 1,
("C", 0, 1), ("T", 0, 1)),
("Edit", None, self.doEdit, 0, ("C", 0, 1), ("C", 0, 2)),
("Reprint", None, self.doReprnt, 0, ("T", 0, 1),
("T", 0, 2)), ("CrsMaint", None, self.doCrsMaint, 0,
("T", 0, 5), ("T", 0, 6)),
("CrsQuery", None, self.doCrsQuery, 1, None,
None), ("StrMaint", None, self.doStrMaint, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0, 2))),
("StrQuery", None, self.doStkQuery, 1, None,
None), ("Exit", None, self.doTopExit, 0, ("T", 0, 1),
(("T", 0, 2), ("T", 0, 3),
("T", 0, 5)), "Exit Purchase Orders"),
("Accept", None, self.doAccept, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0, 2))))
tnd = ((self.doTopEnd, "n"), )
txt = (self.doTopExit, )
cnd = ((self.doColEnd, "n"), )
cxt = (None, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
rows=self.row,
butt=self.but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
vport=True)
def doActTyp(self, frt, pag, r, c, p, i, w):
# Initialise Action Variables
self.acttyp = w
# Initialise Variables
self.dnum = ""
self.onum = ""
self.jnum = ""
self.dadd = ""
self.cnam = ""
self.vatn = ""
self.ribbon = None
ctl = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])],
limit=1)
self.deladd = [
ctl[self.sql.ctlmst_col.index("ctm_sadd1")],
ctl[self.sql.ctlmst_col.index("ctm_sadd2")],
ctl[self.sql.ctlmst_col.index("ctm_sadd3")],
ctl[self.sql.ctlmst_col.index("ctm_spcode")]
]
self.message = ""
for x in (1, 2, 3):
if self.acttyp == "R":
self.df.butt[x][1] = 0
self.df.butt[x][2] = None
else:
self.df.butt[x][1] = 1
self.df.butt[x][2] = ["C", 0, 1]
if self.acttyp == "N":
# Location default
if self.locs == "N":
self.loc = "1"
self.df.loadEntry(frt, pag, p + 2, data=self.loc)
self.df.loadEntry(frt, pag, p + 3, data="Location One")
return "sk3"
return "sk1"
def doOrdNum(self, frt, pag, r, c, p, i, w):
strpom = self.sql.getRec("strpom",
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", w)],
limit=1)
if not strpom:
return "Invalid Document"
if strpom[self.sql.strpom_col.index("pom_delno")] == "cancel":
if self.acttyp == "C":
return "Already Cancelled"
ok = askQuestion(
self.opts["mf"].body,
"Cancelled",
"This order was Cancelled.\n\nDo you want to Reinstate It?",
default="no")
if ok == "no":
return "Order Cancelled"
self.sql.updRec("strpom",
cols=["pom_delno"],
data=[""],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", w)])
strpom[self.sql.strpom_col.index("pom_delno")] = ""
elif strpom[self.sql.strpom_col.index("pom_delno")]:
return "Order Already Received"
self.ordno = CCD(w, "UI", 9.0).work
self.othno = CCD(w, "Na", 9.0).work
self.loc = strpom[self.sql.strpom_col.index("pom_loc")]
self.acno = strpom[self.sql.strpom_col.index("pom_acno")]
self.cnam = strpom[self.sql.strpom_col.index("pom_contact")]
self.vatn = strpom[self.sql.strpom_col.index("pom_vatno")]
self.ordby = strpom[self.sql.strpom_col.index("pom_ordby")]
self.ribbon = ["", "", self.cnam, self.vatn]
self.df.loadEntry(frt, pag, p + 1, data=self.loc)
self.doLoc(frt, pag, r, c + 1, p + 1, i + 1, self.loc)
self.df.loadEntry(frt, pag, p + 3, data=self.acno)
self.doCrsAcc(frt, pag, r, c + 3, p + 3, i + 3, self.acno)
self.df.loadEntry(frt, pag, p + 5, data=self.ordby)
self.doOrdBy(frt, pag, r, c + 5, p + 5, i + 5, self.ordby)
if self.acttyp == "R":
return "sk6"
else:
return "nd"
def doLoc(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("strloc",
cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", w)],
limit=1)
if not desc:
return "Invalid Location"
self.loc = w
self.df.loadEntry(frt, pag, p + 1, data=desc[0])
def doCrsAcc(self, frt, pag, r, c, p, i, w):
self.crsmst = self.sql.getRec("crsmst",
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not self.crsmst:
return "Invalid Account"
if self.crsmst[self.sql.crsmst_col.index("crm_stat")] == "X":
return "Invalid Account, Redundant"
self.acno = w
self.name = self.crsmst[self.sql.crsmst_col.index("crm_name")]
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doOrdBy(self, frt, pag, r, c, p, i, 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 Code"
self.ordby = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
return "sk3"
def doDelNum(self, frt, pag, r, c, p, i, w):
self.delno = w
def doDelDate(self, frt, pag, r, c, p, i, w):
self.deldt = w
def doTopEnd(self):
if self.acttyp == "N":
# Get and Display Next Document Number
ordno = self.sql.getRec("strpom",
cols=["max(pom_ordno)"],
where=[("pom_cono", "=",
self.opts["conum"])],
limit=1)
if not ordno[0]:
self.ordno = CCD(1, "UI", 9).work
self.othno = CCD(1, "Na", 9).work
else:
self.ordno = CCD((int(ordno[0]) + 1), "UI", 9).work
self.othno = CCD((int(ordno[0]) + 1), "Na", 9).work
self.df.loadEntry(self.df.frt, self.df.pag, 1, data=self.ordno)
# Create Document Transaction (Head)
self.dad1, self.dad2, self.dad3, self.dad4 = "", "", "", ""
data = [
self.opts["conum"], self.ordno, self.loc, self.trdt, self.acno,
self.dad1, self.dad2, self.dad3, self.dad4, "", "", "", "",
self.ordby, "", "", 0, self.opts["capnm"], self.sysdtw
]
# Write and Commit Header
self.sql.insRec("strpom", data=data)
self.opts["mf"].dbm.commitDbase()
# Clear Totals
self.doClearTots()
elif self.acttyp == "C":
self.doReadLoadStr()
ok = askQuestion(self.opts["mf"].body,
"Cancel",
"Are You Sure This Order Must be Cancelled?",
default="no")
if ok == "yes":
# Print Cancellation
self.df.setWidget(self.df.mstFrame, state="hide")
PrintOrder(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.ordno,
tname=self.tname,
repprt=self.pr.repprt,
repeml=self.pr.repeml,
copy=self.acttyp.lower())
self.df.setWidget(self.df.mstFrame, state="show")
# Update Deletetion
self.sql.updRec("strpom",
cols=["pom_delno"],
data=["cancel"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno)])
self.opts["mf"].dbm.commitDbase()
# Clear totals and focus
self.doClearTots()
self.df.focusField("T", 0, 1)
else:
self.doReadLoadStr()
self.amend = False
def doReadLoadStr(self):
self.doClearTots()
data = self.sql.getRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno)],
order="pot_group, pot_code")
if not data:
return
for seq, line in enumerate(data):
self.doExtData(line)
if seq >= self.row[0]:
self.df.scrollScreen(0)
pos = (self.row[0] - 1) * 9
else:
pos = seq * 9
# Load Values
self.df.loadEntry("C", 0, pos, data=self.grp)
self.df.loadEntry("C", 0, pos + 1, data=self.code)
self.df.loadEntry("C", 0, pos + 2, data=self.desc)
self.df.loadEntry("C", 0, pos + 3, data=self.qty)
self.df.loadEntry("C", 0, pos + 5, data=self.vatcod)
self.df.loadEntry("C", 0, pos + 6, data=self.price)
self.df.loadEntry("C", 0, pos + 7, data=self.disrat)
self.df.loadEntry("C", 0, pos + 8, data=self.excamt)
self.vattot = float(ASD(self.vattot) + ASD(self.vatamt))
self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt))
self.inctot = float(ASD(self.inctot) + ASD(self.incamt))
if seq >= (self.row[0] - 1):
self.df.scrollScreen(0)
else:
self.df.focusField("C", 0, pos + 10)
self.df.setViewPort("O", self.inctot)
def doTopExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doClearTots(self):
self.vattot = 0
self.ordtot = 0
self.inctot = 0
self.df.clearFrame("C", 0)
self.df.focusField("C", 0, 1)
self.df.setViewPort(None, 0)
def doGrp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group Code"
self.grp = w
def doCod(self, frt, pag, r, c, p, i, w):
strmf1 = self.sql.getRec("strmf1",
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", w)],
limit=1)
if not strmf1:
return "Invalid Code"
if strmf1[self.sql.strmf1_col.index("st1_type")] == "R":
return "Invalid Code (Recipe)"
if strmf1[self.sql.strmf1_col.index("st1_type")] == "X":
return "Invalid Code (Redundant)"
if strmf1[self.sql.strmf1_col.index("st1_value_ind")] == "N":
return "Invalid Code (Value Indicator)"
self.vatcod = strmf1[self.sql.strmf1_col.index("st1_vatcode")]
strmf2 = self.sql.getRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.grp),
("st2_code", "=", w),
("st2_loc", "=", self.loc)],
limit=1)
if not strmf2:
return "Invalid Location"
odt = self.sql.getRec("strpot",
cols=["count(*)"],
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno),
("pot_group", "=", self.grp),
("pot_code", "=", w)],
limit=1)
if odt[0]:
return "This Item is Already On This Order"
odq = self.sql.getRec(tables=["strpom", "strpot"],
cols=["sum(pot_qty)"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_loc", "=", self.loc),
("pom_delno", "=", ""),
("pot_cono", "=", self.opts["conum"]),
("pot_ordno=pom_ordno", ),
("pot_group", "=", self.grp),
("pot_code", "=", w)],
limit=1)
if odq[0]:
state = self.df.disableButtonsTags()
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="DupOrd",
desc="%s of this Item is Already On Order" %
odq[0])
self.df.enableButtonsTags(state=state)
if cf.flag == "no":
return "rf"
self.code = w
desc = strmf1[self.sql.strmf1_col.index("st1_desc")]
self.uoi = strmf1[self.sql.strmf1_col.index("st1_uoi")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
def doDes(self, frt, pag, r, c, p, i, w):
self.desc = w
def doQty(self, frt, pag, r, c, p, i, w):
self.qty = w
self.df.loadEntry(frt, pag, p + 1, data=self.vatcod)
def doVat(self, frt, pag, r, c, p, i, w):
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trdt)
if self.vatrte is None:
return "Invalid V.A.T Code"
self.vatcod = w
# Last Cost Price
lcost = getCost(self.sql,
self.opts["conum"],
self.grp,
self.code,
loc=self.loc,
qty=1,
ind="L")
self.df.loadEntry(frt, pag, p + 1, data=lcost)
def doPri(self, frt, pag, r, c, p, i, w):
self.price = w
self.inc = round((self.price * (self.vatrte + 100.0) / 100.0), 4)
self.exc = round((self.price * 1), 2)
dis = self.crsmst[self.sql.crsmst_col.index("crm_trdis")]
self.df.loadEntry(frt, pag, p + 1, data=dis)
def doDis(self, frt, pag, r, c, p, i, w):
self.disrat = w
dis = float(ASD(100) - ASD(self.disrat))
self.excamt = round((self.qty * self.exc * dis / 100.0), 2)
self.incamt = round((self.qty * self.inc * dis / 100.0), 2)
self.vatamt = float(ASD(self.incamt) - ASD(self.excamt))
self.df.loadEntry(frt, pag, p + 1, data=self.excamt)
self.vattot = float(ASD(self.vattot) + ASD(self.vatamt))
self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt))
self.inctot = float(ASD(self.inctot) + ASD(self.incamt))
self.df.setViewPort("O", self.inctot)
def doColEnd(self):
# Create Purchase Order Transaction (Body)
data = [
self.opts["conum"], self.ordno, self.grp, self.code, self.uoi,
self.desc, self.qty, self.price, self.disrat, self.vatcod,
self.vatrte, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strpot", data=data)
if self.acttyp == "A":
self.amend = True
self.df.advanceLine(0)
def doCrsQuery(self):
callModule(self.opts["mf"],
self.df,
"cr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def doStkQuery(self):
callModule(self.opts["mf"],
self.df,
"st4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
def doDelAdd(self):
tit = ("Delivery Address", )
fld = ((("T", 0, 0, 0), "INA", 30, "Address-1", "Address Line 1", "",
"N", None, None, None,
None), (("T", 0, 1, 0), "INA", 30, "Address-2",
"Address Line 2", "", "N", None, None, None, None),
(("T", 0, 2, 0), "INA", 30, "Address-3", "Address Line 3", "",
"N", None, None, None, None),
(("T", 0, 3, 0), "INA", 30, "Address-4", "Address Line 4", "",
"N", None, None, None, None))
state = self.df.disableButtonsTags()
self.da = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doDelEnd, "n"), ),
txit=(self.doDelExit, ),
focus=False)
for x in range(0, len(self.deladd)):
self.da.loadEntry("T", 0, 0 + x, data=self.deladd[x])
self.da.focusField("T", 0, 1, clr=False)
self.da.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doDelEnd(self):
self.deladd = []
for x in range(0, self.da.topq[0]):
self.deladd.append(self.da.t_work[0][0][x])
self.doDelExit()
def doDelExit(self):
self.da.closeProcess()
def doMessag(self):
tit = ("Order Message", )
cod = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": [("mss_message", "", 0, "Cod"),
("mss_detail", "", 60, "Details")],
"where": [("mss_system", "=", "STR")],
"screen":
self.df.mstFrame
}
fld = ((("T", 0, 0, 0), "IUI", 3, "Message Code", "", "", "N",
self.doMesCod, cod, None, None),
(("T", 0, 1, 0), "ITv", (30, 6), "Message", "", self.message,
"N", None, None, None, None))
but = (("Accept", None, self.doMesEnd, 0, ("T", 0, 1), ("T", 0, 0)), )
state = self.df.disableButtonsTags()
self.mg = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doMesEnd, "n"), ),
txit=(self.doMesExit, ),
butt=but)
self.mg.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doMesCod(self, frt, pag, r, c, p, i, w):
if w:
mess = self.sql.getRec("ctlmes",
where=[("mss_system", "=", "STR"),
("mss_message", "=", w)],
limit=1)
if not mess:
return "Invalid Message Code"
self.message = mess[self.sql.ctlmse_col.index("mss_detail")]
self.mg.loadEntry(frt, pag, p + 1, data=self.message)
def doMesEnd(self):
wid, self.message = self.mg.getEntry("T", 0, 1)
self.doMesExit()
def doMesExit(self):
self.mg.closeProcess()
def doEdit(self):
# Display document items and allow editing of desc, qty and price
recs = self.sql.getRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno)],
order="pot_group, pot_code")
if recs:
data = []
for l in recs:
qty = CCD(l[self.sql.strpot_col.index("pot_qty")], "SD", 11.2)
prc = CCD(l[self.sql.strpot_col.index("pot_price")], "UD",
10.2)
dis = CCD(l[self.sql.strpot_col.index("pot_disper")], "UD",
6.2)
data.append([
l[self.sql.strpot_col.index("pot_group")],
l[self.sql.strpot_col.index("pot_code")],
l[self.sql.strpot_col.index("pot_desc")], qty.disp,
l[self.sql.strpot_col.index("pot_vatcod")], prc.disp,
dis.disp
])
head = ("Grp", "Product-Code", "Description", "Quantity", "V",
"Price", "Disc-%")
lin = {
"stype":
"C",
"head":
head,
"typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 11.2),
("UA", 1), ("UD", 10.2), ("UD", 6.2)),
"data":
data
}
state = self.df.disableButtonsTags()
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.change = chg.selection
self.doChanges()
self.df.enableButtonsTags(state=state)
self.df.focusField("C", 0, self.df.col)
def doChanges(self):
tit = ("Change Items", )
fld = ((("T", 0, 1, 0), "ONA", 3, "Group"), (("T", 0, 2, 0), "ONA", 20,
"Code"),
(("T", 0, 3, 0), "INA", 30, "Description", "", "", "N",
self.doChgDes, None, None, ("notblank", )),
(("T", 0, 4, 0), "ISD", 11.2, "Quantity", "", "", "N",
self.doChgQty, None, None, ("notzero", )),
(("T", 0, 5, 0), "IUD", 10.2, "Selling Price", "", "", "N",
self.doChgPrc, None, None, ("notzero", )),
(("T", 0, 6, 0), "IUD", 6.2, "Discount Percent", "", "", "N",
self.doChgDis, None, None, ("efld", )))
but = (("Delete", None, self.doChgDel, 1, None, None), )
tnd = ((self.doChgEnd, "n"), )
txt = (self.doChgExit, )
self.cg = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
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.loadEntry("T", 0, 4, data=self.change[5])
self.cg.loadEntry("T", 0, 5, data=self.change[6])
self.cg.focusField("T", 0, 3, clr=False)
self.cg.mstFrame.wait_window()
def doChgDes(self, frt, pag, r, c, p, i, w):
self.desc = w
def doChgQty(self, frt, pag, r, c, p, i, w):
self.qty = w
def doChgPrc(self, frt, pag, r, c, p, i, w):
self.price = w
def doChgDis(self, frt, pag, r, c, p, i, w):
self.disrat = w
def doChgDel(self):
grp = self.change[0]
cod = self.change[1]
self.sql.delRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno),
("pot_group", "=", grp),
("pot_code", "=", cod)])
if self.acttyp == "A":
self.amend = True
self.doChgExit(loader=True)
def doChgEnd(self):
grp = self.change[0]
cod = self.change[1]
col = ["pot_desc", "pot_qty", "pot_price", "pot_disper"]
dat = [self.desc, self.qty, self.price, self.disrat]
whr = [("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno), ("pot_group", "=", grp),
("pot_code", "=", cod)]
self.sql.updRec("strpot", cols=col, data=dat, where=whr)
if self.acttyp == "A":
self.amend = True
self.doChgExit(loader=True)
def doChgExit(self, loader=False):
self.cg.closeProcess()
if loader:
self.doReadLoadStr()
def doReprnt(self):
tit = ("Reprint Orders", )
odr = {
"stype":
"R",
"tables": ("strpom", "crsmst"),
"cols": [("pom_ordno", "", 0, "Doc-Num"),
("pom_date", "", 0, "Date"),
("pom_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")],
"where": [("pom_cono", "=", self.opts["conum"]),
("pom_cono=crm_cono", ), ("pom_acno=crm_acno", )],
"screen":
self.opts["mf"].body
}
r1s = (("Copies", "C"), ("Originals", "O"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Document Mode", "", "C", "N",
self.doMode, None, None, None),
(("T", 0, 1, 0), "IUI", 9, "From Number",
"From Document Number", "", "N", self.doOrd, odr, None,
("notzero", )), [("T", 0, 2, 0), "IUI", 9, "To Number",
"To Document Number", "", "N", None, odr,
None, ("notzero", )])
state = self.df.disableButtonsTags()
self.rp = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doReprntEnd, "n"), ),
txit=(self.doReprntExit, ),
view=("N", "V"),
mail=("B", "Y"))
self.rp.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doMode(self, frt, pag, r, c, p, i, w):
if w == "C":
self.copy = "y"
else:
self.copy = "n"
def doOrd(self, frt, pag, r, c, p, i, w):
self.rp.topf[pag][2][5] = w
def doReprntEnd(self):
self.rp.closeProcess()
self.df.setWidget(self.df.mstFrame, state="hide")
frm = self.rp.t_work[0][0][1]
if not self.rp.t_work[0][0][2]:
to = frm
else:
to = self.rp.t_work[0][0][2]
odr = self.sql.getRec("strpom",
cols=["pom_ordno"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", ">=", frm),
("pom_ordno", "<=", to)])
if odr:
PrintOrder(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
odr,
tname=self.tname,
repprt=self.rp.repprt,
repeml=self.rp.repeml,
copy=self.copy)
self.df.setWidget(self.df.mstFrame, state="show")
def doReprntExit(self):
self.rp.closeProcess()
def doCrsMaint(self):
state = self.df.disableButtonsTags()
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="NewCrs")
if cf.flag == "yes":
callModule(self.opts["mf"],
self.df,
"cr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doStrMaint(self):
state = self.df.disableButtonsTags()
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="NewStr")
if cf.flag == "yes":
callModule(self.opts["mf"],
self.df,
"st1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doAccept(self):
self.df.setWidget(self.df.B11, "disabled")
if self.df.col == 1:
self.doCancel()
else:
# Update Tables
self.doUpdateTables()
# Commit Transaction
self.opts["mf"].dbm.commitDbase()
# Print Document
if self.acttyp == "N" or (self.acttyp == "A" and self.amend):
self.df.setWidget(self.df.mstFrame, state="hide")
PrintOrder(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.ordno,
tname=self.tname,
repprt=self.pr.repprt,
repeml=self.pr.repeml,
copy=self.acttyp.lower())
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField("T", 0, 1)
def doRibbon(self):
tit = ("Ribbon Line", )
fld = ((("T", 0, 0, 0), "INA", 30, "Customer Order", "", self.cnam,
"N", None, None, None, None),
(("T", 0, 1,
0), "INA", 30, "Job Number", "", self.cnam, "N", None, None,
None, None), (("T", 0, 2, 0), "INA", 30, "Contact Person", "",
self.cnam, "N", None, None, None, None),
(("T", 0, 3, 0), "INA", 10, "VAT Number", "", self.vatn, "N",
self.doVatNum, None, None, None))
state = self.df.disableButtonsTags()
self.rb = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doRibEnd, "n"), ),
txit=(self.doRibExit, ),
focus=False)
if self.ribbon:
self.rb.loadEntry("T", 0, 0, data=self.ribbon[0])
self.rb.loadEntry("T", 0, 1, data=self.ribbon[1])
self.rb.loadEntry("T", 0, 2, data=self.ribbon[2])
self.rb.loadEntry("T", 0, 3, data=self.ribbon[3])
self.rb.focusField("T", 0, 1)
self.rb.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doVatNum(self, frt, pag, r, c, p, i, w):
if self.ordtot >= 1000.00 and not w:
return "Invalid VAT Number"
def doRibEnd(self):
self.ribbon = []
for x in range(0, self.rb.topq[0]):
self.ribbon.append(self.rb.t_work[0][0][x])
self.doRibExit()
def doRibExit(self):
self.rb.closeProcess()
def doUpdateTables(self):
# Update strpom with ribbon, delivery and message details
whr = [("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)]
if self.ribbon:
self.sql.updRec(
"strpom",
cols=["pom_cusord", "pom_jobnum", "pom_contact", "pom_vatno"],
data=[
self.ribbon[0], self.ribbon[1], self.ribbon[2],
self.ribbon[3]
],
where=whr)
if not self.vatn:
self.sql.updRec("crsmst",
cols=["crm_vatno"],
data=[self.ribbon[1]],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.acno)])
if self.deladd:
self.sql.updRec(
"strpom",
cols=["pom_add1", "pom_add2", "pom_add3", "pom_add4"],
data=[
self.deladd[0], self.deladd[1], self.deladd[2],
self.deladd[3]
],
where=whr)
if self.message:
self.sql.updRec("strpom",
cols=["pom_mess"],
data=[self.message],
where=whr)
if self.acttyp != "R":
return
# Receipt of Order
# Create Stores Transactions and update strpot lines
trn = self.sql.getRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno)],
order="pot_group, pot_code")
if not trn:
return
for line in trn:
self.doExtData(line)
curdt = int(self.deldt / 100)
# Update strpom record
self.sql.updRec("strpom",
cols=["pom_delno", "pom_deldt"],
data=[self.delno, self.deldt],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno)])
# Write strtrn record
data = [
self.opts["conum"], self.grp, self.code, self.loc, self.deldt,
1, self.othno, self.batch, self.delno, self.qty, self.excamt,
0, curdt, self.name, 0, self.acno, "", "STR", self.disrat, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# If Integrated Create GL Transaction (SOH and Recon Accounts)
if self.stgl == "Y" and self.excamt:
# Stock on Hand Control
data = (self.opts["conum"], self.soh, curdt, self.deldt, 5,
self.othno, self.batch, self.excamt, 0, self.name, "",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
cst = float(ASD(0) - ASD(self.excamt))
# Stock Reconciliation Control
data = (self.opts["conum"], self.ssp, curdt, self.deldt, 5,
self.othno, self.batch, cst, 0, self.name, "", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doExtData(self, line):
self.grp = line[self.sql.strpot_col.index("pot_group")]
self.code = line[self.sql.strpot_col.index("pot_code")]
self.uoi = line[self.sql.strpot_col.index("pot_uoi")]
self.desc = line[self.sql.strpot_col.index("pot_desc")]
self.qty = line[self.sql.strpot_col.index("pot_qty")]
self.price = line[self.sql.strpot_col.index("pot_price")]
self.disrat = line[self.sql.strpot_col.index("pot_disper")]
self.vatcod = line[self.sql.strpot_col.index("pot_vatcod")]
self.vatrte = line[self.sql.strpot_col.index("pot_vatrat")]
# Calculate Values
rat = float(ASD(100) + ASD(self.vatrte))
inc = round((self.price * rat / 100.0), 4)
exc = round((self.price * 1), 2)
dis = float(ASD(100) - ASD(self.disrat))
self.excamt = round((self.qty * exc * dis / 100.0), 2)
self.incamt = round((self.qty * inc * dis / 100.0), 2)
self.vatamt = float(ASD(self.incamt) - ASD(self.excamt))
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
if self.acttyp == "N":
self.sql.updRec("strpom",
cols=["pom_delno"],
data=["cancel"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno),
("pom_acno", "=", self.acno)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
class dr2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] != 2:
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
# Setup SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "ctlvmf", "drschn", "drsmst", "drstrn", "genint",
"genmst", "gentrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst",
cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])],
limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
#
self.gc = GetCtl(self.opts["mf"])
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.chains = drsctl["ctd_chain"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.drsctl = ctlctl["drs_ctl"]
self.dis_all = ctlctl["dis_all"]
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.allcoy = self.opts["conum"]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.chains == "N":
self.chain = 0
self.glt = 6
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"DRS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
drc = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"])]
drm["whera"] = [["C", "drm_chain", 0, 1]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
coy = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))
}
viw = {
"stype":
"R",
"tables": ("drstrn", ),
"cols": (("drt_chain", "", 0, ""), ("drt_acno", "", 0, ""),
("drt_ref1", "", 0, ""), ("drt_trdt", "", 0, ""),
("drt_tramt", "", 0, ""), ("drt_taxamt", "", 0, "")),
"where": [("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_batch", "=", self.bh.batno)],
"order":
"drt_seq"
}
tag = (("Deposit", None, None, None, False), ("Allocation", None, None,
None, False))
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One",
"i", "Y", self.doRef1, None, None, ("efld", )),
(("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 3), "INA", (30), "Details", "Deposit Details", "",
"N", self.doTrnDet, None, None, None),
(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
[("C", 2, 0, 0), "OUI", 3, "Coy", "Company Number",
self.opts["conum"], "N", self.doCoyNum, coy, None,
("notzero", )],
[("C", 2, 0, 1), "IUI", 3, "Chn", "Chain Store", "r", "N",
self.doChain, drc, None, ("efld", )],
(("C", 2, 0, 2), "INA", 7, "Acc-Num", "Account Number", "r",
"N", self.doDrsAcc, drm, None, ("notblank", )),
(("C", 2, 0, 3), "ONA", 30, "Name"),
(("C", 2, 0, 4), "ISD", 13.2, "Receipt", "Receipt Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 5), "ISD", 13.2, "Discount", "Discount Amount", "",
"N", self.doDisAmt, None, None, ("efld", ), None,
"Discount Amount to be Added to the Receipt Amount"),
(("C", 2, 0, 6), "OSD", 13.2, "Total-Amount")]
if self.glint == "Y" and self.incoac:
fld[7][1] = "IUI"
if self.chains == "N":
fld[8][1] = "OUI"
but = [("View Entries", viw, None, 1, ("C", 2, 3), ("C", 2, 4),
"View Batch Transactions", 1),
("Interrogate", None, self.queryDrs, 0, ("C", 2, 3),
("C", 2, 0), "Interrogate Debtors Accounts", 1),
("Maintain", None, self.maintainDrs, 0, ("C", 2, 3),
("C", 2, 4), "Maintain Debtors Accounts", 1),
("Canc_el", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1), "", 1)]
else:
but = [("View Entries", viw, None, 0, ("C", 2, 3), ("C", 2, 4),
"View Batch Transactions", 1),
("Interrogate", None, self.queryDrs, 0, ("C", 2, 2),
("C", 2, 0), "Interrogate Debtors Accounts", 1),
("Maintain", None, self.maintainDrs, 0, ("C", 2, 2),
("C", 2, 3), "Maintain Debtors Accounts", 1),
("Canc_el", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1), "", 1)]
but.extend((
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",2),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions, Including Already Allocated",2),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",2),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",2)))
txt = (None, None, None)
cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")]
cxt = [None, self.exitPage1, self.exitPage2]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doRef1(self, frt, pag, r, c, p, i, w):
if not w:
trns = self.sql.getRec("drstrn",
cols=["drt_ref1"],
where=[("drt_cono", "=",
self.opts["conum"]),
("drt_ref1", "like", "R________")],
order="drt_ref1 desc")
auto = False
for trn in trns:
try:
w = "R%08i" % (int(trn[0][1:]) + 1)
auto = True
break
except:
pass
if not auto:
w = "R00000001"
self.df.loadEntry(frt, pag, p, data=w)
chk = self.sql.getRec("drstrn",
cols=["drt_acno"],
where=[("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_ref1", "=", w)])
if chk:
return "A Transaction with this Reference Already Exists"
self.ref1 = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
self.allocated = float(0.00)
def endPage1(self):
self.agecan = False
self.batupd = False
self.updateTables1()
self.updateBatch()
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.glint == "Y":
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not acc:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", w),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.allcoy = w
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
cols=["chm_chain"],
where=[("chm_cono", "=", self.allcoy),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doDrsAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.allcoy),
("drm_chain", "=", self.chain),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.dracno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.allref = self.ref1
while self.sql.getRec("drstrn",
cols=["drt_batch"],
where=[("drt_cono", "=", self.allcoy),
("drt_chain", "=", self.chain),
("drt_acno", "=", self.dracno),
("drt_type", "=", self.opts["rtn"]),
("drt_ref1", "=", self.allref)]):
self.doGetAnotherRef()
def doGetAnotherRef(self):
tit = ("Duplicate Reference Number", )
fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref,
"N", None, None, None, None),
(("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N",
self.doRefNew, None, None, ("notblank", )))
tnd = ((self.doRefEnd, "n"), )
txt = (self.doRefExit, )
state = self.df.disableButtonsTags()
self.tf = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=tnd,
txit=txt)
self.tf.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doRefExit(self):
self.tf.focusField("T", 0, 2)
def doRefNew(self, frt, pag, r, c, p, i, w):
self.allref = w
def doRefEnd(self):
self.tf.closeProcess()
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
ok = self.checkSign()
elif self.allamt > 0 and w < 0:
ok = self.checkSign()
else:
ok = "yes"
if ok != "yes":
return "Invalid Discount Amount (Sign Error)"
self.disamt = w
totamt = float(ASD(self.allamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def checkSign(self):
return askQuestion(self.opts["mf"].body, "Check Sign",
"The Sign of the Discount Amount is not the same "\
"as the Sign of the Receipt Amount, Is This Correct?")
def endPage2(self):
self.amt = float(ASD(0) - ASD(self.allamt))
self.dis = float(ASD(0) - ASD(self.disamt))
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
# Debtors Ledger Transaction
data = [
self.allcoy, self.chain, self.dracno, self.opts["rtn"],
self.allref, self.bh.batno, self.trndat, "", self.amt, 0.00,
self.curdt, self.trndet, "", "N", self.opts["capnm"], self.sysdtw,
0
]
self.sql.insRec("drstrn", data=data)
if self.dis:
data = [
self.allcoy, self.chain, self.dracno, 6, self.allref,
self.bh.batno, self.trndat, "", self.dis, 0.00, self.curdt,
self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("drstrn", data=data)
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.glint == "Y":
# General Ledger Control Transaction (Debtors)
amt = float(ASD(self.amt) + ASD(self.dis))
data = (self.allcoy, self.drsctl, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.disamt:
data = (self.allcoy, self.dis_all, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, self.disamt,
0.00, self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany)
if self.allcoy != self.opts["conum"]:
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=",
self.opts["conum"]),
("cti_inco", "=", self.allcoy)],
limit=1)[0]
data = (self.opts["conum"], acc, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.allcoy),
("cti_inco", "=",
self.opts["conum"])],
limit=1)[0]
amt = float(ASD(0) - ASD(self.amt))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.allref, self.bh.batno, amt, 0.00, self.trndet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="drs",
agetyp=atype,
agekey=[
self.allcoy, self.chain, self.dracno,
self.opts["rtn"], self.allref, self.curdt, self.amt,
self.dis
])
self.agecan = age.cancel
self.agevar.set(False)
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryDrs(self):
callModule(self.opts["mf"],
self.df,
"dr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def maintainDrs(self):
callModule(self.opts["mf"],
self.df,
"dr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class tb1010(object):
def __init__(self, **opts):
self.opts = opts
self.opts["mf"].dbm.openDbase()
if self.setVariables():
self.doProcess()
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
return True
def doProcess(self):
fft = {
"stype":
"R",
"tables": ("ftable", ),
"cols": (("ft_tabl", "", 0, "Table"), ("ft_desc", "", 0,
"Description", "Y")),
"where": [("ft_seq", "=", 1)]
}
ffl = {
"stype":
"R",
"tables": ("ffield", ),
"cols": (("ff_seq", "", 0, "Seq"), ("ff_name", "", 0, "Name"),
("ff_desc", "", 0, "Description", "Y"),
("ff_type", "", 0, "Tp"), ("ff_size", "", 0, "Size")),
"whera": (("T", "ff_tabl", 0, 0), ),
"index":
0
}
ffi = {
"stype":
"R",
"tables": ("ftable", ),
"cols":
(("ft_seq", "", 0, "Seq"), ("ft_type", "", 0,
"T"), ("ft_key0", "", 0, "Column-1"),
("ft_key1", "", 0, "Column-2"), ("ft_key2", "", 0, "Column-3"),
("ft_key3", "", 0, "Column-4"), ("ft_key4", "", 0, "Column-5"),
("ft_key4", "", 0, "Column-6"), ("ft_key4", "", 0, "Column-7")),
"whera": (("T", "ft_tabl", 0, 0), ),
"comnd":
self.doIdxCmd
}
typ = {
"stype": "C",
"titl": "Select the Required Data Type",
"head": ("Cd", "Description"),
"data": dattyp,
"index": 0
}
valtyp = []
for t in dattyp:
valtyp.append(t[0])
self.col = {
"stype": "C",
"titl": "Select the Required Column",
"head": ("Table", "Description"),
"data": []
}
fld = [(("T", 0, 0, 0), "INA", 20, "Table ", "Table Name", "", "Y",
self.doTable, fft, None, ("notin", ("", "ftable", "ffield"))),
(("T", 0, 0, 0), "INA", 30, " Description ", "Description", "",
"N", self.doDesc, None, None, None),
(("C", 1, 0, 0), "IUI", 3, "Seq", "Column Sequence", "i", "N",
self.doColSeq, ffl, None, ("between", 0, 999)),
(("C", 1, 0, 1), "INA", 20, "Column", "Column Name", "", "N",
None, None, None, ("notblank", )),
(("C", 1, 0, 2), "INA", 2, "Tp", "Data Type", "", "N", None,
typ, None, ("in", valtyp)),
(("C", 1, 0, 3), "IUD", 6.1, "Size", "Field Size", "", "N",
None, None, None, ("notzero", )),
(("C", 1, 0, 4), "INA", 30, "Description", "", "", "N", None,
None, None, None),
(("C", 1, 0, 5), "INA", 30, "Heading", "Report Heading", "",
"N", None, None, None, ("notblank", )),
(("C", 2, 0, 0), "IUI", 1, "S", "Sequence", "i", "N",
self.doIdxSeq, ffi, None, ("efld", )),
(("C", 2, 0, 1), "IUA", 1, "T", "Type (U/N)", "", "N", None,
None, None, ("in", ("U", "N"))),
(("C", 2, 0, 2), "INA", (14, 20), "Column-0", "", "", "N",
self.doIdxCol, self.col, None, ("notblank", )),
(("C", 2, 0, 3), "INA", (14, 20), "Column-1", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 4), "INA", (14, 20), "Column-2", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 5), "INA", (14, 20), "Column-3", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 6), "INA", (14, 20), "Column-4", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 7), "INA", (5, 20), "Col-5", "Column-5", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 8), "INA", (5, 20), "Col-6", "Column-6", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 9), "INA", (5, 20), "Col-7", "Column-7", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 10), "INA", (5, 20), "Col-8", "Column-8", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 11), "INA", (5, 20), "Col-9", "Column-9", "", "N",
self.doIdxCol, self.col, None, ("efld", ))]
tag = (("Columns", None, ("C", 1, 1), ("T", 0, 1)),
("Indexes", None, ("C", 1, 1), ("T", 0, 1)))
row = (0, 15, 5)
tnd = ((self.endTop, "y"), )
txt = (self.exitTop, )
cnd = ((None, "n"), (self.endPage1, "y"), (self.endPage2, "y"))
cxt = (None, self.exitPage1, self.exitPage2)
but = (("Print", None, self.doPrint, 0, ("T", 0, 2), ("T", 0, 1)),
("Cancel", None, self.doRestart, 0, ("T", 0, 2), ("T", 0, 1)))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
rows=row,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doTable(self, frt, pag, r, c, p, i, w):
self.tab = w
tab = self.sql.getRec("ftable",
cols=["ft_tabl", "ft_desc"],
where=[("ft_tabl", "=", w), ("ft_seq", "=", 1)],
limit=1)
if not tab:
self.new = "y"
else:
self.new = "n"
self.df.loadEntry(frt, pag, p + 1, data=tab[1])
yn = askQuestion(screen=self.opts["mf"].body, head="Table Exists",
mess="Changing This Record Could Result In Loss of Data, "\
"Are You Sure You Want to Continue?", default="no")
if yn == "no":
return yn
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def endTop(self):
self.fld = makeArray(6, 100, 1, "S")
self.idx = makeArray(12, 20, 1, "S")
if self.new == "n":
fld = self.sql.getRec("ffield",
where=[("ff_tabl", "=", self.tab)],
order="ff_seq")
for n, f in enumerate(fld):
self.fld[n] = f[1:]
idx = self.sql.getRec("ftable",
where=[("ft_tabl", "=", self.tab)],
order="ft_seq")
for n, f in enumerate(idx):
self.idx[n] = f[2:]
self.idx[n][0] = n
self.doPopulate("fld")
else:
self.df.focusField("C", 1, 1)
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doColSeq(self, frt, pag, r, c, p, i, w):
self.colseq = w
for n, s in enumerate(self.fld[self.colseq][1:]):
self.df.loadEntry("C", 1, p + n + 1, data=s)
def endPage1(self):
pos = int(self.df.col / self.df.colq[1]) - 1
self.fld[self.colseq] = copyList(self.df.c_work[1][pos])
self.doPopulate("fld")
def exitPage1(self):
self.createCols()
self.df.selPage("Indexes")
self.doPopulate("idx")
def createCols(self):
self.valcol = []
self.col["data"] = []
for fld in self.fld:
self.valcol.append(fld[1])
self.col["data"].append([fld[1], fld[4]])
def doIdxCmd(self, frt, pag, r, c, p, i, w):
idxseq = int(w[0]) - 1
self.doIdxSeq(frt, pag, r, c, p, i, idxseq)
self.df.focusField(frt, pag, c + 1)
def doIdxSeq(self, frt, pag, r, c, p, i, w):
self.idxseq = w
for n, s in enumerate(self.idx[self.idxseq][1:]):
self.df.loadEntry("C", 2, p + n + 1, data=s)
def doIdxCol(self, frt, pag, r, c, p, i, w):
if w and w not in self.valcol:
return "Invalid Column"
def endPage2(self):
pos = int(self.df.col / self.df.colq[2]) - 1
self.idx[self.idxseq] = copyList(self.df.c_work[2][pos])
self.doPopulate("idx")
def exitPage2(self):
if self.new == "y" and self.df.col == 1:
self.df.selPage("Columns")
else:
if self.tab in tabdic:
tabdic[self.tab]["fld"] = []
tabdic[self.tab]["idx"] = []
else:
tabdic[self.tab] = {"fld": [], "idx": []}
for dat in self.fld:
if dat == [""] * 6:
break
tabdic[self.tab]["fld"].append(dat)
for num, dat in enumerate(self.idx):
if dat == [""] * 12:
break
if num == 0:
dat.insert(0, self.df.t_work[0][0][1])
else:
dat.insert(0, "")
dat[1] = num + 1
fmt = '"%s",%s,"%s"'
ddd = dat[:3]
for n, d in enumerate(dat[3:]):
if d:
fmt += ',"%s"'
ddd.append(d)
fmt += "\n"
tabdic[self.tab]["idx"].append(ddd)
fle = os.path.join(getPrgPath(), "stdtab.py")
outf = open(fle, "w")
outf.write("""tabdic = {""")
tabs = list(tabdic.keys())
tabs.sort()
for tab in tabs:
outf.write("""
"%s": {""" % tab)
for key in ("fld", "idx"):
outf.write("""
"%s": [""" % key)
for fld in tabdic[tab][key]:
outf.write("""
%s""" % json.dumps(fld))
if fld == tabdic[tab][key][-1]:
outf.write("""]""")
else:
outf.write(""",""")
if key == "fld":
outf.write(""",""")
outf.write("""}""")
if tab != tabs[-1]:
outf.write(""",""")
outf.write("""}""")
outf.close()
self.doRestart()
def doPopulate(self, ftyp=None):
if ftyp == "fld":
self.df.clearFrame("C", 1)
for num, dat in enumerate(self.fld):
if dat == [""] * 6:
break
if num > 14:
self.df.scrollScreen(1)
pos = 14
else:
pos = num
self.df.focusField("C", 1, (pos * 6) + 1)
for n, c in enumerate(dat):
self.df.loadEntry("C", 1, (pos * 6) + n, data=c)
self.df.advanceLine(1)
return
self.df.clearFrame("C", 2)
for num, dat in enumerate(self.idx):
if dat == [""] * 12:
break
if num > 4:
self.df.scrollScreen(2)
pos = 4
else:
pos = num
self.df.focusField("C", 2, (pos * 12) + 1)
for n, c in enumerate(dat):
self.df.loadEntry("C", 2, (pos * 12) + n, data=c)
self.df.advanceLine(2)
self.df.focusField("C", 2, self.df.col)
def doRestart(self):
self.df.last[0] = [0, 0]
self.df.selPage("Columns")
self.df.focusField("T", 0, 1)
def doPrint(self):
state = self.df.disableButtonsTags()
cols = [["ff_seq", "UI", 3.0, "Seq"],
["ff_name", "NA", 20.0, "Field Name"],
["ff_type", "NA", 2.0, "Tp"], ["ff_size", "NA", 6.1, "Size"],
["ff_desc", "NA", 30.0, "Description"],
["ff_head", "NA", 20.0, "Heading"]]
whr = [("ff_tabl", "=", self.tab)]
RepPrt(self.opts["mf"],
name=self.tab + "_fld",
tables=["ffield"],
heads=[
"Table Fields for Table %s" % self.tab,
],
cols=cols,
where=whr)
cols = [["ft_desc", "NA", 30.0, "Table Description"],
["ft_seq", "UI", 2.0, "Sq"], ["ft_type", "NA", 1.0, "T"],
["ft_key0", "NA", 10.0, "1st-Key"],
["ft_key1", "NA", 10.0, "2nd-Key"],
["ft_key2", "NA", 10.0, "3rd-Key"],
["ft_key3", "NA", 10.0, "4th-Key"],
["ft_key4", "NA", 10.0, "5th-Key"],
["ft_key5", "NA", 10.0, "6th-Key"],
["ft_key6", "NA", 10.0, "7th-Key"],
["ft_key7", "NA", 10.0, "8th-Key"],
["ft_key8", "NA", 10.0, "9th-Key"],
["ft_key9", "NA", 10.0, "10th-Key"]]
whr = [("ft_tabl", "=", self.tab)]
RepPrt(self.opts["mf"],
name=self.tab + "_idx",
tables=["ftable"],
heads=[
"Table Keys for Table %s" % self.tab,
],
cols=cols,
where=whr)
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
