--- a/web/views/editforms.py Fri Apr 24 19:49:47 2009 +0200
+++ b/web/views/editforms.py Tue Apr 28 10:10:04 2009 +0200
@@ -11,23 +11,21 @@
from simplejson import dumps
-from logilab.common.decorators import iclassmethod
from logilab.mtconverter import html_escape
-from cubicweb import typed_eid
from cubicweb.selectors import (match_kwargs, one_line_rset, non_final_entity,
specified_etype_implements, yes)
from cubicweb.utils import make_uid
from cubicweb.view import EntityView
from cubicweb.common import tags
-from cubicweb.web import INTERNAL_FIELD_VALUE, stdmsgs, uicfg
-from cubicweb.web.form import (FieldNotFound, CompositeForm, EntityFieldsForm,
- FormViewMixIn)
+from cubicweb.web import stdmsgs
+from cubicweb.web.form import CompositeForm, EntityFieldsForm, FormViewMixIn
from cubicweb.web.formfields import guess_field
from cubicweb.web.formwidgets import Button, SubmitButton, ResetButton
from cubicweb.web.formrenderers import (FormRenderer, EntityFormRenderer,
EntityCompositeFormRenderer,
EntityInlinedFormRenderer)
+
_ = unicode
def relation_id(eid, rtype, role, reid):
@@ -125,317 +123,6 @@
self.w(form.form_render(renderer=renderer))
-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)
-
class EditionFormView(FormViewMixIn, EntityView):
"""display primary entity edition form"""
id = 'edition'