cubicweb: comparison web/form.py

equal deleted inserted replaced

-:97774eb6443b
+:ea75dfe32317
 """abstract form view mix-in"""
 category = 'form'
 controller = 'edit'
 http_cache_manager = NoHTTPCacheManager
 add_to_breadcrumbs = False
 def __init__(self, req, rset, **kwargs):
 super(FormViewMixIn, self).__init__(req, rset, **kwargs)
 # get validation session data which may have been previously set.
 # deleting validation errors here breaks form reloading (errors are
 # no more available), they have to be deleted by application's publish
 if foreid == eid:
 errex.eid = var
 break
 else:
 errex.eid = foreid
 def html_headers(self):
 """return a list of html headers (eg something to be inserted between
 <head> and </head> of the returned page
 by default forms are neither indexed nor followed
 """
 return [NOINDEX, NOFOLLOW]
 def linkable(self):
 """override since forms are usually linked by an action,
 so we don't want them to be listed by appli.possible_views
 """
 return False
 # XXX should disappear
 class FormMixIn(object):
 """abstract form mix-in
 XXX: you should inherit from this FIRST (obscure pb with super call)
 """
 varmaker = self.req.varmaker
 self.req.set_page_data('rql_varmaker', varmaker)
 self.varmaker = varmaker
 # XXX deprecated with new form system. Should disappear
 domid = 'entityForm'
 category = 'form'
 controller = 'edit'
 http_cache_manager = NoHTTPCacheManager
 add_to_breadcrumbs = False
 def __init__(self, req, rset, **kwargs):
 super(FormMixIn, self).__init__(req, rset, **kwargs)
 # get validation session data which may have been previously set.
 # deleting validation errors here breaks form reloading (errors are
 # no more available), they have to be deleted by application's publish
 for var, eid in forminfo['eidmap'].items():
 if foreid == eid:
 errex.eid = var
 break
 else:
 errex.eid = foreid
 def html_headers(self):
 """return a list of html headers (eg something to be inserted between
 <head> and </head> of the returned page
 by default forms are neither indexed nor followed
 """
 return [NOINDEX, NOFOLLOW]
 def linkable(self):
 """override since forms are usually linked by an action,
 so we don't want them to be listed by appli.possible_views
 """
 return False
 def button_ok(self, label=None, type='submit', name='defaultsubmit',
 **kwargs):
 label = self.req._(label or stdmsgs.BUTTON_OK).capitalize()
 return self.button(label, name=name, type=type, **kwargs)
 def button_apply(self, label=None, type='button', **kwargs):
 label = self.req._(label or stdmsgs.BUTTON_APPLY).capitalize()
 return self.action_button(label, __action='apply', type=type, **kwargs)
 def button_delete(self, label=None, type='button', **kwargs):
 label = self.req._(label or stdmsgs.BUTTON_DELETE).capitalize()
 return self.action_button(label, __action='delete', type=type, **kwargs)
 def button_cancel(self, label=None, type='button', **kwargs):
 label = self.req._(label or stdmsgs.BUTTON_CANCEL).capitalize()
 return self.action_button(label, __action='cancel', type=type, **kwargs)
 def button_reset(self, label=None, type='reset', name='__action_cancel',
 **kwargs):
 label = self.req._(label or stdmsgs.BUTTON_CANCEL).capitalize()
 return self.button(label, type=type, **kwargs)
 inlined_entity = self.vreg.etype_class(ttype)(self.req, None, None)
 for irschema, _, x in inlined_entity.relations_by_category(categories):
 if inlined_entity.get_widget(irschema, x).need_multipart:
 return True
 return False
 def error_message(self):
 """return formatted error message
 This method should be called once inlined field errors has been consumed
 """
 displayed = self.req.data['displayederrors']
 errors = sorted((field, err) for field, err in errex.errors.items()
 if not field in displayed)
 if errors:
 if len(errors) > 1:
 templstr = '<li>%s</li>\n'
 else:
 templstr = '&nbsp;%s\n'
 for field, err in errors:
 if field is None:
 errormsg += templstr % err
 field.set_name(fieldname)
 allfields.append(field)
 classdict['_fields_'] = allfields
 return super(metafieldsform, mcs).__new__(mcs, name, bases, classdict)
 class FieldNotFound(Exception):
 """raised by field_by_name when a field with the given name has not been
 found
 """
 class FieldsForm(FormMixIn, AppRsetObject):
 __metaclass__ = metafieldsform
 __registry__ = 'forms'
 __select__ = yes()
 is_subform = False
 # attributes overrideable through __init__
 internal_fields = ('__errorurl',) + NAV_FORM_PARAMETERS
 needs_js = ('cubicweb.ajax.js', 'cubicweb.edition.js',)
 needs_css = ('cubicweb.form.css',)
 domid = 'form'
 cwtarget = None
 redirect_path = None
 set_error_url = True
 copy_nav_params = False
 form_buttons = None # form buttons (button widgets instances)
 def __init__(self, req, rset=None, row=None, col=None, submitmsg=None,
 **kwargs):
 super(FieldsForm, self).__init__(req, rset, row=row, col=col)
 self.fields = list(self.__class__._fields_)
 for key, val in kwargs.items():
 fields = cls_or_self.fields
 for field in fields:
 if field.name == name and field.role == role:
 return field
 raise FieldNotFound(name)
 @iclassmethod
 def remove_field(cls_or_self, field):
 """remove a field from form class or instance"""
 if isinstance(cls_or_self, type):
 fields = cls_or_self._fields_
 else:
 fields = cls_or_self.fields
 fields.remove(field)
 @iclassmethod
 def append_field(cls_or_self, field):
 """append a field to form class or instance"""
 if isinstance(cls_or_self, type):
 fields = cls_or_self._fields_
 else:
 fields = cls_or_self.fields
 fields.append(field)
 @property
 def form_needs_multipart(self):
 """true if the form needs enctype=multipart/form-data"""
 return any(field.needs_multipart for field in self.fields)
 def form_add_hidden(self, name, value=None, **kwargs):
 """add an hidden field to the form"""
 field = StringField(name=name, widget=fwdgs.HiddenInput, initial=value,
 **kwargs)
 # by default, hidden input don't set id attribute. If one is
 # explicitly specified, ensure it will be set
 field.widget.setdomid = True
 self.append_field(field)
 return field
 def add_media(self):
 """adds media (CSS & JS) required by this widget"""
 if self.needs_js:
 self.req.add_js(self.needs_js)
 if self.needs_css:
 'id': self.form_field_id(field),
 }
 def form_field_display_value(self, field, rendervalues, load_bytes=False):
 """return field's *string* value to use for display
 looks in
 1. previously submitted form values if any (eg on validation error)
 2. req.form
 3. extra kw args given to render_form
 4. field's typed value
 value = rendervalues[field.name]
 else:
 value = self.form_field_value(field, load_bytes)
 if callable(value):
 value = value(self)
 if value != INTERNAL_FIELD_VALUE:
 value = field.format_value(self.req, value)
 return value
 def form_field_value(self, field, load_bytes=False):
 """return field's *typed* value"""
 value = field.initial
 if callable(value):
 value = value(self)
 return value
 def form_field_error(self, field):
 """return validation error for widget's field, if any"""
 errex = self.req.data.get('formerrors')
 if errex and self._errex_match_field(errex, field):
 self.req.data['displayederrors'].add(field.name)
 return u''
 def form_field_format(self, field):
 """return MIME type used for the given (text or bytes) field"""
 return self.req.property_value('ui.default-text-format')
 def form_field_encoding(self, field):
 """return encoding used for the given (text) field"""
 return self.req.encoding
 def form_field_name(self, field):
 """return qualified name for the given field"""
 return field.name
 def form_field_id(self, field):
 """return dom id for the given field"""
 return field.id
 def form_field_vocabulary(self, field, limit=None):
 """return vocabulary for the given field. Should be overriden in
 specific forms using fields which requires some vocabulary
 """
 raise NotImplementedError
 def _errex_match_field(self, errex, field):
 """return true if the field has some error in given validation exception
 """
 return field.name in errex.errors
 class EntityFieldsForm(FieldsForm):
 __select__ = (match_kwargs('entity') | (one_line_rset & non_final_entity()))
 internal_fields = FieldsForm.internal_fields + ('__type', 'eid')
 domid = 'entityForm'
 def __init__(self, *args, **kwargs):
 self.edited_entity = kwargs.pop('entity', None)
 msg = kwargs.pop('submitmsg', None)
 super(EntityFieldsForm, self).__init__(*args, **kwargs)
 if self.edited_entity is None:
 # If we need to directly attach the new object to another one
 for linkto in self.req.list_form_param('__linkto'):
 self.form_add_hidden('__linkto', linkto)
 msg = '%s %s' % (msg, self.req._('and linked'))
 self.form_add_hidden('__message', msg)
 def _errex_match_field(self, errex, field):
 """return true if the field has some error in given validation exception
 """
 return errex.eid == self.edited_entity.eid and field.name in errex.errors
 value = value()
 else:
 value = super(EntityFieldsForm, self).form_field_value(field,
 load_bytes)
 return value
 def form_build_context(self, values=None):
 """overriden to add edit[s|o] hidden fields and to ensure schema fields
 have eidparam set to True
 edit[s|o] hidden fields are used t o indicate the value for the
 (eschema.has_subject_relation(fieldname) or
 eschema.has_object_relation(fieldname))):
 field.eidparam = True
 self.fields.append(HiddenInitialValueField(field))
 return super(EntityFieldsForm, self).form_build_context(values)
 def form_field_value(self, field, load_bytes=False):
 """return field's *typed* value
 overriden to deal with
 * special eid / __type / edits- / edito- fields
 if entity.has_eid():
 value = [ent.eid for ent in getattr(entity, attr)]
 else:
 value = self._form_field_default_value(field, load_bytes)
 return value
 def form_field_format(self, field):
 """return MIME type used for the given (text or bytes) field"""
 entity = self.edited_entity
 if field.eidparam and entity.e_schema.has_metadata(field.name, 'format') and (
 entity.has_eid() or '%s_format' % field.name in entity):
 """return encoding used for the given (text) field"""
 entity = self.edited_entity
 if field.eidparam and entity.e_schema.has_metadata(field.name, 'encoding') and (
 entity.has_eid() or '%s_encoding' % field.name in entity):
 return self.edited_entity.attr_metadata(field.name, 'encoding')
 return super(EntityFieldsForm, self).form_field_encoding(field)
 def form_field_name(self, field):
 """return qualified name for the given field"""
 if field.eidparam:
 return eid_param(field.name, self.edited_entity.eid)
 return field.name
 def form_field_id(self, field):
 """return dom id for the given field"""
 if field.eidparam:
 return eid_param(field.id, self.edited_entity.eid)
 return field.id
 def form_field_vocabulary(self, field, limit=None):
 """return vocabulary for the given field"""
 role, rtype = field.role, field.name
 method = '%s_%s_vocabulary' % (role, rtype)
 try:
 return sorted(results)
 class CompositeForm(FieldsForm):
 """form composed for sub-forms"""
 def __init__(self, *args, **kwargs):
 super(CompositeForm, self).__init__(*args, **kwargs)
 self.forms = []
 def form_add_subform(self, subform):

branch	tls-sprint
changeset 1437	ea75dfe32317
parent 1406	133476216f4a
child 1451	982e8616d9a2