from collections import OrderedDict import requests import django from django.conf import settings from django.core import serializers from django.core.exceptions import ValidationError, ImproperlyConfigured from django.core.serializers.json import DjangoJSONEncoder from django.db import models from django.db.models.signals import post_save, post_delete from django.test.signals import setting_changed from django.dispatch import receiver try: # Django <= 1.6 backwards compatibility from django.utils import simplejson as json except ImportError: # Django >= 1.7 import json from rest_hooks.signals import hook_event, raw_hook_event, hook_sent_event from rest_hooks.utils import distill_model_event, get_hook_model, get_module, find_and_fire_hook if getattr(settings, 'HOOK_CUSTOM_MODEL', None) is None: settings.HOOK_CUSTOM_MODEL = 'rest_hooks.Hook' HOOK_EVENTS = getattr(settings, 'HOOK_EVENTS', None) if HOOK_EVENTS is None: raise Exception('You need to define settings.HOOK_EVENTS!') _HOOK_EVENT_ACTIONS_CONFIG = None def get_event_actions_config(): global _HOOK_EVENT_ACTIONS_CONFIG if _HOOK_EVENT_ACTIONS_CONFIG is None: _HOOK_EVENT_ACTIONS_CONFIG = {} for event_name, auto in HOOK_EVENTS.items(): if not auto: continue model_label, action = auto.rsplit('.', 1) action_parts = action.rsplit('+', 1) action = action_parts[0] ignore_user_override = False if len(action_parts) == 2: ignore_user_override = True model_config = _HOOK_EVENT_ACTIONS_CONFIG.setdefault(model_label, {}) if action in model_config: raise ImproperlyConfigured( "settings.HOOK_EVENTS have a dublicate {action} for model " "{model_label}".format(action=action, model_label=model_label) ) model_config[action] = (event_name, ignore_user_override,) return _HOOK_EVENT_ACTIONS_CONFIG if getattr(settings, 'HOOK_THREADING', True): from rest_hooks.client import Client client = Client() else: client = requests.Session() AUTH_USER_MODEL = getattr(settings, 'AUTH_USER_MODEL', 'auth.User') class AbstractHook(models.Model): """ Stores a representation of a Hook. """ created = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) user = models.ForeignKey(AUTH_USER_MODEL, related_name='%(class)ss', on_delete=models.CASCADE) event = models.CharField('Event', max_length=64, db_index=True) target = models.URLField('Target URL', max_length=255) class Meta: abstract = True def clean(self): """ Validation for events. """ if self.event not in HOOK_EVENTS.keys(): raise ValidationError( "Invalid hook event {evt}.".format(evt=self.event) ) def dict(self): return { 'id': self.id, 'event': self.event, 'target': self.target } def serialize_hook(self, instance): """ Serialize the object down to Python primitives. By default it uses Django's built in serializer. """ if getattr(instance, 'serialize_hook', None) and callable(instance.serialize_hook): return instance.serialize_hook(hook=self) if getattr(settings, 'HOOK_SERIALIZER', None): serializer = get_module(settings.HOOK_SERIALIZER) return serializer(instance, hook=self) # if no user defined serializers, fallback to the django builtin! data = serializers.serialize('python', [instance])[0] for k, v in data.items(): if isinstance(v, OrderedDict): data[k] = dict(v) if isinstance(data, OrderedDict): data = dict(data) return { 'hook': self.dict(), 'data': data, } def deliver_hook(self, instance, payload_override=None): """ Deliver the payload to the target URL. By default it serializes to JSON and POSTs. Args: instance: instance that triggered event. payload_override: JSON-serializable object or callable that will return such object. If callable is used it should accept 2 arguments: `hook` and `instance`. """ if payload_override is None: payload = self.serialize_hook(instance) else: payload = payload_override if callable(payload): payload = payload(self, instance) if getattr(settings, 'HOOK_DELIVERER', None): deliverer = get_module(settings.HOOK_DELIVERER) deliverer(self.target, payload, instance=instance, hook=self) else: client.post( url=self.target, data=json.dumps(payload, cls=DjangoJSONEncoder), headers={'Content-Type': 'application/json'} ) hook_sent_event.send_robust(sender=self.__class__, payload=payload, instance=instance, hook=self) return None def __unicode__(self): return u'{} => {}'.format(self.event, self.target) class Hook(AbstractHook): if django.VERSION >= (1, 7): class Meta(AbstractHook.Meta): swappable = 'HOOK_CUSTOM_MODEL' ############## ### EVENTS ### ############## def get_model_label(instance): if instance is None: return None opts = instance._meta.concrete_model._meta try: return opts.label except AttributeError: return '.'.join([opts.app_label, opts.object_name]) @receiver(post_save, dispatch_uid='instance-saved-hook') def model_saved(sender, instance, created, raw, using, **kwargs): """ Automatically triggers "created" and "updated" actions. """ model_label = get_model_label(instance) action = 'created' if created else 'updated' distill_model_event(instance, model_label, action) @receiver(post_delete, dispatch_uid='instance-deleted-hook') def model_deleted(sender, instance, using, **kwargs): """ Automatically triggers "deleted" actions. """ model_label = get_model_label(instance) distill_model_event(instance, model_label, 'deleted') @receiver(hook_event, dispatch_uid='instance-custom-hook') def custom_action(sender, action, instance, user=None, **kwargs): """ Manually trigger a custom action (or even a standard action). """ model_label = get_model_label(instance) distill_model_event(instance, model_label, action, user_override=user) @receiver(raw_hook_event, dispatch_uid='raw-custom-hook') def raw_custom_event( sender, event_name, payload, user, send_hook_meta=True, instance=None, trust_event_name=False, **kwargs ): """ Give a full payload """ model_label = get_model_label(instance) new_payload = payload if send_hook_meta: new_payload = lambda hook, instance: { 'hook': hook.dict(), 'data': payload } distill_model_event( instance, model_label, None, user_override=user, event_name=event_name, trust_event_name=trust_event_name, payload_override=new_payload, ) @receiver(setting_changed) def handle_hook_events_change(sender, setting, *args, **kwargs): global _HOOK_EVENT_ACTIONS_CONFIG global HOOK_EVENTS if setting == 'HOOK_EVENTS': _HOOK_EVENT_ACTIONS_CONFIG = None HOOK_EVENTS = settings.HOOK_EVENTS