def createCases_returnMap(self, file, fields, archive_id):
data = {}
reader = csv.reader(file, skipinitialspace=True, delimiter=b",", quoting=csv.QUOTE_MINIMAL, quotechar=b'"')
for line in reader:
row = {}
case_id = 0
for f, d in zip(fields, line):
c = d.strip()
if str(f) == "case_id":
case_id = int(c)
elif str(f) == "year":
row["year"], row["year_text"] = self._determine_year(c)
elif str(f) == "actiontype":
row["actiontype"] = FindInList(
self.actiontypes, "actiontype", c, default={"id": 35, "actiontype": ""}
)["id"]
elif str(f) == "county":
row["county"] = FindInList(self.counties, "county", c, default={"id": 1, "county": ""})["id"]
elif str(f) == "court":
row["court"] = FindInList(self.courts, "court", c, default={"id": 1, "court": ""})["id"]
elif str(f) == "call_number":
row["call_number"] = FindInList(
self.callnumbers, "call_number", c, default={"id": 8, "call_number": ""}
)["id"]
elif str(f) == "container":
row["container"] = FindInList(self.containers, "container", c, default={"id": 1, "container": ""})[
"id"
]
else:
row[f] = c.replace("\n", "").replace("\r", "").replace('"', "")
row["archive"] = archive_id
row["import_file"] = self.request.params.get("import.marker", "not provided")
# ENFORCE CONTAINER TYPE
container_enforcer = int(self.request.params.get("container.enforcer", 0))
if container_enforcer != 0:
row["container"] = int(container_enforcer)
# ENFORCE CALLNUMBER
callnumber_enforcer = int(self.request.params.get("callnumber.enforcer", 0))
if callnumber_enforcer != 0:
row["call_number"] = int(callnumber_enforcer)
cases = Cases(**row)
lastid = cases.insert(self.request)
print "Uploaded Case ID: " + str(lastid)
data[case_id] = lastid
return data
def get_location(cls,entity=None,case=None):
from courtrecords.models import Entities, Cases
id = 0
if entity:
e = Entities.load(id=entity)
case = e.case_id
if case:
c = Cases.load(id=case)
id = c.archive
if id:
return Archives.load(id=id)
return None
def create_invoice(self):
records = self.request.params.getall('records')
if records:
fullname = self.request.params.get('customer.name','')
email = self.request.params.get('customer.email','')
address = self.request.params.get('customer.address','')
address2 = self.request.params.get('customer.address2','')
phone = self.request.params.get('customer.phone','')
agreement = Validators.bool(self.request.params.get('customer.agreement',0))
checkout = self.request.params.getall('customer.checkout')
deliver_digitally = False
deliver_physically = False
# Delivery Options
for option in checkout:
if option == 'digitally':
deliver_digitally = True
if option == 'physically':
deliver_physically = True
# Prep Orders
orders = []
total_price = 0.0
location_emails = {} # to notify any locations a request has been made
for record in records:
c = Cases.load(id=int(record))
e = Entities.load(case_id=int(record))
r = Roles.load(id=e.role)
l = Archives.load(id=c.archive)
location_emails[l.email] = l.email
total_price += float(r.price)
orders.append({'case':int(c.id), 'price' : r.price, 'location':int(l.id)})
invoice = Invoices(fullname=fullname, email=email, address=address, county_state_zip=address2, phone=phone, records=orders,
agreement_accepted=agreement, deliver_digitally=deliver_digitally, deliver_physically=deliver_physically,
total_price='${:,.2f}'.format(total_price))
invoice.insert(self.request)
invoice = Invoices.load(order='id desc')
#Email Client
starting_status = Statuses.load(order='priority asc')
Emailer.send(self.request,
[email],
starting_status.email_subject,
starting_status.email_message,
link=self.request.application_url + '/invoice/' + invoice.hash
)
#Email Archives Involved
Emailer.send(self.request,
list(location_emails),
'Order request has been placed',
'A new order request has been placed',
link=self.request.application_url + '/login?goto=' + self.request.application_url + '/manage/orders'
)
response = HTTPFound(location=route_url('invoice', self.request, hash=invoice.hash))
response.delete_cookie('basket')
return response
else:
return self.response
def manage_records(self):
case_id = self.request.matchdict['case_id']
if case_id != 'new':
case_id = int(case_id)
# Add last entry for new entries
self.set('lastentry',case_id)
lastcase = Cases.load(order='id desc')
if lastcase:
self.set('lastentry',lastcase.id)
# Handle Saving
if 'edit.Form.submit.save' in self.request.params or 'edit.Form.submit.savenext' in self.request.params:
self._save(case_id)
if 'edit.Form.submit.savenext' in self.request.params:
return HTTPFound(location=route_url('manage_records', self.request, case_id='new'))
return HTTPFound(location=route_url('manage_records', self.request, case_id=case_id))
# Handle Loading Information on screen
if case_id == 'new' or case_id == 0:
case = None
else:
case = DBSession.query(Cases,Counties,ActionTypes,Archives).filter(Cases.id == case_id) \
.filter(Cases.actiontype == ActionTypes.id) \
.filter(Cases.county == Counties.id) \
.filter(Cases.archive == Archives.id) \
.first()
entities = []
if case_id != 'new':
entities = DBSession.query(Entities,Roles).filter(Entities.case_id == case_id) \
.filter(Entities.role == Roles.id) \
.order_by('entity asc').all()
self.set('case',case)
self.set('year',self._get_year)
self.set('case_id',case_id)
self.set('entities',entities)
self.set('actiontypes',ActionTypes.loadAll(order="actiontype asc"))
self.set('containers',Containers.loadAll(order="container asc"))
self.set('courts',Courts.loadAll(order="court asc"))
self.set('call_numbers',CallNumbers.loadAll(order="call_number asc"))
self.set('archives',Archives.loadAll(order="name asc"))
self.set('roles',Roles.loadAll(order="role asc"))
self.set('counties',Counties.loadAll(order="county asc"))
self.set('prefixs',Prefixs.loadAll(order="prefix asc"))
self.set('suffixs',Suffixs.loadAll(order="suffix asc"))
#${request.application_url}/manage/data/Entities/delete/${entity.Entities.id}?back=${request.url}
delete_url = ''
if case:
entity_base_url = self.request.application_url + '/manage/data/Entities/delete/'
case_base_url = self.request.application_url + '/manage/data/Cases/delete/'
delete_url = case_base_url + str(case.Cases.id) + '?back='
for e in entities:
delete_url += entity_base_url + str(e.Entities.id) + '?back='
delete_url += self.request.application_url + '/manage/cases' # Back to base
self.set('delete_url', delete_url)
return self.response
def _save(self, case_id):
entities, new_entities = {}, {}
cases, new_cases = {}, {}
for k,v in self.request.params.items():
action, table, attr, id = k.split('.')
if action == 'edit':
if table == 'Entities':
if id not in entities:
entities[id] = { attr : v }
else:
entities[id][attr] = v
if table == 'Cases':
if id not in cases:
cases[id] = { attr : v }
else:
cases[id][attr] = v
if action == 'new':
if table == 'Entities':
if id not in new_entities:
new_entities[id] = { attr : v }
else:
new_entities[id][attr] = v
if table == 'Cases':
if id not in new_cases:
new_cases[id] = { attr : v }
else:
new_cases[id][attr] = v
#new_cases[id]['year'] = self._determine_year
# save new cases
for k,v in new_cases.items():
case = Cases()
for attr,value in v.items():
setattr(case,attr,value)
case.year = self._determine_year(case.year_text)[0]
case_id = case.insert(self.request)
# save new entities
for k,v in new_entities.items():
entity = Entities()
for attr,value in v.items():
setattr(entity,attr,value)
entity.case_id = case_id
entity.insert(self.request)
# save existing cases
for k,v in cases.items():
case = Cases.load(id=k)
for attr,value in v.items():
setattr(case,attr,value)
case.year = self._determine_year(case.year_text)[0]
case.save(self.request)
# save existing entities
for k,v in entities.items():
entity = Entities.load(id=k)
for attr,value in v.items():
setattr(entity,attr,value)
entity.save(self.request)
