class SignalHookTest(SpyAgency, TestCase):
"""Unit tests for djblets.extensions.hooks.SignalHook."""
def setUp(self):
manager = ExtensionManager('')
self.test_extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.patterns = patterns('',
(r'^url_hook_test/', include('djblets.extensions.test.urls')))
self.signal = Signal()
self.spy_on(self._on_signal_fired)
def test_initialize(self):
"""Testing SignalHook initialization connects to signal"""
SignalHook(self.test_extension, self.signal, self._on_signal_fired)
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 1)
def test_shutdown(self):
"""Testing SignalHook.shutdown disconnects from signal"""
hook = SignalHook(self.test_extension, self.signal,
self._on_signal_fired)
hook.shutdown()
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 0)
def _on_signal_fired(self, *args, **kwargs):
pass
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 _project_create_update(request, project_slug=None, template_name="projects/project_form.html"):
"""
Handler for creating and updating a project.
This function helps to eliminate duplication of code between those two
actions, and also allows to apply different permission checks in the
respective views.
"""
if project_slug:
project = get_object_or_404(Project, slug=project_slug)
else:
project = None
if request.method == "POST":
project_form = ProjectForm(request.POST, instance=project, prefix="project")
if project_form.is_valid():
project = project_form.save(commit=False)
project_id = project.id
# Only here the owner is written to the project model
if not project_id:
project.owner = request.user
# provide the form data to any signal handlers before project_save
Signal.send(signals.pre_proj_save, sender=Project, instance=project, form=project_form)
project.save()
project_form.save_m2m()
# TODO: Not sure if here is the best place to put it
Signal.send(signals.post_proj_save_m2m, sender=Project, instance=project, form=project_form)
# ActionLog & Notification
context = {"project": project}
if not project_id:
nt = "project_added"
action_logging(request.user, [project], nt, context=context)
else:
nt = "project_changed"
action_logging(request.user, [project], nt, context=context)
if settings.ENABLE_NOTICES:
txnotification.send_observation_notices_for(project, signal=nt, extra_context=context)
return HttpResponseRedirect(reverse("project_detail", args=[project.slug]))
else:
# Make the current user the maintainer when adding a project
if project:
initial_data = {}
else:
initial_data = {"maintainers": [request.user.pk]}
project_form = ProjectForm(instance=project, prefix="project", initial=initial_data)
return render_to_response(
template_name, {"project_form": project_form, "project": project}, context_instance=RequestContext(request)
)
def setUp(self):
manager = ExtensionManager('')
self.test_extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.signal = Signal()
self.spy_on(self._on_signal_fired)
def test_mock_receiver(self):
signal = Signal()
with mock_signal_receiver(signal) as receiver:
signal.send(sender=None)
self.assertEqual(receiver.call_count, 1)
sentinel = {}
def side_effect(*args, **kwargs):
return sentinel
with mock_signal_receiver(signal, wraps=side_effect) as receiver:
responses = signal.send(sender=None)
self.assertEqual(receiver.call_count, 1)
# Signals respond with a list of tuple pairs [(receiver, response), ...]
self.assertIs(responses[0][1], sentinel)
def async_send(self, sender, **named):
# Bail early if no one is listening.
if not self.receivers:
return []
# Django depends on class_prepared being synchronous.
if self is models.signals.class_prepared:
return Signal.sync_send(self, sender, **named)
_signal_queue.put_nowait((self, sender, named))
return []
def listener():
while 1:
# Make sure this thread can't die.
try:
try:
self, sender, kw = _signal_queue.get()
except ValueError:
log.error('Error unpacking queue item.', exc_info=True)
if self is _sentinel:
break
try:
Signal.sync_send(self, sender, **kw)
except Exception:
log.error('Error calling signal.', exc_info=True)
except Exception:
# Weird things happen during interpreter shutdown.
if log:
log.critical('Uncaught error.', exc_info=True)
def setUp(self):
manager = ExtensionManager('')
self.test_extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.patterns = patterns('',
(r'^url_hook_test/', include('djblets.extensions.test.urls')))
self.signal = Signal()
self.spy_on(self._on_signal_fired)
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 test_custom_signal(self):
class PollPublisher(BasePublisher):
pass
class PollModelObserver(ModelObserver):
publisher = PollPublisher()
class Meta:
model = Poll
def my_signal_receiver(self, sender, **kwargs):
self.do_something(sender, my_arg=kwargs['my_arg'])
def do_something(self, sender, **kwargs):
pass
my_signal = Signal(providing_args=['my_arg'])
custom_signals = {
'my_signal': my_signal
}
self.observer = PollModelObserver(custom_signals=custom_signals)
self.publisher = self.observer.publisher
self.observer.do_something = method_logger(self.observer.do_something)
self.assertFalse(self.observer.do_something.was_called)
my_signal.send_robust(sender=Poll, my_arg='Test argument')
self.assertTrue(self.observer.do_something.was_called)
self.assertEqual(self.observer.do_something.context['args'], (Poll, ))
self.assertEqual(
self.observer.do_something.context['kwargs'], {'my_arg': 'Test argument'}
)
del self.observer
del self.publisher
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')
from django.db.models.signals import post_delete
from django.dispatch import Signal, receiver
from django_tenants.utils import get_tenant_model, schema_exists
post_schema_sync = Signal(providing_args=['tenant'])
post_schema_sync.__doc__ = """
Sent after a tenant has been saved, its schema created and synced
"""
schema_needs_to_be_sync = Signal(providing_args=['tenant'])
schema_needs_to_be_sync.__doc__ = """
Schema needs to be synced
"""
@receiver(post_delete)
def tenant_delete_callback(sender, instance, **kwargs):
if not isinstance(instance, get_tenant_model()):
return
if instance.auto_drop_schema and schema_exists(instance.schema_name):
instance._drop_schema(True)
from django.dispatch import Signal
new_payment_query = Signal(providing_args=['order', 'payment'])
new_payment_query.__doc__ = """
Sent to ask for filling Payment object with additional data:
payment.amount: total amount of an order
payment.currency: amount currency
This data cannot be filled by ``getpaid`` because it is Order structure
agnostic. After filling values just do return.
"""
user_data_query = Signal(providing_args=['order', 'user_data'])
new_payment_query.__doc__ = """
Sent to ask for filling user additional data:
user_data['email']: user email
user_data['lang']: lang code in ISO 2-char format
This data cannot be filled by ``getpaid`` because it is Order structure
agnostic. After filling values just do return.
"""
new_payment = Signal(providing_args=['order', 'payment'])
new_payment.__doc__ = """Sent after creating new payment."""
payment_status_changed = Signal(providing_args=['old_status', 'new_status'])
payment_status_changed.__doc__ = """Sent when Payment status changes."""
redirecting_to_payment_gateway_signal = Signal(providing_args=['request', 'order', 'payment', 'backend'])
to the right language.
HT: http://mirobetm.blogspot.com/2012/02/django-language-set-in-database-field.html
"""
user = kwargs['user']
couch_user = CouchUser.from_django_user(user)
if couch_user and couch_user.language:
kwargs['request'].session['django_language'] = couch_user.language
# Signal that syncs django_user => couch_user
def django_user_post_save_signal(sender, instance, created, **kwargs):
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
def __init__(self):
Signal.__init__(self, providing_args=["dispatcher","data"])
def __init__(self):
Signal.__init__(self, providing_args=['event'])
""" Internal signals """ from django.dispatch import Signal # providing_args = ["instance"] pre_anonymise = Signal() post_anonymise = Signal()
from django.dispatch import Signal
class_prepared = Signal(providing_args=["class"])
pre_init = Signal(providing_args=["instance", "args", "kwargs"],
use_caching=True)
post_init = Signal(providing_args=["instance"], use_caching=True)
pre_save = Signal(providing_args=["instance", "raw", "using", "update_fields"],
use_caching=True)
post_save = Signal(
providing_args=["instance", "raw", "created", "using", "update_fields"],
use_caching=True)
pre_delete = Signal(providing_args=["instance", "using"], use_caching=True)
post_delete = Signal(providing_args=["instance", "using"], use_caching=True)
pre_syncdb = Signal(
providing_args=["app", "create_models", "verbosity", "interactive", "db"])
post_syncdb = Signal(providing_args=[
"class", "app", "created_models", "verbosity", "interactive", "db"
])
m2m_changed = Signal(providing_args=[
"action", "instance", "reverse", "model", "pk_set", "using"
],
use_caching=True)
from django.conf import settings
from django.contrib.sites.shortcuts import get_current_site
from django.core import signing
from django.dispatch import Signal
from django.template.loader import render_to_string
from .views import RegistrationView as BaseRegistrationView
REGISTRATION_SALT = getattr(settings, 'REGISTRATION_SALT', 'registration')
user_registered = Signal(providing_args=["user", "request"])
class RegistrationView(BaseRegistrationView):
email_body_template = 'registration/activation_email.txt'
email_subject_template = 'registration/activation_email_subject.txt'
def register(self, form):
new_user = self.create_inactive_user(form)
user_registered.send(sender=self.__class__,
user=new_user,
request=self.request)
return new_user
def get_success_url(self, user):
return ('registration_complete', (), {})
def create_inactive_user(self, form):
new_user = form.save(commit=False)
new_user.is_active = False
new_user.save()
self.send_activation_email(new_user)
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.dispatch import Signal
from .utilities import send_activation_notification
# Create your models here.
class AdvUser(AbstractUser):
is_activated = models.BooleanField(default=True,
db_index=True,
verbose_name='Прошел активацию?')
send_messages = models.BooleanField(
default=True, verbose_name='Слать оповещения о новых комментариях?')
class Meta(AbstractUser.Meta):
pass
user_registrated = Signal(providing_args=['instance'])
def user_registrated_dispatcher(sender, **kwargs):
send_activation_notification(kwargs['instance'])
user_registrated.connect(user_registrated_dispatcher)
from django.dispatch import receiver, Signal
from . import notifications
post_create = Signal(providing_args=['instance'])
@receiver(post_create)
def content_created(sender, instance, **kwargs):
notifications.ContentCreated.send_all(instance)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.apps import apps
from django.db import models, connection
from django.db.models.signals import pre_save, post_delete
from django.dispatch import Signal
import logging
logger = logging.getLogger(__name__)
cleanup_pre_delete = Signal(providing_args=["file"])
cleanup_post_delete = Signal(providing_args=["file"])
def _find_models_with_filefield():
result = []
for model in apps.get_models():
for field in model._meta.fields:
if isinstance(field, models.FileField):
result.append(model)
break
return result
def _delete_file(file_obj):
def delete_from_storage():
user = models.ForeignKey(User, null=True)
# username field is useful to store guest name of unauthenticated users
username = models.CharField(max_length=20)
date = models.DateTimeField()
room = models.ForeignKey(Room)
content = models.CharField(max_length=5000)
########NEW FILE########
__FILENAME__ = signals
from utils.handlers import MessageHandlerFactory
from django.dispatch import Signal
chat_message_received = Signal(providing_args=[
"room_id",
"username",
"message",
"date",
])
handler = MessageHandlerFactory()
chat_message_received.connect(handler.handle_received_message)
########NEW FILE########
__FILENAME__ = tests
import json
import urlparse
from django.contrib.auth.models import User
from django.test import TestCase
from django.test.client import Client
import json
import re
import time
from datetime import datetime, timedelta
from django.conf import settings, ImproperlyConfigured
from django.dispatch import Signal
from django.utils import timezone
import pytz
import requests
from sms.models import SMS
sms_reply_received = Signal(providing_args=['instance', 'text', 'timestamp'])
class SMSApi(object):
'''
Base class for integrating with 3rd-party SMS service.
'''
def __init__(self, endpoint_url):
self.endpoint_url = endpoint_url
@classmethod
def get_message_id(cls, batch_code):
return '%s-%s' % (cls.MESSAGE_ID_PREFIX, batch_code)
def send(self, numbers, message):
'''
Returns [(apimsgid, address), ...] for each number provided.
from django.dispatch import Signal friendship_request_created = Signal() friendship_request_rejected = Signal() friendship_request_accepted = Signal(providing_args=['from_user', 'to_user']) friendship_removed = Signal(providing_args=['from_user', 'to_user'])
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)
from django.core.mail import EmailMessage
from django.dispatch import Signal, receiver
from django.template.loader import render_to_string
from django.urls import reverse
from oioioi.questions.models import MessageNotifierConfig
new_question_signal = Signal(providing_args=['request', 'instance'])
@receiver(new_question_signal)
def notify_about_new_question(sender, request, instance, **kwargs):
conf = MessageNotifierConfig.objects.filter(contest=instance.contest)
users_to_notify = [x.user for x in conf]
for u in users_to_notify:
send_email_about_new_question(u, request, instance)
def send_email_about_new_question(recipient, request, msg_obj):
context = {
'recipient':
recipient,
'msg':
msg_obj,
'msg_link':
request.build_absolute_uri(
reverse(
'message',
kwargs={
'contest_id': request.contest.id,
'message_id': msg_obj.id
### signals. Also see the DMP documentation on these
### specific signals.
# Triggered just before DMP calls a view's process_request() method.
# If the method returns an HttpResponse object, processing stops and the object is returned to the browser.
#
# request :: The request object, which has several attributes that might be of interest:
# request.dmp.app :: The app name, based on the current url.
# request.dmp.page :: The page name (the views/.py file or templates/.html file), based on the current url.
# request.dmp.urlparams :: Any extra url parameters, based on the current url.
# request.dmp.module :: The module where the view function is located.
# request.dmp.function :: The specific view function within the module to call.
# view_args :: The list of positional arguments to be sent to the view function.
# view_kwargs :: The dictionary of keyword arguments to be sent to the view function.
#
dmp_signal_pre_process_request = Signal(
providing_args=['request', 'view_args', 'view_kwargs'])
# Triggered just after a view's process_request() method returns.
# If the method returns an HttpResponse object, the normal response is replaced with that object.
#
# request :: The request object
# response :: The return from the process_request method, normally an HttpResponse object.
# view_args :: The list of positional arguments that was to the view.
# view_kwargs :: The dictionary of keyword arguments that was sent to the view function.
#
dmp_signal_post_process_request = Signal(
providing_args=['request', 'response', 'view_args', 'view_kwargs'])
# Triggered just before DMP renders a Mako template
# If the method returns a different Template object than the one passed into it, the returned on is used.
# In other words, this signal lets you override any template just before DMP renders it.
import logging
from .models import CharacterOwnership, UserProfile, get_guest_state, State, OwnershipRecord
from django.contrib.auth.models import User
from django.db.models import Q
from django.db.models.signals import pre_save, post_save, pre_delete, post_delete, m2m_changed
from django.dispatch import receiver, Signal
from esi.models import Token
from allianceauth.eveonline.models import EveCharacter
logger = logging.getLogger(__name__)
state_changed = Signal(providing_args=['user', 'state'])
def trigger_state_check(state):
# evaluate all current members to ensure they still have access
for profile in state.userprofile_set.all():
profile.assign_state()
# we may now be available to others with lower states
check_states = State.objects.filter(priority__lt=state.priority)
for profile in UserProfile.objects.filter(state__in=check_states):
if state.available_to_user(profile.user):
profile.state = state
profile.save(update_fields=['state'])
state_changed.send(sender=state.__class__,
user=profile.user,
state=state)
from django.dispatch import Signal
vendor_open = Signal(providing_args=["instance", "created"])
vendor_closed = Signal(providing_args=[
"instance",
])
def __init__(self, providing_args=None):
Signal.__init__(self, providing_args)
self.bind_times = 0
def __init__(self):
Signal.__init__(self, providing_args=['uri','request', 'content'])
from django.dispatch import Signal post_rating = Signal(providing_args=['instance', 'value', 'is_negative'])
def __init__(self):
Signal.__init__(self, providing_args=["wsname","pargs","data", "query"])
from django.dispatch import Signal # providing_args=['instance', 'username'] email_sent = Signal()
from django.conf import settings
from django.dispatch import Signal
message_deleted = Signal(providing_args=["message", "user"])
message_sent = Signal(providing_args=["message", "user"])
message_repled = Signal(providing_args=["message", "user"])
mesage_recovered = Signal(providing_args=["message", "user"])
message_marked_as_unread = Signal(providing_args=["message", "user"])
message_purge = Signal(providing_args=["message", "user"])
try:
#If it's during installation, we should configure the settings otherwise it fails
settings.configure()
except RuntimeError:
# Already configured (installation is complete)
pass
if "notification" in settings.INSTALLED_APPS and getattr(settings, 'PRIVATE_MESSAGES_NOTIFY', True):
from notification import models as notification
from private_messages.forms import ComposeForm
from private_messages.views import delete, undelete, unread, purge
def sent_notification(sender, **kwargs):
msg = kwargs['message']
notification.send([msg.sender], "messages_sent", {'message': msg})
notification.send([msg.recipient], "messages_received", {'message': msg})
def replied_notification(sender, **kwargs):
msg = kwargs['message']
notification.send([msg.sender], "messages_replied", {'message': msg})
notification.send([msg.recipient], "messages_reply_received", {'message': msg})
# 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)
import logging
logger = logging.getLogger('djpg')
from django.dispatch import Signal
from .codes import codes
notification_received = Signal(providing_args=['notification'])
transaction_received = Signal(providing_args=['transaction'])
transaction_waiting = Signal()
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
from django.dispatch import Signal limit_update_succeeded = Signal(providing_args=['order_item']) limit_update_failed = Signal(providing_args=['order_item', 'error_message']) resource_creation_succeeded = Signal(providing_args=['instance']) resource_update_succeeded = Signal(providing_args=['instance']) resource_deletion_succeeded = Signal(providing_args=['instance'])
"""
#todo: maybe better to redo individual badges
#so that get_stored_data() is called implicitly
#from the __init__ function?
for key in BADGES.keys():
get_badge(key).get_stored_data()
#remove any badges from the database
#that are no longer in the BADGES dictionary
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)
from django.core.cache import cache
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
#!/usr/bin/env python
# *_* encoding=utf-8 *_*
from django.dispatch import Signal
from django.contrib.sites.models import Site
from threading import Thread
from blog.akismet import Akismet
from blog.akismet import AkismetError
from blog.models import Blog,OptionSet
from utils.utils import sendmail
comment_was_submit=Signal(providing_args=['comment'])
comment_was_posted = Signal(providing_args=["comment", "request"])
def validate_comment(sender, comment, request, *args, **kwargs):
akismet_enable=OptionSet.get('akismet_enable', 0)
domain="http://%s"%(Site.objects.get_current().domain)
if int(akismet_enable) == 0:
return
akismet_key=OptionSet.get('akismet_key', '')
ak = Akismet(
#key = 'cda0f27f8e2f',
key=akismet_key,
blog_url=domain
)
try:
if ak.verify_key():
data = {
def __init__(self,providing_args = None):
return Signal.__init__(self,providing_args)
else:
stream.upqueue(content_object=instance,
start=instance.created,
end=instance.start_datetime())
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(
""" Signals for articles app """ from django.dispatch import Signal tag_click = Signal(providing_args=["tag", "profile"])
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)
'page': page,
'results_var': results_var,
'counter': counter,
'query': query,
'title': _(u'Media Library'),
'settings_var': get_settings_var(),
'breadcrumbs': get_breadcrumbs(query, path),
'breadcrumbs_title': ""
},
context_instance=Context(request))
browse = staff_member_required(never_cache(browse))
# mkdir signals
filebrowser_pre_createdir = Signal(providing_args=["path", "dirname"])
filebrowser_post_createdir = Signal(providing_args=["path", "dirname"])
def mkdir(request):
"""
Make Directory.
"""
from filebrowser_safe.forms import MakeDirForm
# QUERY / PATH CHECK
query = request.GET
path = get_path(query.get('dir', ''))
if path is None:
msg = _('The requested Folder does not exist.')
from django.dispatch import Signal
import traceback
import sys
from django.core.mail import mail_admins
# our signal
on_error = Signal(providing_args=["exception"])
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()))
from django.dispatch import Signal user_log_in_denied = Signal(providing_args=['user', 'request']) user_impersonated = Signal(providing_args=['user', 'request']) staff_logged_in = Signal(providing_args=['user', 'request']) staff_logged_out = Signal(providing_args=['user', 'request']) staff_log_in_failed = Signal(providing_args=['user', 'username', 'request']) staff_log_in_non_existent = Signal(providing_args=['username', 'request']) staff_log_in_inactive = Signal(providing_args=['user', 'request']) staff_altered_user_data = Signal(providing_args=['user', 'request']) staff_altered_user_password = Signal(providing_args=['user', 'request']) staff_forgot_password = Signal(providing_args=['user', 'request']) staff_confirmed_password = Signal(providing_args=['user', 'request']) staff_delete_client = Signal(providing_args=['user', 'username', 'request']) staff_delete_user = Signal(providing_args=['user', 'username', 'request'])
from cms.utils.conf import get_cms_setting
from django.conf import settings
from django.core.exceptions import ObjectDoesNotExist
from django.db.models import signals
from django.dispatch import Signal
from cms.cache.permissions import (
clear_user_permission_cache, clear_permission_cache)
from cms.models import (Page, Title, CMSPlugin, PagePermission,
GlobalPagePermission, PageUser, PageUserGroup)
from menus.menu_pool import menu_pool
from cms.models.permissionmodels import PageUserGroup
# fired after page location is changed - is moved from one node to other
page_moved = Signal(providing_args=["instance"])
# fired when some of nodes (Title) with applications gets saved
application_post_changed = Signal(providing_args=["instance"])
# fired after page gets published - copied to public model - there may be more
# than one instances published before this signal gets called
post_publish = Signal(providing_args=["instance"])
def update_plugin_positions(**kwargs):
plugin = kwargs['instance']
plugins = CMSPlugin.objects.filter(language=plugin.language, placeholder=plugin.placeholder).order_by("position")
last = 0
for p in plugins:
if p.position != last:
p.position = last
# use different name to avoid module clash
from geonode.utils import json_serializer_producer
from geonode.decorators import on_ogc_backend
from geonode.geoserver.helpers import (gs_catalog, ogc_server_settings,
is_monochromatic_image)
from geonode.geoserver.tasks import geoserver_create_thumbnail
from geonode.layers.models import Layer
from geonode.services.enumerations import CASCADED
from . import BACKEND_PACKAGE
from .tasks import geoserver_cascading_delete, geoserver_post_save_layers
logger = logging.getLogger("geonode.geoserver.signals")
geoserver_post_save_complete = Signal(providing_args=['instance'])
def geoserver_delete(typename):
# cascading_delete should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
geoserver_cascading_delete.apply_async((typename, ))
@on_ogc_backend(BACKEND_PACKAGE)
def geoserver_pre_delete(instance, sender, **kwargs):
"""Removes the layer from GeoServer
"""
# cascading_delete should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
import datetime
from django.db import models
from django.conf import settings
from django.db.models import F
from django.contrib.contenttypes.models import ContentType
from django.contrib.auth.models import User
from django.contrib.contenttypes import generic
from django.dispatch import Signal
# SIGNALS #
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)
from django.dispatch import Signal
post_user_create = Signal(providing_args=('user',))
post_user_change_password = Signal(providing_args=('user',))
