Ejemplo n.º 1
0
    def clean_acronym(self, raise_warnings=False):
        if not self.acronym:
            return

        egy_using_same_acronym = EducationGroupYear.objects. \
            filter(acronym=self.acronym.upper()).exclude(education_group=self.education_group_id)

        # Groups can reuse acronym of other groups
        if self.education_group_type.category == education_group_categories.GROUP:
            egy_using_same_acronym = egy_using_same_acronym. \
                exclude(education_group_type__category=education_group_categories.GROUP)

        egy_using_same_acronym = egy_using_same_acronym.get_nearest_years(self.academic_year.year)

        if egy_using_same_acronym["futur"]:
            raise ValidationError({
                'acronym': _("Acronym already exists in %(academic_year)s") % {
                    "academic_year": self.format_year_to_academic_year(egy_using_same_acronym["futur"])
                }
            })

        if raise_warnings and egy_using_same_acronym["past"]:
            raise ValidationWarning({
                'acronym': _("Acronym existed in %(academic_year)s") % {
                    "academic_year": self.format_year_to_academic_year(egy_using_same_acronym["past"])
                }
            })
Ejemplo n.º 2
0
    def clean_partial_acronym(self, raise_warnings=False):
        if not self.partial_acronym:
            return

        egy_using_same_partial_acronym = EducationGroupYear.objects. \
            filter(partial_acronym=self.partial_acronym.upper()). \
            exclude(education_group=self.education_group_id). \
            get_nearest_years(self.academic_year.year)

        if egy_using_same_partial_acronym["futur"]:
            raise ValidationError({
                'partial_acronym':
                _("Partial acronym already exists in %(academic_year)s") % {
                    "academic_year":
                    self.format_year_to_academic_year(
                        egy_using_same_partial_acronym["futur"])
                }
            })

        my_validation_rule = self.rules.get('partial_acronym')
        if my_validation_rule and not bool(
                re.match(my_validation_rule.regex_rule, self.partial_acronym)):
            raise ValidationError(
                {'partial_acronym': _("Partial acronym is invalid")})

        if raise_warnings and egy_using_same_partial_acronym["past"]:
            raise ValidationWarning({
                'partial_acronym':
                _("Partial acronym existed in %(academic_year)s") % {
                    "academic_year":
                    self.format_year_to_academic_year(
                        egy_using_same_partial_acronym["past"])
                }
            })
Ejemplo n.º 3
0
    def test_response_should_contain_error_message_when_field_not_valid(self):
        self.mocked_clean_acronym.side_effect = ValidationError({"acronym": "error acronym"})
        self.mocked_clean_partial_acronym.side_effect = ValidationWarning({"partial_acronym": "error partial"})

        response = self.client.get(
            self.url,
            data={"academic_year": self.academic_year.pk, "acronym": "TEST"},
            HTTP_X_REQUESTED_WITH='XMLHttpRequest'
        )
        self.assertJSONEqual(
            str(response.content, encoding='utf8'),
            {"acronym": {"msg": "error acronym", "level": messages.DEFAULT_TAGS[messages.ERROR]},
             "partial_acronym": {"msg": "error partial", "level": messages.DEFAULT_TAGS[messages.WARNING]}}
        )