cubicweb: comparison schema.py

equal deleted inserted replaced

-:3ab2682a4b37
+:50e1a6ad3e98
 mainvars.append('O')
 if 'U' in defined:
 mainvars.append('U')
 if not mainvars:
 raise Exception('unable to guess selection variables')
-return ','.join(mainvars)
+return ','.join(sorted(mainvars))
 def split_expression(rqlstring):
 for expr in rqlstring.split(','):
 for noparen in expr.split('('):
 for word in noparen.split():
 else:
 assert not 'eid' in kwargs, kwargs
 assert action in ('read', 'add', 'delete')
 if 'fromeid' in kwargs:
 subjtype = session.describe(kwargs['fromeid'])[0]
+elif 'frometype' in kwargs:
+subjtype = kwargs.pop('frometype')
 else:
 subjtype = None
 if 'toeid' in kwargs:
 objtype = session.describe(kwargs['toeid'])[0]
+elif 'toetype' in kwargs:
+objtype = kwargs.pop('toetype')
 else:
 objtype = None
 if objtype and subjtype:
 return self.rdef(subjtype, objtype).has_perm(session, action, **kwargs)
 elif subjtype:
 def serialize(self):
 # start with a comma for bw compat, see below
 return ';' + self.mainvars + ';' + self.restriction
+@classmethod
 def deserialize(cls, value):
 # XXX < 3.5.10 bw compat
 if not value.startswith(';'):
 return cls(value)
 _, mainvars, restriction = value.split(';', 2)
 return cls(restriction, mainvars)
-deserialize = classmethod(deserialize)
 def check(self, entity, rtype, value):
 """return true if the value satisfy the constraint, else false"""
 # implemented as a hook in the repository
 return 1
 def exec_query(self, session, eidfrom, eidto):
 if eidto is None:
 # checking constraint for an attribute relation
 restriction = 'S eid %(s)s, ' + self.restriction
-args, ck = {'s': eidfrom}, 's'
+args = {'s': eidfrom}
 else:
 restriction = 'S eid %(s)s, O eid %(o)s, ' + self.restriction
-args, ck = {'s': eidfrom, 'o': eidto}, ('s', 'o')
+args = {'s': eidfrom, 'o': eidto}
 rql = 'Any %s WHERE %s' % (self.mainvars,  restriction)
 if self.distinct_query:
 rql = 'DISTINCT ' + rql
-return session.execute(rql, args, ck, build_descr=False)
+return session.execute(rql, args, build_descr=False)
 class RQLConstraint(RepoEnforcedRQLConstraintMixIn, RQLVocabularyConstraint):
 """the rql constraint is similar to the RQLVocabularyConstraint but
 are also enforced at the repository level
 try:
 return session.local_perm_cache[key]
 except KeyError:
 pass
 rql, has_perm_defs, keyarg = self.transform_has_permission()
-if creating:
+# when creating an entity, expression related to X satisfied
-# when creating an entity, consider has_*_permission satisfied
+if creating and 'X' in self.rqlst.defined_vars:
-if has_perm_defs:
+return True
-return True
-return False
 if keyarg is None:
 kwargs.setdefault('u', session.user.eid)
-cachekey = kwargs.keys()
 try:
-rset = session.execute(rql, kwargs, cachekey, build_descr=True)
+rset = session.execute(rql, kwargs, build_descr=True)
 except NotImplementedError:
 self.critical('cant check rql expression, unsupported rql %s', rql)
 if self.eid is not None:
 session.local_perm_cache[key] = False
 return False
 except TypeResolverException, ex:
 # some expression may not be resolvable with current kwargs
 # (type conflict)
 self.warning('%s: %s', rql, str(ex))
+if self.eid is not None:
+session.local_perm_cache[key] = False
+return False
+except Unauthorized, ex:
+self.debug('unauthorized %s: %s', rql, str(ex))
 if self.eid is not None:
 session.local_perm_cache[key] = False
 return False
 else:
 rset = session.eid_rset(kwargs[keyarg])
 from yams.buildobjs import _add_relation as yams_add_relation
 class workflowable_definition(ybo.metadefinition):
 """extends default EntityType's metaclass to add workflow relations
-(i.e. in_state and wf_info_for).
+(i.e. in_state, wf_info_for and custom_workflow). This is the default
-This is the default metaclass for WorkflowableEntityType
+metaclass for WorkflowableEntityType.
 """
 def __new__(mcs, name, bases, classdict):
 abstract = classdict.pop('__abstract__', False)
 cls = super(workflowable_definition, mcs).__new__(mcs, name, bases,
 classdict)
 if not abstract:
 make_workflowable(cls)
 return cls
+class WorkflowableEntityType(ybo.EntityType):
+"""Use this base class instead of :class:`EntityType` to have workflow
+relations (i.e. `in_state`, `wf_info_for` and `custom_workflow`) on your
+entity type.
+"""
+__metaclass__ = workflowable_definition
+__abstract__ = True
 def make_workflowable(cls, in_state_descr=None):
+"""Adds workflow relations as :class:`WorkflowableEntityType`, but usable on
+existing classes which are not using that base class.
+"""
 existing_rels = set(rdef.name for rdef in cls.__relations__)
 # let relation types defined in cw.schemas.workflow carrying
 # cardinality, constraints and other relation definition properties
+etype = getattr(cls, 'name', cls.__name__)
 if 'custom_workflow' not in existing_rels:
-rdef = ybo.SubjectRelation('Workflow')
+rdef = ybo.RelationDefinition(etype, 'custom_workflow', 'Workflow')
-yams_add_relation(cls.__relations__, rdef, 'custom_workflow')
+yams_add_relation(cls.__relations__, rdef)
 if 'in_state' not in existing_rels:
-rdef = ybo.SubjectRelation('State', description=in_state_descr)
+rdef = ybo.RelationDefinition(etype, 'in_state', 'State',
-yams_add_relation(cls.__relations__, rdef, 'in_state')
+description=in_state_descr)
+yams_add_relation(cls.__relations__, rdef)
 if 'wf_info_for' not in existing_rels:
-rdef = ybo.ObjectRelation('TrInfo')
+rdef = ybo.RelationDefinition('TrInfo', 'wf_info_for', etype)
-yams_add_relation(cls.__relations__, rdef, 'wf_info_for')
+yams_add_relation(cls.__relations__, rdef)
-class WorkflowableEntityType(ybo.EntityType):
-__metaclass__ = workflowable_definition
-__abstract__ = True
 # schema loading ##############################################################
 CONSTRAINTS['RQLConstraint'] = RQLConstraint

branch	oldstable
changeset 5993	50e1a6ad3e98
parent 5746	f4fc424747db
child 5752	b0bb553e3be4