def log_user_in(request, user): if not request.user.is_authenticated(): logged_in = False def check_logged_in(sender, **kwargs): nonlocal logged_in if kwargs.get('user') == user: logged_in = True user_logged_in.connect(check_logged_in) response = perform_login(request, user, email_verification=settings.ACCOUNT_EMAIL_VERIFICATION) user_logged_in.disconnect(check_logged_in) if logged_in is False: return response
total_match_projects = Project.objects.filter(user=self.user).count() total_tribe_projects = TribeAudioProject.objects.filter(user=self.user).count() projects = total_match_projects + total_tribe_projects return projects 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(profile_callback) class Influence(models.Model): user = models.ManyToManyField(settings.AUTH_USER_MODEL, related_name='influence_user') text = models.CharField(max_length=20) def __unicode__(self): return self.text
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)
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 self.stripe_id else: return self.user.username def stripeCallback(sender, request, user, **kwargs): #when user is logged in also want the model to create a profile for it user_stripe_account, created = userStripe.objects.get_or_create(user=user) if created: print('created for user %s' % (user.username)) if user_stripe_account.stripe_id == 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): #when user is logged in also want the model to create a profile for it 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 = 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 = profile.objects.get_or_create(user=user) if is_created: userProfile.name = user.username userProfile.save() user_logged_in.connect(profileCallback) user_logged_in.connect(stripeCallback) user_logged_in .connect(stripeCallback)
class profile(models.Model): name = models.CharField(max_length=120) user = models.OneToOneField(settings.AUTH_USER_MODEL, null=True, blank=True) description = models.TextField(default='description default text') def __str__(self): return self.name class userStripe(models.Model): user = models.OneToOneField(settings.AUTH_USER_MODEL) stripe_id = models.CharField(max_length=200, null=True, blank=True) def __str__(self): if self.stripe_id: return str(self.stripe_id) else: return self.user.username def my_callback(sender, **kwargs): print("request finished") print(kwargs) user_logged_in.connect(my_callback)
class userStripe(models.Model): user = models.OneToOneField(settings.AUTH_USER_MODEL) stripe_id = models.CharField(max_length=200, null=True, blank=True) def __str__(self): if self.stripe_id: return 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 not user_stripe_account.stripe_id or user_stripe_account.stripe_id == '': user_stripe_account.stripe_id = stripe.Customer.create(email=user.email)['id'] user_stripe_account.save() def profile_callback(sender, request, user, **kwargs): user_profile, created = profile.objects.get_or_create(user=user) if created: print('Profile For[%s]' % user.username) user_profile.name = user.username user_profile.save() user_signed_up.connect(profile_callback) user_signed_up.connect(stripe_callback) user_logged_in.connect(stripe_callback)
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")
import requests from allauth.account.models import EmailAddress from allauth.account.signals import user_logged_in from allauth.socialaccount.adapter import DefaultSocialAccountAdapter # Remember the last auth provider in the browser. The next time the # login page is visited, this provider can be highlighted to encourage # the user to use the same provider again. def set_last_provider(sender, request, response, user, **kwargs): if "sociallogin" in kwargs: response.set_cookie("auth_provider", kwargs["sociallogin"].account.provider) user_logged_in.connect(set_last_provider) # allauth won't automatically add email addresses from a newly connected # social account unless it's creating a user. When we automatically link # a new social account to an existing user by email matching, bring in # email addresses from the new social account. This can improve email # matching for users with multiple email addresses if another social # account is added later. Delayed until after login to avoid triggering # a call to SocialLogin.save on an existing socialaccount. def add_new_emails(sender, request, response, user, **kwargs): if "sociallogin" not in kwargs: return if not getattr(kwargs["sociallogin"], "autoconnect", False): return
def post_user_signed_up(request, user, **kwargs): sociallogin = kwargs.get('sociallogin') if sociallogin: copy_avatar(request, sociallogin.account.user, sociallogin.account) def post_user_logged_in(request, user, **kwargs): sociallogin = kwargs.get('sociallogin') if sociallogin: copy_avatar(request, sociallogin.account.user, sociallogin.account) post_save.connect(create_user_profile, sender=User) user_signed_up.connect(post_user_signed_up, sender=User) user_logged_in.connect(post_user_logged_in, sender=User) class Video(caching.base.CachingMixin, models.Model): slug = RandomSlugField(length=settings.RANDOMSLUG_LENGTH, blank=True, null=True) video_id = models.CharField(max_length=255, unique=True, null=True) title = models.CharField(max_length=200, null=True, blank=True) description = models.TextField(null=True, blank=True) youtube_url = models.URLField(max_length=255, null=True, blank=True) uploaded = models.DateTimeField() duration = models.BigIntegerField(default=0) added_by = models.ForeignKey(User, blank=True, null=True) added_on = models.DateTimeField(auto_now=True) mp4_url = models.URLField(max_length=255, null=True, blank=True)
EndTime=et, EndDate=Day, Priority='4', Type='A') stu.save() fixedScheduleAdder(stu, user) ## my_Call is a function which is called when user logs in # if profile is created then assign profile name as user name # Call createsched to create or check if created for next 3 days def my_Call(sender, request, user, **kwargs): from Timetable.models import DailySched, Slots userProfile, isCreated = profile.objects.get_or_create(user=user) if isCreated: userProfile.name = user.username userProfile.save() for i in range(4): createSched(date.today() + timedelta(days=i), userProfile, user) ## To execute mycall at login user_logged_in.connect(my_Call) class FeedBack(models.Model): Name = models.CharField(max_length=120) Email = models.EmailField(blank=True) contact = models.IntegerField(null=True) Description = models.CharField(max_length=300)
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)
""" 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) from .signals import (user_created_handler, user_logged_in_handler, email_confirmed_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)
def setUp(self): # Track the signals sent via allauth. self.user_logged_in_count = 0 user_logged_in.connect(self._login_callback)
amount=50, currency="usd", source=token, description='Your Registration is successfull!') self.charge_id = response.id except self.stripe.CardError: return False, {'message': 'failed'} return True, response #signals to create Profile when a user is created @receiver(post_save,sender=User) def create_user_profile(sender,instance,created, **kwargs): if created: Profile.objects.create( user = instance) @receiver(post_save, sender=User) def save_user_profile(sender,instance, **kwargs): instance.profile.save() def logged_in(sender, **kwargs): user = kwargs['user'] request = kwargs['request'] request.session['username'] = '******' # Connect django-allauth Signals user_logged_in.connect(logged_in)
# 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)
invitation_clicked_email = request.session.pop('invitation_clicked_email', None) # No invitation email to handle if not invitation_clicked_email: return # Email not in ebcard or not in the user emails existing_email_address = EmailAddress.objects.filter( email=invitation_clicked_email).first() if not existing_email_address or not (existing_email_address.user == user): get_invitations_adapter().add_message( request, messages.WARNING, 'invitations/messages/invite_cannot_be_accepted_wrong_user.txt', {'email': invitation_clicked_email}) return # Accept invitation invitation = Invitation.objects.filter( email=invitation_clicked_email).first() if invitation: accept_invitation(invitation=invitation, request=request, signal_sender=Invitation, user=user) if app_settings.ACCEPT_INVITE_AFTER_SIGNUP: user_logged_in.connect(accept_invite_after_login_or_signup) user_signed_up.connect(accept_invite_after_login_or_signup)
# Subclass AbstractUser class User(AbstractUser): def __unicode__(self): return self.username def notify_login(sender, user, request, **kwargs): if user.id <> 1 and not settings.DEBUG: body = """Hi, \n User %s (%s %s) Logged in \n Referrer: %s Remote_address: %s HTTP_USER_AGENT: %s\n they logged in to: %s (%s)\n Regards {{cookiecutter.repo_name}}""" % (user, user.first_name, user.last_name, request.META['HTTP_REFERER'], request.META['REMOTE_ADDR'], request.META['HTTP_USER_AGENT'], request.META['SERVER_NAME'], request.META['HTTP_HOST'], ) admin_emails = [v for k,v in settings.ADMINS] send_mail('%s logged in to {{cookiecutter.repo_name}}' % user, body, '{{cookiecutter.email}}', admin_emails, fail_silently=True) user_logged_in.connect(notify_login)
def ready(self): 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 route_next_param_to_query(): # Connect django-allauth Signals user_logged_in.connect(process_logged_in)
'pk': obj._get_pk_val(), 'avg': (self._current['ask'] + self._current['bid']) / 2 }) return dump_object class profile(models.Model): user = models.OneToOneField(settings.AUTH_USER_MODEL, blank=True, null=True) points = models.DecimalField(default=1000, decimal_places=2, max_digits=16) name = models.CharField(max_length=120, default="", blank=True) dailytime = models.DecimalField(default=0, decimal_places=0, max_digits=16) dailycount = models.DecimalField(default=0, decimal_places=0, max_digits=4) def __str__(self): return self.name def profileCallback(sender, request, user, **kwargs): newprofile, is_created = profile.objects.get_or_create(user=user) newprofile.points = 2000 newprofile.name = user.username newprofile.save() #if created: #profile.objects.create(user=instance) user_logged_in.connect(profileCallback)
city = models.CharField(max_length=120, null=True, blank=True) country = models.CharField(max_length=120, null=True, blank=True) active = models.BooleanField(default=True) timestamp = models.DateTimeField(auto_now_add=True) objects = UserSessionManager() def __str__(self): city = self.city country = self.country user = self.user if city and country: return f"{city}, {country}" elif city and not country: return f"{city}" elif country and not city: return f"{country}" return f"{user}" def user_logged_in_receiver(sender, request, *args, **kwargs): user = request.user ip_address = get_client_ip(request) session_key = request.session.session_key UserSession.objects.create_new( user=user, session_key=session_key, ip_address=ip_address ) user_logged_in.connect(user_logged_in_receiver)
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): return str(self.user.username)
from allauth.account.signals import user_logged_in from django.contrib.auth import get_user_model from django.db import models User = get_user_model() def user_logged_in_receiver(request, user, **kwargs): print(request) print(user) user_logged_in.connect(user_logged_in_receiver, sender=User)
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)
def complete_researcher_profile_on_orcid_login(sender, user, **kwargs): orcid = user.socialaccount_set.first().uid r = Researcher.objects.get(orcid=orcid) if r.user_id is None and user is not None: r.user = user r.save(update_fields=['user']) if r.empty_orcid_profile is None: r.init_from_orcid() else: r.fetch_everything_if_outdated() pre_social_login.connect(fetch_on_orcid_login) user_logged_in.connect(complete_researcher_profile_on_orcid_login) # Number of papers shown on a search results page NB_RESULTS_PER_PAGE = 20 class AdvancedPaperSearchView(FormView): """Displays the full search form.""" template_name = 'papers/advanced_search.html' form_class = PaperSearchForm class PaperSearchView(SearchView): """Displays a list of papers and a search form.""" paginate_by = NB_RESULTS_PER_PAGE
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: meta['title'] = music.tag.title
from allauth.account.signals import user_logged_in, user_logged_out from allauth.socialaccount.signals import social_account_added, social_account_updated def clear_user_session_data(sender, request, user, **kwargs): """ Clear the `user` session data (which is there for anon users too). In the future, we may link the `AnonUser` to the user. For example, for them to not loose objects created while anonymous. """ if "user" in request.session: del request.session["user"] user_logged_in.connect(clear_user_session_data) user_logged_out.connect(clear_user_session_data) def set_last_provider(sender, request, response, user, **kwargs): """ Remember the last auth provider in the browser. The next time the login page is visited, this provider can be highlighted to encourage the user to use the same provider again. """ if "sociallogin" in kwargs: response.set_cookie( "auth_provider", kwargs["sociallogin"].account.provider, max_age=315360000, # Ten years in seconds.