Example #1
0
def create_study():
    if request.method == 'GET':
        studies = [
            study.as_native_python()
            for study in Study.get_all_studies_by_name()
        ]
        return render_template('create_study.html',
                               studies=json.dumps(studies),
                               allowed_studies=get_admins_allowed_studies(),
                               system_admin=admin_is_system_admin())

    name = request.form.get('name', '')
    encryption_key = request.form.get('encryption_key', '')

    is_test = request.form.get(
        'is_test') == 'true'  # 'true' -> True, 'false' -> False
    try:
        study = Study.create_with_object_id(name=name,
                                            encryption_key=encryption_key,
                                            is_test=is_test)
        copy_existing_study_if_asked_to(study)
        flash('Successfully created study {}.'.format(name), 'success')
        return redirect('/device_settings/{:d}'.format(study.pk))
    except ValidationError as ve:
        for field, message in ve.message_dict.iteritems():
            flash('{}: {}'.format(field, message[0]), 'danger')
        return redirect('/create_study')
Example #2
0
def create_dummy_study(object_id):
    s = DStudy(
        name="Old Unnamed Study %s" % object_id,
        encryption_key="0"*32,
        object_id=str(object_id),
        deleted=True,
    )
    s.save()
    study_id_dict[object_id] = {"pk": s.id}
    return s
Example #3
0
    def test_get_all_studies_by_name(self):
        study_names = ['My studies', 'MY STUDY', 'my_study', 'your study']
        encryption_key = 'aabbccddeeffgghhiijjkkllmmnnoopp'
        for name in study_names:
            good_study = Study.create_with_object_id(name=name, encryption_key=encryption_key)

        self.assertIn(good_study, Study.get_all_studies_by_name())
        self.assertEqual(list(Study.get_all_studies_by_name().values_list('name', flat=True)), study_names)

        bad_study = Study.create_with_object_id(name='name', encryption_key=encryption_key, deleted=True)
        self.assertNotIn(bad_study, Study.get_all_studies_by_name())
Example #4
0
 def test_settings_mongo_integrity(self):
     study = Study(**self.translated_reference_study)
     study.save()
     
     mongo_reference_settings = self.translated_reference_device_settings
     mongo_reference_settings['study'] = study
     django_settings = DeviceSettings(**mongo_reference_settings)
     x = compare_dictionaries(mongo_reference_settings,
                              django_settings.as_dict(),
                              ignore=['deleted', 'id'])
     self.assertTrue(x)
Example #5
0
 def test_participant_mongo_integrity(self):
     study = Study(**self.translated_reference_study)
     study.save()
 
     reference_participant = self.translated_reference_participant
     django_participant = Participant(study=study,
                                      **reference_participant).as_native_python()
     
     x = compare_dictionaries(reference_participant,
                              django_participant,
                              ignore=['id', 'deleted'])
     self.assertTrue(x)
Example #6
0
 def test_survey_mongo_integrity(self):
     study = Study(**self.translated_reference_study)
     study.save()
     
     mongo_reference_survey = self.translated_reference_survey
     mongo_reference_survey['study'] = study
     
     django_reference_survey = Survey(study=study, **self.translated_reference_survey)
     
     # This comparison requires the as_dict comparison because it has jsonfields
     x = compare_dictionaries(mongo_reference_survey,
                              django_reference_survey.as_dict(),
                              ignore=['deleted', 'id', 'last_modified'])
     self.assertTrue(x)
Example #7
0
 def test_study_create_with_object_id(self):
     self.assertEqual(Study.objects.count(), 0)
     self.assertEqual(DeviceSettings.objects.count(), 0)
     study_name = 'my study'
     encryption_key = 'aabbccddeeffgghhiijjkkllmmnnoopp'
     Study.create_with_object_id(name=study_name, encryption_key=encryption_key)
     new_study = Study.objects.get()
     new_ds = DeviceSettings.objects.get()
     self.assertEqual(Study.objects.count(), 1)
     self.assertEqual(DeviceSettings.objects.count(), 1)
     self.assertEqual(new_study.name, study_name)
     self.assertEqual(new_study.encryption_key, encryption_key)
     self.assertEqual(len(new_study.object_id), 24)
     self.assertEqual(new_study.device_settings, new_ds)
     self.assertFalse(new_study.deleted)
Example #8
0
def edit_researcher(researcher_pk):
    researcher = Researcher.objects.get(pk=researcher_pk)
    admin_is_current_user = (researcher.username == session['admin_username'])
    current_studies = Study.get_all_studies_by_name().filter(
        researchers=researcher)
    return render_template(
        'edit_researcher.html',
        admin=researcher,
        current_studies=current_studies,
        all_studies=Study.get_all_studies_by_name(),
        allowed_studies=get_admins_allowed_studies(),
        admin_is_current_user=admin_is_current_user,
        system_admin=admin_is_system_admin(),
        redirect_url='/edit_researcher/{:s}'.format(researcher_pk),
    )
