def setUp(self):
"""
Setup an example users generator instance so can use the record
"""
gen = UsersGenerator({})
gen.generate_adt_user()
self.record = gen.class_data.findall('record')[0]
def test_multi_wards_with_all_multi_ward_user(self):
"""
Test that when only one user is a multiward user that only one record
is generated
"""
schema = {"ward_manager": {"total": 2, "per_ward": 1, "unassigned": 0, "multi_wards": "all"}}
gen = UsersGenerator(schema)
gen.generate_multi_wards_users(["a", "b"])
xml = gen.class_data
records = xml.findall("record")
self.assertEqual(len(records), 2, "Incorrect number of records")
multi_record_one = records[0]
multi_record_two = records[1]
one_locations = multi_record_one.find("field[@name='location_ids']")
two_locations = multi_record_two.find("field[@name='location_ids']")
self.assertEqual(
one_locations.attrib["eval"],
"[[6, False, [ref('nhc_def_conf_location_wa')," "ref('nhc_def_conf_location_wb')]]]",
"Incorrect Location ids for multiple wards",
)
self.assertEqual(
two_locations.attrib["eval"],
"[[6, False, [ref('nhc_def_conf_location_wa')," "ref('nhc_def_conf_location_wb')]]]",
"Incorrect Location ids for multiple wards",
)
def test_multi_wards_with_all_multi_ward_user(self):
"""
Test that when only one user is a multiward user that only one record
is generated
"""
schema = {
'ward_manager': {
'total': 2,
'per_ward': 0,
'unassigned': 2,
'multi_wards': 'all'
}
}
gen = UsersGenerator(schema)
gen.generate_users_not_assigned()
xml = gen.class_data
records = xml.findall('record')
self.assertEqual(len(records), 2, 'Incorrect number of records')
unassigned_record_one = records[0]
unassigned_record_two = records[1]
one_locations = \
unassigned_record_one.find('field[@name=\'location_ids\']')
two_locations = \
unassigned_record_two.find('field[@name=\'location_ids\']')
self.assertEqual(
one_locations.attrib['eval'], '[[6, False, []]]',
'Incorrect Location ids for multiple wards'
)
self.assertEqual(
two_locations.attrib['eval'], '[[6, False, []]]',
'Incorrect Location ids for multiple wards'
)
def test_unassigned_with_empty_user_schema(self):
"""
Test that multiwards doesn't do anything if no user schema defined
"""
gen = UsersGenerator({})
gen.generate_users_not_assigned()
xml = gen.class_data
records = xml.findall('record')
self.assertEqual(len(records), 0, 'Incorrect number of records')
def test_multi_wards_with_empty_user_schema(self):
"""
Test that multiwards doesn't do anything if no user schema defined
"""
gen = UsersGenerator({})
gen.generate_multi_wards_users(["a", "b", "c", "d", "e"])
xml = gen.class_data
records = xml.findall("record")
self.assertEqual(len(records), 0, "Incorrect number of records")
def test_users_per_ward_with_empty_user_schema(self):
"""
Test that doesn't do anything if no user schema defined
"""
gen = UsersGenerator({})
doc = gen.generate_users_per_ward('a', 666)
xml = doc.findall('data')[0]
records = xml.findall('record')
self.assertEqual(len(records), 0, 'Incorrect number of records')
def test_get_role(self):
hca = "[(4, ref('nh_clinical.role_nhc_hca'))]"
basic_schema = {'hca': {'total': 1, 'per_ward': 1, 'unassigned': 0}}
gen = UsersGenerator(basic_schema)
doc = gen.generate_users_per_ward('a', 2)
user = doc.findall(".//record/[@model='res.users']")[0]
role = get_role(user)
self.assertEqual(role, hca)
def test_bed_number_method(self):
"""
Test that the bed number generator works
"""
gen = UsersGenerator({})
bed_number_gen = gen.get_beds_number_generator(2)
bed_number_first = bed_number_gen.next()
bed_number_last = bed_number_gen.next()
self.assertEqual(bed_number_first, 1, 'Incorrect first generator call')
self.assertEqual(bed_number_last, 2, 'Incorrect last generator call')
def test_create_adt_user(self):
"""
Test that the class has a means of creating the ADT user
"""
gen = UsersGenerator({})
gen.generate_adt_user()
records = gen.class_data.findall('record')
self.assertEqual(len(records), 1, 'Incorrect number of records')
adt_record = records[0]
login = adt_record.find('field[@name=\'login\']')
self.assertEqual(login.text, 'adt', 'Incorrect login name')
def setUp(self):
"""
Setup an example users generator instance so can use the record
"""
john_schema = { # http://cdn.makeagif.com/media/9-13-2015/28JfPx.gif
"nurse": {"total": 1, "per_ward": 0, "unassigned": 1, "multi_wards": [[]]}
}
gen = UsersGenerator(john_schema)
gen.names_generators["nurse"] = (n for n in ["Nadine"])
gen.generate_users_not_assigned()
self.record = gen.class_data.findall("record")[0]
def test_get_hca_nurse_users(self):
basic_schema = {
'hca': {'total': 1, 'per_ward': 1, 'unassigned': 0},
'nurse': {'total': 1, 'per_ward': 1, 'unassigned': 0}
}
gen = UsersGenerator(basic_schema)
doc = gen.generate_users_per_ward('a', 2)
user_ids = get_hca_nurse_users(doc)
self.assertEqual(len(user_ids), 2)
def test_user_per_ward_with_no_user_per_ward(self):
"""
Test that doesn't do anything if no users by ward
"""
basic_schema = {
'hca': {
'total': 666,
'per_ward': 0,
'unassigned': 666,
}
}
gen = UsersGenerator(basic_schema)
doc = gen.generate_users_per_ward('a', 666)
xml = doc.findall('data')[0]
records = xml.findall('record')
self.assertEqual(len(records), 0, 'Incorrect number of records')
def setUp(self):
"""
Setup an example users generator instance so can use the record
"""
john_schema = { # http://cdn.makeagif.com/media/9-13-2015/28JfPx.gif
'ward_manager': {
'total': 1,
'per_ward': 1,
'unassigned': 0,
'multi_wards': [['a', 'b']]
}
}
gen = UsersGenerator(john_schema)
gen.names_generators['ward_manager'] = (n for n in ['Waino'])
gen.generate_multi_wards_users(['a'])
self.record = gen.class_data.findall('record')[0]
def setUp(self):
"""
Setup an example users generator instance so can use the record
"""
john_schema = { # http://cdn.makeagif.com/media/9-13-2015/28JfPx.gif
'nurse': {
'total': 1,
'per_ward': 1,
'unassigned': 0,
'multi_wards': [[]]
}
}
gen = UsersGenerator(john_schema)
gen.names_generators['nurse'] = (n for n in ['Nadine'])
users = gen.generate_users_per_ward('a', 1)
self.record = users.find('data').findall('record')[0]
def test_unassigned_without_unassigned_users(self):
"""
Test that when only one user is a multiward user that only one record
is generated
"""
schema = {
'ward_manager': {
'total': 2,
'per_ward': 1,
'unassigned': 0,
'multi_wards': [['a', 'b'], []]
}
}
gen = UsersGenerator(schema)
gen.generate_users_not_assigned()
xml = gen.class_data
records = xml.findall('record')
self.assertEqual(len(records), 0, 'Incorrect number of records')
def test_user_per_ward_with_non_bed_ward_assignable_user(self):
"""
Test that assigns user to bed when bed assignable
"""
basic_schema = {
'senior_manager': {
'total': 1,
'per_ward': 1,
'unassigned': 0,
}
}
gen = UsersGenerator(basic_schema)
doc = gen.generate_users_per_ward('a', 2)
xml = doc.findall('data')[0]
records = xml.findall('record')
self.assertEqual(len(records), 1, 'Incorrect number of records')
record = records[0]
location = record.find('field[@name=\'location_ids\']')
self.assertEqual(
location.attrib['eval'],
'[[6, False, []]]',
'Incorrect Location ids for user per ward'
)
def __init__(self, wards, beds_per_ward, bed_patient_per_ward,
non_bed_patient_per_ward, users_schema, data_folder):
total_patients_per_ward = \
bed_patient_per_ward + non_bed_patient_per_ward
patient_id_offset = 1
# wards = ['a', 'b', 'c', 'd', 'e']
# bed_patients_per_ward = 28
# non_bed_patients_per_ward = 12
# List of time periods to randomly offset admissions
self.admit_offset_list = ['-1', '-2']
self.admit_date_eval_string = '(datetime.now() + timedelta({0}))' \
'.strftime(\'%Y-%m-%d %H:%M:%S\')'
# Regex to use to get the ID for a patient from id attribute on record
patient_id_regex_string = r'nhc_demo_patient_(\d+)'
self.patient_id_regex = re.compile(patient_id_regex_string)
point_of_service = POSGenerator()
self.indent(point_of_service.root)
users_tree = ElementTree(point_of_service.root)
users_tree.write(os.path.join(data_folder, 'pos.xml'))
users_generator = UsersGenerator(users_schema)
users_generator.generate_adt_user()
users_generator.generate_multi_wards_users(wards)
users_generator.generate_users_not_assigned()
self.indent(users_generator.class_root)
users_tree = ElementTree(users_generator.class_root)
users_tree.write(os.path.join(data_folder, 'users.xml'))
# Generate demo data for each ward,
# with files named after different type of data,
# grouped in one folder for each ward
self.ews_seq = 0
self.assess_seq = 0
self.medical_seq = 0
for index, ward in enumerate(wards):
# Locations demo data
locations = LocationsGenerator(ward, beds_per_ward)
# Users demo data
users_per_ward_root = users_generator.generate_users_per_ward(
ward, beds_per_ward)
# Patients demo data
patients = PatientsGenerator(
(index * total_patients_per_ward) + patient_id_offset,
bed_patient_per_ward,
non_bed_patient_per_ward,
ward
)
offsets = [random.choice(
self.admit_offset_list) for _ in range(
len(patients.data.findall('record')))]
# Spells demo data
spells = SpellsGenerator(patients, offsets)
# Admissions demo data
admissions = AdmissionsGenerator(patients, offsets)
# Placements demo data
placements = PlacementsGenerator(patients, offsets)
# Strategy
risk_distribution = {
'high': 0, 'medium': 2, 'low': 11, 'none': 15
}
# 50% observations are overdue by default
overdue_ratio = 0.5
# all overdue observations are within 30 mins overdue
overdue_distribution = [30]
if index == 0:
# ICU
risk_distribution = {
'high': 3, 'medium': 4, 'low': 20, 'none': 1
}
elif index == 1:
# 75% observations are overdue, 1/3 overdue by 60 mins, the
# rest overdue by, at most, 30 mins
overdue_ratio = 0.75
overdue_distribution = [30, 30, 60]
risk_distribution = {
'high': 0, 'medium': 0, 'low': 20, 'none': 8
}
elif index == 4:
# all observations are on-time
overdue_ratio = 0
risk_distribution = {
'high': 0, 'medium': 0, 'low': 0, 'none': 28
}
news_patients = patients_factory(placements.root)
hca_nurse_ids = get_hca_nurse_users(users_per_ward_root)
partial_news_per_patient = 1
# create ward strategy here
ward_strategy = WardStrategy(
news_patients, hca_nurse_ids, risk_distribution,
partial_news_per_patient, overdue_ratio, overdue_distribution
)
# NEWS demo data
news = NewsGenerator(ward_strategy, self.ews_seq, self.assess_seq,
self.medical_seq)
self.ews_seq = news.ews_seq
self.assess_seq = news.assess_seq
self.medical_seq = news.medical_seq
# Pretty format the XML trees
self.indent(locations.root)
self.indent(users_per_ward_root)
self.indent(patients.root)
self.indent(spells.root)
self.indent(admissions.root)
self.indent(placements.root)
self.indent(news.root)
# Actually write the XML files (creating them if needed)
ward_folder = os.path.join(data_folder, 'ward_{0}'.format(ward))
if not os.path.isdir(ward_folder):
os.mkdir(ward_folder)
locations_tree = ElementTree(locations.root)
locations_tree.write(os.path.join(ward_folder,
'demo_locations.xml'))
users_per_ward_tree = ElementTree(users_per_ward_root)
users_per_ward_tree.write(os.path.join(ward_folder,
'demo_users.xml'))
patients_tree = ElementTree(patients.root)
patients_tree.write(os.path.join(ward_folder, 'demo_patients.xml'))
spells_tree = ElementTree(spells.root)
spells_tree.write(os.path.join(ward_folder, 'demo_spells.xml'))
admissions_tree = ElementTree(admissions.root)
admissions_tree.write(os.path.join(ward_folder,
'demo_admissions.xml'))
placements_tree = ElementTree(placements.root)
placements_tree.write(os.path.join(ward_folder,
'demo_placements.xml'))
news_tree = ElementTree(news.root)
news_tree.write(os.path.join(ward_folder, 'demo_news.xml'))
