def ready(self):
from users.signals import add_to_user_group
from allauth.socialaccount.signals import social_account_added
from django.db.models.signals import post_save
from django.contrib.auth.models import User
post_save.connect(add_to_user_group, sender=User)
social_account_added.connect(add_social_account_mail)
def __init__(self):
post_save.connect(self.user_model_updated, sender=DiscordUser)
post_delete.connect(self.mapping_model_deleted, sender=RoleMapping)
pre_save.connect(self.mapping_model_updated, sender=RoleMapping)
pre_social_login.connect(self.social_account_updated)
social_account_added.connect(self.social_account_updated)
social_account_updated.connect(self.social_account_updated)
social_account_removed.connect(self.social_account_removed)
user_logged_in.connect(self.user_logged_in)
def ready(self):
""" Connect relevant signals to their corresponding handlers. """
social_account_added.connect(
signals.update_user_email_addresses,
dispatch_uid=str(uuid4()),
weak=False
)
user_signed_up.connect(
signals.notify_admins_new_signup,
dispatch_uid=str(uuid4()),
weak=False
)
award = instance
if created:
# The user sending the notifications.
user = award.user
# Generate the message from the template.
content = html.render(name=AWARD_CREATED_HTML_TEMPLATE, award=award, user=user)
subject = "Congratulations: you won %s" % award.badge.name
# Create the message body.
body = MessageBody.objects.create(author=user, subject=subject, text=content)
message = Message.objects.create(user=user, body=body, sent_at=body.sent_at)
# Creates a message to everyone involved
signals.post_save.connect(post_create_messages, sender=Post, dispatch_uid="post-create-messages")
# Creates a message when an award has been made
signals.post_save.connect(award_create_messages, sender=Award, dispatch_uid="award-create-messages")
def disconnect_all():
signals.post_save.disconnect(post_create_messages, sender=Post, dispatch_uid="post-create-messages")
signals.post_save.disconnect(award_create_messages, sender=Award, dispatch_uid="award-create-messages")
# django-allauth sends a signal when a new user is created using a social provider or a new social
# provider is connected to an existing user.
user_signed_up.connect(hook_social_account_added)
social_account_added.connect(hook_social_account_added)
get_invitations_adapter().send_mail(
email_template,
self.email,
ctx)
except Exception:
import traceback
traceback.print_exc()
def get_anonymous_user_instance(user_model):
return user_model(pk=-1, username='******')
""" Connect relevant signals to their corresponding handlers. """
user_logged_in.connect(do_login)
user_logged_out.connect(do_logout)
social_account_added.connect(
update_user_email_addresses,
dispatch_uid=str(uuid4()),
weak=False
)
user_signed_up.connect(
notify_admins_new_signup,
dispatch_uid=str(uuid4()),
weak=False
)
signals.post_save.connect(
profile_post_save,
sender=get_user_model()
)
def get_anonymous_user_instance(Profile):
return Profile(pk=-1, username='******')
def profile_post_save(instance, sender, **kwargs):
"""
Make sure the user belongs by default to the anonymous group.
This will make sure that anonymous permissions will be granted to the new users.
"""
from django.contrib.auth.models import Group
anon_group, created = Group.objects.get_or_create(name='anonymous')
instance.groups.add(anon_group)
# do not create email, when user-account signup code is in use
if getattr(instance, '_disable_account_creation', False):
return
""" Connect relevant signals to their corresponding handlers. """
social_account_added.connect(
update_user_email_addresses,
dispatch_uid=str(uuid4()),
weak=False
)
user_signed_up.connect(
notify_admins_new_signup,
dispatch_uid=str(uuid4()),
weak=False
)
signals.post_save.connect(profile_post_save, sender=Profile)
return self.passage_data["name"]
else:
return str(self.date_created)
def get_absolute_url(self):
return reverse('planner-detail', kwargs={'slug': self.hash_key})
def save(self, *args, **kwargs):
"""
Save the field with a unique "hash_key"
"""
if not self.hash_key:
hasher = hashlib.sha1("".join([self.user.username,
datetime.datetime.now().isoformat()]))
self.hash_key = base64.urlsafe_b64encode(hasher.digest())[0:7]
super(Passage, self).save()
"""
Signal Handlers
"""
from allauth.account.signals import user_signed_up
from allauth.socialaccount.signals import social_account_added
import stathat
def signup_signal_callback(sender, **kwargs):
# stathat statistic for new registrations
stathat.ez_count('*****@*****.**', 'Users Registered', 1)
user_signed_up.connect(signup_signal_callback)
social_account_added.connect(signup_signal_callback) # most likely a registration
text=content)
message = Message.objects.create(user=user,
body=body,
sent_at=body.sent_at)
# Creates a message to everyone involved
signals.post_save.connect(post_create_messages,
sender=Post,
dispatch_uid="post-create-messages")
# Creates a message when an award has been made
signals.post_save.connect(award_create_messages,
sender=Award,
dispatch_uid="award-create-messages")
def disconnect_all():
signals.post_save.disconnect(post_create_messages,
sender=Post,
dispatch_uid="post-create-messages")
signals.post_save.disconnect(award_create_messages,
sender=Award,
dispatch_uid="award-create-messages")
# django-allauth sends a signal when a new user is created using a social provider or a new social
# provider is connected to an existing user.
user_signed_up.connect(hook_social_account_added)
social_account_added.connect(hook_social_account_added)
friends = people.list(userId=token.token, collections='visible')
for friend in friends['items']:
try:
friend_user = SocialAccount.objects.get(uid=friend['id'])
except SocialAccount.DoesNotExist as e:
logger.exception('User should exist but does not. Weird')
continue
shopper_b = Shopper.objects.get_or_create(friend_user.user)
shopper_a.add_friend(shopper_b)
except Exception as e:
logger.exception(e)
def friendify(sender, instance, **kwargs):
"""
Find existing social friends in App and build the relation
"""
account = instance.account
token = instance.token
provider = account.provider
if provider == 'facebook':
build_facebook_friendship(token=token)
elif provider == 'google':
build_google_friendship(token=token)
else:
logging.exception('Unknown Provider')
social_account_added.connect(friendify, sender=SocialLogin)
# email is unverified? Can this user steal it?
continue
elif email.verified and not existing.verified:
existing.verified = True
existing.save()
user_logged_in.connect(add_new_emails)
def update_data_from_provider(sender, request, sociallogin, **kwargs):
"""
Set the user's personal account image (if necessary) from the social account.
"""
import accounts.tasks
import projects.tasks
user = sociallogin.user
provider = sociallogin.account.provider
accounts.tasks.set_image_from_socialaccount(
account_id=user.personal_account.id, provider=provider,
)
if provider == "github":
projects.tasks.refresh_github_repos_for_user(user_id=user.id)
social_account_added.connect(update_data_from_provider)
social_account_updated.connect(update_data_from_provider)
