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 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 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 doOwner(self, frt, pag, r, c, p, i, w):
self.ocode = w
if not self.ocode:
ok = askQuestion(self.opts["mf"].body,
"New Member",
"Is This a New Member?",
default="no")
if ok == "no":
return "Invalid Code"
self.doNewOwner()
if not self.oend:
return "rf"
self.df.loadEntry(frt, pag, p, data=self.ocode)
acc = self.sql.getRec("bksown",
where=[("bof_cono", "=", self.opts["conum"]),
("bof_code", "=", self.ocode)],
limit=1)
if not acc:
return "Invalid Code"
self.df.loadEntry(frt, pag, p + 1, data=self.getOwner(self.ocode))
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 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 doEnd(self):
recs = self.sql.getRec("ctlbat", cols=["count(*)"],
where=[("btm_cono", "=", self.opts["conum"]), ("btm_styp", "=",
"RTL"), ("btm_ind", "=", "N"), ("btm_curdt", "=", self.curdt)],
limit=1)
if recs[0]:
ok = askQuestion(self.opts["mf"].body, "Unbalanced Batches Exist",
"There are unbalanced batches for this month. You "\
"SHOULD not continue, but print a batch error report, and "\
"correct the errors. Continue, YES or NO ?", default="no")
if ok == "yes":
ok = PwdConfirm(self.opts["mf"], conum=self.opts["conum"],
system="RTL", code="UnbalBatch")
if ok.flag == "no":
self.closeProcess()
else:
self.updateTables()
else:
self.closeProcess()
else:
self.updateTables()
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 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 doGenerate(self):
self.opts["mf"].updateStatus("")
ok = askQuestion(self.opts["mf"].body, "ARE YOU SURE???",
"Are You Certain This Is What You Want To Do? This "\
"Will Automatically Generate New Account Numbers For "\
"All Accounts Based On The Account Names!", default="no")
if ok == "no":
self.df.focusField("T", 0, 1)
return
self.df.closeProcess()
self.autogen = "Y"
recs = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=", self.opts["conum"])],
order="lm1_name")
col = self.sql.lonmf1_col
if recs:
p = ProgressBar(self.opts["mf"].body,
typ="Generating Account Numbers",
mxs=len(recs))
for num, acc in enumerate(recs):
p.displayProgress(num)
self.oldacc = acc[col.index("lm1_acno")]
name = acc[col.index("lm1_name")]
for seq in range(1, 100):
self.newacc = genAccNum(name, seq)
if self.newacc == self.oldacc:
break
chk = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=",
self.opts["conum"]),
("lm1_acno", "=", self.newacc)
],
limit=1)
if not chk:
break
self.doProcess(focus=False)
p.closeProgress()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
def doGrp(self, frt, pag, r, c, p, i, w):
self.rgrp = w
rsm = self.sql.getRec("rptstm", where=[("rsm_cono", "=",
self.opts["conum"]), ("rsm_rgrp", "=", w)], limit=1)
if not rsm:
ok = askQuestion(self.opts["mf"].body, "New Group",
"In This a New Report Group?", default="no")
if ok == "no":
return "Invalid Group"
self.new = True
else:
self.new = False
self.tadd = rsm[2]
rsr = self.sql.getRec("rptstr", where=[("rsr_cono", "=",
self.opts["conum"]), ("rsr_rgrp", "=", w)])
self.smod = {}
for rep in rsr:
self.smod[rep[2]] = rep[3]
if not self.smtp:
self.styp = "P"
self.df.loadEntry(frt, pag, p+1, data="P")
return "sk1"
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 doAcno(self, frt, pag, r, c, p, i, w):
if w:
self.oldacc = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=",
self.opts["conum"]),
("lm1_acno", "=", w)],
limit=1)
if not self.oldacc:
return "Invalid Account Number"
self.acno = w
self.name = self.oldacc[self.sql.lonmf1_col.index("lm1_name")]
self.email = self.oldacc[self.sql.lonmf1_col.index("lm1_email")]
for num, dat in enumerate(self.oldacc[1:-1]):
self.df.loadEntry("T", 0, num, data=dat)
self.newacc = False
else:
yn = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Loan Account?",
default="no")
if yn == "no":
return "Invalid Account Number"
self.newacc = True
def doDelivery(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
ok = askQuestion(self.opts["mf"].body, head="Delivery Address",
mess="This Delivery Address Does Not Exist, Would "\
"You Like to Create It Now?", default="no")
if ok == "no":
return "rf"
callModule(self.opts["mf"],
self.df,
"drc410",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=None,
args=w)
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
return "rf"
def doVatCod(self, frt, pag, r, c, p, i, w):
self.vat = w
acc = self.doReadVat(self.vat)
if not acc:
ok = askQuestion(
self.opts["mf"].body, "VAT Code",
"This Code Does Not Exist, Do You Want to Create It?")
if ok == "no":
return "Invalid Code"
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
callModule(self.opts["mf"],
None,
"ms1040",
coy=(self.opts["conum"], self.opts["conam"]),
user=self.opts["capnm"],
args=self.vat)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
acc = self.doReadVat(self.vat)
if not acc:
self.df.loadEntry(frt, pag, p, data="")
return "Invalid Code"
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 doImpRpt(self):
self.df.setWidget(self.df.B0, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
sel = FileDialog(parent=self.opts["mf"].body, title="Import File",
initd=self.opts["mf"].rcdic["wrkdir"], ftype=[("Report", "*.rpt")])
nam = sel.askopenfilename()
err = None
if nam:
fle = open(nam, "r")
for num, line in enumerate(fle):
dat = line.split("|")
if not num:
if dat[0] != "genrpt":
err = "This File Does Not Contain a Valid Format"
break
chk = self.sql.getRec("genrpt",
where=[("glr_cono", "=", dat[1]), ("glr_repno", "=",
dat[2]), ("glr_seq", "=", 0)], limit=1)
if chk:
ok = askQuestion(self.opts["mf"].body, "Replace?",
"This Report Already Exists, Would you like "\
"to Replace It?")
if ok == "yes":
self.sql.delRec("genrpt", where=[("glr_cono", "=",
dat[1]), ("glr_repno", "=", dat[2])])
else:
err = "Report Already Exists"
break
self.sql.insRec("genrpt", data=dat[1:])
else:
self.sql.insRec(dat[0], data=dat[1:])
if not err:
self.opts["mf"].dbm.commitDbase(ask=True)
else:
showError(self.opts["mf"].body, "Invalid Import", err)
self.df.setWidget(self.df.mstFrame, "show")
self.df.focusField("T", 0, 1)
def 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 doGenerate(self):
self.opts["mf"].updateStatus("")
ok = askQuestion(self.opts["mf"].body, "ARE YOU SURE???",
"Are You Certain This Is What You Want To Do? This "\
"Will Automatically Generate New Account Numbers For "\
"All Accounts Based On The Account Names!", default="no")
if ok == "no":
self.df.focusField("T", 0, 1)
return
self.df.closeProcess()
self.autogen = "Y"
recs = self.sql.getRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"])],
order="drm_chain, drm_name")
col = self.sql.drsmst_col
if recs:
p = ProgressBar(self.opts["mf"].body,
typ="Generating Account Numbers",
mxs=len(recs))
for num, acc in enumerate(recs):
p.displayProgress(num)
self.oldchn = self.newchn = acc[col.index("drm_chain")]
self.oldacc = acc[col.index("drm_acno")]
if self.oldacc[:4] == "CASH":
continue
# Remove invalid characters
name = acc[col.index("drm_name")].replace(" ", "")
name = name.replace(".", "")
name = name.replace(",", "")
name = name.replace(";", "")
name = name.replace(":", "")
name = name.replace("'", "")
name = name.replace('"', "")
if len(name) < 5:
name = name + ("0" * (5 - len(name)))
acno = ""
for c in range(0, 5):
acno = (acno + name[c]).upper()
acno = acno.strip()
text = "%s%0" + str((7 - len(acno))) + "d"
for x in range(1, 100):
self.newacc = text % (acno, x)
if self.newacc == self.oldacc:
break
chk = self.sql.getRec("drsmst",
where=[
("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.newchn),
("drm_acno", "=", self.newacc)
])
if not chk:
break
self.oldnot = "%03i%s" % (self.oldchn, self.oldacc)
self.newnot = "%03i%s" % (self.newchn, self.newacc)
self.olddel = acc[col.index("drm_delivery")]
if self.olddel == self.oldacc:
self.newdel = self.newacc
else:
self.newdel = self.olddel
self.doProcess(focus=False)
p.closeProgress()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
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 doEnd(self):
self.df.closeProcess()
whr = [("rcc_cono", "=", self.opts["conum"]), ("rtn_cono=rcc_cono", ),
("rtn_owner=rcc_owner", ), ("rtn_code=rcc_code", ),
("rtn_acno=rcc_acno", ), ("rcc_status", "<>", "X")]
recs = self.sql.getRec(
tables=["rcacon", "rcatnm"],
cols=[
"rcc_cono", "rcc_owner", "rcc_code", "rcc_acno", "rcc_cnum",
"rcc_payind", "rcc_start", "rcc_period", "rcc_rtlamt",
"rcc_deposit", "rcc_wamt", "rcc_wtyp", "rcc_eamt", "rcc_etyp",
"rtn_name"
],
where=whr,
)
if recs:
for num, self.con in enumerate(recs):
own = self.sql.getRec("rcaowm",
cols=["rom_vatdf"],
where=[("rom_cono", "=",
self.opts["conum"]),
("rom_acno", "=", self.con[1])],
limit=1)
if not own:
showError(
self.opts["mf"].body, "Missing Owner",
"This Owner's Record (%s) Could Not Be Found!" %
self.con[1])
continue
self.vatdf = own[0]
self.prm = self.sql.getRec("rcaprm",
cols=["rcp_crate"],
where=[
("rcp_cono", "=",
self.opts["conum"]),
("rcp_owner", "=", self.con[1]),
("rcp_code", "=", self.con[2])
],
limit=1)
if not self.prm:
showError(
self.opts["mf"].body, "Missing Premises",
"This Premises's Record (%s %s) Could Not Be Found!" %
(self.con[1], self.con[2]))
continue
self.freq = self.con[5]
self.strt = CCD(self.con[6], "D1", 10)
self.pers = self.con[7]
self.amnt = self.con[8]
self.depo = self.con[9]
self.wamt = self.con[10]
self.wtyp = self.con[11]
self.eamt = self.con[12]
self.etyp = self.con[13]
if self.freq == "M":
self.mths = 1 * self.pers
elif self.freq == "3":
self.mths = 3 * self.pers
elif self.freq == "6":
self.mths = 6 * self.pers
else:
self.mths = 12 * self.pers
exdt = projectDate(self.strt.work, self.mths - 1, typ="months")
exdt = CCD(mthendDate(exdt), "D1", 10)
if int(exdt.work / 100) <= self.curdt:
self.sql.updRec("rcacon",
cols=["rcc_status"],
data=["X"],
where=[("rcc_cono", "=", self.con[0]),
("rcc_owner", "=", self.con[1]),
("rcc_code", "=", self.con[2]),
("rcc_acno", "=", self.con[3]),
("rcc_cnum", "=", self.con[4])])
ok = askQuestion(self.opts["mf"].body, "Expired Contract",
"This contract has Expired, would you like to "\
"Renew it?\n\nOwner: %s\nPremises: %s\nAccount: %s\n"\
"Name: %s\nStart: %s\nEnd: %s" % (self.con[1],
self.con[2], self.con[3], self.con[14], self.strt.disp,
exdt.disp))
if ok == "no":
continue
self.doExpiredContract()
self.doRaiseRental(num)
self.doRaiseExtra(num)
self.sql.updRec("rcactl",
cols=["cte_lme"],
data=[self.tme],
where=[("cte_cono", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase(ask=True, mess="Do You Want To Save "\
"All Changes?\n\nPlease Note That Once The Changes Have Been "\
"Saved, There Is No Going Back Without Restoring From Backup!")
self.opts["mf"].closeLoop()
def doChange(self, chgs):
if self.doimp:
p1 = ProgressBar(self.opts["mf"].body,
typ="",
mxs=len(self.tables))
genrpt = "no"
else:
genrpt = askQuestion(
self.opts["mf"].body,
head="Report Generator",
mess="Apply this Change to the Report Generator as well?",
default="no")
for num, tab in enumerate(self.tables):
if tab[0] == "genrpt" and genrpt == "no":
continue
if self.doimp:
p1.txtlab.configure(text="Changing %s Table" % tab[0])
p1.displayProgress(num)
new = []
if self.doimp:
p2 = ProgressBar(self.opts["mf"].body,
inn=p1,
typ="",
mxs=len(chgs))
for seq, chg in enumerate(chgs):
if self.doimp:
p2.txtlab.configure(text="Changing Number %s to %s" %
(chg[0], chg[1]))
p2.displayProgress(seq)
# Get records for this change
oldacc, newacc = chg
if tab[0] == "genrpt":
whr = [(tab[1], "in", (0, self.opts["conum"]))]
else:
whr = [(tab[1], "=", self.opts["conum"])]
if tab[0] == "ctlnot":
whr.extend([("not_sys", "=", "GEN"),
(tab[2], "=", str(oldacc))])
elif tab[0] == "ctlvtf":
oldacc = CCD(oldacc, "Na", 7).work
newacc = CCD(newacc, "Na", 7).work
whr.extend([(tab[2], "=", oldacc), (tab[3], "=", "G")])
else:
whr.append((tab[2], "=", oldacc))
recs = self.sql.getRec(tables=tab[0], where=whr)
if not recs:
continue
# Delete records
self.sql.delRec(tab[0], where=whr)
# Make changes
col = getattr(self.sql, "%s_col" % tab[0])
pos = col.index(tab[2])
cpy = copyList(recs)
for rec in cpy:
rec[pos] = newacc
new.append(rec)
if self.doimp:
p2.closeProgress()
if new:
self.sql.insRec(tab[0], data=new)
if self.doimp:
p1.closeProgress()
self.opts["mf"].dbm.commitDbase(ask=True)
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 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 doEnd(self):
self.df.closeProcess()
chk = self.sql.getRec("bwlgme", cols=["bcg_group", "bcg_scod"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=",
self.ccod), ("bcg_game", "=", self.pgame)], order="bcg_group")
if chk[0][0] and self.cfmat == "R":
groups = "Y"
else:
groups = self.groups
self.grps = {}
for rec in chk:
if rec[0] not in self.grps:
self.grps[rec[0]] = [[rec[1]], [], []]
else:
self.grps[rec[0]][0].append(rec[1])
self.keys = list(self.grps.keys())
self.keys.sort()
self.fpdf = MyFpdf(name=self.__class__.__name__, head=65)
self.lastg = None
for g in self.keys:
self.pageHeading()
if self.gamrep == "Y":
self.doReport("G", g)
if g == 0 and len(chk) > 20:
self.pageHeading()
self.doReport("M", g)
if self.pgame == self.games:
# Enter Prizes
for key in self.keys:
if self.cfmat == "R" and groups == "Y":
self.grps[key][1] = 0
else:
self.doPrizes(key)
# Match Winners & Summary
self.gqty = len(self.keys)
self.wins = {}
self.allp = []
self.swin = []
self.where = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "<=", self.pgame),
("btb_cono=bcg_cono",),
("btb_tab=bcg_scod",)]
for grp in range(self.gqty):
if groups == "Y":
gcod = grp + 1
else:
gcod = grp
whr = copyList(self.where)
whr.append(("bcg_group", "=", gcod))
col = [
"bcg_scod", "btb_surname", "btb_names",
"sum(bcg_a_sfor) as sfor",
"sum(bcg_a_sagt) as sagt",
"sum(bcg_a_sfor - bcg_a_sagt) as agg",
"sum(bcg_a_points) as pts"]
recs = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=col,
where=whr, group="bcg_scod, btb_surname, btb_names",
order="pts desc, agg desc, sagt asc")
if not recs:
continue
self.wins[gcod] = []
for x in range(self.grps[gcod][1]):
self.allp.append(recs[x][0])
if recs[x][2]:
nam = "%s, %s" % (recs[x][1], recs[x][2].split()[0])
else:
nam = recs[x][1]
self.wins[gcod].append(nam)
if self.cfmat == "R" and groups == "Y":
self.swin.append(self.grps[gcod][0][0])
if self.sesp == "Y":
self.pageHeading("S")
self.doSesWin()
else:
for grp in self.wins:
if self.wins[grp]:
self.pageHeading("S")
break
self.doMatchWin()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, "report", ext="pdf")
self.fpdf.output(pdfnam, "F")
if self.df.repeml[1] == "Y":
if not self.df.repeml[2]:
col = ["btb_mail"]
whr = [
("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod),
("btb_cono=bce_cono",),
("btb_tab=bce_scod",),
("btb_mail", "<>", "")]
recs = self.sql.getRec(tables=["bwlent", "bwltab"], cols=col,
where=whr)
self.df.repeml[2] = []
for rec in recs:
self.df.repeml[2].append(rec[0])
head = "%s - Results after game %s" % (self.cdes, self.pgame)
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam,
header=head, repprt=self.df.repprt, fromad=self.fromad,
repeml=self.df.repeml)
if self.pgame == self.lgame and self.cfmat == "R" and \
groups == "Y" and not self.poff:
ok = askQuestion(self.opts["mf"].body, "Play-Offs",
"Must a Play-Off Draw be Created and/or Printed?",
default="yes")
if ok == "yes":
self.doSecEnd()
self.opts["mf"].closeLoop()
def doDelete(self):
if self.read == "N":
return
if self.table in ("gentrn", "crstrn", "drstrn"):
ask = askQuestion(self.opts["mf"].body,
"Delete",
"Delete All Associated Records?",
default="no")
else:
ask = "no"
if ask == "yes":
err = ""
tabs = ["gentrn", "ctlvtf", "crsctl", "crstrn", "drsctl", "drstrn"]
sql = Sql(self.opts["mf"].dbm, tables=tabs)
conum = self.olddata[0]
if self.table == "gentrn":
system = "G"
docno = CCD(self.olddata[5], "Na", 9).work
date = CCD(self.olddata[3], "D1", 10).work
dtyp = CCD(self.olddata[4], "UI", 2).work
gtyp = dtyp
elif self.table == "crstrn":
system = "C"
acno = CCD(self.olddata[1], "NA", 7).work
dtyp = CCD(self.olddata[2], "UI", 2).work
docno = CCD(self.olddata[3], "Na", 9).work
date = CCD(self.olddata[5], "D1", 10).work
if dtyp in (1, 4):
gtyp = 5 # Purchase
elif dtyp == 2:
gtyp = 6 # Receipt
elif dtyp == 3:
gtyp = 4 # Journal
elif dtyp == 5:
gtyp = 2 # Payment
glint = sql.getRec("crsctl",
cols=["ctc_glint"],
where=[("ctc_cono", "=", conum)],
limit=1)[0]
else:
system = "D"
chain = CCD(self.olddata[1], "UI", 3).work
acno = CCD(self.olddata[2], "NA", 7).work
dtyp = CCD(self.olddata[3], "UI", 2).work
docno = CCD(self.olddata[4], "Na", 9).work
date = CCD(self.olddata[6], "D1", 10).work
if dtyp in (1, 4):
gtyp = 1 # Sale
elif dtyp == 2:
gtyp = 6 # Receipt
elif dtyp == 3:
gtyp = 4 # Journal
elif dtyp == 5:
gtyp = 2 # Payment
glint = sql.getRec("drsctl",
cols=["ctd_glint"],
where=[("ctd_cono", "=", conum)],
limit=1)[0]
sqv = [("vtt_cono", "=", conum), ("vtt_styp", "=", system),
("vtt_refno", "=", docno), ("vtt_refdt", "=", date),
("vtt_ttyp", "=", dtyp)]
recs = sql.getRec("ctlvtf", where=sqv)
if len(recs) > 1:
err = "ctlvtf recs %s\n" % len(recs)
texc = 0
ttax = 0
for rec in recs:
texc = float(ASD(texc) + ASD(rec[11]))
ttax = float(ASD(ttax) + ASD(rec[12]))
ttot = float(ASD(texc) + ASD(ttax))
ok = "yes"
if system == "G" or glint == "Y":
sqg = [("glt_cono", "=", conum), ("glt_refno", "=", docno),
("glt_trdt", "=", date), ("glt_type", "=", gtyp)]
recs = sql.getRec("gentrn", where=sqg)
gamt = 0
gtax = 0
for rec in recs:
gamt = float(ASD(gamt) + ASD(rec[7]))
gtax = float(ASD(gtax) + ASD(rec[8]))
if gtax != ttax:
err = "%sctlvtf %s <> gentrn %s\n" % (err, ttax, gtax)
if gamt:
err = "%sgentrn debits <> credits" % err
if system == "C":
sqc = [("crt_cono", "=", conum), ("crt_acno", "=", acno),
("crt_ref1", "=", docno), ("crt_trdt", "=", date),
("crt_type", "=", dtyp)]
recs = sql.getRec("crstrn", where=sqc)
if len(recs) > 1:
err = "%scrstrn recs %s\n" % (err, len(recs))
camt = 0
ctax = 0
for rec in recs:
camt = float(ASD(camt) + ASD(rec[7]))
ctax = float(ASD(ctax) + ASD(rec[8]))
if ctax != ttax:
err = "%sctlvtf %s <> crstrn %s\n" % (err, ttax, ctax)
if camt != ttot:
err = "%sctlvtf tot %s <> crstrn tot %s" % (err, ttot,
camt)
if system == "D":
sqd = [("drt_cono", "=", conum), ("drt_chain", "=", chain),
("drt_acno", "=", acno), ("drt_ref1", "=", docno),
("drt_trdt", "=", date), ("drt_type", "=", dtyp)]
recs = sql.getRec("drstrn", where=sqd)
if len(recs) > 1:
err = "%sdrstrn recs %s\n" % (err, len(recs))
damt = 0
dtax = 0
for rec in recs:
damt = float(ASD(damt) - ASD(rec[8]))
dtax = float(ASD(dtax) - ASD(rec[9]))
if dtax != ttax:
err = "%sctlvtf %s <> drstrn %s\n" % (err, ttax, dtax)
if damt != ttot:
err = "%sctlvtf tot %s <> drstrn tot %s" % (err, ttot,
damt)
if err:
ok = askQuestion(self.opts["mf"].body, "Error",
"%s\n\nDelete transaction (y/n)?" % err)
if ok == "yes":
sql.delRec("ctlvtf", where=sqv)
if system == "G" or glint == "Y":
sql.delRec("gentrn", where=sqg)
if system == "C":
sql.delRec("crstrn", where=sqc)
if system == "D":
sql.delRec("drstrn", where=sqd)
else:
self.sql.delRec(self.table, data=self.olddata)
self.olddata = []
self.doReset()
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 doEnd(self):
self.df.closeProcess()
if not self.new:
self.sql.delRec("rptstm", where=[("rsm_cono", "=",
self.opts["conum"]), ("rsm_rgrp", "=", self.rgrp)])
self.sql.delRec("rptstr", where=[("rsr_cono", "=",
self.opts["conum"]), ("rsr_rgrp", "=", self.rgrp)])
self.sql.insRec("rptstm", data=[self.opts["conum"], self.rgrp,
self.tadd])
titl = "Report Stream"
cols = (
("a", "", 0, "CB", "N"),
("b", "R-Code", 6, "NA", "N"),
("c", "System", 25, "NA", "N"),
("d", "Report", 30, "NA", "N"))
data = []
for mod in self.mods:
if mod[0] in self.smod:
data.append(["X", mod[0], mod[1], mod[2]])
else:
data.append(["", mod[0], mod[1], mod[2]])
sc = SelectChoice(self.opts["mf"].body, titl, cols, data)
if sc.selection:
self.count = 1
self.fles = []
self.tmp = os.path.join(self.opts["mf"].rcdic["wrkdir"], "temp")
if os.path.exists(self.tmp):
shutil.rmtree(self.tmp)
os.mkdir(self.tmp)
if self.styp == "E":
self.mess = "Attached please find the following reports:\n"
else:
self.mess = "Reports to Print:\n"
for mod in sc.selection:
if mod[1] == "gl3050":
self.doGetStream()
if self.strm:
self.strm = None
continue
self.opts["mf"].head.configure(text="")
try:
if mod[1] in self.smod:
work = eval(self.smod[mod[1]])
else:
raise Exception
except:
work = self.vars[mod[1]]
var = callModule(self.opts["mf"], None, mod[1],
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"], user=self.opts["capnm"],
args={"noprint": True, "work": work}, ret=["fpdf",
"t_work"])
if var:
nam = os.path.join(self.tmp, "report%s.pdf" % self.count)
self.fles.append(nam)
var["fpdf"].output(nam)
self.mess = "%s\n%2s) %s - %s" % (self.mess, self.count,
mod[2], mod[3])
self.sql.insRec("rptstr", data=[self.opts["conum"],
self.rgrp, mod[1], str(var["t_work"])])
self.count += 1
if self.fles:
if self.styp == "E":
self.mess = "%s\n\nRegards" % self.mess
ok = askQuestion(self.opts["mf"].body, "Mail Reports",
self.mess, default="yes")
if ok == "yes":
self.doEmailReps()
else:
ok = askQuestion(self.opts["mf"].body, "Print Reports",
self.mess, default="yes")
if ok == "yes":
self.doPrintReps()
for fle in self.fles:
os.remove(fle)
self.opts["mf"].dbm.commitDbase(True)
self.closeProcess()
def doEnder(self):
self.df.closeProcess()
recs = self.sql.getRec("memmst",
cols=["mlm_memno"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_state", "=", "A")])
if self.ynd:
p = ProgressBar(self.opts["mf"].body,
typ="Checking Member Categories",
mxs=len(recs))
for num, acc in enumerate(recs):
p.displayProgress(num)
self.memno = acc[0]
data = doChkCatChg(self.opts["mf"], self.opts["conum"],
self.memno, self.nxtdt)
if data:
if not data[3]:
self.doRaiseCharge("B",
data[0],
data[1],
data[2],
data[3],
data[4],
data[5],
data[6],
skip=True)
dte = int("%04i%02i%02i%02i%02i%02i" % \
time.localtime()[:-3])
self.sql.delRec("memcat",
where=[("mlc_cono", "=",
self.opts["conum"]),
("mlc_memno", "=", self.memno),
("mlc_type", "=", "B"),
("mlc_code", "=", data[0])])
self.sql.insRec(
"chglog",
data=[
"memcat", "D",
"%03i%06i%1s%02i" %
(self.opts["conum"], self.memno, "B", data[0]), "",
dte, self.opts["capnm"],
str(data[1]),
str(data[2]), "", 0
])
self.sql.insRec("memcat",
data=[
self.opts["conum"], self.memno, "B",
data[7], "", self.nxtdt, 0, 0
])
self.sql.insRec(
"chglog",
data=[
"memcat", "N",
"%03i%06i%1s%02i" %
(self.opts["conum"], self.memno, "B", data[7]), "",
dte, self.opts["capnm"],
str(self.nxtdt),
str(0), "", 0
])
p.closeProgress()
ok = askQuestion(self.opts["mf"].body,
"Category Changes",
"Would You Like to Display Category Changes?",
default="yes")
if ok == "yes":
callModule(self.opts["mf"],
None,
"ml3060",
coy=(self.opts["conum"], self.opts["conam"]),
args=(projectDate(self.lme, 1), self.nxtdt))
ok = askQuestion(
self.opts["mf"].body,
"Continue",
"Would You Like to Continue with the Month End?",
default="yes")
if ok == "no":
self.opts["mf"].closeLoop()
return
p = ProgressBar(self.opts["mf"].body, typ="F", mxs=len(recs))
for num, acc in enumerate(recs):
p.displayProgress(num)
self.memno = acc[0]
if self.penalty == "Y":
amount = 0
join = "left outer join memage on mta_cono=mlt_cono and "\
"mta_memno=mlt_memno and mta_type=mlt_type and "\
"mta_refno=mlt_refno"
cols = ["mlt_ctyp", "mlt_ccod", "sum(mlt_tramt)"]
wher = [("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno),
("mlt_trdt", "<=", self.cutoff)]
grps = "mlt_ctyp, mlt_ccod"
ordr = "mlt_trdt"
recs = self.sql.getRec("memtrn",
join=join,
cols=cols,
where=wher,
group=grps,
order=ordr)
for rec in recs:
key = "%s%02i" % (rec[0], rec[1])
if key in self.pcodes:
amt = round(rec[2] * self.pcodes[key] / 100.0, 2)
if amt > 0:
amount = float(ASD(amount) + ASD(amt))
if amount:
self.doUpdateTables("", "", "Penalty on Overdue Amounts",
self.penctl, self.tme, amount)
cols = [
"mlc_type", "mlc_code", "mcc_desc", "mcc_freq", "mlc_start",
"mlc_end", "mlc_last", "mcc_glac"
]
wher = [("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", self.memno), ("mlc_start", ">", 0),
("mlc_start", "<=", self.nxtdt), ("mcc_cono=mlc_cono", ),
("mcc_type=mlc_type", ), ("mcc_code=mlc_code", ),
("mcc_freq", "<>", "N")]
cats = self.sql.getRec(tables=["memcat", "memctc"],
cols=cols,
where=wher,
order="mlc_type, mlc_code")
for ctyp, code, desc, freq, start, end, last, glac in cats:
if start > self.nxtdt:
# Not yet Started
continue
if last and end and end < self.nxtdt:
# Ended
continue
if last and freq == "O":
# Once Off
continue
if not self.ynd and last and freq == "A" and \
last >= self.opts["period"][1][0] and \
last <= self.opts["period"][2][0]:
# Out of Period
continue
self.doRaiseCharge(ctyp, code, start, end, last, freq, desc,
glac)
p.closeProgress()
self.sql.updRec("memctl",
cols=["mcm_lme"],
data=[self.tme],
where=[("mcm_cono", "=", self.opts["conum"])])
ok = askQuestion(self.opts["mf"].body,
"Audit Trail",
"Would You Like to Display an Audit Trail?",
default="yes")
if ok == "yes":
callModule(self.opts["mf"],
None,
"ml3020",
coy=(self.opts["conum"], self.opts["conam"]),
args=("F", 0, self.nxtcd, 1, self.batch))
self.opts["mf"].dbm.commitDbase(ask=True,
mess="Do You Want To Save All Entries?\n\nPlease Note That "\
"Once The Entries Have Been Saved, There Is No Going Back "\
"Without Restoring From Backup!")
if self.ynd and self.opts["mf"].dbm.commit == "yes":
callModule(self.opts["mf"],
None,
"msy010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"],
args="N")
self.opts["mf"].closeLoop()
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"
