def testInsert_rightParticipantId(self):
self._make_summary()
summary = ParticipantSummaryDao().get(self.participant.participantId)
self.assertIsNone(summary.physicalMeasurementsStatus)
with FakeClock(TIME_2):
measurements = self.dao.insert(self._make_physical_measurements())
expected_measurements = PhysicalMeasurements(
physicalMeasurementsId=1,
participantId=self.participant.participantId,
resource=self._with_id(self.measurement_json, '1'),
created=TIME_2,
finalized=TIME_1,
final=True,
logPositionId=1,
createdSiteId=1,
finalizedSiteId=2)
self.assertEquals(expected_measurements.asdict(), measurements.asdict())
measurements = self.dao.get(measurements.physicalMeasurementsId)
self.assertEquals(expected_measurements.asdict(), measurements.asdict())
# Completing physical measurements changes the participant summary status
summary = ParticipantSummaryDao().get(self.participant.participantId)
self.assertEquals(PhysicalMeasurementsStatus.COMPLETED, summary.physicalMeasurementsStatus)
self.assertEquals(TIME_2, summary.physicalMeasurementsTime)
self.assertEquals(TIME_2, summary.lastModified)
def skew_duplicate_last_modified():
"""
Query participant summary looking for duplicate lastModified dates.
If there are enough, randomly skew the milliseconds to eliminate
the duplicates.
"""
dao = ParticipantSummaryDao()
min_dups = 6
with dao.session() as session:
# Find last modified dates from participant summary where there are
# at least 6 duplicates.
sql = """
select last_modified, count from (
select last_modified, count(1) as count
from participant_summary group by last_modified order by count desc
) a where a.count > :min_dups
"""
results = session.execute(sql, {'min_dups': min_dups}).fetchall()
if results and len(results) > 0:
# loop over results and randomize only the microseconds value of the timestamp.
for rec in results:
sql = """
update participant_summary set last_modified =
date_add(date_format(last_modified, '%Y-%m-%d %H:%i:%S'),
INTERVAL (FLOOR(RAND() * 999998) + 1) MICROSECOND)
where last_modified = :ts
"""
session.execute(sql, {'ts': rec['last_modified']})
def test_end_to_end(self):
dao = BiobankStoredSampleDao()
self.assertEquals(dao.count(), 0)
# Create 3 participants and pass their (random) IDs into sample rows.
summary_dao = ParticipantSummaryDao()
biobank_ids = []
participant_ids = []
for _ in xrange(3):
participant = self.participant_dao.insert(Participant())
summary_dao.insert(self.participant_summary(participant))
participant_ids.append(participant.participantId)
biobank_ids.append(participant.biobankId)
self.assertEquals(
summary_dao.get(
participant.participantId).numBaselineSamplesArrived, 0)
test1, test2, test3 = random.sample(_BASELINE_TESTS, 3)
samples_file = test_data.open_biobank_samples(*biobank_ids,
test1=test1,
test2=test2,
test3=test3)
input_filename = 'cloud%s.csv' % self._naive_utc_to_naive_central(
clock.CLOCK.now()).strftime(
biobank_samples_pipeline.INPUT_CSV_TIME_FORMAT)
self._write_cloud_csv(input_filename, samples_file.read())
biobank_samples_pipeline.upsert_from_latest_csv()
self.assertEquals(dao.count(), 3)
self._check_summary(participant_ids[0], test1, '2016-11-29T12:19:32')
self._check_summary(participant_ids[1], test2, '2016-11-29T12:38:58')
self._check_summary(participant_ids[2], test3, '2016-11-29T12:41:26')
def setUp(self, **kwargs):
super(MetricsEhrApiTestBase, self).setUp(use_mysql=True, **kwargs)
self.dao = ParticipantDao()
self.ps_dao = ParticipantSummaryDao()
self.ehr_receipt_dao = EhrReceiptDao()
self.ps = ParticipantSummary()
self.calendar_dao = CalendarDao()
self.site_dao = SiteDao()
self.hpo_dao = HPODao()
self.org_dao = OrganizationDao()
self.hpo_test = self._make_hpo(hpoId=TEST_HPO_ID,
name=TEST_HPO_NAME,
displayName='Test',
organizationType=OrganizationType.UNSET)
self.hpo_foo = self._make_hpo(hpoId=10, name='FOO', displayName='Foo')
self.hpo_bar = self._make_hpo(hpoId=11, name='BAR', displayName='Bar')
self.org_foo_a = self._make_org(organizationId=10,
externalId='FOO_A',
displayName='Foo A',
hpoId=self.hpo_foo.hpoId)
self.org_bar_a = self._make_org(organizationId=11,
externalId='BAR_A',
displayName='Bar A',
hpoId=self.hpo_bar.hpoId)
def test_update_with_patch_cancel(self):
self._make_summary()
summary = ParticipantSummaryDao().get(self.participant.participantId)
self.assertIsNone(summary.physicalMeasurementsStatus)
with FakeClock(TIME_2):
measurements = self.dao.insert(self._make_physical_measurements())
cancel = get_restore_or_cancel_info()
with FakeClock(TIME_3):
with PhysicalMeasurementsDao().session() as session:
update = self.dao.update_with_patch(
measurements.physicalMeasurementsId, session, cancel)
self.assertEqual(update.status, PhysicalMeasurementsStatus.CANCELLED)
self.assertEqual(update.reason, cancel['reason'])
self.assertEqual(update.cancelledSiteId, 1)
self.assertEqual(update.cancelledTime, TIME_3)
self.assertEqual(update.cancelledUsername,
cancel['cancelledInfo']['author']['value'])
summary = ParticipantSummaryDao().get(self.participant.participantId)
self.assertEqual(summary.physicalMeasurementsStatus,
PhysicalMeasurementsStatus.CANCELLED)
self.assertEqual(summary.physicalMeasurementsTime, None)
self.assertEqual(summary.physicalMeasurementsFinalizedTime, TIME_1)
self.assertEqual(summary.physicalMeasurementsCreatedSiteId, 1)
self.assertEqual(summary.physicalMeasurementsFinalizedSiteId, 2)
def _update_participant_summary(self, session, obj):
participant_id = obj.participantId
if participant_id is None:
raise BadRequest('participantId is required')
participant_summary_dao = ParticipantSummaryDao()
participant = ParticipantDao().get_for_update(session, participant_id)
if not participant:
raise BadRequest(
"Can't submit physical measurements for unknown participant %s"
% participant_id)
participant_summary = participant.participantSummary
if not participant_summary:
raise BadRequest(
"Can't submit physical measurements for participant %s without consent"
% participant_id)
raise_if_withdrawn(participant_summary)
participant_summary.physicalMeasurementsTime = obj.created
participant_summary.physicalMeasurementsFinalizedTime = obj.finalized
participant_summary.physicalMeasurementsCreatedSiteId = obj.createdSiteId
participant_summary.physicalMeasurementsFinalizedSiteId = obj.finalizedSiteId
participant_summary.lastModified = clock.CLOCK.now()
if participant_summary.physicalMeasurementsStatus != PhysicalMeasurementsStatus.COMPLETED:
participant_summary.physicalMeasurementsStatus = PhysicalMeasurementsStatus.COMPLETED
participant_summary_dao.update_enrollment_status(
participant_summary)
session.merge(participant_summary)
return participant_summary
def setUp(self, use_mysql=True, with_data=True):
super(DvOrderApiTestBase, self).setUp(use_mysql=use_mysql,
with_data=with_data)
self.test_data = {
"subject": "Patient/P123456789",
"awardee": "PITT",
"organization": "PITT_BANNER_HEALTH",
"patient_status": "YES",
"user": "******",
"site": "hpo-site-monroeville",
"authored": "2019-04-26T12:11:41",
"comment": "This is comment"
}
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
self.hpo_dao = HPODao()
self.hpo = self.hpo_dao.get_by_name('PITT')
self.participant = Participant(hpoId=self.hpo.hpoId,
participantId=123456789,
biobankId=7)
self.participant_dao.insert(self.participant)
self.summary = self.participant_summary(self.participant)
self.summary_dao.insert(self.summary)
class DvOrderApiTestBase(FlaskTestBase):
mayolink_response = None
def setUp(self, use_mysql=True, with_data=True):
super(DvOrderApiTestBase, self).setUp(use_mysql=use_mysql,
with_data=with_data)
self.dv_order_dao = DvOrderDao()
self.hpo_dao = HPODao()
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
self.code_dao = CodeDao()
self.hpo = self.hpo_dao.get_by_name('PITT')
self.participant = Participant(hpoId=self.hpo.hpoId,
participantId=123456789,
biobankId=7)
self.participant_dao.insert(self.participant)
self.summary = self.participant_summary(self.participant)
self.summary_dao.insert(self.summary)
mayolinkapi_patcher = mock.patch(
'dao.dv_order_dao.MayoLinkApi',
**{'return_value.post.return_value': self.mayolink_response})
mayolinkapi_patcher.start()
self.addCleanup(mayolinkapi_patcher.stop)
def get_payload(self, filename):
return load_test_data_json(filename)
def get_orders(self):
with self.dv_order_dao.session() as session:
return list(session.query(BiobankDVOrder))
def test_cancelled_order_removes_from_participant_summary(self):
ParticipantSummaryDao().insert(self.participant_summary(self.participant))
samples = [BiobankOrderedSample(
test=self._B_TEST, processingRequired=True, description=u'new sample')]
biobank_order_id = 2
with clock.FakeClock(self.TIME_1):
order_1 = self.dao.insert(self._make_biobank_order())
with clock.FakeClock(self.TIME_2):
self.dao.insert(self._make_biobank_order(samples=samples,
biobankOrderId=biobank_order_id,
identifiers=[
BiobankOrderIdentifier(system='z',
value='x')]))
cancelled_request = self._get_cancel_patch()
ps_dao = ParticipantSummaryDao().get(self.participant.participantId)
self.assertEqual(ps_dao.sampleOrderStatus1ED10, OrderStatus.FINALIZED)
self.assertEqual(ps_dao.sampleOrderStatus1ED10Time, self.TIME_2)
self.assertEqual(ps_dao.sampleOrderStatus2ED10, OrderStatus.CREATED)
self.assertEqual(ps_dao.sampleOrderStatus2ED10Time, self.TIME_2)
self.dao.update_with_patch(order_1.biobankOrderId, cancelled_request,
order_1.version)
ps_dao = ParticipantSummaryDao().get(self.participant.participantId)
self.assertEqual(ps_dao.sampleOrderStatus1ED10, None)
self.assertEqual(ps_dao.sampleOrderStatus1ED10Time, None)
# should not remove the other order
self.assertEqual(ps_dao.sampleOrderStatus2ED10, OrderStatus.CREATED)
self.assertEqual(ps_dao.sampleOrderStatus2ED10Time, self.TIME_2)
self.assertEqual(ps_dao.biospecimenCollectedSiteId, 1)
self.assertEqual(ps_dao.biospecimenFinalizedSiteId, 2)
self.assertEqual(ps_dao.biospecimenProcessedSiteId, 1)
self.assertEqual(ps_dao.biospecimenStatus, OrderStatus.FINALIZED)
def test_validation_no_answer(self):
self.participant = Participant(participantId=123, biobankId=555)
ParticipantDao().insert(self.participant)
self.participant_id = to_client_participant_id(
self.participant.participantId)
summary = ParticipantSummaryDao().insert(
self.participant_summary(self.participant))
result = check_ppi_data_api._get_validation_result(
summary.email, {FIRST_NAME_QUESTION_CODE: 'NotAnswered'})
self.assertEquals(1, result.tests_count)
self.assertEquals(1, result.errors_count)
self.assertEquals(1, len(result.messages))
self.assertIn(FIRST_NAME_QUESTION_CODE, result.messages[0])
# test using phone number as lookup value in API.
summary.loginPhoneNumber = '5555555555'
ParticipantSummaryDao().update(summary)
result = check_ppi_data_api._get_validation_result(
summary.loginPhoneNumber,
{FIRST_NAME_QUESTION_CODE: 'NotAnswered'})
self.assertEquals(1, result.tests_count)
self.assertEquals(1, result.errors_count)
self.assertEquals(1, len(result.messages))
self.assertIn(FIRST_NAME_QUESTION_CODE, result.messages[0])
def _refresh_participant_summary(self, session, obj):
# called when cancelled/restored
participant_summary_dao = ParticipantSummaryDao()
participant_summary = participant_summary_dao.get_for_update(
session, obj.participantId)
non_cancelled_orders = self._get_non_cancelled_biobank_orders(
session, obj.participantId)
participant_summary.biospecimenStatus = OrderStatus.UNSET
participant_summary.biospecimenOrderTime = None
participant_summary.biospecimenSourceSiteId = None
participant_summary.biospecimenCollectedSiteId = None
participant_summary.biospecimenProcessedSiteId = None
participant_summary.biospecimenFinalizedSiteId = None
participant_summary.lastModified = clock.CLOCK.now()
for sample in obj.samples:
status_field = 'sampleOrderStatus' + sample.test
setattr(participant_summary, status_field, OrderStatus.UNSET)
setattr(participant_summary, status_field + 'Time', None)
if len(non_cancelled_orders) > 0:
for order in non_cancelled_orders:
self._set_participant_summary_fields(order,
participant_summary)
participant_summary_dao.update_enrollment_status(participant_summary)
def setUp(self):
super(ParticipantSummaryDaoTest, self).setUp(use_mysql=True)
self.dao = ParticipantSummaryDao()
self.order_dao = BiobankOrderDao()
self.measurement_dao = PhysicalMeasurementsDao()
self.participant_dao = ParticipantDao()
self.no_filter_query = Query([], None, 2, None)
self.one_filter_query = Query(
[FieldFilter("participantId", Operator.EQUALS, 1)], None, 2, None)
self.two_filter_query = Query([
FieldFilter("participantId", Operator.EQUALS, 1),
FieldFilter("hpoId", Operator.EQUALS, PITT_HPO_ID)
], None, 2, None)
self.ascending_biobank_id_query = Query([], OrderBy("biobankId", True),
2, None)
self.descending_biobank_id_query = Query([],
OrderBy("biobankId",
False), 2, None)
self.enrollment_status_order_query = Query([],
OrderBy(
"enrollmentStatus",
True), 2, None)
self.hpo_id_order_query = Query([], OrderBy("hpoId", True), 2, None)
self.first_name_order_query = Query([], OrderBy("firstName", True), 2,
None)
def setUp(self):
super(BiobankOrderApiTest, self).setUp()
self.participant = Participant(participantId=123, biobankId=555)
self.participant_dao = ParticipantDao()
self.participant_dao.insert(self.participant)
self.summary_dao = ParticipantSummaryDao()
self.path = ('Participant/%s/BiobankOrder' %
to_client_participant_id(self.participant.participantId))
def setUp(self, **kwargs):
super(SyncConsentFilesTest, self).setUp(use_mysql=True, **kwargs)
NdbTestBase.doSetUp(self)
TestBase.setup_fake(self)
self.org_dao = OrganizationDao()
self.site_dao = SiteDao()
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
def _enrollment_status(summary):
ps_dao = ParticipantSummaryDao()
consent = summary.get(CONSENT_FOR_STUDY_ENROLLMENT_AND_EHR_METRIC) == SUBMITTED_VALUE
num_completed_baseline_ppi_modules = summary.get(NUM_COMPLETED_BASELINE_PPI_MODULES_METRIC)
physical_measurements = PhysicalMeasurementsStatus(summary.get(PHYSICAL_MEASUREMENTS_METRIC))
samples_to_isolate_dna = SampleStatus(summary.get(SAMPLES_TO_ISOLATE_DNA_METRIC))
return ps_dao.calculate_enrollment_status(consent, num_completed_baseline_ppi_modules,
physical_measurements, samples_to_isolate_dna)
def setUp(self, with_data=True, use_mysql=False):
super(GenomicSetValidationBaseTestCase,
self).setUp(with_data=with_data, use_mysql=use_mysql)
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
self.genomic_set_dao = GenomicSetDao()
self.genomic_member_dao = GenomicSetMemberDao()
self._participant_i = 0
self.setup_data()
def setUp(self):
super(PhysicalMeasurementsDaoTest, self).setUp()
self.participant = Participant(participantId=1, biobankId=2)
ParticipantDao().insert(self.participant)
self.dao = PhysicalMeasurementsDao()
self.participant_summary_dao = ParticipantSummaryDao()
self.measurement_json = json.dumps(load_measurement_json(self.participant.participantId,
TIME_1.isoformat()))
self.biobank = BiobankOrderDao()
def test_end_to_end(self):
dao = BiobankStoredSampleDao()
self.assertEquals(dao.count(), 0)
# Create 3 participants and pass their (random) IDs into sample rows.
summary_dao = ParticipantSummaryDao()
biobank_ids = []
participant_ids = []
nids = 16 # equal to the number of parent rows in 'biobank_samples_1.csv'
cids = 1 # equal to the number of child rows in 'biobank_samples_1.csv'
for _ in xrange(nids):
participant = self.participant_dao.insert(Participant())
summary_dao.insert(self.participant_summary(participant))
participant_ids.append(participant.participantId)
biobank_ids.append(participant.biobankId)
self.assertEquals(
summary_dao.get(
participant.participantId).numBaselineSamplesArrived, 0)
test_codes = random.sample(_BASELINE_TESTS, nids)
samples_file = test_data.open_biobank_samples(biobank_ids=biobank_ids,
tests=test_codes)
lines = samples_file.split('\n')[1:] # remove field name line
input_filename = 'cloud%s.csv' % self._naive_utc_to_naive_central(
clock.CLOCK.now()).strftime(
biobank_samples_pipeline.INPUT_CSV_TIME_FORMAT)
self._write_cloud_csv(input_filename, samples_file)
biobank_samples_pipeline.upsert_from_latest_csv()
self.assertEquals(dao.count(), nids - cids)
for x in range(0, nids):
cols = lines[x].split('\t')
if cols[10].strip(): # skip child sample
continue
# If status is 'In Prep', then sample confirmed timestamp should be empty
if cols[2] == 'In Prep':
self.assertEquals(len(cols[11]), 0)
else:
status = SampleStatus.RECEIVED
ts_str = cols[11]
# DA-814 - Participant Summary test status should be: Unset, Received or Disposed only.
# If sample is disposed, then check disposed timestamp, otherwise check confirmed timestamp.
# DA-871 - Only check status is disposed when reason code is a bad disposal.
if cols[2] == 'Disposed' and get_sample_status_enum_value(
cols[8]) > SampleStatus.UNKNOWN:
status = SampleStatus.DISPOSED
ts_str = cols[9]
ts = datetime.datetime.strptime(ts_str, '%Y/%m/%d %H:%M:%S')
self._check_summary(participant_ids[x], test_codes[x], ts,
status)
def setUp(self): super(GenomicSetFileHandlerTest, self).setUp(use_mysql=True) NdbTestBase.doSetUp(self) TestBase.setup_fake(self) # Everything is stored as a list, so override bucket name as a 1-element list. config.override_setting(config.GENOMIC_SET_BUCKET_NAME, [_FAKE_BUCKET]) config.override_setting(config.BIOBANK_SAMPLES_BUCKET_NAME, [_FAKE_BUCKET]) config.override_setting(config.GENOMIC_BIOBANK_MANIFEST_FOLDER_NAME, [_FAKE_BUCKET_FOLDER]) self.participant_dao = ParticipantDao() self.summary_dao = ParticipantSummaryDao()
def _update_participant_summary(self, session, obj, is_amendment=False):
participant_id = obj.participantId
if participant_id is None:
raise BadRequest('participantId is required')
participant_summary_dao = ParticipantSummaryDao()
participant = ParticipantDao().get_for_update(session, participant_id)
if not participant:
raise BadRequest(
"Can't submit physical measurements for unknown participant %s"
% participant_id)
participant_summary = participant.participantSummary
if not participant_summary:
raise BadRequest(
"Can't submit physical measurements for participant %s without consent"
% participant_id)
raise_if_withdrawn(participant_summary)
participant_summary.lastModified = clock.CLOCK.now()
is_distinct_visit = participant_summary_dao.calculate_distinct_visits(
participant_id, obj.finalized, obj.physicalMeasurementsId)
if obj.status and obj.status == PhysicalMeasurementsStatus.CANCELLED and is_distinct_visit \
and not is_amendment:
participant_summary.numberDistinctVisits -= 1
# These fields set on measurement that is cancelled and doesn't have a previous good measurement
if obj.status and obj.status == PhysicalMeasurementsStatus.CANCELLED and not \
self.has_uncancelled_pm(session, participant):
participant_summary.physicalMeasurementsStatus = PhysicalMeasurementsStatus.CANCELLED
participant_summary.physicalMeasurementsTime = None
participant_summary.physicalMeasurementsFinalizedSiteId = None
# These fields set on any measurement not cancelled
elif obj.status != PhysicalMeasurementsStatus.CANCELLED:
# new PM or if a PM was restored, it is complete again.
participant_summary.physicalMeasurementsStatus = PhysicalMeasurementsStatus.COMPLETED
participant_summary.physicalMeasurementsTime = obj.created
participant_summary.physicalMeasurementsFinalizedTime = obj.finalized
participant_summary.physicalMeasurementsCreatedSiteId = obj.createdSiteId
participant_summary.physicalMeasurementsFinalizedSiteId = obj.finalizedSiteId
if is_distinct_visit and not is_amendment:
participant_summary.numberDistinctVisits += 1
elif obj.status and obj.status == PhysicalMeasurementsStatus.CANCELLED and \
self.has_uncancelled_pm(session, participant):
get_latest_pm = self.get_latest_pm(session, participant)
participant_summary.physicalMeasurementsFinalizedTime = get_latest_pm.finalized
participant_summary.physicalMeasurementsTime = get_latest_pm.created
participant_summary.physicalMeasurementsCreatedSiteId = get_latest_pm.createdSiteId
participant_summary.physicalMeasurementsFinalizedSiteId = get_latest_pm.finalizedSiteId
participant_summary_dao.update_enrollment_status(participant_summary)
session.merge(participant_summary)
return participant_summary
def _update_participant_summary(self, session, obj):
participant_summary_dao = ParticipantSummaryDao()
participant_summary = participant_summary_dao.get_for_update(
session, obj.participantId)
if not participant_summary:
raise BadRequest(
"Can't submit biospecimens for participant %s without consent"
% obj.participantId)
raise_if_withdrawn(participant_summary)
self._set_participant_summary_fields(obj, participant_summary)
participant_summary_dao.update_enrollment_status(participant_summary)
def setUp(self):
super(BiobankSamplesPipelineTest, self).setUp(use_mysql=True)
NdbTestBase.doSetUp(self)
TestBase.setup_fake(self)
config.override_setting(config.BASELINE_SAMPLE_TEST_CODES,
_BASELINE_TESTS)
# Everything is stored as a list, so override bucket name as a 1-element list.
config.override_setting(config.BIOBANK_SAMPLES_BUCKET_NAME,
[_FAKE_BUCKET])
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
def setUp(self, with_data=True, use_mysql=True):
super(EhrReceiptDaoTest, self).setUp(with_data=with_data,
use_mysql=use_mysql)
self.setup_fake()
self.calendar_dao = CalendarDao()
self.org_dao = OrganizationDao()
self.hpo_dao = HPODao()
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
self.ehr_receipt_dao = EhrReceiptDao()
self._setup_initial_data()
def _filter_order_fields(self, resource, pid):
fhir_resource = SimpleFhirR4Reader(resource)
summary = ParticipantSummaryDao().get(pid)
if not summary:
raise BadRequest('No summary for particpant id: {}'.format(pid))
code_dict = summary.asdict()
format_json_code(code_dict, self.code_dao, 'genderIdentityId')
format_json_code(code_dict, self.code_dao, 'stateId')
# MayoLink api has strong opinions on what should be sent and the order of elements. Dont touch.
order = {
'order': {
'collected':
fhir_resource.authoredOn,
'account':
'',
'number':
fhir_resource.extension.get(
url=VIBRENT_BARCODE_URL).valueString,
'patient': {
'medical_record_number': str(summary.biobankId),
'first_name': '*',
'last_name': str(summary.biobankId),
'middle_name': '',
'birth_date': '3/3/1933',
'gender': code_dict['genderIdentity'],
'address1': summary.streetAddress,
'address2': summary.streetAddress2,
'city': summary.city,
'state': code_dict['state'],
'postal_code': str(summary.zipCode),
'phone': str(summary.phoneNumber),
'account_number': None,
'race': summary.race,
'ethnic_group': None
},
'physician': {
'name': None,
'phone': None,
'npi': None
},
'report_notes':
fhir_resource.extension.get(url=VIBRENT_ORDER_URL).valueString,
'tests': {
'test': {
'code': '1SAL2',
'name': 'PMI Saliva, FDA Kit',
'comments': None
}
},
'comments':
'Salivary Kit Order, direct from participant'
}
}
return order
def setUp(self):
super(DvOrderDaoTestBase, self).setUp(use_mysql=True)
self.dao = DvOrderDao()
self.code_dao = CodeDao()
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
self.participant = Participant(participantId=123456789, biobankId=7)
self.participant_dao.insert(self.participant)
self.summary = self.participant_summary(self.participant)
self.summary_dao.insert(self.summary)
def update_participant_summaries_from_job(job):
summary_dao = ParticipantSummaryDao()
now = clock.CLOCK.now()
for i, page in enumerate(job):
LOG.info("Processing page {} of results...".format(i))
parameter_sets = [
{
'pid': row.person_id,
'receipt_time': now,
}
for row in page
]
query_result = summary_dao.bulk_update_ehr_status(parameter_sets)
LOG.info("Affected {} rows.".format(query_result.rowcount))
def test_cancelling_an_order(self):
ParticipantSummaryDao().insert(self.participant_summary(self.participant))
order_1 = self.dao.insert(self._make_biobank_order())
cancelled_request = self._get_cancel_patch()
self.assertEqual(order_1.version, 1)
self.assertEqual(order_1.orderStatus, None)
updated_order = self.dao.update_with_patch(order_1.biobankOrderId, cancelled_request,
order_1.version)
self.assertEqual(updated_order.version, 2)
self.assertEqual(updated_order.cancelledUsername, '*****@*****.**')
self.assertEqual(updated_order.orderStatus, BiobankOrderStatus.CANCELLED)
self.assertEqual(updated_order.amendedReason, cancelled_request['amendedReason'])
ps_dao = ParticipantSummaryDao().get(self.participant.participantId)
self.assertEqual(ps_dao.biospecimenFinalizedSiteId, None)
def test_cancelling_an_order_missing_reason(self):
ParticipantSummaryDao().insert(self.participant_summary(self.participant))
order_1 = self.dao.insert(self._make_biobank_order())
cancelled_request = self._get_cancel_patch()
del cancelled_request['amendedReason']
with self.assertRaises(BadRequest):
self.dao.update_with_patch(order_1.biobankOrderId, cancelled_request, order_1.version)
def test_cancelling_an_order_missing_info(self):
ParticipantSummaryDao().insert(self.participant_summary(self.participant))
order_1 = self.dao.insert(self._make_biobank_order())
# missing cancelled info
cancelled_request = self._get_cancel_patch()
del cancelled_request['cancelledInfo']
with self.assertRaises(BadRequest):
self.dao.update_with_patch(order_1.biobankOrderId, cancelled_request, order_1.version)
# missing site
cancelled_request = self._get_cancel_patch()
del cancelled_request['cancelledInfo']['site']
with self.assertRaises(BadRequest):
self.dao.update_with_patch(order_1.biobankOrderId, cancelled_request, order_1.version)
# missing author
cancelled_request = self._get_cancel_patch()
del cancelled_request['cancelledInfo']['author']
with self.assertRaises(BadRequest):
self.dao.update_with_patch(order_1.biobankOrderId, cancelled_request, order_1.version)
# missing status
cancelled_request = self._get_cancel_patch()
del cancelled_request['status']
with self.assertRaises(BadRequest):
self.dao.update_with_patch(order_1.biobankOrderId, cancelled_request, order_1.version)
def test_generate_samples(self):
participant_id = self.send_post('Participant', {})['participantId']
self.send_consent(participant_id)
self.send_post(
'Participant/%s/BiobankOrder' % participant_id,
load_biobank_order_json(
from_client_participant_id(participant_id)))
# Sanity check that the orders were created correctly.
bo_dao = BiobankOrderDao()
self.assertEquals(1, bo_dao.count())
order = bo_dao.get_all()[0]
self.assertEquals(
11, len(bo_dao.get_with_children(order.biobankOrderId).samples))
self.send_post('DataGen', {
'create_biobank_samples': True,
'samples_missing_fraction': 0.0
})
upsert_from_latest_csv(
) # Run the (usually offline) Biobank CSV import job.
self.assertEquals(11, BiobankStoredSampleDao().count())
ps = ParticipantSummaryDao().get(
from_client_participant_id(participant_id))
self.assertEquals(SampleStatus.RECEIVED, ps.samplesToIsolateDNA)
self.assertEquals(10, ps.numBaselineSamplesArrived)