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 cr3080(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
crsctl = gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sql = Sql(self.opts["mf"].dbm, [
"ctlctl", "ctlmst", "crsctl", "crsmst", "crstrn", "crsage",
"gentrn", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
self.glint = crsctl["ctc_glint"]
self.bestac = crsctl["ctc_bestac"]
self.besttp = crsctl["ctc_besttp"]
self.bankac = crsctl["ctc_bankac"]
self.tplnam = crsctl["ctc_tplnam"]
self.fromad = crsctl["ctc_emadd"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if gc.chkRec(self.opts["conum"], ctlctl, ["crs_ctl"]):
return
self.crsctl = ctlctl["crs_ctl"]
acc = self.sql.getRec("crstrn",
cols=["max(crt_ref1)"],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_type", "=", 5),
("crt_ref1", "like", "EFT______")],
limit=1)
try:
self.cats = int(acc[0][3:])
self.refs = int(acc[0][3:]) + 1
except:
self.cats = 0
self.refs = 1
self.etotal = 0
return True
def mainProcess(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "R"), ("tpm_system", "=", "CRS")],
"order":
"tpm_tname"
}
crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols":
(("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")),
"where": [("crm_cono", "=", self.opts["conum"]),
("crm_stat", "<>", "X")]
}
r1s = (("Yes", "Y"), ("Range", "R"), ("Singles", "S"))
r2s = (("Yes", "Y"), ("No", "N"))
r3s = (("Number", "N"), ("Name", "M"), ("Postal Code", "P"))
r4s = (("Monthly", "M"), ("Daily", "D"))
fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.tplnam,
"Y", self.doTplNam, tpm, None, None),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Whole File", "", "S", "Y",
self.doWhole, None, None, None), [["T", 0, 2, 0], "INA", 7,
"From Account", "", "", "Y",
self.doAcc, crm, None, None],
[["T", 0, 3, 0], "INA", 7, "To Account", "", "", "Y",
self.doAcc, crm, None,
None], (("T", 0, 4, 0), ("IRB", r3s), 0, "Sort Order", "", "N",
"Y", self.doSort, None, None, None),
(("T", 0, 5, 0), ("IRB", r4s), 0, "Terms Base", "", "M", "Y",
self.doFrequency, None, None,
None), (("T", 0, 6, 0), ("IRB", r2s), 0, "Exceptions", "", "N",
"Y", self.doExcepts, None, None, None),
(("T", 0, 7, 0), "ID1", 10, "Due Date", "", self.sysdtw, "Y",
self.doDuedat, None, None, ("efld", )),
(("T", 0, 8, 0), "ID1", 10, "Payment Date", "", self.sysdtw,
"Y", self.doPaydat, None, None, ("efld", )))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("B", "Y"))
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "R"),
("tpm_system", "=", "CRS")],
limit=1)
if not acc:
return "Invalid Template Name"
self.tname = w
def doWhole(self, frt, pag, r, c, p, i, w):
self.whole = w
if self.whole in ("Y", "S"):
self.sacc = ""
self.eacc = ""
self.df.loadEntry("T", 0, p + 1, data=self.sacc)
self.df.loadEntry("T", 0, p + 2, data=self.eacc)
return "sk2"
def doAcc(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("crsmst",
cols=["crm_name", "crm_stat"],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not chk:
return "Invalid Creditors Account"
if not chk[1] == "X":
return "Invalid Account, Redundant"
if c == 3:
self.sacc = w
else:
self.eacc = w
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
def doFrequency(self, frt, pag, r, c, p, i, w):
self.freq = w
def doExcepts(self, frt, pag, r, c, p, i, w):
self.excepts = w
def doDuedat(self, frt, pag, r, c, p, i, w):
self.duedtw = w
self.duedtd = self.df.t_disp[pag][0][p]
def doPaydat(self, frt, pag, r, c, p, i, w):
self.paydtw = w
self.paydtd = self.df.t_disp[pag][0][p]
self.curdt = int(self.paydtw / 100)
self.batno = "E%s" % self.curdt
def doEnd(self):
self.df.closeProcess()
if self.excepts == "Y":
self.doExceptions()
self.emadd = self.df.repeml[2]
if self.bestac:
self.export = open(
os.path.join(
self.opts["mf"].rcdic["wrkdir"],
"best%03d_%s.txt" % (self.opts["conum"], self.paydtw)),
"w")
# Header for BEST
self.export.write("%1s%4s%-40s%8s%1s%8s%-15s%1s%2s%1s%9s%2s%4s"\
"\r\n" % ("*", self.bestac, self.opts["conam"], self.paydtw,
"Y", "", "CREDITORS EFT", "+", self.besttp, 0, "", "01",
"LIVE"))
else:
self.export = None
if self.whole == "S":
recs = getSingleRecords(self.opts["mf"],
"crsmst", ("crm_acno", "crm_name"),
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_termsb", "=", self.freq),
("crm_pyind", "<>", "N"),
("crm_stat", "<>", "X")])
else:
if not self.eacc:
self.eacc = "zzzzzzz"
whr = [("crm_cono", "=", self.opts["conum"]),
("crm_acno", "between", self.sacc, self.eacc),
("crm_termsb", "=", self.freq), ("crm_pyind", "<>", "N"),
("crm_stat", "<>", "X")]
if self.sort == "N":
odr = "crm_acno"
elif self.sort == "M":
odr = "crm_name"
else:
odr = "crm_pcod"
recs = self.sql.getRec("crsmst", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Error",
"No Accounts Selected")
if recs:
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
for num, rec in enumerate(recs):
p.displayProgress(num)
if p.quit:
self.opts["mf"].dbm.rollbackDbase()
break
self.doProcess(rec)
p.closeProgress()
if p.quit or not self.form.page:
pass
elif self.df.repeml[1] == "N" or self.emadd:
self.df.repeml[2] = self.emadd
self.doPrint()
if self.bestac:
# Trailer for BEST
value = int(round((self.etotal * 100), 0))
self.export.write("%1s%4s%1s%30s%013u%47s\r\n" % \
(2, self.bestac, "T", "", value, ""))
self.export.close()
if self.glint == "Y" and self.etotal:
# Create total transactions in GL
data = [
self.opts["conum"], self.crsctl, self.curdt,
self.paydtw, 2, self.refno, self.batno, self.etotal,
0.0,
"Payment EFT%06i to EFT%06i" % (self.refs, self.cats),
"", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
data[1] = self.bankac
data[7] = float(ASD(0) - ASD(self.etotal))
self.sql.insRec("gentrn", data=data)
self.opts["mf"].dbm.commitDbase(
ask=True,
mess="""Would you like to commit all elecronic payments?
If you decide to do this, you must remember to upload the BEST file to the Bank otherwise you are NOT going to Reconcile!""",
default="no")
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doExceptions(self):
crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols":
(("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")),
"where": [("crm_cono", "=", self.opts["conum"]),
("crm_termsb", "=", self.freq), ("crm_stat", "<>", "X")]
}
crt = {
"stype":
"R",
"tables": ("crstrn", ),
"cols":
(("crt_ref1", "", 0, "Reference", "Y"), ("crt_type",
("XX", crtrtp), 3, "Typ"),
("crt_trdt", "", 0, "Date"), ("crt_tramt", "", 0, " Amount"),
("paid", "SD", 13.2,
" Paid"), ("balance", "SD", 13.2,
" Balance"), ("crt_paydt", "", 0, "Pay-Date"),
("crt_payind", "", 0, "I"), ("crt_payamt", "", 0, " Pay-Amnt")),
"wtype":
"D",
"where": [],
"order":
"crt_ref1"
}
types = []
for x in range(1, len(crtrtp) + 1):
types.append((x, crtrtp[x - 1][1]))
typ = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("C", "Type"),
"data": types
}
fld = ((("T", 0, 0,
0), "I@crm_acno", 0, "", "", "", "N", self.doExAcNo, crm,
None, ("notblank", )), (("T", 0, 0, 0), "O@crm_name", 0, ""),
(("C", 0, 0, 1), "I@crt_type", 0, "", "", "", "N",
self.doExTrnTyp, typ, None, ("in", (1, 2, 3, 4, 5))),
(("C", 0, 0, 0), "I@crt_ref1", 0, "", "", "", "N",
self.doExTrnRef, crt, None, ("notblank", )),
(("C", 0, 0, 2), "O@crt_trdt", 0, ""), (("C", 0, 0, 3), "OSD",
13.2, "Balance"),
(("C", 0, 0, 4), "I@crt_payind", 0, "", "", "", "N",
self.doExInd, None, None, ("in", ("Y", "N"))),
(("C", 0, 0, 5), "I@crt_paydt", 0, "", "", "", "N",
self.doExDte, None, None,
("efld", )), (("C", 0, 0, 6), "I@crt_payamt", 0, "", "", "",
"N", self.doExAmt, None, None, ("efld", )))
tnd = ((self.doExEndTop, "n"), )
txt = (self.doExExitTop, )
cnd = ((self.doExEndCol, "y"), )
cxt = (self.doExExitCol, )
self.ex = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
self.ex.mstFrame.wait_window()
def doExAcNo(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(
"crsmst",
cols=["crm_name", "crm_termsb", "crm_pyind", "crm_stat"],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] != self.freq:
return "Invalid Terms Base"
if acc[2] == "N":
return "Invalid Payment Indicator"
if acc[3] == "X":
return "Invalid Account, Redundant"
self.exacc = w
self.ex.loadEntry(frt, pag, p + 1, data=acc[0])
def doExEndTop(self):
self.ex.focusField("C", 0, 1)
def doExExitTop(self):
self.opts["mf"].dbm.commitDbase(
ask=True, mess="Would you like to commit these exceptions?")
self.ex.closeProcess()
def doExTrnTyp(self, frt, pag, r, c, p, i, w):
self.extyp = w
data = []
# Build the data for the F1 choice selection
col, dat = getTrn(self.opts["mf"].dbm,
"crs",
whr=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.exacc),
("crt_type", "=", w)],
zer="N")
if dat:
cols = ("crt_ref1", "crt_type", "crt_trdt", "crt_tramt", "paid",
"balance", "crt_paydt", "crt_payind", "crt_payamt")
for d in dat:
rec = []
for cc in cols:
rec.append(d[col.index(cc)])
data.append(rec)
self.ex.colf[0][1][8]["where"] = data
def doExTrnRef(self, frt, pag, r, c, p, i, w):
col = ["crt_trdt", "balance", "crt_payind", "crt_paydt", "crt_payamt"]
whr = [("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.exacc), ("crt_type", "=", self.extyp),
("crt_ref1", "=", w)]
c, d = getTrn(self.opts["mf"].dbm, "crs", whr=whr, lim=1)
if not d:
return "Invalid Transaction Number"
if not d[0][c.index("balance")]:
return "Transaction Has No Balance"
self.exref = w
self.exdte = d[0][c.index("crt_paydt")]
self.examt = d[0][c.index("crt_payamt")]
for pos, fld in enumerate(col):
self.ex.loadEntry(frt, pag, p + 1 + pos, data=d[0][c.index(fld)])
def doExInd(self, frt, pag, r, c, p, i, w):
self.exind = w
if self.exind == "N":
return "nd"
def doExDte(self, frt, pag, r, c, p, i, w):
self.exdte = w
def doExAmt(self, frt, pag, r, c, p, i, w):
self.examt = w
def doExEndCol(self):
# Update Transaction"
self.sql.updRec("crstrn",
cols=["crt_payind", "crt_paydt", "crt_payamt"],
data=[self.exind, self.exdte, self.examt],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.exacc),
("crt_type", "=", self.extyp),
("crt_ref1", "=", self.exref)])
self.ex.advanceLine(0)
def doExExitCol(self):
self.ex.focusField("T", 0, 1)
def doLoadStatic(self):
cmc = self.sql.ctlmst_col
ctm = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])],
limit=1)
for fld in cmc:
dat = ctm[cmc.index(fld)]
if fld in self.form.tptp:
if fld == "ctm_logo":
self.form.letterhead(cmc, ctm, fld, dat)
continue
self.form.tptp[fld][1] = dat
if "letterhead" in self.form.tptp:
self.form.letterhead(cmc, ctm, "letterhead", None)
self.form.document_date(self.duedtd)
def doProcess(self, crm):
cmc = self.sql.crsmst_col
tdc = self.form.sql.tpldet_col
self.acno = crm[cmc.index("crm_acno")]
eml = crm[cmc.index("crm_acc_email")]
self.form.account_details("crm", cmc, crm, 1)
for col in cmc:
d = "%s_C00" % col
if d in self.form.newdic:
dat = crm[cmc.index(col)]
self.form.newdic[d][tdc.index("tpd_text")] = dat
jon = "cra_curdt <= %s" % self.curdt
whr = [("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.acno), ("crt_payind", "=", "Y"),
("crt_paydt", "<=", self.duedtw)]
ctc, crt = getTrn(self.opts["mf"].dbm,
"crs",
jon=jon,
whr=whr,
zer="N")
if not crt:
return
bal = 0
self.pay = 0
for d in crt:
if d[ctc.index("balance")] < 0:
d[ctc.index("crt_payamt")] = d[ctc.index("balance")]
bal = float(ASD(bal) + ASD(d[ctc.index("balance")]))
self.pay = float(ASD(self.pay) + ASD(d[ctc.index("crt_payamt")]))
if self.pay > bal:
self.pay = bal
if self.pay > 0:
self.bname = crm[cmc.index("crm_bname")]
self.bibt = crm[cmc.index("crm_bibt")]
self.bacc = crm[cmc.index("crm_bacc")]
if self.bname and self.bibt and self.bacc:
self.ptype = "E" # Electronic
test = False
while not test:
self.cats += 1
self.refno = "EFT%06i" % self.cats
# Check if Reference Number Already Exists
chk = self.sql.getRec("crstrn",
where=[("crt_cono", "=",
self.opts["conum"]),
("crt_acno", "=", self.acno),
("crt_type", "=", 5),
("crt_ref1", "=", self.refno)
])
if not chk:
test = True
else:
self.ptype = "C" # Cheque
self.doBody(ctc, crt, tdc)
self.doTotal(tdc)
self.doTail(tdc)
if self.df.repeml[1] == "Y" and not self.emadd:
self.df.repeml[2] = eml
self.doPrint()
def doPrint(self):
if self.df.repeml[1] == "Y" and not self.emadd:
key = "%s_%s" % (self.opts["conum"], self.acno)
else:
key = "%s_all" % self.opts["conum"]
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
key,
ext="pdf")
self.form.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header="%s Remittance Advice" % self.opts["conam"],
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
if self.df.repeml[1] == "Y":
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
def doBody(self, ctc, crt, tdc):
page = 0
count = 0
text = self.form.sql.tpldet_col.index("tpd_text")
for trans in crt:
trbal = trans[ctc.index("balance")]
payamt = trans[ctc.index("crt_payamt")]
if payamt > trbal:
payamt = trbal
trans[ctc.index("balance")] = payamt
if not count:
page += 1
count = self.doHeader(page)
if count == self.form.maxlines:
page = self.doCfwd(page)
count = self.doHeader(page)
for cod in self.form.body:
if cod == "type_code":
c = "crt_type"
elif cod == "line_paid":
c = "paid"
elif cod == "line_balance":
c = "balance"
else:
c = cod
d = "%s_C%02i" % (cod, count)
if cod == "type_code":
ttyp = trans[ctc.index(c)]
self.form.newdic[d][text] = crtrtp[ttyp - 1][0]
else:
self.form.newdic[d][text] = trans[ctc.index(c)]
self.form.doDrawDetail(self.form.newdic[d])
if self.ptype == "E" and self.bestac:
trtp = trans[ctc.index("crt_type")]
ref1 = trans[ctc.index("crt_ref1")]
# Create Ageing Transaction
self.sql.insRec("crsage",
data=[
self.opts["conum"], self.acno, trtp, ref1,
self.curdt, 5, self.refno, payamt, 0
])
count += 1
for x in range(count, self.form.maxlines):
for cod in self.form.body:
d = "%s_C%02i" % (cod, x)
self.form.newdic[d][tdc.index("tpd_text")] = "BLANK"
self.form.doDrawDetail(self.form.newdic[d])
def doHeader(self, page):
tdc = self.form.sql.tpldet_col
self.form.add_page()
for key in self.form.newkey:
nl = copyList(self.form.newdic[key])
if nl[tdc.index("tpd_place")] != "A":
continue
if nl[tdc.index("tpd_detseq")] == "crm_acno_C00":
nl[tdc.index("tpd_text")] = self.acno
elif nl[tdc.index("tpd_detseq")] == "page_number_C00":
nl[tdc.index("tpd_text")] = str(page)
self.form.doDrawDetail(nl)
return 0
def doCfwd(self, page):
if "carried_forward" in self.form.tptp:
tdc = self.form.sql.tpldet_col
line = copyList(self.form.cfwd)
line[tdc.index("tpd_text")] = "Continued on Page %i" % (page + 1)
self.form.doDrawDetail(line)
return page + 1
def doTotal(self, tdc):
for c in self.form.total:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
if c == "total_payment":
line[tdc.index("tpd_text")] = self.pay
self.form.doDrawDetail(line)
if self.ptype == "E" and self.bestac:
value = int(round((self.pay * 100), 0))
self.export.write("%1s%4s%06u%-7s%019u%1s%1s%011u%-20s%10s"\
"%-15s%1s\r\n" % (2, self.bestac, self.bibt, self.acno,
int(self.bacc), "", "1", value, self.bname, "",
self.opts["conam"][:15], ""))
self.etotal = float(ASD(self.etotal) + ASD(self.pay))
# Create Payment and Ageing Transaction
p = float(ASD(0) - ASD(self.pay))
self.sql.insRec("crstrn",
data=[
self.opts["conum"], self.acno, 5, self.refno,
self.batno, self.paydtw, "", p, 0.0, 0.0,
self.curdt, 0, "", 0.0, "Electronic Payment",
"", "", self.opts["capnm"], self.sysdtw, 0
])
self.sql.insRec("crsage",
data=[
self.opts["conum"], self.acno, 5, self.refno,
self.curdt, 5, self.refno, p, 0
])
def doTail(self, tdc):
for c in self.form.tail:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
if c == "eft_message" and self.ptype == "E" and self.bestac:
line[tdc.index("tpd_text")] = "ELECTRONIC TRANSFER AT %s "\
"REFERENCE %s" % (self.paydtd, self.refno)
self.form.doDrawDetail(line)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class 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 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 ar2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.gc = GetCtl(self.opts["mf"])
assctl = self.gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.rordp = assctl["cta_rordp"]
tabs = ["assgrp", "assmst", "assdep", "asstrn"]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.dend = projectDate(self.opts["period"][1][0], -1)
self.todat = 0
self.imports = False
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("assmst", ),
"cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0,
"Description", "Y")),
"where": [("asm_cono", "=", self.opts["conum"])],
"whera": [["C", "asm_group", 0, 0]]
}
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
self.fld = [(("T", 0, 0, 0), "ID1", 10, "Take-on Date", "", self.dend,
"N", self.doTakeOnDate, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N",
self.doAssGrp, grp, None, None),
(("C", 0, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "",
"N", self.doAssCod, cod, None, ("notblank", )),
(("C", 0, 0, 2), "INA", 30, "Description", "Description",
"", "N", self.doDesc, None, None, ("notblank", )),
(("C", 0, 0, 3), "INa", 3, "Dep", "Depreciation Code", "",
"N", self.doDepCode, dep, None, ("notblank", )),
(("C", 0, 0, 4), "ONA", 10, "Dp-Details"),
(("C", 0, 0, 5), "ID1", 10, "Purch-Date", "Purchase Date",
0, "N", self.doPurDat, None, None, ("efld", )),
(("C", 0, 0, 6), "IUD", 10.2, "Cost", "Original Cost", 0,
"N", self.doCost, None, None, ("notzero", )),
(("C", 0, 0,
7), "IUD", 10.2, "Coy-Dep", "Company Depreciation", 0,
"N", self.doCDep, None, None, ("efld", ))]
if self.rordp == "Y":
self.fld.append((("C", 0, 0, 8), "IUD", 10.2, "Rec-Dep",
"Receiver Depreciation", 0, "N", self.doRDep,
None, None, ("efld", )))
tnd = [[self.endPage, "y"]]
txt = (self.exitPage, )
cnd = [[self.endPage, "y"]]
cxt = (self.exitPage, )
but = ((("Import File",None,self.doImport,0,("T",0,0),("C",0,2),
"Import a CSV or XLS File having the following fields: "\
"Asset Group, Code, Description, Depreciation Code, "\
"Purchase Date, Original Cost, Company Depeciation and "\
"Receiver Depreciation if applicable"),))
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
rows=(15, ),
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doTakeOnDate(self, frt, pag, r, c, p, i, w):
if w < self.dend:
return "Invalid Date, Too Far in the Past"
self.todat = w
def doAssGrp(self, frt, pag, r, c, p, i, w):
self.group = w
col = ["asg_depcod"]
whr = [("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group)]
acc = self.sql.getRec("assgrp", cols=col, where=whr, limit=1)
if not acc:
return "Invalid Asset Group"
self.depcod = acc[0]
def doImport(self):
self.df.closeProcess()
self.imports = True
impcol = []
for num, fld in enumerate(self.fld[1:]):
if fld[0][3] == 4:
continue
if num > 4:
num -= 1
impcol.append([fld[4], num, fld[1][1:], fld[2]])
fi = FileImport(self.opts["mf"], impcol=impcol)
err = False
for row, data in enumerate(fi.impdat):
funcs = [
"doAssGrp", "doAssCod", "doDesc", "doDepCode", "doPurDat",
"doCost", "doCDep"
]
if self.rordp == "Y":
funcs.append("doRDep")
for col, func in enumerate(funcs):
err = getattr(self, "%s" % func)("", 0, 0, 0, 0, 0, data[col])
if err:
showError(
self.opts["mf"].body, "Import Error",
"""Row %s Column %s - %s - %s
Please Correct the Import File and Try Again.""" % (row, col, data[col], err))
break
if err:
break
self.endPage()
if err:
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
def doAssCod(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec("assmst",
cols=["asm_desc"],
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group),
("asm_code", "=", w)],
limit=1)
if acc:
ok = askQuestion(screen=self.opts["mf"].body,
head="Asset Exists",
mess="""Asset already exists, Replace?
Please Note that if you decide to Replace the Asset, the Original Asset will be Deleted along with any History which may exist.""",
default="no")
if ok == "no":
return "Invalid Asset"
self.sql.delRec("assmst",
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group),
("asm_code", "=", self.code)])
self.sql.delRec("asstrn",
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)])
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=self.depcod)
def doDepCode(self, frt, pag, r, c, p, i, w):
col = ["asd_rate1r", "asd_desc"]
chk = self.sql.getRec("assdep",
cols=col,
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.rate1r = chk[0]
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=chk[1])
def doPurDat(self, frt, pag, r, c, p, i, w):
if w > self.todat:
return "Invalid Date, After Financial Period"
self.purdat = w
def doCost(self, frt, pag, r, c, p, i, w):
self.ccst = w
if self.rordp == "Y":
self.rcst = w
else:
self.rcst = 0
def doCDep(self, frt, pag, r, c, p, i, w):
self.cdep = float(ASD(0) - ASD(w))
if self.rordp == "N":
self.rdep = 0
return
if not self.rate1r:
self.rdep = 0
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=self.rdep)
return "sk1"
def doRDep(self, frt, pag, r, c, p, i, w):
self.rdep = float(ASD(0) - ASD(w))
def endPage(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
return
data = [
self.opts["conum"], self.group, self.code, self.desc, self.depcod
]
self.sql.insRec("assmst", data=data)
data = [
self.opts["conum"], self.group, self.code, 3, "Take-On", "Take-On",
self.purdat, 1, self.ccst, self.rcst, 0,
int(self.purdat / 100), "Original Cost", "", "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.cdep or self.rdep:
data = [
self.opts["conum"], self.group, self.code, 3, "Take-On",
"Take-On", self.todat, 4, self.cdep, self.rdep, 0,
int(self.todat / 100), "Accumulated Depreciation", "", "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if not self.imports:
self.df.advanceLine(0)
def exitPage(self):
self.df.closeProcess()
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
class 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 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 st2030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.exit = False
self.setPrinter()
if not self.exit:
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"genmst", "gentrn", "strgrp", "strmf1", "strmf2", "strtrn",
"strrcp"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.stk_soh = ctlctl["stk_soh"]
self.stk_susp = ctlctl["stk_susp"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if self.locs == "N":
self.loc = "1"
self.glnum = 0
return True
def setPrinter(self):
tit = ("Printer Selection", )
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=[],
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "P"))
self.opts["mf"].startLoop()
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.pr.closeProcess()
self.opts["mf"].closeLoop()
def dataHeader(self):
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [["C", "st1_group", 0, 0]],
"order":
"st1_group, st1_code",
"index":
1
}
stl = {
"stype":
"R",
"tables": ("strloc", "strmf2"),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Location", "Y")),
"where": [("srl_cono", "=", self.opts["conum"]),
("srl_loc=st2_loc", ), ("st2_cono=srl_cono", )],
"whera": [["C", "st2_group", 0], ["C", "st2_code", 1]],
"order":
"srl_loc",
"index":
0
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N",
self.doIss, None, None, ("notblank", )),
(("T", 0, 0, 0), "ID1", 10, "Date", "Issue Date", self.sysdtw,
"N", self.doDte, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "N",
self.doGroup, gpm, None, ("notblank", )),
[("C", 0, 0, 1), "INA", 20, "Product Code", "", "", "N",
self.doCode, stm, None, ("notblank", )],
(("C", 0, 0, 2), "ONA", 5, "U.O.I"),
(("C", 0, 0, 3), "IUA", 1, "L", "Location", "r", "N",
self.doLoc, stl, None, ("notblank", )),
(("C", 0, 0, 4), "ISD", 9.2, "Quantity", "", "", "N",
self.doQty, None, None, ("notzero", )),
(("C", 0, 0, 5), "OUD", 9.2, "Unit-Cost"),
(("C", 0, 0, 6), "OSD", 9.2, "Value")]
if self.glint == "Y":
fld.append(
(("C", 0, 0, 7), "IUI", 7, "G/L-Acc", "G/L Account Number",
self.stk_susp, "N", self.doGenAcc, glm, None, None))
fld.append((("C", 0, 0, 8), "ONA", 10, "Desc"))
fld.append((("C",0,0,9),"INA",(20,30),"Details","Transaction "\
"Details","","N",self.doTrnDet,None,None,None))
row = (15, )
tnd = ((self.endPage0, "n"), )
txt = (self.exitPage0, )
cnd = ((self.endPage1, "y"), )
cxt = (self.exitPage1, )
but = (("Reprint", None, self.doReprint, 0, ("T", 0, 1), None), )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
rows=row,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doIss(self, frt, pag, r, c, p, i, w):
self.iss = w
def doDte(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.dte = w
self.ddt = self.df.t_disp[pag][0][p]
self.curdt = int(self.dte / 100)
self.batno = "S%s" % self.curdt
def doGroup(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.group = w
def doCode(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_desc", "st1_type", "st1_uoi"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", w),
("st1_type", "<>", "X")],
limit=1)
if not acc:
return "Invalid or Redundant Code"
self.code = w
self.desc = acc[0]
self.gtype = acc[1]
self.df.loadEntry(frt, pag, p + 1, data=acc[2])
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("C", pag, p + 2, data=self.loc)
no = self.checkLoc()
if no:
return no
else:
return "sk2"
def doLoc(self, frt, pag, r, c, p, i, w):
self.loc = w
no = self.checkLoc()
if no:
return no
def checkLoc(self):
acc = self.sql.getRec("strmf2",
cols=["st2_bin"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location For This Product"
def doQty(self, frt, pag, r, c, p, i, w):
self.quant = w
if self.gtype == "R" and self.doRecipe():
return "ff2"
if self.extractCost():
return "rf"
self.df.loadEntry("C", pag, p + 1, data=self.ucost)
self.df.loadEntry("C", pag, p + 2, data=self.tcost)
def doRecipe(self):
self.recipe = self.sql.getRec("strrcp",
where=[("srr_cono", "=",
self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc)],
order="srr_rgroup, srr_rcode")
if not self.recipe:
err = "Invalid Recipe, No Items"
showError(self.opts["mf"].body, "Recipe Error", err)
return err
else:
return self.doRecChg()
def doRecChg(self):
# Display recipe items and allow editing of quantities etc.
data = []
for num, item in enumerate(self.recipe):
st1 = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", item[4]),
("st1_code", "=", item[5])],
limit=1)
err = False
if not st1:
err = "Invalid Stock Record in Recipe"
elif st1[0] == "X":
err = "Redundant Stock Record in Recipe"
if err:
showError(
self.opts["mf"].body, "Recipe Error", """%s!
Group: %s
Code: %s""" % (err, item[4], item[5]))
return err
data.append([num, item[4], item[5], st1[1], item[6]])
titl = "Recipe Items"
head = ("Seq", "Grp", "Product-Code", "Description", "Quantity")
lin = {
"stype": "C",
"titl": titl,
"head": head,
"typs": [("UI", 2), ("NA", 3), ("NA", 20), ("NA", 30),
("SD", 11.2)],
"data": data
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus(
"Select a Product to Edit or Exit to Continue")
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.recchg = chg.selection
self.doRecChanges()
self.doRecChg()
else:
self.df.enableButtonsTags(state=state)
def doRecChanges(self):
tit = ("Change Items", )
fld = ((("T", 0, 0, 0), "ONA", 3,
"Group"), (("T", 0, 1, 0), "ONA", 20,
"Code"), (("T", 0, 2, 0), "ONA", 30, "Description"),
(("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N",
self.doRecQty, None, None, ('notzero', )))
but = (("Delete", None, self.doRecDel, 1, None, None), )
self.rp = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=((self.doRecEnd, "n"), ),
txit=(self.doRecExit, ))
self.rp.loadEntry("T", 0, 0, data=self.recchg[1])
self.rp.loadEntry("T", 0, 1, data=self.recchg[2])
self.rp.loadEntry("T", 0, 2, data=self.recchg[3])
self.rp.loadEntry("T", 0, 3, data=self.recchg[4])
self.rp.focusField("T", 0, 4, clr=False)
self.rp.mstFrame.wait_window()
def doRecQty(self, frt, pag, r, c, p, i, w):
self.recqty = w
def doRecDel(self):
del self.recipe[int(self.recchg[0])]
self.doRecExit()
def doRecEnd(self):
self.recipe[int(self.recchg[0])][6] = self.recqty
self.doRecExit()
def doRecExit(self):
self.rp.closeProcess()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.glnum = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doTrnDet(self, frt, pag, r, c, p, i, w):
if not w:
self.trndet = self.desc
else:
self.trndet = w
def endPage0(self):
self.df.focusField("C", 0, 1)
def endPage1(self):
self.updateTables()
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitPage1(self):
if self.df.col != 1:
self.doPrintDoc(self.pr.repprt)
self.df.focusField("T", 0, 1)
def extractCost(self):
self.ucost = 0
self.tcost = 0
if self.gtype == "R":
for item in self.recipe:
quant = item[6] * self.quant
tcost = self.doCalCost(item[4], item[5], quant)
if tcost is None:
return "error"
self.tcost = float(ASD(self.tcost) + ASD(tcost))
else:
tcost = self.doCalCost(self.group, self.code, self.quant)
if tcost is None:
return "error"
self.tcost = tcost
self.ucost = round(self.tcost / self.quant, 2)
def updateTables(self):
if self.gtype == "R":
# Issue individual items
for item in self.recipe:
acc = self.sql.getRec("strmf1",
cols=["st1_desc"],
where=[("st1_cono", "=", item[0]),
("st1_group", "=", item[4]),
("st1_code", "=", item[5])],
limit=1)
if acc:
des = acc[0]
else:
des = "Unknown Description"
qty = item[6] * self.quant
tcost = self.doCalCost(item[4], item[5], qty, chk=False)
qty = float(ASD(0) - ASD(qty))
val = float(ASD(0) - ASD(tcost))
data = [
self.opts["conum"], item[4], item[5], self.loc, self.dte,
6, self.iss, self.batno, self.glnum, qty, val, 0,
self.curdt, des, 0, "", "", "STR", 0, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# Receive recipe item
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte,
5, self.iss, self.batno, self.glnum, self.quant, self.tcost, 0,
self.curdt, self.desc, 0, "", "", "STR", 0, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# Stores Ledger Transaction
qty = float(ASD(0) - ASD(self.quant))
val = float(ASD(0) - ASD(self.tcost))
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte, 2,
self.iss, self.batno, self.glnum, qty, val, 0, self.curdt,
self.desc, 0, "", "", "STR", 0, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
if self.glint == "N":
return
col = self.sql.gentrn_col
# General Ledger Control Transaction (Stock On Hand)
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.stk_soh),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.dte),
("glt_type", "=", 4),
("glt_refno", "=", self.iss),
("glt_batch", "=", self.batno)],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(val))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.stk_soh, self.curdt,
self.dte, 4, self.iss, self.batno, val, 0,
self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0
])
# General Ledger Transaction (Expense)
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.glnum),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.dte),
("glt_type", "=", 4),
("glt_refno", "=", self.iss),
("glt_batch", "=", self.batno)],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(self.tcost))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.glnum, self.curdt,
self.dte, 4, self.iss, self.batno, self.tcost,
0, self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0
])
def doCalCost(self, grp, code, qty, chk=True):
# Calculate cost price
icost, tcost, bal = getCost(self.sql,
self.opts["conum"],
grp,
code,
loc=self.loc,
qty=qty,
tot=True,
bal=True)
if chk and qty > bal[0]:
acc = self.sql.getRec("strmf1",
cols=["st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", grp),
("st1_code", "=", code)],
limit=1)
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="ExQty",
product=(grp, code, acc[0]))
if cf.flag == "no":
return
return tcost
def doReprint(self):
tit = ("Reprint Documents", )
data = self.sql.getRec("strtrn",
cols=["stt_ref1", "stt_trdt"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2)],
group="stt_ref1, stt_trdt",
order="stt_trdt, stt_ref1")
iss = {
"stype":
"R",
"tables": ("strtrn", ),
"cols": (("stt_ref1", "", 0, "Reference"), ("stt_trdt", "", 0,
"Date", "Y")),
"wtype":
"D",
"where":
data,
"screen":
self.opts["mf"].body,
"comnd":
self.doSelRec
}
isd = {
"stype": "R",
"tables": ("strtrn", ),
"cols": (("stt_trdt", "", 0, "Date"), ),
"where": [("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2)],
"whera": (("T", "stt_ref1", 0, 0), ),
"group": "stt_trdt",
"order": "stt_trdt",
"screen": self.opts["mf"].body
}
fld = ((("T", 0, 0, 0), "INa", 9, "Issue Number", "", "", "N",
self.doRepIss, iss, None, ("notblank", )),
(("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N",
self.doRepDte, isd, None, ("notzero", )))
state = self.df.disableButtonsTags()
self.tx = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doRepEnd, "n"), ),
txit=(self.doRepExit, ),
view=("N", "V"),
mail=("Y", "N"))
self.tx.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSelRec(self, frt, pag, r, c, p, i, w):
self.tx.doKeyPressed(frt, pag, p, w[0])
self.tx.doKeyPressed(frt, pag, p + 1, w[1])
def doRepIss(self, frt, pag, r, c, p, i, w):
self.iss = w
def doRepDte(self, frt, pag, r, c, p, i, w):
self.dte = w
self.ddt = self.df.t_disp[pag][0][p]
acc = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 2),
("stt_ref1", "=", self.iss),
("stt_trdt", "=", self.dte)],
limit=1)
if not acc[0]:
return "No Document Found"
def doRepEnd(self):
self.tx.closeProcess()
self.doPrintDoc(self.tx.repprt)
def doRepExit(self):
self.tx.closeProcess()
def doPrintDoc(self, repprt):
hds = [
"Goods Issued Notes",
"GIN Number: %s GIN Date: %s" % (self.iss, self.ddt)
]
tab = ["strmf1", "strtrn"]
col = [["stt_group", "UA", 3, "Grp", "y"],
["stt_code", "NA", 20, "Product-Code", "y"],
["stt_desc", "NA", 40, "Description", "y"],
["stt_loc", "UA", 1, "L", "y"],
["stt_qty", "SD", 11.2, "Quantity", "y", "y"],
["stt_cost", "SD", 11.2, "Price", "y", "y"]]
gtt = ["stt_cost"]
whr = [("stt_cono", "=", self.opts["conum"]),
("stt_type", "in", (2, 6)), ("stt_ref1", "=", self.iss),
("stt_trdt", "=", self.dte), ("st1_cono=stt_cono", ),
("st1_group=stt_group", ), ("st1_code=stt_code", ),
("st1_type", "<>", "R")]
odr = "stt_seq"
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"],
conum=self.opts["conum"],
conam=self.opts["conam"],
name=self.__class__.__name__,
tables=tab,
heads=hds,
cols=col,
gtots=gtt,
where=whr,
order=odr,
repprt=repprt)
self.df.setWidget(self.df.mstFrame, state="show")
class 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 st2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.exit = False
self.setPrinter()
if not self.exit:
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"gentrn", "strgrp", "strmf1", "strmf2", "strgmu", "strcmu",
"strtrn", "strpom"
],
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.fromad = strctl["cts_emadd"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.stk_soh = ctlctl["stk_soh"]
self.stk_susp = ctlctl["stk_susp"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if self.locs == "N":
self.loc = "1"
return True
def setPrinter(self):
tit = ("Printer Selection", )
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=[],
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "P"),
mail=("N", "Y"))
self.opts["mf"].startLoop()
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.pr.closeProcess()
self.opts["mf"].closeLoop()
def dataHeader(self):
gpm = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
stm = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_group", "", 0, "Grp"), ("st1_code", "", 0, "Product Code"),
("st1_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, 0]],
"order":
"st1_group, st1_code",
"index":
1
}
stl = {
"stype":
"R",
"tables": ("strloc", "strmf2"),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Location", "Y")),
"where": [("srl_cono", "=", self.opts["conum"]),
("srl_loc=st2_loc", ), ("st2_cono=srl_cono", )],
"whera": [["C", "st2_group", 0], ["C", "st2_code", 1]],
"order":
"st2_loc",
"index":
0
}
fld = [(("T", 0, 0, 0), "INa", 9, "GRN Number", "", "", "Y",
self.doGrv, None, None, ("notblank", )),
(("T", 0, 0, 0), "ID1", 10, "Date", "GRN Date", self.sysdtw,
"N", self.doDte, None, None, ("efld", )),
(("T", 0, 0, 0), "INa", 7, "Order Number", "", "", "N",
self.doOrd, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "r", "Y",
self.doGroup, gpm, None, ("notblank", )),
(("C", 0, 0, 1), "INA", (15, 20), "Product Code", "", "", "N",
self.doCode, stm, None, ("notblank", )),
(("C", 0, 0, 2), "ONA", 15, "Description"),
(("C", 0, 0, 3), "ONA", 5, "U.O.I"),
[("C", 0, 0, 4), "IUA", 1, "L", "Location", "r", "N",
self.doLoc, stl, None, ("notblank", )],
(("C", 0, 0, 5), "ISD", 9.2, "Quantity", "", "", "N",
self.doQty, None, None, ("notzero", )),
(("C", 0, 0, 6), "IUD", 9.2, "Unit-Cost", "Unit Cost Price", "",
"N", self.doUcost, None, None, ("notzero", )),
(("C", 0, 0, 7), "IUD", 5.2, "Dis-%", "Discount Percentage", "",
"N", self.doDisPer, None, None, ("efld", )),
(("C", 0, 0, 8), "OSD", 9.2, "Value")]
tnd = ((self.endPage0, "n"), )
txt = (self.exitPage0, )
cnd = ((self.endPage1, "y"), )
cxt = (self.exitPage1, )
but = (("Import", None, self.doImport, 0, ("C", 0, 1), (("T", 0, 1),
("C", 0, 2)),
"Import Stock from a CSV or XLS File"),
("StrQuery", None, self.doQuery, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0, 2))), ("Reprint", None, self.doReprint,
0, ("T", 0, 1), None),
("Cancel", None, self.doCancel, 0, ("C", 0, 1), (("T", 0, 1),
("C", 0, 0))))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doGrv(self, frt, pag, r, c, p, i, w):
self.grv = w
self.cancel = False
def doDte(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.dte = w
self.dtw = self.df.t_disp[0][0][i]
self.curdt = int(self.dte / 100)
self.batno = "S%s" % self.curdt
def doOrd(self, frt, pag, r, c, p, i, w):
self.odr = w
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
if self.locs == "Y":
impcol = [["Location", 0, "UA", 1]]
fld = [(("T",0,0,0),("IRB",(("Yes","Y"),("No","N"))),0,
"Create Items","","N","N",self.doAllLoc,None,None,None,None,
"Create Item in this location if it is a Valid item, i.e. "\
"Already exists in another location")]
else:
impcol = []
fld = []
self.allloc = "N"
impcol.extend([["Group", 1, "UA", 3], ["Code", 2, "NA", 20],
["Quantity", 3, "UD", 10.2],
["Item Cost", 4, "UD", 10.2]])
fi = FileImport(self.opts["mf"], impcol=impcol, impfld=fld)
self.trdis = 0
err = None
for num, line in enumerate(fi.impdat):
if len(line) != len(impcol):
err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \
(num + 1, len(impcol), len(line))
break
if self.locs == "Y":
loc = line[0]
idx = 1
else:
loc = "1"
idx = 0
self.loc = loc.work
self.group = line[idx]
self.code = line[idx + 1]
st1 = self.sql.getRec("strmf1",
where=[("st1_group", "=", self.group),
("st1_code", "=", self.code),
("st1_type", "<>", "X")],
limit=1)
err = False
if not st1:
err = "Line %s: Invalid Group %s or Code %s" % (
(num + 1), self.group, self.code)
elif st1[self.sql.strmf1_col.index("st1_type")] == "R":
err = "Line %s: Invalid Code (Recipe Item)" % (num + 1)
elif st1[self.sql.strmf1_col.index("st1_type")] == "X":
err = "Line %s: Invalid Code (Redundant" % (num + 1)
elif st1[self.sql.strmf1_col.index("st1_type")] == "N":
err = "Line %s: Invalid Code (Value Indicator)" % (num + 1)
if err:
break
self.desc = st1[self.sql.strmf1_col.index("st1_desc")]
st2 = self.sql.getRec("strmf2",
where=[("st2_loc", "=", self.loc),
("st2_group", "=", self.group),
("st2_code", "=", self.code)],
limit=1)
if not st2 and self.allloc == "Y":
st2 = self.sql.getRec("strmf2",
where=[("st2_loc", "=", "1"),
("st2_group", "=", self.group),
("st2_code", "=", self.code)],
limit=1)
if st2:
st2[self.sql.strmf2_col.index("st2_loc")] = self.loc
st2[self.sql.strmf2_col.index("st2_bin")] = ""
st2[self.sql.strmf2_col.index("st2_reord_ind")] = "A"
st2[self.sql.strmf2_col.index("st2_reord_level")] = 0
st2[self.sql.strmf2_col.index("st2_reord_qty")] = 0
self.sql.insRec("strmf2", data=st2)
if not st2:
err = "Line %s: Invalid Location %s" % ((num + 1), self.loc)
break
self.qty = line[idx + 2]
self.tcost = round((self.qty * line[idx + 3]), 2)
self.usell = 0.00
self.updateTables()
if err:
showError(self.opts["mf"].body, "Import Error", err)
elif fi.impdat:
self.opts["mf"].dbm.commitDbase()
self.df.enableButtonsTags(state=state)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doAllLoc(self, obj, w):
self.allloc = w
def doGroup(self, frt, pag, r, c, p, i, w):
self.group = w
acc = self.sql.getRec("strgrp",
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec(
"strmf1",
cols=["st1_type", "st1_desc", "st1_uoi", "st1_value_ind"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group), ("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] == "R":
return "Invalid Code (Recipe Item)"
if acc[0] == "X":
return "Invalid Code (Redundant"
if acc[3] == "N":
return "Invalid Code (Value Indicator)"
self.desc = acc[1]
self.uoi = acc[2]
self.df.loadEntry("C", pag, p + 1, data=self.desc)
self.df.loadEntry("C", pag, p + 2, data=self.uoi)
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("C", pag, p + 3, data=self.loc)
no = self.checkLoc()
if no:
return no
return "sk3"
def doLoc(self, frt, pag, r, c, p, i, w):
self.loc = w
no = self.checkLoc()
if no:
return no
def checkLoc(self):
acc = self.sql.getRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location For This Product"
def doQty(self, frt, pag, r, c, p, i, w):
self.qty = w
# Last Cost Price
lcost = getCost(self.sql,
self.opts["conum"],
self.group,
self.code,
loc=self.loc,
qty=1,
ind="L")
self.df.loadEntry(frt, pag, p + 1, data=lcost)
def doUcost(self, frt, pag, r, c, p, i, w):
self.ucost = w
self.tcost = round((self.qty * self.ucost), 2)
def doDisPer(self, frt, pag, r, c, p, i, w):
self.trdis = w
udis = round((self.ucost * self.trdis / 100), 2)
tdis = round((self.tcost * self.trdis / 100), 2)
self.ucost = float(ASD(self.ucost) - ASD(udis))
self.tcost = float(ASD(self.tcost) - ASD(tdis))
self.df.loadEntry(frt, pag, p + 1, data=self.tcost)
def endPage0(self):
self.df.focusField("C", 0, 1)
def endPage1(self):
self.updateTables()
self.df.advanceLine(0)
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitPage1(self):
if not self.cancel and self.df.col != 1:
self.opts["mf"].dbm.commitDbase()
self.doPrintDoc(self.pr.repprt, self.pr.repeml)
else:
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doCancel(self):
ok = askQuestion(
self.opts["mf"].body,
"Cancel",
"Are You Sure that you want to Cancel this Goods Received Note?",
default="no")
if ok == "yes":
self.cancel = True
self.exitPage1()
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def updateTables(self):
# Stores Ledger Transaction
data = [
self.opts["conum"], self.group, self.code, self.loc, self.dte, 1,
self.grv, self.batno, self.odr, self.qty, self.tcost, 0,
self.curdt, self.desc, 0, "", "", "STR", self.trdis, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
if self.glint == "N":
return
# General Ledger Control Transaction (Stock On Hand)
data = [
self.opts["conum"], self.stk_soh, self.curdt, self.dte, 5,
self.grv, self.batno, self.tcost, 0, self.code, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Stock Suspense)
val = float(ASD(0) - ASD(self.tcost))
data = [
self.opts["conum"], self.stk_susp, self.curdt, self.dte, 5,
self.grv, self.batno, val, 0, self.code, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
def doReprint(self):
tit = ("Reprint Documents", )
dat = self.sql.getRec(
"strtrn",
cols=["stt_loc", "stt_trdt", "stt_ref1", "stt_ref2"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1)],
group="stt_loc, stt_trdt, stt_ref1, stt_ref2",
order="stt_trdt, stt_ref1")
data = []
for d in dat:
try:
# Exclude purchase orders
doc = int(d[2])
chk = self.sql.getRec("strpom",
where=[("pom_cono", "=",
self.opts["conum"]),
("pom_ordno", "=", doc),
("pom_loc", "=", d[0]),
("pom_date", "=", d[1])])
if chk:
continue
except:
pass
data.append([d[2], d[1], d[3]])
grv = {
"stype":
"R",
"tables": ("strtrn", "strpom"),
"cols":
(("stt_ref1", "", 0, "Reference", "Y"),
("stt_trdt", "", 0, "Date"), ("stt_ref2", "", 0, "Order-Num")),
"wtype":
"D",
"where":
data,
"screen":
self.opts["mf"].body,
"comnd":
self.doSelRec
}
grd = {
"stype": "R",
"tables": ("strtrn", ),
"cols":
(("stt_trdt", "", 0, "Date"), ("stt_ref2", "", 0, "Order-Num")),
"where": [("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1)],
"whera": (("T", "stt_ref1", 0, 0), ),
"group": "stt_trdt",
"order": "stt_trdt"
}
fld = ((("T", 0, 0, 0), "INa", 9, "GRN Number", "", "", "N",
self.doRepGrv, grv, None, ("notblank", )),
(("T", 0, 1, 0), "ID1", 10, "Date", "GRN Date", 0, "N",
self.doRepDte, grd, None, ("notzero", )))
state = self.df.disableButtonsTags()
self.tx = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doRepEnd, "n"), ),
txit=(self.doRepExit, ),
view=("Y", "V"),
mail=("Y", "N"))
self.tx.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doSelRec(self, frt, pag, r, c, p, i, w):
self.tx.doKeyPressed(frt, pag, p, w[0])
self.tx.doKeyPressed(frt, pag, p + 1, w[1])
def doRepGrv(self, frt, pag, r, c, p, i, w):
self.grv = w
acc = self.sql.getRec("strtrn",
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1),
("stt_ref1", "=", w)])
if not acc:
return "Invalid GRN Number"
if len(acc) == 1:
self.dte = acc[0][self.sql.strtrn_col.index("stt_trdt")]
self.tx.loadEntry(frt, pag, p + 1, data=self.dte)
self.dtw = self.tx.t_disp[0][0][i + 1]
return "sk1"
def doRepDte(self, frt, pag, r, c, p, i, w):
self.dte = w
self.dtw = self.tx.t_disp[0][0][i]
acc = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_type", "=", 1),
("stt_ref1", "=", self.grv),
("stt_trdt", "=", self.dte)],
limit=1)
if not acc[0]:
return "No Document Found"
def doRepEnd(self):
self.tx.closeProcess()
self.doPrintDoc(self.tx.repprt, self.tx.repeml)
def doRepExit(self):
self.tx.closeProcess()
def doPrintDoc(self, repprt, repeml):
hds = [
"Goods Received Notes",
"GRN Number: %s GRN Date: %s" % (self.grv, self.dtw)
]
col = [["stt_group", "UA", 3, "Grp", "y"],
["stt_code", "NA", 20, "Product-Code", "y"],
["stt_desc", "NA", 40, "Description", "y"],
["stt_loc", "UA", 1, "L", "y"],
["stt_qty", "SD", 11.2, "Quantity", "y"],
["stt_cost", "SD", 11.2, "Price", "y"]]
gtt = ["stt_cost"]
whr = [("stt_cono", "=", self.opts["conum"]), ("stt_type", "=", 1),
("stt_ref1", "=", self.grv), ("stt_trdt", "=", self.dte)]
odr = "stt_seq"
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"],
conum=self.opts["conum"],
conam=self.opts["conam"],
name=self.__class__.__name__,
tables=["strtrn"],
heads=hds,
cols=col,
gtots=gtt,
where=whr,
order=odr,
repprt=repprt,
repeml=repeml,
fromad=self.fromad)
self.df.setWidget(self.df.mstFrame, state="show")
def doQuery(self):
callModule(self.opts["mf"],
self.df,
"st4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
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 st1030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["strgrp", "strmf1", "strmf2", "strloc", "strprc"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
return True
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
st1 = {
"stype":
"R",
"tables": ("strmf1", ),
"cols":
(("st1_code", "", 0, "Product-Code"), ("st1_type", "", 0, "T"),
("st1_desc", "", 0, "Description", "Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [("C", "st1_group", 0)]
}
loc = {
"stype":
"R",
"tables": ("strmf2", "strloc"),
"cols": (("st2_loc", "", 0, "Acc-Num"), ("srl_desc", "", 0,
"Description")),
"where": [("st2_cono", "=", self.opts["conum"])],
"whera": (("C", "st2_group", 0), ("C", "st2_code", 1))
}
self.fld = [(("C", 0, 0, 0), "IUA", 3, "Grp", "Product Group", "", "Y",
self.doGrp, grp, None, None),
(("C", 0, 0, 1), "INA", 20, "Code", "Product Code", "",
"N", self.doCode, st1, None, None),
(("C", 0, 0, 2), "ONA", 30, "Description"),
(("C", 0, 0, 3), "IUA", 1, "L", "Location", "", "N",
self.doLoc, loc, None, None)]
for x in range(self.plevs):
lev = x + 1
txt = "Level-%s" % lev
if lev == 1:
ddd = self.doDelete
else:
ddd = None
self.fld.append((("C", 0, 0, x + 4), "IUD", 10.2, txt, txt, "",
"N", self.doLevel, None, ddd, ("notzero", )))
but = (
("Import File",None,self.doImport,0,("C",0,1),("C",0,2),
"Import Selling Prices from a CSV or XLS File "\
"having the following columns: Group, Code, "\
"Location, Prices by Level"),
("Exit", None, self.doExit, 1, ("C", 0, 1), ("C", 0, 2)))
row = (20, )
self.df = TartanDialog(self.opts["mf"],
rows=row,
eflds=self.fld,
cend=((self.doEnd, "y"), ),
cxit=(self.doExit, ),
butt=but)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
impcol = []
pos = 0
for num, fld in enumerate(self.fld):
if num == 2:
continue
if type(fld[2]) in (tuple, list):
size = fld[2][1]
else:
size = fld[2]
impcol.append([fld[4], pos, fld[1][1:], size])
pos += 1
fi = FileImport(self.opts["mf"], impcol=impcol)
err = None
for num, line in enumerate(fi.impdat):
if len(line) != pos:
err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \
(num + 1, pos, len(line))
break
self.grp = line[0]
chk = self.sql.getRec("strgrp",
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", self.grp)],
limit=1)
if not chk:
err = "Line %s: Invalid Group %s" % ((num + 1), self.grp)
break
self.cod = line[1]
chk = self.sql.getRec("strmf1",
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", self.cod)],
limit=1)
if not chk:
err = "Line %s: Invalid Code %s" % ((num + 1), self.cod)
break
self.loc = line[2]
chk = self.sql.getRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.grp),
("st2_code", "=", self.cod),
("st2_loc", "=", self.loc)],
limit=1)
if not chk:
err = "Line %s: Invalid Location %s" % ((num + 1), self.loc)
break
self.levs = []
for x in range(self.plevs):
self.levs.append(line[x + 3])
if len(self.levs) != self.plevs:
err = "Line %s: Invalid Number of Levels (S/B %s is %s)" % \
((num + 1), self.plevs, len(self.levs))
self.doEnd(det=True)
if err:
showError(self.opts["mf"].body, "Import Error", err)
elif fi.impdat:
self.opts["mf"].dbm.commitDbase()
self.df.enableButtonsTags(state=state)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, 1)
def doGrp(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("strgrp",
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not chk:
return "Invalid Group"
self.grp = w
def doCode(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("strmf1",
cols=["st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", w)],
limit=1)
if not chk:
return "Invalid Code"
self.cod = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if self.locs == "N":
self.loc = "1"
self.df.loadEntry(frt, pag, p + 2, data=self.loc)
self.doLoadLevs(p + 3)
return "sk2"
def doLoc(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.grp),
("st2_code", "=", self.cod),
("st2_loc", "=", w)],
limit=1)
if not chk:
return "Invalid Location"
self.loc = w
self.doLoadLevs(p + 1)
def doDelete(self):
self.sql.delRec("strprc",
where=[("stp_cono", "=", self.opts["conum"]),
("stp_group", "=", self.grp),
("stp_code", "=", self.cod),
("stp_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.clearLine(0, focus=True)
def doLoadLevs(self, p):
self.levs = []
for x in range(self.plevs):
prc = self.sql.getRec("strprc",
cols=["stp_price"],
where=[("stp_cono", "=", self.opts["conum"]),
("stp_group", "=", self.grp),
("stp_code", "=", self.cod),
("stp_loc", "=", self.loc),
("stp_level", "=", x + 1)],
limit=1)
if not prc:
prc = [0]
self.df.loadEntry("C", 0, p, data=prc[0])
self.levs.append(prc[0])
p += 1
def doLevel(self, frt, pag, r, c, p, i, w):
self.levs[i - 4] = w
def doEnd(self, det=False):
self.sql.delRec("strprc",
where=[("stp_cono", "=", self.opts["conum"]),
("stp_group", "=", self.grp),
("stp_code", "=", self.cod),
("stp_loc", "=", self.loc)])
for num, lev in enumerate(self.levs):
self.sql.insRec("strprc",
data=[
self.opts["conum"], self.grp, self.cod,
self.loc, num + 1, lev
])
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
self.df.loadEntry("C", 0, self.df.pos, data=self.grp)
self.df.focusField("C", 0, self.df.col + 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
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 st5020(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, ["strloc", "strgrp", "strmf1",
"strmf2", "strgmu", "strcmu", "strprc", "strtrn", "strvar"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.locs = strctl["cts_locs"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.last = 0
return True
def dataHeader(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Stores Ledger Stock Take Returns (%s)" % self.__class__.__name__)
loc = {
"stype": "R",
"tables": ("strloc",),
"cols": (
("srl_loc", "", 0, "L"),
("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]}
gpm = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
stm1 = {
"stype": "R",
"tables": ("strmf1",),
"cols": (
("st1_group", "", 0, "Grp"),
("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "not", "in", ("R", "X"))],
"whera": [["T", "st1_group", 4, 0]],
"order": "st1_group, st1_code",
"index": 1}
r1s = (("Number","N"),("Bin Number","B"))
r2s = (("Yes","Y"),("No","N"))
r3s = (("No","N"),("Last","L"),("Average","A"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Sort Order","",
"N","Y",self.doSort,None,None,None),
(("T",0,1,0),"IUA",1,"Location","",
"","N",self.doLoc,loc,None,("efld",)),
(("T",0,2,0),("IRB",r2s),0,"Auto Sequence","",
"N","N",self.doAuto,None,None,None),
(("T",0,3,0),"IUA",8,"First Bin Number","",
"","N",self.doFbin,None,None,("efld",)),
(("T",0,4,0),"IUA",3,"First Group","",
"","N",self.doFgrp,gpm,None,None),
(("T",0,5,0),"INA",20,"First Code","",
"","N",self.doFcode,stm1,None,None),
(("T",0,6,0),("IRB",r3s),0,"Cost Prices","",
"N","N",self.doCosts,None,None,None))
tnd = ((self.endPage1,"y"),)
txt = (self.exitPage1,)
self.df1 = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld,
tend=tnd, txit=txt)
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
if self.locs == "N":
self.loc = "1"
self.df1.loadEntry(frt, pag, p+1, data=self.loc)
return "sk1"
def doLoc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strloc", cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]), ("srl_loc", "=", w)],
limit=1)
if not acc:
return "Invalid Location Code"
self.loc = w
def doAuto(self, frt, pag, r, c, p, i, w):
self.auto = w
if self.auto != "Y":
return "sk3"
self.bin = ""
self.fgrp = ""
self.fcode = ""
if self.sort == "N":
return "sk1"
def doFbin(self, frt, pag, r, c, p, i, w):
self.fbin = w
def doFgrp(self, frt, pag, r, c, p, i, w):
if 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.fgrp = w
if not self.fgrp:
self.fcode = ""
self.df1.loadEntry(frt, pag, p+1, data=self.fcode)
return "sk1"
def doFcode(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("strmf1", cols=["st1_type"],
where=[("st1_cono", "=", self.opts["conum"]), ("st1_group",
"=", self.fgrp), ("st1_code", "=", w)], limit=1)
if not acc:
return "Invalid Code"
if acc[0] == "R":
return "Invalid Code (Recipe Item)"
if acc[0] == "X":
return "Invalid Code (Redundant Item)"
self.fcode = w
def doCosts(self, frt, pag, r, c, p, i, w):
self.costs = w
def endPage1(self):
self.df1.closeProcess()
self.dataBody()
if self.auto == "Y":
whr = [("st1_cono", "=", self.opts["conum"])]
if self.fgrp:
whr.append(("st1_group", ">=", self.fgrp))
if self.fcode:
whr.append(("st1_code", ">=", self.fcode))
whr.extend([("st1_type", "not", "in", ("R","X")),
("st2_cono=st1_cono",), ("st2_group=st1_group",),
("st2_code=st1_code",), ("st2_loc", "=", self.loc)])
self.codes = self.sql.getRec(tables=["strmf1", "strmf2"],
cols=["st1_group", "st1_code", "st1_desc", "st1_uoi",
"st2_bin"], where=whr, order="st1_group, st1_code")
if not self.codes:
showError(self.opts["mf"].body, "No Records",
"No Stock Records on File")
self.exitPage2()
else:
self.doNextOne()
def exitPage1(self):
self.df1.closeProcess()
self.opts["mf"].closeLoop()
def dataBody(self):
gpm = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
stm2 = {
"stype": "R",
"tables": ("strmf1",),
"cols": (
("st1_group", "", 0, "Grp"),
("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "not", "in", ("R", "X"))],
"whera": [["C", "st1_group", 0, 0]],
"index": 1}
if self.auto == "Y":
fld = [
(("C",0,0,0),"ONA",3,"Grp"),
(("C",0,0,1),"ONA",20,"Product Code")]
else:
fld = [
(("C",0,0,0),"INA",3,"Grp","Product Group",
"r","N",self.doGroup2,gpm,None,("notblank",)),
(("C",0,0,1),"INA",20,"Product Code","",
"","N",self.doCode2,stm2,None,("notblank",))]
fld.extend([
(("C",0,0,2),"ONA",16,"Description"),
(("C",0,0,3),"ONA",10,"U.O.I"),
(("C",0,0,4),"OUA",8,"Bin")])
if self.costs == "N":
fld.append((("C",0,0,5),"OUD",9.2,"Unit-Cost"))
else:
fld.append((("C",0,0,5),"IUD",9.2,"Unit-Cost","",
"","N",self.doUcost,None,None,("efld",)))
fld.append((("C",0,0,6),"ISD",9.2,"Quantity","",
"","N",self.doQty,None,None,("efld",)))
cnd = ((self.endPage2,"y"),)
cxt = (self.exitPage2,)
self.df2 = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld,
cend=cnd, cxit=cxt)
def doGroup2(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.group2 = w
def doCode2(self, frt, pag, r, c, p, i, w):
ac1 = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]), ("st1_group", "=",
self.group2), ("st1_code", "=", w)], limit=1)
if not ac1:
return "Invalid Code"
if ac1[0] == "R":
return "Invalid Code (Recipe Item)"
if ac1[0] == "X":
return "Invalid Code (Redundant Item)"
ac2 = self.sql.getRec("strmf2", where=[("st2_cono", "=",
self.opts["conum"]), ("st2_group", "=", self.group2), ("st2_code",
"=", w), ("st2_loc", "=", self.loc)], limit=1)
if not ac2:
return "Invalid Location For This Product"
self.code2 = w
self.df2.loadEntry("C", 0, p+1, data=ac1[0])
self.df2.loadEntry("C", 0, p+2, data=ac1[1])
self.bin = ac2[self.sql.strmf2_col.index("st2_bin")]
self.df2.loadEntry("C", 0, p+3, data=self.bin)
self.ucost, qty = self.doGetValues()
self.df2.loadEntry("C", 0, p+4, data=self.ucost)
self.df2.loadEntry("C", 0, p+5, data=qty)
def doUcost(self, frt, pag, r, c, p, i, w):
self.ucost = w
def doQty(self, frt, pag, r, c, p, i, w):
self.qty = w
self.amt1 = round((self.qty * self.ucost), 2)
def endPage2(self):
self.updateTables()
self.df2.advanceLine(0)
if self.auto == "Y":
self.last += 1
self.doNextOne()
def updateTables(self):
# Stores Variance Transaction
whr = [
("stv_cono", "=", self.opts["conum"]),
("stv_group", "=", self.group2),
("stv_code", "=", self.code2),
("stv_loc", "=", self.loc)]
if self.sql.getRec("strvar", where=whr, limit=1):
self.sql.delRec("strvar", where=whr)
self.sql.insRec("strvar", data=[self.opts["conum"], self.group2,
self.code2, self.loc, self.bin, self.qty, self.ucost, 0])
self.opts["mf"].dbm.commitDbase()
def doNextOne(self):
if self.last == len(self.codes):
self.exitPage2()
else:
data = self.codes[self.last]
self.group2 = data[0]
self.code2 = data[1]
self.bin = data[4]
self.ucost, qty = self.doGetValues()
data.extend([self.ucost, qty])
p = self.df2.pos
if self.costs == "N":
xs = 6
else:
xs = 5
for x in range(0, 7):
self.df2.loadEntry("C", 0, (p + x - xs), data=data[x])
self.df2.focusField("C", 0, p)
def doGetValues(self):
var = self.sql.getRec("strvar", where=[("stv_cono", "=",
self.opts["conum"]), ("stv_group", "=", self.group2), ("stv_code",
"=", self.code2), ("stv_loc", "=", self.loc)], limit=1)
if var:
qty = var[self.sql.strvar_col.index("stv_qty")]
cst = var[self.sql.strvar_col.index("stv_ucost")]
if not cst:
bal = self.doGetCost(self.group2, self.code2)
cst = bal[0]
else:
cst, qty = self.doGetCost(self.group2, self.code2)
return (cst, qty)
def doGetCost(self, grp, code):
if self.costs == "N":
ind = "I"
else:
ind = self.costs
cost, bal = getCost(self.sql, self.opts["conum"], grp, code,
loc=self.loc, ind=ind, bal=True)
return (cost, bal[0])
def exitPage2(self):
self.df2.closeProcess()
self.opts["mf"].closeLoop()
class sl2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(
self.opts["mf"].dbm,
["genmst", "gentrn", "wagedc", "wagmst", "waglmf", "wagltf"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
wagctl = self.gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.glint = wagctl["ctw_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["wag_slc"]):
return
self.slnctl = ctlctl["wag_slc"]
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"SLN",
2,
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0,
"Surname", "Y")),
"where": [("wgm_cono", "=", self.opts["conum"])]
}
ced = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"),
("ced_desc", "", 0, "Description", "Y")),
"where": [("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D")],
"index":
1
}
fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2,
"Value"), (("C", 0, 0, 0), "IUI", 5, "EmpNo",
"Employee Number", "", "N", self.doEmpno, wgm, None,
None), (("C", 0, 0, 1), "ONA", 20,
"Name"), (("C", 0, 0, 2), "OUI", 2, "Ln"),
(("C", 0, 0,
3), "INA", 15, "Description", "", "", "N", self.doDesc, None,
None, None), (("C", 0, 0, 4), "ID1", 10, "Date", "", "", "N",
self.doSdate, None, None, None),
(("C", 0, 0, 5), "INa", 9, "Ref-No", "Reference Number", "",
"N", self.doRef, None, None, ("notblank", )),
(("C", 0, 0, 6), "IUI", 3, "Cde", "Deduction Code", "", "N",
self.doCode, ced, None, ("notzero", )),
(("C", 0, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate", "", "N",
self.doInt, None, None,
None), (("C", 0, 0, 8), "IUD", 12.2, "Loan-Amt", "Loan Amount",
"", "N", self.doAmt, None, None, ("notzero", )),
(("C", 0, 0, 9), "IUD", 12.2, "Ded-Amt", "Deduction Amount", "",
"N", self.doDed, None, None, ("efld", )))
but = (("Interrogate", None, self.querySln, 0, ("C", 0, 1), ("C", 0,
2)), )
cnd = ((self.endPage, "y"), )
cxt = (self.exitPage, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
cend=cnd,
cxit=cxt)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 0, 1)
def doEmpno(self, frt, pag, r, c, p, i, w):
self.empno = w
acc = self.sql.getRec("wagmst",
cols=["wgm_sname", "wgm_fname"],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.name = "%s, %s" % (acc[0], acc[1].split()[0])
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.loan = getNextCode(self.sql,
"waglmf",
"wlm_loan",
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)],
start=1,
last=9999999)
self.df.loadEntry("C", pag, p + 2, data=self.loan)
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doSdate(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.sdate = w
def doRef(self, frt, pag, r, c, p, i, w):
self.ref = w
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
desc = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D"),
("ced_code", "=", w)],
limit=1)
if not desc:
return "Invalid Code"
def doInt(self, frt, pag, r, c, p, i, w):
self.rte = w
def doAmt(self, frt, pag, r, c, p, i, w):
self.amt = w
def doDed(self, frt, pag, r, c, p, i, w):
self.ded = w
def endPage(self):
self.updateTables()
self.updateBatch()
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
def exitPage(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def updateTables(self):
if self.bh.multi == "Y":
curdt = int(self.sdate / 100)
else:
curdt = self.bh.curdt
self.sql.insRec("waglmf",
data=[
self.opts["conum"], self.empno, self.loan,
self.desc, self.code, self.rte, self.sdate,
self.ded
])
self.sql.insRec("wagltf",
data=[
self.opts["conum"], self.empno, self.loan,
self.bh.batno, 2, self.sdate, self.ref, self.amt,
self.amt, self.ded, self.rte, curdt, self.desc,
"N", self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Staff Loans Control Account
data = (self.opts["conum"], self.slnctl, curdt, self.sdate, 2,
self.ref, self.bh.batno, self.amt, 0.00, self.name, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
amt = float(ASD(0) - ASD(self.amt))
# General Ledger Bank Account
data = (self.opts["conum"], self.bh.acc, curdt, self.sdate, 2,
self.ref, self.bh.batno, amt, 0.00,
"Staff Loan - %s" % self.name, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def updateBatch(self):
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.amt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def querySln(self):
callModule(self.opts["mf"],
self.df,
"sl4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class 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 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 bc2040(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", "bwlgme"], prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.nstart = bwlctl["ctb_nstart"]
self.dbase = bwlctl["ctb_dbase"]
return True
def mainProcess(self):
com = {
"stype": "R",
"tables": ("bwlcmp",),
"cols": (
("bcm_code", "", 0, "Cod"),
("bcm_name", "", 0, "Name", "Y"),
("bcm_date", "", 0, "Date")),
"where": [("bcm_cono", "=", self.opts["conum"])]}
typ = {
"stype": "R",
"tables": ("bwltyp",),
"cols": (
("bct_code", "", 0, "Cod"),
("bct_desc", "", 0, "Description", "Y")),
"where": [("bct_cono", "=", self.opts["conum"])]}
sk1 = {
"stype": "R",
"tables": ("bwltab",),
"cols": (
("btb_tab", "", 0, "Cod"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names")),
"where": [("btb_cono", "=", self.opts["conum"])],
"order": "btb_surname"}
sk2 = {
"stype": "R",
"tables": ("bwlent", "bwltab"),
"cols": (
("btb_tab", "", 0, "Cod"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names"),
("bce_tcod", "", 0, "T"),
("bce_paid", "", 0, "P")),
"where": [
("btb_cono", "=", self.opts["conum"]),
("btb_tab=bce_scod",)],
"whera": [("T", "bce_ccod", 0, 0)],
"order": "btb_surname"}
fld = (
(("T",0,0,0),"I@bcm_code",0,"Code","Competition Code",
"","Y",self.doCmpCod,com,None,("efld",)),
(("T",0,0,0),"I@bcm_name",0,"Name","",
"","N",self.doCmpNam,None,self.doDelCmp,("notblank",)),
(("T",0,0,0),"I@bcm_date",0,"Date","",
"","N",None,None,None,("efld",)),
(("T",0,0,0),"I@bcm_type",0,"Type","",
"","N",self.doCmpTyp,typ,None,("efld",)),
(("C",0,0,0),"I@btb_tab",0,"P-Code","Player's Code",
"","Y",self.doSkpCod,sk1,None,("efld",)),
(("C",0,0,1),"ONA",30,"Name","",
"","N",None,None,None,("notblank",)),
(("C",0,0,2),"I@bce_tcod",0,"T","Team Code (H or V)",
"H","n",self.doTeam,None,None,("in", ("H","V"))),
(("C",0,0,4),"I@bce_paid",0,"","Paid Flag (Y or N)",
"N","N",self.doPaid,None,self.doDelSkp,("in", ("Y","N"))))
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.erase = False
self.skips = []
if not w:
self.ccod = getNextCode(self.sql, "bwlcmp", "bcm_code",
where=[("bcm_cono", "=", self.opts["conum"])], last=999)
self.df.loadEntry(frt, pag, p, data=self.ccod)
else:
self.ccod = w
self.cmp = self.sql.getRec("bwlcmp", where=[("bcm_cono", "=",
self.opts["conum"]), ("bcm_code", "=", self.ccod)], limit=1)
if not self.cmp:
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:
if self.cmp[self.sql.bwlcmp_col.index("bcm_poff")]:
showError(self.opts["mf"].body, "Complete",
"This Sectional Competition Has Been Completed.")
return "rf"
gme = self.sql.getRec("bwlgme", cols=["count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=",
self.ccod), ("bcg_ocod", "<>", 0)], limit=1)
if gme[0]:
ok = askQuestion(self.opts["mf"].body, "Error",
"""This Competition Has Already Been Drawn.
Do You Want to Erase All Draws and Results?""", default="no")
if ok == "no":
return "rf"
self.erase = True
self.newcmp = False
for num, fld in enumerate(self.cmp[1:-2]):
self.df.loadEntry(frt, pag, p+num, data=fld)
ent = self.sql.getRec("bwlent", cols=["bce_scod"],
where=[("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod)])
for e in ent:
self.skips.append(e[0])
def doDelCmp(self):
if self.newcmp:
showError(self.opts["mf"].body, "Delete", "New Competition")
return
if self.skips:
ok = askQuestion(self.opts["mf"].body, "Delete", "Entries Exist "\
"for this Competition, Are You Sure it must be Deleted?",
default="no")
if ok == "no":
return
self.sql.delRec("bwlcmp", where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_code", "=", self.ccod)])
if self.skips:
self.sql.delRec("bwlent", where=[("bce_cono",
"=", self.opts["conum"]), ("bce_ccod", "=", self.ccod)])
self.sql.delRec("bwlgme", where=[("bcg_cono",
"=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doCmpNam(self, frt, pag, r, c, p, i, w):
self.cmpnam = w
def doCmpTyp(self, frt, pag, r, c, p, i, w):
if not w:
ok = askQuestion(self.opts["mf"].body, head="New Type",
mess="Is This a New Competition Type?")
if ok == "yes":
w = getNextCode(self.sql, "bwltyp", "bct_code",
where=[("bct_cono", "=", self.opts["conum"])], last=99)
w = callModule(self.opts["mf"], self.df, "bc1040",
coy=(self.opts["conum"], self.opts["conam"]), args=w,
ret="ctype")
self.df.loadEntry(frt, pag, p, data=w)
self.typ = self.sql.getRec("bwltyp", where=[("bct_cono", "=",
self.opts["conum"]), ("bct_code", "=", w)], limit=1)
if not self.typ:
return "Invalid Competition Type"
self.cfmat = self.typ[self.sql.bwltyp_col.index("bct_cfmat")]
self.tsize = self.typ[self.sql.bwltyp_col.index("bct_tsize")]
def doSkpCod(self, frt, pag, r, c, p, i, w):
if not w:
ok = askQuestion(self.opts["mf"].body, head="New Non-Member",
mess="Is This a New Non-Member Player?", default="yes")
if ok == "no":
return "Invalid Skip Code"
cod = self.doNewCode()
if not cod:
return "Invalid Skip Code"
self.df.loadEntry(frt, pag, p, data=cod)
else:
cod = w
if cod not in self.skips:
self.skips.append(cod)
self.scod = cod
chk = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.scod)], limit=1)
if not chk:
return "Invalid Player Code"
self.df.loadEntry(frt, pag, p+1, data=self.getName(chk))
ent = self.sql.getRec("bwlent", cols=["bce_tcod",
"bce_paid"], where=[("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod), ("bce_scod", "=", self.scod)],
limit=1)
if ent:
self.newent = False
self.df.loadEntry(frt, pag, p+2, data=ent[0])
self.df.loadEntry(frt, pag, p+3, data=ent[1])
else:
self.newent = True
if self.cfmat == "X":
if self.scod < self.nstart:
self.tcod = "H"
else:
self.tcod = "V"
self.df.loadEntry(frt, pag, p+2, data=self.tcod)
else:
self.tcod = ""
return "sk2"
def doTeam(self, frt, pag, r, c, p, i, w):
self.tcod = w
def doNewCode(self):
r1s = (("Male","M"), ("Female","F"))
r2s = (("Skip",4), ("Third",3), ("Second",2), ("Lead",1))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Gender","",
"M","Y",None,None,None,None),
(("T",0,1,0),"I@btb_surname",0,"","",
"","Y",None,None,None,("notblank",)),
(("T",0,2,0),"I@btb_names",0,"","",
"","Y",None,None,None,("notblank",)),
(("T",0,3,0),"I@btb_home",0,"","",
"","Y",None,None,None,("efld",)),
(("T",0,4,0),"I@btb_work",0,"","",
"","Y",None,None,None,("efld",)),
(("T",0,5,0),"I@btb_cell",0,"","",
"","Y",None,None,None,("efld",)),
(("T",0,6,0),"I@btb_mail",0,"","",
"","Y",self.doNMail,None,None,("efld",)),
(("T",0,7,0),("IRB",r2s),0,"Position","",
4,"Y",self.doNPos,None,None,None),
(("T",0,8,0),"I@btb_rate1",0,"Rating","",
"","Y",None,None,None,("efld",)))
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.new = TartanDialog(self.opts["mf"], eflds=fld,
tend=((self.doNEnd,"y"),), txit=(self.doNExit,))
self.new.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state)
return self.newcod
def doNMail(self, frt, pag, r, c, p, i, w):
if self.cfmat in ("T", "K", "R", "X"):
if self.dbase in ("C", "P"):
self.new.loadEntry(frt, pag, p+1, data=4)
else:
self.new.loadEntry(frt, pag, p+1, data=0)
if self.dbase in ("C", "R"):
self.new.loadEntry(frt, pag, p+2, data=5)
else:
self.new.loadEntry(frt, pag, p+2, data=0)
return "sk2"
if self.dbase == "R":
self.new.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doNPos(self, frt, pag, r, c, p, i, w):
if self.dbase == "P":
self.new.loadEntry(frt, pag, p+1, data=0)
return "sk1"
def doNEnd(self):
self.new.closeProcess()
self.newcod = getNextCode(self.sql, "bwltab", "btb_tab",
where=[("btb_cono", "=", self.opts["conum"])],
start=self.nstart, last=900000)
data = [self.opts["conum"], self.newcod, 0]
data.extend(self.new.t_work[0][0][1:3])
data.extend([self.new.t_work[0][0][0], "", "", "", ""])
data.extend(self.new.t_work[0][0][3:])
data.extend(self.new.t_work[0][0][7:])
data.append(0)
self.sql.insRec("bwltab", data=data)
def doNExit(self):
self.new.closeProcess()
self.newcod = None
def getName(self, chk):
name = chk[0]
if chk[1]:
name += ","
for i in chk[1].split():
name = "%s %s" % (name, i)
return name.upper()
def doPaid(self, frt, pag, r, c, p, i, w):
self.paid = w
def doDelSkp(self):
self.sql.delRec("bwlent", where=[("bce_cono", "=",
self.opts["conum"]), ("bce_ccod", "=", self.ccod),
("bce_scod", "=", self.scod)])
self.sql.delRec("bwlgme", where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.scod)])
self.loadButton()
def doEnd(self):
if self.df.frt == "T":
data = [self.opts["conum"]] + self.df.t_work[0][0] + [0]
if self.newcmp:
self.sql.insRec("bwlcmp", data=data)
else:
if self.erase:
self.sql.delRec("bwlgme", where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod)])
if self.cfmat in ("D", "K"):
self.sql.delRec("bwltms", where=[("btd_cono", "=",
self.opts["conum"]), ("btd_ccod", "=", self.ccod)])
self.sql.delRec("bwlrnd", where=[("bcr_cono", "=",
self.opts["conum"]), ("bcr_ccod", "=", self.ccod)])
if self.cfmat in ("T", "X"):
recs = self.sql.getRec("bwlent",
cols=["bce_scod"], where=[("bce_cono",
"=", self.opts["conum"]), ("bce_ccod",
"=", self.ccod)], order="bce_scod")
skips = []
for rec in recs:
skips.append(rec[0])
self.doPopulate(skips)
data.append(self.cmp[self.sql.bwlcmp_col.index("bcm_xflag")])
self.sql.updRec("bwlcmp", data=data, where=[("bcm_cono", "=",
self.opts["conum"]), ("bcm_code", "=", self.ccod)])
self.loadButton()
self.df.focusField("C", 0, 1)
else:
if self.newent:
self.sql.insRec("bwlent", data=[self.opts["conum"], self.ccod,
self.scod, self.tcod, self.paid])
if self.cfmat in ("T", "X"):
self.doPopulate([self.scod])
else:
self.sql.updRec("bwlent", cols=["bce_tcod", "bce_paid"],
data=[self.tcod, self.paid], where=[("bce_cono", "=",
self.opts["conum"]), ("bce_ccod", "=", self.ccod),
("bce_scod", "=", self.scod)])
self.loadButton()
self.df.advanceLine(0)
def doPopulate(self, scods):
# Populate bwlgme records
num = self.typ[self.sql.bwltyp_col.index("bct_games")]
dgm = self.typ[self.sql.bwltyp_col.index("bct_drawn")]
for scod in scods:
data = [self.opts["conum"], self.ccod, scod, 0, "",
0, 0, "", 0, 0, 0, 0, 0, 0, 0, "", 0, 0]
for x in range(0, dgm):
data[3] = x + 1
data[4] = "D"
self.sql.insRec("bwlgme", data=data)
for x in range(dgm, num):
data[3] = x + 1
data[4] = "S"
self.sql.insRec("bwlgme", data=data)
def loadButton(self):
rec = self.sql.getRec("bwlent", cols=["count(*)"],
where=[("bce_cono", "=", self.opts["conum"]), ("bce_ccod", "=",
self.ccod)], limit=1)
self.df.B0.setLabel("Entered Players (%s)" % int(rec[0]), udl=0)
def doExit(self):
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase()
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ln2030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"genmst", "gentrn", "lonctl", "lonmf1", "lonmf2", "lonrte",
"lontrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
lonctl = self.gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
self.glint = lonctl["cln_glint"]
self.drate = lonctl["cln_drte"]
self.crate = lonctl["cln_crte"]
self.lastd = lonctl["cln_last"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["lon_ctl"]):
return
self.glctl = (ctlctl["lon_ctl"], ctlctl["int_rec"],
ctlctl["int_pay"])
else:
self.glctl = None
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
lm1 = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols":
(("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")),
"where": [("lm1_cono", "=", self.opts["conum"])]
}
lm2 = {
"stype":
"R",
"tables": ("lonmf2", ),
"cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0,
"Description", "Y")),
"where": [("lm2_cono", "=", self.opts["conum"])],
"whera": [("C", "lm2_acno", 0, 0)]
}
dte = {
"stype":
"R",
"tables": ("lonrte", ),
"cols":
(("lrt_start", "", 0, "Start-Date"), ("lrt_drte", "", 0, "DRte-%"),
("lrt_crte", "", 0, "CRte-%")),
"where": [("lrt_cono", "=", self.opts["conum"])],
"whera": [("C", "lrt_acno", 0, 0), ("C", "lrt_loan", 2, 0)],
"order":
"lrt_start"
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "All Current Rates", "", "N",
"N", self.doAll, None, None,
None), (("T", 0, 1, 0), "ID1", 10, "Effective Date", "", "",
"N", self.doSdate, None, None, ("efld", )),
(("T", 0, 2, 0), "IUD", 6.2, "Debit Rate - Old", "",
self.drate, "N", self.doDRte, None, None, None),
(("T", 0, 2, 0), "IUD", 6.2, "New", "New Debit Rate", "", "N",
self.doDRte, None, None,
None), (("T", 0, 3, 0), "IUD", 6.2, "Credit Rate - Old", "",
self.crate, "N", self.doCRte, None, None, None),
(("T", 0, 3, 0), "IUD", 6.2, "New", "New Credit Rate", "", "N",
self.doCRte, None, None,
None), (("C", 0, 0, 0), "IUA", 7, "Acc-Num", "Account Number",
"", "N", self.doAcc, lm1, None, None),
(("C", 0, 0, 1), "ONA", 30,
"Name"), (("C", 0, 0, 2), "IUI", 2, "Ln", "Loan Number", "",
"N", self.doLon, lm2, None, None),
(("C", 0, 0, 3), "ONA", 30,
"Description"), (("C", 0, 0, 4), "ID1", 10, "Date", "", "",
"N", self.doSdate, dte, None, ("efld", )),
(("C", 0, 0, 5), "IUD", 6.2, "DRte-%", "Debit Rate", "", "N",
self.doDRte, None, None,
None), (("C", 0, 0, 6), "IUD", 6.2, "CRte-%", "Credit Rate",
"", "N", self.doCRte, None, None, None))
tnd = ((self.endPage, "y"), )
txt = (self.exitPage, )
cnd = ((self.endPage, "y"), )
cxt = (self.exitPage, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doAll(self, frt, pag, r, c, p, i, w):
self.allrte = w
if self.allrte == "N":
return "nd"
def doSdate(self, frt, pag, r, c, p, i, w):
if w <= self.lastd:
return "Invalid Date, Before Last Interest Raise Date"
self.sdate = w
self.curdt = int(w / 100)
self.chgrte = False
if self.allrte == "N":
chk = self.sql.getRec("lonrte",
where=[("lrt_cono", "=", self.opts["conum"]),
("lrt_acno", "=", self.acno),
("lrt_loan", "=", self.loan),
("lrt_start", "=", w)],
limit=1)
if chk:
self.df.loadEntry(frt, pag, p + 1, data=chk[4])
self.df.loadEntry(frt, pag, p + 2, data=chk[5])
ok = askQuestion(self.opts["mf"].body,
"Exists",
"""This Date "Already Exists.
Debit Rate: %s Credit Rate: %s
Changing It Could Cause Problems.
Would You Like to Continue?""" % (chk[4], chk[5]),
default="no")
if ok == "no":
return "rf"
self.chgrte = True
def doDRte(self, frt, pag, r, c, p, i, w):
if self.df.frt == "T" and p == 2:
self.oldd = w
else:
self.newd = w
def doCRte(self, frt, pag, r, c, p, i, w):
if self.df.frt == "T" and p == 4:
self.oldc = w
else:
self.newc = w
def doAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("lonmf1",
cols=["lm1_name"],
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.acno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
def doLon(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("lonmf2",
where=[("lm2_cono", "=", self.opts["conum"]),
("lm2_acno", "=", self.acno),
("lm2_loan", "=", w)],
limit=1)
if not acc:
return "Invalid Loan Number"
self.loan = w
desc = acc[self.sql.lonmf2_col.index("lm2_desc")]
self.start = acc[self.sql.lonmf2_col.index("lm2_start")]
self.pmths = acc[self.sql.lonmf2_col.index("lm2_pmths")]
if self.pmths:
return "Fixed Loan, Rate Change Not Allowed"
self.df.loadEntry("C", pag, p + 1, data=desc)
def endPage(self):
if self.df.frt == "T":
if self.allrte == "N":
self.df.focusField("C", 0, 1)
else:
self.updateTables()
self.opts["mf"].dbm.commitDbase(True)
self.exitPage()
else:
self.updateTables()
self.df.advanceLine(0)
def exitPage(self):
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase(True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def updateTables(self):
if self.allrte == "Y":
if self.oldd == self.drate and self.oldc == self.crate:
self.sql.updRec("lonctl",
cols=["cln_drte", "cln_crte"],
data=[self.newd, self.newc],
where=[("cln_cono", "=", self.opts["conum"])])
whr = [("lm2_cono", "=", self.opts["conum"]),
("lrt_cono=lm2_cono", ), ("lrt_acno=lm2_acno", ),
("lrt_loan=lm2_loan", ), ("lrt_drte", "=", self.oldd),
("lrt_crte", "=", self.oldc)]
recs = self.sql.getRec(tables=["lonmf2", "lonrte"],
cols=["lm2_acno", "lm2_loan", "lm2_pmths"],
where=whr,
group="lm2_acno, lm2_loan, lm2_pmths",
order="lm2_acno")
else:
recs = [[self.acno, self.loan, 0]]
for rec in recs:
if rec[2]:
# Fixed Period Loan, No Rate Changes Allowed
continue
# Loans Rate Record
if self.chgrte:
self.sql.updRec("lonrte",
cols=["lrt_drte", "lrt_crte"],
data=[self.newd, self.newc],
where=[("lrt_cono", "=", self.opts["conum"]),
("lrt_acno", "=", rec[0]),
("lrt_loan", "=", rec[1]),
("lrt_start", "=", self.sdate)])
else:
self.sql.insRec("lonrte",
data=[
self.opts["conum"], rec[0], rec[1],
self.sdate, self.newd, self.newc
])
class wg2010(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,
["wagedc", "wagmst", "wagcap", "wagcod"],
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
self.m_hrs = wagctl["ctw_m_hrs"]
self.w_hrs = wagctl["ctw_w_hrs"]
self.d_hrs = wagctl["ctw_d_hrs"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.edit = None
return True
def dataHeader(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "Emp-Num"),
("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0,
"First Names")),
"where": [("wgm_cono", "=", self.opts["conum"]),
("wgm_term", "=", 0)]
}
wed = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_code", "", 0, "Code"), ("ced_desc", "", 0,
"Description", "Y")),
"where": [("ced_cono", "=", self.opts["conum"])],
"whera": [["C", "ced_type", 4, 0]]
}
fld = ((("C", 0, 0, 0), "IUI", 5, "EmpNo", "Employee Number", "r", "N",
self.doEmpno, wgm, None, ("efld", )), (("C", 0, 0, 1), "ONA",
40, "Name"),
(("C", 0, 0, 2), "OUI", 3,
"Dep"), (("C", 0, 0, 3), "IUI", 5, "JobNo", "Job Number", "r",
"N", None, None, None, ("efld", )),
(("C", 0, 0, 4), "IUA", 1, "T", "Earnings/Deduction/NoPay", "r",
"N", self.doType, None, None, ("in", ("E", "D"))),
(("C", 0, 0, 5), "IUI", 3, "Cde", "Code Number", "", "N",
self.doCode, wed, None, ("efld", )), (("C", 0, 0, 6), "ONA",
20, "Description"),
(("C", 0, 0, 7), "IUA", 1, "P", "Pay (Y or N)", "Y", "N",
self.doPay, None, None, ("in", ("Y", "N"))), [
("C", 0, 0, 8), "ISD", 13.2, "Amount", "", "", "N",
self.doAmt, None, None, None
])
but = (("Edit", None, self.editData, 0, ("C", 0, 1), ("C", 0, 2)),
("Interrogate", None, self.queryWag, 0, ("C", 0, 1), ("C", 0,
2)))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
cend=((self.endData, "y"), ),
cxit=(self.exitData, ))
def doEmpno(self, frt, pag, r, c, p, i, w):
rec = self.sql.getRec("wagmst",
cols=[
"wgm_sname", "wgm_fname", "wgm_dept",
"wgm_freq", "wgm_term"
],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", w)],
limit=1)
if not rec:
return "Invalid Employee Number"
elif rec[4]:
return "Employment Terminated"
self.empno = w
name = "%s, %s" % (rec[0], rec[1].split()[0])
self.df.loadEntry(frt, pag, p + 1, data=name)
self.df.loadEntry(frt, pag, p + 2, data=rec[2])
self.freq = rec[3]
def doType(self, frt, pag, r, c, p, i, w):
self.rtyp = w
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
rec = self.readWagedc()
if not rec:
return "Invalid Code"
chk = self.sql.getRec("wagcap",
where=[("wcp_cono", "=", self.opts["conum"]),
("wcp_empno", "=", self.empno),
("wcp_type", "=", self.rtyp),
("wcp_code", "=", self.code)])
if chk:
if self.rtyp == "E":
txt = "Earnings"
else:
txt = "Deduction"
ok = askQuestion(self.df.mstFrame, head="Duplicate",
mess="An Entry for this %s Code Already Exists "\
"for this Employee.\n\nIs This Correct?" % txt)
if ok == "no":
return "rf"
self.df.loadEntry(frt, pag, p + 1, rec[0])
if self.rtyp == "E" and self.code == 1:
std = self.sql.getRec("wagcod",
cols=["wcd_eamt"],
where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno),
("wcd_type", "=", "E"),
("wcd_code", "=", self.code)],
limit=1)
if std and std[0]:
hrs = std[0]
elif self.freq == "M":
hrs = self.m_hrs
elif self.freq == "W":
hrs = self.w_hrs
elif self.freq == "D":
hrs = self.d_hrs
else:
hrs = self.m_hrs
self.df.colf[0][8][5] = hrs
else:
self.df.colf[0][8][5] = ""
def doPay(self, frt, pag, r, c, p, i, w):
pass
def doAmt(self, frt, pag, r, c, p, i, w):
self.xrow = r
def readWagedc(self):
rec = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", self.rtyp),
("ced_code", "=", self.code)],
limit=1)
if not rec:
return None
else:
return rec
def endData(self):
r = self.xrow
data = [
self.opts["conum"], self.empno, self.df.c_work[0][r][2],
self.df.c_work[0][r][3], self.df.c_work[0][r][4],
self.df.c_work[0][r][5], self.df.c_work[0][r][7],
self.df.c_work[0][r][8], "N", self.opts["capnm"], self.sysdtw
]
if self.edit:
data.append(self.edit)
self.sql.updRec("wagcap",
data=data,
where=[("wcp_seq", "=", self.edit)])
self.edit = None
else:
data.append(0)
self.sql.insRec("wagcap", data=data)
self.df.advanceLine(0)
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.closeProcess()
self.opts["mf"].closeLoop()
def editData(self):
# Display captured items and allow editing
col = [
"wcp_empno", "wgm_sname", "wcp_dept", "wcp_job", "wcp_type",
"wcp_code", "ced_desc", "wcp_ind", "wcp_amt", "wcp_seq"
]
whr = [("wcp_cono", "=", self.opts["conum"]), ("wcp_paid", "=", "N"),
("wgm_cono=wcp_cono", ), ("wgm_empno=wcp_empno", ),
("ced_cono=wcp_cono", ), ("ced_type=wcp_type", ),
("ced_code=wcp_code", )]
data = self.sql.getRec(tables=["wagcap", "wagmst", "wagedc"],
cols=col,
where=whr,
order="wcp_empno")
if not data:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
titl = "Captured Items"
head = ("EmpNo", "Surname", "Dep", "JobNo", "T", "Cod", "Description",
"I", "Amount", "Sequence")
lin = {
"stype":
"C",
"titl":
titl,
"head":
head,
"typs": [("UI", 5), ("NA", 30), ("UI", 3), ("UI", 5), ("UA", 1),
("UI", 3), ("NA", 20), ("UA", 1), ("SD", 13.2),
("UI", 10)],
"data":
data,
"butt": [("Delete", self.doDelete, True)]
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select an Item to Edit")
chg = SChoice(self.opts["mf"],
deco=True,
titl=lin["titl"],
head=lin["head"],
data=lin["data"],
typs=lin["typs"],
mode="S",
retn="D",
butt=lin["butt"],
scrn=self.df.mstFrame)
self.df.enableButtonsTags(state=state)
if chg and chg.selection:
for num, fld in enumerate(chg.selection):
if num in (0, 3, 4, 5):
self.df.doKeyPressed("C", 0, self.df.pos, fld)
elif num == (len(chg.selection) - 1):
self.edit = int(fld)
else:
self.df.loadEntry(self.df.frt, self.df.pag, num, data=fld)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doDelete(self, args):
self.sql.delRec("wagcap", where=[("wcp_seq", "=", args[-1:][0])])
def queryWag(self):
callModule(self.opts["mf"],
self.df,
"wg4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class gl2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlynd", "genmst", "genbal"],
prog=self.__class__.__name__)
if self.sql.error:
return
per = self.sql.getRec("ctlynd",
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", 0)],
limit=1)
if not per:
showError(
self.opts["mf"].body, "Period Error", """No Period 0!
Please Contact your Software Support and Quote this Message as this is a Serious Error!"""
)
return
self.start = per[self.sql.ctlynd_col.index("cye_start")]
return True
def drawDialog(self):
sel_acc = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
sel_all = {
"stype":
"R",
"tables": ("genbal", "genmst"),
"cols":
(("glo_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description"),
("glo_trdt", "", 0, "Date"), ("glo_cyr", "", 0, "Balance")),
"where": [("glo_cono", "=", self.opts["conum"]),
("glm_cono=glo_cono", ), ("glm_acno=glo_acno", ),
("glo_trdt", "=", self.start)]
}
fld = ((("C", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "N",
self.doAcc, sel_acc, None, None), (("C", 0, 0, 1), "ONA", 30,
"Description"),
(("C", 0, 0, 2), "ISD", 13.2, "Balance", "Balance Value", "",
"N", self.doBal, None, None, None))
but = (("Import File", None, self.doImport, 0, ("C", 0, 1), ("C", 0,
2),
"Import Opening Balances from a CSV or XLS File."),
("All Entries", sel_all, None, 1, ("C", 0, 1), None,
"Display All Existing Balances"),
("Exit", None, self.exitData, 1, ("C", 0, 1), ("C", 0, 2)))
row = (20, )
self.df = TartanDialog(self.opts["mf"],
rows=row,
eflds=fld,
cend=((self.endData, "y"), ),
cxit=(self.exitData, ),
butt=but)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
impcol = [["Account Number", 0, "UI", 7],
["Opening Balance", 1, "SD", 13.2]]
fi = FileImport(self.opts["mf"], impcol=impcol)
err = None
for num, line in enumerate(fi.impdat):
if len(line) != 2:
err = "Line %s: Invalid Number of Fields (S/B %s is %s)" % \
(num + 1, 2, len(line))
break
self.acc = line[0]
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acc)],
limit=1)
if not chk:
err = "Line %s: Invalid Account %s" % ((num + 1), self.acc)
break
self.bal = line[1]
self.old = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)],
limit=1)
if not self.old:
self.new_acc = "y"
else:
self.new_acc = "n"
self.endData(det=True)
if err:
showError(self.opts["mf"].body, "Import Error", err)
elif fi.impdat:
self.opts["mf"].dbm.commitDbase()
self.df.enableButtonsTags(state=state)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doAcc(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not desc:
return "Invalid Account Number"
self.acc = w
self.df.loadEntry(frt, pag, p + 1, data=desc[0])
self.old = self.sql.getRec("genbal",
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)],
limit=1)
if not self.old:
self.new_acc = "y"
else:
self.new_acc = "n"
bal = self.old[self.sql.genbal_col.index("glo_cyr")]
self.df.loadEntry(frt, pag, p + 2, data=bal)
def doBal(self, frt, pag, r, c, p, i, w):
self.bal = w
def endData(self, det=False):
data = [self.opts["conum"], self.acc, self.start, self.bal]
if self.new_acc == "y":
self.sql.insRec("genbal", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genbal_col
data.append(self.old[col.index("glo_xflag")])
self.sql.updRec("genbal",
data=data,
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acc),
("glo_trdt", "=", self.start)])
if det:
return
self.opts["mf"].dbm.commitDbase()
nxt = self.sql.getRec("genmst",
cols=["glm_acno"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", ">", self.acc)],
limit=1)
if nxt:
self.df.colf[0][0][5] = nxt[0]
else:
self.df.colf[0][0][5] = 0
self.df.advanceLine(0)
def exitData(self):
bals = self.sql.getRec("genbal",
cols=["sum(glo_cyr)"],
where=[("glo_cono", "=", self.opts["conum"]),
("glo_trdt", "=", self.start)],
limit=1)
if bals[0]:
diff = CCD(bals[0], "SD", 13.2)
showError(self.opts["mf"].body, "Out of Balance",
"Opening Balances Do Not Balance by %s" % diff.disp)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
else:
showInfo(
self.opts["mf"].body, "Year End",
"""A Year End for the Previous Period Must be Executed to Include These Opening Balances.
If the Current Period is 1 then the Year End for Period 0 must be Executed.""")
self.df.closeProcess()
self.opts["mf"].closeLoop()
class 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 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 bc2030(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,
["bwltab", "bwlflf", "bwlflm", "bwlflt"],
prog=self.__class__.__name__)
if self.sql.error:
return
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"])]
}
dte = {
"stype": "R",
"tables": ("bwlflt", ),
"cols": (("bft_date", "", 0, "Match-Date"), ),
"where": [("bft_cono", "=", self.opts["conum"])],
"whera": [("T", "bft_fmat", 0, 0), ("T", "bft_type", 4, 0)],
"group": "bft_date",
"order": "bft_date"
}
skp = {
"stype":
"R",
"tables": ("bwlflt", "bwlfls", "bwltab"),
"cols":
(("bft_skip", "", 0, "Skp"), ("btb_surname", "", 0, "Surname",
"Y"), ("btb_names", "", 0, "Names"),
("bft_shotsf", "", 0, "For"), ("bft_shotsa", "", 0, "Agt")),
"where": [("bfs_cono", "=", self.opts["conum"]),
("bfs_league", "=", "M"), ("bfs_code=bft_team", ),
("btb_tab=bft_skip", )],
"whera": [("T", "bft_fmat", 0, 0), ("T", "bft_type", 4, 0),
("T", "bft_date", 5, 0)],
"group":
"bft_skip",
"order":
"btb_surname, btb_names"
}
plr = {
"stype":
"R",
"tables": ("bwlflt", "bwltab"),
"cols":
(("bft_player", "", 0, "Plr"), ("bft_position", "", 0, "P"),
("btb_surname", "", 0, "Name", "Y"), ("btb_names", "", 0,
"Name")),
"where": [("btb_cono", "=", self.opts["conum"]),
("btb_cono=bft_cono", ), ("btb_tab=bft_player", )],
"whera": [["T", "bft_fmat", 0, 0], ["T", "bft_type", 4, 0],
["T", "bft_date", 5, 0], ["C", "bft_skip", 0, 0]],
"group":
"bft_player",
"order":
"bft_position"
}
r1s = (("Fixture", "F"), ("Practice", "P"))
fld = ((("T", 0, 0, 0), "I@bft_fmat", 0, "", "", 0, "N", self.doFmat,
fmt, None, ("efld", )), (("T", 0, 0, 0), "ONA", 30, ""),
(("T", 0, 1, 0), "OUI", 1,
"Number of Forms"), (("T", 0, 2, 0), "OUA", 1, "Assess Self"),
(("T", 0, 3,
0), ("IRB", r1s), 0, "Type", "", "F", "N", self.doType, None,
None, None), (("T", 0, 4, 0), "I@bft_date", 0, "", "", "", "N",
self.doDate, dte, None, ("efld", )),
(("C", 0, 0, 0), "I@bft_skip", 0, "", "", "r", "N", self.doSkip,
skp, None, None), (("C", 0, 0, 1), "ONA", 20, ""),
(("C", 0, 0,
2), "I@bft_player", 0, "", "", "", "N", self.doPlayer, plr,
None, None), (("C", 0, 0, 3), "ONA", 20,
""), (("C", 0, 0, 4), "I@bft_shotsf", 0, "", "",
"", "N", self.doShotsf, None, None, None),
(("C", 0, 0,
5), "I@bft_shotsa", 0, "", "", "", "N", self.doShotsa, None,
None, None), (("C", 0, 0, 6), "I@bft_points", 0, "", "", "",
"N", self.doPoints, None, None, None),
(("C", 0, 0, 7), "I@bft_rating1", 0, "", "", "", "N",
self.doRate1, None, None,
None), (("C", 0, 0, 8), "I@bft_rating2", 0, "", "", "", "N",
self.doRate2, None, None,
None), (("C", 0, 0, 9), "I@bft_rating3", 0, "", "", "",
"N", self.doRate3, None, None, None),
(("C", 0, 0, 10), "I@bft_rating4", 0, "", "", "", "N",
self.doRate4, None, None,
None), (("C", 0, 0, 11), "I@bft_remarks", 20, "", "", "", "N",
self.doRemarks, None, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
cnd = ((self.doEnd, "n"), )
cxt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
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"
if acc[self.sql.bwlflf_col.index("bff_assess")] == "N":
return "Assessment Forms Disabled"
self.fmat = w
desc = acc[self.sql.bwlflf_col.index("bff_desc")]
self.forms = acc[self.sql.bwlflf_col.index("bff_forms")]
self.self = acc[self.sql.bwlflf_col.index("bff_self")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
self.df.loadEntry(frt, pag, p + 2, data=self.forms)
self.df.loadEntry(frt, pag, p + 3, data=self.self)
def doType(self, frt, pag, r, c, p, i, w):
self.ftyp = w
def doDate(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwlflm",
where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat),
("bfm_type", "=", self.ftyp),
("bfm_date", "=", w)],
limit=1)
if not acc:
return "Invalid Date"
self.date = w
def doSkip(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["bwlflt", "bwltab"],
cols=[
"btb_surname", "btb_names", "bft_shotsf",
"bft_shotsa", "bft_rating1", "bft_rating2",
"bft_rating3", "bft_rating4", "bft_remarks"
],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_skip", "=", w),
("btb_cono=bft_cono", ),
("btb_tab=bft_skip", )],
limit=1)
if not acc:
return "Invalid Skip"
acc[0] = self.getName(acc[0], acc.pop(1))
if w == self.skip:
self.repeat = True
else:
self.repeat = False
self.skip = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if self.forms == 1:
for x in range(1, 8):
self.df.loadEntry(frt, pag, p + x + 3, data=acc[x])
return "sk3"
def doPlayer(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["bwlflt", "bwltab"],
cols=[
"btb_surname", "btb_names", "bft_position",
"bft_shotsf", "bft_shotsa", "bft_points",
"bft_rating1", "bft_rating2", "bft_rating3",
"bft_rating4", "bft_remarks"
],
where=[("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date),
("bft_skip", "=", self.skip),
("bft_player", "=", w),
("btb_tab=bft_player", )],
limit=1)
if not acc:
return "This Player Did Not Play for this Skip on this Date"
acc[0] = self.getName(acc[0], acc.pop(1))
self.player = w
self.position = acc[1]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if self.repeat:
self.df.loadEntry(frt, pag, p + 2, data=self.shotsf)
self.df.loadEntry(frt, pag, p + 3, data=self.shotsa)
self.df.loadEntry(frt, pag, p + 4, data=self.points)
else:
self.df.loadEntry(frt, pag, p + 2, data=acc[2])
self.df.loadEntry(frt, pag, p + 3, data=acc[3])
self.df.loadEntry(frt, pag, p + 4, data=acc[4])
for x in range(5, 10):
self.df.loadEntry(frt, pag, p + x, data=acc[x])
if self.repeat:
if self.forms == 4 and self.self == "N" and self.position == 1:
self.rate1 = 0
self.df.loadEntry(frt, pag, p + 5, data=self.rate1)
return "sk5"
else:
return "sk4"
def doShotsf(self, frt, pag, r, c, p, i, w):
self.shotsf = w
def doShotsa(self, frt, pag, r, c, p, i, w):
self.shotsa = w
def doPoints(self, frt, pag, r, c, p, i, w):
self.points = w
if self.forms == 4 and self.self == "N" and self.position == 1:
self.rate1 = 0
self.df.loadEntry(frt, pag, p + 1, data=self.rate1)
return "sk1"
def doRate1(self, frt, pag, r, c, p, i, w):
self.rate1 = w
if self.forms == 4 and self.self == "N" and self.position == 2:
self.rate2 = 0
self.df.loadEntry(frt, pag, p + 1, data=self.rate2)
return "sk1"
def doRate2(self, frt, pag, r, c, p, i, w):
self.rate2 = w
if self.forms == 4 and self.self == "N" and self.position == 3:
self.rate3 = 0
self.df.loadEntry(frt, pag, p + 1, data=self.rate3)
return "sk1"
def doRate3(self, frt, pag, r, c, p, i, w):
self.rate3 = w
if self.forms == 4 and self.self == "N" and self.position == 4:
self.rate4 = 0
self.df.loadEntry(frt, pag, p + 1, data=self.rate4)
return "sk1"
def doRate4(self, frt, pag, r, c, p, i, w):
self.rate4 = w
def doRemarks(self, frt, pag, r, c, p, i, w):
self.remarks = w
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
return
col = ["bft_shotsf", "bft_shotsa", "bft_points"]
dat = [self.shotsf, self.shotsa, self.points]
self.sql.updRec("bwlflt",
cols=col,
data=dat,
where=[("bft_fmat", "=", self.fmat),
("bft_date", "=", self.date),
("bft_skip", "=", self.skip)])
col = [
"bft_rating1", "bft_rating2", "bft_rating3", "bft_rating4",
"bft_remarks"
]
dat = [self.rate1, self.rate2, self.rate3, self.rate4, self.remarks]
if self.forms == 1:
for x in range(1, 5):
self.sql.updRec("bwlflt",
cols=col,
data=dat,
where=[("bft_fmat", "=", self.fmat),
("bft_date", "=", self.date),
("bft_skip", "=", self.skip),
("bft_position", "=", x)])
dat[4] = ""
else:
self.sql.updRec("bwlflt",
cols=col,
data=dat,
where=[("bft_fmat", "=", self.fmat),
("bft_date", "=", self.date),
("bft_skip", "=", self.skip),
("bft_player", "=", self.player)])
self.df.advanceLine(0)
def doExit(self):
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def getName(self, snam, fnam):
if fnam:
for i in fnam.split():
snam = "%s %s" % (snam, i[0])
return snam.upper()
class bc2060(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
t = time.localtime()
self.today = ((t[0] * 10000) + (t[1] * 100) + t[2])
self.sql = Sql(self.opts["mf"].dbm,
["bwlcmp", "bwltab", "bwlgme", "bwltyp", "bwlent"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
com = {
"stype":
"R",
"tables": ("bwlcmp", ),
"cols":
(("bcm_code", "", 0, "Cod"), ("bcm_name", "", 0, "Name", "Y"),
("bcm_date", "", 0, "Date")),
"where": [("bcm_cono", "=", self.opts["conum"])]
}
skp = {
"stype":
"R",
"tables": ("bwltab", "bwlgme"),
"cols":
(("btb_tab", "", 0, "Cod"), ("btb_surname", "", 0, "Surname",
"Y"), ("btb_names", "", 0, "Names"),
("bcg_rink", "", 0, "RK"), ("bcg_ocod", "", 0, "Opp")),
"where": [("btb_cono", "=", self.opts["conum"]),
("bcg_cono=btb_cono", ), ("bcg_scod=btb_tab", )],
"whera": [("T", "bcg_ccod", 0, 0), ("T", "bcg_game", 2, 0)],
"group":
"btb_tab",
"order":
"btb_tab"
}
fld = (
(("T",0,0,0),"I@bcm_code",0,"","",
"","Y",self.doCmpCod,com,None,("notzero",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,1,0),"I@bcg_game",0,"Game Number","",
1,"N",self.doGame,None,None,("efld",)),
(("T",0,1,0),"I@bcg_date",0,"Date","",
self.today,"N",self.doDate,None,None,("efld",)),
(("T",0,2,0),"IUA",30,"Greens","Greens (A,B,C)",
"","N",self.doGreens,None,None,("efld",),None,"Available "\
"Greens in the format A,B or A,B345 showing Green Code and "\
"Rinks. If the Rinks are Not Entered they will Default to 6."),
(("C",0,0,0),"I@bcg_scod",0,"","",
"","N",self.doSkpCod,skp,None,("notzero",)),
(("C",0,0,0),"ONA",30,"Skp-Name"),
(("C",0,0,0),"I@bcg_ocod",0,"","",
"","N",self.doOppCod,skp,None,("notzero",)),
(("C",0,0,0),"ONA",30,"Opp-Name"),
(("C",0,0,0),"I@bcg_rink",0,"","",
"","N",self.doRink,None,None,("notblank",)))
but = (("Quit", None, self.doQuit, 1, None, None), )
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
cnd = ((self.doEnd, "y"), )
cxt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("bwlcmp",
cols=["bcm_name", "bcm_date", "bcm_type"],
where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_code", "=", w)],
limit=1)
if not com:
return "Invalid Competition Code"
name, self.sdat, ctyp = com
self.df.loadEntry(frt, pag, p + 1, data=name)
chk = self.sql.getRec("bwltyp",
cols=["bct_cfmat"],
where=[("bct_cono", "=", self.opts["conum"]),
("bct_code", "=", ctyp)],
limit=1)
if chk[0] in ("D", "K", "R"):
return "Knockout and R/Robin Draws Cannot be Changed"
chk = self.sql.getRec("bwlgme",
cols=[
"bcg_game", "bcg_date", "bcg_aflag",
"sum(bcg_ocod)", "sum(bcg_sfor)"
],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", w)],
group="bcg_game, bcg_date, bcg_aflag")
self.ccod = w
self.game = 0
self.draws = {}
self.manual = False
for ck in chk:
if ck[2] == "A" or ck[4]:
continue
if ck[4]:
continue
if ck[2] in ("", "D", "S") and ck[3]:
self.draws[ck[0]] = ck[1:]
if not self.draws:
ok = askQuestion(self.opts["mf"].body, "Manual Draw",
"Is this the First Game and is it going to be a "\
"Manual Draw?", default="no")
if ok == "no":
return "rf"
self.manual = True
self.game = 1
self.df.loadEntry(frt, pag, p + 2, data=self.game)
self.totskp = self.sql.getRec("bwlent",
cols=["count(*)"],
where=[("bce_cono", "=",
self.opts["conum"]),
("bce_ccod", "=", self.ccod)],
limit=1)[0]
return "sk2"
def doGame(self, frt, pag, r, c, p, i, w):
if w not in self.draws:
return "Invalid Game Number"
self.game = w
self.date = self.draws[w][0]
self.df.loadEntry(frt, pag, p + 1, data=self.date)
self.totskp = self.sql.getRec("bwlent",
cols=["count(*)"],
where=[("bce_cono", "=",
self.opts["conum"]),
("bce_ccod", "=", self.ccod)],
limit=1)[0]
def doDate(self, frt, pag, r, c, p, i, w):
if w < self.today or w < self.sdat:
return "Invalid Date, in the Past or Before the Starting Date"
self.date = w
def doGreens(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid Greens"
self.rinks = []
rinks = 0
grns = w.split(",")
for gr in grns:
if len(gr) == 1:
for x in range(1, 7):
self.rinks.append("%s%s" % (gr[0], x))
rinks += 6
elif len(gr) == 2 and gr[1] == "7":
for x in range(1, 8):
self.rinks.append("%s%s" % (gr[0], x))
rinks += 7
else:
for rk in gr[1:]:
self.rinks.append("%s%s" % (gr[0], rk))
rinks += 1
if int(self.totskp / 2) > rinks:
return "Not Enough Rinks"
def doSkpCod(self, frt, pag, r, c, p, i, w):
skp = self.sql.getRec(
tables=["bwlgme", "bwltab"],
cols=["btb_surname", "btb_names", "bcg_ocod", "bcg_rink"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w),
("bcg_game", "=", self.game), ("btb_cono=bcg_cono", ),
("btb_tab=bcg_scod", )],
limit=1)
if not skp:
return "Invalid Skip Code"
self.skip = w
self.old_opp = skp[2]
self.old_rink = skp[3]
if skp[1]:
name = "%s, %s" % tuple(skp[:2])
else:
name = skp[0]
self.df.loadEntry(frt, pag, p + 1, data=name)
if self.old_opp:
self.df.loadEntry(frt, pag, p + 2, data=self.old_opp)
opp = self.sql.getRec("bwltab",
cols=["btb_surname", "btb_names"],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", skp[2])],
limit=1)
if opp[1]:
name = "%s, %s" % tuple(opp[:2])
else:
name = opp[0]
self.df.loadEntry(frt, pag, p + 3, data=name)
if self.old_rink:
self.df.loadEntry(frt, pag, p + 4, data=self.old_rink)
def doOppCod(self, frt, pag, r, c, p, i, w):
opp = self.sql.getRec(
tables=["bwlgme", "bwltab"],
cols=["btb_surname", "btb_names", "bcg_ocod", "bcg_rink"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w),
("bcg_game", "=", self.game), ("btb_cono=bcg_cono", ),
("btb_tab=bcg_scod", )],
limit=1)
if not opp:
return "Invalid Opponents Code"
self.new_opp = w
self.chg_skp = opp[2]
if opp[1]:
name = "%s, %s" % tuple(opp[:2])
else:
name = opp[0]
self.df.loadEntry(frt, pag, p + 1, data=name)
def doRink(self, frt, pag, r, c, p, i, w):
if w not in self.rinks:
return "Invalid Rink"
self.new_rink = w
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
else:
self.df.advanceLine(0)
self.sql.updRec("bwlgme",
cols=["bcg_date", "bcg_ocod", "bcg_rink"],
data=[self.date, self.new_opp, self.new_rink],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.skip),
("bcg_game", "=", self.game)])
self.sql.updRec("bwlgme",
cols=["bcg_date", "bcg_ocod", "bcg_rink"],
data=[self.date, self.skip, self.new_rink],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.new_opp),
("bcg_game", "=", self.game)])
def doExit(self):
if self.df.frt == "C":
chk = self.sql.getRec("bwlgme",
cols=["bcg_ocod", "count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game)],
group="bcg_ocod",
order="bcg_ocod")
for c in chk:
if c[0] and c[1] != 1:
skp = self.sql.getRec("bwlgme",
cols=["bcg_scod"],
where=[("bcg_cono", "=",
self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game),
("bcg_ocod", "=", c[0])],
order="bcg_scod")
err = "Opponent %s is Drawn Against %s Skips\n" % tuple(c)
for s in skp:
err = err + "\nSkip %s" % s[0]
skp = self.sql.sqlRec("Select bce_scod from bwlent where "\
"bce_ccod = %s and bce_scod not in (select bcg_ocod "\
"from bwlgme where bcg_ccod = %s and bcg_game = %s)" %
(self.ccod, self.ccod, self.game))
err = err + "\n\nSkips Without Opponents\n"
for s in skp:
err = err + "\nSkip %s" % s[0]
showError(self.opts["mf"].body, "Skip Error", err)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
chk = self.sql.getRec("bwlgme",
cols=["bcg_rink", "count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game)],
group="bcg_rink",
order="bcg_rink")
for c in chk:
if c[1] != 2:
skp = self.sql.getRec("bwlgme",
cols=["bcg_scod", "bcg_ocod"],
where=[("bcg_cono", "=",
self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game),
("bcg_rink", "=", c[0])],
group="bcg_scod, bcg_ocod, bcg_rink",
order="bcg_scod")
skps = []
for s in skp:
if [s[1], s[0]] not in skps:
skps.append(s)
err = "Rink %s Shows %s time(s)\n" % (c[0], int(c[1] / 2))
for s in skps:
err = err + "\nSkip %2s Opp %2s" % (s[0], s[1])
rnk = self.sql.getRec("bwlgme",
cols=["bcg_rink", "count(*)"],
where=[("bcg_cono", "=",
self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.game)],
group="bcg_rink",
order="bcg_rink")
rnks = []
for r in rnk:
rnks.append(r[0])
mis = ""
for r in self.rinks:
if r not in rnks:
if not mis:
mis = r
else:
mis = "%s, %s" % (mis, r)
err = err + "\n\nAvailable Rink(s)\n\n%s" % mis
showError(self.opts["mf"].body, "Rink Error", err)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doQuit(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.closeProcess()
self.opts["mf"].closeLoop()
class 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 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 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 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 gl6050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlctl", "genmst", "gentrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def doProcess(self):
glm = {
"stype": "R",
"tables": ("ctlctl", "genmst"),
"cols": (
("ctl_conacc", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"where": [
("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "like", "bank_%"),
("glm_cono=ctl_cono",),
("glm_acno=ctl_conacc",)]}
typ = {
"stype": "C",
"title": "Select Type",
"head": ("C", "Type"),
"data": ((2, "Payment"), (4, "Journal"), (6, "Receipt"))}
self.glt = {
"stype": "R",
"tables": ("gentrn",),
"cols": (
("glt_trdt", "", 0, "Date"),
("glt_type", ("XX", gltrtp), 3, "Typ"),
("glt_refno", "", 0, "Reference", "Y"),
("glt_seq", "", 0, "Sequence"),
("glt_tramt", "", 0, "Amount"),
("glt_desc", "", 0, "Details")),
"where": [],
"index": 2,
"zero": "0"}
r1s = (("Yes","Y"), ("No","N"))
fld = (
(("T",0,0,0),"IUI",7,"Bank Account","",
"","N",self.doBankAcc,glm,None,("notzero",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,1,0),"ID2",7,"Last Period","Last Reconciliation Period",
0,"N",self.doLastPer,None,None,("efld",)),
(("T",0,2,0),("IRB",r1s),7,"Clear History","",
"N","N",self.doClear,None,None,None),
(("C",0,0,0),"IUA",1,"T","Reference Type",
2,"N",self.doTrnTyp,typ,None,("in", ("2","4","6"))),
(("C",0,0,1),"INa",9,"Ref-Num","Reference Number",
"i","N",self.doTrnRef,self.glt,None,("notblank",)),
(("C",0,0,2),"OD1",10,"Date"),
(("C",0,0,3),"OSD",13.2,"Amount"),
(("C",0,0,4),"ONA",30,"Details"))
tnd = ((self.endTop,"y"),)
txt = (self.exitTop,)
cnd = ((self.endCol,"y"),)
cxt = (self.exitCol,)
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt, cend=cnd, cxit=cxt)
def doBankAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["ctlctl", "genmst"], cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]), ("glm_acno", "=", w),
("ctl_cono=glm_cono",), ("ctl_conacc=glm_acno",), ("ctl_code",
"like", "bank_%")], limit=1)
if not acc:
return "Invalid Bank Account Number"
self.acno = w
self.df.loadEntry("T", 0, p+1, data=acc[0])
def doLastPer(self, frt, pag, r, c, p, i, w):
self.curdt = w
def doClear(self, frt, pag, r, c, p, i, w):
self.clear = w
def endTop(self):
whr = [
("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno)]
if self.clear == "Y":
self.sql.updRec("gentrn", cols=["glt_recon"], data=[0], where=whr)
whr.extend([("glt_curdt", "<=", self.curdt), ("glt_recon", "=", 0)])
self.sql.updRec("gentrn", cols=["glt_recon"], data=[self.curdt],
where=whr)
self.df.focusField("C", 0, 1)
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doTrnTyp(self, frt, pag, r, c, p, i, w):
self.opts["rtn"] = w
self.df.colf[0][1][8]["where"] = [
("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno),
("glt_type", "=", self.opts["rtn"]),
("glt_curdt", "<=", self.curdt),
("glt_recon", "<>", 0)]
try:
self.df.rs.selection = None
except:
pass
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
try:
rs = self.df.rs.selection
except:
rs = None
if not rs:
wa = [
("glt_type", "=", self.opts["rtn"]),
("glt_refno", "=", self.trnref)]
opt = {}
for k in self.glt:
if k == "where":
opt[k] = copyList(self.glt[k])
opt[k].extend(wa)
elif type(self.glt[k]) == list:
opt[k] = copyList(self.glt[k])
else:
opt[k] = self.glt[k]
rs = self.df.selRecord(1, opt).selection
if rs:
self.df.loadEntry("C", 0, p+1, data=rs[0])
self.df.loadEntry("C", 0, p+2, data=rs[4])
self.df.loadEntry("C", 0, p+3, data=rs[5])
self.seq = rs[3]
return "nd"
else:
return "Invalid Transaction"
def endCol(self):
self.sql.updRec("gentrn", cols=["glt_recon"], data=[0],
where=[("glt_seq", "=", self.seq)])
self.df.advanceLine(0)
def exitCol(self):
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
