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 get_new_Jo(input):
sdate = today.strftime('%Y-%m-%d')
return newjo(input, sdate)
def isoS():
if request.method == 'POST':
monsel, oder, peep, serv, invo, inco, cache, modata, modlink, fdata, invooder = init_storage_zero(
)
invojo, filesel, docref, search11, search12, search21, search31 = init_storage_blank(
)
leftscreen = 1
docref = ' '
err = ['All is well', ' ', ' ', ' ', ' ']
ldata = None
#today = datetime.datetime.today().strftime('%Y-%m-%d')
today = datetime.date.today()
invodate = datetime.date.today()
leftsize = 10
monvec = [
'Month', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
'Sep', 'Oct', 'Nov', 'Dec'
]
monlvec = [
'January', 'February', 'March', 'April', 'May', 'June', 'July',
'August', 'September', 'October', 'November', 'December'
]
match = request.values.get('Match')
modify = request.values.get('Modify')
vmod = request.values.get('Vmod')
minvo = request.values.get('MakeI')
mpack = request.values.get('MakeP')
viewo = request.values.get('ViewO')
viewi = request.values.get('ViewI')
viewp = request.values.get('ViewP')
analyze = request.values.get('Analyze')
print = request.values.get('Print')
addE = request.values.get('addentity')
addS = request.values.get('addservice')
recpay = request.values.get('RecPay')
hispay = request.values.get('HisPay')
monsel = request.values.get('monsel')
returnhit = request.values.get('Return')
deletehit = request.values.get('Delete')
# hidden values
update = request.values.get('Update')
invoupdate = request.values.get('invoUpdate')
recupdate = request.values.get('recUpdate')
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')
oder = request.values.get('oder')
invo = request.values.get('invo')
invooder = request.values.get('invooder')
cache = request.values.get('cache')
peep = request.values.get('peep')
serv = request.values.get('serv')
inco = request.values.get('inco')
modlink = nonone(modlink)
oder = nonone(oder)
invo = nonone(invo)
invooder = nonone(invooder)
peep = nonone(peep)
serv = nonone(serv)
monsel = nonone(monsel)
inco = nonone(inco)
modal = 0
if returnhit is not None:
modlink = 0
invo = 0
invooder = 0
inco = 0
# ____________________________________________________________________________________________________________________B.UpdateDatabases.Storage
if update is not None and modlink == 1:
if oder > 0:
modata = Storage.query.get(oder)
desc = request.values.get('desc')
amount = request.values.get('amount')
thiscomp = request.values.get('thiscomp')
dstart = request.values.get('dstart')
balfwd = request.values.get('pybal')
modata.Description = desc
modata.Amount = amount
modata.Date = dstart
modata.BalFwd = balfwd
ldat = People.query.filter(People.Company == thiscomp).first()
if ldat is not None:
acomp = ldat.Company
aid = ldat.id
else:
acomp = None
aid = None
modata.Company = acomp
modata.Pid = aid
modata.Label = modata.Jo + ' ' + thiscomp + ' ' + amount
db.session.commit()
err[3] = 'Modification to Storage JO ' + modata.Jo + ' completed.'
modlink = 0
if peep > 0:
modata = People.query.get(peep)
modata.Ptype = 'Storage'
vals = [
'company', 'fname', 'mnames', 'lname', 'addr1', 'addr2',
'addr3', 'idtype', 'tid', 'tel', 'email', 'assoc1',
'assoc2', 'date1'
]
a = list(range(len(vals)))
i = 0
for v in vals:
a[i] = request.values.get(v)
i = i + 1
modata.Company = a[0]
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]
db.session.commit()
err = [
' ', ' ', 'Modification to Entity ID ' + str(modata.id) +
' completed.', ' ', ' '
]
modlink = 0
# And now update the crossover to Storage in case the Company info changed:
cross = Storage.query.filter(Storage.Pid == peep)
for cros in cross:
cros.Company = a[0]
db.session.commit()
if serv > 0:
modata = Services.query.get(serv)
vals = ['service', 'price']
a = list(range(len(vals)))
i = 0
for v in vals:
a[i] = request.values.get(v)
i = i + 1
modata.Service = a[0]
modata.Price = a[1]
db.session.commit()
err = [
' ', ' ', 'Modification to Services Data with ID ' +
str(modata.id) + ' completed.', ' ', ' '
]
modlink = 0
if inco > 0:
modata = Income.query.get(inco)
vals = ['desc', 'recamount', 'custref', 'recdate']
i = 0
for v in vals:
a[i] = request.values.get(v)
i = i + 1
modata.Description = a[0]
modata.Amount = a[1]
modata.Ref = a[2]
modata.Date = a[3]
db.session.commit()
err = [
' ', ' ', 'Modification to Income Data with ID ' +
str(modata.id) + ' completed.', ' ', ' '
]
# ____________________________________________________________________________________________________________________E.UpdateDatabases.Storage
# ____________________________________________________________________________________________________________________B.UpdateInvoice.Storage
if invoupdate is not None and monsel != 0:
leftsize = 8
odata1 = Storage.query.get(invooder)
invojo = popjo(invooder, monsel)
ldata = Invoices.query.filter(Invoices.SubJo == invojo).all()
invodate = request.values.get('invodate')
total = 0
for data in ldata:
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))
amount = iqty * float(deach)
else:
deach = "{:.2f}".format(0.00)
amount = 0.00
total = total + amount
amount = "{:.2f}".format(amount)
data.Qty = iqty
data.Ea = deach
data.Amount = amount
data.Total = 0.00
data.Date = invodate
db.session.commit()
if total > 0 and ldata is not None:
for data in ldata:
data.Total = "%0.2f" % total
db.session.commit()
odata1.Amount = "%0.2f" % total
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 Storage JO: ' + invojo, ' ', ' '
]
ldata = Invoices.query.filter(Invoices.SubJo == invojo).all()
# ____________________________________________________________________________________________________________________E.UpdateInvoice.Storage
odata = Storage.query.order_by(Storage.Jo).all()
cdata = People.query.filter(People.Ptype == 'Storage').order_by(
People.Company).all()
sdata = Services.query.all()
oder, peep, serv, numchecked = numcheck(3, odata, cdata, sdata, 0, 0,
['oder', 'peep', 'serv'])
# ____________________________________________________________________________________________________________________E.SearchFilters.Storage
# ____________________________________________________________________________________________________________________B.EmailInvoice.Storage
if emailinvo is not None:
leftsize = 10
leftscreen = 1
modlink = 0
modata = Storage.query.get(invooder)
invojo = popjo(invooder, monsel)
ldata = Invoices.query.filter(Invoices.SubJo == invojo).order_by(
Invoices.Ea.desc()).all()
pdata1 = People.query.filter(People.id == modata.Pid).first()
ldat = Invoices.query.filter(Invoices.SubJo == invojo).first()
if pdata1 is None:
err = [
' ', ' ',
'There is no Billing information for this selection', ' ',
' '
]
else:
email = pdata1.Email
company = pdata1.Company
docref = ldat.Original
if 'vinvoice' not in docref:
err = [
' ', ' ',
'There is no document available for this selection', ' ',
' '
]
else:
if email is not None:
import invoice_mimemail_S
invoice_mimemail_S.main(invojo, docref, email, monsel,
inco, company)
if inco == 0:
for data in ldata:
data.Status = "E"
db.session.commit()
else:
for data in ldata:
data.Status = "P"
db.session.commit()
invooder = 0
invo = 0
inco = 0
# ____________________________________________________________________________________________________________________E.EmailInvoice.Storage
# ____________________________________________________________________________________________________________________B.Viewers.Storage
if viewo is not None and numchecked == 1:
err = [
' ', ' ', 'There is no document available for this selection',
' ', ' '
]
if oder > 0:
modata = Storage.query.get(oder)
if modata.Original is not None:
if len(modata.Original) > 5:
docref = modata.Original
leftscreen = 0
leftsize = 8
modlink = 0
err = [
' ', ' ', 'Viewing document ' + docref, ' ', ' '
]
if (viewo is not None or viewi is not None
or viewp is not None) and numchecked != 1:
err = [
'Must check exactly one box to use this option', ' ', ' ', ' ',
' '
]
if viewi is not None and numchecked == 1:
err = [
'There is no document available for this selection', ' ', ' ',
' ', ' '
]
if monsel == 0:
err[1] = 'Need to select the month'
if oder > 0 and monsel > 0:
invooder = oder
modata = Storage.query.get(oder)
invojo = popjo(oder, monsel)
ldat = Invoices.query.filter(Invoices.SubJo == invojo).first()
if ldat.Original is not None:
docref = ldat.Original
leftscreen = 0
leftsize = 8
modlink = 5
err = [' ', ' ', 'Viewing document ' + docref, ' ', ' ']
# ____________________________________________________________________________________________________________________E.Viewers.Storage
# ____________________________________________________________________________________________________________________B.ModifyEntries.Storage
if (modify is not None or vmod is not None) and numchecked == 1:
modlink = 1
leftsize = 8
if oder > 0:
modata = Storage.query.get(oder)
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 = modata.Original
err = ['All is well', ' ', ' ', ' ', ' ']
if serv > 0:
modata = Services.query.get(serv)
if vmod is not None:
err = [
' ', ' ',
'There is no document available for this selection',
' ', ' '
]
if peep > 0:
modata = People.query.get(peep)
if vmod is not None:
err = [
' ', ' ',
'There is no document available for this selection',
' ', ' '
]
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.ModifyEntries.Storage
# ____________________________________________________________________________________________________________________B.AddEntries.Storage
if addS is not None and serv > 0 and numchecked == 1:
leftsize = 8
modlink = 2
modata = Services.query.get(serv)
if addS is not None and numchecked == 0:
leftsize = 8
modlink = 1
#We will create a blank line and simply modify that by updating:
input = Services(Service='New', Price=0.00)
db.session.add(input)
db.session.commit()
modata = Services.query.filter(Services.Service == 'New').first()
serv = modata.id
err = [' ', ' ', 'Enter Data for New Service', ' ', ' ']
if addS is not None and numchecked > 1:
modlink = 0
err[0] = ' '
err[2] = 'Must check exactly one box to use this option'
if addE is not None and peep > 0 and numchecked == 1:
leftsize = 8
modlink = 3
modata = People.query.get(peep)
if addE is not None and numchecked == 0:
leftsize = 8
modlink = 1
#We will create a blank line and simply modify that by updating:
input = People(Company='New',
First='',
Middle='',
Last='',
Addr1='',
Addr2='',
Addr3='',
Idtype='',
Idnumber='',
Telephone='',
Email='',
Associate1='',
Associate2='',
Date1=today,
Date2=None,
Original=None,
Ptype='Storage',
Temp1=None,
Temp2=None)
db.session.add(input)
db.session.commit()
modata = People.query.filter((People.Company == 'New') &
(People.Ptype == 'Storage')).first()
peep = modata.id
modata.Company = ''
db.session.commit()
modata = People.query.get(peep)
err = [' ', ' ', 'Enter Data for New Company', ' ', ' ']
if addE is not None and numchecked > 1:
modlink = 0
err[0] = ' '
err[2] = 'Must check exactly one box to use this option'
# ____________________________________________________________________________________________________________________E.AddEntries.Storage
# ____________________________________________________________________________________________________________________B.ReceivePayment.Storage
if (recpay is not None and oder > 0 and numchecked == 1
and monsel > 0) or recupdate is not None:
leftsize = 8
if recpay is not None:
invooder = oder
odat = Storage.query.get(invooder)
invojo = popjo(invooder, monsel)
ldat = Invoices.query.filter(Invoices.SubJo == invojo).first()
err = ['Have no Invoice to Receive Against', ' ', ' ', ' ', ' ']
if ldat is not None:
invodate = ldat.Date
if ldat.Original is not None:
docref = ldat.Original
leftscreen = 0
leftsize = 8
incdat = Income.query.filter(Income.SubJo == invojo).first()
if incdat is None:
err = ['Creating New Payment on SubJo', ' ', ' ', ' ', ' ']
paydesc = 'Received payment on Invoice ' + invojo + ' for month of ' + monvec[
monsel]
recamount = str(ldat.Amount)
custref = 'ChkNo'
recdate = datetime.date(today.year, monsel, 28)
input = Income(Jo=odat.Jo,
SubJo=invojo,
Pid=odat.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.SubJo == invojo).first()
inco = modata.id
err = [' ', ' ', 'Amend Payment for Invoice', ' ', ' ']
ldata = Invoices.query.filter(
Invoices.SubJo == invojo).order_by(
Invoices.Ea.desc()).all()
pdata1 = People.query.filter(People.id == odat.Pid).first()
cache = nonone(odat.Cache) + 1
basejo = odat.Jo
involine, paidline, refline, balline = money12(basejo)
balduenow = balline[monsel]
try:
balduenow = float[balduenow]
except:
balduenow = 0.00
if balduenow < .001:
for data in ldata:
data.Status = "P"
db.session.commit()
import make_S_invoice
make_S_invoice.main(odat, ldata, pdata1, invojo, involine,
paidline, refline, balline, invodate,
cache, 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'
odat.Cache = cache
idat = Invoices.query.filter(Invoices.SubJo == invojo).first()
idat.Original = docref
db.session.commit()
leftscreen = 0
err[4] = 'Viewing ' + docref
if recpay is not None and (oder == 0 or numchecked != 1
or monsel == 0):
err = ['Invalid selections:', '', '', '', '']
if oder == 0:
err[1] = 'Must select a Storage Job'
if numchecked != 1:
err[2] = 'Must select exactly one Storage Job'
if monsel == 0:
err[3] = 'Must select a month to apply payment'
# ____________________________________________________________________________________________________________________E.ReceivePayment.Storage
# ____________________________________________________________________________________________________________________B.PaymentHistory.Storage
if hispay is not None or modlink == 7:
if oder == 0 and invooder == 0:
err[1] = 'Must select a Storage Job'
else:
if oder != 0:
invooder = oder
modata = Storage.query.get(invooder)
ldata = Invoices.query.filter(
Invoices.Jo == modata.Jo).order_by(Invoices.SubJo).all()
fdata = Income.query.filter(Income.Jo == modata.Jo).order_by(
Income.SubJo).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 ldata:
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()
ldata = Invoices.query.filter(
Invoices.Jo == modata.Jo).order_by(
Invoices.SubJo).all()
fdata = Income.query.filter(
Income.Jo == modata.Jo).order_by(Income.SubJo).all()
leftsize = 8
modlink = 7
# ____________________________________________________________________________________________________________________E.PaymentHistory.Storage
# ____________________________________________________________________________________________________________________B.Delete.Storage
if deletehit is not None and numchecked == 1:
if oder > 0:
Storage.query.filter(Storage.id == oder).delete()
odata = Storage.query.all()
if peep > 0:
People.query.filter(People.id == peep).delete()
cdata = People.query.filter(
People.Ptype == 'Storage').order_by(People.Company).all()
if serv > 0:
Services.query.filter(Services.id == serv).delete()
sdata = Services.query.all()
db.session.commit()
if deletehit is not None and numchecked != 1:
err = [
' ', ' ',
'Must have exactly one item checked to use this option', ' ',
' '
]
# ____________________________________________________________________________________________________________________E.Delete.Storage
# ____________________________________________________________________________________________________________________B.Invoicing.Storage
if ((minvo is not None and oder > 0)
or invoupdate is not None) and monsel > 0:
err = ['Could not create invoice', ' ', ' ', ' ', ' ']
# First time through: have an order to invoice
if oder > 0:
invooder = oder
myo = Storage.query.get(invooder)
fee = myo.Amount
#Check to see if we have the required data to make an invoice:
invojo = popjo(invooder, monsel)
thismonth = calendar.month_name[monsel]
invodate = request.values.get('invodate')
invo = 1
leftsize = 8
cache = nonone(myo.Cache) + 1
mys = Services.query.get(serv)
if mys is not None:
addserv = mys.Service
price = mys.Price
qty = 1
d = datetime.date(today.year, monsel, 1)
descript = 'Monthly Storage Fee for Month of ' + thismonth
input = Invoices(Jo=myo.Jo,
SubJo=invojo,
Pid=myo.Pid,
Service=addserv,
Description=descript,
Ea=price,
Qty=qty,
Amount=price,
Total=price,
Date=d,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
ldata = Invoices.query.filter(Invoices.SubJo == invojo).first()
if ldata is None:
invodate = datetime.date(today.year, monsel, 1)
#See if there is an invoice from previous month to copy from
try:
invojoprev = popjo(invooder, monsel - 1)
invodate = datetime.date(today.year, monsel, 1)
ldata2 = Invoices.query.filter(
Invoices.SubJo == invojoprev).all()
for data in ldata2:
mydescript = data.Description
newdescript = data.Description
for i in range(12):
if monlvec[i] in newdescript:
j = i + 1
if j == 12:
j = 0
mydescript = newdescript.replace(
monlvec[i], monlvec[j])
input = Invoices(Jo=myo.Jo,
SubJo=invojo,
Pid=myo.Pid,
Service=data.Service,
Description=mydescript,
Ea=data.Ea,
Qty=data.Qty,
Amount=data.Amount,
Date=invodate,
Total=data.Total,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
except:
if mys is None:
addserv = 'Monthly Storage'
price = fee
else:
addserv = mys.Service
price = mys.Price
qty = 1
invodate = datetime.date(today.year, monsel, 1)
descript = 'Monthly Storage Fee for Month of ' + thismonth
input = Invoices(Jo=myo.Jo,
SubJo=invojo,
Pid=myo.Pid,
Service=addserv,
Description=descript,
Ea=price,
Qty=qty,
Amount=price,
Date=invodate,
Total=price,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
else:
ldat = Invoices.query.filter(
Invoices.SubJo == invojo).first()
if ldat is None:
if mys is None:
addserv = 'Monthly Storage'
price = fee
else:
addserv = mys.Service
price = mys.Price
qty = 1
invodate = datetime.date(today.year, monsel, 1)
descript = 'Monthly Storage Fee for Month of ' + thismonth
input = Invoices(Jo=myo.Jo,
SubJo=invojo,
Pid=myo.Pid,
Service=addserv,
Description=descript,
Ea=price,
Qty=qty,
Amount=price,
Date=invodate,
Total=price,
Original=None,
Status='New')
db.session.add(input)
db.session.commit()
ldat = Invoices.query.filter(
Invoices.SubJo == invojo).first()
invodate = ldat.Date
# If have ldata:
err = [' ', ' ', 'Created invoice for JO= ' + invojo, ' ', ' ']
ldata = Invoices.query.filter(Invoices.SubJo == invojo).order_by(
Invoices.Ea.desc()).all()
pdata1 = People.query.filter(People.id == myo.Pid).first()
odat = Storage.query.get(invooder)
basejo = odat.Jo
involine, paidline, refline, balline = money12(basejo)
import make_S_invoice
make_S_invoice.main(odat, ldata, pdata1, invojo, involine,
paidline, refline, balline, invodate, cache, 0)
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'
odat.Path = docref
odat.Cache = cache
idat = Invoices.query.filter(Invoices.SubJo == invojo).first()
idat.Original = docref
db.session.commit()
leftscreen = 0
err[4] = 'Viewing ' + docref
modata = Storage.query.get(invooder)
elif minvo is not None and monsel == 0:
err = [' ', ' ', 'Choose a Month for the Invoice', ' ', ' ']
elif minvo is not None:
err = [
' ', ' ', 'Must select at least 1 Job for this selection', ' ',
' '
]
# ____________________________________________________________________________________________________________________E.Invoicing.Storage
# ____________________________________________________________________________________________________________________B.NewJob.Storage
if newjob is not None:
err = ['Select Source Document from List']
fdata = myoslist(f'tmp/{scac}/data/vunknown')
modlink = 4
leftsize = 8
leftscreen = 0
docref = f'tmp/{scac}/data/vunknown/NewJob.pdf'
if newjob is None and modlink == 4:
filesel = request.values.get('FileSel')
if filesel != '1':
fdata = myoslist(f'tmp/{scac}/data/vunknown')
leftsize = 8
leftscreen = 0
docref = f'tmp/{scac}/data/vunknown/' + filesel
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/vorders/' + filesel
shutil.move(addpath(docold), addpath(docref))
else:
docref = ''
sdate = request.values.get('dstart')
if sdate is None:
sdate = today
jtype = 'S'
nextjo = newjo(jtype, sdate)
thisdesc = request.values.get('thisdesc')
thisamt = request.values.get('thisamt')
thiscomp = request.values.get('thiscomp')
pybal = request.values.get('pybal')
ldat = People.query.filter(People.Company == thiscomp).first()
if ldat is not None:
acomp = ldat.Company
aid = ldat.id
else:
acomp = None
aid = None
label = nextjo + ' ' + thiscomp + ' ' + thisamt
input = Storage(Jo=nextjo,
Description=thisdesc,
BalFwd=pybal,
Amount=thisamt,
Status='New',
Cache=1,
Original=docref,
Path=None,
Pid=aid,
Company=thiscomp,
Date=sdate,
Label=label)
db.session.add(input)
db.session.commit()
modata = Storage.query.filter(Storage.Jo == nextjo).first()
csize = People.query.filter(People.Ptype == 'Storage').order_by(
People.Company).all()
oder = modata.id
leftscreen = 1
err = ['All is well', ' ', ' ', ' ', ' ']
odata = Storage.query.all()
# ____________________________________________________________________________________________________________________E.New Job.Storage
# ____________________________________________________________________________________________________________________B.Matching.Storage
if match is not None:
if oder > 0 and peep > 0 and numchecked == 2:
myo = Storage.query.get(oder)
myp = People.query.get(peep)
myo.Pid = peep
myo.Company = myp.Company
db.session.commit()
if numchecked != 2:
err[1] = 'Must select exactly 2 boxes to use this option.'
err[0] = ' '
# ____________________________________________________________________________________________________________________E.Matching.Storage
# Create the time oriented data for the columns
bm, cm = timedata(odata)
#This is the else for 1st time through
else:
# ____________________________________________________________________________________________________________________B.STORAGEnotPost
odata = Storage.query.order_by(Storage.Jo).all()
cdata = People.query.filter(People.Ptype == 'Storage').order_by(
People.Company).all()
sdata = Services.query.all()
ldata = None
today = datetime.datetime.today().strftime('%Y-%m-%d')
invodate = today
monsel, oder, peep, serv, invo, inco, cache, modata, modlink, fdata, invooder = init_storage_zero(
)
invojo, filesel, docref, search11, search12, search21, search31 = init_storage_blank(
)
monvec = [
'All', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
'Sep', 'Oct', 'Nov', 'Dec'
]
leftscreen = 1
leftsize = 10
docref = ' '
err = ['All is well', ' ', ' ', ' ', ' ']
bm, cm = timedata(odata)
docref = docref.replace('tmp/vinvoice', f'tmp/{scac}/data/vinvoice')
return odata, cdata, sdata, oder, peep, serv, err, modata, modlink, fdata, today, inco, leftscreen, docref, leftsize, ldata, monsel, monvec, invo, invooder, invojo, cache, filesel, bm, cm, invodate
def huntparse():
s = addpath('originals_bin/pdf/hunt/')
t = addpath('processing/pdf_bin/hunt/')
u = addpath('originals_processed/pdf')
for file in os.listdir(s):
if fnmatch.fnmatch(file, '*.pdf'):
shutil.copy(s + file, u)
shutil.move(s + file, t + file)
data = addpath('processing/pdf_bin/hunt')
done = addpath('processing/pdforder/')
viewloc = addpath('tmp/data/vorders/')
#Using new format here the left item is what we are looking for (keyword) and right side is the Label
hitems = ['Total Rate:Amount', 'Commodity:commodity']
# These items we look to see if there are load and delivery points to add to database
vadditems = ['Pickup', 'Shipper', 'Consignee', 'Delivery']
today = datetime.datetime.today()
todaydate = today.date()
todaynow = today.time()
todaystr = datetime.datetime.today().strftime('%Y-%m-%d')
year = str(today.year)
day = str(today.day)
month = str(today.month)
#print(month,day,year)
datestr = 'label:' + month + '/' + day + '/' + year
pyr = year[2] + year[3]
date_p1 = re.compile(
r'(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|June|July|August|September|October|November|December)\s?\d{1,2},?\s?\d{4}'
)
date_y2 = re.compile(r'\d{1,2}[/-]\d{1,2}[/-]\d{2}')
date_y4 = re.compile(r'\d{1,2}[/-]\d{1,2}[/-]\d{4}')
date_p3 = re.compile(
r'\d{1,2}\s?(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s?\d{4}'
)
date_p4 = re.compile(r'\s' + pyr +
'(?:0[1-9]|1[012])(?:0[1-9]|[12][0-9]|3[01])')
time_p24 = re.compile(
r'(?:[1-9]|0[0-9]|1[0-9]|2[01234])[:](?:0[0-9]|[12345][0-9])')
container_p = re.compile(r'[A-Z,a-z]{4}\s?[Ool0123456789]{7}')
amount_p = re.compile(
r'\$(?:[0-9]|[0-9]{2}|[0-9]{3}|[1-9],[0-9]{3})\.[0-9]{2}')
fcount = 0
for file2 in os.listdir(addpath('processing/pdf_bin/hunt')):
if fnmatch.fnmatch(file2, '*.pdf'):
fcount = fcount + 1
base = os.path.splitext(file2)[0]
#print(base)
load = base.replace('Tender_', '')
print('Load=', load)
if not load:
load = '000000'
#print(file2,base,load)
print('Running file: ', file2)
print(
subprocess.check_output([
'pdf2txt.py', '-o', done + load + '.txt',
addpath('processing/pdf_bin/hunt/' + file2)
]))
#See if the order exists already:
o = Orders.query.filter(Orders.Original == file2).first()
if o is None:
jtype = 'T'
nextjo = newjo(jtype, todaystr)
#add some default values here for database:
input = Orders(Status='A0',
Jo=nextjo,
Load=load,
Order=load,
Company=None,
Location=None,
Booking=None,
BOL=None,
Container=None,
Date=None,
Driver=None,
Company2=None,
Time=None,
Date2=None,
Time2=None,
Seal=None,
Pickup=None,
Delivery=None,
Amount=None,
Path=None,
Original=file2,
Description='Load Broker Line Haul',
Chassis=None,
Detention='0',
Storage='0',
Release=0,
Shipper='JB Hunt',
Type=None,
Time3=None,
Bid=0,
Lid=0,
Did=0,
Label=None,
Dropblock1=None,
Dropblock2=None,
Commodity=None,
Packing=None,
Links=None,
Hstat=-1,
Istat=-1,
Proof=None,
Invoice=None,
Gate=None,
Package=None,
Manifest=None,
Scache=0,
Pcache=0,
Icache=0,
Mcache=0,
Pkcache=0,
QBi=0,
InvoTotal=None)
db.session.add(input)
db.session.commit()
o = Orders.query.filter(Orders.Jo == nextjo).first()
# Find and add load and delivery points to database
for j, item in enumerate(vadditems):
with open(done + load + '.txt') as openfile:
for line in openfile:
if len(line) > 3:
linelist = line.split()
word1 = linelist[0]
if item == word1:
line1 = line
line2 = next(openfile)
line3 = next(openfile)
line4 = next(openfile)
line5 = next(openfile)
if j == 0:
pickupdate = line2
print('pickupdate', pickupdate)
linelist2 = line2.split()
print('DATE', linelist2[0], flush=True)
try:
date1 = datetime.datetime.strptime(
linelist2[0], '%Y-%m-%d')
except:
print('Could not convert:',
date1,
flush=True)
date1 = todaydate
try:
time1 = datetime.datetime.strptime(
linelist2[1], '%H:%M').time()
except:
time1 = todaynow
o.Date = date1
o.Time = time1
db.session.commit()
if j == 1:
shipperlines = line2 + line3 + line4 + line5
print('shipperlines: ', shipperlines)
o.Dropblock1 = shipperlines
company = dropupdate(shipperlines)
addr1 = line3.strip()
cdat = Drops.query.filter(
(Drops.Entity == company)
& (Drops.Addr1 == addr1)).first()
if cdat is not None:
lid = cdat.id
else:
lid = 0
o.Company = company
o.Lid = lid
db.session.commit()
if j == 2:
consigneelines = line2 + line3 + line4 + line5
print('consigneelines: ', consigneelines)
o.Dropblock2 = consigneelines
company2 = dropupdate(consigneelines)
addr1 = line3.strip()
cdat = Drops.query.filter(
(Drops.Entity == company2)
& (Drops.Addr1 == addr1)).first()
if cdat is not None:
did = cdat.id
else:
did = 0
o.Company2 = company2
o.Did = did
db.session.commit()
if j == 3:
deliverydate = line2
print('deliverydate', deliverydate)
linelist2 = line2.split()
#print('DATE',linelist2[0])
date2 = datetime.datetime.strptime(
linelist2[0], '%Y-%m-%d')
print(date1)
time2 = datetime.datetime.strptime(
linelist2[1], '%H:%M').time()
o.Date2 = date2
o.Time2 = time2
db.session.commit()
for item in hitems:
list = []
label = item.split(':', 1)[1]
item = item.split(':', 1)[0]
with open(done + load + '.txt') as openfile:
for line in openfile:
if item.lower() in line.lower():
rest = line.lower().split(item.lower(), 1)[1]
rest = line[-len(rest):]
if ':' in rest:
rest = rest.split(':', 1)[1]
elif '#' in rest:
rest = rest.split('#', 1)[1]
elif 'NUMBER' in rest:
rest = rest.split('NUMBER', 1)[1]
rest = rest.replace('#', '')
rest = rest.replace(':', '')
rest = rest.replace('-', '')
rest = rest.strip()
#Could have multiple space inside words which we do not want to store in database:
pieces = rest.split()
phrase = ''
for piece in pieces:
piece = piece.strip()
phrase = phrase + ' ' + piece
rest = phrase.strip()
#print('item=',item,'rest=',rest,'line=',line)
lofrest = len(rest)
if lofrest > 0:
numbers = sum(c.isdigit() for c in rest)
keyratio = float(numbers) / float(lofrest)
else:
keyratio = 0.0
if keyratio > .4:
list.append(rest)
if len(list) > 0:
best = max(list, key=list.count)
else:
best = None
if label == 'Amount':
o.Amount = best
db.session.commit()
if label == 'commodity':
o.Location = best
db.session.commit()
pdat = People.query.filter(People.Company == 'JB Hunt').first()
if pdat is not None:
bid = pdat.id
else:
bid = 0
book = 'JBHunt ' + load
o.Booking = book
o.Bid = bid
o.Type = '53 Dry Van'
db.session.commit()
os.rename(
addpath('processing/pdf_bin/hunt/') + file2, viewloc + file2)
print('File ', fcount)
return
def isoIncM():
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
#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
if modlink == 1:
if oder > 0:
modata = Income.query.get(oder)
vals = [
'jo', 'account', 'from', 'description', 'amount', 'ref',
'pdate', 'original', 'bank', 'depdate', 'depositnum'
]
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.From = a[2]
modata.Description = a[3]
modata.Amount = a[4]
modata.Ref = a[5]
modata.Date = a[6]
modata.Original = a[7]
modata.Bank = a[8]
if a[9] == '': modata.Date2 = None
else: modata.Date2 = a[9]
modata.Depositnum = a[10]
db.session.commit()
err.append('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()
odata = dataget_Inc(thismuch)
# ____________________________________________________________________________________________________________________B.Search.General
if modlink == 0:
oder, numchecked = numcheck(1, odata, 0, 0, 0, 0, ['oder'])
# ____________________________________________________________________________________________________________________E.Search.General
# ____________________________________________________________________________________________________________________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.append('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()
odata = dataget_Inc(thismuch)
if deletehit is not None and numchecked != 1:
err.append('Must have exactly one item checked to use this option')
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 = Income.query.get(oder)
jo = inc.Jo
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:
err.append('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)
depojo = request.values.get('depojo')
sourcelist = []
for oder in odervec:
idat = Income.query.get(oder)
fromco = idat.From
if fromco is None:
cdat = People.query.get(idat.Pid)
if cdat is not None:
fromco = cdat.Company
else:
fromco = 'Unknown Source'
if fromco not in sourcelist: sourcelist.append(fromco)
ref = idat.Ref
acct = idat.Account
bank = request.values.get('acdeposit')
date2 = request.values.get('depdate')
if len(ref) > 2 and ref != 'ChkNo':
idata = Income.query.filter(
(Income.Account == acct)
& (Income.Ref == ref)).all()
for data in idata:
data.Depositnum = depojo
data.Bank = bank
data.Date2 = date2
data.From = fromco
data.Original = os.path.basename(docref)
db.session.commit()
else:
idat.Bank = bank
idat.Date2 = date2
idat.Depositnum = depojo
idat.From = fromco
idat.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
odata = Income.query.all()
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]
odata = dataget_Inc(thismuch)
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, depdata
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 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 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 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