cubicweb: comparison cubicweb/web/views/editcontroller.py

equal deleted inserted replaced

-:d8b66e3fd335
+:3a84a79c4ed5
-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of CubicWeb.
 #
 # CubicWeb is free software: you can redistribute it and/or modify it under the
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
 """The edit controller, automatically handling entity form submitting"""
 from warnings import warn
 from collections import defaultdict
 from datetime import datetime
 from six import text_type
-from logilab.common.deprecation import deprecated
 from logilab.common.graph import ordered_nodes
 from rql.utils import rqlvar_maker
-from cubicweb import _, Binary, ValidationError, UnknownEid
+from cubicweb import _, ValidationError, UnknownEid
 from cubicweb.view import EntityAdapter
 from cubicweb.predicates import is_instance
-from cubicweb.web import (INTERNAL_FIELD_VALUE, RequestError, NothingToEdit,
+from cubicweb.web import RequestError, NothingToEdit, ProcessFormError
-ProcessFormError)
 from cubicweb.web.views import basecontrollers, autoform
 class IEditControlAdapter(EntityAdapter):
 __regid__ = 'IEditControl'
 def valerror_eid(eid):
 try:
 return int(eid)
 except (ValueError, TypeError):
 return eid
 class RqlQuery(object):
 def __init__(self):
 self.edited = []
 self.restrictions = []
 req.data['pending_inlined'] = defaultdict(set)
 req.data['pending_others'] = set()
 req.data['pending_composite_delete'] = set()
 try:
 for formparams in self._ordered_formparams():
-eid = self.edit_entity(formparams)
+self.edit_entity(formparams)
 except (RequestError, NothingToEdit) as ex:
 if '__linkto' in req.form and 'eid' in req.form:
 self.execute_linkto()
 elif '__delete' not in req.form:
 raise ValidationError(None, {None: text_type(ex)})
 try:
 entity = self._cw.execute(rql, rqlquery.kwargs).get_entity(0, 0)
 neweid = entity.eid
 except ValidationError as ex:
 self._to_create[eid] = ex.entity
-if self._cw.ajax_request: # XXX (syt) why?
+if self._cw.ajax_request:  # XXX (syt) why?
 ex.entity = eid
 raise
 self._to_create[eid] = neweid
 return neweid
 # inbetween, use cubicweb standard formid for inlined forms
 formid = 'edition'
 form = req.vreg['forms'].select(formid, req, entity=entity)
 eid = form.actual_eid(entity.eid)
 editedfields = formparams['_cw_entity_fields']
-form.formvalues = {} # init fields value cache
+form.formvalues = {}  # init fields value cache
 for field in form.iter_modified_fields(editedfields, entity):
 self.handle_formfield(form, field, rqlquery)
 # if there are some inlined field which were waiting for this entity's
 # creation, add relevant data to the rqlquery
 for form_, field in req.data['pending_inlined'].pop(entity.eid, ()):
 rqlquery.set_inlined(field.name, form_.edited_entity.eid)
 if not rqlquery.canceled:
 if self.errors:
 errors = dict((f.role_name(), text_type(ex)) for f, ex in self.errors)
 raise ValidationError(valerror_eid(entity.eid), errors)
-if eid is None: # creation or copy
+if eid is None:  # creation or copy
 entity.eid = eid = self._insert_entity(etype, formparams['eid'], rqlquery)
-elif rqlquery.edited: # edition of an existant entity
+elif rqlquery.edited:  # edition of an existant entity
 self.check_concurrent_edition(formparams, eid)
 self._update_entity(eid, rqlquery)
 else:
 self.errors = []
 if is_main_entity:
 # XXX deprecate?
 todelete = req.list_form_param('__delete', formparams, pop=True)
 autoform.delete_relations(req, todelete)
 if '__cloned_eid' in formparams:
 entity.copy_relations(int(formparams['__cloned_eid']))