Example #9
0
def manage_studies():
    studies = [
        study.as_native_python() for study in Study.get_all_studies_by_name()
    ]
    return render_template('manage_studies.html',
                           studies=json.dumps(studies),
                           allowed_studies=get_admins_allowed_studies(),
                           system_admin=admin_is_system_admin())
Example #10
0
def manage_researchers():
    researcher_list = []
    for researcher in Researcher.get_all_researchers_by_username():
        allowed_studies = Study.get_all_studies_by_name().filter(
            researchers=researcher).values_list('name', flat=True)
        researcher_list.append(
            (researcher.as_native_python(), list(allowed_studies)))

    return render_template('manage_researchers.html',
                           admins=json.dumps(researcher_list),
                           allowed_studies=get_admins_allowed_studies(),
                           system_admin=admin_is_system_admin())
Example #11
0
def get_admins_allowed_studies(as_json=True):
    """
    Return a list of studies which the currently logged-in researcher is authorized to view and edit.
    """
    researcher = Researcher.objects.get(username=session['admin_username'])
    study_set = [
        study for study in Study.get_all_studies_by_name().filter(researchers=researcher)
            .values("name", "object_id", "id", "is_test")
    ]
    if as_json:
        return json.dumps(study_set)
    else:
        return study_set
Example #12
0
def migrate_studies():
    d_study_list = []
    for m_study in MStudySet.iterator():
        with error_handler:
            # Create a Django Study object modeled off the Mongolia Study
            study_name = m_study['name']
            d_study = DStudy(
                name=study_name,
                encryption_key=m_study['encryption_key'],
                object_id=m_study['_id'],
                deleted=m_study['deleted'],
                is_test=m_study['is_test'],
            )
    
            # Validate the new Study object and add it to the bulk create list
            d_study.full_clean()
            d_study_list.append(d_study)
    
            # Get lists of Mongolia Surveys, Admins and StudyDeviceSettings attached to this Study
            m_survey_list = m_study['surveys']
            m_admin_list = m_study['admins']
            m_device_settings = m_study['device_settings']
            study_referents[study_name] = {
                'survey_list': m_survey_list,
                'admin_list': m_admin_list,
                'device_settings': m_device_settings,
            }

    # Bulk create the Django Studies
    DStudy.objects.bulk_create(d_study_list)

    # Create a reference from Mongolia Study IDs to Django Studies that doesn't require
    # any future database calls.
    for m_study in MStudySet.iterator():
        with error_handler:
            m_study_id = m_study['_id']
            d_study_id = DStudy.objects.filter(name=m_study['name']).values('pk', 'deleted').get()
            study_id_dict[m_study_id] = d_study_id
Example #13
0
def choose_study():
    allowed_studies = get_admins_allowed_studies_as_query_set()

    # If the admin is authorized to view exactly 1 study, redirect to that study
    if allowed_studies.count() == 1:
        return redirect('/view_study/{:d}'.format(
            allowed_studies.values_list('pk', flat=True).get()))

    # Otherwise, show the "Choose Study" page
    allowed_studies_json = Study.query_set_as_native_json(allowed_studies)
    return render_template('choose_study.html',
                           studies=allowed_studies_json,
                           allowed_studies=allowed_studies_json,
                           system_admin=admin_is_system_admin())
Example #14
0
    def test_study_validation(self):
        study_name = 'my study'
        good_encryption_key = 'aabbccddeeffgghhiijjkkllmmnnoopp'
        short_encryption_key = 'aabbccddeeffgghhiijjkkllmm'
        long_encryption_key = 'aabbccddeeffgghhiijjkkllmmnnooppqqrrsstt'
        with self.assertRaises(ValidationError):
            Study.create_with_object_id(name=study_name, encryption_key=short_encryption_key)
        with self.assertRaises(ValidationError):
            Study.create_with_object_id(name=study_name, encryption_key=long_encryption_key)

        bad_object_id = 'I am too long to be an ObjectID'
        with self.assertRaises(ValidationError):
            Study.objects.create(name=study_name, encryption_key=good_encryption_key, object_id=bad_object_id)

        Study.create_with_object_id(name=study_name, encryption_key=good_encryption_key)
        with self.assertRaises(ValidationError):
            Study.create_with_object_id(name=study_name, encryption_key=good_encryption_key)
Example #15
0
 def get_visible_studies_by_name(self):
     if self.site_admin:
         from database.models import Study
         return Study.get_all_studies_by_name()
     else:
         return self.get_researcher_studies_by_name()
Example #16
0
 def get_researcher_studies_by_name(self):
     from database.models import Study
     return Study.get_researcher_studies_by_name(self)
Example #17
0
 def get_administered_studies_by_name(self):
     from database.models import Study
     return Study._get_administered_studies_by_name(self)
Example #18
0
def get_admins_allowed_studies_as_query_set():
    researcher = Researcher.objects.get(username=session['admin_username'])
    return Study.get_all_studies_by_name().filter(researchers=researcher)
Example #19
0
 def test_study_mongo_integrity(self):
     django_reference_study = Study(**self.translated_reference_study)
     x = compare_dictionaries(self.translated_reference_study,
                              django_reference_study.as_native_python(),
                              ignore=['id'])
     self.assertTrue(x)