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

equal deleted inserted replaced

-:c71339453c1e
+:056de1196ef8
 # Adds all subjects of the entry_of relation in the add menu of the ``Blog``
 # primary view
 uicfg.actionbox_appearsin_addmenu.tag_object_of(('*', 'entry_of', 'Blog'), True)
 """
-from warnings import warn
 from six import string_types
 from cubicweb import neg_role
 from cubicweb.rtags import (RelationTags, RelationTagsBool, RelationTagsSet,
 RelationTagsDict, NoTargetRelationTagsDict,
 section = 'relations'
 else:
 section = 'sideboxes'
 self.tag_relation((sschema, rschema, oschema, role), section)
 primaryview_section = PrimaryViewSectionRelationTags()
 class DisplayCtrlRelationTags(NoTargetRelationTagsDict):
 """primary view display controller configuration"""
 # * 'system'
 # * 'schema'
 # * 'hidden'
 # * 'subobject' (not displayed by default)
-class InitializableDict(dict): # XXX not a rtag. Turn into an appobject?
+class InitializableDict(dict):  # XXX not a rtag. Turn into an appobject?
 def __init__(self, *args, **kwargs):
 super(InitializableDict, self).__init__(*args, **kwargs)
 self.__defaults = dict(self)
 def init(self, schema, check=True):
 elif eschema.is_subobject(strict=True):
 self.setdefault(eschema, 'subobject')
 else:
 self.setdefault(eschema, 'application')
 indexview_etype_section = InitializableDict(
 EmailAddress='subobject',
 Bookmark='system',
 # entity types in the 'system' table by default (managers only)
 CWUser='system', CWGroup='system',
 )
 # autoform.AutomaticEntityForm configuration ##################################
 def _formsections_as_dict(formsections):
 result = {}
 for formsection in formsections:
 formtype, section = formsection.split('_', 1)
 result[formtype] = section
 return result
 def _card_and_comp(sschema, rschema, oschema, role):
 rdef = rschema.rdef(sschema, oschema)
 if role == 'subject':
 card = rdef.cardinality[0]
 composed = not rschema.final and rdef.composite == 'object'
 else:
 card = rdef.cardinality[1]
 composed = not rschema.final and rdef.composite == 'subject'
 return card, composed
 class AutoformSectionRelationTags(RelationTagsSet):
 """autoform relations'section"""
 __regid__ = 'autoform_section'
 # (eg RichTextField, FileField...)
 sectdict.setdefault('main', 'hidden')
 sectdict.setdefault('muledit', 'hidden')
 sectdict.setdefault('inlined', 'hidden')
 # ensure we have a tag for each form type
-if not 'main' in sectdict:
+if 'main' not in sectdict:
 if sschema.is_metadata(rschema):
 sectdict['main'] = 'metadata'
 else:
 card, composed = _card_and_comp(sschema, rschema, oschema, role)
 if card in '1+':
 sectdict['main'] = 'attributes'
-if not 'muledit' in sectdict:
+if 'muledit' not in sectdict:
 sectdict['muledit'] = 'attributes'
 elif rschema.final:
 sectdict['main'] = 'attributes'
 else:
 sectdict['main'] = 'relations'
-if not 'muledit' in sectdict:
+if 'muledit' not in sectdict:
 sectdict['muledit'] = 'hidden'
 if sectdict['main'] == 'attributes':
 card, composed = _card_and_comp(sschema, rschema, oschema, role)
 if card in '1+' and not composed:
 sectdict['muledit'] = 'attributes'
-if not 'inlined' in sectdict:
+if 'inlined' not in sectdict:
 sectdict['inlined'] = sectdict['main']
 # recompute formsections and set it to avoid recomputing
 for formtype, section in sectdict.items():
 formsections.add('%s_%s' % (formtype, section))
 if isinstance(formtype, tuple):
 for ftype in formtype:
 self.tag_relation(key, ftype, section)
 return
 assert formtype in self._allowed_form_types, \
 'formtype should be in (%s), not %s' % (
 ','.join(self._allowed_form_types), formtype)
 assert section in self._allowed_values[formtype], \
 'section for %s should be in (%s), not %s' % (
 formtype, ','.join(self._allowed_values[formtype]), section)
 rtags = self._tagdefs.setdefault(_ensure_str_key(key),
 self.tag_container_cls())
 # remove previous section for this form type if any
 if rtags:
 for tag in rtags.copy():
 for tag in tags:
 assert '_' in tag, (tag, tags)
 section, value = tag.split('_', 1)
 rtags[section] = value
 cls = self.tag_container_cls
