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 queryAss(self):
callModule(self.opts["mf"],
self.df,
"ar4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
def doCrsQuery(self):
callModule(self.opts["mf"],
self.df,
"cr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def queryDrs(self):
callModule(self.opts["mf"],
self.df,
"dr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def doEnd(self):
self.df.closeProcess()
if self.opts["period"][0] == 1:
self.sql.updRec("ctlynd", cols=["cye_start", "cye_end"],
data=[self.s0, self.e0], where=[("cye_cono", "=",
self.opts["conum"]), ("cye_period", "=", 0)])
for per in self.pers:
num = per[self.sql.ctlynd_col.index("cye_period")]
if num == self.opts["period"][0]:
self.start = self.s_per
self.end = self.e_per
else:
self.start = self.getStartDate(self.end)
self.end = self.getEndDate(self.start)
self.sql.updRec("ctlynd", cols=["cye_start", "cye_end"],
data=[self.start, self.end], where=[("cye_cono", "=",
self.opts["conum"]), ("cye_period", "=", num)])
spl = SplashScreen(self.opts["mf"].body,
text="Running Year End Routine for Period %s" % num)
per = getPeriods(self.opts["mf"], self.opts["conum"], num - 1)
per = (num - 1, (per[0].work, per[0].disp), (per[1].work, per[1].disp))
callModule(self.opts["mf"], None, "msy010", coy=(self.opts["conum"],
self.opts["conam"]), period=per, user=self.opts["capnm"], args="N")
spl.closeSplash()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
def maintainDrs(self):
callModule(self.opts["mf"],
self.df,
"dr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def doPrint(self):
if not self.newtyp:
callModule(self.opts["mf"],
None,
"bc3080",
coy=[self.opts["conum"], self.opts["conam"]],
args=[self.ctype, self.cdesc])
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 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 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 doSecEnd(self):
ccod = getNextCode(self.sql, "bwlcmp", "bcm_code",
where=[("bcm_cono", "=", self.opts["conum"])], last=999)
self.sql.updRec("bwlcmp", cols=["bcm_poff"], data=[ccod],
where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_code", "=", self.ccod)])
cdes = self.cdes + " Play-Off"
t = time.localtime()
cdte = ((t[0] * 10000) + (t[1] * 100) + t[2])
self.sql.insRec("bwlcmp", data=[self.opts["conum"],
ccod, cdes, cdte, 0, ""])
for skp in self.swin:
self.sql.insRec("bwlent", data=[self.opts["conum"],
ccod, skp, 0, "Y", ""])
callModule(self.opts["mf"], self.df, "bc2050", coy=[self.opts["conum"],
self.opts["conam"]], args=ccod)
def doEnd(self):
self.df.closeProcess()
# Headings and Mail subject
self.cdes = "%-30s" % self.opts["conam"]
start = self.getDate(self.start)
end = self.getDate(projectDate(self.end, 1))
if self.period == "D":
self.hdes = "Arrivals for Weekdays %s to %s" % (start, end)
elif self.period == "E":
self.hdes = "Arrivals for Weekend %s to %s" % (start, end)
else:
self.hdes = "Arrivals for Period %s to %s" % (start, end)
self.fpdf = MyFpdf(name=self.__class__.__name__, head=80, auto=True)
self.fpdf.header = self.pageHeading
self.rtyp = "A"
self.doArrival()
if self.house == "Y":
self.rtyp = "H"
self.hdes = self.hdes.replace("Arrivals", "Units")
if self.fpdf.page:
self.fpdf.add_page()
self.doHKeeping()
if self.fpdf.page:
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
subj = "%s - %s" % (self.cdes, self.hdes)
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=subj, repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
if self.prtinv == "Y" and self.docs:
# Print Invoice
self.docs.sort()
PrintBookingInvoice(self.opts["mf"], self.opts["conum"],
self.opts["conam"], "I", self.docs, tname=self.tname,
repprt=self.df.repprt, repeml=self.df.repeml)
# Print Statement
self.book.sort()
callModule(self.opts["mf"], None, "bk3070",
coy=(self.opts["conum"], self.opts["conam"]),
args=[self.book, self.df.repprt, self.df.repeml])
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def 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 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 strEnd(self):
self.rs.closeProcess()
col = self.sql.genstr_col
for rep in self.strm:
args = {"stream": True}
args["end"] = self.end
args["typ"] = rep[col.index("gls_typ")]
args["cno"] = rep[col.index("gls_cno")]
args["con"] = rep[col.index("gls_con")]
args["dep"] = "N"
args["dpl"] = [0]
args["rep"] = rep[col.index("gls_rep")]
args["gen"] = rep[col.index("gls_gen")]
args["val"] = rep[col.index("gls_val")]
args["det"] = rep[col.index("gls_det")]
if args["typ"] == "M":
args["var"] = "N"
else:
args["var"] = rep[col.index("gls_var")]
if not args["var"]:
args["var"] = "B"
args["zer"] = rep[col.index("gls_zer")]
args["opt"] = rep[col.index("gls_opt")]
if not args["opt"]:
args["opt"] = "N"
args["num"] = rep[col.index("gls_num")]
if not args["num"]:
args["num"] = "Y"
var = callModule(self.opts["mf"], None, "gl3050",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"], args=args,
ret=["fpdf", "emlhead"])
if var:
nam = os.path.join(self.tmp, "report%s.pdf" % self.count)
self.fles.append(nam)
var["fpdf"].output(nam)
des = var["emlhead"].lower()
des = " ".join(w.capitalize() for w in des.split())
self.mess = "%s\n%2s) %s - %s" % (self.mess, self.count,
"General Ledger", des)
self.count += 1
if var:
self.sql.insRec("rptstr", data=[self.opts["conum"],
self.rgrp, "gl3050", str([[self.end, self.stno, "S", "N",
"N", 1, "N", "V", "", "", "B", "Y", "Y", "Y"]])])
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 doEnd(self):
err = None
if self.same == "Y":
if self.mstart + 400 > self.nstart:
err = "Invalid Range, Too Few Members Allowed For"
elif self.mstart == self.fstart and self.same == "N":
err = "Same Male and Female Starting Numbers"
elif self.mstart < self.fstart:
if self.fstart - self.mstart < 200:
err = "Invalid Range, Too Few Male Numbers"
elif self.nstart < self.fstart + 200:
err = "Invalid Range, Too Few Female Numbers"
elif self.mstart - self.fstart < 200:
err = "Invalid Range, Too Few Female Numbers"
elif self.nstart < self.mstart + 200:
err = "Invalid Range, Too Few Male Numbers"
if err:
self.df.focusField("T", 0, 3, err=err)
else:
data = [self.opts["conum"]]
if not self.memctl:
data.extend(["N", "N"])
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new:
self.sql.insRec("bwlctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.bwlctl_col
data.append(self.acc[col.index("ctb_xflag")])
self.sql.updRec("bwlctl",
data=data,
where=[("ctb_cono", "=", self.opts["conum"])])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.acc):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"bwlctl", "U",
"%03i" % self.opts["conum"],
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if self.chgint and self.oldint == "Y":
recs = self.sql.getRec("bwltab",
cols=["btb_memno"],
where=[("btb_cono", "=",
self.opts["conum"])])
for rec in recs:
data = self.doLoadMember(rec[0])
if data == [0, "", "", "", "", "", "", "", ""]:
continue
self.sql.updRec("bwltab",
cols=[
"btb_memno", "btb_add1", "btb_add2",
"btb_add3", "btb_pcod", "btb_home",
"btb_work", "btb_cell", "btb_mail"
],
data=data,
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_memno", "=", rec[0])])
if not self.new and (self.mstart != self.oldm or \
self.fstart != self.oldf or self.nstart != self.oldn):
# Tab ranges changed
ok = askQuestion(self.opts["mf"].body, "Ranges", "Tab Ranges "\
"Have Changed, Do You Want to Change the Tabs to the "\
"New Ranges?", default="no")
if ok == "yes":
mdif = self.mstart - self.oldm
fdif = self.fstart - self.oldf
ndif = self.nstart - self.oldn
recs = []
if ndif > 0:
recs.extend(self.getNon())
if self.oldm > self.oldf:
recs.extend(self.getWom())
recs.extend(self.getMen())
else:
recs.extend(self.getMen())
recs.extend(self.getWom())
if ndif < 0:
recs.extend(self.getNon())
self.df.setWidget(self.df.mstFrame, state="hide")
pb = ProgressBar(self.opts["mf"].body,
typ="Changing Tabs",
mxs=len(recs))
for num, rec in enumerate(recs):
pb.displayProgress(num)
tab = rec[self.sql.bwltab_col.index("btb_tab")]
gdr = rec[self.sql.bwltab_col.index("btb_gender")]
if tab < self.oldn:
if gdr == "M":
new = tab + mdif
else:
new = tab + fdif
else:
new = tab + ndif
callModule(
self.opts["mf"],
None,
"bc6010",
coy=[self.opts["conum"], self.opts["conam"]],
args=[tab, new])
pb.closeProgress()
self.df.setWidget(self.df.mstFrame, state="show")
self.opts["mf"].dbm.commitDbase()
self.doExit()
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 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 doCalendar(self):
self.number = 0
self.ptyp = None
self.newb = False
udics = {}
self.start = projectDate(self.sysdtw, -7)
bkm = self.sql.getRec("bkmmst",
cols=["max(bkm_depart)"],
where=[("bkm_cono", "=", self.opts["conum"]),
("bkm_state", "<>", "X")],
limit=1)
if not bkm or bkm[0] is None:
days = 15
else:
days = dateDiff(self.start, bkm[0], "days") + 1
if days < 15:
days = 15
bkmunm = self.sql.getRec("bkmunm",
where=[("bum_cono", "=", self.opts["conum"]),
("bum_maxg", "<>", 999)],
order="bum_btyp, bum_code")
if not bkmunm:
showError(self.opts["mf"].body, "Units",
"No Units in the Database")
self.quit = True
return
col = self.sql.bkmunm_col
for num, unit in enumerate(bkmunm):
t = unit[col.index("bum_btyp")]
c = unit[col.index("bum_code")]
d = unit[col.index("bum_desc")]
m = unit[col.index("bum_maxg")]
if t == "A" and c == "ALL":
continue
udics["%s-%s" % (t, c)] = [d, CCD(m, "UI", 3).disp] + [""] * days
for x in range(num, 10):
t = "X"
c = x - num
d = ""
m = " "
udics["%s-%s" % (t, c)] = [d, m] + [""] * days
books = self.sql.getRec(tables="bkmmst",
cols=[
"bkm_number", "bkm_btype", "bkm_arrive",
"bkm_depart", "bkm_state"
],
where=[("bkm_cono", "=", self.opts["conum"]),
("bkm_depart", ">=", self.start),
("bkm_state", "<>", "X")])
for book in books:
if book[2] < self.start:
book[2] = self.start
sday = dateDiff(self.start, book[2], "days")
eday = dateDiff(self.start, book[3], "days")
if book[1] == "O":
eday += 1
bkmrtt = self.sql.getRec("bkmrtt",
cols=["brt_utype", "brt_ucode"],
where=[("brt_cono", "=",
self.opts["conum"]),
("brt_number", "=", book[0])])
units = []
for rtt in bkmrtt:
units.append("%s-%s" % tuple(rtt))
if "A-ALL" in units:
units.remove("A-ALL")
for unit in udics:
if unit[0] == "A":
units.append(unit)
for unit in units:
if unit not in udics:
continue
for d in range(sday, eday):
if book[4] == "Q":
udics[unit][d + 2] = "Query|%s" % book[0]
elif book[4] == "C":
udics[unit][d + 2] = "Confirmed|%s" % book[0]
elif book[4] == "S":
udics[unit][d + 2] = "Settled|%s" % book[0]
titl = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Lodging and Function Bookings Calendar (bk1010)")
labs = (("Code", 8), ("Description", 30), ("Qty", 4))
tags = [("blank", ("black", "white")),
("label", ("black", "lightgray")),
("query", (self.opts["mf"].rcdic["qfg"],
self.opts["mf"].rcdic["qbg"])),
("confirm", (self.opts["mf"].rcdic["cfg"],
self.opts["mf"].rcdic["cbg"])),
("settle", (self.opts["mf"].rcdic["sfg"],
self.opts["mf"].rcdic["sbg"]))]
cols = [[]]
for x in range(days):
d1 = CCD(projectDate(self.start, x), "D1", 10)
d2 = time.strftime("%A", time.strptime(str(d1.work), "%Y%m%d"))
txt = "%s\n%s" % ("{:^10}".format(d2), d1.disp)
cols[0].append((txt, 10))
keys = list(udics.keys())
keys.sort()
data = []
for row, key in enumerate(keys):
cod = ("%s" % key, "label")
des = ("%s" % udics[key][0], "label")
qty = ("%-s" % udics[key][1], "label")
lab = (cod, des, qty)
col = []
lst = None
tag = ""
spn = 1
for c, d in enumerate(udics[key][2:]):
if d == lst:
spn += 1
continue
if lst is not None:
col.append((txt, tag, spn))
spn = 1
lst = d
if not d:
num = 0
txt = "\n"
tag = "blank"
else:
sta, num = d.split("|")
txt = "%s\n%s" % (num, sta)
if sta == ("Query"):
tag = "query"
elif sta == ("Confirmed"):
tag = "confirm"
elif sta == ("Settled"):
tag = "settle"
if spn > 300:
col.append((txt, tag, 300))
col.append((txt, tag, spn - 300))
else:
col.append((txt, tag, spn))
data.append((lab, col))
butt = [("New Booking", self.doNew), ("Search Bookings", self.doSch),
("Deposits List", (self.doRep, "D")),
("Arrivals List", (self.doRep, "L")), ("Quit", self.doQuit)]
cmds = [("<Double-1>", self.doBkm), ("<Button-3>", self.doEnq)]
self.cal = ScrollGrid(
**{
"mf":
self.opts["mf"],
"titl":
titl,
"chgt":
2,
"tags":
tags,
"labs":
labs,
"cols":
cols,
"data":
data,
"butt":
butt,
"cmds":
cmds,
"font": (self.opts["mf"].rcdic["mft"],
self.opts["mf"].rcdic["dfs"]),
"wait":
False,
"minc":
14
})
self.opts["mf"].startLoop(deicon=False)
if self.tt:
self.tt.hideTip()
self.tt = None
self.cal.window.destroy()
self.opts["mf"].setThemeFont()
self.opts["mf"].window.deiconify()
if not self.ptyp and not self.quit:
callModule(self.opts["mf"],
None,
"bk1020",
coy=(self.opts["conum"], self.opts["conam"]),
user=self.opts["capnm"],
args=self.number)
elif self.ptyp == "D":
callModule(self.opts["mf"],
None,
"bk3010",
coy=(self.opts["conum"], self.opts["conam"]),
args=True)
elif self.ptyp == "L":
callModule(self.opts["mf"],
None,
"bk3030",
coy=(self.opts["conum"], self.opts["conam"]),
user=self.opts["capnm"],
args=True)
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 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 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 doEnd(self):
self.df.closeProcess()
tabels = [("genmst", "glm")]
if self.df.t_work[0][0][1] == "Y":
tabels.append(("ctlctl", "ctl"))
if self.df.t_work[0][0][2] == "Y":
tabels.append(("genbal", "glo"))
if self.df.t_work[0][0][3] == "Y":
tabels.append(("gentrn", "glt"))
if self.df.t_work[0][0][4] == "Y":
tabels.append(("genbud", "glb"))
if self.df.t_work[0][0][5] == "Y":
tabels.append(("genjlm", "gjm"))
tabels.append(("genjlt", "gjt"))
if self.df.t_work[0][0][6] == "Y":
tabels.append(("genrpt", "glr"))
if self.df.t_work[0][0][7] == "Y":
tabels.append(("gendtm", "gdm"))
tabels.append(("gendtt", "gdt"))
if self.df.t_work[0][0][8] == "Y":
tabels.append(("genstr", "gls"))
for tab, ref in tabels:
self.sql.delRec(tab,
where=[("%s_cono" % ref, "=", self.opts["conum"])])
recs = self.sql.getRec(tables=tab,
where=[("%s_cono" % ref, "=", self.oldco)])
if recs:
p = ProgressBar(self.opts["mf"].body,
mxs=len(recs),
typ="Copying %s" % tab)
for num, acc in enumerate(recs):
p.displayProgress(num)
coy = "%s_cono" % ref
col = getattr(self.sql, "%s_col" % tab)
acc[col.index(coy)] = self.opts["conum"]
self.sql.insRec(tab, data=acc)
p.closeProgress()
if self.df.t_work[0][0][9] == "Y":
self.sql.delRec("ctlynd",
where=[("cye_cono", "=", self.opts["conum"])])
ynds = self.sql.getRec("ctlynd",
where=[("cye_cono", "=", self.oldco),
("cye_period", "in", (0, 1))],
order="cye_period")
for ynd in ynds:
ynd[0] = self.opts["conum"]
self.sql.insRec("ctlynd", data=ynd)
mxp = self.sql.getRec("ctlynd",
cols=["max(cye_period)"],
where=[("cye_cono", "=", self.oldco)],
limit=1)
for p in range(1, mxp[0]):
pr = getPeriods(self.opts["mf"], self.oldco, p)
per = (p, (pr[0].work, pr[0].disp), (pr[1].work, pr[1].disp))
callModule(self.opts["mf"],
None,
"msy010",
coy=(self.opts["conum"], self.opts["conam"]),
period=per,
user=self.opts["capnm"],
args=pr[2])
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
