def csv_import():
from config.extensions import db
import dal.jurisdiction_dao as juris_dao
if request.method == 'GET':
dao = Dao(stateful=True)
mods = mods_dao.get_all(dao)
grps = groups_dao.get_all(dao, with_members=False)
jurisdictions = juris_dao.get_all(dao)
dao.close()
return render_template(
'contacts/csv_import.html',
modifications=mods,
groups=grps,
jurisdictions=jurisdictions,
title='Contact Import'
)
data = json.loads(request.form['params'])
rex = [Contact(rename_fields(rec)) for rec in data]
for rec in rex:
db.session.add(rec)
try:
db.session.commit()
return jsonify(msg='Successful!')
except Exception as ex:
db.session.rollback()
return jsonify(error=str(ex))
def build_globals():
import globals as gbl
import lib.ui_lib as uil
from dal.dao import Dao
import dal.prj_dal as prj_dal
import dal.emp_dal as emp_dal
dao = Dao(stateful=True)
gbl.prjRex = prj_dal.get_all_active(dao)
gbl.empRex = emp_dal.get_all(dao)
dao.close()
# Add PI and PM names to prjRex
# Build prj name and nickname comparison dicts
empNames = {emp['id']: emp['name'] for emp in gbl.empRex.values()}
for prj in gbl.prjRex.values():
prj['PiName'] = empNames[prj['PI']] if prj['PI'] else ''
prj['PmName'] = empNames[prj['PM']] if prj['PM'] else ''
gbl.prjNames[uil.set2compare(prj['name'])] = prj['id']
gbl.prjNicknames[uil.set2compare(prj['nickname'])] = prj['id']
w = dc.GetTextExtent(prj['name'])[0]
if dc.GetTextExtent(prj['name'])[0] > gbl.widestPrjName:
gbl.widestPrjName = w
w = dc.GetTextExtent(prj['nickname'])[0]
if w > gbl.widestNickname:
gbl.widestNickname = w
gbl.empNames = {uil.set2compare(e['name']): e['id']
for e in gbl.empRex.values()}
gbl.widestEmpName = uil.getWidestTextExtent(font, empNames.values())
def import_spreadsheet():
import lib.excel_lib as xl
from dal.dao import Dao
from models.deposit import Deposit
file = 'c:/bench/allocat/data/test_deposits.xls'
wb = xl.open_wb(file)
sheets = wb.sheet_names()
rex = []
dao = Dao(stateful=True)
for idx in range(0, len(sheets)):
sh = wb.sheet_by_index(idx)
print('Sheet ' + sh.name)
nrows = sum(1 for _ in sh.get_rows())
for rownum in range(0, nrows):
if sh.cell_value(rownum, 1).startswith('506'):
ss_rec = Deposit(sh.row_values(rownum))
# if ss_rec.invoice_num == 'K8H1025':
# print('boo')
if ss_rec.invoice_num[0:2] not in ('K0', 'K9'):
continue
try:
db_rec = Deposit.get_by_invoice_num(dao, ss_rec.invoice_num)
except Exception as ex:
print(str(ex))
if not db_rec:
ss_rec.add(dao)
rex.append(ss_rec)
dao.close()
return rex
def drop():
contact_id = json.loads(request.args['contact_id'])
dao = Dao(stateful=True)
success = con_dao.drop(dao, contact_id)
dao.close()
if not success:
msg = 'Contact not deleted. Please report.'
return jsonify(error=msg)
return jsonify(dropped='Contact dropped!')
def _get_data(self):
from dal.dao import Dao
from models.project import Project
from models.employee import Employee
from models.assignment import Assignment
dao = Dao(db_path=self.db_path, stateful=True)
self._prj_rex = Project.get_all(dao)
self._emp_rex = Employee.get_all(dao)
self._asn_rex = Assignment.get_all(dao)
dao.close()
def update_entries(self):
from dal.dao import Dao
from models.invoice import Invoice
dao = Dao(stateful=True)
invoice_rex = self.import_spreadsheet()
for invoice_rec in list(invoice_rex):
ledger_rec = Invoice.get_by_invoice(dao, invoice_rec.invoice_num)
if ledger_rec:
ledger_rec.update_balance(dao, invoice_rec.amount)
new_rex = Invoice.get_rex(dao)
dao.close()
gbl.dataset.set_ledger_data(new_rex)
self.init_view()
def update_allocat(self):
rex = self.view.get_rex()
new_rex = []
for rec in rex:
new_rec = {
'id': next((x.id for x in self.emps if x.name == rec.name),
None),
'salary': rec.salary,
'fringe': rec.fringe
}
if not new_rec['id']:
uil.show_error('Uh oh! No employee record for ' + rec.name)
return
new_rex.append(new_rec)
dao = Dao(stateful=True)
try:
Employee.update_salaries(dao, new_rex)
uil.show_msg('Hurray!', 'Done!')
except Exception as e:
uil.show_error(str(e))
finally:
dao.close()
def _get_data(self):
from dal.dao import Dao
from tests.ledger_data.test_data import invoices_q2_pre_query
from models.employee import Employee
from models.department import Department
from models.grant_admin import GrantAdmin
from models.invoice import Invoice
from models.assignment import Assignment
dao = Dao(db_path=self.db_path, stateful=True)
self._emp_rex = Employee.get_all(dao)
self._dept_rex = Department.get_all(dao)
self._grant_admin_rex = GrantAdmin.get_all(dao)
invoices_unpaid = Invoice.get_rex(dao)
# invoices_unpaid = invoices_q2
self._invoices_sent = [
invoice for invoice in invoices_unpaid if invoice.sent
]
self._invoices_unsent = [
invoice for invoice in invoices_unpaid if not invoice.sent
]
self._asn_rex = Assignment.get_billables(dao)
dao.close()
"paid BOOLEAN,"
"balance DECIMAL,"
"short_code TEXT,"
"grant_admin TEXT,"
"grant_admin_email TEXT);")
print('Creating ledger table...')
try:
# Need this empty tuple to avoid parameters error from sqlite
dao.execute(sql, ())
print('Ledger table created!')
return True
except Exception as e:
print('Error creating ledger table: ' + str(e))
return False
def populate_ledger():
pass
if __name__ == '__main__':
from dal.dao import Dao
dao = Dao(stateful=True)
build_departments()
build_grant_admins()
build_ledger_employees()
build_ledger()
dao.close()
print('Done!')