-rtags = cls('_'.join([section,value])
+rtags = cls('_'.join([section, value])
-for section,value in rtags.items())
+for section, value in rtags.items())
 return rtags
 def get(self, *key):
 # overriden to avoid recomputing done in parent classes
 return self._tagdefs.get(key, ())
 `strict`:
 bool telling if having local role is enough (strict = False) or not
 """
 tag = '%s_%s' % (formtype, section)
-eschema  = entity.e_schema
+eschema = entity.e_schema
 cw = entity._cw
-permsoverrides = cw.vreg['uicfg'].select('autoform_permissions_overrides', cw, entity=entity)
+permsoverrides = cw.vreg['uicfg'].select('autoform_permissions_overrides', cw,
+entity=entity)
 if entity.has_eid():
 eid = entity.eid
 else:
 eid = None
 strict = False
 for rschema, targetschemas, role in eschema.relation_definitions(True):
 _targetschemas = []
 for tschema in targetschemas:
 # check section's tag first, potentially lower cost than
 # checking permission which may imply rql queries
-if not tag in self.etype_get(eschema, rschema, role, tschema):
+if tag not in self.etype_get(eschema, rschema, role, tschema):
 continue
 rdef = rschema.role_rdef(eschema, tschema, role)
 if rschema.final:
 if not rdef.has_perm(cw, permission, eid=eid,
 creating=eid is None):
 targetschemas = _targetschemas
 rdef = eschema.rdef(rschema, role=role, targettype=targetschemas[0])
 # XXX 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):
+if eid is None and '%s_on_new' % permission in permsoverrides.etype_get(
+eschema, rschema, role):
 yield (rschema, targetschemas, role)
 continue
 if not rschema.final and role == 'subject':
 # on relation with cardinality 1 or ?, we need delete perm as well
 # if the relation is already set
 afs.set_muledit_editable('CWUser', ('firstname', 'surname', 'in_group'))
 """
 for attr in attrs:
 self.edit_as_attr(self, etype, attr, formtype='muledit')
 autoform_section = AutoformSectionRelationTags()
 # relations'field class
 `attr` can be a string or 2-tuple (relname, role_of_etype_in_the_relation)
 """
 self._tag_etype_attr(etype, attr, '*', field)
 autoform_field = AutoformFieldTags()
 # relations'field explicit kwargs (given to field's __init__)
 # set of tags of the form <action>_on_new on relations. <action> is a
 # schema action (add/update/delete/read), and when such a tag is found
 # permissions checking is by-passed and supposed to be ok
 class AutoFormPermissionsOverrides(RelationTagsSet):
 __regid__ = 'autoform_permissions_overrides'
 autoform_permissions_overrides = AutoFormPermissionsOverrides()
 class ReleditTags(NoTargetRelationTagsDict):
 edittarget = None
 if not edittarget:
 edittarget = 'related' if composite else 'rtype'
 self.tag_relation((sschema, rschema, oschema, role),
 {'edit_target': edittarget})
-if not 'novalue_include_rtype' in values:
+if 'novalue_include_rtype' not in values:
 showlabel = primaryview_display_ctrl.get(
 sschema, rschema, oschema, role).get('showlabel', True)
 self.tag_relation((sschema, rschema, oschema, role),
 {'novalue_include_rtype': not showlabel})
 reledit_ctrl = ReleditTags()
 # boxes.EditBox configuration #################################################
 def append_to_addmenu(self, etype, attr, createdtype='*'):
 """adds `attr` in the actions box *addrelated* submenu of `etype`.
 :param etype: the entity type as a string
 :param attr: the name of the attribute or relation to hide
-:param createdtype: the target type of the relation (optional, defaults to '*' (all possible types))
+:param createdtype: the target type of the relation
+(optional, defaults to '*' (all possible types))
 `attr` can be a string or 2-tuple (relname, role_of_etype_in_the_relation)
 """
 self._tag_etype_attr(etype, attr, createdtype, True)
 def remove_from_addmenu(self, etype, attr, createdtype='*'):
 """removes `attr` from the actions box *addrelated* submenu of `etype`.
 :param etype: the entity type as a string
 :param attr: the name of the attribute or relation to hide
-:param createdtype: the target type of the relation (optional, defaults to '*' (all possible types))
+:param createdtype: the target type of the relation
+(optional, defaults to '*' (all possible types))
 `attr` can be a string or 2-tuple (relname, role_of_etype_in_the_relation)
 """
 self._tag_etype_attr(etype, attr, createdtype, False)
 actionbox_appearsin_addmenu = ActionBoxUicfg()
 def registration_callback(vreg):
 vreg.register_all(globals().values(), __name__)
 indexview_etype_section.init(vreg.schema)

changeset 11854	056de1196ef8
parent 11853	c71339453c1e
child 11932	7b2247098f58