Produits Entr'ouvert » w.c.s.

def test_form_edit_string_field_validation(pub):

    create_superuser(pub)

    create_role()

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'form title'

    formdef.fields = [fields.StringField(id='1', label='1st field', type='string')]

    formdef.store()

    app = login(get_app(pub))

    resp = app.get('/backoffice/forms/1/')

    resp = resp.click(href='fields/')

    assert '1st field' in resp.body

    resp = resp.click('Edit', href='1/')

    resp.form['validation$type'] = 'Regular Expression'

    resp.form['validation$value_regex'] = r'\d+'

    resp = resp.form.submit('submit').follow()

    assert FormDef.get(formdef.id).fields[0].validation == {'type': 'regex', 'value': r'\d+'}

    resp = resp.click('Edit', href='1/')

    resp.form['validation$type'] = 'Django Condition'

    resp.form['validation$value_django'] = 'value|decimal < 20'

    resp = resp.form.submit('submit').follow()

    assert FormDef.get(formdef.id).fields[0].validation == {'type': 'django', 'value': 'value|decimal < 20'}

    resp = resp.click('Edit', href='1/')

    resp.form['validation$type'] = 'Django Condition'

    resp.form['validation$value_django'] = '{{ value|decimal < 20 }}'

    resp = resp.form.submit('submit')

    assert 'syntax error' in resp.body

        validation={'type': 'regex', 'value': r'\d{5}$'}, required=False)]

    assert 'invalid value' in resp.body

def test_wcsextrastringwidget_regex_validation():

    fakefield.validation = {'type': 'regex', 'value': r'\d+'}

    fakefield.validation = {'type': 'regex', 'value': r'\d+(\.\d{1,2})?'}

def test_wcsextrastringwidget_builtin_validation():

    class FakeField: pass

    fakefield = FakeField()

    fakefield.validation = {'type': 'digits'}

    widget = WcsExtraStringWidget('test', value='foo', required=False)

    widget.field = fakefield

    mock_form_submission(req, widget, {'test': '12'})

    assert not widget.has_error()

    widget = WcsExtraStringWidget('test', value='foo', required=False)

    widget.field = fakefield

    mock_form_submission(req, widget, {'test': 'az'})

    assert widget.has_error()

    fakefield.validation = {'type': 'zipcode-fr'}

    widget = WcsExtraStringWidget('test', value='foo', required=False)

    widget.field = fakefield

    mock_form_submission(req, widget, {'test': '12345'})

    assert not widget.has_error()

    widget = WcsExtraStringWidget('test', value='foo', required=False)

    widget.field = fakefield

    mock_form_submission(req, widget, {'test': '1234'})

    assert widget.has_error()

def test_wcsextrastringwidget_django_validation():

    class FakeField: pass

    fakefield = FakeField()

    fakefield.validation = {'type': 'django', 'value': 'value|decimal and value|decimal < 20'}

    widget = WcsExtraStringWidget('test', value='foo', required=False)

    widget.field = fakefield

    mock_form_submission(req, widget, {'test': '12'})

    assert not widget.has_error()

    widget = WcsExtraStringWidget('test', value='foo', required=False)

    widget.field = fakefield

    mock_form_submission(req, widget, {'test': '35'})

    assert widget.has_error()

    widget = WcsExtraStringWidget('test', value='foo', required=False)

    widget.field = fakefield

    mock_form_submission(req, widget, {'test': 'az'})

    assert widget.has_error()

        form.add(ValidationWidget, 'validation', title=_('Validation'),

                 value=self.validation, advanced=(not self.validation))

    def migrate(self):

        if isinstance(self.validation, basestring):

            self.validation = {'type': 'regex', 'value': self.validation}

            return True

        return False

    def init_with_xml(self, element, charset, include_id=False):

        super(StringField, self).init_with_xml(element, charset, include_id=include_id)

        self.migrate()

class ValidationCondition(Condition):

    def __init__(self, django_condition, value):

        super(ValidationCondition, self).__init__({'type': 'django', 'value': django_condition})

        self.evaluated_value = value

    def get_data(self):

        return {'value': self.evaluated_value}

class ValidationWidget(CompositeWidget):

    validation_methods = collections.OrderedDict([

        ('digits', {'title': N_('Digits'), 'regex': '\d+'}),

        ('phone-fr', {'title': N_('Phone Number (France)'), 'regex': '0[\d\.\s]{9}'}),

        ('zipcode-fr', {'title': N_('Zip Code (France)'), 'regex': '\d{5}'}),

        ('regex', {'title': N_('Regular Expression')}),

        ('django', {'title': N_('Django Condition')}),

    ])

    def __init__(self, name, value=None, **kwargs):

        super(ValidationWidget, self).__init__(name, value=value, **kwargs)

        if not value:

            value = {}

        options = [('none', _('None'))] + [(x, _(y['title'])) for x, y in self.validation_methods.items()]

        self.add(SingleSelectWidget, 'type', options=options, value=value.get('type'),

                 attrs={'data-dynamic-display-parent': 'true'})

        self.parse()

        if not self.value:

            self.value = {}

        validation_labels = collections.OrderedDict(options)

        self.add(RegexStringWidget, 'value_regex', size=80,

                 value=value.get('value') if value.get('type') == 'regex' else None,

                 attrs={'data-dynamic-display-child-of': 'validation$type',

                        'data-dynamic-display-value': validation_labels.get('regex')})

        self.add(DjangoConditionWidget, 'value_django', size=80,

                 value=value.get('value') if value.get('type') == 'django' else None,

                 attrs={'data-dynamic-display-child-of': 'validation$type',

                        'data-dynamic-display-value': validation_labels.get('django')})

        self._parsed = False

    def _parse(self, request):

        values = {}

        type_ = self.get('type')

        if type_:

            values['type'] = type_

            value = self.get('value_%s' % type_)

            if value:

                values['value'] = value

        self.value = values or None

    def render_content(self):

        r = TemplateIO(html=True)

        for widget in self.get_widgets():

            r += widget.render_error(widget.get_error())

        for widget in self.get_widgets():

            r += widget.render_content()

        return r.getvalue()

    @classmethod

    def get_validation_function(cls, validation):

        pattern = cls.get_validation_pattern(validation)

        if pattern:

            def regex_validation(value):

                match = re.match(pattern, value)

                return bool(match and match.group() == value)

            return regex_validation

        if validation['type'] == 'django':

            def django_validation(value):

                condition = ValidationCondition(validation['value'], value=value)

                return condition.evaluate()

            return django_validation

    @classmethod

    def get_validation_pattern(cls, validation):

        validation_method = cls.validation_methods.get(validation['type'])

        if validation_method and validation_method.get('regex'):

            return validation_method.get('regex')

        if validation['type'] == 'regex':

            return validation['value']

        return None

            pattern = ValidationWidget.get_validation_pattern(self.field.validation)

            if pattern:

                self.attrs['pattern'] = pattern

        return super(WcsExtraStringWidget, self).render_content()

            validation_function = ValidationWidget.get_validation_function(self.field.validation)

            if not validation_function(self.value):

                self.error = _('invalid value')

class DjangoConditionWidget(StringWidget):

    def _parse(self, request):

        super(DjangoConditionWidget, self)._parse(request)

        if self.value:

            try:

                Condition({'type': 'django', 'value': self.value}).validate()

            except ValidationError as e:

                self.set_error(str(e))