+
−"""The automatic entity form.
+
−
+
−:organization: Logilab
+
−:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+
−:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
+
−"""
+
−__docformat__ = "restructuredtext en"
+
−
+
−from logilab.common.decorators import iclassmethod
+
−
+
−from cubicweb import typed_eid
+
−from cubicweb.web import stdmsgs, uicfg
+
−from cubicweb.web.form import FieldNotFound, EntityFieldsForm
+
−from cubicweb.web.formfields import guess_field
+
−from cubicweb.web.formwidgets import Button, SubmitButton
+
−from cubicweb.web.views.editforms import toggleable_relation_link, relation_id
+
−
+
−_ = unicode
+
−
+
−class AutomaticEntityForm(EntityFieldsForm):
+
−    """base automatic form to edit any entity.
+
−
+
−    Designed to be fully generated from schema but highly configurable through:
+
−    * rtags (rcategories, rfields, rwidgets, inlined, rpermissions)
+
−    * various standard form parameters
+
−
+
−    You can also easily customise it by adding/removing fields in
+
−    AutomaticEntityForm instances.
+
−    """
+
−    id = 'edition'
+
−
+
−    cwtarget = 'eformframe'
+
−    cssclass = 'entityForm'
+
−    copy_nav_params = True
+
−    form_buttons = [SubmitButton(stdmsgs.BUTTON_OK),
+
−                    Button(stdmsgs.BUTTON_APPLY, cwaction='apply'),
+
−                    Button(stdmsgs.BUTTON_CANCEL, cwaction='cancel')]
+
−    attrcategories = ('primary', 'secondary')
+
−    # class attributes below are actually stored in the uicfg module since we
+
−    # don't want them to be reloaded
+
−    rcategories = uicfg.rcategories
+
−    rfields = uicfg.rfields
+
−    rwidgets = uicfg.rwidgets
+
−    rinlined = uicfg.rinlined
+
−    rpermissions_overrides = uicfg.rpermissions_overrides
+
−
+
−    @classmethod
+
−    def vreg_initialization_completed(cls):
+
−        """set default category tags for relations where it's not yet defined in
+
−        the category relation tags
+
−        """
+
−        for eschema in cls.schema.entities():
+
−            for rschema, tschemas, role in eschema.relation_definitions(True):
+
−                for tschema in tschemas:
+
−                    if role == 'subject':
+
−                        X, Y = eschema, tschema
+
−                        card = rschema.rproperty(X, Y, 'cardinality')[0]
+
−                        composed = rschema.rproperty(X, Y, 'composite') == 'object'
+
−                    else:
+
−                        X, Y = tschema, eschema
+
−                        card = rschema.rproperty(X, Y, 'cardinality')[1]
+
−                        composed = rschema.rproperty(X, Y, 'composite') == 'subject'
+
−                    if not cls.rcategories.get(rschema, role, X, Y):
+
−                        if eschema.is_metadata(rschema):
+
−                            category = 'generated'
+
−                        elif card in '1+':
+
−                            if not rschema.is_final() and composed:
+
−                                category = 'generated'
+
−                            else:
+
−                                category = 'primary'
+
−                        elif rschema.is_final():
+
−                            category = 'secondary'
+
−                        else:
+
−                            category = 'generic'
+
−                        cls.rcategories.tag_relation(category, (X, rschema, Y), role)
+
−
+
−    @classmethod
+
−    def erelations_by_category(cls, entity, categories=None, permission=None, rtags=None):
+
−        """return a list of (relation schema, target schemas, role) matching
+
−        categories and permission
+
−        """
+
−        if categories is not None:
+
−            if not isinstance(categories, (list, tuple, set, frozenset)):
+
−                categories = (categories,)
+
−            if not isinstance(categories, (set, frozenset)):
+
−                categories = frozenset(categories)
+
−        eschema  = entity.e_schema
+
−        if rtags is None:
+
−            rtags = cls.rcategories
+
−        permsoverrides = cls.rpermissions_overrides
+
−        if entity.has_eid():
+
−            eid = entity.eid
+
−        else:
+
−            eid = None
+
−        for rschema, targetschemas, role in eschema.relation_definitions(True):
+
−            # check category first, potentially lower cost than checking
+
−            # permission which may imply rql queries
+
−            if categories is not None:
+
−                targetschemas = [tschema for tschema in targetschemas
+
−                                 if rtags.etype_get(eschema, rschema, role, tschema) in categories]
+
−                if not targetschemas:
+
−                    continue
+
−            if permission is not None:
+
−                # tag allowing to hijack the permission machinery when
+
−                # permission is not verifiable until the entity is actually
+
−                # created...
+
−                if eid is None and '%s_on_new' % permission in permsoverrides.etype_get(eschema, rschema, role):
+
−                    yield (rschema, targetschemas, role)
+
−                    continue
+
−                if rschema.is_final():
+
−                    if not rschema.has_perm(entity.req, permission, eid):
+
−                        continue
+
−                elif role == 'subject':
+
−                    if not ((eid is None and rschema.has_local_role(permission)) or
+
−                            rschema.has_perm(entity.req, permission, fromeid=eid)):
+
−                        continue
+
−                    # on relation with cardinality 1 or ?, we need delete perm as well
+
−                    # if the relation is already set
+
−                    if (permission == 'add'
+
−                        and rschema.cardinality(eschema, targetschemas[0], role) in '1?'
+
−                        and eid and entity.related(rschema.type, role)
+
−                        and not rschema.has_perm(entity.req, 'delete', fromeid=eid,
+
−                                                 toeid=entity.related(rschema.type, role)[0][0])):
+
−                        continue
+
−                elif role == 'object':
+
−                    if not ((eid is None and rschema.has_local_role(permission)) or
+
−                            rschema.has_perm(entity.req, permission, toeid=eid)):
+
−                        continue
+
−                    # on relation with cardinality 1 or ?, we need delete perm as well
+
−                    # if the relation is already set
+
−                    if (permission == 'add'
+
−                        and rschema.cardinality(targetschemas[0], eschema, role) in '1?'
+
−                        and eid and entity.related(rschema.type, role)
+
−                        and not rschema.has_perm(entity.req, 'delete', toeid=eid,
+
−                                                 fromeid=entity.related(rschema.type, role)[0][0])):
+
−                        continue
+
−            yield (rschema, targetschemas, role)
+
−
+
−    @classmethod
+
−    def esrelations_by_category(cls, entity, categories=None, permission=None):
+
−        """filter out result of relations_by_category(categories, permission) by
+
−        removing final relations
+
−
+
−        return a sorted list of (relation's label, relation'schema, role)
+
−        """
+
−        result = []
+
−        for rschema, ttypes, role in cls.erelations_by_category(
+
−            entity, categories, permission):
+
−            if rschema.is_final():
+
−                continue
+
−            result.append((rschema.display_name(entity.req, role), rschema, role))
+
−        return sorted(result)
+
−
+
−    @iclassmethod
+
−    def field_by_name(cls_or_self, name, role='subject', eschema=None):
+
−        """return field with the given name and role. If field is not explicitly
+
−        defined for the form but `eclass` is specified, guess_field will be
+
−        called.
+
−        """
+
−        try:
+
−            return super(AutomaticEntityForm, cls_or_self).field_by_name(name, role)
+
−        except FieldNotFound: # XXX should raise more explicit exception
+
−            if eschema is None or not name in cls_or_self.schema:
+
−                raise
+
−            rschema = cls_or_self.schema.rschema(name)
+
−            fieldcls = cls_or_self.rfields.etype_get(eschema, rschema, role)
+
−            if fieldcls:
+
−                return fieldcls(name=name, role=role, eidparam=True)
+
−            widget = cls_or_self.rwidgets.etype_get(eschema, rschema, role)
+
−            if widget:
+
−                field = guess_field(eschema, rschema, role,
+
−                                    eidparam=True, widget=widget)
+
−            else:
+
−                field = guess_field(eschema, rschema, role, eidparam=True)
+
−            if field is None:
+
−                raise
+
−            return field
+
−
+
−    def __init__(self, *args, **kwargs):
+
−        super(AutomaticEntityForm, self).__init__(*args, **kwargs)
+
−        entity = self.edited_entity
+
−        if entity.has_eid():
+
−            entity.complete()
+
−        for rschema, role in self.editable_attributes():
+
−            try:
+
−                self.field_by_name(rschema.type, role)
+
−                continue # explicitly specified
+
−            except FieldNotFound:
+
−                # has to be guessed
+
−                try:
+
−                    field = self.field_by_name(rschema.type, role,
+
−                                               eschema=entity.e_schema)
+
−                    self.fields.append(field)
+
−                except FieldNotFound:
+
−                    # meta attribute such as <attr>_format
+
−                    continue
+
−        self.maxrelitems = self.req.property_value('navigation.related-limit')
+
−        self.force_display = bool(self.req.form.get('__force_display'))
+
−
+
−    @property
+
−    def related_limit(self):
+
−        if self.force_display:
+
−            return None
+
−        return self.maxrelitems + 1
+
−
+
−    def relations_by_category(self, categories=None, permission=None):
+
−        """return a list of (relation schema, target schemas, role) matching
+
−        given category(ies) and permission
+
−        """
+
−        return self.erelations_by_category(self.edited_entity, categories,
+
−                                           permission)
+
−
+
−    def inlined_relations(self):
+
−        """return a list of (relation schema, target schemas, role) matching
+
−        given category(ies) and permission
+
−        """
+
−        # we'll need an initialized varmaker if there are some inlined relation
+
−        self.initialize_varmaker()
+
−        return self.erelations_by_category(self.edited_entity, True, 'add', self.rinlined)
+
−
+
−    def srelations_by_category(self, categories=None, permission=None):
+
−        """filter out result of relations_by_category(categories, permission) by
+
−        removing final relations
+
−
+
−        return a sorted list of (relation's label, relation'schema, role)
+
−        """
+
−        return self.esrelations_by_category(self.edited_entity, categories,
+
−                                           permission)
+
−
+
−    def action(self):
+
−        """return the form's action attribute. Default to validateform if not
+
−        explicitly overriden.
+
−        """
+
−        try:
+
−            return self._action
+
−        except AttributeError:
+
−            return self.build_url('validateform')
+
−
+
−    def set_action(self, value):
+
−        """override default action"""
+
−        self._action = value
+
−
+
−    action = property(action, set_action)
+
−
+
−    def editable_attributes(self):
+
−        """return a list of (relation schema, role) to edit for the entity"""
+
−        return [(rschema, x) for rschema, _, x in self.relations_by_category(
+
−                self.attrcategories, 'add') if rschema != 'eid']
+
−
+
−    def relations_table(self):
+
−        """yiels 3-tuples (rtype, target, related_list)
+
−        where <related_list> itself a list of :
+
−          - node_id (will be the entity element's DOM id)
+
−          - appropriate javascript's togglePendingDelete() function call
+
−          - status 'pendingdelete' or ''
+
−          - oneline view of related entity
+
−        """
+
−        entity = self.edited_entity
+
−        pending_deletes = self.req.get_pending_deletes(entity.eid)
+
−        for label, rschema, role in self.srelations_by_category('generic', 'add'):
+
−            relatedrset = entity.related(rschema, role, limit=self.related_limit)
+
−            if rschema.has_perm(self.req, 'delete'):
+
−                toggleable_rel_link_func = toggleable_relation_link
+
−            else:
+
−                toggleable_rel_link_func = lambda x, y, z: u''
+
−            related = []
+
−            for row in xrange(relatedrset.rowcount):
+
−                nodeid = relation_id(entity.eid, rschema, role,
+
−                                     relatedrset[row][0])
+
−                if nodeid in pending_deletes:
+
−                    status = u'pendingDelete'
+
−                    label = '+'
+
−                else:
+
−                    status = u''
+
−                    label = 'x'
+
−                dellink = toggleable_rel_link_func(entity.eid, nodeid, label)
+
−                eview = self.view('oneline', relatedrset, row=row)
+
−                related.append((nodeid, dellink, status, eview))
+
−            yield (rschema, role, related)
+
−
+
−    def restore_pending_inserts(self, cell=False):
+
−        """used to restore edition page as it was before clicking on
+
−        'search for <some entity type>'
+
−        """
+
−        eid = self.edited_entity.eid
+
−        cell = cell and "div_insert_" or "tr"
+
−        pending_inserts = set(self.req.get_pending_inserts(eid))
+
−        for pendingid in pending_inserts:
+
−            eidfrom, rtype, eidto = pendingid.split(':')
+
−            if typed_eid(eidfrom) == eid: # subject
+
−                label = display_name(self.req, rtype, 'subject')
+
−                reid = eidto
+
−            else:
+
−                label = display_name(self.req, rtype, 'object')
+
−                reid = eidfrom
+
−            jscall = "javascript: cancelPendingInsert('%s', '%s', null, %s);" \
+
−                     % (pendingid, cell, eid)
+
−            rset = self.req.eid_rset(reid)
+
−            eview = self.view('text', rset, row=0)
+
−            # XXX find a clean way to handle baskets
+
−            if rset.description[0][0] == 'Basket':
+
−                eview = '%s (%s)' % (eview, display_name(self.req, 'Basket'))
+
−            yield rtype, pendingid, jscall, label, reid, eview
+
−
+
−    # should_* method extracted to allow overriding
+
−
+
−    def should_inline_relation_form(self, rschema, targettype, role):
+
−        """return true if the given relation with entity has role and a
+
−        targettype target should be inlined
+
−        """
+
−        return self.rinlined.etype_get(self.edited_entity.id, rschema, role, targettype)
+
−
+
−    def should_display_inline_creation_form(self, rschema, existant, card):
+
−        """return true if a creation form should be inlined
+
−
+
−        by default true if there is no related entity and we need at least one
+
−        """
+
−        return not existant and card in '1+'
+
−
+
−    def should_display_add_new_relation_link(self, rschema, existant, card):
+
−        """return true if we should add a link to add a new creation form
+
−        (through ajax call)
+
−
+
−        by default true if there is no related entity or if the relation has
+
−        multiple cardinality
+
−        """
+
−        return not existant or card in '+*'
+
−
+
−
+
−def etype_relation_field(etype, rtype, role='subject'):
+
−    eschema = AutomaticEntityForm.schema.eschema(etype)
+
−    return AutomaticEntityForm.field_by_name(rtype, role, eschema)