0001-forms-add-post-conditions-to-page-fields-8962.patch

         assert resp.location == 'http://example.net/backoffice/forms/1/fields/'
         assert FormDef.get(1).fields[0].items == ['XXX']
     def test_form_edit_page_field(pub):
         create_superuser(pub)
         create_role()
         FormDef.wipe()
         formdef = FormDef()
         formdef.name = 'form title'
         formdef.fields = []
         formdef.store()
         app = login(get_app(pub))
         resp = app.get('/backoffice/forms/1/')
         resp = resp.click(href='fields/')
         assert 'There are not yet any fields for this form' in resp.body
         resp.forms[0]['label'] = 'foobar'
         resp.forms[0]['type'] = 'New Page'
         resp = resp.forms[0].submit()
         assert resp.location == 'http://example.net/backoffice/forms/1/fields/'
         resp = resp.follow()
         assert 'foobar' in resp.body
         assert 'Use drag and drop to reorder fields.' in resp.body
         assert len(FormDef.get(1).fields) == 1
         assert FormDef.get(1).fields[0].key == 'page'
         assert FormDef.get(1).fields[0].label == 'foobar'
         resp = resp.click('Edit', href='1/')
         resp.form['post_conditions$element0$condition'] = 'foo'
         resp.form['post_conditions$element0$error_message'] = 'bar'
         resp = resp.form.submit('post_conditions$add_element')
         resp.form['post_conditions$element1$condition'] = 'foo2'
         resp.form['post_conditions$element1$error_message'] = 'bar2'
         resp = resp.form.submit('submit')
         assert FormDef.get(1).fields[0].post_conditions == [
                 {'condition': 'foo', 'error_message': 'bar'},
                 {'condition': 'foo2', 'error_message': 'bar2'},
+        ]
     def test_form_legacy_int_id(pub):
         create_superuser(pub)
         create_role()

         resp = resp.forms[0].submit('submit') # should go to second page
         assert 'f3' in resp.forms[0].fields
     def test_form_multi_page_post_conditions(pub):
         formdef = create_formdef()
         formdef.fields = [fields.PageField(id='0', label='1st page', type='page'),
                 fields.StringField(id='1', label='string', varname='foo'),
                 fields.PageField(id='2', label='2nd page', type='page', condition='False'),
                 fields.StringField(id='3', label='string 2'),
                 fields.PageField(id='4', label='3rd page', type='page'),
                 fields.StringField(id='5', label='string 3', varname='bar'),
+                ]
         formdef.store()
         formdef.data_class().wipe()
         resp = get_app(pub).get('/test/')
         resp.forms[0]['f1'] = 'foo'
         resp = resp.forms[0].submit('submit')
         resp.forms[0]['f5'] = 'bar'
         resp = resp.forms[0].submit('submit')
         assert 'Check values then click submit.' in resp.body
         resp = resp.forms[0].submit('submit')
         assert formdef.data_class().count() == 1
         assert formdef.data_class().select()[0].data['1'] == 'foo'
         assert formdef.data_class().select()[0].data['5'] == 'bar'
         formdef.fields[4].post_conditions = [
             {'condition': 'False', 'error_message': 'You shall not pass.'},
+        ]
         formdef.store()
         formdef.data_class().wipe()
         resp = get_app(pub).get('/test/')
         resp.forms[0]['f1'] = 'foo'
         resp = resp.forms[0].submit('submit')
         resp.forms[0]['f5'] = 'bar'
         resp = resp.forms[0].submit('submit')
         assert 'errornotice' in resp.body
         assert 'You shall not pass.' in resp.body
         formdef.fields[4].post_conditions = [
             {'condition': 'form_var_foo == "foo"', 'error_message': 'You shall not pass.'},
+        ]
         formdef.store()
         formdef.data_class().wipe()
         resp = get_app(pub).get('/test/')
         resp.forms[0]['f1'] = 'bar'
         resp = resp.forms[0].submit('submit')
         resp.forms[0]['f5'] = 'bar'
         resp = resp.forms[0].submit('submit')
         assert 'errornotice' in resp.body
         assert 'You shall not pass.' in resp.body
         resp = get_app(pub).get('/test/')
         resp.forms[0]['f1'] = 'foo'
         resp = resp.forms[0].submit('submit')
         resp.forms[0]['f5'] = 'bar'
         resp = resp.forms[0].submit('submit')
         assert 'Check values then click submit.' in resp.body
         # check a post-condition raising an exception, they should always fail.
         formdef.fields[4].post_conditions = [
             {'condition': '1/0', 'error_message': 'You shall not pass.'},
+        ]
         formdef.store()
         formdef.data_class().wipe()
         resp = get_app(pub).get('/test/')
         resp.forms[0]['f1'] = 'bar'
         resp = resp.forms[0].submit('submit')
         resp.forms[0]['f5'] = 'bar'
         resp = resp.forms[0].submit('submit')
         assert 'errornotice' in resp.body
         assert 'You shall not pass.' in resp.body
         # check a post-condition referring to a field on the same page
         formdef.fields[4].post_conditions = [
             {'condition': 'form_var_bar == "bar"', 'error_message': 'You shall not pass.'},
+        ]
         formdef.store()
         formdef.data_class().wipe()
         resp = get_app(pub).get('/test/')
         resp.forms[0]['f1'] = 'bar'
         resp = resp.forms[0].submit('submit')
         resp.forms[0]['f5'] = 'foo'
         resp = resp.forms[0].submit('submit')
         assert 'errornotice' in resp.body
         assert 'You shall not pass.' in resp.body
         resp = get_app(pub).get('/test/')
         resp.forms[0]['f1'] = 'bar'
         resp = resp.forms[0].submit('submit')
         resp.forms[0]['f5'] = 'bar'
         resp = resp.forms[0].submit('submit')
         assert 'Check values then click submit.' in resp.body
     def test_form_submit_with_user(pub):
         create_user(pub)
         formdef = create_formdef()

         formdef2 = FormDef.import_from_xml(StringIO.StringIO(export), include_id=True)
         assert formdef2.max_field_id == 2
     def test_page_post_conditions():
         formdef = FormDef()
         formdef.name = 'foo'
         formdef.fields = [
             fields.PageField(id='1', type='page',
                 post_conditions=[{'condition': 'blah', 'error_message': 'bar'}]),
+        ]
         fd2 = assert_xml_import_export_works(formdef)
         assert fd2.fields[0].type == 'page'
         assert fd2.fields[0].post_conditions == formdef.fields[0].post_conditions

             else:
                 extra_fields = []
             for attribute in self.get_admin_attributes() + extra_fields:
                 if hasattr(self, '%s_export_to_xml' % attribute):
                     getattr(self, '%s_export_to_xml' % attribute)(field, charset,
                             include_id=include_id)
                     continue
                 if hasattr(self, attribute) and getattr(self, attribute) is not None:
                     val = getattr(self, attribute)
                     if type(val) is dict and not val:
