def __init__(self, credentials, syndrome_id,
format='classic',
deleted='n',
strip_newlines=False):
self.credentials = credentials
self.syndrome_id = syndrome_id
self.format = format
self.strip_newlines = strip_newlines
# Collect names of all forms *in use* for this syndrome
# as well as summary_ids, etc
query = globals.db.query('cases', distinct=True)
query.join('LEFT JOIN case_form_summary USING (case_id)')
query.where('syndrome_id = %s', syndrome_id)
if deleted != 'n':
query.where('NOT case_form_summary.deleted')
caseaccess.acl_query(query, self.credentials, deleted=deleted)
forms_used = set()
self.export_cases = ExportCases()
row_formatter_cls = row_formatters[self.format]
self.row_formatter = row_formatter_cls(self.format, self.strip_newlines)
rows = query.fetchcols(('cases.case_id',
'summary_id', 'form_label', 'form_version'))
for case_id, summary_id, form_name, form_version in rows:
self.export_cases.add_summ_id(case_id, summary_id,
form_name, form_version)
if summary_id is not None:
self.row_formatter.seen_form(case_id, form_name, form_version)
forms_used.add(form_name)
self.forms = Forms(globals.db, forms_used)
def __init__(self, db, cred, person_cols,
syndrome_id=None, case_ids=None):
self.relations = set()
self.case_persons = {}
self.persons = {}
self.short_labels = not person_cols
self.to_syndcs = {}
self.syndcs_label = {}
self.syndcs_color = {}
used_syndcs = set()
query = db.query('syndrome_case_status')
cols = 'syndcs_id', 'syndrome_id', 'name', 'label'
for syndcs_id, syndrome_id, name, label in query.fetchcols(cols):
self.to_syndcs[(syndrome_id, name)] = syndcs_id
self.syndcs_label[syndcs_id] = label
query = db.query('cases')
caseaccess.acl_query(query, cred)
query.join('JOIN case_contacts USING (case_id)')
if case_ids is not None:
subquery = query.sub_expr('OR')
subquery.where_in('case_id', case_ids)
subquery.where_in('contact_id', case_ids)
elif syndrome_id is not None:
query.where('syndrome_id = %s', syndrome_id)
cols = 'syndrome_id','person_id','case_id','contact_id','case_status'
self.persons = {}
for syndrome_id, person_id, case_id, contact_id, status in query.fetchcols(cols):
try:
person = self.persons[person_id]
except KeyError:
person = self.persons[person_id] = Person()
person.case_ids.add(case_id)
syndcs = self.to_syndcs.get((syndrome_id, status))
if syndcs is not None:
person.statuses.add(syndcs)
used_syndcs.add(syndcs)
self.case_persons[case_id] = person_id
if case_id < contact_id:
self.relations.add((case_id, contact_id))
else:
self.relations.add((contact_id, case_id))
if len(self.persons) > MAX_NODES:
raise Error('Sorry, this facility only supports < %d %s (%d required)' % (MAX_NODES, config.person_label, len(self.persons)))
if len(self.relations) > MAX_VERTICES:
raise Error('Sorry, this facility only supports < %d relations (%d required)' % (MAX_VERTICES, len(self.relations)))
if self.persons:
query = db.query('persons')
query.where_in('person_id', self.persons.keys())
for row in query.fetchcols(['person_id'] + list(person_cols)):
person = self.persons[row[0]]
person.label = '\\n'.join(map(str, row[1:]))
used_syndcs = list(used_syndcs)
used_syndcs.sort()
colors = trafficlight.make_n_colors(len(used_syndcs))
for color, syndcs in zip(colors, used_syndcs):
self.syndcs_color[syndcs] = color
self.syndcs_color[None] = '#dddddd';
def case_query(credentials, **kwargs):
"""
Look up a (single) case via kwargs (local_case_id, etc)
"""
query = globals.db.query('cases')
for col, val in kwargs.iteritems():
query.where('%s = %%s' % col, val)
caseaccess.acl_query(query, credentials, deleted=None)
row = query.fetchone()
if row is None:
return None
return Case(credentials, query.fetchone())
def locked_case_ids(credentials, syndrome_id, dataimp_src, importrules):
importer = ImportBase(syndrome_id, dataimp_src, importrules)
if importer.key_proc is None:
raise Error('No key/ID column defined')
local_ids = importer.yield_keys()
query = globals.db.query('cases')
query.join('JOIN persons USING (person_id)')
caseaccess.acl_query(query, credentials)
query.where('(data_src is null OR data_src != %s)', importrules.srclabel)
query.where('(data_src is null OR data_src != %s)', importrules.srclabel)
query.where_in('local_case_id', local_ids)
return query.fetchcols('case_id')
def locked_case_ids(credentials, syndrome_id, dataimp_src, importrules):
importer = ImportBase(syndrome_id, dataimp_src, importrules)
if importer.key_proc is None:
raise Error('No key/ID column defined')
local_ids = importer.yield_keys()
query = globals.db.query('cases')
query.join('JOIN persons USING (person_id)')
caseaccess.acl_query(query, credentials)
query.where('(data_src is null OR data_src != %s)', importrules.srclabel)
query.where('(data_src is null OR data_src != %s)', importrules.srclabel)
query.where_in('local_case_id', local_ids)
return query.fetchcols('case_id')
def row_gen(self, include_forms):
yield 'id_a', 'id_b', 'contact_type', 'contact_date'
query = globals.db.query('case_contacts')
query.join('JOIN cases USING (case_id)')
query.join('LEFT JOIN contact_types USING (contact_type_id)')
query.where('case_id < contact_id')
caseaccess.acl_query(query, self.credentials, deleted=self.deleted)
cols = 'case_id', 'contact_id', 'contact_type', 'contact_date'
for row in query.fetchcols(cols):
if row[-1]:
row = row[:-1] + (row[-1].strftime(ISO_fmt),)
yield row
def case_query(credentials, **kwargs):
"""
Look up a (single) case via kwargs (local_case_id, etc)
"""
query = globals.db.query('cases')
for col, val in kwargs.iteritems():
query.where('%s = %%s' % col, val)
caseaccess.acl_query(query, credentials, deleted=None)
row = query.fetchone()
if row is None:
return None
return Case(credentials, query.fetchone())
def load(self, credentials):
query = globals.db.query('persons')
query.where('person_id = %s', self.person_id)
person = query.fetchone()
if person is None:
return
self.name = 'All cases for %s, %s' %\
(person.surname, person.given_names)
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('person_id = %s', self.person_id)
if self.syndrome_id is not None:
query.where('syndrome_id = %s', self.syndrome_id)
self.case_ids = query.fetchcols('case_id')
def query(self, cred, no_order=False, form_based=False,
include_deleted=False):
kw = {}
if self.order_by and not no_order:
kw['order_by'] = self.query_order()
if self.deleted_filter():
include_deleted = None
query = globals.db.query('cases', **kw)
query.join('JOIN persons USING (person_id)')
caseaccess.acl_query(query, cred, deleted=include_deleted)
query.where('syndrome_id = %s', self.syndrome_id)
if self.show_filters:
self.filter_query(query, form_based=form_based)
return query
def load(self, credentials):
query = globals.db.query('persons')
query.where('person_id = %s', self.person_id)
person = query.fetchone()
if person is None:
return
self.name = 'All cases for %s, %s' %\
(person.surname, person.given_names)
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('person_id = %s', self.person_id)
if self.syndrome_id is not None:
query.where('syndrome_id = %s', self.syndrome_id)
self.case_ids = query.fetchcols('case_id')
def by_person_id(credentials, syndrome_id, person_id):
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('syndrome_id = %s', syndrome_id)
query.where('person_id = %s', person_id)
return SelCaseMerge(credentials, None, query, person.edit_id(person_id))
def edit_case(credentials, case_id):
query = globals.db.query('cases')
query.where('case_id = %s', case_id)
caseaccess.acl_query(query, credentials, deleted=None)
return Case(credentials, query.fetchone())
def by_person_id(credentials, syndrome_id, person_id):
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('syndrome_id = %s', syndrome_id)
query.where('person_id = %s', person_id)
return SelCaseMerge(credentials, None, query, person.edit_id(person_id))
def by_case(credentials, case, person):
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('person_id = %s', case.person_id)
query.where('syndrome_id = %s', case.syndrome_id)
return SelCaseMerge(credentials, case.syndrome_id, query, person)
def _test(cred, expect):
query = self.db.query('cases')
caseaccess.acl_query(query, cred)
self.assertEqual(query.fetchcols('case_id'), expect)
syndset = self.syndsets[int(set_a_idx)]
case_a = syndset[int(case_a_idx)]
case_b = syndset[int(case_b_idx)]
if case_a is case_b: raise ValueError
except (IndexError, ValueError, TypeError):
raise MergeError('Select the two records you wish to merge')
return CaseMerge(case_a.case_id, case_b.case_id)
def by_person(credentials, person_row):
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('person_id = %s', person_row.person_id)
return SelCaseMerge(credentials, None, query, person.edit_row(person_row))
def by_person_id(credentials, syndrome_id, person_id):
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('syndrome_id = %s', syndrome_id)
query.where('person_id = %s', person_id)
return SelCaseMerge(credentials, None, query, person.edit_id(person_id))
def by_case(credentials, case, person):
query = globals.db.query('cases', order_by='case_id')
caseaccess.acl_query(query, credentials, deleted=None)
query.where('person_id = %s', case.person_id)
query.where('syndrome_id = %s', case.syndrome_id)
return SelCaseMerge(credentials, case.syndrome_id, query, person)
def edit_case(credentials, case_id):
query = globals.db.query('cases')
query.where('case_id = %s', case_id)
caseaccess.acl_query(query, credentials, deleted=None)
return Case(credentials, query.fetchone())
