cubicweb: comparison server/hooks.py

equal deleted inserted replaced

-:7bfa83772d90
+:e47d63351891
 def relation_deleted(session, eidfrom, rtype, eidto):
 session.transaction_data.setdefault('pendingrelations', []).append(
 (eidfrom, rtype, eidto))
+def eschema_type_eid(session, etype):
-# base meta-data handling #####################################################
+"""get eid of the CWEType entity for the given yams type"""
+eschema = session.repo.schema.eschema(etype)
+# eschema.eid is None if schema has been readen from the filesystem, not
+# from the database (eg during tests)
+if eschema.eid is None:
+eschema.eid = session.unsafe_execute(
+'Any X WHERE X is CWEType, X name %(name)s', {'name': etype})[0][0]
+return eschema.eid
+# base meta-data handling ######################################################
 def setctime_before_add_entity(session, entity):
 """before create a new entity -> set creation and modification date
 this is a conveniency hook, you shouldn't have to disable it
 """
-if not 'creation_date' in entity:
+timestamp = datetime.now()
-entity['creation_date'] = datetime.now()
+entity.setdefault('creation_date', timestamp)
-if not 'modification_date' in entity:
+entity.setdefault('modification_date', timestamp)
-entity['modification_date'] = datetime.now()
+if not session.get_shared_data('do-not-insert-cwuri'):
-if not 'cwuri' in entity:
+entity.setdefault('cwuri', u'%seid/%s' % (session.base_url(), entity.eid))
-if not session.get_shared_data('do-not-insert-cwuri'):
-entity['cwuri'] = session.base_url() + u'eid/%s' % entity.eid
 def setmtime_before_update_entity(session, entity):
 """update an entity -> set modification date"""
-if not 'modification_date' in entity:
+entity.setdefault('modification_date', datetime.now())
-entity['modification_date'] = datetime.now()
 class SetCreatorOp(PreCommitOperation):
 def precommit_event(self):
-if self.eid in self.session.transaction_data.get('pendingeids', ()):
+session = self.session
+if self.entity.eid in session.transaction_data.get('pendingeids', ()):
 # entity have been created and deleted in the same transaction
 return
-ueid = self.session.user.eid
+if not self.entity.created_by:
-execute = self.session.unsafe_execute
+session.add_relation(self.entity.eid, 'created_by', session.user.eid)
-if not execute('Any X WHERE X created_by U, X eid %(x)s',
-{'x': self.eid}, 'x'):
-execute('SET X created_by U WHERE X eid %(x)s, U eid %(u)s',
-{'x': self.eid, 'u': ueid}, 'x')
 def setowner_after_add_entity(session, entity):
 """create a new entity -> set owner and creator metadata"""
 asession = session.actual_session()
 if not asession.is_internal_session:
-session.unsafe_execute('SET X owned_by U WHERE X eid %(x)s, U eid %(u)s',
+session.add_relation(entity.eid, 'owned_by', asession.user.eid)
-{'x': entity.eid, 'u': asession.user.eid}, 'x')
+SetCreatorOp(asession, entity=entity)
-SetCreatorOp(asession, eid=entity.eid)
 def setis_after_add_entity(session, entity):
 """create a new entity -> set is relation"""
 if hasattr(entity, '_cw_recreating'):
 return
-session.unsafe_execute('SET X is E WHERE X eid %(x)s, E name %(name)s',
+try:
-{'x': entity.eid, 'name': entity.id}, 'x')
+session.add_relation(entity.eid, 'is',
+eschema_type_eid(session, entity.id))
+except IndexError:
+# during schema serialization, skip
+return
 # XXX < 2.50 bw compat
 if not session.get_shared_data('do-not-insert-is_instance_of'):