-...
         def init_with_xml(self, elem, charset, include_id=False):
             for attribute in self.get_admin_attributes():
                 el = elem.find(attribute)
                 if hasattr(self, '%s_init_with_xml' % attribute):
                     getattr(self, '%s_init_with_xml' % attribute)(el, charset,
                             include_id=include_id)
                     continue
                 if el is None:
                     continue
                 if el.getchildren():
-...
     register_field_class(ItemsField)
     class PostConditionsRowWidget(CompositeWidget):
         def __init__(self, name, value=None, **kwargs):
             CompositeWidget.__init__(self, name, value, **kwargs)
             if not value:
                 value = {}
             self.add(StringWidget, name='condition', title=_('Condition'),
                     value=value.get('condition'), size=50)
             self.add(StringWidget, name='error_message', title=_('Error Message'),
                     value=value.get('error_message'), size=50)
         def _parse(self, request):
             if self.get('condition') or self.get('error_message'):
                 self.value = {
                     'condition': self.get('condition'),
                     'error_message': self.get('error_message')
+                }
             else:
                 self.value = None
     class PostConditionsTableWidget(WidgetListAsTable):
         readonly = False
         def __init__(self, name, **kwargs):
             super(PostConditionsTableWidget, self).__init__(name,
                     element_type=PostConditionsRowWidget, **kwargs)
     class PageField(Field):
         key = 'page'
         description = N_('New Page')
         condition = None
         post_conditions = None
         def post_conditions_init_with_xml(self, node, charset, include_id=False):
             if node is None:
                 return
             self.post_conditions = []
             for post_condition_node in node.findall('post_condition'):
                 self.post_conditions.append({
                     'condition': post_condition_node.find('condition').text.encode(charset),
                     'error_message': post_condition_node.find('error_message').text.encode(charset),
                 })
         def post_conditions_export_to_xml(self, node, charset, include_id=False):
             if not self.post_conditions:
                 return
             conditions_node = ET.SubElement(node, 'post_conditions')
             for post_condition in self.post_conditions:
                 condition_node = ET.SubElement(conditions_node, 'post_condition')
                 ET.SubElement(condition_node, 'condition').text = unicode(
                         post_condition['condition'], charset, 'replace')
                 ET.SubElement(condition_node, 'error_message').text = unicode(
                         post_condition['error_message'], charset, 'replace')
         def fill_admin_form(self, form):
             form.add(StringWidget, 'label', title = _('Label'), value = self.label,
                     required = True, size = 50)
             form.add(StringWidget, 'condition', title = _('Condition'), value = self.condition,
                     required = False, size = 50)
             form.add(PostConditionsTableWidget, 'post_conditions',
                     title=_('Post Conditions'),
                     value=self.post_conditions,
                     advanced=not(self.post_conditions))
         def get_admin_attributes(self):
             return Field.get_admin_attributes(self) + ['condition']
             return Field.get_admin_attributes(self) + ['condition', 'post_conditions']
         def add_to_view_form(self, *args):
             pass
         def is_visible(self, dict, formdef):
             if dict is None:
                 return True
             if not self.condition:
         def evaluate_condition(self, dict, formdef, condition):
             if not condition:
                 return True
             # create variables with values currently being evaluated, not yet
