--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/views/autoform.py Tue Apr 28 10:10:04 2009 +0200
@@ -0,0 +1,327 @@
+"""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.formwidgets import Button, SubmitButton
+_ = unicode
+
+class AutomaticEntityForm(EntityFieldsForm):
+ """base automatic form to edit any entity.
+
+ Designed to be flly 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.rtag(rschema, role, X, Y):
+ if 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.set_rtag(category, rschema, role, X, Y)
+
+ @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_rtag(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_rtags(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_rtag(eschema, rschema, role)
+ if fieldcls:
+ return fieldcls(name=name, role=role, eidparam=True)
+ widget = cls_or_self.rwidgets.etype_rtag(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'):
+ toggable_rel_link_func = toggable_relation_link
+ else:
+ toggable_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 = toggable_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_rtag(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)