class bc3080(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.ctyp = self.opts["args"][0]
self.cnam = self.opts["args"][1]
self.card = False
self.qty = 1
self.doEnd()
else:
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, ["bwlcmp", "bwltyp", "bwlpts",
"bwlnot"], 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.fromad = bwlctl["ctb_emadd"]
t = time.localtime()
self.sysdt = time.strftime("%d %B %Y %H:%M:%S", t)
self.image = os.path.join(self.opts["mf"].rcdic["wrkdir"], "bowls.png")
if not os.path.exists(self.image):
getImage("bowls", fle=self.image)
if not os.path.exists(self.image):
self.image = None
self.card = True
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Competition Format")
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"])]}
r1s = (("A4 Page", "P"), ("A6 Card", "C"))
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),"ITV",(50,10),"Notes","",
"","N",self.doNotes,None,None,None,None,"""Enter All Additional Rules and Notes for the Competition e.g. what to do in these cases:
Trial Ends - Only 1 trial end per game.
Burnt Ends - Replay the end."""),
(("T",0,2,0),("IRB",r1s),0,"Paper Type","",
"P","N",self.doPaper,None,None,None),
(("T",0,3,0),"IUI",2,"Quantity","",
1,"N",self.doQty,None,None,("notzero",)))
but = (("Edit Notes", None, self.doEdit, 0, ("T",0,4), ("T",0,5)),)
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], title=self.tit,
eflds=fld, butt=but, tend=tnd, txit=txt, view=("N","V"),
mail=("Y","N"))
def doCmpCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("bwlcmp", cols=["bcm_name", "bcm_type"],
where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=", w)],
limit=1)
if not chk:
return "Invalid Competition Code"
self.ccod = w
self.cnam = chk[0]
self.ctyp = chk[1]
self.df.loadEntry(frt, pag, p+1, data=self.cnam)
nte = self.sql.getRec("bwlnot", where=[("bcn_cono", "=",
self.opts["conum"]), ("bcn_ccod", "=", self.ccod)], limit=1)
if nte:
self.notes = nte[2]
self.df.loadEntry(frt, pag, p+2, self.notes)
return "sk2"
def doEdit(self):
self.df.focusField("T", 0, 3, tag=False)
def doNotes(self, frt, pag, r, c, p, i, w):
self.notes = w
def doPaper(self, frt, pag, r, c, p, i, w):
if w == "P":
self.card = False
else:
self.card = True
def doQty(self, frt, pag, r, c, p, i, w):
self.qty = w
def doEnd(self):
if "args" not in self.opts:
hdr = self.tit
prt = copyList(self.df.repprt)
eml = copyList(self.df.repeml)
self.df.closeProcess()
else:
hdr = "%03i %s - %s" % (self.opts["conum"], self.opts["conam"],
"Competition Format")
prt = ["Y", "V", "view"]
eml = None
self.drawFormat()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], pdfnam=pdfnam, header=hdr,
repprt=prt, fromad=self.fromad, repeml=eml)
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def drawFormat(self):
whr = [
("bct_cono", "=", self.opts["conum"]),
("bct_code", "=", self.ctyp)]
rec = self.sql.getRec("bwltyp", where=whr, limit=1)
ldic = {}
for col in self.sql.bwltyp_col[3:]:
ldic[col] = rec[self.sql.bwltyp_col.index(col)]
whr = [
("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctyp)]
rec = self.sql.getRec("bwlpts", where=whr)
for r in rec:
if r[self.sql.bwlpts_col.index("bcp_ptyp")] == "D":
ptyp = "drawn"
else:
ptyp = "svs"
ldic[ptyp] = {}
for col in self.sql.bwlpts_col[3:]:
ldic[ptyp][col] = r[self.sql.bwlpts_col.index(col)]
if self.card:
self.fpdf = MyFpdf(auto=True)
self.fpdf.set_margins(55, 5, 55)
self.fpdf.c_margin = self.fpdf.c_margin * 2
self.fpdf.set_font("Arial","",8)
h = 3.5
else:
self.fpdf = MyFpdf(auto=True)
self.fpdf.set_font("Arial","",14)
h = 6
self.fpdf.header = self.pageHeading
cwth = self.fpdf.get_string_width("X")
x1 = self.fpdf.l_margin + (cwth * 20)
x2 = self.fpdf.l_margin + (cwth * 22)
for page in range(self.qty):
self.fpdf.add_page()
self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_cfmat"][4],
h=h, ln=0)
if ldic["bct_cfmat"] == "T":
txt = "Tournament"
elif ldic["bct_cfmat"] in ("D", "K"):
txt = "Knockout"
elif ldic["bct_cfmat"] == "R":
txt = "Round Robin"
else:
txt = "Match"
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_tsize"][4],
h=h, ln=0)
self.fpdf.drawText(txt=ldic["bct_tsize"], x=x1, h=h, ctyp="M")
#if ldic["bct_cfmat"] in ("D", "K", "R"):
# return
self.fpdf.drawText(txt="Draw", h=h, ln=0)
if ldic["bct_drawn"] == ldic["bct_games"]:
txt = "All Games will be Random Draws."
else:
if ldic["bct_drawn"] == 1:
txt = "The First Game will be a Random Draw and "\
"thereafter Strength v Strength."
else:
txt = "The First %s Games will be Random Draws and "\
"thereafter Strength v Strength." % ldic["bct_drawn"]
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
if ldic["bct_games"]:
self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_games"][4],
h=h, ln=0)
self.fpdf.drawText(txt=ldic["bct_games"], x=x1, h=h, ctyp="M")
self.fpdf.drawText(txt=self.sql.bwltyp_dic["bct_ends"][4],h=h,ln=0)
self.fpdf.drawText(txt=ldic["bct_ends"], x=x1, h=h, ctyp="M")
if ldic["bct_grgame"]:
self.fpdf.drawText(txt="Groups", h=h, ln=0)
txt = "Teams will be Split into Groups After Game %s." % \
ldic["bct_grgame"]
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
if ldic["bct_adjust"] == "Y":
txt = "With the Exception of Group A, the Scores will be "\
"Adjusted as follows:"
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
if ldic["bct_expunge"]:
gms = ldic["bct_expunge"].split(",")
if len(gms) == 1:
txt = "Game %s will be Expunged" % gms[0]
else:
txt = "Games %s" % gms[0]
for n, g in enumerate(gms[1:]):
if n == len(gms) - 2:
txt = "%s and %s" % (txt, g)
else:
txt = "%s, %s" % (txt, g)
txt = "%s will be Expunged." % txt
self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M")
if ldic["bct_percent"]:
if ldic["bct_expunge"]:
txt = "The Balance of the Games"
else:
txt = "All Games"
txt = "%s will Retain %s%s of their score." % (txt,
ldic["bct_percent"], "%")
self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M")
# Points
self.fpdf.drawText(h=h)
if ldic["bct_pdiff"] == "Y":
nums = ["drawn", "svs"]
else:
nums = ["drawn"]
for ptyp in nums:
if ldic["bct_pdiff"] == "N":
txt = "Scoring for All Games"
elif ptyp == "drawn":
txt = "Scoring for Drawn Games"
else:
txt = "Scoring for S v S Games"
self.fpdf.drawText(txt=txt, h=h)
self.fpdf.underLine(h=h, txt=txt)
if ldic[ptyp]["bcp_sends"]:
self.fpdf.drawText(txt="Skins", h=h, ln=0)
self.fpdf.drawText(txt="Each Set of %s Ends will "\
"Constitute a Skin." % ldic[ptyp]["bcp_sends"], x=x1,
h=h, ctyp="M")
self.fpdf.drawText(txt="Points", h=h, ln=0)
txt = ""
pts = 0
if ldic[ptyp]["bcp_e_points"]:
if ldic[ptyp]["bcp_e_points"] == 1:
txt = "%s Point per End" % ldic[ptyp]["bcp_e_points"]
else:
txt = "%s Points per End" % ldic[ptyp]["bcp_e_points"]
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
pts += (ldic[ptyp]["bcp_e_points"] * ldic["bct_ends"])
if ldic[ptyp]["bcp_s_points"]:
if ldic[ptyp]["bcp_s_points"] == 1:
txt = "%s Point per Skin" % ldic[ptyp]["bcp_s_points"]
else:
txt = "%s Points per Skin" % ldic[ptyp]["bcp_s_points"]
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
pts += (ldic[ptyp]["bcp_s_points"] *
int(ldic["bct_ends"] / ldic[ptyp]["bcp_sends"]))
if ldic[ptyp]["bcp_g_points"]:
if ldic[ptyp]["bcp_g_points"] == 1:
txt = "%s Point per Game" % ldic[ptyp]["bcp_g_points"]
else:
txt = "%s Points per Game" % ldic[ptyp]["bcp_g_points"]
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
pts += ldic[ptyp]["bcp_g_points"]
if ldic[ptyp]["bcp_bonus"] == "Y":
txt = "1 Bonus Point will be Awarded as Follows:"
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
txt = "Winning by %s or More Shots or" % \
(ldic[ptyp]["bcp_win_by"] + 1)
self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M")
txt = "Losing by %s or Less Shots" % \
(ldic[ptyp]["bcp_lose_by"] - 1)
self.fpdf.drawText(txt=txt, x=x2, h=h, ctyp="M")
pts += 1
if pts:
if pts == 1:
txt = "Point"
else:
txt = "Points"
txt = "Therefore a Maximum of %s %s per Game." % (pts, txt)
self.fpdf.drawText(txt=txt, x=x1, h=h, ctyp="M")
if self.notes:
txt = "Notes"
self.fpdf.drawText(h=h)
self.fpdf.drawText(txt=txt, h=h)
self.fpdf.underLine(h=h, txt=txt)
self.fpdf.drawText(txt=self.notes, h=h, ctyp="M")
self.sql.delRec("bwlnot", where=[("bcn_cono", "=",
self.opts["conum"]), ("bcn_ccod", "=", self.ccod)])
self.sql.insRec("bwlnot", data=[self.opts["conum"],
self.ccod, self.notes])
self.opts["mf"].dbm.commitDbase()
def pageHeading(self):
if self.card:
self.fpdf.set_fill_color(220)
self.fpdf.set_font("Arial","B",12)
self.fpdf.drawText("Competiton Format and Points", h=6, align="C",
border="TLRB", fill=True)
self.fpdf.set_line_width(1)
self.fpdf.rect(self.fpdf.l_margin, self.fpdf.t_margin, 100, 140)
self.fpdf.set_line_width(0)
self.fpdf.ln(4)
return
if self.image:
if self.card:
self.fpdf.image(self.image, x=10, y=10, w=7, h=5)
else:
self.fpdf.image(self.image, x=10, y=10, w=15, h=11)
self.fpdf.set_font("Arial","B",15)
self.fpdf.cell(20)
self.fpdf.cell(0,10,"Format Sheet for the %s" % self.cnam,1,0,"C")
self.fpdf.ln(20)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class gl6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
sql = Sql(self.opts["mf"].dbm, "ftable", prog=self.__class__.__name__)
if sql.error:
return
self.unique = ("genbal", "genbud", "genmst", "genrcc", "genrct")
self.tables = [("assgrp", "asg_cono", "asg_assacc"),
("assgrp", "asg_cono", "asg_depacc"),
("assgrp", "asg_cono", "asg_expacc"),
("bkmunm", "bum_cono", "bum_slsa"),
("crsctl", "ctc_cono", "ctc_bankac"),
("crsmst", "crm_cono", "crm_glac"),
("cshana", "can_cono", "can_code"),
("ctlctl", "ctl_cono", "ctl_conacc"),
("ctldep", "dep_dr_coy", "dep_dr_sal"),
("ctldep", "dep_dr_coy", "dep_dr_com"),
("ctldep", "dep_cr_coy", "dep_cr_sal"),
("ctldep", "dep_cr_coy", "dep_cr_com"),
("ctlnot", "not_cono", "not_key"),
("ctlvtf", "vtt_cono", "vtt_acno", "vtt_styp"),
("drsrcm", "dcm_cono", "dcm_glac"),
("genbal", "glo_cono", "glo_acno"),
("genbud", "glb_cono", "glb_acno"),
("genint", "cti_cono", "cti_acno"),
("genjlt", "gjt_cono", "gjt_acno"),
("genmst", "glm_cono", "glm_acno"),
("genrcc", "grc_cono", "grc_acno"),
("genrcc", "grc_acoy", "grc_aacc"),
("genrct", "grt_cono", "grt_acno"),
("genrpt", "glr_cono", "glr_from"),
("genrpt", "glr_cono", "glr_to"),
("gentrn", "glt_cono", "glt_acno"),
("memctc", "mcc_cono", "mcc_glac"),
("rcactl", "cte_cono", "cte_glbnk"),
("rtlprm", "rtp_cono", "rtp_rtlacc"),
("rtlprm", "rtp_cono", "rtp_incacc"),
("strgrp", "gpm_cono", "gpm_sales"),
("strgrp", "gpm_cono", "gpm_costs"),
("strmf1", "st1_cono", "st1_sls"),
("strmf1", "st1_cono", "st1_cos"),
("wagedc", "ced_eglco", "ced_eglno"),
("wagedc", "ced_rglco", "ced_rglno"),
("wagtf2", "wt2_gl_econo", "wt2_gl_eacno"),
("wagtf2", "wt2_gl_rcono", "wt2_gl_racno")]
tabs = []
tables = copyList(self.tables)
for tab in tables:
chk = sql.getRec("ftable", where=[("ft_tabl", "=", tab[0])])
if not chk:
self.tables.remove(tab)
continue
if tab[0] not in tabs:
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.doimp = False
return True
def mainProcess(self):
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "IUI", 7, "Old Number",
"Old Account Number", "", "Y", self.doOldAcc, glm, None,
("notzero", )), (("T", 0, 0, 0), "ONA", 30, ""),
(("T", 0, 1,
0), "IUI", 7, "New Number", "New Account Number", "",
"Y", self.doNewAcc, None, None, ("notzero", )))
but = (
("Import File",None,self.doImport,0,("T",0,1),("T",0,2),
"Import a CSV or XLS File with the Correct Format i.e. "\
"Old Code, New Code. If the New Code is left Blank the "\
"Old Code will be Retained."),)
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doImport(self):
self.df.closeProcess()
self.doimp = True
impcol = []
pos = 0
for num, fld in enumerate(self.fld):
if num == 1:
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)
chgs = fi.impdat
if chgs:
chgs.sort()
self.doChange(chgs)
self.opts["mf"].closeLoop()
def doOldAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number, Does Not exist"
self.oldacc = w
self.df.loadEntry(frt, pag, p + 1, data=acc[3])
def doNewAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if acc:
return "Invalid Account Number, Already Exists"
self.newacc = w
def doEnd(self):
self.doChange([[self.oldacc, self.newacc]])
self.df.focusField("T", 0, 1)
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
class dr1020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.buildScreen()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(
self.opts["mf"].dbm,
["ctlvmf", "drschn", "drsmst", "drsrcm", "drsrct", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.chains = drsctl["ctd_chain"]
self.glac = 0
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
return True
def buildScreen(self):
num_sel = {
"stype":
"R",
"tables": ("drsrcm", ),
"cols":
(("dcm_num", "", 0, "Number"), ("dcm_desc", "", 0, "Description",
"Y"), ("dcm_freq", "", 0, "F")),
"where": [("dcm_cono", "=", self.opts["conum"])]
}
seq_sel = {
"stype":
"R",
"tables": ("drsrct", ),
"cols":
(("dct_seq", "", 0, "Seq"), ("dct_chain", "", 0, "Chn"),
("dct_acno", "", 0,
"Acc-Num"), ("dct_detail", "", 0,
"Charge Details"), ("dct_amnt", "", 0, "Amount"),
("dct_start", "", 0, "Start"), ("dct_end", "", 0, "End")),
"where": [("dct_cono", "=", self.opts["conum"])],
"whera": (("T", "dct_num", 0), )
}
chn_sel = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm_sel = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y")),
"where": [("drm_cono", "=", self.opts["conum"]),
("drm_stat", "<>", "X")],
"whera": (("C", "drm_chain", 1, 0), )
}
glm_sel = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vat_sel = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "Y"))
fld = [
(("T",0,0,0),"IUI",3, "Number","Charge Number",
"","Y",self.doNum,num_sel,None,None),
(("T",0,1,0),"INA",30,"Description","",
"","N",self.doDesc,None,self.doDelNum,("notblank",)),
(("T",0,2,0),("IRB",r1s),0, "Frequency","",
"M","N",self.doFreq,None,None,None),
(("T",0,3,0),"IUI",2, "Day of the Month","Day of the Month",
"","N",self.doDay,num_sel,None,("between",1,30),None,
"Enter the day of the month when the entry must be raised. "\
"Use 30 to denote the last day of the month.")]
if self.glint == "Y":
fld.append(
(("T", 0, 4, 0), "IUI", 7, "Charge Account", "G/L Account", "",
"N", self.doGlAc, glm_sel, None, ("notzero", )))
fld.append((("T", 0, 4, 0), "ONA", 30, ""))
nxt = 5
else:
nxt = 4
fld.append(
(("T", 0, nxt, 0), "IUA", 1, "VAT Code", "V.A.T. Code", self.taxdf,
"N", self.doVat, vat_sel, None, ("notblank", )))
fld.append((("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i",
"N", self.doSeq, seq_sel, None, ("notzero", )))
if self.chains == "Y":
fld.append((("C", 0, 0, 0), "IUI", 3, "Chn", "Chain Store", "",
"N", self.doChn, chn_sel, self.doDelSeq, ("efld", )))
else:
self.chn = 0
fld.append((("C", 0, 0, 0), "OUI", 3, "Chn"))
fld.append((("C", 0, 0, 1), "INA", 7, "Acc-Num", "Account Number", "",
"N", self.doAcc, drm_sel, self.doDelSeq, ("efld", )))
fld.extend(
((("C", 0, 0, 2), "ONA", 30, "Name", "", "", "N", None, None, None,
None), (("C", 0, 0, 3), "ITX", 30, "Charge-Details",
"Charge Details", "", "N", self.doDetail, None, None,
None), (("C", 0, 0, 4), "ISD", 13.2, "Excl-Value",
"Period Exclusive Value", "", "N", self.doValue,
None, None, ("efld", )),
(("C", 0, 0, 5), "ID2", 7, "Start", "Starting Period", "", "N",
self.doStart, None, None, ("efld", )),
(("C", 0, 0, 6), "ID2", 7, "End", "Ending Period", "", "N",
self.doEnd, None, None, ("efld", ))))
but = (("All Entries", seq_sel, None, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0,
2))), ("Re-Sequence", None, self.doReSeq, 0,
("C", 0, 1), (("T", 0, 1), ("C", 0, 2))),
("Abort Changes", None, self.doAbort, 0, ("C", 0, 1), ("T", 0,
1)))
tnd = ((self.endTop, "y"), )
txt = (self.exitTop, )
cnd = ((self.endCol, "y"), )
cxt = (self.exitCol, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doNum(self, frt, pag, r, c, p, i, w):
if not w:
num = self.sql.getRec("drsrcm",
cols=["max(dcm_num)"],
where=[("dcm_cono", "=", self.opts["conum"])
],
limit=1)
if not num or not num[0]:
self.num = 1
else:
self.num = num[0] + 1
self.df.loadEntry(frt, pag, p, data=self.num)
else:
self.num = w
self.rcm = self.sql.getRec("drsrcm",
where=[("dcm_cono", "=",
self.opts["conum"]),
("dcm_num", "=", self.num)],
limit=1)
if not self.rcm:
if self.num == 999:
return "Invalid Number (999), Reserved for Sales Invoices"
self.new_num = "y"
self.nxt = 1
else:
d = self.sql.drsrcm_col
self.new_num = "n"
self.df.loadEntry(frt,
pag,
p + 1,
data=self.rcm[d.index("dcm_desc")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.rcm[d.index("dcm_freq")])
self.df.loadEntry(frt,
pag,
p + 3,
data=self.rcm[d.index("dcm_day")])
if self.glint == "Y":
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rcm[d.index("dcm_glac")])
self.df.loadEntry(frt, pag, p + 5, data=self.getAccount())
self.df.loadEntry(frt,
pag,
p + 6,
data=self.rcm[d.index("dcm_vat")])
else:
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rcm[d.index("dcm_vat")])
for x in range(2):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
if self.num == 999:
return "nd"
def getAccount(self):
return self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=",
self.df.t_work[0][0][4])],
limit=1)[0]
def doDelNum(self):
if self.new_num == "y":
return
self.sql.delRec("drsrcm",
where=[("dcm_cono", "=", self.opts["conum"]),
("dcm_num", "=", self.num)])
try:
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.acc)])
except:
pass
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
if self.glint == "N":
self.vcod = self.taxdf
def doDay(self, frt, pag, r, c, p, i, w):
self.day = w
def doGlAc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.glac = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if not chk[2]:
self.vcod = self.taxdf
else:
self.vcod = chk[2]
self.df.topf[0][4][8] = self.vcod
def doVat(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not acc:
return "Invalid VAT Code"
self.vcod = w
def endTop(self):
data = [
self.opts["conum"], self.num, self.desc, self.freq, self.day,
self.vcod, self.glac, 0
]
if self.new_num == "y":
self.sql.insRec("drsrcm", data=data)
self.df.loadEntry("C", 0, 0, data=1)
self.df.focusField("C", 0, self.nxt)
else:
if data != self.rcm[:len(data)]:
col = self.sql.drsrcm_col
data.append(self.rcm[col.index("dcm_xflag")])
self.sql.updRec("drsrcm",
data=data,
where=[("dcm_cono", "=", self.opts["conum"]),
("dcm_num", "=", self.num)])
self.doReload()
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
self.rct = self.sql.getRec("drsrct",
where=[("dct_cono", "=",
self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)],
limit=1)
if not self.rct:
self.new_seq = "y"
else:
self.new_seq = "n"
col = self.sql.drsrct_col
self.df.loadEntry(frt,
pag,
p + 1,
data=self.rct[col.index("dct_chain")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.rct[col.index("dct_acno")])
acc = self.sql.getRec("drsmst",
cols=["drm_name"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=",
self.rct[col.index("dct_chain")]),
("drm_acno", "=",
self.rct[col.index("dct_acno")])],
limit=1)
self.df.loadEntry(frt, pag, p + 3, data=acc[0])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rct[col.index("dct_detail")])
self.df.loadEntry(frt,
pag,
p + 5,
data=self.rct[col.index("dct_amnt")])
self.df.loadEntry(frt,
pag,
p + 6,
data=self.rct[col.index("dct_start")])
self.df.loadEntry(frt,
pag,
p + 7,
data=self.rct[col.index("dct_end")])
def doDelSeq(self):
if self.new_seq == "y":
return
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)])
self.doReload()
def doChn(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chn = w
def doAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chn),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.acc = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doDetail(self, frt, pag, r, c, p, i, w):
self.det = w
def doValue(self, frt, pag, r, c, p, i, w):
self.val = w
def doStart(self, frt, pag, r, c, p, i, w):
self.start = w
def doEnd(self, frt, pag, r, c, p, i, w):
if w < self.start:
return "Invalid End Date, Before Start"
self.end = w
def endCol(self):
data = [
self.opts["conum"], self.num, self.seq, self.chn, self.acc,
self.det, self.val, self.start, self.end
]
if self.new_seq == "y":
self.sql.insRec("drsrct", data=data)
elif data != self.rct[:len(data)]:
col = self.sql.drsrct_col
data.append(self.rct[col.index("dct_xflag")])
self.sql.updRec("drsrct",
data=data,
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)])
self.doReload()
def exitCol(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doReSeq(self):
recs = self.sql.getRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num)],
order="dct_chain, dct_acno")
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num)])
seq = 0
for rec in recs:
seq += 1
rec[2] = seq
self.sql.insRec("drsrct", data=rec)
self.doReload()
def doAbort(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doReload(self):
self.df.clearFrame("C", 0)
last = (self.df.rows[0] - 1) * 8
trn = self.sql.getRec(tables=["drsrct", "drsmst"],
cols=[
"dct_seq", "dct_chain", "dct_acno",
"drm_name", "dct_detail", "dct_amnt",
"dct_start", "dct_end"
],
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("drm_cono=dct_cono", ),
("drm_chain=dct_chain", ),
("drm_acno=dct_acno", )],
order="dct_seq")
if trn:
for s, t in enumerate(trn):
if s >= self.df.rows[0]:
self.df.scrollScreen(0)
p = last
else:
p = s * 8
self.df.loadEntry("C", 0, p, data=t[0])
self.df.loadEntry("C", 0, p + 1, data=t[1])
self.df.loadEntry("C", 0, p + 2, data=t[2])
self.df.loadEntry("C", 0, p + 3, data=t[3])
self.df.loadEntry("C", 0, p + 4, data=t[4])
self.df.loadEntry("C", 0, p + 5, data=t[5])
self.df.loadEntry("C", 0, p + 6, data=t[6])
self.df.loadEntry("C", 0, p + 7, data=t[7])
if p == last:
self.df.scrollScreen(0)
self.nxt = last + 1
else:
self.nxt = p + 9
else:
self.nxt = 1
self.df.focusField("C", 0, self.nxt)
class dr6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.tables = (("ctlnot", "not_key"), ("drsdel", "del_code"),
("ctlvtf", "vtt_cono", "vtt_acno", "vtt_styp"),
("drsmst", "drm_cono", "drm_chain", "drm_acno",
"drm_delivery"), ("drsrct", "dct_cono", "dct_chain",
"dct_acno"),
("drstrn", "drt_cono", "drt_chain", "drt_acno"),
("drsage", "dra_cono", "dra_chain",
"dra_acno"), ("genrcc", "grc_cono", "grc_achn",
"grc_adrs"), ("slsiv1", "si1_cono",
"si1_chain", "si1_acno"),
("strmf1", "st1_cono", "st1_chn_excl",
"st1_acc_excl"), ("strtrn", "stt_cono", "stt_chain",
"stt_acno", "stt_styp"))
tabs = ["drschn"]
for tab in self.tables:
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.chains = drsctl["ctd_chain"]
self.autogen = "N"
return True
def mainProcess(self):
chn = {
"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_chain", "", 0, "Chn"),
("drm_acno", "", 0, "Acc-Num"),
("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1")],
"where": [("drm_cono", "=", self.opts["conum"])]
}
if self.chains == "Y":
drm["whera"] = [["T", "drm_chain", 0]]
drm["index"] = 1
else:
del drm["cols"][0]
fld = [[["T", 0, 0, 0], "I@drm_chain", 0, "Old Chain",
"Old Chain Number", "", "Y", self.doOldChn, chn, None,
("efld", )],
[["T", 0, 0, 12], "IRW", 7, "Old Account", "Old Account Number",
"", "Y", self.doOldAcc, drm, None, ("notblank", )],
[["T", 0, 0, 30], "O@drm_name", 0, ""],
[["T", 0, 1, 0], "I@drm_chain", 0, "New Chain",
"New Chain Number", "", "Y", self.doNewChn, chn, None,
("efld", )],
[["T", 0, 1, 12], "I@drm_acno", 0, "New Account",
"New Account Number", "", "Y", self.doNewAcc, None, None,
("notblank", )]]
if self.chains == "N":
self.oldchn = self.newchn = 0
del fld[0]
del fld[2]
fld[0][0][3] = 0
fld[1][0][3] = 18
fld[2][0][3] = 0
tnd = ((self.doProcess, "y"), )
txt = (self.doExit, )
but = [("Generate", None, self.doGenerate, 0, ("T", 0, 1), ("T", 0, 2),
"Generate New Account Numbers Based on Names of Accounts")]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
butt=but)
def doOldChn(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Number, Does Not exist"
self.oldchn = w
def doOldAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.oldchn),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number, Does Not exist"
self.oldacc = w
self.oldnot = "%03i%s" % (self.oldchn, w)
self.olddel = acc[self.sql.drsmst_col.index("drm_delivery")]
self.df.loadEntry(frt, pag, p + 1, data=acc[3])
def doNewChn(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Number, Does Not exist"
self.newchn = w
def doNewAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.newchn),
("drm_acno", "=", w)],
limit=1)
if acc:
return "Invalid Account Number, Already Exists"
self.newacc = w
self.newnot = "%03i%s" % (self.newchn, w)
if self.olddel == self.oldacc:
self.newdel = self.newacc
else:
self.newdel = self.olddel
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 doProcess(self, focus=True):
for tab in self.tables:
if tab[0] == "ctlnot":
whr = [("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "DRS"), (tab[1], "=", self.oldnot)]
dat = [self.newnot]
col = [tab[1]]
elif tab[0] == "drsdel":
if self.newdel == self.olddel:
continue
whr = [(tab[1], "=", self.olddel)]
dat = [self.newdel]
col = [tab[1]]
elif tab[0] == "ctlvtf":
whr = [(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldacc), (tab[3], "=", "D")]
dat = [self.newacc]
col = [tab[2]]
elif tab[0] == "drsmst":
whr = [(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldchn), (tab[3], "=", self.oldacc)]
dat = [self.newchn, self.newacc, self.newdel]
col = [tab[2], tab[3], tab[4]]
elif tab[0] == "strtrn":
whr = [(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldchn), (tab[3], "=", self.oldacc),
(tab[4], "=", "INV")]
dat = [self.newchn, self.newacc]
col = [tab[2], tab[3]]
else:
whr = [(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldchn), (tab[3], "=", self.oldacc)]
dat = [self.newchn, self.newacc]
col = [tab[2], tab[3]]
self.sql.updRec(tab[0], where=whr, data=dat, cols=col)
if focus:
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
class rcm010(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, [
"ctlvrf", "ctlvtf", "gentrn", "rcactl", "rcaprm", "rcaowm",
"rcaowt", "rcatnm", "rcacon", "rcatnt"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rcactl = gc.getCtl("rcactl", self.opts["conum"])
if not rcactl:
return
self.lme = rcactl["cte_lme"]
self.glint = rcactl["cte_glint"]
if self.glint == "Y":
self.glbnk = rcactl["cte_glbnk"]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["rca_com", "rca_own", "rca_tnt", "vat_ctl"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.rcacom = ctlctl["rca_com"]
self.rcaown = ctlctl["rca_own"]
self.rcatnt = ctlctl["rca_tnt"]
self.rcatrx = ctlctl["rca_trx"]
self.convat = ctlctl["vat_ctl"]
# Check for Company Record
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
# Set Company VAT Default
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.tme = mthendDate(self.sysdtw)
return True
def mainProcess(self):
fld = ((("T", 0, 0, 0), "Od1", 10, "Last Month End Date"),
(("T", 0, 1, 0), "ID1", 10, "This Month End Date", "", self.tme,
"N", self.doTme, None, None, ("efld", )))
tnd = ((self.doEnd, "Y"), )
txt = (self.closeProcess, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
focus=False)
self.df.loadEntry("T", 0, 0, data=self.lme)
self.df.focusField("T", 0, 2)
def doTme(self, frt, pag, r, c, p, i, w):
if w <= self.lme:
return "Invalid Month-End Date"
self.tme = w
self.curdt = int(w / 100)
yy = int(self.curdt / 100)
mm = (self.curdt % 100) + 1
while mm > 12:
yy += 1
mm -= 12
self.nxtdt = (yy * 10000) + (mm * 100) + 1
self.nxtcd = int(self.nxtdt / 100)
self.batch = "R%06s" % self.nxtcd
chk = self.sql.getRec("rcatnt",
cols=["count(*)"],
where=[("rtu_cono", "=", self.opts["conum"]),
("rtu_type", "=", 1),
("rtu_batch", "=", self.batch),
("rtu_trdt", "=", self.nxtdt),
("rtu_curdt", "=", self.nxtcd)],
limit=1)
if chk[0]:
return "Month-End Already Executed"
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 doExpiredContract(self):
tit = ("Renew Rental Contract", )
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "A"))
chdt = self.strt.work
while True:
chdt = projectDate(chdt, self.mths, typ="months")
exdt = mthendDate(projectDate(chdt, self.mths - 1, typ="months"))
if int(exdt / 100) > self.curdt:
break
self.fld = ((("T", 0, 0, 0), "OUA", 7,
"Owner Code"), (("T", 0, 1, 0), "OUA", 7,
"Premises Code"), (("T", 0, 2, 0), "ONA",
7, "Account Code"),
(("T", 0, 3, 0), "ONA", 30, "Tenant Name"),
(("T", 0, 4, 0), ("IRB", r1s), 0, "Payment Frequency", "",
self.freq, "N", None, None, None,
None), (("T", 0, 5, 0), "ID1", 10, "Start Date", "", chdt,
"N", None, None, None, ("efld", )),
(("T", 0, 6, 0), "IUI", 3, "Number of Periods", "",
self.pers, "N", None, None, None, ("notzero", )),
(("T", 0, 7, 0), "IUD", 12.2, "Rental Amount", "",
self.amnt, "N", None, None, None, ("notzero", )),
(("T", 0, 8, 0), "IUD", 12.2, "Deposit Amount", "",
self.depo, "N", None, None, None, ("efld", )),
(("T", 0, 9, 0), "IUD", 12.2, "Basic Water Amount", "", "",
"N", None, None, None,
("efld", )), (("T", 0, 10, 0), "IUI", 1, "Type", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, 11, 0), "IUD", 12.2, "Basic Exlectricity Amount",
"", "", "N", None, None, None,
("efld", )), (("T", 0, 12, 0), "IUI", 1, "Type", "", "",
"N", None, None, None, ("efld", )))
tnd = ((self.doExpireEnd, "y"), )
txt = (None, )
self.na = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=self.fld,
tend=tnd,
txit=txt,
focus=False)
self.doLoadFocus(chdt)
self.na.mstFrame.wait_window()
def doExpireEnd(self):
dat = self.con[:4]
dat.append(self.con[4] + 1)
for x in range(4, len(self.na.t_work[0][0])):
dat.append(self.na.t_work[0][0][x])
dat.append("C")
self.sql.insRec("rcacon", data=dat)
self.con[:9] = dat[:9]
self.na.closeProcess()
def doRaiseRental(self, num):
ref = CCD((num + 1), "Na", 9).work
amt = CCD(self.con[8], "UD", 12.2).work
vrte = getVatRate(self.sql, self.opts["conum"], self.vatdf, self.nxtdt)
if vrte is None:
vrte = 0.0
vat = CCD(round((amt * vrte / 100), 2), "SD", 11.2).work
tot = float(ASD(amt) + ASD(vat))
# Tenant Transaction
data = self.con[:5]
data.extend([
1, ref, self.batch, self.nxtdt, 1, tot, vat, self.nxtcd,
"Rental Raised", self.vatdf, "", self.opts["capnm"], self.sysdtw, 0
])
self.sql.insRec("rcatnt", data=data)
if self.glint == "Y":
# Update Tenant Control
gld = "%7s Rental Raised" % self.con[3]
data = [
self.opts["conum"], self.rcatnt, self.nxtcd, self.nxtdt, 4,
ref, self.batch, tot, 0, gld, "", "", 0, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
rta = float(ASD(0) - ASD(tot))
rtv = float(ASD(0) - ASD(vat))
# Owner Transaction
data = self.con[:2]
data.extend([
1, ref, self.batch, self.nxtdt, rta, rtv, self.nxtcd,
"Rental on %s Premises" % self.con[2], self.vatdf, "",
self.opts["capnm"], self.sysdtw, 0
])
self.sql.insRec("rcaowt", data=data)
if self.glint == "Y":
# Update Owner Control
gld = "%7s Rental Raised" % self.con[1]
data = [
self.opts["conum"], self.rcaown, self.nxtcd, self.nxtdt, 4,
ref, self.batch, rta, 0, gld, "", "", 0, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.prm[0]:
cma = round((tot * self.prm[0] / 100.0), 2)
vrte = getVatRate(self.sql, self.opts["conum"], self.taxdf,
self.nxtdt)
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.prm[0], "%")
# Raise Commission
data = self.con[:2]
data.extend([
4, ref, self.batch, self.nxtdt, cmt, cmv, self.nxtcd, des,
self.taxdf, "", self.opts["capnm"], self.sysdtw, 0
])
self.sql.insRec("rcaowt", data=data)
if self.glint == "Y":
# Update Owner Control
gld = "%7s Commission Raised" % self.con[1]
data = [
self.opts["conum"], self.rcaown, self.nxtcd, self.nxtdt, 4,
ref, self.batch, 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, self.nxtcd, self.nxtdt, 4,
ref, self.batch, 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", self.nxtcd, "R", 1,
self.batch, ref, self.nxtdt, self.con[3], self.con[14],
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, self.nxtcd,
self.nxtdt, 4, ref, self.batch, tax, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
def doRaiseExtra(self, num):
for x in ("W", "E"):
ref = CCD((num + 1), "Na", 9).work
num += 1
if x == "W":
if not self.con[10]:
continue
amt = self.con[10]
typ = self.con[11]
des = "Basic Water Charge"
elif x == "E":
if not self.con[12]:
continue
amt = self.con[12]
typ = self.con[13]
des = "Basic Electricity Charge"
# Tenant Transaction
data = self.con[:5]
data.extend([
1, ref, self.batch, self.nxtdt, 4, amt, 0, self.nxtcd, des, "",
"", self.opts["capnm"], self.sysdtw, 0
])
self.sql.insRec("rcatnt", data=data)
if self.glint == "Y":
gld = "%7s %7s %7s" % tuple(self.con[1:4])
data = [
self.opts["conum"], self.rcatnt, self.nxtcd, self.nxtdt, 4,
num, self.batch, amt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
amt = float(ASD(0) - ASD(amt))
if typ == 4:
# Services - Owner Recovery
des = "Services Recovery on %s" % self.con[2]
data = [
self.opts["conum"], self.con[1], 4, num, self.batch,
self.nxtdt, amt, 0, self.nxtcd, des, "", "",
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.con[2]
data = [
self.opts["conum"], self.rcaown, self.nxtcd,
self.nxtdt, 4, num, self.batch, amt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
elif self.glint == "Y":
# Non Recovery - Update Rental Control
data = [
self.opts["conum"], self.rcatrx, self.nxtcd, self.nxtdt, 4,
num, self.batch, amt, 0, gld, "", "", 0,
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
def doLoadFocus(self, chdt=None):
for num, fld in enumerate(self.con[1:14]):
if chdt and num == 5:
self.na.loadEntry("T", 0, num, data=chdt)
else:
self.na.loadEntry("T", 0, num, data=fld)
self.na.focusField("T", 0, 4)
def closeProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
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 rtm010(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, ["ctlbat", "ctlvrf", "ctlvtf",
"gentrn", "rtlctl", "rtlprm", "rtlmst", "rtlcon", "rtltrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.glint = rtlctl["ctr_glint"]
self.lme = rtlctl["ctr_lme"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if 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.tme = mthendDate(self.sysdtw)
return True
def mainProcess(self):
fld = (
(("T",0,0,0),"Od1",10,"Last Month End Date"),
(("T",0,1,0),"ID1",10,"This Month End Date","",
self.tme,"N",self.doTme,None,None,("efld",)))
tnd = ((self.doEnd,"Y"), )
txt = (self.closeProcess,)
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt, focus=False)
self.df.loadEntry("T", 0, 0, data=self.lme)
self.df.focusField("T", 0, 2)
def doTme(self, frt, pag, r, c, p, i, w):
if w <= self.lme:
return "Invalid Month-End Date"
self.tme = w
self.curdt = int(w / 100)
yy = int(self.curdt / 100)
mm = (self.curdt % 100) + 1
while mm > 12:
yy += 1
mm -= 12
self.nxtdt = (yy * 10000) + (mm * 100) + 1
self.nxtcd = int(self.nxtdt / 100)
self.batch = "R%06s" % self.nxtcd
chk = self.sql.getRec("rtltrn", cols=["count(*)"],
where=[("rtt_cono", "=", self.opts["conum"]), ("rtt_type", "=", 1),
("rtt_batch", "=", self.batch), ("rtt_trdt", "=", self.nxtdt),
("rtt_curdt", "=", self.nxtcd)], limit=1)
if chk[0]:
return "Month-End Already Executed"
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 updateTables(self):
self.df.closeProcess()
whr = [
("rtc_cono", "=", self.opts["conum"]),
("rtm_cono=rtc_cono",),
("rtm_code=rtc_code",),
("rtm_acno=rtc_acno",),
("rtc_start", "<=", self.nxtdt),
("rtc_status", "<>", "X")]
recs = self.sql.getRec(tables=["rtlcon", "rtlmst"], cols=["rtc_cono",
"rtc_code", "rtc_acno", "rtc_cnum", "rtc_payind", "rtc_start",
"rtc_period", "rtc_rtlamt", "rtm_name", "rtm_vatind"], where=whr)
if recs:
for num, self.rec in enumerate(recs):
self.freq = self.rec[4]
strt = self.rec[5]
self.pers = self.rec[6]
self.amnt = self.rec[7]
if self.freq == "M":
mths = 1 * self.pers
elif self.freq == "3":
mths = 3 * self.pers
elif self.freq == "6":
mths = 6 * self.pers
else:
mths = 12 * self.pers
yy = int(strt / 10000)
mm = int((strt % 10000) / 100) + mths - 1
while mm > 12:
yy += 1
mm -= 12
dd = strt % 100
self.exdt = (yy * 10000) + (mm * 100) + dd
if int(self.exdt / 100) <= self.curdt:
self.sql.updRec("rtlcon", cols=["rtc_status"], data=["X"],
where=[("rtc_cono", "=", self.rec[0]), ("rtc_code",
"=", self.rec[1]), ("rtc_acno", "=", self.rec[2]),
("rtc_cnum", "=", self.rec[3])])
ok = askQuestion(self.opts["mf"].body, "Expired Contract",
"This contract has Expired, would you like to "\
"Renew it?\n\nPremises: %s\nAccount: %s\nName: %s" % \
(self.rec[1], self.rec[2], self.rec[8]))
if ok == "no":
continue
self.doRenewContract()
self.doRaiseRental(num)
self.sql.updRec("rtlctl", cols=["ctr_lme"], data=[self.tme],
where=[("ctr_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 doRenewContract(self):
tit = ("Renew Rental Contract", )
r1s = (
("Monthly","M"),
("Quarterly","3"),
("Bi-Annually", "6"),
("Annually","A"))
self.fld = (
(("T",0,0,0),"OUA",3,"Premises Code"),
(("T",0,1,0),"ONA",7,"Account Code"),
(("T",0,2,0),"ONA",30,"Tenant Name"),
(("T",0,3,0),("IRB",r1s),0,"Payment Frequency","",
self.freq,"N",None,None,None,None),
(("T",0,4,0),"ID1",10,"Start Date","",
self.exdt,"N",None,None,None,("efld",)),
(("T",0,5,0),"IUI",3,"Number of Periods","",
self.pers,"N",None,None,None,("notzero",)),
(("T",0,6,0),"IUD",12.2,"Rental Amount","",
self.amnt,"N",None,None,None,("notzero",)))
tnd = ((self.doRenewEnd,"y"), )
txt = (self.doLoadFocus, )
self.na = TartanDialog(self.opts["mf"], tops=True, title=tit,
eflds=self.fld, tend=tnd, txit=txt, focus=False)
self.doLoadFocus()
self.na.mstFrame.wait_window()
def doRenewEnd(self):
dat = self.rec[:3]
dat.append(self.rec[3] + 1)
for x in range(3, len(self.na.t_work[0][0])):
dat.append(self.na.t_work[0][0][x])
dat.append("C")
self.sql.insRec("rtlcon", data=dat)
self.rec[:8] = dat[:8]
self.na.closeProcess()
def doRaiseRental(self, num):
ref = CCD((num + 1), "Na", 9).work
amt = CCD(self.rec[7], "UD", 12.2).work
vrte = getVatRate(self.sql, self.opts["conum"], self.rec[9], self.nxtdt)
if vrte is None:
vrte = 0.0
vat = CCD(round((amt * vrte / 100), 2), "SD", 11.2).work
tot = float(ASD(amt) + ASD(vat))
data = self.rec[:4]
data.extend([1, ref, self.batch, self.nxtdt, tot, vat, self.nxtcd,
"Rental Raised", self.rec[9], "", self.opts["capnm"], self.sysdtw,
0])
self.sql.insRec("rtltrn", data=data)
if self.rec[9]:
# VAT Transaction (ctlvtf)
val = float(ASD(0) - ASD(amt))
tax = float(ASD(0) - ASD(vat))
data = [self.opts["conum"], self.rec[9], "O", self.nxtcd, "R", 1,
self.batch, ref, self.nxtdt, self.rec[2], self.rec[8],
val, tax, 0, self.opts["capnm"], self.sysdtw, 0]
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
acc = self.sql.getRec("rtlprm", cols=["rtp_rtlacc",
"rtp_incacc"], where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", self.rec[1])], limit=1)
if not acc:
return
ref = "Month/End"
# General Ledger Rental Control
whr = [
("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", acc[0]),
("glt_batch", "=", self.batch),
("glt_curdt", "=", self.nxtcd),
("glt_trdt", "=", self.nxtdt),
("glt_type", "=", 1)]
glt = self.sql.getRec("gentrn", where=whr)
if glt and len(glt) == 1:
val = glt[0][self.sql.gentrn_col.index("glt_tramt")]
val = float(ASD(val) + ASD(tot))
tax = glt[0][self.sql.gentrn_col.index("glt_taxamt")]
tax = float(ASD(tax) + ASD(vat))
self.sql.updRec("gentrn", cols=["glt_tramt", "glt_taxamt"],
data=[val, tax], where=whr)
else:
data = [self.opts["conum"], acc[0], self.nxtcd, self.nxtdt, 1, ref,
self.batch, tot, vat, self.rec[8], self.rec[9], "", 0,
self.opts["capnm"], self.sysdtw, 0]
self.sql.insRec("gentrn", data=data)
amt = float(ASD(0) - ASD(amt))
vat = float(ASD(0) - ASD(vat))
# General Ledger Income Account
whr = [
("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", acc[1]),
("glt_batch", "=", self.batch),
("glt_curdt", "=", self.nxtcd),
("glt_trdt", "=", self.nxtdt),
("glt_type", "=", 1)]
glt = self.sql.getRec("gentrn", where=whr)
if glt and len(glt) == 1:
val = glt[0][self.sql.gentrn_col.index("glt_tramt")]
val = float(ASD(val) + ASD(amt))
self.sql.updRec("gentrn", cols=["glt_tramt"], data=[val], where=whr)
else:
data = [self.opts["conum"], acc[1], self.nxtcd, self.nxtdt, 1, ref,
self.batch, amt, 0.00, self.rec[8], "", "", 0,
self.opts["capnm"], self.sysdtw, 0]
self.sql.insRec("gentrn", data=data)
if not vat:
return
# General Ledger VAT Account
whr = [
("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.convat),
("glt_batch", "=", self.batch),
("glt_curdt", "=", self.nxtcd),
("glt_trdt", "=", self.nxtdt),
("glt_type", "=", 1)]
glt = self.sql.getRec("gentrn", where=whr)
if glt and len(glt) == 1:
val = glt[0][self.sql.gentrn_col.index("glt_tramt")]
val = float(ASD(val) + ASD(vat))
self.sql.updRec("gentrn", cols=["glt_tramt"], data=[val], where=whr)
elif vat:
data = [self.opts["conum"], self.convat, self.nxtcd, self.nxtdt, 1,
ref, self.batch, vat, 0.00, self.rec[8], "", "", 0,
self.opts["capnm"], self.sysdtw, 0]
self.sql.insRec("gentrn", data=data)
def doLoadFocus(self):
self.na.loadEntry("T", 0, 0, data=self.rec[1])
self.na.loadEntry("T", 0, 1, data=self.rec[2])
self.na.loadEntry("T", 0, 2, data=self.rec[8])
self.na.focusField("T", 0, 4)
def closeProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class cs1010(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"])
cshctl = gc.getCtl("cshctl", self.opts["conum"])
if not cshctl:
return
glint = cshctl["ccc_glint"]
if glint == "Y":
showError(self.opts["mf"].window, "Error",
"Cash Analysis is Integrated with General Ledger.")
return
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
self.mods = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
self.mods.append(ctlmst["ctm_modules"][x:x+2])
tabs = ["ctlvmf", "cshmst", "genbal", "genbud",
"genrpt", "gentrn", "chglog"]
if "CR" in self.mods:
tabs.append("crsctl")
if "DR" in self.mods:
tabs.append("drsctl")
if "ST" in self.mods:
tabs.extend(["strctl", "strloc"])
if "SI" in self.mods:
tabs.append("slsctl")
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("cshmst", cols=["count(*)"],
where=[("ccm_cono", "=", self.opts["conum"])], limit=1)
if chk[0]:
self.newgen = False
else:
self.newgen = True
if "args" in self.opts:
self.acno = None
return True
def mainProcess(self):
glm = {
"stype": "R",
"tables": ("cshmst",),
"cols": (
("ccm_acno", "", 0, "Acc-Num"),
("ccm_desc", "", 0, "Description", "Y")),
"where": [("ccm_cono", "=", self.opts["conum"])]}
vat = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "Acc-Num"),
("vtm_desc", "", 0, "Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
fld = (
(("T",0,0,0),"IUI",7,"Acc-Num","Account Number",
"","Y",self.doAccNum,glm,None,("notzero",)),
(("T",0,1,0),"INA",30,"Description","Account Description",
"","N",None,None,None,("notblank",)),
(("T",0,2,0),"IUA",1,"Tax Default","",
self.taxdf,"N",self.doVatCod,vat,None,("notblank",)))
but = (
("Accept",None,self.doAccept,0,("T",0,2),(("T",0,0),("T",0,1))),
("Cancel",None,self.doCancel,0,("T",0,2),(("T",0,0),("T",0,1))),
("Quit",None,self.doQuit,1,None,None))
tnd = ((self.doEnd,"y"), )
txt = (self.doQuit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, butt=but,
tend=tnd, txit=txt)
def doAccNum(self, frt, pag, r, c, p, i, w):
self.acno = w
self.old = self.sql.getRec("cshmst", where=[("ccm_cono", "=",
self.opts["conum"]), ("ccm_acno", "=", self.acno)], limit=1)
if not self.old:
self.new = True
elif "args" in self.opts:
showError(self.opts["mf"].body, "Error",
"Only a New Account is Allowed")
return "rf"
else:
self.new = False
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p+x, data=self.old[x+1])
def doTypCod(self, frt, pag, r, c, p, i, w):
if self.new:
if w == "P":
self.df.topf[pag][4][5] = self.taxdf
else:
self.df.topf[pag][4][5] = "N"
elif not self.df.topf[pag][4][5]:
self.df.topf[pag][4][5] = "N"
def doVatCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlvmf", cols=["vtm_desc"], where=[("vtm_cono",
"=", self.opts["conum"]), ("vtm_code", "=", w)], limit=1)
if not acc:
return "Invalid VAT Code"
def doDelete(self):
t = self.sql.getRec("cshana", cols=["count(*)"], where=[("can_cono",
"=", self.opts["conum"]), ("can_code", "=", self.acno)], limit=1)
if t[0]:
return "Transactions Exist, Not Deleted"
self.sql.delRec("cshmst", where=[("ccm_cono", "=", self.opts["conum"]),
("ccm_code", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["cshmst", "D", "%03i%07i" %
(self.opts["conum"], self.acno), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
if self.newgen:
self.df.butt[1][4] = None
self.df.butt[1][5] = None
data = [self.opts["conum"], self.acno,
self.df.t_work[0][0][1], self.df.t_work[0][0][2]]
if self.new:
self.sql.insRec("cshmst", data=data)
elif data != self.old[:len(data)]:
col = self.sql.cshmst_col
data.append(self.old[col.index("ccm_xflag")])
self.sql.updRec("cshmst", data=data, where=[("ccm_cono", "=",
self.opts["conum"]), ("ccm_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old):
if dat != data[num]:
self.sql.insRec("chglog", data=["cshmst", "U",
"%03i%07i" % (self.opts["conum"], self.acno),
col[num], dte, self.opts["capnm"], str(dat),
str(data[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
if "args" in self.opts:
self.doQuit()
else:
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col+1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.focusField("T", 0, 1)
def doIgExit(self):
self.igexit = True
self.ig.closeProcess()
def doQuit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class st1020(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", "strcst"],
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"]
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), (("C", 0, 0, 4), "IUD", 10.2, "Cost-Price",
"Standard Cost Price", "", "N", self.doCst,
None, None, ("notzero", )))
but = (
("Import File",None,self.doImport,0,("C",0,1),("C",0,2),
"Import Cost Prices from a CSV or XLS File "\
"having the following columns: Group, Code, "\
"Location, Cost-Price"),
("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
err = None
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)
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
if chk[self.sql.strmf1_col.index("st1_value_ind")] != "S":
err = "Line %s: Invalid Value-Ind %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.cst = line[3]
if not self.cst:
err = "Line %s: Invalid Cost %s" % ((num + 1), self.cst)
break
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", "st1_value_ind"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", w)],
limit=1)
if not chk:
return "Invalid Code"
if chk[1] != "S":
return "Invalid Value-Ind"
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.doLoadCost(p + 3)
return "sk1"
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.doLoadCost(p + 1)
def doLoadCost(self, pos):
chk = self.sql.getRec("strcst",
cols=["stc_cost"],
where=[("stc_cono", "=", self.opts["conum"]),
("stc_group", "=", self.grp),
("stc_code", "=", self.cod),
("stc_loc", "=", self.loc)],
limit=1)
if chk:
self.df.loadEntry("C", 0, pos, data=chk[0])
def doDelete(self):
self.sql.delRec("strcst",
where=[("stc_cono", "=", self.opts["conum"]),
("stc_group", "=", self.grp),
("stc_code", "=", self.cod),
("stc_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.clearLine(0, focus=True)
def doCst(self, frt, pag, r, c, p, i, w):
self.cst = w
def doEnd(self, det=False):
self.sql.delRec("strcst",
where=[("stc_cono", "=", self.opts["conum"]),
("stc_group", "=", self.grp),
("stc_code", "=", self.cod),
("stc_loc", "=", self.loc)])
self.sql.insRec(
"strcst",
data=[self.opts["conum"], self.grp, self.cod, self.loc, self.cst])
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 rcc210(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,
"ctlmes",
prog=self.__class__.__name__)
if self.sql.error:
return
self.system = "RCA"
return True
def mainProcess(self):
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Mss"), ("mss_detail", "NA", 50,
"Details")),
"where": [("mss_system", "=", self.system)],
"order":
"mss_message"
}
self.fld = ((("T", 0, 0, 0), "IUI", 3, "Message Number", "", "", "N",
self.doMes, mss, None, ("notzero", )),
(("T", 0, 1, 0), "ITv", (30, 6), "Details", "", "", "N",
self.doDetail, None, self.doDelete, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doMes(self, frt, pag, r, c, p, i, w):
self.message = w
self.old = self.sql.getRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)],
order="mss_message",
limit=1)
if not self.old:
self.new = "Y"
self.df.loadEntry(frt, pag, p + 1, data="")
else:
self.new = "N"
self.detail = self.old[self.sql.ctlmes_col.index("mss_detail")]
self.df.loadEntry(frt, pag, p + 1, data=self.detail)
def doDetail(self, frt, pag, r, c, p, i, w):
if len(w) > 150:
return "Invalid Message Length, Maximum 150 Characters"
def doDelete(self):
self.sql.delRec("ctlmes",
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
wid, self.detail = self.df.getEntry("T", 0, 1)
if len(self.detail) > 150:
self.df.focusField(
"T",
0,
2,
err="Invalid Message Length, Maximum 150 Characters")
else:
data = [self.system, self.message, self.detail]
if self.new == "Y":
self.sql.insRec("ctlmes", data=data)
elif data != self.old[:len(data)]:
col = self.sql.ctlmes_col
data.append(self.old[col.index("mss_xflag")])
self.sql.updRec("ctlmes",
data=data,
where=[("mss_system", "=", self.system),
("mss_message", "=", self.message)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bc3030(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, ["ctlmst", "bwlclb", "bwlflf",
"bwlflm", "bwlflo", "bwltab", "bwlfls", "bwlflt"],
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.fromad = bwlctl["ctb_emadd"]
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": ("bwlflm",),
"cols": (("bfm_date", "", 0, "Match-Date"),),
"where": [("bfm_cono", "=", self.opts["conum"])],
"whera": [("T", "bfm_fmat", 0, 0)],
"group": "bfm_date",
"order": "bfm_date"}
r1s = (("Fixture", "F"), ("Practice", "P"))
fld = (
(("T",0,0,0),"I@bfm_fmat",0,"","",
"","N",self.doFmat,fmt,None,("efld",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,1,0),("IRB",r1s),0,"Type","",
"F","N",self.doType,dte,None,None),
(("T",0,2,0),"I@bfm_date",0,"","",
"","N",self.doDate,dte,None,("efld",)))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt, view=("N","V"), mail=("Y","Y"))
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.rate = acc[self.sql.bwlflf_col.index("bff_rate")]
self.sets = acc[self.sql.bwlflf_col.index("bff_sets")]
self.df.loadEntry(frt, pag, p+1, data=desc)
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", "=", w)],
limit=1)
if acc[0]:
ok = askQuestion(self.opts["mf"].body, "Completed",
"Match Already Completed, Do You Want to Re-Print?")
if ok == "no":
return "rf"
self.reprint = True
else:
self.reprint = False
def doEnd(self):
self.df.closeProcess()
# Get data
cards = []
whr = [
("bft_cono", "=", self.opts["conum"]),
("bft_fmat", "=", self.fmat),
("bft_type", "=", self.ftyp),
("bft_date", "=", self.date)]
if self.forms == 4:
maxf = 8
else:
maxf = 3
whr.append(("bft_position", "=", 1))
col = ["bft_team", "bft_skip", "bft_player"]
whr.extend([
("bfs_cono=bft_cono",),
("bfs_fmat=bft_fmat",),
("bfs_code=bft_team",),
("bfs_league", "=", "M")])
recs = self.sql.getRec(tables=["bwlflt", "bwlfls"], cols=col,
where=whr, order="bft_team, bft_skip, bft_position asc")
for rec in recs:
match = self.sql.getRec("bwlflm", cols=["bfm_opps",
"bfm_venue"], where=[("bfm_cono", "=", self.opts["conum"]),
("bfm_fmat", "=", self.fmat), ("bfm_type", "=", self.ftyp),
("bfm_date", "=", self.date), ("bfm_team", "=", rec[0])],
limit=1)
team = self.sql.getRec("bwlfls", cols=["bfs_desc"],
where=[("bfs_cono", "=", self.opts["conum"]), ("bfs_fmat", "=",
self.fmat), ("bfs_code", "=", rec[0])], limit=1)
opp = self.sql.getRec(tables=["bwlflo", "bwlclb"],
cols=["bfo_desc", "bcc_name"], where=[("bfo_cono", "=",
self.opts["conum"]), ("bfo_fmat", "=", self.fmat), ("bfo_code",
"=", match[0]), ("bcc_code=bfo_club",)], limit=1)
skp = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", rec[1])], limit=1)
if self.forms == 4:
plr = self.sql.getRec(tables=["bwltab", "bwlflt"],
cols=["btb_surname", "btb_names", "bft_position"],
where=[("bft_cono", "=", self.opts["conum"]), ("bft_fmat",
"=", self.fmat), ("bft_date", "=", self.date),
("bft_skip", "=", rec[1]), ("bft_player", "=", rec[2]),
("btb_cono=bft_cono",), ("btb_tab=bft_player",)], limit=1)
else:
plr = self.sql.getRec(tables=["bwltab", "bwlflt"],
cols=["btb_surname", "btb_names"], where=[("bft_cono",
"=", self.opts["conum"]), ("bft_fmat", "=", self.fmat),
("bft_date", "=", self.date), ("bft_skip", "=", rec[1]),
("btb_cono=bft_cono",), ("btb_tab=bft_player",)],
order="bft_position")
if match[1] == "H":
ven = self.opts["conam"]
else:
ven = "%s" % opp[1]
if self.forms == 4:
cards.append([team[0], opp[0], ven, self.getName(skp[0],
skp[1]), self.getName(plr[0], plr[1]), plr[2]])
else:
card = [team[0], opp[0], ven, "%s, %s" % (skp[0], skp[1])]
for p in plr:
card.append(self.getName(p[0], p[1]))
cards.append(card)
while len(cards) % maxf:
if self.forms == 4:
cards.append(["", "", "", "", "", 0])
else:
cards.append(["", "", "", "", "", "", "", ""])
# Print
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, "assess_%s" % self.date, ext="pdf")
fpdf = MyFpdf(name=self.__class__.__name__, head=90)
cw = fpdf.get_string_width("X")
ld = 4.5
if self.forms == 4:
rr = {
"margins": ((2.5, 47.5), (1.5, 15.5)),
"repeat": (2, 4),
"rows": (
(2.5, 1.5, 47.5, 14.5),
(2.5, 8.5, (
(8, 1.5, .8, "Title", True),
(12, 1.5, .8, "Out of %s" % self.rate, True),
(27.5, 1.5, .8, "Remarks", True))),
(2.5, 10, (
(8, 1.5, .9, ("Skip", "Third", "Second", "Lead")),
(12, 1.5)), 4))}
else:
rr = {
"margins": ((2.5, 47.5), (1.5, 20.5)),
"repeat": (1, 3),
"rows": (
(2.5, 1.5, 95.1, 19.5),
(2.5, 11, (
(10, 2, .8, "Position"),
(20, 2, .8, "Name"),
(12, 2, .8, "Rating 1-%s" % self.rate),
(7, 2, .8, "Initial"),
(46.1, 2, .8, "Remarks"))),
(2.5, 13, (
(10, 2, .9, ("Skip", "Third", "Second", "Lead")),
(20, 2), (12, 2), (7, 2)), 4))}
if self.forms == 4:
ppad = 1
h1 = "Assessment Form"
yy = [2, 18, 34, 50]
else:
ppad = 1.5
h1 = "Assessment Form for %s" % self.disp
yy = [2.5, 23.5, 44.5]
for x in range(0, len(cards), maxf):
fpdf.add_page()
last, table = doDrawTable(fpdf, rr, ppad, spad=2, cw=cw, ld=ld)
for y in range(maxf):
card = cards[x + y]
if self.forms == 4:
if y % 2:
xx = 53 * cw
else:
xx = 5 * cw
sx = xx
fpdf.setFont("helvetica", "B", 12)
fpdf.set_y((yy[int(y / 2)]) * ld)
fpdf.drawText(x=xx, w=45 * cw, align="C", txt=h1)
fpdf.setFont("helvetica", "B", 8)
h2 = "%s vs %s at %s on %s" % (card[0], card[1], card[2],
self.disp)
fpdf.drawText(x=xx, w=45 * cw, align="C", txt=h2)
fpdf.setFont("helvetica", "B", 10)
h3 = "Skip: %s Player: %s" % (card[3], card[4])
fpdf.drawText(x=xx, w=45 * cw, align="C", txt=h3)
fpdf.drawText(h=2)
fpdf.setFont("helvetica", "B", 10)
else:
xx = 3 * cw
sx = 25 * cw
fpdf.setFont("helvetica", "B", 18)
fpdf.set_y((yy[y]) * ld)
fpdf.drawText(x=xx, w=90 * cw, h=10, align="C", txt=h1)
fpdf.setFont("helvetica", "B", 16)
h2 = "%s vs %s at %s on %s" % (card[0], card[1], card[2],
self.disp)
fpdf.drawText(x=xx, w=90 * cw, h=8, align="C", txt=h2)
fpdf.drawText()
fpdf.setFont("helvetica", "B", 12)
w1 = fpdf.get_string_width("XXXXXXXXX")
w2 = fpdf.get_string_width("XXXXX")
fpdf.drawText(x=sx + (7 * cw), w=w1, txt="Shots-For", border=1,
fill=1, ln=0)
fpdf.drawText(w=w1, txt="Shots-Agt", border=1, fill=1, ln=0)
fpdf.drawText(w=w1, txt=" Points", border=1, fill=1, ln=0)
fpdf.drawText(w=w2, txt="Total", border=1, fill=1)
if self.sets == "Y":
for s in range(1, 3):
fpdf.drawText(x=sx, h=5, txt="Set %s" % s, ln=0)
fpdf.drawText(x=sx + (7 * cw), w=w1, h=5, txt="",
border=1, ln=0)
fpdf.drawText(w=w1, h=5, txt="", border=1, ln=0)
fpdf.drawText(w=w1, h=5, txt="", border=1, ln=0)
if s == 1:
fpdf.drawText(w=w2, h=5, txt="", border="LR")
else:
fpdf.drawText(w=w2, h=5, txt="", border="LRB")
else:
fpdf.drawText(x=sx + (7 * cw), w=w1, h=5, txt="",
border=1, ln=0)
fpdf.drawText(w=w1, h=5, txt="", border=1, ln=0)
fpdf.drawText(w=w1, h=5, txt="", border=1, ln=0)
fpdf.drawText(w=w2, h=5, txt="", border=1)
if self.forms == 1:
fpdf.setFont("helvetica", "", 12)
r = (y * 21) + 4.5
for z in range(4):
fpdf.set_xy(13.5 * cw, (9 + (z * 2) + r) * ld)
fpdf.drawText(txt=card[4 + z])
elif self.self == "N" and card[5] in (1,2,3,4):
if y % 2:
posx = 127
else:
posx = 25
if card[5] == 1:
posy = fpdf.get_y() + 10
elif card[5] == 2:
posy = fpdf.get_y() + 16.75
elif card[5] == 3:
posy = fpdf.get_y() + 23.5
else:
posy = fpdf.get_y() + 30.25
fpdf.drawText(x=posx, y=posy, txt="XXXXXXX")
fpdf.output(pdfnam, "F")
head = "Match Assessment Forms for %s" % self.disp
doPrinter(mf=self.opts["mf"], header=head, pdfnam=pdfnam,
repprt=self.df.repprt, fromad=self.fromad, repeml=self.df.repeml)
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def getName(self, snam, fnam):
snam = snam.replace("VAN DER", "V D")
snam = snam.replace("JANSE VAN", "J V")
if fnam:
return "%s, %s" % (snam.upper(), fnam.split()[0][0].upper())
else:
return snam.upper()
class mlm010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
mc = GetCtl(self.opts["mf"])
ctlmst = mc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
memctl = mc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
self.ldays = memctl["mcm_ldays"]
self.lme = memctl["mcm_lme"]
self.lmd = int(memctl["mcm_lme"] / 100)
yr = int(self.lme / 10000)
mth = (int(self.lme / 100) % 100) + 1
if mth > 12:
yr += 1
mth = 1
self.tme = mthendDate((yr * 10000) + (mth * 100) + 00)
tabs = [
"chglog", "ctlbat", "ctlmst", "ctlvrf", "ctlvtf", "memage",
"memcat", "memctc", "memctl", "memctp", "memmst", "memtrn"
]
if self.glint == "Y":
tabs.append("gentrn")
ctlctl = mc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "mem_pen", "vat_ctl"]
if mc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.penctl = ctlctl["mem_pen"]
self.vatctl = ctlctl["vat_ctl"]
else:
self.penctl = 0
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.glint == "Y":
check = self.sql.getRec("memctc",
where=[("mcc_cono", "=",
self.opts["conum"]),
("mcc_freq", "<>", "N"),
("mcc_glac", "=", 0)])
if check:
mess = "The following Category Record(s) are Missing G/L "\
"Accounts:\n"
for rec in check:
mess = "%s\n%s, %2s, %s" % (mess, rec[1], rec[2], rec[3])
showError(self.opts["mf"].body, "Invalid Category", mess)
return
t = time.localtime()
self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2]
self.ynd = False
return True
def mainProcess(self):
r1s = (("No", "N"), ("Yes", "Y"))
fld = ((("T", 0, 0, 0), "OD1", 10, "Last Month End Date"),
(("T", 0, 1, 0), "ID1", 10, "This Month End Date", "", self.tme,
"N", self.doTme, None, None, ("efld", )),
(("T", 0, 2, 0), ("IRB", r1s), 0, "Raise Penalties", "", "N",
"N", self.doPenalty, None, None,
None), (("T", 0, 3, 0), "ID1", 10, "Cut-off Date", "", "", "N",
self.doCutOff, None, None, ("efld", )))
tnd = ((self.doEnd, "Y"), )
txt = (self.closeProcess, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
focus=False)
self.df.loadEntry("T", 0, 0, data=self.lme)
self.df.focusField("T", 0, 2)
def doTme(self, frt, pag, r, c, p, i, w):
if w <= self.lme:
return "Invalid Month-End Date, Before Last Month End"
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Month-End Date, Out of Financial Period"
if int(w / 100) == int(self.opts["period"][2][0] / 100):
ok = askQuestion(self.opts["mf"].body,
"Year End",
"Is this the Financial Year End?",
default="yes")
if ok == "yes":
self.ynd = True
w = self.opts["period"][2][0]
self.df.loadEntry(frt, pag, p, data=w)
else:
return "Invalid Month-End Date, Same as Year-End"
if dateDiff(self.lme, w, "months") != 1:
return "There Seems to be a Missing Month End"
self.tme = w
self.curdt = int(w / 100)
yy = int(self.curdt / 100)
mm = (self.curdt % 100) + 1
while mm > 12:
yy += 1
mm -= 12
self.nxtdt = (yy * 10000) + (mm * 100) + 1
self.nxtcd = int(self.nxtdt / 100)
self.batch = "M%06s" % self.curdt
chk = self.sql.getRec("memtrn",
cols=["count(*)"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_type", "=", 1),
("mlt_batch", "=", self.batch),
("mlt_trdt", "=", self.nxtdt),
("mlt_curdt", "=", self.nxtcd)],
limit=1)
if chk[0]:
return "Month-End Already Executed"
num = self.sql.getRec("memtrn",
cols=["max(mlt_refno)"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_type", "=", 1),
("mlt_refno", "like", "A________")],
limit=1)
if not num[0]:
self.refnum = 0
else:
self.refnum = int(num[0][4:])
def doPenalty(self, frt, pag, r, c, p, i, w):
self.penalty = w
if self.penalty == "N":
return "sk1"
def doCutOff(self, frt, pag, r, c, p, i, w):
if w >= self.tme:
return "Invalid Cut-off Date"
self.cutoff = w
self.pcodes = {}
acc = self.sql.getRec("memctp",
cols=["mcp_type", "mcp_code", "mcp_penalty"],
where=[("mcp_cono", "=", self.opts["conum"]),
("mcp_date", "<=", self.cutoff),
("mcp_penalty", "<>", 0)],
order="mcp_date")
for a in acc:
self.pcodes["%s%02i" % (a[0], a[1])] = a[2]
def doEnd(self):
recs = self.sql.getRec("ctlbat",
cols=["count(*)"],
where=[("btm_cono", "=", self.opts["conum"]),
("btm_styp", "=", "MEM"),
("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="MST",
code="UnbalBatch")
if ok.flag == "no":
self.closeProcess()
else:
self.doEnder()
else:
self.closeProcess()
else:
self.doEnder()
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 doRaiseCharge(self,
ctyp,
code,
start,
end,
last,
freq,
desc,
glac,
skip=False):
if freq == "O":
dte = True
nxt = False
else:
dte = False
nxt = bool(self.ynd or freq == "M")
if not last:
if dateDiff(start, self.tme, "days") > self.ldays:
dte = True
else:
nxt = True
if dte:
trdt = start
amt = self.doGetCharge(ctyp, code, trdt)
if amt:
self.doUpdateTables(ctyp, code, desc, glac, trdt, amt)
if not skip and nxt:
if end and self.nxtdt > end:
return
trdt = self.nxtdt
amt = self.doGetCharge(ctyp, code, trdt)
if amt:
self.doUpdateTables(ctyp, code, desc, glac, trdt, amt)
def doGetCharge(self, ctyp, code, date):
prc = self.sql.getRec("memctp",
where=[("mcp_cono", "=", self.opts["conum"]),
("mcp_type", "=", ctyp),
("mcp_code", "=", code),
("mcp_date", "<=", date)],
order="mcp_date desc",
limit=1)
if not prc:
# No Price
return
if prc[5] == "N" or (self.ynd and date == self.nxtdt):
# Not Pro Rata or End of Financial Year
amt = CCD(prc[6], "UD", 12.2).work
else:
# Extract Pro Rata Rate
mths = 17 - dateDiff(date, self.opts["period"][2][0], "months")
if mths < 1:
mths = 12
amt = CCD(prc[mths], "UD", 12.2).work
if not amt:
# No Charge
return
else:
return amt
def doUpdateTables(self, ctyp, code, desc, glac, trdt, amt):
self.refnum += 1
ref = CCD("A%08i" % self.refnum, "Na", 9).work
curdt = int(trdt / 100)
# VAT Rate and Amount
vrte = getVatRate(self.sql, self.opts["conum"], self.taxdf, trdt)
if vrte is None:
vrte = 0.0
vat = CCD(round(((amt * vrte) / (vrte + 100)), 2), "UD", 12.2).work
# Members Ledger Transaction (memtrn)
data = [
self.opts["conum"], self.memno, 1, ref, self.batch, trdt, amt, vat,
curdt, ctyp, code, desc, self.taxdf, "", self.opts["capnm"],
self.sysdt, 0
]
self.sql.insRec("memtrn", data=data)
# Members Ledger Category (memcat)
self.sql.updRec("memcat",
cols=["mlc_last"],
data=[trdt],
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", self.memno),
("mlc_type", "=", ctyp),
("mlc_code", "=", code)])
if vat:
# VAT Transaction (ctlvtf)
val = float(ASD(0) - ASD(amt) + ASD(vat))
tax = float(ASD(0) - ASD(vat))
data = [
self.opts["conum"], self.taxdf, "O", curdt, "M", 1, self.batch,
ref, trdt, self.memno, desc, val, tax, 0, self.opts["capnm"],
self.sysdt, 0
]
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
ref = "ML/MthEnd"
# General Ledger Member Control
whr = [("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.memctl), ("glt_batch", "=", self.batch),
("glt_curdt", "=", curdt), ("glt_trdt", "=", trdt),
("glt_type", "=", 1)]
glt = self.sql.getRec("gentrn", where=whr)
if glt and len(glt) == 1:
tmp = glt[0][self.sql.gentrn_col.index("glt_tramt")]
tmp = float(ASD(tmp) + ASD(amt))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[tmp],
where=whr)
else:
data = [
self.opts["conum"], self.memctl, curdt, trdt, 1, ref,
self.batch, amt, 0, "Month End Raising Charges", "", "", 0,
self.opts["capnm"], self.sysdt, 0
]
self.sql.insRec("gentrn", data=data)
val = float(ASD(0) - ASD(amt) + ASD(vat))
tax = float(ASD(0) - ASD(vat))
# General Ledger Income Account
whr[1] = ("glt_acno", "=", glac)
glt = self.sql.getRec("gentrn", where=whr)
if glt and len(glt) == 1:
tmp = glt[0][self.sql.gentrn_col.index("glt_tramt")]
tmp = float(ASD(tmp) + ASD(val))
glt[0][self.sql.gentrn_col.index("glt_tramt")] = tmp
tmp = glt[0][self.sql.gentrn_col.index("glt_taxamt")]
tmp = float(ASD(tmp) + ASD(tax))
glt[0][self.sql.gentrn_col.index("glt_taxamt")] = tmp
self.sql.updRec("gentrn", data=glt[0], where=whr)
else:
data = [
self.opts["conum"], glac, curdt, trdt, 1, ref, self.batch, val,
tax, "Month End Raising Charges", self.taxdf, "", 0,
self.opts["capnm"], self.sysdt, 0
]
self.sql.insRec("gentrn", data=data)
if not tax:
return
# General Ledger VAT Account
whr = [("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.vatctl), ("glt_batch", "=", self.batch),
("glt_curdt", "=", curdt), ("glt_trdt", "=", trdt),
("glt_type", "=", 1)]
glt = self.sql.getRec("gentrn", where=whr)
if glt and len(glt) == 1:
tmp = glt[0][self.sql.gentrn_col.index("glt_tramt")]
tmp = float(ASD(tmp) + ASD(tax))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[tmp],
where=whr)
else:
data = [
self.opts["conum"], self.vatctl, curdt, trdt, 1, ref,
self.batch, tax, 0.00, "Month End Raising Charges", "", "", 0,
self.opts["capnm"], self.sysdt, 0
]
self.sql.insRec("gentrn", data=data)
def closeProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class sl3020(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, ["wagltf"],
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
lir = wagctl["ctw_i_date"]
self.fromad = wagctl["ctw_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if lir:
fy = int(lir / 10000)
fm = int(lir / 100) - (fy * 100) + 1
if fm == 13:
fy = fy + 1
fm = 1
self.sdate = (fy * 100) + fm
else:
self.sdate = 0
self.edate = int(self.sysdtw / 100)
self.totind = "N"
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Staff Loans Audit Trail (%s)" % self.__class__.__name__)
data = ["All Types"]
for typ in sltrtp:
data.append(typ[1])
btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"}
btm = {
"stype":
"R",
"tables": ("wagltf", ),
"cols": (("wlt_batch", "", 0,
"Bat-Num"), ("wlt_type", ("xx", sltrtp), 20, "Type"),
("wlt_curdt", "", 0, "Cur-Dat")),
"where": [("wlt_cono", "=", self.opts["conum"])],
"group":
"wlt_batch, wlt_type, wlt_curdt",
"order":
"wlt_type, wlt_curdt, wlt_batch"
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "Id2", 7, "Starting Period", "", self.sdate,
"Y", self.doStartPer, None, None, ("efld", )),
(("T", 0, 1, 0), "ID2", 7, "Ending Period", "", self.edate, "Y",
self.doEndPer, None, None, ("efld", )),
(("T", 0, 2, 0), "IUI", 1, "Type", "Transaction Type", "", "Y",
self.doBatTyp, btt, None,
None), (("T", 0, 3, 0), "INa", 7, "Batch Number", "", "", "Y",
self.doBatNum, btm, None,
None), (("T", 0, 4, 0), ("IRB", r1s), 0, "Totals Only",
"", "Y", "Y", self.doTots, None, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("Y", "N"))
def doStartPer(self, frt, pag, r, c, p, i, w):
if w > self.edate:
return "Invalid Period"
self.sdatw = w
self.sdatd = CCD(self.sdatw, "d2", 7).disp
def doEndPer(self, frt, pag, r, c, p, i, w):
if not w:
self.edatw = self.edate
elif w < self.sdatw or w > self.edate:
return "Invalid Period"
else:
self.edatw = w
self.df.loadEntry(frt, pag, p, data=self.edatw)
self.edatd = CCD(self.edatw, "d2", 7).disp
def doBatTyp(self, frt, pag, r, c, p, i, w):
if w > len(sltrtp):
return "Invalid Batch Type"
self.btype = w
if self.btype:
self.df.topf[pag][i + 1][8]["whera"] = [["T", "wlt_type", 0]]
else:
self.df.topf[pag][i + 1][8]["whera"] = []
def doBatNum(self, frt, pag, r, c, p, i, w):
self.batch = w
def doTots(self, frt, pag, r, c, p, i, w):
self.totsonly = w
def doEnd(self):
self.df.closeProcess()
if not self.btype:
self.styp = 0
self.etyp = 99
else:
self.styp = self.etyp = self.btype
if not self.batch:
self.sbat = ""
self.ebat = "zzzzzzz"
else:
self.sbat = self.ebat = self.batch
whr = [("wlt_cono", "=", self.opts["conum"]),
("wlt_curdt", "between", self.sdatw, self.edatw),
("wlt_batch", "between", self.sbat, self.ebat),
("wlt_type", "between", self.styp, self.etyp)]
odr = "wlt_type, wlt_batch, wlt_trdt, wlt_ref"
recs = self.sql.getRec("wagltf", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Transaction Error",
"No Transactions Selected")
else:
self.printReport(recs)
self.closeProcess()
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
if self.totsonly == "Y":
self.head = "%03u %-76s" % (self.opts["conum"], self.opts["conam"])
else:
self.head = "%03u %-97s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.bqty = 0
self.bamt = 0
self.bded = 0
self.tqty = 0
self.tamt = 0
self.tded = 0
self.gqt = [0, 0, 0, 0, 0, 0, 0]
self.gam = [0, 0, 0, 0, 0, 0, 0]
self.gdd = [0, 0, 0, 0, 0, 0, 0]
self.trtp = 0
self.pglin = 999
col = self.sql.wagltf_col
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
empno = CCD(dat[col.index("wlt_empno")], "UI", 5)
loan = CCD(dat[col.index("wlt_loan")], "UI", 2)
batch = CCD(dat[col.index("wlt_batch")], "Na", 7)
trtp = CCD(dat[col.index("wlt_type")], "UI", 2)
trdt = CCD(dat[col.index("wlt_trdt")], "D1", 10)
ref = CCD(dat[col.index("wlt_ref")], "Na", 9)
amt = CCD(dat[col.index("wlt_amt")], "SD", 13.2)
ded = CCD(dat[col.index("wlt_ded")], "SD", 13.2)
per = CCD(dat[col.index("wlt_per")], "UD", 13.2)
desc = CCD(dat[col.index("wlt_desc")], "NA", 30)
if not self.trtp:
self.trtp = trtp.work
self.batch = batch.work
if trtp.work != self.trtp:
self.batchTotal()
self.typeTotal()
self.trtp = trtp.work
self.batch = batch.work
self.pglin = 999
if batch.work != self.batch:
self.batchTotal()
self.batch = batch.work
if self.totsonly != "Y":
self.typeHeading()
if self.pglin > self.fpdf.lpp:
self.pageHeading()
if self.totsonly != "Y":
self.fpdf.drawText("%s %s %s %s %s %s %s %s" % \
(empno.disp, loan.disp, ref.disp, trdt.disp,
desc.disp, per.disp, amt.disp, ded.disp))
self.pglin += 1
self.bqty = self.bqty + 1
self.bamt = float(ASD(self.bamt) + ASD(amt.work))
self.bded = float(ASD(self.bded) + ASD(ded.work))
self.tqty = self.tqty + 1
self.tamt = float(ASD(self.tamt) + ASD(amt.work))
self.tded = float(ASD(self.tded) + ASD(ded.work))
self.gqt[trtp.work - 1] = self.gqt[trtp.work - 1] + 1
self.gam[trtp.work - 1] = float(ASD(self.gam[trtp.work - 1]) + \
ASD(amt.work))
self.gdd[trtp.work - 1] = float(ASD(self.gdd[trtp.work - 1]) + \
ASD(ded.work))
p.closeProgress()
if self.fpdf.page and not p.quit:
self.batchTotal()
self.typeTotal()
self.grandTotal()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.df.repprt,
fromad=self.fromad,
repeml=self.df.repeml)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-34s %-7s %2s %-7s" % \
("Staff Loans Audit Trail for Period",
self.sdatd, "to", self.edatd))
self.fpdf.drawText()
self.pglin = 4
if self.totind == "N":
self.typeHeading()
else:
self.fpdf.drawText("%-14s" % "Totals Summary")
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText(
"%-44s%-8s %-13s %-13s" % \
("Document Type", "Quantity", " Amount", " Deduction"))
else:
self.fpdf.drawText(
"%-30s%-8s %-13s %-13s" % \
("Document Type", "Quantity", " Amount", " Deduction"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def typeHeading(self):
if self.totsonly == "N":
batch = self.batch
else:
batch = "Various"
if self.fpdf.lpp - self.pglin < 7:
self.pageHeading()
return
self.fpdf.setFont(style="B")
self.fpdf.drawText("%-7s %-7s %-10s %3s" % \
("Batch", batch, " Type", sltrtp[self.trtp - 1][1]))
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-53s %-13s %-13s" % \
("Details", " Amount", " Deduction"))
else:
self.fpdf.drawText(
"%-5s %-2s %-9s %-10s %-30s %-13s %-13s %-13s" % \
("Empno", "Ln", "Reference", "Trans-Date", "Remarks",
" I-Rate", " Amount", " Deduction"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def batchTotal(self):
j = CCD(self.bamt, "SD", 13.2)
k = CCD(self.bded, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-5s %-7s %-39s %13s %13s" % \
("Batch", self.batch, "Totals", j.disp, k.disp))
else:
self.fpdf.drawText()
self.pglin += 1
self.fpdf.drawText("%-29s %-44s %13s %13s" % \
(" ", "Batch " + self.batch + " Totals", j.disp, k.disp))
self.pglin += 1
if self.totsonly == "N":
self.fpdf.drawText()
self.pglin += 1
self.bqty = 0
self.bamt = 0
self.bded = 0
def typeTotal(self):
j = CCD(self.tamt, "SD", 13.2)
k = CCD(self.tded, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText()
self.fpdf.drawText("%-53s %13s %13s" %
("Type Totals", j.disp, k.disp))
self.pglin += 2
else:
self.fpdf.drawText("%-29s %-44s %13s %13s" % \
(" ", "Type Totals", j.disp, k.disp))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
self.tqty = 0
self.tamt = 0
self.tded = 0
def grandTotal(self):
self.totind = "Y"
self.pageHeading()
tot = [0, 0, 0, 0]
for x, t in enumerate(sltrtp):
qt = CCD(self.gqt[x], "SI", 8)
am = CCD(self.gam[x], "SD", 13.2)
dd = CCD(self.gdd[x], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-44s %s %s %s" % \
(t[1], qt.disp, am.disp, dd.disp))
else:
self.fpdf.drawText("%-30s %s %s %s" % \
(t[1], qt.disp, am.disp, dd.disp))
tot[0] = tot[0] + qt.work
tot[1] = float(ASD(tot[1]) + ASD(am.work))
tot[2] = float(ASD(tot[2]) + ASD(dd.work))
self.fpdf.drawText()
qt = CCD(tot[0], "SI", 8)
am = CCD(tot[1], "SD", 13.2)
dd = CCD(tot[2], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-44s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, dd.disp))
else:
self.fpdf.drawText("%-30s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, dd.disp))
self.fpdf.drawText()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class tb1010(object):
def __init__(self, **opts):
self.opts = opts
self.opts["mf"].dbm.openDbase()
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ftable", "ffield"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def doProcess(self):
fft = {
"stype":
"R",
"tables": ("ftable", ),
"cols": (("ft_tabl", "", 0, "Table"), ("ft_desc", "", 0,
"Description", "Y")),
"where": [("ft_seq", "=", 1)]
}
ffl = {
"stype":
"R",
"tables": ("ffield", ),
"cols": (("ff_seq", "", 0, "Seq"), ("ff_name", "", 0, "Name"),
("ff_desc", "", 0, "Description", "Y"),
("ff_type", "", 0, "Tp"), ("ff_size", "", 0, "Size")),
"whera": (("T", "ff_tabl", 0, 0), ),
"index":
0
}
ffi = {
"stype":
"R",
"tables": ("ftable", ),
"cols":
(("ft_seq", "", 0, "Seq"), ("ft_type", "", 0,
"T"), ("ft_key0", "", 0, "Column-1"),
("ft_key1", "", 0, "Column-2"), ("ft_key2", "", 0, "Column-3"),
("ft_key3", "", 0, "Column-4"), ("ft_key4", "", 0, "Column-5"),
("ft_key4", "", 0, "Column-6"), ("ft_key4", "", 0, "Column-7")),
"whera": (("T", "ft_tabl", 0, 0), ),
"comnd":
self.doIdxCmd
}
typ = {
"stype": "C",
"titl": "Select the Required Data Type",
"head": ("Cd", "Description"),
"data": dattyp,
"index": 0
}
valtyp = []
for t in dattyp:
valtyp.append(t[0])
self.col = {
"stype": "C",
"titl": "Select the Required Column",
"head": ("Table", "Description"),
"data": []
}
fld = [(("T", 0, 0, 0), "INA", 20, "Table ", "Table Name", "", "Y",
self.doTable, fft, None, ("notin", ("", "ftable", "ffield"))),
(("T", 0, 0, 0), "INA", 30, " Description ", "Description", "",
"N", self.doDesc, None, None, None),
(("C", 1, 0, 0), "IUI", 3, "Seq", "Column Sequence", "i", "N",
self.doColSeq, ffl, None, ("between", 0, 999)),
(("C", 1, 0, 1), "INA", 20, "Column", "Column Name", "", "N",
None, None, None, ("notblank", )),
(("C", 1, 0, 2), "INA", 2, "Tp", "Data Type", "", "N", None,
typ, None, ("in", valtyp)),
(("C", 1, 0, 3), "IUD", 6.1, "Size", "Field Size", "", "N",
None, None, None, ("notzero", )),
(("C", 1, 0, 4), "INA", 30, "Description", "", "", "N", None,
None, None, None),
(("C", 1, 0, 5), "INA", 30, "Heading", "Report Heading", "",
"N", None, None, None, ("notblank", )),
(("C", 2, 0, 0), "IUI", 1, "S", "Sequence", "i", "N",
self.doIdxSeq, ffi, None, ("efld", )),
(("C", 2, 0, 1), "IUA", 1, "T", "Type (U/N)", "", "N", None,
None, None, ("in", ("U", "N"))),
(("C", 2, 0, 2), "INA", (14, 20), "Column-0", "", "", "N",
self.doIdxCol, self.col, None, ("notblank", )),
(("C", 2, 0, 3), "INA", (14, 20), "Column-1", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 4), "INA", (14, 20), "Column-2", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 5), "INA", (14, 20), "Column-3", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 6), "INA", (14, 20), "Column-4", "", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 7), "INA", (5, 20), "Col-5", "Column-5", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 8), "INA", (5, 20), "Col-6", "Column-6", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 9), "INA", (5, 20), "Col-7", "Column-7", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 10), "INA", (5, 20), "Col-8", "Column-8", "", "N",
self.doIdxCol, self.col, None, ("efld", )),
(("C", 2, 0, 11), "INA", (5, 20), "Col-9", "Column-9", "", "N",
self.doIdxCol, self.col, None, ("efld", ))]
tag = (("Columns", None, ("C", 1, 1), ("T", 0, 1)),
("Indexes", None, ("C", 1, 1), ("T", 0, 1)))
row = (0, 15, 5)
tnd = ((self.endTop, "y"), )
txt = (self.exitTop, )
cnd = ((None, "n"), (self.endPage1, "y"), (self.endPage2, "y"))
cxt = (None, self.exitPage1, self.exitPage2)
but = (("Print", None, self.doPrint, 0, ("T", 0, 2), ("T", 0, 1)),
("Cancel", None, self.doRestart, 0, ("T", 0, 2), ("T", 0, 1)))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
rows=row,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doTable(self, frt, pag, r, c, p, i, w):
self.tab = w
tab = self.sql.getRec("ftable",
cols=["ft_tabl", "ft_desc"],
where=[("ft_tabl", "=", w), ("ft_seq", "=", 1)],
limit=1)
if not tab:
self.new = "y"
else:
self.new = "n"
self.df.loadEntry(frt, pag, p + 1, data=tab[1])
yn = askQuestion(screen=self.opts["mf"].body, head="Table Exists",
mess="Changing This Record Could Result In Loss of Data, "\
"Are You Sure You Want to Continue?", default="no")
if yn == "no":
return yn
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def endTop(self):
self.fld = makeArray(6, 100, 1, "S")
self.idx = makeArray(12, 20, 1, "S")
if self.new == "n":
fld = self.sql.getRec("ffield",
where=[("ff_tabl", "=", self.tab)],
order="ff_seq")
for n, f in enumerate(fld):
self.fld[n] = f[1:]
idx = self.sql.getRec("ftable",
where=[("ft_tabl", "=", self.tab)],
order="ft_seq")
for n, f in enumerate(idx):
self.idx[n] = f[2:]
self.idx[n][0] = n
self.doPopulate("fld")
else:
self.df.focusField("C", 1, 1)
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doColSeq(self, frt, pag, r, c, p, i, w):
self.colseq = w
for n, s in enumerate(self.fld[self.colseq][1:]):
self.df.loadEntry("C", 1, p + n + 1, data=s)
def endPage1(self):
pos = int(self.df.col / self.df.colq[1]) - 1
self.fld[self.colseq] = copyList(self.df.c_work[1][pos])
self.doPopulate("fld")
def exitPage1(self):
self.createCols()
self.df.selPage("Indexes")
self.doPopulate("idx")
def createCols(self):
self.valcol = []
self.col["data"] = []
for fld in self.fld:
self.valcol.append(fld[1])
self.col["data"].append([fld[1], fld[4]])
def doIdxCmd(self, frt, pag, r, c, p, i, w):
idxseq = int(w[0]) - 1
self.doIdxSeq(frt, pag, r, c, p, i, idxseq)
self.df.focusField(frt, pag, c + 1)
def doIdxSeq(self, frt, pag, r, c, p, i, w):
self.idxseq = w
for n, s in enumerate(self.idx[self.idxseq][1:]):
self.df.loadEntry("C", 2, p + n + 1, data=s)
def doIdxCol(self, frt, pag, r, c, p, i, w):
if w and w not in self.valcol:
return "Invalid Column"
def endPage2(self):
pos = int(self.df.col / self.df.colq[2]) - 1
self.idx[self.idxseq] = copyList(self.df.c_work[2][pos])
self.doPopulate("idx")
def exitPage2(self):
if self.new == "y" and self.df.col == 1:
self.df.selPage("Columns")
else:
if self.tab in tabdic:
tabdic[self.tab]["fld"] = []
tabdic[self.tab]["idx"] = []
else:
tabdic[self.tab] = {"fld": [], "idx": []}
for dat in self.fld:
if dat == [""] * 6:
break
tabdic[self.tab]["fld"].append(dat)
for num, dat in enumerate(self.idx):
if dat == [""] * 12:
break
if num == 0:
dat.insert(0, self.df.t_work[0][0][1])
else:
dat.insert(0, "")
dat[1] = num + 1
fmt = '"%s",%s,"%s"'
ddd = dat[:3]
for n, d in enumerate(dat[3:]):
if d:
fmt += ',"%s"'
ddd.append(d)
fmt += "\n"
tabdic[self.tab]["idx"].append(ddd)
fle = os.path.join(getPrgPath(), "stdtab.py")
outf = open(fle, "w")
outf.write("""tabdic = {""")
tabs = list(tabdic.keys())
tabs.sort()
for tab in tabs:
outf.write("""
"%s": {""" % tab)
for key in ("fld", "idx"):
outf.write("""
"%s": [""" % key)
for fld in tabdic[tab][key]:
outf.write("""
%s""" % json.dumps(fld))
if fld == tabdic[tab][key][-1]:
outf.write("""]""")
else:
outf.write(""",""")
if key == "fld":
outf.write(""",""")
outf.write("""}""")
if tab != tabs[-1]:
outf.write(""",""")
outf.write("""}""")
outf.close()
self.doRestart()
def doPopulate(self, ftyp=None):
if ftyp == "fld":
self.df.clearFrame("C", 1)
for num, dat in enumerate(self.fld):
if dat == [""] * 6:
break
if num > 14:
self.df.scrollScreen(1)
pos = 14
else:
pos = num
self.df.focusField("C", 1, (pos * 6) + 1)
for n, c in enumerate(dat):
self.df.loadEntry("C", 1, (pos * 6) + n, data=c)
self.df.advanceLine(1)
return
self.df.clearFrame("C", 2)
for num, dat in enumerate(self.idx):
if dat == [""] * 12:
break
if num > 4:
self.df.scrollScreen(2)
pos = 4
else:
pos = num
self.df.focusField("C", 2, (pos * 12) + 1)
for n, c in enumerate(dat):
self.df.loadEntry("C", 2, (pos * 12) + n, data=c)
self.df.advanceLine(2)
self.df.focusField("C", 2, self.df.col)
def doRestart(self):
self.df.last[0] = [0, 0]
self.df.selPage("Columns")
self.df.focusField("T", 0, 1)
def doPrint(self):
state = self.df.disableButtonsTags()
cols = [["ff_seq", "UI", 3.0, "Seq"],
["ff_name", "NA", 20.0, "Field Name"],
["ff_type", "NA", 2.0, "Tp"], ["ff_size", "NA", 6.1, "Size"],
["ff_desc", "NA", 30.0, "Description"],
["ff_head", "NA", 20.0, "Heading"]]
whr = [("ff_tabl", "=", self.tab)]
RepPrt(self.opts["mf"],
name=self.tab + "_fld",
tables=["ffield"],
heads=[
"Table Fields for Table %s" % self.tab,
],
cols=cols,
where=whr)
cols = [["ft_desc", "NA", 30.0, "Table Description"],
["ft_seq", "UI", 2.0, "Sq"], ["ft_type", "NA", 1.0, "T"],
["ft_key0", "NA", 10.0, "1st-Key"],
["ft_key1", "NA", 10.0, "2nd-Key"],
["ft_key2", "NA", 10.0, "3rd-Key"],
["ft_key3", "NA", 10.0, "4th-Key"],
["ft_key4", "NA", 10.0, "5th-Key"],
["ft_key5", "NA", 10.0, "6th-Key"],
["ft_key6", "NA", 10.0, "7th-Key"],
["ft_key7", "NA", 10.0, "8th-Key"],
["ft_key8", "NA", 10.0, "9th-Key"],
["ft_key9", "NA", 10.0, "10th-Key"]]
whr = [("ft_tabl", "=", self.tab)]
RepPrt(self.opts["mf"],
name=self.tab + "_idx",
tables=["ftable"],
heads=[
"Table Keys for Table %s" % self.tab,
],
cols=cols,
where=whr)
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
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()
class st6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.tables = (
("ctlnot", "not_key"),
("slsiv2", "si2_cono", "si2_group", "si2_code"),
("slsiv3", "si3_cono", "si3_rgroup", "si3_rcode"),
("strmf1", "st1_cono", "st1_group", "st1_code"),
("strmf2", "st2_cono", "st2_group", "st2_code"),
("strpot", "pot_cono", "pot_group", "pot_code"),
("strprc", "stp_cono", "stp_group", "stp_code"),
("strrcp", "srr_cono", "srr_group", "srr_code"),
("strrcp", "srr_cono", "srr_rgroup", "srr_rcode"),
("strtrn", "stt_cono", "stt_group", "stt_code"),
("strvar", "stv_cono", "stv_group", "stv_code"))
tabs = ["strgrp"]
for tab in self.tables:
if not tabs.count(tab[0]):
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
crsctl = gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
return True
def mainProcess(self):
grp = {
"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_code", "", 0, "Product-Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [("st1_cono", "=", self.opts["conum"])],
"whera": [["T", "st1_group", 0]]}
r1s = (("Yes", "Y"), ("No", "N"))
self.fld = [
(["T",0,0,0],"IUA",3,"Old Group","Old Group",
"","Y",self.doGroup,grp,None,("notblank",)),
(["T",0,0,31],"ONA",30,""),
(["T",0,1,0],"IUA",3,"New Group","New Group",
"","Y",self.doGroup,grp,None,("notblank",)),
(["T",0,1,31],"ONA",30,""),
(["T",0,2,0],("IRB",r1s),0,"All Codes","All Codes",
"N","Y",self.doAllCod,None,None,None),
(["T",0,3,0],"IRW",20,"Old Code","Old Product Code",
"","Y",self.doOldCod,stm,None,("notblank",)),
(["T",0,3,0],"ONA",30,""),
(["T",0,4,0],"INA",20,"New Code","New Product Code",
"","Y",self.doNewCod,None,None,("notblank",))]
but = (
("Import File",None,self.doImport,0,("T",0,1),("T",0,2),
"Import a CSV or XLS File with the Correct Format i.e. "\
"Old Group, New Group, Old Code, New Code. If the New Code "\
"is left Blank the Old Code will be Retained."),)
tnd = ((self.doProcess,"y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=self.fld,
butt=but, tend=tnd, txit=txt)
def doImport(self):
self.df.closeProcess()
impcol = []
pos = 0
for num, fld in enumerate(self.fld):
if num in (1, 3, 4, 6):
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)
if fi.impdat:
p = ProgressBar(self.opts["mf"].body, typ="Importing Changes",
mxs=len(fi.impdat))
for num, line in enumerate(fi.impdat):
p.displayProgress(num)
self.oldgrp, self.newgrp, self.oldcod = line[:3]
if line[3]:
self.newcod = line[3]
else:
self.newcod = self.oldcod
self.oldnot = "%3s%s" % (self.oldgrp, self.oldcod)
self.newnot = "%3s%s" % (self.newgrp, self.newcod)
self.doChange()
p.closeProgress()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
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, Does Not exist"
self.df.loadEntry(frt, pag, p+1, data=acc[0])
if c == 1:
self.oldgrp = w
else:
self.newgrp = w
if self.newgrp == self.oldgrp:
self.allcod = "N"
self.df.loadEntry(frt, pag, p+2, data=self.allcod)
return "sk2"
def doAllCod(self, frt, pag, r, c, p, i, w):
self.allcod = w
if self.allcod == "Y":
recs = self.sql.getRec("strmf1", where=[("st1_cono", "=",
self.opts["conum"]), ("st1_group", "=", self.oldgrp)])
err = None
for acc in recs:
cod = acc[self.sql.strmf1_col.index("st1_code")]
chk = self.sql.getRec("strmf1", where=[("st1_cono", "=",
self.opts["conum"]), ("st1_group", "=", self.newgrp),
("st1_code", "=", cod)], limit=1)
if chk:
err = "Group: %s Code: %s - Already Exists" % (self.newgrp,
acc[self.sql.strmf1_col.index("st1_code")])
break
if err:
return "%s, Cannot Do All" % err
return "sk3"
def doOldCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1", where=[("st1_cono", "=",
self.opts["conum"]), ("st1_group", "=", self.oldgrp), ("st1_code",
"=", w)], limit=1)
if not acc:
return "Invalid Code, Does Not exist"
self.oldcod = w
self.oldnot = "%3s%s" % (self.oldgrp, w)
desc = acc[self.sql.strmf1_col.index("st1_desc")]
self.df.loadEntry(frt, pag, p+1, data=desc)
def doNewCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1", where=[("st1_cono", "=",
self.opts["conum"]), ("st1_group", "=", self.newgrp), ("st1_code",
"=", w)], limit=1)
if acc:
return "Invalid Code, Already Exists"
self.newcod = w
self.newnot = "%3s%s" % (self.newgrp, w)
def doProcess(self):
if self.allcod == "Y":
recs = self.sql.getRec("strmf1", cols=["st1_code"],
where=[("st1_cono", "=", self.opts["conum"]), ("st1_group",
"=", self.oldgrp)])
p = ProgressBar(self.opts["mf"].body, mxs=len(recs),
typ="Changing All Records for Group %s" % self.oldgrp)
for num, acc in enumerate(recs):
p.displayProgress(num)
self.oldcod = acc[0]
self.newcod = acc[0]
self.oldnot = "%3s%s" % (self.oldgrp, acc[0])
self.newnot = "%3s%s" % (self.newgrp, acc[0])
self.doChange()
p.closeProgress()
self.sql.delRec("strgrp", where=[("gpm_cono", "=",
self.opts["conum"]), ("gpm_group", "=", self.oldgrp)])
else:
self.doChange()
self.df.focusField("T", 0, 1)
def doChange(self):
for tab in self.tables:
if tab[0] == "ctlnot":
whr = [
("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "STR"),
(tab[1], "=", self.oldnot)]
dat = [self.newnot]
col = [tab[1]]
else:
whr = [(tab[2], "=", self.oldgrp), (tab[3], "=", self.oldcod)]
dat = [self.newgrp, self.newcod]
col = [tab[2], tab[3]]
self.sql.updRec(tab[0], where=whr, data=dat, cols=col)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
class gl6080:
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, ["ctlmst", "genmst", "gentrn"],
prog=__name__)
if self.sql.error:
return
return True
def mainProcess(self):
ctm = {
"stype": "R",
"tables": ("ctlmst", ),
"cols": (("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name")),
"order": "ctm_cono",
"index": 0
}
r1s = (("All", "A"), ("Range", "R"), ("Selection", "S"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Company", "", "A", "Y",
self.doCoySel, None, None, None),
(("T", 0, 1, 0), "IUI", 3, "From Company", "", "", "N",
self.doCoyNo, ctm, None, ("notzero", )), (("T", 0, 1, 0),
"ONA", 30, ""),
(("T", 0, 2, 0), "IUI", 3, "To Company", "", "", "N",
self.doCoyNo, ctm, None, ("notzero", )), (("T", 0, 2, 0),
"ONA", 30, ""))
but = (("Exit", None, self.doExit, 0, ("T", 0, 1), ("T", 0, 0)), )
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
view=("Y", "V"))
def doCoySel(self, frt, pag, r, c, p, i, w):
if w == "A":
self.coys = []
for coy in self.sql.getRec("ctlmst",
cols=["ctm_cono"],
order="ctm_cono"):
self.coys.append(coy[0])
return "sk4"
elif w == "S":
self.coys = []
coys = getSingleRecords(self.opts["mf"], "ctlmst",
("ctm_cono", "ctm_name"))
for coy in coys:
self.coys.append(coy[0])
if not self.coys:
return "No Company Selected"
return "sk4"
def doCoyNo(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"
self.df.loadEntry(frt, pag, p + 1, data=nam[0])
if p == 1:
self.fcoy = w
elif w < self.fcoy:
return "Invalid Selection"
else:
self.tcoy = w
self.coys = []
coys = self.sql.getRec("ctlmst",
cols=["ctm_cono"],
where=[("ctm_cono", "between", self.fcoy,
self.tcoy)],
order="ctm_cono")
for coy in coys:
self.coys.append(coy[0])
def doEnd(self):
self.df.closeProcess()
pb = ProgressBar(self.opts["mf"].body, mxs=len(self.coys), esc=True)
miss = {}
for num, coy in enumerate(self.coys):
pb.displayProgress(num)
nam = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", coy)],
limit=1)
accs = self.sql.getRec("gentrn",
cols=["glt_acno"],
where=[("glt_cono", "=", coy)],
group="glt_acno",
order="glt_acno")
for acc in accs:
glm = self.sql.getRec("genmst",
where=[("glm_cono", "=", coy),
("glm_acno", "=", acc[0])],
limit=1)
if not glm:
if coy not in miss:
miss[coy] = []
miss[coy].append((nam[0], acc[0]))
pb.closeProgress()
keys = list(miss.keys())
keys.sort()
data = []
for k in keys:
for a in miss[k]:
data.append((k, a[0], a[1]))
if data:
head = ["Missing Account Numbers"]
cols = [("a", "NA", 3, "Coy", "y"), ("b", "NA", 30, "Name", "y"),
("c", "UI", 7, "Acc-Num", "y")]
RepPrt(self.opts["mf"],
name="gl6080",
tables=data,
heads=head,
cols=cols,
repprt=self.df.repprt,
ttype="D")
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class sl1010(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,
["chglog", "wagedc", "wagmst", "waglmf"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"),
("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0,
"Names")),
"where": [("wgm_cono", "=", self.opts["conum"])]
}
lnm = {
"stype":
"R",
"tables": ("waglmf", ),
"cols": (("wlm_empno", "", 0, "EmpNo"), ("wlm_loan", "", 0, "Ln"),
("wlm_desc", "", 0, "Description", "Y")),
"where": [("wlm_cono", "=", self.opts["conum"])],
"whera": [["T", "wlm_empno", 0]],
"index":
1
}
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), "IUI", 5, "Emp-Num", "Employee Number", "",
"Y", self.doEmp, wgm, None, ("notzero", )), (("T", 0, 0, 0),
"ONA", 30, ""),
(("T", 0, 1, 0), "IUI", 3, "Loan-Num", "Loan Number", "", "N",
self.doLoan, lnm, None,
("notzero", )), (("T", 0, 2, 0), "INA", 30, "Description", "",
"", "N", None, None, None, ("notblank", )),
(("T", 0, 3, 0), "IUI", 3, "Deduction Code", "", "", "N",
self.doDed, ced, None, ("notzero", )),
(("T", 0, 4, 0), "IUD", 6.2, "Interest Percentage", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 5,
0), "ID1", 10, "Start Date", "", "", "N", None, None, None,
("efld", )), (("T", 0, 6, 0), "IUD", 10.2, "Deduction Amount",
"", "", "N", None, None, None, ("efld", )))
tnd = ((self.doEnd, "n"), (self.doEnd, "y"))
txt = (self.doExit, self.doExit)
but = (("Accept", None, self.doAccept, 0, ("T", 0, 4), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 4),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
butt=but)
def doEmp(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("T", pag, p + 1, data=self.name)
def doLoan(self, frt, pag, r, c, p, i, w):
self.loan = w
self.rec = self.sql.getRec("waglmf",
where=[("wlm_cono", "=",
self.opts["conum"]),
("wlm_empno", "=", self.empno),
("wlm_loan", "=", self.loan)],
limit=1)
if not self.rec:
return "Invalid Loan Number"
wlc = self.sql.waglmf_col
self.df.loadEntry(frt,
pag,
p + 1,
data=self.rec[wlc.index("wlm_desc")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.rec[wlc.index("wlm_code")])
self.df.loadEntry(frt,
pag,
p + 3,
data=self.rec[wlc.index("wlm_rate")])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rec[wlc.index("wlm_start")])
self.df.loadEntry(frt,
pag,
p + 5,
data=self.rec[wlc.index("wlm_repay")])
def doDed(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 doEnd(self):
data = [self.opts["conum"]]
for p in range(0, len(self.df.t_work[0][0])):
if p == 1:
continue
data.append(self.df.t_work[0][0][p])
if data != self.rec[:len(data)]:
col = self.sql.waglmf_col
data.append(self.rec[col.index("wlm_xflag")])
self.sql.updRec("waglmf",
data=data,
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno),
("wlm_loan", "=", self.loan)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.rec):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"waglmf", "U",
"%03i%05i%02i" %
(self.opts["conum"], self.empno, self.loan),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.last[0] = [0, 0]
self.df.focusField("T", 0, 1)
def doExit(self):
if not self.df.pag:
self.doCloseProcess()
elif self.df.pag == 1:
self.df.focusField("T", 0, 2)
def doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class td1010(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,
["ctlnot", "telmst", "telgrp", "telcon"],
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.name = ""
return True
def mainProcess(self):
acc = self.sql.getRec("telmst", cols=["count(*)"], limit=1)
if acc[0] > 500:
autoc = False
else:
autoc = True
tdm = {
"stype":
"R",
"tables": ("telmst", ),
"cols": (("tdm_name", "TX", 30, "Name",
"Y"), ("tdm_telno", "TX", 20,
"Telephone"), ("tdm_mobile", "TX", 20, "Mobile"),
("tdm_email", "TX", 50,
"Email-Address"), ("tdm_group", "UA", 12, "Grp")),
"order":
"tdm_name",
"autoc":
autoc,
"sort":
"n"
}
grp = {
"stype": "S",
"tables": "telgrp",
"cols": ("tdg_group", "tdg_desc"),
"order": "tdg_desc"
}
self.fld = ((("T", 0, 0, 0), "I@tdm_name", 50, "", "", "", "Y",
self.doName, tdm, None, ("notblank", )),
(("T", 0, 1, 0), "I@tdm_adr1", 0, "", "", "", "N", None,
None, self.doDelAll,
("efld", )), (("T", 0, 2, 0), "I@tdm_adr2", 0, "", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, 3,
0), "I@tdm_adr3", 0, "", "", "", "N", None, None, None,
("efld", )), (("T", 0, 4, 0), "I@tdm_pcode", 0, "", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 5, 0), "I@tdm_telno", 0, "", "", "", "N", None,
None, None, ("efld", )), (("T", 0, 6, 0), "I@tdm_faxno",
0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 7, 0), "I@tdm_mobile", 0, "", "", "", "N", None,
None, None, ("efld", )), (("T", 0, 8, 0), "I@tdm_email",
0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 9, 0), "I@tdm_group", 0, "", "", "", "N",
self.doGroup, grp, None, ("efld", ), None,
"Comma separated groups which this contact belongs to."))
but = (
("Back",None,self.doUp,1,None,("T",0,1),"",1),
("Forward",None,self.doDn,1,None,("T",0,1),"",1),
("Import",None,self.doImport,1,("T",0,1),("T",0,2),
"Import Names, Addresses and Contact Details from "\
"Booking, Creditor, Debtor and Member Records, if "\
"Available",1),
("Notes",None,self.doNotes,1,("T",0,2),("T",0,1),"",1),
("Print",None,self.doPrint,1,None,None,"",1),
("Apply",None,self.doApply,0,("T",0,2),("T",0,1),"",1),
("Contacts",None,self.doContacts,0,("T",0,2),("T",0,1),"",2,2),
("Cancel",None,self.doCancel,0,("T",0,2),("T",0,1),"",2,2),
("Quit",None,self.doTopExit,1,None,None,"",2,2))
tnd = ((self.doTopEnd, "y"), )
txt = (self.doTopExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
def doClick(self, *opts):
if not self.name or opts[0][1] == 11:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
self.acc = self.sql.getRec("telmst",
where=[("tdm_name", "like", self.name + "%")
],
order="tdm_name asc",
limit=1)
if not self.acc:
self.newmst = True
self.con = 0
else:
self.newmst = False
self.df.setWidget(self.df.B0, "normal")
self.df.setWidget(self.df.B1, "normal")
self.doLoadDetail(self.acc[:-1])
def doGroup(self, frt, pag, r, c, p, i, w):
try:
grp = eval(w)
self.group = ""
for g in grp:
if not self.group:
self.group = g[0]
else:
self.group = "%s,%s" % (self.group, g[0])
except:
self.group = w
self.df.loadEntry(frt, pag, p, data=self.group)
if not self.group:
return
check = self.group.split(",")
err = None
for chk in check:
acc = self.sql.getRec("telgrp",
cols=["tdg_desc"],
where=[("tdg_group", "=", chk)],
limit=1)
if not acc:
err = "Invalid Group %s" % chk
break
return err
def doDelAll(self):
self.sql.delRec("telmst", where=[("tdm_name", "=", self.name)])
self.sql.delRec("telcon", where=[("tdc_name", "=", self.name)])
self.sql.delRec("ctlnot",
where=[("not_cono", "=", 0), ("not_sys", "=", "TEL"),
("not_key", "=", self.name)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doTopEnd(self):
data = self.df.t_work[0][0][:]
if self.newmst:
self.sql.insRec("telmst", data=data)
elif data != self.acc[:len(data)]:
tdm = self.sql.telmst_col
data.append(self.acc[tdm.index("tdm_xflag")])
self.sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", self.name)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doTopExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doUp(self):
acc = self.sql.getRec("telmst",
where=[("tdm_name", "<", self.name)],
order="tdm_name desc",
limit=1)
if acc:
self.doLoadDetail(acc)
self.df.focusField("T", 0, 2)
else:
showWarning(self.opts["mf"].body, "Beginning of File",
"This is the beginning of the file.")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doDn(self):
acc = self.sql.getRec("telmst",
where=[("tdm_name", ">", self.name)],
order="tdm_name asc",
limit=1)
if acc:
self.doLoadDetail(acc)
self.df.focusField("T", 0, 2, "N")
else:
showWarning(self.opts["mf"].body, "End of File",
"You have reached the end of the file.")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doContacts(self):
# Display contacts and allow adding, editing etc.
recs = self.sql.getRec("telcon",
cols=[
"tdc_contact", "tdc_desig", "tdc_telno",
"tdc_celno", "tdc_email"
],
where=[("tdc_name", "=", self.name)],
order="tdc_contact")
if not recs:
recs = [["", "", "", "", ""]]
titl = "Contacts"
cols = (("a", "Name", 30, "NA"), ("b", "Designation", 20,
"NA"), ("c", "Telephone", 20, "NA"),
("d", "Mobile", 20, "NA"), ("e", "Email-Address", 50, "TX"))
butt = (("Add", self.doConAdd), ("Exit", self.doConExit))
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select a Contact to Edit or an Action")
self.contyp = None
self.chg = SelectChoice(self.df.mstFrame,
titl=titl,
cols=cols,
data=recs,
butt=butt,
sort=False)
self.df.enableButtonsTags(state=state)
if not self.contyp and self.chg.selection:
self.contyp = "chg"
con = self.chg.selection[1].strip()
self.conchg = self.sql.getRec("telcon",
where=[("tdc_name", "=", self.name),
("tdc_contact", "=", con)],
limit=1)
if self.contyp in ("add", "chg"):
self.doConChanges()
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doConAdd(self):
self.contyp = "add"
def doConExit(self):
self.contyp = "quit"
def doConChanges(self):
fld = []
if self.contyp == "chg":
tit = ("Change Contact", )
but = (("Delete", None, self.doChgDelete, 1, None,
None), ("Apply", None, self.doChgEnd, 1, None, None),
("Quit", None, self.doChgExit, 1, None, None))
self.contact = self.conchg[1]
else:
tit = ("Add Contact", )
but = None
fld = ((("T", 0, 0, 0), "I@tdc_contact", 0, "", "", "", "N", None,
None, None, ("notblank", )),
(("T", 0, 1, 0), "I@tdc_desig", 0, "", "", "", "N", None, None,
None, ("efld", )), (("T", 0, 2, 0), "I@tdc_telno", 0, "", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 3, 0), "I@tdc_celno", 0, "", "", "", "N", None, None,
None, ("efld", )), (("T", 0, 4, 0), "I@tdc_email", 0, "", "",
"", "N", None, None, None, ("efld", )))
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.rp = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=((self.doChgEnd, "n"), ),
txit=(self.doChgExit, ))
if self.contyp == "chg":
for x in range(5):
self.rp.loadEntry("T", 0, x, data=self.conchg[x + 1])
self.rp.focusField("T", 0, 1, clr=False)
else:
self.rp.focusField("T", 0, 1)
self.rp.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doChgDelete(self):
self.sql.delRec("telcon",
where=[("tdc_name", "=", self.name),
("tdc_contact", "=", self.conchg[1])])
self.opts["mf"].dbm.commitDbase()
self.doChgExit()
def doChgEnd(self):
data = [self.name]
data.extend(self.rp.t_work[0][0])
if self.contyp == "add":
self.sql.insRec("telcon", data=data)
self.opts["mf"].dbm.commitDbase()
elif self.contyp == "chg" and data != self.conchg[:len(data)]:
tdc = self.sql.telcon_col
data.append(self.conchg[tdc.index("tdc_xflag")])
self.sql.updRec("telcon",
data=data,
where=[("tdc_name", "=", self.name),
("tdc_contact", "=", self.contact)])
self.opts["mf"].dbm.commitDbase()
self.doChgExit()
def doChgExit(self):
self.rp.closeProcess()
def doImport(self):
grps = []
commit = False
self.opts["mf"].updateStatus("")
self.df.mstFrame.focus_force()
self.df.mstFrame.winfo_toplevel().update()
self.df.setWidget(self.df.mstFrame, state="hide")
spl = SplashScreen(self.opts["mf"].body,
"Importing Contact Details\n\nPlease Wait")
sql = Sql(self.opts["mf"].dbm,
tables="ftable",
prog=self.__class__.__name__)
bkm = sql.getRec("ftable",
where=[("ft_tabl", "=", "bkmcon")],
cols=["count(*)"],
limit=1)
if bkm and bkm[0]:
commit = True
sql = Sql(self.opts["mf"].dbm,
tables="bkmcon",
prog=self.__class__.__name__)
bkc = sql.bkmcon_col
recs = sql.getRec("bkmcon")
for rec in recs:
if not rec[bkc.index("bkc_telno")] and not \
rec[bkc.index("bkc_faxno")] and not \
rec[bkc.index("bkc_celno")] and not \
rec[bkc.index("bkc_email")]:
continue
nam = rec[bkc.index("bkc_sname")]
fnm = rec[bkc.index("bkc_names")]
if fnm:
nam = "%s, %s" % (nam, fnm.split()[0])
data = [
nam, rec[bkc.index("bkc_addr1")],
rec[bkc.index("bkc_addr2")], rec[bkc.index("bkc_addr3")],
rec[bkc.index("bkc_pcode")], rec[bkc.index("bkc_telno")],
rec[bkc.index("bkc_faxno")], rec[bkc.index("bkc_celno")],
rec[bkc.index("bkc_email")], "BKM"
]
chk = self.sql.getRec("telmst",
where=[("tdm_name", "=", nam)],
limit=1)
if not chk:
self.sql.insRec("telmst", data=data)
elif data != chk[:len(data)]:
tdm = self.sql.telmst_col
data.append(chk[tdm.index("tdm_xflag")])
self.sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", nam)])
grps.append(["BKM", "Bookings"])
bwl = sql.getRec("ftable",
where=[("ft_tabl", "=", "bwltab")],
cols=["count(*)"],
limit=1)
if bwl and bwl[0]:
commit = True
sql = Sql(self.opts["mf"].dbm,
tables="bwltab",
prog=self.__class__.__name__)
btb = sql.bwltab_col
recs = sql.getRec("bwltab")
for rec in recs:
if not rec[btb.index("btb_home")] and not \
rec[btb.index("btb_work")] and not \
rec[btb.index("btb_cell")] and not \
rec[btb.index("btb_mail")]:
continue
nam = rec[btb.index("btb_surname")]
fnm = rec[btb.index("btb_names")]
if fnm:
nam = "%s, %s" % (nam, fnm.split()[0])
data = [
nam, rec[btb.index("btb_add1")],
rec[btb.index("btb_add2")], rec[btb.index("btb_add3")],
rec[btb.index("btb_pcod")], rec[btb.index("btb_home")],
rec[btb.index("btb_work")], rec[btb.index("btb_cell")],
rec[btb.index("btb_mail")], "BWL"
]
chk = self.sql.getRec("telmst",
where=[("tdm_name", "=", nam)],
limit=1)
if not chk:
self.sql.insRec("telmst", data=data)
elif data != chk[:len(data)]:
tdm = self.sql.telmst_col
data.append(chk[tdm.index("tdm_xflag")])
self.sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", nam)])
grps.append(["BWL", "Bowls"])
crs = sql.getRec("ftable",
where=[("ft_tabl", "=", "crsmst")],
cols=["count(*)"],
limit=1)
if crs and crs[0]:
commit = True
sql = Sql(self.opts["mf"].dbm,
tables="crsmst",
prog=self.__class__.__name__)
crm = sql.crsmst_col
recs = sql.getRec("crsmst", where=[("crm_stat", "<>", "X")])
for rec in recs:
nam = "%s" % rec[crm.index("crm_name")]
data = [
nam, rec[crm.index("crm_add1")],
rec[crm.index("crm_add2")], rec[crm.index("crm_add3")],
rec[crm.index("crm_pcod")], rec[crm.index("crm_tel")],
rec[crm.index("crm_fax")], "", "", "CRS"
]
chk = self.sql.getRec("telmst",
where=[("tdm_name", "=", nam)],
limit=1)
if not chk:
self.sql.insRec("telmst", data=data)
elif data != chk[:len(data)]:
tdm = self.sql.telmst_col
data.append(chk[tdm.index("tdm_xflag")])
self.sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", nam)])
con = rec[crm.index("crm_mgr")]
eml = rec[crm.index("crm_mgr_email")]
if eml:
data = [nam, con, "Manager", "", "", eml]
chk = self.sql.getRec("telcon",
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)],
limit=1)
if not chk:
self.sql.insRec("telcon", data=data)
elif data != chk[:len(data)]:
tdc = self.sql.telcon_col
data.append(chk[tdc.index("tdc_xflag")])
self.sql.updRec("telcon",
data=data,
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)])
con = rec[crm.index("crm_acc")]
eml = rec[crm.index("crm_acc_email")]
if eml:
data = [nam, con, "Accounts", "", "", eml]
chk = self.sql.getRec("telcon",
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)],
limit=1)
if not chk:
self.sql.insRec("telcon", data=data)
elif data != chk[:len(data)]:
tdc = self.sql.telcon_col
data.append(chk[tdc.index("tdc_xflag")])
self.sql.updRec("telcon",
data=data,
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)])
con = rec[crm.index("crm_ord")]
eml = rec[crm.index("crm_ord_email")]
if eml:
data = [nam, con, "Orders", "", "", eml]
chk = self.sql.getRec("telcon",
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)],
limit=1)
if not chk:
self.sql.insRec("telcon", data=data)
elif data != chk[:len(data)]:
tdc = self.sql.telcon_col
data.append(chk[tdc.index("tdc_xflag")])
self.sql.updRec("telcon",
data=data,
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)])
grps.append(["CRS", "Creditors"])
drs = sql.getRec("ftable",
where=[("ft_tabl", "=", "drsmst")],
cols=["count(*)"],
limit=1)
if drs and drs[0]:
commit = True
sql = Sql(self.opts["mf"].dbm,
tables="drsmst",
prog=self.__class__.__name__)
drm = sql.drsmst_col
recs = sql.getRec("drsmst", where=[("drm_stat", "<>", "X")])
for rec in recs:
nam = "%s" % rec[drm.index("drm_name")]
data = [
nam, rec[drm.index("drm_add1")],
rec[drm.index("drm_add2")], rec[drm.index("drm_add3")],
rec[drm.index("drm_pcod")], rec[drm.index("drm_tel")],
rec[drm.index("drm_fax")], "", "", "DRS"
]
chk = self.sql.getRec("telmst",
where=[("tdm_name", "=", nam)],
limit=1)
if not chk:
self.sql.insRec("telmst", data=data)
elif data != chk[:len(data)]:
tdm = self.sql.telmst_col
data.append(chk[tdm.index("tdm_xflag")])
self.sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", nam)])
con = rec[drm.index("drm_mgr")]
eml = rec[drm.index("drm_mgr_email")]
if eml:
data = [nam, con, "Manager", "", "", eml]
chk = self.sql.getRec("telcon",
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)],
limit=1)
if not chk:
self.sql.insRec("telcon", data=data)
elif data != chk[:len(data)]:
tdc = self.sql.telcon_col
data.append(chk[tdc.index("tdc_xflag")])
self.sql.updRec("telcon",
data=data,
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)])
con = rec[drm.index("drm_acc")]
eml = rec[drm.index("drm_acc_email")]
if eml:
data = [nam, con, "Accounts", "", "", eml]
chk = self.sql.getRec("telcon",
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)],
limit=1)
if not chk:
self.sql.insRec("telcon", data=data)
elif data != chk[:len(data)]:
tdc = self.sql.telcon_col
data.append(chk[tdc.index("tdc_xflag")])
self.sql.updRec("telcon",
data=data,
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)])
con = rec[drm.index("drm_sls")]
eml = rec[drm.index("drm_sls_email")]
if eml:
data = [nam, con, "Orders", "", "", eml]
chk = self.sql.getRec("telcon",
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)],
limit=1)
if not chk:
self.sql.insRec("telcon", data=data)
elif data != chk[:len(data)]:
tdc = self.sql.telcon_col
data.append(chk[tdc.index("tdc_xflag")])
self.sql.updRec("telcon",
data=data,
where=[("tdc_name", "=", nam),
("tdc_contact", "=", con)])
grps.append(["DRS", "Debtors"])
mem = sql.getRec("ftable",
where=[("ft_tabl", "=", "memmst")],
cols=["count(*)"],
limit=1)
if mem and mem[0]:
commit = True
sql = Sql(self.opts["mf"].dbm,
tables=["memmst", "memadd", "memkon"],
prog=self.__class__.__name__)
mlm = sql.memmst_col
mla = sql.memadd_col
recs = sql.getRec("memmst", where=[("mlm_state", "=", "A")])
for rec in recs:
coy = rec[mlm.index("mlm_cono")]
num = rec[mlm.index("mlm_memno")]
nam = "%s, %s" % (rec[mlm.index("mlm_surname")],
rec[mlm.index("mlm_names")])
add = sql.getRec("memadd",
where=[("mla_cono", "=", coy),
("mla_memno", "=", num),
("mla_type", "=", "P")],
limit=1)
if not add:
add = [coy, num, "P", "", "", "", "", "", "", ""]
add3 = add[mla.index("mla_add3")]
city = add[mla.index("mla_city")]
coun = add[mla.index("mla_country")]
if not add3:
if city:
add3 = city
if coun:
add3 = "%s, %s" % (add3, coun)
elif coun:
add3 = coun
kon = sql.getRec(tables=["memctk", "memkon"],
cols=["mck_type", "mlk_detail"],
where=[("mlk_cono", "=", coy),
("mlk_memno", "=", num),
("mck_code=mlk_code", )])
tel = ""
fax = ""
cel = ""
eml = ""
for k in kon:
if k[0] == "E" and not eml:
eml = k[1]
elif k[0] == "H":
tel = k[1]
elif k[0] == "W" and not tel:
tel = k[1]
elif k[0] == "M":
cel = k[1]
data = [
nam, add[mla.index("mla_add1")],
add[mla.index("mla_add2")], add3,
add[mla.index("mla_code")], tel, fax, cel, eml, "MEM"
]
chk = self.sql.getRec("telmst",
where=[("tdm_name", "=", nam)],
limit=1)
if not chk:
self.sql.insRec("telmst", data=data)
elif data != chk[:len(data)]:
tdm = self.sql.telmst_col
data.append(chk[tdm.index("tdm_xflag")])
self.sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", nam)])
grps.append(["MEM", "Members"])
# Others
tabs = {
"BKS": [
"Book Club", "bksown", None,
[
"bof_snam", "bof_fnam", "bof_add1", "bof_add2", "bof_add3",
"bof_pcod", "bof_home", "bof_work", "bof_cell", "bof_mail"
]
],
"LON": [
"Loan Ledger", "lonmf1", "lm1_cono",
[
"lm1_name", "lm1_addr1", "lm1_addr2", "lm1_addr3",
"lm1_pcode", "lm1_telno", "lm1_faxno", "lm1_celno",
"lm1_email"
]
],
"OWN": [
"Property Owners", "rcaowm", "rom_cono",
[
"rom_name", "rom_add1", "rom_add2", "rom_add3", "rom_pcod",
"rom_home", "rom_office", "rom_mobile", "rom_fax",
"rom_email"
]
],
"TNT": [
"Property Tenants", "rcatnm", "rtn_cono",
[
"rtn_name", "rtn_addr1", "rtn_addr2", "rtn_addr3",
"rtn_pcode", "rtn_telno", "rtn_email"
]
],
"RTL": [
"Rental Tenants", "rtlmst", "rtm_cono",
[
"rtm_name", "rtm_addr1", "rtm_addr2", "rtm_addr3",
"rtm_pcode", "rtm_telno", "rtm_email"
]
],
"SCP": [
"Sectional Competitions", "scpmem", "scm_cono",
["scm_surname", "scm_names", "scm_email", "scm_phone"]
],
"EMP": [
"Employees", "wagmst", "wgm_cono",
[
"wgm_sname", "wgm_fname", "wgm_addr1", "wgm_addr2",
"wgm_addr3", "wgm_pcode", "wgm_telno", "wgm_emadd"
]
]
}
for grp in tabs:
des = tabs[grp][0]
tab = tabs[grp][1]
coy = tabs[grp][2]
col = tabs[grp][3]
sql = Sql(self.opts["mf"].dbm, ["telmst", tab])
if sql.error:
continue
rec = sql.getRec(tab, cols=col)
for r in rec:
snam = None
data = ["", "", "", "", "", "", "", "", "", grp]
for n, c in enumerate(col):
x = c.split("_")[1]
if r[n]:
if x == "name":
data[0] = r[n]
elif x in ("snam", "surname", "sname"):
snam = r[n]
elif snam and x in ("fnam", "names", "fname"):
data[0] = "%s, %s" % (snam, r[n].split()[0])
snam = None
elif x in ("add1", "addr1"):
data[1] = r[n]
elif x in ("add2", "addr2"):
data[2] = r[n]
elif x in ("add3", "addr3"):
data[3] = r[n]
elif x in ("pcod", "pcode"):
data[4] = r[n]
elif x in ("home", "work", "office", "phone"):
data[5] = r[n]
elif x in ("faxno", "fax"):
data[6] = r[n]
elif x in ("cell", "celno", "mobile"):
data[7] = r[n]
elif x in ("mail", "email", "emadd"):
data[8] = r[n]
if not data[5] and not data[6] and not data[7] and not data[8]:
continue
chk = sql.getRec("telmst",
where=[("tdm_name", "=", data[0])],
limit=1)
if not chk:
sql.insRec("telmst", data=data)
elif data != chk[:len(data)]:
tdm = self.sql.telmst_col
data.append(chk[tdm.index("tdm_xflag")])
sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", data[0])])
grps.append([grp, des])
# Groups
for g in grps:
chk = self.sql.getRec("telgrp",
where=[("tdg_group", "=", g[0])],
limit=1)
if not chk:
self.sql.insRec("telgrp", data=g)
spl.closeSplash()
if commit:
self.opts["mf"].dbm.commitDbase(ask=True)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.window.update_idletasks()
self.df.focusField("T", 0, 1)
def doLoadDetail(self, data):
self.name = data[0]
for num, fld in enumerate(data[:-1]):
self.df.loadEntry(self.df.frt, self.df.pag, num, data=fld)
def doNotes(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
NotesCreate(self.opts["mf"], 0, "", self.opts["capnm"], "TEL",
self.name)
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 doPrint(self):
titl = "Select the Required Print Options"
cols = (("a", "C", 1, "UA", "N"), ("b", "Description", 30, "NA", "N"))
if self.df.last[0][0] != 1:
data = [("A", "Print Card")]
else:
data = []
data.extend([("B", "Print Directory"), ("C", "Print Contacts"),
("D", "Print Notes")])
ss = SelectChoice(self.df.mstFrame, titl, cols, data, sort=False)
self.opts["mf"].updateStatus("")
if not ss.selection:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
if ss.selection[1] == "A":
head = ["Card for %s" % self.name]
whr = [("tdm_name", "=", self.name)]
TabPrt(self.opts["mf"],
name=self.__class__.__name__,
tabs="telmst",
head=head,
where=whr)
elif ss.selection[1] == "D":
self.notes = NotesPrint(self.opts["mf"], 0, "", "TEL", loop=False)
if not self.notes.data:
pass
else:
data = []
p = ProgressBar(self.opts["mf"].body,
typ="Generating the Report",
mxs=len(self.notes.data),
esc=True)
for num, dat in enumerate(self.notes.data):
p.displayProgress(num)
if p.quit:
break
desc = textFormat(dat[5], width=50)
for n, d in enumerate(desc):
if not n:
data.append([
dat[2], dat[4],
CCD(dat[3], "d1", 10).disp, dat[6],
CCD(dat[7], "d1", 10).disp, d
])
else:
data.append(["", "", "", "", "", d])
p.closeProgress()
if not p.quit:
name = self.__class__.__name__
head = ["Telephone Directory Notes Listing"]
cols = [["a", "NA", 30, "Name", "y"],
["b", "NA", 20, "User-Name", "y"],
["c", "NA", 10, "Cap-Date", "y"],
["d", "UA", 1, "F", "y"],
["e", "NA", 10, "Act-Date", "y"],
["f", "NA", 50, "Details", "y"]]
RepPrt(self.opts["mf"],
name=name,
tables=data,
heads=head,
cols=cols,
ttype="D",
repprt=self.notes.df.repprt,
repeml=self.notes.df.repeml)
else:
tit = ["Telephone Directory"]
grp = {
"stype":
"R",
"tables": ("telgrp", ),
"cols": (("tdg_group", "UA", 3, "Grp"), ("tdg_desc", "NA", 30,
"Description")),
"order":
"tdg_desc"
}
fld = ((("T", 0, 0, 0), "IUA", 3, "Group", "", "", "N", self.prGrp,
grp, None, ("efld", )), )
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
tend=((self.prEnd, "y"), ),
txit=(self.prExit, ))
self.pr.mstFrame.wait_window()
if not self.prxit:
if self.prgrp:
if ss.selection[1] == "B":
head = ["Details for Group %s" % self.prgrp]
whr = [("tdm_group", "=", self.prgrp)]
else:
head = ["Contacts for Group %s" % self.prgrp]
whr = [("tdm_group", "=", self.prgrp),
("tdc_name=tdm_name", )]
else:
if ss.selection[1] == "B":
head = ["Cards for All Groups"]
whr = []
else:
head = ["Contacts for All Groups"]
whr = []
if ss.selection[1] == "B":
tab = ["telmst"]
col = [
"tdm_name", "tdm_telno", "tdm_faxno", "tdm_mobile",
"tdm_email"
]
else:
tab = ["telmst", "telcon"]
col = [
"tdm_name", "tdc_contact", "tdc_desig", "tdc_telno",
"tdc_celno", "tdc_email"
]
prtdia = (("Y", "V"), ("Y", "N"))
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
tables=tab,
heads=head,
cols=col,
where=whr,
order="tdm_name",
prtdia=prtdia)
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 prGrp(self, frt, pag, r, c, p, i, w):
self.prgrp = w
def prEnd(self):
self.prxit = False
self.pr.closeProcess()
def prExit(self):
self.prxit = True
self.pr.closeProcess()
def doApply(self):
data = self.df.t_work[0][0][:]
if self.df.frt == "T":
if self.newmst:
self.sql.insRec("telmst", data=data)
else:
data.append(self.acc[self.sql.telmst_col.index("tdm_xflag")])
self.sql.updRec("telmst",
data=data,
where=[("tdm_name", "=", self.name)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
class sl2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["genmst", "gentrn", "wagmst", "waglmf", "wagltf"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.col = self.sql.waglmf_col
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.glint = wagctl["ctw_glint"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["wag_slc", "wag_sli"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.glctls = (ctlctl["wag_slc"], ctlctl["wag_sli"])
else:
self.glctls = None
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"SLN",
5,
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
def dataHeader(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"),
("wgm_sname", "", 0, "Surname", "Y"), ("wgm_fname", "", 0,
"Names")),
"where": [("wgm_cono", "=", self.opts["conum"])]
}
lnm = {
"stype":
"R",
"tables": ("waglmf", ),
"cols": (("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0,
"Description", "Y")),
"where": [("wlm_cono", "=", self.opts["conum"])],
"whera": (("C", "wlm_empno", 0), ),
"index":
0
}
typ = {
"stype":
"C",
"titl":
"Transaction Types",
"head": ("C", "Description"),
"data": ((1, "Interest Adjustment"), (3, "Further Advance"),
(4, "Loan Repayment"), (5, "Loan Adjustment")),
"index":
0
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUI", 5, "EmpNo", "Employee Number", "", "N",
self.doEmp, wgm, None, None),
(("C", 1, 0, 1), "ONA", 10, "Name"),
(("C", 1, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N",
self.doLoan, lnm, None, ("notzero", )),
(("C", 1, 0, 3), "ONA", 10, "Descript", "Description", "", "N",
None, None, None, None),
(("C", 1, 0, 4), "ID1", 10, "Trans-Date", "Transaction Date",
self.sysdtw, "N", self.doTrdate, None, None, None),
(("C", 1, 0, 5), "IUI", 1, "T", "Transaction Type", "", "N",
self.doTyp, typ, None, ("in", (1, 3, 4, 5))),
(("C", 1, 0, 6), "INa", 9, "Reference", "Reference Number", "i",
"N", self.doRef, None, None, ("notblank", )),
(("C", 1, 0, 7), "IUD", 6.2, "Intr-%", "New Interest Rate", "",
"N", self.doPer, None, None, None),
(("C", 1, 0, 8), "ISD", 13.2, "Interest",
"Interest (Adds to interest raised)", "", "Y", self.doInt,
None, None, ("notzero", )),
(("C", 1, 0, 9), "ISD", 13.2, "Amount",
"Amount (Adds to advances or payments)", "", "Y", self.doPay,
None, None, ("notzero", )),
(("C", 1, 0, 10), "IUD", 9.2, "Deduct",
"Deduction Amount (New total deduction)", "", "Y", self.doDed,
None, None, ("efld", ))]
if self.glint == "Y":
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = [("Interrogate", None, self.querySln, 0, ("C", 1, 1), ("C", 1,
2))]
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.glint == "Y":
but.append(
("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1)))
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doEmp(self, frt, pag, r, c, p, i, w):
self.empno = w
acc = self.sql.getRec("wagmst",
cols=["wgm_sname"],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
chk = self.sql.getRec("waglmf",
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)])
if len(chk) == 1:
self.acc = chk[0]
self.loan = self.acc[self.col.index("wlm_loan")]
desc = self.acc[self.col.index("wlm_desc")]
self.df.loadEntry("C", pag, p + 2, data=self.loan)
self.df.loadEntry("C", pag, p + 3, data=desc)
return "sk3"
def doLoan(self, frt, pag, r, c, p, i, w):
self.loan = w
self.acc = self.sql.getRec("waglmf",
where=[("wlm_cono", "=",
self.opts["conum"]),
("wlm_empno", "=", self.empno),
("wlm_loan", "=", self.loan)],
limit=1)
if not self.acc:
return "Invalid Loan Number"
desc = self.acc[self.col.index("wlm_desc")]
self.df.loadEntry("C", pag, p + 1, data=desc)
def doTrdate(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trdate = w
def doTyp(self, frt, pag, r, c, p, i, w):
self.typ = w
def doRef(self, frt, pag, r, c, p, i, w):
self.ref = w
per = self.acc[self.col.index("wlm_rate")]
self.df.loadEntry("C", pag, p + 1, data=per)
def doPer(self, frt, pag, r, c, p, i, w):
self.per = w
if self.typ in (3, 4, 5):
self.intp = 0
return "sk1"
def doInt(self, frt, pag, r, c, p, i, w):
self.intp = w
self.pay = 0
self.ded = 0
return "sk2"
def doPay(self, frt, pag, r, c, p, i, w):
self.pay = w
amt = self.acc[self.col.index("wlm_repay")]
self.df.loadEntry("C", pag, p + 1, data=amt)
def doDed(self, frt, pag, r, c, p, i, w):
self.ded = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if not self.val:
self.df.advanceLine(1)
elif self.typ == 1 or self.glint == "N":
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.val)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trdate / 100)
else:
self.curdt = self.bh.curdt
if self.typ == 1:
self.glt = 4
desc = "Interest Adj"
self.val = self.intp
ded = self.acc[self.col.index("wlm_repay")]
cap = 0.00
elif self.typ == 3:
self.glt = 2
desc = "Advance"
self.val = self.pay
ded = self.ded
cap = self.val
elif self.typ == 4:
self.glt = 6
desc = "Repayment"
self.val = float(ASD(0) - ASD(self.pay))
ded = self.ded
cap = 0.00
elif self.typ == 5:
self.glt = 4
desc = "Adjustment"
self.val = self.pay
ded = self.ded
cap = 0.00
self.sql.updRec("waglmf",
cols=["wlm_rate", "wlm_repay"],
data=[self.per, ded],
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno),
("wlm_loan", "=", self.loan)])
self.sql.insRec("wagltf",
data=[
self.opts["conum"], self.empno, self.loan,
self.bh.batno, self.typ, self.trdate, self.ref,
self.val, cap, ded, self.per, self.curdt, desc,
"N", self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Staff Loans Control Account
data = (self.opts["conum"], self.glctls[0], self.curdt, self.trdate,
self.glt, self.ref, self.bh.batno, self.val, 0.00, self.name,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
self.val = float(ASD(0) - ASD(self.val))
if self.typ == 1:
# General Ledger Interest Received
data = (self.opts["conum"], self.glctls[1], self.curdt,
self.trdate, self.glt, self.ref, self.bh.batno, self.val,
0.00, "Staff Loan - %s" % self.name, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.val) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.val:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.val) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
# General Ledger Transaction (Source)
data = (self.opts["conum"], self.genacc, self.curdt, self.trdate,
self.glt, self.ref, self.bh.batno, self.allamt, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.val))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.val))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def querySln(self):
callModule(self.opts["mf"],
self.df,
"sl4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class ml3020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.ptyp, self.sperw, self.eperw, self.btyp, self.batch = \
self.opts["args"]
self.sperd = CCD(self.sperw, "d2", 7).disp
self.eperd = CCD(self.eperw, "d2", 7).disp
self.totsonly = "N"
self.whr = [("mlt_cono", "=", self.opts["conum"])]
if self.ptyp == "F":
self.whr.append(
("mlt_curdt", "between", self.sperw, self.eperw))
else:
self.whr.append(
("mlt_capdt", "between", self.sdatw, self.edatw))
if self.btyp:
self.whr.append(("mlt_type", "=", self.btyp))
self.whr.append(("mlt_batch", "=", self.batch))
self.processRecords()
else:
self.sper = int(self.opts["period"][1][0] / 100)
self.eper = int(self.opts["period"][2][0] / 100)
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, ["ctlmst", "memmst", "memtrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
memctl = gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.fromad = memctl["mcm_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdttm = "(Printed on: %i/%02i/%02i at %02i:%02i) %6s" % (
t[0], t[1], t[2], t[3], t[4], self.__class__.__name__)
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Member's Ledger Audit Trail (%s)" %
self.__class__.__name__)
self.colsh = [
"TP", "BatchNo", "Mem-No", "Name", "Reference", "Date", "Debits",
"Credits", "Tax-Amount", "T", "Remarks"
]
self.forms = [("UI", 2, False, False, True), ("Na", 7),
("UI", 6, False, False, True), ("NA", 30), ("Na", 9),
("D1", 10), ("SD", 13.2), ("SD", 13.2), ("SD", 13.2),
("UA", 1), ("NA", 30)]
self.gqt = [0] * (len(mltrtp) + 1)
self.gdr = [0] * (len(mltrtp) + 1)
self.gcr = [0] * (len(mltrtp) + 1)
self.gvt = [0] * (len(mltrtp) + 1)
self.totind = "N"
return True
def mainProcess(self):
data = ["All Types"]
for typ in mltrtp:
data.append(typ[1])
btt = {"stype": "C", "titl": "Valid Types", "data": data, "retn": "I"}
btm = {
"stype":
"R",
"tables": ("memtrn", ),
"cols": (("mlt_batch", "", 0,
"Bat-Num"), ("mlt_type", ("xx", mltrtp), 20, "Type"),
("mlt_curdt", "", 0, "Cur-Dat")),
"where": [],
"group":
"mlt_batch, mlt_type, mlt_curdt",
"order":
"mlt_type, mlt_curdt, mlt_batch"
}
r1s = (("Financial", "F"), ("Capture", "C"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Period Type", "", "F", "Y",
self.doPtyp, None, None, None),
(("T", 0, 1, 0), "Id2", 7, "Starting Period", "", self.sper,
"Y", self.doStartPer, None, None, ("efld", )),
(("T", 0, 2, 0), "Id2", 7, "Ending Period", "", self.eper, "Y",
self.doEndPer, None, None, ("efld", )),
(("T", 0, 3, 0), "Id1", 10, "Starting Date", "", self.sysdtw,
"Y", self.doStartDat, None, None, ("efld", )),
(("T", 0, 4, 0), "Id1", 10, "Ending Date", "", self.sysdtw, "Y",
self.doEndDat, None, None, ("efld", )),
(("T", 0, 5, 0), "IUI", 1, "Type", "Transaction Type", "", "Y",
self.doBatTyp, btt, None, None),
(("T", 0, 6, 0), "INa", 7, "Batch Number", "", "", "Y",
self.doBatNum, btm, None, None),
(("T", 0, 7, 0), ("IRB", r2s), 0, "Totals Only", "", "Y", "Y",
self.doTots, None, None, None)]
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "N"))
def doPtyp(self, frt, pag, r, c, p, i, w):
self.ptyp = w
if self.ptyp == "C":
return "sk2"
def doStartPer(self, frt, pag, r, c, p, i, w):
if not w:
w = self.sper
elif w < self.sper or w > self.eper:
return "Invalid Period"
self.sperw = w
self.df.loadEntry(frt, pag, p, data=self.sperw)
self.sperd = self.df.t_disp[pag][0][i]
def doEndPer(self, frt, pag, r, c, p, i, w):
if not w:
w = self.eper
elif w < self.sperw or w > self.eper:
return "Invalid Period"
self.eperw = w
self.df.loadEntry(frt, pag, p, self.eperw)
self.eperd = self.df.t_disp[pag][0][i]
return "sk2"
def doStartDat(self, frt, pag, r, c, p, i, w):
self.sdatw = w
self.df.loadEntry(frt, pag, p, data=self.sdatw)
self.sperd = self.df.t_disp[pag][0][i]
def doEndDat(self, frt, pag, r, c, p, i, w):
if w < self.sdatw:
return "Invalid Date"
self.edatw = w
self.df.loadEntry(frt, pag, p, self.edatw)
self.eperd = self.df.t_disp[pag][0][i]
def doBatTyp(self, frt, pag, r, c, p, i, w):
if w > len(mltrtp):
return "Invalid Batch Type"
self.btyp = w
self.whr = [("mlt_cono", "=", self.opts["conum"])]
if self.ptyp == "F":
self.whr.append(("mlt_curdt", "between", self.sperw, self.eperw))
else:
self.whr.append(("mlt_capdt", "between", self.sdatw, self.edatw))
if self.btyp:
self.whr.append(("mlt_type", "=", self.btyp))
self.df.topf[pag][i + 1][8]["where"] = self.whr
def doBatNum(self, frt, pag, r, c, p, i, w):
self.batch = w
if self.batch:
self.whr.append(("mlt_batch", "=", self.batch))
def doTots(self, frt, pag, r, c, p, i, w):
self.totsonly = w
if self.totsonly == "Y":
self.df.setWidget(self.df.topEntry[0][8][3][0], state="hide")
self.df.setWidget(self.df.topEntry[0][8][4][0], state="hide")
else:
self.df.setWidget(self.df.topEntry[0][8][3][0], state="show")
self.df.setWidget(self.df.topEntry[0][8][4][0], state="show")
def doEnd(self):
self.df.closeProcess()
self.processRecords()
self.closeProcess()
def processRecords(self):
if "args" in self.opts:
self.repprt = ["N", "V", "view"]
self.repeml = None
else:
self.repprt = self.df.repprt
self.repeml = self.df.repeml
jon = "left outer join memmst on mlt_cono=mlm_cono and "\
"mlt_memno=mlm_memno"
col = [
"mlt_memno", "mlt_trdt", "mlt_type", "mlt_refno", "mlt_batch",
"mlt_tramt", "mlt_taxamt", "mlt_desc", "mlt_taxind", "mlm_surname",
"mlm_names"
]
odr = "mlt_type, mlt_batch, mlt_trdt, mlt_refno"
recs = self.sql.getRec("memtrn",
join=jon,
cols=col,
where=self.whr,
order=odr)
if not recs:
showError(self.opts["mf"].body, "Transaction Error",
"No Transactions Selected")
elif self.repprt[2] == "export":
self.exportReport(recs)
else:
self.printReport(recs)
def exportReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
expnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"])
self.expheads = [
"%03u %-30s %s" %
(self.opts["conum"], self.opts["conam"], self.sysdttm)
]
self.expheads.append("Member's Ledger Audit Trail for Period "\
"%s to %s" % (self.sperd, self.eperd))
self.expcolsh = [self.colsh]
self.expforms = self.forms
self.expdatas = []
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
p.closeProgress()
return
vals = self.getValues(dat)
if not vals:
continue
memno, trdt, trtp, refno, batch, debit, credit, taxamt, \
detail, taxind, name = vals
line = [
"BODY",
[
trtp.work, batch.work, memno.work, name.work, refno.work,
trdt.work, debit.work, credit.work, taxamt.work,
taxind.work, detail.work
]
]
self.expdatas.append(line)
p.closeProgress()
self.grandTotal()
doWriteExport(xtype=self.repprt[1],
name=expnam,
heads=self.expheads,
colsh=self.expcolsh,
forms=self.expforms,
datas=self.expdatas,
rcdic=self.opts["mf"].rcdic)
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
if self.totsonly == "Y":
self.head = "%03u %-87s" % (self.opts["conum"], self.opts["conam"])
else:
self.head = "%03u %-133s" % (self.opts["conum"],
self.opts["conam"])
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
self.opts["conum"],
ext="pdf")
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.bqty = 0
self.bdrs = 0
self.bcrs = 0
self.bvat = 0
self.tqty = 0
self.tdrs = 0
self.tcrs = 0
self.tvat = 0
self.trtp = 0
self.pglin = 999
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
vals = self.getValues(dat)
if not vals:
continue
memno, trdt, trtp, refno, batch, debit, credit, taxamt, \
detail, taxind, name = vals
if not self.trtp:
self.trtp = trtp.work
self.batch = batch.work
if trtp.work != self.trtp:
self.batchTotal()
self.typeTotal()
self.trtp = trtp.work
self.batch = batch.work
self.pglin = 999
if batch.work != self.batch:
self.batchTotal()
self.batch = batch.work
if self.totsonly != "Y":
self.typeHeading()
if self.pglin > self.fpdf.lpp:
self.pageHeading()
if self.totsonly != "Y":
self.fpdf.drawText(
"%s %s %s %s %s %s %s %s %s" %
(memno.disp, name.disp, refno.disp, trdt.disp, debit.disp,
credit.disp, taxamt.disp, taxind.disp, detail.disp))
self.pglin += 1
# Batch Totals
self.bqty += 1
self.bdrs = float(ASD(self.bdrs) + ASD(debit.work))
self.bcrs = float(ASD(self.bcrs) + ASD(credit.work))
self.bvat = float(ASD(self.bvat) + ASD(taxamt.work))
# Type Totals
self.tqty += 1
self.tdrs = float(ASD(self.tdrs) + ASD(debit.work))
self.tcrs = float(ASD(self.tcrs) + ASD(credit.work))
self.tvat = float(ASD(self.tvat) + ASD(taxamt.work))
p.closeProgress()
if self.fpdf.page and not p.quit:
self.batchTotal()
self.typeTotal()
self.grandTotal()
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header=self.tit,
repprt=self.repprt,
fromad=self.fromad,
repeml=self.repeml)
def getValues(self, data):
memno = CCD(data[0], "UI", 6)
trdt = CCD(data[1], "D1", 10)
trtp = CCD(data[2], "UI", 2)
refno = CCD(data[3], "Na", 9)
batch = CCD(data[4], "Na", 7)
if data[5] < 0:
debit = CCD(0, "SD", 13.2)
credit = CCD(data[5], "SD", 13.2)
else:
debit = CCD(data[5], "SD", 13.2)
credit = CCD(0, "SD", 13.2)
taxamt = CCD(data[6], "SD", 13.2)
detail = CCD(data[7], "NA", 30)
taxind = CCD(data[8], "NA", 1)
name = CCD("%s, %s" % (data[9], data[10]), "NA", 30)
self.gqt[trtp.work - 1] += 1
self.gdr[trtp.work - 1] = float(ASD(self.gdr[trtp.work - 1]) + \
ASD(debit.work))
self.gcr[trtp.work - 1] = float(ASD(self.gcr[trtp.work - 1]) + \
ASD(credit.work))
self.gvt[trtp.work - 1] = float(ASD(self.gvt[trtp.work - 1]) + \
ASD(taxamt.work))
return (memno, trdt, trtp, refno, batch, debit, credit, taxamt, detail,
taxind, name)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("%-38s %-7s %-2s %-7s" %
("Member's Ledger Audit Trail for Period",
self.sperd, "to", self.eperd))
self.fpdf.drawText()
self.pglin = 4
if self.totind == "N":
self.typeHeading()
else:
self.fpdf.drawText("%-14s" % "Totals Summary")
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-27s%-8s %-13s %-13s %-13s %-13s" % \
("Document Type", "Quantity", " Debits",
" Credits", " Difference", " V.A.T."))
else:
self.fpdf.drawText("%-34s%-8s %-13s %-13s %-13s %-13s" % \
("Document Type", "Quantity", " Debits",
" Credits", " Difference", " V.A.T."))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def typeHeading(self):
if self.totsonly != "Y":
batch = self.batch
else:
batch = "Various"
if self.fpdf.lpp - self.pglin < 7:
self.pageHeading()
return
self.fpdf.setFont(style="B")
self.fpdf.drawText("%-7s %7s %-10s %3s" % \
("Batch", batch, " Type", mltrtp[self.trtp - 1][1]))
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText("%-36s %-13s %-13s %-13s %-13s" % \
("Details", " Debits", " Credits", " Difference",
" V.A.T."))
else:
self.fpdf.drawText("%-6s %-30s %-9s %-10s %-13s %-13s %-13s "\
"%-1s %-30s" % ("Mem-No", "Name", "Reference",
" Date", " Debits", " Credits", " Tax-Amount",
"T", "Remarks"))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def batchTotal(self):
j = CCD(self.bdrs, "SD", 13.2)
k = CCD(self.bcrs, "SD", 13.2)
l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 13.2)
m = CCD(self.bvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-36s %13s %13s %13s %13s" % \
("Batch " + self.batch + " Totals", j.disp,
k.disp, l.disp, m.disp))
self.pglin += 1
else:
self.fpdf.drawText()
self.fpdf.drawText("%-6s %-51s %13s %13s %13s" %
(" ", "Batch " + self.batch + " Totals", j.disp,
k.disp, m.disp))
self.fpdf.drawText()
self.pglin += 3
self.bqty = 0
self.bcrs = 0
self.bdrs = 0
self.bvat = 0
def typeTotal(self):
j = CCD(self.tdrs, "SD", 13.2)
k = CCD(self.tcrs, "SD", 13.2)
l = CCD(float(ASD(j.work) + ASD(k.work)), "SD", 13.2)
m = CCD(self.tvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText()
self.fpdf.drawText("%-36s %13s %13s %13s %13s" % \
("Type Totals", j.disp, k.disp, l.disp, m.disp))
self.pglin += 2
else:
self.fpdf.drawText("%-6s %-51s %13s %13s %13s" % \
(" ", "Type-Totals", j.disp, k.disp, m.disp))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
self.tqty = 0
self.tcrs = 0
self.tdrs = 0
self.tvat = 0
def grandTotal(self):
tot = [0, 0, 0, 0, 0]
if self.repprt[2] == "export":
for x in range(len(mltrtp)):
tot[0] = float(ASD(tot[0]) + ASD(self.gdr[x]))
tot[1] = float(ASD(tot[1]) + ASD(self.gcr[x]))
tot[2] = float(ASD(tot[2]) + ASD(self.gvt[x]))
self.expdatas.append(["ULINES"])
self.expdatas.append([
"TOTAL",
[
"", "", "", "", "Grand Totals", "", "", tot[0], tot[1],
tot[2], ""
]
])
self.expdatas.append(["ULINED"])
return
self.totind = "Y"
self.pageHeading()
for x, t in enumerate(mltrtp):
qt = CCD(self.gqt[x], "SI", 8)
dr = CCD(self.gdr[x], "SD", 13.2)
cr = CCD(self.gcr[x], "SD", 13.2)
df = float(ASD(dr.work) + ASD(cr.work))
df = CCD(df, "SD", 13.2)
vt = CCD(self.gvt[x], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-27s %s %s %s %s %s" % \
(t[1], qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
else:
self.fpdf.drawText("%-34s %s %s %s %s %s" % \
(t[1], qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
tot[0] = tot[0] + qt.work
tot[1] = float(ASD(tot[1]) + ASD(dr.work))
tot[2] = float(ASD(tot[2]) + ASD(cr.work))
tot[3] = float(ASD(tot[3]) + ASD(df.work))
tot[4] = float(ASD(tot[4]) + ASD(vt.work))
self.fpdf.drawText()
qt = CCD(tot[0], "SI", 8)
dr = CCD(tot[1], "SD", 13.2)
cr = CCD(tot[2], "SD", 13.2)
df = CCD(tot[3], "SD", 13.2)
vt = CCD(tot[4], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-27s %s %s %s %s %s" % \
("Grand Totals", qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
else:
self.fpdf.drawText("%-34s %s %s %s %s %s" % \
("Grand Totals", qt.disp, dr.disp, cr.disp, df.disp, vt.disp))
self.fpdf.drawText()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class dr2030(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, ["ctlmst", "ctlvrf", "ctlvtf",
"drsmst", "drstrn", "drsrcm", "drsrct", "genmst", "gentrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.fromad = drsctl["ctd_emadd"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"],ctlctl,["drs_ctl","vat_ctl"]):
return
self.drsctl = ctlctl["drs_ctl"]
self.vatctl = ctlctl["vat_ctl"]
ctl = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])], limit=1)
for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3",
"ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_tel",
"ctm_fax", "ctm_b_name", "ctm_b_branch", "ctm_b_ibt",
"ctm_b_acno", "ctm_logo"):
setattr(self, "%s" % col, ctl[self.sql.ctlmst_col.index(col)])
if "LETTERHEAD" in os.environ:
self.ctm_logo = os.environ["LETTERHEAD"]
if not self.ctm_logo or not os.path.exists(self.ctm_logo):
self.ctm_logo = None
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"], self.opts["conum"],
self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"],
multi="N", glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
def doProcess(self):
r1s = (
("Monthly","M"),
("Quarterly","3"),
("Bi-Annually","6"),
("Annually","Y"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Frequency","",
"M","N",self.doFreq,None,None,None),
(("T",0,1,0),("IRB",r2s),1,"All Charges","",
"N","N",self.doAll,None,None,None),
(("T",0,2,0),"INa",9,"2nd Reference","",
"","N",self.doRef2,None,None,None),
(("T",0,3,0),("IRB",r2s),1,"Invoices","",
"N","N",self.doInv,None,None,None))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], eflds=fld,
tend=tnd, txit=txt, view=("N","P"), mail=("N","Y"))
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
self.wher = [("dcm_cono", "=", self.opts["conum"]), ("dcm_freq", "=",
self.freq), ("dcm_last", "<", self.bh.curdt)]
data = self.sql.getRec("drsrcm", where=self.wher)
if not data:
return "No Valid Recurring Charges"
if self.freq == "M":
self.mths = 1
elif self.freq == "3":
self.mths = 3
elif self.freq == "6":
self.mths = 6
else:
self.mths = 12
def doAll(self, frt, pag, r, c, p, i, w):
self.allc = w
def doRef2(self, frt, pag, r, c, p, i, w):
self.ref2 = w
def doInv(self, frt, pag, r, c, p, i, w):
self.inv = w
if self.inv == "N":
self.df.loadEntry(frt, pag, p+2, data="")
return "nd"
def doEml(self, frt, pag, r, c, p, i, w):
self.eml = w
def doEnd(self):
self.df.closeProcess()
if self.allc == "N":
recs = getSingleRecords(self.opts["mf"], "drsrcm", ("dcm_num",
"dcm_desc"), where=self.wher)
else:
recs = self.sql.getRec("drsrcm", where=self.wher)
if recs:
if self.inv == "Y" and self.df.repeml[1] == "N":
self.fpdf = MyFpdf(orientation="L", fmat="A4",
name=self.__class__.__name__, head=128)
for dcm in recs:
num = dcm[self.sql.drsrcm_col.index("dcm_num")]
desc = dcm[self.sql.drsrcm_col.index("dcm_desc")]
day = dcm[self.sql.drsrcm_col.index("dcm_day")]
if day == 30:
self.trdt = mthendDate((self.bh.curdt * 100) + 1)
else:
self.trdt = (self.bh.curdt * 100) + day
vat = dcm[self.sql.drsrcm_col.index("dcm_vat")]
self.vatrte = getVatRate(self.sql, self.opts["conum"],
vat, self.trdt)
glac = dcm[self.sql.drsrcm_col.index("dcm_glac")]
nxt = self.sql.getRec("drstrn", cols=["max(drt_ref1)"],
where=[("drt_cono", "=", self.opts["conum"]), ("drt_ref1",
"like", "RC%03i%s" % (num, "%"))], limit=1)
if not nxt[0]:
nxt = 0
else:
nxt = int(nxt[0][5:])
tot_val = 0
tot_vat = 0
rec = self.sql.getRec("drsrct", where=[("dct_cono", "=",
self.opts["conum"]), ("dct_num", "=", num), ("dct_start",
"<=", self.bh.curdt), ("dct_end", ">=", self.bh.curdt)])
col = self.sql.drsrct_col
for dct in rec:
self.chain = dct[col.index("dct_chain")]
self.acno = dct[col.index("dct_acno")]
# Check for Redundancy
chk = self.sql.getRec("drsmst", cols=["drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain), ("drm_acno", "=",
self.acno)], limit=1)
if chk[0] == "X":
continue
# Check for Valid Period
charge = False
start = dct[col.index("dct_start")]
year = int(start / 100)
month = start % 100
while start <= self.bh.curdt:
if start == self.bh.curdt:
charge = True
break
month += self.mths
if month > 12:
year += 1
month -= 12
start = (year * 100) + month
if not charge:
continue
# Create Transactions
nxt += 1
self.ref = "RC%03i%04i" % (num, nxt)
self.detail = textFormat(dct[col.index("dct_detail")], 73)
self.amnt = dct[col.index("dct_amnt")]
self.vmnt = round(self.amnt * self.vatrte / 100, 2)
self.tmnt = float(ASD(self.amnt) + ASD(self.vmnt))
tot_val = float(ASD(tot_val) + ASD(self.amnt))
tot_vat = float(ASD(tot_vat) + ASD(self.vmnt))
# Debtors (drstrn)
self.sql.insRec("drstrn", data=[self.opts["conum"],
self.chain, self.acno, 1, self.ref, self.bh.batno,
self.trdt, self.ref2, self.tmnt, self.vmnt,
self.bh.curdt, self.detail[0], vat, "Y",
self.opts["capnm"], self.sysdtw, 0])
if self.inv == "Y":
# Create Invoice
self.doInvoice()
# VAT (ctlvtf)
amnt = float(ASD(0) - ASD(self.amnt))
vmnt = float(ASD(0) - ASD(self.vmnt))
data = [self.opts["conum"], vat, "O", self.bh.curdt,
"D", 1, self.bh.batno, self.ref, self.trdt, self.acno,
self.detail[0], amnt, vmnt, 0, self.opts["capnm"],
self.sysdtw, 0]
self.sql.insRec("ctlvtf", data=data)
if self.glint == "Y":
ref = "RC%07i" % num
# Update Debtors Control
amnt = float(ASD(tot_val) + ASD(tot_vat))
data = (self.opts["conum"], self.drsctl, self.bh.curdt,
self.trdt, 1, ref, self.bh.batno, amnt, 0, desc,
"", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# Update Sales Account
amnt = float(ASD(0) - ASD(tot_val))
data = (self.opts["conum"], glac, self.bh.curdt, self.trdt,
1, ref, self.bh.batno, amnt, 0, desc, "", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
amnt = float(ASD(0) - ASD(tot_vat))
if amnt:
# Update VAT Control
data = (self.opts["conum"], self.vatctl, self.bh.curdt,
self.trdt, 1, ref, self.bh.batno, amnt, 0, desc,
"", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# Update Recurring Charge (drsrcm)
self.sql.updRec("drsrcm", cols=["dcm_last"],
data=[self.bh.curdt], where=[("dcm_cono", "=",
self.opts["conum"]), ("dcm_num", "=", num), ("dcm_freq",
"=", self.freq)])
self.opts["mf"].dbm.commitDbase()
if self.inv == "Y" and self.df.repeml[1] == "N":
self.doPrint()
self.opts["mf"].closeLoop()
def doInvoice(self):
if self.df.repeml[1] == "Y":
self.fpdf = MyFpdf(orientation="L", fmat="A4",
name=self.__class__.__name__, head=128)
cw = self.fpdf.get_string_width("X")
ld = self.fpdf.font[2]
ica = CCD(self.tmnt, "SD", 13.2)
iva = CCD(float(ASD(self.tmnt) - ASD(self.amnt)), "SD", 13.2)
ivr = CCD(self.vatrte, "UD", 5.2)
self.drawInvoice(cw, ld)
row = 20
for detail in self.detail:
row += 1
self.fpdf.drawText(x=22.2*cw, y=row*ld, txt=detail)
self.fpdf.drawText(x=97*cw, y=row*ld, txt=ivr.disp)
self.fpdf.drawText(x=103*cw, y=row*ld, txt=ica.disp)
self.printTotals(cw, ld, ica, iva)
if self.df.repeml[1] == "Y":
self.doPrint()
def drawInvoice(self, cw, ld):
self.fpdf.add_page()
self.fpdf.setFont("courier", "B", 16)
self.fpdf.drawText(x=22*cw, y=1*ld, txt=self.ctm_name)
self.fpdf.setFont("courier", "B", 14)
self.fpdf.drawText(x=108*cw, y=2*ld, w=16, align="R", txt="Tax Invoice")
self.fpdf.setFont("courier", "B", self.fpdf.font[1])
if self.ctm_logo:
self.fpdf.image(self.ctm_logo, 45, 3, 138, 28)
else:
self.fpdf.drawText(x=22*cw, y=2.5*ld, txt=self.ctm_add1)
self.fpdf.drawText(x=22*cw, y=3.5*ld, txt=self.ctm_add2)
self.fpdf.drawText(x=22*cw, y=4.5*ld, txt=self.ctm_add3)
self.fpdf.drawText(x=22*cw, y=5.5*ld, txt=self.ctm_pcode)
self.fpdf.drawText(x=54*cw, y=2.5*ld,
txt="RegNo: %s" % self.ctm_regno)
self.fpdf.drawText(x=54*cw, y=3.5*ld,
txt="TaxNo: %s" % self.ctm_taxno)
self.fpdf.drawText(x=54*cw, y=4.5*ld,
txt="TelNo: %s" % self.ctm_tel)
self.fpdf.drawText(x=54*cw, y=5.5*ld,
txt="FaxNo: %s" % self.ctm_fax)
drm = self.sql.getRec("drsmst", where=[("drm_cono", "=",
self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno",
"=", self.acno)], limit=1)
col = self.sql.drsmst_col
self.fpdf.drawText(x=22.5*cw, y=10.5*ld, txt=drm[col.index("drm_name")])
self.fpdf.drawText(x=22.5*cw, y=11.5*ld, txt=drm[col.index("drm_add1")])
self.fpdf.drawText(x=22.5*cw, y=12.5*ld, txt=drm[col.index("drm_add2")])
self.fpdf.drawText(x=22.5*cw, y=13.5*ld, txt=drm[col.index("drm_add3")])
self.fpdf.drawText(x=22.5*cw, y=14.5*ld, txt=drm[col.index("drm_pcod")])
if self.ctm_b_name:
dat = "Name: %s" % self.ctm_b_name
dat = "%s\nBranch: %s" % (dat, self.ctm_b_branch)
dat = "%s\nCode: %s" % (dat, self.ctm_b_ibt)
dat = "%s\nAccount: %s\n " % (dat, self.ctm_b_acno)
self.fpdf.drawText(x=22.5*cw, y=37*ld, txt=dat, ctyp="M")
self.emadd = CCD(drm[col.index("drm_acc_email")], "TX")
# Tables
r1 = {
"margins": ((22.5, 53), (8, 9)),
"repeat": (1, 1),
"rows": [
[22, 8.5, [[32, 1.5, .8, "Charge To:", False]]],
[22, 10, [[32, 5.5]]],
[22, 16, [
[9, 1.5, .8, "Acc-Num", True],
[20, 1.5, .8, "V.A.T. Number", True],
[42, 1.5, .8, "Contact Person", True],
[12, 1.5, .8, "Date", True],
[11, 1.5, .8, "Inv-Number", True]]],
[22, 17.5, [
[9, 1.5, 0, self.acno, True],
[20, 1.5, 0, drm[col.index("drm_vatno")], True],
[42, 1.5, 0, drm[col.index("drm_sls")]],
[12, 1.5, 0, CCD(self.trdt, "D1", 10).disp, True],
[11, 1.5, 0, "%10s" % self.ref]]],
[22, 19, [
[74, 1.5, .8, "Description", False],
[7, 1.5, .8, " Tax-%", False],
[13, 1.5, .8, " Value", False]]],
[22, 20.5, [
[74, 12.5],
[7, 12.5],
[13, 12.5]]],
[22, 33, [
[11, 1.5, .8, "Taxable"],
[12, 1.5],
[12, 1.5, .8, "Non-Taxable"],
[12, 1.5],
[11, 1.5, .8, "Total Tax"],
[11, 1.5],
[12, 1.5, .8, "Total Value"],
[13, 1.5]]]]}
if self.ctm_b_name:
r1["rows"].extend([
[22, 35, [[32, 1.5, .8, "Banking Details", False]]],
[22, 36.5, [[32, 5.5]]]])
doDrawTable(self.fpdf, r1, cw=cw, ld=ld, font=False)
def printTotals(self, cw, ld, ica, iva):
tot = [0, 0, iva.work, ica.work]
if iva.work:
tot[0] = float(ASD(ica.work) - ASD(iva.work))
else:
tot[1] = ica.work
self.fpdf.drawText(x=32*cw, y=33.2*ld, txt=CCD(tot[0],"SD",13.2).disp)
self.fpdf.drawText(x=56*cw, y=33.2*ld, txt=CCD(tot[1],"SD",13.2).disp)
self.fpdf.drawText(x=78*cw, y=33.2*ld, txt=CCD(tot[2],"SD",13.2).disp)
self.fpdf.drawText(x=103*cw, y=33.2*ld, txt=CCD(tot[3],"SD",13.2).disp)
def doPrint(self):
if not self.fpdf.page:
return
if self.df.repeml[1] == "Y":
self.df.repeml[2] = self.emadd.work
key = "%s_%s_%s" % (self.opts["conum"], self.chain, self.acno)
else:
key = "%s_all_all" % self.opts["conum"]
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, key, ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam,
header="%s Invoice" % self.opts["conam"], repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rc1030(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, [
"ctlmst", "rcaprm", "rcaowm", "rcatnm", "rcacon", "rcatnt",
"chglog"
],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
own = {
"stype":
"R",
"tables": ("rcaowm", ),
"cols":
(("rom_acno", "", 0, "Acc-Num"), ("rom_name", "", 0, "Name", "Y")),
"where": [("rom_cono", "=", self.opts["conum"])]
}
prm = {
"stype":
"R",
"tables": ("rcaprm", ),
"cols": (("rcp_code", "", 0, "Prm-Code"), ("rcp_addr1", "", 0,
"Address-Line-1")),
"where": [("rcp_cono", "=", self.opts["conum"])],
"whera": (("T", "rcp_owner", 0, 0), )
}
acc = {
"stype":
"R",
"tables": ("rcatnm", ),
"cols":
(("rtn_acno", "", 0, "Acc-Num"), ("rtn_name", "", 0, "Name", "Y")),
"where": [("rtn_cono", "=", self.opts["conum"])],
"whera": (("T", "rtn_owner", 0, 0), ("T", "rtn_code", 1, 0))
}
typ = {
"stype": "C",
"titl": "Select the Required Type",
"head": ("C", "Type"),
"data": ((4, "Services (Owner)"), (5, "Services (Agency)"))
}
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "A"))
self.fld = ((("T", 0, 0, 0), "INA", 7, "Owners Code", "", "", "Y",
self.doOwner, own, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 7, "Premises Code", "", "", "Y",
self.doPremises, prm, None, ("notblank", )),
(("T", 0, 2, 0), "INA", 7, "Account Code", "", "", "N",
self.doAccount, acc, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Tenant Name", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 4, 0), "INA", 30, "Address Line 1", "", "", "N",
self.doAddr, None, None,
("efld", )), (("T", 0, 5, 0), "INA", 30, "Address Line 2",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 6, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 7, 0), "INA", 4, "Postal Code", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 8, 0), "INA", 20, "Telephone Number", "", "",
"N", None, None, None,
("efld", )), (("T", 0, 9, 0), "ITX", 50, "E-Mail Address",
"", "", "N", None, None, None, ("email", )),
(("T", 0, 10, 0), "INA", 10, "VAT Number", "", "", "N",
self.doVatNum, None, None, ("efld", )),
(("T", 0, 11, 0), ("IRB", r1s), 0, "Payment Frequency", "",
"M", "N", None, None, None,
None), (("T", 0, 12, 0), "ID1", 10, "Start Date", "", "",
"N", None, None, None, ("notzero", )),
(("T", 0, 13, 0), "IUI", 3, "Number of Periods", "Periods",
"", "N", None, None, None, ("notzero", )),
(("T", 0, 14, 0), "IUD", 12.2, "Rental Amount", "",
"", "N", None, None, None,
("notzero", )), (("T", 0, 15, 0), "IUD", 12.2,
"Deposit Amount", "", "", "N", None,
None, None, ("efld", )),
(("T", 0, 16, 0), "IUD", 12.2, "Basic Water Amount", "",
"", "N", self.doBWater, None, None,
("efld", )), (("T", 0, 16, 0), "IUI", 1, "Type", "", "",
"N", None, typ, None, ("efld", )),
(("T", 0, 17, 0), "IUD", 12.2, "Basic Exlectricity Amount",
"", "", "N", self.doBElec, None, None,
("efld", )), (("T", 0, 17, 0), "IUI", 1, "Type", "", "",
"N", self.doEType, typ, None,
("efld", )), (("T", 0, 18, 0), "IUA", 1,
"Status", "", "", "N", None,
None, None, ("in", ("C",
"X"))))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doOwner(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rcaowm",
cols=["rom_name"],
where=[("rom_cono", "=", self.opts["conum"]),
("rom_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Owner"
self.owner = w
def doPremises(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rcaprm",
cols=["rcp_desc"],
where=[("rcp_cono", "=", self.opts["conum"]),
("rcp_owner", "=", self.owner),
("rcp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Premises"
self.code = w
def doAccount(self, frt, pag, r, c, p, i, w):
self.acno = w
self.oldm = self.sql.getRec("rcatnm",
where=[("rtn_cono", "=",
self.opts["conum"]),
("rtn_owner", "=", self.owner),
("rtn_code", "=", self.code),
("rtn_acno", "=", self.acno)],
limit=1)
if not self.oldm:
self.new = "y"
for num in range(4, self.df.topq[0]):
self.df.clearEntry(frt, pag, num + 1)
con = self.sql.getRec("rcacon",
cols=["count(*)"],
where=[("rcc_cono", "=", self.opts["conum"]),
("rcc_owner", "=", self.owner),
("rcc_code", "=", self.code),
("rcc_acno", "=", self.acno)],
limit=1)
if not con[0]:
self.cnum = 1
else:
self.cnum = con[0] + 1
else:
self.new = "n"
for num, fld in enumerate(self.oldm[3:]):
self.df.loadEntry(frt, pag, p + num, data=fld)
oldc = 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")
self.oldc = oldc[-1:][0]
self.cnum = self.oldc[4]
for num, fld in enumerate(self.oldc[5:-1]):
self.df.loadEntry(frt, pag, num + 11, data=fld)
trn = self.sql.getRec("rcatnt",
cols=["count(*)"],
where=[("rtu_cono", "=", self.opts["conum"]),
("rtu_owner", "=", self.owner),
("rtu_code", "=", self.code),
("rtu_acno", "=", self.acno)],
limit=1)
if trn[0]:
self.trn = True
else:
self.trn = False
def doAddr(self, frt, pag, r, c, p, i, w):
if not w:
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data="")
self.df.loadEntry(frt, pag, p + 3, data="")
return "sk3"
def doVatNum(self, frt, pag, r, c, p, i, w):
if self.new == "n" and self.trn:
return "sk1"
def doBWater(self, frt, pag, r, c, p, i, w):
if not w:
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doBElec(self, frt, pag, r, c, p, i, w):
if not w:
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEType(self, frt, pag, r, c, p, i, w):
if self.new == "y":
self.df.loadEntry(frt, pag, p + 1, data="C")
def doDelete(self):
if self.trn:
return "Transactions Exist, Not Deleted"
self.sql.delRec("rcatnm",
where=[("rtn_cono", "=", self.opts["conum"]),
("rtn_owner", "=", self.owner),
("rtn_code", "=", self.code),
("rtn_acno", "=", self.acno)])
self.sql.delRec("rcacon",
where=[("rcc_cono", "=", self.opts["conum"]),
("rcc_owner", "=", self.owner),
("rcc_code", "=", self.code),
("rcc_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["rcatnm", "D", "%03i%-7s" % \
(self.opts["conum"], self.code), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
datm = [self.opts["conum"]]
datc = [
self.opts["conum"], self.owner, self.code, self.acno, self.cnum
]
for num, fld in enumerate(self.df.t_work[0][0]):
if num < 11:
datm.append(fld)
if num > 10:
datc.append(fld)
if self.new == "y":
self.sql.insRec("rcatnm", data=datm)
self.sql.insRec("rcacon", data=datc)
else:
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
if datm != self.oldm[:len(datm)]:
col = self.sql.rcatnm_col
datm.append(self.oldm[col.index("rtn_xflag")])
self.sql.updRec("rcatnm",
data=datm,
where=[("rtn_cono", "=", self.opts["conum"]),
("rtn_owner", "=", self.owner),
("rtn_code", "=", self.code),
("rtn_acno", "=", self.acno)])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec(
"chglog",
data=[
"rcatnm", "U",
"%03i%-7s%-7s" %
(self.opts["conum"], self.owner, self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(datm[num]), "", 0
])
if datc != self.oldc[:len(datc)]:
col = self.sql.rcacon_col
datc.append(self.oldc[col.index("rcc_xflag")])
self.sql.updRec("rcacon",
data=datc,
where=[("rcc_cono", "=", self.opts["conum"]),
("rcc_owner", "=", self.owner),
("rcc_code", "=", self.code),
("rcc_acno", "=", self.acno),
("rcc_cnum", "=", self.cnum)])
for num, dat in enumerate(self.oldc):
if dat != datc[num]:
self.sql.insRec("chglog",
data=[
"rcacon", "U",
"%03i%-7s%-7s%-7s%03i" %
(self.opts["conum"], self.owner,
self.code, self.acno, self.cnum),
col[num], dte, self.opts["capnm"],
str(dat),
str(datc[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class gl1040(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.buildScreen()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["gendtm", "gendtt"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.sper = int(self.opts["period"][1][0] / 100)
self.eper = int(self.opts["period"][2][0] / 100)
return True
def buildScreen(self):
cod_sel = {
"stype":
"R",
"tables": ("gendtm", ),
"cols": (("gdm_code", "", 0, "Cod"), ("gdm_desc", "", 0,
"Description", "Y")),
"where": [("gdm_cono", "=", self.opts["conum"])]
}
per_sel = {
"stype":
"R",
"tables": ("gendtt", ),
"cols":
(("gdt_curdt", "", 0, "Period"), ("gdt_value", "", 0, "Value")),
"where": [("gdt_cono", "=", self.opts["conum"]),
("gdt_curdt", "between", self.sper, self.eper)],
"whera": (("T", "gdt_code", 0), )
}
fld = ((("T", 0, 0, 0, 4), "INa", 2, "Code", "", "", "Y", self.doCode,
cod_sel, None, ("notblank", )),
(("T", 0, 0, 0), "INA", 30, "Description", "", "", "N",
self.doDesc, None, self.doDelCode, ("notblank", )),
(("C", 0, 0, 0), "ID2", 7, "Period", "Financial Period", "p",
"N", self.doPeriod, per_sel, None,
None), (("C", 0, 0, 1), "ISD", 13.2, "Value", "Period Value",
"", "N", self.doValue, None, self.doDelPeriod, None))
row = (17, )
but = (("Cancel", None, self.doCancel, 0, ("C", 0, 1), ("T", 0, 1)),
("Quit", None, self.exitTops, 1, None, None))
txt = (self.exitTops, )
tnd = ((self.endTops, "y"), )
cnd = ((self.endData, "y"), )
cxt = (self.exitData, )
self.df = TartanDialog(self.opts["mf"],
sc=None,
eflds=fld,
rows=row,
butt=but,
tend=tnd,
cend=cnd,
txit=txt,
cxit=cxt)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.oldm = self.sql.getRec("gendtm",
where=[("gdm_cono", "=",
self.opts["conum"]),
("gdm_code", "=", self.code)],
limit=1)
if not self.oldm:
self.newcod = True
else:
self.newcod = False
desc = self.oldm[self.sql.gendtm_col.index("gdm_desc")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
self.loadPeriods(focus=False)
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doDelCode(self):
self.sql.delRec("gendtm",
where=[("gdm_cono", "=", self.opts["conum"]),
("gdm_code", "=", self.code)])
self.sql.delRec("gendtt",
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code)])
self.exitData()
def endTops(self):
data = [self.opts["conum"], self.code, self.desc]
if self.newcod:
self.sql.insRec("gendtm", data=data)
self.df.focusField("C", 0, 1)
else:
if data != self.oldm[:len(data)]:
col = self.sql.gendtm_col
data.append(self.oldm[col.index("gdm_xflag")])
self.sql.updRec("gendtm",
data=data,
where=[("gdm_cono", "=", self.opts["conum"]),
("gdm_code", "=", self.code)])
self.df.focusField("C", 0, self.col)
def doPeriod(self, frt, pag, r, c, p, i, w):
if w < self.sper or w > self.eper:
return "Invalid Period"
self.per = w
self.oldt = self.sql.getRec("gendtt",
where=[("gdt_cono", "=",
self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "=", self.per)],
limit=1)
if not self.oldt:
self.newper = "y"
else:
self.newper = "n"
val = self.oldt[self.sql.gendtt_col.index("gdt_value")]
self.df.loadEntry(frt, pag, p + 1, data=val)
def doDelPeriod(self):
if self.newper == "y":
return
self.sql.delRec("gendtt",
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "=", self.per)])
self.loadPeriods()
def doValue(self, frt, pag, r, c, p, i, w):
self.val = w
def endData(self):
data = [self.opts["conum"], self.code, self.per, self.val]
if self.newper == "y":
self.sql.insRec("gendtt", data=data)
elif data != self.oldt[:len(data)]:
col = self.sql.gendtt_col
data.append(self.oldt[col.index("gdt_xflag")])
self.sql.updRec("gendtt",
data=data,
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "=", self.per)])
self.loadPeriods()
def loadPeriods(self, focus=True):
self.df.clearFrame("C", 0)
pers = self.sql.getRec("gendtt",
cols=["gdt_curdt", "gdt_value"],
where=[("gdt_cono", "=", self.opts["conum"]),
("gdt_code", "=", self.code),
("gdt_curdt", "between", self.sper,
self.eper)])
if pers:
for num, per in enumerate(pers):
p = (num * 2)
self.df.loadEntry("C", 0, p, data=per[0])
self.df.loadEntry("C", 0, p + 1, data=per[1])
self.col = p + 3
else:
self.col = 1
if focus:
self.df.focusField("C", 0, self.col)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def exitTops(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
class rc3020(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, ["rcatnt", "rcatnm"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rcactl = gc.getCtl("rcactl", self.opts["conum"])
if not rcactl:
return
self.fromad = rcactl["cte_emadd"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.curdt = int(self.sysdtw / 100)
self.totind = "N"
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Rental Tenants Audit Trail (%s)" % self.__class__.__name__)
data = ["All Types"]
for typ in rttrtp:
data.append(typ[1])
btt = {
"stype": "C",
"titl": "Valid Types",
"data": data,
"retn": "I"}
btm = {
"stype": "R",
"tables": ("rcatnt",),
"cols": (
("rtu_batch", "", 0, "Bat-Num"),
("rtu_type", ("xx", rttrtp), 20, "Type"),
("rtu_curdt", "", 0, "Cur-Dat")),
"where": [],
"group": "rtu_batch, rtu_type, rtu_curdt",
"order": "rtu_type, rtu_curdt, rtu_batch"}
r1s = (("Financial","F"),("Capture","C"))
r2s = (("Yes","Y"),("No","N"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Period Type","",
"F","Y",self.doPtyp,None,None,None),
(("T",0,1,0),"Id2",7,"Starting Period","",
self.curdt,"Y",self.doStartPer,None,None,("efld",)),
(("T",0,2,0),"Id2",7,"Ending Period","",
self.curdt,"Y",self.doEndPer,None,None,("efld",)),
(("T",0,3,0),"Id1",10,"Starting Date","",
self.sysdtw,"Y",self.doStartDat,None,None,("efld",)),
(("T",0,4,0),"Id1",10,"Ending Date","",
self.sysdtw,"Y",self.doEndDat,None,None,("efld",)),
(("T",0,5,0),"IUI",1,"Type","Transaction Type",
"","Y",self.doBatTyp,btt,None,None),
(("T",0,6,0),"INa",7,"Batch Number","",
"","Y",self.doBatNum,btm,None,None),
(("T",0,7,0),("IRB",r2s),0,"Totals Only","",
"Y","Y",self.doTots,None,None,None))
tnd = ((self.doEnd,"Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld,
tend=tnd, txit=txt, view=("N","V"), mail=("Y","N"))
def doPtyp(self, frt, pag, r, c, p, i, w):
self.ptyp = w
if self.ptyp == "C":
return "sk2"
def doStartPer(self, frt, pag, r, c, p, i, w):
if w > self.curdt:
return "Invalid Period, After To-Day"
else:
self.sperw = w
self.df.loadEntry(frt, pag, p, data=self.sperw)
self.sperd = self.df.t_disp[pag][0][i]
self.df.topf[pag][i+1][5] = self.sperw
def doEndPer(self, frt, pag, r, c, p, i, w):
if not w:
self.eperw = self.sperw
elif w < self.sperw:
return "Invalid Period, Before Start"
else:
self.eperw = w
self.df.loadEntry(frt, pag, p, self.eperw)
self.eperd = self.df.t_disp[pag][0][i]
return "sk2"
def doStartDat(self, frt, pag, r, c, p, i, w):
if w > self.sysdtw:
return "Invalid Date, After To-Day"
else:
self.sdatw = w
self.df.topf[pag][i+1][5] = self.sdatw
self.sperd = self.df.t_disp[pag][0][i]
def doEndDat(self, frt, pag, r, c, p, i, w):
if w == 0:
self.edatw = self.sdatw
elif w < self.sdatw:
return "Invalid Date, Before Start"
else:
self.edatw = w
self.df.loadEntry(frt, pag, p, self.edatw)
self.eperd = self.df.t_disp[pag][0][i]
def doBatTyp(self, frt, pag, r, c, p, i, w):
if w > len(rttrtp):
return "Invalid Batch Type"
self.btyp = w
self.whr = [("rtu_cono", "=", self.opts["conum"])]
if self.ptyp == "F":
self.whr.append(("rtu_curdt", "between", self.sperw, self.eperw))
else:
self.whr.append(("rtu_capdt", "between", self.sdatw, self.edatw))
if self.btyp:
self.whr.append(("rtu_type", "=", w))
self.df.topf[pag][i+1][8]["where"] = self.whr
def doBatNum(self, frt, pag, r, c, p, i, w):
self.batch = w
def doTots(self, frt, pag, r, c, p, i, w):
self.totsonly = w
def doEnd(self):
self.df.closeProcess()
jon = "left outer join rcatnm on rtu_cono=rtn_cono and "\
"rtu_owner=rtn_owner and rtu_code=rtn_code and rtu_acno=rtn_acno"
self.col = ["rtu_owner", "rtu_code", "rtu_acno", "rtu_type",
"rtu_batch", "rtu_refno", "rtu_trdt", "rtu_desc", "rtu_mtyp",
"rtu_tramt", "rtu_taxamt", "rtu_taxind", "rtn_name"]
odr = "rtu_type, rtu_batch, rtu_trdt, rtu_refno"
recs = self.sql.getRec("rcatnt", join=jon, cols=self.col,
where=self.whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Transaction Error",
"No Transactions Selected")
else:
self.printReport(recs)
self.closeProcess()
def printReport(self, recs):
p = ProgressBar(self.opts["mf"].body, mxs=len(recs), esc=True)
if self.totsonly == "Y":
self.head = "%03u %-71s" % (self.opts["conum"], self.opts["conam"])
else:
self.head = "%03u %-136s" % (self.opts["conum"], self.opts["conam"])
self.fpdf = MyFpdf(name=self.__class__.__name__, head=self.head)
self.bqty = 0
self.bamt = 0
self.bdis = 0
self.bvat = 0
self.tqty = 0
self.tamt = 0
self.tdis = 0
self.tvat = 0
self.gqt = [0] * (len(rttrtp) + 1)
self.gam = [0] * (len(rttrtp) + 1)
self.gvt = [0] * (len(rttrtp) + 1)
self.trtp = 0
self.pglin = 999
for num, dat in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
owner = CCD(dat[self.col.index("rtu_owner")], "NA", 7)
code = CCD(dat[self.col.index("rtu_code")], "NA", 7)
acno = CCD(dat[self.col.index("rtu_acno")], "NA", 7)
name = CCD(dat[self.col.index("rtn_name")], "NA", 30)
trtp = CCD(dat[self.col.index("rtu_type")], "UI", 2)
batch = CCD(dat[self.col.index("rtu_batch")], "Na", 7)
refno = CCD(dat[self.col.index("rtu_refno")], "Na", 9)
trdt = CCD(dat[self.col.index("rtu_trdt")], "D1", 10)
desc = CCD(dat[self.col.index("rtu_desc")], "NA", 30)
mtyp = CCD(dat[self.col.index("rtu_mtyp")], "UI", 1)
tramt = CCD(dat[self.col.index("rtu_tramt")], "SD", 13.2)
taxamt = CCD(dat[self.col.index("rtu_taxamt")], "SD", 13.2)
taxind = CCD(dat[self.col.index("rtu_taxind")], "NA", 1)
if not self.trtp:
self.trtp = trtp.work
self.batch = batch.work
if trtp.work != self.trtp:
self.batchTotal()
self.typeTotal()
self.trtp = trtp.work
self.batch = batch.work
self.pglin = 999
if batch.work != self.batch:
self.batchTotal()
self.batch = batch.work
if self.totsonly != "Y":
self.typeHeading()
if self.pglin > self.fpdf.lpp:
self.pageHeading()
if self.totsonly != "Y":
self.fpdf.drawText("%s %s %s %s %s %s %s %s %s %s %s" % \
(owner.disp, code.disp, acno.disp, refno.disp, trdt.disp,
desc.disp, rcmvtp[mtyp.work-1][0], tramt.disp, taxamt.disp,
taxind.disp, name.disp))
self.pglin += 1
self.bqty = self.bqty + 1
self.bamt = float(ASD(self.bamt) + ASD(tramt.work))
self.bvat = float(ASD(self.bvat) + ASD(taxamt.work))
self.tqty = self.tqty + 1
self.tamt = float(ASD(self.tamt) + ASD(tramt.work))
self.tvat = float(ASD(self.tvat) + ASD(taxamt.work))
self.gqt[trtp.work - 1] = self.gqt[trtp.work - 1] + 1
self.gam[trtp.work - 1] = float(ASD(self.gam[trtp.work - 1]) + \
ASD(tramt.work))
self.gvt[trtp.work - 1] = float(ASD(self.gvt[trtp.work - 1]) + \
ASD(taxamt.work))
p.closeProgress()
if self.fpdf.page and not p.quit:
self.batchTotal()
self.typeTotal()
self.grandTotal()
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.tit, repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
def pageHeading(self):
self.fpdf.add_page()
self.fpdf.setFont(style="B")
self.fpdf.drawText(self.head)
self.fpdf.drawText()
self.fpdf.drawText("Rental Tenants Audit Trail for Period "\
"%s to %s" % (self.sperd, self.eperd))
self.fpdf.drawText()
self.pglin = 4
if self.totind == "N":
self.typeHeading()
else:
self.fpdf.drawText("%-14s" % "Totals Summary")
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText(
"%-39s%-8s %-13s %-13s" % ("Document Type", "Quantity",
" Amount", " V.A.T."))
else:
self.fpdf.drawText(
"%-26s%-8s %-13s %-13s" % ("Document Type", "Quantity ",
" Amount", " V.A.T."))
self.fpdf.underLine(txt=self.head)
self.fpdf.setFont()
self.pglin += 4
def typeHeading(self):
if self.totsonly == "N":
batch = self.batch
else:
batch = "Various"
if self.fpdf.lpp - self.pglin < 7:
self.pageHeading()
return
self.fpdf.setFont(style="B")
self.fpdf.drawText("%-7s %7s %-10s %3s" % \
("Batch", batch, " Type", rttrtp[self.trtp - 1][1]))
self.fpdf.drawText()
if self.totsonly == "Y":
self.fpdf.drawText(
"%-48s %-13s %-13s" % \
("Details", " Amount", " Tax-Amount"))
else:
self.fpdf.drawText(
"%-7s %-7s %-7s %-9s %-10s %-30s %-3s %-13s %-13s %-1s "\
"%-30s" % ("Own-Cod", "Prm-Cod", "Acc-Num", "Reference",
" Date", "Remarks", "Mtp", " Amount", " Tax-Amount",
"I", "Tenant"))
self.fpdf.underLine(txt=self.head)
self.pglin += 4
self.fpdf.setFont()
def batchTotal(self):
j = CCD(self.bamt, "SD", 13.2)
k = CCD(self.bvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-48s %13s %13s" % \
("Batch " + self.batch + " Totals", j.disp, k.disp))
else:
self.fpdf.drawText()
self.pglin += 1
self.fpdf.drawText("%-44s %-34s %13s %13s" % (" ",
"Batch " + self.batch + " Totals", j.disp, k.disp))
self.pglin += 1
if self.totsonly != "Y":
self.fpdf.drawText()
self.pglin += 1
self.bqty = 0
self.bamt = 0
self.bdis = 0
self.bvat = 0
def typeTotal(self):
j = CCD(self.tamt, "SD", 13.2)
k = CCD(self.tvat, "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText()
self.fpdf.drawText("%-48s %13s %13s" % \
("Type Totals", j.disp, k.disp))
self.pglin += 2
else:
self.fpdf.drawText("%-44s %-34s %13s %13s" % \
(" ", "Type-Totals", j.disp, k.disp))
self.pglin += 1
self.fpdf.drawText()
self.pglin += 1
self.tqty = 0
self.tamt = 0
self.tdis = 0
self.tvat = 0
def grandTotal(self):
self.totind = "Y"
self.pageHeading()
tot = [0,0,0,0]
for x, t in enumerate(rttrtp):
qt = CCD(self.gqt[x], "SI", 8)
am = CCD(self.gam[x], "SD", 13.2)
vt = CCD(self.gvt[x], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-39s %s %s %s" % \
(t[1], qt.disp, am.disp, vt.disp))
else:
self.fpdf.drawText("%-26s %s %s %s" % \
(t[1], qt.disp, am.disp, vt.disp))
tot[0] = tot[0] + qt.work
tot[1] = float(ASD(tot[1]) + ASD(am.work))
tot[3] = float(ASD(tot[3]) + ASD(vt.work))
self.fpdf.drawText()
qt = CCD(tot[0], "SI", 8)
am = CCD(tot[1], "SD", 13.2)
vt = CCD(tot[3], "SD", 13.2)
if self.totsonly == "Y":
self.fpdf.drawText("%-39s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, vt.disp))
else:
self.fpdf.drawText("%-26s %s %s %s" % \
("Grand Totals", qt.disp, am.disp, vt.disp))
self.fpdf.drawText()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class ms1010(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,
["ctlmst", "ctlynd", "ctlvmf", "ctlvrf", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
cnt = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if not cnt[0]:
self.first = True
else:
self.first = False
self.img = None
return True
def mainProcess(self):
self.tit = ("Company Records File Maintenance", )
ctm = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Num"), ("ctm_name", "", 0, "Name", "Y"))
}
log = {"stype": "F", "types": "fle", "ftype": (("Image", "*"), )}
r1s = (("Yes", "Y"), ("No", "N"))
tag = (("General", None, ("T", 1, 2),
("T", 1, 1)), ("Banking", None, ("T", 1, 2), ("T", 1, 1)),
("Systems", None, ("T", 1, 2),
("T", 1, 1)), ("Logo", None, ("T", 1, 2), ("T", 1, 1)))
fld = [[("T", 1, 0, 0), "IUI", 3, "Company Number", "Number", "", "Y",
self.doCoyNum, ctm, None, ("notzero", )],
(("T", 1, 1, 0), "INA", 30, "Name", "Company Name", "", "N",
self.doCoyNam, None, self.doDelete, ("notblank", )),
(("T", 1, 2, 0), "INA", 30, "Postal Address Line-1",
"Address Line-1", "", "N", None, None, None, None),
(("T", 1, 3, 0), "INA", 30, " Line-2",
"Address Line-2", "", "N", None, None, None, None),
(("T", 1, 4, 0), "INA", 30, " Line-3",
"Address Line-3", "", "N", None, None, None, None),
(("T", 1, 5, 0), "INA", 4, "Postal Code", "", "", "N", None,
None, None, None),
(("T", 1, 6, 0), "INA", 30, "Street Address Line-1",
"Street Address Line-1", "", "N", None, None, None, None),
(("T", 1, 7, 0), "INA", 30, " Line-2",
"Address Line-2", "", "N", None, None, None, None),
(("T", 1, 8, 0), "INA", 30, " Line-3",
"Address Line-3", "", "N", None, None, None, None),
(("T", 1, 9, 0), "INA", 4, "Street Code", "", "", "N", None,
None, None, None),
(("T", 1, 10, 0), "INA", 30, "Contact Name", "", "", "N", None,
None, None, None),
(("T", 1, 11, 0), "INA", 15, "Telephone", "Telephone No", "",
"N", None, None, None, None),
(("T", 1, 12, 0), "INA", 15, "Facsimile", "Facsimile No", "",
"N", None, None, None, None),
(("T", 1, 13, 0), "INA", 15, "Mobile", "Mobile Number", "", "N",
None, None, None, None),
(("T", 1, 14, 0), "ITX", 50, "E-Mail Address", "", "", "N",
None, None, None, ("email", )),
(("T", 1, 15, 0), "ITX", 50, "Internet URL", "", "", "N", None,
None, None, ("efld", )),
(("T", 1, 16, 0), "INA", 20, "Registration No", "", "", "N",
None, None, None, None),
(("T", 1, 17, 0), "INA", 20, "V.A.T. Number", "", "", "N",
self.doVatNum, None, None, None),
(("T", 1, 18, 0), "IUA", 1, "V.A.T. Default", "", "", "N",
self.doVatCod, None, None, ("notblank", )),
(("T", 2, 0, 0), "INA", 30, "Bank Name", "", "", "N", None,
None, None, None),
(("T", 2, 1, 0), "INA", 30, "Bank Branch", "", "", "N", None,
None, None, None),
(("T", 2, 2, 0), "INA", 8, "Bank IBT", "Bank IBT Number", "",
"N", None, None, None, None),
(("T", 2, 3, 0), "INA", 16, "Bank Account",
"Bank Account Number", "", "N", None, None, None, None)]
pos = 1
self.sys = []
for x in range(len(allsys)):
for sss in allsys:
if allsys[sss][3] == pos:
self.sys.append(allsys[sss][1])
fld.append(
(("T", 3, pos, 0), ("IRB", r1s), 0, allsys[sss][0], "",
"N", "N", None, None, None, None))
pos += 1
fld.append((("T", 4, 0, 0), "IFF", 75, "Letterhead Image", "", "", "N",
self.doLogo, log, None, ("fle", "blank")))
but = (("Accept", None, self.doAccept, 0, ("T", 1, 2),
(("T", 1, 1), ("T", 4, 0))), ("Print", None, self.doPrint, 0,
("T", 1, 2), (("T", 1, 1),
("T", 4, 0))),
("Cancel", None, self.doCancel, 0, ("T", 1, 2),
(("T", 1, 1), ("T", 4, 0))), ("Quit", None, self.doExit1, 1,
None, None))
tnd = (None, (self.doEnd, "n"), (self.doEnd, "n"), (self.doEnd, "n"),
(self.doEnd, "y"))
txt = (None, self.doExit1, self.doExit2, self.doExit3, self.doExit4)
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
tags=tag,
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
if self.first:
self.opts["conum"] = 1
self.new = True
self.df.topf[1][0][1] = "OUI"
self.df.loadEntry("T", 1, 0, data=self.opts["conum"])
self.df.focusField("T", 1, 2)
def doClick(self, *opts):
if self.df.pag == 1 and self.df.col == 1:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doCoyNum(self, frt, pag, r, c, p, i, w):
if w == 0:
return "Invalid Company Number"
elif w != 1:
chk = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", 1)],
limit=1)
if not chk:
return "Company 1 Must First Exist"
self.opts["conum"] = w
self.old = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])
],
limit=1)
if not self.old:
self.new = True
else:
self.new = False
self.opts["conam"] = self.old[self.sql.ctlmst_col.index(
"ctm_name")]
for x in range(1, self.df.topq[pag]):
data = self.old[x]
self.df.loadEntry(frt, pag, x, data=data)
for x in range(0, self.df.topq[pag + 1]):
data = self.old[x + self.df.topq[pag]]
self.df.loadEntry(frt, pag + 1, x, data=data)
for x in range(0, self.df.topq[pag + 2]):
self.df.loadEntry(frt, pag + 2, x, data="N")
mods = self.old[self.sql.ctlmst_col.index("ctm_modules")].rstrip()
for x in range(0, len(mods), 2):
idx = self.sys.index(mods[x:x + 2])
self.df.loadEntry(frt, pag + 2, idx, data="Y")
self.logo = self.old[self.sql.ctlmst_col.index("ctm_logo")]
self.df.loadEntry(frt, pag + 3, 0, data=self.logo)
if self.logo:
self.displayLogo(self.logo)
def doDelete(self):
if self.opts["conum"] == 1:
showError(self.opts["mf"].body, "Deletion Error",
"Company 1 Cannot be Deleted")
return
err = False
skp = {
"ctlmst": "ctm_cono",
"ctlynd": "cye_cono",
"ctlvmf": "vtm_cono",
"ctlvrf": "vtr_cono"
}
for tab in tabdic:
if tab in skp:
continue
chk = tabdic[tab]["fld"][0][1]
if chk.count("_cono"):
sql = Sql(self.opts["mf"].dbm,
tab,
prog=self.__class__.__name__)
err = sql.getRec(tables=tab,
where=[(chk, "=", self.opts["conum"])])
if err:
break
if err:
showError(self.opts["mf"].body, "Deletion Error",
"%s Records Exist for This Company, Cannot Delete" % tab)
return
for tab in skp:
self.sql.delRec(tab, where=[(skp[tab], "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase(ask=True)
def doCoyNam(self, frt, pag, r, c, p, i, w):
self.opts["conam"] = w
chk = self.sql.getRec("ctlvmf",
where=[("vtm_cono", "=", self.opts["conum"])],
limit=1)
if not chk:
self.sql.insRec("ctlvmf",
data=[self.opts["conum"], "N", "No VAT", "N"])
self.sql.insRec("ctlvrf", data=[self.opts["conum"], "N", 0, 0])
def doVatNum(self, frt, pag, r, c, p, i, w):
self.vatnum = w
if not self.vatnum:
self.vat = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.vat)
return "sk1"
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 doLogo(self, frt, pag, r, c, p, i, w):
if not w:
if self.img:
self.img.destroyImage()
else:
self.logo = os.path.normpath(w)
if self.displayLogo(self.logo):
return "Invalid Logo Image"
self.df.loadEntry(frt, pag, p, data=self.logo)
def displayLogo(self, logo):
try:
if self.img:
try:
self.img.destroyImage()
except:
pass
self.img = ShowImage(self.df.nb.Page4,
logo,
wrkdir=self.opts["mf"].rcdic["wrkdir"],
msiz=640)
except:
return "error"
def doReadVat(self, w):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
return acc
def doEnd(self):
if self.df.pag == 1:
self.df.selPage("Banking")
self.df.focusField("T", 2, 1)
elif self.df.pag == 2:
self.df.selPage("Systems")
self.df.focusField("T", 3, 1)
elif self.df.pag == 3:
self.df.selPage("Logo")
self.df.focusField("T", 4, 1)
else:
data = []
mods = ""
for x in range(0, len(self.df.t_work[1][0])):
data.append(self.df.t_work[1][0][x])
for x in range(0, len(self.df.t_work[2][0])):
data.append(self.df.t_work[2][0][x])
fin = False
for x in range(0, len(self.df.t_work[3][0])):
if self.df.t_work[3][0][x] == "Y":
mod = self.sys[x]
if mod not in ("BC", "BS", "SC"):
fin = True
mods = mods + mod
data.append(mods)
data.extend(self.df.t_work[4][0][0:2])
if self.new:
self.sql.insRec("ctlmst", data=data)
elif data != self.old[:len(data)]:
col = self.sql.ctlmst_col
data.append(self.old[col.index("ctm_xflag")])
self.sql.updRec("ctlmst",
data=data,
where=[("ctm_cono", "=", self.opts["conum"])])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"ctlmst", "U",
"%03i" % self.opts["conum"],
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if fin:
# Financial Systems
ynd = self.sql.getRec("ctlynd",
cols=["count(*)"],
where=[("cye_cono", "=",
self.opts["conum"])],
limit=1)
if not ynd[0]:
self.doFinPeriod()
if self.xits == "y":
self.doCancel()
return True
self.opts["mf"].dbm.commitDbase()
if self.first:
self.doExit1()
else:
self.df.selPage("General")
self.df.focusField("T", 1, 1)
def doFinPeriod(self):
tit = ("Initial Financial Period", )
fld = ((("T", 0, 0, 0), "ID1", 10, "Period Start Date", "", "", "N",
self.doStartPer, None, None, ("efld", )),
(("T", 0, 1, 0), "ID1", 10, "Period End Date", "", "", "N",
self.doEndPer, None, None, ("efld", )))
tnd = ((self.doPerEnd, "y"), )
txt = (self.doPerExit, )
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.pf = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=tnd,
txit=txt)
self.pf.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.opts["mf"].head.configure(text=self.tit[0])
def doStartPer(self, frt, pag, r, c, p, i, w):
y = int(w / 10000) - 1
m = int((w % 10000) / 100)
if m == 2:
if not y % 4:
d = 29
else:
d = 28
else:
d = w % 100
self.s0 = (y * 10000) + (m * 100) + d
self.s1 = w
y = int(w / 10000) + 1
m -= 1
if not m:
m = 12
y -= 1
self.pf.t_work[0][0][1] = mthendDate((y * 10000) + (m * 100) + 1)
def doEndPer(self, frt, pag, r, c, p, i, w):
if w <= self.s1:
return "Invalid End Period"
y = int(w / 10000) - 1
m = int((w % 10000) / 100)
if m == 2:
if not y % 4:
d = 29
else:
d = 28
else:
d = w % 100
self.e0 = (y * 10000) + (m * 100) + d
self.e1 = w
def doPerEnd(self):
self.sql.insRec("ctlynd",
data=[self.opts["conum"], 0, self.s0, self.e0, 0, "N"])
self.sql.insRec("ctlynd",
data=[self.opts["conum"], 1, self.s1, self.e1, 0, "N"])
self.xits = "n"
self.closeProcess()
def doPerExit(self):
self.xits = "y"
self.closeProcess()
def closeProcess(self):
self.pf.closeProcess()
def doAccept(self):
for page in range(4):
frt, pag, col, mes = self.df.doCheckFields(("T", page + 1, None))
if mes:
break
if mes:
self.df.last[pag][0] = col + 1
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
mod = False
for x in range(len(self.df.t_work[3][0])):
if self.df.t_work[3][0][x] == "Y":
mod = True
break
if not mod:
self.df.selPage("Systems")
self.df.focusField("T", 3, 1, err="Missing System Module")
else:
if self.img:
self.img.destroyImage()
self.df.selPage("Logo")
self.df.doEndFrame("T", 4, cnf="N")
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
TabPrt(self.opts["mf"],
self.opts["conum"],
name=self.__class__.__name__,
tabs="ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])])
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 doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.selPage("General")
self.df.focusField("T", 1, 1)
def doExit1(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doExit2(self):
self.df.selPage("General")
def doExit3(self):
self.df.selPage("Banking")
def doExit4(self):
self.df.selPage("Systems")
class bc1040(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "args" not in self.opts:
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, ["bwltyp", "bwlpts", "bwlcmp"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
typ = {
"stype":
"R",
"tables": ("bwltyp", ),
"cols":
(("bct_code", "", 0, "Cod"), ("bct_desc", "", 0, "Description",
"Y"), ("bct_cfmat", "", 0, "F")),
"where": [("bct_cono", "=", self.opts["conum"])]
}
r1s = (("Tournament", "T"), ("K/Out (D)", "D"), ("K/Out (N)", "K"),
("R/Robin", "R"), ("Teams", "X"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),"I@bct_code",0,"","",
0,"Y",self.doTypCod,typ,None,("efld",)),
(("T",0,1,0),"I@bct_desc",0,"","",
"","N",self.doDesc,None,self.doDelete,("notblank",)),
(("T",0,2,0),("IRB",r1s),0,"Competition Format","",
"T","N",self.doCFmat,None,None,None,None,
"""Select the Competition Format as follows:
Tournament: The default format for tournaments.
K/Out (D): This is for all Drawn Knockout Competitions.
K/Out (N): This is for Normal Knockout Competitions.
R/Robin: This is for Round Robin Competitions.
Teams: This is for Team Competitions e.g. Club V Club.
"""),
(("T",0,3,0),"I@bct_tsize",0,"","",
4,"N",self.doTSize,None,None,("notzero",)),
(("T",0,4,0),"I@bct_games",0,"","",
0,"N",self.doGames,None,None,("notzero",)),
(("T",0,5,0),"I@bct_ends",0,"","",
21,"N",self.doEnds,None,None,("notzero",)),
(("T",0,6,0),("IRB",r2s),0,"Groups by Position","",
"N","N",self.doGroups,None,None,None,None,
"Yes means that teams will be split into Groups after "\
"a certain number of games based on position. No means "\
"that teams will not be split into groups"),
(("T",0,7,0),"I@bct_grgame",0,"","",
0,"N",self.doGrGame,None,None,("efld",)),
(("T",0,8,0),("IRB",r2s),0,"Adjust Scores","",
"N","N",self.doAdjust,None,None,None,None,
"Whether or Not to Modify the Scores of Groups, Other "\
"than Group A, when the Teams are Split into Groups."),
(("T",0,9,0),"I@bct_expunge",0,"","",
"","N",None,None,None,("efld",),None,
"These Comma Separated Game Scores will be Cleared when "\
"Teams are Split into Groups."),
(("T",0,10,0),"I@bct_percent",0,"","",
100,"N",None,None,None,("efld",),None,
"This is the Percentage of the Remaining Game Scores which "\
"Will be Retained when Teams are Split into Groups."),
(("T",0,11,0),"I@bct_drawn",0,"","",
1,"N",self.doDrawn,None,None,("efld",)),
(("T",0,12,0),("IRB",r2s),0,"Strict S v S",
"Strict Strength v Strength",
"N","N",self.doSvS,None,None,None,None,
"Yes means that teams could play against each other, again, "\
"in ANY game. No means that teams could only play against "\
"each other, again, in the FINAL game."),
(("T",0,13,0),("IRB",r2s),0,"Different Drawn Games Scoring","",
"N","N",self.doDiff,None,None,None,None,
"Yes means that Drawn Games have a Different Scoring Format "\
"from Strength V Strength Games."))
but = (("Print", None, self.doPrint, 0, ("T", 0, 2), None),
("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if "args" in self.opts:
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"])
self.df.topf[0][0][1] = "OUI"
self.df.mstFrame.wait_window()
def doTypCod(self, frt, pag, r, c, p, i, w):
if not w:
self.ctype = getNextCode(self.sql,
"bwltyp",
"bct_code",
where=[("bct_cono", "=",
self.opts["conum"])],
last=99)
self.df.loadEntry(frt, pag, p, data=self.ctype)
else:
self.ctype = w
self.old = self.sql.getRec("bwltyp",
where=[("bct_cono", "=",
self.opts["conum"]),
("bct_code", "=", self.ctype)],
limit=1)
if not self.old:
self.newtyp = True
else:
self.newtyp = False
self.cdesc = self.old[self.sql.bwltyp_col.index("bct_desc")]
self.cfmat = self.old[self.sql.bwltyp_col.index("bct_cfmat")]
self.tsize = self.old[self.sql.bwltyp_col.index("bct_tsize")]
self.ends = self.old[self.sql.bwltyp_col.index("bct_ends")]
self.groups = self.old[self.sql.bwltyp_col.index("bct_groups")]
self.adjust = self.old[self.sql.bwltyp_col.index("bct_adjust")]
for num, fld in enumerate(self.old[1:-1]):
self.df.loadEntry(frt, pag, num, data=fld)
chk = self.sql.getRec("bwlcmp",
where=[("bcm_cono", "=", self.opts["conum"]),
("bcm_type", "=", self.ctype)],
limit=1)
if chk:
self.exist = True
else:
self.exist = False
def doDelete(self):
if self.newtyp:
return
if self.exist:
return "There are Competitions Using this Type, Not Deleted"
self.sql.delRec("bwltyp",
where=[("bct_cono", "=", self.opts["conum"]),
("bct_code", "=", self.ctype)])
self.sql.delRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype)])
self.opts["mf"].dbm.commitDbase()
def doDesc(self, frt, pag, r, c, p, i, w):
if self.exist:
ok = askQuestion(self.opts["mf"].body,
"Games exist",
"""There are Competitions Using this Type.
Changes Could Adversely Affect them.
Are you Sure this is what you Want to Do?""",
default="no")
if ok == "no":
return "ff1"
def doCFmat(self, frt, pag, r, c, p, i, w):
self.cfmat = w
def doTSize(self, frt, pag, r, c, p, i, w):
if self.cfmat == "D" and w not in (2, 3):
return "Invalid Team Size"
self.tsize = w
if self.cfmat in ("D", "K", "R"):
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doGames(self, frt, pag, r, c, p, i, w):
self.games = w
def doEnds(self, frt, pag, r, c, p, i, w):
self.ends = w
if self.cfmat in ("D", "K", "R", "X"):
if self.cfmat in ("D", "K", "R"):
defaults = ["N", 0, "N", "", 0, 0, "N", "N"]
else:
defaults = ["N", 0, "N", "", 0, self.games, "N", "N"]
for num, dat in enumerate(defaults):
self.df.loadEntry("T", 0, p + num + 1, data=dat)
self.pdiff = "N"
return "nd"
def doGroups(self, frt, pag, r, c, p, i, w):
self.groups = w
if self.groups == "N":
self.adjust = "N"
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data=self.adjust)
self.df.loadEntry(frt, pag, p + 3, data="")
self.df.loadEntry(frt, pag, p + 4, data="")
return "sk4"
def doGrGame(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid Game Number"
def doAdjust(self, frt, pag, r, c, p, i, w):
self.adjust = w
if self.adjust == "N":
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data=0)
return "sk2"
def doDrawn(self, frt, pag, r, c, p, i, w):
self.drawn = w
if self.drawn == self.games:
# All drawn games
self.pdiff = "N"
self.df.loadEntry(frt, pag, p + 1, data="N")
self.df.loadEntry(frt, pag, p + 2, data="N")
return "sk2"
def doSvS(self, frt, pag, r, c, p, i, w):
if not self.drawn:
self.pdiff = "N"
self.df.loadEntry(frt, pag, p + 1, data="N")
return "sk1"
def doDiff(self, frt, pag, r, c, p, i, w):
self.pdiff = w
def doEnd(self):
data = [self.opts["conum"]] + self.df.t_work[0][0]
if self.newtyp:
self.sql.insRec("bwltyp", data=data)
elif data != self.old[:len(data)]:
col = self.sql.bwltyp_col
data.append(self.old[col.index("bct_xflag")])
self.sql.updRec("bwltyp",
data=data,
where=[("bct_cono", "=", self.opts["conum"]),
("bct_code", "=", self.ctype)])
self.perr = False
if self.cfmat in ("D", "K", "R"):
if self.newtyp:
self.sql.insRec("bwlpts",
data=[
self.opts["conum"], self.ctype, "D", "N",
0, "N", 0, 0, 1, "N", 0, 0
])
else:
self.df.setWidget(self.df.mstFrame, state="hide")
if self.pdiff == "Y":
self.doPtsFmt("D")
if not self.perr:
if self.pdiff == "Y":
self.doPtsFmt("S")
else:
self.doPtsFmt("B")
self.df.setWidget(self.df.mstFrame, state="show")
if self.perr:
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
else:
self.opts["mf"].dbm.commitDbase()
if "args" in self.opts:
self.doExit()
else:
self.df.focusField("T", 0, 1)
def doPtsFmt(self, flag=None):
self.flag = flag
if flag == "D":
txt = "Points Format for Drawn Games"
elif flag == "S":
txt = "Points Format for SvS Games"
else:
txt = "Points Format"
tit = (txt, )
r1s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Skins","",
"N","N",self.doSkins,None,None,None),
(("T",0,1,0),"I@bcp_sends",0,"","",
0,"N",self.doEndsPerSkin,None,None,("efld",)),
(("T",0,2,0),("IRB",r1s),0,"Points Only","",
"N","N",self.doOnly,None,None,None,None,
"Yes means that No Shots are to be captured and that only "\
"Points will be used to determine positions. No means that "\
"Shots and Points are to be captured and used to determine "\
"positions."),
(("T",0,3,0),"I@bcp_e_points",0,"","",
0,"N",self.doPoints,None,None,("efld",)),
(("T",0,4,0),"I@bcp_s_points",0,"","",
0,"N",None,None,None,("efld",)),
(("T",0,5,0),"I@bcp_g_points",0,"","",
0,"N",None,None,None,("efld",)),
(("T",0,6,0),("IRB",r1s),0,"Bonus Points","",
"N","N",self.doBonus,None,None,None),
(("T",0,7,0),"I@bcp_win_by",0,"","",
0,"N",None,None,None,("efld",)),
(("T",0,8,0),"I@bcp_lose_by",0,"","",
0,"N",None,None,None,("efld",)))
but = (("Quit", None, self.doPExit, 1, None, None), )
tnd = ((self.doPEnd, "y"), )
txt = (self.doPExit, )
self.pf = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if self.flag in ("D", "S"):
ptyp = self.flag
else:
ptyp = "D"
acc = self.sql.getRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype),
("bcp_ptyp", "=", ptyp)],
limit=1)
if acc:
self.newpts = False
for num, dat in enumerate(acc[3:-1]):
self.pf.loadEntry("T", 0, num, data=dat)
else:
self.newpts = True
self.pf.focusField("T", 0, 1, clr=False)
self.pf.mstFrame.wait_window()
def doSkins(self, frt, pag, r, c, p, i, w):
self.skins = w
if self.skins == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEndsPerSkin(self, frt, pag, r, c, p, i, w):
if self.ends % w:
return "Invalid Ends per Skin, Not Divisible"
def doOnly(self, frt, pag, r, c, p, i, w):
self.ponly = w
def doPoints(self, frt, pag, r, c, p, i, w):
if self.skins == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doBonus(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 "nd"
def doPEnd(self):
self.pf.closeProcess()
data = [self.opts["conum"], self.ctype, ""]
data.extend(self.pf.t_work[0][0])
if self.flag == "B":
if not self.newpts:
self.sql.delRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype)])
data[2] = "D"
self.sql.insRec("bwlpts", data=data)
data[2] = "S"
self.sql.insRec("bwlpts", data=data)
else:
if not self.newpts:
self.sql.delRec("bwlpts",
where=[("bcp_cono", "=", self.opts["conum"]),
("bcp_code", "=", self.ctype),
("bcp_ptyp", "=", self.flag)])
data[2] = self.flag
self.sql.insRec("bwlpts", data=data)
def doPExit(self):
self.perr = True
self.pf.closeProcess()
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 doExit(self):
self.df.closeProcess()
if "args" not in self.opts:
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class cr6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.tables = (("ctlnot", "not_key"), ("ctlvtf", "vtt_cono",
"vtt_acno", "vtt_styp"),
("crsmst", "crm_cono",
"crm_acno"), ("crstrn", "crt_cono", "crt_acno"),
("crsage", "cra_cono",
"cra_acno"), ("genrcc", "grc_cono", "grc_acrs"),
("strpom", "pom_cono", "pom_acno"),
("strtrn", "stt_cono", "stt_acno", "stt_styp"))
tabs = []
for tab in self.tables:
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
crsctl = gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
self.autogen = "N"
return True
def mainProcess(self):
crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols":
(("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y")),
"where": [("crm_cono", "=", self.opts["conum"])]
}
fld = [(["T", 0, 0, 0], "IRW", 7, "Old Account", "Old Account Number",
"", "Y", self.doOldAcc, crm, None, ("notblank", )),
(["T", 0, 0, 18], "O@crm_name", 0, ""),
(["T", 0, 1,
0], "I@crm_acno", 0, "New Account", "New Account Number", "",
"Y", self.doNewAcc, None, None, ("notblank", ))]
tnd = ((self.doProcess, "y"), )
txt = (self.doExit, )
but = [("Generate", None, self.doGenerate, 0, ("T", 0, 1), ("T", 0, 2),
"Auto Generate New Account Numbers Based on Names of Accounts")
]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
butt=but)
def doOldAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crsmst",
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number, Does Not exist"
self.oldacc = w
self.oldnot = w
self.df.loadEntry(frt, pag, p + 1, data=acc[2])
def doNewAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crsmst",
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if acc:
return "Invalid Account Number, Already Exists"
self.newacc = w
self.newnot = w
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("crsmst",
where=[("crm_cono", "=", self.opts["conum"])],
order="crm_name")
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[1]
name = acc[2].replace(" ", "")
name = name.replace(".", "")
name = name.replace(",", "")
name = name.replace(";", "")
name = name.replace(":", "")
name = name.replace("'", "")
name = name.replace('"', "")
# Remove other invalid characters
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("crsmst",
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_acno", "=", self.newacc)
])
if not chk:
break
self.oldnot = self.oldacc
self.newnot = self.newacc
self.doProcess(focus=False)
p.closeProgress()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
def doProcess(self, focus=True):
for tab in self.tables:
if tab[0] == "ctlnot":
whr = [("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "CRS"), (tab[1], "=", self.oldnot)]
dat = [self.newnot]
col = [tab[1]]
elif tab[0] == "ctlvtf":
whr = [(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldacc), (tab[3], "=", "D")]
dat = [self.newacc]
col = [tab[2]]
elif tab[0] == "strtrn":
whr = [(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldacc), (tab[3], "=", "STR")]
dat = [self.newacc]
col = [tab[2]]
else:
whr = [(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldacc)]
dat = [self.newacc]
col = [tab[2]]
self.sql.updRec(tab[0], where=whr, data=dat, cols=col)
if focus:
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
class ar6010(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"])
assctl = gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.tables = (
("ctlnot", "not_key"),
("ctlvtf", "vtt_cono", "vtt_acno", "vtt_styp"),
("assmst", "asm_cono", "asm_group", "asm_code"),
("asstrn", "ast_cono", "ast_group", "ast_code"))
tabs = ["assgrp"]
for tab in self.tables:
if tab[0] not in tabs:
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
grp = {
"stype": "R",
"tables": ("assgrp",),
"cols": (
("asg_group", "", 0, "Grp"),
("asg_desc", "", 0, "Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]}
asm = {
"stype": "R",
"tables": ("assmst",),
"cols": (
("asm_code", "", 0, "Code"),
("asm_desc", "", 0, "Description", "Y")),
"where": [("asm_cono", "=", self.opts["conum"])],
"whera": [["T", "asm_group", 0]]}
fld = [
(["T",0,0,0],"I@asm_group",0,"Old Group","Old Group",
"","Y",self.doOldGrp,grp,None,("notblank",)),
(["T",0,0,12],"INA",7,"Code","Old Asset Code",
"","Y",self.doOldCod,asm,None,("notblank",)),
(["T",0,0,27],"ONA",30,""),
(["T",0,1,0],"I@asm_group",0,"New Group","New Group",
"","Y",self.doNewGrp,grp,None,("notblank",)),
(["T",0,1,12],"I@asm_code",0,"Code","New Asset Code",
"","Y",self.doNewCod,None,None,("notblank",))]
tnd = ((self.doProcess,"y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd,
txit=txt)
def doOldGrp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("assgrp", where=[("asg_cono", "=",
self.opts["conum"]), ("asg_group", "=", w)], limit=1)
if not acc:
return "Invalid Group, Does Not exist"
self.oldgrp = w
def doOldCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("assmst", where=[("asm_cono", "=",
self.opts["conum"]), ("asm_group", "=", self.oldgrp), ("asm_code",
"=", w)], limit=1)
if not acc:
return "Invalid Code, Does Not exist"
self.oldcod = w
self.oldnot = "%3s%s" % (self.oldgrp, w)
self.df.loadEntry(frt, pag, p+1, data=acc[3])
def doNewGrp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("assgrp", where=[("asg_cono", "=",
self.opts["conum"]), ("asg_group", "=", w)], limit=1)
if not acc:
return "Invalid Group, Does Not exist"
self.newgrp = w
def doNewCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("assmst", where=[("asm_cono", "=",
self.opts["conum"]), ("asm_group", "=", self.newgrp), ("asm_code",
"=", w)], limit=1)
if acc:
return "Invalid Code, Already Exists"
self.newcod = w
self.newnot = "%3s%s" % (self.newgrp, w)
def doProcess(self):
for tab in self.tables:
if tab[0] == "ctlnot":
col = [tab[1]]
dat = [self.newnot]
whr = [
("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "ASS"),
(tab[1], "=", self.oldnot)]
elif tab[0] == "ctlvtf":
col = [tab[2]]
dat = [self.newcod]
whr = [
(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldcod),
(tab[3], "=", "A")]
else:
col = [tab[2], tab[3]]
dat = [self.newgrp, self.newcod]
whr = [
(tab[1], "=", self.opts["conum"]),
(tab[2], "=", self.oldgrp),
(tab[3], "=", self.oldcod)]
self.sql.updRec(tab[0], cols=col, data=dat, where=whr)
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
self.opts["mf"].closeLoop()
class mlc410(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, ["chglog", "memctk", "memkon"],
prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("memctk")
if not chk:
self.sql.insRec("memctk", data=[1, "H", "Home Telephone Number"])
self.sql.insRec("memctk", data=[2, "W", "Work Telephone Number"])
self.sql.insRec("memctk", data=[3, "M", "Mobile Telephone Number"])
self.sql.insRec("memctk", data=[4, "F", "Facsimile Number"])
self.sql.insRec("memctk", data=[5, "E", "E-Mail Address"])
self.opts["mf"].dbm.commitDbase()
return True
def mainProcess(self):
cod = {
"stype":
"R",
"tables": ("memctk", ),
"cols": (("mck_code", "", 0, "CD"), ("mck_desc", "", 0,
"Description", "Y"))
}
typ = {
"stype":
"C",
"title":
"Available Types",
"head": ("C", "Description"),
"data": (("E", "E-Mail"), ("F", "Facsimile"), ("H", "Home Phone"),
("M", "Mobile"), ("W", "Work Phone"))
}
fld = ((("T", 0, 0, 0), "I@mck_code", 0, "", "", "", "N", self.doCode,
cod, None, ("notzero", )),
(("T", 0, 1, 0), "I@mck_type", 0, "", "", "", "N", self.doType,
typ, None, ("in", ("E", "F", "H", "M", "W"))),
(("T", 0, 2, 0), "I@mck_desc", 0, "", "", "", "N", self.doDesc,
None, self.doDelete, ("notblank", )))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 0, 2),
("T", 0, 0)), ("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("memctk",
where=[("mck_code", "=", self.code)],
limit=1)
if self.old:
self.new = False
self.ktyp = self.old[self.sql.memctk_col.index("mck_type")]
self.df.loadEntry(frt, pag, p + 1, data=self.ktyp)
self.desc = self.old[self.sql.memctk_col.index("mck_desc")]
self.df.loadEntry(frt, pag, p + 2, data=self.desc)
else:
self.new = True
def doType(self, frt, pag, r, c, p, i, w):
self.ktyp = w
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doDelete(self):
if self.code in (1, 2, 3, 4, 5):
return "Static Code, Not Deleted"
chk = self.sql.getRec("memkon",
cols=["count(*)"],
where=[("mlk_code", "=", self.code)],
limit=1)
if chk[0]:
return "Code in Use (memkon), Not Deleted"
self.sql.delRec("memctk", where=[("mck_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.code, self.ktyp, self.desc]
if self.new:
self.sql.insRec("memctk", data=data)
elif data != self.old[:len(data)]:
col = self.sql.memctk_col
data.append(self.old[col.index("mck_xflag")])
self.sql.updRec("memctk",
data=data,
where=[("mck_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.df.doEndFrame("T", 0, cnf="N")
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
