def recon_totals(bankacct):
# Find service charges for month:
dlist = []
wlist = []
gdat = Gledger.query.filter((Gledger.Account == bankacct)
& (Gledger.Reconciled == 25)
& (Gledger.Source == bankacct)).first()
if gdat is not None:
bkc = gdat.Credit
else:
bkc = 0
totald, totalc = 0.0, 0.0
gdata = Gledger.query.filter((Gledger.Account == bankacct)
& (Gledger.Reconciled == 25)).all()
for gdat in gdata:
type = gdat.Type
if type == 'DD' or type == 'XD':
totald = totald + gdat.Debit
dlist.append(gdat.id)
if type == 'PC' or type == 'XC':
totalc = totalc + gdat.Credit
wlist.append(gdat.id)
totalc = totalc - bkc
return d2s(float(totald) / 100), d2s(float(totalc) / 100), d2s(
float(bkc) / 100), dlist, wlist
def run_xfer(update, err):
vals = [
'fromacct', 'toacct', 'pamt', 'bref', 'pdate', 'ckmemo', 'bdesc',
'ddate'
]
a = list(range(len(vals)))
for ix, v in enumerate(vals):
a[ix] = request.values.get(v)
if a[4] is None:
a[4] = today
bdol = d2s(a[2])
modata.Memo = a[5]
modata.Description = a[6]
modata.bAmount = bdol
modata.bDate = a[4]
modata.dDate = a[7]
modata.pAmount = bdol
modata.pDate = a[4]
modata.pAccount = a[0]
modata.Ref = a[3]
modata.User = username
modata.Company = a[1]
modata.bAccount = a[1]
adat = Accounts.query.filter(Accounts.Name == a[1]).first()
if adat is not None:
cat = adat.Category
sub = adat.Subcategory
modata.bCat = cat
modata.bSubcat = sub
err.append('Modification to Xfer ' + modata.Jo + ' completed.')
if update is not None:
err = gledger_write('xfer', modata.Jo, modata.Company, modata.pAccount)
return err
def banktotals(bankacct):
totald = 0
totalc = 0
totald_U = 0
totalc_U = 0
endbal = request.values.get('endbal')
begbal = request.values.get('begbal')
print(begbal, endbal)
try:
endbal = float(endbal)
except:
endbal = 0.00
try:
begbal = float(begbal)
except:
begbal = 0.00
gdata = Gledger.query.filter(Gledger.Account == bankacct).all()
for gdat in gdata:
type = gdat.Type
if type == 'DD' or type == 'XD':
totald = totald + gdat.Debit
if gdat.Reconciled == 0 or gdat.Reconciled == 25:
totald_U = totald_U + gdat.Debit
if type == 'PC' or type == 'XC':
totalc = totalc + gdat.Credit
if gdat.Reconciled == 0 or gdat.Reconciled == 25:
totalc_U = totalc_U + gdat.Credit
trial_dr, trial_cr, bk_charge, dlist, wlist = recon_totals(bankacct)
totald = float(totald) / 100
totalc = float(totalc) / 100
diff = begbal + float(trial_dr) - float(trial_cr) - float(
bk_charge) - endbal
totalds = d2s(totald)
totalcs = d2s(totalc)
balance = d2s((float(totald) - float(totalc)) / 100)
totald_Us = d2s(float(totald_U) / 100)
totalc_Us = d2s(float(totalc_U) / 100)
projbal = d2s(float(totald - totalc - totald_U + totalc_U) / 100)
acctinfo = [
balance, totald_Us, totalc_Us, projbal,
d2s(endbal),
d2s(diff), bankacct, totalds, totalcs,
d2s(begbal)
]
return acctinfo
def install_pay_init(bill, err, modlink):
success = 1
modata = Bills.query.get(bill)
status = modata.Status
if status == 'Paid':
success = 0
leftscreen, docref, prevpayvec = 1, 0, 0
err.append(
'Bill has been paid in full. Use unpay to restart payment process'
)
else:
prevpayvec = []
pmtlist = json.loads(modata.PmtList)
paclist = json.loads(modata.PacctList)
reflist = json.loads(modata.RefList)
pmethods = json.loads(modata.MethList)
memolist = json.loads(modata.MemoList)
pdatelist = json.loads(modata.PdateList)
checklist = json.loads(modata.CheckList)
total = 0.00
for ix, pmt in enumerate(pmtlist):
prevpayvec.append([
pmtlist[ix], paclist[ix], pmethods[ix], reflist[ix],
memolist[ix], pdatelist[ix]
])
total = total + float(pmt)
bamtf = float(modata.bAmount)
diff = bamtf - total
modata.pDate = today
modata.pAmount = d2s(diff)
pacct = modata.pAccount
if pacct is None:
pacct = get_def_bank(modata)
elif len(pacct) < 4:
pacct = get_def_bank(modata)
modata.pAccount = pacct
db.session.commit()
modlink = 12
err.append(f'Paying Part of Bill {modata.Jo}')
docref = f'tmp/{scac}/data/vbills/{modata.Original}'
if os.path.isfile(addpath(docref)): leftscreen = 0
else:
leftscreen = 1
err.append('Bill has no source document')
return err, modlink, leftscreen, docref, prevpayvec
def pl_explisting(c, fsize, mtop, hvec, itemslist, justify, totals, bottomy,
kval, exp, details, catbp):
c.setFont('Helvetica-Bold', fsize, leading=None)
l1 = len(itemslist)
dl = fsize * 2
dh = dl * .6
bump = 2.5
sb = 2
if details == 'on':
mtop = mtop - dh
ctr = []
for j, hpt in enumerate(hvec):
if j < len(hvec) - 1:
ctr.append(avg(hpt, hvec[j + 1]))
if l1 == 0:
c.drawString(hvec[4], mtop, 'No Items Reported This Period')
mtop = mtop - dh
for k in range(l1):
newlist = itemslist[k]
jtype = newlist[1]
amount = newlist[-1]
if jtype == exp:
prorated = float(amount) * catbp[kval]
totals[kval] = totals[kval] + prorated
if catbp[kval] < 1.0:
newlist[-1] = '*pr*' + d2s(prorated)
if details == 'on':
for j, i in enumerate(newlist):
if justify[j] == 'l':
c.drawString(hvec[j] + sb, mtop, i)
elif justify[j] == 'c':
c.drawCentredString(ctr[j], mtop, i)
else:
c.drawRightString(hvec[j + 1] - sb, mtop, i)
mtop = mtop - dh
if mtop < bottomy + dh and k + 1 < l1:
mtop = 0
rlist = itemslist[k + 1:l1]
return mtop, totals, rlist
return mtop, totals, 0
def depositcalcs(odervec):
today = datetime.datetime.today().strftime('%m/%d/%Y')
invodate = datetime.date.today().strftime('%m/%d/%Y')
depositdata = []
jolist = []
for oder in odervec:
myo = Gledger.query.get(oder)
jo = myo.Tcode
pid = int(myo.Sid)
myc = People.query.get(pid)
company = myc.Company
amount = d2s(float(myo.Debit) / 100.)
print('For', jo, myo.Ref, company, amount)
if jo not in jolist:
depositdata.append([jo, company, myo.Ref, amount])
jolist.append(jo)
return depositdata
def regular_payment(a, bill, username, err):
modata = Bills.query.get(bill)
pamtf = float(a[0])
pamt = d2s(pamtf)
pacct = a[1]
ckref = a[2]
ckmemo = a[3]
pdate = a[4]
pmethod = a[5]
if pdate is None: pdate = today
modata.Memo = ckmemo
modata.pAmount = pamt
modata.pDate = pdate
modata.pAccount = pacct
modata.Ref = ckref
modata.Temp2 = pmethod
modata.Status = 'Paid'
modata.User = username
db.session.commit()
return err
def undolastpayment(bill):
myb = Bills.query.get(bill)
ix = myb.iflag - 1
pmtlist = json.loads(myb.PmtList)
paclist = json.loads(myb.PacctList)
reflist = json.loads(myb.RefList)
pmethods = json.loads(myb.MethList)
memolist = json.loads(myb.MemoList)
pdatelist = json.loads(myb.PdateList)
checklist = json.loads(myb.CheckList)
pmtlist = pmtlist[:ix]
total = 0.00
for pmt in pmtlist:
total = total + float(pmt)
myb.pAmount = d2s(total)
myb.pAmount2 = pmtlist[-1:]
myb.PmtList = json.dumps(pmtlist)
myb.PacctList = json.dumps(paclist[:ix])
myb.RefList = json.dumps(reflist[:ix])
myb.MemoList = json.dumps(memolist[:ix])
myb.PdateList = json.dumps(pdatelist[:ix])
myb.CheckList = json.dumps(checklist[:ix])
myb.MethList = json.dumps(pmethods[:ix])
myb.Status = 'PartPaid'
db.session.commit()
jo = myb.Jo + f'-{myb.iflag}'
Gledger.query.filter((Gledger.Tcode == jo)
& (Gledger.Type == 'PD')).delete()
Gledger.query.filter((Gledger.Tcode == jo)
& (Gledger.Type == 'PC')).delete()
Gledger.query.filter((Gledger.Tcode == jo)
& (Gledger.Type == 'XD')).delete()
Gledger.query.filter((Gledger.Tcode == jo)
& (Gledger.Type == 'XC')).delete()
db.session.commit()
def newbill_passthru(err, hv, modlink):
leftscreen = 0
assdata = 0
bdate = request.values.get('bdate')
ddate = request.values.get('ddate')
bamt = request.values.get('bamt')
bdesc = request.values.get('bdesc')
narrow = 1
hv[5], hv[6] = vendorlist(narrow)
if modlink == 4:
thiscompany = request.values.get('thiscomp')
form_co = request.values.get('ctype')
form_exp = request.values.get('billacct')
form_type = request.values.get('thistype')
if thiscompany != '0':
cdat = People.query.filter((People.Company == thiscompany)
& ((People.Ptype == 'Vendor') |
(People.Ptype == 'TowCo'))).first()
if cdat is not None:
default_co = cdat.Idtype
default_exp = cdat.Associate1
else:
default_co = None
default_exp = None
else:
default_co = None
default_exp = None
hv[22] = form_type
if form_co == '0':
comp = default_co
else:
comp = form_co
hv[8] = comp
if form_exp == '0':
thisaccount = default_exp
else:
thisaccount = form_exp
hv[9] = thisaccount
ccdat = Accounts.query.filter(Accounts.Name == thisaccount).first()
if cdat is not None:
hv[7] = cdat.Company
cdat.Idtype = comp
cdat.Associate1 = thisaccount
db.session.commit()
ddat = Divisions.query.filter(Divisions.Co == cdat.Idtype).first()
if ddat is not None:
err.append(f'Loading data for {thiscompany} Defaults')
err.append(f'Bill for {cdat.Idtype}: {ddat.Name}')
elif thiscompany != 0:
# This section for case of bill to credit card account
thisaccount = request.values.get('billacct')
ccdat = Accounts.query.filter(Accounts.Name == thisaccount).first()
if ccdat is not None:
hv[7] = thiscompany
hv[8] = ccdat.Co
hv[9] = 'No'
else:
modlink = 4 #reset the vendor feed back to bill feed
cdat = None
if cdat is not None:
# Set account defaults for this vendor
ccode = cdat.Idtype
cchg = request.values.get('ctype')
ddat = Divisions.query.filter(Divisions.Co == cchg).first()
if ddat is not None:
cdat.Idtype = ddat.Co
ccode = ddat.Co
print('expdata coming from above', form_type)
expdata = Accounts.query.filter((
(Accounts.Type == 'Expense') & (Accounts.Co == ccode))
| ((Accounts.Type == 'Credit Card')
& (Accounts.Co == ccode))).order_by(
Accounts.Name).all()
if form_type == 'asset1':
assdata = Accounts.query.filter((Accounts.Type == 'Fixed Asset')
& (Accounts.Co == ccode)).order_by(
Accounts.Name).all()
elif form_type == 'asset2':
assdata = Accounts.query.filter((Accounts.Type == 'Current Asset')
& (Accounts.Co == ccode)).order_by(
Accounts.Name).all()
# Get information from previous bill paid by the vendor
ldata = Bills.query.filter(Bills.Company == cdat.Company).all()
if ldata:
ldat = ldata[-1]
last_desc = ldat.Description
last_memo = ldat.Memo
new_desc = ''
new_memo = ''
try:
for i, x in enumerate(monlvec):
if i == 11:
k = 0
else:
k = i + 1
if x in last_desc:
new_desc = last_desc.replace(x, monlvec[k])
if x in last_memo:
new_memo = last_memo.replace(x, monlvec[k])
last_amt = d2s(ldat.bAmount)
except:
last_amt = 0.00
#No previous bills
# last_date=datetime.datetime.strptime(ldat.bDate,"%Y-%m-%d")+datetime.timedelta(days=30)
last_date = ldat.bDate
if last_date is not None:
last_date = last_date.strftime("%Y-%m-%d")
err.append(
f'The last bill to this vendor was written on {last_date} for ${last_amt}'
)
else:
last_date = 'None'
err.append(f'No Bills Recorded for this Vendor')
vdata = [bdate, ddate, last_amt, new_desc]
else:
# if not then get the category info from the vendor data
vdata = [bdate, ddate, bamt, bdesc]
else:
ccode = hv[8]
print('expdata coming from below', form_type)
expdata = Accounts.query.filter((
(Accounts.Type == 'Expense') & (Accounts.Co == ccode))
| ((Accounts.Type == 'Credit Card')
& (Accounts.Co == ccode))).order_by(
Accounts.Name).all()
if form_type == 'asset1':
assdata = Accounts.query.filter((Accounts.Type == 'Fixed Asset')
& (Accounts.Co == ccode)).order_by(
Accounts.Name).all()
elif form_type == 'asset2':
assdata = Accounts.query.filter((Accounts.Type == 'Current Asset')
& (Accounts.Co == ccode)).order_by(
Accounts.Name).all()
vdata = [bdate, ddate, bamt, bdesc]
return err, modlink, leftscreen, hv, expdata, vdata, assdata
def incoming_setup():
# Came to this point from outside so nothing is translated
bill, peep, cache, modata, modlink, fdata, adata, cdat, pb, passdata, vdata, caldays, daylist, weeksum, nweeks = init_billing_zero(
)
filesel, docref, search11, search12, search13, search14, search21, search22, bType, bClass = init_billing_blank(
)
towid = request.values.get('towid')
towid = nonone(towid)
adat = Autos.query.get(towid)
pufrom = adat.Pufrom
bdesc = 'Towing performed by \r\n' + adat.TowCompany
print('Towing Items', adat.TowCompany, adat.Pufrom)
adata = Autos.query.filter(Autos.Orderid == adat.Orderid).all()
for dat in adata:
bdesc = bdesc + '\r\n' + nons(dat.Year) + ' ' + nons(dat.Make) + \
' ' + nons(dat.Model) + ' VIN: ' + nons(dat.VIN)
dat.Status = 'Paid'
db.session.commit()
cdat = People.query.filter((People.Company == adat.TowCompany) & (
(People.Ptype == 'TowCo') | (People.Ptype == 'Vendor'))).first()
if cdat is None:
input = People(Company=adat.TowCompany,
First=None,
Middle=None,
Last=None,
Addr1=None,
Addr2=None,
Addr3=None,
Idtype=None,
Idnumber=None,
Telephone=None,
Email=None,
Associate1=None,
Associate2=None,
Date1=today,
Date2=None,
Original=None,
Ptype='TowCo',
Temp1=None,
Temp2=None,
Accountid=None)
db.session.add(input)
db.session.commit()
cdat = People.query.filter((People.Company == adat.TowCompany) & (
(People.Ptype == 'TowCo') | (People.Ptype == 'Vendor'))).first()
if cdat is not None:
cid = cdat.Accountid
aid = cdat.id
acdat = Accounts.query.filter(Accounts.id == cid).first()
if acdat is not None:
descript = acdat.Description
baccount = acdat.Name
btype = acdat.Type
bcat = acdat.Category
bsubcat = acdat.Subcategory
else:
bcat = 'NAY'
bsubcat = 'NAY'
descript = ''
baccount = ''
else:
bcat = 'NAY'
bsubcat = 'NAY'
descript = ''
baccount = ''
# Create the new database entry for the source document
sdate = adat.Date2
ckmemo = 'Towing for Dealership Car Purchase'
bamt = d2s(adat.TowCost)
bref = ''
btype = 'Expense'
bcat = 'Direct'
bsubcat = 'Overseas'
account = compdata[9]
baccount = 'Towing Costs'
nextjo = newjo(billexpcode, today_str)
print('JO generation output', billexpdata, nextjo)
input = Bills(Jo=nextjo,
Pid=aid,
Company=cdat.Company,
Memo=ckmemo,
Description=bdesc,
bAmount=bamt,
Status='Paid',
Cache=0,
Original='',
Ref=bref,
bDate=sdate,
pDate=today,
pAmount=bamt,
pMulti=None,
pAccount=account,
bAccount=baccount,
bType=btype,
bCat=bcat,
bSubcat=bsubcat,
Link=pufrom,
User=username,
Co=compdata[10],
Temp1=None,
Temp2=str(towid),
Recurring=0,
dDate=today,
pAmount2='0.00',
pDate2=None,
Code1=None,
Code2=None,
CkCache=0,
QBi=0,
iflag=0,
PmtList=None,
PacctList=None,
RefList=None,
MemoList=None,
PdateList=None,
CheckList=None,
MethList=None)
db.session.add(input)
db.session.commit()
modata = Bills.query.filter(Bills.Jo == nextjo).first()
csize = People.query.filter(People.Ptype == 'TowCo').order_by(
People.Company).all()
bill = modata.id
leftscreen = 1
modlink = 12
def isoBank():
if request.method == 'POST':
# ____________________________________________________________________________________________________________________B.FormVariables.General
from viewfuncs import parseline, popjo, jovec, newjo, timedata, nonone, nononef, enter_bk_charges
from viewfuncs import numcheck, numcheckv, viewbuttons, get_ints, numcheckvec, numcheckv, d2s, erud
today = datetime.date.today()
today_str = today.strftime('%Y-%m-%d')
hv = [0] * 9
#Zero and blank items for default
username = session['username'].capitalize()
cache = request.values.get('cache')
cache = nonone(cache)
modata = 0
modlink = 0
docref = ''
oderstring = ''
acname = request.values.get('acname')
today = datetime.date.today()
now = datetime.datetime.now().strftime('%I:%M %p')
err = []
leftsize = 10
match = request.values.get('Match')
modify = request.values.get('Qmod')
vmod = request.values.get('Vmod')
viewo = request.values.get('View')
returnhit = request.values.get('Return')
deletehit = request.values.get('Delete')
delfile = request.values.get('DELF')
# hidden values
update = request.values.get('Update')
newact = request.values.get('NewA')
thisjob = request.values.get('ThisJob')
oder = request.values.get('oder')
modlink = request.values.get('modlink')
depositmake = request.values.get('depositmake')
recdeposit = request.values.get('recdeposit')
unrecord = request.values.get('unrecord')
thismuch = request.values.get('thismuch')
recothese = request.values.get('recothese')
finalize = request.values.get('finalize')
undothese = request.values.get('undothese')
rdate = request.values.get('rdate')
if rdate is None:
rdate = today_str
hv[0] = rdate
hv[1] = [0]
endbal = request.values.get('endbal')
begbal = request.values.get('begbal')
recready = 1
try:
endbal = float(endbal)
except:
endbal = 0.00
err.append('No Statement Balance Entered for Reconciliation')
recready = 0
try:
begbal = float(begbal)
except:
endbal = 0.00
err.append('No Statement Ending Entered for Reconciliation')
recready = 0
oder = nonone(oder)
modlink = nonone(modlink)
leftscreen = 1
err = ['All is well', ' ', ' ', ' ', ' ']
if returnhit is not None:
modlink = 0
depojo = 0
# ____________________________________________________________________________________________________________________E.FormVariables.General
# ____________________________________________________________________________________________________________________B.DataUpdates.General
if modlink == 1:
if oder > 0:
modata = Income.query.get(oder)
vals = [
'jo', 'subjo', 'pid', 'description', 'amount', 'ref',
'pdate', 'original'
]
a = list(range(len(vals)))
for i, v in enumerate(vals):
a[i] = request.values.get(v)
modata.Jo = a[0]
modata.Account = a[1]
modata.Pid = a[2]
modata.Description = a[3]
modata.Amount = a[4]
modata.Ref = a[5]
modata.Date = a[6]
modata.Original = a[7]
db.session.commit()
err[3] = 'Modification to Income id ' + str(
modata.id) + ' completed.'
if update is not None:
modlink = 0
leftsize = 10
else:
leftsize = 6
leftscreen = 0
modata = Income.query.get(oder)
# ____________________________________________________________________________________________________________________B.GetData.General
#odata = Income.query.all()
print('acname=', acname)
odata = dataget_Bank(thismuch, acname)
acctinfo = banktotals(acname)
# ____________________________________________________________________________________________________________________B.Search.General
if modlink == 0:
oder, numchecked = numcheck(1, odata, 0, 0, 0, 0, ['oder'])
# ____________________________________________________________________________________________________________________E.Search.General
if (recothese is not None or finalize is not None) and recready == 1:
if numchecked > -1:
reset_trial(0)
#Get date of reconciliation and bank charges for month
rdate = request.values.get('rdate')
recdate = datetime.datetime.strptime(rdate, "%Y-%m-%d")
recmo = recdate.month
#if recothese is not None: recmo = 25 #Do not record month until reconciliation final
bkcharges = request.values.get('bkcharges')
bkcharges = d2s(bkcharges)
bkchargeid = 0
try:
bkf = float(bkcharges)
print('bkf=', bkf)
if bkf > 0.0:
bank_jo = enter_bk_charges(acname, bkcharges, rdate,
username)
gdat = Gledger.query.filter(
(Gledger.Tcode == bank_jo)
& (Gledger.Type == 'PC')).first()
if gdat is not None:
bkchargeid = gdat.id
except:
bkf = 0.00
odervec = numcheckv(odata)
print('bkid=', bkchargeid)
if bkchargeid > 0 and bkchargeid not in odervec:
odervec.append(bkchargeid)
hv[1] = odervec
print('hv[1]', hv[1])
for oder in odervec:
gdat = Gledger.query.get(oder)
gdat.Reconciled = 25
db.session.commit()
acctinfo = banktotals(acname)
hv[2], hv[3], hv[4], dlist, wlist = recon_totals(acname)
print(hv[2], hv[3])
odata = dataget_Bank(thismuch, acname)
if finalize is not None:
reset_trial(recmo)
hv[1] = [0]
rdat = Reconciliations.query.filter(
(Reconciliations.Rdate == hv[0])
& (Reconciliations.Account == acname)).first()
try:
dlists = json.dumps(dlist)
except:
dlists = None
try:
wlists = json.dumps(wlist)
except:
wlists = None
if rdat is None:
input = Reconciliations(Account=acname,
Rdate=hv[0],
Bbal=acctinfo[9],
Ebal=acctinfo[4],
Deposits=hv[2],
Withdraws=hv[3],
Servicefees=hv[4],
DepositList=dlists,
WithdrawList=wlists,
Status=1,
Diff=acctinfo[5])
db.session.add(input)
db.session.commit()
else:
print('diff', acctinfo[5])
rdat.Account = acname
rdat.Bbal = acctinfo[9]
rdat.Ebal = acctinfo[4]
rdat.Servicefees = hv[4]
rdat.Deposits = hv[2]
rdat.Withdraws = hv[3]
rdat.DepositList = dlists
rdat.WithdrawList = wlists
rdat.Status = 1
rdat.Rdate = hv[0]
rdat.Diff = acctinfo[5]
db.session.commit()
err.append(
f'Reconciliation data saved for Account {acname} Date: {hv[0]}'
)
else:
err.append('No items checked for reconciliation')
if undothese is not None:
odervec = numcheckv(odata)
for oder in odervec:
gdat = Gledger.query.get(oder)
gdat.Reconciled = 0
db.session.commit()
acctinfo = banktotals(acname)
# ____________________________________________________________________________________________________________________B.Modify.General
if (modify is not None or vmod is not None) and numchecked == 1:
modlink = 1
leftsize = 6
if vmod is not None:
leftscreen = 0
if oder > 0:
modata = Income.query.get(oder)
docref = modata.Original
if (modify is not None or vmod is not None) and numchecked != 1:
modlink = 0
err[0] = ' '
err[2] = 'Must check exactly one box to use this option'
# ____________________________________________________________________________________________________________________E.Modify.General
# ____________________________________________________________________________________________________________________B.Delete.General
if deletehit is not None and numchecked == 1:
if oder > 0:
#This section is to determine if we can delete the source file along with the data. If other data is pointing to this
#file then we need to keep it.
modata = Income.query.get(oder)
Income.query.filter(Income.id == oder).delete()
db.session.commit()
if deletehit is not None and numchecked != 1:
err = [
' ', ' ',
'Must have exactly one item checked to use this option', ' ',
' '
]
# ____________________________________________________________________________________________________________________E.Delete.General
if (depositmake is not None
or recdeposit is not None) and depojo is not None:
err = [
'Must have exactly one item checked to use this option', ' ',
' '
]
odervec = numcheckv(odata)
if len(odervec) > 0:
oderstring = json.dumps(odervec)
else:
udat = users.query.filter(users.name == 'cache').first()
oderstring = udat.email
odervec = json.loads(oderstring)
if odervec is not None:
cache = request.values.get('cache')
if cache is None:
cache = 2
if recdeposit is not None:
cache, docref = reportmaker('recdeposit', odervec)
for oder in odervec:
idat = Income.query.get(oder)
subjo = idat.SubJo
ref = idat.Ref
idata = Income.query.filter((Income.SubJo == subjo) &
(Income.Ref == ref)).all()
for data in idata:
data.SubJo = depojo
db.session.commit()
from gledger_write import gledger_write
gledger_write('deposit', depojo, acctsel, 0)
else:
cache, docref = reportmaker('deposit', odervec)
leftscreen = 0
if viewo is not None and numchecked == 1:
if oder > 0:
modata = Income.query.get(oder)
depojo = modata.SubJo
docref = f'tmp/{scac}/data/vdeposits/' + depojo + '.pdf'
leftscreen = 0
if unrecord is not None and numchecked != 1:
modlink = 0
err[0] = ' '
err[2] = 'Must check exactly one box to use this option'
if cache is not None:
#Save the current cache so we do not start from bad place in future
udat = users.query.filter(users.name == 'cache').first()
udat.username = str(cache)
udat.email = oderstring
db.session.commit()
#This is the else for 1st time through (not posting data from overseas.html)
else:
from viewfuncs import popjo, jovec, timedata, nonone, nononef, init_truck_zero, d2s, erud
today = datetime.date.today()
today_str = today.strftime('%Y-%m-%d')
hv = [0] * 9
hv[0] = today_str
hv[1] = [0]
now = datetime.datetime.now().strftime('%I:%M %p')
reset_trial(0)
oder = 0
modata = 0
modlink = 0
odata = Income.query.all()
leftscreen = 1
leftsize = 10
docref = ''
err = ['All is well', ' ', ' ', ' ', ' ']
thismuch = '1'
udat = users.query.filter(users.name == 'Cache').first()
cache = udat.username
cache = nonone(cache)
adat = Accounts.query.filter(Accounts.Type == 'Bank').first()
bankacct = adat.Name
acctinfo = banktotals(bankacct)
odata = dataget_Bank(thismuch, bankacct)
leftsize = 8
acdata = Accounts.query.filter(Accounts.Type == 'Bank').all()
err = erud(err)
return odata, oder, err, modata, modlink, leftscreen, leftsize, today, now, docref, cache, acdata, thismuch, acctinfo, hv
def isoQuote():
username = session['username'].capitalize()
quot = 0
tbox = [0] * 4
qdat = None
from viewfuncs import dataget_Q, nonone, numcheck
if request.method == 'POST':
emailgo = request.values.get('Email')
updatego = request.values.get('GetQuote')
updatebid = request.values.get('Update')
updateE = request.values.get('UpdateE')
returnhit = request.values.get('Return')
bidname = request.values.get('bidname')
bidthis = request.values.get('bidthis')
bidthis = d2s(bidthis)
locfrom = request.values.get('locfrom')
thismuch = request.values.get('thismuch')
taskbox = request.values.get('taskbox')
taskbox = nonone(taskbox)
quotbut = request.values.get('optradio')
qdata = dataget_Q(thismuch)
#quot, numchecked = numcheck(1, qdata, 0, 0, 0, 0, ['quot'])
if quotbut is not None:
quot = nonone(quotbut)
if quot == 0:
quot = request.values.get('quotpass')
quot = nonone(quot)
qdat = Quotes.query.get(quot)
print(quot, quotbut, username)
if returnhit is not None:
taskbox = 0
quot = 0
if taskbox == 2:
qdat.Status = -1
db.session.commit()
taskbox = 0
if taskbox == 3:
qdat.Status = 0
db.session.commit()
taskbox = 0
if taskbox == 4:
qdat.Status = 3
db.session.commit()
taskbox = 0
if taskbox == 6:
add_quote_emails()
if taskbox == 1 or taskbox == 5:
if quot > 0 and qdat is not None:
locto = qdat.Location
if locto is None:
locto = get_place(qdat.Body)
qdat.Location = locto
db.session.commit()
emailto = qdat.From
if emailto is None:
emailto = qdat.From
qdat.From = emailto
db.session.commit()
else:
comdata = companydata()
locto = comdata[6]
emailto = usernames['expo']
if quot > 0 or taskbox == 5:
if qdat is not None:
locfrom = qdat.Start
if locfrom is None:
locfrom = 'Seagirt Marine Terminal, Baltimore, MD 21224'
else:
locfrom = 'Seagirt Marine Terminal, Baltimore, MD 21224'
if updatego is not None or updatebid is not None or emailgo is not None or updateE is not None:
locto = request.values.get('locto')
if locto is None:
locto = 'Capitol Heights, MD 20743'
locfrom = request.values.get('locfrom')
emailto = request.values.get('edat2')
respondnow = datetime.datetime.now()
if taskbox == 1:
qdat.Start = locfrom
qdat.Location = locto
qdat.From = emailto
qdat.Amount = bidthis
qdat.Person = bidname
qdat.Responder = username
qdat.RespDate = respondnow
qdat.Status = 1
db.session.commit()
if emailgo is not None:
if taskbox == 1:
qdat.Status = 2
db.session.commit()
emaildata = sendquote(bidthis)
taskbox = 0
quot = 0
print('Running Directions:', locfrom, locto, bidthis, bidname,
taskbox, quot)
try:
#################################### Directions Section ######################################
miles, hours, lats, lons, dirdata, tot_dist, tot_dura = get_directions(
locfrom, locto)
#print(f'Total distance {d1s(tot_dist)} miles and total duration {d1s(tot_dura)} hours')
#Calculate road tolls
tollroadlist = ['I-76', 'NJ Tpke']
tollroadcpm = [.784, .275]
legtolls = len(dirdata) * [0.0]
legcodes = len(dirdata) * ['None']
for lx, mi in enumerate(miles):
for nx, tollrd in enumerate(tollroadlist):
if tollrd in dirdata[lx]:
legtolls[lx] = tollroadcpm[nx] * mi
legcodes[lx] = tollrd
#Calculate plaza tolls
fm_tollbox = [39.267757, -76.610192, 39.261248, -76.563158]
bht_tollbox = [
39.259962, -76.566240, 39.239063, -76.603324
]
fsk_tollbox = [
39.232770, -76.502453, 39.202279, -76.569906
]
bay_tollbox = [
39.026893, -76.417512, 38.964938, -76.290104
]
sus_tollbox = [
39.585193, -76.142883, 39.552328, -76.033975
]
new_tollbox = [
39.647121, -75.774523, 39.642613, -75.757187
] #Newark Delaware Toll Center
dmb_tollbox = [
39.702146, -75.553479, 39.669730, -75.483284
]
tollcodes = [
'FM', 'BHT', 'FSK', 'BAY', 'SUS', 'NEW', 'DMB'
]
tollboxes = [
fm_tollbox, bht_tollbox, fsk_tollbox, bay_tollbox,
sus_tollbox, new_tollbox, dmb_tollbox
]
for jx, lat in enumerate(lats):
stat1 = 'ok'
stat2 = 'ok'
stat3 = 0
stat4 = 0
tollcode = 'None'
la = float(lat)
lo = float(lons[jx])
for kx, tollbox in enumerate(tollboxes):
lah = max([tollbox[0], tollbox[2]])
lal = min([tollbox[0], tollbox[2]])
loh = max([tollbox[1], tollbox[3]])
lol = min([tollbox[1], tollbox[3]])
if la > lal and la < lah:
stat1 = 'toll'
if lo > lol and lo < loh:
stat2 = 'toll'
tollcode = tollcodes[kx]
legtolls[jx] = 24.00
legcodes[jx] = tollcode
if jx > 0:
lam = (lah + lal) / 2.0
lom = (loh + lol) / 2.0
la_last = float(lats[jx - 1])
lo_last = float(lons[jx - 1])
stat3, stat4 = checkcross(
lam, la_last, la, lom, lo_last, lo)
if stat3 == 1 and stat4 == 1:
tollcode = tollcodes[kx]
legtolls[jx] = 24.00
legcodes[jx] = tollcode
##print(lat,lons[jx],stat1, stat2, stat3, stat4, tollcode)
tot_tolls = 0.00
ex_drv = 27.41
ex_fuel = .48
ex_toll = 24.00
ex_insur = 4.00
ex_rm = .22
ex_misc = .04
ex_ga = 15
expdata = [
d2s(ex_drv),
d2s(ex_fuel),
d2s(ex_toll),
d2s(ex_insur),
d2s(ex_rm),
d2s(ex_misc),
d2s(ex_ga)
]
porttime = 1.4
loadtime = 2.0
triptime = tot_dura * 2.0
glidetime = 1.0 + triptime * .01
tottime = porttime + loadtime + triptime + glidetime
timedata = [
d1s(triptime),
d1s(porttime),
d1s(loadtime),
d1s(glidetime),
d1s(tottime)
]
tripmiles = tot_dist * 2.0
portmiles = .4
glidemiles = 10 + .005 * tripmiles
totmiles = tripmiles + portmiles + glidemiles
distdata = [
d1s(tripmiles),
d1s(portmiles), '0.0',
d1s(glidemiles),
d1s(totmiles)
]
newdirdata = []
for lx, aline in enumerate(dirdata):
tot_tolls += legtolls[lx]
aline = aline.replace(
'<div style="font-size:0.9em">Toll road</div>', '')
aline = aline.strip()
#print(aline)
#print(f'Dist:{d1s(miles[lx])}, Time:{d1s(hours[lx])}, ')
if legtolls[lx] < .000001:
newdirdata.append(
f'{d1s(miles[lx])} MI {d2s(hours[lx])} HRS {aline}'
)
else:
newdirdata.append(
f'{d1s(miles[lx])} MI {d2s(hours[lx])} HRS {aline} Tolls:${d2s(legtolls[lx])}, TollCode:{legcodes[lx]}'
)
# Cost Analysis:
cost_drv = tottime * ex_drv
cost_fuel = totmiles * ex_fuel
cost_tolls = 2.0 * tot_tolls
cost_insur = tottime * ex_insur
cost_rm = totmiles * ex_rm
cost_misc = totmiles * ex_misc
cost_direct = cost_drv + cost_fuel + cost_tolls + cost_insur + cost_rm + cost_misc
cost_ga = cost_direct * ex_ga / 100.0
cost_total = cost_direct + cost_ga
costdata = [
d2s(cost_drv),
d2s(cost_fuel),
d2s(cost_tolls),
d2s(cost_insur),
d2s(cost_rm),
d2s(cost_misc),
d2s(cost_ga),
d2s(cost_direct),
d2s(cost_total)
]
bid = cost_total * 1.2
cma_bid = bid / 1.13
std_bid = 250. + 2.1 * totmiles
biddata = [
d2s(roundup(bid)),
d2s(roundup(std_bid)),
d2s(roundup(cma_bid))
]
if updatego is not None or quotbut is not None or (
taskbox == 5 and updatebid is None):
bidthis = d2s(roundup(bid))
except:
costdata = None
biddata = None
newdirdata = None
bidthis = None
bidname = None
ex_drv = 27.41
ex_fuel = .48
ex_toll = 24.00
ex_insur = 4.00
ex_rm = .22
ex_misc = .04
ex_ga = 15
expdata = [
d2s(ex_drv),
d2s(ex_fuel),
d2s(ex_toll),
d2s(ex_insur),
d2s(ex_rm),
d2s(ex_misc),
d2s(ex_ga)
]
timedata = []
distdata = []
if quotbut is not None:
#Set the email data:
etitle = f'{cdata[0]} Quote to {locto} from {locfrom}'
if qdat is not None:
customer = qdat.Person
if customer is None:
customer = friendly(emailto)
else:
customer = friendly(emailto)
qdat.Person = customer
bidname = customer
db.session.commit()
ebody, tbox = bodymaker(bidname, cdata, bidthis, locto,
tbox)
ebody = ebody + maketable()
emailin1 = request.values.get('edat2')
if updatego is None:
emailin1 = emailonly(emailto)
emailin2 = ''
emailcc1 = usernames['info']
emailcc2 = usernames['expo']
emaildata = [
etitle, ebody, emailin1, emailin2, emailcc1, emailcc2
]
else:
#Set the email data:
if updatebid is not None or updatego is not None:
etitle = f'{cdata[0]} Quote to {locto} from {locfrom}'
ebody, tbox = bodymaker(bidname, cdata, bidthis, locto,
tbox)
ebody = ebody + maketable()
else:
etitle = request.values.get('edat0')
ebody = request.values.get('edat1')
emailin1 = request.values.get('edat2')
emailin2 = request.values.get('edat3')
emailcc1 = request.values.get('edat4')
emailcc2 = request.values.get('edat5')
emaildata = [
etitle, ebody, emailin1, emailin2, emailcc1, emailcc2
]
#qdat.Response = ebody
db.session.commit()
else:
qdata = dataget_Q(thismuch)
quot = request.values.get('optradio')
if quot is not None:
qdat = Quotes.query.get(quot)
locto = 'Capitol Heights, MD 20743'
locfrom = 'Baltimore Seagirt'
etitle = f'{cdata[0]} Quote for Drayage to {locto} from {locfrom}'
if qdat is not None:
ebody = qdat.Body
else:
ebody = f'Regirgitation from the input'
efrom = usernames['quot']
eto1 = 'unknown'
eto2 = ''
ecc1 = usernames['expo']
ecc2 = usernames['info']
emaildata = [etitle, ebody, eto1, eto2, ecc1, ecc2, efrom]
costdata = None
biddata = None
newdirdata = None
bidthis = None
bidname = None
ex_drv = 27.41
ex_fuel = .48
ex_toll = 24.00
ex_insur = 4.00
ex_rm = .22
ex_misc = .04
ex_ga = 15
expdata = [
d2s(ex_drv),
d2s(ex_fuel),
d2s(ex_toll),
d2s(ex_insur),
d2s(ex_rm),
d2s(ex_misc),
d2s(ex_ga)
]
timedata = []
distdata = []
else:
print('Entering Quotes1', flush=True)
username = session['username'].capitalize()
tbox = []
qdat = None
locto = 'Upper Marlboro, MD 20772'
locfrom = 'Baltimore Seagirt'
etitle = f'{cdata[0]} Quote for Drayage to {locto} from {locfrom}'
ebody = f'Regirgitation from the input'
efrom = usernames['quot']
eto1 = 'unknown'
eto2 = ''
ecc1 = usernames['expo']
ecc2 = usernames['info']
emaildata = [etitle, ebody, eto1, eto2, ecc1, ecc2, efrom]
costdata = None
biddata = None
newdirdata = None
bidthis = None
bidname = None
print('Entering Quotes2', flush=True)
ex_drv = 27.41
ex_fuel = .48
ex_toll = 24.00
ex_insur = 4.00
ex_rm = .22
ex_misc = .04
ex_ga = 15
expdata = [
d2s(ex_drv),
d2s(ex_fuel),
d2s(ex_toll),
d2s(ex_insur),
d2s(ex_rm),
d2s(ex_misc),
d2s(ex_ga)
]
timedata = []
distdata = []
add_quote_emails()
thismuch = '1'
taskbox = 0
quot = 0
print('Entering Quotes3', flush=True)
print('Getting qdata', flush=True)
qdata = dataget_Q(thismuch)
print(quot)
return bidname, costdata, biddata, expdata, timedata, distdata, emaildata, locto, locfrom, newdirdata, qdata, bidthis, taskbox, thismuch, quot, qdat, tbox
def invoiceO(ship, payment):
today = datetime.datetime.today()
myo = OverSeas.query.get(ship)
# Check to see if we have the required data to make an invoice:
pdat = People.query.get(myo.Pid)
if pdat is not None:
invo = 1
leftsize = 8
if myo.Cache is not None:
cache = myo.Cache + 1
else:
cache = 1
# if no invoice has been created add all the basics:
idat = Invoices.query.filter(Invoices.Jo == myo.Jo).first()
if idat is None:
descript = 'Job ' + myo.Jo + ': ' + myo.Pol + ' to ' + myo.Pod
try:
total = myo.Charge.replace('$', '').replace(',', '')
total = float(total)
except:
total = 0.00
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=0,
Service='Overseas Shipping',
Description=descript,
Ea=total,
Qty=1,
Amount=total,
Total=total,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
# These are the services we wish to add to the invoice
sdata = Services.query.order_by(Services.Price.desc()).all()
total = 0
for data in sdata:
testone = request.values.get('serv' + str(data.id))
if testone:
servid = int(testone)
mys = Services.query.get(servid)
qty = 1
total = total + mys.Price
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=myo.Pid,
Service=mys.Service,
Description='',
Ea=mys.Price,
Qty=qty,
Amount=mys.Price,
Total=None,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
adata = Autos.query.filter(Autos.Jo == myo.Jo).all()
for data in adata:
ihave = Invoices.query.filter(
Invoices.SubJo == str(data.id)).first()
if ihave is None:
qty = 1
towcost = data.TowCostEa
if towcost is None:
data.TowCostEa = '0.00'
towcost = '0.00'
towcharge = nononef(towcost)
total = total + towcharge
descript = data.Year + ' ' + data.Color + ' ' + data.Make + ' ' + data.Model + ' VIN:' + data.VIN
input = Invoices(Jo=myo.Jo,
SubJo=str(data.id),
Pid=myo.Pid,
Service='Towing',
Description=descript,
Ea=towcharge,
Qty=qty,
Amount=towcharge,
Total=None,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
total = 0.0
ldata = Invoices.query.filter(Invoices.Jo == myo.Jo).all()
for ldat in ldata:
qty = float(ldat.Qty)
each = float(ldat.Ea)
amount = qty * each
total = total + amount
ldat.Amount = d2s(amount)
db.session.commit()
for ldat in ldata:
ldat.Total = d2s(total)
db.session.commit()
ldat = Invoices.query.filter(Invoices.Jo == myo.Jo).first()
if ldat is None:
invo = 0
leftsize = 10
err = [
' ', ' ', 'No services on invoice yet and none selected', ' ',
' '
]
else:
invo = 1
leftsize = 8
dt = ldat.Date
invodate = ldat.Date.strftime('%m/%d/%Y')
err = [' ', ' ', 'Created invoice for JO= ' + myo.Jo, ' ', ' ']
ldata = Invoices.query.filter(Invoices.Jo == myo.Jo).order_by(
Invoices.Ea.desc()).all()
pdata1 = People.query.get(myo.Pid)
pdata2 = People.query.get(myo.ExportID)
pdata3 = People.query.get(myo.ConsigID)
pdata4 = People.query.get(myo.NotifyID)
# _______________________________________________________________________________________________________________
joborder = myo.Jo
file1 = addpath(f'tmp/{scac}/data/vinvoice/INV' + joborder +
'.pdf')
file2 = addpath(f'tmp/{scac}/data/vinvoice/INV' + joborder + 'c' +
str(cache) + '.pdf')
file3 = addpath(f'tmp/{scac}/data/vinvoice/INV' + joborder + 'c' +
str(cache - 1) + '.pdf')
today = datetime.datetime.today().strftime('%m/%d/%Y')
type = joborder[1]
myb = Bookings.query.filter(
myo.Booking == Bookings.Booking).first()
if myb is not None:
loadat1 = myo.Pol
saildate = myb.SailDate.strftime('%m/%d/%Y')
shipto1 = myo.Pod
arrival = myb.EstArr.strftime('%m/%d/%Y')
theline = myb.Line
vessel = myb.Vessel
else:
loadat1 = myo.Pol
saildate = 'TBD'
shipto1 = myo.Pod
arrival = 'TBD'
theline = ' '
vessel = ' '
if payment != 0:
try:
paydate = payment[2].strftime('%m/%d/%Y')
except:
paydate = payment[2]
billto = list(range(5))
if pdata1 is not None:
billto[0] = comporname(
pdata1.Company,
fullname(pdata1.First, pdata1.Middle, pdata1.Last))
billto[1] = nononestr(pdata1.Addr1)
billto[2] = nononestr(pdata1.Addr2)
billto[3] = nononestr(pdata1.Telephone)
billto[4] = nononestr(pdata1.Email)
else:
for i in range(5):
billto[i] = ' '
loadat = list(range(5))
if pdata2 is not None:
loadat[0] = parselinenoupper(loadat1, 34)
loadat[1] = parselinenoupper('Depart Date: ' + saildate, 28)
loadat[2] = ' '
loadat[3] = parselinenoupper(shipto1, 28)
loadat[4] = parselinenoupper('Est. Arrival Date: ' + arrival,
28)
else:
for i in range(5):
loadat[i] = ' '
shipto = list(range(5))
if pdata3 is not None:
shipto[0] = comporname(
pdata3.Company,
fullname(pdata3.First, pdata3.Middle, pdata3.Last))
shipto[0] = shipto[0].title()
shipto[1] = nononestr(pdata3.Addr1).title()
shipto[2] = nononestr(pdata3.Addr2).title()
shipto[3] = nononestr(pdata3.Telephone)
shipto[4] = nononestr(pdata3.Email).lower()
else:
for i in range(5):
shipto[i] = ' '
us = list(range(4))
us[0] = 'FIRST EAGLE LOGISTICS INC'
us[1] = '505 HAMPTON PARK BLVD UNIT O'
us[2] = 'CAPITOL HEIGHTS MD 20743'
us[3] = '301-516-3000 [email protected]'
line1 = [
'Booking #', 'Container No.', 'Ship', 'Via', 'Vessel', 'Terms'
]
line2 = [
'Quantity', 'Item Code', 'Description', 'Price Each', 'Amount'
]
line3 = [
myo.Booking, myo.Container, theline, myo.MoveType, vessel,
'Due Upon Receipt'
]
note, bank = bankdata('FC')
lab1 = 'Balance Due'
lab2 = 'Add $39.00 for all international wires'
ltm = 36
rtm = 575
ctrall = 310
left_ctr = 170
right_ctr = 480
dl = 17.6
tdl = dl * 2
hls = 530
m1 = hls - dl
m2 = hls - 2 * dl
m3 = hls - 3 * dl
m4 = hls - 4 * dl
m5 = hls - 18 * dl
m6 = hls - 23 * dl
m7 = hls - 27 * dl
fulllinesat = [m1, m2, m3, m4, m5, m6, m7]
p1 = ltm + 87
p2 = ltm + 168
p3 = ctrall - 25
p4 = rtm - 220
p5 = rtm - 120
sds1 = [p1, p2, p3, p4, p5]
n1 = ltm + 50
n2 = ltm + 130
n3 = rtm - 140
n4 = rtm - 70
sds2 = [n1, n2, n3, n4]
q1 = ltm + 180
q2 = rtm - 180
sds3 = [q1, q2]
bump = 2.5
tb = bump * 2
c = canvas.Canvas(file1, pagesize=letter)
c.setLineWidth(1)
logo = addpath("tmp/pics/logo3.jpg")
c.drawImage(logo, 185, 680, mask='auto')
# Date and JO boxes
dateline = m1 + 8.2 * dl
c.rect(rtm - 150, m1 + 7 * dl, 150, 2 * dl, stroke=1, fill=0)
c.line(rtm - 150, dateline, rtm, dateline)
c.line(rtm - 75, m1 + 7 * dl, rtm - 75, m1 + 9 * dl)
ctm = 218
c.rect(ltm, m1 + dl, 175, 5 * dl, stroke=1, fill=0)
c.rect(ctm, m1 + dl, 150, 5 * dl, stroke=1, fill=0)
c.rect(rtm - 200, m1 + dl, 200, 5 * dl, stroke=1, fill=0)
level1 = m1 + 5 * dl
c.line(ltm, level1, ltm + 175, level1)
c.line(ctm, level1, ctm + 150, level1)
c.line(rtm - 200, level1, rtm, level1)
for i in fulllinesat:
c.line(ltm, i, rtm, i)
for k in sds1:
c.line(k, m1, k, m3)
for l in sds2:
c.line(l, m3, l, m5)
for m in sds3:
c.line(m, m6, m, m7)
c.line(ltm, m1, ltm, m7)
c.line(rtm, m1, rtm, m7)
h1 = avg(m6, m7) - 3
c.line(q2, h1, rtm, h1)
c.setFont('Helvetica-Bold', 24, leading=None)
c.drawCentredString(rtm - 75, dateline + 1.5 * dl, 'Invoice')
c.setFont('Helvetica', 12, leading=None)
c.drawCentredString(rtm - 112.5, dateline + bump, 'Date')
c.drawCentredString(rtm - 37.7, dateline + bump, 'Invoice #')
c.drawString(ltm + bump * 3, m1 + 5 * dl + bump * 2, 'Bill To')
c.drawString(ctm + bump * 3, m1 + 5 * dl + bump * 2,
'Port to Port')
c.drawString(rtm - 200 + bump * 2, m1 + 5 * dl + bump * 2,
'Customer/Consignee')
ctr = [
avg(ltm, p1),
avg(p1, p2),
avg(p2, p3),
avg(p3, p4),
avg(p4, p5),
avg(p5, rtm)
]
for j, i in enumerate(line1):
c.drawCentredString(ctr[j], m2 + tb, i)
ctr = [
avg(ltm, n1),
avg(n1, n2),
avg(n2, n3),
avg(n3, n4),
avg(n4, rtm)
]
for j, i in enumerate(line2):
c.drawCentredString(ctr[j], m4 + tb, i)
dh = 12
ct = 305
top = m6 - 1.5 * dh
for i in bank:
c.drawCentredString(ct, top, i)
top = top - dh
top = m1 + 9 * dl - 5
for i in us:
c.drawString(ltm + bump, top, i)
top = top - dh
bottomline = m6 - 23
c.setFont('Helvetica-Bold', 12, leading=None)
c.drawString(q2 + tb, bottomline, 'Balance Due:')
c.setFont('Helvetica', 10, leading=None)
c.drawCentredString(avg(q2, rtm), m7 + 12,
'Add $39.00 for all international wires')
c.setFont('Times-Roman', 9, leading=None)
dh = 9.95
top = m5 - dh
for j, i in enumerate(note):
c.drawString(ltm + tb, top, note[j])
top = top - dh
# _______________________________________________________________________
# Insert data here
# _______________________________________________________________________
c.setFont('Helvetica', 10, leading=None)
dh = 13
top = level1 - dh
lft = ltm + bump * 3
for i in billto:
i = i.title()
c.drawString(lft, top, i)
top = top - dh
top = level1 - dh
lft = ctm + bump * 3
for i in loadat:
for k in i:
c.drawString(lft, top, k)
top = top - dh
top = level1 - dh
lft = rtm - 205 + bump * 3
for i in shipto:
c.drawString(lft, top, i)
top = top - dh
x = avg(rtm - 75, rtm)
y = dateline - dh - bump
c.drawCentredString(x, y, joborder)
x = avg(rtm - 75, rtm - 150)
c.drawCentredString(x, y, invodate)
c.setFont('Helvetica', 9, leading=None)
ctr = [
avg(ltm, p1),
avg(p1, p2),
avg(p2, p3),
avg(p3, p4),
avg(p4, p5),
avg(p5, rtm)
]
for j, i in enumerate(line3):
c.drawCentredString(ctr[j], m3 + tb, i)
total = 0
top = m4 - dh
for data in ldata:
qty = data.Qty
if qty != -1:
qty = int(nonone(data.Qty))
each = float(nonone(data.Ea))
subtotal = qty * each
if subtotal == 0:
sqty = ''
theservice = 'Included/NoTow'
theeach = ''
thesubtotal = ''
else:
sqty = str(qty)
theservice = data.Service
theeach = dollar(each)
thesubtotal = dollar(subtotal)
total = total + subtotal
line4 = [sqty, theservice]
line5 = nononestr(data.Description)
line6 = [theeach, thesubtotal]
ctr = [avg(ltm, n1), avg(n1, n2)]
for j, i in enumerate(line4):
c.drawCentredString(ctr[j], top, i)
c.drawString(n2 + tb, top, line5)
ctr = [n4 - tb * 2, rtm - tb * 2]
for j, i in enumerate(line6):
c.drawRightString(ctr[j], top, i)
top = top - dh
if payment != 0:
c.setFont('Helvetica-Bold', 18, leading=None)
c.drawCentredString(ct, top - 2 * dh, 'Payment Received')
if payment != 0:
c.setFont('Helvetica-Bold', 12, leading=None)
try:
thispay = dollar(float(payment[0]))
except:
thispay = '$0.00'
# dollar(float(payment[0]))
top = top - 4 * dh
try:
c.drawString(
n2 + bump, top, 'Your payment of ' + thispay +
', Ref No. ' + payment[1])
except:
c.drawString(ct, top, 'There is no payment data as of yet')
try:
c.drawString(n2 + bump, top - dh,
'was applied on ' + paydate)
except:
c.drawString(ct, top - dh,
'There is a problem with the date')
thispay = nononef(thispay)
else:
thispay = 0.00
baldue = total - thispay
c.drawRightString(rtm - tb * 2, bottomline, dollar(baldue))
c.showPage()
c.save()
#
# Now make a cache copy
shutil.copy(file1, file2)
try:
shutil.move(file3, file1)
except:
err = 'No file there'
# _______________________________________________________________________________________________________________
if cache > 1:
docref = f'tmp/{scac}/data/vinvoice/INV' + myo.Jo + 'c' + str(
cache) + '.pdf'
# Store for future use
else:
docref = f'tmp/{scac}/data/vinvoice/INV' + myo.Jo + '.pdf'
if payment == 0:
for ldatl in ldata:
ldatl.Pid = pdata1.id
ldatl.Original = docref
db.session.commit()
myo.Ipath = docref
myo.Cache = cache
db.session.commit()
leftscreen = 0
#err[4]='Viewing '+docref
return invo, err, leftscreen, leftsize, docref, dt
def isoDeposit():
if request.method == 'POST':
# ____________________________________________________________________________________________________________________B.FormVariables.General
from viewfuncs import parseline, popjo, jovec, newjo, timedata, nonone, nononef, erud, hasinput
from viewfuncs import numcheck, numcheckv, viewbuttons, get_ints, numcheckvec, numcheckv, d2s
#Zero and blank items for default
username = session['username'].capitalize()
cache = request.values.get('cache')
cache = nonone(cache)
modata = 0
modlink = 0
docref = ''
oderstring = ''
acdeposit = request.values.get('acdeposit')
if acdeposit is None:
acdeposit = request.values.get('actype')
depojo = request.values.get('depojo')
cofor = request.values.get('cofor')
depdate = request.values.get('depdate')
print(depdate, hasinput(depdate))
if not hasinput(depdate):
depdate = datetime.datetime.today().strftime('%Y-%m-%d')
depdata = [acdeposit, cofor, depojo, depdate]
print(depdata)
today = datetime.date.today()
now = datetime.datetime.now().strftime('%I:%M %p')
leftsize = 10
match = request.values.get('Match')
modify = request.values.get('Qmod')
vmod = request.values.get('Vmod')
viewo = request.values.get('View')
returnhit = request.values.get('Return')
deletehit = request.values.get('Delete')
delfile = request.values.get('DELF')
# hidden values
update = request.values.get('Update')
newact = request.values.get('NewA')
thisjob = request.values.get('ThisJob')
oder = request.values.get('oder')
modlink = request.values.get('modlink')
depositmake = request.values.get('depositmake')
recdeposit = request.values.get('recdeposit')
unrecord = request.values.get('unrecord')
thismuch = request.values.get('thismuch')
oder = nonone(oder)
modlink = nonone(modlink)
leftscreen = 1
err = []
if returnhit is not None:
modlink = 0
depojo = 0
depdata = [0, 0, 0, depdate]
# ____________________________________________________________________________________________________________________E.FormVariables.General
# ____________________________________________________________________________________________________________________B.DataUpdates.General
# ____________________________________________________________________________________________________________________B.GetData.General
odata = dataget_Dep(thismuch)
gdata = undeposited(thismuch)
# ____________________________________________________________________________________________________________________B.Search.General
if modlink == 0:
oder, numchecked = numcheck(1, gdata, 0, 0, 0, 0, ['oder'])
# ____________________________________________________________________________________________________________________E.Search.General
acctsel = request.values.get('actype')
if acctsel is not None and not hasinput(depojo):
print(f'Getting depojo acctsel {acctsel}')
cofor = 0
if oder > 0:
inc = Gledger.query.get(oder)
jo = inc.Tcode
cofor = jo[0] + 'D'
else:
acdat = Accounts.query.filter(Accounts.Name == acctsel).first()
if acdat is not None:
cofor = acdat.Co + 'D'
if cofor != 0:
todayyf = datetime.datetime.today().strftime('%Y-%m-%d')
depojo = newjo(cofor, todayyf)
depdata = [acctsel, cofor, depojo, depdate]
# ____________________________________________________________________________________________________________________E.Delete.General
if (depositmake is not None
or recdeposit is not None) and depojo is not None:
odervec = numcheckv(gdata)
print('odervec', odervec)
if len(odervec) > 0:
try:
oderstring = json.dumps(odervec)
except:
oderstring = ''
else:
udat = users.query.filter(users.name == 'cache').first()
oderstring = udat.email
odervec = json.loads(oderstring)
if odervec is not None:
cache = request.values.get('cache')
if cache is None:
cache = 2
if recdeposit is not None:
cache, docref = reportmaker('recdeposit', odervec)
depojo = request.values.get('depojo')
sourcelist = []
total = 0.00
for oder in odervec:
idat = Gledger.query.get(oder)
amount = float(idat.Debit) / 100.
total = total + amount
for oder in odervec:
idat = Gledger.query.get(oder)
fromco = idat.Source
amount = d2s(float(idat.Debit) / 100.)
sid = idat.Sid
jo = idat.Tcode
ref = idat.Ref
if fromco is None:
cdat = People.query.get(idat.Sid)
if cdat is not None:
fromco = cdat.Company
else:
fromco = 'Unknown Source'
if fromco not in sourcelist: sourcelist.append(fromco)
acct = idat.Account
bank = request.values.get('acdeposit')
date2 = request.values.get('depdate')
ddat = Deposits.query.filter(
Deposits.Jo == idat.Tcode).first()
if ddat is None:
input = Deposits(Jo=jo,
Account=acct,
Pid=sid,
Amount=amount,
Total=d2s(total),
Ref=ref,
Date=date2,
Original=os.path.basename(docref),
From=fromco,
Bank=bank,
Date2=today,
Depositnum=depojo)
db.session.add(input)
db.session.commit()
else:
ddat.Depositnum = depojo
ddat.Bank = bank
ddat.Date2 = date2
ddat.From = fromco
ddat.Original = os.path.basename(docref)
db.session.commit()
print('Here', depojo, acctsel)
if len(sourcelist) == 1:
sendsource = sourcelist[0]
else:
sendsource = json.dumps(sourcelist)
if len(sendsource) > 49:
sendsource = 'Multiple Sources'
from gledger_write import gledger_write
gledger_write('deposit', depojo, acctsel, sendsource)
else:
print(odervec)
cache, docref = reportmaker('deposit', odervec)
leftscreen = 0
if unrecord is not None and numchecked == 1:
if oder > 0:
modata = Income.query.get(oder)
subjo = modata.SubJo
idata = Income.query.filter(Income.SubJo == subjo).all()
for idat in idata:
idat.SubJo = 'Mremit'
db.session.commit()
jdat = JO.query.filter(JO.jo == subjo).first()
if jdat is not None:
jdat.dinc = '0.00'
db.session.commit()
Gledger.query.filter(Gledger.Tcode == subjo).delete()
db.session.commit()
if viewo is not None and numchecked == 1:
if oder > 0:
modata = Income.query.get(oder)
filename = modata.Depositnum
docref = f'tmp/{scac}/data/vdeposits/' + filename + '.pdf'
leftscreen = 0
if unrecord is not None and numchecked != 1:
modlink = 0
err.append('Must check exactly one box to use this option')
if cache is not None:
#Save the current cache so we do not start from bad place in future
udat = users.query.filter(users.name == 'cache').first()
udat.username = str(cache)
udat.email = oderstring
db.session.commit()
#This is the else for 1st time through (not posting data from overseas.html)
else:
from viewfuncs import popjo, jovec, timedata, nonone, nononef, init_truck_zero, erud
today = datetime.date.today()
today_str = datetime.datetime.today().strftime('%Y-%m-%d')
now = datetime.datetime.now().strftime('%I:%M %p')
oder = 0
modata = 0
modlink = 0
leftscreen = 1
leftsize = 10
docref = ''
err = ['Ready to make and review account deposits']
thismuch = '2'
udat = users.query.filter(users.name == 'Cache').first()
cache = udat.username
cache = nonone(cache)
depdata = [0, 0, 0, today_str]
gdata = undeposited(thismuch)
odata = dataget_Dep(thismuch)
leftsize = 8
acdata = Accounts.query.filter(Accounts.Type == 'Bank').all()
err = erud(err)
return odata, gdata, oder, err, modata, modlink, leftscreen, leftsize, today, now, docref, cache, acdata, thismuch, depdata
def multi_inv(odata, odervec, chas, newchas):
# First create all the invoices for these specific jobs
for oder in odervec:
myo = Orders.query.get(oder)
con = myo.Container
qty, d1, d2 = chassismatch(myo)
myo.Links = json.dumps(odervec)
Invoices.query.filter(Invoices.Jo == myo.Jo).delete()
myo.Istat = 1
db.session.commit()
for oder in odervec:
myo = Orders.query.get(oder)
qty, d1, d2 = chassismatch(myo)
shipper = myo.Shipper
jo = myo.Jo
bid = myo.Bid
chassis = myo.Chassis
if chassis is None:
chassis = 'NoNum'
myo.Chassis = chassis
db.session.commit()
if 'GBL' in chassis: chas = 0
lid = myo.Lid
if lid is None or lid == 0:
expimp = getexpimp(con)
if expimp == 'Export':
lid = dropupdate2(bid)
if expimp == 'Import':
lid = dropupdate3('BAL')
if lid is None or lid == 0:
myo.lid = 0
myo.Company = 'NAY'
else:
print('lid=',lid)
ddat = Drops.query.get(lid)
myo.Lid = lid
myo.Company = ddat.Entity
db.session.commit()
myo = Orders.query.get(oder)
did = myo.Did
if did is None or did == 0:
expimp = getexpimp(con)
if expimp == 'Export':
did = dropupdate3('BAL')
if expimp == 'Import':
did = dropupdate2(bid)
if did is None or did == 0:
myo.did = 0
myo.Company2 = 'NAY'
else:
ddat = Drops.query.get(did)
myo.Did = did
myo.Company2 = ddat.Entity
db.session.commit()
myo = Orders.query.get(oder)
cache = myo.Icache
c1, c2 = myo.Company, myo.Company2
c1, c2 = stripper(c1), stripper(c2)
if chas != 1:
# Make sure all invoices have the required parts
total = float(myo.Amount)
descript = 'From ' + c1 + ' to ' + c2
input = Invoices(Jo=myo.Jo, SubJo=None, Pid=bid, Service='Line Haul', Description=descript,
Ea=myo.Amount, Qty=1, Amount=total, Total=total, Date=today, Original=None, Status='New')
db.session.add(input)
db.session.commit()
# If chassis to be added then we have to add those fees in:
if chas == 1:
mys = Services.query.filter(Services.Service == 'Chassis Fees').first()
descript = 'Days of Chassis'
if newchas == 0:
price = float(mys.Price)
else:
price = float(newchas)
chassis_amount = price*qty
haul_amount = float(myo.Amount)
total = haul_amount+chassis_amount
input = Invoices(Jo=myo.Jo, SubJo=None, Pid=bid, Service=mys.Service, Description=descript,
Ea=d2s(price), Qty=qty, Amount=chassis_amount, Total=total, Date=today, Original=None, Status='New')
db.session.add(input)
db.session.commit()
descript = 'From ' + c1 + ' to ' + c2
input = Invoices(Jo=myo.Jo, SubJo=None, Pid=bid, Service='Line Haul', Description=descript,
Ea=myo.Amount, Qty=1, Amount=haul_amount, Total=total, Date=today, Original=None, Status='New')
db.session.add(input)
db.session.commit()
# Now write out the invoice
ldata = Invoices.query.filter(Invoices.Jo == myo.Jo).order_by(Invoices.Ea.desc()).all()
pdata1 = People.query.filter(People.id == myo.Bid).first()
pdata2 = Drops.query.filter(Drops.id == myo.Lid).first()
pdata3 = Drops.query.filter(Drops.id == myo.Did).first()
from make_T_invoice import T_invoice
T_invoice(myo, ldata, pdata1, pdata2, pdata3, cache, today, 0)
docref = f'tmp/{scac}/data/vinvoice/INV'+myo.Jo+'c'+str(cache)+'.pdf'
for ldatl in ldata:
ldatl.Pid = pdata1.id
ldatl.Original = docref
db.session.commit()
myo.Invoice = os.path.basename(docref)
myo.Icache = cache+1
db.session.commit()
# Now all the invoices are created. Next pack them up and create a single master invoice.
keydata = [0]*len(odervec)
grandtotal = 0
for jx, ix in enumerate(odervec):
odat = Orders.query.get(ix)
print(f'Working {oder} {odat.Jo} ')
if jx == 0:
pdata1 = People.query.filter(People.id == odat.Bid).first()
date1 = odat.Date
order = odat.Order
date2 = odat.Date2
dtest1 = odat.Date
dtest2 = odat.Date2
if dtest1 < date1:
date1 = dtest1
if dtest2 > date2:
date2 = dtest2
idat = Invoices.query.filter(Invoices.Jo == odat.Jo).order_by(Invoices.Ea.desc()).first()
c1, c2 = odat.Company, odat.Company2
c1, c2 = stripper(c1), stripper(c2)
descr = 'From ' + c1 + ' to ' + c2
keydata[jx] = [odat.Jo, odat.Booking, odat.Container, idat.Total, descr]
grandtotal = grandtotal+float(idat.Total)
print(keydata[jx])
# put together the file paperwork
file1 = f'tmp/{scac}/data/vpackages/P_' + 'test.pdf'
cache2 = int(odat.Pkcache)
docref = f'tmp/{scac}/data/vpackages/P_c'+str(cache2)+'_' + order + '.pdf'
odat.Pkcache = cache2 + 1
for jx, ix in enumerate(odervec):
odat = Orders.query.get(ix)
odat.Package = os.path.basename(docref)
db.session.commit()
import make_TP_invoice
make_TP_invoice.main(file1, keydata, grandtotal, pdata1, date1, date2)
filegather = ['pdfunite', addpath(file1)]
for ix in odervec:
odat = Orders.query.get(ix)
filegather.append(addpath(f'tmp/{scac}/data/vinvoice/{odat.Invoice}'))
filegather.append(addpath(docref))
tes = subprocess.check_output(filegather)
return docref
def plcontents(file4, itemlist, blist, cache):
details = request.values.get('dt3')
indent1 = 50
lastexp = 'D'
today = datetime.datetime.today().strftime('%m/%d/%Y')
invodate = datetime.date.today().strftime('%m/%d/%Y')
sdate = request.values.get('start')
fdate = request.values.get('finish')
try:
start = datetime.datetime.strptime(sdate, '%Y-%m-%d')
end = datetime.datetime.strptime(fdate, '%Y-%m-%d')
except:
start = today
end = today
ltm, rtm, bump, tb, ctrall, left_ctr, right_ctr, dl, dh, tdl, hls, m1, m2, m3, m4, m5, m6, m7, n1, n2, n3 = reportsettings(
1)
pages = [file4]
page = 1
c = canvas.Canvas(file4, pagesize=letter)
c.setLineWidth(1)
bottomy = n3
mtop = n1
p1 = ltm + 55
p15 = ltm + 65
p2 = ltm + 140
p3 = ltm + 200
p4 = ltm + 270
p5 = rtm - 150
p6 = rtm - 50
# p7=rtm-40
#Set the Building Propration for Items shared between FEL and Other
Fbp = .80
prorate = [1.0, 1.0]
inctotals = [0.0, 0.0, 0.0, 0.0]
optype = ['Trucking', 'Overseas', 'Storage', 'Moving']
keyval = ['Order', 'Booking', 'JO', 'JO']
exptotals = [0.0, 0.0]
i_categories = [
'BldRent', 'BldRepMaint', 'Utilities', 'Adv-Mark', 'BankFees', 'Taxes',
'OfficeSupp', 'Insurance', 'ProfFees', 'Other'
]
d_categories = [
'Container', 'Towing', 'Fuel', 'Payroll', 'Rentals', 'Other'
]
catbp = [
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, Fbp, Fbp, Fbp, 1.0, 1.0, 1.0, Fbp, 1.0,
1.0, 1.0
]
extype = []
exptotals = []
for cat in d_categories:
extype.append('D:' + cat)
exptotals.append(0.0)
for cat in i_categories:
extype.append('I:' + cat)
exptotals.append(0.0)
#___________Income_____________________________
for kval in range(4):
complete = 0
while complete == 0 and page < 20:
c, page, pages, mtop = newpagecheck(c, mtop, bottomy + 20, page,
file4, pages)
if details == 'on':
hvec = [ltm, p1, p15, p2, p3, p4, p5, p6, rtm]
headerlist = [
'InvoDate', 'L', 'Service', optype[kval], 'Container',
'From', 'To', 'Invoiced'
]
justify = ['c', 'c', 'l', 'l', 'l', 'l', 'l', 'r']
mtop = stripheader(c, 10, mtop, hvec, headerlist)
elif mtop == n1:
hvec = [ltm, rtm]
headerlist = ['INCOME ALL SOURCES']
justify = ['r']
mtop = stripheader(c, 12, mtop, hvec, headerlist)
mtop = mtop - dh * 1.5
mtop, inctotals, rlist = pl_orderlisting(c, 9, mtop, hvec,
itemlist, justify,
inctotals, bottomy, kval,
optype, details)
if mtop > 0:
complete = 1
else:
c, page, pages, mtop = newpagecheck(c, mtop, bottomy + 20,
page, file4, pages)
itemlist = rlist
if details == 'on':
mtop = mtop - dh
indent = 0
else:
indent = indent1
c.setFont('Helvetica-Bold', 11, leading=None)
if kval == 0:
c.drawString(ltm + indent, mtop, 'Income from:')
c.drawRightString(rtm - bump - indent * 3, mtop,
optype[kval] + ' Operations:')
c.drawRightString(rtm - bump - indent, mtop, dollar(inctotals[kval]))
mtop = mtop - dh * 1.2
inctotal = 0.0
for i in inctotals:
inctotal = inctotal + i
c.setFont('Helvetica-Bold', 11, leading=None)
#mtop=mtop-dh
c.drawRightString(rtm - bump - indent * 2, mtop,
'Total for All Sources of Income:')
c.drawRightString(rtm - bump, mtop, dollar(inctotal))
mtop = mtop - dh
p1 = ltm + 55
p2 = ltm + 120
p3 = ltm + 240
p4 = ltm + 410
p5 = rtm - 120
p6 = rtm - 50
#___________Expenses_____________________________
for kval, exp in enumerate(extype):
#blist.append([d1.strftime('%m/%d/%Y'),'COGS',company,desc,acct,nodollar(bamount)])
complete = 0
count = 0
while complete == 0 and page < 20 and count < 5000:
count += 1
c, page, pages, mtop = newpagecheck(c, mtop, bottomy + 20, page,
file4, pages)
if details == 'on':
hvec = [ltm, p1, p2, p3, p5, p6, rtm]
headerlist = [
'BillDate', 'ExpType', 'Vendor', 'Description', 'Account',
'Expense'
]
justify = ['c', 'c', 'l', 'l', 'l', 'r']
mtop = stripheader(c, 10, mtop, hvec, headerlist)
elif mtop == n1 or kval == 0:
hvec = [ltm, rtm]
headerlist = ['COSTS and EXPENSES']
justify = ['r']
mtop = stripheader(c, 12, mtop, hvec, headerlist)
mtop = mtop - dh * 1.5
mtop, exptotals, rlist = pl_explisting(c, 9, mtop, hvec, blist,
justify, exptotals, bottomy,
kval, exp, details, catbp)
if mtop > 0:
complete = 1
else:
c, page, pages, mtop = newpagecheck(c, mtop, bottomy + 20,
page, file4, pages)
blist = rlist
if details == 'on':
mtop = mtop - dh
indent = 0
else:
indent = indent1
c.setFont('Helvetica-Bold', 11, leading=None)
thisexp = extype[kval][0]
if thisexp != lastexp:
dtotals = exptotals[0:kval]
print(kval, dtotals)
dtotal = 0.0
for tot in dtotals:
dtotal = dtotal + tot
mtop = mtop - dh * .5
c.drawRightString(rtm - bump, mtop, dollar(dtotal))
mtop = mtop - 2 * dh
lastexp = thisexp
c.drawString(ltm + indent, mtop, 'Indirect Costs (Overhead):')
if kval == 0:
c.drawString(ltm + indent, mtop, 'Direct Costs:')
catname = extype[kval].replace('D:', '').replace('I:', '')
c.drawRightString(rtm - bump - indent * 3, mtop, catname + ':')
c.drawRightString(rtm - bump - indent, mtop, dollar(exptotals[kval]))
mtop = mtop - dh
if kval == len(extype) - 1:
lastones = len(exptotals) - len(dtotals)
itotals = exptotals[-lastones:]
itotal = 0.0
for tot in itotals:
itotal = itotal + tot
try:
gapct = itotal / inctotal * 100
except:
gapct = 0.00
mtop = mtop - dh * .5
c.drawString(ltm + indent * 2, mtop,
'Overhead Rate: ' + d2s(gapct) + '%')
c.drawRightString(rtm - bump, mtop, dollar(itotal))
mtop = mtop - 2 * dh
exptotal = 0.0
for i in exptotals:
exptotal = exptotal + i
c.setFont('Helvetica-Bold', 11, leading=None)
c.drawRightString(rtm - bump, mtop,
'Total for All Expenses: ' + dollar(exptotal))
mtop = mtop - 2 * dh
c.showPage()
c.save()
if len(pages) > 1:
pdfcommand = ['pdfunite']
for page in pages:
pdfcommand.append(page)
multioutput = addpath(f'tmp/{scac}/data/vreport/multioutput' +
str(cache) + '.pdf')
pdfcommand.append(multioutput)
tes = subprocess.check_output(pdfcommand)
else:
multioutput = ''
return pages, multioutput
def depositcontents(file4, itemlist, cache, nextjo, acctin, stamp):
today = datetime.datetime.today().strftime('%m/%d/%Y')
invodate = datetime.date.today().strftime('%m/%d/%Y')
adat = Accounts.query.filter(Accounts.Name == acctin).first()
if adat is not None:
rt = adat.Routing
an = adat.AcctNumber
else:
rt = 'Unknown'
an = 'Unknow'
ltm, rtm, bump, tb, ctrall, left_ctr, right_ctr, dl, dh, tdl, hls, m1, m2, m3, m4, m5, m6, m7, n1, n2, n3 = reportsettings(
1)
pages = [file4]
page = 1
c = canvas.Canvas(file4, pagesize=letter)
c.setLineWidth(1)
place = [ltm + 10, ltm + 90, ltm + 270, ltm + 450, ltm + 500, rtm - 80]
ctr = []
for j, p in enumerate(place):
if j < len(place) - 1:
ctr.append(avg(p, place[j + 1]))
#Main Items Listing
c.setFont('Helvetica-Bold', 14, leading=None)
c.drawString(45, 550, 'Deposit Ticket ' + nextjo)
c.drawString(45, 530, 'Bank Account: ' + acctin)
c.drawString(305, 550, 'Account Number: ' + an)
c.drawString(305, 530, 'Bank Routing: ' + rt)
c.setFont('Helvetica-Bold', 12, leading=None)
top = n2 + dh - 50
c.drawString(place[0], top, 'Checks Deposited: Details by Job Order')
top = top - dl
for j, i in enumerate(
['Job Order', 'Customer', 'Remit/Check Ref #', 'Amount']):
if j == 3:
c.drawRightString(place[j], top, i)
else:
c.drawString(place[j], top, i)
c.setFont('Helvetica', 12, leading=None)
top = top - dh
total = 0.00
checks = []
cktotals = []
complist = []
l1 = len(itemlist)
for k in range(l1):
newlist = itemlist[k]
for j, i in enumerate(newlist):
if j == 2:
if i not in checks:
checks.append(i)
complist.append(newlist[1])
if j == 3:
c.drawRightString(place[j], top, i)
amt = float(i)
total = total + amt
else:
c.drawString(place[j], top, i)
top = top - dl
if top < n3:
c.showPage()
c.save()
page = page + 1
base = file4.replace('.pdf', '')
newfile = base + 'page' + str(page) + '.pdf'
top = n2 - dh
c = canvas.Canvas(newfile, pagesize=letter)
pages.append(newfile)
totals = d2s(total)
c.setFont('Helvetica-Bold', 12, leading=None)
c.drawString(place[2], top, 'Total:')
c.drawRightString(place[3], top, totals)
for ch in checks:
subtotal = 0.00
for items in itemlist:
if items[2] == ch:
amt = float(items[3])
subtotal = subtotal + amt
cktotals.append(subtotal)
#Main Items Listing
c.setFont('Helvetica-Bold', 12, leading=None)
top = top - 2 * dh
c.drawString(place[0], top, 'Checks Deposited: Summary by Check')
top = top - dl
for j, i in enumerate(['Check#', 'Customer', '', 'Amount']):
if j == 3:
c.drawRightString(place[j], top, i)
else:
c.drawString(place[j], top, i)
c.setFont('Helvetica', 12, leading=None)
top = top - dh
total = 0.00
for j, ch in enumerate(checks):
c.drawString(place[0], top, ch)
c.drawString(place[1], top, complist[j])
c.drawRightString(place[3], top, d2s(cktotals[j]))
top = top - dh
c.setFont('Helvetica-Bold', 12, leading=None)
c.drawString(place[2], top, 'Total:')
c.drawRightString(place[3], top, totals)
if stamp == 1:
c.setFont('Helvetica-Bold', 14, leading=None)
top = top - 3 * dh
depstamp = addpath(f"tmp/{scac}/pics/deposited.png")
c.drawImage(depstamp, 135, 50, mask='auto')
c.drawCentredString(307, 65, today)
jdat = JO.query.filter(JO.jo == nextjo).first()
jdat.dinc = d2s(totals)
db.session.commit()
c.showPage()
c.save()
if len(pages) > 1:
pdfcommand = ['pdfunite']
for page in pages:
pdfcommand.append(page)
multioutput = addpath(f'tmp/{scac}/data/vreport/multioutput' +
str(cache) + '.pdf')
pdfcommand.append(multioutput)
tes = subprocess.check_output(pdfcommand)
else:
multioutput = ''
return pages, multioutput
def modbill(bill, update, err, docref, expdata, assdata, leftscreen, modlink,
hv):
success = 1
modata = Bills.query.get(bill)
# Just updating the billing section
vendor = request.values.get('thiscomp')
vdat = People.query.filter((People.Ptype == 'Vendor')
& (People.Company == vendor)).first()
ptype = request.values.get('thistype')
jo = modata.Jo
ccode = jo[0]
expdata = Accounts.query.filter((
(Accounts.Type == 'Expense') & (Accounts.Co == ccode))
| ((Accounts.Type == 'Credit Card')
& (Accounts.Co == ccode))).order_by(
Accounts.Name).all()
if ptype == 'asset1':
assdata = Accounts.query.filter((Accounts.Type == 'Fixed Asset')
& (Accounts.Co == ccode)).order_by(
Accounts.Name).all()
elif ptype == 'asset2':
assdata = Accounts.query.filter((Accounts.Type == 'Current Asset')
& (Accounts.Co == ccode)).order_by(
Accounts.Name).all()
co = request.values.get('ctype')
if co == 'Pick':
if vdat is not None:
co = vdat.Idtype
defexp = request.values.get('billacct')
if defexp == '1':
if vdat is not None:
defexp = vdat.Associate1
vals = ['bamt', 'bdate', 'ddate', 'bdesc']
a = list(range(len(vals)))
for ix, v in enumerate(vals):
a[ix] = request.values.get(v)
try:
ba = float(a[0])
ba = d2s(ba)
except:
success = 0
err.append('Bill amount not a valid number')
cdat = People.query.filter((People.Company == vendor) & (
(People.Ptype == 'Vendor') | (People.Ptype == 'TowCo')
| (People.Ptype == 'Overseas'))).first()
if cdat is not None:
modata.Pid = cdat.id
if cdat.Ptype == 'TowCo': hv[3] = '2'
else:
modata.Pid = 0
err.append('Vendor not found in database')
modata.Company = vendor
modata.bAccount = defexp
modata.Co = co
modata.Code2 = ptype
if success == 1 and update is not None:
modata.bAmount = ba
modata.bDate = a[1]
modata.dDate = a[2]
modata.Description = a[3]
leftscreen = 1
modlink = 0
db.session.commit()
docref = f'tmp/{scac}/data/vbills/{modata.Original}'
if os.path.isfile(addpath(docref)):
leftscreen = 0
err.append(f'Paying Bill {modata.Jo}')
else:
leftscreen = 1
err.append(f'modifying Bill {modata.Jo}')
err.append('Bill has no source document')
return err, docref, expdata, assdata, leftscreen, modlink, hv
def multi_pay_init(bill, err, modlink):
# See how many bills are to be paid together
nbill = 0
bill_ids = []
total = 0
for data in bdata:
testone = request.values.get('bill' + str(data.id))
if testone:
myb = Bills.query.get(data.id)
try:
nbill = nbill + 1
bamt = myb.bAmount
bamt = d2s(bamt)
amt = float(bamt)
total = total + amt
bill_ids.append(data.id)
except:
err.append('Some checked bills of multi-pay already paid')
exit = 1
if exit == 0 and nbill > 1:
# Create link code
linkcode = 'Link'
# Create a master reference from first bill
masterbill = bill_ids[0]
myb = Bills.query.get(masterbill)
masterref = myb.Ref
masteracct = myb.pAccount
masterdesc = ''
masterpid = myb.Pid
masterpayee = myb.Company
co = myb.Co
expdata = Accounts.query.filter((
(Accounts.Type == 'Expense') & (Accounts.Co == co))
| ((Accounts.Type == 'Credit Card')
& (Accounts.Co == co))).order_by(
Accounts.Name).all()
if masteracct is None or len(masteracct) < 4:
masteracct = 'Industrial Bank'
for bill in bill_ids:
myb = Bills.query.get(bill)
linkcode = linkcode + '+' + str(bill)
try:
descline = 'Bill ID:' + str(myb.id) + ' Billcode: ' + \
myb.Jo + ' Amount: ' + str(myb.bAmount) + '\n'
except:
descline = 'Bill ID:' + str(myb.id)
masterdesc = masterdesc + descline
for bill in bill_ids:
myb = Bills.query.get(bill)
myb.Status = 'Paid-M'
myb.Link = linkcode
myb.pDate = today
myb.pAmount = myb.bAmount
myb.pMulti = "{:.2f}".format(total)
myb.Ref = masterref
myb.pAccount = masteracct
myb.Description = masterdesc
myb.Pid = masterpid
myb.Company = masterpayee
db.session.commit()
jo = myb.Jo
err = gledger_write('paybill', jo, myb.bAccount, myb.pAccount)
return err, modlink, leftscreen, docref
def installment(a, bill, username, err):
modata = Bills.query.get(bill)
pamtf = float(a[0])
bamtf = float(modata.bAmount)
pamt = d2s(pamtf)
pacct = a[1]
ckref = a[2]
ckmemo = a[3]
pdate = a[4]
pmethod = a[5]
if pdate is None: pdate = today
ckfile = modata.Code1
if ckfile is None: ckfile = 'NoFile'
iflag = modata.iflag
#If this is first payment of installments can still change bill information
if iflag == 0 or iflag is None:
modata.iflag = 1
modata.Memo = ckmemo
modata.pAmount = pamt
modata.pAmount2 = pamt
modata.pDate = pdate
modata.pAccount = pacct
modata.Ref = ckref
modata.Status = 'PartPaid'
modata.User = username
db.session.commit()
pmtlist, paclist, reflist, memolist, pdatelist, checklist, pmethods = [],[],[],[],[],[],[]
else:
iflag = iflag + 1
modata.iflag = iflag
modata.Memo = ckmemo
modata.pAmount2 = pamt
modata.pDate = pdate
modata.pAccount = pacct
modata.Ref = ckref
modata.Status = 'PartPaid'
modata.User = username
pmtlist = json.loads(modata.PmtList)
paclist = json.loads(modata.PacctList)
reflist = json.loads(modata.RefList)
memolist = json.loads(modata.MemoList)
pdatelist = json.loads(modata.PdateList)
checklist = json.loads(modata.CheckList)
pmethods = json.loads(modata.MethList)
total = pamtf
for pmt in pmtlist:
total = total + float(pmt)
diff = bamtf - total
if diff < .01:
print(bamtf, total, diff)
modata.Status = 'Paid'
modata.pAmount = d2s(total)
pmtlist.append(pamt)
paclist.append(pacct)
reflist.append(ckref)
memolist.append(ckmemo)
pdatelist.append(pdate)
checklist.append(ckfile)
pmethods.append(pmethod)
modata.PmtList = json.dumps(pmtlist)
modata.PacctList = json.dumps(paclist)
modata.RefList = json.dumps(reflist)
modata.MemoList = json.dumps(memolist)
modata.PdateList = json.dumps(pdatelist)
modata.CheckList = json.dumps(checklist)
modata.MethList = json.dumps(pmethods)
db.session.commit()
return err
def run_paybill(bill, update, err, hv, docref, username, modlink):
modata = Bills.query.get(bill)
success = 1
# This section means paying the bill and the transaction is not a transfer
pamt = request.values.get('pamt')
pacct = request.values.get('account')
pmethod = request.values.get('method')
pmemo = request.values.get('ckmemo')
pdate = request.values.get('pdate')
if pmethod == 'Check': modata.Ref = next_check(pacct, modata.id)
elif pmethod == 'Bank Debit Card': modata.Ref = f'xx{getdebit(pacct)}'
elif pmethod == 'Online Epay': modata.Ref = 'Epay'
elif pmethod == 'Vendor ACH': modata.Ref = 'ACH'
modata.pAmount = d2s(pamt)
modata.pAccount = pacct
modata.Temp2 = pmethod
modata.Memo = pmemo
modata.pDate = pdate
db.session.commit()
# If it is an installment then need to grab the previous payment data if not an update:
if update is None and modlink == 12:
err, modlink, leftscreen, docref, prevpayvec = install_pay_init(
bill, err, modlink)
hv[19] = prevpayvec
# if updating the database:
elif update is not None:
vals = ['pamt', 'account', 'bref', 'ckmemo', 'pdate', 'method']
a = list(range(len(vals)))
for ix, v in enumerate(vals):
a[ix] = request.values.get(v)
try:
pa = float(a[0])
except:
success = 0
err.append('Paid amount not a valid number')
try:
ba = float(modata.bAmount)
except:
success = 0
err.append('Bill amount not a valid number')
if success:
if pa < ba or modlink == 12:
print('Installment Section')
err = installment(a, bill, username, err)
else:
err = regular_payment(a, bill, username, err)
# Write to ledger as bill or asset
modata = Bills.query.get(bill)
jo, baccount = modata.Jo, modata.bAccount
ptype = modata.Code2
if ptype == 'bill':
err = gledger_write('paybill', jo, baccount, pacct)
elif ptype == 'asset1':
err = gledger_write('purchase', jo, baccount, pacct)
elif ptype == 'asset2':
err = gledger_write('purchase', jo, baccount, pacct)
return err, hv, docref, modlink
def isoH():
if request.method == 'POST':
username = session['username'].capitalize()
from viewfuncs import d2s, newjo, popjo, jovec, timedata, nonone, nononef, GetCo, init_horizon_zero, numcheck, sdiff, calendar7_weeks, GetCo3
cars, auto, peep, invo, cache, modata, modlink, invooder, stamp, fdata, csize, invodate, inco, cdat, pb, passdata, vdata, caldays, daylist, weeksum, nweeks = init_horizon_zero(
)
filesel = ''
docref = ''
doctxt = ''
displdata = 0
err = ['All is well', ' ', ' ', ' ', ' ']
# ____________________________________________________________________________________________________________________B.FormVariables.Dealer
leftsize = 10
today = datetime.date.today()
jobdate = datetime.date.today()
match = request.values.get('Match')
modify = request.values.get('Modify')
vmod = request.values.get('Vmod')
minvo = request.values.get('MakeI')
mbill = request.values.get('MakeB')
viewo = request.values.get('ViewO')
viewi = request.values.get('ViewI')
addE = request.values.get('addentity')
addA = request.values.get('addauto')
returnhit = request.values.get('Return')
deletehit = request.values.get('Delete')
datatable1 = request.values.get('datatable1')
datatable2 = request.values.get('datatable2')
datatable3 = request.values.get('datatable3')
dlist = [datatable1, datatable2, datatable3]
# hidden values
update = request.values.get('Update')
invoupdate = request.values.get('invoUpdate')
modlink = request.values.get('passmodlink')
emailnow = request.values.get('emailnow')
emailinvo = request.values.get('emailInvo')
newjob = request.values.get('NewJ')
thisjob = request.values.get('ThisJob')
recpay = request.values.get('RecPay')
hispay = request.values.get('HisPay')
recupdate = request.values.get('recUpdate')
calendar = request.values.get('Calendar')
calupdate = request.values.get('calupdate')
cars = request.values.get('cars')
peep = request.values.get('peep')
auto = request.values.get('auto')
invo = request.values.get('invo')
invooder = request.values.get('invooder')
cache = request.values.get('cache')
modata = 0
idata = 0
leftscreen = 1
docref = ''
ldata = None
modlink = nonone(modlink)
cars = nonone(cars)
peep = nonone(peep)
auto = nonone(auto)
invo = nonone(invo)
invooder = nonone(invooder)
cache = nonone(cache)
if returnhit is not None:
modlink = 0
invooder = 0
cars = 0
invo = 0
# ____________________________________________________________________________________________________________________E.FormVariables.Dealer
# ____________________________________________________________________________________________________________________B.DataModifications.Dealer
if update is not None and modlink == 2:
modata = People.query.get(peep)
vals = [
'company', 'fname', 'mnames', 'lname', 'addr1', 'addr2',
'addr3', 'idtype', 'tid', 'tel', 'email', 'assoc1', 'assoc2',
'date1', 'ptype'
]
a = list(range(len(vals)))
i = 0
for v in vals:
a[i] = request.values.get(v)
i = i + 1
try:
sdate1dt = datetime.datetime.strptime(a[13], "%Y-%m-%d")
except:
a[13] = datetime.datetime.today().strftime('%Y-%m-%d')
input = People(Company=a[0],
First=a[1],
Middle=a[2],
Last=a[3],
Addr1=a[4],
Addr2=a[5],
Addr3=a[6],
Idtype=a[7],
Idnumber=a[8],
Telephone=a[9],
Email=a[10],
Associate1=a[11],
Associate2=a[12],
Date1=a[13],
Ptype=a[14],
Date2=None,
Original=None,
Temp1=None,
Temp2=None)
db.session.add(input)
db.session.commit()
err = [' ', ' ', 'New Entity Added to Database.', ' ', ' ']
modlink = 0
if (update is not None and modlink == 1) or (update is not None
and modlink == 10):
if cars > 0:
modata = Dealer.query.get(cars)
vals = [
'cost', 'sale', 'bfee', 'tow', 'repair', 'oitem', 'ocost',
'modelyear', 'make', 'model', 'color', 'vin', 'dfee',
'thiscompany'
]
a = list(range(len(vals)))
i = 0
for v in vals:
a[i] = request.values.get(v)
i = i + 1
modata.Cost = a[0]
modata.Sale = a[1]
modata.Bfee = a[2]
modata.Tow = a[3]
modata.Repair = a[4]
modata.Oitem = a[5]
modata.Ocost = a[6]
modata.Year = a[7]
modata.Make = a[8]
modata.Model = a[9]
modata.Color = a[10]
modata.Vin = a[11]
modata.DocumentFee = a[12]
modata.Company = a[13]
pdat = People.query.filter(People.Company == a[13]).first()
if pdat is not None:
modata.Pid = pdat.id
try:
modata.Label = modata.Jo + ' ' + a[13]
except:
err[4] = 'Cannot create Label with missing information (company, Year, Make, Model)'
db.session.commit()
err = [
' ', ' ', 'Modification to Auto Sale JO ' + modata.Jo +
' completed.', ' ', ' '
]
modlink = 0
if peep > 0:
modata = People.query.get(peep)
vals = [
'company', 'fname', 'mnames', 'lname', 'addr1', 'addr2',
'addr3', 'idtype', 'tid', 'tel', 'email', 'assoc1',
'assoc2', 'date1', 'role'
]
a = list(range(len(vals)))
i = 0
for v in vals:
a[i] = request.values.get(v)
i = i + 1
modata.First = a[1]
modata.Middle = a[2]
modata.Last = a[3]
modata.Addr1 = a[4]
modata.Addr2 = a[5]
modata.Addr3 = a[6]
modata.Idtype = a[7]
modata.Idnumber = a[8]
modata.Telephone = a[9]
modata.Email = a[10]
modata.Associate1 = a[11]
modata.Associate2 = a[12]
modata.Date1 = a[13]
modata.Ptype = a[14]
#Need to infuse change into Autos if it is a Tow Company:
if modata.Ptype == 'TowCo' or a[14] == 'TowCo':
adat = Autos.query.filter(
Autos.TowCompany == modata.Company).first()
if adat is not None:
adat.TowCompany = a[0]
modata.Company = a[0]
db.session.commit()
err = [
' ', ' ', 'Modification to Entity ID ' + str(modata.id) +
' completed.', ' ', ' '
]
modlink = 0
if auto > 0 or modlink == 10:
if modlink == 10:
filesel = request.values.get('FileSel')
if filesel != '1':
oldref = f'tmp/{scac}/data/vunknown/' + filesel
oldtxt = oldref.split('.', 1)[0] + '.txt'
else:
oldref = ''
oldtxt = ''
modata = Autos.query.filter(Autos.Status == 'New').first()
auto = modata.id
docref = f'tmp/{scac}/data/vdispatch/DISP' + str(
auto) + '.pdf'
doctxt = f'tmp/{scac}/data/vdispatch/DISP' + str(
auto) + '.txt'
try:
shutil.move(addpath(oldref), addpath(docref))
except:
err[3] = '.pdf file already moved'
try:
shutil.move(addpath(oldtxt), addpath(doctxt))
except:
err[4] = '.txt file already moved'
modata.Original = docref
modlink = 0
else:
modata = Autos.query.get(auto)
vals = [
'modelyear', 'make', 'model', 'color', 'vin', 'title',
'state', 'empweight', 'dispatched', 'owner', 'towcompany',
'towcost', 'delto', 'orderid', 'newtowcompany',
'towcostea', 'pufrom', 'cvalue', 'ncars'
]
a = list(range(len(vals)))
for i, v in enumerate(vals):
a[i] = request.values.get(v)
modata.Year = a[0]
modata.Make = a[1]
modata.Model = a[2]
modata.Color = a[3]
modata.VIN = a[4]
modata.Title = a[5]
modata.State = a[6]
modata.EmpWeight = a[7]
modata.Dispatched = a[8]
modata.Owner = a[9]
company = a[10]
if company == '1':
modata.TowCompany = a[14]
input = People(Company=a[14],
First='',
Middle='',
Last='',
Addr1='',
Addr2='',
Addr3='',
Idtype='',
Idnumber='',
Telephone='',
Email='',
Associate1='',
Associate2='',
Date1=today,
Date2=None,
Original='',
Ptype='TowCo',
Temp1='',
Temp2='')
db.session.add(input)
modata.TowCompany = a[14]
else:
modata.TowCompany = company
modata.TowCost = d2s(a[11])
modata.Delto = a[12]
modata.Pufrom = a[16]
modata.Value = d2s(a[17])
ncars = a[18]
try:
ncars = int(a[18])
towcost = float(d2s(a[11]))
towcostea = towcost / float(ncars)
towcostea = str(towcostea)
towcostea = d2s(towcostea)
modata.TowCostEa = towcostea
except:
modata.TowCostEa = a[15]
ncars = 0
modata.Ncars = ncars
sdate1 = request.values.get('date1')
try:
sdate1dt = datetime.datetime.strptime(sdate1, "%Y-%m-%d")
except:
sdate1 = today.strftime('%Y-%m-%d')
sdate2 = request.values.get('date2')
try:
sdate2dt = datetime.datetime.strptime(sdate2, "%Y-%m-%d")
except:
sdate2 = today.strftime('%Y-%m-%d')
modata.Date1 = sdate1
modata.Date2 = sdate2
modata.Orderid = a[13]
modata.Status = 'Novo'
db.session.commit()
err = [
' ', ' ', 'Modification to Auto Data ' + str(modata.id) +
' completed.', ' ', ' '
]
modlink = 0
# ____________________________________________________________________________________________________________________E.DataModifications.Dealer
# ____________________________________________________________________________________________________________________B.InvoiceUpdate.Dealer
if invoupdate is not None:
leftsize = 8
hdata1 = Dealer.query.get(invooder)
invodate = request.values.get('invodate')
#if invodate is None:
#invodate=today
idata = Invoices.query.filter(Invoices.Jo == hdata1.Jo).all()
for data in idata:
iqty = request.values.get('qty' + str(data.id))
iqty = nononef(iqty)
data.Description = request.values.get('desc' + str(data.id))
deach = request.values.get('cost' + str(data.id))
if deach is not None:
deach = "{:.2f}".format(float(deach))
else:
deach = "{:.2f}".format(0.00)
data.Qty = iqty
data.Ea = deach
data.Date = invodate
db.session.commit()
#Remove zeros from invoice in case a zero was the mod
Invoices.query.filter(Invoices.Qty == 0).delete()
db.session.commit()
#Create invoice code for order
err = [' ', ' ', 'Invoice created for JO: ' + hdata1.Jo, ' ', ' ']
idat = Invoices.query.filter(Invoices.Jo == hdata1.Jo).first()
invodate = idat.Date
idata = Invoices.query.filter(Invoices.Jo == hdata1.Jo).all()
amt = 0.0
for data in idata:
amt = amt + float(data.Qty) * float(data.Ea)
hdata1.Charge = "%0.2f" % amt
hdata1.Status = 'Invoiced'
db.session.commit()
invo = 1
# Regenerate invoice with new data
idata = Invoices.query.filter(Invoices.Jo == hdata1.Jo).order_by(
Invoices.Ea.desc()).all()
pdat = People.query.filter(People.id == hdata1.Pid).first()
cache = cache + 1
import make_H_invoice
make_H_invoice.main(hdata1, idata, pdat, cache, invodate, 0)
if cache > 0:
docref = f'tmp/{scac}/data/vinvoice/INV' + hdata1.Jo + 'c' + str(
cache) + '.pdf'
else:
docref = f'tmp/{scac}/data/vinvoice/INV' + hdata1.Jo + '.pdf'
hdata1.Ipath = docref
hdata1.Cache = cache
db.session.commit()
leftscreen = 0
err[3] = 'invooder=' + str(invooder)
err[4] = 'Viewing ' + docref
modata = Dealer.query.get(invooder)
# ____________________________________________________________________________________________________________________E.InvoiceUpdate.Dealer
# ____________________________________________________________________________________________________________________B.SetBaseData.Dealer
hdata = Dealer.query.all()
adata = Autos.query.all()
pdata = People.query.filter((People.Ptype == 'Jays')
| (People.Ptype == 'TowCo')).all()
# ____________________________________________________________________________________________________________________E.SetBaseData.Dealer
# ____________________________________________________________________________________________________________________B.Numcheck.Dealer
try:
cars, auto, peep, numchecked = numcheck(3, hdata, adata, pdata, 0,
0,
['cars', 'auto', 'peep'])
except:
cars = 0
auto = 0
peep = 0
numchecked = 0
# ____________________________________________________________________________________________________________________E.Numcheck.Dealer
# ____________________________________________________________________________________________________________________B.Views.Dealer
if (viewo is not None or viewi is not None) and numchecked == 1:
err = [
' ', ' ', 'There is no document available for this selection',
' ', ' '
]
if cars > 0 and viewi is not None:
modata = Dealer.query.get(cars)
if modata.Ipath is not None:
docref = modata.Ipath
if cars > 0 and viewo is not None:
modata = Dealer.query.get(cars)
if modata.Apath is not None:
docref = modata.Apath
if auto > 0:
modata = Autos.query.get(auto)
if modata.Original is not None:
docref = modata.Original
if (auto > 0 or cars > 0) and docref:
if len(docref) > 5:
leftscreen = 0
leftsize = 10
modlink = 0
err = ['All is well', ' ', ' ', ' ', ' ']
if (viewo is not None or viewi is not None) and numchecked != 1:
err = [
'Must check exactly one box to use this option', ' ', ' ', ' ',
' '
]
# ____________________________________________________________________________________________________________________E.Views.Dealer
# ____________________________________________________________________________________________________________________B.ModifySetup.Dealer
if (modify is not None or vmod is not None) and numchecked == 1:
modlink = 1
leftsize = 8
if cars > 0:
fdata = myoslist(f'tmp/{scac}/data/vunknown')
fdata.sort()
modata = Dealer.query.get(cars)
jobdate = modata.Date
if vmod is not None:
err = [
' ', ' ',
'There is no document available for this selection',
' ', ' '
]
if modata.Apath is not None:
if len(modata.Apath) > 5:
leftscreen = 0
docref = f'tmp/{scac}/data/vcarbuy/' + modata.Apath
err = ['All is well', ' ', ' ', ' ', ' ']
if peep > 0:
modata = People.query.get(peep)
if vmod is not None:
err = [
' ', ' ',
'There is no document available for this selection',
' ', ' '
]
if modata.Original is not None:
if len(modata.Original) > 5:
leftscreen = 0
docref = f'tmp/{scac}/data/vpersons/' + modata.Original
err = ['All is well', ' ', ' ', ' ', ' ']
if auto > 0:
modata = Autos.query.get(auto)
if vmod is not None:
err = [
' ', ' ',
'There is no document available for this selection',
' ', ' '
]
if modata.Original is not None:
if len(modata.Original) > 5:
leftscreen = 0
leftsize = 8
docref = modata.Original
doctxt = docref.split('.', 1)[0] + '.txt'
err = ['All is well', ' ', ' ', ' ', ' ']
if (modify is not None or vmod is not None) and numchecked != 1:
modlink = 0
err[0] = ' '
err[2] = 'Must check exactly one box to use this option'
# ____________________________________________________________________________________________________________________E.ModifySetup.Dealer
# ____________________________________________________________________________________________________________________B.AddItemsSetup.Dealer
if addE is not None and peep > 0 and numchecked == 1:
modlink = 2
modata = People.query.get(peep)
if addE is not None:
leftsize = 8
modlink = 1
#We will create a blank line and simply modify that by updating:
input = People(Company='New',
First=None,
Middle=None,
Last=None,
Addr1=None,
Addr2=None,
Addr3=None,
Idtype=None,
Idnumber=None,
Telephone=None,
Email=None,
Associate1=None,
Associate2=None,
Date1=None,
Date2=None,
Original=None,
Ptype='Dealer',
Temp1=None,
Temp2=None,
Accountid=None)
db.session.add(input)
db.session.commit()
modata = People.query.filter((People.Company == 'New')
& (People.Ptype == 'Dealer')).first()
if modata is not None:
peep = modata.id
else:
peep = 0
err = [' ', ' ', 'Enter Data for New Entity', ' ', ' ']
if addA is not None or modlink == 10:
leftscreen = 0
leftsize = 8
if modlink == 10:
titledata = General.query.filter(
(General.Subject.contains('title'))
& (General.Category.contains('1'))).all()
fdata = []
displdata = []
for title in titledata:
fdata.append(title.Path)
displdata.append(title.Category)
filesel = request.values.get('FileSel')
docref = f'tmp/{scac}/data/vgeneral/' + filesel
doctxt = docref.split('.', 1)[0] + '.txt'
if modlink != 10:
titledata = General.query.filter(
(General.Subject.contains('title'))
& (General.Category.contains('1'))).all()
fdata = []
displdata = []
for title in titledata:
file1 = f'tmp/{scac}/data/vgeneral/' + title.Path
fdata.append(title.Path)
displdata.append(title.Category)
docref = f'tmp/{scac}/data/vgeneral/' + fdata[0]
doctxt = ''
#We will create a blank line and simply modify that by updating:
input = Autos(Jo=None,
Hjo=None,
Year=None,
Make=None,
Model=None,
Color=None,
VIN=None,
Title=None,
State=None,
EmpWeight=None,
Dispatched=None,
Value=None,
TowCompany=None,
TowCost=None,
TowCostEa=None,
Original=None,
Status='New',
Date1=None,
Date2=None,
Pufrom=None,
Delto=None,
Ncars=None,
Orderid=None)
db.session.add(input)
db.session.commit()
modata = Autos.query.filter(Autos.Status == 'New').first()
if modata is not None:
auto = modata.id
else:
auto = 0
modlink = 10
err = [' ', ' ', 'Enter Data for New Auto', ' ', ' ']
# ____________________________________________________________________________________________________________________E.AddItemsSetup.Dealer
# ____________________________________________________________________________________________________________________B.Email.Dealer
if emailinvo is not None:
leftsize = 8
leftscreen = 0
modlink = 0
modata = Dealerquery.get(invooder)
ldata = Invoices.query.filter(Invoices.Jo == modata.Jo).order_by(
Invoices.Ea.desc()).all()
jo = modata.Jo
pdat = People.query.filter(People.id == modata.Pid).first()
if pdat is None:
err = [
' ', ' ',
'There is no Billing information for this selection', ' ',
' '
]
else:
email = pdat.Email
docref = modata.Ipath
modata.Status = 'EmlInvo'
db.session.commit()
if 'vinvoice' not in docref:
err = [
' ', ' ',
'There is no document available for this selection', ' ',
' '
]
else:
if email is not None:
import invoice_mimemail2
invoice_mimemail2.main(jo, docref, email)
# ____________________________________________________________________________________________________________________E.Email.Dealer
# ____________________________________________________________________________________________________________________B.Delete.Dealer
if deletehit is not None and numchecked == 1:
if cars > 0:
Dealer.query.filter(Dealer.id == cars).delete()
if peep > 0:
People.query.filter(People.id == peep).delete()
if auto > 0:
Autos.query.filter(Autos.id == auto).delete()
db.session.commit()
pdata = GetCo('Jays', 'All')
hdata = Dealer.query.order_by(Dealer.Jo).all()
adata = Autos.query.all()
if deletehit is not None and numchecked != 1:
err = [
' ', ' ',
'Must have exactly one item checked to use this option', ' ',
' '
]
# ____________________________________________________________________________________________________________________E.Delete.Dealer
# ____________________________________________________________________________________________________________________B.ReceivePayment.Dealer
if (recpay is not None and cars > 0
and numchecked == 1) or recupdate is not None:
leftsize = 8
if recpay is not None:
invooder = cars
hdat = Dealer.query.get(invooder)
invojo = hdat.Jo
ldat = Invoices.query.filter(Invoices.Jo == invojo).first()
err = ['Have no Invoice to Receive Against', ' ', ' ', ' ', ' ']
if ldat is not None:
idate = ldat.Date
if ldat.Original is not None:
docref = ldat.Original
leftscreen = 0
leftsize = 8
incdat = Income.query.filter(Income.Jo == invojo).first()
if incdat is None:
err = ['Creating New Payment on Jo', ' ', ' ', ' ', ' ']
paydesc = 'Receive payment on Invoice ' + invojo
recamount = str(ldat.Amount)
custref = 'ChkNo'
recdate = today
input = Income(Jo=hdat.Jo,
SubJo=None,
Pid=hdat.Pid,
Description=paydesc,
Amount=recamount,
Ref=custref,
Date=recdate,
Original=None)
db.session.add(input)
payment = 0
else:
recamount = request.values.get('recamount')
custref = request.values.get('custref')
desc = request.values.get('desc')
recdate = request.values.get('recdate')
incdat.Amount = recamount
incdat.Ref = custref
incdat.Description = desc
incdat.Date = recdate
db.session.commit()
payment = [recamount, custref, recdate]
modata = Income.query.filter(Income.Jo == invojo).first()
inco = modata.id
err = [' ', ' ', 'Amend Payment for Invoice', ' ', ' ']
ldata = Invoices.query.filter(Invoices.Jo == invojo).order_by(
Invoices.Ea.desc()).all()
pdat = People.query.filter(People.id == hdat.Pid).first()
cache = nonone(hdat.Cache) + 1
import make_H_invoice
make_H_invoice.main(hdat, ldata, pdat, cache, invodate,
payment)
if cache > 1:
docref = f'tmp/{scac}/data/vinvoice/INV' + invojo + 'c' + str(
cache) + '.pdf'
# Store for future use
else:
docref = f'tmp/{scac}/data/vinvoice/INV' + invojo + '.pdf'
hdat.Cache = cache
hdat.Status = 'Paid'
idat = Invoices.query.filter(Invoices.Jo == invojo).first()
idat.Original = docref
db.session.commit()
leftscreen = 0
err[4] = 'Viewing ' + docref
if recpay is not None and (cars == 0 or numchecked != 1):
err = ['Invalid selections:', '', '', '', '']
if cars == 0:
err[1] = 'Must select a Dealer Job'
if numchecked != 1:
err[2] = 'Must select exactly one Dealer Job'
# ____________________________________________________________________________________________________________________E.Receive Payment.Dealer
# ____________________________________________________________________________________________________________________B.Payment History.Dealer
if hispay is not None or modlink == 7:
if cars == 0 and invooder == 0:
err[1] = 'Must select an Dealer Job'
else:
if cars != 0:
invooder = cars
modata = Dealer.query.get(invooder)
idata = Invoices.query.filter(
Invoices.Jo == modata.Jo).order_by(Invoices.Jo).all()
fdata = Income.query.filter(Income.Jo == modata.Jo).order_by(
Income.Jo).all()
#Check to see if we need to delete anything from history
killthis = request.values.get('killthis')
if killthis is not None and modlink == 7:
for data in idata:
testone = request.values.get('bill' + str(data.id))
if testone:
kill = int(testone)
Invoices.query.filter(Invoices.id == kill).delete()
db.session.commit()
for data in fdata:
testone = request.values.get('pay' + str(data.id))
if testone:
kill = int(testone)
Income.query.filter(Income.id == kill).delete()
db.session.commit()
idata = Invoices.query.filter(
Invoices.Jo == modata.Jo).order_by(Invoices.Jo).all()
fdata = Income.query.filter(
Income.Jo == modata.Jo).order_by(Income.Jo).all()
leftsize = 8
modlink = 7
# ____________________________________________________________________________________________________________________E.PaymentHistory.Dealer
# ____________________________________________________________________________________________________________________B.Invoice.Dealer
if (minvo is not None and cars > 0):
err = ['Could not create invoice', ' ', ' ', ' ', ' ']
# First time through: have an order to invoice
if cars > 0:
invooder = cars
myo = Dealer.query.get(invooder)
#Check to see if we have the required data to make an invoice:
bid = myo.Pid
if bid is None:
err[1] = 'No Billing Data'
if bid:
invo = 1
leftsize = 8
if myo.Cache is not None:
cache = myo.Cache + 1
else:
cache = 1
hdata = Dealer.query.filter(Dealer.Jo == myo.Jo).all()
total = 0
#Delete previous invoices created for this Jo
killdata = Invoices.query.filter(
Invoices.Jo == myo.Jo).delete()
for data in hdata:
qty = 1
towcost = nononef(data.Tow)
repaircost = nononef(data.Repair)
othercost = nononef(data.Ocost)
buyerfee = nononef(data.Bfee)
carcost = nononef(data.Sale)
docfee = nononef(data.DocumentFee)
total = total + towcost + repaircost + othercost + buyerfee + carcost + docfee
if carcost > 0:
descript = data.Year + ' ' + data.Make + ' ' + data.Model + ' VIN:' + data.Vin
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=bid,
Service='Car Purchase',
Description=descript,
Ea=carcost,
Qty=qty,
Amount=carcost,
Total=total,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
if buyerfee > 0:
descript = 'Buyer fee for VIN: ' + data.Vin
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=bid,
Service='Buyer Fee',
Description=descript,
Ea=buyerfee,
Qty=qty,
Amount=buyerfee,
Total=total,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
if towcost > 0:
descript = 'Towing cost for VIN: ' + data.Vin
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=bid,
Service='Towing',
Description=descript,
Ea=towcost,
Qty=qty,
Amount=towcost,
Total=total,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
if repaircost > 0:
descript = 'Repair cost for VIN: ' + data.Vin
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=bid,
Service='Repairs',
Description=descript,
Ea=repaircost,
Qty=qty,
Amount=repaircost,
Total=total,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
if docfee > 0:
descript = 'Dealer document fee for VIN: ' + data.Vin
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=bid,
Service='Document Fee',
Description=descript,
Ea=docfee,
Qty=qty,
Amount=docfee,
Total=total,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
if othercost > 0:
descript = data.Oitem + ' for VIN: ' + data.Vin
input = Invoices(Jo=myo.Jo,
SubJo=None,
Pid=bid,
Service=data.Oitem,
Description=descript,
Ea=othercost,
Qty=qty,
Amount=othercost,
Total=total,
Date=today,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
#Cycle through again so all the line items have the correct total amount
idata = Invoices.query.filter(Invoices.Jo == myo.Jo).all()
if idata is not None:
for data in idata:
data.Total = total
db.session.commit()
ldat = Invoices.query.filter(Invoices.Jo == myo.Jo).first()
if ldat is None:
invo = 0
leftsize = 10
err = [
' ', ' ',
'No services on invoice yet and none selected', ' ',
' '
]
else:
invo = 1
leftsize = 8
invodate = ldat.Date
err = [
' ', ' ', 'Created invoice for JO= ' + myo.Jo, ' ', ' '
]
ldata = Invoices.query.filter(
Invoices.Jo == myo.Jo).order_by(
Invoices.Ea.desc()).all()
pdat = People.query.filter(People.id == myo.Pid).first()
import make_H_invoice
make_H_invoice.main(myo, ldata, pdat, cache, invodate, 0)
if cache > 0:
docref = f'tmp/{scac}/data/vinvoice/INV' + myo.Jo + 'c' + str(
cache) + '.pdf'
# Store for future use
else:
docref = f'tmp/{scac}/data/vinvoice/INV' + myo.Jo + '.pdf'
myo.Ipath = docref
myo.Cache = cache
db.session.commit()
leftscreen = 0
err[3] = 'invooder=' + str(invooder)
err[4] = 'Viewing ' + docref
modata = Dealer.query.get(invooder)
elif minvo is not None:
err = [
' ', ' ', 'Must select at least 1 Job for this selection', ' ',
' '
]
# ____________________________________________________________________________________________________________________E.Invoice.Dealer
# ____________________________________________________________________________________________________________________B.Newjob.Dealer
if newjob is not None:
err = ['Select Source Document from List']
jobdate = datetime.date.today()
modlink = 4
leftsize = 8
leftscreen = 0
docref = f'tmp/{scac}/data/vunknown/NewJob.pdf'
doctxt = ''
if newjob is None and modlink == 4:
filesel = request.values.get('FileSel')
fdata = myoslist(f'tmp/{scac}/data/vunknown')
fdata.sort()
jobdate = request.values.get('dstart')
leftsize = 8
leftscreen = 0
if filesel != '1':
docref = f'tmp/{scac}/data/vunknown/' + filesel
doctxt = docref.split('.', 1)[0] + '.txt'
else:
docref = ''
doctxt = ''
if thisjob is not None:
modlink = 0
#Create the new database entry for the source document
filesel = request.values.get('FileSel')
if filesel != '1':
docold = f'tmp/{scac}/data/vunknown/' + filesel
docref = f'tmp/{scac}/data/vcarbuy/' + filesel
try:
shutil.move(addpath(docold), addpath(docref))
except:
err[0] = 'File moved'
else:
docref = ''
sdate = request.values.get('dstart')
if sdate is None:
sdate = today
jtype = 'J'
nextjo = newjo(jtype, sdate)
company = request.values.get('thiscompany')
bid = People.query.filter(People.Company == company).first()
if bid is not None:
idb = bid.id
else:
idb = 0
input = Dealer(Jo=nextjo,
Pid=idb,
Company=company,
Aid=0,
Make=None,
Model=None,
Year=None,
Vin=None,
Cost=None,
Sale=None,
Bfee=None,
Tow=None,
Repair=None,
Oitem=None,
Ocost=None,
Ipath=None,
Apath=filesel,
Cache=0,
Status='New',
Label=None,
Date=sdate,
DocumentFee='')
db.session.add(input)
db.session.commit()
modata = Dealer.query.filter(Dealer.Jo == nextjo).first()
cars = modata.id
leftscreen = 0
err = ['All is well', ' ', ' ', ' ', ' ']
# ____________________________________________________________________________________________________________________E.Newjob.Dealer
# ____________________________________________________________________________________________________________________B.Match.Dealer
if match is not None:
if cars > 0 and peep > 0 and numchecked == 2:
mys = Dealer.query.get(cars)
myp = People.query.get(peep)
mys.Pid = myp.id
mys.Company = myp.Company
db.session.commit()
if cars > 0 and auto > 0 and numchecked == 2:
mys = Dealer.query.get(cars)
mya = Autos.query.get(auto)
thisjo = mys.Jo
mya.Hjo = thisjo
# Check to see if we need a new JO line because we already have a car assigned
if mys.Aid > 0 and mys.Aid != auto:
#We need a new line item
input = Dealer(Jo=thisjo,
Pid=mys.Pid,
Company=mys.Company,
Aid=0,
Make=None,
Model=None,
Year=None,
Vin=None,
Cost=None,
Sale=None,
Bfee=None,
Tow=None,
Repair=None,
Oitem=None,
Ocost=None,
Ipath=None,
Apath=None,
Cache=0,
Status='New',
Label=None,
DocumentFee='')
db.session.add(input)
db.session.commit()
mys = Dealer.query.filter((Dealer.Jo == thisjo)
& (Dealer.Aid == 0)).first()
mys.Aid = auto
mys.Make = mya.Make
mys.Model = mya.Model
mys.Year = mya.Year
mys.Vin = mya.VIN
mys.Status = 'Car'
mya.Status = 'M'
db.session.commit()
if numchecked != 2:
err[1] = 'Must select exactly 2 boxes to use this option.'
err[0] = ' '
# ____________________________________________________________________________________________________________________E.Match.Dealer
# ____________________________________________________________________________________________________________________B.Calendar.Dealer
if calendar is not None or calupdate is not None:
leftscreen = 2
if calupdate is not None:
waft = request.values.get('waft')
wbef = request.values.get('wbef')
waft = nonone(waft)
wbef = nonone(wbef)
nweeks = [wbef, waft]
else:
nweeks = [2, 3]
caldays, daylist, weeksum = calendar7_weeks('Dealer', nweeks)
# ____________________________________________________________________________________________________________________E.Calendar.Dealer
#This is the else for 1st time through (not posting data from Dealer.html)
else:
from viewfuncs import GetCo, popjo, jovec, timedata, nonone, nononef, init_horizon_zero, GetCo3
#today = datetime.date.today().strftime('%Y-%m-%d')
#now = datetime.datetime.now().strftime('%I:%M %p')
jobdate = datetime.date.today()
idata = 0
leftscreen = 1
cars, auto, peep, invo, cache, modata, modlink, invooder, stamp, fdata, csize, invodate, inco, cdat, pb, passdata, vdata, caldays, daylist, weeksum, nweeks = init_horizon_zero(
)
leftscreen = 1
dlist = ['off'] * 3
dlist[1] = 'on'
filesel = ''
docref = ''
doctxt = ''
leftsize = 10
err = ['All is well', ' ', ' ', ' ', ' ']
displdata = 0
if fdata == 0:
fdata = myoslist('data/vunknown')
fdata.sort()
pdata = GetCo('Jays', 'All')
sdata = Services.query.all()
hdata = Dealer.query.all()
adata = Autos.query.all()
leftsize = 8
return hdata, adata, pdata, idata, fdata, displdata, cars, invooder, auto, peep, err, modata, caldays, daylist, nweeks, invodate, doctxt, sdata, dlist, modlink, inco, invo, cache, filesel, leftscreen, docref, leftsize, jobdate
def calendar7_weeks_all(lweeks):
today = datetime.datetime.today()
nweeks = lweeks[0] + lweeks[1]
ndays = nweeks * 7
day = today.day
d = today
nlist = ndays * 12
caldays = list(range(ndays))
caldt = list(range(ndays))
daylist = list(range(nlist))
shlst = list(range(nlist))
days_ahead = [0] * nweeks
calmon = [0] * nweeks
next_weekday = [0] * nweeks
datestr = [0] * nweeks
for i in range(ndays):
for j in range(12):
k = 9 * i + j
daylist[k] = 0
for i in range(7):
days_ahead1 = i - 7 - d.weekday()
if days_ahead1 <= 0:
days_ahead1 += 7
day0 = days_ahead1 - 7 * lweeks[0]
for m in range(nweeks):
days_ahead[m] = day0 + 7 * m
next_weekday[m] = d + datetime.timedelta(days_ahead[m])
calmon[m] = str(next_weekday[m].month)
caldays[i + 7 *
m] = calendar.day_abbr[i] + ' ' + calendar.month_abbr[int(
calmon[m])] + ' ' + str(next_weekday[m].day)
datestr[m] = str(next_weekday[m].month) + '/' + str(
next_weekday[m].day) + '/' + str(next_weekday[m].year)
caldt[i + 7 * m] = datetime.datetime.strptime(
datestr[m], '%m/%d/%Y')
if next_weekday[lweeks[0]].day == day:
caldays[i + 7 * lweeks[0]] = 'X' + calendar.day_abbr[
i] + ' ' + calendar.month_abbr[int(
calmon[lweeks[0]])] + ' ' + str(
next_weekday[lweeks[0]].day)
if 1 == 1:
weeksum = 0
j1 = 0
j2 = 0
j3 = 0
j4 = 0
j5 = 0
for i in range(ndays):
dloc = caldt[i]
dloc2 = dloc + datetime.timedelta(days=1)
#___Overseas Part________________________________________________________________
odata = OverSeas.query.filter(OverSeas.PuDate == dloc).all()
for j1, data in enumerate(odata):
k = 12 * i + j1
shipper = data.BillTo
if len(shipper) > 8:
shipper = re.match(r'\W*(\w[^,. !?"]*)',
shipper).groups()[0]
pod = data.Pod
pol = data.Pol
if len(pod) > 8:
pod = re.match(r'\W*(\w[^,. !?"]*)', pod).groups()[0]
if len(pol) > 8:
pol = re.match(r'\W*(\w[^,. !?"]*)', pol).groups()[0]
container = data.Container
book = data.Booking
bdat = Bookings.query.filter(
Bookings.Booking == data.Booking).first()
if bdat is not None:
doccut = bdat.PortCut.strftime('%m/%d/%Y')
else:
doccut = ''
cb = []
comlist = ChalkBoard.query.filter(
ChalkBoard.Jo == data.Jo).all()
for c in comlist:
addline = c.register_date.strftime(
'%m/%d/%Y'
) + ' by ' + c.creator + ' at ' + c.register_date.strftime(
'%H:%M') + ': ' + c.comments
addline = parselinenoupper(addline, 85)
for a in addline:
cb.append(a)
drv = Drivers.query.filter(Drivers.Name == data.Driver).first()
if drv is not None:
phone = drv.Phone
trk = drv.Truck
plate = drv.Tag
else:
phone = ''
trk = ''
plate = ''
lt = data.Jo
lt = lt[6:8]
shlst[k] = [lt, 'O', 'blue darken-4']
daylist[k] = [
data.id, shipper, book, container, pol, pod, data.Jo,
data.Status, data.Driver, phone, trk, plate, doccut, cb
]
#___Trucking Part________________________________________________________________
tdata = Orders.query.filter((Orders.Date >= dloc)
& (Orders.Date < dloc2)).all()
for j2, data in enumerate(tdata):
k = 12 * i + j1 + j2 + 1
shipper = data.Shipper
if len(shipper) > 8:
shipper = re.match(r'\W*(\w[^,. !?"]*)',
shipper).groups()[0]
loc1 = People.query.filter((People.Company == data.Company) & (
People.Ptype == 'Trucking')).first()
loc2 = People.query.filter(
(People.Company == data.Company2)
& (People.Ptype == 'Trucking')).first()
drv = Drivers.query.filter(Drivers.Name == data.Driver).first()
if loc1 is not None:
addr11 = loc1.Addr1
addr21 = loc1.Addr2
else:
addr11 = ''
addr21 = ''
if loc2 is not None:
addr12 = loc2.Addr1
addr22 = loc2.Addr2
else:
addr12 = ''
addr22 = ''
if drv is not None:
phone = drv.Phone
trk = drv.Truck
plate = drv.Tag
else:
phone = ''
trk = ''
plate = ''
cb = []
comlist = ChalkBoard.query.filter(
ChalkBoard.Jo == data.Jo).all()
for c in comlist:
addline = c.register_date.strftime(
'%m/%d/%Y'
) + ' by ' + c.creator + ' at ' + c.register_date.strftime(
'%H:%M') + ': ' + c.comments
addline = parselinenoupper(addline, 85)
for a in addline:
cb.append(a)
lt = data.Jo
lt = lt[6:8]
if 'Global' in shipper:
oview = data.Type
if oview is not None:
if len(oview) > 5:
oview = oview[0:5]
else:
oview = data.Order
if len(oview) > 5:
oview = oview[-6:]
shlst[k] = [lt, 'T', 'red darken-4']
daylist[k] = [
data.Order, data.Pickup, data.Booking, data.Driver,
data.Time, data.Jo, data.Container, data.Status, shipper,
data.id, data.Company, addr11, addr21, data.Company2,
addr12, addr22, phone, trk, plate, cb, oview
]
#___Horizon/Towing Part________________________________________________________________
adata = db.session.query(
Autos.Orderid).distinct().filter(Autos.Date2 == dloc)
for j3, data in enumerate(adata):
adat = Autos.query.filter(
(Autos.Orderid == data.Orderid)).first()
cb = []
comlist = ChalkBoard.query.filter(
ChalkBoard.Jo == adat.Jo).all()
for c in comlist:
addline = c.register_date.strftime(
'%m/%d/%Y'
) + ' by ' + c.creator + ' at ' + c.register_date.strftime(
'%H:%M') + ': ' + c.comments
addline = parselinenoupper(addline, 85)
for a in addline:
cb.append(a)
com = adat.TowCompany
if com is None or com == '' or len(com) < 2:
com = 'FIX'
if adat is not None:
autolist = []
allcars = Autos.query.filter(
Autos.Orderid == adat.Orderid).all()
for ncars, car in enumerate(allcars):
autolist.append(
[car.Year, car.Make, car.Model, car.VIN])
ncars = ncars + 1
try:
amt = adat.TowCost
amt = d2s(amt)
amteach = float(amt) / ncars
amteach = dollar(amteach)
amt = '$' + amt
amt = amt.replace('.00', '')
except:
amt = '$0.00'
amteach = '$0.00'
towid = 'tow' + str(adat.id)
k = 12 * i + j1 + j2 + j3 + 2
shlst[k] = [amt, 'H', 'amber accent-4']
daylist[k] = [
adat.id, com, amt, adat.Status, autolist, cb, adat.Jo,
amteach, ncars, towid
]
#___Moving Part________________________________________________________________
#mdata = Moving.query.filter(Moving.Date == dloc).all()
mdata = []
for j4, data in enumerate(mdata):
k = 12 * i + j1 + j2 + j3 + j4 + 3
shipper = data.Shipper
if len(shipper) > 8:
shipper = re.match(r'\W*(\w[^,. !?"]*)',
shipper).groups()[0]
loc1 = Drops.query.filter(Drops.Entity == data.Drop1).first()
loc2 = Drops.query.filter(Drops.Entity == data.Drop2).first()
drv = Drivers.query.filter(Drivers.Name == data.Driver).first()
if loc1 is not None:
addr11 = loc1.Addr1
addr21 = loc1.Addr2
else:
addr11 = ''
addr21 = ''
if loc2 is not None:
addr12 = loc2.Addr1
addr22 = loc2.Addr2
else:
addr12 = 'NF'
addr22 = 'NF'
if drv is not None:
phone = drv.Phone
trk = drv.Truck
plate = drv.Tag
else:
phone = ''
trk = ''
plate = ''
cb = []
comlist = ChalkBoard.query.filter(
ChalkBoard.Jo == data.Jo).all()
for c in comlist:
addline = c.register_date.strftime(
'%m/%d/%Y'
) + ' by ' + c.creator + ' at ' + c.register_date.strftime(
'%H:%M') + ': ' + c.comments
addline = parselinenoupper(addline, 85)
for a in addline:
cb.append(a)
lt = data.Jo
lt = lt[6:8]
shlst[k] = [lt, 'M']
daylist[k] = [
data.id, data.Jo, shipper, data.Drop1, addr11, addr21,
data.Time, data.Drop2, addr12, addr22, data.Time2,
data.Container, data.Driver, data.Status, phone, trk,
plate, cb, data.Amount
]
return caldays, daylist, weeksum, shlst
def isoB(indat):
if request.method == 'POST':
from viewfuncs import nonone, numcheck, newjo
from viewfuncs import calendar7_weeks, txtfile, numcheckvec, d2s, erud, dataget_B, hv_capture, docuploader, get_def_bank
from gledger_write import gledger_write, gledger_app_write
# Initialize variables used in the python code that require a value
username, bill, peep, cache, modata, modlink, fdata, adata, cdat, pb, passdata, vdata, caldays, daylist,\
weeksum, nweeks, filesel, docref, doctxt, bType, bClass, expdata, addjobselect, jobdata, modal, viewck, acceptthese,\
assdata, monlvec = var_start()
divdat = Divisions.query.all()
todaydt = datetime.datetime.today()
today = todaydt.strftime('%Y-%m-%d')
docref = ' '
doctxt = ' '
if indat == 'stay' or indat == 0: indat = '0'
# Get all the variables appearing on the html page including button pushes
match, vmod, modify2, viewo, addE, addE2, paybill, paybill2, unpay, printck, returnhit, deletehit, \
update, modlink, newbill, thisbill, newxfer, thisxfer, calendar, calupdate, incoming, datatable1, \
datatable2, copy, copy12, qpay, bill, cache, peep, uploadS, thismuch, vendmuch, thisbox0, thisbox1, thisbox2, \
thisbox3, thisbox4, thisbox5, thisbox6 = var_request()
modlink, bill, peep = nonone(modlink), nonone(bill), nonone(peep)
dlist = [datatable1, datatable2]
leftscreen = 0
oid = 0
# Get varibles that may be selected from the selection boxes and dont override the button pushes
hv, newbill, addE, copy, copy12, UploadS, newxfer, vmod, match, acceptthese, qpay, paybill, paybill2, printck, \
viewo, viewbill, viewck, deletehit, unpay, lbox, holdvec, err \
= get_selections(thismuch, vendmuch, thisbox0, thisbox1, thisbox2, thisbox3, thisbox4, thisbox5, thisbox6,
newbill, vmod, paybill, printck)
#Key variables may need to be altered based on the type of selection container in modlink:
#modlink = 1 initial selection of an item to modify with update
#modlink = 4 part of sequence in creating a new bill
#modlink = 8 creating a new vendor during new bill process
#modlink = 6 paying multiple bills with one check
#modlink = 14 paying one bill with one check
#after modification is started, if it is a bill and selection boxes are updated with onchange:
#modlink = 7 modification to a bill for continuous modification until update button is used
#modlink = 11 paying a bill
#modlink = 12 quickpay (pay using default values)
#modlink = 70 controls process of document uploading to establish a bill
leftscreen = alterations(modlink, leftscreen)
if returnhit is not None: modlink, leftscreen, indat = cleanup()
# ____________________________________________________________________________________________________________________B.QuickBillPayTowing
if incoming is not None: incoming_setup()
# ____________________________________________________________________________________________________________________E.QuickBillPayTowing
# ____________________________________________________________________________________________________________________B.Uploading
if modlink == 4 and (newbill is None and thisbill is None
and update is None):
modlink, err, bill, docref = uploadsource(modlink, err, oid,
docref, username)
if modlink == 70:
err, oid = docuploader('bill')
modlink = 0
# ____________________________________________________________________________________________________________________E.Uploading
# ____________________________________________________________________________________________________________________B.UpdateDatabasesSection
if (
update is not None and modlink == 1
) or modlink == 8 or modlink == 7 or modlink == 6 or modlink == 11 or modlink == 12 or modlink == 14:
success = 1
if bill > 0:
modata = Bills.query.get(bill)
# if paying a bill there could be multiple link items to capture
if modlink == 6:
try:
links = json.loads(modata.Link)
except:
links = 0
if links != 0:
bill = links[0]
modata = Bills.query.get(bill)
#Modifying only the billing information (but getting the billing information if paying the bill
if modlink == 7:
err, docref, expdata, assdata, leftscreen, modlink, hv = modbill(
bill, update, err, docref, expdata, assdata,
leftscreen, modlink, hv)
cdat = People.query.filter(
People.Company == modata.Company).first()
if cdat is not None:
if cdat.Ptype == 'TowCo': hv[3] = '2'
ifxfer = modata.bType
if ifxfer == 'XFER':
run_xfer(update, err)
if modlink == 11 or modlink == 12 or modlink == 14:
err, hv, docref, modlink = run_paybill(
bill, update, err, hv, docref, username, modlink)
if modal == 1:
calendar = 1
modlink = 0
# create return status
if update is not None and modlink != 6 and success:
modlink = 0
leftscreen = 1
indat = '0'
if modlink == 9 or modlink == 8:
err, expdata, modlink, peep = modpeeps(peep, update, err, modlink,
expdata)
modata = People.query.get(peep)
print(modata.Company)
# _____________________________________________________________________________________________________________B.UpdateDatabasesSection
bdata, cdata = dataget_B(hv[1], hv[0], hv[3])
# ____________________________________________________________________________________________________________________B.SearchFilters
if acceptthese == 1:
print('acceptthese', acceptthese)
modlink = 0
# Check to see if these are all new jobs ready to be updated to ready status
odervec = numcheckvec(bdata, 'bill')
print(odervec)
if len(odervec) > 0:
for ix in odervec:
bdat = Bills.query.get(ix)
bdat.Temp2 = None
db.session.commit()
else:
err.append('Must check at least one box to use this option')
if modlink < 5:
bill, peep, numchecked = numcheck(2, bdata, cdata, 0, 0, 0,
['bill', 'peep'])
else:
numchecked = 0
if uploadS is not None:
print('Using uploadS')
if bill > 0 and numchecked == 1:
bdat = Bills.query.get(bill)
jo = bdat.Jo
cache = bdat.Cache
filename2 = f'Source_{jo}_c{str(cache)}.pdf'
err.append(f'File uploaded as {filename2}')
#Provide a file name for the upload and store message:
edat = LastMessage.query.filter(
LastMessage.User == username).first()
if edat is not None:
edat.Err = json.dumps(err)
db.session.commit()
else:
input = LastMessage(User=username, Err=json.dumps(err))
db.session.add(input)
db.session.commit()
modlink = 70
leftscreen = 1
mm3 = 0
else:
err.append('No Bill Selected for Source Upload')
err.append('Select One Box')
# ____________________________________________________________________________________________________________________E.SearchFilters
# ____________________________________________________________________________________________________________________B.Viewers
if viewo == 1 and numchecked == 1:
if bill > 0:
modata = Bills.query.get(bill)
viewtype = 'source'
hv[2] = viewtype
if modata.Original is not None:
if len(modata.Original) > 5:
docref = f'tmp/{scac}/data/vbills/{modata.Original}'
leftscreen = 0
leftsize = 8
modlink = 0
err.append('Viewing document ' + docref)
if viewo == 1 and numchecked != 1:
err.append('Must check exactly one box to view source file')
if viewck == 1 and numchecked == 1:
if bill > 0:
modata = Bills.query.get(bill)
viewtype = 'check'
hv[2] = viewtype
if modata.Code1 is not None:
if len(modata.Code1) > 5:
docref = f'tmp/{scac}/data/vchecks/{modata.Code1}'
leftscreen = 0
leftsize = 8
modlink = 0
err.append('Viewing check ' + docref)
if viewck == 1 and numchecked != 1:
err.append('Must check exactly one box to view checks')
# ____________________________________________________________________________________________________________________E.Viewers
# ____________________________________________________________________________________________________________________B.Modify Entries
if vmod is not None and numchecked == 1:
modlink, leftscreen, docref, expdata, modata = mod_init(
err, bill, peep)
# Modification coming from calendar
if modify2 is not None:
bill = nonone(modify2)
modata = Bills.query.get(bill)
modlink = 7
leftsize = 8
# ____________________________________________________________________________________________________________________E.Modify Entries
# ____________________________________________________________________________________________________________________B.Add Entries
if addE is not None:
leftsize = 8
modlink = 9
# Remove any new starts that were not completed
People.query.filter(People.Ptype == 'NewVendor').delete()
# We will create a blank line and simply modify that by updating:
input = People(Company='',
First=None,
Middle=None,
Last=None,
Addr1='',
Addr2='',
Addr3='',
Idtype=None,
Idnumber='',
Telephone='',
Email='',
Associate1=None,
Associate2=None,
Date1=today,
Date2=None,
Original=None,
Ptype='NewVendor',
Temp1=None,
Temp2=None,
Accountid=None)
db.session.add(input)
db.session.commit()
modata = People.query.filter(People.Ptype == 'NewVendor').first()
peep = modata.id
err.append('Enter Data for New Entity')
expdata = Accounts.query.filter(
Accounts.Type == 'Expense').order_by(Accounts.Name).all()
if addE2 is not None:
leftsize = 8
modlink = 8
# We will create a blank line and simply modify that by updating:
hlist = hv_capture([
'thiscomp', 'ctype', 'billacct', 'bamt', 'bdate', 'ddate',
'bdesc'
])
hv = hv[0:2] + hlist
print(hv)
# We will create a blank line and simply modify that by updating:
input = People(Company='',
First=None,
Middle=None,
Last=None,
Addr1='',
Addr2='',
Addr3='',
Idtype=None,
Idnumber='',
Telephone='',
Email='',
Associate1=None,
Associate2=None,
Date1=today,
Date2=None,
Original=None,
Ptype='NewVendor',
Temp1=None,
Temp2=None,
Accountid=None)
db.session.add(input)
db.session.commit()
modata = People.query.filter(People.Ptype == 'NewVendor').first()
peep = modata.id
err.append('Enter Data for New Entity')
expdata = Accounts.query.filter(
Accounts.Type == 'Expense').order_by(Accounts.Name).all()
# ____________________________________________________________________________________________________________________E.Add Entries
# ____________________________________________________________________________________________________________________B.Delete an Entry
if deletehit is not None and numchecked >= 1:
if bill > 0:
bdat = Bills.query.get(bill)
try:
orderid = nonone(bdat.Temp2)
adat = Autos.query.get(orderid)
if adat is not None:
adata = Autos.query.filter(
Autos.Orderid == adat.Orderid).all()
for dat in adata:
dat.Status = 'Novo'
except:
err.append('Delete problem')
jo = bdat.Jo
Gledger.query.filter(Gledger.Tcode == jo).delete()
Bills.query.filter(Bills.id == bill).delete()
db.session.commit()
if peep > 0:
peepvec = numcheckvec(cdata, 'peep')
for peep in peepvec:
People.query.filter(People.id == peep).delete()
db.session.commit()
bdata = Bills.query.order_by(Bills.bDate).all()
cdata = People.query.filter((People.Ptype == 'Vendor')
| (People.Ptype == 'TowCo')).order_by(
People.Company).all()
if deletehit is not None and numchecked == 0:
err.append(
'Must have at least one item checked to use this option')
# ____________________________________________________________________________________________________________________E.Delete an Entry
# ____________________________________________________________________________________________________________________B.NewXfer.Billing
if newxfer == 1:
modlink = 3
err.append('Select Source Document from List')
leftscreen = 0
expdata = Accounts.query.filter(
(Accounts.Type != 'Expense') & (Accounts.Type != 'Income')
& (~Accounts.Type.contains('Accounts'))).order_by(
Accounts.Name).all()
vdata = [today, today, '', '']
if newxfer is None and modlink == 3:
leftscreen = 0
bdate = request.values.get('bdate')
ddate = request.values.get('bdate')
xamt = request.values.get('xamt')
new_desc = request.values.get('desc')
xferfrom = request.values.get('fromacct')
xferto = request.values.get('toacct')
if xamt is None:
xamt = '0.00'
vdata = [bdate, ddate, xamt, new_desc, xferfrom, xferto]
print(vdata)
expdata = Accounts.query.filter(
(Accounts.Type != 'Expense') & (Accounts.Type != 'Income')
& (~Accounts.Type.contains('Accounts'))).order_by(
Accounts.Name).all()
if thisxfer is not None:
modlink = 0
sdate = request.values.get('bdate')
if sdate is None or sdate == '':
sdate = today
fromacct = request.values.get('fromacct')
toacct = request.values.get('toacct')
adat = Accounts.query.filter(Accounts.Name == toacct).first()
if adat is not None:
cat = adat.Category
sub = adat.Subcategory
else:
cat = None
sub = None
xamt = request.values.get('xamt')
xamt = d2s(xamt)
xdesc = request.values.get('xdesc')
btype = 'XFER'
nextjo = newjo(billxfrcode, today)
co = nextjo[0]
input = Bills(Jo=nextjo,
Pid=0,
Company=toacct,
Memo=None,
Description=xdesc,
bAmount=xamt,
Status='Paid',
Cache=0,
Original=None,
Ref=None,
bDate=sdate,
pDate=sdate,
pAmount=xamt,
pMulti=None,
pAccount=fromacct,
bAccount=toacct,
bType=btype,
bCat=cat,
bSubcat=sub,
Link=None,
User=username,
Co=co,
Temp1=None,
Temp2=None,
Recurring=0,
dDate=today,
pAmount2='0.00',
pDate2=None,
Code1=None,
Code2=None,
CkCache=0,
QBi=0,
iflag=0,
PmtList=None,
PacctList=None,
RefList=None,
MemoList=None,
PdateList=None,
CheckList=None,
MethList=None)
db.session.add(input)
db.session.commit()
modata = Bills.query.filter(Bills.Jo == nextjo).first()
err = gledger_write('xfer', nextjo, toacct, fromacct)
bill = modata.id
leftscreen = 1
err.append('All is well')
bdata = Bills.query.order_by(Bills.bDate).all()
# ____________________________________________________________________________________________________________________E.NewXfer.Billing
if copy == 1:
if bill > 0 and numchecked == 1:
# sdate=today.strftime('%Y-%m-%d')
bdat = Bills.query.get(bill)
thisdate = bdat.bDate
nextdate = thisdate + datetime.timedelta(days=30)
nextjo = newjo(billexpcode, today)
input = Bills(Jo=nextjo,
Pid=bdat.Pid,
Company=bdat.Company,
Memo=bdat.Memo,
Description=bdat.Description,
bAmount=bdat.bAmount,
Status=bdat.Status,
Cache=0,
Original=bdat.Original,
Ref=bdat.Ref,
bDate=nextdate,
pDate=None,
pAmount='0.00',
pMulti=None,
pAccount=bdat.pAccount,
bAccount=bdat.bAccount,
bType=bdat.bType,
bCat=bdat.bCat,
bSubcat=bdat.bSubcat,
Link=None,
User=username,
Co=bdat.Co,
Temp1=None,
Temp2='Copy',
Recurring=0,
dDate=today,
pAmount2='0.00',
pDate2=None,
Code1=None,
Code2=None,
CkCache=0,
QBi=0,
iflag=0,
PmtList=None,
PacctList=None,
RefList=None,
MemoList=None,
PdateList=None,
CheckList=None,
MethList=None)
db.session.add(input)
db.session.commit()
err = gledger_write('newbill', nextjo, bdat.bAccount,
bdat.pAccount)
elif peep > 0 and numchecked == 1:
# sdate=today.strftime('%Y-%m-%d')
pdat = People.query.get(peep)
input = People(Company=pdat.Company,
First=pdat.First,
Middle='Copy',
Last=None,
Addr1=pdat.Addr1,
Addr2=pdat.Addr2,
Addr3=pdat.Addr3,
Idtype=pdat.Idtype,
Idnumber=pdat.Idnumber,
Telephone=pdat.Telephone,
Email=pdat.Email,
Associate1=pdat.Associate1,
Associate2=pdat.Associate2,
Date1=today,
Date2=None,
Original=None,
Ptype='Vendor',
Temp1=pdat.Temp1,
Temp2=pdat.Temp2,
Accountid=pdat.Accountid)
db.session.add(input)
db.session.commit()
else:
err.append('Must select one item to use this function')
if copy12 is not None:
if bill > 0 and numchecked == 1:
# sdate=today.strftime('%Y-%m-%d')
bdat = Bills.query.get(bill)
thisdate = bdat.bDate
year = thisdate.year
month = thisdate.month
day = thisdate.day
while month < 12:
month = month + 1
nextdate = datetime.datetime(year, month, day)
nextjo = newjo(billexptype, today)
input = Bills(Jo=nextjo,
Pid=bdat.Pid,
Company=bdat.Company,
Memo=bdat.Memo,
Description=bdat.Description,
bAmount=bdat.bAmount,
Status=bdat.Status,
Cache=0,
Original=bdat.Original,
Ref=bdat.Ref,
bDate=nextdate,
pDate=None,
pAmount='0.00',
pMulti=None,
pAccount=bdat.pAccount,
bAccount=bdat.bAccount,
bType=bdat.bType,
bCat=bdat.bCat,
bSubcat=bdat.bSubcat,
Link=None,
User=username,
Co=bdat.Co,
Temp1=None,
Temp2='Copy',
Recurring=0,
dDate=today,
pAmount2='0.00',
pDate2=None,
Code1=None,
Code2=None,
CkCache=0,
QBi=0,
iflag=0,
PmtList=None,
PacctList=None,
RefList=None,
MemoList=None,
PdateList=None,
CheckList=None,
MethList=None)
db.session.add(input)
db.session.commit()
err = gledger_write('newbill', nextjo, bdat.bAccount,
bdat.pAccount)
if qpay is not None:
if bill > 0 and numchecked == 1:
print('qpay entered!!')
bdat = Bills.query.get(bill)
bdat.pDate = bdat.bDate
bdat.pAmount = bdat.bAmount
bdat.Temp2 = ''
bdat.Status = 'Paid'
pacct = bdat.pAccount
if pacct is None:
pacct = get_def_bank(bdat)
elif pacct == '0' or pacct == '1' or pacct == 0 or pacct == 1:
pacct = get_def_bank(bdat)
bdat.pAccount = pacct
db.session.commit()
# ____________________________________________________________________________________________________________________B.NewJob
if newbill is not None:
err, modlink, leftscreen, hv, expdata, vdata = newbill_init(
err, hv)
if newbill is None and modlink == 4:
err, modlink, leftscreen, hv, expdata, vdata, assdata = newbill_passthru(
err, hv, modlink)
if thisbill is not None:
err, modlink, leftscreen, bill = newbill_update(
err, hv, modlink, username)
bdata = Bills.query.order_by(Bills.bDate).all()
# ____________________________________________________________________________________________________________________E.New Bill
if unpay == 1:
if numchecked == 1 and bill > 0:
myb = Bills.query.get(bill)
iflag = myb.iflag
if iflag is None: iflag = 0
if iflag > 0:
undolastpayment(bill)
err.append(
f'Unpaid Last Payment on Bill {myb.Jo} and removed from register'
)
else:
myb.Status = 'Unpaid'
myb.pAmount = '0.00'
db.session.commit()
Gledger.query.filter((Gledger.Tcode == myb.Jo)
& (Gledger.Type == 'PD')).delete()
Gledger.query.filter((Gledger.Tcode == myb.Jo)
& (Gledger.Type == 'PC')).delete()
Gledger.query.filter((Gledger.Tcode == myb.Jo)
& (Gledger.Type == 'XD')).delete()
Gledger.query.filter((Gledger.Tcode == myb.Jo)
& (Gledger.Type == 'XC')).delete()
db.session.commit()
err.append(f'Unpay Bill {myb.Jo} and remove from register')
else:
err.append('Must select one Bill to Unpay')
if paybill is not None or paybill2 is not None or viewbill == 1:
print('paybill', numchecked, modlink, bill)
if numchecked == 1 and bill > 0:
myb = Bills.query.get(bill)
if viewbill == 1 and myb.Status == 'Paid': modlink = 15
if myb.iflag is None: myb.iflag = 0
if myb.iflag > 0:
err, modlink, leftscreen, docref, prevpayvec = install_pay_init(
bill, err, modlink)
hv[19] = prevpayvec
else:
err, modlink, leftscreen, docref = pay_init(
bill, err, modlink)
modata = Bills.query.get(bill)
if numchecked > 1 and bill > 0:
err, modlink, lefscreen, docref = multi_pay_init(
bill, err, modlink)
modata = Bills.query.get(bill)
if numchecked == 0 or bill == 0:
err.append('Must check at least one bill for this selection')
err.append(f'Numchecked = {numchecked}')
bdata = Bills.query.order_by(Bills.bDate).all()
if printck is not None or modlink == 6 or modlink == 14 or indat != '0':
from viewfuncs import check_prep
def multi_prep(bill):
if bdat.Status == 'Paid-M':
linkcode = bdat.Link
sbdata = Bills.query.filter(Bills.Link == linkcode)
link = linkcode.replace('Link+', '')
items = link.split('+')
links = []
[links.append(int(item)) for item in items]
else:
links = 0
sbdata = 0
if printck is not None and numchecked == 1:
modlink = 14
elif printck is not None and numchecked > 1:
modlink = 6
if indat != '0':
bdat = Bills.query.filter(Bills.Jo == indat).first()
bill = bdat.id
modlink = 6
if numchecked == 1: modlink = 14
if (numchecked >= 1 and bill > 0
) or modlink == 6 or modlink == 12 or modlink == 14:
if modlink == 6 or modlink == 12 or modlink == 14:
bdat = Bills.query.get(bill)
try:
bill_list = json.loads(bdat.Link)
except:
bill_list = [bill]
billready, err, linkcode = check_prep(bill_list)
else:
bill_list = numcheckvec(bdata, 'bill')
billready, err, linkcode = check_prep(bill_list)
if billready == 1:
from viewfuncs import check_inputs
sbdata = Bills.query.filter(Bills.Link == linkcode).all()
links = json.loads(linkcode)
bdat = Bills.query.get(links[0])
pdat = People.query.get(bdat.Pid)
ckcache = bdat.CkCache
if ckcache is None or ckcache == 0:
ckcache = 1
last_ckfile = f'Check_{bdat.Jo}_{bdat.Ref}_c{str(ckcache-1)}.pdf'
ckfile = f'Check_{bdat.Jo}_{bdat.Ref}_c{str(ckcache)}.pdf'
docref = f'tmp/{scac}/data/vchecks/{ckfile}'
bdat.Code1 = ckfile
ckcache = ckcache + 1
bdat.CkCache = ckcache
pamount = bdat.pAmount
if pamount == '0.00':
bdat.pAmount = bdat.bAmount
db.session.commit()
ckstyle = request.values.get('ckstyle')
if ckstyle is not None:
hv[21] = ckstyle
ckstyle = nonone(ckstyle)
else:
ckstyle = 1
err = check_inputs(bill_list)
co = bdat.Co
expdata = Accounts.query.filter((
(Accounts.Type == 'Expense') & (Accounts.Co == co)) | (
(Accounts.Type == 'Credit Card')
& (Accounts.Co == co))).order_by(
Accounts.Name).all()
#modlink = 6
leftscreen = 0
modata = Bills.query.get(links[0])
pb = 1
if err[0] != 'All is Well':
err.append(
'Check will not be displayed until above input items input or corrected'
)
else:
from writechecks import writechecks
if pdat is not None:
writechecks(bdat, pdat, docref, sbdata, links,
ckstyle)
ck_check = bdat.bType
db.session.commit()
pacct = bdat.pAccount
#Only write to the ledger on update
if update is not None:
if pacct is not None and pacct != '0':
print('check is', ck_check)
if ck_check == 'Credit Card' or ck_check == 'XFER':
print('Doing the Transfer')
err = err = gledger_write(
'xfer', bdat.Jo, bdat.bAccount,
bdat.pAccount)
err.append(
f'Ledger xfer for {bdat.Jo} to {bdat.bAccount} from {bdat.pAccount}'
)
else:
print('Paying the Bill')
err = gledger_write(
'paybill', bdat.Jo, bdat.bAccount,
bdat.pAccount)
err.append(
f'Ledger paid {bdat.Jo} to {bdat.bAccount} from {bdat.pAccount}'
)
else:
err.append(
'No Account for Fund Withdrawal')
#Attempt to remove the previous cache copy:
try:
last_file = addpath(
f'tmp/{scac}/data/vchecks/{last_ckfile}')
os.remove(last_file)
except:
print(f'Could nor remove {last_file}')
else:
err.append(
'Must select exactly 1 Bill box to use this option.')
# ____________________________________________________________________________________________________________________B.Matching
if match is not None:
if bill > 0 and peep > 0 and numchecked == 2:
myo = Bills.query.get(bill)
myp = People.query.get(peep)
myo.Pid = peep
myo.Company = myp.Company
myo.Description = myp.Associate1
db.session.commit()
if numchecked != 2:
err.append('Must select exactly 2 boxes to use this option.')
# ____________________________________________________________________________________________________________________E.Matching
# ____________________________________________________________________________________________________________________B.Calendar.Billing
if calendar is not None or calupdate is not None:
leftscreen = 2
if calupdate is not None:
waft = request.values.get('waft')
wbef = request.values.get('wbef')
waft = nonone(waft)
wbef = nonone(wbef)
nweeks = [wbef, waft]
else:
nweeks = [2, 2]
caldays, daylist, weeksum = calendar7_weeks('Billing', nweeks)
if calupdate is not None:
for j in range(len(daylist)):
ilist = daylist[j]
if ilist:
tid = ilist[0]
fnum = 'note' + str(tid)
fput = request.values.get(fnum)
if len(fput) > 3:
billno = f'{scac}_Bill_{str(tid)}'
input = ChalkBoard(Jo=billno,
creator=username,
comments=fput,
status=1)
db.session.add(input)
db.session.commit()
caldays, daylist, weeksum = calendar7_weeks('Billing', nweeks)
# ____________________________________________________________________________________________________________________E.Calendar.Billing
if (modlink > 0 and bill > 0) or (modlink > 0
and peep > 0) or leftscreen == 0:
leftsize = 8
elif leftscreen == 2:
leftsize = 10
else:
leftsize = 10
else:
username, bill, peep, cache, modata, modlink, fdata, adata, cdat, pb, passdata, vdata, caldays, daylist,\
weeksum, nweeks, filesel, docref, doctxt, bType, bClass, expdata, addjobselect, jobdata, modal, viewck, acceptthese,\
assdata, monlvec = var_start()
err = []
hv = [0] * 25
hv[0] = 'X'
hv[1] = '1'
from viewfuncs import nonone, erud, dataget_B
leftscreen = 1
leftsize = 10
addjobselect = 0
dlist = ['on'] * 2
dlist[1] = 'off'
jobdata = 0
modal = 0
expdata = 0
assdata = [0]
divdat = Divisions.query.all()
err.append('All is well')
leftsize = 8
rightsize = 12 - leftsize
today = datetime.date.today()
critday = datetime.date.today() + datetime.timedelta(days=7)
bdata, cdata = dataget_B(hv[1], hv[0], hv[3])
hv[23] = assdata
acdata = Accounts.query.filter(
(Accounts.Type == 'Bank') | (Accounts.Type == 'Credit Card')
| (Accounts.Type == 'Current Liability')).order_by(
Accounts.Name).all()
err = erud(err)
if expdata == 0:
expdata = Accounts.query.filter(Accounts.Type == 'Expense').order_by(
Accounts.Name).all()
return username, divdat, hv, bdata, cdata, bill, peep, err, modata, adata, acdata, expdata, modlink, caldays, daylist, weeksum, nweeks, addjobselect, jobdata, modal, dlist, fdata, today, cdat, pb, critday, vdata, leftscreen, docref, doctxt, leftsize, cache, filesel
def newbill_update(err, hv, modlink, username):
modlink = 0
# Create the new database entry for the source document
bdate = request.values.get('bdate')
ddate = request.values.get('ddate')
print('bdate:', bdate, ddate)
thiscompany = request.values.get('thiscomp')
thistype = request.values.get('thistype')
cdat = People.query.filter((People.Company == thiscompany) & (
(People.Ptype == 'Vendor') | (People.Ptype == 'TowCo'))).first()
if cdat is not None:
acomp = cdat.Company
cid = cdat.Accountid
aid = cdat.id
cc_check = cdat.Associate2
acdat = Accounts.query.filter(Accounts.id == cid).first()
if acdat is not None:
baccount = acdat.Name
category = acdat.Category
subcat = acdat.Subcategory
descript = acdat.Description
btype = acdat.Type
else:
category = 'NAY'
subcat = 'NAY'
descript = ''
btype = ''
baccount = ''
else:
# This section for case of bill to credit card account
thisaccount = request.values.get('billacct')
ccdat = Accounts.query.filter(Accounts.Name == thisaccount).first()
if ccdat is not None:
acomp = ccdat.Name
aid = ccdat.id
category = ccdat.Category
subcat = ccdat.Subcategory
descript = ccdat.Description
btype = ccdat.Type
else:
acomp = None
aid = None
category = 'NAY'
subcat = 'NAY'
descript = ''
btype = ''
baccount = ''
bdesc = request.values.get('bdesc')
bamt = request.values.get('bamt')
bamt = d2s(bamt)
bcomp = request.values.get('bcomp')
cco = request.values.get('ctype')
print(f'Getting nextjo with {cco} and {today_str}')
if cc_check == 'Credit Card':
nextjo = newjo(cco + 'X', today_str)
else:
nextjo = newjo(cco + 'B', today_str)
account = request.values.get('crataccount')
if thistype == 'bill':
baccount = request.values.get('billacct')
code2 = 'bill'
else:
baccount = request.values.get('assacct')
code2 = request.values.get('billacct')
acdat = Accounts.query.filter(Accounts.Name == baccount).first()
if acdat is not None:
baccount = acdat.Name
category = acdat.Category
subcat = acdat.Subcategory
descript = acdat.Description
btype = acdat.Type
input = Bills(Jo=nextjo,
Pid=aid,
Company=acomp,
Memo='',
Description=bdesc,
bAmount=bamt,
Status='Unpaid',
Cache=0,
Original=None,
Ref='',
bDate=bdate,
pDate=today,
pAmount='0.00',
pMulti=None,
pAccount=account,
bAccount=baccount,
bType=btype,
bCat=category,
bSubcat=subcat,
Link=None,
User=username,
Co=cco,
Temp1=None,
Temp2=None,
Recurring=0,
dDate=ddate,
pAmount2='0.00',
pDate2=None,
Code1=None,
Code2=code2,
CkCache=0,
QBi=0,
iflag=0,
PmtList=None,
PacctList=None,
RefList=None,
MemoList=None,
PdateList=None,
CheckList=None,
MethList=None)
db.session.add(input)
db.session.commit()
if cc_check != 'Credit Card':
if thistype == 'bill':
err = gledger_write('newbill', nextjo, baccount, account)
elif thistype == 'asset1':
err = gledger_write('purchase', nextjo, baccount, account)
elif thistype == 'asset2':
err = gledger_write('purchase', nextjo, baccount, account)
adat = Adjusting.query.filter((Adjusting.Jo == nextjo)
& (Adjusting.Status == 0)).first()
dt2 = datetime.datetime.strptime(ddate, "%Y-%m-%d")
dt1 = datetime.datetime.strptime(bdate, "%Y-%m-%d")
delta = dt2 - dt1
ndays_incl = delta.days + 1
adjamt = float(bamt) / ndays_incl
adjamt = d2s(adjamt)
if adat is None:
mop = dt1.month
input = Adjusting(Jo=nextjo,
Date=bdate,
DateEnd=ddate,
Mop=mop,
Moa=0,
Asset=baccount,
Expense=code2,
Amtp=bamt,
Amta=adjamt,
Status=0)
db.session.add(input)
db.session.commit()
else:
err.append('This adjusting account exists. Must delete it.')
# Check if shared account:
adat = Accounts.query.filter(Accounts.Name == baccount).first()
if adat is not None:
shared = adat.Shared
if isinstance(shared, str):
divid, fromtoid, tofromid, mirrorid = json.loads(shared)
print('found idlist', divid, fromtoid, tofromid, mirrorid)
ddat = Divisions.query.get(divid)
apportion = float(ddat.Apportion)
appamt = float(bamt) * apportion
gledger_app_write('app1', nextjo, cco, fromtoid, mirrorid, appamt)
gledger_app_write('app2', nextjo, ddat.Co, mirrorid, tofromid,
appamt)
# reget because we need the bill unique id number in the document
modata = Bills.query.filter(Bills.Jo == nextjo).first()
csize = People.query.filter((People.Ptype == 'Vendor')
| (People.Ptype == 'TowCo')).order_by(
People.Company).all()
bill = modata.id
leftscreen = 1
err.append('All is well')
return err, modlink, leftscreen, bill
