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_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 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 _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 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 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_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 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 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 _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_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 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_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 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) surveys.release_session_key() if created: messages.success(request, _('Questionnaire created successfully.')) redirect_url = reverse("survey_list") return HttpResponseRedirect(redirect_url) if limesurvey_available: questionnaires_list = surveys.find_all_active_questionnaires() 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.')) surveys.release_session_key() context = { "survey_form": survey_form, "creating": True, "editing": True, "questionnaires_list": questionnaires_list, 'limesurvey_available': limesurvey_available } return render(request, template_name, context)
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 _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 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 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_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 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 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 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 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 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() 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) has_file_upload_question = is_type_of_question_in_survey( surveys=surveys, survey=survey, type="|" ) surveys.release_session_key() if created: if has_file_upload_question: messages.warning(request, _('NES can\'t retrieve files from \"file upload\" ' 'questions from LimeSurvey.') + ' ' + _('See \"Best Pratices and Recommendations\" at ' 'https://nes.rtfd.io for more details.')) messages.success(request, _('Questionnaire created successfully.')) redirect_url = reverse("survey_list") return HttpResponseRedirect(redirect_url) surveys.release_session_key() context = { "survey_form": survey_form, "creating": True, "editing": True, "questionnaires_list": questionnaires_list, 'limesurvey_available': limesurvey_available } return render(request, template_name, context)
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 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()
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 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 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 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 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): 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 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_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