def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
receiver_name = '.'.join(
[receiver.__class__.__module__, receiver.__class__.__name__])
if receiver_name != self.allowed_receiver:
raise AccessForbidden(u"%s is not allowed to connect" %
receiver_name)
Signal.connect(self, receiver, sender, weak, dispatch_uid)
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
receiver_name = '.'.join(
[receiver.__class__.__module__, receiver.__class__.__name__]
)
if receiver_name != self.allowed_receiver:
logger.error(u"没有注册过signal receiver: %s" % receiver_name)
Signal.connect(self, receiver, sender, weak, dispatch_uid)
class Publisher(SignalLogger):
"""Base class for signaling Publisher.
The base __init__ function setups the signaling object that a Subscriber can connect to.
"""
def __init__(self):
"""Setups signaling object.
"""
super().__init__()
self._signal = Signal()
def subscribe(self, handle):
"""Subscribe a handle to this publisher.
"""
self._signal.connect(handle)
def unsubscribe(self, handle):
"""Unsubscribe a handle from this publisher.
"""
self._signal.disconnect(handle)
def emit(self, **kwargs):
"""Emits arguments to the subscribers.
"""
self._signal.send(sender=self, **kwargs)
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
receiver_name = '.'.join(
[receiver.__class__.__module__, receiver.__class__.__name__])
if receiver_name != self.allowed_receiver:
raise UnauthorizedSignalReceiver()
Signal.connect(self, receiver, sender, weak, dispatch_uid)
def suspended_signal( signal, receiver, sender=None, weak=True, dispatch_uid=None ):
result = Signal.disconnect( signal, receiver, sender=sender, dispatch_uid=dispatch_uid )
assert result, 'Signal was not disconnected; details: {}'.format(
(signal, receiver, sender, dispatch_uid))
try:
yield result
finally:
Signal.connect( signal, receiver, sender=sender, weak=weak, dispatch_uid=dispatch_uid )
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
receiver_name = '.'.join([receiver.__class__.__module__,
receiver.__class__.__name__ ])
if receiver_name != self.allowed_receiver:
raise UnauthorizedSignalReceiver()
Signal.connect(self, receiver, sender, weak, dispatch_uid)
def get_data_from_signal(signal: Signal) -> Dict[str, Any]:
data_holder = {}
def receiver(**kwargs):
data_holder.update(kwargs)
signal.connect(receiver)
yield data_holder
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
# 一般情况下中间件只会被初始化一次，在不明情况下，中间件会在用户请求后，再初始化一次
# 目前先姑且认定这种情况的初始化属于异常情况不进行信号绑定
if self.bind_times >= 1:
return
receiver_name = ".".join(
[receiver.__class__.__module__, receiver.__class__.__name__])
if receiver_name != self.allowed_receiver:
raise BaseException(u"%s is not allowed to connect" %
receiver_name)
Signal.connect(self, receiver, sender, weak, dispatch_uid)
self.bind_times += 1
def ready(self):
self.mqtt = MqttClient()
self.Message = self.get_model('Message')
self.TxInfo = self.get_model('TxInfo')
self.RxInfo = self.get_model('RxInfo')
self.Node = self.get_model('Node')
self.Gateway = self.get_model('Gateway')
self.User = self.get_model('User')
Signal.connect(self.mqtt.getSignal(),
receiver=self.on_message_recieved,
weak=False,
dispatch_uid="dd5e8bfe-ea9b-42a3-a595-4810d0987650")
self.init_nodes()
self.init_gateways()
def test_signal(self):
action = Signal(providing_args=[
'verb', 'target', 'description'
])
def action_handler(verb, target, **kwargs):
kwargs.pop('signal')
sender = kwargs.pop('sender')
print(sender, verb, target, kwargs)
action.connect(action_handler, dispatch_uid='qevent.test')
def action_event(verb, target, **kwargs):
kwargs.pop('signal')
print(verb, kwargs)
action.connect(action_event, dispatch_uid='qevent.test2')
action.send('Alice', verb='say', target='Bob', description='Hello')
def test_other_signals_always_enabled(self, signal: Signal) -> None:
self.other_message = None
def listener(signal: Signal, sender, message: str) -> None:
self.other_message = message
other_signal = Signal()
other_signal.connect(listener)
with disable_signals([signal]):
other_signal.send(sender=None, message="always_enabled")
assert len(self.messages) == 0
assert self.other_message == "always_enabled"
def init_gateways(self):
for uuid in [
'bf7bd09c-fe10-429b-b563-f841b683d235',
'f0836050-415f-43df-9ec5-3bde9718ab16',
'5e5b06c4-a3fb-44e2-b2e8-c577637cb632'
]:
if not self.Gateway.objects.filter(mac=uuid).exists():
self.Gateway(gps_lat=random.random() * 190 - 90,
gps_lon=random.random() * 360 - 180,
last_seen=timezone.now(),
mac=uuid,
user=random.choice(self.User.objects.all()),
serial=uuid[1:10] + "-" + uuid[-10:-1]).save()
Signal.connect(self.mqtt.getSignal(),
receiver=self.on_message_recieved,
weak=False,
dispatch_uid="dd5e8bfe-ea9b-42a3-a595-4810d0987650")
class Channel(object):
def __init__(self, name, providing_args):
self.name = name
self.signal = Signal(providing_args=providing_args)
def __str__(self):
return str(self.name)
def __unicode__(self):
return unicode(self.name)
def __repr__(self):
return '<Channel: {0}>'.format(self.name)
def publish(self, **kwargs):
"Publishes to the channel which notifies all connected handlers."
log.debug('Publish to {0}'.format(self))
self.signal.send(sender=self.name, **kwargs)
def subscribe(self, receiver):
"Subscribes an external handler to this channel."
log.debug('{0}.{1} subscribe to {2}'.format(receiver.__module__, receiver.__name__, self))
self.signal.connect(receiver)
class Channel(object):
def __init__(self, name, providing_args):
self.name = name
self.signal = Signal(providing_args=providing_args)
def __str__(self):
return str(self.name)
def __unicode__(self):
return unicode(self.name)
def __repr__(self):
return '<Channel: {0}>'.format(self.name)
def publish(self, **kwargs):
"Publishes to the channel which notifies all connected handlers."
log.debug('Publish to {0}'.format(self))
self.signal.send(sender=self.name, **kwargs)
def subscribe(self, receiver):
"Subscribes an external handler to this channel."
log.debug('{0}.{1} subscribe to {2}'.format(receiver.__module__,
receiver.__name__, self))
self.signal.connect(receiver)
def ready(self):
if settings.PDNS_ENABLE:
from . import signals
# Connect signals here instead of using the @receiver decorator to
# avoid accidental connection of signals when importing the signals
# module (e.g. in unit tests).
Signal.connect(post_commit, signals.create_domains)
Signal.connect(post_commit, signals.update_domains)
Signal.connect(post_commit, signals.delete_domains)
from tcms.apps.management.models import TestTag, TestTag
from tcms.apps.testcases.models import TestCase, TestCaseTag, TestCaseBug, \
TestCaseBugSystem as BugSystem
from tcms.apps.testcases.models import TestCaseCategory
from tcms.apps.testcases.models import TestCasePlan
from tcms.apps.testcases.models import TestCaseStatus
from tcms.apps.testcases.views import get_selected_testcases
from tcms.apps.testcases.views import plan_from_request_or_none
from tcms.apps.testplans.models import TestPlan, TestCasePlan
from tcms.apps.testruns import signals as run_watchers
from tcms.apps.testruns.models import TestRun, TestCaseRun, TestRunTag, TestCaseRunStatus
from tcms.core.helpers.comments import add_comment
from tcms.core.utils import get_string_combinations
post_update = Signal(providing_args=["instances", "kwargs"])
post_update.connect(run_watchers.post_update_handler)
def check_permission(request, ctype):
perm = '%s.change_%s' % tuple(ctype.split('.'))
if request.user.has_perm(perm):
return True
return False
def strip_parameters(request, skip_parameters):
parameters = {}
for dict_ in request.REQUEST.dicts:
for k, v in dict_.items():
if k not in skip_parameters and v:
parameters[str(k)] = v
for p in plugins:
if p.position != last:
p.position = last
p.save()
last += 1
signals.post_delete.connect(update_plugin_positions, sender=CMSPlugin, dispatch_uid="cms.plugin.update_position")
def update_title_paths(instance, **kwargs):
"""Update child pages paths in case when page was moved.
"""
for title in instance.title_set.all():
title.save()
page_moved.connect(update_title_paths, sender=Page, dispatch_uid="cms.title.update_path")
def update_title(title):
slug = u'%s' % title.slug
if title.page.is_home():
title.path = ''
elif not title.has_url_overwrite:
title.path = u'%s' % slug
parent_page_id = title.page.parent_id
if parent_page_id:
parent_title = Title.objects.get_title(parent_page_id,
language=title.language, language_fallback=True)
if parent_title:
from django.dispatch import Signal
from .purge import PurgeRequest
try:
from .tasks import PurgeRequestTask
except:
tasks_available = False
else:
tasks_available = True
purge_request = Signal()
def purge_request_handler(sender, **kwargs):
pr = PurgeRequest()
pr.add(sender.get_absolute_url())
result = pr.purge()
return result
purge_request.connect(purge_request_handler)
if tasks_available:
queue_purge_request = Signal()
def queue_purge_request_handler(sender, **kwargs):
result = PurgeRequestTask.delay(sender)
queue_purge_request.connect(queue_purge_request_handler)
from django.core import serializers
from django.dispatch import Signal
from tcms.apps.testplans.models import TestPlan, TestCasePlan
from tcms.apps.testcases.models import TestCase, TestCaseTag, TestCaseBugSystem as BugSystem
from tcms.apps.testruns.models import TestRun, TestCaseRun, TestRunTag, TestCaseRunStatus
from tcms.apps.management.models import TestTag, TestTag
from tcms.core.utils import get_string_combinations
from tcms.core.helpers.comments import add_comment
from tcms.apps.testcases.models import TestCaseCategory
from tcms.apps.management.models import Component, TestBuild, Version
from tcms.apps.testruns import signals as run_watchers
post_update = Signal(providing_args=["instances", "kwargs"])
post_update.connect(run_watchers.post_update_handler)
def check_permission(request, ctype):
perm = '%s.change_%s' % tuple(ctype.split('.'))
if request.user.has_perm(perm):
return True
return False
def strip_parameters(request, skip_parameters):
parameters = {}
for dict_ in request.REQUEST.dicts:
for k, v in dict_.items():
if k not in skip_parameters and v:
parameters[str(k)] = v
return parameters
def handle_error(func, default=None):
"""
A function decorator that will eat errors
"""
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception, exception:
on_error.send_robust(sender=None, exception=exception)
if callable(default):
return default()
return default
return wrapper
def send_failure_email(exception, **kwargs):
subject = "Error (%s)" % exception
subject = subject.replace("\n", "")
trace = "\n".join(traceback.format_exception(*sys.exc_info()))
try:
mail_admins(subject, trace, fail_silently=True)
except:
pass # TODO
on_error.connect(send_failure_email)
is_active = models.BooleanField(default=True,
db_index=True,
verbose_name='Выводить на экран?')
created_at = models.DateTimeField(auto_now_add=True,
db_index=True,
verbose_name='Опубликован')
class Meta:
verbose_name_plural = 'Комментарии'
verbose_name = 'Комментарий'
ordering = ['created_at']
user_registrated = Signal(providing_args=['instance'])
def user_registrated_dispatcher(sender, **kwargs):
send_activation_notification(kwargs['instance'])
user_registrated.connect(user_registrated_dispatcher)
def post_save_dispatcher(sender, **kwargs):
author = kwargs['instance'].bb.author
if kwargs['created'] and author.send_messages:
send_new_comment_notification(kwargs['instance'])
post_save.connect(post_save_dispatcher, sender=Comment)
import importlib
from django.dispatch import Signal
from hunger.utils import setting
invite_sent = Signal(providing_args=['invitation'])
def invitation_code_sent(sender, invitation, **kwargs):
"""Send invitation code to user.
Invitation could be InvitationCode or Invitation.
"""
if sender.__name__ == 'Invitation':
email = invitation.email
code = invitation.code.code
elif sender.__name__ == 'InvitationCode':
email = kwargs.pop('email', None)
code = invitation.code
bits = setting('HUNGER_EMAIL_INVITE_FUNCTION').rsplit('.', 1)
module_name, func_name = bits
module = importlib.import_module(module_name)
func = getattr(module, func_name)
func(email, code, **kwargs)
invite_sent.connect(invitation_code_sent)
"""
Mark an unpaid purchase as paid and send a purchase_paid signal
"""
if not self.paid:
self.paid = True
self.save( update_fields=['paid'] )
purchase_paid.send(sender=self, purchase=self)
# ~~~ Custom signals ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
purchase_paid = Signal(providing_args=["purchase"])
# ~~~ Signal handlers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def send_mail_on_paiement(sender, purchase, **kwargs):
send_confirmation_email(purchase)
purchase_paid.connect(send_mail_on_paiement)
# ~~~ Payment handling
class IPNHandler(object):
import logging
log = logging.getLogger("IPN handler")
def __init__(self, sender=None, **kwargs):
self.ERROR = None
self.ipn = sender
purchase = TicketPurchase.objects.get( invoice_id = self.ipn.invoice)
if self.ipn.test_ipn:
return
#assert not purchase.paid, "This ticket is already marked as paid..."
assert self.ipn.payment_status == "Completed", \
"Payment status is " + self.ipn.payment_status
return CouchUser.django_user_post_save_signal(sender, instance, created)
post_save.connect(django_user_post_save_signal, User)
commcare_user_post_save = Signal(providing_args=["couch_user"])
couch_user_post_save = Signal(providing_args=["couch_user"])
def update_user_in_es(sender, couch_user, **kwargs):
"""
Automatically sync the user to elastic directly on save or delete
"""
send_to_elasticsearch("users", couch_user.to_json(),
delete=couch_user.to_be_deleted())
couch_user_post_save.connect(update_user_in_es)
"""
This section automatically creates Couch users whenever a registration xform is received
Question: is it possible to receive registration data from the phone after Case 3?
If so, we need to check for a user created via Case 3 and link them to this account
automatically
"""
def create_user_from_commcare_registration(sender, xform, **kwargs):
"""
# this comes in as xml that looks like:
# <n0:registration xmlns:n0="openrosa.org/user-registration">
# <username>user</username>
post_check = Signal(providing_args=['measure', 'value'])
def generate_raw_data(sender, measure, value, *args, **kwargs):
"""
Generate raw data from Informer.
"""
interval = getattr(settings, 'DJANGO_INFORMER_PREVENT_SAVE_UNTIL', None)
if not interval:
return
reference = timezone.now()
limit = reference - timedelta(minutes=interval)
indicator = sender.__class__.__name__.replace('Informer', '')
measure = measure.replace('check_', '')
exists = Raw.objects.filter(
indicator=indicator, measure=measure, date__gt=limit).exists()
if exists:
return
Raw.objects.get_or_create(
indicator=indicator, measure=measure, value=value, date=reference)
post_check.connect(generate_raw_data, sender=None)
p.position = last
p.save()
last += 1
signals.post_delete.connect(update_plugin_positions, sender=CMSPlugin, dispatch_uid="cms.plugin.update_position")
def update_title_paths(instance, **kwargs):
"""Update child pages paths in case when page was moved.
"""
for title in instance.title_set.all():
title.save()
page_moved.connect(update_title_paths, sender=Page, dispatch_uid="cms.title.update_path")
def update_title(title):
slug = u'%s' % title.slug
if title.page.is_home():
title.path = ''
elif not title.has_url_overwrite:
title.path = u'%s' % slug
parent_page_id = title.page.parent_id
if parent_page_id:
parent_title = Title.objects.get_title(parent_page_id,
language=title.language, language_fallback=True)
if parent_title:
models.signals.post_save.connect(update_event_create_stream, sender=Event)
def remove_event_create_stream(sender, instance, **kwargs):
Stream.objects.get(slug="event-create").dequeue(content_object=instance)
models.signals.post_delete.connect(remove_event_create_stream, sender=Event)
rsvp_recieved = Signal(providing_args=["guest"])
def notification_on_rsvp(sender, guest, **kwargs):
if guest.rsvp_status and guest.notify_on_rsvp:
Stream.objects.get(slug="event-rsvp-notification").enqueue(content_object=guest, start=guest.updated)
rsvp_recieved.connect(notification_on_rsvp)
def notification_on_group_association_request(sender, instance, created, **kwargs):
if created:
Stream.objects.get(slug="event-group-association-request").enqueue(
content_object=instance, start=instance.created
)
models.signals.post_save.connect(notification_on_group_association_request, sender=GroupAssociationRequest)
and tracker.activity_exists():
type = 'activity_completed'
points = DefaultGamificationEvent.objects.get(
event='activity_completed').points
if tracker.get_activity_type() == "media":
description = "Media played: " + tracker.get_activity_title()
type = 'mediaplayed'
points = calculate_media_points(tracker)
else:
description = "Activity completed: " + tracker.get_activity_title()
tracker_process_points(tracker, type, description, points)
def badgeaward_callback(sender, **kwargs):
award = kwargs.get('instance')
if not apply_points(award.user):
return
p = Points()
p.points = award.badge.points
p.type = 'badgeawarded'
p.description = award.description
p.user = award.user
p.save()
models.signals.post_save.connect(tracker_callback, sender=Tracker)
course_downloaded.connect(course_downloaded_callback)
links_updated.send(sender=self)
super(FeaturedLink, self).save()
def calculate_slug(self):
slug = self.name.lower()
slug = slug.replace("'", "")
return re.sub(r"[^a-z0-9]+", "-", slug).strip("-")
def __unicode__(self):
return self.name
class Meta(object):
ordering = ("sequence", "name")
links_updated = Signal(providing_args=[])
from django.core.cache import cache
def trash_the_cache(sender, **kwargs):
cache.clear()
links_updated.connect(trash_the_cache)
# class FeaturedLinkPlugin (CMSPlugin):
# link = models.ForeignKey(FeaturedLink)
# import cms_plugins
from django.dispatch import Signal
from django.core.cache import cache
from django_wepay.settings import WEPAY_IPN_LIMIT
__all__ = ['ipn_received', 'user_deleted', 'checkout_state_changed',
'preapproval_state_changed', 'withdrawal_state_changed']
ipn_received = Signal(providing_args=['request', 'instance'])
user_deleted = Signal(providing_args=['user'])
checkout_state_changed = Signal(
providing_args=['checkout', 'previous_state', 'response'])
preapproval_state_changed = Signal(
providing_args=['preapproval', 'previous_state', 'response'])
withdrawal_state_changed = Signal(
providing_args=['withdrawal', 'previous_state', 'response'])
def throttle_ipn_protect(sender, **kwargs):
key = "django_wepay_ipn_count"
count = cache.get(key, 0)
if count >= WEPAY_IPN_LIMIT[0]:
raise Exception("IPN limit Exceded")
count+= 1
cache.set(key, count, timeout=WEPAY_IPN_LIMIT[1])
ipn_received.connect(throttle_ipn_protect)
msg = kwargs['message']
user = kwargs['user']
notification.send([user], "messages_deleted", {'message': msg})
def recovered_notification(sender, **kwargs):
msg = kwargs['message']
user = kwargs['user']
notification.send([user], "messages_recovered", {'message': msg})
def unread_notification(sender, **kwargs):
msg = kwargs['message']
user = kwargs['user']
notification.send([user], "messages_marked_unread", {'message': msg})
def purge_notification(sender, **kwargs):
msg = kwargs['message']
user = kwargs['user']
notification.send([user], "messages_purged", {'message': msg})
message_deleted.connect(deleted_notification, sender=delete)
message_sent.connect(sent_notification, sender=ComposeForm)
message_repled.connect(replied_notification, sender=ComposeForm)
mesage_recovered.connect(recovered_notification, sender=undelete)
message_marked_as_unread.connect(unread_notification, sender=unread)
message_purge.connect(purge_notification, sender=purge)
# fallback for email notification if django-notification could not be found
from private_messages.utils import new_message_email
from django.db.models import signals
from private_messages.models import Message
signals.post_save.connect(new_message_email, sender=Message)
elif data[k] is 'blank':
data[k] = ''
print('==> {}'.format({'topic': topic, 'args': [data]}))
r = requests.post("https://drc.blue-labs.org:7998/rest-bridge",
json={
'topic': topic,
'args': [data]
})
r.raise_for_status()
webhook_s = Signal(providing_args=['hook_model', 'hook_action', 'data'])
webhook_s.connect(notify_of_webhook)
@csrf_exempt
@fstamp
def webhook(request: requests.request) -> JsonResponse:
''' API callback mechanism. Generally, updates our local cache and pushes
messages to the REST bridge for WAMP publication
'''
for k, v in request.META.items():
print('whk {:>40}: {}'.format(k, v))
secret_token = 'e5bffb72d83c9b52cc1e5ade29cd331657830bef63101f4b74cf005256b847ae'
if len(request.body) == 0:
from django.apps import AppConfig
from django.dispatch import Signal
from .utilities import send_activation_email
class BlogConfig(AppConfig):
name = 'blog'
verbose_name = 'Блог'
user_registered = Signal(providing_args=['instance'])
def user_registered_dispatcher(sender, **kwargs):
send_activation_email(kwargs['instance'])
user_registered.connect(user_registered_dispatcher)
return profile
create_vikundi_object = Signal(providing_args=["auth_user", "group_name", "org"])
def create_vikundi_object_handler(sender, **kwargs):
logger.debug ('Creating vikundi %s' % kwargs)
auth_user = kwargs['auth_user']
group_name = kwargs['group_name']
org = kwargs['org']
slot = utility.auto_alloc_slot(get_or_create_user_profile(auth_user), auth_user.is_superuser)
user = auth_user.get_profile()
Vikundi.create(user, group_name, slot, org = org)
create_vikundi_object.connect(create_vikundi_object_handler)
#def user_left_group(sender, **kwargs):
# logger.debug("Deleting user group %s" % kwargs)
# action = Actions.objects.get(action_desc = 'left group')
# user_group = kwargs['instance']
# hist = UserGroupHistory(user = user_group.user, group = user_group.group, action = action)
# hist.save()
#post_delete.connect(user_left_group, sender=UserGroups)
def user_joined_group(sender, **kwargs):
if not kwargs['created']:
return
action = Actions.objects.get(action_desc = 'joined group')
elif KEY_VALUE not in validated_message:
raised_error = ERROR_TSL[KEY_TSL_NO_VALUE] % message
elif KEY_DATE not in validated_message:
raised_error = ERROR_TSL[KEY_TSL_NO_DATE] % message
elif KEY_DST_TIMEZONE not in validated_message:
raised_error = ERROR_TSL[KEY_TSL_NO_DST_TIMEZONE] % message
elif KEY_NON_DST_TIMEZONE not in validated_message:
raised_error = ERROR_TSL[KEY_TSL_NO_NON_DST_TIMEZONE] % message
except ValueError:
raised_error = ERROR_TSL[KEY_TSL_BAD_JSON] % message
return raised_error, validated_message
@receiver(SIGNAL_TIMESERIES)
def timeseries_receiver(sender, **kwargs): # pylint: disable=I0011,W0613
"""Receiver method for timeseries signal
"""
timeseries = ""
if KEY_TIMESERIES in kwargs:
timeseries = kwargs[KEY_TIMESERIES]
raised_error, validated_timeseries = validate_message(timeseries)
if raised_error:
FILE_STORAGE_SPACE.store_error(raised_error)
elif validated_timeseries[KEY_VARIABLE_ID] == KEY_ERROR:
FILE_STORAGE_SPACE.insert_error(validated_timeseries)
else:
FILE_STORAGE_SPACE.insert_series(validated_timeseries)
SIGNAL_TIMESERIES.connect(timeseries_receiver)
BadgeData.objects.exclude(slug__in=map(slugify, BADGES.keys())).delete()
award_badges_signal = Signal(
providing_args=['actor', 'event', 'context_object', 'timestamp'])
#actor - user who triggers the event
#event - string name of the event, e.g 'downvote'
#context_object - database object related to the event, e.g. question
@auto_now_timestamp
def award_badges(event=None,
actor=None,
context_object=None,
timestamp=None,
**kwargs):
"""function that is called when signal `award_badges_signal` is sent
"""
try:
consider_badges = EVENTS_TO_BADGES[event]
except KeyError:
raise NotImplementedError('event "%s" is not implemented' % event)
for badge in consider_badges:
badge_instance = badge()
if badge_instance.is_enabled():
badge_instance.consider_award(actor, context_object, timestamp)
award_badges_signal.connect(award_badges)
@receiver(pre_delete, sender=TaskItemResult)
def task_revoke_handler(sender, instance, **kwargs):
task_id = str(instance)
di = smodels.DataItem.objects.get_subclass(id=instance.task.item.id)
if isinstance(di, smodels.SEDataItem):
routing = 'search'
elif isinstance(di, smodels.ASDataItem):
routing = 'automation'
else:
return
result = celery_app.AsyncResult(task_id)
# it the task is not over yet, revoke and terminate it
if not result.ready():
celery_app.control.revoke(task_id, terminate=True)
# then send a message with expiration 0 to ensure the result is dropped from the backend
# NB: a method named 'forget' for the AsyncResult class exists but is not implemented yet for multiple backends
with Connection(settings.BROKER_URL) as conn:
with Publisher(connection=conn, exchange="scapl", exchange_type="topic", routing_key=settings.ROUTING_KEYS[routing]) as pub:
pub.send({
'task': 'generic',
'id': task_id,
'args': (None, ),
'expiration': 0,
})
wizard_load = Signal(providing_args=['task_id', 'cmd', 'conn', 'routing'])
wizard_load.connect(wizard_load_handler)
transaction_available = Signal()
transaction_dispute = Signal()
transaction_returned = Signal()
transaction_canceled = Signal()
transaction_unknown = Signal()
def dispatch_transaction(sender, **kwargs):
transaction = kwargs.pop('transaction')
code = transaction['code']
status = int(transaction['status'])
signals = {
codes.waiting: transaction_waiting,
codes.analysis: transaction_analysis,
codes.paid: transaction_paid,
codes.available: transaction_available,
codes.dispute: transaction_dispute,
codes.returned: transaction_returned,
codes.canceled: transaction_canceled
}
signals \
.get(status, transaction_unknown) \
.send(sender=None, transaction=transaction)
logger.info('Transaction with status "%s" and code "%s" dispatched'
% (status, code))
transaction_received.connect(dispatch_transaction)
model = Foo
class C(Activity):
class Meta:
model = Foo
class D(Activity):
def is_locked(self):
return not self.workflow.data.flag
class Meta:
model = Foo
signals = (foo_change,)
def on_foo_change(sender, **kwargs):
sender.workflow.unlock(D)
foo_change.connect(on_foo_change)
class E(Activity):
class Meta:
model = Foo
@guard(model=Foo)
def GUARD(workflow):
return workflow.data.flag
class V(Activity):
class Meta:
model = Foo
vary_on = FooReview
transaction_analysis = Signal()
transaction_paid = Signal()
transaction_available = Signal()
transaction_dispute = Signal()
transaction_returned = Signal()
transaction_canceled = Signal()
transaction_unknown = Signal()
def dispatch_transaction(sender, **kwargs):
transaction = kwargs.pop('transaction')
status = int(transaction['status'])
signals = {
codes.waiting: transaction_waiting,
codes.analysis: transaction_analysis,
codes.paid: transaction_paid,
codes.available: transaction_available,
codes.dispute: transaction_dispute,
codes.returned: transaction_returned,
codes.canceled: transaction_canceled
}
signals \
.get(status, transaction_unknown) \
.send(sender=None, transaction=transaction)
logger.info('Transaction with status "%s" dispatched' % (status,))
transaction_received.connect(dispatch_transaction)
p = Points()
p.points = settings.OPPIA_POINTS['COURSE_DOWNLOADED']
p.type = 'coursedownloaded'
p.description = "Course downloaded: " + course.get_title()
p.user = user
p.course = course
p.save()
return
def badgeaward_callback(sender, **kwargs):
award = kwargs.get('instance')
if not apply_points(award.user):
return
p = Points()
p.points = award.badge.points
p.type = 'badgeawarded'
p.description = award.description
p.user = award.user
p.save()
return
course_downloaded.connect(course_download_callback)
models.signals.post_save.connect(tracker_callback, sender=Tracker)
models.signals.post_save.connect(signup_callback, sender=User)
models.signals.post_save.connect(createquiz_callback, sender=Quiz)
models.signals.post_save.connect(quizattempt_callback, sender=QuizAttempt)
def log_resultexam_change_list_stud_event(sender, **kwargs):
logger = logging.getLogger(__name__)
result_exam = kwargs['instance']
if kwargs['action'] == 'post_add':
logger.info("List of students was modified \
in result_exam {}".format(result_exam.id))
# bellow will be custom signal
contact_admin_signal = Signal(providing_args=[])
def contact_admin_handler(sender, **kwargs):
logger = logging.getLogger('contact_admin_logger')
logger.info("My custom handler for contact admin form.")
contact_admin_signal.connect(contact_admin_handler)
# handler for requests
def counter_start_request(sender, **kwargs):
day_counter, created = DayCounterRequest.objects.get_or_create(date=date.today())
day_counter.counter += 1
day_counter.save()
logger = logging.getLogger('django.request')
logger.info("request #{}".format(day_counter.counter))
request_started.connect(counter_start_request)
@receiver(post_migrate)
def all_migrate_command(sender, **kwargs):
logger = logging.getLogger(__name__)
db_info = kwargs['using']
subject = 'Welcome to STARS'
message = render_to_string('emails/new_member_email.txt', context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [user.email])
# I don't know why project_member is returned here but it definitely isn't defined here
#return (member, project_member,)
return (member,)
# Create project member profiles and send each coordinator an email
def assign_coordinators_handler(sender, **kwargs):
members = kwargs.get('members', None)
project = kwargs.get('project', None)
for member in members:
project_member = ProjectMember(member=member, project=project, is_coordinator=True, role='Coordinator')
project_member.save()
context = {
'project_url': Site.objects.get_current().domain + reverse('cms:edit_project_url', kwargs={'pk': project.pk}),
'coordinator': project_member.member.user.get_full_name()
}
subject = 'Project created: %s' % project.title
message = render_to_string('emails/project_coordinator_email.txt', context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [project_member.member.user.email])
return members
create_profile.connect(create_profile_handler)
assign_coordinators.connect(assign_coordinators_handler)
from askbot.models.repute import BadgeData
BadgeData.objects.exclude(
slug__in = map(slugify, BADGES.keys())
).delete()
award_badges_signal = Signal(
providing_args=[
'actor', 'event', 'context_object', 'timestamp'
]
)
#actor - user who triggers the event
#event - string name of the event, e.g 'downvote'
#context_object - database object related to the event, e.g. question
@auto_now_timestamp
def award_badges(event=None, actor=None,
context_object=None, timestamp=None, **kwargs):
"""function that is called when signal `award_badges_signal` is sent
"""
try:
consider_badges = EVENTS_TO_BADGES[event]
except KeyError:
raise NotImplementedError('event "%s" is not implemented' % event)
for badge in consider_badges:
badge_instance = badge()
if badge_instance.is_enabled():
badge_instance.consider_award(actor, context_object, timestamp)
award_badges_signal.connect(award_badges)
dashboard_accessed = Signal(providing_args=["request", "data"])
def dashboard_accessed_callback(sender, **kwargs):
request = kwargs.get('request')
data = kwargs.get('data')
if request.path.startswith("/admin") or request.path.startswith("/api"):
return
data_to_store = {}
if data:
for d in data:
# don't save any sensitive info
if d not in ('csrfmiddlewaretoken', 'password', 'password_again',
'api_key'):
data_to_store[d] = data[d]
if request.user.is_authenticated:
dal = DashboardAccessLog()
dal.user = request.user
dal.url = request.path
dal.data = json.dumps(data_to_store)
dal.ip = request.META.get('REMOTE_ADDR', oppia.DEFAULT_IP_ADDRESS)
dal.agent = request.META.get('HTTP_USER_AGENT', 'unknown')
dal.save()
dashboard_accessed.connect(dashboard_accessed_callback)
if ak.comment_check(comment.content.encode('utf-8'), data=data, build_data=True):
comment.is_public = False
comment.save()
ak.submit_spam(comment.content.encode('utf-8'), data=data, build_data=True)
except AkismetError:
pass
def on_comment_was_posted(sender,comment,request,*args,**kwargs):
th = Thread(target=validate_comment,args=(sender,comment,request))
th.start()
def on_comment_was_submit(sender,comment,*args,**kwargs):
blog=Blog.get()
domain="http://%s"%(Site.objects.get_current().domain)
if comment.parent_id != '0':
old_c=comment.parent
emailtitle=u'您在 '+blog.title+u' 上的评论有了新的回复'
if old_c.mail_notify:
sendmail('email/reply_comment.txt',{'old':old_c,"comment":comment,
'blog':blog,'domain':domain},
emailtitle,old_c.email)
else:
comments_notify=OptionSet.get('comments_notify',1)
if int(comments_notify) == 1 and comment.is_public==True:
emailtitle=u'文章'+comment.object.title+u'有了新的评论'
sendmail('email/new_comment.txt',{'comment':comment,'domain':domain},emailtitle,blog.email)
comment_was_posted.connect(on_comment_was_posted)
comment_was_submit.connect(on_comment_was_submit)
#coding: utf-8
from django.dispatch import Signal
from django.core.mail import mail_admins, mail_managers
from onpay.conf import get_constant
refilled_balance = Signal(providing_args=["user", "sum"])
def update_balance(sender, **kw):
"Пример пополнения баланса"
kw['user'].footman_profile.money += kw['sum']
kw['user'].footman_profile.save()
def email_notification(sender, **kw):
mail_managers(
subject=u"Money from %s" % kw['user'].username,
message=u"Balance refilled for %s RUR" % kw['sum'],
)
if get_constant("enable_footman_update_balance"):
refilled_balance.connect(update_balance)
if get_constant("enable_email_notify"):
refilled_balance.connect(email_notification)
from django.conf import settings
from django.contrib.auth import login, get_backends
from django.dispatch import Signal
# A new user has registered.
user_registered = Signal(providing_args=["user", "request"])
# A user has activated his or her account.
user_activated = Signal(providing_args=["user", "request"])
def login_user(sender, user, request, **kwargs):
""" Automatically authenticate the user when activated """
backend = get_backends()[0] # Hack to bypass `authenticate()`.
user.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__)
login(request, user)
request.session['REGISTRATION_AUTO_LOGIN'] = True
request.session.modified = True
if getattr(settings, 'REGISTRATION_AUTO_LOGIN', False):
user_activated.connect(login_user)
# by me for student aand teacher profile
# user_registered.connect(create_profile)
import user_profile
from django.conf import settings
from django.dispatch import Signal
from django.core.exceptions import ImproperlyConfigured
from . import simple_source
any_attributes_call = Signal(providing_args=["user"])
listed_attributes_call = Signal(providing_args=["user", "definitions"])
listed_attributes_with_source_call = Signal(providing_args=["user", "definitions", "source", "auth_source"])
add_attributes = Signal(providing_args=["instance", "user", "attributes", "context"])
any_attributes_call.connect(user_profile.get_attributes)
listed_attributes_call.connect(user_profile.get_attributes)
listed_attributes_with_source_call.connect(user_profile.get_attributes)
any_attributes_call.connect(simple_source.get_attributes)
listed_attributes_call.connect(simple_source.get_attributes)
listed_attributes_with_source_call.connect(simple_source.get_attributes)
if getattr(settings, "A2_ATTRIBUTE_AGGREGATOR_LDAP_SOURCE", False):
try:
import ldap_sources
except ImportError:
raise ImproperlyConfigured(
"A2_ATTRIBUTE_AGGREGATOR_LDAP_SOURCE is activated but the pyhon ldap library is not available"
)
if ldap_sources:
#-*- coding: utf-8 -*- ''' Created on 2014年7月4日 @author: jin ''' from django.dispatch import Signal from apps.pay_app.alipay import update_order_charge_by_alipay # Sent when a payment is successfully processed. alipay_dpn_successful = Signal() alipay_dpn_flagged = Signal() alipay_dpn_successful.connect(update_order_charge_by_alipay)
except ImportError:
celery = None
if celery:
# We put this at this module level so a developer can gain
# access even if SORL_URL_PRECACHE != 'celery'
@celery.task(ignore_result=True)
def handle_precache_task(sender_model, instance_model, instance_pk,
model_config, **kwargs):
sender = get_model(*sender_model.split('.'))
instance = get_model(*instance_model.split('.'))\
.objects.get(pk=instance_pk)
handle_precache(sender, instance, model_config, **kwargs)
def delay_precache(sender, instance, model_config, **kwargs):
sender_model = "%s.%s" % (sender._meta.app_label,
sender._meta.object_name)
instance_model = "%s.%s" % (instance._meta.app_label,
instance._meta.object_name)
kwargs.pop('signal', None) # Signals can't be pickled
handle_precache_task.delay(sender_model, instance_model,
instance.pk, model_config, **kwargs)
# A developer may choose to use a method other than Django signals
# (e.g. non-Celery task queue) to handle the precache actions.
_precache = getattr(settings, 'SORL_URL_PRECACHE', True)
if celery and _precache == "celery":
precache_sorl.connect(delay_precache)
elif _precache:
precache_sorl.connect(handle_precache)
sender_content_type=ContentType.objects.get_for_model(sender),
sender_object_id=sender.id,
)
for option in ("target", "action"):
try:
obj = kwargs[option]
if obj is not None:
setattr(new_item, "{0}_content_type".format(option),
ContentType.objects.get_for_model(obj))
setattr(new_item, "{0}_object_id".format(option),
obj.id)
except:
pass
new_item.save()
else:
new_item = Activity(
verb=verb,
sender_content_type=ContentType.objects.get_for_model(sender),
sender_object_id=sender.id,
)
for option in ("target", "action"):
obj = kwargs.pop(option, None)
if obj is not None:
setattr(new_item, "{0}_content_type".format(option),
ContentType.objects.get_for_model(obj))
setattr(new_item, "{0}_object_id".format(option), obj.id)
new_item.save()
activity_item.connect(new_activity_item)
from django.dispatch import Signal
NONCE_FIELD_NAME = 'nonce'
auth_login = Signal(providing_args = ["user","successful"])
auth_logout = Signal(providing_args = ["user"])
def LogAuthLogin(sender, user, successful, **kwargs):
if successful:
msg = user.username + ' has logged in with success'
else:
msg = user + ' has tried to login without success'
info(msg)
def LogAuthLogout(sender, user, **kwargs):
msg = str(user)
msg += ' has logged out'
info(msg)
auth_login.connect(LogAuthLogin, dispatch_uid = "authentic2.idp")
auth_logout.connect(LogAuthLogout, dispatch_uid = "authentic2.idp")
# oppia/reports/signals.py
from django.dispatch import Signal
from oppia.reports.models import DashboardAccessLog
dashboard_accessed = Signal(providing_args=["request", "data"])
def dashboard_accessed_callback(sender, **kwargs):
request = kwargs.get('request')
data = kwargs.get('data')
dal = DashboardAccessLog()
dal.user = request.user
dal.url = request.build_absolute_uri()
dal.data = data
dal.ip = request.META.get('REMOTE_ADDR','0.0.0.0')
dal.agent = request.META.get('HTTP_USER_AGENT','unknown')
dal.save()
return
dashboard_accessed.connect(dashboard_accessed_callback)
def logging_abstract(instance, action, **kwargs):
data = {}
for i in instance.__dict__.keys():
if '_' == i[0]:
continue
data.update({i: instance.__dict__[i]})
response = json.dumps(data, cls=DatetimeJSONEncoder)
content_type = ContentType.objects.get_for_model(instance)
log = Log(content_type=content_type, data=response,
action=action, oid=instance.pk, user=settings.CURRENT_USER)
log.save()
def logging_postsave(instance, created, **kwargs):
logging_abstract(instance, created and 'create' or 'update', **kwargs)
def logging_postdelete(instance, **kwargs):
logging_abstract(instance, 'delete', **kwargs)
def logging_mysignals(sender, **kwargs):
log = Log(user=sender, model='global action',
data='', action=kwargs['action'])
log.save()
signal_log_action = Signal(providing_args=['action'])
signal_log_action.connect(logging_mysignals)
delete_hit_count = Signal(providing_args=['save_hitcount',])
def delete_hit_count_callback(sender, instance,
save_hitcount=False, **kwargs):
'''
Custom callback for the Hit.delete() method.
Hit.delete(): removes the hit from the associated HitCount object.
Hit.delete(save_hitcount=True): preserves the hit for the associated
HitCount object.
'''
if not save_hitcount:
instance.hitcount.hits = F('hits') - 1
instance.hitcount.save()
delete_hit_count.connect(delete_hit_count_callback)
# EXCEPTIONS #
class DuplicateContentObject(Exception):
'If content_object already exists for this model'
pass
# MANAGERS #
class HitManager(models.Manager):
def filter_active(self, *args, **kwargs):
'''
Return only the 'active' hits.
from threading import Event
transaction_in_progress = Event()
transaction_affected_feeds = defaultdict(set)
def transaction_bulk_start(signal, sender, **kwz):
transaction_in_progress.set()
def transaction_bulk_process(signal, sender, **kwz):
if not transaction_in_progress.is_set(): return
Feed.update_handler(transaction_affected_feeds)
transaction_affected_feeds.clear() # in case of several commits
def transaction_bulk_cancel(signal, sender, **kwz):
if transaction_in_progress.is_set(): return
transaction_affected_feeds.clear() # not to interfere with next commit
def transaction_bulk_finish(signal, sender, **kwz):
# Transaction should be already comitted/rolled-back at this point
transaction_in_progress.clear()
transaction_affected_feeds.clear()
transaction_start.connect(transaction_bulk_start, sender='bulk_update')
transaction_pre_commit.connect(transaction_bulk_process)
transaction_post_rollback.connect(transaction_bulk_cancel)
transaction_finish.connect(transaction_bulk_finish, sender='bulk_update')
