cubicweb: comparison web/formfields.py

equal deleted inserted replaced

-:7b88d12b4ee2
+:b8be8fc77c27
 """method called before by form_build_context to trigger potential field
 initialization requiring the form instance
 """
 pass
+def process_form_value(self, form):
+"""process posted form and return correctly typed value"""
+widget = self.get_widget(form)
+return widget.process_field_data(form, self)
+def process_posted(self, form):
+for field in self.actual_fields(form):
+if field is self:
+yield field.name, field.process_form_value(form)
+else:
+# recursive function: we might have compound fields
+# of compound fields (of compound fields of ...)
+for fieldname, value in field.process_posted(form):
+yield fieldname, value
 class StringField(Field):
 widget = TextArea
 def __init__(self, max_length=None, **kwargs):
 fkwargs['widget'] = Select()
 fcstr = FormatConstraint()
 fkwargs['choices'] = fcstr.vocabulary(form=form)
 fkwargs['internationalizable'] = True
 fkwargs['initial'] = lambda f: f.form_field_format(self)
+fkwargs['eidparam'] = self.eidparam
 field = StringField(name=self.name + '_format', **fkwargs)
 req.data[self] = field
 return field
 def actual_fields(self, form):
 def render_subfield(self, form, field, renderer):
 return (renderer.render_label(form, field)
 + field.render(form, renderer)
 + renderer.render_help(form, field)
 + u'<br/>')
+def process_form_value(self, form):
+posted = form.req.form
+value = posted.get(form.form_field_name(self))
+formkey = form.form_field_name(self)
+if ('%s__detach' % form.context[self]['name']) in posted:
+# drop current file value
+value = None
+# no need to check value when nor explicit detach nor new file
+# submitted, since it will think the attribute is not modified
+elif value:
+filename, _, stream = value
+# value is a  3-uple (filename, mimetype, stream)
+value = Binary(stream.read())
+if not val.getvalue(): # usually an unexistant file
+value = None
+else:
+value.filename = filename
+return value
 class EditableFileField(FileField):
 editable_formats = ('text/plain', 'text/html', 'text/rest')
 wdgs.append(u'<p><b>%s</b></p>' % msg)
 wdgs.append(TextArea(setdomid=False).render(form, self, renderer))
 # XXX restore form context?
 return '\n'.join(wdgs)
+def process_form_value(self, form):
+value = form.req.form.get(form.form_field_name(self))
+if isinstance(value, unicode):
+# file modified using a text widget
+encoding = form.form_field_encoding(self)
+return Binary(value.encode(encoding))
+return super(EditableFileField, self).process_form_value(form)
 class IntField(Field):
 def __init__(self, min=None, max=None, **kwargs):
 super(IntField, self).__init__(**kwargs)
 self.min = min
 self.max = max
 if isinstance(self.widget, TextInput):
 self.widget.attrs.setdefault('size', 5)
 self.widget.attrs.setdefault('maxlength', 15)
+def process_form_value(self, form):
+return int(Field.process_form_value(self, form))
 class BooleanField(Field):
 widget = Radio
 def vocabulary(self, form):
 if self.choices:
 return self.choices
 return [(form.req._('yes'), '1'), (form.req._('no'), '')]
+def process_form_value(self, form):
+return bool(Field.process_form_value(self, form))
 class FloatField(IntField):
 def format_single_value(self, req, value):
 formatstr = req.property_value('ui.float-format')
 if value is None:
 return formatstr % float(value)
 def render_example(self, req):
 return self.format_single_value(req, 1.234)
+def process_form_value(self, form):
+return float(Field.process_form_value(self, form))
 class DateField(StringField):
 format_prop = 'ui.date-format'
 widget = DateTimePicker
 return value and ustrftime(value, req.property_value(self.format_prop)) or u''
 def render_example(self, req):
 return self.format_single_value(req, datetime.now())
+def process_form_value(self, form):
+# widget is supposed to return a date as a correctly formatted string
+date = Field.process_form_value(self, form)
+# but for some widgets, it might be simpler to return date objects
+# directly, so handle that case :
+if isinstance(date, basestring):
+date = form.parse_date(wdgdate, 'Date')
+return date
 class DateTimeField(DateField):
 format_prop = 'ui.datetime-format'
+def process_form_value(self, form):
+# widget is supposed to return a date as a correctly formatted string
+date = Field.process_form_value(self, form)
+# but for some widgets, it might be simpler to return date objects
+# directly, so handle that case :
+if isinstance(date, basestring):
+date = form.parse_datetime(wdgdate, 'Datetime')
+return date
 class TimeField(DateField):
 format_prop = 'ui.time-format'
 widget = TextInput
+def process_form_value(self, form):
-class HiddenInitialValueField(Field):
+# widget is supposed to return a date as a correctly formatted string
-def __init__(self, visible_field):
+time = Field.process_form_value(self, form)
-name = 'edit%s-%s' % (visible_field.role[0], visible_field.name)
+# but for some widgets, it might be simpler to return time objects
-super(HiddenInitialValueField, self).__init__(
+# directly, so handle that case :
-name=name, widget=HiddenInput, eidparam=True)
+if isinstance(time, basestring):
-self.visible_field = visible_field
+time = form.parse_time(wdgdate, 'Time')
+return time
-def format_single_value(self, req, value):
-return self.visible_field.format_single_value(req, value)
 class RelationField(Field):
 # XXX (syt): iirc, we originaly don't sort relation vocabulary since we want
 # to let entity.unrelated_rql control this, usually to get most recently
 # modified entities in the select box instead of by alphabetical order. Now,
 kwargs['name'] = rschema.type
 if role == 'object':
 kwargs['label'] = (eschema.type + '_object', rschema.type)
 else:
 kwargs['label'] = (eschema.type, rschema.type)
+kwargs['eidparam'] = True
 kwargs.setdefault('help', help)
 if rschema.is_final():
 if skip_meta_attr and rschema in eschema.meta_attributes():
 return None
 fieldclass = FIELDS[targetschema]

changeset 3388	b8be8fc77c27
parent 3347	428f95118556
parent 3387	a357d4147eee
child 3451	6b46d73823f5