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 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 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 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 bcc110(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, [
"memctl", "memctc", "memmst", "memadd", "memkon", "bwlctl",
"bwltab", "chglog"
],
prog=self.__class__.__name__)
if self.sql.error:
if self.sql.error == ["memctl"]:
self.memctl = False
self.chgint = False
self.mlint = None
self.same = "N"
else:
return
else:
self.memctl = True
self.acc = self.sql.getRec("bwlctl",
where=[("ctb_cono", "=", self.opts["conum"])
],
limit=1)
if not self.acc:
self.new = True
self.acc = [
self.opts["conum"], "N", "N", 0, 0, 0, 0, "C", "A", "N", "Y",
4, 0, 0, "A", "B", "", ""
]
else:
self.new = False
self.oldm = self.acc[self.sql.bwlctl_col.index("ctb_mstart")]
self.oldf = self.acc[self.sql.bwlctl_col.index("ctb_fstart")]
self.oldn = self.acc[self.sql.bwlctl_col.index("ctb_nstart")]
if self.memctl:
self.mlint = self.sql.getRec("memctl",
where=[("mcm_cono", "=",
self.opts["conum"])],
limit=1)
return True
def drawDialog(self):
cat = {
"stype":
"R",
"tables": ("memctc", ),
"cols":
(("mcc_code", "", 0, "Code"), ("mcc_desc", "", 0, "Description")),
"where":
(("mcc_cono", "=", self.opts["conum"]), ("mcc_type", "=", "C"))
}
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("Position", "P"), ("Rating", "R"), ("Combined", "C"))
r3s = (("Ascending", "A"), ("Descending", "D"))
r4s = (("S32L-S32L", "A"), ("S32L-L23S", "B"))
if self.memctl:
self.fld = [
(("T",0,0,0),["IRB",r1s],0,"M/L Integration","",
self.acc[1],"N",self.doMlint,None,None,None,None,
"Select whether to Integrate this system with the "\
"Members Ledger System."),
(("T",0,1,0),("IRB",r1s),0,"Same Numbers","",
self.acc[2],"N",self.doSame,None,None,None,None,
"If the Members Ledger is Integrated select "\
"whether the Tab numbers and Members Ledger numbers "\
"are the Same."),
(("T",0,2,0),"IUI",2,"Category Code","",
self.acc[3],"N",self.doCat,cat,None,None,None,
"If the Members Ledger is Integrated enter which "\
"Members Ledger Sports category is for Bowls.")]
seq = 3
else:
self.fld = []
seq = 0
self.fld.extend([
(("T",0,seq,0),"IUI",6,"Male Start Seq","",
self.acc[4],"N",self.doMStart,None,None,("notzero",),None,
"The Starting Tab number for Males."),
(("T",0,seq + 1,0),"IUI",6,"Female Start Seq","",
self.acc[5],"N",self.doFStart,None,None,("notzero",),None,
"The Starting Tab number for Females."),
(("T",0,seq + 2,0),"IUI",6,"Non-Member Start Seq","",
self.acc[6],"N",self.doNStart,None,None,("notzero",),None,
"The Starting Tab number for Visitors."),
(("T",0,seq + 3,0),("IRB",r2s),0,"Draw Base","",
self.acc[7],"N",self.doBase,None,None,None,None,
"The Default method of doing Draws."),
(("T",0,seq + 4,0),("IRB",r3s),0,"Rating Order","",
self.acc[8],"N",None,None,None,None,None,
"With Ratings select whether Ratings are Ascending "\
"or Descending in strength."),
(("T",0,seq + 5,0),("IRB",r1s),0,"Mixed Ratings","",
self.acc[9],"N",None,None,None,None,None,
"Select if Different Ratings are Used for Mixed "\
"Gender Draws."),
(("T",0,seq + 6,0),("IRB",r1s),0,"Replace Fours","",
self.acc[10],"N",None,None,None,None,None,
"When the Draw is Trips Use Pairs Instead of Fours "\
"when Applicable."),
(("T",0,seq + 7,0),"IUI",2,"Weeks Between Draws","",
self.acc[11],"N",None,None,None,("between", 0, 4),None,
"Minimum number of Weeks that Players Should Not be "\
"Drawn in the Same Team."),
(("T",0,seq + 8,0),"IUD",5.2,"Rate - Member","",
self.acc[12],"N",None,None,None,("efld",)),
(("T",0,seq + 9,0),"IUD",5.2,"Rate - Visitor","",
self.acc[13],"N",None,None,None,("efld",)),
(("T",0,seq + 10,0),"IUA",6,"Greens","",
self.acc[14],"N",self.doGreens,None,None,("notblank",)),
(("T",0,seq + 11,0),("IRB",r4s),0,"Draw Format","",
self.acc[15],"N",None,None,None,None),
(("T",0,seq + 12,0),"ITX",50,"Email Address","",
self.acc[16],"N",None,None,None,("email",))])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 1), ("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)
if not self.new:
if self.memctl:
seq = 1
self.oldint = self.acc[0]
else:
seq = 4
for n, f in enumerate(self.acc[seq:-1]):
self.df.loadEntry("T", 0, n, data=f)
if not self.memctl:
self.chgint = False
self.same = "N"
self.df.focusField("T", 0, 1, clr=False)
def doMlint(self, frt, pag, r, c, p, i, w):
if w == "Y" and not self.mlint:
return "Invalid Selection, Member's System Not Set Up"
if not self.new and w != self.oldint:
self.chgint = True
else:
self.chgint = False
if w == "N":
self.same = "N"
self.df.loadEntry(frt, pag, p + 1, data=self.same)
self.mcat = 0
self.df.loadEntry(frt, pag, p + 2, data=self.mcat)
return "sk2"
def doSame(self, frt, pag, r, c, p, i, w):
self.same = w
def doCat(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("memctc",
where=[("mcc_cono", "=", self.opts["conum"]),
("mcc_type", "=", "C"),
("mcc_code", "=", w)],
limit=1)
if not chk:
return "Invalid Code"
self.mcat = w
def doMStart(self, frt, pag, r, c, p, i, w):
self.mstart = w
def doFStart(self, frt, pag, r, c, p, i, w):
if w == self.mstart and self.same == "N":
return "Invalid Number, Same as Male"
if w != self.mstart:
if w < self.mstart:
r = self.mstart - w
g = "Female"
else:
r = w - self.mstart
g = "Male"
if r < 200:
return "ff5|Invalid Numbers, Too Few %s Tabs. (Minimum 200)" % g
self.fstart = w
def doNStart(self, frt, pag, r, c, p, i, w):
if w < self.mstart or w < self.fstart or w > 890000:
return "Invalid Number, Less than Male or Female or > 890000"
if self.mstart == self.fstart:
t = "Members"
r = w - self.mstart
m = 400
elif self.fstart < self.mstart:
t = "Male"
r = w - self.mstart
m = 200
else:
t = "Female"
r = w - self.fstart
m = 200
if r < m:
return "Invalid Number, Too Few %s Tabs. (Minimum %s)" % (t, m)
self.nstart = w
def doBase(self, frt, pag, r, c, p, i, w):
if w == "P":
self.df.loadEntry(frt, pag, p + 1, data="A")
return "sk1"
if not self.acc[7]:
self.df.t_work[0][0][p + 1] = "A"
def doGreens(self, frt, pag, r, c, p, i, w):
w = w.strip().replace(" ", "")
self.df.loadEntry(frt, pag, p, data=w)
def doEnd(self):
err = None
if self.same == "Y":
if self.mstart + 400 > self.nstart:
err = "Invalid Range, Too Few Members Allowed For"
elif self.mstart == self.fstart and self.same == "N":
err = "Same Male and Female Starting Numbers"
elif self.mstart < self.fstart:
if self.fstart - self.mstart < 200:
err = "Invalid Range, Too Few Male Numbers"
elif self.nstart < self.fstart + 200:
err = "Invalid Range, Too Few Female Numbers"
elif self.mstart - self.fstart < 200:
err = "Invalid Range, Too Few Female Numbers"
elif self.nstart < self.mstart + 200:
err = "Invalid Range, Too Few Male Numbers"
if err:
self.df.focusField("T", 0, 3, err=err)
else:
data = [self.opts["conum"]]
if not self.memctl:
data.extend(["N", "N"])
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new:
self.sql.insRec("bwlctl", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.bwlctl_col
data.append(self.acc[col.index("ctb_xflag")])
self.sql.updRec("bwlctl",
data=data,
where=[("ctb_cono", "=", self.opts["conum"])])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.acc):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"bwlctl", "U",
"%03i" % self.opts["conum"],
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if self.chgint and self.oldint == "Y":
recs = self.sql.getRec("bwltab",
cols=["btb_memno"],
where=[("btb_cono", "=",
self.opts["conum"])])
for rec in recs:
data = self.doLoadMember(rec[0])
if data == [0, "", "", "", "", "", "", "", ""]:
continue
self.sql.updRec("bwltab",
cols=[
"btb_memno", "btb_add1", "btb_add2",
"btb_add3", "btb_pcod", "btb_home",
"btb_work", "btb_cell", "btb_mail"
],
data=data,
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_memno", "=", rec[0])])
if not self.new and (self.mstart != self.oldm or \
self.fstart != self.oldf or self.nstart != self.oldn):
# Tab ranges changed
ok = askQuestion(self.opts["mf"].body, "Ranges", "Tab Ranges "\
"Have Changed, Do You Want to Change the Tabs to the "\
"New Ranges?", default="no")
if ok == "yes":
mdif = self.mstart - self.oldm
fdif = self.fstart - self.oldf
ndif = self.nstart - self.oldn
recs = []
if ndif > 0:
recs.extend(self.getNon())
if self.oldm > self.oldf:
recs.extend(self.getWom())
recs.extend(self.getMen())
else:
recs.extend(self.getMen())
recs.extend(self.getWom())
if ndif < 0:
recs.extend(self.getNon())
self.df.setWidget(self.df.mstFrame, state="hide")
pb = ProgressBar(self.opts["mf"].body,
typ="Changing Tabs",
mxs=len(recs))
for num, rec in enumerate(recs):
pb.displayProgress(num)
tab = rec[self.sql.bwltab_col.index("btb_tab")]
gdr = rec[self.sql.bwltab_col.index("btb_gender")]
if tab < self.oldn:
if gdr == "M":
new = tab + mdif
else:
new = tab + fdif
else:
new = tab + ndif
callModule(
self.opts["mf"],
None,
"bc6010",
coy=[self.opts["conum"], self.opts["conam"]],
args=[tab, new])
pb.closeProgress()
self.df.setWidget(self.df.mstFrame, state="show")
self.opts["mf"].dbm.commitDbase()
self.doExit()
def getMen(self):
recs = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "<", self.oldn),
("btb_gender", "=", "M")],
order="btb_tab")
return recs
def getWom(self):
recs = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "<", self.oldn),
("btb_gender", "=", "F")],
order="btb_tab")
return recs
def getNon(self):
end = self.oldm
if self.oldf > end:
end = self.oldf
recs = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", ">=", self.oldn)],
order="btb_tab")
return recs
def doLoadMember(self, memno):
acc = self.sql.getRec("memmst",
cols=["mlm_surname", "mlm_names", "mlm_gender"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", memno)],
limit=1)
if not acc:
return [0, "", "", "", "", "", "", "", ""]
self.df.loadEntry("T", 0, 1, data=memno)
self.df.loadEntry("T", 0, 2, data=acc[0])
self.df.loadEntry("T", 0, 3, data=acc[1])
self.gender = acc[2]
self.df.loadEntry("T", 0, 4, data=self.gender)
for typ in ("A", "P"):
data = self.sql.getRec(
"memadd",
cols=["mla_add1", "mla_add2", "mla_add3", "mla_code"],
where=[("mla_cono", "=", self.opts["conum"]),
("mla_memno", "=", memno), ("mla_type", "=", typ)],
limit=1)
if data:
break
if data:
data.insert(0, 0)
else:
data = ["", "", "", "", ""]
for num, cod in enumerate((1, 2, 3, 5)):
kk = self.sql.getRec("memkon",
cols=["mlk_detail"],
where=[("mlk_cono", "=", self.opts["conum"]),
("mlk_memno", "=", memno),
("mlk_code", "=", cod)],
limit=1)
if kk:
data.append(kk[0])
else:
data.append("")
return data
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
self.same = self.df.t_work[0][0][1]
self.mcat = self.df.t_work[0][0][2]
self.mstart = self.df.t_work[0][0][3]
self.fstart = self.df.t_work[0][0][4]
self.nstart = self.df.t_work[0][0][5]
self.df.doEndFrame("T", 0, cnf="N")
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 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 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 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()
def doCleanDatabase(self):
txt = "Cleaning Database ... Please Wait"
if self.opts["mf"] and self.opts["mf"].window:
self.opts["mf"].updateStatus(txt)
elif self.opts["bar"]:
print(txt)
# Removing unused tables
self.doGetTables()
if self.opts["bar"] and self.opts["mf"] and self.opts["mf"].window:
pb = ProgressBar(self.opts["mf"].body,
mxs=(len(self.old) + len(self.tabs)),
typ=txt)
for n1, t in enumerate(self.old):
if self.opts["mf"] and self.opts["mf"].window:
self.opts["mf"].updateStatus(t)
if self.opts["bar"]:
pb.displayProgress(n1)
if t not in self.tabs:
self.dbm.dropTable(t, True)
self.dbm.commitDbase()
# Creating new tables and/or indexes
if self.opts["mf"] and self.opts["mf"].window:
self.opts["mf"].updateStatus("")
for n2, t in enumerate(self.tabs):
if self.opts["mf"] and self.opts["mf"].window:
self.opts["mf"].updateStatus(t)
if self.opts["bar"]:
pb.displayProgress(n1 + n2)
if not self.dbm.checkTable(t):
opts = copyList(self.topts)
opts.append(("-t", t))
DBCreate(dbm=self.dbm, opts=opts)
self.tabs.append(t)
else:
self.doCreateIndexes(t)
self.dbm.commitDbase()
if self.opts["mf"] and self.opts["mf"].window:
self.opts["mf"].updateStatus("")
if self.opts["bar"]:
pb.closeProgress()
# Fix ctlmst and Stores Markup
tabs = ["ctlmst", "strctl", "strgrp", "strgmu", "strcmu"]
sql = Sql(self.dbm, tabs)
coys = sql.getRec("ctlmst", cols=["ctm_cono"])
for coy in coys:
mods = sql.getRec("ctlmst",
cols=["ctm_modules"],
where=[("ctm_cono", "=", coy[0])],
limit=1)
newm = ""
for x in range(0, len(mods[0]), 2):
if mods[0][x:x + 2] == "PS":
continue
newm += mods[0][x:x + 2]
sql.updRec("ctlmst",
cols=["ctm_modules"],
data=[newm],
where=[("ctm_cono", "=", coy[0])])
sctl = sql.getRec("strctl",
cols=["cts_plevs", "cts_automu"],
where=[("cts_cono", "=", coy[0])],
limit=1)
if sctl:
if sctl[1] == "N":
sql.delRec("strgmu", where=[("smg_cono", "=", coy[0])])
sql.delRec("strcmu", where=[("smc_cono", "=", coy[0])])
else:
if sctl[1] == "Y":
sql.updRec("strctl",
cols=["cts_automu"],
data=["L"],
where=[("cts_cono", "=", coy[0])])
sctl[1] = "L"
grps = sql.getRec("strgrp",
cols=["gpm_group"],
where=[("gpm_cono", "=", coy[0])])
for grp in grps:
for lvl in range(1, sctl[0] + 1):
sql.delRec("strcmu",
where=[("smc_cono", "=", coy[0]),
("smc_group", "=", grp[0]),
("smc_level", "=", lvl),
("smc_markup", "=", 0)])
gmu = sql.getRec("strgmu",
cols=["smg_markup"],
where=[("smg_cono", "=", coy[0]),
("smg_group", "=", grp[0]),
("smg_level", "=", lvl)],
limit=1)
if gmu:
if not gmu[0]:
sql.delRec("strgmu",
where=[
("smg_cono", "=", coy[0]),
("smg_group", "=", grp[0]),
("smg_level", "=", lvl)
])
sql.delRec("strcmu",
where=[("smc_cono", "=", coy[0]),
("smc_group", "=", grp[0]),
("smc_level", "=", lvl),
("smc_markup", "=", gmu[0])])
# Standard Records
if self.opts["mf"] and self.opts["mf"].window:
spl = SplashScreen(self.opts["mf"].body,
"Creating Standard Records\n\nPlease Wait")
self.opts["mf"].updateStatus("Creating Standard Records")
elif self.opts["bar"]:
print("Creating Standard Records .... Please Wait")
sql = Sql(self.dbm, ["ffield", "frelat"],
error=False,
prog=self.__class__.__name__)
if not sql.error:
sql.sqlRec("Delete from frelat")
self.doPopulate(sql, "frelat", "_cono")
sql = Sql(self.dbm,
"wagrcv",
error=False,
prog=self.__class__.__name__)
if not sql.error:
sql.sqlRec("Delete from wagrcv")
self.doPopulate(sql, "wagrcv")
sql = Sql(self.dbm, ["tplmst", "tpldet"],
error=False,
prog=self.__class__.__name__)
if not sql.error:
for tpl in stdtpl:
sql.sqlRec("Delete from tplmst where tpm_tname = '%s'" % tpl)
sql.sqlRec("Delete from tpldet where tpd_tname = '%s'" % tpl)
for dat in datdic["tplmst"]:
sql.insRec("tplmst", data=dat)
for dat in datdic["tpldet"]:
sql.insRec("tpldet", data=dat)
sql = Sql(self.dbm, ["wagtxa", "wagtxr"],
error=False,
prog=self.__class__.__name__)
if not sql.error:
try:
from tartanWork import payeRates, siteRates, uifRates, sdlRates
for t in ("wagtxa", "wagtxr"):
if t == "wagtxa":
for year in payeRates:
sql.delRec(t, where=[("wta_year", "=", int(year))])
data = [int(year)]
for n, d in enumerate(payeRates[year]["allow"]):
data.append(d)
if n == 1 and \
len(payeRates[year]["allow"]) == 3:
data.append(d)
data.append(siteRates[year])
data.extend(uifRates[year])
data.extend(sdlRates[year])
sql.insRec("wagtxa", data=data)
elif t == "wagtxr":
for year in payeRates:
sql.delRec(t, where=[("wtr_year", "=", int(year))])
to = 9999999
for rate in payeRates[year]["rates"]:
dat = [int(year)]
if rate[0]:
dat.append(rate[0] + 1)
dat.append(to)
dat.extend(rate[1:])
to = rate[0]
else:
dat.append(0)
dat.append(to)
dat.extend(rate[1:])
sql.insRec("wagtxr", data=dat)
except:
pass
# Close Splash
if self.opts["mf"] and self.opts["mf"].window:
self.opts["mf"].updateStatus("")
spl.closeSplash()
self.dbm.commitDbase()
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 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()
class cs2020(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"])
cshctl = gc.getCtl("cshctl", self.opts["conum"])
if not cshctl:
return
self.glint = cshctl["ccc_glint"]
if self.glint == "N":
showError(self.opts["mf"].window, "Error",
"Cash Analysis Not Integrated.")
return
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
self.cshctl = ctlctl["csh_ctl"]
self.vatctl = ctlctl["vat_ctl"]
tabs = ["cshana", "cshcnt", "gentrn", "ctlvtf"]
self.sql = Sql(self.opts["mf"].dbm, tables=tabs,
prog=self.__class__.__name__)
if self.sql.error:
return
self.dte = self.sql.getRec("cshcnt", cols=["max(cct_date)"],
where=[("cct_cono", "=", self.opts["conum"])], limit=1)[0]
t = time.localtime()
self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Cash Merge (%s)" % self.__class__.__name__)
dte = {
"stype": "R",
"tables": ("cshcnt",),
"cols": (
("cct_date", "", 0, "Date"),),
"where": [("cct_cono", "=", self.opts["conum"])],
"group": "cct_date"}
fld = (
(("T",0,0,0),"ID1",10,"From Date","",
self.dte,"Y",self.doFrom,dte,None,("efld",)),
(("T",0,1,0),"Id1",10,"To Date","To Date",
"","Y",self.doTo,dte,None,("efld",)))
tnd = ((self.doEnd,"Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], title=self.tit, eflds=fld,
tend=tnd, txit=txt)
def doFrom(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.fm = w
self.fmd = self.df.t_disp[pag][r][p]
self.df.loadEntry(frt, pag, p+1, data=self.fm)
def doTo(self, frt, pag, r, c, p, i, w):
if not w:
w = self.fm
elif w < self.fm:
return "Invalid To Date"
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.to = w
self.tod = CCD(w, "D1", 10).disp
csh = self.sql.getRec("cshcnt", where=[("cct_cono", "=",
self.opts["conum"]), ("cct_type", "=", "T"), ("cct_date",
"between", self.fm, self.to)])
if not csh:
return "ff1|Invalid Cash Capture Dates"
def doEnd(self):
self.df.closeProcess()
recs = self.sql.getRec("cshana", where=[("can_cono", "=",
self.opts["conum"]), ("can_trdt", "between", self.fm, self.to),
("can_gflag", "=", "N")], order="can_trdt")
if not recs:
showInfo(self.opts["mf"].window, "Merge",
"There are No Records to Merge.")
else:
for rec in recs:
# Expense and Income
acc = self.sql.getRec("gentrn", cols=["max(glt_refno)"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.cshctl), ("glt_type", "=", 4),
("glt_refno", "like", "CS_______")], limit=1)
if acc:
try:
auto = int(acc[0][2:]) + 1
except:
auto = 1
else:
auto = 1
refno = "CS%07d" % auto
ttyp = rec[self.sql.cshana_col.index("can_type")]
iamnt = rec[self.sql.cshana_col.index("can_incamt")]
vamnt = rec[self.sql.cshana_col.index("can_vatamt")]
eamnt = float(ASD(iamnt) - ASD(vamnt))
if ttyp == "T":
iamnt = float(ASD(0) - ASD(iamnt))
vamnt = float(ASD(0) - ASD(vamnt))
eamnt = float(ASD(0) - ASD(eamnt))
vcod = rec[self.sql.cshana_col.index("can_vatcod")]
data = [rec[self.sql.cshana_col.index("can_cono")]]
acno = rec[self.sql.cshana_col.index("can_code")]
trdt = rec[self.sql.cshana_col.index("can_trdt")]
curdt = int(trdt / 100)
data.extend([acno, curdt, trdt, 4, refno, "CSHMRGE",
eamnt, vamnt, "Cash Analysis", vcod])
data.extend(["", 0, self.opts["capnm"], self.sysdt])
self.sql.insRec("gentrn", data=data)
# VAT Control
data[1] = self.vatctl
data[7] = vamnt
data[8] = 0
self.sql.insRec("gentrn", data=data)
# Cash Control
data[1] = self.cshctl
data[7] = float(ASD(0) - ASD(iamnt))
data[8] = 0
data[9] = rec[self.sql.cshana_col.index("can_desc")]
self.sql.insRec("gentrn", data=data)
# VAT Record
data = [rec[self.sql.cshana_col.index("can_cono")]]
data.append(vcod)
if ttyp == "T":
data.append("O")
else:
data.append("I")
data.extend([curdt, "G", 4, "CSHMRG", refno, trdt, acno,
"Cash Analysis", eamnt, vamnt, 0, self.opts["capnm"],
self.sysdt])
self.sql.insRec("ctlvtf", data=data)
# Update
seq = rec[self.sql.cshana_col.index("can_seq")]
self.sql.updRec("cshana", cols=["can_gflag"], data=["Y"],
where=[("can_seq", "=", seq)])
self.opts["mf"].dbm.commitDbase(True)
self.closeProcess()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
self.opts["mf"].closeLoop()
class ar2030(object):
def __init__(self, **opts):
self.opts = opts
if "args" in self.opts:
self.args = self.opts["args"]
else:
self.args = None
if self.setVariables():
if self.args:
if not self.doChkDate(self.args[0]):
self.endPage0()
else:
self.dataHeader()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
gc = GetCtl(self.opts["mf"])
assctl = gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.glint = assctl["cta_glint"]
self.rordp = assctl["cta_rordp"]
self.lastp = assctl["cta_lastp"]
self.sper = int(self.opts["period"][1][0] / 100)
self.eper = int(self.opts["period"][2][0] / 100)
yr = int(self.lastp / 100)
mt = (self.lastp % 100) + 1
if mt > 12:
yr += 1
mt = 1
self.curdt = (yr * 100) + mt
if self.curdt > self.eper:
self.curdt = self.eper
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
tabs = ["assctl", "assgrp", "assmst", "assdep", "asstrn", "gentrn"]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("asstrn",
where=[("ast_cono", "=", self.opts["conum"]),
("ast_mtyp", "=", 4),
("ast_curdt", ">", self.eper)])
if chk:
if not self.args:
showError(self.opts["mf"].body, "Period Error",
"Depreciation Has Already Been Raised in "\
"the Next Financial Period")
return
return True
def dataHeader(self):
fld = ((("T", 0, 0, 0), "ID2", 7, "Cut-off Period", "", self.curdt,
"N", self.doTrdate, None, None, None), )
tnd = ((self.endPage0, "y"), )
txt = (self.exitPage0, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt)
def doTrdate(self, frt, pag, r, c, p, i, w):
chk = self.doChkDate(w)
if chk:
return chk
def doChkDate(self, date):
if date < self.sper or date > self.eper:
return "Invalid Date, Not in Financial Period"
if self.lastp and self.lastp < self.sper:
dte1 = mthendDate(self.lastp * 100)
dte2 = mthendDate(self.sper * 100)
if dateDiff(dte1, dte2, "months") > 1:
return "Missing Depreciation for Previous Period"
self.curdt = date
def endPage0(self):
if self.args:
recs = self.sql.getRec("assmst",
where=[("asm_cono", "=",
self.opts["conum"]),
("asm_group", "=", self.args[1]),
("asm_code", "=", self.args[2])])
else:
self.df.closeProcess()
recs = self.sql.getRec("assmst",
where=[("asm_cono", "=", self.opts["conum"])
])
if recs:
self.doRaiseAll(recs)
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doRaiseAll(self, recs):
if not self.args:
p = ProgressBar(self.opts["mf"].body,
mxs=len(recs),
typ="Raising Depreciation ... Please Wait")
for num, dat in enumerate(recs):
if not self.args:
p.displayProgress(num)
self.group = CCD(dat[self.sql.assmst_col.index("asm_group")], "UA",
3)
grp = self.sql.getRec("assgrp",
where=[("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group.work)],
limit=1)
if not grp:
if not self.args:
showError(self.opts["mf"].body, "Group Error",
"Missing Group (%s) Record" % self.group.disp)
abort = True
break
self.depacc = grp[self.sql.assgrp_col.index("asg_depacc")]
self.expacc = grp[self.sql.assgrp_col.index("asg_expacc")]
self.code = dat[self.sql.assmst_col.index("asm_code")]
depcod = dat[self.sql.assmst_col.index("asm_depcod")]
# Get Depreciation Record
self.dep = self.sql.getRec(tables="assdep",
where=[("asd_cono", "=",
self.opts["conum"]),
("asd_code", "=", depcod)],
limit=1)
if not self.dep:
showError(self.opts["mf"].body, "Error",
"Depreciation Code %s Does Not Exist.\n\n"\
"Aborting." % depcod)
abort = True
break
bals = Balances(self.opts["mf"],
"ASS",
self.opts["conum"],
self.sper,
keys=(self.group.work, self.code))
asset = bals.doAssBals()
if not asset:
continue
self.cap, cdp, rdp, cbl, rbl, mov = asset
# Raise depreciation from start period to curdt or sale date
self.lurdt = self.sper
sales = False
while not sales and self.lurdt <= self.curdt:
trans = self.sql.getRec(
"asstrn",
cols=["ast_mtyp", "round(sum(ast_amt1), 2)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group.work),
("ast_code", "=", self.code),
("ast_curdt", "=", self.lurdt),
("ast_mtyp", "<>", 4)],
group="ast_mtyp")
if trans:
for mov, amt in trans:
if mov == 5:
sales = True
self.cap = 0
break
self.cap = float(ASD(self.cap) + ASD(amt))
if self.cap:
self.doRaiseDep()
self.lurdt = self.doIncrCurdt()
if not self.args:
p.closeProgress()
if abort:
self.opts["mf"].dbm.rollbackDbase()
else:
self.sql.updRec("assctl",
cols=["cta_lastp"],
data=[self.curdt],
where=[("cta_cono", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
def doIncrCurdt(self):
yr = int(self.lurdt / 100)
mt = self.lurdt % 100
if mt == 12:
yr += 1
mt = 1
else:
mt += 1
return (yr * 100) + mt
def doRaiseDep(self):
# Calculate Depreciations and check if Raised
# else create transaction and accumulate variables
#
# Extract Closing Balance at lurdt
where = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group.work),
("ast_code", "=", self.code)]
whr = copyList(where)
whr.append(("ast_curdt", "<=", self.lurdt))
bal = self.sql.getRec(
"asstrn",
cols=["round(sum(ast_amt1), 2)", "round(sum(ast_amt2), 2)"],
where=whr,
limit=1)
if bal and bal[0] <= 0:
return
# Get Date Purchased and Months to trdt
self.trdt = mthendDate(self.lurdt * 100)
acc = self.sql.getRec("asstrn",
cols=["min(ast_date)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group.work),
("ast_code", "=", self.code),
("ast_mtyp", "=", 1)],
limit=1)
years = dateDiff(acc[0], self.trdt, "years")
if years > 6:
# Maximum of 7 variable rates in assdep record
years = 6
# Extract Depreciation up to previous year end
whr = copyList(where)
whr.extend([("ast_mtyp", "=", 4), ("ast_curdt", "<", self.sper)])
pmd = self.sql.getRec(
"asstrn",
cols=["round(sum(ast_amt1), 2)", "round(sum(ast_amt2), 2)"],
where=whr,
limit=1)
if not pmd[0]:
pmd[0] = 0
if not pmd[1]:
pmd[1] = 0
#
# Extract Depreciation for lurdt
whr = copyList(where)
whr.extend([("ast_mtyp", "=", 4), ("ast_curdt", "=", self.lurdt)])
cmd = self.sql.getRec("asstrn",
cols=[
"max(ast_refno)", "round(sum(ast_amt1), 2)",
"round(sum(ast_amt2), 2)"
],
where=whr,
limit=1)
if not cmd[0] or cmd[0] == "Take-On":
self.refno = CCD(1, "Na", 9).work
else:
self.refno = CCD(cmd[0], "Na", 9).work
if not cmd[1]:
cmd[1] = 0
if not cmd[2]:
cmd[2] = 0
if self.dep[self.sql.assdep_col.index("asd_typec")] == "S":
# Straight Line
cval = self.cap
crat = self.dep[self.sql.assdep_col.index("asd_rate1c")]
for x in range(2, years + 2):
n = self.dep[self.sql.assdep_col.index("asd_rate%sc" % x)]
if n:
crat = n
else:
# Depreciating Balance
cval = float(ASD(self.cap) + ASD(pmd[0]))
crat = self.dep[self.sql.assdep_col.index("asd_rate1c")]
if cval:
if cval < 0:
cdep = 0
else:
cdep = round((cval * crat / 100.0 / 12), 2)
cdep = float(ASD(cdep) + ASD(cmd[1]))
cbal = float(ASD(bal[0]) - ASD(cdep))
if cbal < 0:
cdep = float(ASD(cdep) + ASD(cbal))
cdep = float(ASD(0) - ASD(cdep))
typer = self.dep[self.sql.assdep_col.index("asd_typer")]
if self.rordp == "N" or typer == "N":
rdep = 0
else:
if typer == "S":
# Straight Line
rval = self.cap
rrat = self.dep[self.sql.assdep_col.index("asd_rate1r")]
for x in range(2, years + 2):
n = self.dep[self.sql.assdep_col.index("asd_rate%sr" % x)]
if n:
rrat = n
else:
# Depreciating Balance
rval = float(ASD(self.cap) + ASD(pmd[1]))
rrat = self.dep[self.sql.assdep_col.index("asd_rate1r")]
if rval:
if rval < 0:
rdep = 0
else:
rdep = round((rval * rrat / 100.0 / 12), 2)
rdep = float(ASD(rdep) + ASD(cmd[2]))
rbal = float(ASD(bal[1]) - ASD(rdep))
if rbal < 0:
rdep = float(ASD(rdep) + ASD(rbal))
rdep = float(ASD(0) - ASD(rdep))
if cdep or rdep:
data = [
self.opts["conum"], self.group.work, self.code, 4, self.refno,
"AutoDep", self.trdt, 4, cdep, rdep, 0, self.lurdt,
"Auto Raising of Depreciation", "", "", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.glint == "Y" and cdep:
self.doWriteGen(self.depacc, cdep)
cdep = float(ASD(0) - ASD(cdep))
self.doWriteGen(self.expacc, cdep)
def doWriteGen(self, accno, amnt):
whr = [("glt_cono", "=", self.opts["conum"]), ("glt_acno", "=", accno),
("glt_batch", "=", "AutoDep"), ("glt_curdt", "=", self.lurdt),
("glt_trdt", "=", self.trdt), ("glt_type", "=", 4)]
acc = self.sql.getRec("gentrn", where=whr)
if acc and len(acc) == 1:
amt = acc[0][self.sql.gentrn_col.index("glt_tramt")]
amt = float(ASD(amt) + ASD(amnt))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amt],
where=whr)
else:
data = [
self.opts["conum"], accno, self.lurdt, self.trdt, 4,
self.refno, "AutoDep", amnt, 0, "Auto Raising of Depreciation",
"", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
def exitPage0(self):
self.df.closeProcess()
if "wait" not in self.opts:
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 ml3080(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,
["memmst", "memsta", "memtrn", "memcat", "memctc", "memctp"],
prog=self.__class__.__name__)
if self.sql.error:
return
mc = GetCtl(self.opts["mf"])
memctl = mc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.fromad = memctl["mcm_emadd"]
self.s_per = int(self.opts["period"][1][0] / 100)
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
r1s = (("Number", "N"), ("Surname", "M"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Sort Order", "", "N", "Y",
self.doSort, None, None, None),
(("T", 0, 1, 0), ("IRB", r2s), 0, "Include Pay Plan", "", "N",
"Y", self.doPayPlan, None, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "N"))
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
def doPayPlan(self, frt, pag, r, c, p, i, w):
self.plan = w
def doEnd(self):
self.df.closeProcess()
col = [
"mlm_memno", "mlm_surname", "mlm_names", "mlm_payplan", "mlc_code"
]
whr = [("mlm_cono", "=", self.opts["conum"]), ("mlm_state", "=", "A")]
if self.plan == "N":
whr.append(("mlm_payplan", "=", "N"))
whr.extend([("mlc_cono=mlm_cono", ), ("mlc_memno=mlm_memno", ),
("mlc_type", "=", "B")])
grp = "mlm_memno, mlm_surname, mlm_names, mlm_payplan, mlc_code"
if self.sort == "N":
odr = "mlm_memno"
else:
odr = "mlm_surname"
sp = SplashScreen(self.opts["mf"].body,
"Preparing Report ... Please Wait")
recs = self.sql.getRec(tables=["memmst", "memcat"],
cols=col,
where=whr,
group=grp,
order=odr)
sp.closeSplash()
if not recs:
self.opts["mf"].closeLoop()
return
p = ProgressBar(self.opts["mf"].body,
typ="Generating the Report",
mxs=len(recs),
esc=True)
data = []
for num, rec in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
whr = [("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", rec[0])]
trn = getTrn(self.opts["mf"].dbm, "mem", whr=whr, zer="N")
bal = 0
inv = 0
for t in trn[1]:
c = trn[0]
bal = float(ASD(bal) + ASD(t[c.index("mlt_tramt")]))
if t[c.index("mlt_type")] == 1 and \
t[c.index("mlt_curdt")] >= self.s_per:
inv = float(ASD(inv) + ASD(t[c.index("mlt_tramt")]))
if not bal or bal < inv:
continue
cat = self.sql.getRec(tables=["memctc", "memctp"],
cols=["mcc_desc", "mcp_rate_01"],
where=[("mcc_cono", "=", self.opts["conum"]),
("mcc_type", "=", "B"),
("mcc_code", "=", rec[4]),
("mcp_cono=mcc_cono", ),
("mcp_type=mcc_type", ),
("mcp_code=mcc_code", )],
order="mcp_date desc",
limit=1)
if not cat or bal < cat[1]:
continue
rec[1] = "%s, %s" % (rec[1], rec[2])
del rec[2]
rec[3] = cat[0]
rec.append(cat[1])
rec.append(inv)
rec.append(bal)
data.append(rec)
p.closeProgress()
if p.quit:
self.opts["mf"].closeLoop()
return
name = self.__class__.__name__
head = ["Members Suspension Report"]
cols = [["a", "NA", 7, "Mem-No", "y"], ["b", "NA", 50, "Name", "y"],
["d", "UA", 1, "P", "y"],
["c", "NA", 30, "Active-Category", "y"],
["e", "SD", 13.2, "Subscription", "y"],
["f", "SD", 13.2, "Tot-Invoiced", "y"],
["g", "SD", 13.2, "Tot-Balance", "y"]]
rep = RepPrt(self.opts["mf"],
conum=self.opts["conum"],
conam=self.opts["conam"],
name=name,
tables=data,
heads=head,
cols=cols,
gtots=("e", "f", "g"),
ttype="D",
repprt=self.df.repprt,
repeml=self.df.repeml,
fromad=self.fromad)
if not rep.xits:
ask = askChoice(self.opts["mf"].body,
"Suspend Members",
"Select Members to Suspend",
butt=(("All", "A"), ("Some", "S"), ("None", "N")),
default="None")
if ask in ("A", "S"):
if ask == "S":
cols = ["memno", "name"]
dics = {
"memno": ("", 0, "UI", 6, "Member Number", "Mem-No"),
"name": ("", 1, "NA", 50, "Member Name", "Name")
}
newd = []
for dat in data:
newd.append((dat[0], dat[1]))
data = getSingleRecords(self.opts["mf"],
"",
cols,
where=newd,
ttype="D",
dic=dics)
if data:
p = ProgressBar(self.opts["mf"].body,
typ="Suspending Members",
mxs=len(data))
for num, rec in enumerate(data):
p.displayProgress(num)
self.sql.updRec("memmst",
cols=["mlm_state", "mlm_sdate"],
data=["S", self.sysdtw],
where=[("mlm_cono", "=",
self.opts["conum"]),
("mlm_memno", "=", rec[0])])
self.sql.insRec("memsta",
data=[
self.opts["conum"], rec[0], "S",
self.sysdtw, self.opts["capnm"],
self.sysdtw, 0
])
self.opts["mf"].dbm.commitDbase()
p.closeProgress()
self.opts["mf"].closeLoop()
def doExit(self):
self.df.closeProcess()
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 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 st2040(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, ["strgrp", "strmf1", "strmf2",
"strtrn"], 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"]
if self.locs == "N":
showError(self.opts["mf"].body, "Error",
"Multiple Locations Are Not Enabled")
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
gpm = {
"stype": "R",
"tables": ("strgrp",),
"cols": (
("gpm_group", "", 0, "Grp"),
("gpm_desc", "", 0, "Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]}
stm = {
"stype": "R",
"tables": ("strmf1",),
"cols": (
("st1_group", "", 0, "Grp"),
("st1_code", "", 0, "Product Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [
("st1_cono", "=", self.opts["conum"]),
("st1_type", "not", "in", ("R", "X"))],
"whera": [["C", "st1_group", 0, 0]],
"order": "st1_group, st1_code",
"index": 1}
stl = {
"stype": "R",
"tables": ("strloc", "strmf2"),
"cols": (
("srl_loc", "", 0, "L"),
("srl_desc", "", 0, "Location", "Y")),
"where": [
("srl_cono", "=", self.opts["conum"]),
("srl_loc=st2_loc",),
("st2_cono=srl_cono",)],
"whera": [["C", "st2_group", 0], ["C", "st2_code", 1]],
"order": "srl_loc",
"index": 0}
fld = [
(("T",0,0,0),"INa",7,"Transfer Number","",
"","N",self.doTrf,None,None,("notblank",)),
(("T",0,0,0),"ID1",10,"Date","Transfer Date",
self.sysdtw,"N",self.doDte,None,None,("efld",)),
(("C",0,0,0),"IUA",3,"Grp","Product Group",
"r","N",self.doGroup,gpm,None,("notblank",)),
(("C",0,0,1),"INA",20,"Product Code","",
"","N",self.doCode,stm,None,("notblank",)),
(("C",0,0,2),"ONA",25,"Description"),
(("C",0,0,3),"ONA",10,"U.O.I"),
(("C",0,0,4),"ISD",9.2,"Quantity","",
"","N",self.doQty,None,None,("notzero",)),
(("C",0,0,5),"IUA",1,"F","From Location",
"","N",self.doLoc1,stl,None,("notblank",)),
(("C",0,0,6),"IUA",1,"T","To Location",
"","N",self.doLoc2,stl,None,("notblank",)),
(("C",0,0,7),"ISD",9.2,"Unit-Cost","Unit Cost Price",
"","N",None,None,None,("notzero",)),
(("C",0,0,8),"INA",(15,30),"Details","Transaction Details",
"","N",self.doTrnDet,None,None,None)]
row = (15,)
tnd = ((self.endPage0,"n"),)
txt = (self.exitPage0,)
cnd = ((self.endPage1,"y"),)
cxt = (self.exitPage1,)
self.df = TartanDialog(self.opts["mf"], eflds=fld, rows=row,
tend=tnd, txit=txt, cend=cnd, cxit=cxt)
def doTrf(self, frt, pag, r, c, p, i, w):
self.trf = w
def doDte(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
self.dte = w
self.curdt = int(self.dte / 100)
self.batno = "S%s" % self.curdt
def doGroup(self, frt, pag, r, c, p, i, w):
self.group = 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"
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec("strmf1", cols=["st1_type", "st1_desc",
"st1_uoi"], where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group), ("st1_code", "=", w)], limit=1)
if not acc:
return "Invalid Code"
if acc[0] == "R":
return "Invalid Code (Recipe Item)"
if acc[0] == "X":
return "Invalid Code (Redundant)"
self.df.loadEntry("C", pag, p+1, data=acc[1])
self.df.loadEntry("C", pag, p+2, data=acc[2])
def doQty(self, frt, pag, r, c, p, i, w):
self.qty = w
def doLoc1(self, frt, pag, r, c, p, i, w):
self.acc = self.sql.getRec("strmf2", where=[("st2_cono", "=",
self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code",
"=", self.code), ("st2_loc", "=", w)], limit=1)
if not self.acc:
return "Invalid Location For This Product"
self.loc1 = w
self.extractCost()
self.amt = round((self.qty * self.ucost), 2)
self.df.loadEntry("C", pag, p+2, data=self.ucost)
def doLoc2(self, frt, pag, r, c, p, i, w):
if w == self.loc1:
return "Invalid Location, Same as From"
self.newloc = "N"
acc = self.sql.getRec("strmf2", where=[("st2_cono", "=",
self.opts["conum"]), ("st2_group", "=", self.group), ("st2_code",
"=", self.code), ("st2_loc", "=", w)], limit=1)
if not acc:
ok = askQuestion(self.opts["mf"].body, "New Location",
"This location does not exist for this product. " \
"Are you sure that you want to create it?")
if ok == "yes":
self.newloc = "Y"
else:
return "Invalid Location For This Product"
self.loc2 = w
return "sk1"
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
def endPage0(self):
self.df.focusField("C", 0, 1)
def endPage1(self):
self.updateTables()
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def exitPage1(self):
self.df.focusField("T", 0, 1)
def extractCost(self):
qbal = 0
vbal = 0
self.ucost = 0
stt_rslt = self.sql.getRec("strtrn",
cols=["round(sum(stt_qty),2)", "round(sum(stt_cost),2)"],
where=[("stt_cono", "=", self.opts["conum"]), ("stt_group", "=",
self.group), ("stt_code", "=", self.code), ("stt_loc", "=",
self.loc1)])
if stt_rslt:
qbal = CCD(stt_rslt[0][0], "SD", 13.2).work
vbal = CCD(stt_rslt[0][1], "SD", 13.2).work
if qbal:
self.ucost = round((vbal / qbal), 2)
def updateTables(self):
# Stores Ledger Transaction
qty = float(ASD(0) - ASD(self.qty))
val = float(ASD(0) - ASD(self.amt))
if qty >= 0:
rtn = 3
else:
rtn = 4
self.sql.insRec("strtrn", data=[self.opts["conum"], self.group,
self.code, self.loc1, self.dte, rtn, self.trf, self.batno, "",
qty, val, 0, self.curdt, self.trndet, 0, "", "", "STR", 0, "N",
self.opts["capnm"], self.sysdtw, 0])
# Stores Ledger Transaction
if self.qty >= 0:
rtn = 3
else:
rtn = 4
if self.newloc == "Y":
self.acc[self.sql.strmf2_col.index("st2_loc")] = self.loc2
self.sql.insRec("strmf2", data=self.acc)
self.sql.insRec("strtrn", data=[self.opts["conum"], self.group,
self.code, self.loc2, self.dte, rtn, self.trf, self.batno, "",
self.qty, self.amt, 0, self.curdt, self.trndet, 0, "", "",
"STR", 0, "", self.opts["capnm"], self.sysdtw, 0])
