def get_form_ui(self):
synd = syndrome.syndromes[self.syndrome_id]
f = form_ui.Form('%s %s' % (synd.name, self.name), table='None')
f.question(text=synd.description, inputs=[])
demog_fields = demogfields.get_demog_fields(globals.db,
self.syndrome_id)
for field in demog_fields.context_fields('case'):
if field.render in ('textinput', 'case_dob'):
f.question(text=field.label,
input=form_ui.TextInput(field.name))
elif field.render == 'textarea':
f.question(text=field.label,
input=form_ui.TextArea(field.name))
elif field.render == 'dateinput':
f.question(text=field.label,
input=form_ui.TextInput(field.name,
post_text='dd-mm-yyyy'))
elif field.render == 'datetimeinput':
f.question(text=field.label,
input=form_ui.TextInput(
field.name, post_text='dd-mm-yyyy HH:MM'))
elif field.render == 'select':
f.question(text=field.label,
input=form_ui.RadioList(field.name,
choices=field.optionexpr()))
f.update_labels()
return f
def __init__(self, prefs, syndrome_id, notification_window):
paged_search.PagedSearch.__init__(self, globals.db, prefs, None)
self.syndrome_id = syndrome_id
self.syndrome_name = syndrome.syndromes[syndrome_id].name
self.notification_window = notification_window
cases_by_person = {}
cols = 'person_id', 'case_id'
query = globals.db.query('cases', order_by=self.order_by)
query.where('NOT deleted')
query.join('JOIN persons USING (person_id)')
query.where('syndrome_id = %s', self.syndrome_id)
for person_id, case_id in query.fetchcols(cols):
person_case_ids = cases_by_person.setdefault(person_id, [])
person_case_ids.append(case_id)
cases_by_person = [(person_id, cases)
for person_id, cases in cases_by_person.iteritems()
if len(cases) >= 2]
if not cases_by_person:
raise globals.Error('No duplicates found')
self.cases_by_person = dict(cases_by_person)
# Put person ids in order
person_ids = self.cases_by_person.keys()
query = globals.db.query('persons', order_by='surname, given_names')
query.where_in('person_id', person_ids)
self.pkeys = query.fetchcols('person_id')
# fields
fields = demogfields.get_demog_fields(globals.db, self.syndrome_id)
fields = fields.context_fields('result')
self.fields = []
for name in self.case_fields:
try:
self.fields.append(fields.field_by_name(name))
except KeyError:
pass
def __init__(self, prefs, syndrome_id, notification_window):
paged_search.PagedSearch.__init__(self, globals.db, prefs, None)
self.syndrome_id = syndrome_id
self.syndrome_name = syndrome.syndromes[syndrome_id].name
self.notification_window = notification_window
cases_by_person = {}
cols = 'person_id', 'case_id'
query = globals.db.query('cases', order_by=self.order_by)
query.where('NOT deleted')
query.join('JOIN persons USING (person_id)')
query.where('syndrome_id = %s', self.syndrome_id)
for person_id, case_id in query.fetchcols(cols):
person_case_ids = cases_by_person.setdefault(person_id, [])
person_case_ids.append(case_id)
cases_by_person = [(person_id, cases)
for person_id, cases in cases_by_person.iteritems()
if len(cases) >= 2]
if not cases_by_person:
raise globals.Error('No duplicates found')
self.cases_by_person = dict(cases_by_person)
# Put person ids in order
person_ids = self.cases_by_person.keys()
query = globals.db.query('persons', order_by='surname, given_names')
query.where_in('person_id', person_ids)
self.pkeys = query.fetchcols('person_id')
# fields
fields = demogfields.get_demog_fields(globals.db, self.syndrome_id)
fields = fields.context_fields('result')
self.fields = []
for name in self.case_fields:
try:
self.fields.append(fields.field_by_name(name))
except KeyError:
pass
def field_api(self):
def _field_api(field):
self.failUnless(hasattr(field, 'disabled'))
self.failUnless(hasattr(field, 'entity'))
self.failUnless(hasattr(field, 'field'))
self.failUnless(hasattr(field, 'hideable'))
self.failUnless(hasattr(field, 'label'))
self.failUnless(hasattr(field, 'name'))
self.failUnless(hasattr(field, 'render'))
self.failUnless(hasattr(field, 'section'))
for context in demogfields.contexts:
self.failUnless(hasattr(field, 'show_' + context))
self.failUnless(field.show(context) in (True, False))
for field in demogfields.get_demog_fields(self.db, None):
_field_api(field)
for field in demogfields.get_demog_fields(self.db, 0):
_field_api(field)
def fields_optionexpr(self):
fields = demogfields.get_demog_fields(globals.db, None)
return [(field.name, field.label)
for field in fields
if (field.entity == 'person'
and field.name not in self.special_fields)]
self.label = other.label
self.weight = other.weight
self.fields = list(other.fields)
def case_summary(db, case_id, case_dict, person_dict):
case_row = case_dict.get(case_id)
if case_row is None:
return 'unknown'
fields = demogfields.get_demog_fields(db, case_row.syndrome_id)
fields = fields.context_fields('result')
person_row = person_dict.get(case_row.person_id)
if person_row is not None:
summary = '%s, %s' % (fields.summary(case_row),
fields.summary(person_row))
return summary
def case_summary(db, case_id, case_dict, person_dict):
case_row = case_dict.get(case_id)
if case_row is None:
return 'unknown'
fields = demogfields.get_demog_fields(db, case_row.syndrome_id)
fields = fields.context_fields('result')
person_row = person_dict.get(case_row.person_id)
if person_row is not None:
summary = '%s, %s' % (fields.summary(case_row),
fields.summary(person_row))
return summary
def page_display(ctx):
ctx.locals.page = ctx.locals.likely.result_page()
fields = demogfields.get_demog_fields(globals.db, None)
ctx.locals.fields = [f for f in fields.context_fields('result')
if f.name in show_fields]
if not ctx.locals.likely.full_likely:
ctx.add_error('No duplicate matches found')
elif not ctx.locals.page:
ctx.add_message('No duplicate matches found (%d match(es) excluded)' %
ctx.locals.likely.exclude_count)
ctx.run_template('dupepersons.html')
def init_fields(self, person_a, person_b):
self.person_a = person_a
self.person_b = person_b
self.fields = []
for field in demogfields.get_demog_fields(globals.db, None):
if hasattr(person_a, field.name) and hasattr(person_b, field.name):
if field.name == 'DOB':
mc = DOBMergeCol(self, field, len(self.fields))
else:
mc = MergeCol(self, field, len(self.fields))
self.fields.append(mc)
self.status, self.exclude_reason =\
persondupe.get_status(self.id_a, self.id_b, for_update=True)
def init_fields(self, person_a, person_b):
self.person_a = person_a
self.person_b = person_b
self.fields = []
for field in demogfields.get_demog_fields(globals.db, None):
if hasattr(person_a, field.name) and hasattr(person_b, field.name):
if field.name == 'DOB':
mc = DOBMergeCol(self, field, len(self.fields))
else:
mc = MergeCol(self, field, len(self.fields))
self.fields.append(mc)
self.status, self.exclude_reason =\
persondupe.get_status(self.id_a, self.id_b, for_update=True)
def __init__(self, importer):
self.label = 'Demographics'
fields = demogfields.get_demog_fields(globals.db, importer.syndrome_id)
fields = fields.context_fields('case')
self.col_procs = []
importer.key_proc = None
for field in fields:
try:
rule = importer.importrules[field.name]
except KeyError:
continue
try:
method = None
# rather use str.rsplit, but it's not in py 2.3
# ns, field = col_proc.field.rsplit('.', 1)
names = field.field.split('.')
args = {
'name': field.name,
'label': field.label,
'entity': names[1],
'target': names[2],
'rule': rule,
'outtrans': field.outtrans,
'options': None,
}
if field.name == 'DOB':
method = ImportAgeCol
args['index'] = importer.dataimp_rows.col_idx(rule.src)
age_idx = None
if isinstance(rule, elements.ImportAgeSource):
age_idx = importer.dataimp_rows.col_idx(rule.age)
args['age_index'] = age_idx
elif isinstance(rule, elements.ImportSource):
method = ImportCol
args['index'] = importer.dataimp_rows.col_idx(rule.src)
elif isinstance(rule, elements.ImportFixed):
method = ValueCol
elif isinstance(rule, elements.ImportIgnore):
continue
else:
raise Error('unknown rule type: %r' % rule)
if field.optionexpr is not None:
args['options'] = set([v[0] for v in field.optionexpr()])
col_proc = method(**args)
self.col_procs.append(col_proc)
if field.name == 'local_case_id':
importer.key_proc = col_proc
except Error, e:
importer.error('field %r: %s' % (field.label, e))
def __init__(self, importer):
self.label = 'Demographics'
fields = demogfields.get_demog_fields(globals.db, importer.syndrome_id)
fields = fields.context_fields('case')
self.col_procs = []
importer.key_proc = None
for field in fields:
try:
rule = importer.importrules[field.name]
except KeyError:
continue
try:
method = None
# rather use str.rsplit, but it's not in py 2.3
# ns, field = col_proc.field.rsplit('.', 1)
names = field.field.split('.')
args = {
'name': field.name,
'label': field.label,
'entity': names[1],
'target': names[2],
'rule': rule,
'outtrans': field.outtrans,
'options': None,
}
if field.name == 'DOB':
method = ImportAgeCol
args['index'] = importer.dataimp_rows.col_idx(rule.src)
age_idx = None
if isinstance(rule, elements.ImportAgeSource):
age_idx = importer.dataimp_rows.col_idx(rule.age)
args['age_index'] = age_idx
elif isinstance(rule, elements.ImportSource):
method = ImportCol
args['index'] = importer.dataimp_rows.col_idx(rule.src)
elif isinstance(rule, elements.ImportFixed):
method = ValueCol
elif isinstance(rule, elements.ImportIgnore):
continue
else:
raise Error('unknown rule type: %r' % rule)
if field.optionexpr is not None:
args['options'] = set([v[0] for v in field.optionexpr()])
col_proc = method(**args)
self.col_procs.append(col_proc)
if field.name == 'local_case_id':
importer.key_proc = col_proc
except Error, e:
importer.error('field %r: %s' % (field.label, e))
def user(self):
# Check defaults derived from classes with no local override
common_fields = demogfields.get_demog_fields(self.db, None)
self.assertEqual(common_fields[CD_FIELD].name, 'case_definition')
self.assertEqual(common_fields[CD_FIELD].show('case'), True)
self.assertEqual(common_fields[CD_FIELD].show('search'), True)
self.assertEqual(common_fields[CD_FIELD].show('person'), False)
# Syndrome-specific fields with no override
synd_fields = demogfields.get_demog_fields(self.db, None)
self.assertEqual(synd_fields[CD_FIELD].name, 'case_definition')
self.assertEqual(synd_fields[CD_FIELD].show('case'), True)
self.assertEqual(synd_fields[CD_FIELD].show('search'), True)
self.assertEqual(synd_fields[CD_FIELD].show('person'), False)
# Now check defaults with db-derived common override
self.execute('INSERT INTO %s (name, label, show_case)'
' VALUES (%%s, %%s, %%s)',
('case_definition', 'LABEL', False))
demogfields.flush()
common_fields = demogfields.get_demog_fields(self.db, None)
self.assertEqual(common_fields[CD_FIELD].name, 'case_definition')
self.assertEqual(common_fields[CD_FIELD].label, 'LABEL')
self.assertEqual(common_fields[CD_FIELD].show('case'), False)
self.assertEqual(common_fields[CD_FIELD].show('search'), True)
self.assertEqual(common_fields[CD_FIELD].show('person'), False)
# Syndrome-specific fields with common override
demogfields.flush()
synd_fields = demogfields.get_demog_fields(self.db, 1)
self.assertEqual(synd_fields[CD_FIELD].name, 'case_definition')
self.assertEqual(synd_fields[CD_FIELD].label, 'LABEL')
self.assertEqual(synd_fields[CD_FIELD].show('case'), False)
self.assertEqual(synd_fields[CD_FIELD].show('search'), True)
self.assertEqual(synd_fields[CD_FIELD].show('person'), False)
# Now check Syndrome-specific with Syndrome-specific override
self.execute('INSERT INTO %s (syndrome_id, name, label, show_search)'
' VALUES (%%s, %%s, %%s, %%s)',
(1, 'case_definition', 'FROG', False))
demogfields.flush()
synd_fields = demogfields.get_demog_fields(self.db, 1)
self.assertEqual(synd_fields[CD_FIELD].name, 'case_definition')
self.assertEqual(synd_fields[CD_FIELD].label, 'FROG')
self.assertEqual(synd_fields[CD_FIELD].show('case'), True)
self.assertEqual(synd_fields[CD_FIELD].show('search'), False)
self.assertEqual(synd_fields[CD_FIELD].show('person'), False)
# And verify common values have not changed
demogfields.flush()
common_fields = demogfields.get_demog_fields(self.db, None)
self.assertEqual(common_fields[CD_FIELD].name, 'case_definition')
self.assertEqual(common_fields[CD_FIELD].label, 'LABEL')
self.assertEqual(common_fields[CD_FIELD].show('case'), False)
self.assertEqual(common_fields[CD_FIELD].show('search'), True)
self.assertEqual(common_fields[CD_FIELD].show('person'), False)
def context_field_api(self):
def _field_api(field):
self.failUnless(hasattr(field, 'context'))
self.failUnless(hasattr(field, 'disabled'))
self.failUnless(hasattr(field, 'entity'))
self.failUnless(hasattr(field, 'field'))
self.failUnless(hasattr(field, 'hideable'))
self.failUnless(hasattr(field, 'label'))
self.failUnless(hasattr(field, 'name'))
self.failUnless(hasattr(field, 'render'))
self.failUnless(hasattr(field, 'section'))
fields = demogfields.get_demog_fields(self.db, None)
for context in demogfields.contexts:
for field in fields.context_fields(context):
_field_api(field)
def summary(self):
fields = demogfields.get_demog_fields(globals.db, self.syndrome_id)
fields = fields.reordered_context_fields(self.rp.initial_cols,
'result')
return fields.summary(self.case_row)
def demogfield(self, name):
if self._demogfields is None:
self._demogfields = {}
for field in demogfields.get_demog_fields(globals.db, None):
self._demogfields[field.name] = field
return self._demogfields[name]
def demogfield(self, name):
if self._demogfields is None:
self._demogfields = {}
for field in demogfields.get_demog_fields(globals.db, None):
self._demogfields[field.name] = field
return self._demogfields[name]
def demogfields(self):
return demogfields.get_demog_fields(globals.db, self.syndrome_id)
def demogfields(self):
fields = demogfields.get_demog_fields(globals.db, None)
return [fields.field_by_name(field) for field in self.fields]
def get_demog_fields(self, context):
disabled = self.viewonly() or bool(self.person.data_src)
syndrome_id = self.case_row.syndrome_id
fields = demogfields.get_demog_fields(globals.db, syndrome_id)
return fields.context_fields(context, disabled=disabled)
def field_label(self, field):
# get_demog_fields() and field_by_name() internally cache lookups
demog_fields = demogfields.get_demog_fields(globals.db,
self.case_row.syndrome_id)
return demog_fields.field_by_name(field).label
def page_display(ctx):
fields = demogfields.get_demog_fields(globals.db, None)
ctx.locals.case_id_label = fields.field_by_name('case_id').label
ctx.run_template('manualdupe.html')
def demog_fields(self, context=None):
fields = demogfields.get_demog_fields(globals.db, self.syndrome_id)
if context is not None:
fields = fields.context_fields(context)
return fields
def page_display(ctx):
fields = demogfields.get_demog_fields(globals.db, None)
ctx.locals.case_id_label = fields.field_by_name('case_id').label
ctx.run_template('manualdupe.html')
def demogfields(self):
return demogfields.get_demog_fields(globals.db, self.syndrome_id)
def get_demog_fields(self, context):
disabled = self.viewonly() or bool(self.person.data_src)
syndrome_id = self.case_row.syndrome_id
fields = demogfields.get_demog_fields(globals.db, syndrome_id)
return fields.context_fields(context, disabled=disabled)
def summary(self, order=None):
from casemgr import demogfields
fields = demogfields.get_demog_fields(globals.db, None)
fields = fields.reordered_context_fields(order, 'result')
return fields.summary(self)
def field_label(self, field):
# get_demog_fields() and field_by_name() internally cache lookups
demog_fields = demogfields.get_demog_fields(globals.db,
self.case_row.syndrome_id)
return demog_fields.field_by_name(field).label
def summary(self):
fields = demogfields.get_demog_fields(globals.db, self.syndrome_id)
fields = fields.reordered_context_fields(self.rp.initial_cols, 'result')
return fields.summary(self.case_row)