def connect(self, signal: ModelSignal, receiver: Callable = default_receiver, model_class: Optional[Type[models.Model]] = None) -> None: """ Connects signal with all related models to any existing active resource. """ model_classes = [model_class] if model_class else self.related_models() for model_class in model_classes: signal.connect(receiver, sender=model_class) logger.info( f'Signal {signal}: {model_class} -> {default_receiver}')
def after_save_instance_handler(sender, **kwargs: ModelSignal): if "created" in kwargs.keys(): created: bool = kwargs["created"] else: created: bool = False if isinstance(kwargs["instance"], Message): message: Message = kwargs["instance"] if message.instant_send: async_to_sync(get_channel_layer().group_send)( "chat_group", { "type": "chat_message", "message": message.to_json(created=created) }, ) if isinstance(kwargs["instance"], Node): node_update: Node = kwargs["instance"] async_to_sync(get_channel_layer().group_send)( "chat_group", { "type": "chat_message", "message": node_update.to_json(created=created) }, )
def disconnect( self, signal: ModelSignal, receiver: Callable = default_receiver, model_class: Optional[Type[models.Model]] = None ) -> Dict[Type[models.Model], bool]: """ Disconnects signal with all related models to any existing active resource. """ model_classes = [model_class] if model_class else self.related_models() return { model_class: signal.disconnect(receiver, sender=model_class) for model_class in model_classes }
from django.db.models.signals import ModelSignal expired = ModelSignal(providing_args=["instance"], use_caching=True)
from django.db.models.signals import ModelSignal pre_softdelete = ModelSignal(use_caching=True) post_softdelete = ModelSignal(use_caching=True) post_undelete = ModelSignal(use_caching=True)
# -*- coding: utf-8 -*- # author:CY # datetime:2020/7/14 20:18 from django.db.models.signals import ModelSignal pre_ud_save = ModelSignal(providing_args=["sender", "queryset", 'request'], use_caching=True) aft_ud_save = ModelSignal(providing_args=["sender", "queryset", 'request'], use_caching=True)
from django.db.models.signals import ModelSignal # Behaves like Djangos normal pre-/post_save signals signals with the # added arguments ``target`` and ``position`` that matches those of # ``move_to``. # If the signal is called from ``save`` it'll not be pass position. node_moved = ModelSignal(providing_args=[ 'instance', 'target', 'position' ])
from django.db.models.signals import ModelSignal data_refreshed = ModelSignal()
from django.db.models.signals import ModelSignal authenticated_pre_save = ModelSignal( providing_args=["instance", "raw", "using", "update_fields", "request"], use_caching=True) authenticated_post_save = ModelSignal(providing_args=[ "instance", "raw", "created", "using", "update_fields", "request" ], use_caching=True) authenticated_save = authenticated_post_save authenticated_pre_delete = ModelSignal( providing_args=["instance", "using", "request"], use_caching=True) authenticated_post_delete = ModelSignal( providing_args=["instance", "using", "request"], use_caching=True) authenticated_delete = authenticated_pre_delete
from django.db.models.signals import ModelSignal post_softdelete = ModelSignal(providing_args=["instance", "using"], use_caching=True) post_softcreate = ModelSignal(providing_args=["instance", "using"], use_caching=True)
from django.db.models.signals import ModelSignal pre_softdelete = ModelSignal() post_softdelete = ModelSignal()
from django.template.defaultfilters import default logger = logging.getLogger(__name__) def content_file_name(instance, filename): return 'upload/{0}/{1}/'.format(instance.author, filename) def profile_file_name(instance, filename): return 'upload/{0}/{1}/'.format(instance.username, filename) from django.db.models.signals import ModelSignal pre_bulk_update = ModelSignal(use_caching=True) post_bulk_update = ModelSignal(use_caching=True) class UpdateManager(models.QuerySet): """ updateの前後でSignalを定義。 """ def update(self, **kwargs): pre_bulk_update.send(sender=self.model, queryset=self, update_kwargs=kwargs) res = super(UpdateManager, self).update(**kwargs) post_bulk_update.send(sender=self.model, queryset=self, update_kwargs=kwargs)
from django.db.models.signals import ModelSignal pre_safe_delete = ModelSignal(providing_args=["instance", "using"], use_caching=True) post_safe_delete = ModelSignal(providing_args=["instance", "using"], use_caching=True)
# -*- coding: utf-8 -*- # ++ This file `signals.py` is generated at 2/15/17 7:52 PM ++ from django.db.models.signals import ModelSignal __author__ = 'Md Nazrul Islam<*****@*****.**>' queryset_update = ModelSignal(providing_args=["queryset", "update_kwargs"], use_caching=True)
from django.dispatch import receiver from notifications.signals import notify from django.db.models.signals import post_save from django.db.models.signals import ModelSignal from django.conf import settings social_request_accepted = ModelSignal(providing_args=['instance',]) social_request_rejected = ModelSignal(providing_args=['instance',]) @receiver(post_save, sender='marathon.SocialRequest') def generate_notification(sender, created, instance, **kwargs): if created: notify.send( instance.by.user, recipient=instance.to.user, verb='request', description=instance.tile, target=instance ) @receiver(social_request_rejected, sender='marathon.SocialRequest') @receiver(social_request_accepted, sender='marathon.SocialRequest') def mark_disabled(sender, instance, **kwargs): if instance.label in settings.MARK_DISABLED: same_type_requests = instance.__class__.objects.filter( label=instance.label, status=instance.__class__.PENDING, to=instance.to, data=instance.data, ).exclude(pk=instance.pk)
from mezzanine.core.models import CONTENT_STATUS_PUBLISHED from html2text import html2text from happystamp.util import generate_key from happystamp.util import generate_form from happystamp.util import generate_reward_form from happystamp.util import app_sticker_template from happystamp.util import redeem_card_template from happystamp.util import reward_card_template from happystamp.gcm import GCMMessage from happystamp.gcm import post_push new_customer = ModelSignal(providing_args=["instance"]) def upload_directory_path(instance, filename): return 'user_{0}/{1}'.format(instance.user.id, filename) ############################################################################### # Customer # ############################################################################### class mCustomer(User): class Meta: verbose_name = _("Customer") verbose_name_plural = _("My Customers") proxy = True
from django.db.models.signals import ModelSignal, post_save from django.dispatch import receiver from libs.core.cms.api.configs import CMSCoreConfig from webdjango.exceptions import BadRequest from webdjango.signals.CoreSignals import (config_group_register, config_register) from webdjango.utils.JsonLogic import jsonLogic from .models.Form import FormSubmitted from .models.Page import Page from .models.Menu import MenuItem from django.core.cache import cache pre_get_page = ModelSignal(providing_args=["request", "args", "kwargs"], use_caching=True) post_get_page = ModelSignal( providing_args=["instance", "request", "args", "kwargs"], use_caching=True) form_action_triggered = django.dispatch.Signal( providing_args=["instance", "formSubmitted"]) @receiver(config_register) def register_configs(*args, **kwargs): return CMSCoreConfig.INPUTS @receiver(config_group_register) def register_config_group(*args, **kwargs): return CMSCoreConfig.GROUP
from django.db.models.signals import ModelSignal tenant_prepared = ModelSignal(providing_args=["tenant"])
set_auth_groups_collection_permissions, set_auth_groups_page_permissions, PAGE_AUTH_GROUP_TYPES, MODERATORS_PAGE_PERMISSIONS, EDITORS_PAGE_PERMISSIONS, COMMON_COLLECTION_NAME, MODERATORS_COLLECTION_PERMISSIONS, EDITORS_COLLECTION_PERMISSIONS, get_auth_groups, set_auth_groups_wagtailadmin_access, ) from .models import LocalGroup, LocalGroupPage, HomeSubPage, HomePage # Custom Signals local_group_create = ModelSignal(providing_args=["instance"]) local_group_name_change = ModelSignal( providing_args=["instance", "old_name", "new_name"]) # LocalGroup @receiver( local_group_name_change, sender=LocalGroup, dispatch_uid="update_pages_auth_group_names_once", ) def update_pages_auth_group_names(sender, instance=None, created=False, **kwargs):
from django.db.models.signals import ModelSignal # Behaves like Djangos normal pre-/post_save signals signals with the # added arguments ``target`` and ``position`` that matches those of # ``move_to``. # If the signal is called from ``save`` it'll not be pass position. node_moved = ModelSignal()
from django.db.models.signals import ModelSignal from core.exceptions import ApplicationValidationError model_validation = ModelSignal( providing_args=["instance", "raw", "using", "update_fields"], use_caching=True ) class ModelValidationMixin: def clean(self): model_validation.send(sender=self.__class__, instance=self) def validate_fields_with_abilities(ability, data, **kwargs): for field, action in kwargs.items(): if field in data and not ability.can(action, data[field]): raise ApplicationValidationError( {field: [f"Cannot {action} {field} {data[field]}"]} )
from django.db.models.signals import ModelSignal # These signals are sent when model instances are created in bulk pre_bulk_create = ModelSignal(providing_args=['instances']) post_bulk_create = ModelSignal(providing_args=['instances']) # These signals are sent when a model is updated homogeneously (i.e.: queryset.update(field=value) pre_update = ModelSignal(providing_args=['instances']) post_update = ModelSignal(providing_args=['instances']) # These signals are sent when a model's fields are updated heterogeously (i.e.: queryset.update_fields(...)) pre_update_fields = ModelSignal(providing_args=[ 'instances', 'field_names', 'field_defaults', 'batch_size' ]) post_update_fields = ModelSignal(providing_args=[ 'instances', 'queryset', 'field_names', 'field_defaults', 'batch_size', 'n' ])