cubicweb: comparison web/views/forms.py

equal deleted inserted replaced

-:495862266785
+:6b46d73823f5
 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)
+self._cw.add_js(self.needs_js)
 if self.needs_css:
-self.req.add_css(self.needs_css)
+self._cw.add_css(self.needs_css)
 def form_render(self, **values):
 """render this form, using the renderer given in args or the default
 FormRenderer()
 """
 if renderer is None:
 renderer = self.form_default_renderer()
 return renderer.render(self, values)
 def form_default_renderer(self):
-return self.vreg['formrenderers'].select(self.form_renderer_id,
+return self._cw.vreg['formrenderers'].select(self.form_renderer_id,
-self.req, rset=self.rset,
+self._cw, rset=self.cw_rset,
-row=self.row, col=self.col)
+row=self.cw_row, col=self.cw_col)
 def form_build_context(self, rendervalues=None):
 """build form context values (the .context attribute which is a
 dictionary with field instance as key associated to a dictionary
 containing field 'name' (qualified), 'id', 'value' (for display, always
 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)
+value = field.format_value(self._cw, value)
 return value
 def _req_display_value(self, field):
 qname = self.form_field_name(field)
 if qname in self.form_previous_values:
 return self.form_previous_values[qname]
-if qname in self.req.form:
+if qname in self._cw.form:
-return self.req.form[qname]
+return self._cw.form[qname]
-if field.name in self.req.form:
+if field.name in self._cw.form:
-return self.req.form[field.name]
+return self._cw.form[field.name]
 return None
 def form_field_value(self, field, load_bytes=False):
 """return field's *typed* value"""
 myattr = '%s_%s_default' % (field.role, field.name)
 return u'<span class="error">%s</span>' % self.form_valerror.errors[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')
+return self._cw.property_value('ui.default-text-format')
 def form_field_encoding(self, field):
 """return encoding used for the given (text) field"""
-return self.req.encoding
+return self._cw.encoding
 def form_field_name(self, field):
 """return qualified name for the given field"""
 return field.name
 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:
-self.edited_entity = self.complete_entity(self.row or 0, self.col or 0)
+self.edited_entity = self.complete_entity(self.cw_row or 0, self.cw_col or 0)
 self.form_add_hidden('__type', eidparam=True)
 self.form_add_hidden('eid')
 if kwargs.get('mainform', True): # mainform default to true in parent
 self.form_add_hidden(u'__maineid', self.edited_entity.eid)
 # If we need to directly attach the new object to another one
-if self.req.list_form_param('__linkto'):
+if self._cw.list_form_param('__linkto'):
-for linkto in self.req.list_form_param('__linkto'):
+for linkto in self._cw.list_form_param('__linkto'):
 self.form_add_hidden('__linkto', linkto)
 if msg:
-msg = '%s %s' % (msg, self.req._('and linked'))
+msg = '%s %s' % (msg, self._cw._('and linked'))
 else:
-msg = self.req._('entity linked')
+msg = self._cw._('entity linked')
 if msg:
 self.form_add_hidden('__message', msg)
 def _field_has_error(self, field):
 """return true if the field has some error in given validation exception
 def _form_field_default_value(self, field, load_bytes):
 defaultattr = 'default_%s' % field.name
 if hasattr(self.edited_entity, defaultattr):
 # XXX bw compat, default_<field name> on the entity
 warn('found %s on %s, should be set on a specific form'
-% (defaultattr, self.edited_entity.id), DeprecationWarning)
+% (defaultattr, self.edited_entity.__regid__), DeprecationWarning)
 value = getattr(self.edited_entity, defaultattr)
 if callable(value):
 value = value()
 else:
 value = super(EntityFieldsForm, self).form_field_value(field,
 load_bytes)
 return value
 def form_default_renderer(self):
-return self.vreg['formrenderers'].select(
+return self._cw.vreg['formrenderers'].select(
-self.form_renderer_id, self.req, rset=self.rset, row=self.row,
+self.form_renderer_id, self._cw, rset=self.cw_rset, row=self.cw_row,
-col=self.col, entity=self.edited_entity)
+col=self.cw_col, entity=self.edited_entity)
 ##    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
 ##        """
 if attr == 'eid':
 return entity.eid
 if not field.eidparam:
 return super(EntityFieldsForm, self).form_field_value(field, load_bytes)
 if attr == '__type':
-return entity.id
+return entity.__regid__
-if self.schema.rschema(attr).is_final():
+if self._cw.schema.rschema(attr).is_final():
 attrtype = entity.e_schema.destination(attr)
 if attrtype == 'Password':
 return entity.has_eid() and INTERNAL_FIELD_VALUE or ''
 if attrtype == 'Bytes':
 if entity.has_eid():
 """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 self.edited_entity.attr_metadata(field.name, 'format')
-return self.req.property_value('ui.default-text-format')
+return self._cw.property_value('ui.default-text-format')
 def form_field_encoding(self, field):
 """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 (
 vocabfunc = getattr(self.edited_entity, method)
 except AttributeError:
 vocabfunc = getattr(self, '%s_relation_vocabulary' % role)
 else:
 warn('found %s on %s, should be set on a specific form'
-% (method, self.edited_entity.id), DeprecationWarning)
+% (method, self.edited_entity.__regid__), DeprecationWarning)
 # NOTE: it is the responsibility of `vocabfunc` to sort the result
 #       (direclty through RQL or via a python sort). This is also
 #       important because `vocabfunc` might return a list with
 #       couples (label, None) which act as separators. In these
 #       cases, it doesn't make sense to sort results afterwards.
 """defaut vocabulary method for the given relation, looking for
 relation's object entities (i.e. self is the subject)
 """
 entity = self.edited_entity
 if isinstance(rtype, basestring):
-rtype = entity.schema.rschema(rtype)
+rtype = self._cw.vreg.schema.rschema(rtype)
 done = None
 assert not rtype.is_final(), rtype
 if entity.has_eid():
 done = set(e.eid for e in getattr(entity, str(rtype)))
 result = []
 """defaut vocabulary method for the given relation, looking for
 relation's subject entities (i.e. self is the object)
 """
 entity = self.edited_entity
 if isinstance(rtype, basestring):
-rtype = entity.schema.rschema(rtype)
+rtype = self._cw.vreg.schema.rschema(rtype)
 done = None
 if entity.has_eid():
 done = set(e.eid for e in getattr(entity, 'reverse_%s' % rtype))
 result = []
 rsetsize = None

changeset 3451	6b46d73823f5
parent 3396	fb261afd49cd
child 3467	a6405235aac6