+
−"""The edit controller, handling form submitting.
+
−
+
−:organization: Logilab
+
−:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.
+
−:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
+
−:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
+
−"""
+
−__docformat__ = "restructuredtext en"
+
−
+
−from decimal import Decimal
+
−
+
−from rql.utils import rqlvar_maker
+
−
+
−from cubicweb import Binary, ValidationError, typed_eid
+
−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
+
−
+
−
+
−class ToDoLater(Exception):
+
−    """exception used in the edit controller to indicate that a relation
+
−    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):
+
−    __regid__ = 'edit'
+
−
+
−    def publish(self, rset=None):
+
−        """edit / create / copy / delete entity / relations"""
+
−        for key in self._cw.form:
+
−            # There should be 0 or 1 action
+
−            if key.startswith('__action_'):
+
−                cbname = key[1:]
+
−                try:
+
−                    callback = getattr(self, cbname)
+
−                except AttributeError:
+
−                    raise RequestError(self._cw._('invalid action %r' % key))
+
−                else:
+
−                    return callback()
+
−        self._default_publish()
+
−        self.reset()
+
−
+
−    def _default_publish(self):
+
−        req = self._cw
+
−        self.errors = []
+
−        self.relations_rql = []
+
−        # so we're able to know the main entity from the repository side
+
−        if '__maineid' in form:
+
−            req.set_shared_data('__maineid', form['__maineid'], querydata=True)
+
−        # no specific action, generic edition
+
−        self._to_create = req.data['eidmap'] = {}
+
−        self._pending_relations = []
+
−        todelete = self._cw.get_pending_deletes()
+
−        toinsert = self._cw.get_pending_inserts()
+
−        try:
+
−            methodname = req.form.pop('__method', None)
+
−            for eid in req.edited_eids():
+
−                # __type and eid
+
−                formparams = req.extract_entity_params(eid, minparams=2)
+
−                if methodname is not None:
+
−                    entity = req.entity_from_eid(eid)
+
−                    method = getattr(entity, methodname)
+
−                    method(formparams)
+
−                eid = self.edit_entity(formparams)
+
−        except (RequestError, NothingToEdit):
+
−            if '__linkto' in req.form and 'eid' in req.form:
+
−                self.execute_linkto()
+
−            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._cw.execute(*querydef)
+
−        # handle relations in newly created entities
+
−        # XXX find a way to merge _pending_relations and relations_rql
+
−        if self._pending_relations:
+
−            for form, field, entity in self._pending_relations:
+
−                for querydef in self.handle_relation(form, field, entity, True):
+
−                    self._cw.execute(*querydef)
+
−        # XXX this processes *all* pending operations of *all* entities
+
−        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 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._cw.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._cw.execute(rql, rqlquery.kwargs).get_entity(0, 0)
+
−            neweid = entity.eid
+
−        except ValidationError, ex:
+
−            self._to_create[eid] = ex.entity
+
−            if self._cw.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._cw.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._cw.vreg['etypes'].etype_class(etype)(self._cw)
+
−        entity.eid = formparams['eid']
+
−        eid = self._get_eid(entity.eid)
+
−        is_main_entity = self._cw.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
+
−        rqlquery = RqlQuery()
+
−        # process inlined relations at the same time as attributes
+
−        # this will generate less rql queries and might be useful in
+
−        # a few dark corners
+
−        formid = self._cw.form.get('__form_id', 'edition')
+
−        form = self._cw.vreg['forms'].select(formid, self._cw, 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
+
−            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._cw.list_form_param('__delete', formparams, pop=True)
+
−            self.delete_relations(parse_relations_descr(todelete))
+
−        if formparams.has_key('__cloned_eid'):
+
−            entity.copy_relations(typed_eid(formparams['__cloned_eid']))
+
−        if formparams.has_key('__insert'):
+
−            toinsert = self._cw.list_form_param('__insert', formparams, pop=True)
+
−            self.insert_relations(parse_relations_descr(toinsert))
+
−        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._cw.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()
+
−
+
−    def _action_cancel(self):
+
−        errorurl = self._cw.form.get('__errorurl')
+
−        if errorurl:
+
−            self._cw.cancel_edition(errorurl)
+
−        self._cw.message = self._cw._('edit canceled')
+
−        return self.reset()
+
−
+
−    def _action_delete(self):
+
−        self.delete_entities(self._cw.edited_eids(withtype=True))
+
−        return self.reset()
+
−
+
−    def _relation_values(self, form, field, entity, late=False):
+
−        """handle edition for the (rschema, x) relation of the given entity
+
−        """
+
−        values = set()
+
−        for eid in field.process_form_value(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 handle_inlined_relation(self, form, field, entity, rqlquery):
+
−        """handle edition for the (rschema, x) relation of the given entity
+
−        """
+
−        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_relation(self, form, field, entity, late=False):
+
−        """handle edition for the (rschema, x) relation of the given entity
+
−        """
+
−        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
+
−        rschema = self._cw.schema.rschema(field.name)
+
−        if field.role == 'subject':
+
−            desttype = rschema.objects(etype)[0]
+
−            card = rschema.rproperty(etype, desttype, 'cardinality')[0]
+
−            subjvar, objvar = 'X', 'Y'
+
−        else:
+
−            desttype = rschema.subjects(etype)[0]
+
−            card = rschema.rproperty(desttype, etype, 'cardinality')[1]
+
−            subjvar, objvar = 'Y', 'X'
+
−        eid = 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
+
−            rql = 'DELETE %s %s %s WHERE X eid %%(x)s, Y eid %%(y)s' % (
+
−                subjvar, rschema, objvar)
+
−            for reid in origvalues.difference(values):
+
−                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:
+
−                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
+
−        # created entity)
+
−        assert eid or eid == 0, repr(eid) # 0 is a valid eid
+
−        try:
+
−            return typed_eid(eid)
+
−        except ValueError:
+
−            try:
+
−                return self._to_create[eid]
+
−            except KeyError:
+
−                self._to_create[eid] = None
+
−                return None
+
−
+
−    def _linked_eids(self, eids, late=False):
+
−        """return a list of eids if they are all known, else raise ToDoLater
+
−        """
+
−
+
−