cubicweb: comparison server/hook.py

equal deleted inserted replaced

-:b8287e54b528
+:8bc6eac1fac1
 from logilab.common.decorators import classproperty
 from logilab.common.deprecation import deprecated
 from logilab.common.logging_ext import set_log_methods
 from cubicweb import RegistryNotFound
+from cubicweb.vregistry import classid
 from cubicweb.cwvreg import CWRegistry, VRegistry
 from cubicweb.selectors import (objectify_selector, lltrace, ExpectedValueSelector,
 is_instance)
 from cubicweb.appobject import AppObject
 from cubicweb.server.session import security_enabled
 class HooksRegistry(CWRegistry):
 def initialization_completed(self):
 for appobjects in self.values():
 for cls in appobjects:
 if not cls.enabled:
-warn('[3.6] %s: enabled is deprecated' % cls)
+warn('[3.6] %s: enabled is deprecated' % classid(cls))
 self.unregister(cls)
 def register(self, obj, **kwargs):
 obj.check_events()
 super(HooksRegistry, self).register(obj, **kwargs)
 for event in ALL_HOOKS:
 VRegistry.REGISTRY_FACTORY['%s_hooks' % event] = HooksRegistry
-_MARKER = object()
+@deprecated('[3.10] use entity.cw_edited.oldnewvalue(attr)')
 def entity_oldnewvalue(entity, attr):
-"""returns the couple (old attr value, new attr value)
+return entity.cw_edited.oldnewvalue(attr)
-NOTE: will only work in a before_update_entity hook
-"""
-# get new value and remove from local dict to force a db query to
-# fetch old value
-newvalue = entity.pop(attr, _MARKER)
-oldvalue = getattr(entity, attr)
-if newvalue is not _MARKER:
-entity[attr] = newvalue
-else:
-newvalue = oldvalue
-return oldvalue, newvalue
 # some hook specific selectors #################################################
 @objectify_selector
 cls.check_events()
 return ['%s_hooks' % ev for ev in cls.events]
 @classproperty
 def __regid__(cls):
-warn('[3.6] %s.%s: please specify an id for your hook'
+warn('[3.6] %s: please specify an id for your hook' % classid(cls),
-% (cls.__module__, cls.__name__), DeprecationWarning)
+DeprecationWarning)
 return str(id(cls))
 @classmethod
 def __registered__(cls, reg):
 super(Hook, cls).__registered__(reg)
 if getattr(cls, 'accepts', None):
-warn('[3.6] %s.%s: accepts is deprecated, define proper __select__'
+warn('[3.6] %s: accepts is deprecated, define proper __select__'
-% (cls.__module__, cls.__name__), DeprecationWarning)
+% classid(cls), DeprecationWarning)
 rtypes = []
 for ertype in cls.accepts:
 if ertype.islower():
 rtypes.append(ertype)
 else:
 super(Hook, self).__init__(req, **kwargs)
 self.event = event
 def __call__(self):
 if hasattr(self, 'call'):
-cls = self.__class__
+warn('[3.6] %s: call is deprecated, implement __call__'
-warn('[3.6] %s.%s: call is deprecated, implement __call__'
+% classid(self.__class__), DeprecationWarning)
-% (cls.__module__, cls.__name__), DeprecationWarning)
 if self.event.endswith('_relation'):
 self.call(self._cw, self.eidfrom, self.rtype, self.eidto)
 elif 'delete' in self.event:
 self.call(self._cw, self.entity.eid)
 elif self.event.startswith('server_'):
 return None
 return -(i + 1)
 def handle_event(self, event):
 """delegate event handling to the opertaion"""
+if event == 'postcommit_event' and hasattr(self, 'commit_event'):
+warn('[3.10] %s: commit_event method has been replaced by postcommit_event'
+% classid(self.__class__), DeprecationWarning)
+self.commit_event()
 getattr(self, event)()
 def precommit_event(self):
 """the observed connections pool is preparing a commit"""
 def revertprecommit_event(self):
 """an error went when pre-commiting this operation or a later one
 should revert pre-commit's changes but take care, they may have not
-been all considered if it's this operation which failed
-"""
-def commit_event(self):
-"""the observed connections pool is commiting"""
-def revertcommit_event(self):
-"""an error went when commiting this operation or a later one
-should revert commit's changes but take care, they may have not
 been all considered if it's this operation which failed
 """
 def rollback_event(self):
 """the observed connections pool has been rollbacked
 if i is None:
 return None
 return -(i + 1)
-class SingleOperation(Operation):
-"""special operation which should be called once"""
+class SingleLastOperation(Operation):
+"""special operation which should be called once and after all other
+operations
+"""
 def register(self, session):
 """override register to handle cases where this operation has already
 been added
 """
 operations = session.pending_operations
 for i, op in enumerate(reversed(operations)):
 if op.__class__ is self.__class__:
 return -(i+1)
 return None
-class SingleLastOperation(SingleOperation):
-"""special operation which should be called once and after all other
-operations
-"""
 def insert_index(self):
 return None
 class SendMailOp(SingleLastOperation):
 def register(self, session):
 previous = super(SendMailOp, self).register(session)
 if previous:
 self.to_send = previous.to_send + self.to_send
-def commit_event(self):
+def postcommit_event(self):
 self.session.repo.threaded_task(self.sendmails)
 def sendmails(self):
 self.session.vreg.config.sendmails(self.to_send)
 class CleanupDeletedEidsCacheOp(SingleLastOperation):
 """on commit of delete query, we have to remove from repository's
 type/source cache eids of entities deleted in that transaction.
 """
-def commit_event(self):
+def postcommit_event(self):
 """the observed connections pool has been rollbacked,
 remove inserted eid from repository type/source cache
 """
 try:
 self.session.repo.clear_caches(

changeset 6142	8bc6eac1fac1
parent 5877	0c7b7b76a84f
child 6147	95c604ec89bf