def main(argv): # TODO: test for new_limesurvey_id existence questionnaire_id, new_limesurvey_id = parse_options(argv) questionnaire = Questionnaire.objects.get(id=questionnaire_id) survey = questionnaire.survey old_limesurvey_id = survey.lime_survey_id survey.lime_survey_id = new_limesurvey_id # TODO: # if old_limesurvey_id == new_limesurvey_id do nothing, exit with message survey.save() limesurvey_surveys = Questionnaires() print('Getting old tokens ...') old_tokens = \ limesurvey_surveys.find_tokens_by_questionnaire(old_limesurvey_id) print('Getting new tokens ...') new_tokens = \ limesurvey_surveys.find_tokens_by_questionnaire(survey.lime_survey_id) print('Updating experiment questionnaire responses ...') for q_experiment_response in EQuestionnaireResponse.objects.filter( data_configuration_tree__component_configuration__component= questionnaire.id): update_questionnaire_response(old_tokens, new_tokens, q_experiment_response) print('Updating patients questionnaire responses ...') for q_patient_response in PQuestionnaireResponse.objects.filter( survey=survey): update_questionnaire_response(old_tokens, new_tokens, q_patient_response)
def survey_list(request, template_name='survey/survey_list.html'): surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) questionnaires_list = [] language_code = request.LANGUAGE_CODE for survey in Survey.objects.all(): language = get_questionnaire_language(surveys, survey.lime_survey_id, language_code) questionnaires_list.append({ 'id': survey.id, 'lime_survey_id': survey.lime_survey_id, 'title': surveys.get_survey_title(survey.lime_survey_id, language), 'is_initial_evaluation': survey.is_initial_evaluation }) surveys.release_session_key() questionnaires_list = sorted(questionnaires_list, key=itemgetter('title')) context = { 'questionnaires_list': questionnaires_list, 'limesurvey_available': limesurvey_available } return render(request, template_name, context)
def update_questionnaire_list(questionnaire_list, heading_type, current_language="pt-BR"): questionnaire_list_updated = [] if heading_type == 'code': return questionnaire_list questionnaire_lime_survey = Questionnaires() for questionnaire in questionnaire_list: # position 0: id, postion 1: title questionnaire_id = questionnaire[0] # position 2: output_list (field, header) fields, headers = zip(*questionnaire[2]) questionnaire_field_header = get_questionnaire_header(questionnaire_lime_survey, questionnaire_id, fields, heading_type, current_language) questionnaire_list_updated.append([questionnaire_id, questionnaire[1], questionnaire_field_header]) questionnaire_lime_survey.release_session_key() return questionnaire_list_updated
def test_surveys_list_get_updated(self): lime_survey = Questionnaires() sid = None # Create a new survey at LimeSurvey with pt title try: pt_title_survey = 'Questionário Teste' sid = lime_survey.add_survey(9999, pt_title_survey, 'pt-BR', 'G') # Update the infos when viewed survey = Survey.objects.create(lime_survey_id=sid) # Check that pt_title is null self.assertIsNone(Survey.objects.last().pt_title) self.client.get(reverse('survey_list')) # Check that pt_title is updated self.assertEqual(Survey.objects.last().pt_title, pt_title_survey) # Simulate a discrepancy between the survey informations at limesurvey and NES survey.pt_title = "Título discrepante" survey.save() self.assertNotEqual(Survey.objects.last().pt_title, pt_title_survey) # Simulate clicking to update the list with new limesurvey information self.client.post(reverse('survey_list'), {'action': 'update'}, follow=True) # Check if the pt_title was updated properly self.assertEqual(Survey.objects.last().pt_title, pt_title_survey) finally: # Deletes the survey created at Lime Survey self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def survey_update(request, survey_id, template_name="survey/survey_register.html"): survey = get_object_or_404(Survey, pk=survey_id) surveys = Questionnaires() language = get_questionnaire_language(surveys, survey.lime_survey_id, request.LANGUAGE_CODE) survey_title = surveys.get_survey_title(survey.lime_survey_id, language) limesurvey_available = check_limesurvey_access(request, surveys) surveys.release_session_key() survey_form = SurveyForm(request.POST or None, instance=survey, initial={'title': str(survey.lime_survey_id) + ' - ' + survey_title}) if request.method == "POST": if request.POST['action'] == "save": if survey_form.is_valid(): if survey_form.has_changed(): survey_form.save() messages.success(request, _('Questionnaire updated successfully.')) else: messages.success(request, _('There are no changes to save.')) redirect_url = reverse("survey_view", args=(survey.id,)) return HttpResponseRedirect(redirect_url) context = { "limesurvey_available": limesurvey_available, "survey": survey, "survey_form": survey_form, "survey_title": survey_title, "editing": True, "creating": False} return render(request, template_name, context)
def survey_update(request, survey_id, template_name="survey/survey_register.html"): survey = get_object_or_404(Survey, pk=survey_id) surveys = Questionnaires() survey_title = surveys.get_survey_title(survey.lime_survey_id) limesurvey_available = check_limesurvey_access(request, surveys) surveys.release_session_key() survey_form = SurveyForm(request.POST or None, instance=survey, initial={'title': str(survey.lime_survey_id) + ' - ' + survey_title}) if request.method == "POST": if request.POST['action'] == "save": if survey_form.is_valid(): if survey_form.has_changed(): survey_form.save() messages.success(request, _('Questionnaire updated successfully.')) else: messages.success(request, _('There are no changes to save.')) redirect_url = reverse("survey_view", args=(survey.id,)) return HttpResponseRedirect(redirect_url) context = { "limesurvey_available": limesurvey_available, "survey": survey, "survey_form": survey_form, "survey_title": survey_title, "editing": True, "creating": False} return render(request, template_name, context)
def survey_list(request, template_name='survey/survey_list.html'): surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) questionnaires_list = [] for survey in Survey.objects.all(): questionnaires_list.append( { 'id': survey.id, 'lime_survey_id': survey.lime_survey_id, 'title': surveys.get_survey_title(survey.lime_survey_id), 'is_initial_evaluation': survey.is_initial_evaluation } ) surveys.release_session_key() questionnaires_list = sorted(questionnaires_list, key=itemgetter('title')) context = { 'questionnaires_list': questionnaires_list, 'limesurvey_available': limesurvey_available } return render(request, template_name, context)
def test_add_and_delete_survey_methods(self): questionnaires = Questionnaires() sid = questionnaires.add_survey('9999', 'Questionario de Teste', 'en', 'G') self.assertGreaterEqual(sid, 0) status = questionnaires.delete_survey(sid) self.assertEqual(status, 'OK')
def test_survey_without_pt_or_en_title_returns_default_language_title_to_be_listed_but_does_not_save( self, mockServer): mockServer.return_value.get_session_key.return_value = \ 'vz224sb7jzkvh8i4kpx8fxbcxd67meht' mockServer.return_value.add_survey.return_value = 21212150 mockServer.return_value.get_language_properties.side_effect = [{ 'surveyls_title': None }, { 'surveyls_title': None }, { 'surveyls_title': 'Test Questionnaire in French' }] mockServer.return_value.get_survey_properties.return_value = { 'active': 'N' } lime_survey = Questionnaires() # Create a new survey at LimeSurvey withou titles in pt or en languages fr_title_survey = 'Test Questionnaire in French' sid = lime_survey.add_survey(9999, fr_title_survey, 'fr', 'G') Survey.objects.create(lime_survey_id=sid) response = self.client.get(reverse('survey_list')) # Check if the page renders the fr title of the survey self.assertContains(response, fr_title_survey) # Check that pt_title and en_title remain null self.assertIsNone(Survey.objects.last().en_title) self.assertIsNone(Survey.objects.last().pt_title)
def _export_surveys(self): """Export experiment surveys archives using LimeSurvey RPC API. :return: list of survey archive paths """ questionnaire_ids = Questionnaire.objects.filter( experiment=self.experiment).values_list('survey_id', flat=True) surveys = Survey.objects.filter(id__in=questionnaire_ids) ls_interface = Questionnaires(settings.LIMESURVEY['URL_API'] + '/index.php/plugins/unsecure?plugin=extendRemoteControl&function=action') if ls_interface.session_key is None: return self.LIMESURVEY_ERROR, _('Could not export LimeSurvey data. Please try again. If problem persists ' 'please contact the system administator') archive_paths = [] for survey in surveys: result = ls_interface.export_survey(survey.lime_survey_id) if result is None: return self.LIMESURVEY_ERROR, _( 'Could not export LimeSurvey data. Please try again. If problem persists ' 'please contact the system administator') decoded_archive = b64decode(result) lsa_archive_path = os.path.join(self.temp_dir, str(survey.lime_survey_id) + '.lsa') lsa_archive = open(lsa_archive_path, 'wb') lsa_archive.write(decoded_archive) archive_paths.append(lsa_archive_path) ls_interface.release_session_key() return archive_paths if archive_paths else [] # TODO (NES_956): return empty list?
def test_add_and_delete_survey_methods(self): questionnaires = Questionnaires() sid = questionnaires.add_survey('9999', 'Questionario de Teste', 'en', 'G') self.assertGreaterEqual(sid, 0) status = questionnaires.delete_survey(sid) self.assertEqual(status, 'OK')
def test_find_questionnaire_by_id_method_found_survey(self): questionnaires = Questionnaires() list_survey = self.server.list_surveys(self.session_key, None) self.server.release_session_key(self.session_key) self.assertEqual( questionnaires.find_questionnaire_by_id(list_survey[3]['sid']), list_survey[3]) questionnaires.release_session_key()
def survey_view(request, survey_id, template_name="survey/survey_register.html"): survey = get_object_or_404(Survey, pk=survey_id) surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) language = get_questionnaire_language(surveys, survey.lime_survey_id, request.LANGUAGE_CODE) survey_title = surveys.get_survey_title(survey.lime_survey_id, language) # There is no need to use "request.POST or None" because the data will never be changed here. In fact we have to # use "None" only, because request.POST does not contain any value because the fields are disabled, and this results # in the form being created without considering the initial value. survey_form = SurveyForm( None, instance=survey, initial={'title': str(survey.lime_survey_id) + ' - ' + survey_title}) for field in survey_form.fields: survey_form.fields[field].widget.attrs['disabled'] = True if request.method == "POST": if request.POST['action'] == "remove": try: survey.delete() messages.success(request, _('Questionnaire deleted successfully.')) return redirect('survey_list') except ProtectedError: messages.error( request, _("It was not possible to delete questionnaire, because there are experimental " "answers or steps associated.")) patients_questionnaire_data_list = create_patients_questionnaire_data_list( survey, surveys) if request.user.has_perm("experiment.view_researchproject"): experiments_questionnaire_data_list = create_experiments_questionnaire_data_list( survey, surveys) else: experiments_questionnaire_data_list = [] context = { "limesurvey_available": limesurvey_available, "patients_questionnaire_data_list": patients_questionnaire_data_list, "experiments_questionnaire_data_list": experiments_questionnaire_data_list, "survey": survey, "survey_form": survey_form, "survey_title": survey_title, } return render(request, template_name, context)
def test_list_active_questionnaires(self): questionnaires = Questionnaires() list_survey = self.server.list_surveys(self.session_key, None) self.server.release_session_key(self.session_key) list_active_survey = [] for survey in list_survey: survey_has_token = questionnaires.survey_has_token_table(survey['sid']) if survey['active'] == "Y" and survey_has_token is True: list_active_survey.append(survey) self.assertEqual(questionnaires.find_all_active_questionnaires(), list_active_survey) questionnaires.release_session_key()
def test_acquisitiondate_field_is_not_hidden(self): ls = Questionnaires() groups = ls.list_groups(LS_ID) identification_group = next(item for item in groups if item['group_name'] == 'Identification') questions = ls.list_questions(LS_ID, identification_group['gid']) acquisitiondate_question = next(item for item in questions if item['title'] == 'acquisitiondate') question_properties = ls.get_question_properties( acquisitiondate_question['qid'], 'en') self.assertEqual(question_properties['attributes']['hidden'], '0')
def survey_create(request, template_name="survey/survey_register.html"): survey_form = SurveyForm(request.POST or None, initial={ 'title': 'title', 'is_initial_evaluation': False }) surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) questionnaires_list = [] if limesurvey_available: questionnaires_list = surveys.find_all_active_questionnaires() surveys.release_session_key() if questionnaires_list: # removing surveys already registered used_surveys = Survey.objects.all() for used_survey in used_surveys: for questionnaire in questionnaires_list: if used_survey.lime_survey_id == questionnaire['sid']: questionnaires_list.remove(questionnaire) break else: messages.warning(request, _('No questionnaire found.')) if request.method == "POST": if request.POST['action'] == "save": if survey_form.is_valid(): survey_added = survey_form.save(commit=False) survey, created = Survey.objects.get_or_create( lime_survey_id=request.POST['questionnaire_selected'], is_initial_evaluation=survey_added.is_initial_evaluation) if created: messages.success(request, _('Questionnaire created successfully.')) redirect_url = reverse("survey_list") return HttpResponseRedirect(redirect_url) context = { "survey_form": survey_form, "creating": True, "editing": True, "questionnaires_list": questionnaires_list, 'limesurvey_available': limesurvey_available } return render(request, template_name, context)
def survey_list(request, template_name='survey/survey_list.html'): surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) questionnaires_list = [] language_code = request.LANGUAGE_CODE update = False if request.method == "POST": if request.POST['action'] == "update": update = True for survey in Survey.objects.all(): survey_title = get_survey_title_based_on_the_user_language(survey, language_code, update) # Get the status of the survey # If there's any inactive survey, search LimeSurvey to see if there's any change in that matter # and update the fields in the database is_active = survey.is_active if not is_active or update: status = surveys.get_survey_properties(survey.lime_survey_id, 'active') if status == 'Y': survey.is_active = True else: survey.is_active = False survey.save() questionnaires_list.append( { 'id': survey.id, 'lime_survey_id': survey.lime_survey_id, 'title': survey_title, 'is_initial_evaluation': survey.is_initial_evaluation, 'is_active': survey.is_active, } ) surveys.release_session_key() questionnaires_list = sorted(questionnaires_list, key=itemgetter('title')) context = { 'questionnaires_list': questionnaires_list, 'limesurvey_available': limesurvey_available, } return render(request, template_name, context)
def survey_list(request, template_name='survey/survey_list.html'): surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) questionnaires_list = [] language_code = request.LANGUAGE_CODE update = False if request.method == "POST": if request.POST['action'] == "update": update = True for survey in Survey.objects.all(): survey_title = get_survey_title_based_on_the_user_language(survey, language_code, update) # Get the status of the survey # If there's any inactive survey, search LimeSurvey to see if there's any change in that matter # and update the fields in the database is_active = survey.is_active if not is_active or update: status = surveys.get_survey_properties(survey.lime_survey_id, 'active') if status == 'Y': survey.is_active = True else: survey.is_active = False survey.save() questionnaires_list.append( { 'id': survey.id, 'lime_survey_id': survey.lime_survey_id, 'title': survey_title, 'is_initial_evaluation': survey.is_initial_evaluation, 'is_active': survey.is_active, } ) surveys.release_session_key() questionnaires_list = sorted(questionnaires_list, key=itemgetter('title')) context = { 'questionnaires_list': questionnaires_list, 'limesurvey_available': limesurvey_available, } return render(request, template_name, context)
def test_get_question_properties(self, mockServer): lime_survey = Questionnaires() lime_survey.get_question_properties(1, 'en') question_properties = { 'gid', 'question', 'question_order', 'subquestions', 'answeroptions', 'title', 'type', 'attributes_lang', 'attributes', 'other' } (session_key, question_id, properties, language), kwargs = \ mockServer.return_value.get_question_properties.call_args self.assertTrue( set(question_properties).issubset(properties), str(set(question_properties)) + ' is not a subset of ' + str(set(properties)))
def test_get_question_properties(self, mockServerClass): lime_survey = Questionnaires() lime_survey.get_question_properties(1, 'en') question_properties = { 'gid', 'question', 'question_order', 'subquestions', 'answeroptions', 'title', 'type', 'attributes_lang', 'attributes', 'other' } (session_key, question_id, properties, language), kwargs = \ mockServerClass.return_value.get_question_properties.call_args self.assertTrue( set(question_properties).issubset(properties), str(set(question_properties)) + ' is not a subset of ' + str(set(properties)) )
def find_questionnaire_name(survey, language_code): language_code = language_code.lower() titles = {'pt-br': survey.pt_title, 'en': survey.en_title} fallback_language = 'en' if language_code == 'pt-br' else 'pt-br' if titles[language_code] is not None and titles[language_code] != '': title = titles[language_code] elif titles[fallback_language] is not None \ and titles[fallback_language] != '': title = titles[fallback_language] else: surveys = Questionnaires() title = surveys.get_survey_title(survey.lime_survey_id) surveys.release_session_key() return {'sid': survey.lime_survey_id, 'name': title}
def survey_view(request, survey_id, template_name="survey/survey_register.html"): survey = get_object_or_404(Survey, pk=survey_id) surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) language = get_questionnaire_language(surveys, survey.lime_survey_id, request.LANGUAGE_CODE) survey_title = surveys.get_survey_title(survey.lime_survey_id, language) # There is no need to use "request.POST or None" because the data will never be changed here. In fact we have to # use "None" only, because request.POST does not contain any value because the fields are disabled, and this results # in the form being created without considering the initial value. survey_form = SurveyForm(None, instance=survey, initial={'title': str(survey.lime_survey_id) + ' - ' + survey_title}) for field in survey_form.fields: survey_form.fields[field].widget.attrs['disabled'] = True if request.method == "POST": if request.POST['action'] == "remove": try: survey.delete() messages.success(request, _('Questionnaire deleted successfully.')) return redirect('survey_list') except ProtectedError: messages.error(request, _("It was not possible to delete questionnaire, because there are experimental " "answers or steps associated.")) patients_questionnaire_data_list = create_patients_questionnaire_data_list(survey, surveys) if request.user.has_perm("experiment.view_researchproject"): experiments_questionnaire_data_list = create_experiments_questionnaire_data_list(survey, surveys) else: experiments_questionnaire_data_list = [] context = { "limesurvey_available": limesurvey_available, "patients_questionnaire_data_list": patients_questionnaire_data_list, "experiments_questionnaire_data_list": experiments_questionnaire_data_list, "survey": survey, "survey_form": survey_form, "survey_title": survey_title, } return render(request, template_name, context)
def test_create_questionnaire_explanation_fields_has_question_order( self, mockServerClass): # There are fields that # create_questionnaire_explanation_fields method get filled we must # to define before calling it (fake values) survey_utils = QuestionnaireUtils() questionnaire_id = '999999' fields = ['question'] survey_utils.questionnaires_experiment_data[questionnaire_id] = {} survey_utils.questionnaires_experiment_data[questionnaire_id][ 'fields'] = fields survey_utils.questionnaires_experiment_data[questionnaire_id][ 'header'] = 'dummie_header' # mock needed LimeSurvey RPC API methods mockServerClass.return_value.get_language_properties.return_value = \ {'surveyls_title': 'Ein wunderbar Titel'} mockServerClass.return_value.list_questions.return_value = [{ 'id': { 'qid': 1 } }] # mock get_question_properties LimeSurvey API method using # ABCSearchEngine.QUESTION_PROPERTIES constant list with fake values question_order = 21 group_id = 981 question_properties = dict( zip(ABCSearchEngine.QUESTION_PROPERTIES, [ group_id, 'Question Title', question_order, 'No available answers', 'No available answer options', 'question', 'N', 'No available attributes', {'hidden', '1' }, 'N' ])) mockServerClass.return_value.get_question_properties.return_value = \ question_properties # mock list_groups LimeSurvey API method (fake values) language = 'en' entrance_survey = False mockServerClass.return_value.list_groups.return_value = \ [{'randomization_group': '', 'id': {'gid': group_id, 'language': language}, 'group_name': 'Grupo 1', 'description': '', 'group_order': 1, 'sid': 376459, 'gid': group_id, 'language': language, 'grelevance': ''}] lime_survey = Questionnaires() error, questionnaire_fields = survey_utils.create_questionnaire_explanation_fields( questionnaire_id, language, lime_survey, fields, entrance_survey) # First line contains metadata column headers, subsequent lines # contains the metadata column values. # Assert for correct length for metadata headers and values self.assertTrue(len(questionnaire_fields[0]), len(questionnaire_fields[1])) # asserts for question_order field self.assertTrue('question_order' in questionnaire_fields[0]) index_ = questionnaire_fields[0].index('question_order') self.assertEqual(questionnaire_fields[1][index_], str(question_order))
def survey_create(request, template_name="survey/survey_register.html"): survey_form = SurveyForm(request.POST or None, initial={'title': 'title', 'is_initial_evaluation': False}) surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) questionnaires_list = [] if limesurvey_available: questionnaires_list = surveys.find_all_active_questionnaires() surveys.release_session_key() # removing surveys already registered used_surveys = Survey.objects.all() for used_survey in used_surveys: for questionnaire in questionnaires_list: if used_survey.lime_survey_id == questionnaire['sid']: questionnaires_list.remove(questionnaire) break if request.method == "POST": if request.POST['action'] == "save": if survey_form.is_valid(): survey_added = survey_form.save(commit=False) survey, created = Survey.objects.get_or_create( lime_survey_id=request.POST['questionnaire_selected'], is_initial_evaluation=survey_added.is_initial_evaluation) if created: messages.success(request, _('Questionnaire created successfully.')) redirect_url = reverse("survey_list") return HttpResponseRedirect(redirect_url) context = { "survey_form": survey_form, "creating": True, "editing": True, "questionnaires_list": questionnaires_list, 'limesurvey_available': limesurvey_available } return render(request, template_name, context)
def _import_limesurvey_surveys(self): """Import surveys to Limesurvey server :return: list of limsurvey surveys imported """ result = 0, '' ls_interface = Questionnaires() if ls_interface.session_key is None: result = self.LIMESURVEY_ERROR, _('Could not import survey(s) to LimeSurvey. Only Experiment data was ' 'imported. You can remove experiment imported and try again. If problem ' 'persists please contact system administrator') return result limesurvey_ids = [] # Does not add try/exception trying to open zipfile here because it # was done in import_all method with zipfile.ZipFile(self.file_path) as zip_file: for old_ls_id, dummy_ls_id in self.limesurvey_relations.items(): survey_archivename = str(old_ls_id) + '.lsa' if survey_archivename in zip_file.namelist(): survey_archive = zip_file.extract(survey_archivename, self.temp_dir) with open(survey_archive, 'rb') as file: encoded_string = b64encode(file.read()) encoded_string = encoded_string.decode('utf-8') new_ls_id = ls_interface.import_survey(encoded_string) if new_ls_id is None: result = self.LIMESURVEY_ERROR, _('Could not import survey(s) to LimeSurvey. Only ' 'Experiment data was imported. You can remove experiment ' 'imported and try again. If problem persists please ' 'contact system administrator') return result survey = Survey.objects.get(lime_survey_id=dummy_ls_id) survey.lime_survey_id = new_ls_id survey.save() limesurvey_ids.append(new_ls_id) else: # TODO (NES-956): add information that was not a survey archive # to this survey continue if limesurvey_ids: result = self._remove_limesurvey_participants() if not result[0]: return self._update_limesurvey_identification_questions() return result
def build_questionnaire(self, questionnaire_list, language=DEFAULT_LANGUAGE): print("questionnaire") self.data["questionnaires"] = [] questionnaire_lime_survey = Questionnaires() for sid, title, field_header_list in questionnaire_list: language = get_questionnaire_language(questionnaire_lime_survey, sid, language) self.data["questionnaires"].append({"id": sid, "language": language, "prefix_filename_fields": PREFIX_FILENAME_FIELDS, "questionnaire_name": title, "prefix_filename_responses": PREFIX_FILENAME_RESPONSES, "output_list": []}) for header, field in field_header_list: output_data = {"header": header, "field": field} self.data["questionnaires"][-1]["output_list"].append(output_data) # ["header"] = header # self.data["questionnaires"][0]["output_list"]["field"] = field questionnaire_lime_survey.release_session_key()
def test_survey_without_pt_or_en_title_in_ls_returns_default_language_title_to_be_listed_but_dont_save(self): lime_survey = Questionnaires() sid = None # Create a new survey at LimeSurvey withou titles in pt or en languages try: fr_title_survey = 'Test Questionnaire in French' sid = lime_survey.add_survey(9999, fr_title_survey, 'fr', 'G') Survey.objects.create(lime_survey_id=sid) response = self.client.get(reverse('survey_list')) # Check if the page renders the fr title of the survey self.assertContains(response, fr_title_survey) # Check that pt_title and en_title remain null self.assertIsNone(Survey.objects.last().en_title) self.assertIsNone(Survey.objects.last().pt_title) finally: # Deletes the survey created at Lime Survey self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def get_survey_title_based_on_the_user_language(survey, language_code, update=False): if not update: # Get the titles in both languages and return the one compatible with the user's language, # If the title is blank in that language, return it in the other language, and # if that one is also blank, try to update the titles in each language # if any of them updates isn't blank, recursively calls this function # otherwise, try to get the title for this survey at LimeSurvey and return it titles = {'pt-br': survey.pt_title, 'en': survey.en_title} fallback_language = 'en' if language_code == 'pt-br' else 'pt-br' if titles[language_code]: return titles[language_code] elif titles[fallback_language]: return titles[fallback_language] surveys = Questionnaires() pt_title = surveys.get_survey_title(survey.lime_survey_id, 'pt-BR') en_title = surveys.get_survey_title(survey.lime_survey_id, 'en') if language_code == 'pt-br' and pt_title: surveys.release_session_key() survey.pt_title = pt_title survey.save() return get_survey_title_based_on_the_user_language(survey, language_code) elif language_code == 'en' and en_title: surveys.release_session_key() survey.en_title = en_title survey.save() return get_survey_title_based_on_the_user_language(survey, language_code) else: title = surveys.get_survey_title(survey.lime_survey_id) surveys.release_session_key() if title: return title else: return survey.lime_survey_id
def test_survey_without_pt_or_en_title_in_ls_returns_default_language_title_to_be_listed_but_dont_save( self): lime_survey = Questionnaires() sid = None # Create a new survey at LimeSurvey withou titles in pt or en languages try: fr_title_survey = 'Test Questionnaire in French' sid = lime_survey.add_survey(9999, fr_title_survey, 'fr', 'G') Survey.objects.create(lime_survey_id=sid) response = self.client.get(reverse('survey_list')) # Check if the page renders the fr title of the survey self.assertContains(response, fr_title_survey) # Check that pt_title and en_title remain null self.assertIsNone(Survey.objects.last().en_title) self.assertIsNone(Survey.objects.last().pt_title) finally: # Deletes the survey created at Lime Survey self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def test_surveys_list_get_updated(self): lime_survey = Questionnaires() sid = None # Create a new survey at LimeSurvey with pt title try: pt_title_survey = 'Questionário Teste' sid = lime_survey.add_survey(9999, pt_title_survey, 'pt-BR', 'G') # Update the infos when viewed survey = Survey.objects.create(lime_survey_id=sid) # Check that pt_title is null self.assertIsNone(Survey.objects.last().pt_title) self.client.get(reverse('survey_list')) # Check that pt_title is updated self.assertEqual(Survey.objects.last().pt_title, pt_title_survey) # Simulate a discrepancy between the survey informations at limesurvey and NES survey.pt_title = "Título discrepante" survey.save() self.assertNotEqual(Survey.objects.last().pt_title, pt_title_survey) # Simulate clicking to update the list with new limesurvey information self.client.post(reverse('survey_list'), {'action': 'update'}, follow=True) # Check if the pt_title was updated properly self.assertEqual(Survey.objects.last().pt_title, pt_title_survey) finally: # Deletes the survey created at Lime Survey self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def test_add_participant_to_a_survey(self): """testa a insercao de participante em um questionario """ surveys = Questionnaires() list_active_surveys = surveys.find_all_active_questionnaires() self.assertNotEqual(list_active_surveys, None) survey = list_active_surveys[0] sid = int(survey['sid']) # list_participants = self.server.list_participants(self.session_key, sid) # participant_data = {'email': '*****@*****.**', 'lastname': 'junqueira', 'firstname': 'juca'} participant_data_result = surveys.add_participant(sid) # verificar se info retornada eh a mesma # self.assertEqual(participant_data_result[0]['email'], participant_data['email']) # self.assertEqual(participant_data_result[0]['lastname'], participant_data['lastname']) # self.assertEqual(participant_data_result[0]['firsStname'], participant_data['firstname']) self.assertNotEqual(participant_data_result, None) # list_participants_new = self.server.list_participants(self.session_key, sid) # self.assertEqual(len(list_participants_new), len(list_participants) + 1) # token_id = participant_data_result[0]['tid'] token_id = participant_data_result['tid'] # tokens_to_delete = [token_id] # remover participante do questionario result = self.server.delete_participants(self.session_key, sid, [token_id]) self.assertEqual(result[str(token_id)], 'Deleted') surveys.release_session_key()
def test_list_active_questionnaires(self): questionnaires = Questionnaires() list_survey = self.server.list_surveys(self.session_key, None) self.server.release_session_key(self.session_key) list_active_survey = [] for survey in list_survey: survey_has_token = questionnaires.survey_has_token_table( survey['sid']) if survey['active'] == "Y" and survey_has_token is True: list_active_survey.append(survey) self.assertEqual(questionnaires.find_all_active_questionnaires(), list_active_survey) questionnaires.release_session_key()
def _update_limesurvey_identification_questions(self): """Must be called after updating Limesurvey surveys references """ result = 0, '' indexes = self._get_indexes('experiment', 'questionnaire') ls_interface = Questionnaires( settings.LIMESURVEY['URL_API'] + '/index.php/plugins/unsecure?plugin=extendRemoteControl&function=action') questionnaire_utils = QuestionnaireUtils() for index in indexes: questionnaire = Questionnaire.objects.get(id=self.data[index]['pk']) questionnaire_responses = QuestionnaireResponse.objects.filter( data_configuration_tree__component_configuration__component=questionnaire.id) limesurvey_id = questionnaire.survey.lime_survey_id for response in questionnaire_responses: responsible_id = response.questionnaire_responsible_id subject_id = response.subject_of_group.subject_id token_id = response.token_id token = ls_interface.get_participant_properties(limesurvey_id, token_id, 'token') if token is None: result = self.LIMESURVEY_ERROR, _('Could not update identification questions for all responses.') continue # TODO (NES-956): get the language. By now put 'en' to test ls_subject_id_column_name = \ questionnaire_utils.get_response_column_name_for_identification_group_questions( ls_interface, limesurvey_id, 'subjectid', 'en') if isinstance(ls_subject_id_column_name, tuple): # Returned error result = ls_subject_id_column_name[0], _('Could not update identification questions for all ' 'responses.') continue ls_responsible_id_column_name = \ questionnaire_utils.get_response_column_name_for_identification_group_questions( ls_interface, limesurvey_id, 'responsibleid', 'en') if isinstance(ls_responsible_id_column_name, tuple): # Returned error result = ls_responsible_id_column_name[0], _('Could not update identification questions for all ' 'responses.') continue result_update = ls_interface.update_response(limesurvey_id, { 'token': token, ls_subject_id_column_name: subject_id, ls_responsible_id_column_name: responsible_id }) if not result_update: return self.LIMESURVEY_ERROR, _('Could not update all responses.') ls_interface.release_session_key() return result
def test_delete_participant_to_a_survey(self): """ Remove survey participant test testa a insercao de participante em um questionario """ surveys = Questionnaires() list_active_surveys = surveys.find_all_active_questionnaires() self.assertNotEqual(list_active_surveys, None) survey = list_active_surveys[0] sid = int(survey['sid']) # list_participants = self.server.list_participants(self.session_key, sid) # participant_data = {'email': '*****@*****.**', 'lastname': 'junqueira', 'firstname': 'juca'} participant_data_result = surveys.add_participant(sid) # verificar se info retornada eh a mesma # self.assertEqual(participant_data_result[0]['email'], participant_data['email']) # self.assertEqual(participant_data_result[0]['lastname'], participant_data['lastname']) # self.assertEqual(participant_data_result[0]['firstname'], participant_data['firstname']) self.assertNotEqual(participant_data_result, None) # list_participants_new = self.server.list_participants(self.session_key, sid) # self.assertEqual(len(list_participants_new), len(list_participants) + 1) # token_id = participant_data_result[0]['tid'] token_id = participant_data_result['tid'] # tokens_to_delete = [token_id] # remover participante do questionario result = surveys.delete_participant(sid, token_id) self.assertEqual(result[str(token_id)], 'Deleted') surveys.release_session_key()
def get_questionnaire_responses(language_code, lime_survey_id, token_id, request): questionnaire_responses = [] surveys = Questionnaires() token = surveys.get_participant_properties(lime_survey_id, token_id, "token") question_properties = [] groups = surveys.list_groups(lime_survey_id) survey_title = surveys.get_survey_title(lime_survey_id) if not isinstance(groups, dict): # defining language to be showed languages = surveys.get_survey_languages(lime_survey_id) # language to be showed can be the base language, or... language = languages['language'] # ...can be one of the additional languages if language.lower() != language_code.lower() and languages['additional_languages']: # search for the right language in addional languages, # considering that the LimeSurvey uses upper case in the two-letter language code, like en-US and pt-BR. additional_languages_list = languages['additional_languages'].split(' ') additional_languages_list_lower = [item.lower() for item in additional_languages_list] if language_code.lower() in additional_languages_list_lower: index = additional_languages_list_lower.index(language_code.lower()) language = additional_languages_list[index] for group in groups: if 'id' in group and group['id']['language'] == language: question_list = surveys.list_questions(lime_survey_id, group['id']) question_list = sorted(question_list) for question in question_list: properties = surveys.get_question_properties(question, group['id']['language']) # cleaning the question field properties['question'] = re.sub('{.*?}', '', re.sub('<.*?>', '', properties['question'])) properties['question'] = properties['question'].replace(' ', '').strip() is_purely_formula = (properties['type'] == '*') and (properties['question'] == '') if not is_purely_formula and properties['question'] != '': if isinstance(properties['subquestions'], dict): question_properties.append({ 'question': properties['question'], 'question_id': properties['title'], 'answer_options': 'super_question', 'type': properties['type'], 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) for key, value in sorted(properties['subquestions'].items()): question_properties.append({ 'question': value['question'], 'question_id': properties['title'] + '[' + value['title'] + ']', 'answer_options': properties['answeroptions'], 'type': properties['type'], 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) else: question_properties.append({ 'question': properties['question'], 'question_id': properties['title'], 'answer_options': properties['answeroptions'], 'type': properties['type'], 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) # Reading from Limesurvey and... responses_string = surveys.get_responses_by_token(lime_survey_id, token, language) # ... transforming to a list: # response_list[0] has the questions # response_list[1] has the answers responses_list = [] if isinstance(responses_string, bytes): reader = csv.reader(StringIO(responses_string.decode()), delimiter=',') for row in reader: responses_list.append(row) for question in question_properties: if not question['hidden']: if isinstance(question, str) and question['answer_options'] == "super_question": if question['question'] != '': questionnaire_responses.append({ 'question': question['question'], 'answer': '', 'type': question['type'] }) else: answer = '' if question['type'] == '1': answer_list = [] if question['question_id'] + "[1]" in responses_list[0]: index = responses_list[0].index(question['question_id'] + "[1]") answer_options = question['answer_options'] # if 'dualscale_headerA' in question['attributes_lang']: answer = question['attributes_lang']['dualscale_headerA'] + ": " if responses_list[1][index] in answer_options: answer_option = answer_options[responses_list[1][index]] answer += answer_option['answer'] else: answer += 'Sem resposta' # else: # answer += 'Sem resposta' answer_list.append(answer) if question['question_id'] + "[2]" in responses_list[0]: index = responses_list[0].index(question['question_id'] + "[2]") answer_options = question['answer_options'] # if 'dualscale_headerB' in question['attributes_lang']: answer = question['attributes_lang']['dualscale_headerB'] + ": " if responses_list[1][index] in answer_options: answer_option = answer_options[responses_list[1][index]] answer += answer_option['answer'] else: answer += 'Sem resposta' # else: # answer += 'Sem resposta' answer_list.append(answer) questionnaire_responses.append({ 'question': question['question'], 'answer': answer_list, 'type': question['type'] }) else: if question['question_id'] in responses_list[0]: index = responses_list[0].index(question['question_id']) answer_options = question['answer_options'] if isinstance(answer_options, dict): if responses_list[1][index] in answer_options: answer_option = answer_options[responses_list[1][index]] answer = answer_option['answer'] else: answer = 'Sem resposta' else: if question['type'] == 'D': if responses_list[1][index]: answer = datetime.datetime.strptime(responses_list[1][index], '%Y-%m-%d %H:%M:%S') else: answer = '' else: answer = responses_list[1][index] questionnaire_responses.append({ 'question': question['question'], 'answer': answer, 'type': question['type'] }) else: messages.error(request, _("LimeSurvey did not find fill data for this questionnaire.")) surveys.release_session_key() return survey_title, questionnaire_responses
def test_complete_survey(self): lime_survey = Questionnaires() sid = None try: # Cria uma nova survey no lime survey title_survey = 'Questionario de teste' sid = lime_survey.add_survey(9999, title_survey, 'en', 'G') # Obtenho o titulo da survey survey_title = lime_survey.get_survey_title(sid) self.assertEqual(survey_title, title_survey) # Verifica se esta ativa survey_active = lime_survey.get_survey_properties(sid, 'active') self.assertEqual(survey_active, 'N') # Obtem uma propriedade - Administrador da Survey survey_admin = lime_survey.get_survey_properties(sid, 'admin') self.assertEqual(survey_admin, None) # Importar grupo de questoes handle_file_import = \ open('quiz/static/quiz/tests/limesurvey_groups.lsg', 'r') questions_data = handle_file_import.read() questions_id = \ lime_survey.insert_questions(sid, questions_data, 'lsg') self.assertGreaterEqual(questions_id, 1) # Inicia tabela de tokens self.assertEqual(lime_survey.activate_tokens(sid), 'OK') # Ativar survey self.assertEqual(lime_survey.activate_survey(sid), 'OK') # Verifica se esta ativa survey_active = lime_survey.get_survey_properties(sid, 'active') self.assertEqual(survey_active, 'Y') # Adiciona participante e obtem o token result_token = lime_survey.add_participant(sid) # Verifica se o token está presente na tabela de participantes token = lime_survey.get_participant_properties(sid, result_token, "token") self.assertEqual(token, result_token['token']) finally: # Deleta a survey gerada no Lime Survey self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def test_find_all_questionnaires_method_returns_correct_result(self): questionnaires = Questionnaires() list_survey = self.server.list_surveys(self.session_key, None) self.server.release_session_key(self.session_key) self.assertEqual(questionnaires.find_all_questionnaires(), list_survey) questionnaires.release_session_key()
def survey_update_sensitive_questions( request, survey_id, template_name="survey/survey_sensitive_fields.html"): survey = get_object_or_404(Survey, pk=survey_id) surveys = Questionnaires() language = get_questionnaire_language(surveys, survey.lime_survey_id, request.LANGUAGE_CODE) survey_title = surveys.get_survey_title(survey.lime_survey_id, language) limesurvey_available = check_limesurvey_access(request, surveys) current_selected_fields = SensitiveQuestion.objects.filter(survey=survey) field_code = get_survey_header(surveys, survey, language, 'code') field_text = get_survey_header(surveys, survey, language, 'full') surveys.release_session_key() counter = 0 available_fields = [] while counter < len(field_code): if field_code[counter] not in questionnaire_evaluation_fields_excluded: available_fields.append({ 'code': field_code[counter], 'text': field_text[counter], 'checked': current_selected_fields.filter( code=field_code[counter]).exists() }) counter += 1 if request.method == "POST": if request.POST['action'] == "save": changed = False # for each available fields for field in available_fields: field_code = field['code'] field_text = field['text'] # field was selected if "field_" + str(field_code) in request.POST and request.POST[ "field_" + str(field_code)] == 'on': # field not in current configuration if not current_selected_fields.filter( code=str(field_code)).exists(): # Add itens selected SensitiveQuestion.objects.create(survey=survey, code=field_code, question=field_text) changed = True else: # field in current configuration if current_selected_fields.filter( code=str(field_code)).exists(): current_selected_fields.filter( code=str(field_code)).delete() changed = True # Exclude unknown items unkown_items = SensitiveQuestion.objects.filter( survey=survey).exclude( code__in=[field['code'] for field in available_fields]) if unkown_items.exists(): unkown_items.delete() changed = True if changed: messages.success(request, _('Questionnaire was updated successfully.')) else: messages.success(request, _('There are no changes to save.')) redirect_url = reverse("survey_view", args=(survey.id, )) return HttpResponseRedirect(redirect_url) context = { "available_fields": available_fields, "limesurvey_available": limesurvey_available, "survey": survey, "survey_title": survey_title } return render(request, template_name, context)
def build_questionnaire(self, questionnaire_list, language, entrance_questionnaire): questionnaire_lime_survey = Questionnaires() if "questionnaire_language" not in self.data: self.data["questionnaire_language"] = {} if entrance_questionnaire: self.data["questionnaires"] = [] for index, sid, title, field_header_list in questionnaire_list: output_language = get_questionnaire_language( questionnaire_lime_survey, sid, language) languages = questionnaire_lime_survey.get_survey_languages(sid) language_list = [languages['language']] additional_language = languages['additional_languages'].split( ' ') for item in additional_language: if item != '': language_list.append(item) if sid not in self.data["questionnaire_language"]: self.data["questionnaire_language"][sid] = { "language_list": language_list, "output_language": output_language, } # if sid not in self.data['questionnaires']: self.data["questionnaires"].append({ "id": sid, "prefix_filename_fields": PREFIX_FILENAME_FIELDS, "questionnaire_name": title, "prefix_filename_responses": PREFIX_FILENAME_RESPONSES, "output_list": [], "responses_list": [] }) for header, field in field_header_list: output_data = {"header": header, "field": field} self.data["questionnaires"][-1]["output_list"].append( output_data) else: self.data["questionnaires_from_experiments"] = {} for index, group_id, sid, title, field_header_list in questionnaire_list: output_language = get_questionnaire_language( questionnaire_lime_survey, sid, language) languages = questionnaire_lime_survey.get_survey_languages(sid) language_list = [languages['language']] additional_language = languages['additional_languages'].split( ' ') for item in additional_language: if item != '': language_list.append(item) if sid not in self.data["questionnaire_language"]: self.data["questionnaire_language"][sid] = { "language_list": language_list, "output_language": output_language, } if group_id not in self.data[ 'questionnaires_from_experiments']: self.data['questionnaires_from_experiments'][group_id] = {} if sid not in self.data['questionnaires_from_experiments'][ group_id]: self.data['questionnaires_from_experiments'][group_id][ sid] = { "prefix_filename_fields": PREFIX_FILENAME_FIELDS, "questionnaire_name": title, "prefix_filename_responses": PREFIX_FILENAME_RESPONSES, "output_list": [] } for header, field in field_header_list: output_data = {"header": header, "field": field} self.data["questionnaires_from_experiments"][group_id][ sid]["output_list"].append(output_data) if sid not in self.data["questionnaire_list"]: self.data["questionnaire_list"].append(sid) questionnaire_lime_survey.release_session_key()
def test_find_all_questionnaires_method_returns_correct_result(self): questionnaires = Questionnaires() list_survey = self.server.list_surveys(self.session_key, None) self.server.release_session_key(self.session_key) self.assertEqual(questionnaires.find_all_questionnaires(), list_survey) questionnaires.release_session_key()
def _remove_limesurvey_participants(self): """Must be called after updating Limesurvey surveys references""" result = 0, '' indexes = self._get_indexes('experiment', 'questionnaire') ls_interface = Questionnaires() # As there can be same survey in more than one questionnaire component, # create a dictionaire to nao questionnaire compontents by limesurvey # surveys. token_ids_survey = dict() for index in indexes: questionnaire = Questionnaire.objects.get(id=self.data[index]['pk']) limesurvey_id = questionnaire.survey.lime_survey_id # Initialize dict if first time of limesurvey_id if limesurvey_id not in token_ids_survey: token_ids_survey[limesurvey_id] = [] token_ids = list(QuestionnaireResponse.objects.filter( data_configuration_tree__component_configuration__component= questionnaire.id).values_list('token_id', flat=True)) token_ids_survey[limesurvey_id] += token_ids for limesurvey_id, token_ids in token_ids_survey.items(): all_participants = ls_interface.find_tokens_by_questionnaire(limesurvey_id) if all_participants is None: result = self.LIMESURVEY_ERROR, _('Could not clear all extra survey participants data.') continue # TODO (NES-956): don't remove participants of other experiment of this NES. for participant in all_participants: if participant['tid'] not in token_ids: status_delete = ls_interface.delete_participants(limesurvey_id, [participant['tid']]) if status_delete is None: result = self.LIMESURVEY_ERROR, _('Could not clear all extra survey participants data.') continue responses = ls_interface.get_responses_by_token(sid=limesurvey_id, token=participant['token']) if responses is None: result = self.LIMESURVEY_ERROR, _('Could not clear all extra survey participants data.') continue responses = QuestionnaireUtils.responses_to_csv(responses) del(responses[0]) # First line is the header line response_ids = [] for response in responses: response_ids.append(int(response[0])) ls_interface = Questionnaires( settings.LIMESURVEY['URL_API'] + '/index.php/plugins/unsecure?plugin=extendRemoteControl&function=action') status = ls_interface.delete_responses(limesurvey_id, response_ids) if status is None: result = self.LIMESURVEY_ERROR, _('Could not clear all extra survey participants data.') ls_interface = Questionnaires() # Return to access core RPC ls_interface.release_session_key() return result
def test_find_questionnaire_by_id_method_not_found_survey_by_out_of_range(self): questionnaires = Questionnaires() self.assertEqual(None, questionnaires.find_questionnaire_by_id(10000000)) questionnaires.release_session_key()
def process_per_questionnaire(self): error_msg = "" export_per_questionnaire_directory = '' export_metadata_directory = '' path_per_questionnaire = '' # and save per_participant data if self.get_input_data("export_per_questionnaire"): per_questionnaire_directory = self.get_input_data("per_questionnaire_directory") error_msg, path_per_questionnaire = create_directory(self.get_export_directory(), per_questionnaire_directory) if error_msg != "": return error_msg export_per_questionnaire_directory = path.join(self.get_input_data("base_directory"), self.get_input_data("per_questionnaire_directory")) export_metadata_directory = path.join(self.get_input_data("base_directory"), metadata_directory) questionnaire_lime_survey = Questionnaires() for questionnaire in self.get_input_data("questionnaires"): questionnaire_id = questionnaire["id"] language = questionnaire["language"] print(questionnaire_id) # per_participant_data is updated by define_questionnaire method fields_description = self.define_questionnaire(questionnaire, questionnaire_lime_survey) # create directory for questionnaire: <per_questionnaire>/<q_code_title> if self.get_input_data("export_per_questionnaire") and (len(fields_description) > 1): # path_questionnaire = str(questionnaire_id) questionnaire_code = self.get_questionnaire_code_from_id(questionnaire_id) questionnaire_title = self.get_title_reduced(questionnaire_id=questionnaire_id) path_questionnaire = "%s_%s" % (str(questionnaire_code), questionnaire_title) error_msg, export_path = create_directory(path_per_questionnaire, path_questionnaire) if error_msg != "": return error_msg export_filename = "%s_%s.csv" % (questionnaire["prefix_filename_responses"], str(questionnaire_code)) export_directory = path.join(export_per_questionnaire_directory, path_questionnaire) complete_filename = path.join(export_path, export_filename) save_to_csv(complete_filename, fields_description) # create questionnaire fields file ("fields.csv") fields = self.get_questionnaire_fields(questionnaire_id) questionnaire_fields = self.create_questionnaire_explanation_fields_file(questionnaire_id, language, questionnaire_lime_survey, fields) self.files_to_zip_list.append([complete_filename, export_directory]) export_filename = "%s_%s.csv" % (questionnaire["prefix_filename_fields"], str(questionnaire_code)) export_directory = path.join(export_metadata_directory, path_questionnaire) complete_filename = path.join(export_path, export_filename) save_to_csv(complete_filename, questionnaire_fields) self.files_to_zip_list.append([complete_filename, export_directory]) questionnaire_lime_survey.release_session_key() return error_msg
def survey_update_sensitive_questions(request, survey_id, template_name="survey/survey_sensitive_fields.html"): survey = get_object_or_404(Survey, pk=survey_id) surveys = Questionnaires() language = get_questionnaire_language(surveys, survey.lime_survey_id, request.LANGUAGE_CODE) survey_title = surveys.get_survey_title(survey.lime_survey_id, language) limesurvey_available = check_limesurvey_access(request, surveys) current_selected_fields = SensitiveQuestion.objects.filter(survey=survey) field_code = get_survey_header(surveys, survey, language, 'code') field_text = get_survey_header(surveys, survey, language, 'full') surveys.release_session_key() counter = 0 available_fields = [] while counter < len(field_code): if field_code[counter] not in questionnaire_evaluation_fields_excluded: available_fields.append( {'code': field_code[counter], 'text': field_text[counter], 'checked': current_selected_fields.filter(code=field_code[counter]).exists()}) counter += 1 if request.method == "POST": if request.POST['action'] == "save": changed = False # for each available fields for field in available_fields: field_code = field['code'] field_text = field['text'] # field was selected if "field_" + str(field_code) in request.POST and request.POST["field_" + str(field_code)] == 'on': # field not in current configuration if not current_selected_fields.filter(code=str(field_code)).exists(): # Add itens selected SensitiveQuestion.objects.create(survey=survey, code=field_code, question=field_text) changed = True else: # field in current configuration if current_selected_fields.filter(code=str(field_code)).exists(): current_selected_fields.filter(code=str(field_code)).delete() changed = True # Exclude unknown items unkown_items = SensitiveQuestion.objects.filter(survey=survey).exclude( code__in=[field['code'] for field in available_fields]) if unkown_items.exists(): unkown_items.delete() changed = True if changed: messages.success(request, _('Questionnaire was updated successfully.')) else: messages.success(request, _('There are no changes to save.')) redirect_url = reverse("survey_view", args=(survey.id,)) return HttpResponseRedirect(redirect_url) context = { "available_fields": available_fields, "limesurvey_available": limesurvey_available, "survey": survey, "survey_title": survey_title} return render(request, template_name, context)
def get_questionnaire_fields(questionnaire_code_list, language_current="pt-BR"): """ :param questionnaire_code_list: list with questionnaire id to be formatted with json file :return: 1 list: questionnaires_included - questionnaire_id that was included in the .txt file """ questionnaires_included = [] questionnaire_lime_survey = Questionnaires() for questionnaire in questionnaire_code_list: questionnaire_id = questionnaire["sid"] language_new = get_questionnaire_language(questionnaire_lime_survey, questionnaire_id, language_current) # get a valid token (anyone) survey = Survey.objects.filter(lime_survey_id=questionnaire_id).first() token_id = QuestionnaireResponse.objects.filter(survey=survey).first().token_id token = questionnaire_lime_survey.get_participant_properties(questionnaire_id, token_id, "token") responses_string = questionnaire_lime_survey.get_header_response(questionnaire_id, language_new, token) questionnaire_title = questionnaire_lime_survey.get_survey_title(questionnaire_id, language_new) # print("id: %d " % questionnaire_id) if not isinstance(responses_string, dict): record_question = {'sid': questionnaire_id, "title": questionnaire_title, "output_list": []} questionnaire_questions = perform_csv_response(responses_string) responses_full = questionnaire_lime_survey.get_header_response(questionnaire_id, language_new, token, heading_type='full') questionnaire_questions_full = perform_csv_response(responses_full) index = 0 # line 0 - header information for question in questionnaire_questions[0]: if question not in questionnaire_evaluation_fields_excluded: # properties = questionnaire_lime_survey.get_question_properties(question, language) # record_question["output_list"].append({"field": question, # "header": question}) description = questionnaire_questions_full[0][index] # if len(description)+3+len(question) > 120: # length = 120 - (3+len(question)) # # description_part1 = description[:length-30] # description_part2 = description[-25:] # description = description_part1 + "..." + description_part2 record_question["output_list"].append({"field": question, "header": question, "description": description }) index += 1 questionnaires_included.append(record_question) questionnaire_lime_survey.release_session_key() return questionnaires_included
def get_questionnaire_responses(language_code, lime_survey_id, token_id, request): groups_of_questions = [] surveys = Questionnaires() token = surveys.get_participant_properties(lime_survey_id, token_id, "token") question_properties = [] groups = surveys.list_groups(lime_survey_id) # defining language to be showed languages = surveys.get_survey_languages(lime_survey_id) # language to be showed can be the base language, or... language = languages['language'] # ...can be one of the additional languages if language.lower() != language_code.lower( ) and languages['additional_languages']: # search for the right language in addional languages, # considering that the LimeSurvey uses upper case in the two-letter language code, like en-US and pt-BR. additional_languages_list = languages['additional_languages'].split( ' ') additional_languages_list_lower = [ item.lower() for item in additional_languages_list ] if language_code.lower() in additional_languages_list_lower: index = additional_languages_list_lower.index( language_code.lower()) language = additional_languages_list[index] survey_title = surveys.get_survey_title(lime_survey_id, language) if not isinstance(groups, dict): for group in groups: if 'id' in group and group['id']['language'] == language: question_list = surveys.list_questions(lime_survey_id, group['id']) question_list = sorted(question_list) for question in question_list: properties = surveys.get_question_properties( question, group['id']['language']) # cleaning the question field properties['question'] = re.sub( '{.*?}', '', re.sub('<.*?>', '', properties['question'])) properties['question'] = properties['question'].replace( ' ', '').strip() is_purely_formula = (properties['type'] == '*') and (properties['question'] == '') if not is_purely_formula and properties['question'] != '': if isinstance(properties['subquestions'], dict): question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': properties['question'], 'question_id': properties['title'], 'answer_options': 'super_question', 'type': 'X', # properties['type'], 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) for key, value in sorted( properties['subquestions'].items()): question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': value['question'], 'question_id': properties['title'] + '[' + value['title'] + ']', 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) if properties['other'] == 'Y': question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': _('Other'), 'question_id': properties['title'] + '[other]', 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': True, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) else: question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': properties['question'], 'question_id': properties['title'], 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) else: question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': _("Formula") + " (" + properties['title'] + ")", 'question_id': properties['title'], 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': False }) # Reading from Limesurvey and... responses_string = surveys.get_responses_by_token( lime_survey_id, token, language) # ... transforming to a list: # response_list[0] has the questions # response_list[1] has the answers responses_list = [] if isinstance(responses_string, bytes): reader = csv.reader(StringIO(responses_string.decode()), delimiter=',') for row in reader: responses_list.append(row) previous_question = '' last_super_question = '' last_super_question_index = [] # for question in question_properties: for response in responses_list[0]: questions = [] for question_prop in question_properties: question_id = question_prop['question_id'] if question_id in response: if response.split('[')[0] in question_id: questions.append(question_prop) for question in questions: if question and (question['question_id'] != previous_question): if not question['hidden']: if isinstance(question['answer_options'], str) and \ question['answer_options'] == "super_question": if question['question'] != '' and question[ 'question_id'] != last_super_question: groups_of_questions = add_questionnaire_response_to_group( groups_of_questions, question, '', None, no_response_flag=True) last_super_question = question[ 'question_id'] last_super_question_index = [ len(groups_of_questions) - 1, len(groups_of_questions[-1] ['questionnaire_responses']) - 1 ] else: previous_question = question['question_id'] answer = '' no_response_flag = False # type 'X' means "Text display" if not question['type'] == 'X': # type "1" means "Array dual scale" if question['type'] == '1': answer_list = [] if question[ 'question_id'] + "[1]" in responses_list[ 0]: index = responses_list[0].index( question['question_id'] + "[1]") answer_options = question[ 'answer_options'] answer = question[ 'attributes_lang'][ 'dualscale_headerA'] + ": " if responses_list[1][ index] in answer_options: answer_option = answer_options[ responses_list[1][index]] answer += answer_option[ 'answer'] else: # Sem resposta answer += _('No answer') no_response_flag = True answer_list.append(answer) if question[ 'question_id'] + "[2]" in responses_list[ 0]: index = responses_list[0].index( question['question_id'] + "[2]") answer_options = question[ 'answer_options'] answer = question[ 'attributes_lang'][ 'dualscale_headerB'] + ": " if responses_list[1][ index] in answer_options: answer_option = answer_options[ responses_list[1][index]] answer += answer_option[ 'answer'] else: # Sem resposta answer += _('No answer') no_response_flag = True answer_list.append(answer) groups_of_questions = add_questionnaire_response_to_group( groups_of_questions, question, answer_list, None, no_response_flag) else: link = '' if question[ 'question_id'] in responses_list[ 0]: index = responses_list[0].index( question['question_id']) answer_options = question[ 'answer_options'] if isinstance( answer_options, dict): # type "M" means "Multiple choice" if question['type'] == 'M': answer = responses_list[1][ index] if question['other']: if answer == '': no_response_flag = True else: if answer != 'Y': no_response_flag = True else: if responses_list[1][ index] in answer_options: answer_option = answer_options[ responses_list[1] [index]] answer = answer_option[ 'answer'] else: # Sem resposta answer = _('No answer') no_response_flag = True else: # type "D" means "Date/Time" if question['type'] == 'D': if responses_list[1][ index]: answer = datetime.datetime.strptime( responses_list[1] [index], '%Y-%m-%d %H:%M:%S' ) else: answer = '' no_response_flag = True else: answer = responses_list[1][ index] # type "M" means "Multiple choice" if question['type'] == 'M': if question['other']: if answer == '': no_response_flag = True else: if answer != 'Y': no_response_flag = True if question[ 'type'] == '|' and answer: link = settings.LIMESURVEY['URL_WEB'] + \ '/index.php/admin/responses/sa/browse/fieldname/' + \ str(lime_survey_id) + 'X' + \ str(question['gid']) + 'X' + \ str(question['qid']) + \ '/id/' + responses_list[1][0] + \ '/surveyid/' + str(lime_survey_id) + \ '/downloadindividualfile/' + \ json.loads(answer[1:-1])['name'] groups_of_questions = add_questionnaire_response_to_group( groups_of_questions, question, answer, link, no_response_flag) # checking if the super-question should be unmarked if last_super_question and not no_response_flag \ and question['question_id'].split('[')[0] == last_super_question: mark_off_super_question( groups_of_questions, last_super_question_index) else: messages.error( request, _("LimeSurvey did not find fill data for this questionnaire.")) surveys.release_session_key() return survey_title, groups_of_questions
def build_questionnaire(self, questionnaire_list, language, entrance_questionnaire): questionnaire_lime_survey = Questionnaires() if "questionnaire_language" not in self.data: self.data["questionnaire_language"] = {} if entrance_questionnaire: self.data["questionnaires"] = [] for index, sid, title, field_header_list in questionnaire_list: output_language = get_questionnaire_language(questionnaire_lime_survey, sid, language) languages = questionnaire_lime_survey.get_survey_languages(sid) language_list = [languages['language']] if languages['additional_languages']: additional_language = languages['additional_languages'].split(' ') else: additional_language = [''] for item in additional_language: if item != '': language_list.append(item) if sid not in self.data["questionnaire_language"]: self.data["questionnaire_language"][sid] = { "language_list": language_list, "output_language": output_language, } # if sid not in self.data['questionnaires']: self.data["questionnaires"].append({"id": sid, "prefix_filename_fields": PREFIX_FILENAME_FIELDS, "questionnaire_name": title, "prefix_filename_responses": PREFIX_FILENAME_RESPONSES, "output_list": [], "responses_list": []}) for header, field in field_header_list: output_data = {"header": header, "field": field} self.data["questionnaires"][-1]["output_list"].append(output_data) else: self.data["questionnaires_from_experiments"] = {} for index, group_id, sid, title, field_header_list in questionnaire_list: output_language = get_questionnaire_language(questionnaire_lime_survey, sid, language) languages = questionnaire_lime_survey.get_survey_languages(sid) language_list = [languages['language']] if languages['additional_languages']: additional_language = languages['additional_languages'].split(' ') else: additional_language = [''] for item in additional_language: if item != '': language_list.append(item) if sid not in self.data["questionnaire_language"]: self.data["questionnaire_language"][sid] = { "language_list": language_list, "output_language": output_language, } if group_id not in self.data['questionnaires_from_experiments']: self.data['questionnaires_from_experiments'][group_id] = {} if sid not in self.data['questionnaires_from_experiments'][group_id]: self.data['questionnaires_from_experiments'][group_id][sid] = { "prefix_filename_fields": PREFIX_FILENAME_FIELDS, "questionnaire_name": title, "prefix_filename_responses": PREFIX_FILENAME_RESPONSES, "output_list": [] } for header, field in field_header_list: output_data = {"header": header, "field": field} self.data["questionnaires_from_experiments"][group_id][sid]["output_list"].append(output_data) if sid not in self.data["questionnaire_list"]: self.data["questionnaire_list"].append(sid) questionnaire_lime_survey.release_session_key()
def test_survey_create_with_fileupload_question(self): lime_survey = Questionnaires() sid = None try: # Cria uma nova survey no lime survey title_survey = 'Questionario de teste' sid = lime_survey.add_survey(9999, title_survey, 'en', 'G') # Obtenho o titulo da survey survey_title = lime_survey.get_survey_title(sid) self.assertEqual(survey_title, title_survey) # Verifica se esta ativa survey_active = lime_survey.get_survey_properties(sid, 'active') self.assertEqual(survey_active, 'N') # Obtem uma propriedade - Administrador da Survey survey_admin = lime_survey.get_survey_properties(sid, 'admin') self.assertEqual(survey_admin, None) # Importar grupo de questoes handle_file_import = \ open('quiz/static/quiz/tests/limesurvey_groups_with_fileupload.lsg', 'r') questions_data = handle_file_import.read() questions_id = \ lime_survey.insert_questions(sid, questions_data, 'lsg') self.assertGreaterEqual(questions_id, 1) # Inicia tabela de tokens self.assertEqual(lime_survey.activate_tokens(sid), 'OK') # Ativar survey self.assertEqual(lime_survey.activate_survey(sid), 'OK') # Verifica se esta ativa survey_active = lime_survey.get_survey_properties(sid, 'active') self.assertEqual(survey_active, 'Y') # Request the survey register screen response = self.client.get(reverse('survey_create')) self.assertEqual(response.status_code, 200) # Set survey data # self.data = {'action': 'save', 'title': 'Survey title'} self.data = {'action': 'save', 'questionnaire_selected': sid} # Count the number of surveys currently in database count_before_insert = Survey.objects.all().count() # Add the new survey response = self.client.post(reverse('survey_create'), self.data) self.assertEqual(response.status_code, 302) # Assert if the message is parsed self.assertEqual( response.wsgi_request._messages._queued_messages[0].message, 'O NES não importa arquivos carregados pelo Limesurvey através de questões do tipo \'Envio de arquivo\'. Veja \"Best Pratices and Recommendations\" em https://nes.rtfd.io para mais detalhes.' ) # Count the number of surveys currently in database count_after_insert = Survey.objects.all().count() # Check if it has increased self.assertEqual(count_after_insert, count_before_insert + 1) finally: # Deleta a survey gerada no Lime Survey self.assertEqual(lime_survey.delete_survey(sid), 'OK')
def export_view(request, template_name="export/export_data.html"): export_form = ExportForm(request.POST or None, initial={'title': 'title', 'responses': ['short'], 'headings': 'code'}) # , 'per_participant': False, # 'per_questinnaire': False}) # export_form.per_participant = False # export_form.per_questionnaire = True # context = {} # test with pagination # a = [{"b": "2", "c": "3"}, {"d": "7", "e": "8"}] # b = [1, 2, 3, 4, 5] # c = [7, 9, (4, 3, 2)] # # contact_list = [a, b, c] # # paginator = Paginator(contact_list, 1) # Show 1 info per page # # page = request.GET.get('page') # try: # contacts = paginator.page(page) # except PageNotAnInteger: # # If page is not an integer, deliver first page. # page = 1 # contacts = paginator.page(1) # except EmptyPage: # # If page is out of range (e.g. 9999), deliver last page of results. # page = paginator.num_pages # contacts = paginator.page(paginator.num_pages) # page = 1 # # if page == 1: selected_ev_quest = [] selected_participant = [] selected_diagnosis = [] if request.method == "POST": questionnaires_selected_list = request.POST.getlist('to[]') questionnaires_list = [] # fields = {} previous_questionnaire_id = 0 output_list = [] for questionnaire in questionnaires_selected_list: sid, title, field, header = questionnaire.split("*") sid = int(sid) # transform to integer # # if sid not in fields: # fields[sid] = [] # fields[sid].append(field) if sid != previous_questionnaire_id: if previous_questionnaire_id != 0: output_list = [] questionnaires_list.append([sid, title, output_list]) previous_questionnaire_id = sid output_list.append((field, header)) # get participants list participant_selected_list = request.POST.getlist('patient_selected') participants_list = [] for participant in participant_selected_list: participants_list.append(participant.split("*")) # get diagnosis list diagnosis_selected_list = request.POST.getlist('diagnosis_selected') diagnosis_list = [] for diagnosis in diagnosis_selected_list: diagnosis_list.append(diagnosis.split("*")) selected_data_available = (len(questionnaires_selected_list) or len(participant_selected_list) or len(diagnosis_selected_list)) if selected_data_available: if export_form.is_valid(): print("valid data") per_participant = export_form.cleaned_data['per_participant'] per_questionnaire = export_form.cleaned_data['per_questionnaire'] heading_type = export_form.cleaned_data['headings'] responses_type = export_form.cleaned_data['responses'] questionnaires_list = update_questionnaire_list(questionnaires_list, heading_type, request.LANGUAGE_CODE) # insert participation_code update_participants_list(participants_list, heading_type) update_diagnosis_list(diagnosis_list, heading_type) # output_filename = # "/Users/sueli/PycharmProjects/nes/patientregistrationsystem/qdc/export/json_export_output2.json" # MEDIA_ROOT/export/username_id/export_id # input_export_file = create_initial_directory(request.user) export_instance = create_export_instance(request.user) input_export_file = path.join(EXPORT_DIRECTORY, path.join(str(request.user.id), path.join(str(export_instance.id), str(JSON_FILENAME)))) # copy data to .../media/export/<user_id>/<export_id>/ input_filename = path.join(settings.MEDIA_ROOT, input_export_file) create_directory(settings.MEDIA_ROOT, path.split(input_export_file)[0]) build_complete_export_structure(per_participant, per_questionnaire, participants_list, diagnosis_list, questionnaires_list, responses_type, heading_type, input_filename, request.LANGUAGE_CODE) complete_filename = export_create(request, export_instance.id, input_filename) if complete_filename: messages.success(request, _("Export was finished correctly")) # return file to the user # error_message = "a" # return_response = complete_filename # # redirect_url = reverse("export_result", args=(return_response, error_message)) # return HttpResponseRedirect(redirect_url ) print("antes do fim: httpResponse") zip_file = open(complete_filename, 'rb') response = HttpResponse(zip_file, content_type='application/zip') response['Content-Disposition'] = 'attachment; filename="export.zip"' response['Content-Length'] = path.getsize(complete_filename) return response else: messages.error(request, _("Export data was not generated.")) else: for questionnaire in questionnaires_list: for field in questionnaire[2]: # get output_list selected_ev_quest.append((questionnaire[0], field[0])) for participant in participants_list: selected_participant.append(participant[0]) for diagnosis in diagnosis_list: selected_diagnosis.append(diagnosis[0]) else: messages.error(request, _("No data was select. Export data was not generated.")) # else: # page 1 - list of questionnaires surveys = Questionnaires() limesurvey_available = check_limesurvey_access(request, surveys) questionnaires_list = [] if limesurvey_available: questionnaires_list = surveys.find_all_active_questionnaires() surveys.release_session_key() questionnaires_list_final = [] # removing surveys that are not entrance evaluation # entrance_evaluation_questionnaires = QuestionnaireResponse.objects.all() entrance_evaluation_questionnaire_ids_list = set(QuestionnaireResponse.objects.values_list('survey', flat=True)) # ev_questionnaire_ids_list = entrance_evaluation_questionnaires.values_list("survey") surveys_with_ev_list = Survey.objects.filter(id__in=entrance_evaluation_questionnaire_ids_list) for survey in surveys_with_ev_list: for questionnaire in questionnaires_list: if survey.lime_survey_id == questionnaire['sid']: questionnaires_list_final.append(questionnaire) break # page 2 fields # entrance evaluation questionnarie fields # if len(language_code) > 2: # language_code = "{}-{}".format(language_code[:2],language_code[-2:].upper()) questionnaires_fields_list = get_questionnaire_fields(questionnaires_list_final, request.LANGUAGE_CODE) if len(selected_ev_quest): questionnaire_ids, field_id = zip(*selected_ev_quest) else: questionnaire_ids = () for questionnaire in questionnaires_fields_list: questionnaire["selected_counter"] = questionnaire_ids.count(questionnaire["sid"]) for output_list in questionnaire["output_list"]: if (questionnaire["sid"], output_list["field"]) in selected_ev_quest: output_list["selected"] = True # for field in questionnaires_fields_list: # for questionnaire in questionnaires_list_final: # if field["sid"] == questionnaire['sid']: # field["title"] = questionnaire["surveyls_title"] # break context = { "limesurvey_available": limesurvey_available, "export_form": export_form, # "questionnaires_list": questionnaires_list_final, # "contacts": contacts, "patient_fields": patient_fields, "diagnosis_fields": diagnosis_fields, "questionnaires_fields_list": questionnaires_fields_list, "selected_ev_quest": selected_ev_quest, "selected_participant": selected_participant, "selected_diagnosis": selected_diagnosis, } # elif page == 2: return render(request, template_name, context)
def get_questionnaire_responses(language_code, lime_survey_id, token_id, request): groups_of_questions = [] surveys = Questionnaires() token = surveys.get_participant_properties( lime_survey_id, token_id, "token" ) question_properties = [] groups = surveys.list_groups(lime_survey_id) # defining language to be showed languages = surveys.get_survey_languages(lime_survey_id) # language to be showed can be the base language, or... language = languages['language'] # ...can be one of the additional languages if language.lower() != language_code.lower() and \ languages['additional_languages']: # search for the right language in addional languages, # considering that the LimeSurvey uses upper case in the two-letter # language code, like en-US and pt-BR. additional_languages_list = languages['additional_languages'].split(' ') additional_languages_list_lower = [item.lower() for item in additional_languages_list] if language_code.lower() in additional_languages_list_lower: index = additional_languages_list_lower.index(language_code.lower()) language = additional_languages_list[index] survey_title = surveys.get_survey_title(lime_survey_id, language) if not isinstance(groups, dict): for group in groups: if 'id' in group and group['id']['language'] == language: question_list = surveys.list_questions( lime_survey_id, group['id']['gid'] ) question_list = sorted(question_list) for question in question_list: properties = surveys.get_question_properties( question, group['id']['language'] ) # cleaning the question field properties['question'] = re.sub( '{.*?}', '', re.sub('<.*?>', '', properties['question']) ) properties['question'] = \ properties['question'].replace(' ', '').strip() is_purely_formula = (properties['type'] == '*') and \ (properties['question'] == '') if not is_purely_formula and properties['question'] != '': if isinstance(properties['subquestions'], dict): question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': properties['question'], 'question_id': properties['title'], 'answer_options': 'super_question', 'type': 'X', 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) for key, value in sorted( properties['subquestions'].items() ): question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': value['question'], 'question_id': properties['title'] + '[' + value['title'] + ']', 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) if properties['other'] == 'Y': question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': _('Other'), 'question_id': properties['title'] + '[other]', 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': True, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) else: question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': properties['question'], 'question_id': properties['title'], 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': 'hidden' in properties['attributes'] and properties['attributes']['hidden'] == '1' }) else: question_properties.append({ 'gid': group['id']['gid'], 'group_name': group['group_name'], 'qid': question, 'question': _("Formula") + " (" + properties['title'] + ")", 'question_id': properties['title'], 'answer_options': properties['answeroptions'], 'type': properties['type'], 'other': False, 'attributes_lang': properties['attributes_lang'], 'hidden': False }) # Reading from Limesurvey and... responses_string = surveys.get_responses_by_token( lime_survey_id, token, language ) # ... transforming to a list: responses_list = [] if isinstance(responses_string, bytes): reader_ = csv.reader( StringIO(responses_string.decode()), delimiter=',' ) for row in reader_: responses_list.append(row) previous_question = '' last_super_question = '' last_super_question_index = [] # for question in question_properties: for response in responses_list[0]: questions = [] for question_prop in question_properties: question_id = question_prop['question_id'] if question_id in response: if response.split('[')[0] in question_id: questions.append(question_prop) for question in questions: if question and \ (question['question_id'] != previous_question): if not question['hidden']: if isinstance(question['answer_options'], str) \ and question['answer_options'] == \ "super_question": if question['question'] != '' and \ question['question_id'] != \ last_super_question: groups_of_questions = \ add_questionnaire_response_to_group( groups_of_questions, question, '', None, no_response_flag=True ) last_super_question = \ question['question_id'] last_super_question_index = [ len(groups_of_questions) - 1, len(groups_of_questions[-1] ['questionnaire_responses']) - 1] else: previous_question = question['question_id'] answer = '' no_response_flag = False # type 'X' means "Text display" if not question['type'] == 'X': # type "1" means "Array dual scale" if question['type'] == '1': answer_list = [] if question['question_id'] + "[1]" in \ responses_list[0]: index = \ responses_list[0].index( question['question_id'] + "[1]" ) answer_options = \ question['answer_options'] answer = \ question['question_id'] + "[1]: " if responses_list[1][index] in \ answer_options: answer_option = \ answer_options[responses_list[1][index]] answer += \ answer_option['answer'] else: # Sem resposta answer += _('No answer') no_response_flag = True answer_list.append(answer) if question['question_id'] + "[2]" in \ responses_list[0]: index = \ responses_list[0].index( question['question_id'] + "[2]" ) answer_options = \ question['answer_options'] answer = \ question['question_id'] + "[2]: " if responses_list[1][index] in \ answer_options: answer_option = \ answer_options[responses_list[1][index]] answer += \ answer_option['answer'] else: # sem resposta answer += _('No answer') no_response_flag = True answer_list.append(answer) groups_of_questions =\ add_questionnaire_response_to_group( groups_of_questions, question, answer_list, None, no_response_flag ) else: link = '' if question['question_id'] in \ responses_list[0]: index = \ responses_list[0].index(question['question_id']) answer_options = question['answer_options'] if isinstance(answer_options, dict): # type "M" means "Multiple # choice" if question['type'] == 'M': answer = responses_list[1][index] if question['other']: if answer == '': no_response_flag = True else: if answer != 'Y': no_response_flag = True else: if responses_list[1][index] in \ answer_options: answer_option = \ answer_options[responses_list[1][index]] answer = \ answer_option['answer'] else: # sem resposta answer = _('No answer') no_response_flag = True else: # type "D" means "Date/Time" if question['type'] == 'D': if responses_list[1][index]: answer = \ datetime.datetime.strptime( responses_list[1][index], '%Y-%m-%d %H:%M:%S' ) else: answer = '' no_response_flag = True else: answer = responses_list[1][index] # type "M" means "Multiple choice" if question['type'] == 'M': if question['other']: if answer == '': no_response_flag = True else: if answer != 'Y': no_response_flag = True # not show fileupload questions if question['type'] != '|': groups_of_questions = \ add_questionnaire_response_to_group( groups_of_questions, question, answer, link, no_response_flag ) # checking if the super-question # should be unmarked if last_super_question and not \ no_response_flag and \ question['question_id'].split('[')[0] \ == last_super_question: mark_off_super_question( groups_of_questions, last_super_question_index ) else: messages.error( request, _("LimeSurvey did not find fill data for this questionnaire.") ) surveys.release_session_key() return survey_title, groups_of_questions
def test_find_questionnaire_by_id_method_not_found_survey_by_string(self): questionnaires = Questionnaires() self.assertEqual(None, questionnaires.find_questionnaire_by_id('three')) questionnaires.release_session_key()
def test_find_questionnaire_by_id_method_found_survey(self): questionnaires = Questionnaires() list_survey = self.server.list_surveys(self.session_key, None) self.server.release_session_key(self.session_key) self.assertEqual(questionnaires.find_questionnaire_by_id(list_survey[3]['sid']), list_survey[3]) questionnaires.release_session_key()