def doCopyTables(self):
p1 = ProgressBar(self.opts["mf"].body,
mxs=len(self.tables),
typ="Copying Database")
for num, tab in enumerate(self.tables):
p1.displayProgress(num)
if tab[0] not in ("ftable", "ffield"):
if tab[0] not in tabdic:
print("NO", tab, "in tabdic")
continue
self.opts["mf"].updateStatus("Adding Table %s" % tab[0])
opts = [("-t", tab[0]), ("-x", False)]
DBCreate(dbm=self.opts["mf"].dbm, opts=opts)
self.opts["mf"].updateStatus("Populating Table %s" % tab[0])
sqt = Sql(self.opts["mf"].dbm,
tab[0],
prog=self.__class__.__name__)
try:
sqt.delRec(tab[0])
except:
pass
sqf = Sql(self.dbm, tab[0], prog=self.__class__.__name__)
dat = sqf.getRec(tables=tab[0])
if dat:
p2 = ProgressBar(self.opts["mf"].body,
inn=p1,
mxs=len(dat),
typ="Populating Table %s" % tab[0])
sqt.insRec(tab[0], data=dat, dofmt=False, pbar=p2)
self.opts["mf"].dbm.commitDbase()
p2.closeProgress()
p1.closeProgress()
def doFixAge(self):
if self.opts["mf"] and self.opts["mf"].window:
spl = SplashScreen(self.opts["mf"].body,
"Checking Age Records\n\nPlease Wait")
self.opts["mf"].updateStatus("Checking Age Records")
elif self.opts["bar"]:
print("Checking Age Records .... Please Wait")
for sss in ("crs", "drs"):
sql = Sql(self.dbm, ["%smst" % sss, "%sage" % sss], prog=__name__)
if sss == "drs":
col = ["dra_cono", "dra_chain", "dra_acno"]
grp = "dra_cono, dra_chain, dra_acno"
else:
col = ["cra_cono", "cra_acno"]
grp = "cra_cono, cra_acno"
recs = sql.getRec("%sage" % sss, cols=col, group=grp)
for rec in recs:
whr = []
for n, c in enumerate(col):
whr.append((c.replace("a_", "m_"), "=", rec[n]))
if not sql.getRec("%smst" % sss, where=whr):
sql.delRec("%sage" % sss, cols=col, data=rec)
self.dbm.commitDbase()
if self.opts["mf"] and self.opts["mf"].window:
self.opts["mf"].updateStatus("")
spl.closeSplash()
class ln1010(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):
self.sql = Sql(self.opts["mf"].dbm, ["chglog", "lonmf1", "lonmf2"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
lonctl = gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(self):
con = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols":
(("lm1_acno", "", 0, "Code"), ("lm1_name", "", 0, "Surname", "Y"),
("lm1_email", "", 0, "Email Address"))
}
if "args" in self.opts:
fld = [(("T", 0, 0, 0), "OUA", 7, "Account Code"),
(("T", 0, 1, 0), "ITX", 30, "Name", "", "", "N",
self.doName, None, None, ("notblank", ))]
self.newacc = True
self.acno = None
else:
fld = [(("T", 0, 0, 0), "IUA", 7, "Account Code", "", "", "Y",
self.doAcno, con, None, None),
(("T", 0, 1, 0), "ITX", 30, "Name", "", "", "N",
self.doName, None, self.doDelete, ("notblank", ))]
fld.extend([(("T", 0, 2, 0), "ITX", 30, "Address Line 1", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 3, 0), "ITX", 30, "Address Line 2", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 4, 0), "ITX", 30, "Address Line 3", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 5, 0), "ITX", 4, "Postal Code", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 6, 0), "ITX", 20, "Telephone Number", "", "",
"N", None, None, None, ("efld", )),
(("T", 0, 7, 0), "ITX", 20, "Fax Number", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 8, 0), "ITX", 20, "Mobile Number", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 9, 0), "ITX", 30, "E-Mail Address", "", "", "N",
None, None, None, ("email", ))])
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2), ("T", 0, 1)),
("Quit", None, self.doExit, 1, None, None))
tnd = ((self.doAccept, "N"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
def doClick(self, *opts):
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doAcno(self, frt, pag, r, c, p, i, w):
if w:
self.oldacc = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=",
self.opts["conum"]),
("lm1_acno", "=", w)],
limit=1)
if not self.oldacc:
return "Invalid Account Number"
self.acno = w
self.name = self.oldacc[self.sql.lonmf1_col.index("lm1_name")]
self.email = self.oldacc[self.sql.lonmf1_col.index("lm1_email")]
for num, dat in enumerate(self.oldacc[1:-1]):
self.df.loadEntry("T", 0, num, data=dat)
self.newacc = False
else:
yn = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Loan Account?",
default="no")
if yn == "no":
return "Invalid Account Number"
self.newacc = True
def doName(self, frt, pag, r, c, p, i, w):
if self.newacc:
chk = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_name", "=", w)],
limit=1)
if chk:
return "An Account With This Name Already Exists"
for seq in range(1, 100):
self.acno = genAccNum(w, seq)
chk = self.sql.getRec("lonmf1",
where=[("lm1_cono", "=",
self.opts["conum"]),
("lm1_acno", "=", self.acno)],
limit=1)
if not chk:
break
self.df.loadEntry(frt, pag, p - 1, data=self.acno)
def doDelete(self):
chk = self.sql.getRec("lonmf2",
cols=["count(*)"],
where=[("lm2_cono", "=", self.opts["conum"]),
("lm2_acno", "=", self.acno)],
limit=1)
if chk[0]:
return "Loans Exist, Not Deleted"
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("lonmf1",
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_acno", "=", self.acno)])
self.sql.insRec("chglog",
data=[
"lonmf1", "D",
"%03i%-7s" % (self.opts["conum"], self.acno), "",
dte, self.opts["capnm"], "", "", "", 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)
return
# Create/Update Record
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
data = [self.opts["conum"]]
for x in range(len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.newacc:
self.sql.insRec("lonmf1", data=data)
elif data != self.oldacc[:len(data)]:
col = self.sql.lonmf1_col
data.append(self.oldacc[col.index("lm1_xflag")])
self.sql.updRec("lonmf1",
data=data,
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_acno", "=", self.acno)])
for num, dat in enumerate(self.oldacc):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"lonmf1", "U",
"%03i%-7s" % (self.opts["conum"], self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if "args" in self.opts:
self.doExit()
else:
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class bc6010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.oldtab = self.opts["args"][0]
self.newtab = self.opts["args"][1]
self.doProcess()
else:
self.mainProcess()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.tables = (("bwldrt", "bdt_cono", "bdt_tab", "bdt_team1",
"bdt_team2", "bdt_team3"), ("bwlent", "bce_cono",
"bce_scod"),
("bwlflm", "bfm_cono", "bfm_captain"),
("bwlflt", "bft_cono", "bft_skip", "bft_player"),
("bwlgme", "bcg_cono", "bcg_scod",
"bcg_ocod"), ("bwltab", "btb_cono", "btb_tab"))
tabs = []
for tab in self.tables:
if tab[0] not in tabs:
tabs.append(tab[0])
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.mlint = bwlctl["ctb_mlint"]
self.samen = bwlctl["ctb_samen"]
if self.mlint == "Y" and self.samen == "Y":
return
self.mstart = bwlctl["ctb_mstart"]
self.fstart = bwlctl["ctb_fstart"]
self.nstart = bwlctl["ctb_nstart"]
return True
def mainProcess(self):
tab = {
"stype":
"R",
"tables": ("bwltab", ),
"cols": (("btb_tab", "", 0, "Tab-No"),
("btb_surname", "", 0, "Surname", "Y"), ("btb_names", "",
0, "Names")),
"where": [("btb_cono", "=", self.opts["conum"])],
"order":
"btb_tab"
}
fld = [(["T", 0, 0, 0], "I@btb_tab", 0, "Old Tab", "Old Tab Number",
"", "Y", self.doOldTab, tab, None, ("notzero", )),
(["T", 0, 0, 18], "ONA", 30, ""),
(["T", 0, 1, 0], "I@btb_tab", 0, "New Tab", "New Tab Number",
"", "Y", self.doNewTab, None, None, ("notzero", ))]
tnd = ((self.doProcess, "y"), )
txt = (self.doExit, )
but = [("Generate", None, self.doGenerate, 0, ("T", 0, 1), ("T", 0, 2),
"Auto Generate New Tab Numbers Based on Names and Gender")]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
butt=but)
def doOldTab(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if not acc:
return "Invalid Tab Number, Does Not exist"
self.oldtab = w
self.gender = acc[self.sql.bwltab_col.index("btb_gender")]
if acc[4]:
self.df.loadEntry(frt,
pag,
p + 1,
data="%s, %s" % (acc[3], acc[4].split()[0]))
else:
self.df.loadEntry(frt, pag, p + 1, data=acc[3])
def doNewTab(self, frt, pag, r, c, p, i, w):
if self.oldtab < self.nstart:
if self.mstart < self.fstart:
if self.gender == "M" and w >= self.fstart:
return "Invalid Male Tab Number"
elif self.gender == "F" and w < self.fstart:
return "Invalid Female Tab Number"
elif self.gender == "M" and w >= self.mstart:
return "Invalid Male Tab Number"
elif self.gender == "F" and w < self.mstart:
return "Invalid Female Tab Number"
elif w < self.nstart:
return "Invalid Non-Member Tab Number"
acc = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", w)],
limit=1)
if acc:
return "Invalid Tab Number, Already Exists"
self.newtab = w
def doGenerate(self):
self.opts["mf"].updateStatus("")
but = (("Members", "M"), ("Non Members", "N"), ("All", "A"), ("None",
"X"))
ok = askChoice(self.opts["mf"].body, "ARE YOU SURE???",
"Are you Certain this is what you want To Do? This will "\
"Automatically Generate New Tab Numbers For Selected Range "\
"Based On Member's Names and Gender!", butt=but, default="None")
if ok == "X":
self.df.focusField("T", 0, 1)
return
self.df.closeProcess()
splash = SplashScreen(self.opts["mf"].body,
"Generating New Tab Numbers ... Please Wait")
# Create temporary tables
for ot in self.tables:
tt = "%s_temp" % ot[0]
self.sql.sqlRec("Create table %s as Select * from %s "\
"where %s = %s" % (tt, ot[0], ot[1], self.opts["conum"]))
self.sql.delRec(ot[0], where=[(ot[1], "=", self.opts["conum"])])
mem = self.sql.sqlRec("Select * from bwltab_temp where btb_cono = %s "\
"and btb_tab < %s order by btb_surname, btb_names" %
(self.opts["conum"], self.nstart))
non = self.sql.sqlRec("Select * from bwltab_temp where btb_cono = %s "\
"and btb_tab >= %s order by btb_surname, btb_names" %
(self.opts["conum"], self.nstart))
mstart = self.mstart
fstart = self.fstart
nstart = self.nstart
key = {}
for tab in mem:
otb = tab[self.sql.bwltab_col.index("btb_tab")]
if ok in ("A", "M"):
gdr = tab[self.sql.bwltab_col.index("btb_gender")]
if gdr == "M":
new = mstart
mstart += 1
else:
new = fstart
fstart += 1
key[otb] = new
else:
key[otb] = otb
for tab in non:
otb = tab[self.sql.bwltab_col.index("btb_tab")]
if ok in ("A", "N"):
key[otb] = nstart
nstart += 1
else:
key[otb] = otb
for ot in self.tables:
tt = "%s_temp" % ot[0]
cc = getattr(self.sql, "%s_col" % ot[0])
recs = self.sql.sqlRec("Select * from %s" % tt)
for rec in recs:
for k in ot[2:]:
c = rec[cc.index(k)]
if c not in key:
continue
rec[cc.index(k)] = key[c]
self.sql.insRec(ot[0], data=rec)
self.sql.sqlRec("Drop table %s" % tt)
self.opts["mf"].dbm.commitDbase(ask=True)
splash.closeSplash()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doProcess(self):
for tab in self.tables:
for x in range(len(tab[2:])):
whr = [(tab[1], "=", self.opts["conum"]),
(tab[x + 2], "=", self.oldtab)]
dat = [self.newtab]
col = [tab[x + 2]]
self.sql.updRec(tab[0], where=whr, data=dat, cols=col)
if "args" not in self.opts:
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].dbm.commitDbase(ask=True)
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class bc2070(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, ["bwlcmp", "bwltab", "bwlent",
"bwltyp", "bwlpts", "bwlgme"], prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
bcp = {
"stype": "R",
"tables": ("bwlcmp",),
"cols": (
("bcm_code", "", 0, "Cod"),
("bcm_name", "", 0, "Name", "Y"),
("bcm_date", "", 0, "Date")),
"where": [("bcm_cono", "=", self.opts["conum"])]}
gme = {
"stype": "R",
"tables": ("bwlgme",),
"cols": (
("bcg_game", "", 0, "GC"),
("bcg_type", "", 0, "T"),
("bcg_date", "", 0, "Date")),
"where": [("bcg_cono", "=", self.opts["conum"])],
"whera": [("T", "bcg_ccod", 0, 0)],
"group": "bcg_game"}
skp = {
"stype": "R",
"tables": ("bwlent", "bwltab", "bwlgme"),
"cols": (
("btb_tab", "", 0, "Cod"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names"),
("bcg_rink", "", 0, "RK")),
"where": [
("bce_cono", "=", self.opts["conum"]),
("btb_cono=bce_cono",),
("btb_tab=bce_scod",),
("bcg_cono=bce_cono",),
("bcg_scod=bce_scod",),
("bcg_ocod<900000",),
("bcg_sfor=0 and bcg_sagt=0",)],
"whera": [
("T", "bce_ccod", 0, 0),
("T", "bcg_ccod", 0, 0),
("T", "bcg_game", 2, 0)],
"order": "bcg_rink"}
fld = (
(("T",0,0,0),"I@bcm_code",0,"","",
"","Y",self.doCmpCod,bcp,None,("notzero",)),
(("T",0,0,0),"ONA",30,""),
(("T",0,0,0),"I@bcg_game",0,"Game Number","",
"","N",self.doGamCod,gme,None,("efld",)),
(("T",0,0,0),"IUI",2,"Ends Completed","",
0,"N",self.doEndsFin,None,None,("efld",)),
(("C",0,0,0),"I@bcg_scod",0,"","",
"","N",self.doSkpCod,skp,None,("efld",)),
(("C",0,0,0),"ONA",30,"Skp-Name"),
(("C",0,0,0),"I@bcg_sfor",0,"","",
"","N",self.doShots,None,None,("efld",)),
(("C",0,0,0),"I@bcg_points",0,"","",
"","N",self.doPoints,None,None,("efld",)),
(("C",0,0,0),"O@bcg_ocod",0,""),
(("C",0,0,0),"ONA",30,"Opp-Name"),
(("C",0,0,0),"I@bcg_sagt",0,"","",
"","N",self.doShots,None,None,("efld",)),
(("C",0,0,0),"I@bcg_points",0,"","",
"","N",self.doPoints,None,None,("efld",)))
but = (("Quit",None,self.doQuit,1,None,None),)
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
cnd = ((self.doEnd,"y"),)
cxt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
rows=(19,), eflds=fld, butt=but, tend=tnd, txit=txt,
cend=cnd, cxit=cxt)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("bwlcmp", cols=["bcm_name", "bcm_type"],
where=[("bcm_cono", "=", self.opts["conum"]), ("bcm_code", "=",
w)], limit=1)
if not com:
return "Invalid Competition Code"
self.ccod = w
self.code = com[1]
self.df.loadEntry(frt, pag, p + 1, data=com[0])
if not self.code:
bwltyp = [self.opts["conum"], 0, "KO", "K", 1, 0, 21,
"N", 0, "N", "", 0, 0, "N", "N", ""]
else:
bwltyp = self.sql.getRec("bwltyp", where=[("bct_cono", "=",
self.opts["conum"]), ("bct_code", "=", com[1])], limit=1)
self.cfmat = bwltyp[self.sql.bwltyp_col.index("bct_cfmat")]
self.groups = bwltyp[self.sql.bwltyp_col.index("bct_groups")]
self.grgame = bwltyp[self.sql.bwltyp_col.index("bct_grgame")]
if self.cfmat == "R":
games = self.sql.getRec("bwlgme", cols=["count(*)"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=", 1)],
group="bcg_group")
self.games = 0
for gme in games:
if gme[0] > self.games:
self.games = gme[0]
self.games -= 1
elif self.cfmat in ("D", "K"):
totskp = self.sql.getRec("bwlent", cols=["count(*)"],
where=[("bce_cono", "=", self.opts["conum"]),
("bce_ccod", "=", self.ccod)], limit=1)[0]
pwrs = 2
self.games = 1
while pwrs < totskp:
self.games += 1
pwrs = pwrs * 2
else:
self.games = bwltyp[self.sql.bwltyp_col.index("bct_games")]
self.ends = bwltyp[self.sql.bwltyp_col.index("bct_ends")]
chk = self.sql.getRec("bwlgme", cols=["bcg_game",
"sum(bcg_sfor)", "sum(bcg_sagt)", "sum(bcg_points)"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod", "=",
self.ccod), ("bcg_aflag", "in", ("", "D"))],
group="bcg_game", order="bcg_game")
for game in chk:
self.gcod = game[0]
if not game[1] and not game[2] and not game[3]:
self.df.loadEntry(frt, pag, p + 2, data=self.gcod)
break
self.df.loadEntry(frt, pag, p + 3, data=self.ends)
def doGamCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("bwlgme", cols=["bcg_aflag",
"sum(bcg_ocod)"], where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=", w)],
group="bcg_aflag")
if not chk:
return "Invalid Game Number"
for ck in chk:
if not ck[0] and not ck[1]:
return "Invalid Game Number, Not Yet Drawn"
if w != self.games:
col = [
"bcg_game",
"bcg_type",
"sum(bcg_ocod)",
"sum(bcg_sfor)",
"sum(bcg_points)"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", ">", w)]
drwn = self.sql.getRec("bwlgme", cols=col, where=whr,
group="bcg_game, bcg_type", order="bcg_game")
drawn = []
for n, d in enumerate(drwn):
if d[1] == "S" and d[2]:
if d[3] or d[4]:
drawn = "X"
break
drawn.append(d[0])
if drawn == "X":
showError(self.opts["mf"].body, "Error",
"Results Have Already Been Captured for Game %s" % d[0])
return "Completed SvS Game %s" % d[0]
elif drawn:
if len(drawn) == 1:
text = "Game %s" % drawn[0]
plural = "Draw"
word = "Has"
else:
text = "Games"
for d in drawn:
text += " %s" % d
plural = "Draws"
word = "Have"
ok = askQuestion(self.opts["mf"].body, head="Draw Done",
mess="""Strength v Strength %s %s Been Drawn.
Do You Want to Delete the %s and Alter This Game's Results?
You Will Then Have to Re-Print Reports and Re-Draw %s.
If You Continue and Have Not Made a Backup You Will Not be Able to Restore.
Do You Still Want to Continue?""" % (text, word, plural, text), default="no")
if ok == "no":
return "rf"
col = ["bcg_date", "bcg_ocod", "bcg_rink"]
dat = [0, 0, ""]
if self.groups == "Y" and w == self.grgame:
col.append("bcg_group")
dat.append(0)
col.extend(["bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"])
dat.extend([0, 0, 0, 0, 0, 0, ""])
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "in", tuple(drawn))]
self.sql.updRec("bwlgme", cols=col, data=dat, where=whr)
self.opts["mf"].dbm.commitDbase()
elif chk[0] in ("A", "S"):
return "Invalid Game Number, Abandoned or Skipped"
self.gcod = w
gtyp = self.sql.getRec("bwlgme", cols=["bcg_type"],
where=[("bcg_cono", "=", self.opts["conum"]), ("bcg_ccod",
"=", self.ccod), ("bcg_game", "=", w)], limit=1)[0]
bwlpts = self.sql.getRec("bwlpts", where=[("bcp_cono",
"=", self.opts["conum"]), ("bcp_code", "=", self.code),
("bcp_ptyp", "=", gtyp)], limit=1)
if not bwlpts:
bwlpts = [self.opts["conum"], 0, "D", "N", 0, "N",
0, 0, 1, "N", 0, 0, ""]
self.skins = bwlpts[self.sql.bwlpts_col.index("bcp_skins")]
self.sends = bwlpts[self.sql.bwlpts_col.index("bcp_sends")]
self.ponly = bwlpts[self.sql.bwlpts_col.index("bcp_p_only")]
self.epts = bwlpts[self.sql.bwlpts_col.index("bcp_e_points")]
self.spts = bwlpts[self.sql.bwlpts_col.index("bcp_s_points")]
self.gpts = bwlpts[self.sql.bwlpts_col.index("bcp_g_points")]
self.bpts = bwlpts[self.sql.bwlpts_col.index("bcp_bonus")]
dif = bwlpts[self.sql.bwlpts_col.index("bcp_win_by")]
self.win_by = [dif, dif * -1]
dif = bwlpts[self.sql.bwlpts_col.index("bcp_lose_by")]
self.lose_by = [dif, dif * -1]
def doEndsFin(self, frt, pag, r, c, p, i, w):
self.bonus = self.bpts
if w != self.ends:
if not w:
but = (("Exit",1),("Skipped",2),("Abandoned",3))
ok = askChoice(self.opts["mf"].body, head="Zero Ends",
mess="No Ends Completed, Choose Option", butt=but)
if ok == 1:
return "rf"
elif ok == 2:
self.sql.updRec("bwlgme", cols=["bcg_aflag"], data=["S"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=",
self.gcod)])
elif ok == 3:
self.sql.updRec("bwlgme", cols=["bcg_ocod", "bcg_rink",
"bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"], data=[0, "", 0, 0, 0, 0, 0, 0, "A"],
where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_game", "=",
self.gcod)])
self.opts["mf"].dbm.commitDbase()
return "xt"
ok = askQuestion(self.opts["mf"].body, head="Shortened",
mess="Was This Game Shortened?", default="no")
if ok == "no":
return "rf"
if self.bonus == "Y":
ok = askQuestion(self.opts["mf"].body, head="Bonus Points",
mess="Must Bonus Points Still be Awarded?", default="no")
if ok == "no":
self.bonus = "N"
self.totpts = (w * self.epts) + self.gpts
if self.skins == "Y":
self.totpts = self.totpts + (int(w / self.sends) * self.spts)
if self.bonus == "Y":
self.maxpts = float(ASD(self.totpts) + ASD(1))
else:
self.maxpts = self.totpts
def doSkpCod(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec(tables=["bwlgme", "bwltab"], cols=["btb_surname",
"btb_names", "bcg_ocod", "bcg_sfor", "bcg_sagt",
"bcg_points"], where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", w), ("bcg_game",
"=", self.gcod), ("btb_tab=bcg_scod",)], limit=1)
if not chk:
return "Invalid Skip Code"
if chk[3] or chk[4] or chk[5]:
ok = askQuestion(self.opts["mf"].body, head="Already Entered",
mess="""This Card Has Already Been Entered, Re-Enter?
Shots For: %s
Shots Against: %s
Points: %s""" % (chk[3], chk[4], chk[5]),
default="no")
if ok == "no":
return "rf"
self.reenter = True
else:
self.reenter = False
self.skp = w
self.opp = chk[2]
if self.opp > 900000:
return "This Skip Had a Bye"
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 1, data=name)
if self.ponly == "N":
self.df.loadEntry(frt, pag, p + 2, data=chk[3])
self.df.loadEntry(frt, pag, p + 3, data=chk[5])
self.df.loadEntry(frt, pag, p + 4, data=self.opp)
if self.cfmat in ("D", "K"):
opp = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.opp)], limit=1)
chk = opp + [chk[4], chk[3], 0]
else:
chk = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=["btb_surname", "btb_names", "bcg_sfor",
"bcg_sagt", "bcg_points"], where=[("bcg_cono",
"=", self.opts["conum"]), ("bcg_ccod", "=", self.ccod),
("bcg_scod", "=", self.opp), ("bcg_game", "=", self.gcod),
("btb_tab=bcg_scod",)], limit=1)
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 5, data=name)
if self.ponly == "N":
self.df.loadEntry(frt, pag, p + 6, data=chk[2])
self.df.loadEntry(frt, pag, p + 7, data=chk[4])
if self.ponly == "Y":
self.mpts = self.totpts
return "sk2"
def doShots(self, frt, pag, r, c, p, i, w):
if i == 2:
self.s_for = w
if self.cfmat in ("D", "K", "R"):
self.p_for = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
if not self.s_for or (not self.totpts and self.bonus != "Y"):
self.p_for = w
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
else:
self.s_agt = w
if self.cfmat in ("D", "K"):
self.p_agt = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
if self.cfmat == "R":
if self.s_for == self.s_agt:
self.p_for = self.p_agt = .5
elif self.s_for > self.s_agt:
self.p_for = 1
self.p_agt = 0
else:
self.p_for = 0
self.p_agt = 1
self.df.loadEntry(frt, pag, p - 3, data=self.p_for)
self.df.loadEntry(frt, pag, p + 1, data=self.p_agt)
return "sk1"
if not self.s_agt or (not self.totpts and self.bonus != "Y"):
self.p_agt = w
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
self.mpts = self.totpts
if self.bonus == "N":
return
diff = float(ASD(self.s_for) - ASD(self.s_agt))
if not diff:
return
if diff > self.win_by[0] or diff < self.win_by[1]:
self.mpts = float(ASD(self.mpts) + ASD(1))
elif diff < self.lose_by[0] and diff > self.lose_by[1]:
self.mpts = float(ASD(self.mpts) + ASD(1))
def doPoints(self, frt, pag, r, c, p, i, w):
if w and w % 1 not in (0.0, 0.5):
return "Invalid Decimal in Points"
if w > self.maxpts:
return "Invalid Points, Exceed Maximum"
if i == 3:
self.p_for = w
self.df.loadEntry(frt, pag, p + 1, data=self.opp)
chk = self.sql.getRec("bwltab", cols=["btb_surname",
"btb_names"], where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.opp)], limit=1)
if chk[1]:
name = "%s, %s" % tuple(chk[:2])
else:
name = chk[0]
self.df.loadEntry(frt, pag, p + 2, data=name)
if self.ponly == "Y":
self.s_for = w
return "sk3"
else:
return "sk2"
if not w:
self.p_agt = float(ASD(self.mpts) - ASD(self.p_for))
self.df.loadEntry(frt, pag, p, data=self.p_agt)
else:
self.p_agt = w
if self.ponly == "Y":
self.s_agt = self.p_agt
tot = float(ASD(self.p_for) + ASD(self.p_agt))
if tot != self.mpts:
return "Invalid Total Points (%s s/b %s)" % (tot, self.mpts)
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
self.doLoadCards()
else:
if self.ponly == "Y" and not self.p_for and not self.p_agt:
aflag = "S"
elif self.ponly == "N" and not self.s_for and not self.s_agt:
aflag = "S"
else:
aflag = ""
col = [
"bcg_sfor", "bcg_sagt", "bcg_points",
"bcg_a_sfor", "bcg_a_sagt", "bcg_a_points",
"bcg_aflag"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod)]
w = whr[:]
w.append(("bcg_scod", "=", self.skp))
self.sql.updRec("bwlgme", cols=col, data=[self.s_for, self.s_agt,
self.p_for, self.s_for, self.s_agt, self.p_for, aflag],
where=w)
if self.cfmat not in ("D", "K"):
w = whr[:]
w.append(("bcg_scod", "=", self.opp))
self.sql.updRec("bwlgme", cols=col, data=[self.s_agt,
self.s_for, self.p_agt, self.s_agt, self.s_for,
self.p_agt, aflag], where=w)
self.opts["mf"].dbm.commitDbase()
if self.reenter:
self.doLoadCards()
else:
self.df.advanceLine(0)
def doLoadCards(self):
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod)]
if self.ponly == "Y":
whr.append(("bcg_points", ">", 0))
else:
whr.append(("(", "bcg_sfor", ">", 0, "or",
"bcg_sagt", ">", 0, ")"))
recs = self.sql.getRec("bwlgme", cols=["bcg_scod", "bcg_ocod"],
where=whr, order="bcg_scod")
if not recs:
return
self.df.clearFrame("C", 0)
self.df.focusField("C", 0, 1)
skips = []
seq = 0
for rec in recs:
if rec[0] in skips:
continue
skips.extend(rec)
col = [
"btb_surname", "btb_names",
"bcg_sfor", "bcg_sagt", "bcg_points"]
skp = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=col, where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[0]),
("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)], limit=1)
idx = seq * 8
self.df.loadEntry("C", 0, idx, data=rec[0])
if skp[1]:
name = "%s, %s" % tuple(skp[:2])
else:
name = skp[0]
self.df.loadEntry("C", 0, idx + 1, data=name)
self.df.loadEntry("C", 0, idx + 2, data=skp[2])
self.df.loadEntry("C", 0, idx + 3, data=skp[4])
if self.cfmat in ("D", "K"):
tab = self.sql.getRec("bwltab", cols=col[:2],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", rec[1])], limit=1)
opp = tab + [skp[3], skp[4], 0]
else:
opp = self.sql.getRec(tables=["bwlgme", "bwltab"],
cols=col, where=[("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod), ("bcg_scod", "=", rec[1]),
("bcg_game", "=", self.gcod), ("btb_tab=bcg_scod",)],
limit=1)
self.df.loadEntry("C", 0, idx + 4, data=rec[1])
if opp[1]:
name = "%s, %s" % tuple(opp[:2])
else:
name = opp[0]
self.df.loadEntry("C", 0, idx + 5, data=name)
self.df.loadEntry("C", 0, idx + 6, data=opp[2])
self.df.loadEntry("C", 0, idx + 7, data=opp[4])
self.df.advanceLine(0)
if seq < 17:
seq += 1
def doExit(self):
if self.df.frt == "C" and self.df.col != 1:
chk = self.sql.getRec("bwlgme", where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod), ("bcg_game",
"=", self.gcod), ("bcg_aflag", "in", ("", "D"))])
for c in chk:
scod = c[self.sql.bwlgme_col.index("bcg_scod")]
ocod = c[self.sql.bwlgme_col.index("bcg_ocod")]
if scod > 900000 or ocod > 900000:
continue
if self.ponly == "Y":
fors = c[self.sql.bwlgme_col.index("bcg_points")]
agts = self.sql.getRec("bwlgme",
cols=["bcg_points"], where=[("bcg_cono", "=",
self.opts["conum"]), ("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod), ("bcg_scod",
"=", ocod)], limit=1)[0]
else:
fors = c[self.sql.bwlgme_col.index("bcg_sfor")]
agts = c[self.sql.bwlgme_col.index("bcg_sagt")]
if not fors and not agts:
self.df.focusField(self.df.frt, self.df.pag, self.df.col,
err="Missing Score Card for Skips %s and %s" % (scod,
ocod))
return
if self.cfmat in ("D", "K") and self.gcod != self.games:
# Delete Next Round's Records
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod)]
w = whr[:]
w.append(("bcg_game", ">", self.gcod))
self.sql.delRec("bwlgme", where=w)
# Create Next Round's Records
whr.append(("bcg_game", "=", self.gcod))
odr = "bcg_group, bcg_pair, bcg_scod"
g = self.sql.bwlgme_col
for grp in range(1, 3):
w = whr[:]
w.append(("bcg_group", "=", grp))
recs = self.sql.getRec("bwlgme", where=w, order=odr)
for num in range(0, len(recs), 2):
pair = int(num / 2) + 1
rec1 = copyList(recs[num])
if len(recs) == 1:
w = whr[:]
w.append(("bcg_group", "=", 2))
rec2 = self.sql.getRec("bwlgme", where=w,
order=odr, limit=1)
grp = 2
else:
rec2 = copyList(recs[num + 1])
skp1 = rec1[g.index("bcg_scod")]
opp1 = rec1[g.index("bcg_ocod")]
for1 = rec1[g.index("bcg_sfor")]
agt1 = rec1[g.index("bcg_sagt")]
skp2 = rec2[g.index("bcg_scod")]
opp2 = rec2[g.index("bcg_ocod")]
for2 = rec2[g.index("bcg_sfor")]
agt2 = rec2[g.index("bcg_sagt")]
if opp1 > 900000:
pl1 = skp1
elif for1 > agt1:
pl1 = skp1
else:
pl1 = opp1
if opp2 > 900000:
pl2 = skp2
elif for2 > agt2:
pl2 = skp2
else:
pl2 = opp2
dat = [self.opts["conum"], self.ccod, pl1,
self.gcod + 1, "D", 0, pl2, "", grp, 0,
0, 0.0, 0, 0, 0.0, "", 0, pair]
self.sql.insRec("bwlgme", data=dat)
if len(recs) == 1:
break
self.opts["mf"].dbm.commitDbase()
if self.cfmat in ("D", "K"):
callModule(self.opts["mf"], self.df, "bc2050",
coy=[self.opts["conum"], self.opts["conam"]],
args=self.ccod)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doQuit(self, event=None):
col = ["count(*)"]
whr = [
("bcg_cono", "=", self.opts["conum"]),
("bcg_ccod", "=", self.ccod),
("bcg_game", "=", self.gcod),
("bcg_scod", "<", 900000),
("bcg_ocod", "<", 900000),
("bcg_sfor=0 and bcg_sagt=0",)]
chk = self.sql.getRec("bwlgme", cols=col, where=whr, limit=1)
if chk[0]:
ok = askQuestion(self.opts["mf"].body, "Quit Capture",
"Are You Sure that you would like to Quit before "\
"capturing All Results?", default="no")
if ok == "no":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.df.closeProcess()
self.opts["mf"].closeLoop()
class stc210(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,
"struoi",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
unm = {
"stype":
"R",
"tables": ("struoi", ),
"cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0,
"Description", "Y")),
"where": [("unm_cono", "=", self.opts["conum"])]
}
self.fld = ((("T", 0, 0, 0), "INA", 10, "Unit Of Issue", "", "", "N",
self.doUnit, unm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, 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)))
tnd = ((self.doEnd, "Y"), )
txt = (self.closeProcess, )
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doUnit(self, frt, pag, r, c, p, i, w):
self.uoi = w
self.old = self.sql.getRec("struoi",
where=[("unm_cono", "=",
self.opts["conum"]),
("unm_unit", "=", self.uoi)],
limit=1)
if not self.old:
self.new = "Y"
else:
self.new = "N"
desc = self.old[self.sql.struoi_col.index("unm_desc")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
def doDelete(self):
self.sql.delRec("struoi",
where=[("unm_cono", "=", self.opts["conum"]),
("unm_unit", "=", self.uoi)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("struoi", data=data)
elif data != self.old[:len(data)]:
col = self.sql.struoi_col
data.append(self.old[col.index("unm_xflag")])
self.sql.updRec("struoi",
data=data,
where=[("unm_cono", "=", self.opts["conum"]),
("unm_unit", "=", self.uoi)])
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 closeProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ms1040(object):
def __init__(self, **opts):
self.opts = opts
if "args" in opts:
self.code = opts["args"]
else:
self.code = None
if self.setVariables():
self.mainProcess()
if self.code:
self.df.doKeyPressed("T", 0, 0, self.code)
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, ["ctlvmf", "ctlvrf", "ctlvtf",
"chglog"], prog=self.__class__.__name__)
if self.sql.error:
return
if not self.code:
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
if not ctlmst["ctm_taxno"]:
showError(self.opts["mf"].body, "Unregistered",
"The Company Record Does Not Have a V.A.T. Number")
return
return True
def mainProcess(self):
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y"),
("vtm_cat", "", 0, "C")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [("vtr_cono", "=", self.opts["conum"])],
"whera": [["T", "vtr_code", 0, 0]]}
vtt = {
"stype": "C",
"titl": "VAT Types",
"head": ("C", "Description"),
"data": [
["N", "None"],
["S", "Standard"],
["Z", "Zero Rated"],
["C", "Capital Item"],
["X", "Excluded Item"]]}
fld = (
(("T",0,0,0),"IUA",1,"V.A.T. Code","",
"","Y",self.doCode,vtm,None,("notblank",)),
(("T",0,1,0),"INA",30,"Description","",
"","N",self.doDesc,None,self.doDelete,("notblank",)),
(("T",0,2,0),"IUA",1,"Category","",
"S","N",self.doCat,vtt,None,("in", ("C","N","S","X","Z"))),
(("C",0,0,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doStart,vtr,None,("efld",)),
(("C",0,0,1),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doRate,None,None,("efld",)))
but = (
("Print",None,self.doPrint,0,("T",0,1),(("T",0,0),("T",0,2))),
("Add",None,self.doAdd,0,("T",0,0),None),
("Edit",None,self.doEdit,0,("T",0,0),None),
("Exit",None,self.doExit,0,("T",0,0),(("T",0,1),("C",0,1))))
tnd = ((self.doTEnd,"y"), )
txt = (self.doTExit, )
cnd = ((self.doCEnd,"y"), )
cxt = (self.doCExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld,
butt=but, tend=tnd, txit=txt, cend=cnd, cxit=cxt, rows=(15,))
def doPrint(self):
hds = "V.A.T. Records"
col = [
["vtm_code", "UA", 1, "C"],
["vtm_desc", "NA", 30, "Description"],
["vtm_cat", "UA", 1, "T"],
["vtr_date", "d1", 10, "Start-Date"],
["vtr_rate", "UD", 6.2, "Rate"]]
recs = self.sql.getRec(tables=["ctlvmf", "ctlvrf"], cols=["vtm_code",
"vtm_desc", "vtm_cat", "vtr_date", "vtr_rate"], where=[("vtm_cono",
"=", self.opts["conum"]), ("vtr_cono=vtm_cono",),
("vtr_code=vtm_code",)], order="vtm_code, vtr_date")
code = None
data = copyList(recs)
for num, rec in enumerate(recs):
if rec[0] == code:
data[num][0] = ""
data[num][1] = ""
data[num][2] = ""
code = rec[0]
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=data,
heads=[hds], ttype="D", cols=col, prtdia=(("Y","V"), ("Y","N")))
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.focusField("T", 0, 1)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.oldm = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)], limit=1)
if not self.oldm:
self.newm = True
else:
self.newm = False
self.desc = self.oldm[self.sql.ctlvmf_col.index("vtm_desc")]
self.df.loadEntry(frt, pag, p+1, data=self.desc)
self.cat = self.oldm[self.sql.ctlvmf_col.index("vtm_cat")]
self.df.loadEntry(frt, pag, p+2, data=self.cat)
self.doLoadRates()
return "ff2"
def doDelete(self):
if self.df.frt == "T":
if self.doCheckTrn():
showError(self.opts["mf"].body, "Exists",
"Transactions Exist for this Code, Not Deleted")
return
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["ctlvmf", "D", "%03i%-1s" % \
(self.opts["conum"], self.code), "", dte, self.opts["capnm"],
"", "", "", 0])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doCat(self, frt, pag, r, c, p, i, w):
self.cat = w
def doTEnd(self):
self.edit = False
datm = [self.opts["conum"]]
datm.extend(self.df.t_work[0][0][:3])
if self.newm:
self.sql.insRec("ctlvmf", data=datm)
if self.cat in ("N", "X", "Z"):
newr = [self.opts["conum"], self.code, 0, 0]
self.sql.insRec("ctlvrf", data=newr)
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
else:
self.doButtons()
self.df.focusField("C", 0, 1)
elif self.cat in ("N", "X", "Z"):
self.df.focusField("T", 0, 1)
elif datm != self.oldm[:len(datm)]:
col = self.sql.ctlvmf_col
datm.append(self.oldm[col.index("vtm_xflag")])
self.sql.updRec("ctlvmf", data=datm, where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec("chglog", data=["ctlvmf",
"U", "%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datm[num]), "", 0])
self.doButtons()
self.opts["mf"].dbm.commitDbase()
def doTExit(self):
chks = ""
recs = self.sql.getRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"])])
for rec in recs:
rte = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", rec[1])])
if not rte:
if rec[3] in ("N", "X", "Z"):
self.sql.insRec("ctlvrf", data=[rec[0], rec[1], 0, 0])
self.opts["mf"].dbm.commitDbase()
continue
chks = "%s\n%1s %-30s %1s" % (chks, rec[1], rec[2], rec[3])
if chks:
showError(self.opts["mf"].body, "Missing Rate Record", "The "\
"following VAT Codes do Not have Rate Records:\n%s\n\n"\
"You will Not be able to Exit until you either Create "\
"Rate Records or Delete these codes." % chks)
self.df.focusField("T", 0, 1)
else:
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doAdd(self):
for num, rec in enumerate(self.df.c_work[0]):
if not rec[0] and not rec[1]:
pos = (num * 2) + 1
self.df.focusField("C", 0, pos)
break
def doEdit(self):
self.edit = True
self.newr = False
tit = "Edit Rate"
vtr = {
"stype": "R",
"tables": ("ctlvrf",),
"cols": (
("vtr_date", "", 0, "Start-Date"),
("vtr_rate", "", 0, "Rate")),
"where": [
("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)]}
fld = (
(("T",0,0,0),"OUA",1,"V.A.T. Code"),
(("T",0,1,0),"ONA",30,"Description"),
(("T",0,2,0),"OUA",1,"Category"),
(("T",0,3,0),"Id1",10,"Start-Date","The Starting Date",
"","N",self.doEStart,vtr,self.doEDelete,("efld",)),
(("T",0,4,0),"IUD",6.2,"Rate-%","The Rate",
"","N",self.doERate,None,self.doEDelete,("notzero",)))
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
self.ed = TartanDialog(self.opts["mf"], title=tit, tops=True,
eflds=fld, tend=((self.doEEnd,"n"),), txit=(self.doEExit,))
self.ed.loadEntry("T", 0, 0, data=self.code)
self.ed.loadEntry("T", 0, 1, data=self.desc)
self.ed.loadEntry("T", 0, 2, data=self.cat)
self.ed.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
if self.exit:
self.df.focusField("T", 0, 1)
else:
self.doExit()
def doEDelete(self):
self.exit = False
if self.ed.pos == 3:
if self.doCheckTrn():
return ("T", 0, 4, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code)])
else:
if self.doCheckTrn(self.start):
return ("T", 0, 5, "Transactions Exist, Not Deleted")
self.sql.delRec("ctlvrf", where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
self.ed.closeProcess()
chk = self.sql.getRec("ctlvrf", cols=["count(*)"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], limit=1)
if not chk[0]:
self.sql.delRec("ctlvmf", where=[("vtm_cono", "=",
self.opts["conum"]), ("vtm_code", "=", self.code)])
self.exit = True
self.opts["mf"].dbm.commitDbase()
return "nf"
def doEStart(self, frt, pag, r, c, p, i, w):
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", w)], limit=1)
if not self.oldr:
return "Date Does Not Exist"
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist for Date, Editing Not Allowed.")
return "Invalid Date"
self.start = w
self.rate = self.oldr[3]
self.ed.loadEntry(frt, pag, p+1, data=self.rate)
def doERate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doEEnd(self):
self.ed.closeProcess()
self.doCEnd()
def doEExit(self):
self.ed.closeProcess()
def doStart(self, frt, pag, r, c, p, i, w):
if self.doCheckTrn(w):
showError(self.opts["mf"].body, "Date Error",
"Transactions Exist On or After This Starting Date.")
return "Invalid Date"
self.start = w
self.oldr = self.sql.getRec("ctlvrf", where=[("vtr_cono",
"=", self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)], limit=1)
if not self.oldr:
self.newr = True
if self.cat in ("N", "X", "Z"):
if self.edit:
self.ed.loadEntry(frt, pag, p+1, data=0)
else:
self.df.loadEntry(frt, pag, p+1, data=0)
return "nd"
else:
self.newr = False
if self.edit:
self.ed.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
else:
self.df.loadEntry(frt, pag, p+1,
data=self.oldr[self.sql.ctlvrf_col.index("vtr_rate")])
def doRate(self, frt, pag, r, c, p, i, w):
if not w:
yes = askQuestion(self.opts["mf"].body, "Zero Rate",
"Are You Sure That This Rate is Correct?", default="no")
if yes == "no":
return "Invalid Rate"
self.rate = w
def doCheckTrn(self, date=None):
where = [
("vtt_cono", "=", self.opts["conum"]),
("vtt_code", "=", self.code)]
if date:
where.append(("vtt_refdt", ">=", date))
return self.sql.getRec("ctlvtf", cols=["count(*)"],
where=where, limit=1)[0]
def doCEnd(self):
datr = [self.opts["conum"], self.code, self.start, self.rate]
if self.newr:
self.sql.insRec("ctlvrf", data=datr)
elif datr != self.oldr[:len(datr)]:
col = self.sql.ctlvrf_col
datr.append(self.oldr[col.index("vtr_xflag")])
self.sql.updRec("ctlvrf", data=datr, where=[("vtr_cono", "=",
self.opts["conum"]), ("vtr_code", "=", self.code),
("vtr_date", "=", self.start)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldr):
if dat != datr[num]:
self.sql.insRec("chglog", data=["ctlvrf", "U",
"%03i%-1s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"], str(dat),
str(datr[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
self.edit = False
self.doExit()
def doCExit(self):
self.edit = False
self.doExit()
def doLoadRates(self):
self.df.clearFrame("C", 0)
recs = self.sql.getRec("ctlvrf",
cols=["vtr_date", "vtr_rate"],
where=[("vtr_cono", "=", self.opts["conum"]),
("vtr_code", "=", self.code)], order="vtr_date")
for num, rec in enumerate(recs):
pos = (num * 2)
if pos > 27:
self.df.scrollScreen(0)
pos = 26
self.df.focusField("C", 0, pos + 1)
self.df.loadEntry("C", 0, pos, data=rec[0])
self.df.focusField("C", 0, pos + 2)
self.df.loadEntry("C", 0, pos + 1, data=rec[1], zero=True)
def doButtons(self):
self.df.setWidget(self.df.B1, "normal")
self.df.setWidget(self.df.B2, "normal")
self.df.setWidget(self.df.B3, "normal")
self.opts["mf"].window.focus_set()
def doExit(self):
self.df.setWidget(self.df.B3, "disabled")
self.df.focusField("T", 0, 1)
class glc210(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", "genmst", "genint"],
prog=self.__class__.__name__)
if self.sql.error:
return
chk = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if chk[0] == 1:
showInfo(self.opts["mf"].body, "Intercompany",
"There is Only 1 Company Record")
return
return True
def mainProcess(self):
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy-Num"),
("ctm_name", "", 0, "Name", "Y")),
"where": [("ctm_cono", "!=", self.opts["conum"])]}
gl1 = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]}
gl2 = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"whera": [["T", "glm_cono", 0, 0]]}
data = self.sql.getRec(tables=["genint", "genmst"], cols=["cti_inco",
"glm_desc"], where=[("cti_cono", "=", self.opts["conum"]),
("glm_cono=cti_cono",), ("glm_acno=cti_acno",)], order="cti_inco")
self.gl3 = {
"stype": "C",
"titl": "Existing Companies",
"head": ("Coy","Name"),
"typs": (("UI", 3), ("NA", 30)),
"data": data}
fld = (
(("T",0,0,0,14),"IUI",3,"Coy-Num","Company Number",
"","Y",self.doCoyNum,coy,None,None),
(("T",0,0,17),"ONA",30,""),
(("T",0,1,0,10),"IUI",7,"Acc-Num-1","G/L Account Number",
"","N",self.doAccNum1,gl1,self.doDelete,("notzero",),None,
"The above company's account number in company %s." %
self.opts["conum"]),
(("T",0,1,17),"ONA",30,""),
(("T",0,2,0,10),"IUI",7,"Acc-Num-2","G/L Account Number",
"","N",self.doAccNum2,gl2,None,("notzero",),None,
"Company %s's account number in the above company." %
self.opts["conum"]),
(("T",0,2,17),"ONA",30,""))
but = (
("Show All",self.gl3,None,0,("T",0,1),("T",0,2)),
("Cancel",None,self.doCancel,0,("T",0,3),("T",0,1)),
("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 doCoyNum(self, frt, pag, r, c, p, i, w):
if w == 0:
return "Invalid Company Number"
if w == self.opts["conum"]:
return "Invalid Company, Same Company Not Allowed"
self.cono2 = w
acc = self.sql.getRec("ctlmst", cols=["ctm_name"],
where=[("ctm_cono", "=", self.cono2)], limit=1)
if not acc:
return "Invalid Company Number"
self.df.loadEntry(frt, pag, 1, data=acc[0])
self.acc1 = self.sql.getRec("genint", where=[("cti_cono",
"=", self.opts["conum"]), ("cti_inco", "=", self.cono2)], limit=1)
if not self.acc1:
self.new1 = "y"
else:
self.new1 = "n"
self.acno1 = self.acc1[self.sql.genint_col.index("cti_acno")]
desc = self.readAcno(self.opts["conum"], self.acno1)
self.df.loadEntry(frt, pag, 2, data=self.acno1)
self.df.loadEntry(frt, pag, 3, data=desc[0])
self.acc2 = self.sql.getRec("genint", where=[("cti_cono",
"=", self.cono2), ("cti_inco", "=", self.opts["conum"])], limit=1)
if not self.acc2:
self.new2 = "y"
else:
self.new2 = "n"
self.acno2 = self.acc2[self.sql.genint_col.index("cti_acno")]
desc = self.readAcno(self.cono2, self.acno2)
self.df.loadEntry(frt, pag, 4, data=self.acno2)
self.df.loadEntry(frt, pag, 5, data=desc[0])
def doDelete(self):
if self.new1 == "n":
self.sql.delRec("genint", where=[("cti_cono", "=",
self.opts["conum"]), ("cti_inco", "=", self.cono2)])
if self.new2 == "n":
self.sql.delRec("genint", where=[("cti_cono", "=", self.cono2),
("cti_inco", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doAccNum1(self, frt, pag, r, c, p, i, w):
desc = self.readAcno(self.opts["conum"], w)
if not desc:
return "Invalid Account Number"
self.acno1 = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
def doAccNum2(self, frt, pag, r, c, p, i, w):
desc = self.readAcno(self.cono2, w)
if not desc:
return "Invalid Account Number"
self.acno2 = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
def readAcno(self, cono, acno):
acc = self.sql.getRec("genmst", cols=["glm_desc"],
where=[("glm_cono", "=", cono), ("glm_acno", "=", acno)], limit=1)
return acc
def doEnd(self):
data1 = [self.opts["conum"], self.cono2, self.acno1]
data2 = [self.cono2, self.opts["conum"], self.acno2]
if self.new1 == "y":
self.sql.insRec("genint", data=data1)
elif data1 != self.acc1[:len(data1)]:
col = self.sql.genint_col
data1.append(self.acc1[col.index("cti_xflag")])
self.sql.updRec("genint", data=data1, where=[("cti_cono", "=",
self.opts["conum"]), ("cti_inco", "=", self.cono2)])
if self.new2 == "y":
self.sql.insRec("genint", data=data2)
elif data2 != self.acc2[:len(data2)]:
col = self.sql.genint_col
data2.append(self.acc2[col.index("cti_xflag")])
self.sql.updRec("genint", data=data2, where=[("cti_cono", "=",
self.cono2), ("cti_inco", "=", self.opts["conum"])])
self.opts["mf"].dbm.commitDbase()
data = self.sql.getRec(tables=["genint", "genmst"], cols=["cti_cono",
"glm_desc"], where=[("cti_cono", "=", self.opts["conum"]),
("glm_cono=cti_inco",)], order="cti_inco")
self.gl3["data"] = data
self.df.focusField("T", 0, 1)
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 gl6060(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):
self.sql = Sql(self.opts["mf"].dbm, ["ctlctl", "genmst", "genrct"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
self.tit = ("%03i %s" % (self.opts["conum"], self.opts["conam"]),
"Delete Imported Bank Statements (%s)" %
self.__class__.__name__)
glm = {
"stype":
"R",
"tables": ("ctlctl", "genmst"),
"cols": (("ctl_conacc", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono", ),
("glm_acno=ctl_conacc", )]
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), "IUI", 7, "Bank Account", "", "", "Y",
self.doBankAcc, glm, None, ("efld", )),
(("T", 0, 1,
0), "Id1", 10, "From Date", "From Date (0 for Beginning)", 0,
"Y", self.doFrom, None, None, ("efld", )),
(("T", 0, 2, 0), "Id1", 10, "To Date", "To Date (0 for End)",
0, "Y", self.doTo, None, None, ("efld", )),
(("T", 0, 3, 0), ("IRB", r1s), 0, "Unallocated Only", "", "Y",
"Y", self.doUnall, None, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
title=self.tit,
eflds=fld,
tend=tnd,
txit=txt)
def doBankAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["ctlctl", "genmst"],
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w),
("ctl_cono=glm_cono", ),
("ctl_conacc=glm_acno", ),
("ctl_code", "like", "bank_%")],
limit=1)
if not acc:
return "Invalid Bank Account Number"
self.acnow = w
self.acnod = self.df.t_disp[pag][r][p]
self.name = acc[0]
def doFrom(self, frt, pag, r, c, p, i, w):
self.start = w
def doTo(self, frt, pag, r, c, p, i, w):
if w and self.start and w < self.start:
return "Invalid Date, Earlier than From Date"
self.to = w
def doUnall(self, frt, pag, r, c, p, i, w):
self.unall = w
def doEnd(self):
self.df.closeProcess()
whr = [("grt_cono", "=", self.opts["conum"]),
("grt_acno", "=", self.acnow)]
if self.start:
whr.append(("grt_date", ">=", self.start))
if self.to:
whr.append(("grt_date", "<=", self.to))
if self.unall == "Y":
whr.append(("grt_flag", "=", "N"))
cnt = self.sql.getRec("genrct", cols=["count(*)"], where=whr, limit=1)
self.sql.delRec("genrct", where=whr)
self.opts["mf"].dbm.commitDbase(
ask=True,
mess="A Total of %s Records were Deleted" % cnt[0],
default="no")
self.closeProcess()
def doExit(self):
self.df.closeProcess()
self.closeProcess()
def closeProcess(self):
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class bsc210(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, ["bksaut", "bksmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
clb = {
"stype": "R",
"tables": ("bksaut",),
"cols": (
("baf_code", "", 0, "Cod"),
("baf_snam", "", 0, "Surname", "Y"),
("baf_fnam", "", 0, "Names")),
"order": "baf_snam"}
fld = (
(("T",0,0,0),"I@baf_code",0,"","",
"","Y",self.doCode,clb,None,("efld",)),
(("T",0,1,0),"I@baf_snam",0,"","",
"","N",self.doSnam,None,self.doDelete,("notblank",)),
(("T",0,2,0),"I@baf_fnam",0,"","",
"","N",self.doFnam,None,None,("efld",)))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], tops=False,
eflds=fld, tend=tnd, txit=txt)
def doCode(self, frt, pag, r, c, p, i, w):
if not w:
self.author = getNextCode(self.sql, "bksaut", "baf_code", last=999)
self.df.loadEntry(frt, pag, p, data=self.author)
else:
self.author = w
self.old = self.sql.getRec("bksaut", where=[("baf_code", "=",
self.author)], limit=1)
if not self.old:
self.newaut = True
else:
self.newaut = False
for num, fld in enumerate(self.old[:-1]):
self.df.loadEntry(frt, pag, num, data=fld)
def doDelete(self):
chk = self.sql.getRec("bksmst", where=[("bmf_auth",
"=", self.author)], limit=1)
if chk:
showError(self.opts["mf"].body, "Error", "Author in Use")
return
self.sql.delRec("bksaut", where=[("baf_code", "=", self.author)])
self.opts["mf"].dbm.commitDbase()
def doSnam(self, frt, pag, r, c, p, i, w):
self.snam = w
def doFnam(self, frt, pag, r, c, p, i, w):
if self.newaut:
chk = self.sql.getRec("bksaut", where=[("baf_snam",
"=", self.snam), ("baf_fnam", "=", w)], limit=1)
if chk:
return "An Author with this Name Already Exists"
def doEnd(self):
data = self.df.t_work[0][0][:]
if self.newaut:
self.sql.insRec("bksaut", data=data)
elif data != self.old[:len(data)]:
col = self.sql.bksaut_col
data.append(self.old[col.index("baf_xflag")])
self.sql.updRec("bksaut", data=data, where=[("baf_code", "=",
self.author)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class bc1010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.mainProcess()
if "args" in self.opts:
self.tabcvt = False
self.gentab = False
self.newtab = True
self.tab = self.opts["args"]
self.df.loadEntry("T", 0, 0, data=self.tab)
self.df.topf[0][0][1] = "OUI"
self.df.topf[0][1][1] = "OUI"
self.df.focusField("T", 0, 2)
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, [
"chglog", "bwlent", "bwlgme", "bwltab", "bwldrt", "bwlflm",
"bwlflt", "memmst", "memkon", "memadd", "memcat"
],
prog=self.__class__.__name__)
if self.sql.error:
if self.sql.error == ["memmst", "memkon"]:
self.memmst = False
else:
return
else:
self.memmst = True
gc = GetCtl(self.opts["mf"])
bwlctl = gc.getCtl("bwlctl", self.opts["conum"])
if not bwlctl:
return
self.mlint = bwlctl["ctb_mlint"]
self.samen = bwlctl["ctb_samen"]
self.mscat = bwlctl["ctb_mscat"]
self.mstart = bwlctl["ctb_mstart"]
self.fstart = bwlctl["ctb_fstart"]
self.nstart = bwlctl["ctb_nstart"]
self.dbase = bwlctl["ctb_dbase"]
self.order = bwlctl["ctb_order"]
self.mixed = bwlctl["ctb_mixed"]
self.fromad = bwlctl["ctb_emadd"]
self.keys = (("bwltab", "btb_cono", "btb_tab"), ("bwldrt", "bdt_cono",
"bdt_tab"),
("bwlent", "bce_cono", "bce_scod"), ("bwlflt", "bft_cono",
"bft_player"),
("bwlgme", "bcg_cono", "bcg_scod"), ("bwldrt", "bdt_cono",
"bdt_team1"),
("bwldrt", "bdt_cono",
"bdt_team2"), ("bwldrt", "bdt_cono", "bdt_team3"),
("bwlflt", "bft_cono", "bft_skip"), ("bwlgme", "bcg_cono",
"bcg_ocod"))
return True
def mainProcess(self):
tab = {
"stype":
"R",
"tables": ("bwltab", ),
"cols": [("btb_tab", "", 0, "Tab"),
("btb_surname", "", 0, "Surname", "Y"),
("btb_names", "", 0, "Names"),
("btb_bsano", "", 0, "BSA-No")],
"where": [("btb_cono", "=", self.opts["conum"])],
"order":
"btb_surname"
}
if self.mlint == "N":
mlm = None
else:
tab["cols"].insert(3, ("btb_memno", "", 0, "Mem-No"))
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0,
"Mem-No"), ("mlm_oldno", "", 0,
"Old-No"), ("mlm_idnum", "", 0, "Identity-Numb"),
("mlm_gender", "", 0, "G"), ("mlm_state", "", 0, "S"),
("mlm_surname", "", 0, "Surname", "Y"), ("mlm_names", "", 0,
"Names", "F")),
"where": [("mlm_cono", "=", self.opts["conum"])],
"order":
"mlm_surname, mlm_names"
}
r1s = (("Male", "M"), ("Female", "F"))
if self.dbase == "R":
r2s = (("None", "0"), )
else:
r2s = (("Skip", "4"), ("Third", "3"), ("Second", "2"), ("Lead",
"1"))
fld = [(("T", 0, 0,
0), "I@btb_tab", 0, "", "", "", "Y", self.doTab, tab, None,
("efld", ), None, "Note: Tab numbers Must be Unique."),
[("T", 0, 1, 0), "I@btb_memno", 0, "", "", "", "N",
self.doMember, mlm, self.doDelete, ("efld", )],
(("T", 0, 2, 0), "I@btb_surname", 0, "", "", "", "N",
self.doSurname, None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "I@btb_names", 0, "", "", "", "N",
self.doNames, None, None, ("efld", )),
(("T", 0, 4, 0), ("IRB", r1s), 0, "Gender", "", "M", "N",
self.doGender, None, None, None),
(("T", 0, 5, 0), "I@btb_add1", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 6, 0), "I@btb_add2", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 7, 0), "I@btb_add3", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 8, 0), "I@btb_pcod", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 9, 0), "I@btb_home", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 10, 0), "I@btb_work", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 11, 0), "I@btb_cell", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 12, 0), "I@btb_mail", 0, "", "", "", "N",
self.doEmail, None, None, ("efld", )),
(("T", 0, 13, 0), ("IRB", r2s), 0, "Position - Primary", "",
"1", "N", self.doPos, None, self.doDelete, None),
(("T", 0, 14, 0), "I@btb_rate1", 0, "", "", "", "N",
self.doRate, None, None, ("efld", )),
(("T", 0, 15, 0), ("IRB", r2s), 0, "Position - Mixed", "", "1",
"N", self.doPos, None, None, None),
(("T", 0, 16, 0), "I@btb_rate2", 0, "", "", "", "N", None, None,
None, ("efld", )),
(("T", 0, 17, 0), "I@btb_bsano", 0, "", "", "", "N", None, None,
None, ("efld", ))]
if self.mlint == "N":
fld[1] = [("T", 0, 1, 0), "O@btb_memno", 0, ""]
if self.mlint == "Y":
but = []
else:
but = [("Import", None, self.doImport, 0, ("T", 0, 1),
(("T", 0, 2), ("T", 0, 3)),
"Import Tabs and/or Ratings from a CSV or XLS File.")]
but.extend([("Accept", None, self.doEnd, 0, ("T", 0, 3), ("T", 0, 0),
"Accept All Fields and Continue"),
("Convert", None, self.doConvert, 0, ("T", 0, 3),
("T", 0, 4), "Convert a Visitor's Tab to a Member's Tab"),
("Print", None, self.doPrint, 1, None, None)])
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
tops=False,
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.col == 1:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doTab(self, frt, pag, r, c, p, i, w):
self.tab = w
self.newvis = False
self.tabcvt = False
self.tabchg = False
if not self.tab:
if self.mlint == "Y" and self.samen == "Y":
ok = askQuestion(self.opts["mf"].body,
"New Tab",
"Is this TAB for a Visitor",
default="no")
if ok == "no":
return "New Member, Please Create in Ledger"
self.newvis = True
self.gentab = True
self.newtab = True
else:
self.gentab = False
self.oldtab = self.sql.getRec("bwltab",
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_tab", "=", self.tab)],
limit=1)
if not self.oldtab:
self.newtab = True
else:
self.newtab = False
for num, fld in enumerate(self.oldtab[1:-1]):
if num == 2:
self.snam = fld
elif num == 3:
self.fnam = fld
elif num == 4:
self.gender = fld
elif num in (13, 15):
fld = str(fld)
if num == 13:
self.pos1 = fld
self.df.loadEntry(frt, pag, num, data=fld)
if self.tab and self.mlint == "Y":
if self.oldtab:
memno = self.oldtab[self.sql.bwltab_col.index("btb_memno")]
elif self.tab < self.nstart and self.samen == "Y":
memno = self.tab
else:
memno = 0
else:
memno = 0
if memno:
chk = self.doLoadMember(memno)
if chk:
return chk
if self.dbase == "R":
return "sk13"
return "sk12"
if self.newvis or self.tab >= self.nstart:
return "sk1"
def doMember(self, frt, pag, r, c, p, i, w):
if w:
if self.newtab or not self.oldtab[2]:
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=",
self.opts["conum"]),
("btb_memno", "=", w)],
limit=1)
if chk:
return "Member Already Has a TAB"
chk = self.doLoadMember(w)
if chk:
return chk
if self.newtab and not self.tab:
chk = self.getNextTab()
if not chk:
return "Invalid Membership Number"
if self.dbase == "R":
return "sk12"
return "sk11"
elif self.tab and self.tab < self.nstart and self.mlint == "Y":
return "Invalid Membership Number"
def doLoadMember(self, memno):
# Check member
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 "Member %s Does Not Exist" % memno
# Check category
if self.mscat:
cat = self.sql.getRec("memcat",
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", memno),
("mlc_type", "=", "C"),
("mlc_code", "=", self.mscat)],
limit=1)
if not cat:
return "Member %s is Not in the Bowls Category" % memno
self.snam = acc[0]
self.fnam = acc[1]
self.gender = acc[2]
self.df.loadEntry("T", 0, 1, data=memno)
self.df.loadEntry("T", 0, 2, data=self.snam)
self.df.loadEntry("T", 0, 3, data=self.fnam)
self.df.loadEntry("T", 0, 4, data=self.gender)
for typ in ("A", "P"):
ad = 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 ad:
break
if ad:
self.df.loadEntry("T", 0, 5, data=ad[0])
self.df.loadEntry("T", 0, 6, data=ad[1])
self.df.loadEntry("T", 0, 7, data=ad[2])
self.df.loadEntry("T", 0, 8, data=ad[3])
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:
self.df.loadEntry("T", 0, num + 9, data=kk[0])
def doSurname(self, frt, pag, r, c, p, i, w):
self.sname = w
def doNames(self, frt, pag, r, c, p, i, w):
if self.newtab:
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_surname", "=", self.sname,
"and", "btb_names", "=", w)],
limit=1)
if chk:
tab = chk[self.sql.bwltab_col.index("btb_tab")]
self.doTab(frt, pag, 0, 1, 0, 0, tab)
return "ff3"
if self.mstart < self.fstart and self.tab >= self.fstart:
self.df.loadEntry(frt, pag, p + 1, data="F")
elif self.fstart < self.mstart and self.tab < self.mstart:
self.df.loadEntry(frt, pag, p + 1, data="F")
return
if self.sname != self.snam or w != self.fnam:
but = [("Amendment", "A"), ("Re-Issue", "R"), ("Neither", "N")]
ok = askChoice(self.opts["mf"].body,
"Name Change",
"Please Select the Reason for the Name Change",
butt=but,
default="Neither")
if ok == "N":
return "ff3"
if ok == "R":
self.tabchg = True
for x in range(1, 15):
self.df.clearEntry(frt, pag, c + x)
def doGender(self, frt, pag, r, c, p, i, w):
self.gender = w
if self.gentab:
chk = self.getNextTab()
if not chk:
return "ff2|Invalid Membership Number"
if self.tab < self.nstart:
if self.mstart < self.fstart:
if self.gender == "M" and self.tab >= self.fstart:
return "ff5|Invalid Gender for Tab Number"
elif self.gender == "F" and self.tab < self.fstart:
return "ff5|Invalid Gender for Tab Number"
else:
if self.gender == "F" and self.tab >= self.mstart:
return "ff5|Invalid Gender for Tab Number"
elif self.gender == "M" and self.tab < self.mstart:
return "ff5|Invalid Gender for Tab Number"
def doEmail(self, frt, pag, r, c, p, i, w):
if self.dbase in ("C", "P") and self.df.t_work[0][0][13] == "0":
self.df.t_work[0][0][13] = "1"
if self.dbase == "R":
self.pos1 = "0"
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
return "sk1"
def doPos(self, frt, pag, r, c, p, i, w):
if p == 13:
self.pos1 = w
self.df.loadEntry(frt, pag, p + 2, data=w)
if self.dbase == "P":
self.df.loadEntry(frt, pag, p + 1, data="")
if p == 13:
self.df.loadEntry(frt, pag, p + 3, data="")
if self.mixed == "N":
return "sk3"
else:
return "sk1"
def doRate(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p + 1, data=self.pos1)
self.df.loadEntry(frt, pag, p + 2, data=w)
if self.dbase == "R":
self.df.loadEntry(frt, pag, p + 1, data="")
if self.mixed == "N":
return "sk2"
else:
return "sk1"
if self.mixed == "N":
return "sk2"
def getNextTab(self):
if self.newvis:
ok = "yes"
else:
ok = askQuestion(self.opts["mf"].body,
"Type",
"Is this TAB for a Visitor",
default="no")
if ok == "no":
if self.samen == "Y":
return
if self.gender == "M":
start = self.mstart
if self.mstart < self.fstart:
last = self.fstart
else:
last = self.nstart
else:
start = self.fstart
if self.mstart < self.fstart:
last = self.nstart
else:
last = self.mstart
else:
start = self.nstart
last = 900000
self.tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])],
start=start,
last=last)
self.df.loadEntry("T", 0, 0, data=self.tab)
return True
def doDelete(self):
if self.newtab:
return
error = False
for key in self.keys:
if key[0] == "bwltab":
continue
chk = self.sql.getRec(tables=key[0],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.tab)],
limit=1)
if chk:
error = True
break
if error:
if self.tab < self.nstart:
# Member
ok = askQuestion(self.opts["mf"].body,
"Convert",
"Convert this Member to a Visitor",
default="yes")
if ok == "no":
return "Not Deleted nor Converted"
tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])
],
start=self.nstart,
last=900000)
for key in self.keys:
self.sql.updRec(key[0],
cols=[key[2]],
data=[tab],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.tab)])
else:
# Visitor
chk = self.sql.getRec("bwlent",
where=[("bce_cono", "=",
self.opts["conum"]),
("bce_scod", "=", self.tab)])
if chk:
return "There is History for this Player, Not Deleted"
self.sql.delRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
else:
self.sql.delRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
self.opts["mf"].dbm.commitDbase()
def doConvert(self):
titl = "Enter Member's Tab Number"
ent = SimpleDialog(parent=self.df.window,
title=titl,
cols=(("a", "Tab Number ", 6, "UI",
"Tab"), ))
ent.sframe.wait_window()
try:
self.merge = False
if self.gender == "M":
start = self.mstart
if self.mstart < self.fstart:
last = self.fstart - 1
else:
last = self.nstart - 1
else:
start = self.fstart
if self.mstart < self.fstart:
last = self.nstart - 1
else:
last = self.mstart - 1
tab = ent.data[0]
if not tab:
tab = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])
],
start=start,
last=last)
if tab < start or tab > last:
showInfo(self.opts["mf"].body, "Error",
"Invalid Tab Number for Gender")
raise Exception
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", tab)],
limit=1)
if chk:
ok = askQuestion(
self.opts["mf"].body, "Invalid",
"This Tab is Already Allocated, Do You Want to Merge?")
if ok == "no":
raise Exception
self.merge = True
self.tabcvt = True
self.old = self.tab
self.tab = tab
self.df.loadEntry(self.df.frt, self.df.pag, 0, data=self.tab)
self.df.focusField(self.df.frt, self.df.pag, 6)
except:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
if self.mlint == "Y":
self.colsd = [["Membership Number", "N", "btb_memno"]]
else:
self.colsd = []
self.colsd.extend([["Surname & Initials", "Y", "name"],
["Surname", "N", "btb_surname"],
["First Names", "N", "btb_names"],
["Gender", "N", "btb_gender"],
["Address", "N", "address"],
["Telephone - Home", "N", "btb_home"],
["Telephone - Work", "N", "btb_work"],
["Telephone - Cell", "N", "btb_cell"],
["Email Address", "N", "btb_mail"],
["Ratings", "N", "ratings"],
["BSA Number", "N", "btb_bsano"],
["Order", "T", "order"]])
r1s = (("Members", "M"), ("Guests", "G"), ("All", "A"))
r2s = (("Males", "M"), ("Females", "F"), ("All", "A"))
r3s = (("Yes", "Y"), ("No", "N"))
r4s = (("Tab", "T"), ("Surname", "S"), ("Rating", "R"))
fld = [(("T", 0, 0, 0), ("IRB", r1s), 0, "Tab Group", "", "M", "Y",
self.doCGroup, None, None, None),
(("T", 0, 1, 0), ("IRB", r2s), 0, "Gender", "", "A", "Y",
self.doCGender, None, None, None)]
idx = 1
for dat in self.colsd:
idx += 1
if dat == self.colsd[-1]:
rb = r4s
else:
rb = r3s
fld.append((("T", 0, idx, 0), ("IRB", rb), 0, dat[0], "", dat[1],
"N", self.doCField, None, None, None))
tnd = ((self.doCEnd, "Y"), )
txt = (self.doCExit, )
self.pr = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("Y", "V"),
mail=("Y", "Y"))
self.pr.mstFrame.wait_window()
if self.cols:
cols = []
dic = self.sql.bwltab_dic
for col in self.cols:
if col == "name":
cols.append(["name", "NA", 30, "Name"])
elif col == "address":
cols.append([
"btb_add1", dic["btb_add1"][2], dic["btb_add1"][3],
dic["btb_add1"][5]
])
cols.append([
"btb_add2", dic["btb_add2"][2], dic["btb_add2"][3],
dic["btb_add2"][5]
])
cols.append([
"btb_add3", dic["btb_add3"][2], dic["btb_add3"][3],
dic["btb_add3"][5]
])
cols.append([
"btb_pcod", dic["btb_pcod"][2], dic["btb_pcod"][3],
dic["btb_pcod"][5]
])
elif col == "ratings":
if self.dbase == "P":
cols.append([
"btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3],
dic["btb_pos1"][5]
])
cols.append([
"btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3],
dic["btb_pos2"][5]
])
elif self.dbase == "R":
cols.append([
"btb_rate1", dic["btb_rate1"][2],
dic["btb_rate1"][3], dic["btb_rate1"][5]
])
cols.append([
"btb_rate2", dic["btb_rate2"][2],
dic["btb_rate2"][3], dic["btb_rate2"][5]
])
else:
cols.append([
"btb_pos1", dic["btb_pos1"][2], dic["btb_pos1"][3],
dic["btb_pos1"][5]
])
cols.append([
"btb_rate1", dic["btb_rate1"][2],
dic["btb_rate1"][3], dic["btb_rate1"][5]
])
cols.append([
"btb_pos2", dic["btb_pos2"][2], dic["btb_pos2"][3],
dic["btb_pos2"][5]
])
cols.append([
"btb_rate2", dic["btb_rate2"][2],
dic["btb_rate2"][3], dic["btb_rate2"][5]
])
else:
cols.append([col, dic[col][2], dic[col][3], dic[col][5]])
whr = [("btb_cono", "=", self.opts["conum"])]
if self.cgroup == "M":
whr.append(("btb_tab", "<", self.nstart))
elif self.cgroup == "G":
whr.append(("btb_tab", ">=", self.nstart))
if self.cgender in ("F", "M"):
whr.append(("btb_gender", "=", self.cgender))
if self.odr == "T":
odr = "btb_tab"
elif self.odr == "S":
odr = "btb_surname, btb_names"
else:
odr = "btb_pos1 desc, btb_rate1 desc, btb_surname, btb_names"
recs = self.sql.getRec("bwltab", where=whr, order=odr)
data = []
btc = self.sql.bwltab_col
for rec in recs:
dat = []
for col in self.cols:
if col == "name":
snam = rec[btc.index("btb_surname")]
fnam = rec[btc.index("btb_names")]
if fnam:
fnam = fnam.split()
for num, nam in enumerate(fnam):
if not num:
init = nam[0].upper()
else:
init = "%s %s" % (init, nam[0].upper())
dat.append("%s, %s" % (snam, init))
else:
dat.append(snam)
elif col == "address":
dat.append(rec[btc.index("btb_add1")])
dat.append(rec[btc.index("btb_add2")])
dat.append(rec[btc.index("btb_add3")])
dat.append(rec[btc.index("btb_pcod")])
elif col == "ratings":
if self.dbase == "P":
dat.append(rec[btc.index("btb_pos1")])
dat.append(rec[btc.index("btb_pos2")])
elif self.dbase == "R":
dat.append(rec[btc.index("btb_rate1")])
dat.append(rec[btc.index("btb_rate2")])
else:
dat.append(rec[btc.index("btb_pos1")])
dat.append(rec[btc.index("btb_rate1")])
dat.append(rec[btc.index("btb_pos2")])
dat.append(rec[btc.index("btb_rate2")])
else:
dat.append(rec[btc.index(col)])
data.append(dat)
tit = "Tabs Lising for"
if self.cgroup == "A":
tit = "%s Members and Guests" % tit
elif self.cgroup == "M":
tit = "%s Members Only" % tit
else:
tit = "%s Guests Only" % tit
if self.cgender == "A":
tit = "%s (All Genders)" % tit
elif self.cgender == "M":
tit = "%s (Males Only)" % tit
else:
tit = "%s (Females Only)" % tit
RepPrt(self.opts["mf"],
name=self.__class__.__name__,
conum=self.opts["conum"],
conam=self.opts["conam"],
heads=[tit],
ttype="D",
tables=data,
cols=cols,
repprt=self.pr.repprt,
repeml=self.pr.repeml,
fromad=self.fromad)
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
self.df.window.focus_force()
self.df.focusField("T", 0, 1)
def doCGroup(self, frt, pag, r, c, p, i, w):
self.cgroup = w
def doCGender(self, frt, pag, r, c, p, i, w):
self.cgender = w
def doCField(self, frt, pag, r, c, p, i, w):
if self.mlint == "N":
idx = 2
else:
idx = 3
if p == idx and w == "Y":
self.pr.loadEntry(frt, pag, p + 1, data="N")
self.pr.loadEntry(frt, pag, p + 2, data="N")
return "sk2"
def doCEnd(self):
self.pr.closeProcess()
self.cols = ["btb_tab"]
if self.pr.repeml[0] == "N":
end = -2
else:
end = -4
for num, dat in enumerate(self.pr.t_work[0][0][2:end]):
if dat == "Y":
self.cols.append(self.colsd[num][2])
elif dat in ("T", "S", "R"):
self.odr = dat
def doCExit(self):
self.cols = []
self.pr.closeProcess()
def doEnd(self):
if self.tabcvt:
# Conversion to Member
for key in self.keys:
if key[0] == "bwltab" and self.merge:
self.sql.delRec(key[0],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.old)])
continue
self.sql.updRec(key[0],
cols=[key[2]],
data=[self.tab],
where=[(key[1], "=", self.opts["conum"]),
(key[2], "=", self.old)])
# Continue
cols = []
for x in range(18):
cols.append(x)
if self.dbase == "R":
cols.remove(13)
cols.remove(15)
flds = ("T", 0, cols)
frt, pag, col, mes = self.df.doCheckFields(flds)
if mes:
self.df.focusField(frt, pag, (col + 1), err=mes)
return
tabdat = [self.opts["conum"]] + self.df.t_work[0][0]
if self.newtab:
self.sql.insRec("bwltab", data=tabdat)
elif self.tabchg:
tabdat.append("")
self.doTabChg(tabdat)
elif tabdat != self.oldtab[:len(tabdat)]:
col = self.sql.bwltab_col
tabdat.append(self.oldtab[col.index("btb_xflag")])
self.sql.updRec("bwltab",
data=tabdat,
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", self.tab)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.oldtab):
if dat != tabdat[num]:
self.sql.insRec(
"chglog",
data=[
"bwltab", "U",
"%03i%06s" % (self.opts["conum"], self.tab),
col[num], dte, self.opts["capnm"],
str(dat),
str(tabdat[num]), "", 0
])
self.opts["mf"].dbm.commitDbase()
if "args" in self.opts:
self.doExit()
else:
self.df.focusField("T", 0, 1)
def doTabChg(self, tabdat):
code = getNextCode(self.sql,
"bwltab",
"btb_tab",
where=[("btb_cono", "=", self.opts["conum"])],
start=self.nstart,
last=900000)
tables = (("bwldrt", "bdt_cono", "bdt_tab", "bdt_team1", "bdt_team2",
"bdt_team3"), ("bwlent", "bce_cono", "bce_scod"),
("bwlflm", "bfm_cono", "bfm_captain"),
("bwlflt", "bft_cono", "bft_skip", "bft_player"),
("bwlgme", "bcg_cono", "bcg_scod",
"bcg_ocod"), ("bwltab", "btb_cono", "btb_tab"))
for tab in tables:
for col in tab[2:]:
self.sql.updRec(tab[0],
cols=[col],
data=[code],
where=[(tab[1], "=", self.opts["conum"]),
(col, "=", self.tab)])
self.sql.insRec("bwltab", data=tabdat)
def doImport(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Import Details", )
r1s = (("Ratings Only", "R"), ("All Fields", "A"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Details", "", "R", "N",
self.doImpDet, None, None, None), )
self.ip = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doImpEnd, "y"), ),
txit=(self.doImpExit, ))
self.ip.mstFrame.wait_window()
# Populate
if self.impdet is None:
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)
return
fi = FileImport(self.opts["mf"], imptab="bwltab", impskp=self.impskp)
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Ratings",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if self.mixed == "N":
line.extend([0, ""])
chk = self.sql.getRec("bwltab",
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", line[0])],
limit=1)
if not chk:
if self.impdet == "R":
err = "%s %s Does Not Exist" % (fi.impcol[0][0], line[0])
break
line.insert(0, self.opts["conum"])
if self.mlint == "N":
line.insert(2, 0)
self.sql.insRec("bwltab", data=line)
else:
tmp = ["btb_pos1", "btb_rate1", "btb_pos2", "btb_rate2"]
if self.impdet == "R":
cols = tmp
else:
cols = [
"btb_surname", "btb_names", "btb_gender", "btb_add1",
"btb_add2", "btb_add3", "btb_pcod", "btb_home",
"btb_work", "btb_cell", "btb_mail"
] + tmp + ["btb_bsano"]
self.sql.updRec("bwltab",
cols=cols,
data=line[1:],
where=[("btb_cono", "=", self.opts["conum"]),
("btb_tab", "=", line[0])])
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
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 doImpDet(self, frt, pag, r, c, p, i, w):
self.impdet = w
def doImpEnd(self):
self.impskp = ["btb_cono"]
if self.mlint == "N":
self.impskp.append("btb_memno")
if self.impdet == "R":
self.impskp.extend([
"btb_surname", "btb_names", "btb_gender", "btb_add1",
"btb_add2", "btb_add3", "btb_pcod", "btb_home", "btb_work",
"btb_cell", "btb_mail", "btb_bsano"
])
if self.mixed == "N":
self.impskp.extend(["btb_pos2", "btb_rate2"])
self.impskp.append("btb_xflag")
self.ip.closeProcess()
def doImpExit(self):
self.impdet = None
self.ip.closeProcess()
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class dr1010(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):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmes", "ctlrep", "chglog", "ctlnot", "slsiv1", "drsact",
"drschn", "drsdel", "drsmst", "drstrn", "drstyp"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
drsctl = gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.chains = drsctl["ctd_chain"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def mainProcess(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"] = [["T", "drm_chain", 0]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
dlm = {
"stype":
"R",
"tables": ("drsdel", ),
"cols": (("del_code", "", 0, "Del-Cod"), ("del_add1", "", 0,
"Address", "Y"))
}
rpm = {
"stype": "R",
"tables": ("ctlrep", ),
"cols":
(("rep_code", "", 0, "Rep"), ("rep_name", "", 0, "Name", "Y")),
"where": [("rep_cono", "=", self.opts["conum"])]
}
act = {
"stype":
"R",
"tables": ("drsact", ),
"cols": (("dac_code", "", 0, "Cod"), ("dac_desc", "", 0,
"Description", "Y"))
}
typ = {
"stype":
"R",
"tables": ("drstyp", ),
"cols": (("dtp_code", "", 0, "Cod"), ("dtp_desc", "", 0,
"Description", "Y"))
}
msi = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details", "Y")),
"where": [("mss_system", "=", "INV")]
}
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details", "Y")),
"where": [("mss_system", "=", "STA")]
}
tag = (("Basic-_A", None, ("T", 1, 1), ("T", 0, 1)),
("Basic-_B", None, ("T", 1, 1), ("T", 0, 1)))
r1s = (("Yes", "Y"), ("No", "N"))
r2s = (("New", "N"), ("Good", "G"), ("Fair", "F"), ("Poor", "P"),
("Bad", "B"))
self.fld = [
[("T",0,0,0),"IUI",3,"Chain Store","",
"","Y",self.doChain,drc,None,("efld",)],
[("T",0,0,14),"INA",7,"Acc-Num","Account Number",
"","N",self.doAcno,drm,None,("efld",),None,
"To Automatically Generate Account Numbers for "\
"New Accounts enter a Blank Account Number."],
(("T",0,0,30),"INA",30,"Name","",
"","N",self.doName,None,self.doDelete,("notblank",)),
[("T",0,0,0),"INA",7,"Acc-Num","Account Number",
"","Y",self.doAcno,drm,None,("efld",),None,
"To Automatically Generate Account Numbers for "\
"New Accounts enter a Blank Account Number."],
(("T",0,0,14),"INA",30,"Name","",
"","N",self.doName,None,self.doDelete,("notblank",)),
(("T",1,0,0),"INA",30,"Address Line 1","",
"","N",None,None,None,("notblank",)),
(("T",1,1,0),"INA",30,"Address Line 2","",
"","N",None,None,None,("efld",)),
(("T",1,2,0),"INA",30,"Address Line 3","",
"","N",None,None,None,("efld",)),
(("T",1,3,0),"INA",4,"Postal Code","",
"","N",None,None,None,("efld",)),
(("T",1,4,0),"INA",20,"Telephone","",
"","N",None,None,None,("efld",)),
(("T",1,5,0),"INA",20,"Fax","",
"","N",None,None,None,("efld",)),
(("T",1,6,0),"INA",30,"Manager","Manager's Name",
"","N",None,None,None,("efld",)),
(("T",1,6,47),"ITX",30,"E-Mail","Manager's E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,7,0),"INA",30,"Accounts","Accounts Contact",
"","N",None,None,None,("efld",)),
(("T",1,7,47),"ITX",30,"E-Mail","Accounts E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,8,0),"INA",30,"Sales","Sales Contact",
"","N",None,None,None,("efld",)),
(("T",1,8,47),"ITX",30,"E-Mail","Sales E-Mail Address",
"","N",None,None,None,("email",)),
(("T",1,9,0),"Id1",10,"Date Opened","Date Account Opened",
self.sysdtw,"N",None,None,None,("efld",)),
(("T",1,10,0),"Id1",10,"Date Registered","",
"","N",None,None,None,("efld",)),
(("T",1,11,0),"INA",10,"V.A.T Number","",
"","N",None,None,None,("efld",)),
(("T",1,12,0),"INa",7,"Delivery Code","",
"","N",self.doDelivery,dlm,None,("efld",)),
(("T",1,13,0),"INa",3,"Rep Code","",
"","N",self.doRep,rpm,None,("efld",)),
(("T",1,13,20),"ONA",26,""),
(("T",1,14,0),"IUA",3,"Business Activity","",
"","N",self.doBusAct,act,None,("efld",)),
(("T",1,14,20),"ONA",26,""),
(("T",1,15,0),"IUA",3,"Business Type","",
"","N",self.doBusTyp,typ,None,("efld",)),
(("T",1,15,20),"ONA",26,""),
(("T",2,0,0),"IUI",1,"Price Level","",
"","N",None,None,None,("efld",)),
(("T",2,1,0),"IUD",5.2,"Discount Percentage","",
"","N",None,None,None,("efld",)),
(("T",2,2,0),"IUD",5.2,"Interest Percentage","",
"","N",None,None,None,("efld",)),
(("T",2,3,0),"IUI",3,"Referral Terms","",
"","N",None,None,None,("efld",)),
(("T",2,4,0),"IUI",3,"Rejected Terms","",
"","N",None,None,None,("efld",)),
(("T",2,5,0),"IUI",5,"Credit Limit","",
"","N",None,None,None,("efld",)),
(("T",2,6,0),("IRB",r1s),0,"Stop Indicator","",
"N","N",None,None,None,None),
(("T",2,7,0),"IUI",3,"Invoice Message","",
"","N",self.doImes,msi,None,("efld",)),
(("T",2,7,22),"ONA",50,""),
(("T",2,8,0),"IUI",3,"Statement Message","",
"","N",self.doSmes,mss,None,("efld",)),
(("T",2,8,22),"ONA",50,""),
(("T",2,9,0),("IRB",r2s),0,"Credit Rating","",
"N","N",None,None,None,None)]
but = (("Import", None, self.doImport, 0, ("T", 0, 1), ("T", 0, 2),
"Import Account Details from a CSV or XLS File."),
("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 1)),
("Print", None, self.doPrint, 0, ("T", 1, 1), ("T", 0, 1)),
("Cancel", None, self.doCancel, 0, ("T", 1, 1),
("T", 0, 1)), ("Quit", None, self.doExit1, 1, None, None))
tnd = ((self.doEnd1, "N"), (self.doEnd2, "N"), (self.doAccept, "Y"))
txt = (self.doExit1, self.doExit2, self.doExit3)
if self.chains == "Y":
del self.fld[3]
del self.fld[3]
else:
del self.fld[0]
del self.fld[0]
del self.fld[0]
self.chain = 0
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt,
clicks=self.doClick)
if "args" in self.opts:
if self.chains == "Y":
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][0])
self.df.doKeyPressed("T", 0, 1, data=self.opts["args"][1])
else:
self.chain = self.opts["args"][0]
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][1])
def doClick(self, *opts):
if self.df.pag == 0:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", self.chain)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doAcno(self, frt, pag, r, c, p, i, w):
self.acno = w
if self.acno:
self.old = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)],
limit=1)
if not self.acno or not self.old:
ok = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if ok == "no":
return "Invalid Account Number"
pw = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="DRS",
code="NewAcc")
if pw.flag == "no":
if "args" in self.opts:
return "xt"
else:
return "New Account Creation is Not Allowed"
self.new = True
elif self.old[self.sql.drsmst_col.index("drm_stat")] == "X":
return "Invalid Account, Redundant"
else:
self.new = False
self.df.loadEntry("T", pag, p + 1, data=self.old[3])
d = 4
for pg in range(1, self.df.pgs + 1):
for x in range(0, self.df.topq[pg]):
if pg == 1 and x in (17, 19, 21):
continue
if pg == 2 and x in (8, 10):
continue
if pg == 2 and x == 11 and not self.old[d]:
data = "N"
else:
data = self.old[d]
self.df.loadEntry("T", pg, x, data=data)
d += 1
self.loadRep()
self.loadAct()
self.loadTyp()
self.loadInvMess()
self.loadStaMess()
def loadRep(self):
acc = self.sql.getRec("ctlrep",
cols=["rep_name"],
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=",
self.df.t_work[1][0][16])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 17, data=acc[0])
def loadAct(self):
acc = self.sql.getRec("drsact",
cols=["dac_desc"],
where=[("dac_code", "=",
self.df.t_work[1][0][18])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 19, data=acc[0])
def loadTyp(self):
acc = self.sql.getRec("drstyp",
cols=["dtp_desc"],
where=[("dtp_code", "=",
self.df.t_work[1][0][20])],
limit=1)
if acc:
self.df.loadEntry("T", 1, 21, data=acc[0])
def loadInvMess(self):
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "INV"),
("mss_message", "=",
self.df.t_work[2][0][7])],
limit=1)
if acc:
self.df.loadEntry("T", 2, 8, data=acc[0])
def loadStaMess(self):
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "STA"),
("mss_message", "=",
self.df.t_work[2][0][9])],
limit=1)
if acc:
self.df.loadEntry("T", 2, 10, data=acc[0])
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
if self.new and not self.acno:
for x in range(1, 100):
self.acno = genAccNum(self.name, x, 7)
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)],
limit=1)
if not chk:
break
self.df.loadEntry("T", 0, 0, data=self.acno)
def doDelivery(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
ok = askQuestion(self.opts["mf"].body, head="Delivery Address",
mess="This Delivery Address Does Not Exist, Would "\
"You Like to Create It Now?", default="no")
if ok == "no":
return "rf"
callModule(self.opts["mf"],
self.df,
"drc410",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=None,
args=w)
acc = self.sql.getRec("drsdel",
where=[("del_code", "=", w)],
limit=1)
if not acc:
return "rf"
def doRep(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlrep",
cols=["rep_name"],
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=", w)],
limit=1)
if not acc:
return "Invalid Rep"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doBusAct(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drsact",
cols=["dac_desc"],
where=[("dac_code", "=", w)],
limit=1)
if not acc:
return "Invalid Business Activity"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doBusTyp(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drstyp",
cols=["dtp_desc"],
where=[("dtp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Business Type"
self.df.loadEntry("T", 1, p + 1, data=acc[0])
def doImes(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "INV"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Invoice Message"
self.df.loadEntry("T", 2, p + 1, data=acc[0])
def doSmes(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "STA"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Statement Message"
self.df.loadEntry("T", 2, p + 1, data=acc[0])
def doDelete(self):
trs = self.sql.getRec("drstrn",
cols=["count(*)"],
where=[("drt_cono", "=", self.opts["conum"]),
("drt_chain", "=", self.chain),
("drt_acno", "=", self.acno)],
limit=1)
if trs[0]:
return "%s Transactions Exist, Not Deleted" % trs[0]
iv1 = self.sql.getRec("slsiv1",
cols=["count(*)"],
where=[("si1_cono", "=", self.opts["conum"]),
("si1_chain", "=", self.chain),
("si1_acno", "=", self.acno)],
limit=1)
if iv1[0]:
return "%s Sales Document Exists, Not Deleted" % iv1[0]
key = "%03i%s" % (self.chain, self.acno)
nte = self.sql.getRec("ctlnot",
cols=["count(*)"],
where=[("not_cono", "=", self.opts["conum"]),
("not_sys", "=", "DRS"),
("not_key", "=", key)],
limit=1)
if nte[0]:
return "%s Notes Exist, Not Deleted" % nte[0]
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.delRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
self.sql.insRec("chglog", data=["drsmst", "D", "%03i%03i%-7s" % \
(self.opts["conum"], self.chain, self.acno), "", dte,
self.opts["capnm"], "", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd1(self):
self.df.focusField("T", 1, 1, clr=self.new)
def doEnd2(self):
self.df.selPage("Basic-B")
self.df.focusField("T", 2, 1, clr=self.new)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields()
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col + 1
else:
self.df.last[pag][1] = col + 1
self.df.selPage(self.df.tags[pag - 1][0])
else:
self.df.focusField(frt, pag, (col + 1), err=mes)
else:
data = [self.opts["conum"], self.chain]
if self.chains == "Y":
f = 1
else:
f = 0
for x in range(f, f + 2):
data.append(self.df.t_work[0][0][x])
for x in range(0, len(self.df.t_work[1][0])):
if x in (17, 19, 21):
continue
data.append(self.df.t_work[1][0][x])
for x in range(0, len(self.df.t_work[2][0])):
if x in (8, 10):
continue
data.append(self.df.t_work[2][0][x])
if self.new:
data.extend(["N", ""])
self.sql.insRec("drsmst", data=data)
else:
col = self.sql.drsmst_col
data.append(self.old[col.index("drm_stat")])
data.append(self.old[col.index("drm_xflag")])
if data != self.old:
self.sql.updRec("drsmst",
data=data,
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_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=[
"drsmst", "U",
"%03i%03i%-7s" % (self.opts["conum"],
self.chain, self.acno),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
if "args" in self.opts:
self.doExit1()
else:
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doImport(self):
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="drsmst", impskp=["drm_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Debtor's Accounts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
if not line[1]:
if not line[2]:
err = "Blank Account Number and Blank Name"
break
for x in range(1, 100):
line[1] = genAccNum(line[2], x, 7)
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=",
self.opts["conum"]),
("drm_chain", "=", line[0]),
("drm_acno", "=", line[1])],
limit=1)
if not chk:
break
chk = self.sql.getRec("drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", line[0]),
("drm_acno", "=", line[1])],
limit=1)
if chk:
err = "%s %s %s %s Already Exists" % (fi.impcol[0][0], line[0],
fi.impcol[1][0], line[1])
break
if not line[2]:
err = "Blank Name"
break
if not line[15]:
line[15] = self.sysdtw
if not line[28]:
line[28] = "N"
if not line[31]:
line[31] = "N"
line.insert(0, self.opts["conum"])
self.sql.insRec("drsmst", data=line)
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doPrint(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
TabPrt(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
name=self.__class__.__name__,
tabs="drsmst",
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", self.acno)])
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.last[0] = [0, 0]
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doExit1(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doExit2(self):
self.df.focusField("T", 0, 1)
def doExit3(self):
self.df.selPage("Basic-A")
class wgc210(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,
"wagrcv",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
rcv = {
"stype": "R",
"tables": ("wagrcv", ),
"cols":
(("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details"))
}
self.fld = ((("T", 0, 0, 0), "IUI", 4, "Item Code", "", "", "N",
self.doCode, rcv, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 50, "Description", "", "", "N",
None, 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=self.fld,
butt=but,
tend=tnd,
txit=txt)
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec("wagrcv",
where=[("rcv_code", "=", self.code)],
limit=1)
if not acc:
self.new = "Y"
else:
self.new = "N"
for x in range(1, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=acc[x])
def doDelete(self):
self.sql.delRec("wagrcv", where=[("rcv_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dat = []
for x in range(0, len(self.df.t_work[0][0])):
dat.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("wagrcv", data=dat)
else:
self.sql.updRec("wagrcv",
data=dat,
where=[("rcv_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 arc210(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, ["assdep", "assgrp", "assmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
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"]
return True
def mainProcess(self):
cod = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Grp"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])],
"order":
"asd_code"
}
r1s = (("Straight Line", "S"), ("Diminishing Balance", "D"))
fld = [(("T", 0, 0, 0), "I@asd_code", 0, "", "", "", "N", self.doCode,
cod, None, ("notblank", )),
(("T", 0, 1, 0), "I@asd_desc", 0, "", "", "", "N", None, None,
self.doDelete, ("notblank", )),
(("T", 0, 2, 0), ("IRB", r1s), 0, "Type", "", "S", "N",
self.doDepTyp, None, None, None)]
if self.rordp == "Y":
fld.append(
(("T", 0, 3, 0), ("IRB", r1s), 0, "Receiver Type",
"Receiver Type", "S", "N", self.doRecTyp, None, None, None))
fld.append(
(("C", 0, 0, 0), "IUD", 12.2, "Company-Rate", "Company Rate", "",
"N", self.doCoyRte, None, None, ("efld", ), ("Period", 7)))
if self.rordp == "Y":
fld.append(
(("C", 0, 0, 1), "IUD", 12.2, "Receiver-Rate", "Receiver Rate",
"", "N", self.doRecRte, None, None, ("efld", )))
but = (("Cancel", None, self.doCancel, 0, ("T", 0, 2), ("T", 0, 1)), )
tnd = ((self.doEnd, "n"), )
txt = (self.doExit, )
cnd = ((self.doEnd, "n"), )
cxt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
for x in range(7):
self.df.colLabel[0][x].configure(text="Year %s" % (x + 1))
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.acc = self.sql.getRec("assdep",
where=[("asd_cono", "=",
self.opts["conum"]),
("asd_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
for x in range(self.df.topq[pag]):
self.df.loadEntry("T", 0, x, data=self.acc[x + 1])
if self.rordp == "Y":
inc = 1
else:
x += 1
inc = 2
for y in range(0, 14, inc):
self.df.loadEntry("C",
0,
int(y / inc),
data=self.acc[x + y + 2])
def doDepTyp(self, frt, pag, r, c, p, i, w):
self.ctyp = w
def doRecTyp(self, frt, pag, r, c, p, i, w):
self.rtyp = w
def doCoyRte(self, frt, pag, r, c, p, i, w):
if self.ctyp == "D" or not w:
self.df.colf[pag][0][1] = "OUD"
return
if w and p != 0 and not self.df.c_work[0][r - 1][i]:
return "Value Not Allowed after a Zero"
def doRecRte(self, frt, pag, r, c, p, i, w):
if self.rtyp == "D" or not w:
self.df.colf[pag][1][1] = "OUD"
return
if w and p != 1 and not self.df.c_work[0][r - 1][i]:
return "Value Not Allowed"
def doDelete(self):
ck1 = self.sql.getRec("assgrp",
where=[("asg_cono", "=", self.opts["conum"]),
("asg_depcod", "=", self.code)])
ck2 = self.sql.getRec("assmst",
where=[("asm_cono", "=", self.opts["conum"]),
("asm_depcod", "=", self.code)])
if ck1 or ck2:
return "Code in Use, Not Deleted"
self.sql.delRec("assdep",
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", self.df.t_work[0][0][0])])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
elif self.df.col != len(self.df.colEntry[0]):
self.df.focusField(self.df.frt, self.df.pag, self.df.col + 1)
else:
self.df.colf[0][0][1] = "IUD"
if self.rordp == "Y":
self.df.colf[0][1][1] = "IUD"
if self.df.entryConfirm("", dflt="y") == "y":
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
data.append(self.df.t_work[0][0][x])
if self.rordp == "N":
data.append("N")
for x in range(0, len(self.df.c_work[0])):
data.extend(self.df.c_work[0][x])
if self.rordp == "N":
data.append(0)
if self.new == "Y":
self.sql.insRec("assdep", data=data)
elif data != self.acc[:len(data)]:
col = self.sql.assdep_col
data.append(self.acc[col.index("asd_xflag")])
self.sql.updRec("assdep",
data=data,
where=[("asd_cono", "=",
self.opts["conum"]),
("asd_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
else:
self.df.focusField("C", 0, 1)
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
if self.df.frt == "T":
self.df.closeProcess()
self.opts["mf"].closeLoop()
elif self.df.col == 1:
self.doCancel()
else:
data = self.df.c_work[0][self.df.row][self.df.idx]
self.df.loadEntry("C", 0, self.df.pos, data=data)
self.df.focusField("C", 0, self.df.pos)
class st2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.exit = False
self.selectPrinter()
if not self.exit:
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "ctlmes", "ctlvrf", "ctlrep", "crsmst", "gentrn",
"strgrp", "strloc", "strmf1", "strmf2", "strpom", "strpot",
"strtrn", "strgmu", "strcmu", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
mods = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
mods.append(ctlmst["ctm_modules"][x:x + 2])
if "CR" not in mods:
showError(
self.opts["mf"].body, "System Error",
"This module requires you to have a Creditor's Activated")
return
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.stgl = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
self.dtpl = strctl["cts_tplnam"]
if self.stgl == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.soh = ctlctl["stk_soh"]
self.ssp = ctlctl["stk_susp"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def selectPrinter(self):
tit = ("Printer Selection", )
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "O"), ("tpm_system", "=", "STR")],
"order":
"tpm_tname"
}
fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.dtpl, "N",
self.doTplNam, tpm, None, None),
(("T", 0, 1, 0), "ID1", 10, "Order Date", "", self.sysdtw, "N",
self.doOrdDate, None, None, ("efld", )))
self.pr = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=fld,
tend=((self.doPrtEnd, "y"), ),
txit=(self.doPrtExit, ),
view=("N", "P"),
mail=("N", "Y", "Y"))
self.opts["mf"].startLoop()
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "O"),
("tpm_system", "=", "STR")],
limit=1)
if not acc:
return "Invalid Template Name"
self.tname = w
def doOrdDate(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.trdt = w
self.trdd = self.pr.t_disp[0][0][1]
self.curdt = int(self.trdt / 100)
self.batch = "S%s" % self.curdt
def doPrtEnd(self):
self.doPrtClose()
def doPrtExit(self):
self.exit = True
self.doPrtClose()
def doPrtClose(self):
self.pr.closeProcess()
self.opts["mf"].closeLoop()
def mainProcess(self):
doc = {
"stype":
"R",
"tables": ("strpom", "crsmst"),
"cols":
(("pom_ordno", "", 0, "Ord-Num"), ("pom_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")),
"where": [("pom_cono", "=", self.opts["conum"]),
("crm_cono=pom_cono", ), ("crm_acno=pom_acno", ),
("pom_delno", "=", "")]
}
loc = {
"stype":
"R",
"tables": ("strloc", ),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]
}
crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols": [("crm_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")],
"where": [("crm_cono", "=", self.opts["conum"]),
("crm_stat", "<>", "X")],
"index":
0
}
odr = {
"stype": "R",
"tables": ("ctlrep", ),
"cols": [("rep_code", "", 0, "Ord"),
("rep_name", "", 0, "Name", "Y")],
"where": [("rep_cono", "=", self.opts["conum"])],
"index": 0
}
grp = {
"stype":
"R",
"tables": ("strgrp", ),
"cols": (("gpm_group", "", 0, "Grp"), ("gpm_desc", "", 0,
"Description", "Y")),
"where": [("gpm_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("strmf1", ),
"cols": (("st1_code", "", 0, "Product-Code"),
("st1_desc", "", 0, "Description", "Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "not", "in", ("R", "X")),
("st1_value_ind", "<>", "N")],
"whera": [("C", "st1_group", 0)],
"order":
"st1_group, st1_code"
}
r1s = (("New", "N"), ("Amend", "A"), ("Receive", "R"), ("Cancel", "C"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Action", "", "N", "Y",
self.doActTyp, None, None,
None), (("T", 0, 1, 0), "IUI", 9, "Ord-No", "Order Number", "",
"N", self.doOrdNum, doc, None, ("notblank", )),
(("T", 0, 2, 0), "IUA", 1, "Loc", "Location Code", "1", "N",
self.doLoc, loc, None, None), (("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "INA", 7, "Acc-No", "Account Number", "", "N",
self.doCrsAcc, crm, None, None), (("T", 0, 3, 0), "ONA", 30,
""),
(("T", 0, 4, 0), "INa", 3, "Ord-By", "Ordered By", "", "N",
self.doOrdBy, odr, None, None), (("T", 0, 4, 0), "ONA", 30,
""),
(("T", 0, 5, 0), "INa", 7, "Del-No", "Delivery Note Number", "",
"N", self.doDelNum, None, None, ("notblank", )),
(("T", 0, 5, 0), "ID1", 10, "Date", "Delivery Date", self.trdt,
"N", self.doDelDate, None, None,
("efld", )), (("C", 0, 0, 0), "INA", 3, "Grp", "Product Group",
"", "Y", self.doGrp, grp, None, None),
(("C", 0, 0, 1), "INA", 20, "Product-Code", "", "", "N",
self.doCod, cod, None,
None), (("C", 0, 0, 2), "INA", (20, 30), "Description", "", "",
"N", self.doDes, None, None,
None), (("C", 0, 0, 3), "ISD", 11.2, "Quantity", "", 1,
"N", self.doQty, None, None, ("notzero", )),
(("C", 0, 0, 4), "IUA", 1, "V", "V.A.T. Code", "I", "N",
self.doVat, None, None, ("notblank", )),
(("C", 0, 0, 5), "IUD", 10.2, "Price", "Exclusive Price", "",
"N", self.doPri, None, None,
None), (("C", 0, 0, 6), "IUD", 6.2, "Dis-%", "Trade Discount",
"", "N", self.doDis, None, None,
None), (("C", 0, 0, 7), "OSD", 10.2, "Value"))
self.row = (15, )
self.but = (("Cancel", None, self.doCancel, 1, ("C", 0, 1),
("T", 0, 1)), ("DelAdd", None, self.doDelAdd, 1,
("C", 0, 1), ("T", 0, 1)),
("Ribbon", None, self.doRibbon, 1, ("C", 0, 1),
("T", 0, 1)), ("Message", None, self.doMessag, 1,
("C", 0, 1), ("T", 0, 1)),
("Edit", None, self.doEdit, 0, ("C", 0, 1), ("C", 0, 2)),
("Reprint", None, self.doReprnt, 0, ("T", 0, 1),
("T", 0, 2)), ("CrsMaint", None, self.doCrsMaint, 0,
("T", 0, 5), ("T", 0, 6)),
("CrsQuery", None, self.doCrsQuery, 1, None,
None), ("StrMaint", None, self.doStrMaint, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0, 2))),
("StrQuery", None, self.doStkQuery, 1, None,
None), ("Exit", None, self.doTopExit, 0, ("T", 0, 1),
(("T", 0, 2), ("T", 0, 3),
("T", 0, 5)), "Exit Purchase Orders"),
("Accept", None, self.doAccept, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0, 2))))
tnd = ((self.doTopEnd, "n"), )
txt = (self.doTopExit, )
cnd = ((self.doColEnd, "n"), )
cxt = (None, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
rows=self.row,
butt=self.but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
vport=True)
def doActTyp(self, frt, pag, r, c, p, i, w):
# Initialise Action Variables
self.acttyp = w
# Initialise Variables
self.dnum = ""
self.onum = ""
self.jnum = ""
self.dadd = ""
self.cnam = ""
self.vatn = ""
self.ribbon = None
ctl = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])],
limit=1)
self.deladd = [
ctl[self.sql.ctlmst_col.index("ctm_sadd1")],
ctl[self.sql.ctlmst_col.index("ctm_sadd2")],
ctl[self.sql.ctlmst_col.index("ctm_sadd3")],
ctl[self.sql.ctlmst_col.index("ctm_spcode")]
]
self.message = ""
for x in (1, 2, 3):
if self.acttyp == "R":
self.df.butt[x][1] = 0
self.df.butt[x][2] = None
else:
self.df.butt[x][1] = 1
self.df.butt[x][2] = ["C", 0, 1]
if self.acttyp == "N":
# Location default
if self.locs == "N":
self.loc = "1"
self.df.loadEntry(frt, pag, p + 2, data=self.loc)
self.df.loadEntry(frt, pag, p + 3, data="Location One")
return "sk3"
return "sk1"
def doOrdNum(self, frt, pag, r, c, p, i, w):
strpom = self.sql.getRec("strpom",
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", w)],
limit=1)
if not strpom:
return "Invalid Document"
if strpom[self.sql.strpom_col.index("pom_delno")] == "cancel":
if self.acttyp == "C":
return "Already Cancelled"
ok = askQuestion(
self.opts["mf"].body,
"Cancelled",
"This order was Cancelled.\n\nDo you want to Reinstate It?",
default="no")
if ok == "no":
return "Order Cancelled"
self.sql.updRec("strpom",
cols=["pom_delno"],
data=[""],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", w)])
strpom[self.sql.strpom_col.index("pom_delno")] = ""
elif strpom[self.sql.strpom_col.index("pom_delno")]:
return "Order Already Received"
self.ordno = CCD(w, "UI", 9.0).work
self.othno = CCD(w, "Na", 9.0).work
self.loc = strpom[self.sql.strpom_col.index("pom_loc")]
self.acno = strpom[self.sql.strpom_col.index("pom_acno")]
self.cnam = strpom[self.sql.strpom_col.index("pom_contact")]
self.vatn = strpom[self.sql.strpom_col.index("pom_vatno")]
self.ordby = strpom[self.sql.strpom_col.index("pom_ordby")]
self.ribbon = ["", "", self.cnam, self.vatn]
self.df.loadEntry(frt, pag, p + 1, data=self.loc)
self.doLoc(frt, pag, r, c + 1, p + 1, i + 1, self.loc)
self.df.loadEntry(frt, pag, p + 3, data=self.acno)
self.doCrsAcc(frt, pag, r, c + 3, p + 3, i + 3, self.acno)
self.df.loadEntry(frt, pag, p + 5, data=self.ordby)
self.doOrdBy(frt, pag, r, c + 5, p + 5, i + 5, self.ordby)
if self.acttyp == "R":
return "sk6"
else:
return "nd"
def doLoc(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("strloc",
cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", w)],
limit=1)
if not desc:
return "Invalid Location"
self.loc = w
self.df.loadEntry(frt, pag, p + 1, data=desc[0])
def doCrsAcc(self, frt, pag, r, c, p, i, w):
self.crsmst = self.sql.getRec("crsmst",
where=[("crm_cono", "=",
self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not self.crsmst:
return "Invalid Account"
if self.crsmst[self.sql.crsmst_col.index("crm_stat")] == "X":
return "Invalid Account, Redundant"
self.acno = w
self.name = self.crsmst[self.sql.crsmst_col.index("crm_name")]
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doOrdBy(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlrep",
cols=["rep_name"],
where=[("rep_cono", "=", self.opts["conum"]),
("rep_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
self.ordby = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
return "sk3"
def doDelNum(self, frt, pag, r, c, p, i, w):
self.delno = w
def doDelDate(self, frt, pag, r, c, p, i, w):
self.deldt = w
def doTopEnd(self):
if self.acttyp == "N":
# Get and Display Next Document Number
ordno = self.sql.getRec("strpom",
cols=["max(pom_ordno)"],
where=[("pom_cono", "=",
self.opts["conum"])],
limit=1)
if not ordno[0]:
self.ordno = CCD(1, "UI", 9).work
self.othno = CCD(1, "Na", 9).work
else:
self.ordno = CCD((int(ordno[0]) + 1), "UI", 9).work
self.othno = CCD((int(ordno[0]) + 1), "Na", 9).work
self.df.loadEntry(self.df.frt, self.df.pag, 1, data=self.ordno)
# Create Document Transaction (Head)
self.dad1, self.dad2, self.dad3, self.dad4 = "", "", "", ""
data = [
self.opts["conum"], self.ordno, self.loc, self.trdt, self.acno,
self.dad1, self.dad2, self.dad3, self.dad4, "", "", "", "",
self.ordby, "", "", 0, self.opts["capnm"], self.sysdtw
]
# Write and Commit Header
self.sql.insRec("strpom", data=data)
self.opts["mf"].dbm.commitDbase()
# Clear Totals
self.doClearTots()
elif self.acttyp == "C":
self.doReadLoadStr()
ok = askQuestion(self.opts["mf"].body,
"Cancel",
"Are You Sure This Order Must be Cancelled?",
default="no")
if ok == "yes":
# Print Cancellation
self.df.setWidget(self.df.mstFrame, state="hide")
PrintOrder(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.ordno,
tname=self.tname,
repprt=self.pr.repprt,
repeml=self.pr.repeml,
copy=self.acttyp.lower())
self.df.setWidget(self.df.mstFrame, state="show")
# Update Deletetion
self.sql.updRec("strpom",
cols=["pom_delno"],
data=["cancel"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno)])
self.opts["mf"].dbm.commitDbase()
# Clear totals and focus
self.doClearTots()
self.df.focusField("T", 0, 1)
else:
self.doReadLoadStr()
self.amend = False
def doReadLoadStr(self):
self.doClearTots()
data = self.sql.getRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno)],
order="pot_group, pot_code")
if not data:
return
for seq, line in enumerate(data):
self.doExtData(line)
if seq >= self.row[0]:
self.df.scrollScreen(0)
pos = (self.row[0] - 1) * 9
else:
pos = seq * 9
# Load Values
self.df.loadEntry("C", 0, pos, data=self.grp)
self.df.loadEntry("C", 0, pos + 1, data=self.code)
self.df.loadEntry("C", 0, pos + 2, data=self.desc)
self.df.loadEntry("C", 0, pos + 3, data=self.qty)
self.df.loadEntry("C", 0, pos + 5, data=self.vatcod)
self.df.loadEntry("C", 0, pos + 6, data=self.price)
self.df.loadEntry("C", 0, pos + 7, data=self.disrat)
self.df.loadEntry("C", 0, pos + 8, data=self.excamt)
self.vattot = float(ASD(self.vattot) + ASD(self.vatamt))
self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt))
self.inctot = float(ASD(self.inctot) + ASD(self.incamt))
if seq >= (self.row[0] - 1):
self.df.scrollScreen(0)
else:
self.df.focusField("C", 0, pos + 10)
self.df.setViewPort("O", self.inctot)
def doTopExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doClearTots(self):
self.vattot = 0
self.ordtot = 0
self.inctot = 0
self.df.clearFrame("C", 0)
self.df.focusField("C", 0, 1)
self.df.setViewPort(None, 0)
def doGrp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group Code"
self.grp = w
def doCod(self, frt, pag, r, c, p, i, w):
strmf1 = self.sql.getRec("strmf1",
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.grp),
("st1_code", "=", w)],
limit=1)
if not strmf1:
return "Invalid Code"
if strmf1[self.sql.strmf1_col.index("st1_type")] == "R":
return "Invalid Code (Recipe)"
if strmf1[self.sql.strmf1_col.index("st1_type")] == "X":
return "Invalid Code (Redundant)"
if strmf1[self.sql.strmf1_col.index("st1_value_ind")] == "N":
return "Invalid Code (Value Indicator)"
self.vatcod = strmf1[self.sql.strmf1_col.index("st1_vatcode")]
strmf2 = self.sql.getRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.grp),
("st2_code", "=", w),
("st2_loc", "=", self.loc)],
limit=1)
if not strmf2:
return "Invalid Location"
odt = self.sql.getRec("strpot",
cols=["count(*)"],
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno),
("pot_group", "=", self.grp),
("pot_code", "=", w)],
limit=1)
if odt[0]:
return "This Item is Already On This Order"
odq = self.sql.getRec(tables=["strpom", "strpot"],
cols=["sum(pot_qty)"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_loc", "=", self.loc),
("pom_delno", "=", ""),
("pot_cono", "=", self.opts["conum"]),
("pot_ordno=pom_ordno", ),
("pot_group", "=", self.grp),
("pot_code", "=", w)],
limit=1)
if odq[0]:
state = self.df.disableButtonsTags()
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="DupOrd",
desc="%s of this Item is Already On Order" %
odq[0])
self.df.enableButtonsTags(state=state)
if cf.flag == "no":
return "rf"
self.code = w
desc = strmf1[self.sql.strmf1_col.index("st1_desc")]
self.uoi = strmf1[self.sql.strmf1_col.index("st1_uoi")]
self.df.loadEntry(frt, pag, p + 1, data=desc)
def doDes(self, frt, pag, r, c, p, i, w):
self.desc = w
def doQty(self, frt, pag, r, c, p, i, w):
self.qty = w
self.df.loadEntry(frt, pag, p + 1, data=self.vatcod)
def doVat(self, frt, pag, r, c, p, i, w):
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trdt)
if self.vatrte is None:
return "Invalid V.A.T Code"
self.vatcod = w
# Last Cost Price
lcost = getCost(self.sql,
self.opts["conum"],
self.grp,
self.code,
loc=self.loc,
qty=1,
ind="L")
self.df.loadEntry(frt, pag, p + 1, data=lcost)
def doPri(self, frt, pag, r, c, p, i, w):
self.price = w
self.inc = round((self.price * (self.vatrte + 100.0) / 100.0), 4)
self.exc = round((self.price * 1), 2)
dis = self.crsmst[self.sql.crsmst_col.index("crm_trdis")]
self.df.loadEntry(frt, pag, p + 1, data=dis)
def doDis(self, frt, pag, r, c, p, i, w):
self.disrat = w
dis = float(ASD(100) - ASD(self.disrat))
self.excamt = round((self.qty * self.exc * dis / 100.0), 2)
self.incamt = round((self.qty * self.inc * dis / 100.0), 2)
self.vatamt = float(ASD(self.incamt) - ASD(self.excamt))
self.df.loadEntry(frt, pag, p + 1, data=self.excamt)
self.vattot = float(ASD(self.vattot) + ASD(self.vatamt))
self.ordtot = float(ASD(self.ordtot) + ASD(self.excamt))
self.inctot = float(ASD(self.inctot) + ASD(self.incamt))
self.df.setViewPort("O", self.inctot)
def doColEnd(self):
# Create Purchase Order Transaction (Body)
data = [
self.opts["conum"], self.ordno, self.grp, self.code, self.uoi,
self.desc, self.qty, self.price, self.disrat, self.vatcod,
self.vatrte, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strpot", data=data)
if self.acttyp == "A":
self.amend = True
self.df.advanceLine(0)
def doCrsQuery(self):
callModule(self.opts["mf"],
self.df,
"cr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def doStkQuery(self):
callModule(self.opts["mf"],
self.df,
"st4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
def doDelAdd(self):
tit = ("Delivery Address", )
fld = ((("T", 0, 0, 0), "INA", 30, "Address-1", "Address Line 1", "",
"N", None, None, None,
None), (("T", 0, 1, 0), "INA", 30, "Address-2",
"Address Line 2", "", "N", None, None, None, None),
(("T", 0, 2, 0), "INA", 30, "Address-3", "Address Line 3", "",
"N", None, None, None, None),
(("T", 0, 3, 0), "INA", 30, "Address-4", "Address Line 4", "",
"N", None, None, None, None))
state = self.df.disableButtonsTags()
self.da = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doDelEnd, "n"), ),
txit=(self.doDelExit, ),
focus=False)
for x in range(0, len(self.deladd)):
self.da.loadEntry("T", 0, 0 + x, data=self.deladd[x])
self.da.focusField("T", 0, 1, clr=False)
self.da.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doDelEnd(self):
self.deladd = []
for x in range(0, self.da.topq[0]):
self.deladd.append(self.da.t_work[0][0][x])
self.doDelExit()
def doDelExit(self):
self.da.closeProcess()
def doMessag(self):
tit = ("Order Message", )
cod = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": [("mss_message", "", 0, "Cod"),
("mss_detail", "", 60, "Details")],
"where": [("mss_system", "=", "STR")],
"screen":
self.df.mstFrame
}
fld = ((("T", 0, 0, 0), "IUI", 3, "Message Code", "", "", "N",
self.doMesCod, cod, None, None),
(("T", 0, 1, 0), "ITv", (30, 6), "Message", "", self.message,
"N", None, None, None, None))
but = (("Accept", None, self.doMesEnd, 0, ("T", 0, 1), ("T", 0, 0)), )
state = self.df.disableButtonsTags()
self.mg = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doMesEnd, "n"), ),
txit=(self.doMesExit, ),
butt=but)
self.mg.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doMesCod(self, frt, pag, r, c, p, i, w):
if w:
mess = self.sql.getRec("ctlmes",
where=[("mss_system", "=", "STR"),
("mss_message", "=", w)],
limit=1)
if not mess:
return "Invalid Message Code"
self.message = mess[self.sql.ctlmse_col.index("mss_detail")]
self.mg.loadEntry(frt, pag, p + 1, data=self.message)
def doMesEnd(self):
wid, self.message = self.mg.getEntry("T", 0, 1)
self.doMesExit()
def doMesExit(self):
self.mg.closeProcess()
def doEdit(self):
# Display document items and allow editing of desc, qty and price
recs = self.sql.getRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno)],
order="pot_group, pot_code")
if recs:
data = []
for l in recs:
qty = CCD(l[self.sql.strpot_col.index("pot_qty")], "SD", 11.2)
prc = CCD(l[self.sql.strpot_col.index("pot_price")], "UD",
10.2)
dis = CCD(l[self.sql.strpot_col.index("pot_disper")], "UD",
6.2)
data.append([
l[self.sql.strpot_col.index("pot_group")],
l[self.sql.strpot_col.index("pot_code")],
l[self.sql.strpot_col.index("pot_desc")], qty.disp,
l[self.sql.strpot_col.index("pot_vatcod")], prc.disp,
dis.disp
])
head = ("Grp", "Product-Code", "Description", "Quantity", "V",
"Price", "Disc-%")
lin = {
"stype":
"C",
"head":
head,
"typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 11.2),
("UA", 1), ("UD", 10.2), ("UD", 6.2)),
"data":
data
}
state = self.df.disableButtonsTags()
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.change = chg.selection
self.doChanges()
self.df.enableButtonsTags(state=state)
self.df.focusField("C", 0, self.df.col)
def doChanges(self):
tit = ("Change Items", )
fld = ((("T", 0, 1, 0), "ONA", 3, "Group"), (("T", 0, 2, 0), "ONA", 20,
"Code"),
(("T", 0, 3, 0), "INA", 30, "Description", "", "", "N",
self.doChgDes, None, None, ("notblank", )),
(("T", 0, 4, 0), "ISD", 11.2, "Quantity", "", "", "N",
self.doChgQty, None, None, ("notzero", )),
(("T", 0, 5, 0), "IUD", 10.2, "Selling Price", "", "", "N",
self.doChgPrc, None, None, ("notzero", )),
(("T", 0, 6, 0), "IUD", 6.2, "Discount Percent", "", "", "N",
self.doChgDis, None, None, ("efld", )))
but = (("Delete", None, self.doChgDel, 1, None, None), )
tnd = ((self.doChgEnd, "n"), )
txt = (self.doChgExit, )
self.cg = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
self.cg.loadEntry("T", 0, 0, data=self.change[0])
self.cg.loadEntry("T", 0, 1, data=self.change[1])
self.cg.loadEntry("T", 0, 2, data=self.change[2])
self.cg.loadEntry("T", 0, 3, data=self.change[3])
self.cg.loadEntry("T", 0, 4, data=self.change[5])
self.cg.loadEntry("T", 0, 5, data=self.change[6])
self.cg.focusField("T", 0, 3, clr=False)
self.cg.mstFrame.wait_window()
def doChgDes(self, frt, pag, r, c, p, i, w):
self.desc = w
def doChgQty(self, frt, pag, r, c, p, i, w):
self.qty = w
def doChgPrc(self, frt, pag, r, c, p, i, w):
self.price = w
def doChgDis(self, frt, pag, r, c, p, i, w):
self.disrat = w
def doChgDel(self):
grp = self.change[0]
cod = self.change[1]
self.sql.delRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno),
("pot_group", "=", grp),
("pot_code", "=", cod)])
if self.acttyp == "A":
self.amend = True
self.doChgExit(loader=True)
def doChgEnd(self):
grp = self.change[0]
cod = self.change[1]
col = ["pot_desc", "pot_qty", "pot_price", "pot_disper"]
dat = [self.desc, self.qty, self.price, self.disrat]
whr = [("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno), ("pot_group", "=", grp),
("pot_code", "=", cod)]
self.sql.updRec("strpot", cols=col, data=dat, where=whr)
if self.acttyp == "A":
self.amend = True
self.doChgExit(loader=True)
def doChgExit(self, loader=False):
self.cg.closeProcess()
if loader:
self.doReadLoadStr()
def doReprnt(self):
tit = ("Reprint Orders", )
odr = {
"stype":
"R",
"tables": ("strpom", "crsmst"),
"cols": [("pom_ordno", "", 0, "Doc-Num"),
("pom_date", "", 0, "Date"),
("pom_acno", "", 0, "Acc-Num"),
("crm_name", "", 0, "Name", "Y")],
"where": [("pom_cono", "=", self.opts["conum"]),
("pom_cono=crm_cono", ), ("pom_acno=crm_acno", )],
"screen":
self.opts["mf"].body
}
r1s = (("Copies", "C"), ("Originals", "O"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Document Mode", "", "C", "N",
self.doMode, None, None, None),
(("T", 0, 1, 0), "IUI", 9, "From Number",
"From Document Number", "", "N", self.doOrd, odr, None,
("notzero", )), [("T", 0, 2, 0), "IUI", 9, "To Number",
"To Document Number", "", "N", None, odr,
None, ("notzero", )])
state = self.df.disableButtonsTags()
self.rp = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doReprntEnd, "n"), ),
txit=(self.doReprntExit, ),
view=("N", "V"),
mail=("B", "Y"))
self.rp.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doMode(self, frt, pag, r, c, p, i, w):
if w == "C":
self.copy = "y"
else:
self.copy = "n"
def doOrd(self, frt, pag, r, c, p, i, w):
self.rp.topf[pag][2][5] = w
def doReprntEnd(self):
self.rp.closeProcess()
self.df.setWidget(self.df.mstFrame, state="hide")
frm = self.rp.t_work[0][0][1]
if not self.rp.t_work[0][0][2]:
to = frm
else:
to = self.rp.t_work[0][0][2]
odr = self.sql.getRec("strpom",
cols=["pom_ordno"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", ">=", frm),
("pom_ordno", "<=", to)])
if odr:
PrintOrder(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
odr,
tname=self.tname,
repprt=self.rp.repprt,
repeml=self.rp.repeml,
copy=self.copy)
self.df.setWidget(self.df.mstFrame, state="show")
def doReprntExit(self):
self.rp.closeProcess()
def doCrsMaint(self):
state = self.df.disableButtonsTags()
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="NewCrs")
if cf.flag == "yes":
callModule(self.opts["mf"],
self.df,
"cr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doStrMaint(self):
state = self.df.disableButtonsTags()
cf = PwdConfirm(self.opts["mf"],
conum=self.opts["conum"],
system="STR",
code="NewStr")
if cf.flag == "yes":
callModule(self.opts["mf"],
self.df,
"st1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doAccept(self):
self.df.setWidget(self.df.B11, "disabled")
if self.df.col == 1:
self.doCancel()
else:
# Update Tables
self.doUpdateTables()
# Commit Transaction
self.opts["mf"].dbm.commitDbase()
# Print Document
if self.acttyp == "N" or (self.acttyp == "A" and self.amend):
self.df.setWidget(self.df.mstFrame, state="hide")
PrintOrder(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.ordno,
tname=self.tname,
repprt=self.pr.repprt,
repeml=self.pr.repeml,
copy=self.acttyp.lower())
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField("T", 0, 1)
def doRibbon(self):
tit = ("Ribbon Line", )
fld = ((("T", 0, 0, 0), "INA", 30, "Customer Order", "", self.cnam,
"N", None, None, None, None),
(("T", 0, 1,
0), "INA", 30, "Job Number", "", self.cnam, "N", None, None,
None, None), (("T", 0, 2, 0), "INA", 30, "Contact Person", "",
self.cnam, "N", None, None, None, None),
(("T", 0, 3, 0), "INA", 10, "VAT Number", "", self.vatn, "N",
self.doVatNum, None, None, None))
state = self.df.disableButtonsTags()
self.rb = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doRibEnd, "n"), ),
txit=(self.doRibExit, ),
focus=False)
if self.ribbon:
self.rb.loadEntry("T", 0, 0, data=self.ribbon[0])
self.rb.loadEntry("T", 0, 1, data=self.ribbon[1])
self.rb.loadEntry("T", 0, 2, data=self.ribbon[2])
self.rb.loadEntry("T", 0, 3, data=self.ribbon[3])
self.rb.focusField("T", 0, 1)
self.rb.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doVatNum(self, frt, pag, r, c, p, i, w):
if self.ordtot >= 1000.00 and not w:
return "Invalid VAT Number"
def doRibEnd(self):
self.ribbon = []
for x in range(0, self.rb.topq[0]):
self.ribbon.append(self.rb.t_work[0][0][x])
self.doRibExit()
def doRibExit(self):
self.rb.closeProcess()
def doUpdateTables(self):
# Update strpom with ribbon, delivery and message details
whr = [("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno), ("pom_acno", "=", self.acno)]
if self.ribbon:
self.sql.updRec(
"strpom",
cols=["pom_cusord", "pom_jobnum", "pom_contact", "pom_vatno"],
data=[
self.ribbon[0], self.ribbon[1], self.ribbon[2],
self.ribbon[3]
],
where=whr)
if not self.vatn:
self.sql.updRec("crsmst",
cols=["crm_vatno"],
data=[self.ribbon[1]],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.acno)])
if self.deladd:
self.sql.updRec(
"strpom",
cols=["pom_add1", "pom_add2", "pom_add3", "pom_add4"],
data=[
self.deladd[0], self.deladd[1], self.deladd[2],
self.deladd[3]
],
where=whr)
if self.message:
self.sql.updRec("strpom",
cols=["pom_mess"],
data=[self.message],
where=whr)
if self.acttyp != "R":
return
# Receipt of Order
# Create Stores Transactions and update strpot lines
trn = self.sql.getRec("strpot",
where=[("pot_cono", "=", self.opts["conum"]),
("pot_ordno", "=", self.ordno)],
order="pot_group, pot_code")
if not trn:
return
for line in trn:
self.doExtData(line)
curdt = int(self.deldt / 100)
# Update strpom record
self.sql.updRec("strpom",
cols=["pom_delno", "pom_deldt"],
data=[self.delno, self.deldt],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno)])
# Write strtrn record
data = [
self.opts["conum"], self.grp, self.code, self.loc, self.deldt,
1, self.othno, self.batch, self.delno, self.qty, self.excamt,
0, curdt, self.name, 0, self.acno, "", "STR", self.disrat, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("strtrn", data=data)
# If Integrated Create GL Transaction (SOH and Recon Accounts)
if self.stgl == "Y" and self.excamt:
# Stock on Hand Control
data = (self.opts["conum"], self.soh, curdt, self.deldt, 5,
self.othno, self.batch, self.excamt, 0, self.name, "",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
cst = float(ASD(0) - ASD(self.excamt))
# Stock Reconciliation Control
data = (self.opts["conum"], self.ssp, curdt, self.deldt, 5,
self.othno, self.batch, cst, 0, self.name, "", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doExtData(self, line):
self.grp = line[self.sql.strpot_col.index("pot_group")]
self.code = line[self.sql.strpot_col.index("pot_code")]
self.uoi = line[self.sql.strpot_col.index("pot_uoi")]
self.desc = line[self.sql.strpot_col.index("pot_desc")]
self.qty = line[self.sql.strpot_col.index("pot_qty")]
self.price = line[self.sql.strpot_col.index("pot_price")]
self.disrat = line[self.sql.strpot_col.index("pot_disper")]
self.vatcod = line[self.sql.strpot_col.index("pot_vatcod")]
self.vatrte = line[self.sql.strpot_col.index("pot_vatrat")]
# Calculate Values
rat = float(ASD(100) + ASD(self.vatrte))
inc = round((self.price * rat / 100.0), 4)
exc = round((self.price * 1), 2)
dis = float(ASD(100) - ASD(self.disrat))
self.excamt = round((self.qty * exc * dis / 100.0), 2)
self.incamt = round((self.qty * inc * dis / 100.0), 2)
self.vatamt = float(ASD(self.incamt) - ASD(self.excamt))
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
if self.acttyp == "N":
self.sql.updRec("strpom",
cols=["pom_delno"],
data=["cancel"],
where=[("pom_cono", "=", self.opts["conum"]),
("pom_ordno", "=", self.ordno),
("pom_acno", "=", self.acno)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
class bkc210(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, ["bkmrtm", "bkmrtr", "bkmrtt"],
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def drawDialog(self):
brm = {
"stype": "R",
"tables": ("bkmrtm",),
"cols": (
("brm_code", "", 0, "Code"),
("brm_desc", "", 0, "Description"),
("brm_base", "", 0, "B")),
"where": [("brm_cono", "=", self.opts["conum"])],
"whera": [("T", "brm_type", 0, 0)],
"order": "brm_code"}
brr = {
"stype": "R",
"tables": ("bkmrtr",),
"cols": (
("brr_date", "", 0, "Start-Date"),
("brr_rate", "", 0, "Rte-Amount")),
"where": [("brr_cono", "=", self.opts["conum"])],
"whera": [("T", "brr_type", 0, 0), ("T", "brr_code", 1, 0)],
"order": "brr_date"}
r1s = (
("Accomodation","A"),
("Other","O"))
r2s = (
("/Unit/Person/Day","A"),
("/Unit/Person","B"),
("/Unit/Day","C"),
("/Unit","D"))
self.fld = (
(("T",0,0,0),("IRB",r1s),0,"Unit Type","",
"A","Y",self.doType,None,None,None),
(("T",0,1,0),"IUI",3,"Code","",
"","N",self.doCode,brm,None,None),
(("T",0,2,0),"ITX",30,"Description","",
"","N",None,None,self.doDelete,("notblank",)),
(("T",0,3,0),("IRB",r2s),0,"Rate Base","",
"A","N",self.doBase,None,None,None),
(("T",0,4,0),"Id1",10.2,"Starting Date","",
0,"N",self.doExpd,brr,None,("efld",)),
(("T",0,5,0),"IUD",10.2,"Rate Amount","",
0,"N",self.doRate,None,self.doDelete,("efld",)))
but = (("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 doType(self, frt, pag, r, c, p, i, w):
self.rtype = w
def doCode(self, frt, pag, r, c, p, i, w):
if not w:
acc = self.sql.getRec("bkmrtm", cols=["max(brm_code)"],
where=[("brm_cono", "=", self.opts["conum"]), ("brm_type",
"=", self.rtype)], limit=1)
if not acc[0]:
w = 1
else:
w = acc[0] + 1
self.df.loadEntry(frt, pag, p, data=w)
self.rcode = w
self.rtm = self.sql.getRec("bkmrtm", where=[("brm_cono", "=",
self.opts["conum"]), ("brm_type", "=", self.rtype), ("brm_code",
"=", self.rcode)], limit=1)
if not self.rtm:
self.newr = True
else:
self.newr = False
for num, dat in enumerate(self.rtm[3:-1]):
self.df.loadEntry(frt, pag, p+num+1, data=dat)
def doBase(self, frt, pag, r, c, p, i, w):
self.rbase = w
def doExpd(self, frt, pag, r, c, p, i, w):
self.newx = True
if not self.newr:
self.rtr = self.sql.getRec("bkmrtr", where=[("brr_cono",
"=", self.opts["conum"]), ("brr_type", "=", self.rtype),
("brr_code", "=", self.rcode), ("brr_date", "=", w)], limit=1)
if self.rtr:
self.newx = False
rate = self.rtr[self.sql.bkmrtr_col.index("brr_rate")]
self.df.loadEntry(frt, pag, p+1, data=rate)
self.date = w
def doRate(self, frt, pag, r, c, p, i, w):
self.rate = w
def doDelete(self):
if self.df.col == 6:
self.sql.delRec("bkmrtr", where=[("brr_cono", "=",
self.opts["conum"]), ("brr_type", "=", self.rtype),
("brr_code", "=", self.rcode), ("brr_date", "=", self.date)])
return
chk = self.sql.getRec("bkmrtt", where=[("brt_cono", "=",
self.opts["conum"]), ("brt_utype", "=", self.rtype), ("brt_rcode",
"=", self.rcode)])
if not chk:
# Rate has been used, do not delete master record only rates
self.sql.delRec("bkmrtm", where=[("brm_cono", "=",
self.opts["conum"]), ("brm_type", "=", self.rtype),
("brm_code", "=", self.rcode)])
self.sql.delRec("bkmrtr", where=[("brr_cono", "=", self.opts["conum"]),
("brr_type", "=", self.rtype), ("brr_code", "=", self.rcode)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
data.extend(self.df.t_work[0][0][:4])
if self.newr:
self.sql.insRec("bkmrtm", data=data)
elif data != self.rtm[:len(data)]:
col = self.sql.bkmrtm_col
data.append(self.rtm[col.index("brm_xflag")])
self.sql.updRec("bkmrtm", data=data, where=[("brm_cono", "=",
self.opts["conum"]), ("brm_type", "=", self.rtype),
("brm_code", "=", self.rcode)])
data = [self.opts["conum"]]
data.extend(self.df.t_work[0][0][:2])
data.extend(self.df.t_work[0][0][4:6])
if self.newx:
self.sql.insRec("bkmrtr", data=data)
elif data != self.rtr[:len(data)]:
col = self.sql.bkmrtr_col
data.append(self.rtr[col.index("brr_xflag")])
self.sql.updRec("bkmrtr", data=data, where=[("brr_cono",
"=", self.opts["conum"]), ("brr_type", "=", self.rtype),
("brr_code", "=", self.rcode), ("brr_date", "=", self.date)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class gl1010(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"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
self.gldep = ctlsys["sys_gl_dep"]
self.gldig = ctlsys["sys_gl_dig"]
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 = [
"ctlctl", "ctldep", "ctlvmf", "genmst", "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("genmst",
cols=["count(*)"],
where=[("glm_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": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_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"])]
}
r1s = (("Profit & Loss", "P"), ("Balance Sheet", "B"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = [(("T", 0, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "", "Y",
self.doAccNum, glm, None, ("notzero", )),
(("T", 0, 1, 0), ("IRB", r1s), 0, "Account Type", "", "P", "N",
self.doTypCod, None, self.doDelete, None),
(("T", 0, 2,
0), "INA", 30, "Description", "Account Description", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), ("IRB", r2s), 0, "Allow Postings", "", "Y",
"N", None, None, None, None),
[("T", 0, 4, 0), "IUA", 1, "Tax Default", "", "", "N",
self.doVatCod, vat, None, ("notblank", )]]
but = [
("Import",None,self.doImport,0,("T",0,1),("T",0,2),
"Import a Chart of Accounts from a CSV or XLS file "\
"having the following fields: Account Number, "\
"Account Type (P/B), Description, Direct Postings (Y/N), "\
"VAT Code"),
["Populate",None,self.doPopulate,0,("T",0,1),("T",0,2),
"Generate a Chart of Accounts with Accompanying Control "\
"Records and Financial Statement Report. This Only Applies "\
"to Unpopulated (NEW) Ledgers."],
("Accept",None,self.doAccept,0,(("T",0,2),("T",0,5)),
(("T",0,0),("T",0,1))),
("Cancel",None,self.doCancel,0,(("T",0,2),("T",0,5)),
(("T",0,0),("T",0,1))),
("Quit",None,self.doQuit,1,None,None,"",1,4)]
tnd = ((self.doEnd, "y"), )
txt = (self.doQuit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt)
if not self.newgen:
self.df.butt[1][4] = None
self.df.butt[1][5] = None
self.df.setWidget(self.df.B1, state="disabled")
def doAccNum(self, frt, pag, r, c, p, i, w):
self.acno = w
self.old = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", self.acno)],
limit=1)
if not self.old:
self.new = True
if self.gldep == "Y":
err = self.doCheckDep(self.acno)
if err:
return err
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("gentrn",
cols=["count(*)"],
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.acno)],
limit=1)
if t[0]:
return "Transactions Exist, Not Deleted"
self.sql.delRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", self.acno)])
self.sql.delRec("genbal",
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.acno)])
self.sql.delRec("genbud",
where=[("glb_cono", "=", self.opts["conum"]),
("glb_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"genmst", "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], self.df.t_work[0][0][3],
self.df.t_work[0][0][4]
]
if self.new:
self.sql.insRec("genmst", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genmst_col
data.append(self.old[col.index("glm_xflag")])
self.sql.updRec("genmst",
data=data,
where=[("glm_cono", "=", self.opts["conum"]),
("glm_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=[
"genmst", "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()
self.df.setWidget(self.df.B3, state="disabled")
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 doImport(self):
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
fi = FileImport(self.opts["mf"], imptab="genmst", impskp=["glm_cono"])
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Chart of Accounts",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
sp.displayProgress(num)
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", line[0])],
limit=1)
if chk:
err = "%s %s Already Exists" % (fi.impcol[0][0], line[0])
break
if self.gldep == "Y":
err = self.doCheckDep(line[0])
if err:
break
if line[1] not in ("B", "P"):
err = "Invalid %s %s, Only B or P" % (fi.impcol[1][0], line[1])
break
if not line[2]:
err = "Blank Description"
break
if line[3] not in ("Y", "N"):
err = "Invalid %s %s" % (fi.impcol[3][0], line[3])
break
chk = self.sql.getRec("ctlvmf",
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", line[4])],
limit=1)
if not chk:
err = "%s %s Does Not Exist" % (fi.impcol[4][0], line[4])
break
line.insert(0, self.opts["conum"])
self.sql.insRec("genmst", data=line)
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doCheckDep(self, acno):
dep = int(acno / (10**(7 - self.gldig)))
acc = int(acno % (10**(7 - self.gldig)))
if dep:
chk = self.sql.getRec("ctldep",
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", dep)],
limit=1)
if not chk:
return "Invalid Department Number (%s)" % dep
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc)],
limit=1)
if chk:
return "This Account Number (%s) is in Use" % acc
def doPopulate(self):
if not self.newgen:
showError(self.opts["mf"].body, "Populate Error",
"You Cannot Populate with Existing Accounts")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
if self.gldep == "Y":
showError(self.opts["mf"].body, "Populate Error",
"You Cannot Populate with Departments Enabled")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.igcrs = "N"
self.igdrs = "N"
self.igstr = "N"
self.df.setWidget(self.df.B3, state="disabled")
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Integrate Subsiduary Ledgers", )
r1s = (("Yes", "Y"), ("No", "N"))
fld = []
col = 0
if "CR" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Creditor's Ledger",
"Creditor's Ledger", "N", "N", self.doIgCrs, None,
None, None, None))
col += 1
if "DR" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Debtor's Ledger",
"Debtor's Ledger", "N", "N", self.doIgDrs, None, None,
None, None))
col += 1
if "ST" in self.mods:
fld.append((("T", 0, col, 0), ("IRB", r1s), 0, "Stores's Ledger",
"Stores's Ledger", "N", "N", self.doIgStr, None, None,
None, None))
if fld:
self.ig = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doIgEnd, "y"), ),
txit=(self.doIgExit, ))
self.ig.mstFrame.wait_window()
if self.igexit:
self.doQuit()
return
sp = SplashScreen(self.opts["mf"].body,
"Populating Records\n\nPlease Wait ...")
# genmst
genmst = datdic["genmst"]
for dat in genmst:
dat.insert(0, self.opts["conum"])
dat.append("Y")
if dat[2] == "B":
dat.append("N")
else:
dat.append(self.taxdf)
self.sql.insRec("genmst", data=dat)
# genrpt
genrpt = datdic["genrpt"]
for dat in genrpt:
dat.insert(0, self.opts["conum"])
self.sql.insRec("genrpt", data=dat)
# ctlctl
crsctl = 0
drsctl = 0
stksoh = 0
ctlctl = datdic["ctlctl"]
for dat in ctlctl:
if dat[0] in ("crs_ctl", "dis_rec"):
if self.igcrs != "Y":
continue
if dat[0] == "crs_ctl":
crsctl = int(dat[2])
elif dat[0] in ("drs_ctl", "dis_all"):
if self.igdrs != "Y":
continue
if dat[0] == "drs_ctl":
drsctl = int(dat[2])
elif dat[0] in ("stk_soh", "stk_susp"):
if self.igstr != "Y":
continue
if dat[0] == "stk_soh":
stksoh = int(dat[2])
elif dat[0] in ("wag_ctl", "wag_slc", "wag_sli"):
continue
dat.insert(0, self.opts["conum"])
self.sql.insRec("ctlctl", data=dat)
if "CR" in self.mods:
chk = self.sql.getRec("crsctl",
where=[("ctc_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("crsctl",
data=[
self.opts["conum"], self.igcrs, "E", "", 0,
0, "remittance_advice", ""
])
else:
self.sql.updRec("crsctl",
cols=["ctc_glint"],
data=[self.igcrs],
where=[("ctc_cono", "=", self.opts["conum"])])
if self.igcrs == "Y" and crsctl:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", crsctl)])
if "DR" in self.mods:
chk = self.sql.getRec("drsctl",
where=[("ctd_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("drsctl",
data=[
self.opts["conum"], self.igdrs, "E", "N",
"statement_normal", "Y", ""
])
else:
self.sql.updRec("drsctl",
cols=["ctd_glint"],
data=[self.igdrs],
where=[("ctd_cono", "=", self.opts["conum"])])
if self.igdrs == "Y" and drsctl:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", drsctl)])
if "ST" in self.mods:
chk = self.sql.getRec("strctl",
where=[("cts_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("strctl",
data=[
self.opts["conum"], self.igstr, "N", 1,
"N", "purchase_order", ""
])
else:
self.sql.updRec("strctl",
cols=["cts_glint"],
data=[self.igstr],
where=[("cts_cono", "=", self.opts["conum"])])
chk = self.sql.getRec("strloc",
where=[("srl_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec("strloc",
data=[
self.opts["conum"], "1",
"Location Number One", "", "", "", ""
])
if self.igstr == "Y" and stksoh:
self.sql.updRec("genmst",
cols=["glm_ind"],
data=["N"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", stksoh)])
if "SI" in self.mods:
chk = self.sql.getRec("slsctl",
where=[("ctv_cono", "=", self.opts["conum"])
])
if not chk:
self.sql.insRec(
"slsctl",
data=[self.opts["conum"], "Y", "Y", "sales_document", ""])
sp.closeSplash()
self.df.butt[1][4] = None
self.df.butt[1][5] = None
self.opts["mf"].dbm.commitDbase()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doIgCrs(self, frt, pag, r, c, p, i, w):
self.igcrs = w
def doIgDrs(self, frt, pag, r, c, p, i, w):
self.igdrs = w
def doIgStr(self, frt, pag, r, c, p, i, w):
self.igstr = w
def doIgEnd(self):
self.igexit = False
self.ig.closeProcess()
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 gl1060(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):
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"assgrp", "crsmst", "ctlctl", "ctlmst", "ctlvmf", "drsmst",
"drschn", "genint", "genmst", "genrcc", "rtlprm"
],
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"])
return True
def mainProcess(self):
ctl = {
"stype":
"R",
"tables": ("ctlctl", "genmst"),
"cols":
(("ctl_code", "", 0, "Ctl-Code"), ("ctl_conacc", "", 0, "G/L-Num"),
("glm_desc", "", 30, "Description")),
"where": [("ctl_cono", "=", self.opts["conum"]),
("ctl_code", "like", "bank_%"), ("glm_cono=ctl_cono", ),
("glm_acno=ctl_conacc", )],
"index":
1
}
rcc = {
"stype":
"R",
"tables": ("genrcc", ),
"cols":
(("grc_memo", "", 0, "Code"), ("grc_desc1", "", 0, "Details"),
("grc_rtn", "", 0, "R"), ("grc_acoy", "", 0, "Coy"),
("grc_aacc", "", 0, "Acc-Num"), ("grc_acrs", "", 0, "Crs-Acc"),
("grc_achn", "", 0, "Chn"), ("grc_adrs", "", 0,
"Drs-Acc"), ("grc_vat", "", 0, "V")),
"where": [("grc_cono", "=", self.opts["conum"])],
"whera": [["T", "grc_acno", 0]]
}
rct = {
"stype":
"R",
"tables": ("genrct", ),
"cols": (("grt_memo", "", 75, "Details"), ("grt_amount", "SD",
13.2, "Value")),
"where": [("grt_cono", "=", self.opts["conum"]),
("grt_flag", "=", "N")],
"whera": [["T", "grt_acno", 0, 0]],
"group":
"grt_memo",
"order":
"grt_memo",
"comnd":
self.doSameField
}
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": [["T", "glm_cono", 7]]
}
chn = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"whera": [["T", "chm_cono", 7]]
}
self.crm = {
"stype":
"R",
"tables": ("crsmst", ),
"cols":
(("crm_acno", "", 0, "Acc-Num"), ("crm_name", "", 0, "Name", "Y"),
("crm_add1", "", 0, "Address Line 1")),
"where": [("crm_stat", "<>", "X")],
"whera": [["T", "crm_cono", 7]]
}
self.drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1")),
"where": [("drm_stat", "<>", "X")],
"whera": [["T", "drm_cono", 7], ["T", "drm_chain", 11]]
}
vat = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "Acc-Num"), ("vtm_desc", "", 0,
"Description", "Y")),
"whera": [["T", "vtm_cono", 7]]
}
r1s = (("Payment", "P"), ("Receipt", "R"))
r2s = (("Oldest", "O"), ("Current", "C"))
fld = [[("T", 0, 0, 0), "IUI", 7, "Bank Account", "", "",
"Y", self.doAccNum, ctl, None, None],
(("T", 0, 0, 0), "ONA", 30, ""),
[("T", 0, 1, 0), "IUI", 5, "Memo Code",
"Memo Code (Blank for Next)", "", "Y", self.doMemo, rcc, None,
None],
[("T", 0, 2, 0), "INA", 50, "Memo Desc Contains", "", "", "N",
self.doDesc1, rct, self.doDelete, ("notblank", )],
(("T", 0, 3, 0), "INA", 50, " and Contains",
"Desc Also Contains", "", "N", self.doDesc2, rct, None, None),
(("T", 0, 4, 0), "INA", 50, " and Contains",
"Desc Also Contains", "", "N", self.doDesc3, rct, None, None),
(("T", 0, 5, 0), ("IRB", r1s), 0, "Transaction Type", "", "P",
"N", self.doTypCod, None, None, None),
(("T", 0, 6,
0), "IUI", 7, "Allocation Company", "", self.opts["conum"],
"N", self.doAllCoy, coy, None, ("notzero", )),
(("T", 0, 6, 0), "ONA", 30, ""),
(("T", 0, 7, 0), "IUI", 7, "Allocation Account", "", "", "N",
self.doAllAcc, glm, None, ("notzero", )),
(("T", 0, 7, 0), "ONA", 30, ""),
[["T", 0, 8, 0], "IUI", 3, "Chn", "Chain Store Code", 0, "N",
self.doDrsChn, chn, None, ("efld", )],
(("T", 0, 8, 0), "ONA", 30, ""),
[("T", 0, 9, 0), "INA", 7, "Acc-Num", "Account Number", "", "N",
self.doCrsDrsAcc, self.crm, None, ("notblank", )],
(("T", 0, 9, 0), "ONA", 30, ""),
(("T", 0, 10, 0), ("IRB", r2s), 0, "Ageing Code", "", "O", "N",
self.doCrsDrsAge, None, None, None, None, """
The Ageing Codes are as follows:
Oldest - Automatically age against the oldest outstanding transactions.
Current - Do not age the transaction.
"""),
(("T", 0, 11, 0), "INA", 1, "Vat Code", "", "", "N",
self.doVatCod, vat, None, None)]
but = [("Cancel", None, self.doCancel, 0, ("T", 0, 4), ("T", 0, 1)),
("Quit", None, self.doExit, 1, None, None)]
if "args" in self.opts:
for f in (0, 2, 3):
if f == 3:
fld[f][4] += "(noesc)"
else:
fld[f][7] = None
fld[f][8] = None
fld[f][9] = None
del but[0]
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
if "args" in self.opts:
foc = False
else:
foc = True
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
focus=foc)
if "args" in self.opts:
self.df.loadEntry("T", 0, 0, data=self.opts["args"][0])
self.doAccNum("T", 0, 0, 1, 0, 0, self.opts["args"][0])
self.df.loadEntry("T", 0, 2, data=0)
self.doMemo("T", 0, 0, 3, 2, 2, 0)
self.df.loadEntry("T", 0, 3, data=self.opts["args"][1][2])
self.df.focusField("T", 0, 4)
def doAccNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec(tables=["ctlctl", "genmst"],
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w),
("ctl_cono=glm_cono", ),
("ctl_conacc=glm_acno", ),
("ctl_code", "like", "bank_%")],
limit=1)
if not acc:
return "Invalid Bank Account"
self.acno = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doSameField(self, frt, pag, r, c, p, i, w):
self.df.loadEntry("T", 0, self.df.pos, data=w[0])
self.df.focusField("T", 0, self.df.col)
def doMemo(self, frt, pag, r, c, p, i, w):
if not w:
w = self.sql.getRec("genrcc",
cols=["max(grc_memo)"],
where=[("grc_cono", "=", self.opts["conum"]),
("grc_acno", "=", self.acno)],
limit=1)
if not w or not w[0]:
self.memo = 1
else:
self.memo = w[0] + 1
self.df.loadEntry(frt, pag, p, data=self.memo)
else:
self.memo = w
self.old = self.sql.getRec("genrcc",
where=[("grc_cono", "=",
self.opts["conum"]),
("grc_acno", "=", self.acno),
("grc_memo", "=", self.memo)],
limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
col = self.sql.genrcc_col
self.desc1 = self.old[col.index("grc_desc1")]
self.desc2 = self.old[col.index("grc_desc2")]
self.desc3 = self.old[col.index("grc_desc3")]
self.opts["rtn"] = self.old[col.index("grc_rtn")]
self.acoy = self.old[col.index("grc_acoy")]
self.aacc = self.old[col.index("grc_aacc")]
self.acrs = self.old[col.index("grc_acrs")]
self.achn = self.old[col.index("grc_achn")]
self.aage = self.old[col.index("grc_aage")]
self.adrs = self.old[col.index("grc_adrs")]
self.vat = self.old[col.index("grc_vat")]
self.df.loadEntry(frt, pag, 3, data=self.desc1)
self.df.loadEntry(frt, pag, 4, data=self.desc2)
self.df.loadEntry(frt, pag, 5, data=self.desc3)
self.df.loadEntry(frt, pag, 6, data=self.opts["rtn"])
self.df.loadEntry(frt, pag, 7, data=self.acoy)
self.df.loadEntry(frt, pag, 8, data=self.getCoyName())
self.df.loadEntry(frt, pag, 9, data=self.aacc)
self.df.loadEntry(frt, pag, 10, data=self.getAccDesc())
# Creditor and Debtor Details
if self.acrs:
self.crsdrs = "crs"
self.df.loadEntry(frt, pag, 11, data=0)
self.df.loadEntry(frt, pag, 12, data="")
self.df.loadEntry(frt, pag, 13, data=self.acrs)
self.df.loadEntry(frt, pag, 14, data=self.getCrsName())
self.df.loadEntry(frt, pag, 15, data=self.aage)
elif self.adrs:
self.crsdrs = "drs"
self.df.loadEntry(frt, pag, 11, data=self.achn)
if self.achn:
self.df.loadEntry(frt, pag, 12, data=self.getChainName())
else:
self.df.loadEntry(frt, pag, 12, data="")
self.df.loadEntry(frt, pag, 13, data=self.adrs)
self.df.loadEntry(frt, pag, 14, data=self.getDrsName())
self.df.loadEntry(frt, pag, 15, data=self.aage)
else:
self.crsdrs = None
self.df.loadEntry(frt, pag, 11, data=0)
self.df.loadEntry(frt, pag, 12, data="")
self.df.loadEntry(frt, pag, 13, data="")
self.df.loadEntry(frt, pag, 14, data="")
self.df.loadEntry(frt, pag, 15, data="")
# VAT Code
self.df.loadEntry(frt, pag, 16, data=self.vat)
def doDesc1(self, frt, pag, r, c, p, i, w):
self.desc1 = w
def doDesc2(self, frt, pag, r, c, p, i, w):
self.desc2 = w
if not self.desc2:
self.desc3 = ""
self.df.loadEntry(frt, pag, p + 1, data=self.desc3)
if "args" in self.opts:
if self.opts["args"][1][-1] < 0:
self.opts["rtn"] = "P"
else:
self.opts["rtn"] = "R"
self.df.loadEntry(frt, pag, p + 2, data=self.opts["rtn"])
return "sk2"
return "sk1"
def doDesc3(self, frt, pag, r, c, p, i, w):
self.desc3 = w
if "args" in self.opts:
if self.opts["args"][1][-1] < 0:
self.opts["rtn"] = "P"
else:
self.opts["rtn"] = "R"
self.df.loadEntry(frt, pag, p + 1, data=self.opts["rtn"])
return "sk1"
def doTypCod(self, frt, pag, r, c, p, i, w):
self.opts["rtn"] = w
if not self.incoac:
self.acoy = self.opts["conum"]
if self.doChkLoadCtls():
return "rf"
else:
self.df.loadEntry(frt, pag, p + 1, data=self.acoy)
self.df.loadEntry(frt, pag, p + 2, data=self.getCoyName())
return "sk2"
def doAllCoy(self, frt, pag, r, c, p, i, w):
self.acoy = w
name = self.getCoyName()
if not name:
return "Invalid Company Number"
self.df.loadEntry(frt, pag, p + 1, data=name)
return self.doChkLoadCtls()
def doChkLoadCtls(self):
# Check for Intercompany Records
if self.acoy != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", self.opts["conum"]),
("cti_inco", "=", self.acoy)],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 1"
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", self.acoy),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
# Get Company Details
ctlmst = self.gc.getCtl("ctlmst", self.acoy)
if not ctlmst:
return "rf"
# Set Company VAT Default
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
# Check for Integrated Systems
mod = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
mod.append(ctlmst["ctm_modules"][x:x + 2])
# Check for Control Records e.g. VAT and Discounts
self.ctlctl = self.gc.getCtl("ctlctl", self.acoy)
if not self.ctlctl:
return "rf"
ctls = ["vat_ctl"]
# Load Crs Integration
if mod.count("CR"):
ctl = self.gc.getCtl("crsctl", self.acoy)
if not ctl:
return "rf"
self.crs_gl = ctl["ctc_glint"]
if self.crs_gl == "Y":
ctls.extend(["crs_ctl", "dis_rec"])
else:
self.crs_gl = "N"
# Load Drs Integration and Chain Store Flag
if mod.count("DR"):
ctl = self.gc.getCtl("drsctl", self.acoy)
if not ctl:
return "rf"
self.drs_gl = ctl["ctd_glint"]
self.drs_ch = ctl["ctd_chain"]
if self.drs_gl == "Y":
ctls.extend(["drs_ctl", "dis_all"])
else:
self.drs_gl = "N"
if self.gc.chkRec(self.acoy, self.ctlctl, ctls):
return "rf"
def doAllAcc(self, frt, pag, r, c, p, i, w):
if self.acoy == self.opts["conum"] and w == self.acno:
return "This is the Bank Account Number"
ctl = True
self.crsdrs = False
if self.crs_gl == "Y" and w == self.ctlctl["crs_ctl"]:
self.crsdrs = "crs"
self.df.topf[0][p + 4][8] = self.crm
elif self.drs_gl == "Y" and w == self.ctlctl["drs_ctl"]:
self.crsdrs = "drs"
self.df.topf[0][p + 4][8] = self.drm
if self.crsdrs:
ctl = False
chk = chkGenAcc(self.opts["mf"], self.acoy, w, ctl=ctl)
if type(chk) is str:
return chk
self.aacc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if self.crsdrs:
if self.crsdrs == "crs" or self.drs_ch == "N":
self.achn = 0
self.df.topf[0][p + 2][1] = "OUI"
self.df.loadEntry(frt, pag, p + 2, data=self.achn)
self.df.loadEntry(frt, pag, p + 3, data="")
return "sk3"
elif self.crsdrs == "drs":
self.df.topf[0][p + 2][1] = "IUI"
return "sk1"
else:
self.acrs = ""
self.achn = 0
self.adrs = ""
self.aage = ""
self.df.loadEntry(frt, pag, p + 2, data=0)
self.df.loadEntry(frt, pag, p + 3, data="")
self.df.loadEntry(frt, pag, p + 4, data="")
self.df.loadEntry(frt, pag, p + 5, data="")
self.df.loadEntry(frt, pag, p + 6, data="")
if not self.df.t_work[pag][0][p + 7]:
if chk[2]:
self.df.loadEntry(frt, pag, p + 7, data=chk[2])
else:
self.df.loadEntry(frt, pag, p + 7, data=self.taxdf)
return "sk6"
def doDrsChn(self, frt, pag, r, c, p, i, w):
self.achn = w
name = self.getChainName()
if not name:
return "Invalid Account Number"
self.df.loadEntry(frt, pag, p + 1, data=name)
def doCrsDrsAcc(self, frt, pag, r, c, p, i, w):
if self.crsdrs == "crs":
self.acrs = w
name = self.getCrsName()
else:
self.adrs = w
name = self.getDrsName()
if not name:
return "Invalid Account Number %s" % self.crsdrs.capitalize()
if name[1] == "X":
return "Invalid Account %s, Redundant" % self.crsdrs.capitalize()
self.df.loadEntry(frt, pag, p + 1, data=name[0])
def doCrsDrsAge(self, frt, pag, r, c, p, i, w):
self.aage = w
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):
vat = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.acoy),
("vtm_code", "=", w)],
limit=1)
if not vat:
return "Invalid VAT Code"
self.vat = w
def doDelete(self):
self.sql.delRec("genrcc",
where=[("grc_cono", "=", self.opts["conum"]),
("grc_acno", "=", self.acno),
("grc_memo", "=", self.memo)])
def doEnd(self):
data = [
self.opts["conum"], self.acno, self.memo, self.desc1, self.desc2,
self.desc3, self.opts["rtn"], self.acoy, self.aacc
]
if self.crsdrs:
if self.crsdrs == "crs":
data.extend([self.acrs, 0, "", self.aage, self.vat])
else:
data.extend(["", self.achn, self.adrs, self.aage, self.vat])
else:
data.extend(["", 0, "", "", self.vat])
if self.new == "y":
self.sql.insRec("genrcc", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genrcc_col
data.append(self.old[col.index("grc_xflag")])
self.sql.updRec("genrcc",
data=data,
where=[("grc_cono", "=", self.opts["conum"]),
("grc_acno", "=", self.acno),
("grc_memo", "=", self.memo)])
if "args" in self.opts:
self.doExit()
else:
for x in range(2, self.df.topq[0]):
self.df.loadEntry("T", 0, x, data="")
self.df.focusField("T", 0, 3)
def getCoyName(self):
coy = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", self.acoy)],
limit=1)
if coy:
return coy[0]
def getAccDesc(self):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.acoy),
("glm_acno", "=", self.aacc)],
limit=1)
if acc:
return acc[0]
def getCrsName(self):
acc = self.sql.getRec("crsmst",
cols=["crm_name", "ctm_stat"],
where=[("crm_cono", "=", self.acoy),
("crm_acno", "=", self.acrs)],
limit=1)
if acc:
return acc
def getChainName(self):
acc = self.sql.getRec("drschn",
cols=["chm_name"],
where=[("chm_cono", "=", self.acoy),
("chm_chain", "=", self.achn)],
limit=1)
if acc:
return acc[0]
def getDrsName(self):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.acoy),
("drm_chain", "=", self.achn),
("drm_acno", "=", self.adrs)],
limit=1)
if acc:
return acc
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit(self):
self.opts["mf"].dbm.commitDbase()
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class ar2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
self.gc = GetCtl(self.opts["mf"])
assctl = self.gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.rordp = assctl["cta_rordp"]
tabs = ["assgrp", "assmst", "assdep", "asstrn"]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.dend = projectDate(self.opts["period"][1][0], -1)
self.todat = 0
self.imports = False
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def drawDialog(self):
grp = {
"stype":
"R",
"tables": ("assgrp", ),
"cols": (("asg_group", "", 0, "Grp"), ("asg_desc", "", 0,
"Description", "Y")),
"where": [("asg_cono", "=", self.opts["conum"])]
}
cod = {
"stype":
"R",
"tables": ("assmst", ),
"cols": (("asm_code", "", 0, "Cod-Num"), ("asm_desc", "", 0,
"Description", "Y")),
"where": [("asm_cono", "=", self.opts["conum"])],
"whera": [["C", "asm_group", 0, 0]]
}
dep = {
"stype":
"R",
"tables": ("assdep", ),
"cols": (("asd_code", "", 0, "Cod"), ("asd_desc", "", 0,
"Description", "Y")),
"where": [("asd_cono", "=", self.opts["conum"])]
}
self.fld = [(("T", 0, 0, 0), "ID1", 10, "Take-on Date", "", self.dend,
"N", self.doTakeOnDate, None, None, ("efld", )),
(("C", 0, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N",
self.doAssGrp, grp, None, None),
(("C", 0, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "",
"N", self.doAssCod, cod, None, ("notblank", )),
(("C", 0, 0, 2), "INA", 30, "Description", "Description",
"", "N", self.doDesc, None, None, ("notblank", )),
(("C", 0, 0, 3), "INa", 3, "Dep", "Depreciation Code", "",
"N", self.doDepCode, dep, None, ("notblank", )),
(("C", 0, 0, 4), "ONA", 10, "Dp-Details"),
(("C", 0, 0, 5), "ID1", 10, "Purch-Date", "Purchase Date",
0, "N", self.doPurDat, None, None, ("efld", )),
(("C", 0, 0, 6), "IUD", 10.2, "Cost", "Original Cost", 0,
"N", self.doCost, None, None, ("notzero", )),
(("C", 0, 0,
7), "IUD", 10.2, "Coy-Dep", "Company Depreciation", 0,
"N", self.doCDep, None, None, ("efld", ))]
if self.rordp == "Y":
self.fld.append((("C", 0, 0, 8), "IUD", 10.2, "Rec-Dep",
"Receiver Depreciation", 0, "N", self.doRDep,
None, None, ("efld", )))
tnd = [[self.endPage, "y"]]
txt = (self.exitPage, )
cnd = [[self.endPage, "y"]]
cxt = (self.exitPage, )
but = ((("Import File",None,self.doImport,0,("T",0,0),("C",0,2),
"Import a CSV or XLS File having the following fields: "\
"Asset Group, Code, Description, Depreciation Code, "\
"Purchase Date, Original Cost, Company Depeciation and "\
"Receiver Depreciation if applicable"),))
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
rows=(15, ),
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doTakeOnDate(self, frt, pag, r, c, p, i, w):
if w < self.dend:
return "Invalid Date, Too Far in the Past"
self.todat = w
def doAssGrp(self, frt, pag, r, c, p, i, w):
self.group = w
col = ["asg_depcod"]
whr = [("asg_cono", "=", self.opts["conum"]),
("asg_group", "=", self.group)]
acc = self.sql.getRec("assgrp", cols=col, where=whr, limit=1)
if not acc:
return "Invalid Asset Group"
self.depcod = acc[0]
def doImport(self):
self.df.closeProcess()
self.imports = True
impcol = []
for num, fld in enumerate(self.fld[1:]):
if fld[0][3] == 4:
continue
if num > 4:
num -= 1
impcol.append([fld[4], num, fld[1][1:], fld[2]])
fi = FileImport(self.opts["mf"], impcol=impcol)
err = False
for row, data in enumerate(fi.impdat):
funcs = [
"doAssGrp", "doAssCod", "doDesc", "doDepCode", "doPurDat",
"doCost", "doCDep"
]
if self.rordp == "Y":
funcs.append("doRDep")
for col, func in enumerate(funcs):
err = getattr(self, "%s" % func)("", 0, 0, 0, 0, 0, data[col])
if err:
showError(
self.opts["mf"].body, "Import Error",
"""Row %s Column %s - %s - %s
Please Correct the Import File and Try Again.""" % (row, col, data[col], err))
break
if err:
break
self.endPage()
if err:
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
def doAssCod(self, frt, pag, r, c, p, i, w):
self.code = w
acc = self.sql.getRec("assmst",
cols=["asm_desc"],
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group),
("asm_code", "=", w)],
limit=1)
if acc:
ok = askQuestion(screen=self.opts["mf"].body,
head="Asset Exists",
mess="""Asset already exists, Replace?
Please Note that if you decide to Replace the Asset, the Original Asset will be Deleted along with any History which may exist.""",
default="no")
if ok == "no":
return "Invalid Asset"
self.sql.delRec("assmst",
where=[("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group),
("asm_code", "=", self.code)])
self.sql.delRec("asstrn",
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)])
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=self.depcod)
def doDepCode(self, frt, pag, r, c, p, i, w):
col = ["asd_rate1r", "asd_desc"]
chk = self.sql.getRec("assdep",
cols=col,
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.rate1r = chk[0]
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=chk[1])
def doPurDat(self, frt, pag, r, c, p, i, w):
if w > self.todat:
return "Invalid Date, After Financial Period"
self.purdat = w
def doCost(self, frt, pag, r, c, p, i, w):
self.ccst = w
if self.rordp == "Y":
self.rcst = w
else:
self.rcst = 0
def doCDep(self, frt, pag, r, c, p, i, w):
self.cdep = float(ASD(0) - ASD(w))
if self.rordp == "N":
self.rdep = 0
return
if not self.rate1r:
self.rdep = 0
if not self.imports:
self.df.loadEntry(frt, pag, p + 1, data=self.rdep)
return "sk1"
def doRDep(self, frt, pag, r, c, p, i, w):
self.rdep = float(ASD(0) - ASD(w))
def endPage(self):
if self.df.frt == "T":
self.df.focusField("C", 0, 1)
return
data = [
self.opts["conum"], self.group, self.code, self.desc, self.depcod
]
self.sql.insRec("assmst", data=data)
data = [
self.opts["conum"], self.group, self.code, 3, "Take-On", "Take-On",
self.purdat, 1, self.ccst, self.rcst, 0,
int(self.purdat / 100), "Original Cost", "", "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.cdep or self.rdep:
data = [
self.opts["conum"], self.group, self.code, 3, "Take-On",
"Take-On", self.todat, 4, self.cdep, self.rdep, 0,
int(self.todat / 100), "Accumulated Depreciation", "", "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if not self.imports:
self.df.advanceLine(0)
def exitPage(self):
self.df.closeProcess()
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
class st1010(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):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlvmf", "ctlrep", "drschn", "drsmst", "genmst", "slsiv1",
"slsiv2", "strgrp", "strloc", "strmf1", "strmf2", "strgmu",
"strcmu", "strprc", "strrcp", "struoi", "strtrn", "strpot",
"strvar", "slsiv3", "chglog"
],
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.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
self.automu = strctl["cts_automu"]
self.drsctl = gc.getCtl("drsctl", self.opts["conum"], error=False)
if not self.drsctl:
self.chains = "N"
else:
self.chains = self.drsctl["ctd_chain"]
return True
def mainProcess(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_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"]),
("st1_type", "<>", "X")],
"whera": [],
"index":
1
}
loc = {
"stype":
"R",
"tables": ("strloc", ),
"cols":
(("srl_loc", "", 0, "L"), ("srl_desc", "", 0, "Description", "Y")),
"where": [("srl_cono", "=", self.opts["conum"])]
}
unm = {
"stype":
"R",
"tables": ("struoi", ),
"cols": (("unm_unit", "", 0, "Unit"), ("unm_desc", "", 0,
"Description", "Y")),
"where": [("unm_cono", "=", self.opts["conum"])]
}
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_stat", "<>", "X")]
drm["whera"] = [["T", "drm_chain", 10]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0), ("drm_stat", "<>", "X")]
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
tag = (("Basic-_A", None, ("T", 0, 0),
("T", 0, 1)), ("Basic-_B", None, ("T", 0, 0), ("T", 0, 1)),
("Recipes", self.doReadLoadRecipe, None, ("T", 0, 1)))
r1s = (("Normal", "N"), ("Recipe", "R"))
r2s = (("Average", "A"), ("Standard", "S"), ("None", "N"))
r3s = (("Manual", "M"), ("Automatic", "A"), ("Zero", "N"))
self.fld = [(("T", 0, 0, 0), "IUA", 3, "Group", "Product Group", "",
"Y", self.doGroup, gpm, None, ("notblank", )),
(("T", 0, 0, 0), "INA", 20, "Code", "Product Code", "",
"N", self.doCode, stm, None, ("notblank", )),
(("T", 0, 0, 0), "IUA", 1, "Loc", "Location", "1", "N",
self.doLoc, loc, None, ("notblank", )),
(("T", 0, 0, 0), "ONA", 30, ""),
(("T", 1, 0, 0), ("IRB", r1s), 0, "Type of Item", "", "N",
"N", self.doType, None, None, None),
(("T", 1, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 1, 2, 0), "INA", 10, "Unit of Issue", "", "", "N",
self.doUoi, unm, None, ("notblank", )),
(("T", 1, 2, 0), "ONA", 30, ""),
(("T", 1, 3, 0), ("IRB", r2s), 0, "Cost Price Indicator",
"", "A", "N", self.doValInd, None, None, None),
(("T", 1, 4, 0), "IUA", 1, "VAT Code", "", "", "N",
self.doVat, vtm, None, ("notblank", )),
(("T", 1, 4, 0), "ONA", 30, ""),
(("T", 1, 5, 0), "IUI", 3, "Exclusive Chainstore", "", "",
"N", self.doChnExcl, drc, None, ("efld", )),
(("T", 1, 5, 0), "ONA", 30, ""),
(("T", 1, 6, 0), "INA", 7, "Exclusive Account", "", "",
"N", self.doAccExcl, drm, None, ("efld", )),
(("T", 1, 6, 0), "ONA", 30, ""),
(("T", 1, 7, 0), "IUI", 7, "Sales Code", "", "", "N",
self.doSales, glm, None, ("efld", )),
(("T", 1, 7, 0), "ONA", 30, ""),
(("T", 1, 8, 0), "IUI", 7, "COS Code", "", "", "N",
self.doCos, glm, None, ("efld", )),
(("T", 1, 8, 0), "ONA", 30, ""),
(("T", 2, 0, 0), "IUA", 8, "Bin Number", "", "", "N", None,
None, self.doDelete, ("efld", )),
(("T", 2, 1, 0), ("IRB", r3s), 0, "Re-Order Indicator", "",
"A", "N", self.doReord, None, None, None),
(("T", 2, 2, 0), "IUI", 7, "Re-Order Level", "", "", "N",
None, None, None, ("efld", )),
(("T", 2, 3, 0), "IUI", 7, "Re-Order Quantity", "", "",
"N", None, None, None, ("efld", ))]
if self.automu in ("A", "L"):
self.fld.append(
(("T", 2, 4, 0), "IUD", 6.2, "Percentabge Markup Lv1", "", "",
"N", None, None, None, ("efld", )))
for x in range(1, self.plevs):
self.fld.append((("T", 2, 4, 0), "IUD", 6.2, "Lv%s" % (x + 1),
"", "", "N", None, None, None, ("efld", )))
self.fld.extend([(("C", 3, 0, 0), "INA", 3, "Grp", "Product Group",
"r", "N", self.doRecGrp, gpm, None, None),
(("C", 3, 0,
1), "INA", 20, "Product-Code", "Product Code", "",
"N", self.doRecCod, stm, None, None),
(("C", 3, 0, 2), "ONA", 30, "Description"),
(("C", 3, 0, 3), "IUD", 11.2, "Quantity", "", "", "N",
self.doRecQty, None, self.doDelRec, ("notzero", ))])
but = (("Edit", None, self.doEditor, 0, ("C", 3, 1), None),
("Accept", None, self.doAccept, 0, ("T", 0, 0), ("T", 0, 1)),
("Cancel", None, self.doCancel, 0, ("T", 0, 0),
("T", 0, 1)), ("Quit", None, self.doQuit, 1, None, None))
tnd = ((self.doEnd, "N"), (self.doEnd, "N"), (self.doEnd, "Y"), None)
txt = (self.doExit, self.doExit, self.doExit, self.doExit)
cnd = (None, None, None, (self.doEnd, "N"))
cxt = (None, None, None, self.doExit)
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.pag == 0 or not self.gtype:
return
if opts[0] == (1, 0) and not self.newcode:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doGroup(self, frt, pag, r, c, p, i, w):
self.grpacc = self.sql.getRec(
"strgrp",
cols=["gpm_vatcode", "gpm_sales", "gpm_costs"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not self.grpacc:
return "Invalid Group"
self.group = w
self.df.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]]
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.mups = [0, 0, 0, 0, 0]
self.old1 = self.sql.getRec("strmf1",
where=[("st1_cono", "=",
self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", w)],
limit=1)
if not self.old1:
self.newcode = True
self.gtype = None
elif self.old1[3] == "X":
return "Redundant Code"
else:
self.newcode = False
d = 3
for x in range(0, self.df.topq[1]):
if x in (3, 6, 8, 10, 12, 14):
continue
if x == 0:
self.gtype = self.old1[d]
self.df.loadEntry("T", 1, x, data=self.old1[d])
if x == 2:
get = self.getUoi(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 5:
get = self.getVat(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 7:
get = self.getChnExcl(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if x == 9:
get = self.getAccExcl(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
if self.glint == "Y" and x in (11, 13):
get = self.getGenDes(self.old1[d])
if get:
self.df.loadEntry("T", 1, x + 1, data=get[0])
d += 1
if self.locs == "N":
self.loc = "1"
self.df.loadEntry("T", 0, 2, data=self.loc)
err = self.checkLoc()
if err:
return err
return "sk1"
def doLoc(self, frt, pag, r, c, p, i, w):
if w == 0:
return "Invalid Location"
self.loc = w
err = self.checkLoc()
if err:
return err
def checkLoc(self):
acc = self.sql.getRec("strloc",
cols=["srl_desc"],
where=[("srl_cono", "=", self.opts["conum"]),
("srl_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Location Code"
else:
self.df.loadEntry("T", 0, 3, data=acc[0])
self.old2 = self.sql.getRec("strmf2",
where=[("st2_cono", "=",
self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)],
limit=1)
if not self.old2:
ok = askQuestion(self.opts["mf"].body, "New Location",
"This location does not exist for this product. " \
"Are you sure that you want to create it?")
if ok == "yes":
self.newloc = "Y"
else:
return "Rejected Location"
if not self.old2:
self.newloc = "Y"
else:
self.newloc = "N"
d = 3
for x in range(0, 4):
d = d + 1
self.df.loadEntry("T", 2, x, data=self.old2[d])
if self.automu in ("A", "L"):
for y in range(self.plevs):
mup = getMarkup(self.sql, self.opts["conum"], self.group,
self.code, self.loc, y + 1)
self.df.loadEntry("T", 2, 4 + y, data=mup)
self.mups[y] = mup
def doType(self, frt, pag, r, c, p, i, w):
self.gtype = w
if self.gtype == "R":
self.df.enableTag(2)
else:
self.df.disableTag(2)
def doUoi(self, frt, pag, r, c, p, i, w):
acc = self.getUoi(w)
if not acc:
return "Invalid UOI Record"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doValInd(self, frt, pag, r, c, p, i, w):
self.df.topf[1][5][5] = self.grpacc[0]
def doVat(self, frt, pag, r, c, p, i, w):
acc = self.getVat(w)
if not acc:
return "Invalid VAT Record"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if not self.drsctl:
self.chain = 0
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 1, data="")
if self.glint == "N":
return "sk9"
else:
return "sk4"
def doChnExcl(self, frt, pag, r, c, p, i, w):
if w:
acc = self.getChnExcl(w)
if not acc:
return "Invalid Chainstore"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
self.chain = w
def doAccExcl(self, frt, pag, r, c, p, i, w):
if w:
acc = self.getAccExcl(w)
if not acc:
return "Invalid Debtors Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if self.glint == "N":
return "sk5"
if self.newcode:
self.df.loadEntry(frt, pag, p + 2, data=self.grpacc[1])
if self.grpacc[1]:
acc = self.getGenDes(self.grpacc[1])
if not acc:
return "Invalid Sales Code"
self.df.loadEntry(frt, pag, p + 3, data=acc[0])
self.df.loadEntry(frt, pag, p + 4, data=self.grpacc[2])
if self.grpacc[2]:
acc = self.getGenDes(self.grpacc[2])
if not acc:
return "Invalid C.O.S. Code"
self.df.loadEntry(frt, pag, p + 5, data=acc[0])
def doSales(self, frt, pag, r, c, p, i, w):
acc = self.getGenDes(w)
if not acc:
return "Invalid Sales Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doCos(self, frt, pag, r, c, p, i, w):
acc = self.getGenDes(w)
if not acc:
return "Invalid COS Account"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doReord(self, frt, pag, r, c, p, i, w):
if w == "N":
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data=0)
return "sk2"
def getUoi(self, dat):
acc = self.sql.getRec("struoi",
cols=["unm_desc"],
where=[("unm_cono", "=", self.opts["conum"]),
("unm_unit", "=", dat)],
limit=1)
return acc
def getVat(self, dat):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", dat)],
limit=1)
return acc
def getChnExcl(self, dat):
self.chain = dat
if dat:
acc = self.sql.getRec("drschn",
cols=["chm_name"],
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", dat)],
limit=1)
return acc
def getAccExcl(self, dat):
if dat:
acc = self.sql.getRec("drsmst",
cols=["drm_name"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain),
("drm_acno", "=", dat),
("drm_stat", "<>", "X")],
limit=1)
return acc
def getGenDes(self, dat):
if dat:
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", dat)],
limit=1)
return acc
def doRecGrp(self, frt, pag, r, c, p, i, w):
self.rgroup = 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"
self.df.topf[0][1][8]["whera"] = [["C", "st1_group", 0, 3]]
def doRecCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.rgroup),
("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] == "R":
return "Invalid Type (Recipe)"
self.df.loadEntry(frt, pag, p + 1, data=acc[1])
acc = self.sql.getRec("strmf2",
cols=["st2_bin"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.rgroup),
("st2_code", "=", w),
("st2_loc", "=", self.loc)],
limit=1)
if not acc:
return "Invalid Code (2)"
self.rcode = w
acc = self.sql.getRec("strrcp",
cols=["srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)],
limit=1)
if acc:
self.newrec = "n"
self.df.loadEntry(frt, pag, p + 2, data=acc[0])
else:
self.newrec = "y"
def doRecQty(self, frt, pag, r, c, p, i, w):
self.rqty = w
def doEditor(self):
if self.df.pag != 3:
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
# Display recipe items and allow editing of details
data = self.sql.getRec(
tables=["strrcp", "strmf1"],
cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code), ("srr_loc", "=", self.loc),
("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ),
("st1_code=srr_rcode", )])
if data:
titl = "Recipe Items"
head = ("Grp", "Product-Code", "Description", "Quantity")
lin = {
"stype": "C",
"titl": titl,
"head": head,
"typs": (("NA", 3), ("NA", 20), ("NA", 30), ("SD", 10.2)),
"data": data
}
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Select a Product to Edit")
chg = self.df.selChoice(lin)
if chg and chg.selection:
self.change = chg.selection
self.doChgChanges()
self.df.enableButtonsTags(state=state)
self.df.focusField("C", 3, self.df.col)
def doChgChanges(self):
tit = ("Change Items", )
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_type", "", 0, "T"), ("st1_desc", "", 0, "Description",
"Y")),
"where": [("st1_cono", "=", self.opts["conum"])],
"whera": [],
"index":
1
}
fld = ((("T", 0, 0, 0), "INA", 3, "Group", "Product Group", "", "N",
self.doChgGrp, gpm, None, ('notblank', )),
(("T", 0, 1, 0), "INA", 20, "Code", "Product Code", "", "N",
self.doChgCod, stm, None,
('notblank', )), (("T", 0, 2, 0), "ONA", 30, "Description"),
(("T", 0, 3, 0), "ISD", 10.2, "Quantity", "", "", "N",
self.doChgQty, None, None, ('notzero', )))
but = [["Delete", None, self.doChgDel, 1, None, None]]
self.cg = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
butt=but,
tend=((self.doChgEnd, "n"), ),
txit=(self.doChgExit, ))
self.cg.loadEntry("T", 0, 0, data=self.change[0])
self.cg.loadEntry("T", 0, 1, data=self.change[1])
self.cg.loadEntry("T", 0, 2, data=self.change[2])
self.cg.loadEntry("T", 0, 3, data=self.change[3])
self.cg.focusField("T", 0, 1, clr=False)
self.cg.mstFrame.wait_window()
def doChgGrp(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strgrp",
cols=["gpm_desc"],
where=[("gpm_cono", "=", self.opts["conum"]),
("gpm_group", "=", w)],
limit=1)
if not acc:
return "Invalid Group"
self.rgroup = w
self.cg.topf[0][1][8]["whera"] = [["T", "st1_group", 0, 0]]
def doChgCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("strmf1",
cols=["st1_type", "st1_desc"],
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.rgroup),
("st1_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
if acc[0] != "N":
return "Invalid Type"
cnt = self.sql.getRec("strrcp",
cols=["count(*)"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.rgroup),
("srr_code", "=", w)],
limit=1)
if cnt[0]:
return "Product Already In Recipe"
self.rcode = w
self.cg.loadEntry("T", 0, 2, data=acc[1])
def doChgQty(self, frt, pag, r, c, p, i, w):
self.rqty = w
def doChgDel(self):
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.change[0]),
("srr_rcode", "=", self.change[1])])
self.doReadLoadRecipe()
self.doChgExit()
def doChgEnd(self):
self.sql.updRec("strrcp",
cols=["srr_rgroup", "srr_rcode", "srr_rqty"],
data=[self.rgroup, self.rcode, self.rqty],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.loc),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.change[0]),
("srr_rcode", "=", self.change[1])])
self.doReadLoadRecipe()
self.doChgExit()
def doChgExit(self):
self.cg.closeProcess()
def doDelete(self):
trn = self.sql.getRec("strpot",
cols=["count(*)"],
where=[("pot_cono", "=", self.opts["conum"]),
("pot_group", "=", self.group),
("pot_code", "=", self.code)],
limit=1)
if trn[0]:
return "Purchase Orders Exist, Not Deleted"
trn = self.sql.getRec("strtrn",
cols=["count(*)"],
where=[("stt_cono", "=", self.opts["conum"]),
("stt_group", "=", self.group),
("stt_code", "=", self.code),
("stt_loc", "=", self.loc)],
limit=1)
if trn[0]:
return "Stores Transactions Exist, Not Deleted"
trn = self.sql.getRec("slsiv2",
cols=["count(*)"],
where=[("si2_cono", "=", self.opts["conum"]),
("si2_group", "=", self.group),
("si2_code", "=", self.code),
("si2_loc", "=", self.loc)],
limit=1)
if trn[0]:
return "Sales-2 Transactions Exist, Not Deleted"
trn = self.sql.getRec("slsiv3",
cols=["count(*)"],
where=[("si3_cono", "=", self.opts["conum"]),
("si3_rgroup", "=", self.group),
("si3_rcode", "=", self.code)],
limit=1)
if trn[0]:
return "Sales-3 Transactions Exist, Not Deleted"
self.sql.delRec("strmf2",
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["strmf2", "D", "%03i%-3s%-20s%-1s" % \
(self.opts["conum"], self.group, self.code, self.loc), "", dte,
self.opts["capnm"], "", "", "", 0])
st2 = self.sql.getRec("strmf2",
cols=["count(*)"],
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code)],
limit=1)
if not st2[0]:
self.sql.delRec("strmf1",
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", self.code)])
self.sql.insRec("chglog", data=["strmf1", "D", "%03i%-3s%-20s" % \
(self.opts["conum"], self.group, self.code), "", dte,
self.opts["capnm"], "", "", "", 0])
# Other Files
self.sql.delRec("strcst",
where=[("stc_cono", "=", self.opts["conum"]),
("stc_group", "=", self.group),
("stc_code", "=", self.code),
("stc_loc", "=", self.loc)])
self.sql.delRec("strprc",
where=[("stp_cono", "=", self.opts["conum"]),
("stp_group", "=", self.group),
("stp_code", "=", self.code),
("stp_loc", "=", self.loc)])
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc)])
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.group),
("srr_rcode", "=", self.code)])
self.sql.delRec("strvar",
where=[("stv_cono", "=", self.opts["conum"]),
("stv_group", "=", self.group),
("stv_code", "=", self.code),
("stv_loc", "=", self.loc)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doDelRec(self):
self.sql.delRec("strrcp",
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)])
self.df.clearLine(2, focus=True)
def doEnd(self):
if self.df.frt == "T" and self.df.pag == 0:
if self.newcode:
self.df.focusField("T", 1, 1)
else:
if self.gtype == "R":
self.df.enableTag(2)
self.df.skip[1] = [1]
self.df.focusField("T", 1, 2, clr=False)
elif self.df.frt == "T" and self.df.pag == 1:
self.df.selPage("Basic-B")
elif self.df.frt == "T" and self.df.pag == 2:
if self.gtype == "R":
self.df.selPage("Recipes")
else:
self.doEnder()
elif self.df.frt == "C" and self.df.pag == 3:
data = [
self.opts["conum"], self.group, self.code, self.loc,
self.rgroup, self.rcode, self.rqty
]
if self.newrec == "y":
self.sql.insRec("strrcp", data=data)
self.df.advanceLine(3)
else:
whr = [("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code),
("srr_loc", "=", self.loc),
("srr_rgroup", "=", self.rgroup),
("srr_rcode", "=", self.rcode)]
self.sql.updRec("strrcp", data=data, where=whr)
self.doReadLoadRecipe()
def doEnder(self):
data = [self.opts["conum"]]
for x in range(0, 2):
data.append(self.df.t_work[0][0][x])
for x in range(0, len(self.df.t_work[1][0])):
if x in (3, 6, 8, 10, 12, 14):
continue
data.append(self.df.t_work[1][0][x])
if self.newcode:
self.sql.insRec("strmf1", data=data)
elif data != self.old1[:len(data)]:
col = self.sql.strmf1_col
data.append(self.old1[col.index("st1_xflag")])
self.sql.updRec("strmf1",
data=data,
where=[("st1_cono", "=", self.opts["conum"]),
("st1_group", "=", self.group),
("st1_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old1):
if dat != data[num]:
self.sql.insRec(
"chglog",
data=[
"strmf1", "U",
"%03i%-3s%-20s" %
(self.opts["conum"], self.group, self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
data = [self.opts["conum"], self.group, self.code, self.loc]
for x in range(0, 4):
data.append(self.df.t_work[2][0][x])
if self.newloc == "Y":
self.sql.insRec("strmf2", data=data)
elif data != self.old2[:len(data)]:
col = self.sql.strmf2_col
data.append(self.old2[col.index("st2_xflag")])
self.sql.updRec("strmf2",
data=data,
where=[("st2_cono", "=", self.opts["conum"]),
("st2_group", "=", self.group),
("st2_code", "=", self.code),
("st2_loc", "=", self.loc)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
for num, dat in enumerate(self.old2):
if dat != data[num]:
self.sql.insRec("chglog",
data=[
"strmf2", "U",
"%03i%-3s%-20s%-1s" %
(self.opts["conum"], self.group,
self.code, self.loc), col[num], dte,
self.opts["capnm"],
str(dat),
str(data[num]), "", 0
])
self.sql.delRec("strcmu",
where=[("smc_cono", "=", self.opts["conum"]),
("smc_group", "=", self.group),
("smc_code", "=", self.code),
("smc_loc", "=", self.loc)])
for num, mup in enumerate(self.df.t_work[2][0][4:]):
if mup and mup != self.mups[num]:
self.sql.insRec("strcmu",
data=[
self.opts["conum"], self.group, self.code,
self.loc, num + 1, mup
])
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
def doReadLoadRecipe(self):
self.df.clearFrame("C", 3)
self.df.focusField("C", 3, 1)
rec = self.sql.getRec(
tables=["strrcp", "strmf1"],
cols=["srr_rgroup", "srr_rcode", "st1_desc", "srr_rqty"],
where=[("srr_cono", "=", self.opts["conum"]),
("srr_group", "=", self.group),
("srr_code", "=", self.code), ("srr_loc", "=", self.loc),
("st1_cono=srr_cono", ), ("st1_group=srr_rgroup", ),
("st1_code=srr_rcode", )])
if rec:
mxs = (self.df.rows[3] - 1) * self.df.colq[3]
for l, r in enumerate(rec):
for i, d in enumerate(r):
c = l * self.df.colq[3]
if c > mxs:
c = mxs
self.df.loadEntry("C", 3, (c + i), data=d)
self.df.advanceLine(3)
def doExit(self):
if self.df.frt == "T" and self.df.pag == 0:
self.doQuit()
elif self.df.frt == "T" and self.df.pag == 1:
if self.newcode:
self.df.focusField("T", 1, 1)
else:
self.df.skip[1] = [1]
self.df.focusField("T", 1, 2, clr=False)
elif self.df.frt == "T" and self.df.pag == 2:
self.df.focusField("T", 2, 1)
elif self.df.frt == "C" and self.df.pag == 3:
if self.df.col == 1:
self.df.focusField("C", 3, 1)
else:
self.doEnder()
def doAccept(self):
ok = "yes"
for page in (1, 2):
frt, pag, col, err = self.df.doCheckFields(("T", page, None))
if err:
ok = "no"
if pag and pag != self.df.pag:
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col + 1), err=err)
break
if ok == "yes":
self.doEnder()
def doQuit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.selPage("Basic-A")
self.df.focusField("T", 0, 1)
class ml3040(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.tname = self.stpl
self.mesno = 0
self.doEnd()
else:
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"])
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
memctl = gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.ldays = memctl["mcm_ldays"]
self.lme = memctl["mcm_lme"]
self.stpl = memctl["mcm_sttpl"]
self.fromad = memctl["mcm_emadd"]
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmes", "ctlmst", "memmst", "memtrn", "memadd", "memcat",
"memctc", "memctp", "memctk", "memkon", "memlnk", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
yy = int(self.lme / 10000)
mm = (int(self.lme / 100) % 100) + 1
while mm > 12:
yy += 1
mm -= 12
self.nme = mthendDate((yy * 10000) + (mm * 100) + 1)
mm += 1
while mm > 12:
yy += 1
mm -= 12
self.nne = mthendDate((yy * 10000) + (mm * 100) + 1)
self.trtypes = []
for t in mltrtp:
self.trtypes.append(t[0])
return True
def mainProcess(self):
tpm = {
"stype":
"R",
"tables": ("tplmst", ),
"cols": (("tpm_tname", "", 0, "Template"), ("tpm_title", "", 0,
"Title", "Y")),
"where": [("tpm_type", "=", "R"), ("tpm_system", "=", "MEM")],
"order":
"tpm_tname"
}
self.mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("mlm_idnum", "", 0, "Identity-Numb"), ("mlm_gender", "", 0, "G"),
("mlm_state", "", 0, "S"), ("mlm_surname", "", 0, "Surname", "Y"),
("mlm_names", "", 0, "Names", "F")),
"where": [],
"order":
"mlm_surname, mlm_names",
"sort":
False
}
mss = {
"stype":
"R",
"tables": ("ctlmes", ),
"cols": (("mss_message", "", 0, "Num"), ("mss_detail", "NA", 50,
"Details")),
"where": [("mss_system", "=", "MEM")],
"order":
"mss_message"
}
r1s = (("All", "Z"), ("Active", "A"), ("Deceased", "D"),
("Inactive", "I"), ("Resigned", "R"), ("Suspended",
"S"), ("Defaulted", "X"))
r2s = (("Yes", "Y"), ("Range", "R"), ("Singles", "S"),
("Print Only", "P"), ("Email Only", "E"))
r3s = (("Yes", "Y"), ("No", "N"))
r4s = (("Yes", "Y"), ("No", "N"), ("Current", "C"))
r5s = (("Number", "N"), ("Surname", "M"))
fld = ((("T", 0, 0, 0), "INA", 20, "Template Name", "", self.stpl, "Y",
self.doTplNam, tpm, None,
None), (("T", 0, 1, 0), ("IRB", r1s), 0, "Status", "", "A",
"Y", self.doStatus, None, None, None),
(("T", 0, 2, 0), ("IRB", r2s), 0, "Whole File", "", "Y", "Y",
self.doWhole, None, None, None),
(("T", 0, 3, 0), "IUI", 6, "Member Start", "Starting Number", 1,
"Y", self.doMember, self.mlm, None,
None), (("T", 0, 3, 0), "IUI", 6, "End", "Ending Number",
999999, "Y", self.doMember, self.mlm, None, None),
(("T", 0, 4, 0), ("IRB", r3s), 0, "Current Year Only", "", "N",
"Y", self.doCurrent, None, None,
None), (("T", 0, 5, 0), ("IRB", r4s), 0, "Zero Balances", "",
"C", "Y", self.doZeros, None, None, None),
(("T", 0, 6, 0), ("IRB", r3s), 0, "Paid Transactions", "", "Y",
"Y", self.doPaid, None, None,
None), (("T", 0, 7, 0), ("IRB", r3s), 0, "Minus Balances", "",
"N", "Y", self.doMinus, None, None,
None), (("T", 0, 8, 0), "IUI", 3, "Message Number", "",
"", "Y", self.doMessno, mss, None, ("efld", )),
(("T", 0, 9, 0), "ID1", 10, "Statement Date", "", self.sysdtw,
"Y", self.doDat, None, None,
("efld", )), (("T", 0, 10, 0), ("IRB", r5s), 0, "Sort Order",
"", "N", "Y", self.doSort, None, None, None))
tnd = ((self.doEnd, "Y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
view=("N", "V"),
mail=("B", "Y"))
def doTplNam(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("tplmst",
where=[("tpm_tname", "=", w),
("tpm_type", "=", "S"),
("tpm_system", "=", "MEM")],
limit=1)
if not acc:
return "Invalid Template Name"
self.tname = w
def doStatus(self, frt, pag, r, c, p, i, w):
self.status = w
self.mlm["where"] = [("mlm_cono", "=", self.opts["conum"])]
if self.status != "Z": # Not All
self.mlm["where"].append(("mlm_state", "=", self.status))
def doWhole(self, frt, pag, r, c, p, i, w):
self.whole = w
if self.whole != "R":
self.df.loadEntry(frt, pag, p + 1, data="")
self.df.loadEntry(frt, pag, p + 2, data="")
return "sk2"
def doMember(self, frt, pag, r, c, p, i, w):
if p == 3:
self.start = w
elif w < self.start:
return "Invalid Member, Before From"
else:
self.to = w
def doCurrent(self, frt, pag, r, c, p, i, w):
self.current = w
def doZeros(self, frt, pag, r, c, p, i, w):
self.zeros = w
if self.zeros == "Y":
self.paid = "Y"
self.df.loadEntry(frt, pag, p + 1, data=self.paid)
return "sk1"
def doPaid(self, frt, pag, r, c, p, i, w):
self.paid = w
def doMinus(self, frt, pag, r, c, p, i, w):
self.minus = w
def doMessno(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "MEM"),
("mss_message", "=", w)],
limit=1)
if not acc:
return "Invalid Message Number"
self.mesno = w
def doDat(self, frt, pag, r, c, p, i, w):
self.pro = False
self.ynd = False
if w > self.nne:
showError(self.opts["mf"].body, "Month End Error",
"More than Two Month Ends are Missing, Aborting ...")
return "rf"
if w > self.nme:
if self.nme == self.opts["period"][2][0]:
ok = askQuestion(self.opts["mf"].body, "Year End Error",
"A Year End as at %s Has Not Been Run\n\n"\
"Would You Like to Raise Pro-Forma Charges?" %
self.opts["period"][2][1])
if ok == "yes":
self.pro = True
self.ynd = True
else:
ok = askQuestion(self.opts["mf"].body, "Month End Error",
"A Month End as at %s Has Not Been Run\n\n"\
"Would You Like to Raise Pro-Forma Charges?" %
CCD(self.nme, "D1", 10).disp)
if ok == "yes":
self.pro = True
self.datew = w
self.dated = self.df.t_disp[pag][0][p]
self.curdt = int(w / 100)
def doSort(self, frt, pag, r, c, p, i, w):
self.sort = w
def doEnd(self):
if "args" in self.opts:
self.whole = "S"
self.current = "N"
self.zeros = "Y"
self.paid = "Y"
self.minus = "Y"
self.mes = None
self.mes = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "MEM"),
("mss_message", "=", 1)],
limit=1)
self.curdt = int(self.opts["args"][1] / 100)
self.dated = CCD(self.opts["args"][1], "D1", 10).disp
self.pro = False
self.repprt = self.opts["args"][2]
self.repeml = self.opts["args"][3]
recs = [self.opts["args"][0]]
else:
self.df.closeProcess()
self.repprt = self.df.repprt
self.repeml = self.df.repeml
whr = [("mlm_cono", "=", self.opts["conum"])]
if self.status != "Z": # Not All
whr.append(("mlm_state", "=", self.status))
if self.sort == "N":
odr = "mlm_memno"
else:
odr = "mlm_surname"
if self.whole == "S":
recs = getSingleRecords(
self.opts["mf"],
"memmst", ("mlm_memno", "mlm_surname", "mlm_names"),
head=["X", "Number", "Surname", "Names"],
where=whr,
order=odr,
selcol="mlm_surname")
else:
if self.whole == "R":
whr.append(("mlm_memno", "between", self.start, self.to))
recs = self.sql.getRec("memmst", where=whr, order=odr)
if not recs:
showError(self.opts["mf"].body, "Error",
"No Accounts Selected")
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
return
# Remove all linked accounts
col = self.sql.memmst_col
nos = []
for acc in recs:
nos.append(acc[col.index("mlm_memno")])
chk = copyList(recs)
for acc in chk:
whr = [("mll_cono", "=", self.opts["conum"]),
("mll_lnkno", "=", acc[col.index("mlm_memno")])]
lnk = self.sql.getRec("memlnk", where=whr, limit=1)
if lnk and lnk[1] in nos:
recs.remove(acc)
if recs:
self.emadd = self.repeml[2]
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
if self.repeml[1] == "N":
mess = "Printing Statements"
else:
mess = "Printing and Emailing Statements"
p = ProgressBar(self.opts["mf"].body,
typ=mess,
mxs=len(recs),
esc=True)
for num, rec in enumerate(recs):
p.displayProgress(num)
if p.quit:
break
if self.pro:
self.doProForma(rec)
self.doProcess(rec)
p.closeProgress()
if self.pro:
self.opts["mf"].dbm.rollbackDbase()
if p.quit or not self.form.page:
pass
elif self.repeml[1] == "N" or self.emadd:
self.repeml[2] = self.emadd
self.doPrint()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
def doLoadStatic(self):
cmc = self.sql.ctlmst_col
ctm = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])],
limit=1)
for fld in cmc:
dat = ctm[cmc.index(fld)]
if fld in self.form.tptp:
if fld == "ctm_logo":
self.form.letterhead(cmc, ctm, fld, dat)
continue
self.form.tptp[fld][1] = dat
if "letterhead" in self.form.tptp:
self.form.letterhead(cmc, ctm, "letterhead", None)
self.form.document_date(self.dated)
self.form.bank_details(cmc, ctm, 0)
def doProForma(self, rec):
self.refno = 0
dmc = self.sql.memmst_col
acc = [rec[dmc.index("mlm_memno")]]
lnk = self.sql.getRec("memlnk",
cols=["mll_lnkno"],
where=[("mll_cono", "=", self.opts["conum"]),
("mll_memno", "=", acc[0])])
for l in lnk:
chk = self.sql.getRec("memmst",
cols=["mlm_state"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", l[0])],
limit=1)
if chk and chk[0] == "A":
acc.append(l[0])
for memno in acc:
if self.ynd:
data = doChkCatChg(self.opts["mf"], self.opts["conum"], memno,
self.datew)
if data:
if not data[3]:
self.doRaiseCharge(memno,
"B",
data[0],
data[1],
data[2],
data[3],
data[4],
data[5],
skip=True)
self.sql.delRec("memcat",
where=[("mlc_cono", "=",
self.opts["conum"]),
("mlc_memno", "=", memno),
("mlc_type", "=", "B"),
("mlc_code", "=", data[0])])
self.sql.insRec("memcat",
data=[
self.opts["conum"], memno, "B",
data[7], "", self.datew, 0, 0
])
cols = [
"mlc_type", "mlc_code", "mcc_desc", "mcc_freq", "mlc_start",
"mlc_end", "mlc_last"
]
wher = [("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", memno), ("mlc_start", ">", 0),
("mlc_start", "<=", self.datew), ("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 in cats:
if start > self.datew:
# Not yet Started
continue
if last and end and end < self.datew:
# Ended
continue
if last and freq == "O":
# Once Off
continue
if last and last > self.opts["period"][2][0]:
# Already Raised for Next Period in Advance
continue
if not self.ynd and last and freq == "A" and \
last >= self.opts["period"][1][0] and \
last <= self.opts["period"][2][0]:
# Already Raised in Financial Period
continue
self.doRaiseCharge(memno, ctyp, code, start, end, last, freq,
desc)
def doRaiseCharge(self,
memno,
ctyp,
code,
start,
end,
last,
freq,
desc,
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.nme, "days") > self.ldays:
dte = True
else:
nxt = True
if dte:
trdt = start
amt = self.doGetCharge(ctyp, code, trdt)
if amt:
self.doUpdateTables(memno, ctyp, code, desc, trdt, amt)
if not skip and nxt:
if end and self.datew > end:
return
trdt = self.datew
amt = self.doGetCharge(ctyp, code, trdt)
if amt:
self.doUpdateTables(memno, ctyp, code, desc, 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.datew):
# 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, memno, ctyp, code, desc, trdt, amt):
batch = "PROFORM"
self.refno += 1
refno = "PF%07i" % self.refno
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) / 114), 2), "UD", 12.2).work
# Members Ledger Transaction (memtrn)
self.sql.insRec("memtrn",
data=[
self.opts["conum"], memno, 1, refno, batch, trdt,
amt, vat, curdt, ctyp, code, desc, self.taxdf, "",
self.opts["capnm"], self.sysdtw, 0
],
unique="mlt_refno")
# Members Category Record (memcat)
self.sql.updRec("memcat",
cols=["mlc_last"],
data=[trdt],
where=[("mlc_cono", "=", self.opts["conum"]),
("mlc_memno", "=", memno),
("mlc_type", "=", ctyp),
("mlc_code", "=", code)])
def doProcess(self, mlm):
dmc = self.sql.memmst_col
tdc = self.form.sql.tpldet_col
self.memno = mlm[dmc.index("mlm_memno")]
self.doGetBalTrn()
if not self.mlt[1]:
return
if self.zeros == "N" and not self.tbal:
return
elif self.zeros == "C" and not self.tbal and not self.mlt[2]:
return
if self.minus == "N" and self.tbal < 0:
return
eml = []
kon = self.sql.getRec(tables=["memctk", "memkon"],
cols=["mlk_detail"],
where=[("mck_type", "=", "E"),
("mlk_cono", "=", self.opts["conum"]),
("mlk_memno", "=", self.memno),
("mlk_code=mck_code", )])
for k in kon:
eml.append(k[0])
if self.whole == "E" and not eml:
return
elif self.whole == "P" and eml:
return
for col in dmc:
d = "%s_C00" % col
if d in self.form.newdic:
dat = mlm[dmc.index(col)]
self.form.newdic[d][tdc.index("tpd_text")] = dat
self.doHeader(mlm, dmc, tdc)
mlc, mlt = self.mlt[:2]
if self.current == "Y":
amt = 0
bal = 0
cdt = int(self.opts["period"][2][0] / 100)
trn = copy.deepcopy(mlt)
mlt = []
while trn:
rec = trn.pop()
if rec[mlc.index("mlt_curdt")] < cdt:
amt = float(ASD(amt) + ASD(rec[mlc.index("mlt_tramt")]))
bal = float(ASD(bal) + ASD(rec[mlc.index("balance")]))
else:
mlt.append(rec)
if amt or bal:
rec[mlc.index("mlt_type")] = 3
rec[mlc.index("mlt_refno")] = "B/FWD"
rec[mlc.index("mlt_batch")] = ""
rec[mlc.index("mlt_tramt")] = amt
rec[mlc.index("balance")] = bal
rec[mlc.index("mlt_taxamt")] = 0
rec[mlc.index("mlt_desc")] = "Balance Brought Forward"
rec[mlc.index("mlt_taxind")] = ""
rec[mlc.index("mlt_batind")] = ""
mlt.insert(0, rec)
if len(mlt) <= self.form.maxlines:
self.doBody(mlc, mlt, tdc)
else:
amt = 0
bal = 0
lines = len(mlt) - self.form.maxlines + 1
for _ in range(lines):
trn = mlt.pop(0)
amt = float(ASD(amt) + ASD(trn[mlc.index("mlt_tramt")]))
bal = float(ASD(bal) + ASD(trn[mlc.index("balance")]))
trn[mlc.index("mlt_type")] = 3
trn[mlc.index("mlt_refno")] = "B/FWD"
trn[mlc.index("mlt_batch")] = ""
trn[mlc.index("mlt_tramt")] = amt
trn[mlc.index("balance")] = bal
trn[mlc.index("mlt_taxamt")] = 0
trn[mlc.index("mlt_desc")] = "Balance Brought Forward"
trn[mlc.index("mlt_taxind")] = ""
trn[mlc.index("mlt_batind")] = ""
mlt.insert(0, trn)
self.doBody(mlc, mlt, tdc)
self.doTotal(tdc)
self.doTail(tdc)
if self.repeml[1] == "Y" and not self.emadd:
self.repeml[2] = eml
self.doPrint()
def doGetBalTrn(self):
if self.paid == "Y":
trans = "A"
else:
trans = "Y"
bals = Balances(self.opts["mf"], "MEM", self.opts["conum"], self.curdt,
(self.memno, ))
self.obal, self.tbal, self.ages, self.mlt = bals.doAllBals(trans=trans)
lnk = self.sql.getRec("memlnk",
cols=["mll_lnkno"],
where=[("mll_cono", "=", self.opts["conum"]),
("mll_memno", "=", self.memno)])
if not lnk:
return
for l in lnk:
bals = Balances(self.opts["mf"], "MEM", self.opts["conum"],
self.curdt, (l[0], ))
obal, tbal, ages, mlt = bals.doAllBals(trans=trans)
for n, d in enumerate(mlt[1]):
mlt[1][n][mlt[0].index("mlt_desc")] = "%s (%s)" % \
(d[mlt[0].index("mlt_desc")][:30],
d[mlt[0].index("mlt_memno")])
self.obal = float(ASD(self.obal) + ASD(obal))
self.tbal = float(ASD(self.tbal) + ASD(tbal))
for x in range(5):
self.ages[x] = float(ASD(self.ages[x]) + ASD(ages[x]))
self.mlt[1].extend(mlt[1])
self.mlt[2] += mlt[2]
# Sort Transaction by Date
self.mlt[1].sort(key=lambda x: x[mlt[0].index("mlt_trdt")])
def doHeader(self, mlm, dmc, tdc):
self.form.add_page()
if "account_details" in self.form.tptp:
tit = mlm[dmc.index("mlm_title")]
sur = mlm[dmc.index("mlm_surname")]
nam = mlm[dmc.index("mlm_names")]
ini = ""
for n, d in enumerate(nam.split()):
if n < 3:
if not ini:
ini = d[0].upper()
else:
ini = "%s %s" % (ini, d[0].upper())
nad = "%s %s %s" % (tit.strip(), ini.strip(), sur.strip())
add = self.sql.getRec("memadd",
where=[("mla_cono", "=", self.opts["conum"]),
("mla_memno", "=", self.memno),
("mla_type", "=", "P")],
limit=1)
adc = self.sql.memadd_col
if add:
if add[adc.index("mla_add1")]:
nad = "%s\n%s" % (nad, add[adc.index("mla_add1")])
if add[adc.index("mla_add2")]:
nad = "%s\n%s" % (nad, add[adc.index("mla_add2")])
if add[adc.index("mla_add3")]:
nad = "%s\n%s" % (nad, add[adc.index("mla_add3")])
if add[adc.index("mla_city")]:
nad = "%s\n%s" % (nad, add[adc.index("mla_city")])
if add[adc.index("mla_country")]:
nad = "%s\n%-s, %-s" % (nad, add[adc.index("mla_code")],
add[adc.index("mla_country")])
else:
nad = "%s\n%s" % (nad, add[adc.index("mla_code")])
else:
nad = "\n\n\n\n\n"
self.form.newdic["account_details_C00"][tdc.index(
"tpd_text")] = nad
for key in self.form.newkey:
nl = copyList(self.form.newdic[key])
if nl[tdc.index("tpd_place")] != "A":
continue
if nl[tdc.index("tpd_detseq")] == "mlm_memno_C00":
nl[tdc.index("tpd_text")] = self.memno
self.form.doDrawDetail(nl)
def doBody(self, mlc, mlt, tdc):
text = self.form.sql.tpldet_col.index("tpd_text")
self.tots = [0.0, 0.0, 0.0]
count = 0
for trans in mlt:
if trans[mlc.index("mlt_type")] not in (5, 6) and \
trans[mlc.index("mlt_curdt")] == self.curdt:
if self.paid == "Y":
self.tots[1] = float(ASD(self.tots[1]) + \
ASD(trans[mlc.index("mlt_tramt")]))
else:
self.tots[1] = float(ASD(self.tots[1]) + \
ASD(trans[mlc.index("balance")]))
if trans[mlc.index("mlt_taxamt")]:
self.tots[1] = float(ASD(self.tots[1]) - \
ASD(trans[mlc.index("mlt_taxamt")]))
self.tots[2] = float(ASD(self.tots[2]) + \
ASD(trans[mlc.index("mlt_taxamt")]))
else:
self.tots[0] = float(ASD(self.tots[0]) + \
ASD(trans[mlc.index("balance")]))
for cod in self.form.body:
if cod == "type_code":
c = "mlt_type"
elif self.paid == "N" and cod == "mlt_tramt":
c = "balance"
else:
c = cod
d = "%s_C%02i" % (cod, count)
if cod == "type_code":
ttyp = trans[mlc.index(c)]
self.form.newdic[d][text] = mltrtp[ttyp - 1][0]
else:
self.form.newdic[d][text] = trans[mlc.index(c)]
self.form.doDrawDetail(self.form.newdic[d])
count += 1
for x in range(count, self.form.maxlines):
for cod in self.form.body:
d = "%s_C%02i" % (cod, x)
self.form.newdic[d][tdc.index("tpd_text")] = "BLANK"
self.form.doDrawDetail(self.form.newdic[d])
def doTotal(self, tdc):
for c in self.form.total:
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
line = self.form.newdic[d]
if c == "120_day_balance":
line[tdc.index("tpd_text")] = self.ages[4]
elif c == "90_day_balance":
line[tdc.index("tpd_text")] = self.ages[3]
elif c == "60_day_balance":
line[tdc.index("tpd_text")] = self.ages[2]
elif c == "30_day_balance":
line[tdc.index("tpd_text")] = self.ages[1]
elif c == "current_balance":
line[tdc.index("tpd_text")] = self.ages[0]
elif c == "total_arrears":
line[tdc.index("tpd_text")] = self.tots[0]
elif c == "month_exclusive":
line[tdc.index("tpd_text")] = self.tots[1]
elif c == "month_tax":
line[tdc.index("tpd_text")] = self.tots[2]
elif c == "total_balance":
line[tdc.index("tpd_text")] = self.tbal
self.form.doDrawDetail(line)
def doTail(self, tdc):
for c in self.form.tail:
if c == "message" and not self.mesno:
continue
t = "%s_T00" % c
if c in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[c])
elif t in self.form.newdic:
self.form.doDrawDetail(self.form.newdic[t])
d = "%s_C00" % c
if d in self.form.newdic:
if d == "message_C00" and self.mesno:
mes = self.sql.getRec("ctlmes",
cols=["mss_detail"],
where=[("mss_system", "=", "MEM"),
("mss_message", "=",
self.mesno)],
limit=1)
self.form.newdic[d][tdc.index("tpd_text")] = mes[0]
self.form.doDrawDetail(self.form.newdic[d])
def doPrint(self):
if self.repeml[1] == "Y" and not self.emadd:
key = "%s_%s" % (self.opts["conum"], self.memno)
else:
key = "%s_all" % self.opts["conum"]
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__,
key,
ext="pdf")
self.form.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"],
conum=self.opts["conum"],
pdfnam=pdfnam,
header="%s Statement at %s" %
(self.opts["conam"], self.dated),
fromad=self.fromad,
repprt=self.repprt,
repeml=self.repeml)
if self.repeml[1] == "Y":
self.form = DrawForm(self.opts["mf"].dbm,
self.tname,
wrkdir=self.opts["mf"].rcdic["wrkdir"])
self.doLoadStatic()
self.form.doNewDetail()
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class wg1010(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, ["ctldep", "chglog", "wagbal",
"wagcap", "wagcod", "wagedc", "wagmst", "wagtf1", "wagtf2",
"waglmf", "wagltf"], 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"),
("wgm_freq", "", 0, "F"),
("wgm_start", "", 0, "Start-Date"),
("wgm_term", "", 0, "Term-Date")),
"where": [("wgm_cono", "=", self.opts["conum"])]}
dep = {
"stype": "R",
"tables": ("ctldep",),
"cols": (
("dep_code", "", 0, "Dep"),
("dep_name", "", 0, "Name", "Y")),
"where": [("dep_cono", "=", self.opts["conum"])]}
wec = {
"stype": "R",
"tables": ("wagedc",),
"cols": (
("ced_code", "", 0, "Code"),
("ced_desc", "", 0, "Description", "Y")),
"where": [
("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "E")]}
wdc = {
"stype": "R",
"tables": ("wagedc",),
"cols": (
("ced_code", "", 0, "Code"),
("ced_desc", "", 0, "Description", "Y")),
"where": [
("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D")]}
r1s = (("Weekly","W"),("2xWeekly","F"),("Monthly ","M"))
r2s = (("Cash ","C"),("Cheque ","Q"),("Electronic","E"))
r3s = (("Yes","Y"),("No","N"))
r4s = (("Current","1"),("Transmission","2"),("Savings","3"))
fld = (
(("T",0,0,0),"IUI",5,"Emp-Num","Employee Number",
"","Y",self.doEmpNum,wgm,None,("notzero",)),
(("T",0,0,0),"IUI",3,"Department","",
"","N",self.doDept,dep,None,None),
(("T",0,0,0),"IUI",1,"Class","",
"","N",None,None,None,None),
(("T",1,0,0),"INA",30,"Surname","",
"","N",None,None,None,("notblank",)),
(("T",1,1,0),"INA",30,"Names","",
"","N",None,None,None,("notblank",)),
(("T",1,2,0),"ID1",10,"Date of Birth","",
"","N",self.doDOB,None,None,("efld",)),
(("T",1,3,0),"INA",13,"ID Number","",
"","N",self.doIdNo,None,None,("idno",)),
(("T",1,4,0),"INA",16,"Spouse Name","",
"","N",None,None,None,None),
(("T",1,5,0),"INA",13,"Spouse ID Number","",
"","N",self.doIdNo,None,None,("idno",)),
(("T",1,6,0),"INA",30,"Address Line 1","",
"","N",None,None,None,("notblank",)),
(("T",1,7,0),"INA",30,"Address Line 2","",
"","N",None,None,None,None),
(("T",1,8,0),"INA",30,"Address Line 3","",
"","N",None,None,None,None),
(("T",1,9,0),"INA",4,"Postal Code","",
"","N",None,None,None,("notblank",)),
(("T",1,10,0),"INA",16,"Telephone Number","",
"","N",None,None,None,None),
(("T",1,11,0),"ITX",50,"E-Mail Address","",
"","N",None,None,None,("email",)),
(("T",1,12,0),"ID1",10,"Start Date","",
"","N",None,None,None,("efld",)),
(("T",1,13,0),"IUD",10.2,"Salary/Rate","",
"","N",None,None,None,("efld",)),
(("T",1,14,0),("IRB",r1s),0,"Pay Freq","Pay Frequency",
"M","N",None,None,None,None),
(("T",1,15,0),("IRB",r2s),0,"Pay Type","",
"E","N",self.doPayTyp,None,None,None),
(("T",2,0,0),("IRB",r3s),0,"P.A.Y.E.","",
"Y","N",None,None,None,None),
(("T",2,1,0),"INA",16,"Tax Office","",
"","N",None,None,None,None),
(("T",2,2,0),"INA",10,"Tax Number","",
"","N",None,None,None,None),
(("T",2,3,0),"IUA",1,"Nature of Employee","",
"A","N",None,None,None,("notblank",)),
(("T",2,4,0),"IUI",9,"Reg Number","Registration Number",
"","N",None,None,None,None),
(("T",2,5,0),"IUA",1,"Voluntary Excess","",
"N","N",None,None,None,None),
(("T",2,6,0),"IUD",6.2,"Fixed Rate","",
"","N",None,None,None,None),
(("T",2,7,0),"INA",13,"Directive","",
"","N",None,None,None,None),
(("T",3,0,0),("IRB",r4s),0,"Account Type","Bank Account Type",
"1","N",None,None,None,None),
(("T",3,1,0),"INA",30,"Bank Name","",
"","N",self.doBankNam,None,None,None),
(("T",3,2,0),"IUI",8,"Branch Code","Bank Branch Code",
"","N",self.doBankBch,None,None,None),
(("T",3,3,0),"INA",16,"Account Number","Bank Account Number",
"","N",self.doBankAcc,None,None,None),
(("T",3,4,0),"INA",30,"Account Holder's Name","",
"","N",self.doHolderNam,None,None,None),
(("T",3,5,0),"IUI",1,"Holder's Relationship","",
"","N",self.doHolderRel,None,None,None),
(("C",4,0,0),"IUI",3,"Cod","Earnings Code",
"","N",self.doEarnCod,wec,None,("efld",)),
(("C",4,0,1),"ONA",30,"Description"),
(("C",4,0,2),"ISD",13.2,"Amnt/Rate","Amount or Rate",
"","N",self.doEarnAmt,None,self.doCodeDelete,("efld",)),
(("C",5,0,0),"IUI",3,"Cod","Deduction Code",
"","N",self.doDedCod,wdc,None,("efld",)),
(("C",5,0,1),"ONA",30,"Description"),
(("C",5,0,2),"ISD",13.2,"Amnt/Rate","Employees Amount or Rate",
"","N",self.doDedEAmt,None,self.doCodeDelete,("efld",)),
(("C",5,0,3),"ISD",13.2,"Amnt/Rate","Employers Amount or Rate",
"","N",self.doDedRAmt,None,None,("efld",)),
(("T",6,0,0),"ISD",13.2,"Balance-1","",
"","N",None,None,None,("efld",)),
(("T",6,1,0),"ISD",13.2,"Balance-2","",
"","N",None,None,None,("efld",)),
(("T",6,2,0),"ISD",13.2,"Balance-3","",
"","N",None,None,None,("efld",)))
tag = (
("General",None,("T",0,0),("T",0,1)),
("Tax",None,("T",0,0),("T",0,1)),
("Bank",None,("T",0,0),("T",0,1)),
("Earnings",None,("T",0,0),("T",0,1)),
("Deductions",None,("T",0,0),("T",0,1)),
("Balances",None,("T",0,0),("T",0,1)))
tnd = (
(self.doEnd, "n"),
(self.doEnd, "n"),
(self.doEnd, "n"),
(self.doEnd, "n"),
None,
None,
(self.doEnd, "y"))
txt = (
self.doExit,
self.doExit,
self.doExit,
self.doExit,
None,
None,
self.doExit)
cnd = (
None,
None,
None,
None,
(self.doEndEarn, "y"),
(self.doEndDed, "y"),
None)
cxt = (
None,
None,
None,
None,
self.doExit,
self.doExit,
None)
but = (
("Accept",None,self.doAccept,0,("T",0,2),("T",0,1)),
("Print",None,self.doPrint,0,("T",0,2),("T",0,0)),
("Cancel",None,self.doCancel,0,("T",0,2),("T",0,0)),
("Quit",None,self.doCloseProcess,1,None,None))
row = [0,0,0,0,15,15,0]
self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag,
rows=row, tend=tnd, txit=txt, cend=cnd, cxit=cxt, butt=but,
clicks=self.doClick)
def doClick(self, *opts):
if self.df.pag == 0:
return
self.df.focusField("T", opts[0][0], opts[0][1] + 1)
def doEmpNum(self, frt, pag, r, c, p, i, w):
self.empno = w
self.oldm = self.sql.getRec("wagmst", where=[("wgm_cono", "=",
self.opts["conum"]), ("wgm_empno", "=", self.empno)], limit=1)
self.oldb = self.sql.getRec("wagbal", where=[("wbl_cono", "=",
self.opts["conum"]), ("wbl_empno", "=", self.empno)],
order="wbl_balno")
if not self.oldm:
self.new = True
self.term = 0
self.ptyp = ""
else:
self.new = False
self.term = self.oldm[len(self.oldm)-1]
d = 1
for pg in range(0, self.df.pgs):
for x in range(0, self.df.topq[pg]):
self.df.loadEntry("T", pg, x, data=self.oldm[d])
d = d + 1
self.ptyp = self.df.t_work[1][0][15]
self.doLoadEarnDed("E")
self.doLoadEarnDed("D")
if self.oldb:
for b in self.oldb:
self.df.loadEntry("T", 6, b[2]-1, data=b[3])
def doDept(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctldep", cols=["dep_name"],
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", w)], limit=1)
if not acc:
return "Invalid Department"
self.dept = w
def doDOB(self, frt, pag, r, c, p, i, w):
self.dob = w
def doIdNo(self, frt, pag, r, c, p, i, w):
if p == 6:
a = int(int(w) / 10000000)
b = int(self.dob % 1000000)
if a != b:
return "ID Number Does Not Agree with Birth Date"
def doPayTyp(self, frt, pag, r, c, p, i, w):
self.ptyp = w
def doBankNam(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Bank Name"
def doBankBch(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Branch"
def doBankAcc(self, frt, pag, r, c, p, i, w):
if self.ptyp == "E" and not w:
return "Invalid Account"
def doHolderNam(self, frt, pag, r, c, p, i, w):
self.holnam = w
def doHolderRel(self, frt, pag, r, c, p, i, w):
self.holrel = w
def doEnd(self):
if self.df.pag == 0:
self.df.focusField("T", 1, 1)
elif self.df.pag == 1:
self.df.selPage("Tax")
self.df.focusField("T", 2, 1)
elif self.df.pag == 2:
self.df.selPage("Bank")
self.df.focusField("T", 3, 1)
elif self.df.pag == 3:
self.df.selPage("Earnings")
elif self.df.pag == 6:
self.doAccept()
def doEarnCod(self, frt, pag, r, c, p, i, w):
desc = self.sql.getRec("wagedc", cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]), ("ced_type", "=",
"E"), ("ced_code", "=", w)], limit=1)
if not desc:
return "Invalid Code"
self.code = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=",
self.empno), ("wcd_type", "=", "E"), ("wcd_code", "=", w)],
limit=1)
if not code:
self.ncod = "y"
else:
self.ncod = "n"
self.df.loadEntry(frt, pag, p+2, data=code[0])
def doEarnAmt(self, frt, pag, r, c, p, i, w):
self.eamt = w
self.ramt = 0
def doEndEarn(self):
self.doEndCode("E")
def doDedCod(self, frt, pag, r, c, p, i, 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"
self.code = w
self.df.loadEntry(frt, pag, p+1, data=desc[0])
code = self.sql.getRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
where=[("wcd_cono", "=", self.opts["conum"]), ("wcd_empno", "=",
self.empno), ("wcd_type", "=", "D"), ("wcd_code", "=", w)],
limit=1)
if not code:
self.ncod = "y"
else:
self.ncod = "n"
self.df.loadEntry(frt, pag, p+2, data=code[0])
self.df.loadEntry(frt, pag, p+3, data=code[1])
def doDedEAmt(self, frt, pag, r, c, p, i, w):
self.eamt = w
def doDedRAmt(self, frt, pag, r, c, p, i, w):
self.ramt = w
def doEndDed(self):
self.doEndCode("D")
def doEndCode(self, rtype):
if self.ncod == "y":
self.sql.insRec("wagcod", data=[self.opts["conum"],
self.empno, rtype, self.code, self.eamt, self.ramt])
else:
self.sql.updRec("wagcod", cols=["wcd_eamt", "wcd_ramt"],
data=[self.eamt, self.ramt], where=[("wcd_cono", "=",
self.opts["conum"]), ("wcd_empno", "=", self.empno),
("wcd_type", "=", rtype), ("wcd_code", "=", self.code)])
self.doLoadEarnDed(rtype, focus=True)
def doLoadEarnDed(self, rtype, focus=False):
if rtype == "E":
pag = 4
else:
pag = 5
self.df.clearFrame("C", pag)
codes = self.sql.getRec(tables=["wagcod", "wagedc"], cols=["wcd_code",
"ced_desc", "wcd_eamt", "wcd_ramt"], where=[("wcd_cono", "=",
self.opts["conum"]), ("wcd_empno", "=", self.empno), ("wcd_type",
"=", rtype), ("ced_cono = wcd_cono",), ("ced_type = wcd_type",),
("ced_code = wcd_code",)])
if not codes:
return
p = 0
for cod in codes:
for i, c in enumerate(cod):
if rtype == "E" and i == 3:
continue
self.df.loadEntry("C", pag, p, data=c)
p = p + 1
if focus:
self.df.focusField("C", pag, p+1)
else:
self.df.last[pag][1] = p + 1
def doCodeDelete(self):
if self.df.pag == 4:
rtype = "E"
else:
rtype = "D"
code = self.df.c_work[self.df.pag][self.df.row][self.df.idx-2]
self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno), ("wcd_type", "=", rtype),
("wcd_code", "=", code)])
self.doLoadEarnDed(rtype, focus=True)
def doAccept(self):
frt, pag, col, mes = self.df.doCheckFields(("T",0,None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(("T",1,None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(("T",2,None))
if not mes and self.df.t_work[1][0][15] == "E":
frt, pag, col, mes = self.df.doCheckFields(("T",3,None))
if mes:
if pag > 0 and pag != self.df.pag:
if frt == "T":
self.df.last[pag][0] = col+1
else:
self.df.last[pag][1] = col+1
self.df.selPage(self.df.tags[pag - 1][0])
self.df.focusField(frt, pag, (col+1), err=mes)
else:
data = [self.opts["conum"]]
for p in range(0, self.df.pgs):
for x in range(0, self.df.topq[p]):
data.append(self.df.t_work[p][0][x])
data.append(self.term)
if self.new:
self.sql.insRec("wagmst", data=data)
for b in range(3):
data = [self.opts["conum"], self.empno, b+1,
self.df.t_work[6][0][b], ""]
self.sql.insRec("wagbal", data=data)
else:
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
if data != self.oldm[:len(data)]:
col = self.sql.wagmst_col
data.append(self.oldm[col.index("wgm_xflag")])
self.sql.updRec("wagmst", data=data, where=[("wgm_cono",
"=", self.opts["conum"]), ("wgm_empno", "=",
self.empno)])
for num, dat in enumerate(self.oldm):
if dat != data[num]:
self.sql.insRec("chglog", data=["wagmst", "U",
"%03i%05i" % (self.opts["conum"], self.empno),
col[num], dte, self.opts["capnm"], str(dat),
str(data[num]), "", 0])
for n, b in enumerate(self.df.t_work[6][0]):
lvl = n + 1
data = [self.opts["conum"], self.empno, lvl, b]
whr = [
("wbl_cono", "=", self.opts["conum"]),
("wbl_empno", "=", self.empno),
("wbl_balno", "=", lvl)]
chk = self.sql.getRec("wagbal", where=whr, limit=1)
if not chk:
self.sql.insRec("wagbal", data=data)
continue
if data != self.oldb[n][:len(data)]:
col = self.sql.wagbal_col
data.append(self.oldb[n][col.index("wbl_xflag")])
self.sql.updRec("wagbal", data=data, where=whr)
for num, dat in enumerate(self.oldb[n]):
if dat != data[num]:
self.sql.insRec("chglog", data=["wagbal", "U",
"%03i%05i%i" % (self.opts["conum"],
self.empno, lvl), col[num], dte,
self.opts["capnm"], str(dat),
str(data[num]), "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("General")
self.df.focusField("T", 0, 1)
def doMainDelete(self):
t = self.sql.getRec("wagtf1", cols=["count(*)"],
where=[("wt1_cono", "=", self.opts["conum"]), ("wt1_empno", "=",
self.empno)], limit=1)
if t[0]:
return "Transactions 1 Exist, Not Deleted"
t = self.sql.getRec("wagtf2", cols=["count(*)"],
where=[("wt2_cono", "=", self.opts["conum"]), ("wt2_empno=%s", "=",
self.empno)], limit=1)
if t[0]:
return "Transactions 2 Exist, Not Deleted"
t = self.sql.getRec("wagltf", cols=["count(*)"],
where=[("wlt_cono", "=", self.opts["conum"]), ("wlt_empno", "=",
self.empno)], limit=1)
if t[0]:
return "Loan Transactions Exist, Not Deleted"
self.sql.delRec("wagbal", where=[("wbl_cono", "=", self.opts["conum"]),
("wbl_empno", "=", self.empno)])
self.sql.delRec("wagcap", where=[("wcp_cono", "=", self.opts["conum"]),
("wcp_empno", "=", self.empno)])
self.sql.delRec("wagcod", where=[("wcd_cono", "=", self.opts["conum"]),
("wcd_empno", "=", self.empno)])
self.sql.delRec("waglmf", where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)])
self.sql.delRec("wagmst", where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog", data=["wagmst", "D", "%03i%05i" %
(self.opts["conum"], self.empno), "", dte, self.opts["capnm"],
"", "", "", 0])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doPrint(self):
tables = []
for pag in range(0, (self.df.pgs+1)):
for x in range(0, self.df.topq[pag]):
lin = []
lin.append(self.df.topf[pag][x][3])
lin.append(self.df.t_disp[pag][0][x])
tables.append(lin)
heads = ["Salaries and Wages File Maintenance"]
cols = [["a","NA",30.0,"Field Name"],
["b","NA",30.0,"Values"]]
state = self.df.disableButtonsTags()
RepPrt(self.opts["mf"], name=self.__class__.__name__, tables=tables,
heads=heads, cols=cols, conum=self.opts["conum"],
conam=self.opts["conam"], ttype="D")
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.last[0] = [0, 0]
self.df.selPage("General")
self.df.focusField("T", 0, 1)
def doExit(self):
if self.df.pag == 0:
self.doCloseProcess()
elif self.df.pag == 1:
self.df.focusField("T", 0, 3)
elif self.df.pag == 2:
self.df.selPage("General")
elif self.df.pag == 3:
self.df.selPage("Tax")
elif self.df.pag == 4:
self.df.selPage("Deductions")
elif self.df.pag == 5:
self.df.selPage("Balances")
def doCloseProcess(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class drc410(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):
self.sql = Sql(self.opts["mf"].dbm,
"drsdel",
prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
dlm = {
"stype":
"R",
"tables": ("drsdel", ),
"cols":
(("del_code", "", 0, "Del-Cod"), ("del_add1", "", 0, "Address"))
}
self.fld = [[("T", 0, 0, 0), "INa", 7, "Code", "Address Code", "", "N",
self.doCode, dlm, None, ("notblank", )],
(("T", 0, 1, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 4, 0), "INA", 30, "Address Line 4", "", "", "N",
None, None, None, ("efld", ))]
if "args" in self.opts:
self.fld[0][1] = "ONa"
self.fld[0][5] = self.opts["args"]
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 doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.acc = self.sql.getRec("drsdel",
where=[("del_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = "Y"
else:
self.new = "N"
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=self.acc[x])
def doDelete(self):
self.sql.delRec("drsdel", where=[("del_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
dat = []
for x in range(0, len(self.df.t_work[0][0])):
dat.append(self.df.t_work[0][0][x])
if self.new == "Y":
self.sql.insRec("drsdel", data=dat)
elif dat != self.acc[:len(dat)]:
col = self.sql.drsdel_col
dat.append(self.acc[col.index("del_xflag")])
self.sql.updRec("drsdel",
data=dat,
where=[("del_code", "=", self.code)])
if "args" in self.opts:
self.doExit()
else:
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()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class rtc210(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", "genmst", "rtlprm", "rtlmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.glint = rtlctl["ctr_glint"]
return True
def mainProcess(self):
prm = {
"stype":
"R",
"tables": ("rtlprm", ),
"cols": (("rtp_code", "", 0, "Prm-Code"), ("rtp_desc", "", 0,
"Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])],
"order":
"glm_acno"
}
self.fld = [(("T", 0, 0, 0), "INA", 7, "Premises Code", "Premises", "",
"N", self.doPrmCod, prm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 30, "Description", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 2", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 4, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 4, "Postal Code", "PCod", "", "N",
None, None, None, ("notblank", ))]
if self.glint == "Y":
self.fld.append(
(("T", 0, 6, 0), "IUI", 7, "Rental Account", "", "", "N",
self.doRental, glm, None, ("notzero", ), None,
"Rental Control Account in the General Ledger."))
self.fld.append((("T", 0, 6, 0), "ONA", 30, ""))
self.fld.append(
(("T", 0, 7, 0), "IUI", 7, "Income Account", "", "", "N",
self.doIncome, glm, None, ("notzero", ), None,
"Rental Income Account in the General Ledger."))
self.fld.append((("T", 0, 7, 0), "ONA", 30, ""))
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 doPrmCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("rtlprm",
where=[("rtp_cono", "=",
self.opts["conum"]),
("rtp_code", "=", self.code)],
limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
acc = copyList(self.old[:-1])
acc.append("")
acc.insert(8, "")
for x in range(0, self.df.topq[pag]):
self.df.loadEntry(frt, pag, p + x, data=acc[x + 1])
if self.glint == "N":
return
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc[7])],
limit=1)
if des:
self.df.loadEntry("T", 0, 7, data=des[0])
des = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", acc[9])],
limit=1)
if des:
self.df.loadEntry("T", 0, 9, data=des[0])
def doRental(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", 0, 7, data=acc[0])
def doIncome(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid G/L Account"
self.df.loadEntry("T", 0, 9, data=acc[0])
def doDelete(self):
mst = self.sql.getRec("rtlmst",
cols=["count(*)"],
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code)],
limit=1)
if mst[0]:
return "Accounts Exist, Not Deleted"
self.sql.delRec("rtlprm",
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", self.code)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"rtlprm", "D",
"%03i%-7s" % (self.opts["conum"], self.code), "",
dte, self.opts["capnm"], "", "", "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for x in range(0, len(self.df.t_work[0][0])):
if self.glint == "Y" and x in (7, 9):
continue
data.append(self.df.t_work[0][0][x])
if self.glint == "N":
data.extend([0, 0])
if self.new == "y":
self.sql.insRec("rtlprm", data=data)
elif data != self.old[:len(data)]:
col = self.sql.rtlprm_col
data.append(self.old[col.index("rtp_xflag")])
self.sql.updRec("rtlprm",
data=data,
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", self.code)])
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=[
"rtlprm", "U",
"%03i%-7s" % (self.opts["conum"], self.code),
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.focusField("T", 0, 1)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class gl1050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for control record and departments
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
# Check for multiple companies
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "genrpc", "genstr",
"gendtm", "genrpt"], prog=self.__class__.__name__)
if self.sql.error:
return
acc = self.sql.getRec("ctlmst", cols=["count(*)"], limit=1)
if acc[0] > 1:
self.coys = True
else:
self.coys = False
self.strm = 0
return True
def doProcess(self):
st1 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_strm", "", 0, "Str"),
("gls_desc", "", 0, "Description", "Y")),
"where": [("gls_cono", "=", self.opts["conum"])],
"group": "gls_strm, gls_desc"}
st2 = {
"stype": "R",
"tables": ("genstr",),
"cols": (
("gls_seq", "", 0, "Seq"),
("gls_typ", "", 0, "T"),
("gls_cno", "", 0, "CN"),
("gls_con", "", 0, "C"),
("gls_rep", "", 0, "Rep"),
("gls_gen", "", 0, "G"),
("gls_val", "", 0, "V"),
("gls_det", "", 0, "Det"),
("gls_var", "", 0, "B"),
("gls_zer", "", 0, "Z"),
("gls_opt", "", 0, "O"),
("gls_num", "", 0, "N"),
("gls_prnt", "", 20, "Printer-Name"),
("gls_mail", "", 20, "E-Mail-Address")),
"where": [("gls_cono", "=", self.opts["conum"])],
"whera": (("T", "gls_strm", 0, 0),),
"comnd": self.doSelTyp}
typ = {
"stype": "C",
"title": "Available Types",
"head": ("C", "Description"),
"data": (
("S", "YTD Report"),
("H", "Last 3 Years YTD Report"),
("L", "MTD and YTD Report"),
("M", "Monthly Report"),
("C", "Customised Report"))}
rpc = {
"stype": "R",
"tables": ("genrpc",),
"cols": (
("glc_cusno", "", 0, "CN"),
("glc_head1", "", 0, "Heading-1"),
("glc_head2", "", 0, "Heading-2"),
("glc_head3", "", 0, "Heading-3"),
("glc_head4", "", 0, "Heading-4")),
"where": [("glc_cono", "=", self.opts["conum"])]}
rpt = {
"stype": "R",
"tables": ("genrpt",),
"cols": (
("glr_cono", "", 0, "Coy"),
("glr_repno", "", 0, "Rep"),
("glr_type", "", 0, "T"),
("glr_desc", "", 0, "Description", "Y")),
"where": [("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_seq", "=", 0)],
"group": "glr_cono, glr_repno, glr_type, glr_desc",
"index": 1}
con = {
"stype": "C",
"title": "Available Options",
"head": ("C", "Description"),
"data": (
("V", "Actuals"),
("B", "Budgets"),
("C", "Actuals and Budgets"),
("X", "Variance to Budget"),
("D", "Detail"))}
det = {
"stype": "R",
"tables": ("gendtm",),
"cols": (
("gdm_code", "", 0, "Cod"),
("gdm_desc", "", 0, "Description")),
"where": [("gdm_cono", "=", self.opts["conum"])]}
prts = getPrinters(wrkdir=self.opts["mf"].rcdic["wrkdir"])
prts.insert(1, "Export")
if "None" not in prts:
prts.append("None")
prt = {
"stype": "C",
"titl": "Select Required Printer",
"head": ("Name", "Description"),
"data": prts}
cts = ("V", "B", "C", "X", "D")
fld = (
(("T",0,0,0),"IUI",3,"Stream-Number","Stream Number",
0,"Y",self.doStr,st1,None,("notzero",)),
(("T",0,0,0),"INA",30,"Description","",
"","N",self.doDsc,None,self.doDelStr,("notblank",)),
(("C",0,0,0),"IUI",3,"Seq","Sequence Number",
"i","N",self.doSeq,st2,None,("efld",)),
(("C",0,0,1),"IUA",1,"T","Report Type",
"S","N",self.doTyp,typ,self.doDelLin,
("in",("S","H","L","M","C"))),
(("C",0,0,2),"IUI",2,"CN","Custom Number",
0,"N",self.doCus,rpc,None,("efld",)),
(("C",0,0,3),"IUA",1,"C","Consolidate (Y/N)",
"N","N",self.doCon,None,None,("in",("Y","N"))),
(("C",0,0,4),"IUI",3,"Rep","Report Number",
0,"N",self.doRep,rpt,None,("notzero",)),
(("C",0,0,5),"IUA",1,"G","General Report (Y/N)",
"N","N",self.doGen,None,None,("in",("Y","N"))),
(("C",0,0,6),"IUA",1,"V","Report Contents",
"V","N",self.doContent,con,None,("in",cts)),
(("C",0,0,7),"INa",2,"Cod","Details Code",
"","N",self.doCod,det,None,None),
(("C",0,0,8),"IUA",1,"V","Variance (B/P/N)",
"B","N",self.doVar,None,None,("in",("B","P","N"))),
(("C",0,0,9),"IUA",1,"Z","Ignore Zeros (Y/N)",
"Y","N",None,None,None,("in",("Y","N"))),
(("C",0,0,10),"IUA",1,"O","Print Options (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,11),"IUA",1,"N","Print Numbers (Y/N)",
"N","N",None,None,None,("in",("Y","N"))),
(("C",0,0,12),"ITX",30,"Printer Name","Printer-Name",
"Default","N",self.doPrt,prt,None,("in",prts)),
(("C",0,0,13),"ITX",30,"E-Mail Address","E-Mail-Address",
"","N",None,None,None,("email",)))
but = (
("Cancel",None,self.doCancel,0,("C",0,1),("T",0,1)),
("Quit",None,self.exitTops,1,None,None))
self.df = TartanDialog(self.opts["mf"], eflds=fld,
tend=((self.endTops,"n"),), txit=(self.exitTops,),
cend=((self.endData,"y"),), cxit=(self.exitData,), butt=but)
self.df.focusField("T", 0, 1)
def doStr(self, frt, pag, r, c, p, i, w):
self.strm = w
self.old = self.sql.getRec("genstr", where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm)], limit=1)
if not self.old:
self.new = "y"
else:
self.new = "n"
self.desc = self.old[self.sql.genstr_col.index("gls_desc")]
self.df.loadEntry(frt, pag, p+1, self.desc)
def doDelStr(self):
if self.new == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
def doDsc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
dt = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm), ("gls_seq", "=",
self.seq)], limit=1)
if not dt:
self.newlin = "y"
else:
self.newlin = "n"
for n, d in enumerate(dt[3:-1]):
self.df.loadEntry(frt, pag, p+n, data=d)
def doTyp(self, frt, pag, r, c, p, i, w):
self.typ = w
if self.typ != "C":
self.cno = 0
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+2, data="N")
return "sk2"
return "sk1"
def doCus(self, frt, pag, r, c, p, i, w):
cn = self.sql.getRec("genrpc", where=[("glc_cono", "=",
self.opts["conum"]), ("glc_cusno", "=", w)], limit=1)
if not cn:
return "Invalid Custom Report Number"
self.cno = w
if not self.coys:
self.con = "N"
self.df.loadEntry(frt, pag, p+1, data="N")
return "sk1"
def doCon(self, frt, pag, r, c, p, i, w):
self.con = w
def doRep(self, frt, pag, r, c, p, i, w):
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("(", "glr_cono", "=", 0, "or", "glr_cono", "=",
self.opts["conum"], ")"), ("glr_repno", "=", w)], limit=1)
if not rp:
return "No Such Report"
self.rep = w
def doGen(self, frt, pag, r, c, p, i, w):
if w == "Y":
c = 0
else:
c = self.opts["conum"]
rp = self.sql.getRec("genrpt", cols=["glr_cono", "glr_repno"],
where=[("glr_cono", "=", c), ("glr_repno", "=", self.rep)],
limit=1)
if not rp:
return "No Such Report"
self.gen = w
def doContent(self, frt, pag, r, c, p, i, w):
if w in ("B", "C", "X") and self.typ in ("S", "L", "C"):
return "Invalid Choice for this Report Type"
if w == "D":
return
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def doCod(self, frt, pag, r, c, p, i, w):
d = self.sql.getRec("gendtm", cols=["gdm_desc"],
where=[("gdm_cono", "=", self.opts["conum"]), ("gdm_code", "=",
w)], limit=1)
if not d:
return "Invalid Detail Code"
def doVar(self, frt, pag, r, c, p, i, w):
if self.typ == "C" and w not in ("B", "P"):
return "Invalid Variance, Only B or P"
def doPrt(self, frt, pag, r, c, p, i, w):
if w == "Export":
self.df.loadEntry(frt, pag, p+1, data="")
return "sk1"
def endTops(self):
if self.new == "y":
self.df.focusField("C", 0, 1)
else:
self.doLoadLines()
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 doSelTyp(self, frt, pag, r, c, p, i, w):
self.newlin = "n"
self.seq = w[0]
self.typ = w[1]
self.cno = w[2]
self.con = w[3]
self.rep = w[4]
self.gen = w[5]
for x, d in enumerate(w):
self.df.loadEntry(frt, pag, p+x, data=d)
self.df.focusField(frt, pag, c+1)
def doDelLin(self):
if self.newlin == "y":
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm), ("gls_seq", "=", self.seq)])
self.doReSeq()
def endData(self):
data = [self.opts["conum"], self.strm, self.desc, self.seq, self.typ,
self.cno, self.con, self.rep, self.gen]
for x in range(6, 14):
data.append(self.df.c_work[self.df.pag][self.df.row][x])
if self.newlin == "y":
self.sql.insRec("genstr", data=data)
elif data != self.old[:len(data)]:
col = self.sql.genstr_col
data.append(self.old[col.index("gls_xflag")])
self.sql.updRec("genstr", data=data, where=[("gls_cono",
"=", self.opts["conum"]), ("gls_strm", "=", self.strm),
("gls_seq", "=", self.seq)])
self.doLoadLines()
def exitData(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doReSeq(self):
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
if not recs:
self.newlin = "y"
self.df.focusField("C", 0, 1)
return
self.sql.delRec("genstr", where=[("gls_cono", "=", self.opts["conum"]),
("gls_strm", "=", self.strm)])
for seq, acc in enumerate(recs):
acc[3] = seq
self.sql.insRec("genstr", data=acc)
self.doLoadLines()
def doLoadLines(self):
self.df.clearFrame("C", 0)
pos = 0
recs = self.sql.getRec("genstr", where=[("gls_cono", "=",
self.opts["conum"]), ("gls_strm", "=", self.strm)],
order="gls_seq")
for row, rec in enumerate(recs):
for num, dat in enumerate(rec[3:-1]):
self.df.loadEntry("C", 0, pos, data=dat)
pos += 1
if pos == (self.df.rows[0] * self.df.colq[0]):
self.df.scrollScreen(0)
pos = pos - self.df.colq[0]
pos += 1
self.df.focusField("C", 0, pos)
class bs1010(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"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
tabs = ["bksmst", "bksown", "bksaut", "chglog"]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
return True
def mainProcess(self):
bmf = {
"stype":
"R",
"tables": ("bksmst", "bksown"),
"cols":
(("bmf_stat", "", 0, "S"), ("bmf_code", "", 0, "Code"),
("bmf_titl", "", 0, "Title", "Y"), ("bmf_ownr", "", 0, "Ownr"),
("bof_fnam", "", 0, "Name"), ("bmf_mnth", "", 0, "Mth-Rec")),
"where": [("bmf_cono", "=", self.opts["conum"]),
("bof_cono=bmf_cono", ), ("bof_code=bmf_ownr", )],
"order":
"bmf_stat, bmf_titl",
"index":
1
}
amf = {
"stype":
"R",
"tables": ("bksaut", ),
"cols":
(("baf_code", "", 0, "Code"), ("baf_snam", "", 0, "Surname", "Y"),
("baf_fnam", "", 0, "Names")),
"order":
"baf_code"
}
omf = {
"stype":
"R",
"tables": ("bksown", ),
"cols":
(("bof_code", "", 0, "Code"), ("bof_snam", "", 0, "Surname", "Y"),
("bof_fnam", "", 0, "Names")),
"where": [("bof_cono", "=", self.opts["conum"])],
"order":
"bof_code"
}
r1s = (("Current", "C"), ("Removed", "X"))
fld = ((("T", 0, 0,
0), "IUI", 4, "Code", "", "", "Y", self.doCode, bmf, None,
("efld", )), (("T", 0, 1, 0), "ITX", 30, "Title", "", "", "N",
self.doTitle, None, None, ("notblank", )),
(("T", 0, 2, 0), "IUI", 4, "Author", "", "", "N", self.doAuthor,
amf, None, ("efld", )), (("T", 0, 2, 0), "ONA", 30, ""),
(("T", 0, 3, 0), "IUI", 4, "Owner", "", "", "N", self.doOwner,
omf, None, ("efld", )), (("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4,
0), "ID2", 7, "Month", "", "", "N", self.doMonth, None, None,
("efld", )), (("T", 0, 5, 0), ("IRB", r1s), 0, "Status", "",
"C", "N", self.doStatus, None, None, None))
but = (("Accept", None, self.doAccept, 0, ("T", 0, 2),
(("T", 0, 0), ("T", 0, 1))), ("Exit", None, self.doExit, 0,
("T", 0, 1), 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.bcode = w
if not self.bcode:
ok = askQuestion(self.opts["mf"].body,
"New Book",
"Is This a New Book?",
default="no")
if ok == "no":
return "Invalid Code"
self.newbk = True
self.bcode = getNextCode(self.sql,
"bksmst",
"bmf_code",
start=1,
last=9999)
self.df.loadEntry(frt, pag, p, data=self.bcode)
else:
self.old = self.sql.getRec("bksmst",
where=[("bmf_cono", "=",
self.opts["conum"]),
("bmf_code", "=", self.bcode)],
limit=1)
if not self.old:
ok = askQuestion(self.opts["mf"].body,
"Code",
"Is This a Manual Code?",
default="no")
if ok == "no":
return "Invalid Code"
self.newbk = True
return
col = 0
self.newbk = False
for num, dat in enumerate(self.old[1:-1]):
self.df.loadEntry(frt, pag, col, data=dat)
if num == 2:
col += 1
self.df.loadEntry(frt, pag, col, data=self.getAuthor(dat))
elif num == 3:
col += 1
self.df.loadEntry(frt, pag, col, data=self.getOwner(dat))
col += 1
def doDelete(self):
self.sql.delRec("bksmst",
where=[("bmf_cono", "=", self.opts["conum"]),
("bmf_code", "=", self.bcode)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doTitle(self, frt, pag, r, c, p, i, w):
self.title = w
def doAuthor(self, frt, pag, r, c, p, i, w):
self.acode = w
if not self.acode:
ok = askQuestion(self.opts["mf"].body,
"New Author",
"Is This a New Author?",
default="no")
if ok == "no":
return "Invalid Code"
self.doNewAuthor()
if not self.aend:
return "rf"
self.df.loadEntry(frt, pag, p, data=self.acode)
acc = self.sql.getRec("bksaut",
where=[("baf_code", "=", self.acode)],
limit=1)
if not acc:
return "Invalid Code"
self.df.loadEntry(frt, pag, p + 1, data=self.getAuthor(self.acode))
def doNewAuthor(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Author's Details", )
fld = ((("T", 0, 0, 0), "ITX", 30, "Surname", "", "", "Y", None, None,
None, ("notblank", )), (("T", 0, 1, 0), "ITX", 30, "Names", "",
"", "Y", None, None, None, ("efld", )))
self.aa = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doAutEnd, "y"), ),
txit=(self.doAutExit, ))
self.aa.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doAutEnd(self):
self.aend = True
self.acode = getNextCode(self.sql,
"bksaut",
"baf_code",
start=1,
last=9999)
data = [self.acode, self.aa.t_work[0][0][0], self.aa.t_work[0][0][1]]
self.sql.insRec("bksaut", data=data)
self.aa.closeProcess()
def doAutExit(self):
self.aend = False
self.aa.closeProcess()
def getAuthor(self, code):
acc = self.sql.getRec("bksaut",
where=[("baf_code", "=", code)],
limit=1)
if acc:
return "%s, %s" % (acc[1], acc[2])
else:
return ""
def doOwner(self, frt, pag, r, c, p, i, w):
self.ocode = w
if not self.ocode:
ok = askQuestion(self.opts["mf"].body,
"New Member",
"Is This a New Member?",
default="no")
if ok == "no":
return "Invalid Code"
self.doNewOwner()
if not self.oend:
return "rf"
self.df.loadEntry(frt, pag, p, data=self.ocode)
acc = self.sql.getRec("bksown",
where=[("bof_cono", "=", self.opts["conum"]),
("bof_code", "=", self.ocode)],
limit=1)
if not acc:
return "Invalid Code"
self.df.loadEntry(frt, pag, p + 1, data=self.getOwner(self.ocode))
def doNewOwner(self):
state = self.df.disableButtonsTags()
self.df.setWidget(self.df.mstFrame, state="hide")
tit = ("Owner's Details", )
fld = ((("T", 0, 0, 0), "ITX", 30, "Surname", "", "", "Y", None, None,
None, ("notblank", )), (("T", 0, 1, 0), "ITX", 30, "Names", "",
"", "Y", None, None, None, ("efld", )))
self.oo = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=((self.doOwnEnd, "y"), ),
txit=(self.doOwnExit, ))
self.oo.mstFrame.wait_window()
self.df.setWidget(self.df.mstFrame, state="show")
self.df.enableButtonsTags(state=state)
def doOwnEnd(self):
self.oend = True
self.ocode = getNextCode(self.sql,
"bksown",
"bof_code",
start=1,
last=9999)
data = [
self.opts["conum"], self.acode, self.oo.t_work[0][0][0],
self.oo.t_work[0][0][1], "", "", "", "", "", "", "", ""
]
self.sql.insRec("bksown", data=data)
self.oo.closeProcess()
def doOwnExit(self):
self.oend = False
self.oo.closeProcess()
def getOwner(self, code):
acc = self.sql.getRec("bksown",
where=[("bof_cono", "=", self.opts["conum"]),
("bof_code", "=", code)],
limit=1)
if acc:
return "%s, %s" % (acc[2], acc[3])
else:
return ""
def doMonth(self, frt, pag, r, c, p, i, w):
self.month = w
def doStatus(self, frt, pag, r, c, p, i, w):
self.status = w
def doEnd(self):
data = [self.opts["conum"]]
for num, dat in enumerate(self.df.t_work[0][0]):
if num in (3, 5):
continue
data.append(dat)
if self.newbk:
self.sql.insRec("bksmst", data=data)
elif data != self.old[:len(data)]:
col = self.sql.bksmst_col
data.append(self.old[col.index("bmf_xflag")])
self.sql.updRec("bksmst",
data=data,
where=[("bmf_cono", "=", self.opts["conum"]),
("bmf_code", "=", self.bcode)])
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=[
"bksmst", "U",
"%03i%04i" % (self.opts["conum"], self.bcode),
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 doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class rt1010(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):
self.sql = Sql(
self.opts["mf"].dbm,
["ctlmst", "rtlprm", "rtlmst", "rtlcon", "rtltrn", "chglog"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
return True
def mainProcess(self):
prm = {
"stype":
"R",
"tables": ("rtlprm", ),
"cols": (("rtp_code", "", 0, "Prm-Code"), ("rtp_desc", "", 0,
"Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]
}
acc = {
"stype":
"R",
"tables": ("rtlmst", ),
"cols":
(("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")),
"where": [("rtm_cono", "=", self.opts["conum"])],
"whera": (("T", "rtm_code", 0, 0), )
}
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "A"))
r2s = (("Current", "C"), ("Expired", "X"))
self.fld = ((("T", 0, 0, 0), "INA", 7, "Premises Code", "", "", "Y",
self.doPremises, prm, None, ("notblank", )),
(("T", 0, 1, 0), "INA", 7, "Account Code", "", "", "N",
self.doAccount, acc, None, ("notblank", )),
(("T", 0, 2, 0), "INA", 30, "Tenant Name", "", "", "N",
None, None, self.doDelete, ("notblank", )),
(("T", 0, 3, 0), "INA", 30, "Address Line 1", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 4, 0), "INA", 30, "Address Line 2",
"", "", "N", None, None, None, ("efld", )),
(("T", 0, 5, 0), "INA", 30, "Address Line 3", "", "", "N",
None, None, None,
("efld", )), (("T", 0, 6, 0), "INA", 4, "Postal Code", "",
"", "N", None, None, None, ("efld", )),
(("T", 0, 7, 0), "INA", 20, "Telephone Number", "", "",
"N", None, None, None,
("efld", )), (("T", 0, 8, 0), "ITX", 50, "E-Mail Address",
"", "", "N", None, None, None, ("email", )),
(("T", 0, 9, 0), "IUA", 1, "VAT Indicator", "", self.taxdf,
"N", None, None, None,
("notblank", )), (("T", 0, 10, 0), "INA", 10,
"VAT Number", "", "", "N",
self.doVatNum, None, None, ("efld", )),
(("T", 0, 11, 0), ("IRB", r1s), 0, "Payment Frequency", "",
"M", "N", None, None, None,
None), (("T", 0, 12, 0), "ID1", 10, "Start Date", "", "",
"N", self.doStart, None, None,
("notzero", )), (("T", 0, 13, 0), "IUI", 3,
"Number of Periods", "", "", "N",
None, None, None, ("notzero", )),
(("T", 0, 14, 0), "IUD", 12.2, "Rental Amount", "", "",
"N", self.doAmount, None, None,
("notzero", )), (("T", 0, 15,
0), ("IRB", r2s), 0, "Status", "", "",
"N", None, None, None, 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)
if "args" in self.opts:
self.df.doKeyPressed("T", 0, 0, data=self.opts["args"][0])
self.df.doKeyPressed("T", 0, 1, data=self.opts["args"][1])
def doPremises(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlprm",
cols=["rtp_desc"],
where=[("rtp_cono", "=", self.opts["conum"]),
("rtp_code", "=", w)],
limit=1)
if not acc:
return "Invalid Premises"
self.code = w
col = ["rtc_payind", "rtc_start", "rtc_period"]
whr = [("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code), ("rtc_status", "=", "C")]
chk = self.sql.getRec("rtlcon",
cols=col,
where=whr,
order="rtc_start desc")
if not chk:
self.end = 0
return
freq, start, period = chk[0]
if freq == "M":
self.end = CCD(projectDate(start, period, "months"), "D1", 10)
elif freq == "3":
self.end = CCD(projectDate(start, period * 3, "months"), "D1", 10)
elif freq == "6":
self.end = CCD(projectDate(start, period * 6, "months"), "D1", 10)
else:
self.end = CCD(projectDate(start, period, "years"), "D1", 10)
def doAccount(self, frt, pag, r, c, p, i, w):
self.acno = w
self.oldm = self.sql.getRec("rtlmst",
where=[("rtm_cono", "=",
self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", self.acno)],
limit=1)
if not self.oldm:
self.new = "y"
for num in range(2, self.df.topq[0]):
self.df.clearEntry(frt, pag, num + 1)
con = self.sql.getRec("rtlcon",
cols=["count(*)"],
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)],
limit=1)
if not con[0]:
self.cnum = 1
else:
self.cnum = con[0] + 1
else:
self.new = "n"
for num, fld in enumerate(self.oldm[2:]):
self.df.loadEntry(frt, pag, p + num, data=fld)
self.oldc = self.sql.getRec("rtlcon",
where=[("rtc_cono", "=",
self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)],
order="rtc_cnum")
self.cnum = self.oldc[-1:][0][3]
for num, fld in enumerate(self.oldc[-1:][0][4:-1]):
self.df.loadEntry(frt, pag, num + 11, data=fld)
trn = self.sql.getRec("rtltrn",
cols=["count(*)"],
where=[("rtt_cono", "=", self.opts["conum"]),
("rtt_code", "=", self.code),
("rtt_acno", "=", self.acno)],
limit=1)
if trn[0]:
self.trn = True
else:
self.trn = False
def doVatNum(self, frt, pag, r, c, p, i, w):
if self.new == "n" and self.trn:
return "sk1"
def doStart(self, frt, pag, r, c, p, i, w):
if self.new == "y" and self.end and w < self.end.work:
return "Premises Already Let till %s" % self.end.disp
def doAmount(self, frt, pag, r, c, p, i, w):
if self.new == "y":
self.df.loadEntry(frt, pag, p + 1, data="C")
def doDelete(self):
if self.trn:
return "Transactions Exist, Not Deleted"
self.sql.delRec("rtlmst",
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", self.acno)])
self.sql.delRec("rtlcon",
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)])
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
self.sql.insRec("chglog",
data=[
"rtlmst", "D",
"%03i%-7s" % (self.opts["conum"], self.code), "",
dte, self.opts["capnm"], "", "", 0
])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
datm = [self.opts["conum"]]
datc = [self.opts["conum"], self.code, self.acno, self.cnum]
for num, fld in enumerate(self.df.t_work[0][0]):
if num < 11:
datm.append(fld)
if num > 10:
datc.append(fld)
if self.new == "y":
self.sql.insRec("rtlmst", data=datm)
self.sql.insRec("rtlcon", data=datc)
else:
dte = int("%04i%02i%02i%02i%02i%02i" % time.localtime()[:-3])
if datm != self.oldm[:len(datm)]:
col = self.sql.rtlmst_col
datm.append(self.oldm[col.index("rtm_xflag")])
self.sql.updRec("rtlmst",
data=datm,
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", self.acno)])
for num, dat in enumerate(self.oldm):
if dat != datm[num]:
self.sql.insRec(
"chglog",
data=[
"rtlmst", "U",
"%03i%-7s" % (self.opts["conum"], self.code),
col[num], dte, self.opts["capnm"],
str(dat),
str(datm[num]), "", 0
])
if datc != self.oldc[-1:][0][:len(datc)]:
col = self.sql.rtlcon_col
datc.append(self.oldc[col.index("rtc_xflag")])
self.sql.updRec("rtlcon",
data=datc,
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno),
("rtc_cnum", "=", self.cnum)])
for num, dat in enumerate(self.oldc[-1:][0]):
if dat != datc[num]:
self.sql.insRec("chglog",
data=[
"rtlcon", "U",
"%03i%-7s%-7s%03i" %
(self.opts["conum"], self.code,
self.acno, self.cnum), col[num],
dte, self.opts["capnm"],
str(dat),
str(datc[num]), "", 0
])
if "args" in self.opts:
self.doExit()
else:
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()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
class ms1020(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,
["ctlsys", "ctlmst", "ctldep", "genmst", "wagmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctlsys = gc.getCtl("ctlsys")
if not ctlsys:
return
dept = ctlsys["sys_gl_dep"]
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.glint = "N"
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
if ctlmst["ctm_modules"][x:x + 2] in ("SL", "WG"):
dept = "Y"
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
self.glint = "N"
else:
self.glint = wagctl["ctw_glint"]
break
if dept == "N":
showError(self.opts["mf"].body, "Error",
"Departments have Not been Enabled")
return
if self.glint == "N":
self.co1 = 0
self.sy1 = 0
self.cm1 = 0
self.co2 = 0
self.sy2 = 0
self.cm2 = 0
else:
self.coys = self.sql.getRec("ctlmst", cols=["count(*)"],
limit=1)[0]
return True
def mainProcess(self):
dep = {
"stype": "R",
"tables": ("ctldep", ),
"cols":
(("dep_code", "", 0, "Cod"), ("dep_name", "", 0, "Name", "Y")),
"where": [("dep_cono", "=", self.opts["conum"])]
}
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")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
self.fld = [(("T", 0, 0, 0), "IUI", 3, "Department", "Department Code",
"", "N", self.doDepartment, dep, None, ("notzero", )),
(("T", 0, 1, 0), "INA", 30, "Name", "", "", "N",
self.doName, None, self.doDelete, ("notblank", ))]
if self.glint == "Y":
if self.coys == 1:
self.fld.append((("T", 0, 2, 0), "OUI", 7, "Debit Company"))
else:
self.fld.append(
(("T", 0, 2, 0), "IUI", 7, "Debit Company", "",
self.opts["conum"], "N", self.doCoy, coy, None, None))
self.fld.append((("T", 0, 2, 0), "ONA", 30, ""))
self.fld.extend([
(("T", 0, 3, 0), "IUI", 7, " Salary A/C", "", "", "N",
self.doSal, glm, None, ("notzero", )),
(("T", 0, 3, 0), "ONA", 30, ""),
(("T", 0, 4, 0), "IUI", 7, " Commission A/C", "", "",
"N", self.doCom, glm, None, ("efld", )),
(("T", 0, 4, 0), "ONA", 30, "")
])
if self.coys == 1:
self.fld.append((("T", 0, 5, 0), "OUI", 7, "Credit Company"))
else:
self.fld.append(
(("T", 0, 5, 0), "IUI", 7, "Credit Company", "",
self.opts["conum"], "N", self.doCoy, coy, None, None))
self.fld.append((("T", 0, 5, 0), "ONA", 30, ""))
self.fld.extend([
(("T", 0, 6, 0), "IUI", 7, " Salary A/C", "", "", "N",
self.doSal, glm, None, ("notzero", )),
(("T", 0, 6, 0), "ONA", 30, ""),
(("T", 0, 7, 0), "IUI", 7, " Commission A/C", "", "",
"N", self.doCom, glm, None, ("efld", )),
(("T", 0, 7, 0), "ONA", 30, "")
])
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 doDepartment(self, frt, pag, r, c, p, i, w):
self.code = w
self.old = self.sql.getRec("ctldep",
where=[("dep_cono", "=",
self.opts["conum"]),
("dep_code", "=", self.code)],
limit=1)
if not self.old:
self.new = "Y"
else:
self.new = "N"
self.doLoadRec(self.old)
def doLoadRec(self, rec):
if not rec:
self.df.clearFrame("T", 0)
self.df.loadEntry("T", 0, 0, data=self.code)
return
for num, dat in enumerate(rec[2:-1]):
if num == 0:
seq = 1
self.df.loadEntry("T", 0, seq, data=dat)
if self.glint == "N":
return
seq += 1
elif num in (1, 4):
coy = dat
if not coy:
dat = ""
else:
nam = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", coy)],
limit=1)
self.df.loadEntry("T", 0, seq, data=coy)
self.df.loadEntry("T", 0, seq + 1, data=nam[0])
seq += 2
elif num in (2, 3, 5, 6):
if dat:
dsc = self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", coy),
("glm_acno", "=", dat)],
limit=1)
else:
dsc = [""]
self.df.loadEntry("T", 0, seq, data=dat)
self.df.loadEntry("T", 0, seq + 1, data=dsc[0])
seq += 2
def doName(self, frt, pag, r, c, p, i, w):
self.name = w
if self.glint == "Y" and self.coys == 1:
self.co1 = self.opts["conum"]
self.co2 = self.opts["conum"]
self.df.loadEntry(frt, pag, p + 1, data=self.opts["conum"])
self.df.loadEntry(frt, pag, p + 2, data=self.opts["conam"])
return "sk2"
def doCoy(self, frt, pag, r, c, p, i, w):
coy = self.sql.getRec("ctlmst",
cols=["ctm_name "],
where=[("ctm_cono", "=", w)],
limit=1)
if not coy:
return "Invalid Company Number"
if p == 2:
self.co1 = w
else:
self.co2 = w
self.df.loadEntry(frt, pag, p + 1, coy[0])
def doSal(self, frt, pag, r, c, p, i, w):
if p == 4:
co = self.co1
else:
co = self.co2
chk = chkGenAcc(self.opts["mf"], co, w)
if type(chk) is str:
return chk
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
def doCom(self, frt, pag, r, c, p, i, w):
if w:
if p == 6:
co = self.co1
else:
co = self.co2
chk = chkGenAcc(self.opts["mf"], co, w)
if type(chk) is str:
return chk
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if p == 6 and self.coys == 1:
self.df.loadEntry(frt, pag, p + 2, data=self.opts["conum"])
self.df.loadEntry(frt, pag, p + 3, data=self.opts["conam"])
return "sk2"
def doDelete(self):
if self.glint == "Y":
chk = self.sql.getRec("wagmst",
where=[("wgm_dept", "=", self.code)])
if chk:
return "Department is in Use, Not Deleted"
self.sql.delRec("ctldep",
where=[("dep_cono", "=", self.opts["conum"]),
("dep_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEnd(self):
data = [self.opts["conum"]]
for num, dat in enumerate(self.df.t_work[0][0]):
if num in (3, 5, 7, 9, 11, 13):
continue
data.append(dat)
if self.glint == "N":
data.extend([0, 0, 0, 0, 0, 0])
if self.new == "Y":
self.sql.insRec("ctldep", data=data)
elif data != self.old[:len(data)]:
col = self.sql.ctldep_col
data.append(self.old[col.index("dep_xflag")])
self.sql.updRec("ctldep",
data=data,
where=[("dep_cono", "=", self.opts["conum"]),
("dep_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 st5040(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,
["gentrn", "strmf1", "strtrn", "strvar", "strprc"],
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.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["stk_soh", "stk_susp"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.stk_soh = ctlctl["stk_soh"]
self.stk_susp = ctlctl["stk_susp"]
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, "Merging Date", "", self.sysdtw,
"N", self.doDate, None, None, ("efld", ))]
tnd = ((self.endPage, "y"), )
txt = (self.exitPage, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt)
def doDate(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.date = w
self.curdt = int(w / 100)
def endPage(self):
self.df.closeProcess()
col = [
"stv_group", "stv_code", "stv_loc", "stv_bin", "stv_qty",
"stv_ucost", "stv_usell"
]
recs = self.sql.getRec(tables=["strmf1", "strvar"],
cols=col,
where=[("stv_cono", "=", self.opts["conum"]),
("stv_cono=st1_cono", ),
("stv_group=st1_group", ),
("stv_code=st1_code", )],
order="stv_group, stv_code, stv_loc")
if not recs:
showError(self.opts["mf"].body, "Processing Error",
"No Records Selected")
else:
p = ProgressBar(self.opts["mf"].body, typ="F", mxs=len(recs))
for num, dat in enumerate(recs):
p.displayProgress(num)
self.updateTables(num + 1, col, dat)
self.sql.delRec(
"strvar",
where=[("stv_cono", "=", self.opts["conum"]),
("stv_group", "=", dat[col.index("stv_group")]),
("stv_code", "=", dat[col.index("stv_code")]),
("stv_loc", "=", dat[col.index("stv_loc")])])
self.opts["mf"].dbm.commitDbase()
p.closeProgress()
self.opts["mf"].closeLoop()
def exitPage(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def updateTables(self, cnt, col, rec):
grp = rec[col.index("stv_group")]
code = rec[col.index("stv_code")]
loc = rec[col.index("stv_loc")]
vqty = CCD(rec[col.index("stv_qty")], "SD", 12.2)
vprc = CCD(rec[col.index("stv_ucost")], "UD", 12.2)
sell = CCD(rec[col.index("stv_usell")], "UD", 12.2)
# Selling Price Records
if sell.work:
whr = [("stp_cono", "=", self.opts["conum"]),
("stp_group", "=", grp), ("stp_code", "=", code),
("stp_loc", "=", loc), ("stp_level", "=", 1)]
self.sql.delRec("strprc", where=whr)
self.sql.insRec(
"strprc",
data=[self.opts["conum"], grp, code, loc, 1, sell.work])
# Test for Variances
bals = Balances(self.opts["mf"],
"STR",
self.opts["conum"],
self.curdt,
keys=(grp, code, loc, ("P", self.opts["period"][0])))
m_ob, m_mv, m_cb, y_ob, y_mv, y_cb, ac, lc, ls = bals.doStrBals()
fqty = CCD(y_cb[0], "SD", 12.2)
fval = CCD(y_cb[1], "SD", 12.2)
if fval.work and fqty.work:
c = round((fval.work / fqty.work), 2)
else:
c = 0
fprc = CCD(c, "SD", 12.2)
if fprc.work != vprc.work and vprc.work:
prc = vprc.work
else:
prc = fprc.work
prc = CCD(prc, "SD", 12.2)
val = round((prc.work * vqty.work), 2)
vval = CCD(val, "SD", 12.2)
qdif = CCD(float(ASD(vqty.work) - ASD(fqty.work)), "SD", 12.2)
vdif = CCD(float(ASD(vval.work) - ASD(fval.work)), "SD", 12.2)
if not qdif.work and not vdif.work:
return
# Stores Ledger Transaction
if qdif.work >= 0:
rtn = 5
else:
rtn = 6
ref = CCD(cnt, "Na", 9).work
self.sql.insRec("strtrn",
data=[
self.opts["conum"], rec[col.index("stv_group")],
rec[col.index("stv_code")],
rec[col.index("stv_loc")], self.date, rtn, ref,
"ST-MERG", "", qdif.work, vdif.work, 0, self.curdt,
"Stock Take Adjustment", 0, "", "", "STR", 0, "",
self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Control Transaction (Stock On Hand)
col = self.sql.gentrn_col
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.stk_soh),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.date),
("glt_type", "=", 4),
("glt_refno", "=", "STOCK-ADJ"),
("glt_batch", "=", "ST-MERG")],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(vdif.work))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.stk_soh, self.curdt,
self.date, 4, "STOCK-ADJ", "ST-MERG",
vdif.work, 0, "Stock Take Adjustment", "N", "",
0, self.opts["capnm"], self.sysdtw, 0
])
# General Ledger Control Transaction (Stock Suspense)
val = float(ASD(0) - ASD(vdif.work))
acc = self.sql.getRec("gentrn",
where=[("glt_cono", "=", self.opts["conum"]),
("glt_acno", "=", self.stk_susp),
("glt_curdt", "=", self.curdt),
("glt_trdt", "=", self.date),
("glt_type", "=", 4),
("glt_refno", "=", "STOCK-ADJ"),
("glt_batch", "=", "ST-MERG")],
limit=1)
if acc:
amnt = float(ASD(acc[col.index("glt_tramt")]) + ASD(val))
self.sql.updRec("gentrn",
cols=["glt_tramt"],
data=[amnt],
where=[("glt_seq", "=", acc[col.index("glt_seq")])
])
else:
self.sql.insRec("gentrn",
data=[
self.opts["conum"], self.stk_susp, self.curdt,
self.date, 4, "STOCK-ADJ", "ST-MERG", val, 0,
"Stock Take Adjustment", "N", "", 0,
self.opts["capnm"], self.sysdtw, 0
])
class sc2030(object):
def __init__(self, **opts):
self.opts = opts
if "test" not in opts:
self.opts["test"] = None
if self.setVariables():
if self.opts["test"]:
self.doImport()
else:
self.mainProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["scpcmp", "scpmem", "scpent", "scpgme"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.pair = 0
self.doimport = False
return True
def mainProcess(self):
com = {
"stype":
"R",
"tables": ("scpcmp", ),
"cols":
(("scp_ccod", "", 0, "CCD"), ("scp_name", "", 0, "Name", "Y"),
("scp_tsiz", "", 0, "S"), ("scp_fmat", "", 0, "F"),
("scp_nsec", "", 0, "NS"), ("scp_nent", "", 0, "NE")),
"where": [("scp_cono", "=", self.opts["conum"])]
}
self.sec = {
"stype": "C",
"titl": "Available Sections",
"head": ("Sec", "Club"),
"typs": (("Ua", 3), ("NA", 30)),
"data": []
}
self.skp = {
"stype":
"R",
"tables": ("scpmem", "scpgme"),
"cols": (("a", "UI", 6, "S-Code"), ("b", "NA", 30, "Name", "Y"),
("c", "UI", 6, "O-Code"), ("d", "NA", 30, "Name"),
("e", "UI", 3, "For"), ("f", "UI", 3, "Agt")),
"where": [],
"wtype":
"D"
}
tag = (("Results", None, ("T", 0, 0), ("T", 0, 1)), )
r1s = (("Main", "M"), ("Play-Offs", "P"))
fld = ((("T", 0, 0,
0), "I@scp_ccod", 0, "", "", "", "Y", self.doCmpCod, com,
None, ("notzero", )), (("T", 0, 0, 0), "O@scp_name", 0, ""),
(("T", 0, 1,
0), ("IRB", r1s), 0, "Type", "", "", "N", self.doCmpTyp, None,
None, None), (("T", 0, 2, 0), "I@scg_rnum", 0, "Round", "", "",
"N", self.doRndNum, None, None, ("notzero", )),
(("T", 1, 0, 0), "IUI", 2, "Section Number", "", "", "N",
self.doSecNum, None, None, ("notzero", )),
(("T", 1, 0, 0), "IUA", 1, "Sub-Section", "", "", "N",
self.doSubNum, None, None, ("in", ("A", "B"))),
(("C", 1, 0, 0), "I@scg_scod", 0, "", "", 0, "N", self.doSkpCod,
self.skp, None, ("notzero", )), (("C", 1, 0, 0), "ONA", 30,
"Skp-Name"),
(("C", 1, 0, 0), "I@scg_sfor", 0, "", "", "", "N", self.doShots,
None, None, ("efld", )), (("C", 1, 0, 0), "I@scg_ocod", 0, "",
"", 0, "N", self.doSkpCod, self.skp,
None, ("notzero", )),
(("C", 1, 0, 0), "ONA", 30,
"Opp-Name"), (("C", 1, 0, 0), "I@scg_sagt", 0, "", "", "", "N",
self.doShots, None, None, ("efld", )))
tnd = ((self.doTopEnd, "y"), (self.doTopEnd, "n"))
txt = (self.doTopExit, self.doTopExit)
cnd = (None, (self.doColEnd, "n"))
cxt = (None, self.doColExit)
but = (("Import Results", None, self.doImport, 0, ("T", 1, 1),
(("T", 1, 2), ("T", 1, 0))),
("Show Entries", None, self.doShow, 0, ("C", 1, 1), ("C", 1,
2)))
self.df = TartanDialog(self.opts["mf"],
tags=tag,
eflds=fld,
rows=(0, 16),
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
def doCmpCod(self, frt, pag, r, c, p, i, w):
com = self.sql.getRec("scpcmp",
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", w)],
limit=1)
if not com:
return "Invalid Competition Code"
if not com[2]:
return "Competiton Draw Not Yet Done"
chk = self.sql.getRec("scpent",
cols=["count(*)"],
where=[("sce_cono", "=", self.opts["conum"]),
("sce_ccod", "=", w)],
limit=1)
if not chk[0]:
return "There are No Entries for this Competition"
self.ccod = w
self.name = com[self.sql.scpcmp_col.index("scp_name")]
self.fmat = com[self.sql.scpcmp_col.index("scp_fmat")]
self.nsec = com[self.sql.scpcmp_col.index("scp_nsec")]
self.nent = com[self.sql.scpcmp_col.index("scp_nent")]
self.ssub = com[self.sql.scpcmp_col.index("scp_subs")]
self.squa = com[self.sql.scpcmp_col.index("scp_qual")]
self.clup = com[self.sql.scpcmp_col.index("scp_clup")]
self.mrnds = com[self.sql.scpcmp_col.index("scp_mrnds")]
self.prnds = com[self.sql.scpcmp_col.index("scp_prnds")]
self.state = com[self.sql.scpcmp_col.index("scp_state")]
if not self.doimport:
self.df.loadEntry(frt, pag, p + 1, data=self.name)
self.byenum = 900000
if self.state < 3:
self.ctyp = "M"
self.lrnd = self.mrnds
if not self.doimport:
self.df.loadEntry(frt, pag, p + 2, data=self.ctyp)
return "sk2"
elif self.state == 6:
return "All Results Already Captured"
else:
self.ctyp = "P"
self.lrnd = self.prnds
if not self.doimport:
self.df.loadEntry(frt, pag, p + 2, data=self.ctyp)
def doCmpTyp(self, frt, pag, r, c, p, i, w):
self.ctyp = w
chk = self.sql.getRec(
"scpgme",
cols=["count(*)", "sum(scg_sfor)", "sum(scg_sagt)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "P")],
limit=1)
if self.ctyp == "M":
if chk[0] and (chk[1] or chk[2]):
return "Play-Offs Already Started"
self.lrnd = self.mrnds
elif not chk[0]:
return "Play-Offs Draw Not Yet Done"
else:
self.lrnd = self.prnds
def doRndNum(self, frt, pag, r, c, p, i, w):
if self.ctyp == "M" and self.clup == "Y" and w > 1:
more = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_rnum", "=", w - 1),
("scg_ocod", "=", 0)],
limit=1)[0]
if more:
return "Closed-Up Draw, Round %s Results Missing" % (w - 1)
if w > self.lrnd:
return "Invalid Round, Exceeds Maximum (%s)" % self.lrnd
if w > 1:
chk = self.sql.getRec("scpgme",
cols=[
"scg_scod", "scg_ocod", "sum(scg_sfor)",
"sum(scg_sagt)"
],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w - 1)])
for s in chk:
if s[0] < 900000 and s[1] < 900000 and not s[2] and not s[3]:
return "Invalid Round, Previous Round Missing"
chk = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "<", w),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("(", "scg_sfor", "=", 0, "and",
"scg_sagt", "=", 0, ")")])
if chk:
return "Previous Round Not Yet Completely Captured"
chk = self.sql.getRec("scpgme",
cols=["sum(scg_sfor)", "sum(scg_sagt)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", ">", w)],
limit=1)
if chk[0] or chk[1]:
return "Invalid Round, Later Rounds Captured"
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)])[0]
if not chk:
ok = askQuestion(self.opts["mf"].body,
"Already Entered",
"""All Results for this Round Already Captured.
Would you Like to Recapture this Round?""",
default="no")
if ok == "no":
return "Already Captured"
if self.fmat == "K" or self.ctyp == "R":
if self.ctyp == "M" and w == self.mrnds:
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "R")])
else:
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", w + 1)])
self.rnum = w
self.doimport = False
def doImport(self):
self.doimport = True
if self.opts["test"]:
self.ccod, self.rnum, impfle = self.opts["test"]
err = self.doCmpCod("T", 0, 0, 0, 0, 0, self.ccod)
if err:
print(err)
return
self.doGetOldWin()
impdlg = False
else:
impfle = None
impdlg = True
self.df.setWidget(self.df.mstFrame, state="hide")
cols = [["scg_snum", 0, "UI", 2], ["scg_subs", 1, "UA", 1],
["scg_scod", 2, "UI", 6], ["scg_ocod", 3, "UI", 6],
["scg_sfor", 4, "UI", 2], ["scg_sagt", 5, "UI", 2]]
fi = FileImport(self.opts["mf"],
impcol=cols,
impfle=impfle,
impdlg=impdlg)
if fi.impdat:
if not self.opts["test"]:
sp = ProgressBar(self.opts["mf"].body,
typ="Importing Results",
mxs=len(fi.impdat))
err = None
for num, line in enumerate(fi.impdat):
if not self.opts["test"]:
sp.displayProgress(num)
if not line[0]:
continue
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", line[0]), ("scg_subs", "=", line[1]),
("scg_rnum", "=", self.rnum)]
if self.clup == "Y":
self.newo = True
whr.append(("scg_scod", "in", (line[2], line[3])))
else:
self.newo = False
whr.append(("scg_scod", "=", line[2]))
whr.append(("scg_ocod", "=", line[3]))
chk = self.sql.getRec("scpgme", where=whr)
if not chk:
err = "Invalid Skip %s, Opponent %s" % (line[2], line[3])
break
if line[2] > 900000 or line[3] > 900000:
pass
elif not line[4] and not line[5]:
err = "Zero Results"
break
self.snum = line[0]
self.subs = line[1]
self.scod = line[2]
self.ocod = line[3]
self.sfor = line[4]
self.sagt = line[5]
self.doColEnd()
if not self.opts["test"]:
sp.closeProgress()
if err:
err = "Line %s: %s" % ((num + 1), err)
showError(
self.opts["mf"].body, "Import Error", """%s
Please Correct your Import File and then Try Again.""" % err)
self.opts["mf"].dbm.rollbackDbase()
else:
self.ierr = False
if self.ssub == "Y":
secs = int(self.nsec / 2)
else:
secs = self.nsec
for self.snum in range(1, secs + 1):
if self.ssub == "Y":
for self.subs in ("A", "B"):
self.doColExit()
if self.ierr:
break
if self.ierr:
break
else:
self.subs = ""
self.doColExit()
if self.ierr:
break
if not self.ierr:
self.opts["mf"].dbm.commitDbase()
self.doTopExit()
if not self.opts["test"]:
self.df.setWidget(self.df.mstFrame, state="show")
self.df.focusField("T", 0, 1)
def doSecNum(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", w)],
limit=1)
if not chk:
return "Invalid Section Number"
self.snum = w
if self.ssub == "N" or self.ctyp == "P":
self.subs = ""
self.df.loadEntry(frt, pag, p + 1, data=self.subs)
self.doLoadSkips()
return "sk1"
def doSubNum(self, frt, pag, r, c, p, i, w):
self.subs = w
self.doLoadSkips()
def doTopEnd(self):
if self.df.pag == 0:
if self.ctyp == "P":
self.snum = 1
self.df.loadEntry("T", 1, 0, data=self.snum)
self.subs = ""
self.df.loadEntry("T", 1, 1, data=self.subs)
self.doLoadSkips()
self.df.focusField("C", 1, 1)
else:
self.doGetOldWin()
self.df.focusField("T", 1, 1)
else:
self.df.focusField("C", 1, 1)
def doLoadSkips(self):
col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"]
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum), ("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs), ("scg_ocod", "<", 900000)]
data = []
recs = self.sql.getRec("scpgme", cols=col, where=whr)
for rec in recs:
data.append((rec[0], self.getName(rec[0]), rec[1],
self.getName(rec[1]), rec[2], rec[3]))
self.skp["where"] = data
def doTopExit(self):
if not self.opts["test"] and self.df.pag == 0:
self.df.closeProcess()
self.opts["mf"].closeLoop()
else:
# Check all entries for round
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)[0]
if chk:
txt = "Not All the Results for Round %s Captured" % self.rnum
if self.opts["test"]:
self.opts["mf"].dbm.rollbackDbase()
return
txt = "%s\n\nDo You want to Exit and Lose All Results for "\
"this Round?" % txt
ok = askQuestion(self.opts["mf"].body,
"Missing Results",
txt,
default="no")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 1, 1)
return
if self.rnum == self.lrnd:
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "M"),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)[0]
if not chk:
# Update scpcmp if no missing entries
self.sql.updRec("scpcmp",
cols=["scp_state"],
data=[3],
where=[("scp_cono", "=",
self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
self.opts["mf"].dbm.commitDbase()
if not self.doimport:
if self.ctyp == "P":
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 0, 1)
def doSkpCod(self, frt, pag, r, c, p, i, w):
skp = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", w)],
limit=1)
if not skp:
return "Invalid Skip"
if skp[self.sql.scpgme_col.index("scg_ocod")] > 900000:
return "Skip has a Bye"
if i == 3:
if w == self.scod:
return "Playing Against Himself?"
if skp[self.sql.scpgme_col.index("scg_ocod")]:
return "Already Paired"
self.ocod = w
onam = self.getName(self.ocod)
self.df.loadEntry("C", 1, p + 1, data=onam)
self.df.loadEntry("C", 1, p + 2, data=0)
return
self.scod = w
snam = self.getName(w)
self.df.loadEntry("C", 1, p + 1, data=snam)
sfor = skp[self.sql.scpgme_col.index("scg_sfor")]
self.df.loadEntry("C", 1, p + 2, data=sfor)
self.ocod = skp[self.sql.scpgme_col.index("scg_ocod")]
if self.ocod:
self.newo = False
self.df.loadEntry("C", 1, p + 3, data=self.ocod)
onam = self.getName(self.ocod)
self.df.loadEntry("C", 1, p + 4, data=onam)
ofor = skp[self.sql.scpgme_col.index("scg_sagt")]
self.df.loadEntry("C", 1, p + 5, data=ofor)
else:
self.newo = True
def getName(self, code):
if code > 900000:
return "Bye"
nam = self.sql.getRec("scpmem",
cols=["scm_surname", "scm_names"],
where=[("scm_cono", "=", self.opts["conum"]),
("scm_scod", "=", code)],
limit=1)
return "%s, %s" % (nam[0], nam[1][0])
def doShots(self, frt, pag, r, c, p, i, w):
if i == 2:
self.sfor = w
if not self.newo:
return "sk2"
else:
self.sagt = w
def doPoints(self, frt, pag, r, c, p, i, w):
pass
def doColEnd(self):
if self.fmat == "K":
if self.newo:
self.sql.delRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.ocod)])
cols = ["scg_ocod"]
data = [self.ocod]
else:
cols = []
data = []
if self.clup == "Y":
cols.extend(["scg_sfor", "scg_sagt", "scg_pair"])
self.pair += 1
data.extend([self.sfor, self.sagt, self.pair])
else:
cols.extend(["scg_sfor", "scg_sagt"])
data.extend([self.sfor, self.sagt])
self.sql.updRec("scpgme",
cols=cols,
data=data,
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.scod)])
else:
if self.sfor == self.sagt:
pfor = .5
pagt = .5
elif self.sfor > self.sagt:
pfor = 1
pagt = 0
else:
pfor = 0
pagt = 1
self.sql.updRec("scpgme",
cols=["scg_sfor", "scg_sagt", "scg_pnts"],
data=[self.sfor, self.sagt, pfor],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.scod)])
self.sql.updRec("scpgme",
cols=["scg_sfor", "scg_sagt", "scg_pnts"],
data=[self.sagt, self.sfor, pagt],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum),
("scg_scod", "=", self.ocod)])
self.scod = 0
if not self.doimport:
self.doLoadSkips()
self.df.advanceLine(1)
def doShow(self):
cols = (("scod", "Skip", 6, "UI",
"N"), ("sname", "Name", 30, "NA",
"N"), ("sfor", "Shots", 5, "UI", "N"), ("ocod", "Oppt",
6, "UI", "N"),
("oname", "Name", 30, "NA", "N"), ("sagt", "Shots", 5, "UI",
"N"))
recs = self.sql.getRec("scpgme",
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum)])
done = []
data = []
for rec in recs:
scod = rec[self.sql.scpgme_col.index("scg_scod")]
ocod = rec[self.sql.scpgme_col.index("scg_ocod")]
if scod in done or scod > 900000 or ocod in done or ocod > 900000:
continue
sfor = rec[self.sql.scpgme_col.index("scg_sfor")]
sagt = rec[self.sql.scpgme_col.index("scg_sagt")]
data.append((scod, self.getName(scod), sfor, ocod,
self.getName(ocod), sagt))
SelectChoice(self.opts["mf"].window, "Results", cols, data)
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
def doColExit(self):
chk = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("(", "scg_sfor", "=", 0, "and",
"scg_sagt", "=", 0, ")")],
limit=1)
if chk[0] and (self.clup == "N" or self.ctyp == "P" or \
(self.clup == "Y" and self.rnum > 1)):
# All results for section not yet entered
if self.doimport:
showError(self.opts["mf"].body, "Missing Results",
"Some Results are Missing, Please Check Import "\
"File and Retry")
self.opts["mf"].dbm.rollbackDbase()
self.ierr = True
return
ok = askQuestion(self.opts["mf"].body, "Missing Results",
"Some Result are Missing. Do You want to Exit and Lose "\
"the Results for this Section?")
if ok == "no":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
self.opts["mf"].dbm.rollbackDbase()
else:
chk = self.doUpdateTables()
if not self.doimport:
if chk == "continue":
self.df.focusField(self.df.frt, self.df.pag, self.df.col)
return
if chk == "abort":
self.opts["mf"].dbm.rollbackDbase()
else:
self.opts["mf"].dbm.commitDbase()
if not self.doimport:
self.df.clearFrame("T", 1)
self.df.clearFrame("C", 1)
if self.ctyp == "P":
self.df.focusField("T", 0, 4)
else:
self.df.focusField("T", 1, 1)
def doUpdateTables(self):
nrnd = self.rnum + 1
if self.fmat == "K" and self.clup == "Y" and self.ctyp == "M":
# Closed up draw (1st and maybe 2nd Round)
skps = self.sql.getRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs),
("scg_rnum", "=", self.rnum)])
byes = []
nums = {}
for skp in skps:
scod = skp[self.sql.scpgme_col.index("scg_scod")]
ocod = skp[self.sql.scpgme_col.index("scg_ocod")]
if not ocod:
byes.append(scod)
nums[scod] = skp
for skp in byes:
if self.opts["test"]:
ok = "B"
else:
ok = askChoice(self.opts["mf"].body, "Capture Error",
"The Results for Skip %s - %s is Missing. Did he/she "\
"Withdraw or have a Bye?" % (skp, self.getName(skp)),
butt=(("No", "N"), ("Withdraw", "W"), ("Bye", "B"),
("Abort", "A")), default="Bye")
if ok == "N":
return "continue"
if ok == "A":
return "abort"
if ok == "W":
self.sql.delRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_scod", "=", skp)])
byes.remove(skp)
del nums[skp]
continue
for scod in nums:
rec = nums[scod]
scod = rec[self.sql.scpgme_col.index("scg_scod")]
ocod = rec[self.sql.scpgme_col.index("scg_ocod")]
sfor = rec[self.sql.scpgme_col.index("scg_sfor")]
sagt = rec[self.sql.scpgme_col.index("scg_sagt")]
where = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_subs", "=", self.subs), ("scg_rnum", "=", nrnd),
("scg_scod", "=", scod)]
if scod in byes:
self.byenum += 1
# Create bye
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[self.byenum],
where=where)
if nrnd < self.lrnd:
# Create next round record
rec[self.sql.scpgme_col.index("scg_rnum")] = nrnd
rec[self.sql.scpgme_col.index("scg_ocod")] = 0
rec[self.sql.scpgme_col.index("scg_sfor")] = 0
rec[self.sql.scpgme_col.index("scg_sagt")] = 0
rec[self.sql.scpgme_col.index("scg_seed")] = 0
rec[self.sql.scpgme_col.index("scg_pair")] = 0
if scod not in byes and sfor < sagt and ocod:
scod = ocod
rec[self.sql.scpgme_col.index("scg_scod")] = scod
chk = self.sql.getRec("scpgme", where=where, limit=1)
if not chk:
self.sql.insRec("scpgme", data=rec)
else:
self.sql.updRec("scpgme", data=rec, where=where)
else:
# Update playoff records
cod = self.snum + 700000
if sfor > sagt:
win = scod
else:
win = ocod
whr = where[:6]
whr[2] = ("scg_ctyp", "=", "P")
whr[3] = ("scg_snum", "=", 1)
whr[5] = ("scg_rnum", "=", 1)
whr.append(("scg_scod", "=", cod))
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win],
where=whr)
whr[6] = ("scg_ocod", "=", cod)
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win],
where=whr)
if (self.fmat == "K" and self.clup == "N") or self.ctyp == "P":
recs = self.sql.getRec("scpgme",
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum),
("scg_rnum", "=", self.rnum)],
order="scg_group, scg_pair")
group = 0
for num in range(0, len(recs), 2):
one = recs[num]
snum = one[self.sql.scpgme_col.index("scg_snum")]
subs = one[self.sql.scpgme_col.index("scg_subs")]
if group != one[self.sql.scpgme_col.index("scg_group")]:
group = one[self.sql.scpgme_col.index("scg_group")]
pair = 1
else:
pair += 1
cod1 = one[self.sql.scpgme_col.index("scg_scod")]
opp1 = one[self.sql.scpgme_col.index("scg_ocod")]
for1 = one[self.sql.scpgme_col.index("scg_sfor")]
agt1 = one[self.sql.scpgme_col.index("scg_sagt")]
if opp1 > 900000 or for1 > agt1:
win1 = cod1
else:
win1 = opp1
if len(recs[num:]) > 1:
two = recs[num + 1]
cod2 = two[self.sql.scpgme_col.index("scg_scod")]
opp2 = two[self.sql.scpgme_col.index("scg_ocod")]
for2 = two[self.sql.scpgme_col.index("scg_sfor")]
agt2 = two[self.sql.scpgme_col.index("scg_sagt")]
if opp2 > 900000 or for2 > agt2:
win2 = cod2
else:
win2 = opp2
else:
win2 = 0
# Create next round record
sgc = self.sql.scpgme_col
whr = [("scg_cono", "=", one[sgc.index("scg_cono")]),
("scg_ccod", "=", one[sgc.index("scg_ccod")]),
("scg_ctyp", "=", one[sgc.index("scg_ctyp")]),
("scg_snum", "=", one[sgc.index("scg_snum")]),
("scg_subs", "=", one[sgc.index("scg_subs")]),
("scg_rnum", "=", nrnd),
("scg_ktyp", "=", one[sgc.index("scg_ktyp")]),
("scg_scod", "=", win1)]
one[sgc.index("scg_rnum")] = nrnd
one[sgc.index("scg_scod")] = win1
one[sgc.index("scg_ocod")] = win2
one[sgc.index("scg_sfor")] = 0
one[sgc.index("scg_sagt")] = 0
one[sgc.index("scg_pnts")] = 0
one[sgc.index("scg_pair")] = pair
if not self.sql.getRec("scpgme", where=whr, limit=1):
self.sql.insRec("scpgme", data=one)
else:
self.sql.updRec("scpgme",
cols=["scg_ocod", "scg_pair"],
data=[win2, pair],
where=whr)
if self.rnum == self.lrnd and \
self.ctyp == "M" and self.nsec > 2:
# Create playoff records with winners codes
if not self.oldwin:
if subs == "B":
key = snum + 800000
else:
key = snum + 700000
else:
key = self.oldwin[snum]
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win1],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_scod", "=", key)])
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win1],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_ocod", "=", key)])
elif self.squa == "S" and self.rnum == self.lrnd:
# Update playoff records with winners codes
if self.ssub == "Y":
lsub = "B"
else:
lsub = ""
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", self.ctyp),
("scg_snum", "=", self.snum), ("scg_subs", "=", self.subs)]
if self.fmat == "K":
col = ["scg_scod", "scg_ocod", "scg_sfor", "scg_sagt"]
whr.append(("scg_rnum", "=", self.lrnd))
rec = self.sql.getRec("scpgme", cols=col, where=whr, limit=1)
if rec[2] > rec[3]:
win = rec[0]
else:
win = rec[1]
else:
self.doGetNewWin(sect=self.snum, sub=self.subs)
win = self.newwin[self.snum]
if not self.oldwin:
if self.subs == "B":
key = self.snum + 800000
else:
key = self.snum + 700000
else:
key = self.oldwin[self.snum]
self.sql.updRec("scpgme",
cols=["scg_scod"],
data=[win],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_scod", "=", key)])
self.sql.updRec("scpgme",
cols=["scg_ocod"],
data=[win],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_rnum", "=", 1),
("scg_ocod", "=", key)])
if self.snum == self.nsec and self.subs == lsub:
self.sql.updRec("scpgme",
cols=["scg_ktyp"],
data=["M"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P")])
# Check if all results for the round are captured
chek = self.sql.getRec("scpgme",
cols=["count(*)"],
where=[("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", self.ctyp),
("scg_rnum", "=", self.rnum),
("scg_scod", "<", 900000),
("scg_ocod", "<", 900000),
("scg_sfor", "=", 0),
("scg_sagt", "=", 0)],
limit=1)
if chek[0]:
return
if self.clup == "Y" and self.ctyp == "M" and nrnd == self.lrnd:
state = 3
elif self.rnum == self.lrnd:
if self.ctyp == "M":
state = 3
else:
state = 6
elif self.ctyp == "M":
state = 2
else:
state = 5
self.sql.updRec("scpcmp",
cols=["scp_state"],
data=[state],
where=[("scp_cono", "=", self.opts["conum"]),
("scp_ccod", "=", self.ccod)])
def doGetOldWin(self):
self.oldwin = {}
if self.ctyp == "M" and self.rnum == self.lrnd:
recs = self.sql.getRec("scpgme",
cols=["scg_scod", "scg_ocod"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=", self.ccod),
("scg_ctyp", "=", "P"),
("scg_snum", "=", 1)])
for rec in recs:
for cod in rec:
if cod < 900000:
sec = self.sql.getRec("scpgme",
cols=["scg_snum"],
where=[("scg_cono", "=",
self.opts["conum"]),
("scg_ccod", "=",
self.ccod),
("scg_ctyp", "=", "M"),
("scg_scod", "=", cod)],
limit=1)
if sec:
self.oldwin[sec[0]] = cod
def doGetNewWin(self, sect=None, sub=""):
# Get Leaders
self.newwin = {}
if sect is None:
secs = []
for x in range(self.nsec):
secs.append(x + 1)
else:
secs = [sect]
for sec in secs:
col = [
"scg_scod", "sum(scg_pnts) as a",
"sum(scg_sfor - scg_sagt) as b",
"round(sum(scg_sfor) / sum(scg_sagt), 2) as c"
]
whr = [("scg_cono", "=", self.opts["conum"]),
("scg_ccod", "=", self.ccod), ("scg_ctyp", "=", "M"),
("scg_snum", "=", sec), ("scg_subs", "=", sub)]
grp = "scg_scod"
odr = "a desc, b desc, c desc"
rec = self.sql.getRec("scpgme",
cols=col,
where=whr,
group=grp,
order=odr,
limit=1)
self.newwin[sec] = rec[0]
