def setup_intervention_qbs(self, intervention=None):
if not intervention:
intervention = Intervention(name='symptom tracker',
description='test')
with SessionScope(db):
db.session.add(intervention)
db.session.commit()
eq5d = self.add_questionnaire(name='eq5d')
epic26 = self.add_questionnaire(name='epic26')
recur6 = Recur(start='{"months": 3, "weeks": -2}',
cycle_length='{"months": 6}',
termination='{"months": 27}')
exists = Recur.query.filter_by(start=recur6.start,
cycle_length=recur6.cycle_length,
termination=recur6.termination).first()
if exists:
recur6 = exists
with SessionScope(db):
db.session.add(eq5d)
db.session.add(epic26)
db.session.add(recur6)
db.session.commit()
intervention, eq5d, epic26, recur6 = map(
db.session.merge, (intervention, eq5d, epic26, recur6))
qb_base = QuestionnaireBank(name='Symptom Tracker Baseline',
classification='baseline',
intervention_id=intervention.id,
start='{"days": 0}',
expired='{"months": 3, "days": -14}')
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qbq2 = QuestionnaireBankQuestionnaire(questionnaire=eq5d, rank=1)
qb_base.questionnaires.append(qbq)
qb_base.questionnaires.append(qbq2)
qb_r6 = QuestionnaireBank(name='Symptom Tracker Recurring',
classification='recurring',
intervention_id=intervention.id,
start='{"days": 0}',
expired='{"months": 3}',
recurs=[recur6])
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qbq2 = QuestionnaireBankQuestionnaire(questionnaire=eq5d, rank=1)
qb_r6.questionnaires.append(qbq)
qb_r6.questionnaires.append(qbq2)
with SessionScope(db):
db.session.add(qb_base)
db.session.add(qb_r6)
db.session.commit()
return db.session.merge(intervention)
def test_qb_pre_retired(self):
# Confirm backdating returns the correct QB
weekago = now - timedelta(days=7)
org, rpv3, rpv3_id = self.setup_org_n_rp(rp_name='v3')
org, rpv2, rpv2_id = self.setup_org_n_rp(org=org,
rp_name='v2',
retired_as_of=weekago)
qn3 = self.add_questionnaire(name='epic26-v3')
qn2 = self.add_questionnaire(name='epic26-v2')
qb3 = QuestionnaireBank(name='Test Questionnaire Bank v3',
classification='baseline',
research_protocol_id=rpv3_id,
start='{"days": 0}',
overdue='{"days": 7}',
expired='{"days": 90}')
qbq3 = QuestionnaireBankQuestionnaire(questionnaire=qn3, rank=0)
qb3.questionnaires.append(qbq3)
qb2 = QuestionnaireBank(name='Test Questionnaire Bank v2',
classification='baseline',
research_protocol_id=rpv2_id,
start='{"days": 0}',
overdue='{"days": 7}',
expired='{"days": 90}')
qbq2 = QuestionnaireBankQuestionnaire(questionnaire=qn2, rank=0)
qb2.questionnaires.append(qbq2)
self.test_user.organizations.append(org)
audit = Audit(user_id=TEST_USER_ID, subject_id=TEST_USER_ID)
uc = UserConsent(user_id=TEST_USER_ID,
organization=org,
audit=audit,
agreement_url='http://no.com')
with SessionScope(db):
map(db.session.add, (qb2, qb3))
db.session.add(audit)
db.session.add(uc)
db.session.commit()
user, org, qb2, qb3 = map(db.session.merge,
(self.test_user, org, qb2, qb3))
# w/o backdating, should get current QB
self.assertEqual(
qb3,
QuestionnaireBank.most_current_qb(
user, as_of_date=now).questionnaire_bank)
# backdate prior to retirement of previous, should get the previous QB
pre_retirement = weekago - timedelta(days=1)
self.assertEqual(
qb2,
QuestionnaireBank.most_current_qb(
user, as_of_date=pre_retirement).questionnaire_bank)
def test_lookup_with_intervention(self):
intv = Intervention(name='TEST', description='Test Intervention')
epic26 = Questionnaire(name='epic26')
eproms_add = Questionnaire(name='eproms_add')
with SessionScope(db):
db.session.add(intv)
db.session.add(epic26)
db.session.add(eproms_add)
db.session.commit()
intv, epic26, eproms_add = map(db.session.merge,
(intv, epic26, eproms_add))
bank = QuestionnaireBank(name='CRV', intervention_id=intv.id)
for rank, q in enumerate((epic26, eproms_add)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
days_till_due=7,
days_till_overdue=90,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user.interventions.append(intv)
with SessionScope(db):
db.session.add(bank)
db.session.commit()
# User associated with INTV intervention should generate appropriate
# questionnaires
self.test_user = db.session.merge(self.test_user)
qd = QuestionnaireDetails(self.test_user, datetime.utcnow())
results = list(qd.baseline())
self.assertEquals(2, len(results))
# confirm rank sticks
self.assertEquals(results[0]['name'], 'epic26')
self.assertEquals(results[1]['name'], 'eproms_add')
def test_lookup_with_intervention(self):
intv = Intervention(name='TEST', description='Test Intervention')
epic26 = self.add_questionnaire(name='epic26')
eproms_add = self.add_questionnaire(name='eproms_add')
with SessionScope(db):
db.session.add(intv)
db.session.commit()
intv, epic26, eproms_add = map(db.session.merge,
(intv, epic26, eproms_add))
bank = QuestionnaireBank(name='CRV',
intervention_id=intv.id,
start='{"days": 7}',
expired='{"days": 90}')
for rank, q in enumerate((epic26, eproms_add)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user.interventions.append(intv)
self.login()
self.add_required_clinical_data()
with SessionScope(db):
db.session.add(bank)
db.session.commit()
# User associated with INTV intervention should generate appropriate
# questionnaires
self.test_user = db.session.merge(self.test_user)
qb = QuestionnaireBank.most_current_qb(
self.test_user, as_of_date=now).questionnaire_bank
results = list(qb.questionnaires)
self.assertEqual(2, len(results))
def test_lookup_for_user(self):
crv, rp, rp_id = self.setup_org_n_rp(org_name='CRV')
epic26 = self.add_questionnaire(name='epic26')
eproms_add = self.add_questionnaire(name='eproms_add')
comorb = self.add_questionnaire(name='comorb')
crv, epic26, eproms_add, comorb = map(
db.session.merge, (crv, epic26, eproms_add, comorb))
bank = QuestionnaireBank(name='CRV',
research_protocol_id=rp_id,
start='{"days": 7}',
expired='{"days": 90}')
for rank, q in enumerate((epic26, eproms_add, comorb)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user.organizations.append(crv)
self.consent_with_org(org_id=crv.id)
with SessionScope(db):
db.session.add(bank)
db.session.commit()
# User associated with CRV org should generate appropriate
# questionnaires
self.test_user = db.session.merge(self.test_user)
qb = QuestionnaireBank.most_current_qb(
self.test_user, as_of_date=now).questionnaire_bank
results = list(qb.questionnaires)
self.assertEqual(3, len(results))
# confirm rank sticks
self.assertEqual(results[0].name, 'epic26')
self.assertEqual(results[2].name, 'comorb')
def test_org_trigger_date(self):
# testing org-based QBs
org, rp, rp_id = self.setup_org_n_rp()
q = self.add_questionnaire(name='q')
q, org, self.test_user = map(db.session.merge,
(q, org, self.test_user))
qb = QuestionnaireBank(name='qb',
research_protocol_id=rp_id,
classification='baseline',
start='{"days": 1}',
expired='{"days": 2}')
qbq = QuestionnaireBankQuestionnaire(rank=0, questionnaire=q)
qb.questionnaires.append(qbq)
# user without consents or TX date should return None
assert not trigger_date(self.test_user)
# user with consent should return consent date
self.consent_with_org(org.id, setdate=now)
self.test_user = db.session.merge(self.test_user)
assert trigger_date(self.test_user) == now
assert trigger_date(self.test_user, qb) == now
# user with consent and TX date should return TX date (if qb.recurs)
tx_date = datetime(2017, 6, 10, 20, 00, 00, 000000)
self.add_procedure(code='7',
display='Focal therapy',
system=ICHOM,
setdate=tx_date)
self.test_user = db.session.merge(self.test_user)
recur = Recur(start='{"months": 3}',
cycle_length='{"months": 6}',
termination='{"months": 24}')
qb.recurs.append(recur)
assert trigger_date(self.test_user, qb) == tx_date
def test_lookup_with_intervention(self):
intv = Intervention(name='TEST', description='Test Intervention')
epic26 = self.add_questionnaire(name='epic26')
eproms_add = self.add_questionnaire(name='eproms_add')
with SessionScope(db):
db.session.add(intv)
db.session.commit()
intv, epic26, eproms_add = map(db.session.merge,
(intv, epic26, eproms_add))
bank = QuestionnaireBank(name='CRV',
intervention_id=intv.id,
start='{"days": 7}',
expired='{"days": 90}')
for rank, q in enumerate((epic26, eproms_add)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user.interventions.append(intv)
self.login()
self.add_required_clinical_data()
with SessionScope(db):
db.session.add(bank)
db.session.commit()
# Patient associated with INTV intervention should generate appropriate
# questionnaires as of start date
self.promote_user(role_name=ROLE.PATIENT.value)
self.test_user = db.session.merge(self.test_user)
qb_status = QB_Status(self.test_user,
as_of_date=now + relativedelta(days=8))
qb = qb_status.current_qbd().questionnaire_bank
results = list(qb.questionnaires)
assert len(results) == 2
def setup_qb(self,
questionnaire_name,
qb_name,
classification,
rp_id,
expired=None):
"""Shortcut to setup a testing QB with given values
Sets up a single qb with a single questionnaire for given
classification and research_protocol
"""
if expired is None:
expired = '{"days": 90}'
qn = self.add_questionnaire(questionnaire_name)
qb = QuestionnaireBank(name=qb_name,
classification=classification,
research_protocol_id=rp_id,
start='{"days": 0}',
expired=expired)
qbq = QuestionnaireBankQuestionnaire(questionnaire=qn, rank=0)
qb.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(qb)
db.session.commit()
return db.session.merge(qb)
def test_serialize(self):
q1 = Questionnaire(name='q1')
q2 = Questionnaire(name='q2')
org = Organization(name='org')
with SessionScope(db):
db.session.add(q1)
db.session.add(q2)
db.session.add(org)
db.session.commit()
q1, q2, org = map(db.session.merge, (q1, q2, org))
qb = QuestionnaireBank(name='qb',
organization_id=org.id,
classification='baseline')
for rank, q in enumerate((q1, q2)):
qbq = QuestionnaireBankQuestionnaire(days_till_due=5,
days_till_overdue=30,
rank=rank,
questionnaire=q)
qb.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(qb)
db.session.commit()
qb = db.session.merge(qb)
data = qb.as_json()
self.assertEquals('QuestionnaireBank', data.get('resourceType'))
self.assertEquals(2, len(data['questionnaires']))
def test_overdue_stats(self):
self.promote_user(user=self.test_user, role_name=ROLE.PATIENT.value)
rp = ResearchProtocol(name='proto')
with SessionScope(db):
db.session.add(rp)
db.session.commit()
rp = db.session.merge(rp)
rp_id = rp.id
crv = Organization(name='CRV')
crv.research_protocols.append(rp)
epic26 = self.add_questionnaire(name='epic26')
with SessionScope(db):
db.session.add(crv)
db.session.commit()
crv, epic26 = map(db.session.merge, (crv, epic26))
crv_id = crv.id
bank = QuestionnaireBank(name='CRV',
research_protocol_id=rp_id,
start='{"days": 1}',
overdue='{"days": 2}',
expired='{"days": 90}')
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=epic26.id,
rank=0)
bank.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(bank)
db.session.commit()
self.test_user = db.session.merge(self.test_user)
self.test_user.organizations.append(crv)
self.consent_with_org(org_id=crv_id)
self.test_user = db.session.merge(self.test_user)
# test user with status = 'Expired' (should not show up)
a_s = QB_Status(self.test_user, as_of_date=datetime.utcnow())
assert a_s.overall_status == OverallStatus.expired
ostats = self.get_ostats()
assert len(ostats) == 0
# test user with status = 'Overdue' (should show up)
self.consent_with_org(org_id=crv_id, backdate=relativedelta(days=18))
with SessionScope(db):
db.session.add(bank)
db.session.commit()
crv, self.test_user = map(db.session.merge, (crv, self.test_user))
invalidate_users_QBT(self.test_user.id)
a_s = QB_Status(self.test_user, as_of_date=datetime.utcnow())
assert a_s.overall_status == OverallStatus.overdue
ostats = self.get_ostats()
assert len(ostats) == 1
assert ostats[(crv.id, crv.name)] == [(15, TEST_USER_ID)]
def test_submit_assessment_for_qb(self):
swagger_spec = swagger(self.app)
data = swagger_spec['definitions']['QuestionnaireResponse']['example']
rp = ResearchProtocol(name='proto')
with SessionScope(db):
db.session.add(rp)
db.session.commit()
rp = db.session.merge(rp)
rp_id = rp.id
qn = self.add_questionnaire(name='epic26')
org = Organization(name="testorg")
org.research_protocols.append(rp)
with SessionScope(db):
db.session.add(qn)
db.session.add(org)
db.session.commit()
qn, org = map(db.session.merge, (qn, org))
qb = QuestionnaireBank(name='Test Questionnaire Bank',
classification='baseline',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 7}',
expired='{"days": 90}')
qbq = QuestionnaireBankQuestionnaire(questionnaire=qn, rank=0)
qb.questionnaires.append(qbq)
test_user = get_user(TEST_USER_ID)
test_user.organizations.append(org)
audit = Audit(user_id=TEST_USER_ID, subject_id=TEST_USER_ID)
uc = UserConsent(user_id=TEST_USER_ID,
organization=org,
audit=audit,
agreement_url='http://no.com')
with SessionScope(db):
db.session.add(qb)
db.session.add(test_user)
db.session.add(audit)
db.session.add(uc)
db.session.commit()
qb = db.session.merge(qb)
self.login()
response = self.client.post(
'/api/patient/{}/assessment'.format(TEST_USER_ID),
content_type='application/json',
data=json.dumps(data),
)
assert response.status_code == 200
test_user = get_user(TEST_USER_ID)
assert test_user.questionnaire_responses.count() == 1
assert test_user.questionnaire_responses[0].questionnaire_bank_id ==\
qb.id
def mock_tnth_questionnairebanks():
for name in (symptom_tracker_instruments):
TestCase.add_questionnaire(name=name)
# Symptom Tracker Baseline
self_management = INTERVENTION.SELF_MANAGEMENT
st_qb = QuestionnaireBank(
name='symptom_tracker',
classification='baseline',
intervention_id=self_management.id,
start='{"days": 0}',
expired='{"months": 3}'
)
for rank, instrument in enumerate(symptom_tracker_instruments):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
st_qb.questionnaires.append(qbq)
# Symptom Tracker Recurrence
st_recur = Recur(
start='{"months": 3}', cycle_length='{"months": 3}',
termination='{"months": 27}')
with SessionScope(db):
db.session.add(st_qb)
db.session.add(st_recur)
db.session.commit()
self_management = INTERVENTION.SELF_MANAGEMENT
st_recur_qb = QuestionnaireBank(
name='symptom_tracker_recurring',
classification='recurring',
intervention_id=self_management.id,
start='{"days": 0}',
expired='{"months": 3}',
recurs=[st_recur]
)
for rank, instrument in enumerate(symptom_tracker_instruments):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
st_recur_qb.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(st_recur_qb)
db.session.commit()
def test_questionnaire_banks_recurs(self):
# set up a few recurring instances
initial_recur = Recur(days_to_start=90,
days_in_cycle=90,
days_till_termination=720)
every_six_thereafter = Recur(days_to_start=720, days_in_cycle=180)
metastatic_org = Organization(name='metastatic')
questionnaire = Questionnaire(name='test_q')
with SessionScope(db):
db.session.add(initial_recur)
db.session.add(every_six_thereafter)
db.session.add(metastatic_org)
db.session.add(questionnaire)
db.session.commit()
initial_recur = db.session.merge(initial_recur)
every_six_thereafter = db.session.merge(every_six_thereafter)
metastatic_org_id = db.session.merge(metastatic_org).id
# with bits in place, setup a recurring QB
mr_qb = QuestionnaireBank(name='metastatic_recurring',
classification='recurring',
organization_id=metastatic_org_id)
questionnaire = db.session.merge(questionnaire)
recurs = [initial_recur, every_six_thereafter]
qbq = QuestionnaireBankQuestionnaire(questionnaire=questionnaire,
days_till_due=1,
days_till_overdue=30,
rank=1,
recurs=recurs)
mr_qb.questionnaires.append(qbq)
# confirm persistence of this questionnaire bank includes the bits
# added above
results = mr_qb.as_json()
copy = QuestionnaireBank.from_json(results)
self.assertEquals(copy.name, mr_qb.name)
copy_q = copy.questionnaires[0]
self.assertEquals(copy_q.recurs, [initial_recur, every_six_thereafter])
# now, modify the persisted form, remove one recur and add another
new_recur = Recur(days_to_start=900,
days_in_cycle=180,
days_till_termination=1800)
results['questionnaires'][0]['recurs'] = [
initial_recur.as_json(),
new_recur.as_json()
]
updated_copy = QuestionnaireBank.from_json(results)
self.assertEquals(
[r.as_json() for r in updated_copy.questionnaires[0].recurs],
[r.as_json() for r in (initial_recur, new_recur)])
def test_overdue_stats(self):
self.promote_user(user=self.test_user, role_name=ROLE.PATIENT.value)
rp = ResearchProtocol(name='proto')
with SessionScope(db):
db.session.add(rp)
db.session.commit()
rp = db.session.merge(rp)
rp_id = rp.id
crv = Organization(name='CRV')
crv.research_protocols.append(rp)
epic26 = self.add_questionnaire(name='epic26')
with SessionScope(db):
db.session.add(crv)
db.session.commit()
crv, epic26 = map(db.session.merge, (crv, epic26))
bank = QuestionnaireBank(name='CRV',
research_protocol_id=rp_id,
start='{"days": 1}',
overdue='{"days": 2}',
expired='{"days": 90}')
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=epic26.id,
rank=0)
bank.questionnaires.append(qbq)
self.test_user = db.session.merge(self.test_user)
# test user with status = 'Expired' (should not show up)
a_s = AssessmentStatus(self.test_user, as_of_date=datetime.utcnow())
self.assertEqual(a_s.overall_status, 'Expired')
ostats = self.get_ostats()
self.assertEqual(len(ostats), 0)
# test user with status = 'Overdue' (should show up)
self.test_user.organizations.append(crv)
self.consent_with_org(org_id=crv.id, backdate=relativedelta(days=18))
with SessionScope(db):
db.session.add(bank)
db.session.commit()
crv, self.test_user = map(db.session.merge, (crv, self.test_user))
a_s = AssessmentStatus(self.test_user, as_of_date=datetime.utcnow())
self.assertEqual(a_s.overall_status, 'Overdue')
ostats = self.get_ostats()
self.assertEqual(len(ostats), 1)
self.assertEqual(ostats[crv], [15])
def test_intervention_trigger_date(self):
# testing intervention-based QBs
q = self.add_questionnaire('q')
interv = Intervention(name='interv', description='test')
with SessionScope(db):
db.session.add(interv)
db.session.commit()
q, interv, self.test_user = map(db.session.merge,
(q, interv, self.test_user))
qb = QuestionnaireBank(name='qb',
intervention_id=interv.id,
classification='baseline',
start='{"days": 1}',
expired='{"days": 2}')
qbq = QuestionnaireBankQuestionnaire(rank=0, questionnaire=q)
qb.questionnaires.append(qbq)
# user without biopsy or TX date should return None
self.assertFalse(qb.trigger_date(self.test_user))
# user with biopsy should return biopsy date
self.login()
self.test_user.save_observation(codeable_concept=CC.BIOPSY,
value_quantity=CC.TRUE_VALUE,
audit=Audit(user_id=TEST_USER_ID,
subject_id=TEST_USER_ID),
status='',
issued=None)
self.test_user = db.session.merge(self.test_user)
obs = self.test_user.observations.first()
self.assertEqual(obs.codeable_concept.codings[0].display, 'biopsy')
self.assertEqual(qb.trigger_date(self.test_user), obs.issued)
# user with biopsy and TX date should return TX date
tx_date = datetime.utcnow()
self.add_procedure(code='7',
display='Focal therapy',
system=ICHOM,
setdate=tx_date)
self.test_user = db.session.merge(self.test_user)
qb.__trigger_date = None # clear out stored trigger_date
self.assertEqual(qb.trigger_date(self.test_user), tx_date)
def test_start(self):
org, rp, rp_id = self.setup_org_n_rp()
q = self.add_questionnaire('q')
q, org = map(db.session.merge, (q, org))
qb = QuestionnaireBank(name='qb',
research_protocol_id=rp_id,
classification='baseline',
start='{"days": 1}',
expired='{"days": 2}')
qbq = QuestionnaireBankQuestionnaire(rank=0, questionnaire=q)
qb.questionnaires.append(qbq)
trigger_date = datetime.strptime('2000-01-01', '%Y-%m-%d')
start = qb.calculated_start(trigger_date).relative_start
assert start > trigger_date
assert start == datetime.strptime('2000-01-02', '%Y-%m-%d')
end = qb.calculated_expiry(start)
expected_expiry = datetime.strptime('2000-01-04', '%Y-%m-%d')
assert end == expected_expiry
def test_lookup_for_user(self):
crv, rp, rp_id = self.setup_org_n_rp(org_name='CRV')
epic26 = self.add_questionnaire(name='epic26')
eproms_add = self.add_questionnaire(name='eproms_add')
comorb = self.add_questionnaire(name='comorb')
crv, epic26, eproms_add, comorb = map(
db.session.merge, (crv, epic26, eproms_add, comorb))
bank = QuestionnaireBank(name='CRV',
research_protocol_id=rp_id,
start='{"days": 7}',
expired='{"days": 90}')
for rank, q in enumerate((epic26, eproms_add, comorb)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user = db.session.merge(self.test_user)
self.test_user.organizations.append(crv)
self.consent_with_org(org_id=crv.id, setdate=now)
self.promote_user(role_name=ROLE.PATIENT.value)
with SessionScope(db):
db.session.add(bank)
db.session.commit()
# User associated with CRV org should generate appropriate
# questionnaires
self.test_user = db.session.merge(self.test_user)
# Doesn't start for 7 days, initially shouldn't get any
qb_stat = QB_Status(user=self.test_user, as_of_date=now)
assert qb_stat.current_qbd() is None
qb_stat = QB_Status(user=self.test_user,
as_of_date=now + relativedelta(days=7))
qb = qb_stat.current_qbd().questionnaire_bank
results = list(qb.questionnaires)
assert len(results) == 3
# confirm rank sticks
assert results[0].name == 'epic26'
assert results[2].name == 'comorb'
def test_questionnaire_gets(self):
crv, rp, rp_id = self.setup_org_n_rp(org_name='CRV')
epic26 = self.add_questionnaire(name='epic26')
eproms_add = self.add_questionnaire(name='eproms_add')
comorb = self.add_questionnaire(name='comorb')
crv, epic26, eproms_add, comorb = map(
db.session.merge, (crv, epic26, eproms_add, comorb))
resp = self.client.get('/api/questionnaire')
assert resp.status_code == 200
assert len(resp.json['entry']) == 3
assert all(('resource' in entry for entry in resp.json['entry']))
resp = self.client.get('/api/questionnaire/{}?system={}'.format(
'epic26', TRUENTH_QUESTIONNAIRE_CODE_SYSTEM))
assert resp.status_code == 200
q_ids = [
ident for ident in resp.json['identifier']
if ident['system'] == TRUENTH_QUESTIONNAIRE_CODE_SYSTEM
]
assert len(q_ids) == 1
assert q_ids[0]['value'] == 'epic26'
bank = QuestionnaireBank(name='CRV',
research_protocol_id=rp_id,
start='{"days": 7}',
expired='{"days": 90}')
for rank, q in enumerate((epic26, eproms_add, comorb)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user = db.session.merge(self.test_user)
self.test_user.organizations.append(crv)
with SessionScope(db):
db.session.add(bank)
db.session.commit()
resp = self.client.get('/api/questionnaire_bank')
assert resp.status_code == 200
assert len(resp.json['entry'][0]['resource']['questionnaires']) == 3
def test_due(self):
org, rp, rp_id = self.setup_org_n_rp()
q = self.add_questionnaire('q')
q, org = map(db.session.merge, (q, org))
qb = QuestionnaireBank(name='qb',
research_protocol_id=rp_id,
classification='baseline',
start='{"days": 1}',
due='{"days": 2}')
qbq = QuestionnaireBankQuestionnaire(rank=0, questionnaire=q)
qb.questionnaires.append(qbq)
trigger_date = datetime.strptime('2000-01-01', '%Y-%m-%d')
now = datetime.now()
start = qb.calculated_start(trigger_date,
as_of_date=now).relative_start
self.assertTrue(start > trigger_date)
self.assertEqual(start, datetime.strptime('2000-01-02', '%Y-%m-%d'))
due = qb.calculated_due(trigger_date, as_of_date=now)
expected_due = datetime.strptime('2000-01-04', '%Y-%m-%d')
self.assertEqual(due, expected_due)
def test_serialize(self):
org, rp, rp_id = self.setup_org_n_rp()
q1 = self.add_questionnaire(name='q1')
q2 = self.add_questionnaire(name='q2')
q1, q2, org = map(db.session.merge, (q1, q2, org))
qb = QuestionnaireBank(name='qb',
research_protocol_id=rp_id,
classification='baseline',
start='{"days": 0}',
overdue='{"days": 5}',
expired='{"days": 30}')
for rank, q in enumerate((q1, q2)):
qbq = QuestionnaireBankQuestionnaire(rank=rank, questionnaire=q)
qb.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(qb)
db.session.commit()
qb = db.session.merge(qb)
data = qb.as_json()
assert 'QuestionnaireBank' == data.get('resourceType')
assert len(data['questionnaires']) == 2
def test_questionnaire_gets(self):
crv = Organization(name='CRV')
epic26 = Questionnaire(name='epic26')
eproms_add = Questionnaire(name='eproms_add')
comorb = Questionnaire(name='comorb')
with SessionScope(db):
db.session.add(crv)
db.session.add(epic26)
db.session.add(eproms_add)
db.session.add(comorb)
db.session.commit()
crv, epic26, eproms_add, comorb = map(
db.session.merge, (crv, epic26, eproms_add, comorb))
resp = self.client.get('/api/questionnaire')
self.assert200(resp)
self.assertEquals(len(resp.json['entry']), 3)
resp = self.client.get('/api/questionnaire/{}'.format('epic26'))
self.assert200(resp)
self.assertEquals(resp.json['questionnaire']['name'], 'epic26')
bank = QuestionnaireBank(name='CRV', organization_id=crv.id)
for rank, q in enumerate((epic26, eproms_add, comorb)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
days_till_due=7,
days_till_overdue=90,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user.organizations.append(crv)
with SessionScope(db):
db.session.add(bank)
db.session.commit()
resp = self.client.get('/api/questionnaire_bank')
self.assert200(resp)
self.assertEquals(len(resp.json['entry'][0]['questionnaires']), 3)
def test_intervention_in_progress(self):
# testing intervention-based QBs
q = self.add_questionnaire('q')
interv = Intervention(name='interv', description='test')
with SessionScope(db):
db.session.add(interv)
db.session.commit()
q, interv, self.test_user = map(db.session.merge,
(q, interv, self.test_user))
qb = QuestionnaireBank(name='qb',
intervention_id=interv.id,
classification='baseline',
start='{"days": 0}',
expired='{"days": 2}')
qbq = QuestionnaireBankQuestionnaire(rank=0, questionnaire=q)
qb.questionnaires.append(qbq)
# user with biopsy should return biopsy date
self.login()
self.test_user.save_observation(codeable_concept=CC.BIOPSY,
value_quantity=CC.TRUE_VALUE,
audit=Audit(user_id=TEST_USER_ID,
subject_id=TEST_USER_ID),
status='',
issued=now)
self.promote_user(role_name=ROLE.PATIENT.value)
self.test_user = db.session.merge(self.test_user)
obs = self.test_user.observations.first()
assert obs.codeable_concept.codings[0].display == 'biopsy'
assert trigger_date(self.test_user, qb) == obs.issued
# add mock in-process QB - confirm current qb is still correct
mock_qr('q', 'in-progress', qb=qb)
self.test_user, qb = map(db.session.merge, (self.test_user, qb))
qb_stat = QB_Status(user=self.test_user, as_of_date=now)
assert qb_stat.current_qbd().questionnaire_bank == qb
def test_lookup_for_user(self):
crv = Organization(name='CRV')
epic26 = Questionnaire(name='epic26')
eproms_add = Questionnaire(name='eproms_add')
comorb = Questionnaire(name='comorb')
with SessionScope(db):
db.session.add(crv)
db.session.add(epic26)
db.session.add(eproms_add)
db.session.add(comorb)
db.session.commit()
crv, epic26, eproms_add, comorb = map(
db.session.merge, (crv, epic26, eproms_add, comorb))
bank = QuestionnaireBank(name='CRV', organization_id=crv.id)
for rank, q in enumerate((epic26, eproms_add, comorb)):
qbq = QuestionnaireBankQuestionnaire(questionnaire_id=q.id,
days_till_due=7,
days_till_overdue=90,
rank=rank)
bank.questionnaires.append(qbq)
self.test_user.organizations.append(crv)
with SessionScope(db):
db.session.add(bank)
db.session.commit()
# User associated with CRV org should generate appropriate
# questionnaires
self.test_user = db.session.merge(self.test_user)
qd = QuestionnaireDetails(self.test_user, datetime.utcnow())
results = list(qd.baseline())
self.assertEquals(3, len(results))
# confirm rank sticks
self.assertEquals(results[0]['name'], 'epic26')
self.assertEquals(results[2]['name'], 'comorb')
def test_questionnaire_banks_recurs(self):
# only one recurrence per qb allowed at this time
initial_recur = Recur(start='{"days": 90}',
cycle_length='{"days": 90}',
termination='{"days": 720}')
every_six_thereafter = Recur(start='{"days": 720}',
cycle_length='{"days": 180}')
rp = ResearchProtocol(name='proto')
with SessionScope(db):
db.session.add(rp)
db.session.commit()
rp = db.session.merge(rp)
rp_id = rp.id
metastatic_org = Organization(name='metastatic')
metastatic_org.research_protocols.append(rp)
questionnaire = self.add_questionnaire(name='test_q')
with SessionScope(db):
db.session.add(initial_recur)
db.session.add(every_six_thereafter)
db.session.add(metastatic_org)
db.session.add(questionnaire)
db.session.commit()
initial_recur = db.session.merge(initial_recur)
every_six_thereafter = db.session.merge(every_six_thereafter)
# with bits in place, setup a recurring QB
recurs = [initial_recur, every_six_thereafter]
mr_qb = QuestionnaireBank(name='metastatic_recurring',
classification='recurring',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 1}',
expired='{"days": 30}',
recurs=recurs)
questionnaire = db.session.merge(questionnaire)
qbq = QuestionnaireBankQuestionnaire(questionnaire=questionnaire,
rank=1)
mr_qb.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(mr_qb)
db.session.commit()
mr_qb, initial_recur, every_six_thereafter = map(
db.session.merge, (mr_qb, initial_recur, every_six_thereafter))
# confirm persistence of this questionnaire bank includes the bits
# added above
results = mr_qb.as_json()
copy = QuestionnaireBank.from_json(results)
assert copy.name == mr_qb.name
assert copy.recurs == [initial_recur, every_six_thereafter]
# now, modify the persisted form, remove one recur and add another
new_recur = Recur(start='{"days": 900}',
cycle_length='{"days": 180}',
termination='{"days": 1800}')
results['recurs'] = [initial_recur.as_json(), new_recur.as_json()]
updated_copy = QuestionnaireBank.from_json(results)
assert ([r.as_json() for r in updated_copy.recurs
] == [r.as_json() for r in (initial_recur, new_recur)])
def mock_questionnairebanks():
# Define test Orgs and QuestionnaireBanks for each group
localized_org = Organization(name='localized')
metastatic_org = Organization(name='metastatic')
# Recurring assessments every 3 months up to 24 months, then every
# 6 months prems alternate with epic26 - start with prems
initial_recur = Recur(days_to_start=90,
days_in_cycle=90,
days_till_termination=720)
initial_recur_prems = Recur(days_to_start=90,
days_in_cycle=180,
days_till_termination=720)
initial_recur_epic26 = Recur(days_to_start=180,
days_in_cycle=180,
days_till_termination=720)
every_six_thereafter = Recur(days_to_start=720, days_in_cycle=180)
every_six_thereafter_prems = Recur(days_to_start=720, days_in_cycle=360)
every_six_thereafter_epic26 = Recur(days_to_start=900, days_in_cycle=360)
with SessionScope(db):
for name in (localized_instruments.union(
*(metastatic_baseline_instruments,
metastatic_indefinite_instruments,
metastatic_recurring_instruments))):
db.session.add(Questionnaire(name=name))
db.session.add(localized_org)
db.session.add(metastatic_org)
db.session.add(initial_recur)
db.session.add(initial_recur_prems)
db.session.add(initial_recur_epic26)
db.session.add(every_six_thereafter)
db.session.add(every_six_thereafter_prems)
db.session.add(every_six_thereafter_epic26)
db.session.commit()
localized_org, metastatic_org = map(db.session.merge,
(localized_org, metastatic_org))
localized_org_id = localized_org.id
metastatic_org_id = metastatic_org.id
initial_recur = db.session.merge(initial_recur)
initial_recur_prems = db.session.merge(initial_recur_prems)
initial_recur_epic26 = db.session.merge(initial_recur_epic26)
every_six_thereafter = db.session.merge(every_six_thereafter)
every_six_thereafter_prems = db.session.merge(every_six_thereafter_prems)
every_six_thereafter_epic26 = db.session.merge(every_six_thereafter_epic26)
# Localized baseline
l_qb = QuestionnaireBank(name='localized',
classification='baseline',
organization_id=localized_org_id)
for rank, instrument in enumerate(localized_instruments):
q = Questionnaire.query.filter_by(name=instrument).one()
qbq = QuestionnaireBankQuestionnaire(questionnaire=q,
days_till_due=7,
days_till_overdue=90,
rank=rank)
l_qb.questionnaires.append(qbq)
# Metastatic baseline
mb_qb = QuestionnaireBank(name='metastatic',
classification='baseline',
organization_id=metastatic_org_id)
for rank, instrument in enumerate(metastatic_baseline_instruments):
q = Questionnaire.query.filter_by(name=instrument).one()
qbq = QuestionnaireBankQuestionnaire(questionnaire=q,
days_till_due=1,
days_till_overdue=30,
rank=rank)
mb_qb.questionnaires.append(qbq)
# Metastatic indefinite
mi_qb = QuestionnaireBank(name='metastatic_indefinite',
classification='indefinite',
organization_id=metastatic_org_id)
for rank, instrument in enumerate(metastatic_indefinite_instruments):
q = Questionnaire.query.filter_by(name=instrument).one()
qbq = QuestionnaireBankQuestionnaire(questionnaire=q,
days_till_due=1,
days_till_overdue=3000,
rank=rank)
mi_qb.questionnaires.append(qbq)
# Metastatic recurring
mr_qb = QuestionnaireBank(name='metastatic_recurring',
classification='recurring',
organization_id=metastatic_org_id)
for rank, instrument in enumerate(metastatic_recurring_instruments):
q = Questionnaire.query.filter_by(name=instrument).one()
if instrument == 'prems':
recurs = [initial_recur_prems, every_six_thereafter_prems]
elif instrument == 'epic26':
recurs = [initial_recur_epic26, every_six_thereafter_epic26]
else:
recurs = [initial_recur, every_six_thereafter]
qbq = QuestionnaireBankQuestionnaire(questionnaire=q,
days_till_due=1,
days_till_overdue=30,
rank=rank,
recurs=recurs)
mr_qb.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(l_qb)
db.session.add(mb_qb)
db.session.add(mi_qb)
db.session.add(mr_qb)
db.session.commit()
def setup_qbs(self, org=None, rp_name='v2', retired_as_of=None):
org, rp, rp_id = self.setup_org_n_rp(org=org,
org_name='CRV',
rp_name=rp_name,
retired_as_of=retired_as_of)
epic26 = self.add_questionnaire(name='epic26_{}'.format(rp_name))
recur3 = Recur(start='{"months": 3}',
cycle_length='{"months": 6}',
termination='{"months": 24}')
exists = Recur.query.filter_by(start=recur3.start,
cycle_length=recur3.cycle_length,
termination=recur3.termination).first()
if exists:
recur3 = exists
recur6 = Recur(start='{"months": 6}',
cycle_length='{"years": 1}',
termination='{"years": 3, "months": 3}')
exists = Recur.query.filter_by(start=recur6.start,
cycle_length=recur6.cycle_length,
termination=recur6.termination).first()
if exists:
recur6 = exists
with SessionScope(db):
db.session.add(epic26)
db.session.add(recur3)
db.session.add(recur6)
db.session.commit()
org, epic26, recur3, recur6 = map(db.session.merge,
(org, epic26, recur3, recur6))
qb_base = QuestionnaireBank(name='CRV Baseline {}'.format(rp_name),
classification='baseline',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}')
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qb_base.questionnaires.append(qbq)
qb_m3 = QuestionnaireBank(
name='CRV_recurring_3mo_period {}'.format(rp_name),
classification='recurring',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}',
recurs=[recur3])
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qb_m3.questionnaires.append(qbq)
qb_m6 = QuestionnaireBank(
name='CRV_recurring_6mo_period {}'.format(rp_name),
classification='recurring',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}',
recurs=[recur6])
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qb_m6.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(qb_base)
db.session.add(qb_m3)
db.session.add(qb_m6)
db.session.commit()
qb_base, qb_m3, qb_m6 = map(db.session.merge, (qb_base, qb_m3, qb_m6))
return db.session.merge(org)
def test_outdated_inprogress_qb(self):
# create base QB/RP
org, rp, rp_id = self.setup_org_n_rp(org_name='testorg')
qn = self.add_questionnaire(name='epic26')
qn, org, self.test_user = map(db.session.merge,
(qn, org, self.test_user))
org_id = org.id
qb = QuestionnaireBank(name='Test Questionnaire Bank',
classification='baseline',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 7}',
expired='{"days": 90}')
qbq = QuestionnaireBankQuestionnaire(questionnaire=qn, rank=0)
qb.questionnaires.append(qbq)
self.test_user.organizations.append(org)
self.promote_user(role_name=ROLE.PATIENT.value)
audit = Audit(user_id=TEST_USER_ID, subject_id=TEST_USER_ID)
uc = UserConsent(user_id=TEST_USER_ID,
organization=org,
audit=audit,
agreement_url='http://no.com',
acceptance_date=now)
with SessionScope(db):
db.session.add(qb)
db.session.add(self.test_user)
db.session.add(audit)
db.session.add(uc)
db.session.commit()
qb = db.session.merge(qb)
# create in-progress QNR for User/QB/RP
mock_qr(instrument_id='epic26',
status='in-progress',
timestamp=now,
qb=qb)
# User associated with CRV org should generate appropriate
# questionnaires
self.test_user = db.session.merge(self.test_user)
qb_stat = QB_Status(self.test_user, now)
qb = qb_stat.current_qbd().questionnaire_bank
assert qb.research_protocol.name == 'proto'
# Pointing the User's org to a new QB/RP
# marking the old RP as retired as of yesterday
old_rp = OrganizationResearchProtocol.query.filter(
OrganizationResearchProtocol.organization_id == org_id,
OrganizationResearchProtocol.research_protocol_id == rp_id).one()
old_rp.retired_as_of = now - timedelta(days=1)
rp2 = ResearchProtocol(name='new_proto')
qn2 = self.add_questionnaire(name='epic27')
with SessionScope(db):
db.session.add(rp2)
db.session.commit()
rp2 = db.session.merge(rp2)
rp2_id = rp2.id
qn2, org = map(db.session.merge, (qn2, org))
qb2 = QuestionnaireBank(name='Test Questionnaire Bank 2',
classification='baseline',
research_protocol_id=rp2_id,
start='{"days": 0}',
overdue='{"days": 7}',
expired='{"days": 90}')
qbq2 = QuestionnaireBankQuestionnaire(questionnaire=qn2, rank=0)
qb2.questionnaires.append(qbq2)
org.research_protocols.append(rp2)
with SessionScope(db):
db.session.add(qb2)
db.session.add(org)
db.session.commit()
qb2 = db.session.merge(qb2)
# outdated QB/RP should be used as long as User has in-progress QNR
self.test_user = db.session.merge(self.test_user)
qb_stat = QB_Status(self.test_user, now)
qb = qb_stat.current_qbd().questionnaire_bank
assert qb.name == 'Test Questionnaire Bank'
assert qb.research_protocol.name == 'proto'
# completing QNR should result in completed status
# shouldn't pick up new protocol till next iteration
mock_qr(instrument_id='epic26',
status='completed',
timestamp=now,
qb=qb)
self.test_user = db.session.merge(self.test_user)
invalidate_users_QBT(TEST_USER_ID)
qb_stat = QB_Status(self.test_user, now)
qb = qb_stat.current_qbd().questionnaire_bank
assert qb.name == 'Test Questionnaire Bank'
assert qb_stat.overall_status == OverallStatus.completed
def setup_org_qbs(self,
org=None,
rp_name='v2',
retired_as_of=None,
include_indef=False):
org_name = org.name if org else 'CRV'
org, rp, rp_id = self.setup_org_n_rp(org=org,
org_name=org_name,
rp_name=rp_name,
retired_as_of=retired_as_of)
# enable re-entrance - if first q exists, probably a second
# org is being setup - return as the rest is done
q_name = 'eortc_{}'.format(rp_name)
for q in Questionnaire.query.all():
if q.name == q_name:
return
eortc = self.add_questionnaire(name=q_name)
epic26 = self.add_questionnaire(name='epic26_{}'.format(rp_name))
recur3 = Recur(start='{"months": 3}',
cycle_length='{"months": 6}',
termination='{"months": 24}')
exists = Recur.query.filter_by(start=recur3.start,
cycle_length=recur3.cycle_length,
termination=recur3.termination).first()
if exists:
recur3 = exists
recur6 = Recur(start='{"months": 6}',
cycle_length='{"years": 1}',
termination='{"years": 3, "months": 3}')
exists = Recur.query.filter_by(start=recur6.start,
cycle_length=recur6.cycle_length,
termination=recur6.termination).first()
if exists:
recur6 = exists
with SessionScope(db):
db.session.add(eortc)
db.session.add(epic26)
db.session.add(recur3)
db.session.add(recur6)
db.session.commit()
org, eortc, epic26, recur3, recur6 = map(
db.session.merge, (org, eortc, epic26, recur3, recur6))
qb_base = QuestionnaireBank(name='{} Baseline {}'.format(
org_name, rp_name),
classification='baseline',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}')
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qbq2 = QuestionnaireBankQuestionnaire(questionnaire=eortc, rank=1)
qb_base.questionnaires.append(qbq)
qb_base.questionnaires.append(qbq2)
qb_m3 = QuestionnaireBank(name='{}_recurring_3mo_period {}'.format(
org_name, rp_name),
classification='recurring',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}',
recurs=[recur3])
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qbq2 = QuestionnaireBankQuestionnaire(questionnaire=eortc, rank=1)
qb_m3.questionnaires.append(qbq)
qb_m3.questionnaires.append(qbq2)
qb_m6 = QuestionnaireBank(name='{}_recurring_6mo_period {}'.format(
org_name, rp_name),
classification='recurring',
research_protocol_id=rp_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}',
recurs=[recur6])
qbq = QuestionnaireBankQuestionnaire(questionnaire=epic26, rank=0)
qbq2 = QuestionnaireBankQuestionnaire(questionnaire=eortc, rank=1)
qb_m6.questionnaires.append(qbq)
qb_m6.questionnaires.append(qbq2)
with SessionScope(db):
db.session.add(qb_base)
db.session.add(qb_m3)
db.session.add(qb_m6)
db.session.commit()
if include_indef:
self.setup_qb(questionnaire_name='irondemog_{}'.format(rp_name),
qb_name='indef_{}'.format(rp_name),
classification='indefinite',
rp_id=rp_id,
expired="{\"years\": 50}")
return db.session.merge(org)
def mock_eproms_questionnairebanks():
# Define base ResearchProtocols
localized_protocol = ResearchProtocol(name='localized_protocol')
metastatic_protocol = ResearchProtocol(name='metastatic_protocol')
with SessionScope(db):
db.session.add(localized_protocol)
db.session.add(metastatic_protocol)
db.session.commit()
localized_protocol = db.session.merge(localized_protocol)
metastatic_protocol = db.session.merge(metastatic_protocol)
locpro_id = localized_protocol.id
metapro_id = metastatic_protocol.id
# Define test Orgs and QuestionnaireBanks for each group
localized_org = Organization(name='localized')
localized_org.research_protocols.append(localized_protocol)
metastatic_org = Organization(name='metastatic')
metastatic_org.research_protocols.append(metastatic_protocol)
# from https://docs.google.com/spreadsheets/d/\
# 1oJ8HKfMHOdXkSshjRlr8lFXxT4aUHX5ntxnKMgf50wE/edit#gid=1339608238
three_q_recur = Recur(start='{"months": 3}',
cycle_length='{"months": 6}',
termination='{"months": 24}')
four_q_recur1 = Recur(start='{"months": 6}',
cycle_length='{"years": 1}',
termination='{"months": 21}')
four_q_recur2 = Recur(start='{"months": 30}',
cycle_length='{"years": 1}',
termination='{"months": 33}')
six_q_recur = Recur(start='{"years": 1}',
cycle_length='{"years": 1}',
termination='{"years": 3, "months": 3}')
for name in (localized_instruments.union(
*(metastatic_baseline_instruments,
metastatic_indefinite_instruments, metastatic_3, metastatic_4,
metastatic_6))):
TestCase.add_questionnaire(name=name)
with SessionScope(db):
db.session.add(localized_org)
db.session.add(metastatic_org)
db.session.add(three_q_recur)
db.session.add(four_q_recur1)
db.session.add(four_q_recur2)
db.session.add(six_q_recur)
db.session.commit()
localized_org, metastatic_org = map(db.session.merge,
(localized_org, metastatic_org))
three_q_recur = db.session.merge(three_q_recur)
four_q_recur1 = db.session.merge(four_q_recur1)
four_q_recur2 = db.session.merge(four_q_recur2)
six_q_recur = db.session.merge(six_q_recur)
# Localized baseline
l_qb = QuestionnaireBank(name='localized',
classification='baseline',
research_protocol_id=locpro_id,
start='{"days": 0}',
overdue='{"days": 7}',
expired='{"months": 3}')
for rank, instrument in enumerate(localized_instruments):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
l_qb.questionnaires.append(qbq)
# Metastatic baseline
mb_qb = QuestionnaireBank(name='metastatic',
classification='baseline',
research_protocol_id=metapro_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}')
for rank, instrument in enumerate(metastatic_baseline_instruments):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
mb_qb.questionnaires.append(qbq)
# Metastatic indefinite
mi_qb = QuestionnaireBank(name='metastatic_indefinite',
classification='indefinite',
research_protocol_id=metapro_id,
start='{"days": 0}',
expired='{"years": 50}')
for rank, instrument in enumerate(metastatic_indefinite_instruments):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
mi_qb.questionnaires.append(qbq)
# Metastatic recurring 3
mr3_qb = QuestionnaireBank(name='metastatic_recurring3',
classification='recurring',
research_protocol_id=metapro_id,
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}',
recurs=[three_q_recur])
for rank, instrument in enumerate(metastatic_3):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
mr3_qb.questionnaires.append(qbq)
# Metastatic recurring 4
mr4_qb = QuestionnaireBank(name='metastatic_recurring4',
classification='recurring',
research_protocol_id=metapro_id,
recurs=[four_q_recur1, four_q_recur2],
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}')
for rank, instrument in enumerate(metastatic_4):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
mr4_qb.questionnaires.append(qbq)
# Metastatic recurring 6
mr6_qb = QuestionnaireBank(name='metastatic_recurring6',
classification='recurring',
research_protocol_id=metapro_id,
recurs=[six_q_recur],
start='{"days": 0}',
overdue='{"days": 30}',
expired='{"months": 3}')
for rank, instrument in enumerate(metastatic_6):
q = Questionnaire.find_by_name(name=instrument)
qbq = QuestionnaireBankQuestionnaire(questionnaire=q, rank=rank)
mr6_qb.questionnaires.append(qbq)
with SessionScope(db):
db.session.add(l_qb)
db.session.add(mb_qb)
db.session.add(mi_qb)
db.session.add(mr3_qb)
db.session.add(mr4_qb)
db.session.add(mr6_qb)
db.session.commit()