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 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()
def doEnd(self):
self.df.closeProcess()
tabs = ["wagmst"]
self.head = "Salaries and Wages - Employee Master Report"
whr = [("wgm_cono", "=", self.opts["conum"])]
if self.dep:
whr.append(("wgm_dept", "=", self.dep))
opts = "Dept: %s" % self.dep
else:
opts = None
odr = "wgm_empno"
if self.typ == "C":
sql = Sql(self.opts["mf"].dbm, "wagmst",
prog=self.__class__.__name__)
recs = sql.getRec(tables=tabs, where=whr)
if not recs:
self.closeProcess()
return
col = sql.wagmst_col
dic = sql.wagmst_dic
self.fpdf = MyFpdf(name=self.__class__.__name__, head=80, auto=True)
self.fpdf.header = self.doHead
self.fpdf.set_font("Courier", "B", 12)
cwth = self.fpdf.get_string_width("X")
for rec in recs:
self.fpdf.add_page()
max1, max2 = 0, 0
for c in col[:-1]:
if max1 < len(dic[c][4]):
max1 = len(dic[c][4])
if max2 < int(dic[c][3]):
max2 = int(dic[c][3])
self.fpdf.set_font("Courier", "B", 12)
self.fpdf.drawText(h=5, txt="%-20s" % dic[c][4], ln=0)
self.fpdf.set_font("Courier", "", 12)
if dic[c][4] == "Pay Frequency":
if rec[col.index(c)] == "F":
txt = "Fortnightly"
elif rec[col.index(c)] == "M":
txt = "Monthly"
else:
txt = "Weekly"
self.fpdf.drawText(h=5, x=cwth*40, txt=txt)
elif dic[c][4] == "Pay Type":
if rec[col.index(c)] == "C":
txt = "Cash"
elif rec[col.index(c)] == "Q":
txt = "Cheque"
else:
txt = "Electronic"
self.fpdf.drawText(h=5, x=cwth*40, txt=txt)
elif dic[c][4] == "Account Type":
if rec[col.index(c)] == "1":
txt = "Current"
elif rec[col.index(c)] == "2":
txt = "Transmission"
else:
txt = "Savings"
self.fpdf.drawText(h=5, x=cwth*40, txt=txt)
else:
self.fpdf.drawText(h=5, x=cwth*40,
txt=CCD(rec[col.index(c)],
dic[c][2], dic[c][3]).disp)
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, self.opts["conum"], ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"],
pdfnam=pdfnam, header=self.head, repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
else:
cols = [
["wgm_empno", "UI", 5, "EmpNo", "y"],
["wgm_sname", "NA", 30, "Surname", "y"],
["wgm_fname", "NA", 30, "Names", "y"],
["wgm_freq", "UA", 1, "F", "y"],
["wgm_start", "D1", 10, "Comm-Date", "y"],
["wgm_term", "d1", 10, "Term-Date", "y"]]
RepPrt(self.opts["mf"], conum=self.opts["conum"],
conam=self.opts["conam"], name=self.__class__.__name__,
tables=tabs, heads=[self.head], cols=cols, where=whr,
order=odr, opts=opts, repprt=self.df.repprt,
repeml=self.df.repeml, fromad=self.fromad)
self.closeProcess()
class rc3070(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
"rcaowm",
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rcactl = gc.getCtl("rcactl", self.opts["conum"])
if not rcactl:
return
self.fromad = rcactl["cte_emadd"]
self.notes = NotesPrint(self.opts["mf"], self.opts["conum"],
self.opts["conam"], "RCA")
if not self.notes.data:
return
return True
def mainProcess(self):
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
if len(dat[2].strip()) > 7:
continue
desc = textFormat(dat[5], width=50)
for n, d in enumerate(desc):
if not n:
acc = dat[2][:7].strip()
nam = self.sql.getRec("rcaowm",
cols=["rom_name"],
where=[("rom_cono", "=",
self.opts["conum"]),
("rom_acno", "=", acc)],
limit=1)
if not nam:
continue
data.append([
acc, nam[0], 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 = ["Rental's Masterfile Notes Listing"]
cols = [["a", "NA", 7, "Acc-Num", "y"],
["b", "NA", 30, "Acc-Name", "y"],
["c", "NA", 20, "User-Name", "y"],
["d", "NA", 10, "Cap-Date", "y"], ["e", "UA", 1, "F", "y"],
["f", "NA", 10, "Act-Date", "y"],
["g", "NA", 50, "Details", "y"]]
RepPrt(self.opts["mf"],
conum=self.opts["conum"],
conam=self.opts["conam"],
name=name,
tables=data,
heads=head,
cols=cols,
ttype="D",
repprt=self.notes.df.repprt,
repeml=self.notes.df.repeml,
fromad=self.fromad)
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 si3090(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, ["slsiv1", "drsmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.s_dte = int(self.opts["period"][1][0])
self.e_dte = int(self.opts["period"][2][0])
return True
def mainProcess(self):
r1s = (("Both", "B"), ("Invoices", "I"), ("Credit Notes", "C"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Document Type", "", "B", "Y",
self.doType, None, None, None),
(("T", 0, 1, 0), "ID1", 10, "From Date", "", self.s_dte, "N",
self.doDate, None, None, ("notzero", )),
(("T", 0, 2, 0), "ID1", 10, "To Date", "", self.e_dte, "N",
self.doDate, None, None, ("notzero", )))
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 doType(self, frt, pag, r, c, p, i, w):
self.type = w
if self.type == "C":
self.dtyp = "Credit Notes"
elif self.type == "I":
self.dtyp = "Invoices"
else:
self.dtyp = "Documents"
def doDate(self, frt, pag, r, c, p, i, w):
if p == 1:
self.sdte = w
else:
self.edte = w
def doEnd(self):
data = []
self.df.closeProcess()
hed = ["Cancelled Sales %s" % self.dtyp]
tab = ["slsiv1", "drsmst"]
col = [
"si1_rtn", "si1_docno", "si1_date", "si1_acno", "drm_name",
"si1_invno"
]
whr = [("si1_cono", "=", self.opts["conum"]),
("si1_date", "between", self.sdte, self.edte),
("drm_cono=si1_cono", ), ("drm_chain=si1_chain", ),
("drm_acno=si1_acno", )]
if self.type == "B":
whr.append(("si1_rtn", "in", ("C", "I")))
else:
whr.append(("si1_rtn", "=", self.type))
whr.append(("si1_invno", "=", "cancel"))
odr = "si1_rtn, si1_docno"
data = self.sql.getRec(tables=tab, cols=col, where=whr, order=odr)
cols = []
dics = self.sql.slsiv1_dic.copy()
dics.update(self.sql.drsmst_dic)
for c in col[:5]:
cols.append((c, dics[c][2], dics[c][3], dics[c][5]))
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
tables=data,
ttype="D",
heads=hed,
cols=cols)
self.opts["mf"].closeLoop()
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 sl2030(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, ["wagctl", "waglmf"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
glint = wagctl["ctw_glint"]
if 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.glctl = (ctlctl["wag_slc"], ctlctl["wag_sli"],
ctlctl["wag_sli"])
else:
self.glctl = None
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
fld = ((("T", 0, 0, 0), "ID1", 10, "Transaction Date", "", self.sysdtw,
"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):
self.trdate = w
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
def endPage0(self):
self.df.closeProcess()
recs = self.sql.getRec("waglmf",
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_rate", ">", 0),
("wlm_start", "<", self.trdate)],
order="wlm_empno, wlm_loan")
p = ProgressBar(self.opts["mf"].body, mxs=len(recs))
for num, rec in enumerate(recs):
p.displayProgress(num)
curdt = int(self.trdate / 100)
batch = "L%s" % curdt
LoanInterest("S",
self.opts["mf"].dbm,
rec,
update="Y",
batch=batch,
curdt=curdt,
tdate=self.trdate,
glctl=self.glctl,
capnm=self.opts["capnm"])
p.closeProgress()
self.sql.updRec("wagctl",
cols=["ctw_i_date"],
data=[self.trdate],
where=[("ctw_cono", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
def exitPage0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
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])
