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 update_dept(self, obj, value):
obj.name = value.upper()
if not obj.name:
uil.show_error('Department name missing!')
return
if obj.id:
obj.update(Dao())
else:
obj.id = obj.add(Dao())
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_admin(self, obj, value):
err_msg = vl.validate_name(value)
if err_msg:
uil.show_error(err_msg)
return
obj.name = value.upper()
if obj.id:
obj.update(Dao())
else:
obj.add(Dao())
def groups():
con_rex = con_dao.get_all(Dao())
contacts = [{
'id': rec['id'],
'name': StrLib.common_name(rec)
} for rec in con_rex]
return render_template('groups/groups.html',
title='Groups',
groups=grp_dao.get_all(Dao(), with_members=True),
contacts=contacts,
modifications=Modification.get_all(serialized=True))
def update_admin_email(self, obj, value):
if not vl.validate_email(value):
uil.show_error('Invalid email!')
return
if not obj.name:
uil.show_error('Admin name missing!')
return
obj.email = value
if obj.id:
obj.update(Dao())
else:
obj.add(Dao())
def processAsn(self):
from dal.dao import Dao
import dal.asn_dal as asn_dal
d = self.formData
if self.asn is None:
d['employee_id'] = self.cboOwner.getSelectionId()
d['project_id'] = self.ownerRec['id']
result = asn_dal.add(Dao(), d)
print(result)
else:
d['employee_id'] = self.asn['employee_id']
d['project_id'] = self.asn['project_id']
result = asn_dal.update(Dao(), self.asn['id'], d)
print(result)
def setProps(self, emp_id):
self.assignee = 'Project'
self.dlg = EmpAsnDlg
self.dal = emp_dal
if emp_id:
self.asns = emp_dal.getAsns(Dao(), emp_id)
gbl.empRex[emp_id]['asns'] = self.asns
def update_member():
params = json.loads(request.form['params'])
try:
nrows = grp_dao.update_member(Dao(), params)
return jsonify(nrows=nrows)
except Exception as ex:
return jsonify(error=str(ex))
def add_member():
params = json.loads(request.form['params'])
try:
mem_id = grp_dao.add_member(Dao(), params)
return jsonify(mem_id=mem_id)
except Exception as ex:
return jsonify(error=str(ex))
def drop():
grp_id = json.loads(request.args['grp_id'])
try:
grp_dao.drop(Dao(), grp_id)
return jsonify(dropped='Group dropped!')
except Exception as ex:
return jsonify(error=str(ex))
def setProps(self, prj_id):
self.assignee = 'Employee'
self.dlg = PrjAsnDlg
self.dal = prj_dal
if prj_id:
self.asns = prj_dal.getAsns(Dao(), prj_id)
gbl.prjRex[prj_id]['asns'] = self.asns
def buildDataSet(self, start, thru, months):
from dal.dao import Dao
import dal.asn_dal as asn_dal
asns = asn_dal.get_for_timeframe(Dao(), start, thru)
self.emp_asns = {emp['id']: [] for emp in gbl.empRex.values()}
for asn in asns:
self.emp_asns[asn['employee_id']].append(asn)
for emp in gbl.empRex:
row = EffRow(emp)
for month in months:
cell = EffCell(month)
for emp_asn in self.emp_asns[emp]:
uglyMo = ml.uglify(month)
if uglyMo < emp_asn['first_month'] or uglyMo > emp_asn[
'last_month']:
continue
cell.total += emp_asn['effort']
cell.efforts.append(
PercentEffort(emp_asn['project'], emp_asn['effort']))
row.cells.append(cell)
self.rows.append(row)
self.breakdowns = self.build_breakdowns()
def drop_member():
mem_id = json.loads(request.args['mem_id'])
try:
grp_dao.drop(Dao(), mem_id)
return jsonify(dropped='Member dropped!')
except Exception as ex:
return jsonify(error=str(ex))
def save_form(self):
form_vals = self.view.get_form_values()
obj = self.view.get_work_list_selection()
updatable_flds = [
'dept', 'admin_approved', 'va_approved', 'invoice_num', 'amount',
'short_code', 'grant_admin', 'grant_admin_email'
]
for fld in updatable_flds:
setattr(obj, fld, form_vals[fld])
if obj.id:
result = obj.update(Dao())
else:
result = obj.add(Dao())
self.view.reload_work_grid(obj)
uil.show_msg('Ledger updated!', 'Hooray')
def update_model(self, form_values):
model = self.model[self.view.get_selected_idx()]
try:
model.update(Dao(), form_values)
except Exception as ex:
uil.show_error(str(ex))
return
uil.show_msg('Employee updated!', 'Hallelujah!')
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 add_model(self, form_values):
new_model = Employee(self.get_new_model_values(form_values))
try:
new_model.id = new_model.add(Dao())
except Exception as ex:
uil.show_error(str(ex))
return
uil.show_msg('Employee added!', 'Hallelujah!')
def pm_dlg(self, emp):
dlg = PmDlg(self.view, emp)
dlg.ShowModal()
if dlg.emp.pm:
dlg.emp.update_pm(Dao())
self.set_emp_lists()
dlg.Destroy()
uil.show_msg('PM updated!', 'Yippee!')
def add_pm(self):
emp = self.view.get_emp_selection()
dlg = PmDlg(self.view, emp)
dlg.ShowModal()
if dlg.emp.pm:
dlg.emp.update_pm(Dao())
self.set_emp_lists()
dlg.Destroy()
uil.show_msg('PM updated!', 'Yippee!')
def save(self):
from dal.dao import Dao
from models.assignment import Assignment
import wx
form_values = self.get_form_values()
if self.is_valid(form_values):
try:
if self.asn:
self.asn.from_dict(form_values)
self.asn.update(Dao())
else:
self.asn = Assignment(form_values)
self.asn.add(Dao())
except Exception as ex:
vl.show_errmsg(None, str(ex))
return
wx.MessageBox('Assignment saved!', 'Hallelujah!', wx.OK)
self.view.Parent.Close()
def update_pm_nonva_email(self, emp, value):
if not vl.validate_email(value):
uil.show_error('Invalid non-VA email!')
return
if not emp.name:
uil.show_error('PM name missing!')
return
emp.nonva_email = value
emp.update_pm(Dao())
def drop(self, action):
idx = self.view.get_selected_idx()
if action == 'Undrop':
self.undrop(idx)
return
try:
self.model[idx].drop(Dao())
except Exception as ex:
uil.show_error(str(ex))
return
def add_model(self, form_values):
from models.project import Project
new_model = Project(self.get_new_model_values(form_values))
try:
new_model.id = new_model.add(Dao())
except Exception as ex:
uil.show_error(str(ex))
return
uil.show_msg('Project added!', 'Hallelujah!')
def addRec(self):
try:
rec_id = self.dal.add(Dao(), self.formData)
except Exception as ex:
wx.MessageBox('Error adding %s: %s' % (self.ownerName, str(ex)))
return False
self.ownerRec = self.formData.copy()
self.ownerRec['id'] = rec_id
self.supplementRec()
self.ownerRec['active'] = 1
self.updateMyRex()
wx.MessageBox('%s added!' % self.ownerName)
return True
def dropRec(self):
try:
result = self.dal.delete(Dao(), [self.ownerRec['id']])
except Exception as ex:
wx.MessageBox('Error dropping %s: %s' % (self.ownerName, str(ex)))
return False
if result != 1:
wx.MessageBox('Unanticipated error dropping %s' % self.ownerName)
return False
del self.rex[self.ownerRec['id']]
self.GrandParent.loadList(self.rex.values())
wx.MessageBox('%s dropped!' % self.ownerName)
return True
def drop_asn(self):
selections = self.view.get_selected_asns()
ids = [x.id for x in selections]
if not ids:
uil.show_error('No assignments selected!')
return
if uil.confirm(self.view, 'Drop selected assignments?'):
try:
Assignment.drop_many(Dao(), ids)
except Exception as ex:
uil.show_error(str(ex))
return