def test_should_invalidate_special_characters_sent_for_choice(self): with self.assertRaises(AnswerNotInListException): constraint = ChoiceConstraint( single_select_constraint=False, list_of_valid_choices=["village", "urban", "city", "country"], code="Q1") constraint.validate("a!b")
def test_should_not_validate_wrong_choice(self): with self.assertRaises(AnswerNotInListException): constraint = ChoiceConstraint( single_select_constraint=True, list_of_valid_choices=["village", "urban"], code="Q1") constraint.validate("c")
def test_should_not_validate_no_values_sent_for_choice(self): with self.assertRaises(AnswerHasNoValuesException): constraint = ChoiceConstraint( single_select_constraint=True, list_of_valid_choices=["village", "urban"], code="Q1") constraint.validate("")
def test_should_validate_multiple_choice(self): constraint = ChoiceConstraint( single_select_constraint=False, list_of_valid_choices=["village", "urban"], code="Q1") v_data = constraint.validate("ab") self.assertEquals(v_data, ["village", "urban"])
def test_should_invalidate_answer_with_2_numbers(self): valid_choices = [ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "1a", "1b", "1c" ] with self.assertRaises(AnswerNotInListException): constraint = ChoiceConstraint(single_select_constraint=False, list_of_valid_choices=valid_choices, code="Q1") constraint.validate("abc1b341c")
def test_should_not_validate_wrong_choice(self): with self.assertRaises(AnswerNotInListException): valid_choices = [ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "1a", "1b", "1c" ] constraint = ChoiceConstraint(single_select_constraint=True, list_of_valid_choices=valid_choices, code="Q1") constraint.validate("1d")
def test_should_not_validate_answer_with_one_letter_followed_by_one_number_on_a_single_choice( self): valid_choices = [ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "1a", "1b", "1c" ] with self.assertRaises(AnswerNotInListException): constraint = ChoiceConstraint(single_select_constraint=True, list_of_valid_choices=valid_choices, code="Q1") constraint.validate("a1")
def test_should_not_validate_multiple_values_sent_for_single_choice(self): with self.assertRaises(AnswerHasTooManyValuesException): valid_choices = [ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "1a", "1b", "1c" ] constraint = ChoiceConstraint(single_select_constraint=True, list_of_valid_choices=valid_choices, code="Q1") self.assertEqual(constraint.validate("1b"), ['1b']) constraint.validate("a1a")
def __init__(self, name, code, label, options, ddtype, instruction=None, language=field_attributes.DEFAULT_LANGUAGE, single_select_flag=True): assert len(options) > 0 type = field_attributes.SELECT_FIELD if single_select_flag else field_attributes.MULTISELECT_FIELD self.SINGLE_SELECT_FLAG = single_select_flag Field.__init__(self, type=type, name=name, code=code, label=label, language=language, ddtype=ddtype, instruction=instruction) self._dict[self.OPTIONS] = [] valid_choices = self._dict[self.OPTIONS] if options is not None: for option in options: if isinstance(option, tuple): single_language_specific_option = { 'text': { language: option[0] }, 'val': option[1] } elif isinstance(option, dict): single_language_specific_option = option else: single_language_specific_option = { 'text': { language: option } } valid_choices.append(single_language_specific_option) self.constraint = ChoiceConstraint( list_of_valid_choices=[ each.get('text').get(language) for each in valid_choices ], single_select_constraint=single_select_flag, code=code)
def __init__(self, name, code, label, options, instruction=None, single_select_flag=True, required=True, parent_field_code=None, has_other=False): assert len(options) > 0 type = field_attributes.SELECT_FIELD if single_select_flag else field_attributes.MULTISELECT_FIELD self.single_select_flag = single_select_flag Field.__init__(self, type=type, name=name, code=code, label=label, instruction=instruction, required=required, parent_field_code=parent_field_code) self._dict[self.OPTIONS] = [] valid_choices = self._dict[self.OPTIONS] if has_other: self._dict['has_other'] = has_other if options is not None: for option in options: if isinstance(option, tuple): single_language_specific_option = { 'text': option[0], 'val': option[1] } elif isinstance(option, dict): single_language_specific_option = option else: single_language_specific_option = { 'text': option, 'val': option } valid_choices.append(single_language_specific_option) self.constraint = ChoiceConstraint( list_of_valid_choices=valid_choices, single_select_constraint=single_select_flag, code=code, has_other=has_other)
class SelectField(Field): OPTIONS = "choices" def __init__(self, name, code, label, options, ddtype, instruction=None, language=field_attributes.DEFAULT_LANGUAGE, single_select_flag=True): assert len(options) > 0 type = field_attributes.SELECT_FIELD if single_select_flag else field_attributes.MULTISELECT_FIELD self.SINGLE_SELECT_FLAG = single_select_flag Field.__init__(self, type=type, name=name, code=code, label=label, language=language, ddtype=ddtype, instruction=instruction) self._dict[self.OPTIONS] = [] valid_choices = self._dict[self.OPTIONS] if options is not None: for option in options: if isinstance(option, tuple): single_language_specific_option = {'text': {language: option[0]}, 'val': option[1]} elif isinstance(option, dict): single_language_specific_option = option else: single_language_specific_option = {'text': {language: option}} valid_choices.append(single_language_specific_option) self.constraint = ChoiceConstraint( list_of_valid_choices=[each.get('text').get(language) for each in valid_choices], single_select_constraint=single_select_flag, code=code) SINGLE_SELECT_FLAG = 'single_select_flag' def validate(self, value): return self.constraint.validate(answer=value) @property def options(self): return self._dict.get(self.OPTIONS) def _to_json_view(self): dict = self._dict.copy() option_list = [] for option in self.options: option_text = option["text"][field_attributes.DEFAULT_LANGUAGE] option_list.append({"text": option_text, "val": option.get("val")}) dict['choices'] = option_list dict['ddtype'] = dict['ddtype'].to_json() return dict def to_html(self): options_html = "" for option in self.options: options_html += '<option value="%s">%s</option>' % (option['val'], option['text']['eng'], ) multiple_select = '' if self.SINGLE_SELECT_FLAG else 'MULTIPLE' return '<select name="%s" %s>%s</select>' % (self.name, multiple_select, options_html)
def __init__(self, name, code, label, options, ddtype, instruction=None, language=field_attributes.DEFAULT_LANGUAGE, single_select_flag=True): assert len(options) > 0 type = field_attributes.SELECT_FIELD if single_select_flag else field_attributes.MULTISELECT_FIELD self.SINGLE_SELECT_FLAG = single_select_flag Field.__init__(self, type=type, name=name, code=code, label=label, language=language, ddtype=ddtype, instruction=instruction) self._dict[self.OPTIONS] = [] valid_choices = self._dict[self.OPTIONS] if options is not None: for option in options: if isinstance(option, tuple): single_language_specific_option = {'text': {language: option[0]}, 'val': option[1]} elif isinstance(option, dict): single_language_specific_option = option else: single_language_specific_option = {'text': {language: option}} valid_choices.append(single_language_specific_option) self.constraint = ChoiceConstraint( list_of_valid_choices=[each.get('text').get(language) for each in valid_choices], single_select_constraint=single_select_flag, code=code)
def test_should_invalidate_special_characters_sent_for_choice(self): with self.assertRaises(AnswerNotInListException): constraint = ChoiceConstraint(single_select_constraint=False, list_of_valid_choices=["village", "urban", "city", "country"], code="Q1") constraint.validate("a!b")
def test_should_not_validate_no_values_sent_for_choice(self): with self.assertRaises(AnswerHasNoValuesException): constraint = ChoiceConstraint(single_select_constraint=True, list_of_valid_choices=["village", "urban"], code="Q1") constraint.validate("")
def test_should_validate_multiple_choice(self): constraint = ChoiceConstraint(single_select_constraint=False, list_of_valid_choices=["village", "urban"], code="Q1") v_data = constraint.validate("ab") self.assertEquals(v_data, ["village", "urban"])
class SelectField(Field): '''option values for this should contain single letters like a,b,c,d etc and after 26 options should start with a number followed by single character like 1a,1b,1c,1d etc ''' OPTIONS = "choices" def __init__(self, name, code, label, options, instruction=None, single_select_flag=True, required=True, parent_field_code=None, has_other=False): assert len(options) > 0 type = field_attributes.SELECT_FIELD if single_select_flag else field_attributes.MULTISELECT_FIELD self.single_select_flag = single_select_flag Field.__init__(self, type=type, name=name, code=code, label=label, instruction=instruction, required=required, parent_field_code=parent_field_code) self._dict[self.OPTIONS] = [] valid_choices = self._dict[self.OPTIONS] if has_other: self._dict['has_other'] = has_other if options is not None: for option in options: if isinstance(option, tuple): single_language_specific_option = { 'text': option[0], 'val': option[1] } elif isinstance(option, dict): single_language_specific_option = option else: single_language_specific_option = { 'text': option, 'val': option } valid_choices.append(single_language_specific_option) self.constraint = ChoiceConstraint( list_of_valid_choices=valid_choices, single_select_constraint=single_select_flag, code=code, has_other=has_other) SINGLE_SELECT_FLAG = 'single_select_flag' def validate(self, value): Field.validate(self, value) return self.constraint.validate(answer=value) @property def options(self): return self._dict.get(self.OPTIONS) def _to_json_view(self): dict = self._dict.copy() return dict @property def has_other(self): return self._dict.get('has_other') def get_constraint_text(self): return [option["text"] for option in self.options] def convert_to_unicode(self): if self.value is None: return unicode("") return unicode(",".join([unicode(i) for i in self.value])) if isinstance( self.value, list) else unicode(self.value) # def _get_value_by_option(self, option): # for opt in self.options: # opt_text = opt['text'] # opt_value = opt['val'] # if opt_value.lower() == option.lower(): # return opt_text # return None @property def is_single_select(self): return self.type == "select1" def get_value_by_option(self, option, default=None): for opt in self.options: opt_text = opt['text'] opt_value = opt['val'] if opt_value.lower() == option.lower(): return opt_text return default def get_option_value_list(self, question_value): # if isinstance(question_value, list) and question_value[0] == 'other': # if self.is_single_select: # return [question_value[1]] # else: # question_value = ','.join(question_value[1].split(' ')) options = self.get_option_list(question_value) result = [] for option in options: option_value = self.get_value_by_option(option, default=option) if option_value: result.append(option_value) return result def get_option_list(self, question_value): if question_value is None: return [] question_value = question_value.lower() if ',' in question_value: responses = question_value.split(',') responses = [r.strip() for r in responses] elif ' ' in question_value: responses = question_value.split(' ') elif question_value in [ item.get('val') for item in self._dict[self.OPTIONS] ]: # yes in ['yes','no'] responses = [question_value] elif self.has_other and question_value == 'other': responses = ['other'] else: responses = re.findall(r'[1-9]?[a-zA-Z]', question_value) return responses def formatted_field_values_for_excel(self, value): if value is None: return [] options = self.get_option_list(value) result = [] for option in options: option_value = self.get_value_by_option(option) if option_value: result.append(option_value) return result def get_options_map(self): options_map = {} for option in self.options: options_map.update({option['val']: option['text']}) return options_map def escape_option_text(self): for option in self._dict.get(self.OPTIONS): option['text'] = escape(option['text'])
def test_should_not_validate_wrong_choice(self): with self.assertRaises(AnswerNotInListException): constraint = ChoiceConstraint(single_select_constraint=True, list_of_valid_choices=["village", "urban"], code="Q1") constraint.validate("c")
class SelectField(Field): OPTIONS = "choices" def __init__(self, name, code, label, options, ddtype, instruction=None, language=field_attributes.DEFAULT_LANGUAGE, single_select_flag=True): assert len(options) > 0 type = field_attributes.SELECT_FIELD if single_select_flag else field_attributes.MULTISELECT_FIELD self.SINGLE_SELECT_FLAG = single_select_flag Field.__init__(self, type=type, name=name, code=code, label=label, language=language, ddtype=ddtype, instruction=instruction) self._dict[self.OPTIONS] = [] valid_choices = self._dict[self.OPTIONS] if options is not None: for option in options: if isinstance(option, tuple): single_language_specific_option = { 'text': { language: option[0] }, 'val': option[1] } elif isinstance(option, dict): single_language_specific_option = option else: single_language_specific_option = { 'text': { language: option } } valid_choices.append(single_language_specific_option) self.constraint = ChoiceConstraint( list_of_valid_choices=[ each.get('text').get(language) for each in valid_choices ], single_select_constraint=single_select_flag, code=code) SINGLE_SELECT_FLAG = 'single_select_flag' def validate(self, value): return self.constraint.validate(answer=value) @property def options(self): return self._dict.get(self.OPTIONS) def _to_json_view(self): dict = self._dict.copy() option_list = [] for option in self.options: option_text = option["text"][field_attributes.DEFAULT_LANGUAGE] option_list.append({"text": option_text, "val": option.get("val")}) dict['choices'] = option_list dict['ddtype'] = dict['ddtype'].to_json() return dict def to_html(self): options_html = "" for option in self.options: options_html += '<option value="%s">%s</option>' % ( option['val'], option['text']['eng'], ) multiple_select = '' if self.SINGLE_SELECT_FLAG else 'MULTIPLE' return '<select name="%s" %s>%s</select>' % ( self.name, multiple_select, options_html)