def remove_current_user(backend, uid, user=None, *args, **kwargs):
"""
Handles cases where there was a user logged in (or lazy user) when the
social authentication started. Normal users are logged out. Lazy users are
kept, if and only if social account has not yet been used.
"""
extra_login = False
request = backend.strategy.request
provider = backend.name
social = backend.strategy.storage.user.get_social_auth(provider, uid)
session_next = backend.strategy.session_get('next')
if social:
if user and social.user != user:
if is_lazy_user(user):
user.delete()
else:
logout(request)
user = None
extra_login = True
else:
if user and is_lazy_user(user):
delete_lazy_user(user)
if session_next:
backend.strategy.session_set('next', session_next)
return {'user': user, 'extra_login': extra_login, 'backend': backend}
def remove_current_user(backend, uid, user=None, *args, **kwargs):
"""
Handles cases where there was a user loged in (or lazy user) when the
social authentication started. Normal users are logged out. Lazy users are
kept, if and only if social account has not yet been used.
"""
# if there was a user, force login because social auth won't do it
force_login = user is not None
request = backend.strategy.request
provider = backend.name
social = backend.strategy.storage.user.get_social_auth(provider, uid)
if social:
if user and social.user != user:
if is_lazy_user(user):
# delete lazy user, if he is to be forgotten anyway
LazyUser.objects.filter(user=user).delete()
user.delete()
else:
logout(request)
user = None
else:
if user:
if is_lazy_user(user):
delete_lazy_user(user)
else:
logout(request)
user = None
return {'user': user,
'force_login': force_login}
def remove_current_user(backend, uid, user=None, *args, **kwargs):
"""
Handles cases where there was a user logged in (or lazy user) when the
social authentication started. Normal users are logged out. Lazy users are
kept, if and only if social account has not yet been used.
"""
extra_login = False
request = backend.strategy.request
provider = backend.name
social = backend.strategy.storage.user.get_social_auth(provider, uid)
session_next = backend.strategy.session_get('next')
if social:
if user and social.user != user:
if is_lazy_user(user):
user.delete()
else:
logout(request)
user = None
extra_login = True
else:
if user and is_lazy_user(user):
delete_lazy_user(user)
if session_next:
backend.strategy.session_set('next', session_next)
return {'user': user, 'extra_login': extra_login, 'backend': backend}
def remove_current_user(backend, uid, user=None, *args, **kwargs):
"""
Handles cases where there was a user loged in (or lazy user) when the
social authentication started. Normal users are logged out. Lazy users are
kept, if and only if social account has not yet been used.
"""
# if there was a user, force login because social auth won't do it
force_login = user is not None
request = backend.strategy.request
provider = backend.name
social = backend.strategy.storage.user.get_social_auth(provider, uid)
if social:
if user and social.user != user:
if is_lazy_user(user):
# delete lazy user, if he is to be forgotten anyway
LazyUser.objects.filter(user=user).delete()
user.delete()
else:
logout(request)
user = None
else:
if user:
if is_lazy_user(user):
delete_lazy_user(user)
else:
logout(request)
user = None
return {'user': user, 'force_login': force_login}
def get(self, request, *args, **kwargs):
try:
if is_lazy_user(CustomUser.objects.get(pk=kwargs['pk'])):
return redirect(reverse('chat:chat-dashboard'))
except:
return redirect(reverse('chat:chat-dashboard'))
return super(AccountDetailView, self).get(request, *args, **kwargs)
def complete(request, backend, *args, **kwargs):
"""Authentication complete view, override this view if transaction
management doesn't suit your needs."""
if request.user.is_authenticated() and not is_lazy_user(request.user):
return associate_complete(request, backend, *args, **kwargs)
else:
return complete_process(request, backend, *args, **kwargs)
def globalhome(request):
username = request.user
if is_lazy_user(request.user):
request.session.guest = True
pop = Artist.objects.filter(global_pop=True, alive=True)
top_image = sorted(pop,
key=lambda x: ((x.mean_fitness / 10)**2) *
(math.log(max(1, x.seen)) + 1),
reverse=True)[0]
gen = max([a.generation for a in pop])
users = len(set([a.user for a in pop]))
fits = [a.mean_fitness for a in pop.filter(seen__gte=0)]
fitness = round(sum(fits) / len(fits), 2)
variety = conrad_utils.genetic_diversity(pop)
if top_image.image500 == '':
im = GA.display(top_image.genome, size=(500, 500))
out = "{}_500.PNG".format(top_image)
storage_utils.upload(im, 'media/' + out)
top_image.image500 = out
top_image.save()
top_image = top_image.image500.url
pop_data = [top_image, gen, fitness, variety, users]
context = {'pop_data': pop_data, 'username': username}
return render(request, 'conrad/globalhome.html', context)
def profile(request):
if not request.user.is_authenticated:
return HttpResponseRedirect('/accounts/login/')
if is_lazy_user(request.user):
return HttpResponseRedirect('/accounts/login/')
else:
return render(request, 'conrad/profile.html')
def complete(request, backend, *args, **kwargs):
"""Authentication complete view, override this view if transaction
management doesn't suit your needs."""
if request.user.is_authenticated() and not is_lazy_user(request.user):
return associate_complete(request, backend, *args, **kwargs)
else:
return complete_process(request, backend, *args, **kwargs)
def loggedIn(request):
response = {}
response['username'] = user_service.loggedIn(request)
# TODO: refactor - not clear why loggedIn should return username, use
# correct names and make it more explicit
response['is-lazy-user'] = is_lazy_user(request.user)
return JsonResponse(response)
def merge(self, lazy_user, user):
"""Merge the given lazy user into the already existing user"""
if not is_lazy_user(lazy_user):
raise NotLazyError('You cannot merge a non-lazy user')
#send the merge before deleting the user, to be able to handle the situation properly
merge.send(self, lazy_user=lazy_user, user=user)
lazy_user.delete()
def logout(request):
if request.method == "POST":
user = request.user
response = allauth.logout(request)
# lazy users are deleted on logout
if is_lazy_user(user):
user.delete()
return response
def details(request):
if not request.user.is_authenticated() or is_lazy_user(request.user):
return HttpResponseBadRequest('Requires logged-in user.')
user = user_service.get_user_information(request)
details_dict = {}
details_dict["username"] = user.username
details_dict["email"] = user.email
return JsonResponse(details_dict)
def register(request, username, firstname, lastname, email, passwd):
user = request.user
if is_lazy_user(user):
convert_lazy_user(user, username, email, passwd)
elif user.is_anonymous():
user = User.objects.create_user(username, email=email, password=passwd,
first_name=firstname, last_name=lastname)
login(request, username, passwd)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Only allow others to view profiles of "registered" of regular users,
# but allow automatically created (session) users to view their own
# profile.
if is_lazy_user(self.user) and self.user != self.request.user:
raise Http404()
context['user'] = self.user
return context
def test_convert_lazy_user(self):
lazy_user, _ = LazyUser.objects.create_lazy_user()
user, _ = do_authenticate(lazy_user)
self.assertFalse(is_lazy_user(lazy_user), 'Lazy user should have been converted.')
lazy_user = User.objects.get(pk=lazy_user.pk) # refresh original user object
self.assertIsNotNone(user, 'Processed user should not have been None.')
self.assertEqual(user, lazy_user, 'No new user should have been created.')
social_users = user.social_auth.all()
self.assertNotEqual(social_users, [], 'No social auth user has been created.')
def userhome(request):
username = request.user
if is_lazy_user(request.user):
request.session.guest = True
pop_list = list(
set([
p.population
for p in Artist.objects.filter(user=username, global_pop=False)
]))
if pop_list:
pops = [
Artist.objects.filter(user=username,
population=p,
global_pop=False) for p in pop_list
]
top_images = [
p.filter(seen__gte=0).order_by('-fitness', '-created')[0]
for p in pops
]
gens = [max([a.generation for a in p]) for p in pops]
la = [max([a.last_active for a in p]) for p in pops]
fitnesses = [
round(
sum([a.fitness for a in p.filter(seen__gte=0)]) /
len([a.fitness for a in p.filter(seen__gte=0)]), 2)
for p in pops
]
varieties = [
conrad_utils.genetic_diversity(pops[i].filter(generation=gens[i]))
for i in range(len(pops))
]
no_to_go = [(len(pops[i].filter(generation=gens[i], seen__lte=0)))
for i in range(len(pops))]
for i in top_images:
if i.image == '':
im = GA.display(i.genome)
out = "{}.PNG".format(i)
storage_utils.upload(im, 'media/' + out)
i.image = out
i.save()
top_images = [i.image.url for i in top_images]
user_pops = [[
pop_list[i], top_images[i], gens[i], fitnesses[i], varieties[i],
no_to_go[i], la[i]
] for i in range(len(pop_list))]
new_pop = max(pop_list) + 1
else:
user_pops = []
new_pop = 0
context = {
'user_pops': user_pops,
'username': username,
'new_pop': new_pop
}
return render(request, 'conrad/userhome.html', context)
def referral(request, username):
referrer = get_object_or_404(User, username=username)
from lazysignup.utils import is_lazy_user
if is_lazy_user(request.user) and not request.user.referred_by:
request.user.referred_by = referrer
request.user.save()
return HttpResponseRedirect('/')
def delete_lazy_user(user):
qs = LazyUser.objects.filter(user=user)
if qs:
qs.delete()
LazyUser.objects.update()
converted.send(None, user=user)
# remove lazy sign up backend
user.backend = None
user.save()
assert not is_lazy_user(user)
def testConvertGood(self):
# Check that the convert() method on the lazy user manager
# correctly converts the lazy user
user = LazyUser.objects.create_lazy_user("foo")
d = {"username": "******", "password1": "password", "password2": "password"}
form = GoodUserCreationForm(d, instance=user)
self.assertTrue(form.is_valid())
user = LazyUser.objects.convert(form)
self.assertFalse(is_lazy_user(user))
def get(self, request, *args, **kwargs):
if not self.request.user.id == int(kwargs['pk']):
return redirect(
reverse('account-detail', kwargs={'pk': request.user.pk}))
try:
if is_lazy_user(CustomUser.objects.get(pk=kwargs['pk'])):
return redirect(reverse('chat:chat-dashboard'))
except:
return redirect(reverse('chat:chat-dashboard'))
return super(AccountEditView, self).get(request, *args, **kwargs)
def leaderboard(request):
# latest_question_list = Question.objects.order_by('-pub_date')[:5]
# _seed_database(groups['EE'])
user = request.user
assert user is not None
template = loader.get_template("core/leaderboard.html")
gs = cm.Guess.objects.all()
scores = collections.defaultdict(int)
confidences = collections.defaultdict(int)
total = collections.defaultdict(int)
correct = collections.defaultdict(int)
last_guess_on = {}
for g in gs:
scores[g.user_id] += _score_guess(g)
confidences[g.user_id] += g.confidence
total[g.user_id] += 1
correct[g.user_id] += 1 if g.is_correct else 0
last_guess_on[g.user_id] = max(
g.created,
last_guess_on.get(g.user_id,
make_aware(datetime.datetime(2000, 1, 1))))
leader_data = list(sorted(scores.items(), key=lambda x: -x[1])[:20])
leader_users = cm.User.objects.filter(id__in=[_[0] for _ in leader_data])
leader_users = {
_.id: (_.username if not is_lazy_user(_) else f"Anonymous #{_.id}")
for _ in leader_users
}
leaderboard = []
for user_id, score in leader_data:
leaderboard.append({
"score":
score,
"user_id":
user_id,
"username":
leader_users[user_id],
"total":
total[user_id],
"correct":
correct[user_id],
"avg_confidence":
round(float(confidences[user_id]) / float(total[user_id]), 1),
"last_guess_on":
last_guess_on[user_id], #.isoformat(),
})
print(leaderboard)
context = {"leaderboard": leaderboard}
return HttpResponse(template.render(context, request))
def formatted_handle(self):
if is_lazy_user(self.user):
return self.handle + ' on ' + timezone.localtime(
self.timestamp).strftime('%b %-d %-I:%M %p PST')
else:
return mark_safe(
'<a href="' +
reverse('account-detail', kwargs={'pk': self.user.pk}) +
'" target="_blank">' + self.handle + '</a>' + ' on ' +
timezone.localtime(self.timestamp).strftime(
'%b %-d %-I:%M %p PST'))
def convert_lazy_user(user, username, email, password):
# TODO: proper error handling of user with the used username (or email,
# depending what we will use for identification)
user.username = username
user.email = email
user.set_password(password)
user.backend = None
user.save()
LazyUser.objects.filter(user=user).delete()
converted.send(None, user=user)
assert is_lazy_user(user) == False
def login(request, username, password):
user = authenticate(username=username, password=password)
# TODO: properly handle these scenarios
if user is None or not user.is_active:
return None
# TODO: Throws away any progress made before login, this should probably
# not happen. Also seems to throw some exceptions.
if is_lazy_user(request.user):
LazyUser.objects.filter(user=request.user).delete()
request.user.delete()
djangologin(request, user)
return user
def login(request, username, password):
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
if is_lazy_user(request.user):
LazyUser.objects.filter(user=request.user).delete()
request.user.delete()
log(request, user)
return True
else:
return False
else:
return False
def test_create_or_convert(self):
user, username = LazyUser.objects.create_lazy_user()
email = '*****@*****.**'
first_name = 'Petr'
password = '******'
converted_user = create_or_convert(user, email, first_name, password)
self.assertEqual(user, converted_user)
self.assertFalse(is_lazy_user(user))
self.assertEqual(user.email, email)
self.assertEqual(user.username, email)
self.assertTrue(user.check_password(password))
self.assertEqual(user.first_name, first_name)
def rename_lazyaccount(request): user = request.user username = user.username # Makes random username if is_lazy_user(user) and len(username) >= 30: user = User.objects.get(username = username) user.username = "******" + ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits) for _ in range(7)) group = Group.objects.get(name="Guest") group.user_set.add(user) user.save() request.user = user
def wrapped(request, *args, **kwargs):
from lazysignup.utils import is_lazy_user
try:
user = get_user(request)
if is_lazy_user(user) or not user.is_authenticated():
raise Exception("Not registered")
except:
return HttpResponseRedirect("{url}?next={this_url}".format(
url = settings.LOGIN_URL,
this_url = urlquote(request.get_full_path())
))
return func(request, *args, **kwargs)
def test_convert_lazy_user(self):
lazy_user, _ = LazyUser.objects.create_lazy_user()
user, _ = do_authenticate(lazy_user)
self.assertFalse(is_lazy_user(lazy_user),
'Lazy user should have been converted.')
lazy_user = User.objects.get(
pk=lazy_user.pk) # refresh original user object
self.assertIsNotNone(user, 'Processed user should not have been None.')
self.assertEqual(user, lazy_user,
'No new user should have been created.')
social_users = user.social_auth.all()
self.assertNotEqual(social_users, [],
'No social auth user has been created.')
def convert_lazy_user(user, username, email, password):
# check is username is still available
qs = User.objects.filter(username=username)
if qs:
return None
user.username = username
user.email = email
user.set_password(password)
user.backend = None
user.save()
delete_lazy_user(user)
assert not is_lazy_user(user)
def login(request, username, password):
user = authenticate(username=username, password=password)
# TODO: properly handle these scenarios
if user is None or not user.is_active:
return None
# TODO: Throws away any progress made before login, this should probably
# not happen. Also seems to throw some exceptions.
if is_lazy_user(request.user):
LazyUser.objects.filter(user=request.user).delete()
request.user.delete()
djangologin(request, user)
return user
def test_convert_good(self):
# Check that the convert() method on the lazy user manager
# correctly converts the lazy user
user, username = LazyUser.objects.create_lazy_user()
d = {
'username': '******',
'password1': 'password',
'password2': 'password',
}
form = GoodUserCreationForm(d, instance=user)
self.assertTrue(form.is_valid())
user = LazyUser.objects.convert(form)
self.assertFalse(is_lazy_user(user))
def testGoodCustomConvertForm(self):
self.client.get("/lazy/")
response = self.client.post(
reverse("test_good_convert"), {"username": "******", "password1": "password", "password2": "password"}
)
users = User.objects.all()
self.assertEqual(1, len(users))
user = users[0]
# The credentials returned by get_credentials should have been used
self.assertEqual(user, authenticate(username="******", password="******"))
# The user should no longer be lazy
self.assertFalse(is_lazy_user(user))
def get_user_information(request):
"""
Returns user with all the fields from the database.
Args:
request: request that envoked this method
Returns:
Object holding all the user information or None if there is not any.
"""
if not (request.user.is_anonymous() or is_lazy_user(request.user)):
return User.objects.get(username=request.user)
else:
return None
def test_convert_good(self):
# Check that the convert() method on the lazy user manager
# correctly converts the lazy user
user, username = LazyUser.objects.create_lazy_user()
d = {
'username': '******',
'password1': 'password',
'password2': 'password',
}
form = GoodUserCreationForm(d, instance=user)
self.assertTrue(form.is_valid())
user = LazyUser.objects.convert(form)
self.assertFalse(is_lazy_user(user))
def delete_lazy_user(user):
"""
If there is a lazy user associated with the given user, it is deleted.
"""
qs = LazyUser.objects.filter(user=user)
if qs:
qs.delete()
LazyUser.objects.update()
converted.send(None, user=user)
# set default authentication backend
user.backend = None
user.save()
assert not is_lazy_user(user)
return user
def delete_lazy_user(user):
"""
If there is a lazy user associated with the given user, it is deleted.
"""
qs = LazyUser.objects.filter(user=user)
if qs:
qs.delete()
LazyUser.objects.update()
converted.send(None, user=user)
# set default authentication backend
user.backend = None
user.save()
assert not is_lazy_user(user)
return user
def signup(request, username, firstname, lastname, email, password):
# check is username is still available
qs = User.objects.filter(username=username)
if qs:
return None
user = request.user
if is_lazy_user(user):
convert_lazy_user(user, username, email, password)
else:
User.objects.create_user(username, email=email, password=password,
first_name=firstname, last_name=lastname)
# TODO: what if login fails?
user = login(request, username, password)
return user
def create_or_convert(user, email, first_name, password):
"""
Creates a new user unless the current user is lazy one. In that case the
lazy user is converted and user details are updated.
"""
# usernames do not allow whole range of characters, so we generate them from email
username = email
if user and is_lazy_user(user):
user.username = username
user.email = email
user.first_name = first_name
else:
user = User(username=username, email=email, first_name=first_name)
user.set_password(password)
return delete_lazy_user(user)
def detail(request, slug):
"""
Show a single session, with attendees
"""
session = get_object_or_404(Session, slug=slug)
if session.is_break:
raise Http404
qs = Fav.objects.filter(session=session)
attendees = [x.user for x in qs if not is_lazy_user(x.user)] if qs.exists() else None
return render_to_response('session.html',
{"session": session,
"attendees":attendees},
context_instance=RequestContext(request))
def person(request, profile_id):
"""
Show one of the awesome speakers or attendees
"""
requested_user = get_object_or_404(User, pk=profile_id)
if is_lazy_user(requested_user):
raise Http404
qs = Fav.objects.filter(user=requested_user)
attending = [x.session for x in qs] if qs.exists() else None
return render_to_response('profile.html',
{"person": requested_user,
"attending": attending},
context_instance=RequestContext(request))
def test_good_custom_convert_form(self):
self.client.get('/lazy/')
self.client.post(reverse('test_good_convert'), {
'username': '******',
'password1': 'password',
'password2': 'password',
})
users = get_user_model().objects.all()
self.assertEqual(1, len(users))
user = users[0]
# The credentials returned by get_credentials should have been used
self.assertEqual(user, authenticate(username='******', password='******'))
# The user should no longer be lazy
self.assertFalse(is_lazy_user(user))
def test_good_custom_convert_form(self):
self.client.get('/lazy/')
self.client.post(reverse('test_good_convert'), {
'username': '******',
'password1': 'password',
'password2': 'password',
})
users = User.objects.all()
self.assertEqual(1, len(users))
user = users[0]
# The credentials returned by get_credentials should have been used
self.assertEqual(user, authenticate(username='******', password='******'))
# The user should no longer be lazy
self.assertFalse(is_lazy_user(user))
def convert(self, form):
""" Convert a lazy user to a non-lazy one. The form passed
in is expected to be a ModelForm instance, bound to the user
to be converted.
The converted ``User`` object is returned.
Raises a TypeError if the user is not lazy.
"""
if not is_lazy_user(form.instance):
raise NotLazyError, 'You cannot convert a non-lazy user'
user = form.save()
# We need to remove the LazyUser instance assocated with the
# newly-converted user
self.filter(user=user).delete()
return user
def detail(request, slug):
"""
Show a single session, with attendees
"""
session = get_object_or_404(Session, slug=slug)
if session.is_break:
raise Http404
qs = Fav.objects.filter(session=session)
attendees = [x.user for x in qs
if not is_lazy_user(x.user)] if qs.exists() else None
return render_to_response('session.html', {
"session": session,
"attendees": attendees
},
context_instance=RequestContext(request))
def convert(self, form):
""" Convert a lazy user to a non-lazy one. The form passed
in is expected to be a ModelForm instance, bound to the user
to be converted.
The converted ``User`` object is returned.
Raises a TypeError if the user is not lazy.
"""
if not is_lazy_user(form.instance):
raise NotLazyError, 'You cannot convert a non-lazy user'
user = form.save()
# We need to remove the LazyUser instance assocated with the
# newly-converted user
self.filter(user=user).delete()
return user
def identify(request, group_code, bird_seq=None):
# latest_question_list = Question.objects.order_by('-pub_date')[:5]
# _seed_database(groups['EE'])
user = request.user
assert user is not None
last_seq = (cm.Bird.objects.filter(
group=group_code,
guess__user=user).order_by("-seq").values_list("seq",
flat=True).first())
if bird_seq is None:
bird_seq = last_seq if last_seq else 0
bird_to_guess = get_image(group_code, bird_seq)
# served_birds[bird_to_guess['assetId']] = bird_to_guess
bird_stats = get_bird_stats(bird_to_guess)
user_stats = get_user_stats(request.user)
context = {
# 'bird': bird_to_guess,
"bird_id": bird_to_guess.id,
"seq": bird_to_guess.seq,
"image_url": bird_to_guess.image_url,
"location":
bird_to_guess.location_line1 + " in " + bird_to_guess.location_line2,
"observation_date": bird_to_guess.observation_date.isoformat(),
"photo_by": bird_to_guess.ebird_user_display_name,
"group": cc.GROUPS[group_code],
"confidences": cc.CONFIDENCES,
"bird_stats": bird_stats,
"user_stats": user_stats,
}
if is_lazy_user(request.user) and bird_to_guess.seq > 10:
context['prompt_user_to_create'] = True
# import pprint
# pprint.pprint(bird_to_guess.__dict__)
# pprint.pprint(bird_stats)
# pprint.pprint(user_stats)
template = loader.get_template("core/identify.html")
return HttpResponse(template.render(context, request))
def test_good_custom_convert_form(self):
self.client.get("/lazy/")
self.client.post(
reverse("test_good_convert"),
{
"username": "******",
"password1": "password",
"password2": "password",
},
)
users = get_user_model().objects.all()
self.assertEqual(1, len(users))
user = users[0]
# The credentials returned by get_credentials should have been used
self.assertEqual(user, authenticate(username="******", password="******"))
# The user should no longer be lazy
self.assertFalse(is_lazy_user(user))
def fblink(request):
next = get_next(request)
fbprofile = request.session.get("fbprofile", None)
fbgraph = request.session.get("fbgraph", None)
if not (fbprofile and fbgraph):
return HttpResponseRedirect("/")
message = ""
if request.method == "GET":
try:
from lazysignup.models import LazyUser
from lazysignup.utils import is_lazy_user
if is_lazy_user(request.user):
redirect, user, message = link_fb_user(request, request.user, fbprofile)
if redirect:
LazyUser.objects.filter(user=user).delete()
return redirect
else:
pass
except:
pass
form = AuthenticationForm()
else:
form = AuthenticationForm(data=request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data["username"], password=form.cleaned_data["password"])
if user is not None:
redirect, user, message = link_fb_user(request, user, fbprofile)
if redirect:
return redirect
else:
pass
else:
# Return an 'invalid login' error message.
message = "Login invalid"
pass
else:
pass
return render_to_response(
"fbuser/signup.djhtml",
{"path": request.path, "form": form, "message": message},
context_instance=RequestContext(request),
)
def create_or_convert(user, email, first_name, password):
"""
Creates a new user unless the current user is lazy one. In that case the
lazy user is converted and user details are updated.
"""
# usernames do not allow whole range of characters, so we generate them from email
username = email
if user and is_lazy_user(user):
user.username = username
user.email = email
user.first_name = first_name
else:
user = User(
username=username,
email=email,
first_name=first_name
)
user.set_password(password)
return delete_lazy_user(user)
def personaregister(request):
if request.method == "POST":
form = BrowserIDForm(data=request.POST)
user = request.user
# I've taken the - not - from the docs out of the next line
if form.is_valid():
result = verify(form.cleaned_data['assertion'], get_audience(request))
if result:
if is_lazy_user(user):
if User.objects.filter(email=result[u'email']):
existinguser = User.objects.get(email=result[u'email'])
existinguser.backend = 'django_browserid.auth.BrowserIDBackend'
login(request, existinguser)
else:
foo = LazyUser.objects.get(user=user)
foo.delete()
user.email = result[u'email']
user.save()
return redirect('/')
def check_user_last_seen(request):
if not request.user.is_authenticated or is_lazy_user(request.user):
return
username = request.user.username
user_objset = User.objects.filter(username=username)
if len(user_objset) < 1:
return
user_obj = user_objset[0]
uls_objset = UserLastSeen.objects.filter(Uid=user_obj)
if len(uls_objset) < 1:
uls_obj = UserLastSeen.objects.create(Uid=user_obj)
uls_obj.save()
pass
else:
uls_obj = uls_objset[0]
uls_obj.LastSeen = datetime.now()
return
def get_user_details(user):
if user is None:
return empty_user_details()
if isinstance(user, AnonymousUser):
qs = []
else:
# does not work with anonymous/lazy users
qs = UserSocialAuth.objects.filter(user=user)
details_dict = {}
details_dict["authenticated"] = user.is_authenticated()
details_dict["username"] = user.get_username()
details_dict["is-lazy-user"] = is_lazy_user(user)
if hasattr(user, 'first_name'):
details_dict["first-name"] = user.first_name
else:
details_dict["first-name"] = ''
if hasattr(user, 'last_name'):
details_dict["last-name"] = user.last_name
else:
details_dict["last-name"] = ''
if hasattr(user, 'email'):
details_dict["email"] = user.email
else:
details_dict["email"] = ''
if hasattr(user, 'is_staff'):
details_dict["is-staff"] = user.is_staff
else:
details_dict["is-staff"] = False
details_dict["providers"] = []
for social_user in qs:
details_dict["providers"].append(social_user.provider)
return details_dict
def inner(request, *args, **kwargs):
if not is_lazy_user(request.user):
return func(request, *args, **kwargs)
else:
return redirect(*redirect_args, **redirect_kwargs)
def test_anonymous_not_lazy(self):
# Anonymous users are not lazy
self.assertFalse(is_lazy_user(AnonymousUser()))
