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)
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")
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)
def setUp(self):
# Track the signals sent via allauth.
self.user_logged_in_count = 0
user_logged_in.connect(self._login_callback)
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.