-basetypes = entity.e_schema.ancestors() + [entity.e_schema]
+for etype in entity.e_schema.ancestors() + [entity.e_schema]:
-session.unsafe_execute('SET X is_instance_of E WHERE X eid %%(x)s, E name IN (%s)' %
+session.add_relation(entity.eid, 'is_instance_of',
-','.join("'%s'" % str(etype) for etype in basetypes),
+eschema_type_eid(session, etype))
-{'x': entity.eid}, 'x')
 def setowner_after_add_user(session, entity):
 """when a user has been created, add owned_by relation on itself"""
-session.unsafe_execute('SET X owned_by X WHERE X eid %(x)s',
+session.add_relation(entity.eid, 'owned_by', entity.eid)
-{'x': entity.eid}, 'x')
 def fti_update_after_add_relation(session, eidfrom, rtype, eidto):
 """sync fulltext index when relevant relation is added. Reindexing the
 contained entity is enough since it will implicitly reindex the container
 entity.
 ftcontainer = session.repo.schema.rschema(rtype).fulltext_container
 if ftcontainer == 'subject':
 FTIndexEntityOp(session, entity=session.entity_from_eid(eidto))
 elif ftcontainer == 'object':
 FTIndexEntityOp(session, entity=session.entity_from_eid(eidfrom))
 def fti_update_after_delete_relation(session, eidfrom, rtype, eidto):
 """sync fulltext index when relevant relation is deleted. Reindexing both
 entities is necessary.
 """
 if session.repo.schema.rschema(rtype).fulltext_container:
 FTIndexEntityOp(session, entity=session.entity_from_eid(eidto))
 FTIndexEntityOp(session, entity=session.entity_from_eid(eidfrom))
 class SyncOwnersOp(PreCommitOperation):
 def precommit_event(self):
 self.session.unsafe_execute('SET X owned_by U WHERE C owned_by U, C eid %(c)s,'
 'NOT EXISTS(X owned_by U, X eid %(x)s)',
 {'c': self.compositeeid, 'x': self.composedeid},
 ('c', 'x'))
 def sync_owner_after_add_composite_relation(session, eidfrom, rtype, eidto):
 """when adding composite relation, the composed should have the same owners
 has the composite
 """
 if rtype == 'wf_info_for':
-# skip this special composite relation
+# skip this special composite relation # XXX (syt) why?
 return
 composite = rproperty(session, rtype, eidfrom, eidto, 'composite')
 if composite == 'subject':
 SyncOwnersOp(session, compositeeid=eidfrom, composedeid=eidto)
 elif composite == 'object':
 SyncOwnersOp(session, compositeeid=eidto, composedeid=eidfrom)
 def _register_metadata_hooks(hm):
 """register meta-data related hooks on the hooks manager"""
 hm.register_hook(setctime_before_add_entity, 'before_add_entity', '')
 hm.register_hook(setmtime_before_update_entity, 'before_update_entity', '')
 if 'is' in hm.schema:
 hm.register_hook(setis_after_add_entity, 'after_add_entity', '')
 if 'CWUser' in hm.schema:
 hm.register_hook(setowner_after_add_user, 'after_add_entity', 'CWUser')
 # core hooks ##################################################################
 class DelayedDeleteOp(PreCommitOperation):
 """delete the object of composite relation except if the relation
 has actually been redirected to another composite
 etype = session.describe(self.eid)[0]
 session.unsafe_execute('DELETE %s X WHERE X eid %%(x)s, NOT %s'
 % (etype, self.relation),
 {'x': self.eid}, 'x')
 def handle_composite_before_del_relation(session, eidfrom, rtype, eidto):
 """delete the object of composite relation"""
 composite = rproperty(session, rtype, eidfrom, eidto, 'composite')
 if composite == 'subject':
 DelayedDeleteOp(session, eid=eidto, relation='Y %s X' % rtype)
 elif composite == 'object':
 DelayedDeleteOp(session, eid=eidfrom, relation='X %s Y' % rtype)
 def before_del_group(session, eid):
 """check that we don't remove the owners group"""
 check_internal_entity(session, eid, ('owners',))
 constraint)
 def commit_event(self):
 pass
 def cstrcheck_after_add_relation(session, eidfrom, rtype, eidto):
 """check the relation satisfy its constraints
 this is delayed to a precommit time operation since other relation which
 will make constraint satisfied may be added later.
 if rset and rset[0][0] != entity.eid:
 msg = session._('the value "%s" is already used, use another one')
 raise ValidationError(entity.eid, {attr: msg % val})
 class CheckRequiredRelationOperation(LateOperation):
 """checking relation cardinality has to be done after commit in
 case the relation is being replaced
 """
 eid, rtype = None, None
 return
 if self.session.unsafe_execute(*self._rql()).rowcount < 1:
 etype = self.session.describe(self.eid)[0]
 _ = self.session._
 msg = _('at least one relation %(rtype)s is required on %(etype)s (%(eid)s)')
-raise ValidationError(self.eid, {self.rtype: msg % {'rtype': _(self.rtype),
+msg %= {'rtype': _(self.rtype), 'etype': _(etype), 'eid': self.eid}
-'etype': _(etype),
+raise ValidationError(self.eid, {self.rtype: msg})
-'eid': self.eid}})
 def commit_event(self):
 pass
 def _rql(self):
 raise NotImplementedError()
 class CheckSRelationOp(CheckRequiredRelationOperation):
 """check required subject relation"""
 def _rql(self):
 return 'Any O WHERE S eid %%(x)s, S %s O' % self.rtype, {'x': self.eid}, 'x'
 class CheckORelationOp(CheckRequiredRelationOperation):
 """check required object relation"""
 def _rql(self):
 return 'Any S WHERE O eid %%(x)s, S %s O' % self.rtype, {'x': self.eid}, 'x'
 def checkrel_if_necessary(session, opcls, rtype, eid):
 """check an equivalent operation has not already been added"""
 for op in session.pending_operations:
 if isinstance(op, opcls) and op.rtype == rtype and op.eid == eid:
 break
 else:
 opcls(session, rtype=rtype, eid=eid)
 def cardinalitycheck_after_add_entity(session, entity):
 """check cardinalities are satisfied"""
 eid = entity.eid
 for rschema, targetschemas, x in entity.e_schema.relation_definitions():
 opcls = CheckORelationOp
 card = rschema.rproperty(subjtype, objtype, 'cardinality')
 if card[cardindex] in '1+':
 checkrel_if_necessary(session, opcls, rschema.type, eid)
 def cardinalitycheck_before_del_relation(session, eidfrom, rtype, eidto):
 """check cardinalities are satisfied"""
 card = rproperty(session, rtype, eidfrom, eidto, 'cardinality')
 pendingeids = session.transaction_data.get('pendingeids', ())
 if card[0] in '1+' and not eidfrom in pendingeids:
 rql = 'Any N WHERE G eid %(x)s, G name N'
 result = session.execute(rql, {'x': kwargs['geid']}, 'x', build_descr=False)
 Operation.__init__(self, session, *args, **kwargs)
 self.group = result[0][0]
 class DeleteGroupOp(GroupOperation):
 """synchronize user when a in_group relation has been deleted"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 groups = self.cnxuser.groups
 groups.remove(self.group)
 except KeyError:
 self.error('user %s not in group %s',  self.cnxuser, self.group)
 return
 def after_del_in_group(session, fromeid, rtype, toeid):
 """modify user permission, need to update users"""
 for session_ in get_user_sessions(session.repo, fromeid):
 DeleteGroupOp(session, cnxuser=session_.user, geid=toeid)
 self.warning('user %s already in group %s', self.cnxuser,
 self.group)
 return
 groups.add(self.group)
 def after_add_in_group(session, fromeid, rtype, toeid):
 """modify user permission, need to update users"""
 for session_ in get_user_sessions(session.repo, fromeid):
 AddGroupOp(session, cnxuser=session_.user, geid=toeid)
 try:
 self.repo.close(self.cnxid)
 except BadConnectionId:
 pass # already closed
 def after_del_user(session, eid):
 """modify user permission, need to update users"""
 for session_ in get_user_sessions(session.repo, eid):
 DelUserOp(session, session_.id)
 def _register_usergroup_hooks(hm):
 """register user/group related hooks on the hooks manager"""
 hm.register_hook(after_del_user, 'after_delete_entity', 'CWUser')
 hm.register_hook(after_add_in_group, 'after_add_relation', 'in_group')
 def set_initial_state_after_add(session, entity):
 SetInitialStateOp(session, entity=entity)
 def _register_wf_hooks(hm):
 """register workflow related hooks on the hooks manager"""
 if 'in_state' in hm.schema:
 hm.register_hook(before_add_in_state, 'before_add_relation', 'in_state')
 hm.register_hook(relation_deleted, 'before_delete_relation', 'in_state')
 try:
 del self.epropdict[self.key]
 except KeyError:
 self.error('%s has no associated value', self.key)
 class ChangeCWPropertyOp(Operation):
 """a user's custom properties has been added/changed"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 self.epropdict[self.key] = self.value
 class AddCWPropertyOp(Operation):
 """a user's custom properties has been added/changed"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 eprop = self.eprop
 if not eprop.for_user:
 self.repo.vreg.eprop_values[eprop.pkey] = eprop.value
 # if for_user is set, update is handled by a ChangeCWPropertyOp operation
 def after_add_eproperty(session, entity):
 key, value = entity.pkey, entity.value
 try:
 value = session.vreg.typed_value(key, value)
 except UnknownProperty:
 raise ValidationError(entity.eid, {'pkey': session._('unknown property key')})
 except ValueError, ex:
 raise ValidationError(entity.eid, {'value': session._(str(ex))})
 if not session.user.matching_groups('managers'):
