def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"gentrn", "strmf1", "strmf2", "strgmu", "strcmu", "strprc",
"strtrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
strctl = gc.getCtl("strctl", self.opts["conum"])
if not strctl:
return
self.glint = strctl["cts_glint"]
self.locs = strctl["cts_locs"]
self.plevs = strctl["cts_plevs"]
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 setVariables(self):
gc = GetCtl(self.opts["mf"])
lonctl = gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
glint = lonctl["cln_glint"]
tab = ["lonctl", "lonmf2", "lontrn"]
if glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["lon_ctl", "int_rec", "int_pay"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.glctl = (
ctlctl["lon_ctl"], ctlctl["int_rec"], ctlctl["int_pay"])
tab.append("gentrn")
else:
self.glctl = None
self.sql = Sql(self.opts["mf"].dbm, tables=tab,
prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
yr = int(self.sysdtw / 10000)
mt = (int(self.sysdtw / 100) % 100) - 1
self.lme = mthendDate((yr * 10000) + (mt * 100) + 1)
return True
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
["genmst", "gentrn", "wagmst", "waglmf", "wagltf"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.col = self.sql.waglmf_col
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.glint = wagctl["ctw_glint"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["wag_slc", "wag_sli"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.glctls = (ctlctl["wag_slc"], ctlctl["wag_sli"])
else:
self.glctls = None
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def setVariables(self):
mc = GetCtl(self.opts["mf"])
ctlmst = mc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
memctl = mc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
self.ldays = memctl["mcm_ldays"]
self.lme = memctl["mcm_lme"]
self.lmd = int(memctl["mcm_lme"] / 100)
yr = int(self.lme / 10000)
mth = (int(self.lme / 100) % 100) + 1
if mth > 12:
yr += 1
mth = 1
self.tme = mthendDate((yr * 10000) + (mth * 100) + 00)
tabs = [
"chglog", "ctlbat", "ctlmst", "ctlvrf", "ctlvtf", "memage",
"memcat", "memctc", "memctl", "memctp", "memmst", "memtrn"
]
if self.glint == "Y":
tabs.append("gentrn")
ctlctl = mc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "mem_pen", "vat_ctl"]
if mc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.penctl = ctlctl["mem_pen"]
self.vatctl = ctlctl["vat_ctl"]
else:
self.penctl = 0
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.glint == "Y":
check = self.sql.getRec("memctc",
where=[("mcc_cono", "=",
self.opts["conum"]),
("mcc_freq", "<>", "N"),
("mcc_glac", "=", 0)])
if check:
mess = "The following Category Record(s) are Missing G/L "\
"Accounts:\n"
for rec in check:
mess = "%s\n%s, %2s, %s" % (mess, rec[1], rec[2], rec[3])
showError(self.opts["mf"].body, "Invalid Category", mess)
return
t = time.localtime()
self.sysdt = (t[0] * 10000) + (t[1] * 100) + t[2]
self.ynd = False
return True
def setVariables(self):
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.hrsmt = float(wagctl["ctw_m_hrs"])
self.hrswk = float(wagctl["ctw_w_hrs"])
self.hrsdy = float(wagctl["ctw_d_hrs"])
self.glint = wagctl["ctw_glint"]
self.bestac = wagctl["ctw_bestac"]
self.besttp = wagctl["ctw_besttp"]
self.tplnam = wagctl["ctw_tplnam"]
tabs = [
"tplmst", "wagcod", "wagedc", "wagmst", "wagcap", "wagbal",
"wagtf1", "wagtf2", "waglmf", "wagltf", "wagtxa", "wagtxr"
]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if gc.chkRec(self.opts["conum"], ctlctl, ["wag_ctl"]):
return
self.wagctl = ctlctl["wag_ctl"]
self.slnctl = ctlctl["wag_slc"]
tabs.extend(["ctldep", "ctlmst", "genmst", "genint", "gentrn"])
self.sql = Sql(self.opts["mf"].dbm,
tables=tabs,
prog=self.__class__.__name__)
if self.sql.error:
return
accs = self.sql.getRec("waglmf",
cols=["wlm_code"],
where=[("wlm_cono", "=", self.opts["conum"])],
group="wlm_code")
self.lonacc = []
for acc in accs:
self.lonacc.append(acc[0])
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sysdtd = CCD(self.sysdtw, "d1", 10).disp
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
self.etotal = 0
self.pgnum = 0
self.empnos = []
return True
def setVariables(self):
tabs = [
"ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genmst", "gentrn",
"rcaowm", "rcaowt", "rcaprm", "rcatnm", "rcacon", "rcatnt"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, 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
self.taxdf = ctlmst["ctm_taxdf"]
rcactl = gc.getCtl("rcactl", self.opts["conum"])
if not rcactl:
return
self.glint = rcactl["cte_glint"]
self.ch1 = ((rcactl["cte_lme"] // 100) * 100) + 1
self.ch2 = projectDate(self.ch1, 2, typ="months")
if self.glint == "Y":
self.glbnk = rcactl["cte_glbnk"]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = [
"rca_com", "rca_dep", "rca_fee", "rca_orx", "rca_own",
"rca_tnt", "rca_trx", "vat_ctl"
]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.rcacom = ctlctl["rca_com"]
self.rcadep = ctlctl["rca_dep"]
self.rcafee = ctlctl["rca_fee"]
self.rcaorx = ctlctl["rca_orx"]
self.rcaown = ctlctl["rca_own"]
self.rcatnt = ctlctl["rca_tnt"]
self.rcatrx = ctlctl["rca_trx"]
self.convat = ctlctl["vat_ctl"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.batno = "R%04i%02i" % (t[0], t[1])
return True
def setVariables(self):
gc = GetCtl(self.opts["mf"])
crsctl = gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.sql = Sql(self.opts["mf"].dbm, [
"ctlctl", "ctlmst", "crsctl", "crsmst", "crstrn", "crsage",
"gentrn", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
self.glint = crsctl["ctc_glint"]
self.bestac = crsctl["ctc_bestac"]
self.besttp = crsctl["ctc_besttp"]
self.bankac = crsctl["ctc_bankac"]
self.tplnam = crsctl["ctc_tplnam"]
self.fromad = crsctl["ctc_emadd"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if gc.chkRec(self.opts["conum"], ctlctl, ["crs_ctl"]):
return
self.crsctl = ctlctl["crs_ctl"]
acc = self.sql.getRec("crstrn",
cols=["max(crt_ref1)"],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_type", "=", 5),
("crt_ref1", "like", "EFT______")],
limit=1)
try:
self.cats = int(acc[0][3:])
self.refs = int(acc[0][3:]) + 1
except:
self.cats = 0
self.refs = 1
self.etotal = 0
return True
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 setVariables(self):
self.sql = Sql(self.opts["mf"].dbm,
tables=[
"bkmmst", "bkmcon", "bkmrtt", "bkmtrn", "bkmunm",
"ctlmst", "ctlvtf", "gentrn", "tplmst"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
ctl = gc.getCtl("ctlmst", self.opts["conum"])
if not ctl:
return
for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3",
"ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_taxdf",
"ctm_tel", "ctm_fax", "ctm_b_name", "ctm_b_ibt",
"ctm_b_acno", "ctm_logo"):
setattr(self, "%s" % col, ctl[col])
if self.ctm_logo and "LETTERHEAD" in os.environ:
self.ctm_logo = os.environ["LETTERHEAD"]
if not self.ctm_logo or not os.path.exists(self.ctm_logo):
self.ctm_logo = None
bkmctl = gc.getCtl("bkmctl", self.opts["conum"])
if not bkmctl:
return
self.glint = bkmctl["cbk_glint"]
self.tplnam = bkmctl["cbk_invtpl"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["vat_ctl", "bkm_ctl"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.vatctl = ctlctl["vat_ctl"]
self.bkmctl = ctlctl["bkm_ctl"]
t = time.localtime()
self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2])
return True
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"ctlvrf", "ctlvtf", "gentrn", "rcactl", "rcaprm", "rcaowm",
"rcaowt", "rcatnm", "rcacon", "rcatnt"
],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rcactl = gc.getCtl("rcactl", self.opts["conum"])
if not rcactl:
return
self.lme = rcactl["cte_lme"]
self.glint = rcactl["cte_glint"]
if self.glint == "Y":
self.glbnk = rcactl["cte_glbnk"]
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["rca_com", "rca_own", "rca_tnt", "vat_ctl"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.rcacom = ctlctl["rca_com"]
self.rcaown = ctlctl["rca_own"]
self.rcatnt = ctlctl["rca_tnt"]
self.rcatrx = ctlctl["rca_trx"]
self.convat = ctlctl["vat_ctl"]
# Check for Company Record
ctlmst = gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
# Set Company VAT Default
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.tme = mthendDate(self.sysdtw)
return True
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlbat", "ctlvrf", "ctlvtf",
"gentrn", "rtlctl", "rtlprm", "rtlmst", "rtlcon", "rtltrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
rtlctl = gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.glint = rtlctl["ctr_glint"]
self.lme = rtlctl["ctr_lme"]
if self.glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return
self.convat = ctlctl["vat_ctl"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.tme = mthendDate(self.sysdtw)
return True
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["wagctl", "waglmf"],
prog=self.__class__.__name__)
if self.sql.error:
return
gc = GetCtl(self.opts["mf"])
wagctl = gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
glint = wagctl["ctw_glint"]
if glint == "Y":
ctlctl = gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["wag_slc", "wag_sli"]
if gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.glctl = (ctlctl["wag_slc"], ctlctl["wag_sli"],
ctlctl["wag_sli"])
else:
self.glctl = None
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
class gl2050(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Company Record
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
# Check and Load VAT Control
self.ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not self.ctlctl:
return
if self.gc.chkRec(self.opts["conum"], self.ctlctl, ["vat_ctl"]):
return
self.convat = self.ctlctl["vat_ctl"]
# Set Batch Indicator
self.batind = "Y"
# Create SQL Object
tabs = [
"ctlctl", "ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint",
"genjlm", "genjlt", "genmst", "gentrn", "assgrp", "rtlprm"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"GEN",
self.opts["rtn"],
multi="Y")
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = ((t[0] * 10000) + (t[1] * 100) + t[2])
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][1][0] / 100)
return True
def doProcess(self):
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "Y"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "Frequency", "", "M", "N",
self.doFreq, None, None, None),
(("T", 0, 1, 0), ("IRB", r2s), 9, "All Journals", "", "N", "N",
self.doAllJnl, None, None, None),
(("T", 0, 2, 0), ("IRB", r2s), 1, "All Periods", "", "N", "N",
self.doAllPer, None, None, None))
tnd = ((self.doEnd, "y"), )
txt = (self.doExit, )
self.df = TartanDialog(self.opts["mf"], eflds=fld, tend=tnd, txit=txt)
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
self.wher = [("gjm_cono", "=", self.opts["conum"]),
("gjm_freq", "=", self.freq),
("gjm_start", "<=", self.bh.curdt),
("gjm_end", ">=", self.bh.curdt),
("gjm_last", "<", self.bh.curdt)]
data = self.sql.getRec("genjlm",
cols=["gjm_num", "gjm_desc"],
where=self.wher)
if not data:
return "No Valid Standard Journals"
if self.freq == "M":
self.mths = 1
elif self.freq == "3":
self.mths = 3
elif self.freq == "6":
self.mths = 6
else:
self.mths = 12
def doAllJnl(self, frt, pag, r, c, p, i, w):
self.alljnl = w
def doAllPer(self, frt, pag, r, c, p, i, w):
self.allper = w
def doEnd(self):
self.df.closeProcess()
if self.alljnl == "N":
recs = getSingleRecords(self.opts["mf"],
"genjlm", ("gjm_num", "gjm_desc"),
where=self.wher)
else:
recs = self.sql.getRec("genjlm", where=self.wher)
if not recs:
self.opts["mf"].closeLoop()
return
for gjm in recs:
self.trnref = gjm[self.sql.genjlm_col.index("gjm_num")]
self.trndet = gjm[self.sql.genjlm_col.index("gjm_desc")]
start = gjm[self.sql.genjlm_col.index("gjm_start")]
last = gjm[self.sql.genjlm_col.index("gjm_last")]
dates = []
while start <= self.bh.curdt:
if start < self.s_per or start <= last:
pass
elif self.allper == "N" and start == self.bh.curdt:
dates.append(start)
elif self.allper == "Y" and start <= self.bh.curdt:
dates.append(start)
start = self.nextPeriod(start)
for self.curdt in dates:
self.trndat = mthendDate((self.curdt * 100))
data = self.sql.getRec(
"genjlt",
cols=["gjt_acno", "gjt_amnt", "gjt_vatc"],
where=[("gjt_cono", "=", self.opts["conum"]),
("gjt_num", "=", self.trnref),
("gjt_amnt", "<>", 0)])
if not data:
continue
for tran in data:
self.acno = tran[0]
self.trnamt = tran[1]
self.vatcod = tran[2]
vrte = getVatRate(self.sql, self.opts["conum"],
self.vatcod, self.trndat)
if vrte is None:
vrte = 0.0
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.updateTables()
self.updateBatch()
self.sql.updRec("genjlm",
cols=["gjm_last"],
data=[self.curdt],
where=[("gjm_cono", "=", self.opts["conum"]),
("gjm_num", "=", self.trnref),
("gjm_freq", "=", self.freq)])
self.opts["mf"].dbm.commitDbase()
self.opts["mf"].closeLoop()
def nextPeriod(self, period):
yy = int(period / 100)
mm = (period % 100) + self.mths
if mm > 12:
yy += 1
mm -= 12
return (yy * 100) + mm
def updateTables(self):
amt = float(ASD(self.trnamt) - ASD(self.vatamt))
data = (self.opts["conum"], self.acno, self.curdt, self.trndat,
self.opts["rtn"], self.trnref, self.bh.batno, amt, self.vatamt,
self.trndet, self.vatcod, self.batind, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.vatcod:
if self.vatamt:
data = (self.opts["conum"], self.convat, self.curdt,
self.trndat, self.opts["rtn"], self.trnref,
self.bh.batno, self.vatamt, 0.00, self.trndet,
self.vatcod, self.batind, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if amt < 0:
vtyp = "O"
else:
vtyp = "I"
data = (self.opts["conum"], self.vatcod, vtyp, self.curdt, "G",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.acno, self.trndet, amt, self.vatamt, 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ml2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] != 5:
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
tabs = ["ctlvmf", "memmst", "memtrn"]
self.gc = GetCtl(self.opts["mf"])
memctl = self.gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.dis_all = ctlctl["dis_all"]
tabs.extend(["genmst", "gentrn"])
# Setup SQL Object
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"MEM",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
self.glt = 4
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def drawDialog(self):
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("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",
"sort":
False
}
tag = (("Deposit", None, None, None, False), ("Allocation", None, None,
None, False))
fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One",
"i", "Y", self.doRefno, None, None, ("efld", )),
(("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 3), "INA", 30, "Details", "Deposit Details", "",
"N", self.doTrnDet, None, None,
None), (("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", 2, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N",
self.doMemAcc, mlm, None, ("notblank", )), (("C", 2, 0, 1),
"ONA", 30, "Name"),
(("C", 2, 0, 2), "ISD", 13.2, "Receipt", "Receipt Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, ("efld", ), None,
"Discount Amount to be Added to the Receipt Amount."),
(("C", 2, 0, 4), "OSD", 13.2, "Total-Amount"))
but = (
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",1),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",1),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",1),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",1),
("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1))
txt = (None, None, None)
cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")]
cxt = [None, self.exitPage1, self.exitPage2]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doRefno(self, frt, pag, r, c, p, i, w):
if not w:
trns = self.sql.getRec("memtrn",
cols=["mlt_refno"],
where=[("mlt_cono", "=",
self.opts["conum"]),
("mlt_refno", "like", "R________")],
order="mlt_refno desc")
auto = False
for trn in trns:
try:
w = "R%08i" % (int(trn[0][1:]) + 1)
auto = True
break
except:
pass
if not auto:
w = "R00000001"
self.df.loadEntry(frt, pag, p, data=w)
chk = self.sql.getRec("memtrn",
cols=["mlt_memno"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", w)])
if chk:
return "A Transaction with this Number Already Exists"
self.refno = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
self.allocated = float(0.00)
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
self.agecan = False
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.glint == "Y":
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doMemAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memmst",
cols=["mlm_title", "mlm_initial", "mlm_surname"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", w)],
limit=1)
if not acc:
return "Invalid Member Number"
self.memno = w
self.name = "%s, %s %s" % (acc[2], acc[0], acc[1])
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.allref = self.refno
while self.sql.getRec("memtrn",
cols=["mlt_batch"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", self.allref)]):
self.doGetAnotherRef()
def doGetAnotherRef(self):
tit = ("Duplicate Reference Number", )
fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref,
"N", None, None, None, None),
(("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N",
self.doRefNew, None, None, ("notblank", )))
tnd = ((self.doRefEnd, "n"), )
txt = (self.doRefExit, )
state = self.df.disableButtonsTags()
self.tf = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=tnd,
txit=txt)
self.tf.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doRefExit(self):
self.tf.focusField("T", 0, 2)
def doRefNew(self, frt, pag, r, c, p, i, w):
self.allref = w
def doRefEnd(self):
self.tf.closeProcess()
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
ok = self.checkSign()
elif self.allamt > 0 and w < 0:
ok = self.checkSign()
else:
ok = "yes"
if ok != "yes":
return "Invalid Discount Amount (Sign Error)"
self.disamt = w
totamt = float(ASD(self.allamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def checkSign(self):
return askQuestion(self.opts["mf"].body, "Check Sign",
"The Sign of the Discount Amount is not the same as the Sign "\
"of the Receipt Amount, Is This Correct?")
def endPage2(self):
self.amt = float(ASD(0) - ASD(self.allamt))
self.dis = float(ASD(0) - ASD(self.disamt))
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(0, 5):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
# Members Ledger Transaction
data = [
self.opts["conum"], self.memno, self.opts["rtn"], self.allref,
self.bh.batno, self.trndat, self.amt, 0.00, self.curdt, "", 0,
self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data)
if self.dis:
data = [
self.opts["conum"], self.memno, 6, self.allref, self.bh.batno,
self.trndat, self.dis, 0.00, self.curdt, "", 0, self.trndet,
"", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data, unique="mlt_refno")
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.glint == "Y":
# General Ledger Control Transaction (Members)
amt = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.memctl, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.disamt:
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.allref, self.bh.batno,
self.disamt, 0.00, self.trndet, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="mem",
agetyp=atype,
agekey=[
self.opts["conum"], self.memno, self.opts["rtn"],
self.allref, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
self.agevar.set(False)
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
class dr2030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.doProcess()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlvrf", "ctlvtf",
"drsmst", "drstrn", "drsrcm", "drsrct", "genmst", "gentrn"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.fromad = drsctl["ctd_emadd"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"],ctlctl,["drs_ctl","vat_ctl"]):
return
self.drsctl = ctlctl["drs_ctl"]
self.vatctl = ctlctl["vat_ctl"]
ctl = self.sql.getRec("ctlmst",
where=[("ctm_cono", "=", self.opts["conum"])], limit=1)
for col in ("ctm_name", "ctm_add1", "ctm_add2", "ctm_add3",
"ctm_pcode", "ctm_regno", "ctm_taxno", "ctm_tel",
"ctm_fax", "ctm_b_name", "ctm_b_branch", "ctm_b_ibt",
"ctm_b_acno", "ctm_logo"):
setattr(self, "%s" % col, ctl[self.sql.ctlmst_col.index(col)])
if "LETTERHEAD" in os.environ:
self.ctm_logo = os.environ["LETTERHEAD"]
if not self.ctm_logo or not os.path.exists(self.ctm_logo):
self.ctm_logo = None
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"], self.opts["conum"],
self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"],
multi="N", glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
def doProcess(self):
r1s = (
("Monthly","M"),
("Quarterly","3"),
("Bi-Annually","6"),
("Annually","Y"))
r2s = (("Yes", "Y"), ("No", "N"))
fld = (
(("T",0,0,0),("IRB",r1s),0,"Frequency","",
"M","N",self.doFreq,None,None,None),
(("T",0,1,0),("IRB",r2s),1,"All Charges","",
"N","N",self.doAll,None,None,None),
(("T",0,2,0),"INa",9,"2nd Reference","",
"","N",self.doRef2,None,None,None),
(("T",0,3,0),("IRB",r2s),1,"Invoices","",
"N","N",self.doInv,None,None,None))
tnd = ((self.doEnd,"y"),)
txt = (self.doExit,)
self.df = TartanDialog(self.opts["mf"], eflds=fld,
tend=tnd, txit=txt, view=("N","P"), mail=("N","Y"))
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
self.wher = [("dcm_cono", "=", self.opts["conum"]), ("dcm_freq", "=",
self.freq), ("dcm_last", "<", self.bh.curdt)]
data = self.sql.getRec("drsrcm", where=self.wher)
if not data:
return "No Valid Recurring Charges"
if self.freq == "M":
self.mths = 1
elif self.freq == "3":
self.mths = 3
elif self.freq == "6":
self.mths = 6
else:
self.mths = 12
def doAll(self, frt, pag, r, c, p, i, w):
self.allc = w
def doRef2(self, frt, pag, r, c, p, i, w):
self.ref2 = w
def doInv(self, frt, pag, r, c, p, i, w):
self.inv = w
if self.inv == "N":
self.df.loadEntry(frt, pag, p+2, data="")
return "nd"
def doEml(self, frt, pag, r, c, p, i, w):
self.eml = w
def doEnd(self):
self.df.closeProcess()
if self.allc == "N":
recs = getSingleRecords(self.opts["mf"], "drsrcm", ("dcm_num",
"dcm_desc"), where=self.wher)
else:
recs = self.sql.getRec("drsrcm", where=self.wher)
if recs:
if self.inv == "Y" and self.df.repeml[1] == "N":
self.fpdf = MyFpdf(orientation="L", fmat="A4",
name=self.__class__.__name__, head=128)
for dcm in recs:
num = dcm[self.sql.drsrcm_col.index("dcm_num")]
desc = dcm[self.sql.drsrcm_col.index("dcm_desc")]
day = dcm[self.sql.drsrcm_col.index("dcm_day")]
if day == 30:
self.trdt = mthendDate((self.bh.curdt * 100) + 1)
else:
self.trdt = (self.bh.curdt * 100) + day
vat = dcm[self.sql.drsrcm_col.index("dcm_vat")]
self.vatrte = getVatRate(self.sql, self.opts["conum"],
vat, self.trdt)
glac = dcm[self.sql.drsrcm_col.index("dcm_glac")]
nxt = self.sql.getRec("drstrn", cols=["max(drt_ref1)"],
where=[("drt_cono", "=", self.opts["conum"]), ("drt_ref1",
"like", "RC%03i%s" % (num, "%"))], limit=1)
if not nxt[0]:
nxt = 0
else:
nxt = int(nxt[0][5:])
tot_val = 0
tot_vat = 0
rec = self.sql.getRec("drsrct", where=[("dct_cono", "=",
self.opts["conum"]), ("dct_num", "=", num), ("dct_start",
"<=", self.bh.curdt), ("dct_end", ">=", self.bh.curdt)])
col = self.sql.drsrct_col
for dct in rec:
self.chain = dct[col.index("dct_chain")]
self.acno = dct[col.index("dct_acno")]
# Check for Redundancy
chk = self.sql.getRec("drsmst", cols=["drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chain), ("drm_acno", "=",
self.acno)], limit=1)
if chk[0] == "X":
continue
# Check for Valid Period
charge = False
start = dct[col.index("dct_start")]
year = int(start / 100)
month = start % 100
while start <= self.bh.curdt:
if start == self.bh.curdt:
charge = True
break
month += self.mths
if month > 12:
year += 1
month -= 12
start = (year * 100) + month
if not charge:
continue
# Create Transactions
nxt += 1
self.ref = "RC%03i%04i" % (num, nxt)
self.detail = textFormat(dct[col.index("dct_detail")], 73)
self.amnt = dct[col.index("dct_amnt")]
self.vmnt = round(self.amnt * self.vatrte / 100, 2)
self.tmnt = float(ASD(self.amnt) + ASD(self.vmnt))
tot_val = float(ASD(tot_val) + ASD(self.amnt))
tot_vat = float(ASD(tot_vat) + ASD(self.vmnt))
# Debtors (drstrn)
self.sql.insRec("drstrn", data=[self.opts["conum"],
self.chain, self.acno, 1, self.ref, self.bh.batno,
self.trdt, self.ref2, self.tmnt, self.vmnt,
self.bh.curdt, self.detail[0], vat, "Y",
self.opts["capnm"], self.sysdtw, 0])
if self.inv == "Y":
# Create Invoice
self.doInvoice()
# VAT (ctlvtf)
amnt = float(ASD(0) - ASD(self.amnt))
vmnt = float(ASD(0) - ASD(self.vmnt))
data = [self.opts["conum"], vat, "O", self.bh.curdt,
"D", 1, self.bh.batno, self.ref, self.trdt, self.acno,
self.detail[0], amnt, vmnt, 0, self.opts["capnm"],
self.sysdtw, 0]
self.sql.insRec("ctlvtf", data=data)
if self.glint == "Y":
ref = "RC%07i" % num
# Update Debtors Control
amnt = float(ASD(tot_val) + ASD(tot_vat))
data = (self.opts["conum"], self.drsctl, self.bh.curdt,
self.trdt, 1, ref, self.bh.batno, amnt, 0, desc,
"", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# Update Sales Account
amnt = float(ASD(0) - ASD(tot_val))
data = (self.opts["conum"], glac, self.bh.curdt, self.trdt,
1, ref, self.bh.batno, amnt, 0, desc, "", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
amnt = float(ASD(0) - ASD(tot_vat))
if amnt:
# Update VAT Control
data = (self.opts["conum"], self.vatctl, self.bh.curdt,
self.trdt, 1, ref, self.bh.batno, amnt, 0, desc,
"", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# Update Recurring Charge (drsrcm)
self.sql.updRec("drsrcm", cols=["dcm_last"],
data=[self.bh.curdt], where=[("dcm_cono", "=",
self.opts["conum"]), ("dcm_num", "=", num), ("dcm_freq",
"=", self.freq)])
self.opts["mf"].dbm.commitDbase()
if self.inv == "Y" and self.df.repeml[1] == "N":
self.doPrint()
self.opts["mf"].closeLoop()
def doInvoice(self):
if self.df.repeml[1] == "Y":
self.fpdf = MyFpdf(orientation="L", fmat="A4",
name=self.__class__.__name__, head=128)
cw = self.fpdf.get_string_width("X")
ld = self.fpdf.font[2]
ica = CCD(self.tmnt, "SD", 13.2)
iva = CCD(float(ASD(self.tmnt) - ASD(self.amnt)), "SD", 13.2)
ivr = CCD(self.vatrte, "UD", 5.2)
self.drawInvoice(cw, ld)
row = 20
for detail in self.detail:
row += 1
self.fpdf.drawText(x=22.2*cw, y=row*ld, txt=detail)
self.fpdf.drawText(x=97*cw, y=row*ld, txt=ivr.disp)
self.fpdf.drawText(x=103*cw, y=row*ld, txt=ica.disp)
self.printTotals(cw, ld, ica, iva)
if self.df.repeml[1] == "Y":
self.doPrint()
def drawInvoice(self, cw, ld):
self.fpdf.add_page()
self.fpdf.setFont("courier", "B", 16)
self.fpdf.drawText(x=22*cw, y=1*ld, txt=self.ctm_name)
self.fpdf.setFont("courier", "B", 14)
self.fpdf.drawText(x=108*cw, y=2*ld, w=16, align="R", txt="Tax Invoice")
self.fpdf.setFont("courier", "B", self.fpdf.font[1])
if self.ctm_logo:
self.fpdf.image(self.ctm_logo, 45, 3, 138, 28)
else:
self.fpdf.drawText(x=22*cw, y=2.5*ld, txt=self.ctm_add1)
self.fpdf.drawText(x=22*cw, y=3.5*ld, txt=self.ctm_add2)
self.fpdf.drawText(x=22*cw, y=4.5*ld, txt=self.ctm_add3)
self.fpdf.drawText(x=22*cw, y=5.5*ld, txt=self.ctm_pcode)
self.fpdf.drawText(x=54*cw, y=2.5*ld,
txt="RegNo: %s" % self.ctm_regno)
self.fpdf.drawText(x=54*cw, y=3.5*ld,
txt="TaxNo: %s" % self.ctm_taxno)
self.fpdf.drawText(x=54*cw, y=4.5*ld,
txt="TelNo: %s" % self.ctm_tel)
self.fpdf.drawText(x=54*cw, y=5.5*ld,
txt="FaxNo: %s" % self.ctm_fax)
drm = self.sql.getRec("drsmst", where=[("drm_cono", "=",
self.opts["conum"]), ("drm_chain", "=", self.chain), ("drm_acno",
"=", self.acno)], limit=1)
col = self.sql.drsmst_col
self.fpdf.drawText(x=22.5*cw, y=10.5*ld, txt=drm[col.index("drm_name")])
self.fpdf.drawText(x=22.5*cw, y=11.5*ld, txt=drm[col.index("drm_add1")])
self.fpdf.drawText(x=22.5*cw, y=12.5*ld, txt=drm[col.index("drm_add2")])
self.fpdf.drawText(x=22.5*cw, y=13.5*ld, txt=drm[col.index("drm_add3")])
self.fpdf.drawText(x=22.5*cw, y=14.5*ld, txt=drm[col.index("drm_pcod")])
if self.ctm_b_name:
dat = "Name: %s" % self.ctm_b_name
dat = "%s\nBranch: %s" % (dat, self.ctm_b_branch)
dat = "%s\nCode: %s" % (dat, self.ctm_b_ibt)
dat = "%s\nAccount: %s\n " % (dat, self.ctm_b_acno)
self.fpdf.drawText(x=22.5*cw, y=37*ld, txt=dat, ctyp="M")
self.emadd = CCD(drm[col.index("drm_acc_email")], "TX")
# Tables
r1 = {
"margins": ((22.5, 53), (8, 9)),
"repeat": (1, 1),
"rows": [
[22, 8.5, [[32, 1.5, .8, "Charge To:", False]]],
[22, 10, [[32, 5.5]]],
[22, 16, [
[9, 1.5, .8, "Acc-Num", True],
[20, 1.5, .8, "V.A.T. Number", True],
[42, 1.5, .8, "Contact Person", True],
[12, 1.5, .8, "Date", True],
[11, 1.5, .8, "Inv-Number", True]]],
[22, 17.5, [
[9, 1.5, 0, self.acno, True],
[20, 1.5, 0, drm[col.index("drm_vatno")], True],
[42, 1.5, 0, drm[col.index("drm_sls")]],
[12, 1.5, 0, CCD(self.trdt, "D1", 10).disp, True],
[11, 1.5, 0, "%10s" % self.ref]]],
[22, 19, [
[74, 1.5, .8, "Description", False],
[7, 1.5, .8, " Tax-%", False],
[13, 1.5, .8, " Value", False]]],
[22, 20.5, [
[74, 12.5],
[7, 12.5],
[13, 12.5]]],
[22, 33, [
[11, 1.5, .8, "Taxable"],
[12, 1.5],
[12, 1.5, .8, "Non-Taxable"],
[12, 1.5],
[11, 1.5, .8, "Total Tax"],
[11, 1.5],
[12, 1.5, .8, "Total Value"],
[13, 1.5]]]]}
if self.ctm_b_name:
r1["rows"].extend([
[22, 35, [[32, 1.5, .8, "Banking Details", False]]],
[22, 36.5, [[32, 5.5]]]])
doDrawTable(self.fpdf, r1, cw=cw, ld=ld, font=False)
def printTotals(self, cw, ld, ica, iva):
tot = [0, 0, iva.work, ica.work]
if iva.work:
tot[0] = float(ASD(ica.work) - ASD(iva.work))
else:
tot[1] = ica.work
self.fpdf.drawText(x=32*cw, y=33.2*ld, txt=CCD(tot[0],"SD",13.2).disp)
self.fpdf.drawText(x=56*cw, y=33.2*ld, txt=CCD(tot[1],"SD",13.2).disp)
self.fpdf.drawText(x=78*cw, y=33.2*ld, txt=CCD(tot[2],"SD",13.2).disp)
self.fpdf.drawText(x=103*cw, y=33.2*ld, txt=CCD(tot[3],"SD",13.2).disp)
def doPrint(self):
if not self.fpdf.page:
return
if self.df.repeml[1] == "Y":
self.df.repeml[2] = self.emadd.work
key = "%s_%s_%s" % (self.opts["conum"], self.chain, self.acno)
else:
key = "%s_all_all" % self.opts["conum"]
pdfnam = getModName(self.opts["mf"].rcdic["wrkdir"],
self.__class__.__name__, key, ext="pdf")
self.fpdf.output(pdfnam, "F")
doPrinter(mf=self.opts["mf"], conum=self.opts["conum"], pdfnam=pdfnam,
header="%s Invoice" % self.opts["conam"], repprt=self.df.repprt,
fromad=self.fromad, repeml=self.df.repeml)
def doExit(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
class ln2030(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(self.opts["mf"].dbm, [
"genmst", "gentrn", "lonctl", "lonmf1", "lonmf2", "lonrte",
"lontrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
lonctl = self.gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
self.glint = lonctl["cln_glint"]
self.drate = lonctl["cln_drte"]
self.crate = lonctl["cln_crte"]
self.lastd = lonctl["cln_last"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["lon_ctl"]):
return
self.glctl = (ctlctl["lon_ctl"], ctlctl["int_rec"],
ctlctl["int_pay"])
else:
self.glctl = None
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
lm1 = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols":
(("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")),
"where": [("lm1_cono", "=", self.opts["conum"])]
}
lm2 = {
"stype":
"R",
"tables": ("lonmf2", ),
"cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0,
"Description", "Y")),
"where": [("lm2_cono", "=", self.opts["conum"])],
"whera": [("C", "lm2_acno", 0, 0)]
}
dte = {
"stype":
"R",
"tables": ("lonrte", ),
"cols":
(("lrt_start", "", 0, "Start-Date"), ("lrt_drte", "", 0, "DRte-%"),
("lrt_crte", "", 0, "CRte-%")),
"where": [("lrt_cono", "=", self.opts["conum"])],
"whera": [("C", "lrt_acno", 0, 0), ("C", "lrt_loan", 2, 0)],
"order":
"lrt_start"
}
r1s = (("Yes", "Y"), ("No", "N"))
fld = ((("T", 0, 0, 0), ("IRB", r1s), 0, "All Current Rates", "", "N",
"N", self.doAll, None, None,
None), (("T", 0, 1, 0), "ID1", 10, "Effective Date", "", "",
"N", self.doSdate, None, None, ("efld", )),
(("T", 0, 2, 0), "IUD", 6.2, "Debit Rate - Old", "",
self.drate, "N", self.doDRte, None, None, None),
(("T", 0, 2, 0), "IUD", 6.2, "New", "New Debit Rate", "", "N",
self.doDRte, None, None,
None), (("T", 0, 3, 0), "IUD", 6.2, "Credit Rate - Old", "",
self.crate, "N", self.doCRte, None, None, None),
(("T", 0, 3, 0), "IUD", 6.2, "New", "New Credit Rate", "", "N",
self.doCRte, None, None,
None), (("C", 0, 0, 0), "IUA", 7, "Acc-Num", "Account Number",
"", "N", self.doAcc, lm1, None, None),
(("C", 0, 0, 1), "ONA", 30,
"Name"), (("C", 0, 0, 2), "IUI", 2, "Ln", "Loan Number", "",
"N", self.doLon, lm2, None, None),
(("C", 0, 0, 3), "ONA", 30,
"Description"), (("C", 0, 0, 4), "ID1", 10, "Date", "", "",
"N", self.doSdate, dte, None, ("efld", )),
(("C", 0, 0, 5), "IUD", 6.2, "DRte-%", "Debit Rate", "", "N",
self.doDRte, None, None,
None), (("C", 0, 0, 6), "IUD", 6.2, "CRte-%", "Credit Rate",
"", "N", self.doCRte, None, None, None))
tnd = ((self.endPage, "y"), )
txt = (self.exitPage, )
cnd = ((self.endPage, "y"), )
cxt = (self.exitPage, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doAll(self, frt, pag, r, c, p, i, w):
self.allrte = w
if self.allrte == "N":
return "nd"
def doSdate(self, frt, pag, r, c, p, i, w):
if w <= self.lastd:
return "Invalid Date, Before Last Interest Raise Date"
self.sdate = w
self.curdt = int(w / 100)
self.chgrte = False
if self.allrte == "N":
chk = self.sql.getRec("lonrte",
where=[("lrt_cono", "=", self.opts["conum"]),
("lrt_acno", "=", self.acno),
("lrt_loan", "=", self.loan),
("lrt_start", "=", w)],
limit=1)
if chk:
self.df.loadEntry(frt, pag, p + 1, data=chk[4])
self.df.loadEntry(frt, pag, p + 2, data=chk[5])
ok = askQuestion(self.opts["mf"].body,
"Exists",
"""This Date "Already Exists.
Debit Rate: %s Credit Rate: %s
Changing It Could Cause Problems.
Would You Like to Continue?""" % (chk[4], chk[5]),
default="no")
if ok == "no":
return "rf"
self.chgrte = True
def doDRte(self, frt, pag, r, c, p, i, w):
if self.df.frt == "T" and p == 2:
self.oldd = w
else:
self.newd = w
def doCRte(self, frt, pag, r, c, p, i, w):
if self.df.frt == "T" and p == 4:
self.oldc = w
else:
self.newc = w
def doAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("lonmf1",
cols=["lm1_name"],
where=[("lm1_cono", "=", self.opts["conum"]),
("lm1_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.acno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
def doLon(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("lonmf2",
where=[("lm2_cono", "=", self.opts["conum"]),
("lm2_acno", "=", self.acno),
("lm2_loan", "=", w)],
limit=1)
if not acc:
return "Invalid Loan Number"
self.loan = w
desc = acc[self.sql.lonmf2_col.index("lm2_desc")]
self.start = acc[self.sql.lonmf2_col.index("lm2_start")]
self.pmths = acc[self.sql.lonmf2_col.index("lm2_pmths")]
if self.pmths:
return "Fixed Loan, Rate Change Not Allowed"
self.df.loadEntry("C", pag, p + 1, data=desc)
def endPage(self):
if self.df.frt == "T":
if self.allrte == "N":
self.df.focusField("C", 0, 1)
else:
self.updateTables()
self.opts["mf"].dbm.commitDbase(True)
self.exitPage()
else:
self.updateTables()
self.df.advanceLine(0)
def exitPage(self):
if self.df.frt == "C":
self.opts["mf"].dbm.commitDbase(True)
self.df.closeProcess()
self.opts["mf"].closeLoop()
def updateTables(self):
if self.allrte == "Y":
if self.oldd == self.drate and self.oldc == self.crate:
self.sql.updRec("lonctl",
cols=["cln_drte", "cln_crte"],
data=[self.newd, self.newc],
where=[("cln_cono", "=", self.opts["conum"])])
whr = [("lm2_cono", "=", self.opts["conum"]),
("lrt_cono=lm2_cono", ), ("lrt_acno=lm2_acno", ),
("lrt_loan=lm2_loan", ), ("lrt_drte", "=", self.oldd),
("lrt_crte", "=", self.oldc)]
recs = self.sql.getRec(tables=["lonmf2", "lonrte"],
cols=["lm2_acno", "lm2_loan", "lm2_pmths"],
where=whr,
group="lm2_acno, lm2_loan, lm2_pmths",
order="lm2_acno")
else:
recs = [[self.acno, self.loan, 0]]
for rec in recs:
if rec[2]:
# Fixed Period Loan, No Rate Changes Allowed
continue
# Loans Rate Record
if self.chgrte:
self.sql.updRec("lonrte",
cols=["lrt_drte", "lrt_crte"],
data=[self.newd, self.newc],
where=[("lrt_cono", "=", self.opts["conum"]),
("lrt_acno", "=", rec[0]),
("lrt_loan", "=", rec[1]),
("lrt_start", "=", self.sdate)])
else:
self.sql.insRec("lonrte",
data=[
self.opts["conum"], rec[0], rec[1],
self.sdate, self.newd, self.newc
])
class ar2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
if self.opts["rtn"] not in (1, 2, 3):
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
self.gc = GetCtl(self.opts["mf"])
assctl = self.gc.getCtl("assctl", self.opts["conum"])
if not assctl:
return
self.glint = assctl["cta_glint"]
self.rordp = assctl["cta_rordp"]
tabs = [
"assgrp", "assmst", "assdep", "asstrn", "ctlvmf", "ctlvrf",
"ctlvtf", "genint", "genmst", "gentrn"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.glint == "Y":
# Check Sale of Asset Record
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, "ass_sls"):
return
self.slsac = ctlctl["ass_sls"]
# Check for VAT Control
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return
self.convat = ctlctl["vat_ctl"]
# Check All Group Control Records
errs = ("Group %s Has An Invalid", "Asset Control Account (%s)",
"Accumulated Depreciation Account (%s)",
"Depreciation Expense Account (%s)")
ass = self.sql.getRec(
"assgrp",
cols=["asg_group", "asg_assacc", "asg_depacc", "asg_expacc"],
where=[("asg_cono", "=", self.opts["conum"])])
for acc in ass:
for x in range(1, 4):
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", acc[x])],
limit=1)
if not chk:
mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x])
showError(self.opts["mf"].body, "Control Error", mess)
return
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"ASS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 2:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
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, 1]]
}
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"])]
}
data = []
for x in range(1, (len(armvtp) + 1)):
data.append([x, armvtp[x - 1][1]])
mov = {
"stype": "C",
"titl": "Valid Types",
"head": ("C", "Description"),
"data": data
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUA", 3, "Grp", "Asset Group", "r", "N",
self.doAssGrp, grp, None, None),
(("C", 1, 0, 1), "INa", 7, "Cod-Num", "Asset Code", "r", "N",
self.doAssCod, cod, None, ("notblank", )),
(("C", 1, 0, 2), "ONA", 13, "Description"),
(("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "IUI", 1, "M", "Movement Type", "r", "N",
self.doTrnMov, mov, None, ("in", (1, 2, 3, 4, 5))),
(("C", 1, 0, 6), "ISD", 13.2, "Company", "Company Amount", "",
"N", self.doCoyAmt, None, None, None),
(("C", 1, 0, 7), "ISD", 13.2, "Receiver", "Receiver Amount", "",
"N", self.doRorAmt, None, None, None),
(("C", 1, 0, 8), "IUA", 1, "V", "V.A.T Code", "C", "N",
self.doVatCod, vtm, None, ("notblank", )),
(("C", 1, 0, 9), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
(("C", 1, 0,
10), "INA", (13, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = (("Interrogate", None, self.queryAss, 0, ("C", 1, 1),
("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1)))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doAssGrp(self, frt, pag, r, c, p, i, w):
whr = [("asg_cono", "=", self.opts["conum"]), ("asg_group", "=", w)]
acc = self.sql.getRec("assgrp", where=whr, limit=1)
if not acc:
return "Invalid Asset Group"
self.group = w
self.depcod = acc[self.sql.assgrp_col.index("asg_depcod")]
self.assacc = acc[self.sql.assgrp_col.index("asg_assacc")]
self.depacc = acc[self.sql.assgrp_col.index("asg_depacc")]
self.expacc = acc[self.sql.assgrp_col.index("asg_expacc")]
def doAssCod(self, frt, pag, r, c, p, i, w):
self.code = w
self.buydt = 0
self.seldt = 0
col = ["asm_desc", "asm_depcod"]
whr = [("asm_cono", "=", self.opts["conum"]),
("asm_group", "=", self.group), ("asm_code", "=", self.code)]
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
ok = askQuestion(screen=self.opts["mf"].body,
head="New Asset",
mess="Asset does not exist, Create?")
if ok == "no":
return "Invalid Asset"
self.doNewAsset()
acc = self.sql.getRec("assmst", cols=col, where=whr, limit=1)
if not acc:
return "Asset Not Found"
self.new = "y"
else:
self.new = "n"
dep = self.sql.getRec("assdep",
cols=["asd_rate1r"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", acc[1])],
limit=1)
self.rate1r = dep[0]
col = ["ast_date"]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "=", 1)]
pur = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if pur:
self.buydt = pur[0]
whr = [("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group), ("ast_code", "=", self.code),
("ast_mtyp", "in", (3, 5))]
sel = self.sql.getRec("asstrn", cols=col, where=whr, limit=1)
if sel:
self.seldt = sel[0]
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
if self.new == "y":
self.trnmov = 1
self.df.loadEntry(frt, pag, p + 1, data=self.trnmov)
return "sk1"
def doTrnMov(self, frt, pag, r, c, p, i, w):
if type(w) == list:
w = w[0] + 1
# Do some tests to see if not new again or already sold etc.
if w == 4 and self.opts["rtn"] != 3:
return "Depreciation Only Allowed with Journal Entries"
if self.opts["rtn"] == 1 and w not in (1, 2):
return "Invalid Choice For Payment"
if self.opts["rtn"] == 2 and w not in (5, ):
return "Invalid Choice For Receipt"
if w == 1 and self.buydt:
return "Asset Already Purchased"
if w in (2, 3, 4, 5) and self.seldt:
return "Asset Already Sold or Written Off"
if w in (2, 3, 4, 5) and not self.buydt:
return "Asset Not Yet Purchased"
self.df.loadEntry(frt, pag, p, data=w)
self.trnmov = w
if self.trnmov == 3:
bal = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)", "sum(ast_amt2)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
self.coyamt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 1, data=self.coyamt)
self.roramt = float(ASD(0) - ASD(bal[0]))
self.df.loadEntry(frt, pag, p + 2, data=self.roramt)
self.vatcode = ""
self.trnvat = 0
return "sk4"
def doCoyAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.coyamt = w
if self.rordp == "N" or not self.rate1r or self.trnmov != 4:
self.roramt = 0
self.df.loadEntry(frt, pag, p + 1, data=self.roramt)
if self.trnmov == 4:
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 2, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 3, data=self.trnvat)
return "sk3"
return "sk1"
def doRorAmt(self, frt, pag, r, c, p, i, w):
if self.opts["rtn"] == 3 and self.trnmov == 5 and w > 0:
ok = askQuestion(screen=self.opts["mf"].body,
head="Debit",
mess="Should this Amount not be a Credit Entry?")
if ok == "yes":
w = float(ASD(0) - ASD(w))
self.df.loadEntry(frt, pag, p, data=w)
self.roramt = w
self.vatcode = ""
self.trnvat = 0
self.df.loadEntry(frt, pag, p + 1, data=self.vatcode)
self.df.loadEntry(frt, pag, p + 2, data=self.trnvat)
return "sk2"
def doVatCod(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.trnvat = round((self.coyamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.trnvat)
if not self.trnvat:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.coyamt < 0 and w > 0:
self.trnvat = float(ASD(0) - ASD(w))
elif self.coyamt > 0 and w < 0:
self.trnvat = float(ASD(0) - ASD(w))
else:
self.trnvat = w
self.df.loadEntry(frt, pag, p, data=self.trnvat)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (1, 2) and self.glint == "Y":
self.df.colf[2][3][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if self.coyamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.glint == "N" or self.opts["rtn"] in (1, 2) or \
self.trnmov == 4:
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(1)
else:
self.coyamt = float(ASD(0) - ASD(self.coyamt))
self.df.loadEntry("T", 2, 0, data=self.coyamt)
self.df.selPage("Allocation")
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.coyamt
self.vat = self.trnvat
if self.trnmov == 4:
self.net = float(ASD(0) - ASD(self.coyamt))
self.ror = float(ASD(0) - ASD(self.roramt))
else:
self.net = self.ror = float(ASD(self.coyamt) - ASD(self.trnvat))
if self.opts["rtn"] == 1: # Payments
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
acc = self.assacc
self.glt = 2
elif self.opts["rtn"] == 2: # Receipts
if self.coyamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.net = float(ASD(0) - ASD(self.net))
acc = self.assacc
self.glt = 6
elif self.opts["rtn"] == 3: # Journal Entries
self.recon = 0
if self.trnmov == 4:
acc = self.depacc
else:
acc = self.assacc
self.glt = 4
# Asset Register Transaction
data = [
self.opts["conum"], self.group, self.code, self.opts["rtn"],
self.trnref, self.bh.batno, self.trndat, self.trnmov, self.net,
self.ror, self.vat, self.curdt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("asstrn", data=data)
if self.vatcode:
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "I", self.curdt, "A",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.code, self.trndet, self.amt, self.vat, 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Asset or Depreciation Account
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, self.net, self.vat, self.trndet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.vat:
# General Ledger Control Transaction (V.A.T.)
data = [
self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.vat, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
self.amt = float(ASD(0) - ASD(self.amt))
if self.opts["rtn"] in (1, 2):
# General Ledger Control Transaction (Bank)
data = [
self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
elif self.trnmov == 4:
# General Ledger Expense Account (Depreciation)
data = [
self.opts["conum"], self.expacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.coyamt, self.vat,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
if self.trnmov == 5:
# Sale of Asset
# Raise Depreciation
callModule(self.opts["mf"],
None,
"ar2030",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"],
args=(self.curdt, self.group, self.code))
# Generate Sale
amt = self.sql.getRec("asstrn",
cols=["sum(ast_amt1)"],
where=[("ast_cono", "=", self.opts["conum"]),
("ast_group", "=", self.group),
("ast_code", "=", self.code)],
limit=1)
if amt[0]:
data = [
self.opts["conum"], self.slsac, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt[0], 0,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("gentrn", data=data)
data[1] = acc
data[7] = float(ASD(0) - ASD(amt[0]))
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int(int((self.df.last[1][1] - 1) / self.df.colq[1]))
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.coyamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.coyamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
# General Ledger Transaction (Allocation)
amt = float(ASD(0) - ASD(self.allamt))
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, amt, 0.00, self.alldet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.coyamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.coyamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def doNewAsset(self):
tit = ("Create New Asset", )
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), "INA", 30, "Description", "", "", "N",
None, None, None, ("notblank", )),
(("T", 0, 1, 0), "INa", 3, "Dep Code", "Depreciation Code",
self.depcod, "N", self.doDepCode, dep, None,
("notblank", )), (("T", 0, 1, 0), "ONA", 34, ""))
tnd = ((self.doNewEnd, "N"), )
txt = (self.doNewXit, )
state = self.df.disableButtonsTags()
self.na = TartanDialog(self.opts["mf"],
tops=True,
title=tit,
eflds=self.fld,
tend=tnd,
txit=txt)
self.na.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doDepCode(self, frt, pag, r, c, p, i, w):
chk = self.sql.getRec("assdep",
cols=["asd_desc"],
where=[("asd_cono", "=", self.opts["conum"]),
("asd_code", "=", w)],
limit=1)
if not chk:
return "Invalid Depreciation Code"
self.na.loadEntry(frt, pag, p + 1, data=chk[0])
def doNewEnd(self):
dat = [self.opts["conum"], self.group, self.code]
for x in range(len(self.na.t_work[0][0]) - 1):
dat.append(self.na.t_work[0][0][x])
self.sql.insRec("assmst", data=dat)
self.doNewXit()
def doNewXit(self):
self.na.closeProcess()
def queryAss(self):
callModule(self.opts["mf"],
self.df,
"ar4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=self.opts["period"],
user=self.opts["capnm"])
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 rt2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
tabs = [
"ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "genint", "genmst",
"gentrn", "rtlprm", "rtlmst", "rtlcon", "rtltrn"
]
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
if self.opts["rtn"] not in (2, 3, 4):
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
self.gc = GetCtl(self.opts["mf"])
rtlctl = self.gc.getCtl("rtlctl", self.opts["conum"])
if not rtlctl:
return
self.glint = rtlctl["ctr_glint"]
if self.glint == "Y":
# Check All Premises Control Records
errs = ("Premises %s Has An Invalid",
"Rental Control Account (%s)",
"Rental Income Account (%s)")
ass = self.sql.getRec(
"rtlprm",
cols=["rtp_code", "rtp_rtlacc", "rtp_incacc"],
where=[("rtp_cono", "=", self.opts["conum"])])
for acc in ass:
for x in range(1, 3):
chk = self.sql.getRec("genmst",
where=[("glm_cono", "=",
self.opts["conum"]),
("glm_acno", "=", acc[x])],
limit=1)
if not chk:
mess = "%s %s" % (errs[0] % acc[0], errs[x] % acc[x])
showError(self.opts["mf"].body, "Control Error", mess)
return
# Check for VAT Control
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return
self.convat = ctlctl["vat_ctl"]
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"RTL",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 2:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
return True
def drawDialog(self):
prm = {
"stype":
"R",
"tables": ("rtlprm", ),
"cols": (("rtp_code", "", 0, "Prm-Cod"), ("rtp_desc", "", 0,
"Description", "Y")),
"where": [("rtp_cono", "=", self.opts["conum"])]
}
mst = {
"stype":
"R",
"tables": ("rtlmst", ),
"cols":
(("rtm_acno", "", 0, "Acc-Num"), ("rtm_name", "", 0, "Name", "Y")),
"where": [("rtm_cono", "=", self.opts["conum"])],
"whera": [["C", "rtm_code", 0, 1]]
}
con = {
"stype":
"R",
"tables": ("rtlcon", ),
"cols":
(("rtc_cnum", "", 0, "Acc-Num"), ("rtc_payind", "", 0, "F"),
("rtc_start", "", 0, "Start-Date"), ("rtc_period", "", 0, "Per")),
"where": [("rtc_cono", "=", self.opts["conum"])],
"whera": [["C", "rtc_code", 0, 1], ["C", "rtc_acno", 1, 1]]
}
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"])]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INA", 7, "Prm-Cod", "Premises Code", "r", "N",
self.doPrmCod, prm, None, None),
(("C", 1, 0, 1), "INA", 7, "Acc-Num", "Account Number", "r",
"N", self.doAccNum, mst, None, None),
(("C", 1, 0, 2), "IUI", 3, "Seq", "Contract Sequence", "", "N",
self.doConSeq, con, None, None),
(("C", 1, 0, 3), "INa", 9, "Reference", "Reference Number", "i",
"N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, None),
(("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", "", "N",
self.doVatCod, vtm, None, ("notblank", )),
(("C", 1, 0, 7), "ISD", 11.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
[("C", 1, 0, 8), "INA", 30, "Details", "Transaction Details",
"", "N", self.doTrnDet, None, None, None]]
if self.opts["rtn"] not in (2, 3) and self.glint == "Y":
fld[10][2] = (22, 30)
fld.extend([[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 30, "Description"),
(("C", 2, 0,
2), "ISD", 13.2, "All-Amt", "Allocation Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 3), "INA", 30, "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))])
but = (("Interrogate", None, self.queryRtl, 0, ("C", 1, 1),
("C", 1, 2)), ("Cancel", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1)))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (2, 3) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doPrmCod(self, frt, pag, r, c, p, i, w):
whr = [("rtp_cono", "=", self.opts["conum"]), ("rtp_code", "=", w)]
acc = self.sql.getRec("rtlprm", where=whr, limit=1)
if not acc:
return "Invalid Premises Code"
self.code = w
self.rtlacc = acc[self.sql.rtlprm_col.index("rtp_rtlacc")]
def doAccNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("rtlmst",
cols=["rtm_name", "rtm_vatind"],
where=[("rtm_cono", "=", self.opts["conum"]),
("rtm_code", "=", self.code),
("rtm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.acno = w
con = self.sql.getRec("rtlcon",
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno)],
order="rtc_cnum")
if not con:
return "No Valid Contracts"
self.cnum = con[-1:][0][3]
self.df.colf[1][2][5] = self.cnum
if self.opts["rtn"] == 4:
self.df.colf[1][6][5] = acc[1]
else:
self.df.colf[1][6][5] = "N"
def doConSeq(self, frt, pag, r, c, p, i, w):
con = self.sql.getRec("rtlcon",
where=[("rtc_cono", "=", self.opts["conum"]),
("rtc_code", "=", self.code),
("rtc_acno", "=", self.acno),
("rtc_cnum", "=", w)],
order="rtc_cnum")
if not con:
return "Invalid Contract Sequence"
self.cnum = w
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.trnref = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.opts["rtn"] in (2, 3):
self.vatcode = ""
self.trnvat = 0
return "sk2"
def doVatCod(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.trnvat = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.trnvat)
if not self.trnvat:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.trnvat = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.trnvat = float(ASD(0) - ASD(w))
else:
self.trnvat = w
self.df.loadEntry(frt, pag, p, data=self.trnvat)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (2, 3) and self.glint == "Y":
self.df.colf[2][3][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] in (2, 3) or self.glint == "N":
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.trnamt = float(ASD(self.trnamt) - ASD(self.trnvat))
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.selPage("Allocation")
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.trnvat
if self.opts["rtn"] == 2: # Receipts
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.glt = 6
elif self.opts["rtn"] == 3: # Payments
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.glt = 2
elif self.opts["rtn"] == 4: # Journal Entries
self.recon = 0
self.glt = 4
# Rental Ledger Transaction
data = [
self.opts["conum"], self.code, self.acno, self.cnum,
self.opts["rtn"], self.trnref, self.bh.batno, self.trndat,
self.amt, self.vat, self.curdt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("rtltrn", data=data)
if self.vatcode:
# VAT Transaction (ctlvtf)
exc = float(ASD(0) - ASD(self.amt) + ASD(self.vat))
vat = float(ASD(0) - ASD(self.vat))
data = (self.opts["conum"], self.vatcode, "O", self.curdt, "R",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.code, self.trndet, exc, vat, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Rental Account
data = (self.opts["conum"], self.rtlacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, self.vat,
self.trndet, self.vatcode, "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
self.trnamt = float(ASD(0) - ASD(self.amt))
self.trnvat = float(ASD(0) - ASD(self.vat))
if self.vatcode and self.trnvat:
# General Ledger Control Transaction (V.A.T.)
data = (self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.trnvat, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
if self.opts["rtn"] in (2, 3):
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
# General Ledger Transaction (Source)
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.allamt, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryRtl(self):
callModule(self.opts["mf"],
self.df,
"rt4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class cr2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] not in (1, 2, 3, 4, 5):
showError(self.opts["mf"].body, "Control Error",
"Invalid Routine %s, Only 1 - 5 Are Allowed" % \
str(self.opts["rtn"]))
return
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "ctlvmf", "ctlvrf", "ctlvtf", "crsmst", "crstrn",
"genint", "genmst", "gentrn", "lonmf1", "lonmf2", "lonrte",
"lontrn", "wagedc", "wagmst", "waglmf", "wagltf"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Company record
self.gc = GetCtl(self.opts["mf"])
self.allcoy = self.opts["conum"]
self.allnam = self.opts["conam"]
ctlmst = self.gc.getCtl("ctlmst", self.allcoy)
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
# 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:
rec = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if rec:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in rec]
else:
self.incoac = False
# Get Enabled Modules
self.lonmod = False
self.lonpag = None
self.slnmod = False
self.slnpag = None
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
if ctlmst["ctm_modules"][x:x + 2] == "LN":
self.lonmod = True
elif ctlmst["ctm_modules"][x:x + 2] == "SL":
self.slnmod = True
# Rest of Controls
crsctl = self.gc.getCtl("crsctl", self.opts["conum"])
if not crsctl:
return
self.glint = crsctl["ctc_glint"]
self.glinp = crsctl["ctc_glinp"]
if self.glint == "Y":
self.ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not self.ctlctl:
return
ctls = ["crs_ctl", "vat_ctl", "dis_rec"]
if self.gc.chkRec(self.opts["conum"], self.ctlctl, ctls):
return
self.crsctl = self.ctlctl["crs_ctl"]
self.disrec = self.ctlctl["dis_rec"]
# Batch Header
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
if self.opts["rtn"] == 1:
self.glt = 5
elif self.opts["rtn"] == 2:
self.glt = 6
elif self.opts["rtn"] == 3:
self.glt = 4
elif self.opts["rtn"] == 4:
self.glt = 5
elif self.opts["rtn"] == 5:
self.glt = 2
self.agevar = tk.BooleanVar()
self.othvar = tk.BooleanVar()
self.agevar.set(False)
self.othvar.set(False)
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"CRS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
def drawDialog(self):
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")]
}
coy = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"whera": [("C", "glm_cono", 0, 2)]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
if self.opts["rtn"] in (1, 4) and self.lonmod:
lm1 = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols": (("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0,
"Name", "Y")),
"whera": [("C", "lm1_cono", 0, 2)]
}
lm2 = {
"stype":
"R",
"tables": ("lonmf2", ),
"cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0,
"Description", "Y")),
"whera": [("C", "lm2_cono", 0, 2), ("C", "lm2_acno", 0)]
}
if self.opts["rtn"] in (1, 4) and self.slnmod:
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0,
"Surname", "Y"),
("wgm_fname", "", 0, "Names")),
"whera": [("C", "wgm_cono", 0, 2)]
}
lnm = {
"stype":
"R",
"tables": ("waglmf", ),
"cols": (("wlm_loan", "", 0, "Ln"), ("wlm_desc", "", 0,
"Description", "Y")),
"where": [("wlm_cono", "=", self.opts["conum"])],
"whera": [("C", "wgm_cono", 0, 2), ("C", "wlm_empno", 0)]
}
ced = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"),
("ced_desc", "", 0, "Description", "Y")),
"where": [("ced_type", "=", "D")],
"whera": [("C", "wgm_cono", 0, 2)],
"index":
1
}
viw = {
"stype":
"R",
"tables": ("crstrn", ),
"cols": (("crt_acno", "", 0, ""), ("crt_ref1", "", 0, ""),
("crt_trdt", "", 0, ""), ("crt_tramt", "", 0,
""), ("crt_taxamt", "", 0, "")),
"where": [("crt_cono", "=", self.opts["conum"]),
("crt_type", "=", self.opts["rtn"]),
("crt_batch", "=", self.bh.batno)],
"order":
"crt_seq",
"comnd":
self.doView
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INA", 7, "Acc-Num", "Account Number", "r",
"Y", self.doCrsAcc, crm, None, None),
[("C", 1, 0, 1), "ONA", 10, "Name"],
(("C", 1, 0, 2), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doRef1, None, None, ("notblank", )),
(("C", 1, 0, 3), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 4), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, None)]
if self.opts["rtn"] in (2, 5):
fld[3][2] = 22
fld.extend([
(("C", 1, 0, 5), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, None, None,
"Discount Amount to be Added to the Transaction Amount."),
(("C", 1, 0, 6), "OSD", 13.2, "Total-Amount"),
[("C", 1, 0, 7), "INA", (22, 30), "Details",
"Transaction Details", "", "N", self.doTrnDet, None, None,
None]
])
elif self.glint == "Y":
if self.glinp == "E":
tx1 = "Exc-Amount"
tx2 = "Exclusive Amount"
else:
tx1 = "Inc-Amount"
tx2 = "Inclusive Amount"
fld[3][2] = 30
fld.extend([(("C", 1, 0, 5), "INA", (27, 30), "Details",
"Transaction Details", "", "N", self.doTrnDet, None,
None, None),
[("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"],
[("C", 2, 0, 0), "IUI", 3, "Coy", "Company Number",
self.opts["conum"], "N", self.doCoyNum, coy, None,
None],
(("C", 2, 0, 1), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 2), "ONA", 19, "Description"),
(("C", 2, 0, 3), "IUA", 1, "V", "V.A.T Code", "", "N",
self.doVatCode2, vtm, None, ("notblank", )),
(("C", 2, 0, 4), "ISD", 13.2, tx1, tx2, "", "N",
self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 5), "ISD", 13.2, "V.A.T", "V.A.T Amount",
"", "N", self.doAllVat, None, None, None),
(("C", 2, 0, 6), "INA", (26, 30), "Details", "",
"", "N", self.doAllDet, None, None, ("notblank", ))])
if not self.incoac:
fld[9][1] = "OUI"
nxt = 3
if self.opts["rtn"] in (1, 4) and self.lonmod:
fld.extend([
(("T", nxt, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", nxt, 0, 0), "IUA", 7, "Acc-Num", "Account Number",
0, "N", self.doLonAcc, lm1, None, None),
(("C", nxt, 0, 1), "ONA", 30, "Name"),
(("C", nxt, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N",
self.doLonNum, lm2, None, None),
(("C", nxt, 0, 3), "INA", 30, "Description", "", "", "N",
self.doLonDes, None, None, ("notblank", )),
(("C", nxt, 0, 4), "ISD", 13.2, "Amount", "", "", "N",
self.doLonAmt, None, None, ("efld", )),
(("C", nxt, 0, 5), "IUD", 6.2, "DRte-%", "Debit Rate", "",
"N", self.doLonDri, None, None, None),
(("C", nxt, 0, 6), "IUD", 6.2, "CRte-%", "Credit Rate", "",
"N", self.doLonDri, None, None, None),
(("C", nxt, 0, 7), "IUI", 3, "Mth", "Period in Months", "",
"N", self.doLonMth, None, None, ("efld", )),
(("C", nxt, 0, 8), "OUD", 12.2, "Repayment")
])
self.lonpag = nxt
nxt += 1
if self.opts["rtn"] in (1, 4) and self.slnmod:
fld.extend([
(("T", nxt, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", nxt, 0, 0), "IUI", 5, "EmpNo", "Employee Number", 0,
"N", self.doEmpNum, wgm, None, None),
(("C", nxt, 0, 1), "ONA", 20, "Name"),
(("C", nxt, 0, 2), "IUI", 2, "Ln", "Loan Number", "", "N",
self.doSlnNum, lnm, None, None),
(("C", nxt, 0, 3), "INA", 20, "Description", "", "", "N",
self.doSlnDes, None, None, ("notblank", )),
(("C", nxt, 0, 4), "ISD", 13.2, "Amount", "", "", "N",
self.doSlnAmt, None, None, ("efld", )),
(("C", nxt, 0, 5), "IUI", 3, "Cde", "Deduction Code", "",
"N", self.doSlnCod, ced, None, ("efld", )),
(("C", nxt, 0, 6), "ONA", 20, "Description"),
(("C", nxt, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate",
"", "N", self.doSlnInt, None, None, None),
(("C", nxt, 0,
8), "IUD", 13.2, "Ded-Amt", "Deduction Amount", "", "N",
self.doSlnDed, None, None, ("efld", ))
])
self.slnpag = nxt
else:
fld[3][2] = 20
fld.extend([(("C", 1, 0,
5), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode1, vtm, None, ("notblank", )),
(("C", 1, 0, 6), "ISD", 13.2, "V.A.T", "V.A.T Amount",
"", "N", self.doVatAmt, None, None, None),
[("C", 1, 0, 7), "INA", (18, 30), "Details",
"Transaction Details", "", "N", self.doTrnDet, None,
None, None]])
but = (
("Interrogate",None,self.queryCrs,0,("C",1,1),("C",1,2),
"Interrogate Creditors Records",1),
("View Entries",viw,None,0,("C",1,1),("C",1,2),
"View Batch Transactions",1),
("Maintain",None,self.maintainCrs,0,("C",1,1),("C",1,2),
"Maintain Creditors Records",1),
("Canc_el",None,self.doCancel,0,("C",2,1),("C",1,1),
"Cancel the Entry",1),
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",2),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",2),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated Transaction",2),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",2))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] not in (2, 5) and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
if self.opts["rtn"] in (1, 4) and self.lonmod:
tag.append(("LON", None, None, None, False))
cnd.append((self.endLon, "y"))
cxt.append(self.exitLon)
if self.opts["rtn"] in (1, 4) and self.slnmod:
tag.append(("SLN", None, None, None, False))
cnd.append((self.endSln, "y"))
cxt.append(self.exitSln)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doView(self, *event):
self.df.focusField("C", 1, 1)
def doCrsAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crsmst",
cols=[
"crm_name", "crm_terms", "crm_vatno",
"crm_termsb", "crm_stday", "crm_pydis",
"crm_glac", "crm_stat"
],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[7] == "X":
return "Invalid Account, Redundant"
self.cracno = w
self.name = acc[0]
self.term = acc[1]
self.vatn = acc[2]
self.base = acc[3]
self.stdt = acc[4]
self.pdis = acc[5]
self.glac = acc[6]
self.popv = False
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doRef1(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("crstrn",
cols=["crt_batch"],
where=[("crt_cono", "=", self.opts["conum"]),
("crt_acno", "=", self.cracno),
("crt_type", "=", self.opts["rtn"]),
("crt_ref1", "=", w)],
limit=1)
if acc:
return "Transaction Already Exists"
self.trnref = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.glint == "Y" or self.opts["rtn"] in (2, 5):
self.vatcode = "N"
self.vatamt = 0
if self.opts["rtn"] not in (2, 5) and self.glint == "N":
if not self.vatn:
self.df.loadEntry(frt, pag, p + 1, data="N")
else:
self.df.loadEntry(frt, pag, p + 1, data=self.taxdf)
def doVatCode1(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
if vrte and not self.vatn:
ok = askQuestion(self.opts["mf"].window, "VAT Number",
"This Account Does Not Have a VAT Number.\n\nMust "\
"it be Populated?", default="yes")
if ok == "yes":
self.vatn = w
self.popv = True
self.vatcode = w
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.vatamt)
if not self.vatamt:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.vatamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.vatamt = float(ASD(0) - ASD(w))
else:
self.vatamt = w
self.df.loadEntry(frt, pag, p, data=self.vatamt)
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.disamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.disamt = float(ASD(0) - ASD(w))
else:
self.disamt = w
self.df.loadEntry(frt, pag, p, data=self.disamt)
totamt = float(ASD(self.trnamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] not in (2, 5) and self.glint == "Y":
self.df.colf[2][6][5] = w
self.allocated = float(0.00)
def endPage1(self):
self.cancel = False
self.agecan = False
self.batupd = False
self.updateTables1()
if self.cancel:
return
else:
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] in (2, 5) or self.glint == "N":
self.doCrsTrn()
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.vatamt
if self.opts["rtn"] == 1: # Invoices
self.recon = 0
self.dis = 0.00
self.per = self.pdis
elif self.opts["rtn"] == 2: # Receipts
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.vat = 0.00
self.dis = self.disamt
self.per = 0.00
elif self.opts["rtn"] == 3: # Journals
self.recon = 0
self.dis = 0.00
self.per = 0.00
elif self.opts["rtn"] == 4: # Credit Notes
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.dis = 0.00
self.per = self.pdis
elif self.opts["rtn"] == 5: # Payments
if self.trnamt == 0:
self.recon = self.curdt
else:
self.recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = 0.00
self.dis = float(ASD(0) - ASD(self.disamt))
self.per = 0.00
if self.opts["rtn"] == 1:
self.doAgeCurrent()
else:
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(4, 8):
if self.opts["rtn"] == 3 and x == 6:
continue
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B4, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
if self.glint == "N":
return
# General Ledger Control Transaction (Creditors)
val = float(ASD(0) - ASD(self.amt) - ASD(self.dis))
data = (self.opts["conum"], self.crsctl, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, val, 0.00, self.trndet,
"N", "", self.recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Bank)
if self.opts["rtn"] in (2, 5):
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", self.recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.dis:
data = (self.opts["conum"], self.disrec, self.curdt,
self.trndat, self.glt, self.trnref, self.bh.batno,
self.dis, 0.00, self.trndet, "N", "", self.recon,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="crs",
agetyp=atype,
agekey=[
self.opts["conum"], self.cracno, self.opts["rtn"],
self.trnref, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
if self.agevar.get():
self.agevar.set(False)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
nam = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not nam:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", w),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.ctlctl = self.gc.getCtl("ctlctl", w)
if not self.ctlctl:
return "rf"
self.allcoy = w
self.allnam = nam[0]
self.df.loadEntry(frt, pag, p + 1, data=self.glac)
def doGenAcc(self, frt, pag, r, c, p, i, w):
ctl = True
self.loan = False
if "lon_ctl" in self.ctlctl and w == self.ctlctl["lon_ctl"]:
self.loan = "other"
elif "wag_slc" in self.ctlctl and w == self.ctlctl["wag_slc"]:
self.loan = "staff"
if self.loan:
ctl = False
chk = chkGenAcc(self.opts["mf"], self.allcoy, w, ctl=ctl)
if type(chk) is str:
return chk
if not self.vatn:
self.taxgl = "N"
elif not chk[2]:
self.taxgl = self.taxdf
else:
self.taxgl = chk[2]
self.genacc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
self.df.loadEntry(frt, pag, p + 2, data=self.taxgl)
def doVatCode2(self, frt, pag, r, c, p, i, w):
ctlctl = self.gc.getCtl("ctlctl", self.allcoy, error=False)
if not ctlctl:
return "Missing ctlctl Record for Company"
if self.gc.chkRec(self.allcoy, ctlctl, ["vat_ctl"]):
return "Missing or Invalid Control Record"
self.convat = ctlctl["vat_ctl"]
self.vatrte = getVatRate(self.sql, self.allcoy, w, self.trndat)
if self.vatrte is None:
return "Invalid V.A.T Code"
if self.vatrte and not self.vatn:
ok = askQuestion(self.opts["mf"].window, "VAT Number",
"This Account Does Not Have a VAT Number.\n\nMust "\
"it be Populated?", default="yes")
if ok == "yes":
self.vatn = w
self.popv = True
self.vatcode = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if not w:
incamt = float(ASD(self.trnamt) - ASD(self.allocated))
elif self.glinp == "E":
incamt = round((w * (100 + self.vatrte) / 100), 2)
else:
incamt = w
self.allamt = round((incamt * 100 / (100 + self.vatrte)), 2)
self.allvat = float(ASD(incamt) - ASD(self.allamt))
if self.glinp == "E":
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.df.loadEntry(frt, pag, p, data=incamt)
self.df.loadEntry(frt, pag, p + 1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p + 2, data=self.name)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if (self.allamt < 0 and w > 0) or (self.allamt > 0 and w < 0):
w = float(ASD(0) - ASD(w))
if self.glinp == "I" and w != self.allvat:
self.allamt = float(ASD(self.allamt) + ASD(self.allvat) - ASD(w))
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.cancel = True
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
for pg in range(self.df.pgs, 1, -1):
self.df.clearFrame("C", pg)
self.df.selPage("Transaction")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
if self.othvar.get():
self.othvar.set(False)
def endPage2(self):
self.updateTables2()
if self.loan and self.loan == "other":
self.othtot = self.allamt
self.df.selPage("LON")
self.df.loadEntry("T", self.lonpag, 0, data=self.othtot)
self.df.focusField("C", self.lonpag, 1)
self.othvar.set(True)
self.df.mstFrame.wait_variable(self.othvar)
if self.cancel:
return
elif self.loan and self.loan == "staff":
self.othtot = self.allamt
self.df.selPage("SLN")
self.df.loadEntry("T", self.slnpag, 0, data=self.othtot)
self.df.focusField("C", self.slnpag, 1)
self.othvar.set(True)
self.df.mstFrame.wait_variable(self.othvar)
if self.cancel:
return
self.allocated = float(ASD(self.allocated) + ASD(self.allamt) + \
ASD(self.allvat))
if self.allocated == self.trnamt:
self.doCrsTrn()
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1: # Invoices
self.debit()
elif self.opts["rtn"] == 3: # Journals
self.debit()
elif self.opts["rtn"] == 4: # Credit Notes
self.credit()
def debit(self):
amt = self.allamt
vat = self.allvat
self.restDebitCredit(amt, vat)
def credit(self):
amt = float(ASD(0) - ASD(self.allamt))
vat = float(ASD(0) - ASD(self.allvat))
self.restDebitCredit(amt, vat)
def restDebitCredit(self, amt, vat):
# VAT Transaction (ctlvtf)
data = (self.allcoy, self.vatcode, "I", self.curdt, "C",
self.opts["rtn"], self.bh.batno, self.trnref, self.trndat,
self.cracno, self.alldet, amt, vat, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Transaction (Expense)
data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, amt, vat, self.alldet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany)
if self.allcoy != self.opts["conum"]:
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.opts["conum"]),
("cti_inco", "=", self.allcoy)],
limit=1)[0]
val = float(ASD(amt) + ASD(vat))
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, val, 0.00, self.alldet, "N",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.allcoy),
("cti_inco", "=", self.opts["conum"])
],
limit=1)[0]
val = float(ASD(0) - ASD(amt) - ASD(vat))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.trnref, self.bh.batno, val, 0.00, self.alldet, "N",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if vat:
# General Ledger Control Transaction (V.A.T.)
data = (self.allcoy, self.convat, self.curdt, self.trndat,
self.glt, self.trnref, self.bh.batno, vat, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
self.vat = float(ASD(self.vat) + ASD(vat))
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def doCrsTrn(self):
# Creditors Master File
if self.popv:
self.sql.updRec("crsmst",
cols=["crm_vatno"],
data=["Unknown"],
where=[("crm_cono", "=", self.opts["conum"]),
("crm_acno", "=", self.cracno)])
# Creditors Ledger Transaction
paydt = paymentDate(self.base, self.stdt, self.term, self.trndat)
data = [
self.opts["conum"], self.cracno, self.opts["rtn"], self.trnref,
self.bh.batno, self.trndat, "", self.amt, self.vat, self.per,
self.curdt, paydt, "Y", self.amt, self.trndet, self.vatcode, "N",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("crstrn", data=data)
if not self.dis:
return
data = [
self.opts["conum"], self.cracno, 6, self.trnref, self.bh.batno,
self.trndat, "", self.dis, self.vat, 0, self.curdt, paydt, "Y",
self.dis, self.trndet, self.vatcode, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("crstrn", data=data)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryCrs(self):
callModule(self.opts["mf"],
self.df,
"cr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def maintainCrs(self):
callModule(self.opts["mf"],
self.df,
"cr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def doLonAcc(self, frt, pag, r, c, p, i, w):
newacc = False
if not w and self.opts["rtn"] == 1:
yn = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if yn == "no":
return "Invalid Account Number"
newacc = True
w = callModule(self.opts["mf"],
self.df,
"ln1010",
coy=(self.allcoy, self.allnam),
user=self.opts["capnm"],
args="auto",
ret="acno")
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("lonmf1",
cols=["lm1_name"],
where=[("lm1_cono", "=", self.allcoy),
("lm1_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.lonacc = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
if newacc:
self.lonnum = 1
self.newlon = True
self.df.loadEntry(frt, pag, p + 2, data=self.lonnum)
return "sk2"
def doLonNum(self, frt, pag, r, c, p, i, w):
if not w and self.opts["rtn"] == 1:
ok = askQuestion(self.opts["mf"].body,
head="New Loan",
mess="Is This a New Loan?",
default="no")
if ok == "yes":
self.newlon = True
self.lonnum = getNextCode(self.sql,
"lonmf2",
"lm2_loan",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc)
],
start=1,
last=9999999)
self.df.loadEntry(frt, pag, p, data=self.lonnum)
else:
return "Invalid Loan Number"
else:
self.lonmf2 = self.sql.getRec("lonmf2",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc),
("lm2_loan", "=", w)
],
limit=1)
if not self.lonmf2:
return "Invalid Loan Number"
self.lonnum = w
self.newlon = False
self.londes = self.lonmf2[self.sql.lonmf2_col.index("lm2_desc")]
self.londat = self.lonmf2[self.sql.lonmf2_col.index("lm2_start")]
self.lonmth = self.lonmf2[self.sql.lonmf2_col.index("lm2_pmths")]
self.lonpay = self.lonmf2[self.sql.lonmf2_col.index("lm2_repay")]
if self.lonmth:
return "Invalid Entry, Fixed Loan"
self.df.loadEntry(frt, pag, p + 1, data=self.londes)
return "sk1"
def doLonDes(self, frt, pag, r, c, p, i, w):
self.londes = w
def doLonAmt(self, frt, pag, r, c, p, i, w):
self.lonamt = w
if not self.lonamt:
self.lonamt = self.othtot
self.df.loadEntry(frt, pag, p, data=self.lonamt)
if not self.newlon:
self.newdri = 0
return "nd"
def doLonDri(self, frt, pag, r, c, p, i, w):
self.newdri = w
def doLonCri(self, frt, pag, r, c, p, i, w):
self.newcri = w
def doLonMth(self, frt, pag, r, c, p, i, w):
self.lonmth = w
if self.lonmth:
rte = (self.newdri / 1200.0)
self.lonpay = round(
((self.lonamt * rte) * ((1 + rte)**w)) / (((1 + rte)**w) - 1),
2)
else:
self.lonpay = 0
self.df.loadEntry(frt, pag, p + 1, data=self.lonpay)
def endLon(self):
if self.opts["rtn"] == 4:
tramt = float(ASD(0.0) - ASD(self.lonamt))
else:
tramt = self.lonamt
self.othtot = float(ASD(self.othtot) - ASD(self.lonamt))
if self.newlon:
# Loans Rate
self.sql.insRec("lonrte",
data=[
self.allcoy, self.lonacc, self.lonnum,
self.trndat, self.newdri, self.newcri
])
# Loans Ledger Masterfile
self.sql.insRec("lonmf2",
data=[
self.allcoy, self.lonacc, self.lonnum,
self.londes, self.trndat, self.lonmth,
self.lonpay, 0
])
self.othrtn = 2
else:
self.othrtn = 3
# Loans Ledger Transaction
data = [
self.allcoy, self.lonacc, self.lonnum, self.bh.batno, self.othrtn,
self.trndat, self.trnref, tramt, self.curdt, self.alldet, "",
self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("lontrn", data=data)
if self.othtot:
self.df.loadEntry("T", self.lonpag, 0, data=self.othtot)
self.df.advanceLine(self.lonpag)
else:
self.othvar.set(False)
def exitLon(self):
self.df.focusField("C", self.lonpag, self.df.col)
def doEmpNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("wagmst",
cols=["wgm_sname", "wgm_fname"],
where=[("wgm_cono", "=", self.allcoy),
("wgm_empno", "=", w)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.empnum = w
empnam = "%s, %s" % (acc[0], acc[1].split()[0])
self.df.loadEntry(frt, pag, p + 1, data=empnam)
def doSlnNum(self, frt, pag, r, c, p, i, w):
if not w and self.opts["rtn"] == 1:
ok = askQuestion(self.opts["mf"].body,
head="New Loan",
mess="Is This a New Loan?",
default="no")
if ok == "yes":
self.newsln = True
self.slnnum = getNextCode(self.sql,
"waglmf",
"wlm_loan",
where=[
("wlm_cono", "=", self.allcoy),
("wlm_empno", "=", self.empnum)
],
start=1,
last=9999999)
self.df.loadEntry(frt, pag, p, data=self.slnnum)
else:
return "Invalid Loan Number"
else:
acc = self.sql.getRec("waglmf",
where=[("wlm_cono", "=", self.allcoy),
("wlm_empno", "=", self.empnum),
("wlm_loan", "=", w)],
limit=1)
if not acc:
return "Invalid Loan Number"
self.slnnum = w
self.newsln = False
self.slndes = acc[self.sql.waglmf_col.index("wlm_desc")]
self.slncod = acc[self.sql.waglmf_col.index("wlm_code")]
self.slnrte = acc[self.sql.waglmf_col.index("wlm_rate")]
self.slndat = acc[self.sql.waglmf_col.index("wlm_start")]
self.slnded = acc[self.sql.waglmf_col.index("wlm_repay")]
self.df.loadEntry(frt, pag, p + 1, data=self.slndes)
return "sk1"
def doSlnDes(self, frt, pag, r, c, p, i, w):
self.slndes = w
def doSlnAmt(self, frt, pag, r, c, p, i, w):
self.slnamt = w
if not self.slnamt:
self.slnamt = self.othtot
self.df.loadEntry(frt, pag, p, data=self.slnamt)
if not self.newsln:
self.df.loadEntry(frt, pag, p + 1, data=self.slncod)
def doSlnCod(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=", self.allcoy),
("ced_type", "=", "D"),
("ced_code", "=", w)],
limit=1)
if not acc:
return "Invalid Code"
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
self.slncod = w
if not self.newsln:
self.newrte = 0
self.slnded = 0
return "nd"
def doSlnInt(self, frt, pag, r, c, p, i, w):
self.newrte = w
if not self.newsln:
self.df.loadEntry(frt, pag, p + 2, data=self.slnded)
def doSlnDed(self, frt, pag, r, c, p, i, w):
self.slnded = w
def endSln(self):
if self.opts["rtn"] == 4:
tramt = float(ASD(0.0) - ASD(self.slnamt))
else:
tramt = self.slnamt
self.othtot = float(ASD(self.othtot) - ASD(self.slnamt))
if self.newsln:
# Staff Loans Ledger Masterfile
self.sql.insRec("waglmf",
data=[
self.allcoy, self.empnum, self.slnnum,
self.slndes, self.slncod, self.newrte,
self.trndat, self.slnded
])
self.othrtn = 2
else:
self.othrtn = 3
# Staff Loans Ledger Transaction
data = [
self.allcoy, self.empnum, self.slnnum, self.bh.batno, self.othrtn,
self.trndat, self.trnref, tramt, tramt, self.slnded, self.newrte,
self.curdt, self.alldet, "", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("wagltf", data=data)
if self.othtot:
self.df.loadEntry("T", self.slnpag, 0, data=self.othtot)
self.df.advanceLine(self.slnpag)
else:
self.othvar.set(False)
def exitSln(self):
self.df.focusField("C", self.slnpag, self.df.col)
class sl2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.dataHeader()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(
self.opts["mf"].dbm,
["genmst", "gentrn", "wagedc", "wagmst", "waglmf", "wagltf"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
wagctl = self.gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.glint = wagctl["ctw_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["wag_slc"]):
return
self.slnctl = ctlctl["wag_slc"]
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"SLN",
2,
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
return True
def dataHeader(self):
wgm = {
"stype":
"R",
"tables": ("wagmst", ),
"cols": (("wgm_empno", "", 0, "EmpNo"), ("wgm_sname", "", 0,
"Surname", "Y")),
"where": [("wgm_cono", "=", self.opts["conum"])]
}
ced = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_type", "", 0, "T"), ("ced_code", "", 0, "Cde"),
("ced_desc", "", 0, "Description", "Y")),
"where": [("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D")],
"index":
1
}
fld = ((("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2,
"Value"), (("C", 0, 0, 0), "IUI", 5, "EmpNo",
"Employee Number", "", "N", self.doEmpno, wgm, None,
None), (("C", 0, 0, 1), "ONA", 20,
"Name"), (("C", 0, 0, 2), "OUI", 2, "Ln"),
(("C", 0, 0,
3), "INA", 15, "Description", "", "", "N", self.doDesc, None,
None, None), (("C", 0, 0, 4), "ID1", 10, "Date", "", "", "N",
self.doSdate, None, None, None),
(("C", 0, 0, 5), "INa", 9, "Ref-No", "Reference Number", "",
"N", self.doRef, None, None, ("notblank", )),
(("C", 0, 0, 6), "IUI", 3, "Cde", "Deduction Code", "", "N",
self.doCode, ced, None, ("notzero", )),
(("C", 0, 0, 7), "IUD", 6.2, "Intr-%", "Interest Rate", "", "N",
self.doInt, None, None,
None), (("C", 0, 0, 8), "IUD", 12.2, "Loan-Amt", "Loan Amount",
"", "N", self.doAmt, None, None, ("notzero", )),
(("C", 0, 0, 9), "IUD", 12.2, "Ded-Amt", "Deduction Amount", "",
"N", self.doDed, None, None, ("efld", )))
but = (("Interrogate", None, self.querySln, 0, ("C", 0, 1), ("C", 0,
2)), )
cnd = ((self.endPage, "y"), )
cxt = (self.exitPage, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
cend=cnd,
cxit=cxt)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 0, 1)
def doEmpno(self, frt, pag, r, c, p, i, w):
self.empno = w
acc = self.sql.getRec("wagmst",
cols=["wgm_sname", "wgm_fname"],
where=[("wgm_cono", "=", self.opts["conum"]),
("wgm_empno", "=", self.empno)],
limit=1)
if not acc:
return "Invalid Employee Number"
self.name = "%s, %s" % (acc[0], acc[1].split()[0])
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.loan = getNextCode(self.sql,
"waglmf",
"wlm_loan",
where=[("wlm_cono", "=", self.opts["conum"]),
("wlm_empno", "=", self.empno)],
start=1,
last=9999999)
self.df.loadEntry("C", pag, p + 2, data=self.loan)
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doSdate(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.sdate = w
def doRef(self, frt, pag, r, c, p, i, w):
self.ref = w
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
desc = self.sql.getRec("wagedc",
cols=["ced_desc"],
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", "D"),
("ced_code", "=", w)],
limit=1)
if not desc:
return "Invalid Code"
def doInt(self, frt, pag, r, c, p, i, w):
self.rte = w
def doAmt(self, frt, pag, r, c, p, i, w):
self.amt = w
def doDed(self, frt, pag, r, c, p, i, w):
self.ded = w
def endPage(self):
self.updateTables()
self.updateBatch()
self.opts["mf"].dbm.commitDbase()
self.df.advanceLine(0)
def exitPage(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def updateTables(self):
if self.bh.multi == "Y":
curdt = int(self.sdate / 100)
else:
curdt = self.bh.curdt
self.sql.insRec("waglmf",
data=[
self.opts["conum"], self.empno, self.loan,
self.desc, self.code, self.rte, self.sdate,
self.ded
])
self.sql.insRec("wagltf",
data=[
self.opts["conum"], self.empno, self.loan,
self.bh.batno, 2, self.sdate, self.ref, self.amt,
self.amt, self.ded, self.rte, curdt, self.desc,
"N", self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Staff Loans Control Account
data = (self.opts["conum"], self.slnctl, curdt, self.sdate, 2,
self.ref, self.bh.batno, self.amt, 0.00, self.name, "N", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
amt = float(ASD(0) - ASD(self.amt))
# General Ledger Bank Account
data = (self.opts["conum"], self.bh.acc, curdt, self.sdate, 2,
self.ref, self.bh.batno, amt, 0.00,
"Staff Loan - %s" % self.name, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def updateBatch(self):
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.amt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def querySln(self):
callModule(self.opts["mf"],
self.df,
"sl4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class dr2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] not in (1, 3, 4, 5):
showError(self.opts["mf"].body, "Control Error",
"Invalid Routine %s, Only 1, 3, 4 and 5 Are Allowed" % \
str(self.opts["rtn"]))
return
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, ["ctlmst", "ctlvmf", "ctlvrf",
"ctlvtf", "drschn", "drsmst", "drstrn", "genint", "genmst",
"gentrn"], prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst", cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])], limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint", cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
self.gc = GetCtl(self.opts["mf"])
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.glinp = drsctl["ctd_glinp"]
self.chains = drsctl["ctd_chain"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.drsctl = ctlctl["drs_ctl"]
self.dis_all = ctlctl["dis_all"]
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.allcoy = self.opts["conum"]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.chains == "N":
self.chain = 0
if self.opts["rtn"] == 1:
self.glt = 1
elif self.opts["rtn"] == 3:
self.glt = 4
elif self.opts["rtn"] == 4:
self.glt = 1
elif self.opts["rtn"] == 5:
self.glt = 2
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"], self.opts["conum"],
self.opts["conam"], self.opts["period"], "DRS", self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 4:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
drc = {
"stype": "R",
"tables": ("drschn",),
"cols": (
("chm_chain", "", 0, "Num"),
("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]}
drm = {
"stype": "R",
"tables": ("drsmst",),
"cols": (
("drm_acno", "", 0, "Acc-Num"),
("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"])]
drm["whera"] = [["C", "drm_chain", 0, 1]]
else:
drm["where"] = [
("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
coy = {
"stype": "R",
"tables": ("ctlmst",),
"cols": (
("ctm_cono", "", 0, "Coy"),
("ctm_name", "", 0, "Name", "Y"))}
glm = {
"stype": "R",
"tables": ("genmst",),
"cols": (
("glm_acno", "", 0, "Acc-Num"),
("glm_desc", "", 0, "Description", "Y")),
"whera": [["C", "glm_cono", 0, 2]]}
vtm = {
"stype": "R",
"tables": ("ctlvmf",),
"cols": (
("vtm_code", "", 0, "C"),
("vtm_desc", "", 0, "Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]}
viw = {
"stype": "R",
"tables": ("drstrn",),
"cols": (
("drt_chain", "", 0, ""),
("drt_acno", "", 0, ""),
("drt_ref1", "", 0, ""),
("drt_trdt", "", 0, ""),
("drt_tramt", "", 0, ""),
("drt_taxamt", "", 0, "")),
"where": [
("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_batch", "=", self.bh.batno)],
"order": "drt_seq"}
fld = [
(("T",0,0,0),"OUI",9,"Batch %s Quantity" % self.bh.batno),
(("T",0,0,0),"OSD",13.2,"Value"),
[("C",1,0,0),"IUI",3,"Chn","Chain Store",
"r","Y",self.doChain,drc,None,("efld",)],
[("C",1,0,1),"INA",7,"Acc-Num","Account Number",
"r","N",self.doDrsAcc,drm,None,("notblank",)],
[("C",1,0,2),"ONA",10,"Name"],
(("C",1,0,3),"INa",9,"Reference","Reference Number One",
"i","N",self.doRef1,None,None,("notblank",)),
(("C",1,0,4),"ID1",10,"Date","Transaction Date",
"r","N",self.doTrnDat,None,None,("efld",)),
(("C",1,0,5),"ISD",13.2,"Amount","Transaction Amount",
"","N",self.doTrnAmt,None,None,("efld",))]
if self.opts["rtn"] == 5:
fld[4][2] = 20
fld.extend([
[["C",1,0,6],"ISD",13.2,"Discount",
"Discount Amount","","N",self.doDisAmt,None,None,None,None,
"Discout Amount to be Added to the Transaction Amount"],
[["C",1,0,7],"OSD",13.2,"Total-Amount"],
[["C",1,0,8],"INA",(20,30),"Details","Transaction Details",
"","N",self.doTrnDet,None,None,None]])
elif self.glint == "Y":
if self.glinp == "E":
tx1 = "Exc-Amount"
tx2 = "Exclusive Amount"
else:
tx1 = "Inc-Amount"
tx2 = "Inclusive Amount"
fld[4][2] = 24
fld.extend([
[["C",1,0,6],"INA",30,"Details","Transaction Details",
"","N",self.doTrnDet,None,None,None],
[("T",2,0,0),"OSD",13.2,"Unallocated Balance"],
[("C",2,0,0),"IUI",3,"Coy","Company Number",
self.opts["conum"],"N",self.doCoyNum,coy,None,None],
(("C",2,0,1),"IUI",7,"Acc-Num","Account Number",
"","N",self.doGenAcc,glm,None,None),
(("C",2,0,2),"ONA",19,"Description"),
(("C",2,0,3),"IUA",1,"V","V.A.T Code",
self.taxdf,"N",self.doVatCode2,vtm,None,("notblank",)),
(("C",2,0,4),"ISD",13.2,tx1,tx2,
"","N",self.doAllAmt,None,None,("efld",)),
(("C",2,0,5),"ISD",13.2,"V.A.T","V.A.T Amount",
"","N",self.doAllVat,None,None,None),
[("C",2,0,6),"INA",(26,30),"Details","",
"","N",self.doAllDet,None,None,("notblank",)]])
if not self.incoac:
fld[10][1] = "OUI"
else:
fld[4][2] = 22
fld.extend([
(("C",1,0,6),"IUA",1,"V","V.A.T Code",
self.taxdf,"N",self.doVatCode1,vtm,None,("notblank",)),
(("C",1,0,7),"ISD",13.2,"V.A.T","V.A.T Amount",
"","N",self.doVatAmt,None,None,None),
[["C",1,0,8],"INA",(20,30),"Details","Transaction Details",
"","N",self.doTrnDet,None,None,None]])
if self.chains == "N":
fld[2][1] = "OUI"
idx = 2
else:
idx = 1
but = (
("Interrogate",None,self.queryDrs,0,("C",1,idx),("C",1,idx+1),
"Interrogate Debtors Records",1),
("View Entries",viw,None,0,("C",1,idx),("C",1,idx+1),
"View Batch Transactions",1),
("Maintain",None,self.maintainDrs,0,("C",1,idx),("C",1,idx+1),
"Maintain Debtors Records",1),
("Canc_el",None,self.doCancel,0,("C",2,1),("C",1,1),
"Cancel the Entry",1),
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",2),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",2),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",2),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",2))
tag = [("Transaction", None, None, None, False)]
cnd = [(None,"n"), (self.endPage1,"y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] != 5 and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2,"y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"], eflds=fld, tags=tag, cend=cnd,
cxit=cxt, butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn", cols=["chm_chain"],
where=[("chm_cono", "=", self.opts["conum"]), ("chm_chain",
"=", w)], limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doDrsAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst", cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]), ("drm_chain", "=",
self.chain), ("drm_acno", "=", w)], limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.dracno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p+1, data=self.name)
def doRef1(self, frt, pag, r, c, p, i, w):
self.ref1 = w
acc = self.sql.getRec("drstrn", cols=["drt_batch"],
where=[("drt_cono", "=", self.opts["conum"]), ("drt_chain", "=",
self.chain), ("drt_acno", "=", self.dracno), ("drt_type", "=",
self.opts["rtn"]), ("drt_ref1", "=", self.ref1)], limit=1)
if acc:
return "Transaction Already Exists"
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.glint == "Y" or self.opts["rtn"] == 5:
self.vatcode = "N"
self.vatamt = 0
def doVatCode1(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p+1, self.vatamt)
if not self.vatamt:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.vatamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.vatamt = float(ASD(0) - ASD(w))
else:
self.vatamt = w
self.df.loadEntry(frt, pag, p, data=self.vatamt)
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.disamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.disamt = float(ASD(0) - ASD(w))
else:
self.disamt = w
self.df.loadEntry(frt, pag, p, data=self.disamt)
totamt = float(ASD(self.trnamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p+1, data=totamt)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] != 5 and self.glint == "Y":
self.df.colf[2][6][5] = w
self.allocated = float(0.00)
def endPage1(self):
self.cancel = False
self.agecan = False
self.batupd = False
self.updateTables1()
if self.cancel:
return
else:
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] == 5 or self.glint == "N":
self.doDrsTrn()
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.vatamt
if self.opts["rtn"] == 1: # Invoices
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 3: # Journals
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 4: # Credit Notes
recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.vat = float(ASD(0) - ASD(self.vat))
self.dis = 0.00
elif self.opts["rtn"] == 5: # Payments
if self.trnamt == 0:
recon = self.curdt
else:
recon = 0
self.vat = 0.00
self.dis = self.disamt
if self.opts["rtn"] == 1:
self.doAgeCurrent()
else:
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(4, 8):
if self.opts["rtn"] == 3 and x == 6:
continue
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B4, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
if self.glint == "N":
return
# General Ledger Control Transaction (Debtors)
val = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.drsctl, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet,
"N", "", recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Bank)
if self.opts["rtn"] == 5:
val = float(ASD(0) - ASD(self.amt))
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, val, 0.00, self.trndet,
"N", "", recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.dis:
val = float(ASD(0) - ASD(self.dis))
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.ref1, self.bh.batno, val,
0.00, self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"], system="drs", agetyp=atype,
agekey=[self.opts["conum"], self.chain, self.dracno,
self.opts["rtn"], self.ref1, self.curdt, self.amt,
self.dis])
self.agecan = age.cancel
if self.agevar.get():
self.agevar.set(False)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlmst", cols=["ctm_name"],
where=[("ctm_cono", "=", w)], limit=1)
if not acc:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint", where=[("cti_cono", "=",
w), ("cti_inco", "=", self.opts["conum"])], limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.allcoy = w
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.allcoy, w)
if type(chk) is str:
return chk
if not chk[2]:
self.taxgl = self.taxdf
else:
self.taxgl = chk[2]
self.genacc = w
self.df.loadEntry("C", pag, p+1, chk[0])
self.df.loadEntry("C", pag, p+2, data=self.taxgl)
def doVatCode2(self, frt, pag, r, c, p, i, w):
ctlctl = self.gc.getCtl("ctlctl", self.allcoy, error=False)
if not ctlctl:
return "Missing ctlctl Record for Company"
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return "Missing or Invalid Control Record"
self.convat = ctlctl["vat_ctl"]
self.vatrte = getVatRate(self.sql, self.allcoy, w, self.trndat)
if self.vatrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if not w:
incamt = float(ASD(self.trnamt) - ASD(self.allocated))
elif self.glinp == "E":
incamt = round((w * (100 + self.vatrte) / 100), 2)
else:
incamt = w
self.allamt = round((incamt * 100 / (100 + self.vatrte)), 2)
self.allvat = float(ASD(incamt) - ASD(self.allamt))
if self.glinp == "E":
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.df.loadEntry(frt, pag, p, data=incamt)
self.df.loadEntry(frt, pag, p+1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p+2, data=self.name)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if (self.allamt < 0 and w > 0) or (self.allamt > 0 and w < 0):
w = float(ASD(0) - ASD(w))
if self.glinp == "I" and w != self.allvat:
self.allamt = float(ASD(self.allamt) + ASD(self.allvat) - ASD(w))
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p+1, data=self.name)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(self.opts["mf"].body, head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.cancel = True
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
if self.glint == "Y" and self.opts["rtn"] != 5:
self.df.clearFrame("C", 2)
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.selPage("Transaction")
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + \
ASD(self.allamt) + ASD(self.allvat))
if self.allocated == self.trnamt:
self.doDrsTrn()
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1: # Invoices
self.credit()
elif self.opts["rtn"] == 3: # Journals
self.credit()
elif self.opts["rtn"] == 4: # Credit Notes
self.debit()
def debit(self):
amt = self.allamt
vat = self.allvat
self.restDebitCredit(amt, vat)
def credit(self):
amt = float(ASD(0) - ASD(self.allamt))
vat = float(ASD(0) - ASD(self.allvat))
self.restDebitCredit(amt, vat)
def restDebitCredit(self, amt, vat):
# VAT Transaction (ctlvtf)
data = (self.allcoy, self.vatcode, "O", self.curdt, "D",
self.opts["rtn"], self.bh.batno, self.ref1, self.trndat,
self.dracno, self.alldet, amt, vat, 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Transaction (Allocation)
data = (self.allcoy, self.genacc, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, amt, vat, self.alldet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany)
if self.allcoy != self.opts["conum"]:
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint", cols=["cti_acno"],
where=[("cti_cono", "=", self.opts["conum"]), ("cti_inco", "=",
self.allcoy)], limit=1)[0]
val = float(ASD(amt) + ASD(vat))
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.ref1, self.bh.batno, val, 0.00, self.alldet, "N",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint", cols=["cti_acno"],
where=[("cti_cono", "=", self.allcoy), ("cti_inco", "=",
self.opts["conum"])], limit=1)[0]
val = float(ASD(0) - ASD(amt) - ASD(vat))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.ref1, self.bh.batno, val, 0.00, self.alldet, "N",
"", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if vat:
# General Ledger Control Transaction (V.A.T.)
data = (self.allcoy, self.convat, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, vat, 0.00, self.alldet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
self.vat = float(ASD(self.vat) + ASD(vat))
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def doDrsTrn(self):
# Debtors Ledger Transaction
data = [self.opts["conum"], self.chain, self.dracno, self.opts["rtn"],
self.ref1, self.bh.batno, self.trndat, "", self.amt, self.vat,
self.curdt, self.trndet, self.vatcode, "N", self.opts["capnm"],
self.sysdtw, 0]
self.sql.insRec("drstrn", data=data)
if not self.dis:
return
data = [self.opts["conum"], self.chain, self.dracno, 6, self.ref1,
self.bh.batno, self.trndat, "", self.dis, self.vat, self.curdt,
self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0]
self.sql.insRec("drstrn", data=data)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryDrs(self):
callModule(self.opts["mf"], self.df, "dr4010", coy=(self.opts["conum"],
self.opts["conam"]), period=None, user=self.opts["capnm"])
def maintainDrs(self):
callModule(self.opts["mf"], self.df, "dr1010", coy=(self.opts["conum"],
self.opts["conam"]), period=None, user=self.opts["capnm"])
class dr1020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.buildScreen()
self.opts["mf"].startLoop()
def setVariables(self):
self.sql = Sql(
self.opts["mf"].dbm,
["ctlvmf", "drschn", "drsmst", "drsrcm", "drsrct", "genmst"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if not self.taxdf:
self.taxdf = "N"
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.chains = drsctl["ctd_chain"]
self.glac = 0
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.s_per = int(self.opts["period"][1][0] / 100)
self.e_per = int(self.opts["period"][2][0] / 100)
return True
def buildScreen(self):
num_sel = {
"stype":
"R",
"tables": ("drsrcm", ),
"cols":
(("dcm_num", "", 0, "Number"), ("dcm_desc", "", 0, "Description",
"Y"), ("dcm_freq", "", 0, "F")),
"where": [("dcm_cono", "=", self.opts["conum"])]
}
seq_sel = {
"stype":
"R",
"tables": ("drsrct", ),
"cols":
(("dct_seq", "", 0, "Seq"), ("dct_chain", "", 0, "Chn"),
("dct_acno", "", 0,
"Acc-Num"), ("dct_detail", "", 0,
"Charge Details"), ("dct_amnt", "", 0, "Amount"),
("dct_start", "", 0, "Start"), ("dct_end", "", 0, "End")),
"where": [("dct_cono", "=", self.opts["conum"])],
"whera": (("T", "dct_num", 0), )
}
chn_sel = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm_sel = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y")),
"where": [("drm_cono", "=", self.opts["conum"]),
("drm_stat", "<>", "X")],
"whera": (("C", "drm_chain", 1, 0), )
}
glm_sel = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vat_sel = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
r1s = (("Monthly", "M"), ("Quarterly", "3"), ("Bi-Annually", "6"),
("Annually", "Y"))
fld = [
(("T",0,0,0),"IUI",3, "Number","Charge Number",
"","Y",self.doNum,num_sel,None,None),
(("T",0,1,0),"INA",30,"Description","",
"","N",self.doDesc,None,self.doDelNum,("notblank",)),
(("T",0,2,0),("IRB",r1s),0, "Frequency","",
"M","N",self.doFreq,None,None,None),
(("T",0,3,0),"IUI",2, "Day of the Month","Day of the Month",
"","N",self.doDay,num_sel,None,("between",1,30),None,
"Enter the day of the month when the entry must be raised. "\
"Use 30 to denote the last day of the month.")]
if self.glint == "Y":
fld.append(
(("T", 0, 4, 0), "IUI", 7, "Charge Account", "G/L Account", "",
"N", self.doGlAc, glm_sel, None, ("notzero", )))
fld.append((("T", 0, 4, 0), "ONA", 30, ""))
nxt = 5
else:
nxt = 4
fld.append(
(("T", 0, nxt, 0), "IUA", 1, "VAT Code", "V.A.T. Code", self.taxdf,
"N", self.doVat, vat_sel, None, ("notblank", )))
fld.append((("C", 0, 0, 0), "IUI", 3, "Seq", "Sequence Number", "i",
"N", self.doSeq, seq_sel, None, ("notzero", )))
if self.chains == "Y":
fld.append((("C", 0, 0, 0), "IUI", 3, "Chn", "Chain Store", "",
"N", self.doChn, chn_sel, self.doDelSeq, ("efld", )))
else:
self.chn = 0
fld.append((("C", 0, 0, 0), "OUI", 3, "Chn"))
fld.append((("C", 0, 0, 1), "INA", 7, "Acc-Num", "Account Number", "",
"N", self.doAcc, drm_sel, self.doDelSeq, ("efld", )))
fld.extend(
((("C", 0, 0, 2), "ONA", 30, "Name", "", "", "N", None, None, None,
None), (("C", 0, 0, 3), "ITX", 30, "Charge-Details",
"Charge Details", "", "N", self.doDetail, None, None,
None), (("C", 0, 0, 4), "ISD", 13.2, "Excl-Value",
"Period Exclusive Value", "", "N", self.doValue,
None, None, ("efld", )),
(("C", 0, 0, 5), "ID2", 7, "Start", "Starting Period", "", "N",
self.doStart, None, None, ("efld", )),
(("C", 0, 0, 6), "ID2", 7, "End", "Ending Period", "", "N",
self.doEnd, None, None, ("efld", ))))
but = (("All Entries", seq_sel, None, 0, ("C", 0, 1),
(("T", 0, 1), ("C", 0,
2))), ("Re-Sequence", None, self.doReSeq, 0,
("C", 0, 1), (("T", 0, 1), ("C", 0, 2))),
("Abort Changes", None, self.doAbort, 0, ("C", 0, 1), ("T", 0,
1)))
tnd = ((self.endTop, "y"), )
txt = (self.exitTop, )
cnd = ((self.endCol, "y"), )
cxt = (self.exitCol, )
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
butt=but,
tend=tnd,
txit=txt,
cend=cnd,
cxit=cxt)
def doNum(self, frt, pag, r, c, p, i, w):
if not w:
num = self.sql.getRec("drsrcm",
cols=["max(dcm_num)"],
where=[("dcm_cono", "=", self.opts["conum"])
],
limit=1)
if not num or not num[0]:
self.num = 1
else:
self.num = num[0] + 1
self.df.loadEntry(frt, pag, p, data=self.num)
else:
self.num = w
self.rcm = self.sql.getRec("drsrcm",
where=[("dcm_cono", "=",
self.opts["conum"]),
("dcm_num", "=", self.num)],
limit=1)
if not self.rcm:
if self.num == 999:
return "Invalid Number (999), Reserved for Sales Invoices"
self.new_num = "y"
self.nxt = 1
else:
d = self.sql.drsrcm_col
self.new_num = "n"
self.df.loadEntry(frt,
pag,
p + 1,
data=self.rcm[d.index("dcm_desc")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.rcm[d.index("dcm_freq")])
self.df.loadEntry(frt,
pag,
p + 3,
data=self.rcm[d.index("dcm_day")])
if self.glint == "Y":
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rcm[d.index("dcm_glac")])
self.df.loadEntry(frt, pag, p + 5, data=self.getAccount())
self.df.loadEntry(frt,
pag,
p + 6,
data=self.rcm[d.index("dcm_vat")])
else:
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rcm[d.index("dcm_vat")])
for x in range(2):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
if self.num == 999:
return "nd"
def getAccount(self):
return self.sql.getRec("genmst",
cols=["glm_desc"],
where=[("glm_cono", "=", self.opts["conum"]),
("glm_acno", "=",
self.df.t_work[0][0][4])],
limit=1)[0]
def doDelNum(self):
if self.new_num == "y":
return
self.sql.delRec("drsrcm",
where=[("dcm_cono", "=", self.opts["conum"]),
("dcm_num", "=", self.num)])
try:
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.acc)])
except:
pass
def doDesc(self, frt, pag, r, c, p, i, w):
self.desc = w
def doFreq(self, frt, pag, r, c, p, i, w):
self.freq = w
if self.glint == "N":
self.vcod = self.taxdf
def doDay(self, frt, pag, r, c, p, i, w):
self.day = w
def doGlAc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
self.glac = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
if not chk[2]:
self.vcod = self.taxdf
else:
self.vcod = chk[2]
self.df.topf[0][4][8] = self.vcod
def doVat(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlvmf",
cols=["vtm_desc"],
where=[("vtm_cono", "=", self.opts["conum"]),
("vtm_code", "=", w)],
limit=1)
if not acc:
return "Invalid VAT Code"
self.vcod = w
def endTop(self):
data = [
self.opts["conum"], self.num, self.desc, self.freq, self.day,
self.vcod, self.glac, 0
]
if self.new_num == "y":
self.sql.insRec("drsrcm", data=data)
self.df.loadEntry("C", 0, 0, data=1)
self.df.focusField("C", 0, self.nxt)
else:
if data != self.rcm[:len(data)]:
col = self.sql.drsrcm_col
data.append(self.rcm[col.index("dcm_xflag")])
self.sql.updRec("drsrcm",
data=data,
where=[("dcm_cono", "=", self.opts["conum"]),
("dcm_num", "=", self.num)])
self.doReload()
def exitTop(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doSeq(self, frt, pag, r, c, p, i, w):
self.seq = w
self.rct = self.sql.getRec("drsrct",
where=[("dct_cono", "=",
self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)],
limit=1)
if not self.rct:
self.new_seq = "y"
else:
self.new_seq = "n"
col = self.sql.drsrct_col
self.df.loadEntry(frt,
pag,
p + 1,
data=self.rct[col.index("dct_chain")])
self.df.loadEntry(frt,
pag,
p + 2,
data=self.rct[col.index("dct_acno")])
acc = self.sql.getRec("drsmst",
cols=["drm_name"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=",
self.rct[col.index("dct_chain")]),
("drm_acno", "=",
self.rct[col.index("dct_acno")])],
limit=1)
self.df.loadEntry(frt, pag, p + 3, data=acc[0])
self.df.loadEntry(frt,
pag,
p + 4,
data=self.rct[col.index("dct_detail")])
self.df.loadEntry(frt,
pag,
p + 5,
data=self.rct[col.index("dct_amnt")])
self.df.loadEntry(frt,
pag,
p + 6,
data=self.rct[col.index("dct_start")])
self.df.loadEntry(frt,
pag,
p + 7,
data=self.rct[col.index("dct_end")])
def doDelSeq(self):
if self.new_seq == "y":
return
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)])
self.doReload()
def doChn(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
where=[("chm_cono", "=", self.opts["conum"]),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chn = w
def doAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", self.chn),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.acc = w
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doDetail(self, frt, pag, r, c, p, i, w):
self.det = w
def doValue(self, frt, pag, r, c, p, i, w):
self.val = w
def doStart(self, frt, pag, r, c, p, i, w):
self.start = w
def doEnd(self, frt, pag, r, c, p, i, w):
if w < self.start:
return "Invalid End Date, Before Start"
self.end = w
def endCol(self):
data = [
self.opts["conum"], self.num, self.seq, self.chn, self.acc,
self.det, self.val, self.start, self.end
]
if self.new_seq == "y":
self.sql.insRec("drsrct", data=data)
elif data != self.rct[:len(data)]:
col = self.sql.drsrct_col
data.append(self.rct[col.index("dct_xflag")])
self.sql.updRec("drsrct",
data=data,
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("dct_seq", "=", self.seq)])
self.doReload()
def exitCol(self):
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doReSeq(self):
recs = self.sql.getRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num)],
order="dct_chain, dct_acno")
self.sql.delRec("drsrct",
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num)])
seq = 0
for rec in recs:
seq += 1
rec[2] = seq
self.sql.insRec("drsrct", data=rec)
self.doReload()
def doAbort(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doReload(self):
self.df.clearFrame("C", 0)
last = (self.df.rows[0] - 1) * 8
trn = self.sql.getRec(tables=["drsrct", "drsmst"],
cols=[
"dct_seq", "dct_chain", "dct_acno",
"drm_name", "dct_detail", "dct_amnt",
"dct_start", "dct_end"
],
where=[("dct_cono", "=", self.opts["conum"]),
("dct_num", "=", self.num),
("drm_cono=dct_cono", ),
("drm_chain=dct_chain", ),
("drm_acno=dct_acno", )],
order="dct_seq")
if trn:
for s, t in enumerate(trn):
if s >= self.df.rows[0]:
self.df.scrollScreen(0)
p = last
else:
p = s * 8
self.df.loadEntry("C", 0, p, data=t[0])
self.df.loadEntry("C", 0, p + 1, data=t[1])
self.df.loadEntry("C", 0, p + 2, data=t[2])
self.df.loadEntry("C", 0, p + 3, data=t[3])
self.df.loadEntry("C", 0, p + 4, data=t[4])
self.df.loadEntry("C", 0, p + 5, data=t[5])
self.df.loadEntry("C", 0, p + 6, data=t[6])
self.df.loadEntry("C", 0, p + 7, data=t[7])
if p == last:
self.df.scrollScreen(0)
self.nxt = last + 1
else:
self.nxt = p + 9
else:
self.nxt = 1
self.df.focusField("C", 0, self.nxt)
class wgc310(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", "wagrcv", "wagedc", "wagtf2"],
prog=self.__class__.__name__)
if self.sql.error:
return
self.gc = GetCtl(self.opts["mf"])
wagctl = self.gc.getCtl("wagctl", self.opts["conum"])
if not wagctl:
return
self.glint = wagctl["ctw_glint"]
return True
def mainProcess(self):
ced = {
"stype":
"R",
"tables": ("wagedc", ),
"cols": (("ced_code", "", 0, "Cde"), ("ced_desc", "", 0,
"Description", "Y")),
"where": [("ced_cono", "=", self.opts["conum"])],
"whera": [["T", "ced_type", 0]],
"order":
"ced_code"
}
bas = {
"stype":
"C",
"titl":
"Available Base Rates",
"head": ("C", "Description"),
"data":
((1, "X * Normal Rate of Pay * Factor"),
(2, "Normal Pay * Factor"), (3, "Normal Pay * Factor / 100"),
(4, "X * Daily Rate of Pay * Factor"),
(5, "X * Hourly Rate of Pay * Factor"),
(6, "U.I.F. Pay * Factor"), (7, "S.D.L. Pay * Factor"))
}
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"])]
}
rcv = {
"stype":
"R",
"tables": ("wagrcv", ),
"cols":
(("rcv_code", "", 0, "Code"), ("rcv_desc", "", 0, "Details", "Y"))
}
r1s = (("Variable", "V"), ("Fixed", "F"))
r2s = (("Amount", "A"), ("Rate", "R"))
r3s = (("Salary", "S"), ("Commission", "C"))
r4s = (("Amount", "A"), ("Rate", "R"), ("None", "N"))
r5s = (("Yes", "Y"), ("No", "N"), ("Notional", "T"), ("One Time", "O"),
("Retrench", "R"))
r6s = (("Yes", "Y"), ("No", "N"))
tag = (("Detail-_A", None, ("T", 0, 0), ("T", 0, 1)),
("Detail-_B", None, ("T", 0, 0), ("T", 0, 1)))
self.fld = ((("T", 0, 0,
0), "IUA", 1, "Type", "Earning/Deduction Type", "E", "N",
self.doType, None, None, ("in", ("E", "D"))),
(("T", 0, 0, 0), "IUI", 3, "Code", "", "", "N",
self.doCode, ced, None, ("notzero", )),
(("T", 0, 0, 0), "ONA", 30, "Description"),
(("T", 1, 0, 0), "INA", 30, "Description", "", "", "N",
self.doDesc, None, self.doDelete,
("notblank", )), (("T", 1, 1, 0), ("IRB", r1s), 0, "Type",
"", "V", "N", None, None, None, None),
(("T", 1, 2, 0), ("IRB", r2s), 0, "Employee Portion", "",
"A", "N", self.doEmployeePortion, None, None, None),
(("T", 1, 3, 0), "IUI", 3, " Base", "", "", "N",
self.doEmployeeBase, bas, None,
("between", 0,
7)), (("T", 1, 4, 0), "IUD", 8.2, " Value", "",
"", "N", self.doValue, None, None, ("efld", )),
(("T", 1, 5, 0), "IUD", 8.2, " Limit", "", "", "N",
self.doElim, None, None, ("efld", )),
(("T", 1, 6, 0), "IUI", 3, " GL/Cono", "", "", "N",
self.doEglco, coy, None,
("efld", )), (("T", 1, 6,
0), "IUI", 7, " GL/Acno", "", "",
"N", self.doEglno, glm, None, ("efld", )),
(("T", 1, 7, 0), ("IRB", r3s), 0, "Earnings Type", "", "S",
"N", self.doEarnType, None, None,
None), (("T", 1, 8,
0), ("IRB", r4s), 0, "Employer Portion", "", "N",
"N", self.doEmployerPortion, None, None, None),
(("T", 1, 9, 0), "IUI", 3, " Base", "Base", "",
"N", self.doEmployerBase, bas, None,
("between", 0,
7)), (("T", 1, 10, 0), "IUD", 8.2, " Value", "",
"", "N", None, None, None,
("efld", )), (("T", 1, 11, 0), "IUD", 8.2,
" Limit", "", "", "N",
self.doRlim, None, None, ("efld", )),
(("T", 1, 12, 0), "IUI", 3, " GL/Cono", "", "",
"N", self.doRglco, coy, None,
("efld", )), (("T", 1, 12,
0), "IUI", 7, " GL/Acno", "", "",
"N", self.doRglno, glm, None, ("efld", )),
(("T", 1, 13, 0), ("IRB", r5s), 0, "Tax Code", "", "N",
"N", self.doTaxcode, None, None,
None), (("T", 1, 14, 0), "IUD", 6.2, "Tax Portion", "",
"", "N", self.doTaxportion, None, None,
("efld", )), (("T", 2,
0, 0), "IUI", 4, "Rec Of Rev Code",
"", "", "N", self.doRcv, rcv, None,
("notzero", )), (("T", 2, 0, 0),
"ONA", 30, ""),
(("T", 2, 1, 0), ("IRB", r6s), 0, "Union Report", "", "N",
"N", self.doUniRep, None, None,
None), (("T", 2, 2, 0), ("IRB", r6s), 0, "Must Pay", "",
"N", "N", None, None, None, None),
(("T", 2, 3, 0), "IUI", 2, "Balance Number", "", "", "N",
self.doBalNo, None, None,
("between", 0,
3)), (("T", 2, 4, 0), "IUD", 5.2, "Hourly Limit", "", "",
"N", self.doLimit, None, None, ("efld", )),
(("T", 2, 5, 0), ("IRB", r6s), 0, "Monthly Deduction", "",
"N", "N", self.doMthly, None, None,
None), (("T", 2, 6, 0), "IUD", 6.2, "UIF Percentage", "",
"", "N", None, None, None,
("efld", )), (("T", 2, 7, 0), "IUD", 6.2,
"SDL Percentage", "", "", "N", None,
None, None, ("efld", )))
but = (("Accept", None, self.doAccept, 0, ("T", 1, 1), ("T", 0, 0)),
("Cancel", None, self.doCancel, 0, ("T", 1, 1),
("T", 0, 0)), ("Quit", None, self.doExit0, 1, None, None))
tnd = ((self.doEnd0, "N"), (self.doEnd1, "N"), (self.doEnd2, "Y"))
txt = (self.doExit0, self.doExit1, self.doExit2)
self.df = TartanDialog(self.opts["mf"],
eflds=self.fld,
tags=tag,
butt=but,
tend=tnd,
txit=txt)
def doType(self, frt, pag, r, c, p, i, w):
self.rtype = w
if self.rtype == "E":
self.df.topf[1][15][5] = "Y"
else:
self.df.topf[1][15][5] = "Y"
def doCode(self, frt, pag, r, c, p, i, w):
self.code = w
self.acc = self.sql.getRec("wagedc",
where=[("ced_cono", "=",
self.opts["conum"]),
("ced_type", "=", self.rtype),
("ced_code", "=", self.code)],
limit=1)
if not self.acc:
self.new = True
if self.rtype == "D" and self.code == 1:
showInfo(self.opts["mf"].body, "PAYE",
"This code is Reserved for PAYE Deductions")
elif self.rtype == "D" and self.code == 2:
showInfo(self.opts["mf"].body, "UIF",
"This code is Reserved for UIF Deductions")
else:
self.new = False
d = 3
self.df.loadEntry(frt, pag, p + 1, data=self.acc[d])
for pg in range(1, self.df.pgs + 1):
for x in range(0, self.df.topq[pg]):
if pg == 2 and x == 1:
continue
self.df.loadEntry("T", pg, x, data=self.acc[d])
if pg == 2 and not x:
ror = self.sql.getRec("wagrcv",
limit=1,
cols=["rcv_desc"],
where=[("rcv_code", "=",
self.acc[d])])
if not ror:
desc = ""
else:
desc = ror[0]
self.df.loadEntry("T", 2, 1, data=desc)
d = d + 1
def doDesc(self, frt, pag, r, c, p, i, w):
self.df.loadEntry("T", 0, 2, data=self.df.t_disp[1][0][0])
if self.rtype == "E" and self.code < 6:
self.df.loadEntry("T", 1, p + 1, data="V")
self.df.loadEntry("T", 1, p + 2, data="R")
if self.code == 5:
self.df.loadEntry("T", 1, p + 3, data=4)
else:
self.df.loadEntry("T", 1, p + 3, data=1)
if self.code in (1, 5):
self.df.loadEntry("T", 1, p + 4, data=1)
self.df.loadEntry("T", 1, p + 5, data=0)
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 6, data=0)
self.df.loadEntry("T", 1, p + 7, data=0)
self.df.loadEntry("T", 1, p + 8, data="S")
return "sk8"
else:
return "sk5"
else:
return "sk3"
elif self.rtype == "D" and self.code in (1, 2):
if self.code == 1:
self.df.loadEntry("T", 1, 1, data="V")
self.df.loadEntry("T", 1, 2, data="R")
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 6, data=0)
self.df.loadEntry("T", 1, p + 7, data=0)
self.df.loadEntry("T", 1, p + 9, data="N")
self.df.loadEntry("T", 1, p + 15, data="N")
return "nd"
return "sk5"
elif self.code == 2:
self.df.loadEntry("T", 1, 1, data="V")
self.df.loadEntry("T", 1, 2, data="R")
self.df.loadEntry("T", 1, 3, data=6)
return "sk3"
def doDelete(self):
t = self.sql.getRec("wagtf2",
cols=["count(*)"],
where=[("wt2_cono", "=", self.opts["conum"]),
("wt2_type", "=", self.rtype),
("wt2_code", "=", self.code)],
limit=1)
if t[0]:
return "Transactions Exist, Not Deleted"
self.sql.delRec("wagedc",
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", self.rtype),
("ced_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.focusField("T", 0, 1)
def doEmployeePortion(self, frt, pag, r, c, p, i, w):
if w == "A":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEmployeeBase(self, frt, pag, r, c, p, i, w):
if w > 7:
return "Invalid Employee Base"
def doValue(self, frt, pag, r, c, p, i, w):
self.value = w
if self.rtype == "E" and self.code < 6:
self.df.loadEntry("T", 1, p + 1, data=0)
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 2, data=0)
self.df.loadEntry("T", 1, p + 3, data=0)
self.df.loadEntry("T", 1, p + 4, data="S")
return "sk3"
else:
return "sk1"
def doElim(self, frt, pag, r, c, p, i, w):
self.elim = w
if self.glint != "Y":
self.df.loadEntry("T", 1, p + 1, data=0)
self.df.loadEntry("T", 1, p + 2, data=0)
if self.rtype == "E":
return "sk2"
else:
self.df.loadEntry("T", 1, p + 3, data="")
return "sk3"
def doEglco(self, frt, pag, r, c, p, i, w):
if self.rtype == "E" and self.code < 6 and not w:
# Use department code for integration
self.eglco = w
self.df.loadEntry("T", 1, p + 1, data=0)
self.df.loadEntry("T", 1, p + 2, data="S")
self.df.loadEntry("T", 1, p + 9, data="Y")
self.df.loadEntry("T", 1, p + 10, data=100.00)
return "sk10"
if w:
self.eglco = w
else:
self.eglco = self.opts["conum"]
name = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", self.eglco)],
limit=1)
if not name:
return "Invalid Company"
def doEglno(self, frt, pag, r, c, p, i, w):
if self.rtype == "D":
ctl = self.gc.getCtl("ctlctl", self.eglco)
if ctl and not self.gc.chkRec(self.eglco, ctl, ["wag_slc"]):
sln = ctl["wag_slc"]
else:
sln = None
else:
sln = None
if w and w != sln:
chk = chkGenAcc(self.opts["mf"], self.eglco, w)
if type(chk) is str:
return chk
self.eglno = w
if self.rtype == "D":
if self.code == 2:
self.df.loadEntry(frt, pag, 9, data="R")
self.df.loadEntry(frt, pag, 10, data=6)
self.df.loadEntry(frt, pag, 11, data=self.value)
self.df.loadEntry(frt, pag, 12, data=self.elim)
self.df.loadEntry(frt, pag, 13, data=self.eglco)
self.df.loadEntry(frt, pag, 14, data=self.eglno)
return "sk7"
else:
return "sk1"
if self.code < 6:
self.df.loadEntry("T", 1, p + 1, data="S")
self.df.loadEntry("T", 1, p + 8, data="Y")
self.df.loadEntry("T", 1, p + 9, data=100.00)
return "sk9"
def doEarnType(self, frt, pag, r, c, p, i, w):
if self.rtype == "E":
return "sk6"
def doEmployerPortion(self, frt, pag, r, c, p, i, w):
if w == "N":
for x in range(1, 6):
self.df.loadEntry(frt, pag, p + x, data=0)
return "sk5"
if w == "A":
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEmployerBase(self, frt, pag, r, c, p, i, w):
if w > 7:
return "Invalid Employer Base"
def doRlim(self, frt, pag, r, c, p, i, w):
if self.glint != "Y":
return "sk2"
def doRglco(self, frt, pag, r, c, p, i, w):
if not w:
w = self.opts["conum"]
name = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not name:
return "Invalid Company"
self.rglco = w
def doRglno(self, frt, pag, r, c, p, i, w):
if w:
chk = chkGenAcc(self.opts["mf"], self.rglco, w)
if type(chk) is str:
return chk
def doTaxcode(self, frt, pag, r, c, p, i, w):
if self.rtype == "D" and w not in ("Y", "T", "N"):
return "Invalid Selection"
if w == "N":
self.df.loadEntry("T", pag, p + 1, data=0)
return "sk1"
if self.glint == "Y" and not self.eglno and w != "T":
return "ff8|Invalid G/L Account Number"
def doTaxportion(self, frt, pag, r, c, p, i, w):
if not w:
return "Invalid Tax Portion"
def doRcv(self, frt, pag, r, c, p, i, w):
if w == 4101:
return "SITE Code Not Allowed"
acc = self.sql.getRec("wagrcv",
cols=["rcv_desc"],
where=[("rcv_code", "=", w)],
limit=1)
if not acc:
return "Invalid Rec of Rev Code"
else:
self.df.loadEntry(frt, pag, p + 1, data=acc[0])
def doUniRep(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p + 1, data="N")
if self.rtype == "E":
if self.code in (1, 2, 3, 4, 5):
self.df.loadEntry(frt, pag, p + 2, data=0)
self.df.loadEntry(frt, pag, p + 3, data=0)
self.df.loadEntry(frt, pag, p + 4, data="N")
self.df.loadEntry(frt, pag, p + 5, data=100.00)
return "sk5"
return "sk4"
return "sk1"
def doBalNo(self, frt, pag, r, c, p, i, w):
if self.rtype == "E":
self.df.loadEntry(frt, pag, p + 1, data=0)
self.df.loadEntry(frt, pag, p + 2, data="N")
self.df.loadEntry(frt, pag, p + 3, data="N")
return "sk3"
def doLimit(self, frt, pag, r, c, p, i, w):
pass
def doMthly(self, frt, pag, r, c, p, i, w):
self.df.loadEntry(frt, pag, p + 1, data=0)
return "sk1"
def doEnd0(self):
self.df.focusField("T", 1, 1, clr=self.new)
def doEnd1(self):
self.df.selPage("Detail-B")
self.df.focusField("T", 2, 1, clr=self.new)
def doEnd2(self):
dat = [self.opts["conum"]]
for x in range(0, 2):
dat.append(self.df.t_work[0][0][x])
for x in range(0, len(self.df.t_work[1][0])):
dat.append(self.df.t_work[1][0][x])
for x in range(0, len(self.df.t_work[2][0])):
if x in (0, 2, 3, 4, 5, 6, 7, 8):
dat.append(self.df.t_work[2][0][x])
if self.new:
self.sql.insRec("wagedc", data=dat)
elif dat != self.acc[:len(dat)]:
col = self.sql.wagedc_col
dat.append(self.acc[col.index("ced_xflag")])
self.sql.updRec("wagedc",
data=dat,
where=[("ced_cono", "=", self.opts["conum"]),
("ced_type", "=", self.rtype),
("ced_code", "=", self.code)])
self.opts["mf"].dbm.commitDbase()
self.df.last[0] = [0, 0]
self.df.selPage("Detail-A")
self.df.focusField("T", 0, 1)
def doAccept(self):
if self.rtype == "D":
frt, pag, col, mes = self.df.doCheckFields(("T", 0, None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14)))
if not mes:
if self.df.t_work[1][0][15] not in ("Y", "N", "T", "O",
"R"):
frt = "T"
pag = 1
col = 15
mes = "Invalid Tax Code Selection"
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 1, (16, )))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 2, (0, 2, 3, 4, 5, 6)))
else:
frt, pag, col, mes = self.df.doCheckFields(("T", 0, None))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 1, (0, 1, 2, 3, 4, 5, 6, 7, 8, 15, 16)))
if not mes:
frt, pag, col, mes = self.df.doCheckFields(
("T", 2, (0, 2, 3)))
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:
self.doEnd2()
def doCancel(self):
self.opts["mf"].dbm.rollbackDbase()
self.df.focusField("T", 0, 1)
def doExit0(self):
self.df.closeProcess()
self.opts["mf"].closeLoop()
def doExit1(self):
self.df.focusField("T", 0, 1)
def doExit2(self):
self.df.selPage("Detail-A")
class ml2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] not in (1, 2, 3, 4):
showError(self.opts["mf"].body, "Control Error",
"Invalid Routine %s, Only 1-4 Are Allowed" % \
str(self.opts["rtn"]))
return
tabs = ["ctlvmf", "ctlvrf", "ctlvtf", "memmst", "memtrn"]
self.gc = GetCtl(self.opts["mf"])
memctl = self.gc.getCtl("memctl", self.opts["conum"])
if not memctl:
return
self.glint = memctl["mcm_glint"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["mem_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.memctl = ctlctl["mem_ctl"]
self.dis_all = ctlctl["dis_all"]
tabs.extend(["gentrn", "genmst"])
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"MEM",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.opts["rtn"] == 1:
self.glt = 1
elif self.opts["rtn"] == 2:
self.glt = 2
elif self.opts["rtn"] == 3:
self.glt = 4
elif self.opts["rtn"] == 4:
self.glt = 1
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def drawDialog(self):
mlm = {
"stype":
"R",
"tables": ("memmst", ),
"cols":
(("mlm_memno", "", 0, "Mem-No"), ("mlm_oldno", "", 0, "Old-No"),
("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",
"sort":
False
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"where": [("glm_cono", "=", self.opts["conum"])]
}
vtm = {
"stype":
"R",
"tables": ("ctlvmf", ),
"cols": (("vtm_code", "", 0, "C"), ("vtm_desc", "", 0,
"Description", "Y")),
"where": [("vtm_cono", "=", self.opts["conum"])]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "IUI", 6, "Mem-No", "Member Number", "r", "N",
self.doMemAcc, mlm, None, ("notzero", )),
[("C", 1, 0, 1), "ONA", 10, "Name"],
(("C", 1, 0, 2), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doRefno, None, None, ("notblank", )),
(("C", 1, 0, 3), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 4), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("efld", ))]
if self.opts["rtn"] == 2:
fld[3][2] = 20
fld.extend([
(("C", 1, 0, 5), "ISD", 13.2, "Discount", "Discount Amount",
"", "N", self.doDisAmt, None, None, None, None,
"Discount Amount to be Added to the Transaction Amount."),
(("C", 1, 0, 6), "OSD", 13.2, "Total-Amount"),
(("C", 1, 0,
7), "INA", (20, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)
])
elif self.glint == "Y":
fld[3][2] = 24
fld.extend([
(("C", 1, 0, 5), "INA", 30, "Details", "Transaction Details",
"", "N", self.doTrnDet, None, None, None),
(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
(("C", 2, 0, 0), "IUI", 7, "Acc-Num", "Account Number", "",
"N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 1), "ONA", 19, "Description"),
(("C", 2, 0, 2), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode2, vtm, None, ("notblank", )),
(("C", 2, 0, 3), "ISD", 13.2, "All-Amt", "Allocation Amount",
"", "N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 4), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doAllVat, None, None, None),
(("C", 2, 0, 5), "INA", (26, 30), "Details", "", "", "N",
self.doAllDet, None, None, ("notblank", ))
])
else:
fld[3][2] = 22
fld.extend([
(("C", 1, 0, 6), "IUA", 1, "V", "V.A.T Code", self.taxdf, "N",
self.doVatCode1, vtm, None, ("notblank", )),
(("C", 1, 0, 7), "ISD", 13.2, "V.A.T", "V.A.T Amount", "", "N",
self.doVatAmt, None, None, None),
(("C", 1, 0,
8), "INA", (20, 30), "Details", "Transaction Details", "",
"N", self.doTrnDet, None, None, None)
])
but = (
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",1),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions Including Already Allocated",1),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",1),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",1),
("Cancel",None,self.doCancel,0,("C",2,1),("C",1,1),"",1))
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] != 2 and self.glint == "Y":
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doMemAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memmst",
cols=["mlm_title", "mlm_initial", "mlm_surname"],
where=[("mlm_cono", "=", self.opts["conum"]),
("mlm_memno", "=", w)],
limit=1)
if not acc:
return "Invalid Member Number"
self.memno = w
self.name = "%s, %s %s" % (acc[2], acc[0], acc[1])
self.df.loadEntry("C", pag, p + 1, data=self.name)
def doRefno(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("memtrn",
cols=["mlt_batch"],
where=[("mlt_cono", "=", self.opts["conum"]),
("mlt_memno", "=", self.memno),
("mlt_type", "=", self.opts["rtn"]),
("mlt_refno", "=", w)],
limit=1)
if acc:
return "Transaction Already Exists"
self.refno = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if w > mthendDate(self.bh.curdt * 100):
return "Invalid Date, After Batch Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if self.glint == "Y" or self.opts["rtn"] == 2:
self.vatcode = "N"
self.vatamt = 0
def doVatCode1(self, frt, pag, r, c, p, i, w):
vrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if vrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
self.vatamt = round((self.trnamt * vrte / (vrte + 100)), 2)
self.df.loadEntry(frt, pag, p + 1, self.vatamt)
if not self.vatamt:
return "sk1"
def doVatAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.vatamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.vatamt = float(ASD(0) - ASD(w))
else:
self.vatamt = w
self.df.loadEntry(frt, pag, p, data=self.vatamt)
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.trnamt < 0 and w > 0:
self.disamt = float(ASD(0) - ASD(w))
elif self.trnamt > 0 and w < 0:
self.disamt = float(ASD(0) - ASD(w))
else:
self.disamt = w
self.df.loadEntry(frt, pag, p, data=self.disamt)
totamt = float(ASD(self.trnamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.opts["rtn"] != 2 and self.glint == "Y":
self.df.colf[2][5][5] = w
self.allocated = float(0.00)
def endPage1(self):
self.cancel = False
self.agecan = False
self.batupd = False
self.updateTables1()
if self.cancel:
return
else:
self.updateBatch()
if self.trnamt == 0:
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
if self.opts["rtn"] == 2 or self.glint == "N":
self.doMemTrn()
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
self.amt = self.trnamt
self.vat = self.vatamt
if self.opts["rtn"] == 1: # Invoices
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 2: # Payment
if self.trnamt == 0:
recon = self.curdt
else:
recon = 0
self.vat = 0.00
self.dis = self.disamt
elif self.opts["rtn"] == 3: # Journal
recon = 0
self.dis = 0.00
elif self.opts["rtn"] == 4: # Credit Note
recon = 0
self.amt = float(ASD(0) - ASD(self.amt))
self.dis = 0.00
if self.opts["rtn"] == 1:
self.ageloop = False
self.doAgeCurrent()
else:
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.df.setWidget(self.df.B0, "focus")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
if self.glint == "N":
return
# General Ledger Control Transaction (Members)
val = float(ASD(self.amt) + ASD(self.dis))
data = (self.opts["conum"], self.memctl, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, val, 0.00, self.trndet,
"N", "", recon, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Bank)
if self.opts["rtn"] == 2:
val = float(ASD(0) - ASD(self.amt))
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, val, 0.00,
self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.dis:
val = float(ASD(0) - ASD(self.dis))
data = (self.opts["conum"], self.dis_all, self.curdt,
self.trndat, self.glt, self.refno, self.bh.batno, val,
0.00, self.trndet, "N", "", recon, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(0, 4):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="mem",
agetyp=atype,
agekey=[
self.opts["conum"], self.memno, self.opts["rtn"],
self.refno, self.curdt, self.amt, self.dis
])
self.agecan = age.cancel
if self.agevar.get():
self.agevar.set(False)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.opts["conum"], w)
if type(chk) is str:
return chk
if not chk[2]:
self.taxgl = self.taxdf
else:
self.taxgl = chk[2]
self.genacc = w
self.df.loadEntry("C", pag, p + 1, data=chk[0])
self.df.loadEntry("C", pag, p + 2, data=self.taxgl)
def doVatCode2(self, frt, pag, r, c, p, i, w):
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"], error=False)
if not ctlctl:
return "Missing ctlctl Record for Company"
if self.gc.chkRec(self.opts["conum"], ctlctl, ["vat_ctl"]):
return "Missing or Invalid Control Record"
self.convat = ctlctl["vat_ctl"]
self.vatrte = getVatRate(self.sql, self.opts["conum"], w, self.trndat)
if self.vatrte is None:
return "Invalid V.A.T Code"
self.vatcode = w
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.allamt = round((allamt * 100 / (100 + self.vatrte)), 2)
self.df.loadEntry(frt, pag, p, data=self.allamt)
self.allvat = float(ASD(allamt) - ASD(self.allamt))
else:
self.allamt = w
self.allvat = round((self.allamt * self.vatrte / 100), 2)
self.df.loadEntry(frt, pag, p + 1, data=self.allvat)
if not self.allvat:
self.df.loadEntry(frt, pag, p + 2, data=self.name)
return "sk1"
def doAllVat(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
self.allvat = float(ASD(0) - ASD(w))
elif self.allamt > 0 and w < 0:
self.allvat = float(ASD(0) - ASD(w))
else:
self.allvat = w
self.df.loadEntry(frt, pag, p, data=self.allvat)
self.df.loadEntry(frt, pag, p + 1, data=self.name)
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.cancel = True
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
if self.glint == "Y":
self.df.clearFrame("C", 2)
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.selPage("Transaction")
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + \
ASD(self.allamt) + ASD(self.allvat))
if self.allocated == self.trnamt:
self.doMemTrn()
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1: # Invoices
self.credit()
elif self.opts["rtn"] == 3: # Journal Entry
self.credit()
elif self.opts["rtn"] == 4: # Credit Notes
self.debit()
def debit(self):
amt = self.allamt
vat = self.allvat
self.restDebitCredit(amt, vat)
def credit(self):
amt = float(ASD(0) - ASD(self.allamt))
vat = float(ASD(0) - ASD(self.allvat))
self.restDebitCredit(amt, vat)
def restDebitCredit(self, amt, vat):
# VAT Transaction (ctlvtf)
data = (self.opts["conum"], self.vatcode, "O", self.curdt, "M",
self.glt, self.bh.batno, self.refno, self.trndat, self.memno,
self.alldet, amt, vat, 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("ctlvtf", data=data)
if self.glint == "N":
return
# General Ledger Transaction (Expense)
data = (self.opts["conum"], self.genacc, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, amt, vat, self.alldet,
self.vatcode, "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if vat:
# General Ledger Control Transaction (V.A.T.)
data = (self.opts["conum"], self.convat, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, vat, 0.00,
self.alldet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
vat = float(ASD(0) - ASD(vat))
self.vat += vat
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def doMemTrn(self):
# Members Ledger Transaction
data = [
self.opts["conum"], self.memno, self.opts["rtn"], self.refno,
self.bh.batno, self.trndat, self.amt, self.vat, self.curdt, "", 0,
self.trndet, self.vatcode, "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data)
if self.dis:
data = [
self.opts["conum"], self.memno, 6, self.refno, self.bh.batno,
self.trndat, self.dis, self.vat, self.curdt, "", 0,
self.trndet, self.vatcode, "N", self.opts["capnm"],
self.sysdtw, 0
]
self.sql.insRec("memtrn", data=data, unique="mlt_refno")
def updateBatch(self, rev=False):
if rev:
self.bh.batqty -= 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty += 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
class ln2010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Create SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "lonmf1", "lonmf2", "lonrte", "lontrn", "genint",
"genmst", "gentrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst",
cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])],
limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
self.gc = GetCtl(self.opts["mf"])
lonctl = self.gc.getCtl("lonctl", self.opts["conum"])
if not lonctl:
return
self.glint = lonctl["cln_glint"]
self.drte = lonctl["cln_drte"]
self.crte = lonctl["cln_crte"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["lon_ctl", "int_rec", "int_pay"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.lonctl = ctlctl["lon_ctl"]
self.intrec = ctlctl["int_rec"]
self.intpay = ctlctl["int_pay"]
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.allcoy = self.opts["conum"]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"LON",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
if self.opts["rtn"] == 4:
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
lm1 = {
"stype":
"R",
"tables": ("lonmf1", ),
"cols":
(("lm1_acno", "", 0, "Acc-Num"), ("lm1_name", "", 0, "Name", "Y")),
"where": [("lm1_cono", "=", self.opts["conum"])]
}
lm2 = {
"stype":
"R",
"tables": ("lonmf2", ),
"cols": (("lm2_loan", "", 0, "Ln"), ("lm2_desc", "", 0,
"Description", "Y")),
"where": [("lm2_cono", "=", self.opts["conum"])],
"whera": [("C", "lm2_acno", 0)]
}
coy = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))
}
glm = {
"stype":
"R",
"tables": ("genmst", ),
"cols": (("glm_acno", "", 0, "Acc-Num"), ("glm_desc", "", 0,
"Description", "Y")),
"whera": [["C", "glm_cono", 0, 2]]
}
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INA", 7, "Acc-Num", "Account Code", "", "Y",
self.doLonAcc, lm1, None, ("efld", )),
(("C", 1, 0, 1), "ONA", 10, "Name"),
(("C", 1, 0, 2), "IUI", 2, "LN", "Loan Number", "", "N",
self.doLonNum, lm2, None, ("efld", )),
(("C", 1, 0, 3), "ITX", (12, 30), "Description", "", "", "N",
self.doLonDes, None, None, ("notblank", )),
(("C", 1, 0, 4), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 5), "INa", 9, "Reference", "Reference Number One",
"i", "N", self.doTrnRef, None, None, ("notblank", )),
(("C", 1, 0, 6), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 7), "IUD", 6.2, "DRte-%", "Debit Rate", self.drte,
"N", self.doLonDrt, None, None, None),
(("C", 1, 0, 8), "IUD", 6.2, "CRte-%", "Credit Rate", self.crte,
"N", self.doLonCrt, None, None, None),
(("C", 1, 0, 9), "IUI", 3, "Mth", "Period in Months", "", "N",
self.doLonMth, None, None, ("efld", )),
(("C", 1, 0, 10), "OUD", 12.2, "Repay-Amt"),
(("C", 1, 0, 11), "INA", 30, "Details", "Loan Details", "", "N",
self.doTrnDet, None, None, None)]
if self.opts["rtn"] == 3 and self.glint == "Y":
fld.extend([(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
[("C", 2, 0, 0), "IUI", 3, "Coy", "Company Number",
self.opts["conum"], "N", self.doCoyNum, coy, None,
None],
(("C", 2, 0, 1), "IUI", 7, "Acc-Num", "Account Number",
"", "N", self.doGenAcc, glm, None, None),
(("C", 2, 0, 2), "ONA", 19, "Description"),
(("C", 2, 0,
4), "ISD", 13.2, "All-Amount", "Allocation Amount",
"", "N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 6), "INA", 30, "Allocation Details", "",
"", "N", self.doAllDet, None, None, ("notblank", ))])
if not self.incoac:
fld[15][1] = "OUI"
but = [("Interrogate", None, self.querySln, 0, ("C", 1, 1), ("C", 1,
2))]
tag = [("Transaction", None, None, None, False)]
cnd = [(None, "n"), (self.endPage1, "y")]
cxt = [None, self.exitPage1]
if self.opts["rtn"] == 3 and self.glint == "Y":
but.append(
("Cancel", None, self.doCancel, 0, ("C", 2, 1), ("C", 1, 1)))
tag.append(("Allocation", None, None, None, False))
cnd.append((self.endPage2, "y"))
cxt.append(self.exitPage2)
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doLonAcc(self, frt, pag, r, c, p, i, w):
newacc = False
if not w and self.opts["rtn"] in (1, 2, 3):
yn = askQuestion(self.opts["mf"].body,
"New Account",
"Is This a New Account?",
default="no")
if yn == "no":
return "Invalid Account Number"
newacc = True
w = callModule(self.opts["mf"],
self.df,
"ln1010",
coy=(self.opts["conum"], self.opts["conam"]),
user=self.opts["capnm"],
args="auto",
ret="acno")
self.df.loadEntry(frt, pag, p, data=w)
acc = self.sql.getRec("lonmf1",
cols=["lm1_name"],
where=[("lm1_cono", "=", self.allcoy),
("lm1_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
self.lonacc = w
self.name = acc[0]
self.df.loadEntry(frt, pag, p + 1, data=self.name)
if newacc:
self.lonnum = 1
self.newlon = True
self.df.loadEntry(frt, pag, p + 2, data=self.lonnum)
return "sk2"
def doLonNum(self, frt, pag, r, c, p, i, w):
self.newlon = False
if not w and self.opts["rtn"] in (1, 2, 3):
ok = askQuestion(self.opts["mf"].body,
head="New Loan",
mess="Is This a New Loan?",
default="no")
if ok == "yes":
self.newlon = True
self.lonnum = getNextCode(self.sql,
"lonmf2",
"lm2_loan",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc)
],
start=1,
last=9999999)
self.df.loadEntry(frt, pag, p, data=self.lonnum)
else:
return "Invalid Loan Number"
else:
self.lonmf2 = self.sql.getRec("lonmf2",
where=[
("lm2_cono", "=", self.allcoy),
("lm2_acno", "=", self.lonacc),
("lm2_loan", "=", w)
],
limit=1)
if not self.lonmf2:
return "Invalid Loan Number"
self.lonnum = w
self.londes = self.lonmf2[self.sql.lonmf2_col.index("lm2_desc")]
self.londat = self.lonmf2[self.sql.lonmf2_col.index("lm2_start")]
self.lonmth = self.lonmf2[self.sql.lonmf2_col.index("lm2_pmths")]
self.lonpay = self.lonmf2[self.sql.lonmf2_col.index("lm2_repay")]
if self.opts["rtn"] in (1, 3) and self.lonmth:
showError(
self.opts["mf"].body, "Fixed Loan",
"""This is a Fixed Period Loan.
Please Create a New Loan for this Account.""")
return "Invalid Loan Number"
self.df.loadEntry(frt, pag, p + 1, data=self.londes)
return "sk1"
def doLonDes(self, frt, pag, r, c, p, i, w):
self.londes = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnRef(self, frt, pag, r, c, p, i, w):
self.refno = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
if not self.newlon:
self.londrt = 0
self.loncrt = 0
self.lonmth = 0
self.lonpay = 0
if self.opts["rtn"] in (1, 2):
return "nd"
else:
return "sk4"
def doLonDrt(self, frt, pag, r, c, p, i, w):
self.londrt = w
def doLonCrt(self, frt, pag, r, c, p, i, w):
self.loncrt = w
def doLonMth(self, frt, pag, r, c, p, i, w):
self.lonmth = w
if self.lonmth:
rte = (self.londrt / 1200.0)
self.lonpay = round(
((self.trnamt * rte) * ((1 + rte)**w)) / (((1 + rte)**w) - 1),
2)
else:
self.lonpay = 0
self.df.loadEntry(frt, pag, p + 1, data=self.lonpay)
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
if self.glint == "Y" and self.opts["rtn"] == 3:
self.df.colf[2][4][5] = w
def endPage1(self):
self.batupd = False
self.updateTables1()
self.updateBatch()
if not self.val:
self.df.advanceLine(1)
elif self.opts["rtn"] in (1, 2, 4) or self.glint == "N":
self.opts["mf"].dbm.commitDbase()
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
self.allocated = float(0.0)
self.df.loadEntry("T", 2, 0, data=self.val)
self.df.selPage("Allocation")
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.opts["rtn"] == 1:
self.glt = 2
desc = "Loan Advance"
self.val = self.trnamt
elif self.opts["rtn"] == 2:
self.glt = 6
desc = "Loan Repayment"
self.val = float(ASD(0) - ASD(self.trnamt))
elif self.opts["rtn"] == 3:
self.glt = 4
desc = self.trndet
self.val = self.trnamt
elif self.opts["rtn"] == 4:
self.glt = 4
desc = self.trndet
self.val = self.trnamt
if self.newlon:
# Loans Masterfile
self.sql.insRec("lonmf2",
data=[
self.opts["conum"], self.lonacc, self.lonnum,
self.londes, self.trndat, self.lonmth,
self.lonpay, 0
])
# Loans Rate File
self.sql.insRec("lonrte",
data=[
self.opts["conum"], self.lonacc, self.lonnum,
self.trndat, self.londrt, self.loncrt
])
# Loans Transaction File
self.sql.insRec("lontrn",
data=[
self.opts["conum"], self.lonacc, self.lonnum,
self.bh.batno, self.opts["rtn"], self.trndat,
self.refno, self.val, self.curdt, desc, "N",
self.opts["capnm"], self.sysdtw, 0
])
if self.glint == "N":
return
# General Ledger Loans Control Account
data = (self.opts["conum"], self.lonctl, self.curdt, self.trndat,
self.glt, self.refno, self.bh.batno, self.val, 0.00, self.name,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.opts["rtn"] in (1, 2, 4):
# General Ledger Bank or Interest
self.val = float(ASD(0) - ASD(self.val))
if self.opts["rtn"] in (1, 2):
ctl = self.bh.acc
elif self.val < 0:
ctl = self.intrec
else:
ctl = self.intpay
data = (self.opts["conum"], ctl, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, self.val, 0.00,
"Loan - %s" % self.name, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not acc:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", w),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.allcoy = w
def doGenAcc(self, frt, pag, r, c, p, i, w):
chk = chkGenAcc(self.opts["mf"], self.allcoy, w)
if type(chk) is str:
return chk
self.genacc = w
self.df.loadEntry(frt, pag, p + 1, data=chk[0])
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.val) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doAllDet(self, frt, pag, r, c, p, i, w):
self.alldet = w
def doCancel(self):
ok = askQuestion(self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def endPage2(self):
self.updateTables2()
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.allocated == self.val:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Transaction")
self.df.advanceLine(1)
else:
bal = float(ASD(self.val) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def updateTables2(self):
val = float(ASD(0) - ASD(self.allamt))
# General Ledger Transaction (Allocation)
data = (self.allcoy, self.genacc, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, val, 0.00, self.alldet, "", "", 0,
self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany)
if self.allcoy != self.opts["conum"]:
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.opts["conum"]),
("cti_inco", "=", self.allcoy)],
limit=1)[0]
data = (self.opts["conum"], acc, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, val, 0.00, self.alldet, "N", "",
0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.allcoy),
("cti_inco", "=", self.opts["conum"])
],
limit=1)[0]
val = float(ASD(0) - ASD(val))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.refno, self.bh.batno, val, 0.00, self.alldet, "N", "",
0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.val))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.val))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def querySln(self):
callModule(self.opts["mf"],
self.df,
"ln4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class dr2020(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
self.drawDialog()
self.opts["mf"].startLoop()
def setVariables(self):
# Check for Valid Posting Routine
if self.opts["rtn"] != 2:
mes = "Invalid Routine %s" % str(self.opts["rtn"])
showError(self.opts["mf"].body, "Control Error", mes)
return
# Setup SQL Object
self.sql = Sql(self.opts["mf"].dbm, [
"ctlmst", "ctlvmf", "drschn", "drsmst", "drstrn", "genint",
"genmst", "gentrn"
],
prog=self.__class__.__name__)
if self.sql.error:
return
# Check for Intercompany Facility
if not self.sql.getRec("ctlmst",
cols=["count(*)"],
where=[("ctm_cono", "<>", self.opts["conum"])],
limit=1)[0]:
self.incoac = False
else:
itg = self.sql.getRec("genint",
cols=["cti_inco"],
where=[("cti_cono", "=", self.opts["conum"])
])
if itg:
self.incoac = [self.opts["conum"]]
[self.incoac.append(coy[0]) for coy in itg]
else:
self.incoac = False
#
self.gc = GetCtl(self.opts["mf"])
drsctl = self.gc.getCtl("drsctl", self.opts["conum"])
if not drsctl:
return
self.glint = drsctl["ctd_glint"]
self.chains = drsctl["ctd_chain"]
if self.glint == "Y":
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
ctls = ["drs_ctl", "vat_ctl", "dis_all"]
if self.gc.chkRec(self.opts["conum"], ctlctl, ctls):
return
self.drsctl = ctlctl["drs_ctl"]
self.dis_all = ctlctl["dis_all"]
self.batchHeader()
if not self.bh.batno:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.allcoy = self.opts["conum"]
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
self.taxdf = ctlmst["ctm_taxdf"]
if self.chains == "N":
self.chain = 0
self.glt = 6
self.agevar = tk.BooleanVar()
self.agevar.set(False)
return True
def batchHeader(self):
self.bh = Batches(self.opts["mf"],
self.opts["conum"],
self.opts["conam"],
self.opts["period"],
"DRS",
self.opts["rtn"],
glint=self.glint)
self.bh.doBatchHeader()
if not self.bh.batno:
return
self.bh.batval = float(ASD(0) - ASD(self.bh.batval))
def drawDialog(self):
drc = {
"stype": "R",
"tables": ("drschn", ),
"cols":
(("chm_chain", "", 0, "Num"), ("chm_name", "", 0, "Name", "Y")),
"where": [("chm_cono", "=", self.opts["conum"])]
}
drm = {
"stype":
"R",
"tables": ("drsmst", ),
"cols":
(("drm_acno", "", 0, "Acc-Num"), ("drm_name", "", 0, "Name", "Y"),
("drm_add1", "", 0, "Address Line 1"))
}
if self.chains == "Y":
drm["where"] = [("drm_cono", "=", self.opts["conum"])]
drm["whera"] = [["C", "drm_chain", 0, 1]]
else:
drm["where"] = [("drm_cono", "=", self.opts["conum"]),
("drm_chain", "=", 0)]
drm["where"].append(("drm_stat", "<>", "X"))
coy = {
"stype": "R",
"tables": ("ctlmst", ),
"cols":
(("ctm_cono", "", 0, "Coy"), ("ctm_name", "", 0, "Name", "Y"))
}
viw = {
"stype":
"R",
"tables": ("drstrn", ),
"cols": (("drt_chain", "", 0, ""), ("drt_acno", "", 0, ""),
("drt_ref1", "", 0, ""), ("drt_trdt", "", 0, ""),
("drt_tramt", "", 0, ""), ("drt_taxamt", "", 0, "")),
"where": [("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_batch", "=", self.bh.batno)],
"order":
"drt_seq"
}
tag = (("Deposit", None, None, None, False), ("Allocation", None, None,
None, False))
fld = [(("T", 0, 0, 0), "OUI", 9, "Batch %s Quantity" % self.bh.batno),
(("T", 0, 0, 0), "OSD", 13.2, "Value"),
(("C", 1, 0, 0), "INa", 9, "Reference", "Reference Number One",
"i", "Y", self.doRef1, None, None, ("efld", )),
(("C", 1, 0, 1), "ID1", 10, "Date", "Transaction Date", "r",
"N", self.doTrnDat, None, None, ("efld", )),
(("C", 1, 0, 2), "ISD", 13.2, "Amount", "Transaction Amount",
"", "N", self.doTrnAmt, None, None, ("notzero", )),
(("C", 1, 0, 3), "INA", (30), "Details", "Deposit Details", "",
"N", self.doTrnDet, None, None, None),
(("T", 2, 0, 0), "OSD", 13.2, "Unallocated Balance"),
[("C", 2, 0, 0), "OUI", 3, "Coy", "Company Number",
self.opts["conum"], "N", self.doCoyNum, coy, None,
("notzero", )],
[("C", 2, 0, 1), "IUI", 3, "Chn", "Chain Store", "r", "N",
self.doChain, drc, None, ("efld", )],
(("C", 2, 0, 2), "INA", 7, "Acc-Num", "Account Number", "r",
"N", self.doDrsAcc, drm, None, ("notblank", )),
(("C", 2, 0, 3), "ONA", 30, "Name"),
(("C", 2, 0, 4), "ISD", 13.2, "Receipt", "Receipt Amount", "",
"N", self.doAllAmt, None, None, ("efld", )),
(("C", 2, 0, 5), "ISD", 13.2, "Discount", "Discount Amount", "",
"N", self.doDisAmt, None, None, ("efld", ), None,
"Discount Amount to be Added to the Receipt Amount"),
(("C", 2, 0, 6), "OSD", 13.2, "Total-Amount")]
if self.glint == "Y" and self.incoac:
fld[7][1] = "IUI"
if self.chains == "N":
fld[8][1] = "OUI"
but = [("View Entries", viw, None, 1, ("C", 2, 3), ("C", 2, 4),
"View Batch Transactions", 1),
("Interrogate", None, self.queryDrs, 0, ("C", 2, 3),
("C", 2, 0), "Interrogate Debtors Accounts", 1),
("Maintain", None, self.maintainDrs, 0, ("C", 2, 3),
("C", 2, 4), "Maintain Debtors Accounts", 1),
("Canc_el", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1), "", 1)]
else:
but = [("View Entries", viw, None, 0, ("C", 2, 3), ("C", 2, 4),
"View Batch Transactions", 1),
("Interrogate", None, self.queryDrs, 0, ("C", 2, 2),
("C", 2, 0), "Interrogate Debtors Accounts", 1),
("Maintain", None, self.maintainDrs, 0, ("C", 2, 2),
("C", 2, 3), "Maintain Debtors Accounts", 1),
("Canc_el", None, self.doCancel, 0, ("C", 2, 1),
("C", 1, 1), "", 1)]
but.extend((
("Age _Normal",None,self.doAgeNormal,0,None,None,
"Only Show Unallocated Transactions",2),
("Age _History",None,self.doAgeHistory,0,None,None,
"Show All Transactions, Including Already Allocated",2),
("Age _Automatic",None,self.doAgeAuto,0,None,None,
"Automatically Allocate the Amount Starting With the "\
"Oldest Unallocated One",2),
("Age _Current",None,self.doAgeCurrent,0,None,None,
"Leave the Transaction Unallocated",2)))
txt = (None, None, None)
cnd = [None, (self.endPage1, "y"), (self.endPage2, "y")]
cxt = [None, self.exitPage1, self.exitPage2]
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tags=tag,
txit=txt,
cend=cnd,
cxit=cxt,
butt=but)
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
self.df.focusField("C", 1, 1)
def doRef1(self, frt, pag, r, c, p, i, w):
if not w:
trns = self.sql.getRec("drstrn",
cols=["drt_ref1"],
where=[("drt_cono", "=",
self.opts["conum"]),
("drt_ref1", "like", "R________")],
order="drt_ref1 desc")
auto = False
for trn in trns:
try:
w = "R%08i" % (int(trn[0][1:]) + 1)
auto = True
break
except:
pass
if not auto:
w = "R00000001"
self.df.loadEntry(frt, pag, p, data=w)
chk = self.sql.getRec("drstrn",
cols=["drt_acno"],
where=[("drt_cono", "=", self.opts["conum"]),
("drt_type", "=", self.opts["rtn"]),
("drt_ref1", "=", w)])
if chk:
return "A Transaction with this Reference Already Exists"
self.ref1 = w
def doTrnDat(self, frt, pag, r, c, p, i, w):
if w < self.opts["period"][1][0] or w > self.opts["period"][2][0]:
return "Invalid Date, Not in Financial Period"
if self.bh.multi == "N" and int(w / 100) > self.bh.curdt:
return "Invalid Date, After Batch Period"
self.trndat = w
def doTrnAmt(self, frt, pag, r, c, p, i, w):
self.trnamt = w
def doTrnDet(self, frt, pag, r, c, p, i, w):
self.trndet = w
self.allocated = float(0.00)
def endPage1(self):
self.agecan = False
self.batupd = False
self.updateTables1()
self.updateBatch()
self.allocated = float(0.0)
self.df.selPage("Allocation")
self.df.loadEntry("T", 2, 0, data=self.trnamt)
self.df.focusField("C", 2, 1)
def updateTables1(self):
if self.bh.multi == "Y":
self.curdt = int(self.trndat / 100)
else:
self.curdt = self.bh.curdt
if self.glint == "Y":
# General Ledger Control Transaction (Bank)
data = (self.opts["conum"], self.bh.acc, self.curdt, self.trndat,
self.glt, self.ref1, self.bh.batno, self.trnamt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
def exitPage1(self):
self.df.closeProcess()
self.bh.doBatchTotal()
self.opts["mf"].closeLoop()
def doCoyNum(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("ctlmst",
cols=["ctm_name"],
where=[("ctm_cono", "=", w)],
limit=1)
if not acc:
return "Invalid Company, Missing"
if self.incoac and w not in self.incoac:
return "Invalid Company, No Intercompany Record 1"
if w != self.opts["conum"]:
acc = self.sql.getRec("genint",
where=[("cti_cono", "=", w),
("cti_inco", "=", self.opts["conum"])
],
limit=1)
if not acc:
return "Invalid Company, No Intercompany Record 2"
self.allcoy = w
def doChain(self, frt, pag, r, c, p, i, w):
if w:
acc = self.sql.getRec("drschn",
cols=["chm_chain"],
where=[("chm_cono", "=", self.allcoy),
("chm_chain", "=", w)],
limit=1)
if not acc:
return "Invalid Chain Store"
self.chain = w
def doDrsAcc(self, frt, pag, r, c, p, i, w):
acc = self.sql.getRec("drsmst",
cols=["drm_name", "drm_stat"],
where=[("drm_cono", "=", self.allcoy),
("drm_chain", "=", self.chain),
("drm_acno", "=", w)],
limit=1)
if not acc:
return "Invalid Account Number"
if acc[1] == "X":
return "Invalid Account, Redundant"
self.dracno = w
self.name = acc[0]
self.df.loadEntry("C", pag, p + 1, data=self.name)
self.allref = self.ref1
while self.sql.getRec("drstrn",
cols=["drt_batch"],
where=[("drt_cono", "=", self.allcoy),
("drt_chain", "=", self.chain),
("drt_acno", "=", self.dracno),
("drt_type", "=", self.opts["rtn"]),
("drt_ref1", "=", self.allref)]):
self.doGetAnotherRef()
def doGetAnotherRef(self):
tit = ("Duplicate Reference Number", )
fld = ((("T", 0, 0, 0), "ONa", 9, "Old Reference", "", self.allref,
"N", None, None, None, None),
(("T", 0, 1, 0), "INa", 9, "New Reference", "", "", "N",
self.doRefNew, None, None, ("notblank", )))
tnd = ((self.doRefEnd, "n"), )
txt = (self.doRefExit, )
state = self.df.disableButtonsTags()
self.tf = TartanDialog(self.opts["mf"],
title=tit,
tops=True,
eflds=fld,
tend=tnd,
txit=txt)
self.tf.mstFrame.wait_window()
self.df.enableButtonsTags(state=state)
def doRefExit(self):
self.tf.focusField("T", 0, 2)
def doRefNew(self, frt, pag, r, c, p, i, w):
self.allref = w
def doRefEnd(self):
self.tf.closeProcess()
def doAllAmt(self, frt, pag, r, c, p, i, w):
if w == 0:
self.allamt = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry(frt, pag, p, data=self.allamt)
else:
self.allamt = w
def doDisAmt(self, frt, pag, r, c, p, i, w):
if self.allamt < 0 and w > 0:
ok = self.checkSign()
elif self.allamt > 0 and w < 0:
ok = self.checkSign()
else:
ok = "yes"
if ok != "yes":
return "Invalid Discount Amount (Sign Error)"
self.disamt = w
totamt = float(ASD(self.allamt) + ASD(self.disamt))
self.df.loadEntry(frt, pag, p + 1, data=totamt)
def checkSign(self):
return askQuestion(self.opts["mf"].body, "Check Sign",
"The Sign of the Discount Amount is not the same "\
"as the Sign of the Receipt Amount, Is This Correct?")
def endPage2(self):
self.amt = float(ASD(0) - ASD(self.allamt))
self.dis = float(ASD(0) - ASD(self.disamt))
state = self.df.disableButtonsTags()
self.opts["mf"].updateStatus("Choose an Ageing Option")
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "normal")
self.agevar.set(True)
self.df.mstFrame.wait_variable(self.agevar)
self.df.enableButtonsTags(state=state)
if self.agecan:
self.doCancel()
return
# Debtors Ledger Transaction
data = [
self.allcoy, self.chain, self.dracno, self.opts["rtn"],
self.allref, self.bh.batno, self.trndat, "", self.amt, 0.00,
self.curdt, self.trndet, "", "N", self.opts["capnm"], self.sysdtw,
0
]
self.sql.insRec("drstrn", data=data)
if self.dis:
data = [
self.allcoy, self.chain, self.dracno, 6, self.allref,
self.bh.batno, self.trndat, "", self.dis, 0.00, self.curdt,
self.trndet, "", "N", self.opts["capnm"], self.sysdtw, 0
]
self.sql.insRec("drstrn", data=data)
self.allocated = float(ASD(self.allocated) + ASD(self.allamt))
if self.glint == "Y":
# General Ledger Control Transaction (Debtors)
amt = float(ASD(self.amt) + ASD(self.dis))
data = (self.allcoy, self.drsctl, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"], self.sysdtw,
0)
self.sql.insRec("gentrn", data=data)
# General Ledger Control Transaction (Discount)
if self.disamt:
data = (self.allcoy, self.dis_all, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, self.disamt,
0.00, self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany)
if self.allcoy != self.opts["conum"]:
# General Ledger Transaction (Intercompany From)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=",
self.opts["conum"]),
("cti_inco", "=", self.allcoy)],
limit=1)[0]
data = (self.opts["conum"], acc, self.curdt, self.trndat,
self.glt, self.allref, self.bh.batno, self.amt, 0.00,
self.trndet, "N", "", 0, self.opts["capnm"],
self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
# General Ledger Transaction (Intercompany To)
acc = self.sql.getRec("genint",
cols=["cti_acno"],
where=[("cti_cono", "=", self.allcoy),
("cti_inco", "=",
self.opts["conum"])],
limit=1)[0]
amt = float(ASD(0) - ASD(self.amt))
data = (self.allcoy, acc, self.curdt, self.trndat, self.glt,
self.allref, self.bh.batno, amt, 0.00, self.trndet,
"N", "", 0, self.opts["capnm"], self.sysdtw, 0)
self.sql.insRec("gentrn", data=data)
if self.allocated == self.trnamt:
self.opts["mf"].dbm.commitDbase()
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
self.df.advanceLine(1)
else:
bal = float(ASD(self.trnamt) - ASD(self.allocated))
self.df.loadEntry("T", 2, 0, data=bal)
self.df.advanceLine(2)
def doAgeNormal(self):
self.doAgeing("N")
def doAgeHistory(self):
self.doAgeing("H")
def doAgeAuto(self):
self.doAgeing("O")
def doAgeCurrent(self):
self.doAgeing("C")
def doAgeing(self, atype):
# Disable All Ageing Buttons
for x in range(4, 8):
wid = getattr(self.df, "B%s" % x)
self.df.setWidget(wid, "disabled")
self.opts["mf"].updateStatus("Select Transaction to Allocate Against")
age = AgeAll(self.opts["mf"],
system="drs",
agetyp=atype,
agekey=[
self.allcoy, self.chain, self.dracno,
self.opts["rtn"], self.allref, self.curdt, self.amt,
self.dis
])
self.agecan = age.cancel
self.agevar.set(False)
def doCancel(self):
if self.agecan:
ok = "yes"
else:
ok = askQuestion(
self.opts["mf"].body,
head="Cancel",
mess="Are You Certain You Want to Cancel This Entry?")
if ok == "yes":
self.opts["mf"].dbm.rollbackDbase()
if self.batupd:
self.updateBatch(rev=True)
self.df.clearFrame("C", 2)
self.df.selPage("Deposit")
row = int((self.df.last[1][1] - 1) / self.df.colq[1])
col = (row * self.df.colq[1]) + 1
self.df.focusField("C", 1, col)
def exitPage2(self):
self.df.focusField("C", 2, self.df.col)
def updateBatch(self, rev=False):
if rev:
self.bh.batqty = self.bh.batqty - 1
self.bh.batval = float(ASD(self.bh.batval) - ASD(self.trnamt))
else:
self.batupd = True
self.bh.batqty = self.bh.batqty + 1
self.bh.batval = float(ASD(self.bh.batval) + ASD(self.trnamt))
self.df.loadEntry("T", 0, 0, data=self.bh.batqty)
self.df.loadEntry("T", 0, 1, data=self.bh.batval)
def queryDrs(self):
callModule(self.opts["mf"],
self.df,
"dr4010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
def maintainDrs(self):
callModule(self.opts["mf"],
self.df,
"dr1010",
coy=(self.opts["conum"], self.opts["conam"]),
period=None,
user=self.opts["capnm"])
class msy010(object):
def __init__(self, **opts):
self.opts = opts
if self.setVariables():
if "args" in self.opts:
self.final = self.opts["args"]
self.doEnd()
else:
self.drawScreen()
if "wait" in self.opts:
self.df.mstFrame.wait_window()
else:
self.opts["mf"].startLoop()
def setVariables(self):
self.gc = GetCtl(self.opts["mf"])
ctlsys = self.gc.getCtl("ctlsys", self.opts["conum"])
if not ctlsys:
return
self.years = ctlsys["sys_years"]
if self.years and self.years < 7:
showError(
self.opts["mf"].body, "History",
"""At least 7 years history should be retained.
Please select Control --> System Record Maintenance and change the Years to Keep field"""
)
return
ctlmst = self.gc.getCtl("ctlmst", self.opts["conum"])
if not ctlmst:
return
tabs = ["ctlsys", "ctlynd", "ftable"]
self.mod = []
for x in range(0, len(ctlmst["ctm_modules"].rstrip()), 2):
self.mod.append(ctlmst["ctm_modules"][x:x + 2])
if "AR" in self.mod:
tabs.append("assctl")
if "CR" in self.mod:
tabs.append("crsage")
if "DR" in self.mod:
tabs.append("drsage")
if "GL" in self.mod:
ctlctl = self.gc.getCtl("ctlctl", self.opts["conum"])
if not ctlctl:
return
if self.gc.chkRec(self.opts["conum"], ctlctl, ["ret_inc"]):
return
self.ri_acc = ctlctl["ret_inc"]
tabs.extend(["genbal", "genmst", "gentrn"])
if "LN" in self.mod:
tabs.append("lonctl")
if "ML" in self.mod:
tabs.append("memage")
tabs.append("memctl")
if "RC" in self.mod:
tabs.append("rcactl")
if "RT" in self.mod:
tabs.append("rtlctl")
if "WG" in self.mod:
tabs.append("wagctl")
self.sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
if self.sql.error:
return
t = time.localtime()
self.sysdtw = (t[0] * 10000) + (t[1] * 100) + t[2]
self.c_per = int(self.opts["period"][0])
self.start = self.opts["period"][1][0]
self.end = self.opts["period"][2][0]
self.cur = int(self.opts["period"][2][0] / 100)
self.l_per = self.sql.getRec("ctlynd",
cols=["max(cye_period)"],
where=[("cye_cono", "=",
self.opts["conum"])],
limit=1)[0]
self.last, self.oldf = self.sql.getRec(
"ctlynd",
cols=["cye_last", "cye_final"],
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", self.opts["period"][0])],
limit=1)[:2]
if self.oldf == "Y" and "args" not in self.opts:
cf = PwdConfirm(self.opts["mf"],
conum=0,
system="MST",
code="YearEnd")
if cf.pwd and cf.flag == "ok":
return True
if not cf.pwd:
showError(self.opts["mf"].body, "Year-End Error",
"This Period Has Already Been Finalised")
return
return True
def drawScreen(self):
r1s = (("Yes", "Y"), ("No", "N"))
fld = [
(("T", 0, 0, 0), "OD1", 10, "Starting Date", "", self.start, "N",
None, None, None, None, ("efld", )),
[("T", 0, 1, 0), "ID1", 10, "Ending Date ", "Ending Date",
self.end, "N", self.doDate, None, None, None, ("efld", )],
(("T", 0, 2, 0), ("IRB", r1s), 0, "Finalise", "", self.oldf, "N",
self.doFinal, None, None, None, None,
"""Finalising a financial period prevents any further data capture for that period as well as any previous periods i.e. if you finalise a period all previous financial periods are also automatically finalised."""
)
]
if self.last:
fld[1][1] = "OD1"
self.df = TartanDialog(self.opts["mf"],
eflds=fld,
tend=((self.doEnd, "y"), ),
txit=(self.doExit, ))
def doDate(self, frt, pag, r, c, p, i, w):
if w <= self.start:
return "Invalid Year End Date"
self.end = w
self.cur = int(w / 100)
def doFinal(self, frt, pag, r, c, p, i, w):
if w == "Y":
if "AR" in self.mod:
c = self.gc.getCtl("assctl", self.opts["conum"])
if not c:
return "Missing Asset Control"
if c["cta_glint"] == "Y" and c["cta_lastp"] < self.cur:
return "Depreciation Has Not Been Raised for Assets"
if "LN" in self.mod:
c = self.gc.getCtl("lonctl", self.opts["conum"])
if not c:
return "Missing Loans Control"
lst = c["cln_last"]
glt = c["cln_glint"]
drt = c["cln_drte"]
crt = c["cln_crte"]
lst = c["cln_last"]
if glt == "Y" and (drt or crt) and lst < self.end:
return "Interest Has Not Been Raised for Loans"
if "ML" in self.mod:
c = self.gc.getCtl("memctl", self.opts["conum"])
if not c:
return "Missing Members Control"
if c["mcm_glint"] == "Y" and c["mcm_lme"] < self.end:
return "A Month-End Has Not Been Completed for Members"
if "RC" in self.mod:
c = self.gc.getCtl("rcactl", self.opts["conum"])
if not c:
return "Missing Rentals Control"
if c["cte_glint"] == "Y" and c["cte_lme"] < self.end:
return "A Month-End Has Not Been Completed for Rentals"
if "RT" in self.mod:
c = self.gc.getCtl("rtlctl", self.opts["conum"])
if not c:
return "Missing Rentals Control"
if c["ctr_glint"] == "Y" and c["ctr_lme"] < self.end:
return "A Month-End Has Not Been Completed for Rentals"
if "WG" in self.mod:
c = self.gc.getCtl("wagctl", self.opts["conum"])
if not c:
return "Missing Salaries Control"
glt = c["ctw_glint"]
rte = c["ctw_i_rate"]
lst = c["ctw_i_date"]
if glt == "Y" and rte and lst < self.end:
return "Interest Has Not Been Raised for Staff Loans"
self.final = w
def doEnd(self):
if "args" not in self.opts:
self.df.closeProcess()
pb = ProgressBar(self.opts["mf"].body,
mxs=self.c_per,
typ=("F", "Processing Periods"))
for per in range(0, self.c_per + 1):
if "args" not in self.opts:
pb.displayProgress(per)
chk = self.sql.getRec("ctlynd",
cols=["cye_final"],
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", per)],
limit=1)
if self.oldf == "Y" or chk[0] != "Y":
self.retinc = 0
self.doYearEnd(per)
if "args" not in self.opts:
pb.closeProgress()
if self.years:
self.doDropYears()
self.opts["mf"].dbm.commitDbase()
if "args" not in self.opts:
self.doExit()
def doYearEnd(self, per):
self.sql.updRec("ctlynd",
cols=["cye_last", "cye_final"],
data=[self.sysdtw, self.final],
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", per)])
if per == self.c_per:
start_c = self.start
end_c = self.end
if (per + 1) > self.l_per:
newy = int(end_c / 10000)
newm = (int(end_c / 100) % 100) + 1
if newm > 12:
newy += 1
newm -= 12
news = (newy * 10000) + (newm * 100) + 1
newy = int(end_c / 10000) + 1
newm = int(end_c / 100) % 100
newe = (newy * 10000) + (newm * 100) + 1
newe = mthendDate(newe)
self.sql.insRec(
"ctlynd",
data=[self.opts["conum"], (per + 1), news, newe, 0, "N"])
else:
s, e, f = getPeriods(self.opts["mf"], self.opts["conum"], per)
if s is None or e is None:
return
start_c = s.work
end_c = e.work
sp = int(start_c / 100)
ep = int(end_c / 100)
s, e, f = getPeriods(self.opts["mf"], self.opts["conum"], (per + 1))
start_n = s.work
if "GL" not in self.mod:
return
self.sql.delRec("genbal",
where=[("glo_cono", "=", self.opts["conum"]),
("glo_trdt", "=", start_n)])
gm = self.sql.getRec("genmst",
cols=["glm_acno, glm_type"],
where=[("glm_cono", "=", self.opts["conum"])])
if gm:
for ac in gm:
ov = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", ac[0]),
("glo_trdt", "=", start_c)],
limit=1)
if not ov:
ov = CCD(0, "SD", 13.2)
else:
ov = CCD(ov[0], "SD", 13.2)
cy = self.sql.getRec("gentrn",
cols=["round(sum(glt_tramt), 2)"],
where=[("glt_cono", "=",
self.opts["conum"]),
("glt_acno", "=", ac[0]),
("glt_curdt", "between", sp, ep)],
limit=1)
if not cy[0]:
cy = CCD(0, "SD", 13.2)
else:
cy = CCD(cy[0], "SD", 13.2)
bal = float(ASD(ov.work) + ASD(cy.work))
if ac[1] == "P":
self.retinc = float(ASD(self.retinc) + ASD(bal))
bal = 0.00
self.sql.insRec("genbal",
data=[self.opts["conum"], ac[0], start_n, bal])
ri_bal = self.sql.getRec("genbal",
cols=["glo_cyr"],
where=[("glo_cono", "=",
self.opts["conum"]),
("glo_acno", "=", self.ri_acc),
("glo_trdt", "=", start_n)],
limit=1)
if not ri_bal:
self.sql.insRec("genbal",
data=[
self.opts["conum"], self.ri_acc, start_n,
self.retinc
])
else:
bal = float(ASD(ri_bal[0]) + ASD(self.retinc))
self.sql.updRec("genbal",
cols=["glo_cyr"],
data=[bal],
where=[("glo_cono", "=", self.opts["conum"]),
("glo_acno", "=", self.ri_acc),
("glo_trdt", "=", start_n)])
def doDropYears(self):
"""
TABLES is a list of tables to be actioned as follows:
[tran_table, date_column, [amount columns], mfile_table]
"""
TABLES = [["asstrn", "ast_curdt", ["ast_amt1", "ast_amt2"], "assmst"],
["bkmtrn", "bkt_curdt", ["bkt_tramt"], "bkmmst"], ["chglog"],
["crspay", "cpt_date", []],
["crstrn", "crt_curdt", ["crt_tramt"], "crsmst"],
["ctlbat", "btm_curdt", []], ["ctllog"], ["ctlnot"],
["ctlvtf", "vtt_curdt", []],
["drstrn", "drt_curdt", ["drt_tramt"], "drsmst"], ["emllog"],
["genbal", "glo_trdt", []], ["genbud", "glb_curdt", []],
["gendtt", "gdt_curdt", []], ["genrct", "grt_date", []],
["gentrn", "glt_curdt", ["glt_tramt"], "genmst"],
["lontrn", "lnt_curdt", ["lnt_tramt"], "lonmf2"],
["memtrn", "mlt_curdt", ["mlt_tramt"], "memmst"],
["memtrs", "mst_trdt", []],
["rcaowt", "rot_curdt", ["rot_tramt"], "rcaowm"],
["rcatnt", "rtu_curdt", ["rtu_tramt"], "rcatnm"],
["rtltrn", "rtt_curdt", ["rtt_tramt"], "rtlmst"],
["slsiv1", "si1_date", []], ["strpom", "pom_date", []],
["strtrn", "stt_curdt", ["stt_qty", "stt_cost"], "strmf1"],
["wagltf", "wlt_curdt", ["wlt_amt"], "waglmf"],
["wagtf1", "wt1_date", []], ["wagtf2", "wt2_date", []]]
ynds = self.sql.getRec("ctlynd",
where=[("cye_cono", "=", self.opts["conum"])],
order="cye_period")
if len(ynds) <= self.years:
return
last = ynds[len(ynds) - (self.years + 1)]
sdate = last[self.sql.ctlynd_col.index("cye_start")]
edate = last[self.sql.ctlynd_col.index("cye_end")]
etime = (edate * 10000) + 9999
emldt = "%04i-%02i-99 99:99" % (int(edate / 10000),
(int(edate / 100) % 100))
ecurdt = int(edate / 100)
count = 0
for ynd in ynds:
if ynd[1] < last[1]:
self.sql.delRec("ctlynd",
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", ynd[1])])
else:
self.sql.updRec("ctlynd",
cols=["cye_period"],
data=[count],
where=[("cye_cono", "=", self.opts["conum"]),
("cye_period", "=", ynd[1])])
count += 1
tables = self.sql.getRec("ftable", order="ft_tabl")
ourtab = []
for tab in tables:
ourtab.append(tab[0])
tabs = list(tabdic.keys())
if "args" not in self.opts:
pb = ProgressBar(self.opts["mf"].body,
typ=("G", "Dropping Periods Older Than %s Years" %
self.years))
sql = Sql(self.opts["mf"].dbm, tabs, prog=self.__class__.__name__)
for tab in TABLES:
if "args" not in self.opts:
pb.displayProgress()
if tab[0] not in ourtab:
continue
if tab[0] == "chglog":
key = "%03i%s" % (self.opts["conum"], "%")
sql.delRec(tab[0],
where=[("chg_key", "like", key),
("chg_dte", "<=", etime)])
continue
if tab[0] == "ctllog":
sql.delRec(tab[0], where=[("clg_start", "<=", etime)])
continue
if tab[0] == "ctlnot":
sql.delRec(tab[0],
where=[("not_cono", "=", self.opts["conum"]),
("not_date", "<=", edate)])
continue
if tab[0] == "emllog":
sql.delRec(tab[0], where=[("eml_dtt", "<=", emldt)])
continue
ftt = self.sql.getRec("ftable", where=[("ft_tabl", "=", tab[0])])
pfxt = ftt[0][4].split("_")[0]
coyt = None
for k in ftt:
for f in k[4:]:
if f.count("_cono"):
coyt = f
break
if coyt:
break
if coyt:
whrt = [(coyt, "=", self.opts["conum"])]
else:
whrt = []
if tab[2]:
ftm = self.sql.getRec("ftable",
where=[("ft_tabl", "=", tab[3]),
("ft_seq=1", )],
limit=1)
pfxm = ftm[4].split("_")[0]
keyt = []
keym = []
coym = None
for c in ftm[4:]:
if c:
if c.count("_cono"):
coym = c
keym.append(c)
t = c.replace(pfxm, pfxt)
keyt.append(t)
if coym:
whrm = [(coym, "=", self.opts["conum"])]
else:
whrm = []
if not tab[2]:
if tab[1].count("_curdt"):
whrt.append((tab[1], "<=", ecurdt))
sql.delRec(tab[0], where=whrt)
elif tab[0] == "crspay":
whrt.extend([("cpt_date", "<=", edate),
("cpt_flag", "=", "Y")])
sql.delRec(tab[0], where=whrt)
elif tab[0] == "drsrcm":
whrt.append((tab[1], "<=", ecurdt))
recs = sql.getRec(tables=tab[0], where=whrt)
for num, rec in enumerate(recs):
if "args" not in self.opts and not num % 10:
pb.displayProgress()
sql.delRec(tab[0],
where=[("dcm_cono", "=", rec[0]),
("dcm_num", "=", rec[1])])
sql.delRec("drsrct",
where=[("dct_cono", "=", rec[0]),
("dct_num", "=", rec[1])])
elif tab[0] == "genbal":
whrt.append((tab[1], "<=", sdate))
sql.delRec(tab[0], where=whrt)
elif tab[0] == "genrct":
whrt.append((tab[1], "<=", sdate))
sql.delRec(tab[0], where=whrt)
elif tab[0] == "memtrs":
whrt.append((tab[1], "<=", sdate))
sql.delRec(tab[0], where=whrt)
elif tab[0] == "strpom":
whrt.append((tab[1], "<=", edate))
recs = sql.getRec(tables=tab[0], where=whrt)
for num, rec in enumerate(recs):
if "args" not in self.opts and not num % 10:
pb.displayProgress()
sql.delRec(tab[0],
where=[("pom_cono", "=", rec[0]),
("pom_ordno", "=", rec[1])])
sql.delRec("strpot",
where=[("pot_cono", "=", rec[0]),
("pot_ordno", "=", rec[1])])
elif tab[0] == "slsiv1":
whrt.append((tab[1], "<=", edate))
recs = sql.getRec(tables=tab[0], where=whrt)
for num, rec in enumerate(recs):
if "args" not in self.opts and not num % 10:
pb.displayProgress()
sql.delRec(tab[0],
where=[("si1_cono", "=", rec[0]),
("si1_rtn", "=", rec[1]),
("si1_docno", "=", rec[2])])
sql.delRec("slsiv2",
where=[("si2_cono", "=", rec[0]),
("si2_rtn", "=", rec[1]),
("si2_docno", "=", rec[2])])
sql.delRec("slsiv3",
where=[("si3_cono", "=", rec[0]),
("si3_rtn", "=", rec[1]),
("si3_docno", "=", rec[2])])
elif tab[0] == "strpom":
whrt.append((tab[1], "<=", edate))
recs = sql.getRec(tables=tab[0], where=whrt)
for num, rec in enumerate(recs):
if "args" not in self.opts and not num % 10:
pb.displayProgress()
sql.delRec(tab[0],
where=[("pom_cono", "=", rec[0]),
("pom_ordno", "=", rec[1])])
sql.delRec("strpot",
where=[("pot_cono", "=", rec[0]),
("pot_ordno", "=", rec[1])])
elif tab[0] == "wagtf1":
whrt.append((tab[1], "<=", sdate))
sql.delRec(tab[0], where=whrt)
elif tab[0] == "wagtf2":
whrt.append((tab[1], "<=", sdate))
sql.delRec(tab[0], where=whrt)
else:
recs = sql.getRec(tables=tab[3], where=whrm)
for num, rec in enumerate(recs):
if "args" not in self.opts and not num % 10:
pb.displayProgress()
whr = copyList(whrt)
for k in keyt:
if not k.count("_cono"):
dat = rec[getattr(sql, "%s_col" % tab[0]).index(k)]
whr.append((k, '=', dat))
if tab[0] == "asstrn":
whr.append(("ast_mtyp", "<>", 1))
col = ["ast_mtyp"]
grp = "ast_cono, ast_group, ast_code, ast_mtyp"
lim = 0
elif tab[0] == "rcatnt":
col = ["rtu_cnum", "rtu_mtyp"]
grp = "rtu_cono, rtu_owner, rtu_code, rtu_acno, "\
"rtu_cnum, rtu_mtyp"
lim = 0
elif tab[0] == "rtltrn":
col = ["rtt_cnum"]
grp = "rtt_cono, rtt_code, rtt_acno, rtt_cnum"
lim = 0
elif tab[0] == "strtrn":
col = ["stt_loc"]
grp = "stt_cono, stt_group, stt_code, stt_loc"
lim = 0
elif tab[0] == "wagltf":
mt = sql.getRec("wagltf",
cols=["wlt_loan", "max(wlt_curdt)"],
where=[("wlt_cono", "=", rec[0]),
("wlt_empno", "=", rec[1])],
group="wlt_cono, wlt_empno, wlt_loan",
order="wlt_cono, wlt_empno, wlt_loan")
for m in mt:
if m[1] >= ecurdt:
continue
b = sql.getRec("wagltf",
cols=["sum(wlt_amt)"],
where=[("wlt_cono", "=", rec[0]),
("wlt_empno", "=", rec[1]),
("wlt_loan", "=", m[0])],
limit=1)
if not b[0]:
continue
sql.delRec("waglmf",
where=[("wlm_cono", "=", rec[0]),
("wlm_empno", "=", rec[1]),
("wlm_loan", "=", m[0])])
sql.delRec("wagltf",
where=[("wlt_cono", "=", rec[0]),
("wlt_empno", "=", rec[1]),
("wlt_loan", "=", m[0])])
continue
else:
col = []
grp = None
lim = 1
for c in tab[2]:
col.append("sum(%s)" % c)
whr.append((tab[1], "<=", ecurdt))
bals = sql.getRec(tables=tab[0],
cols=col,
where=whr,
group=grp,
order=grp,
limit=lim)
if not bals:
continue
sql.delRec(tab[0], where=whr)
if tab[0] == "asstrn":
from tartanWork import armvtp
for bal in bals:
# Create Transactions
if not bal[1] and not bal[2]:
continue
data = rec[:3]
data.extend([
3, "Bal-Fwd", "Bal-Fwd", edate, bal[0], bal[1],
bal[2], 0, ecurdt,
"%s Brought Forward" % armvtp[bal[0] - 1][1],
"", "", self.opts["capnm"], self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
elif tab[0] == "bkmtrn" and bals[0]:
data = rec[:2]
data.extend([
5, "Bal-Fwd", "Bal-Fwd", edate, "", bals[0], 0,
ecurdt, "Brought Forward", "", "",
self.opts["capnm"], self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
elif tab[0] == "crstrn" and bals[0]:
data = rec[:2]
data.extend([
3, "Bal-Fwd", "Bal-Fwd", edate, "", bals[0], 0, 0,
ecurdt, self.sysdtw, "Y", bals[0],
"Brought Forward", "", "", self.opts["capnm"],
self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
# Re-Age Transactions
doAutoAge(self.opts["mf"].dbm, "crs", rec[0], rec[1])
elif tab[0] == "drstrn" and bals[0]:
data = rec[:3]
data.extend([
3, "Bal-Fwd", "Bal-Fwd", edate, "", bals[0], 0,
ecurdt, "Brought Forward", "", "",
self.opts["capnm"], self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
# Re-Age Transactions
doAutoAge(self.opts["mf"].dbm, "drs", rec[0], rec[1],
rec[2])
elif tab[0] == "gentrn" and bals[0]:
continue
elif tab[0] == "memtrn" and bals[0]:
data = rec[:2]
data.extend([
3, "Bal-Fwd", "Bal-Fwd", edate, bals[0], 0, ecurdt,
"", 0, "Brought Forward", "", "",
self.opts["capnm"], self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
# Re-Age Transactions
doAutoAge(self.opts["mf"].dbm, "mem", rec[0], rec[1])
elif tab[0] == "rcaowt" and bals[0]:
data = rec[:2]
data.extend([
4, "Bal-Fwd", "Bal-Fwd", edate, bals[0], 0, ecurdt,
"Brought Forward", "", "", self.opts["capnm"],
self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
elif tab[0] == "rcatnt":
from tartanWork import rcmvtp
for bal in bals:
# Create Transactions
if not bal[2]:
continue
data = rec[:4]
data.extend([
bal[0], 4, "Bal-Fwd", "Bal-Fwd", edate, bal[1],
bal[2], 0, ecurdt,
"%s Brought Forward" % rcmvtp[bal[1] - 1][1],
"", "", self.opts["capnm"], self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
elif tab[0] == "rtltrn":
for bal in bals:
# Create Transactions
if not bal[1]:
continue
data = rec[:3]
data.extend([
bal[0], 4, "Bal-Fwd", "Bal-Fwd", edate, bal[1],
0, ecurdt, "Brought Forward", "", "",
self.opts["capnm"], self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
elif tab[0] == "strtrn":
for bal in bals:
# Create Transactions
if not bal[1] and not bal[2]:
continue
data = rec[:3]
if bal[1] < 0:
typ = 6
else:
typ = 5
data.extend([
bal[0], edate, typ, "Bal-Fwd", "Bal-Fwd", "",
bal[1], bal[2], 0, ecurdt, "Brought Forward",
0, "", "", "", 0, "", self.opts["capnm"],
self.sysdtw, 0
])
sql.insRec(tab[0], data=data)
if "args" not in self.opts:
pb.closeProgress()
def doExit(self):
self.df.closeProcess()
if "wait" not in self.opts:
self.opts["mf"].closeLoop()
