class userStripe(models.Model): user = models.OneToOneField(settings.AUTH_USER_MODEL) stripe_id = models.CharField(max_length=200, null=True, blank=True) def __unicode__(self): if self.stripe_id: return str(self.stripe_id) else: return self.user.username def stripeCallback(sender, request, user, **kwargs): user_stripe_account, created = userStripe.objects.get_or_create( user=user) if created: print('created for %s' % (user.username)) if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '': new_stripe_id = stripe.Customer.create(email=user.email) user_stripe_account.stripe_id = new_stripe_id['id'] user_stripe_account.save() def profileCallback(sender, request, user, **kwargs): userProfile, is_created = userStripe.objects.get_or_create(user=user) if is_created: userProfile.name = user.username userProfile.save() user_logged_in.connect(stripeCallback) user_signed_up.connect(stripeCallback) user_signed_up.connect(profileCallback)
def ready(self): from actstream import registry registry.register(self.get_model('User')) from allauth.account.signals import user_logged_in, user_signed_up from .receivers import update_joined, update_last_login user_signed_up.connect(update_joined) user_logged_in.connect(update_last_login)
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 )
def test_user_signed_up_signal(self): sent_signals = [] def on_signed_up(sender, request, user, **kwargs): sociallogin = kwargs["sociallogin"] self.assertEqual(sociallogin.account.provider, GoogleProvider.id) self.assertEqual(sociallogin.account.user, user) sent_signals.append(sender) user_signed_up.connect(on_signed_up) self.login(self.get_mocked_response(verified_email=True)) self.assertTrue(len(sent_signals) > 0)
def test_user_signed_up_signal(self, mock_login_signal): sent_signals = [] def on_signed_up(sender, request, user, **kwargs): sociallogin = kwargs["sociallogin"] self.assertEqual(sociallogin.account.provider, PEAMUProvider.id) self.assertEqual(sociallogin.account.user, user) sent_signals.append(sender) user_signed_up.connect(on_signed_up) self.login(self.get_mocked_response()) self.assertEqual(mock_login_signal.call_count, 1) self.assertTrue(len(sent_signals) > 0)
def ready(self) -> None: super().ready() update_dynamic_preferences() password_changed.connect(ldap_change_password) password_reset.connect(ldap_change_password) password_set.connect(ldap_change_password) user_signed_up.connect(ldap_create_user) from django_auth_ldap.backend import populate_user # noqa populate_user.connect(ldap_sync_user_on_login)
def ready(self): from allauth.account.signals import user_signed_up, user_logged_in from django.conf.global_settings import AUTH_USER_MODEL from django.db.models.signals import post_save from main.signals import set_blank_location, user_signed_up_, check_if_userlocation, user_logged_in_, \ create_auth_token from main.utils import create_profile user_signed_up.connect(receiver=set_blank_location) user_signed_up.connect(receiver=user_signed_up_) user_logged_in.connect(receiver=check_if_userlocation) post_save.connect(receiver=create_profile, sender=AUTH_USER_MODEL) user_logged_in.connect(receiver=user_logged_in_) post_save.connect(receiver=create_auth_token, sender=AUTH_USER_MODEL)
def ready(self): super(UserConfig, self).ready() # the user signal handlers to connect to User = self.get_model("User") signals.post_save.connect(self.on_user_save, sender=User, dispatch_uid="users.user.post_save") user_signed_up.connect(self.on_user_signed_up) email_confirmed.connect(self.on_email_confirmed) social_account_removed.connect(self.on_social_account_removed) # the user ban signal handlers to connect to UserBan = self.get_model("UserBan") signals.post_save.connect(self.on_ban_save, sender=UserBan, dispatch_uid="users.user_ban.save") signals.post_delete.connect(self.on_ban_delete, sender=UserBan, dispatch_uid="users.user_ban.delete")
def test_user_signed_up_signal(self): sent_signals = [] def on_signed_up(sender, request, user, **kwargs): sociallogin = kwargs['sociallogin'] self.assertEqual(sociallogin.account.provider, GoogleProvider.id) self.assertEqual(sociallogin.account.user, user) sent_signals.append(sender) user_signed_up.connect(on_signed_up) self.login(self.get_mocked_response(verified_email=True)) self.assertTrue(len(sent_signals) > 0)
def ready(self): # Deve-se imortar daqui para evitar erro de Modelos ainda não carregdos no setup do Django from django.db.models.signals import pre_save, post_save from allauth.account.signals import user_signed_up from .signals import my_user_signed_up, voluntario_post_save, entidade_pre_save, entidade_post_save # Conexão de sinais user_signed_up.connect(my_user_signed_up) post_save.connect(voluntario_post_save, sender='vol.Voluntario') pre_save.connect(entidade_pre_save, sender='vol.Entidade') pre_save.connect(entidade_pre_save, sender='vol.EntidadeAguardandoAprovacao') post_save.connect(entidade_post_save, sender='vol.Entidade') post_save.connect(entidade_post_save, sender='vol.EntidadeAguardandoAprovacao')
def ready(self): user_signed_up.connect(log_user_signed_up, dispatch_uid="user_signed_up") email_confirmed.connect(log_email_confirmed, dispatch_uid="email_confirmed") from allauth.account.models import EmailAddress post_save.connect(handle_email_created, sender=EmailAddress, dispatch_uid="email_created") from mainsite.signals import handle_token_save from mainsite.models import AccessTokenProxy from oauth2_provider.models import AccessToken post_save.connect(handle_token_save, sender=AccessToken, dispatch_uid="token_saved") post_save.connect(handle_token_save, sender=AccessTokenProxy, dispatch_uid="token_proxy_saved")
def ready(self): super(UserConfig, self).ready() # the user signal handlers to connect to User = self.get_model('User') signals.post_save.connect(self.on_user_save, sender=User, dispatch_uid='users.user.post_save') user_signed_up.connect(self.on_user_signed_up) email_confirmed.connect(self.on_email_confirmed) social_account_removed.connect(self.on_social_account_removed) # the user ban signal handlers to connect to UserBan = self.get_model('UserBan') signals.post_save.connect(self.on_ban_save, sender=UserBan, dispatch_uid='users.user_ban.save') signals.post_delete.connect(self.on_ban_delete, sender=UserBan, dispatch_uid='users.user_ban.delete')
def test_user_signed_up_signal(self): self.signal_was_called = False def handler(sender, **kwargs): self.signal_was_called = True user_signed_up.connect(handler) data = { # 'first_name': 'Testing', # 'last_name': 'Signup', # 'birthday': '11/12/90', # 'state': 'CO', 'email': '*****@*****.**', 'email2': '*****@*****.**', 'password1': 'mytestpassword2', 'password2': 'mytestpassword2', } response = self.client.post('/accounts/signup/', data) self.assertTrue(self.signal_was_called) user_signed_up.disconnect(handler)
class userStripe(models.Model): user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE) stripe_id = models.CharField(max_length=200, null=True, blank=True) def __unicode__(self): # Если есть ID, преобразуй в его в строку: if self.stripe_id: return str(self.stripe_id) # Иначе верни имя пользователя: else: return self.user.username def stripeCallback(sender, request, user, **kwargs): user_stripe_account, created = userStripe.objects.get_or_create( user=user) # Если Stripe пользователя создан, появляется его профиль. if created: print(f'created for {user.username}') # Если ID системы stripe не существует, то используй email пользователя для его создания: if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '': new_stripe_id = stripe.Customer.create(email=user.email) user_stripe_account.stripe_id = new_stripe_id['id'] user_stripe_account.save() def profileCallback(sender, request, user, **kwargs): userProfile, is_created = Profile.objects.get_or_create(user=user) # Если пользователь создан, появляется его профиль. if is_created: userProfile.name = user.username userProfile.save() user_logged_in.connect(stripeCallback) user_signed_up.connect(stripeCallback) user_signed_up.connect(profileCallback)
from allauth.account.signals import user_signed_up from actions.utils import create_action from .models import Profile def user_created(request, user, **kwargs): """ Creates empty user profile when a new user signs up """ Profile.objects.create(user=user) create_action(user, "has signed up") user_signed_up.connect(user_created)
""" Users models """ # -*- coding: utf-8 -*- from django.contrib.auth.models import AbstractUser #from django.utils.translation import ugettext_lazy as _ from allauth.account.signals import (user_signed_up, user_logged_in, email_confirmed, password_reset) from .signals import (user_created_handler, user_logged_in_handler, email_confirmed_handler, user_password_reset_handler) # Subclass AbstractUser class User(AbstractUser): """ This is the extended Django user on the web application, so that we can add additional data and behavior to the base user model. Each front end django user has a corresponding user entry in the API backend. """ def __unicode__(self): return self.username # Hook up signals to django-allauth user_signed_up.connect(user_created_handler) email_confirmed.connect(email_confirmed_handler) user_logged_in.connect(user_logged_in_handler) password_reset.connect(user_password_reset_handler)
from django.db import models from allauth.account.forms import SignupForm from django.contrib.auth import get_user_model from allauth.account.signals import user_signed_up class Profile(models.Model): user = models.OneToOneField(get_user_model(), on_delete=models.CASCADE) location = models.CharField(max_length=50, blank=True) interest = models.CharField(max_length=240, blank=True) about = models.TextField(blank=True) def __str__(self): return f"{self.user.username} profile" User = get_user_model() def user_signed_up_receiver(request, user, **kwargs): if user_signed_up: Profile.objects.create(user=user) user_signed_up.connect(user_signed_up_receiver, sender=User)
else: return self.user.username def stripe_callback(sender, request, user, **kwargs): user_stripe_account, created = UserStripe.objects.get_or_create(user=user) if created: print "created for {}".format(user.username) if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '': new_stripe_id = stripe.Customer.create(email=user.email) user_stripe_account.stripe_id = new_stripe_id['id'] user_stripe_account.save() user_signed_up.connect(stripe_callback) user_logged_in.connect(stripe_callback) class UserDefaultAddress(models.Model): user = models.OneToOneField(settings.AUTH_USER_MODEL) shipping = models.ForeignKey("UserAddress", null=True, blank=True, related_name="user_address_shipping_default") billing = models.ForeignKey("UserAddress", null=True, blank=True, related_name="user_address_billing_default") def __unicode__(self):
def get_full_name(self): full_name = '%s %s' % (self.first_name, self.last_name) return full_name.strip() def get_short_name(self): return self.first_name def email_user(self, subject, message, from_email=None): send_mail(subject, message, from_email, [self.email]) def get_user_type(self): if self.is_superuser: return "superuser" elif self.groups.filter(name='professors').count(): return "professors" elif self.groups.filter(name='students').count(): return "students" return "unidentified" def is_pilot(self): return self.groups.filter(name='pilot_course').count() > 0 @staticmethod def add_default_group(sender, user, **kwargs): if settings.REGISTRATION_DEFAULT_GROUP_NAME: user.groups.add(Group.objects.get(name=settings.REGISTRATION_DEFAULT_GROUP_NAME)) user.save() user_signed_up.connect(TimtecUser.add_default_group, dispatch_uid="TimtecUser.add_default_group")
from django.conf import settings from django.shortcuts import reverse from django.core.validators import MaxValueValidator, MinValueValidator from django.utils.text import slugify from allauth.account.signals import user_signed_up from django.contrib.auth import get_user_model #User Groups from django.contrib.auth.models import Group def add_user_to_group(request, user, **kwargs): user.groups.add(Group.objects.get(name='customers')) user_signed_up.connect(add_user_to_group, sender=get_user_model()) CATEGORY_CHOICES = ( ('A', 'Available'), ('NA', 'Not Available'), ) LABEL_CHOICES = ( ('P', 'primary'), ('S', 'secondary'), ('D', 'danger'), ) PAYMENTS_CHOICES = ( ('S', 'Online Payment'), ('C', 'Cash On Delivier '), )
"Error setting up invited user - Inviter user not found") else: user.userorganization = inviter_user.userorganization user.is_admin = False user.is_team_member = True user.is_organisation_default = False try: user.save() except: logger.critical("Error updating invited users") else: try: emailAddress = EmailAddress.objects.get(email=user.email) except: emailAddress = EmailAddress() emailAddress.user = user.pk emailAddress.email = user.email emailAddress.verified = True emailAddress.primary = True try: emailAddress.save() except: logger.critical("Error setting up verified email") else: logger.info("Invited users - email already verified.") user_signed_up.connect(post_user_signed_up_checkinvitation) email_confirmed.connect(post_email_confirmed)
def __unicode__(self): if self.stripe_id: return str(self.stripe_id) else: return self.user.username def stripeCallback(sender,request,user,**kwargs): '''create a stripe user for just looged in users and assign a stripe id''' user_stripe_account,created = stripeUser.objects.get_or_create(user=user) if created: print ('created for %s'%(user.username)) if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '': #new customer created using useremail, request made new_stripe_id = stripe.Customer.create(email=user.email) #from stripe docs-how to create new customer. #the stripeid is alloted from the JSON response to above request user_stripe_account.stripe_id = new_stripe_id['id'] user_stripe_account.save() def dashboardCallback(sender,request,user,**kwargs): '''create a dashboard for just signed up users''' userdashboard, is_created = dashboard.objects.get_or_create(user=user) if is_created: userdashboard.username = user.username userdashboard.save() user_logged_in.connect(stripeCallback) user_signed_up.connect(dashboardCallback) user_signed_up.connect(stripeCallback)
def ready(self): user_signed_up.connect(log_user_signed_up, dispatch_uid="user_signed_up") email_confirmed.connect(log_email_confirmed, dispatch_uid="email_confirmed")
class userStripe(models.Model): user = models.OneToOneField(settings.AUTH_USER_MODEL) stripe_id = models.CharField(max_length=200, null=True, blank=True) def __unicode__(self): if self.stripe_id: return str(self.stripe_id) else: return self.user.username def clbk(sender, request, user, **kwargs): stripe_ac, created = userStripe.objects.get_or_create(user=user) if created: print "created for %s" % (user.username) if stripe_ac.stripe_id == None or stripe_ac.stripe_id == "": new_stripe_id = stripe.Customer.create(email=user.email) stripe_ac.stripe_id = new_stripe_id["id"] stripe_ac.save() prof, cr = Profiles.objects.get_or_create(user=user) if cr: prof.name = user.username prof.save() user_logged_in.connect(clbk) user_signed_up.connect(clbk)
name += ' ' name += last_name account.name = name if social_login.account.provider == 'google': if 'name' in social_login.account.extra_data: account.name = social_login.account.extra_data['name'] if 'picture' in social_login.account.extra_data: account.external_avatar_url = social_login.account.extra_data['picture'] account.save() # Connect django-allauth Signals user_signed_up.connect(new_sign_up) class AccountManager(BaseUserManager): def create_user(self, email, password=None, **kwargs): if not email: raise ValueError('Users must have a valid email address.') if not kwargs.get('username'): raise ValueError('Users must have a valid username.') account = self.model( email=self.normalize_email(email), username=kwargs.get('username') ) account.set_password(password)
except: # whoops, user is gone... user = None if user is not None: self.upsert_user(user) mongo = MongoConnector() def update_user_handler(sender, **kwargs): mongo.upsert_user(kwargs.get('user')) def update_related_user_handler(sender, **kwargs): mongo.upsert_related_user(kwargs.get('instance')) def update_emailrelated_handler(sender, **kwargs): mongo.upsert_related_user(kwargs.get('email_address')) def user_delete_handler(sender, **kwargs): mongo.remove_user(kwargs.get('instance')) user_signed_up.connect(update_user_handler, dispatch_uid='dd_user_signed_up') user_logged_in.connect(update_user_handler, dispatch_uid='dd_user_logged_in') email_changed.connect(update_user_handler, dispatch_uid='dd_email_changed') email_added.connect(update_user_handler, dispatch_uid='dd_email_added') email_confirmed.connect(update_emailrelated_handler, dispatch_uid='dd_email_donfirmed') post_delete.connect(user_delete_handler, sender=User, dispatch_uid='dd_user_delete') post_delete.connect(update_related_user_handler, sender=EmailAddress, dispatch_uid='dd_email_delete') post_delete.connect(update_related_user_handler, sender=SocialAccount, dispatch_uid='dd_social_delete') post_save.connect(update_related_user_handler, sender=SocialAccount, dispatch_uid='dd_social_save')
def ready(self): user_signed_up.connect(process_upon_user_signed_up, dispatch_uid="process_upon_user_signed_up") user_logged_in.connect(process_upon_user_logged_in, dispatch_uid="process_upon_user_logged_in")
from allauth.account.signals import user_signed_up from dd_invitation import admin_views as invitation def consume_invite_token(sender, **kwargs): request = kwargs.get('request', None) user = kwargs.get('user', None) if request is not None: token = request.session.get('invitation_token', None) if token is not None: request.session['invitation_token'] = None invitation.consume_token(request, token, extra_user=user) user_signed_up.connect(consume_invite_token, dispatch_uid='dd_user_signed_up_consume_token')
name += last_name account.name = name if social_login.account.provider == 'google': if 'name' in social_login.account.extra_data: account.name = social_login.account.extra_data['name'] if 'picture' in social_login.account.extra_data: account.external_avatar_url = social_login.account.extra_data[ 'picture'] account.save() # Connect django-allauth Signals user_signed_up.connect(new_sign_up) class AccountManager(BaseUserManager): def create_user(self, email, password=None, **kwargs): if not email: raise ValueError('Users must have a valid email address.') if not kwargs.get('username'): raise ValueError('Users must have a valid username.') account = self.model(email=self.normalize_email(email), username=kwargs.get('username')) account.set_password(password) account.access_level = 0
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() )
display_name = models.CharField(max_length=100) is_online = models.BooleanField(default=False) status = models.CharField(max_length=255, blank=True) def __str__(self): return self.display_name @staticmethod def create_profile(request, user, **kwargs): return Profile.objects.create( user=user, display_name='{}.{}'.format( user.first_name, user.last_name).strip('.'), ) user_signed_up.connect(Profile.create_profile) class Organization(models.Model): name = models.CharField(max_length=255) is_active = models.BooleanField(default=True) users = models.ManyToManyField(Profile) def __str__(self): return self.name class Room(models.Model): name = models.CharField(max_length=75) organization = models.ManyToManyField(Organization, blank=True) users = models.ManyToManyField(
# - get object or 404, get list or 404, paging # 과제2 bootstrap 디자인, 템플릿, 확장 # 20190514 # 과제1: Document, Category, Board 모델까지 확장 # Category - board = models.ForeignKey(Board) # 게시판에서의 category - 질문, 답변, 판매, 구매 # 쇼핑몰에서의 category - 상의, 하의, -> 상위 카테고리 - 하위코테고리 # category에 depth를 어떻게 구현할 것이냐? 고민! # 과제2: 검색 페이지 구현, Board?, Category?, Document? # ex) 검색시 programming이라는 이름을 가진 1) 게시판, 2) 카테고리, 3) 게시글 # 과제3: 전화번호부 # 구현 - 이름, 전화번호, 메모 + 검색 from allauth.account.signals import user_signed_up from allauth.socialaccount.models import SocialAccount # 과제 : 페이스북으로 소셜 로그인 - heroku 업로드 # 시그널이 발생했을 때 실행 될 함수 def naver_signup(request, user, **kwargs): social_user = SocialAccount.objects.filter(user=user) if social_user.exists(): user.last_name = social_user[0].extra_data['name'] user.save() # 시그널과 해당 함수 connect # 시그널 연결방법 2가지 receiver 쓰는 방법, connect 쓰는 방법 user_signed_up.connect(naver_signup)
# user = kwargs["user"] # id_stripe, created = UserStripe.objects.get_or_create(user = user) # if created: # print ("created stripe id for %s"%(user.username)) # user_profile, is_created = Profile.objects.get_or_create(user = user) # if is_created: # user_profile.name = user.username # user_profile.save() def stripe_call_back (sender, **kwargs): user = kwargs["user"] user_stripe_acc, created = UserStripe.objects.get_or_create(user=user) if created: print ("created stripe id for %s" %(user.username)) if user_stripe_acc.stripe_id is None or user_stripe_acc.stripe_id == '': new_stripe_id = stripe.Customer.create(email=user.email) user_stripe_acc.stripe_id = new_stripe_id['id'] user_stripe_acc.save() def profile_call_back (sender, **kwargs): user = kwargs["user"] user_profile, is_created = Profile.objects.get_or_create(user=user) if is_created: user_profile.name = user.username user_profile.save() user_logged_in.connect(stripe_call_back) user_signed_up.connect(profile_call_back) user_signed_up.connect(stripe_call_back) # user_logged_in.connect(my_callback)
# def __unicode__(self): # if self.stripe_id: # return str(self.stripe_id) # else: # return self.user.username # # # def stripe_callback(sender, request, user, **kwargs): # user_stripe_account, created = UserStripe.objects.get_or_create(user=user) # if created: # print "created for %s" %(user.username) # # if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '': # new_stripe_id = stripe.Customer.create(email=user.email) # user_stripe_account.stripe_id = new_stripe_id['id'] # user_stripe_account.save() # # # def profile_callback(sender, request, user, **kwargs): profile, is_created = Profile.objects.get_or_create(user=user) if is_created: profile.name = user.username profile.save() # # # user_logged_in.connect(stripe_callback) # user_signed_up.connect(stripe_callback) user_signed_up.connect(profile_callback) #
################################################################### ################################################################### def profile_create(sender, request, user, *args, **kwargs): try: with transaction.atomic(): profile = Profile(user=user) profile.save() except IntegrityError: user.delete() except: user.delete() user_signed_up.connect(profile_create, dispatch_uid="profile_create") """ def generate_welcome_notification(sender, instance, created, *args, **kwargs): print "##########################################" print "##########################################" print "##########################################" print sender print "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" print instance print "##########################################" print created if created: notification = Notification(profile = None, tittle = WELCOME_HEAD_STR, message = WELCOME_BODY_STR)
def get_short_name(self): return self.first_name def email_user(self, subject, message, from_email=None): send_mail(subject, message, from_email, [self.email]) def get_user_type(self): if self.is_superuser: return "superuser" elif self.groups.filter(name='professors').count(): return "professors" elif self.groups.filter(name='students').count(): return "students" return "unidentified" def is_pilot(self): return self.groups.filter(name='pilot_course').count() > 0 @staticmethod def add_default_group(sender, user, **kwargs): if settings.REGISTRATION_DEFAULT_GROUP_NAME: user.groups.add( Group.objects.get( name=settings.REGISTRATION_DEFAULT_GROUP_NAME)) user.save() user_signed_up.connect(TimtecUser.add_default_group, dispatch_uid="TimtecUser.add_default_group")
if hasattr(user, '_wrapped') and hasattr(user, '_setup'): if user._wrapped.__class__ == object: user._setup() user = user._wrapped if not user.is_staff: user.is_staff = True user.save() try: profile = Profile.objects.get(user=user) except Profile.DoesNotExist: profile = Profile(user=user) profile.save() user_signed_up.connect(add_profile) user_logged_in.connect(add_profile) # Create your views here. def get_music_metadata(file): with open(os.path.join(temp_upload_path,file.name),'wb+') as destination: for chunk in file.chunks(): destination.write(chunk) meta = {} music = eyed3.load(os.path.join(temp_upload_path,file.name)) if music: if music.tag:
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)
def set_registration_active(self): from allauth.account.signals import user_signed_up, email_confirmed user_signed_up.connect(self.set_inactive) email_confirmed.connect(self.set_active)
if self.stripe_id: return str(self.stripe_id) else: return self.user.username def StripeCallback(sender,request,user, **kwargs): # print "Request finished!" # print kwargs user_stripe_account,created =userStripe.objects.get_or_create(user=user) if created: print "created for %s" %(user.username) if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id =='': new_stripe_id = stripe.Customer.create(email=user.email) user_stripe_account.stripe_id =new_stripe_id['id'] user_stripe_account.save() def profileCallback(sender,request,user, **kwargs): userProfile,is_created =profile.objects.get_or_create(user=user) if is_created: userProfile.name =user.username userProfile.save() # user_logged_in.connect(my_callback) user_signed_up.connect(profileCallback) user_signed_up.connect(StripeCallback) user_logged_in.connect(StripeCallback)
from django.shortcuts import render, HttpResponseRedirect from django.contrib.auth import login, logout from django.dispatch import receiver from allauth.account.signals import user_signed_up, user_logged_in from accounts.models import User def signup_handler(sender, user, request, **kwargs): extra_data = user.socialaccount_set.filter(provider='facebook')[0].extra_data user.gender = extra_data['gender'] user.name = extra_data['name'] user.email = extra_data['email'] user.save() def logout(request): print ("logout") logout(request) return HttpResponseRedirect('/') def login_handler(sender, user, request, **kwargs): print(sender) print(user) print(request) user_logged_in.connect(login_handler) user_signed_up.connect(signup_handler)
def get_absolute_url(self): return reverse('profile-detail', kwargs={'pk': self.pk}) def __str__(self): return self.user.username def ProfileCallback(sender, request, user, **kwargs): userProfile, is_created = Profile.objects.get_or_create(user=user) if is_created: userProfile.name = user.username userProfile.save() user_signed_up.connect(ProfileCallback) RoomType = [ ('Single', 'Singles Rooms'), ('Double', 'Doubles Rooms'), ('Triple', 'Triples Rooms'), ('Quadruple', 'Quadruples Rooms'), ] price_none = 0 price_single = 20 price_double = 30 price_triple = 40 price_quadruple = 50 Prices = [ (price_none, '-----'),
author = models.ForeignKey(Author, null=True) publisher = models.ForeignKey(Publisher, null=True) series = models.ForeignKey(Series, null=True) edition = models.CharField(max_length=128, blank=True) year = models.IntegerField(choices=YEAR_CHOICES, null=True, blank=True) dropbox_id = models.CharField(max_length=256, unique=True) dropbox_sharing_link = models.URLField(default="") tags = TaggableManager() def __str__(self): return "{s.title}".format(s=self) def dropbox_link(self): if self.dropbox_sharing_link: return self.dropbox_sharing_link sharing_link = get_dropbox_sharing_link(self.owner, self.dropbox_id) self.dropbox_sharing_link = sharing_link self.save() return sharing_link def initial_import(request, user, **kwargs): from . import tasks tasks.sync_dropbox.delay(*build_args_for_sync_dropbox(user)) user_signed_up.connect(initial_import)
class clienteStripe(models.Model): user=models.OneToOneField(settings.AUTH_USER_MODEL) stripe_id = models.CharField(max_length=200, null=True, blank=True) def __unicode__(self): pass if self.stripe_id: return self.stripe_id else: return self.usuario.username def stripeCallback(sender,request, user, **kwargs): cuenta_usuario_Stripe, id_creada=clienteStripe.objects.get_or_create(user=user) if id_creada: print "created for %s"%(user.username) if cuenta_usuario_Stripe.stripe_id == None or cuenta_usuario_Stripe.stripe_id=="": new_stripe_id = stripe.Customer.create(email=user.email) cuenta_usuario_Stripe.stripe_id = new_stripe_id['id'] cuenta_usuario_Stripe.save() def clienteCallback(sender,request, user, **kwargs): usuarioCliente, Cliente_creado=cliente.objects.get_or_create(usuario=user) if Cliente_creado: usuarioCliente.nombre= user.username usuarioCliente.save() user_logged_in.connect(stripeCallback) user_signed_up.connect(stripeCallback) user_signed_up.connect(clienteCallback)
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)
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)
if self.passage_data.has_key("name"): 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
def __unicode__(self): if self.stripe_id: return str(self.stripe_id) else: return self.user.username def stripeCallback(sender, request, user, **kwargs): user_stripe_account, created = userStripe.objects.get_or_create(user=user) if created: print 'created for %s'%(user.username) if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id =='': new_stripe_id = stripe.Customer.create(email=user.email) user_stripe_account.stripe_id = new_stripe_id['id'] user_stripe_account.save() def profileCallback(sender, request, user, **kwargs): userProfile, is_created = profile.objects.get_or_create(user=user) if is_created: userProfile.name = user.username userProfile.save() user_logged_in.connect(stripeCallback) user_signed_up.connect(profileCallback) user_signed_up.connect(stripeCallback)
if resp['status'] == '200': root = ET.fromstring(content) else: logger.warning('Did not get 200 back from webgroups for %s. Got % ' % ( socialaccount.user, resp)) return modules = [] for group in root.findall('group'): if group.find('type').text == "Module": dep_code = group.find('department').attrib['code'] name = group.attrib['name'] m = re.match(regex % dep_code, name).group(1) modules.append(m) year = extra_data['warwickyearofstudy'] logger.info('User %s: ') logger.info(' Student: %s' % extra_data['student']) logger.info(' Staff: %s' % extra_data['staff']) logger.info(' Modules: %s' % modules) if extra_data['student'] == 'true': create_student_profile(user, modules, year) # if extra_data['staff# '] == 'true': # LecturerProfile() user_signed_up.connect(warwick_sign_up)