-...
             data = get_publisher().substitutions.get_context_variables()
             try:
                 if eval(self.condition, get_publisher().get_global_eval_dict(), data):
                 if eval(condition, get_publisher().get_global_eval_dict(), data):
                     return True
             except Exception, e:
                 get_logger().warn('failed to evaluate condition "%s" (%r)' % (self.condition, e))
                 return True
                 raise RuntimeError()
             return False
         def is_visible(self, dict, formdef):
             if dict is None:
                 return True
             try:
                 return self.evaluate_condition(dict, formdef, self.condition)
             except RuntimeError:
                 return True
     register_field_class(PageField)

             return self.page(0)
         def page(self, page_no, page_change=True, log_detail=None):
         def page(self, page_no, page_change=True, log_detail=None, page_error_messages=None):
             r = TemplateIO(html=True)
             displayed_fields = []
-...
                 self.feed_current_data(magictoken)
             form = self.formdef.create_form(page_no, displayed_fields)
             if page_error_messages:
                 form.add_global_errors(page_error_messages)
             if getattr(session, 'ajax_form_token', None):
                 form.add_hidden('_ajax_form_token', session.ajax_form_token)
             if get_request().is_in_backoffice():
-...
                     filled = self.save_draft(form_data, page_no)
                     return redirect(filled.get_url().rstrip('/'))
                 page_error_messages = []
                 if form.get_submit() == 'submit':
                     pages = [x for x in self.formdef.fields if x.type == 'page']
                     try:
                         page = pages[page_no]
                         post_conditions = page.post_conditions or []
                     except IndexError:
                         post_conditions = []
                     form_data = session.get_by_magictoken(magictoken, {})
                     data = self.formdef.get_data(form)
                     form_data.update(data)
                     for i, post_condition in enumerate(post_conditions):
                         condition = post_condition.get('condition')
                         error_message = post_condition.get('error_message')
                         errored = False
                         try:
                             if not page.evaluate_condition(form_data, self.formdef, condition):
                                 errored = True
                         except RuntimeError:
                             errored = True
                         if errored:
                             form.add(HiddenErrorWidget, 'post_condition%d' % i)
                             form.set_error('post_condition%d' % i, 'error')
                             page_error_messages.append(error_message)
                 # form.get_submit() returns the name of the clicked button, and
                 # it will return True if the form has been submitted, but not
                 # by clicking on a submit widget; for example if an "add row"
-...
                         # page hidden field had an error in its submission), in
                         # that case we just fall back to the first page.
                         page_no = 0
                     return self.page(page_no, page_change=False)
                     return self.page(page_no, page_change=False,
                             page_error_messages=page_error_messages)
                 form_data = session.get_by_magictoken(magictoken, {})
                 data = self.formdef.get_data(form)

             if kwargs.get('advanced_label'):
                 self.advanced_label = kwargs.pop('advanced_label')
             QuixoteForm.__init__(self, *args, **kwargs)
             self.global_error_messages = None
         def keep_referer(self):
             self.add(HiddenWidget, '__keep_referer',
-...
                 l.append(self.captcha)
             return l
         def add_global_errors(self, error_messages):
             self.global_error_messages = error_messages
         def _get_default_action(self):
             if get_request().get_header('x-popup') == 'true':
                 # do not leave action empty for popups, as they get embedded into
-...
             return htmltext('<div class="infonotice">%s</div>' % _(self.info))
         def _render_error_notice(self):
             return htmltext('<div class="errornotice">%s</div>' % _(
                         QuixoteForm._render_error_notice(self)))
             errors = []
             if self.has_errors():
                 errors.append(_(QuixoteForm._render_error_notice(self)))
             if self.global_error_messages:
                 errors.extend(self.global_error_messages)
             t = TemplateIO(html=True)
             t += htmltext('<div class="errornotice">')
             for error in errors:
                 t += htmltext('<p>%s</p>') % error
             t += htmltext('</div>')
             return t.getvalue()
         def _render_body(self):
             r = TemplateIO(html=True)
             if self.has_errors():
             if self.has_errors() or self.global_error_messages:
                 r += self._render_error_notice()
             if self.info:
                 r += self._render_info_notice()
-...
         def _parse(self, request):
             CompositeWidget._parse(self, request)
             self.value = self.get('latlng')
     class HiddenErrorWidget(HiddenWidget):
         def set_error(self, error):
             Widget.set_error(self, error)
+    -

Projet

Général

Profil

Produits Entr'ouvert » w.c.s.