cubicweb: comparison server/hooks.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 get_user_sessions, rproperty)
 from cubicweb.server.repository import FTIndexEntityOp
 def relation_deleted(session, eidfrom, rtype, eidto):
 session.add_query_data('pendingrelations', (eidfrom, rtype, eidto))
 # 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:
 entity['creation_date'] = datetime.now()
 if not 'modification_date' in entity:
 def setmtime_before_update_entity(session, entity):
 """update an entity -> set modification date"""
 if not 'modification_date' in entity:
 entity['modification_date'] = datetime.now()
 class SetCreatorOp(PreCommitOperation):
 def precommit_event(self):
 if self.eid in self.session.query_data('pendingeids', ()):
 # entity have been created and deleted in the same transaction
 return
 ueid = self.session.user.eid
 execute = self.session.unsafe_execute
 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"""
 entities is necessary.
 """
 if session.repo.schema.rschema(rtype).fulltext_container:
 FTIndexEntityOp(session, entity=session.entity(eidto))
 FTIndexEntityOp(session, entity=session.entity(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':
 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', '')
 hm.register_hook(setowner_after_add_entity, 'after_add_entity', '')
 hm.register_hook(fti_update_after_delete_relation, 'after_delete_relation', '')
 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
 """
 def precommit_event(self):
 session = self.session
 if not self.eid in session.query_data('pendingeids', ()):
 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)
 """check that we don't remove the owners group"""
 check_internal_entity(session, eid, ('owners',))
 # schema validation hooks #####################################################
 class CheckConstraintsOperation(LateOperation):
 """check a new relation satisfy its constraints
 """
 def precommit_event(self):
 eidfrom, rtype, eidto = self.rdef
 try:
 constraint.repo_check(self.session, eidfrom, rtype, eidto)
 except NotImplementedError:
 self.critical('can\'t check constraint %s, not supported',
 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.
 class CheckRequiredRelationOperation(LateOperation):
 """checking relation cardinality has to be done after commit in
 case the relation is being replaced
 """
 eid, rtype = None, None
 def precommit_event(self):
 # recheck pending eids
 if self.eid in self.session.query_data('pendingeids', ()):
 return
 if self.session.unsafe_execute(*self._rql()).rowcount < 1:
 etype = self.session.describe(self.eid)[0]
 msg = self.session._('at least one relation %(rtype)s is required on %(etype)s (%(eid)s)')
 raise ValidationError(self.eid, {self.rtype: msg % {'rtype': self.rtype,
 'etype': etype,
 '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'
 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():
 # skip automatically handled relations
 def _register_core_hooks(hm):
 hm.register_hook(handle_composite_before_del_relation, 'before_delete_relation', '')
 hm.register_hook(before_del_group, 'before_delete_entity', 'CWGroup')
 #hm.register_hook(cstrcheck_before_update_entity, 'before_update_entity', '')
 hm.register_hook(cardinalitycheck_after_add_entity, 'after_add_entity', '')
 hm.register_hook(cardinalitycheck_before_del_relation, 'before_delete_relation', '')
 hm.register_hook(cstrcheck_after_add_relation, 'after_add_relation', '')
 hm.register_hook(uniquecstrcheck_before_modification, 'before_add_entity', '')
 hm.register_hook(uniquecstrcheck_before_modification, 'before_update_entity', '')
 # user/groups synchronisation #################################################
 class GroupOperation(Operation):
 """base class for group operation"""
 geid = None
 def __init__(self, session, *args, **kwargs):
 """override to get the group name before actual groups manipulation:
 we may temporarily loose right access during a commit event, so
 no query should be emitted while comitting
 """
 rql = 'Any N WHERE G eid %(x)s, G name N'
 result = session.execute(rql, {'x': kwargs['geid']}, 'x', build_descr=False)
 try:
 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)
 class AddGroupOp(GroupOperation):
 """synchronize user when a in_group relation has been added"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 groups = self.cnxuser.groups
 class DelUserOp(Operation):
 """synchronize user when a in_group relation has been added"""
 def __init__(self, session, cnxid):
 self.cnxid = cnxid
 Operation.__init__(self, session)
 def commit_event(self):
 """the observed connections pool has been commited"""
 try:
 self.repo.close(self.cnxid)
 except BadConnectionId:
 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')
 hm.register_hook(after_del_in_group, 'after_delete_relation', 'in_group')
 {'x' : entity.eid, 's' : rset[0][0]}, 'x')
 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')
 # CWProperty hooks #############################################################
 class DelCWPropertyOp(Operation):
 """a user's custom properties has been deleted"""
 def commit_event(self):
 """the observed connections pool has been commited"""
 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 not session.user.matching_groups('managers'):
 session.unsafe_execute('SET P for_user U WHERE P eid %(x)s,U eid %(u)s',
 {'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)
 except UnknownProperty:
 key=key, value=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.query_data('pendingrelations', ()):
 if rtype == 'for_user' and eidfrom == eid:
 # if for_user was set, delete has already been handled
 break
 raise ValidationError(fromeid,
 {'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):

branch	tls-sprint
changeset 1802	d628defebc17
parent 1398	5fe84a5f7035
child 1977	606923dff11b