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 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 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 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 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()))