-if is_main_entity: # only execute linkto for the main entity
+if is_main_entity:  # only execute linkto for the main entity
 self.execute_linkto(entity.eid)
 return eid
 def handle_formfield(self, form, field, rqlquery=None):
 entity = form.edited_entity
 eschema = entity.e_schema
 try:
 for field, value in field.process_posted(form):
-if not (
+if not ((field.role == 'subject' and field.name in eschema.subjrels)
-(field.role == 'subject' and field.name in eschema.subjrels)
+or
-or
+(field.role == 'object' and field.name in eschema.objrels)):
-(field.role == 'object' and field.name in eschema.objrels)):
 continue
 rschema = self._cw.vreg.schema.rschema(field.name)
 if rschema.final:
 rqlquery.set_attribute(field.name, value)
 continue
 if entity.has_eid():
-origvalues = set(data[0] for data in entity.related(field.name, field.role).rows)
+origvalues = set(row[0] for row in entity.related(field.name, field.role).rows)
 else:
 origvalues = set()
 if value is None or value == origvalues:
-continue # not edited / not modified / to do later
+continue  # not edited / not modified / to do later
 unlinked_eids = origvalues - value
 if unlinked_eids:
 # Special handling of composite relation removal
 if rschema.inlined and rqlquery is not None and field.role == 'subject':
 self.handle_inlined_relation(form, field, value, origvalues, rqlquery)
 elif form.edited_entity.has_eid():
 self.handle_relation(form, field, value, origvalues)
 else:
-form._cw.data['pending_others'].add( (form, field) )
+form._cw.data['pending_others'].add((form, field))
 except ProcessFormError as exc:
 self.errors.append((field, exc))
 def handle_composite_removal(self, form, field,
 self.handle_relation(form, field, values, origvalues)
 def handle_relation(self, form, field, values, origvalues):
 """handle edition for the (rschema, x) relation of the given entity
 """
-etype = form.edited_entity.e_schema
 rschema = self._cw.vreg.schema.rschema(field.name)
 if field.role == 'subject':
-desttype = rschema.objects(etype)[0]
-card = rschema.rdef(etype, desttype).cardinality[0]
 subjvar, objvar = 'X', 'Y'
 else:
-desttype = rschema.subjects(etype)[0]
-card = rschema.rdef(desttype, etype).cardinality[1]
 subjvar, objvar = 'Y', 'X'
 eid = form.edited_entity.eid
 if field.role == 'object' or not rschema.inlined or not values:
 # this is not an inlined relation or no values specified,
 # explicty remove relations
 redirect_info = set()
 eidtypes = tuple(eidtypes)
 for eid, etype in eidtypes:
 entity = self._cw.entity_from_eid(eid, etype)
 path, params = entity.cw_adapt_to('IEditControl').after_deletion_path()
-redirect_info.add( (path, tuple(params.items())) )
+redirect_info.add((path, tuple(params.items())))
 entity.cw_delete()
 if len(redirect_info) > 1:
 # In the face of ambiguity, refuse the temptation to guess.
 self._after_deletion_path = 'view', ()
 else:
 self._after_deletion_path = next(iter(redirect_info))
 if len(eidtypes) > 1:
 self._cw.set_message(self._cw._('entities deleted'))
 else:
 self._cw.set_message(self._cw._('entity deleted'))
 def check_concurrent_edition(self, formparams, eid):
 req = self._cw
 try:
 form_ts = datetime.utcfromtimestamp(float(formparams['__form_generation_time']))
 # We only mark the message for translation but the actual
 # translation will be handled by the Validation mechanism...
 msg = _("Entity %(eid)s has changed since you started to edit it."
 " Reload the page and reapply your changes.")
 # ... this is why we pass the formats' dict as a third argument.
-raise ValidationError(eid, {None: msg}, {'eid' : eid})
+raise ValidationError(eid, {None: msg}, {'eid': eid})
 def _action_apply(self):
 self._default_publish()
 self.reset()

changeset 11870	3a84a79c4ed5
parent 11767	432f87a63057
child 11897	2ceb0bfa4b3f