-session.unsafe_execute('SET P for_user U WHERE P eid %(x)s,U eid %(u)s',
+session.add_relation(entity.eid, 'for_user', session.user.eid)
-{'x': entity.eid, 'u': session.user.eid}, 'x')
 else:
 AddCWPropertyOp(session, eprop=entity)
 def after_update_eproperty(session, entity):
 key, value = entity.pkey, entity.value
 try:
 value = session.vreg.typed_value(key, value)
 else:
 # site wide properties
 ChangeCWPropertyOp(session, epropdict=session.vreg.eprop_values,
 key=key, value=value)
 def before_del_eproperty(session, eid):
 for eidfrom, rtype, eidto in session.transaction_data.get('pendingrelations', ()):
 if rtype == 'for_user' and eidfrom == eid:
 # if for_user was set, delete has already been handled
 break
 else:
 key = session.execute('Any K WHERE P eid %(x)s, P pkey K',
 {'x': eid}, 'x')[0][0]
 DelCWPropertyOp(session, epropdict=session.vreg.eprop_values, key=key)
 def after_add_for_user(session, fromeid, rtype, toeid):
 if not session.describe(fromeid)[0] == 'CWProperty':
 return
 key, value = session.execute('Any K,V WHERE P eid %(x)s,P pkey K,P value V',
 {'for_user': session._("site-wide property can't be set for user")})
 for session_ in get_user_sessions(session.repo, toeid):
 ChangeCWPropertyOp(session, epropdict=session_.user.properties,
 key=key, value=value)
 def before_del_for_user(session, fromeid, rtype, toeid):
 key = session.execute('Any K WHERE P eid %(x)s, P pkey K',
 {'x': fromeid}, 'x')[0][0]
 relation_deleted(session, fromeid, rtype, toeid)
 for session_ in get_user_sessions(session.repo, toeid):
 DelCWPropertyOp(session, epropdict=session_.user.properties, key=key)
 def _register_eproperty_hooks(hm):
 """register workflow related hooks on the hooks manager"""
 hm.register_hook(after_add_eproperty, 'after_add_entity', 'CWProperty')
 hm.register_hook(after_update_eproperty, 'after_update_entity', 'CWProperty')

changeset 2603	e47d63351891
parent 2463	5200c0f7d2d5
child 2605	c4f6a53884ec