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

Frédéric Péters, 20 janvier 2016 18:43

Voir les différences: en ligne côte à côte

Subject: [PATCH] forms: add post-conditions to page fields (#8962)

 wcs/fields.py      | 54 ++++++++++++++++++++++++++++++++++++++++++++++--------
 wcs/forms/root.py  | 27 +++++++++++++++++++++++++--
 wcs/qommon/form.py | 24 +++++++++++++++++++++---
 3 files changed, 92 insertions(+), 13 deletions(-)

     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 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, {})
                     for i, post_condition in enumerate(post_conditions):
                         condition = post_condition.get('condition')
                         error_message = post_condition.get('error_message')
                         try:
                             if not page.evaluate_condition(form_data, self.formdef, condition):
                                 form.add(HiddenErrorWidget, 'post_condition%d' % i)
                                 form.set_error('post_condition%d' % i, 'error')
                                 page_error_messages.append(error_message)
                         except RuntimeError:
                             pass
                 # 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.

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