# HG changeset patch # User Adrien Di Mascio # Date 1253617722 -7200 # Node ID b8be8fc77c276b7e080034ffdfd53684340e8057 # Parent 7b88d12b4ee242e652a9f2b53f8f3c9a4d62d1a3# Parent a357d4147eee2817dd5b4f1736c56f8bfdd7bb6e backport old changesets corresponding to new form / controller implementation diff -r 7b88d12b4ee2 -r b8be8fc77c27 web/_exceptions.py --- a/web/_exceptions.py Tue Sep 22 12:11:12 2009 +0200 +++ b/web/_exceptions.py Tue Sep 22 13:08:42 2009 +0200 @@ -19,6 +19,10 @@ class NothingToEdit(RequestError): """raised when an edit request doesn't specify any eid to edit""" +class ProcessFormError(RequestError): + """raised when posted data can't be processed by the corresponding field + """ + class NotFound(RequestError): """raised when a 404 error should be returned""" diff -r 7b88d12b4ee2 -r b8be8fc77c27 web/formfields.py --- a/web/formfields.py Tue Sep 22 12:11:12 2009 +0200 +++ b/web/formfields.py Tue Sep 22 13:08:42 2009 +0200 @@ -214,6 +214,21 @@ """ 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 @@ -286,6 +301,7 @@ 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 @@ -361,6 +377,25 @@ + renderer.render_help(form, field) + u'
') + 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') @@ -391,6 +426,14 @@ # 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): @@ -401,6 +444,8 @@ 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 @@ -410,6 +455,8 @@ 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): @@ -421,6 +468,8 @@ 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' @@ -432,26 +481,39 @@ 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 - -class HiddenInitialValueField(Field): - def __init__(self, visible_field): - name = 'edit%s-%s' % (visible_field.role[0], visible_field.name) - super(HiddenInitialValueField, self).__init__( - name=name, widget=HiddenInput, eidparam=True) - self.visible_field = visible_field - - def format_single_value(self, req, value): - return self.visible_field.format_single_value(req, value) - + def process_form_value(self, form): + # widget is supposed to return a date as a correctly formatted string + time = Field.process_form_value(self, form) + # but for some widgets, it might be simpler to return time objects + # directly, so handle that case : + if isinstance(time, basestring): + time = form.parse_time(wdgdate, 'Time') + return time class RelationField(Field): # XXX (syt): iirc, we originaly don't sort relation vocabulary since we want @@ -533,6 +595,7 @@ 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(): diff -r 7b88d12b4ee2 -r b8be8fc77c27 web/formwidgets.py --- a/web/formwidgets.py Tue Sep 22 12:11:12 2009 +0200 +++ b/web/formwidgets.py Tue Sep 22 13:08:42 2009 +0200 @@ -11,7 +11,7 @@ from warnings import warn from cubicweb.common import tags, uilib -from cubicweb.web import stdmsgs, INTERNAL_FIELD_VALUE +from cubicweb.web import stdmsgs, INTERNAL_FIELD_VALUE, ProcessFormError class FieldWidget(object): @@ -63,6 +63,10 @@ attrs['tabindex'] = form.req.next_tabindex() return name, values, attrs + def process_field_data(self, form, field): + formkey = form.form_field_name(field) + posted = form.req.form + return posted.get(formkey) class Input(FieldWidget): """abstract widget class for tag based widgets""" @@ -114,11 +118,25 @@ **{'class': 'emphasis'})] return u'\n'.join(inputs) + def process_field_data(self, form, field): + passwd1 = super(PasswordInput, self).process_field_data(form, field) + fieldname = form.form_field_name(field) + passwd2 = form.req.form[fieldname+'-confirm'] + if passwd1 == passwd2: + if passwd1 is None: + return None + return passwd1.encode('utf-8') + raise ProcessFormError(form.req._("password and confirmation don't match")) class PasswordSingleInput(Input): """ without a confirmation field""" type = 'password' + def process_field_data(self, form, field): + value = super(PasswordSingleInput, self).process_field_data(form, field) + if value is not None: + return value.encode('utf-8') + return value class FileInput(Input): """""" diff -r 7b88d12b4ee2 -r b8be8fc77c27 web/views/editcontroller.py --- a/web/views/editcontroller.py Tue Sep 22 12:11:12 2009 +0200 +++ b/web/views/editcontroller.py Tue Sep 22 13:08:42 2009 +0200 @@ -12,7 +12,7 @@ from rql.utils import rqlvar_maker from cubicweb import Binary, ValidationError, typed_eid -from cubicweb.web import INTERNAL_FIELD_VALUE, RequestError, NothingToEdit +from cubicweb.web import INTERNAL_FIELD_VALUE, RequestError, NothingToEdit, ProcessFormError from cubicweb.web.controller import parse_relations_descr from cubicweb.web.views.basecontrollers import ViewController @@ -22,6 +22,32 @@ can't be handled right now and have to be handled later """ +class RqlQuery(object): + def __init__(self): + self.edited = [] + self.restrictions = [] + self.kwargs = {} + + def insert_query(self, etype): + if self.edited: + rql = 'INSERT %s X: %s' % (etype, ','.join(self.edited)) + else: + rql = 'INSERT %s X' % etype + if self.restrictions: + rql += ' WHERE %s' % ','.join(self.restrictions) + return rql + + def update_query(self, eid): + varmaker = rqlvar_maker() + var = varmaker.next() + while var in self.kwargs: + var = varmaker.next() + rql = 'SET %s WHERE X eid %%(%s)s' % (','.join(self.edited), var) + if self.restrictions: + rql += ', %s' % ','.join(self.restrictions) + self.kwargs[var] = eid + return rql + class EditController(ViewController): id = 'edit' @@ -42,14 +68,15 @@ def _default_publish(self): req = self.req - form = req.form + self.errors = [] + self.relations_rql = [] # no specific action, generic edition self._to_create = req.data['eidmap'] = {} self._pending_relations = [] todelete = self.req.get_pending_deletes() toinsert = self.req.get_pending_inserts() try: - methodname = form.pop('__method', None) + methodname = req.form.pop('__method', None) for eid in req.edited_eids(): # __type and eid formparams = req.extract_entity_params(eid, minparams=2) @@ -59,84 +86,72 @@ method(formparams) eid = self.edit_entity(formparams) except (RequestError, NothingToEdit): - if '__linkto' in form and 'eid' in form: + if '__linkto' in req.form and 'eid' in req.form: self.execute_linkto() - elif not ('__delete' in form or '__insert' in form or todelete or toinsert): + elif not ('__delete' in req.form or '__insert' in req.form or todelete or toinsert): raise ValidationError(None, {None: req._('nothing to edit')}) + for querydef in self.relations_rql: + self.req.execute(*querydef) # handle relations in newly created entities + # XXX find a way to merge _pending_relations and relations_rql if self._pending_relations: - for rschema, formparams, x, entity in self._pending_relations: - self.handle_relation(rschema, formparams, x, entity, True) - + for form, field, entity in self._pending_relations: + for querydef in self.handle_relation(form, field, entity, True): + self.req.execute(*querydef) # XXX this processes *all* pending operations of *all* entities - if form.has_key('__delete'): - todelete += req.list_form_param('__delete', form, pop=True) + if req.form.has_key('__delete'): + todelete += req.list_form_param('__delete', req.form, pop=True) if todelete: self.delete_relations(parse_relations_descr(todelete)) - if form.has_key('__insert'): - toinsert = req.list_form_param('__insert', form, pop=True) + if req.form.has_key('__insert'): + toinsert = req.list_form_param('__insert', req.form, pop=True) if toinsert: self.insert_relations(parse_relations_descr(toinsert)) self.req.remove_pending_operations() + def _insert_entity(self, etype, eid, rqlquery): + rql = rqlquery.insert_query(etype) + try: + # get the new entity (in some cases, the type might have + # changed as for the File --> Image mutation) + entity = self.req.execute(rql, rqlquery.kwargs).get_entity(0, 0) + neweid = entity.eid + except ValidationError, ex: + self._to_create[eid] = ex.entity + if self.req.json_request: # XXX (syt) why? + ex.entity = eid + raise + self._to_create[eid] = neweid + return neweid + + def _update_entity(self, eid, rqlquery): + rql = rqlquery.update_query(eid) + self.req.execute(rql, rqlquery.kwargs) + def edit_entity(self, formparams, multiple=False): """edit / create / copy an entity and return its eid""" etype = formparams['__type'] entity = self.vreg['etypes'].etype_class(etype)(self.req) - entity.eid = eid = self._get_eid(formparams['eid']) - edited = self.req.form.get('__maineid') == formparams['eid'] - # let a chance to do some entity specific stuff. + entity.eid = formparams['eid'] + eid = self._get_eid(entity.eid) + is_main_entity = self.req.form.get('__maineid') == formparams['eid'] + # let a chance to do some entity specific stuff.tn entity.pre_web_edit() # create a rql query from parameters - self.relations = [] - self.restrictions = [] + rqlquery = RqlQuery() # process inlined relations at the same time as attributes - # this is required by some external source such as the svn source which - # needs some information provided by those inlined relation. Moreover - # this will generate less write queries. - for rschema in entity.e_schema.subject_relations(): - if rschema.is_final(): - self.handle_attribute(entity, rschema, formparams) - elif rschema.inlined: - self.handle_inlined_relation(rschema, formparams, entity) - execute = self.req.execute + # this will generate less rql queries and might be useful in + # a few dark corners + formid = self.req.form.get('__form_id', 'edition') + form = self.vreg['forms'].select(formid, self.req, entity=entity) + for field in form.fields: + if form.form_field_modified(field): + self.handle_formfield(form, field, entity, rqlquery) if eid is None: # creation or copy - if self.relations: - rql = 'INSERT %s X: %s' % (etype, ','.join(self.relations)) - else: - rql = 'INSERT %s X' % etype - if self.restrictions: - rql += ' WHERE %s' % ','.join(self.restrictions) - try: - # get the new entity (in some cases, the type might have - # changed as for the File --> Image mutation) - entity = execute(rql, formparams).get_entity(0, 0) - eid = entity.eid - except ValidationError, ex: - self._to_create[formparams['eid']] = ex.entity - if self.req.json_request: # XXX (syt) why? - ex.entity = formparams['eid'] - raise - self._to_create[formparams['eid']] = eid - elif self.relations: # edition of an existant entity - varmaker = rqlvar_maker() - var = varmaker.next() - while var in formparams: - var = varmaker.next() - rql = 'SET %s WHERE X eid %%(%s)s' % (','.join(self.relations), var) - if self.restrictions: - rql += ', %s' % ','.join(self.restrictions) - formparams[var] = eid - execute(rql, formparams) - for rschema in entity.e_schema.subject_relations(): - if rschema.is_final() or rschema.inlined: - continue - self.handle_relation(rschema, formparams, 'subject', entity) - for rschema in entity.e_schema.object_relations(): - if rschema.is_final(): - continue - self.handle_relation(rschema, formparams, 'object', entity) - if edited: + entity.eid = self._insert_entity(etype, formparams['eid'], rqlquery) + elif rqlquery.edited: # edition of an existant entity + self._update_entity(eid, rqlquery) + if is_main_entity: self.notify_edited(entity) if formparams.has_key('__delete'): todelete = self.req.list_form_param('__delete', formparams, pop=True) @@ -146,10 +161,31 @@ if formparams.has_key('__insert'): toinsert = self.req.list_form_param('__insert', formparams, pop=True) self.insert_relations(parse_relations_descr(toinsert)) - if edited: # only execute linkto for the main entity + if is_main_entity: # only execute linkto for the main entity self.execute_linkto(eid) return eid + def handle_formfield(self, form, field, entity, rqlquery): + eschema = entity.e_schema + try: + for attr, value in field.process_posted(form): + if not ( + (field.role == 'subject' and eschema.has_subject_relation(field.name)) + or + (field.role == 'object' and eschema.has_object_relation(field.name))): + continue + rschema = self.schema.rschema(field.name) + if rschema.is_final(): + rqlquery.kwargs[attr] = value + rqlquery.edited.append('X %s %%(%s)s' % (attr, attr)) + elif rschema.inlined: + self.handle_inlined_relation(form, field, entity, rqlquery) + else: + self.relations_rql += self.handle_relation( + form, field, entity) + except ProcessFormError, exc: + self.errors.append((field, exc)) + def _action_apply(self): self._default_publish() self.reset() @@ -165,158 +201,49 @@ self.delete_entities(self.req.edited_eids(withtype=True)) return self.reset() - def _needs_edition(self, rtype, formparams, entity): - """returns True and and the new value if `rtype` was edited""" - editkey = 'edits-%s' % rtype - if not editkey in formparams: - return False, None # not edited - value = formparams.get(rtype) or None - if entity.has_eid() and (formparams.get(editkey) or None) == value: - return False, None # not modified - if value == INTERNAL_FIELD_VALUE: - value = None - return True, value - - def handle_attribute(self, entity, rschema, formparams): - """append to `relations` part of the rql query to edit the - attribute described by the given schema if necessary + def _relation_values(self, form, field, entity, late=False): + """handle edition for the (rschema, x) relation of the given entity """ - attr = rschema.type - edition_needed, value = self._needs_edition(attr, formparams, entity) - if not edition_needed: - return - # test if entity class defines a special handler for this attribute - custom_edit = getattr(entity, 'custom_%s_edit' % attr, None) - if custom_edit: - custom_edit(formparams, value, self.relations) - return - attrtype = rschema.objects(entity.e_schema)[0].type - # on checkbox or selection, the field may not be in params - # NOTE: raising ValidationError here is not a good solution because - # we can't gather all errors at once. Hopefully, the new 3.6.x - # form handling will fix that - if attrtype == 'Boolean': - value = bool(value) - elif attrtype == 'Decimal': - value = Decimal(value) - elif attrtype == 'Bytes': - # if it is a file, transport it using a Binary (StringIO) - # XXX later __detach is for the new widget system, the former is to - # be removed once web/widgets.py has been dropped - if formparams.has_key('%s__detach' % attr): - # 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 isinstance(value, unicode): - # file modified using a text widget - encoding = entity.attr_metadata(attr, 'encoding') - value = Binary(value.encode(encoding)) - elif value: - # value is a 3-uple (filename, mimetype, stream) - val = Binary(value[2].read()) - if not val.getvalue(): # usually an unexistant file - value = None - else: - val.filename = value[0] - # ignore browser submitted MIME type since it may be buggy - # XXX add a config option to tell if we should consider it - # or not? - #if entity.e_schema.has_metadata(attr, 'format'): - # key = '%s_format' % attr - # formparams[key] = value[1] - # self.relations.append('X %s_format %%(%s)s' - # % (attr, key)) - # XXX suppose a File compatible schema - if entity.e_schema.has_subject_relation('name') \ - and not formparams.get('name'): - formparams['name'] = value[0] - self.relations.append('X name %(name)s') - value = val - else: - # no specified value, skip - return - elif value is not None: - if attrtype == 'Int': - try: - value = int(value) - except ValueError: - raise ValidationError(entity.eid, - {attr: self.req._("invalid integer value")}) - elif attrtype == 'Float': - try: - value = float(value) - except ValueError: - raise ValidationError(entity.eid, - {attr: self.req._("invalid float value")}) - elif attrtype in ('Date', 'Datetime', 'Time'): - try: - value = self.parse_datetime(value, attrtype) - except ValueError: - raise ValidationError(entity.eid, - {attr: self.req._("invalid date")}) - elif attrtype == 'Password': - # check confirmation (see PasswordWidget for confirmation field name) - confirmval = formparams.get(attr + '-confirm') - if confirmval != value: - raise ValidationError(entity.eid, - {attr: self.req._("password and confirmation don't match")}) - # password should *always* be utf8 encoded - value = value.encode('UTF8') - else: - # strip strings - value = value.strip() - elif attrtype == 'Password': - # skip None password - return # unset password - formparams[attr] = value - self.relations.append('X %s %%(%s)s' % (attr, attr)) + values = set() + for eid in field.process_form_data(form): + if not eid: # AutoCompletionWidget + continue + typed_eid = self._get_eid(eid) + if typed_eid is None: + if late: + # eid is still None while it's already a late call + # this mean that the associated entity has not been created + raise Exception("eid %s is still not created" % eid) + self._pending_relations.append( (form, field, entity) ) + return None + values.add(typed_eid) + return values - def _relation_values(self, rschema, formparams, x, entity, late=False): + def handle_inlined_relation(self, form, field, entity, rqlquery): """handle edition for the (rschema, x) relation of the given entity """ - rtype = rschema.type - editkey = 'edit%s-%s' % (x[0], rtype) - if not editkey in formparams: - return # not edited - try: - values = self._linked_eids(self.req.list_form_param(rtype, formparams), late) - except ToDoLater: - self._pending_relations.append((rschema, formparams, x, entity)) - return - origvalues = set(typed_eid(eid) for eid in self.req.list_form_param(editkey, formparams)) - return values, origvalues + origvalues = set(row[0] for row in entity.related(field.name, field.role)) + values = self._relation_values(form, field, entity) + if values is None or values == origvalues: + return # not edited / not modified / to do later + attr = field.name + if values: + rqlquery.kwargs[attr] = iter(values).next() + rqlquery.edition.append('X %s %s' % (attr, attr.upper())) + rqlquery.restrictions.append('%s eid %%(%s)s' % (attr.upper(), attr)) + elif entity.has_eid(): + self.relations_rql += self.handle_relation(form, field, entity) - def handle_inlined_relation(self, rschema, formparams, entity, late=False): + def handle_relation(self, form, field, entity, late=False): """handle edition for the (rschema, x) relation of the given entity """ - try: - values, origvalues = self._relation_values(rschema, formparams, - 'subject', entity, late) - except TypeError: - return # not edited / to do later - if values == origvalues: - return # not modified - attr = str(rschema) - if values: - formparams[attr] = iter(values).next() - self.relations.append('X %s %s' % (attr, attr.upper())) - self.restrictions.append('%s eid %%(%s)s' % (attr.upper(), attr)) - elif entity.has_eid(): - self.handle_relation(rschema, formparams, 'subject', entity, late) - - def handle_relation(self, rschema, formparams, x, entity, late=False): - """handle edition for the (rschema, x) relation of the given entity - """ - try: - values, origvalues = self._relation_values(rschema, formparams, x, - entity, late) - except TypeError: - return # not edited / to do later + origvalues = set(row[0] for row in entity.related(field.name, field.role)) + values = self._relation_values(form, field, entity, late) + if values is None or values == origvalues: + return # not edited / not modified / to do later etype = entity.e_schema - if values == origvalues: - return # not modified - if x == 'subject': + rschema = self.schema.rschema(field.name) + if field.role == 'subject': desttype = rschema.objects(etype)[0] card = rschema.rproperty(etype, desttype, 'cardinality')[0] subjvar, objvar = 'X', 'Y' @@ -325,19 +252,19 @@ card = rschema.rproperty(desttype, etype, 'cardinality')[1] subjvar, objvar = 'Y', 'X' eid = entity.eid - if x == 'object' or not rschema.inlined or not values: + if field.role == 'object' or not rschema.inlined or not values: # this is not an inlined relation or no values specified, # explicty remove relations rql = 'DELETE %s %s %s WHERE X eid %%(x)s, Y eid %%(y)s' % ( subjvar, rschema, objvar) for reid in origvalues.difference(values): - self.req.execute(rql, {'x': eid, 'y': reid}, ('x', 'y')) + yield (rql, {'x': eid, 'y': reid}, ('x', 'y')) seteids = values.difference(origvalues) if seteids: rql = 'SET %s %s %s WHERE X eid %%(x)s, Y eid %%(y)s' % ( subjvar, rschema, objvar) for reid in seteids: - self.req.execute(rql, {'x': eid, 'y': reid}, ('x', 'y')) + yield (rql, {'x': eid, 'y': reid}, ('x', 'y')) def _get_eid(self, eid): # should be either an int (existant entity) or a variable (to be @@ -355,18 +282,5 @@ def _linked_eids(self, eids, late=False): """return a list of eids if they are all known, else raise ToDoLater """ - result = set() - for eid in eids: - if not eid: # AutoCompletionWidget - continue - eid = self._get_eid(eid) - if eid is None: - if not late: - raise ToDoLater() - # eid is still None while it's already a late call - # this mean that the associated entity has not been created - raise Exception('duh') - result.add(eid) - return result diff -r 7b88d12b4ee2 -r b8be8fc77c27 web/views/editforms.py --- a/web/views/editforms.py Tue Sep 22 12:11:12 2009 +0200 +++ b/web/views/editforms.py Tue Sep 22 13:08:42 2009 +0200 @@ -484,12 +484,6 @@ def add_hiddens(self, form, entity, peid, rtype, role): # to ease overriding (see cubes.vcsfile.views.forms for instance) - if self.keep_entity(form, entity, peid, rtype): - if entity.has_eid(): - rval = entity.eid - else: - rval = INTERNAL_FIELD_VALUE - form.form_add_hidden('edit%s-%s:%s' % (role[0], rtype, peid), rval) form.form_add_hidden(name='%s:%s' % (rtype, peid), value=entity.eid, id='rel-%s-%s-%s' % (peid, rtype, entity.eid)) diff -r 7b88d12b4ee2 -r b8be8fc77c27 web/views/formrenderers.py --- a/web/views/formrenderers.py Tue Sep 22 12:11:12 2009 +0200 +++ b/web/views/formrenderers.py Tue Sep 22 13:08:42 2009 +0200 @@ -16,7 +16,7 @@ from cubicweb.appobject import AppObject from cubicweb.selectors import entity_implements, yes from cubicweb.web import eid_param, formwidgets as fwdgs -from cubicweb.web.formfields import HiddenInitialValueField +from cubicweb.web.widgets import checkbox def checkbox(name, value, attrs='', checked=None): if checked is None: @@ -168,8 +168,6 @@ return tag + '>' def display_field(self, form, field): - if isinstance(field, HiddenInitialValueField): - field = field.visible_field return (self.display_fields is None or field.name in form.internal_fields or (field.name, field.role) in self.display_fields @@ -257,8 +255,6 @@ def display_field(self, form, field): if not super(EntityBaseFormRenderer, self).display_field(form, field): - if isinstance(field, HiddenInitialValueField): - field = field.visible_field ismeta = form.edited_entity.e_schema.is_metadata(field.name) return ismeta is not None and ( ismeta[0] in self.display_fields or diff -r 7b88d12b4ee2 -r b8be8fc77c27 web/views/forms.py --- a/web/views/forms.py Tue Sep 22 12:11:12 2009 +0200 +++ b/web/views/forms.py Tue Sep 22 13:08:42 2009 +0200 @@ -16,7 +16,7 @@ from cubicweb.web import INTERNAL_FIELD_VALUE, eid_param from cubicweb.web import form, formwidgets as fwdgs from cubicweb.web.controller import NAV_FORM_PARAMETERS -from cubicweb.web.formfields import HiddenInitialValueField, StringField +from cubicweb.web.formfields import StringField class FieldsForm(form.Form): @@ -281,6 +281,9 @@ """ raise NotImplementedError + def form_field_modified(self, field): + return field.is_visible() + def _field_has_error(self, field): """return true if the field has some error in given validation exception """ @@ -372,30 +375,26 @@ self.form_renderer_id, self.req, rset=self.rset, row=self.row, col=self.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 - - edit[s|o] hidden fields are used to indicate the value for the - associated field before the (potential) modification made when - submitting the form. - """ - eschema = self.edited_entity.e_schema - for field in self.fields[:]: - for field in field.actual_fields(self): - fieldname = field.name - if fieldname != 'eid' and ( - (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_build_context(self, values=None): +## """overriden to add edit[s|o] hidden fields and to ensure schema fields +## have eidparam set to True +## """ +## eschema = self.edited_entity.e_schema +## for field in self.fields[:]: +## for field in field.actual_fields(self): +## fieldname = field.name +## if fieldname != 'eid' and ( +## (eschema.has_subject_relation(fieldname) or +## eschema.has_object_relation(fieldname))): +## # XXX why do we need to do this here ? +## field.eidparam = True +## 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 + * special eid / __type * lookup for values on edited entities """ attr = field.name @@ -404,14 +403,6 @@ return entity.eid if not field.eidparam: return super(EntityFieldsForm, self).form_field_value(field, load_bytes) - if attr.startswith('edits-') or attr.startswith('edito-'): - # edit[s|o]- fieds must have the actual value stored on the entity - assert hasattr(field, 'visible_field') - vfield = field.visible_field - assert vfield.eidparam - if entity.has_eid(): - return self.form_field_value(vfield) - return INTERNAL_FIELD_VALUE if attr == '__type': return entity.id if self.schema.rschema(attr).is_final(): @@ -487,7 +478,32 @@ # cases, it doesn't make sense to sort results afterwards. return vocabfunc(rtype, limit) - # XXX should be on the field, no? + def form_field_modified(self, field): + if field.is_visible(): + # fields not corresponding to an entity attribute / relations + # are considered modified + if not field.eidparam: + return True # XXX + try: + if field.role == 'subject': + previous_value = getattr(self.edited_entity, field.name) + else: + previous_value = getattr(self.edited_entity, + 'reverse_%s' % field.name) + except AttributeError: + # fields with eidparam=True but not corresponding to an actual + # attribute or relation + return True + # if it's a non final relation, we need the eids + if isinstance(previous_value, list): + # widget should return untyped eids + previous_value = set(unicode(e.eid) for e in previous_value) + new_value = field.process_form_value(self) + if self.edited_entity.has_eid() and (previous_value == new_value): + return False # not modified + return True + return False + def subject_relation_vocabulary(self, rtype, limit=None): """defaut vocabulary method for the given relation, looking for relation's object entities (i.e. self is the subject)