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)