def proc_persons(options, cred, persons):
"""
Person-based import - one or more <Case> elements inside a <Cases>
element inside each <Person>
"""
ticker = Ticker('cases')
for person_elem in persons:
try:
assert_tag(person_elem, 'Person')
cases_elem = want_elem(person_elem, 'Cases')
person_id = None
for case_elem in cases_elem.getchildren():
assert_tag(case_elem, 'Case')
synd = find_syndrome(case_elem.get('syndrome'))
case = cases.new_case(cred, synd.syndrome_id,
use_person_id=person_id)
if person_id is None:
copy_node(person_elem, case.person)
case.person.data_src = options.data_src
case.update()
if person_id is None:
person_id = case.case_row.person_id
proc_forms(options, synd, case, case_elem)
ticker.tick()
except Exception, e:
dump(person_elem)
raise
cmdcommon.abort(e)
def __init__(self, credentials, syndrome_id, dataimp_src, importrules):
ImportBase.__init__(self, syndrome_id, dataimp_src, importrules)
self.rows = []
self.header = []
self.group_header = []
if self.errors:
return
for group in self.groups:
self.group_header.append((group.label, len(group)))
self.header.extend(group.headings())
self.n_cols = len(self.header)
try:
for row in self.dataimp_rows:
case = cases.new_case(credentials,
self.syndrome_id,
defer_case_id=True)
row_pp = []
for group in self.groups:
row_pp.extend(group.preview(self, case, row))
self.rows.append(row_pp)
except TooManyErrors:
pass
except Error, e:
# For aborting errors
self.error(e)
def main(args):
user = raw_input('%s Username: '******'SARS'][0]
for record in xrange(int(args[0])):
case = cases.new_case(cred, synd.syndrome_id, None)
random_person(case.person)
case.update()
globals.db.commit()
def main(args):
r = Random()
db = schema.define_db()
cred = credentials.Credentials()
cred.set_user(db, 'andrewm')
cred.get_units(db)
cred.set_unit(db, 0)
cred.authenticate_user(db, 'andrewm')
synd = [s for s in syndrome.get_syndromes(db, cred) if s.name == 'SARS'][0]
for filename in args:
f = open(filename)
testrecs = []
for rec in csv_load.load(f):
testrecs.append(rec)
f.close()
testrecs_len = len(testrecs)
try:
count = 0
while count < testrecs_len:
record = testrecs[count]
count += 1
print count
case = cases.new_case(db, cred, synd)
d = str(datetime.datetime.now()).split()[0].split("-")
t = str(datetime.datetime.now()).split()[1].split(":")[:-1]
case.case_row.onset_datetime = d[2] + "/" + d[1] + "/" + d[0] + " " + t[0] + ":" + t[1]
xform_person(record, case.person_row,r)
case.update(db)
for i in range(Random().choice([0,1,2,3,4,5,6,7,8910,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25])):
mycontacts = contact.Contacts(db,case)
mycontact = mycontacts.new_contact(db)
record = testrecs[count]
count += 1
xform_person(record,mycontact.person_row,r)
d = str(datetime.datetime.now()).split()[0].split("-")
t = str(datetime.datetime.now()).split()[1].split(":")[:-1]
mycontact.contact_row.contact_date = d[2] + "/" + d[1] + "/" + d[0] + " " + t[0] + ":" + t[1]
"""
fu = contact.Followup(case,mycontact,db.new_row('followup_summary'))
fu.get_form_ui(db)
fu.followup_row = db.new_row(fu.form_ui.table)
fu.followup_row.contact_id = mycontact.contact_row.contact_id
fu.followuo_row.contact_date = ':'.join(str(datetime.datetime.now() - datetime.timedelta(2)).split(':')[:-1])
fu.summary.contact_id = mycontact.contact_row.contact_id
# self.summary.summary = ', '.join(summary).capitalize()
fu.summary.form_date = fu.followup_row.form_date
fu.summary.db_update()
fu.followup_row.followup_summary_id =fu.summary.followup_summary_id
fu.followup_row.db_update()
"""
mycontact.update()
db.commit()
finally:
f.close()
def main(args):
user = raw_input('%s Username: '******'SARS'][0]
for record in xrange(int(args[0])):
case = cases.new_case(cred, synd.syndrome_id, None)
random_person(case.person)
case.update()
globals.db.commit()
def proc_cases(options, cred, cases):
"""
Case-based import - single <Person> element contained within each <Case>
"""
ticker = Ticker('cases')
for case_elem in cases:
try:
assert_tag(case_elem, 'Case')
person_elem = want_elem(case_elem, 'Person')
synd = find_syndrome(case_elem.get('syndrome'))
case = cases.new_case(cred, synd.syndrome_id)
copy_node(person_elem, case.person)
case.person.data_src = options.data_src
case.update()
proc_forms(options, synd, case, case_elem)
except Exception, e:
dump(case_elem)
raise
cmdcommon.abort(e)
ticker.tick()
def __init__(self, credentials, syndrome_id, dataimp_src, importrules):
ImportBase.__init__(self, syndrome_id, dataimp_src, importrules)
if self.errors:
return
self.update_cnt = self.new_cnt = self.conflict_cnt = 0
try:
for row in self.dataimp_rows:
case = None
dup_person_id = None
if self.key_proc is not None:
key = self.key_proc.get(row)
# XXX We may get a dbapi.IntegrityError exception here,
# because the local_case_id column does not have a unique
# constraint, and this query may return multiple rows - how
# to fix?
try:
case = cases.case_query(credentials,
syndrome_id=self.syndrome_id,
local_case_id=key)
except dbobj.IntegrityError:
self.error('%r %s is not unique' % (self.key_proc.label, key))
continue
if (case is not None
and case.person.data_src != self.importrules.srclabel):
if self.importrules.conflicts == 'duplicate':
dup_person_id = case.person.person_id
case = None
else:
self.locked_cases.append(key)
continue
if case is None:
case = cases.new_case(credentials, self.syndrome_id,
defer_case_id=False)
case.person.data_src = self.importrules.srclabel
self.new_cnt += 1
else:
self.update_cnt += 1
for group in self.groups:
group.update(self, case, row)
if dup_person_id is not None:
persondupe.conflict(dup_person_id, case.person.person_id)
self.conflict_cnt += 1
self.status = ('Loaded %d records, updated %d, created %d' %
(self.update_cnt + self.new_cnt,
self.update_cnt, self.new_cnt))
if self.importrules.conflicts == 'duplicate' and self.conflict_cnt:
self.status += ' (%s duplicates created)' % self.conflict_cnt
except TooManyErrors:
pass
except Error, e:
self.error(e)
def __init__(self, credentials, syndrome_id, dataimp_src, importrules):
ImportBase.__init__(self, syndrome_id, dataimp_src, importrules)
self.rows = []
self.header = []
self.group_header = []
if self.errors:
return
for group in self.groups:
self.group_header.append((group.label, len(group)))
self.header.extend(group.headings())
self.n_cols = len(self.header)
try:
for row in self.dataimp_rows:
case = cases.new_case(credentials, self.syndrome_id,
defer_case_id=True)
row_pp = []
for group in self.groups:
row_pp.extend(group.preview(self, case, row))
self.rows.append(row_pp)
except TooManyErrors:
pass
except Error, e:
# For aborting errors
self.error(e)
except dbobj.IntegrityError:
self.error('%r %s is not unique' %
(self.key_proc.label, key))
continue
if (case is not None
and case.person.data_src != self.importrules.srclabel):
if self.importrules.conflicts == 'duplicate':
dup_person_id = case.person.person_id
case = None
else:
self.locked_cases.append(key)
continue
if case is None:
case = cases.new_case(credentials,
self.syndrome_id,
defer_case_id=False)
case.person.data_src = self.importrules.srclabel
self.new_cnt += 1
else:
self.update_cnt += 1
for group in self.groups:
group.update(self, case, row)
if dup_person_id is not None:
persondupe.conflict(dup_person_id, case.person.person_id)
self.conflict_cnt += 1
self.status = ('Loaded %d records, updated %d, created %d' %
(self.update_cnt + self.new_cnt, self.update_cnt,
self.new_cnt))
if self.importrules.conflicts == 'duplicate' and self.conflict_cnt:
self.status += ' (%s duplicates created)' % self.conflict_cnt
def precreate_case(ctx, case):
if config.immediate_create:
try:
log = case.db_desc()
case.update()
case.user_log(log)
globals.db.commit()
ctx.add_message('Case created')
except dbobj.DatabaseError, e:
globals.db.rollback()
ctx.add_error(e)
def new_case(ctx, syndrome_id, **kw):
case = cases.new_case(ctx.locals._credentials, syndrome_id, **kw)
precreate_case(ctx, case)
return case
def go_id(ctx, id):
"""
Given a check-digit protected entity ID, load the appropriate object
and push the appropriate edit page.
"""
if not id:
return
if id.isdigit():
id = int(id)
case = cases.edit_case(ctx.locals._credentials, id)
ctx.locals.caseset = None
def new_case(ctx, syndrome_id, **kw):
case = cases.new_case(ctx.locals._credentials, syndrome_id, **kw)
precreate_case(ctx, case)
return case