def load_chunk(self, offset):
window = self.case_ids[offset:offset + self.chunk_size]
if not window:
raise IndexError
formdata = get_formdata_by_case(self.output_rows, window)
query = globals.db.query('cases')
query.join('JOIN persons USING (person_id)')
query.where_in('case_id', window)
self.__preload = {}
self.__preload_offset = offset
if self.load_tags:
cases_tags = casetags.CasesTags(window)
for caseperson in query.fetchcols(self.caseperson_cols):
caseperson = dict(izip(self.caseperson_cols, caseperson))
case_id = caseperson['case_id']
if self.load_tags:
tags = cases_tags.get(case_id)
if tags:
caseperson['tags'] = str(tags)
gencase = self.__preload[case_id] = GenCase(case_id)
gencase.columns = self.output_rows[0].as_list(NS(caseperson))
for og in self.output_rows[1:]:
if not og.form_name:
gencase.addtext(og.label, og.as_text(NS(caseperson)),
case_id)
else:
for values in formdata[case_id][og.form_name]:
if isinstance(values, basestring):
gencase.addtext(None, values)
else:
form_id = form_ui.form_id(values['summary_id'])
gencase.addtext('%s %s' % (og.label, form_id),
og.as_text(NS(values)), form_id)
def preload(self, case_ids):
query = globals.db.query('cases')
query.join('JOIN persons USING (person_id)')
preload = Preload(self.columns, query, 'case_id', case_ids)
if self.load_tags:
cases_tags = casetags.CasesTags(case_ids)
for ns in preload.itervalues():
tags = cases_tags.get(ns.case_id)
if tags:
ns.tags = str(tags)
return preload
def _fetch_cases(self, for_update=False):
query = globals.db.query('cases', for_update=for_update)
query.where_in('case_id', (self.id_a, self.id_b))
try:
a, b = query.fetchall()
except ValueError:
raise MergeError('Error fetching records (incorrect count)')
cases_tags = casetags.CasesTags((a.case_id, b.case_id))
a.tags = cases_tags.get(a.case_id)
b.tags = cases_tags.get(b.case_id)
if a.case_id == self.id_a and b.case_id == self.id_b:
return a, b
elif a.case_id == self.id_b and b.case_id == self.id_a:
return b, a
else:
raise MergeError('Error fetching records (incorrect records)')
def page_rows(self):
if not self.pkeys:
return []
# Collect ordering and linking information
self._page_to_selected()
person_ids = []
self.page_case_ids = set()
for person_id, person_case_ids in self.page_pkeys():
person_ids.append(person_id)
self.page_case_ids.update(person_case_ids)
self._selected_to_page()
# Fetch persons
person_map = {}
query = globals.db.query('persons')
query.where_in('person_id', person_ids)
for row in query.fetchall():
person_map[row.person_id] = Person(self, row)
# Fetch cases
case_map = {}
query = globals.db.query('cases')
query.where_in('case_id', self.page_case_ids)
for row in query.fetchall():
case_map[row.case_id] = CaseSummary(self, row)
# Fetch case tags
cases_tags = casetags.CasesTags(self.page_case_ids)
# Now collate
result = []
for person_id, person_case_ids in self.page_pkeys():
try:
person = person_map[person_id]
except KeyError:
pass
else:
result.append(person)
for case_id in person_case_ids:
try:
case_summary = case_map[case_id]
except KeyError:
pass
else:
person.cases.append(case_summary)
case_summary.case_row.tags = \
cases_tags.get(case_summary.case_id)
return result
def page_rows(self):
person_ids = self.page_pkeys()
page_case_ids = set()
for person_id in person_ids:
page_case_ids.update(self.cases_by_person[person_id])
# Fetch persons
query = globals.db.query('persons')
query.where_in('person_id', person_ids)
person_by_id = {}
for row in query.fetchall():
person_by_id[row.person_id] = person.person(row)
# Fetch cases
query = globals.db.query('cases')
query.where_in('case_id', page_case_ids)
query.where('NOT deleted')
case_by_id = {}
for row in query.fetchall():
case_by_id[row.case_id] = CaseSummary(row)
# Fetch case tags
cases_tags = casetags.CasesTags(page_case_ids)
# Now join them up
persons = []
for person_id in person_ids:
case_ids = self.cases_by_person[person_id]
try:
pers = person_by_id[person_id]
except KeyError:
continue
pers.cases = []
for case_id in case_ids:
try:
pers.cases.append(case_by_id[case_id])
except KeyError:
continue
if len(pers.cases) < 2:
continue
for cs in pers.cases:
cs.row.tags = cases_tags.get(cs.row.case_id)
persons.append(pers)
return persons
# Remove duplicate update_time (on cases, and on persons)
self.case_cols.remove('last_update')
self.case_cols.remove('last_update')
def set_include_forms(self, include_forms):
self.include_forms = include_forms
def preload(self, db, cases):
id_idx = self.case_cols.index('case_id')
query = db.query('cases')
query.join('JOIN persons USING (person_id)')
query.where_in('case_id', [case.id for case in cases])
self.cases = {}
for row in query.fetchcols(self.case_cols):
self.cases[row[id_idx]] = row
self.cases_tags = casetags.CasesTags(self.cases.keys())
for name in self.include_forms:
self.forms_by_name[name].clear()
formvers_summids = ExportCase.summid_by_form_version(cases,
self.include_forms)
for (form_name, form_version), summ_ids in formvers_summids:
form = self.forms_by_name[form_name]
form.preload(db, form_version, summ_ids)
def col_labels(self, db):
self._get_case_cols(db)
labels = list(self.case_cols)
labels.append('tags')
for name in self.include_forms:
labels.extend(self.forms_by_name[name].col_labels())
return labels
return cmp(self.name, other.name)
class SelCaseMerge:
def __init__(self, credentials, syndrome_id, query, person):
self.syndrome_id = syndrome_id
self.query = query
self.person = person
# self.update()
def update(self):
cases = self.query.fetchall()
case_ids = [case.case_id for case in cases]
cases_tags = casetags.CasesTags(case_ids)
syndsets = {}
for case in cases:
case.tags = cases_tags.get(case.case_id)
syndset = syndsets.get(case.syndrome_id)
if syndset is None:
syndset = SyndromeCaseMergeSet(case.syndrome_id)
syndsets[case.syndrome_id] = syndset
syndset.append(case)
self.syndsets = [
syndset for syndset in syndsets.values() if len(syndset) > 1
]
self.syndsets.sort()
self.index_a = '0,0'
self.index_b = '0,1'