def auto_login(request, uidb36, token, template="autologin/failed.html", redirect_to="/"): redirect = request.GET.get('next', None) args = request.GET.copy() if 'next' in args: del args['next'] args = args.urlencode() if redirect is None: redirect = redirect_to if args != "": if '?' in redirect: redirect += '&' else: redirect += '?' redirect += args User = get_user_model() try: user = User.objects.get(pk=base36_to_int(uidb36)) except (ValueError, User.DoesNotExist): user = None if request.user.is_authenticated(): if request.user == user: update_last_login(None, user) return HttpResponseRedirect(redirect) else: user = None if user is None or not default_token_generator.check_token(user, token): return TemplateResponse(request, template, {}, status=400) else: user.backend = 'django.contrib.auth.backends.ModelBackend' login(request, user) return HttpResponseRedirect(redirect)
def post(self, request): # Get redirect URL redirect_url = request.REQUEST.get('next', reverse_lazy('cursos:listar')) # Check if user has been authenticated before - if so, redirect him/her to the main site if request.user is not None and request.user.is_authenticated(): return redirect(redirect_url) form = LoginForm(request.POST) if form.is_valid(): # Login the authenticated user to the site and redirect - remember to log this event user = form.user login_to_site(request, user) update_last_login(None, user = user) return redirect(redirect_url) # Login failed - report errors back to the user return render_to_response('accounts/login.html', context = RequestContext(request, locals()), status = 401 )
def get_or_fetch(self, pk): u = self.filter(pk=pk).first() if u: # Set last_login field for the updating queue update_last_login(None, u) return u user_dict = wechat_client.user.get(pk) return self.create(**self.amend_model_params(**user_dict))
def safe_update_last_login(sender, user, **kwargs): """ Identical to Django's built-in handler except that we gracefully handle database failures. tl;dr logging in should not fail when a db is read-only """ try: update_last_login(sender, user, **kwargs) except DatabaseError as exc: logging.warn(six.text_type(exc), exc_info=True)
def jwt_response_payload_handler(token, user=None, request=None): if user: # if the last_login is set, update it. if user.last_login: update_last_login(None, user) now = datetime.datetime.now() game = NflGame.objects.filter(starts_at__gte=now).order_by('starts_at').first() current_week = 21 if not game else games.week return {'access_token': token, 'user_id': user.id, 'current_week': current_week}
def post(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) if serializer.is_valid(): user = serializer.object.get("user") or request.user update_last_login(None, user) token = serializer.object.get("token") response_data = jwt_response_payload_handler(token, user, request) return Response(response_data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def confirm_email_address( request, uidb36, token, error_template="onboarding/failed_email_confirm.html", template="onboarding/email_confirm.html", redirect_to="/", ): redirect = request.GET.get("next", None) args = request.GET.copy() if "next" in args: del args["next"] args = args.urlencode() if redirect is None: redirect = redirect_to if args != "": if "?" in redirect: redirect += "&" else: redirect += "?" redirect += args try: user = User.objects.get(pk=base36_to_int(uidb36)) except (ValueError, User.DoesNotExist): user = None if request.user.is_authenticated() and request.user != user: user = None if user is None or not token_generator.check_token(user, token): return TemplateResponse(request, error_template, {}, status=400) if request.method == "POST": if request.user.is_authenticated(): if request.user == user: user.is_active = True user.save() update_last_login(None, user) return HttpResponseRedirect(redirect) else: return TemplateResponse(request, error_template, {}, status=400) user.is_active = True user.save() user.backend = "django.contrib.auth.backends.ModelBackend" login(request, user) return HttpResponseRedirect(redirect) else: return TemplateResponse(request, template, {"next": redirect, "email": user.email})
def login(request): """ 通过 GitHub 的 oauth 系统登陆 """ code = request.query_params.get('code') if code is None: return Response({ 'error': 'Please provide code', 'redirect': f'https://github.com/login/oauth/authorize?client_id={client_id}' }, status=HTTP_400_BAD_REQUEST) access_token = get_access_token(code) if access_token is None: return Response({ 'error': 'Wrong code', }, status=HTTP_401_UNAUTHORIZED) user_info = get_user_info(access_token) username = user_info['login'] email = user_info['email'] password = '******' # 没有任何用处,也不会用这个密码来登陆 user = authenticate(username=username, password=password) # 如果之前没有这个用户则创建 if not user: user = User.objects.create_user( username=username, email=email, password=password ) user_detail = UserDetail( user=user, username=username, github_id=user_info.get('id', ''), node_id=user_info.get('node_id', ''), avatar_url=user_info.get('avatar_url', ''), gravatar_id=user_info.get('gravatar_id', ''), url=user_info.get('url', ''), html_url=user_info.get('html_url', ''), name=user_info.get('name', ''), blog=user_info.get('blog', ''), location=user_info.get('location', ''), email=user_info.get('email', ''), bio=user_info.get('bio', ''), ) user_detail.save() update_last_login(None, user) # 返回 Token token, _ = Token.objects.get_or_create(user=user) return Response({ 'token': token.key }, status=HTTP_200_OK)
def validate(self, data): username = data['username'] password = data['password'] user = authenticate(username=username, password=password) if user is None: raise ValidationError(detail='Incorrect username or password', status_code=status.HTTP_401_UNAUTHORIZED) payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) return { 'username': user.username, 'token': jwt_token, 'user_id': user.id }
def validate(self, data): username = EmailAddress.objects.get( email_id=data.get("username")).user_id or MobileNumber.objects.get( mobile_number=data.get("username")).user_id or null password = data.get("password") user = authenticate(user=username, password=password) if user is None: raise serializers.ValidationError( 'A user with this username and password is not found.') try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given username and password does not exists') return {'user': user.user, 'token': jwt_token}
def validate(self, data): username = data.get("username", None) password = data.get("password", None) user = authenticate(username=username, password=password) if user is None: raise serializers.ValidationError( 'A user with this email and password is not found.' ) try: update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given email and password does not exists' ) return { 'email': user.email }
def validate(self, data): username = data.get('username') password = data.get('password', None) user = authenticate(username=username, password=password) if user is None: return {'username': '******'} try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given username and password does not exist') return {'username': user.username, 'token': jwt_token}
def post(self, request, *args, **kwargs): result = super().post(request, *args, **kwargs) try: user = UserProfile.objects.get(username=request.data['username']) if not user.verified: user.send_verification_email() return Response( { 'detail': VERIFY_EMAIL_MESSAGE, 'email': user.email }, status=status.HTTP_401_UNAUTHORIZED) update_last_login(None, user) except: # pylint: disable=bare-except pass return result
def validate(self, data): email = data.get('email', None) password = data.get('password', None) user = authenticate(email=email, password=password) if user is None: raise serializers.ValidationError( 'A user with this email and password is not found.') try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) print(payload) print(jwt_token) update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given email and password does not exists') return {'email': user.email, 'token': jwt_token}
def validate(self, attrs): data = super().validate(attrs) refresh = self.get_token(self.user) data["refresh"] = str(refresh) data["access"] = str(refresh.access_token) data["user"] = { "profile_picture_url": self.user.profile.profile_picture_url, "first_name": self.user.profile.first_name, "last_name": self.user.profile.last_name, } if api_settings.UPDATE_LAST_LOGIN: update_last_login(None, self.user) return data
def post(self, request, *args, **kwargs): username = self.request.data['username'] email = self.request.data['email'] password = self.request.data['password'] if User.objects.filter(username=username).first(): return Response(data={ 'title': 'Already Exist', 'message': 'There is already user that has same username', 'error_code': 100 }, status=400) if User.objects.filter(email=email).first(): return Response(data={ 'title': 'Already Exist', 'message': 'There is already user that has same email', 'error_code': 101 }, status=400) user = User.objects.create_user( username=username, email=email, password=password, ) try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except User.DoesNotExist: return Response(data={ 'title': 'Login error', 'message': 'Something went wrong. Please try again later', 'error_code': 102 }, status=400) return Response(data={ 'success': True, 'token': jwt_token, 'user': UserSerializer(user).data }, status=200)
def token_obtain_sliding_login_handler(request, username, password): """ Takes a set of user credentials and returns a sliding JSON web token to prove the authentication of those credentials. """ ser = TokenObtainSlidingSerializer(data={ get_username_field(): username, 'password': password }) try: ser.is_valid(raise_exception=True) except: raise InvalidUser('用户名/密码输入错误') update_last_login(None, ser.user) session_user_update(request, ser.user) res = dict(token=ser.validated_data.get('token'), user=UserSerializer(ser.user).data) return res
def login(self, request): serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) username = serializer.data['login'] password = serializer.data['senha'] user = authenticate(username=username, password=password) if not user: return Response({"erro": "Login ou senha incorretos"}, status=status.HTTP_400_BAD_REQUEST) update_last_login(None, user) tokens = RefreshToken.for_user(user) # Gera os tokens JWT return Response( { 'refresh': str(tokens), 'access': str(tokens.access_token), }, status.HTTP_200_OK )
def post(self, request): email = request.data['email'] password = request.data['password'] user = authenticate(email=email, password=password) if user is None: queryset = CustomUser.objects.filter(email=email) data = Register_User_serializera(queryset, many=True) if password == data.data[0]['password']: jwt_token = JWT_ENCODE_HANDLER(email) return Response({'email': email, "token": jwt_token}) try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except CustomUser.DoesNotExist: raise serializers.ValidationError( 'User with given email and password does not exists') return Response({'email': user.email, 'token': jwt_token})
def validate(self, data): email = data['email'] password = data['password'] user = authenticate(username=email, password=password) if user is None: # raise some exception raise serializers.ValidationError( 'A user with this email/username and password is not found') try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given email and password does not exist') return {'email': user.email, 'token': jwt_token}
def get(self, request): access_token = request.COOKIES.get(settings.AUTH_COOKIE_KEY) if access_token is None: logger.warning("Access token not found in cookie") return Response(status=status.HTTP_401_UNAUTHORIZED) try: validated_user, _ = JWTHttpOnlyCookieAuthentication( ).authenticate_token(access_token) except: validated_user = None if validated_user is None: return Response(status=status.HTTP_401_UNAUTHORIZED) update_last_login(None, validated_user) user_serializer = serializers.UserSerializer(validated_user) return Response({"user": user_serializer.data}, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.validated_data print(UserSerializer(user, context=self.get_serializer_context()).data) try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except UserModel.DoesNotExist: raise serializers.ValidationError( 'User with given username and password does not exist') return Response({ "user": UserSerializer(user, context=self.get_serializer_context()).data, "token": jwt_token })
def post(self, request, *args, **kwargs): """ Override to check user login Args: request (object): The request object """ serializer = self.serializer_class(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.validated_data['user'] # Update last logged in update_last_login(None, user) data = get_user_profile_data(user) return Response(data, status=status.HTTP_200_OK)
def validate(self, data): username = data.get('username', None) password = data.get('password', None) user = authenticate(username=username, password=password) if user is None: raise serializers.ValidationError('tài khoản k tồn tại') try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given email and password does not exists') else: data['user'] = user data['token'] = jwt_token return data
def validate(self, data): email = data.get("email", None) password = data.get("password", None) user = authenticate(email=email, password=password) if user is None: raise serializers.ValidationError( 'A user with this email and password is not found.') try: payload = api_settings.JWT_PAYLOAD_HANDLER(user) jwt_token = api_settings.JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except CustomUser.DoesNotExist: raise serializers.ValidationError( 'User with given email and password does not exists') return { 'email': user.email, 'token': jwt_token.encode(payload, "SECRET_KEY") }
def validate(self, data): email = data.get("email", None) password = data.get("password", None) user = authenticate(email=email, password=password) print("USERR:", user) if user is None: raise serializers.ValidationError('Invalid Credentials') try: # JWT TPayload Generation payload = JWT_PAYLOAD_HANDLER(user) # JWT Token Generation jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except: raise serializers.ValidationError( 'User with this email and password is not found.') return {'email': user.email, 'token': jwt_token}
def create(self, validated_data): profile_data = validated_data.pop('profile') user = User.objects.create_user(**validated_data) UserProfile.objects.create(user=user, first_name=profile_data['first_name'], last_name=profile_data['last_name'], phone_number=profile_data['phone_number'], age=profile_data['age'], gender=profile_data['gender']) login_user = authenticate(user=user.username, password=user.password) payload = JWT_PAYLOAD_HANDLER(login_user) jwt_token = JWT_PAYLOAD_HANDLER(payload) update_last_login(None, login_user) return { 'username': login_user.username, 'token': jwt_token, }
def validate(self, data): email = data.get("email", None) password = data.get("password", None) user = authenticate(email=email, password=password) if user is None: raise serializers.ValidationError("No such User exists") try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError("No such User exists") return { "email": user.email, "token": jwt_token, }
def validate(self, data): username = data.get("username", None) password = data.get("password", None) try: user = User.objects.get(username=username) except User.DoesNotExist: user = User.objects.create_user(**data) user = authenticate(username=username, password=password) if user is None: raise serializers.ValidationError( 'User with given username and password does not exists') try: payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given username and password does not exists') return {'username': user.username, 'token': jwt_token}
def validate(self, attrs): data = super().validate(attrs) refresh = self.get_token(self.user) data['refresh'] = str(refresh) data['access'] = str(refresh.access_token) data['user'] = self.user.pk data['first_name'] = self.user.first_name data['last_name'] = self.user.last_name data['email'] = self.user.email data['username'] = self.user.username data['phone_number'] = self.user.phone_number if api_settings.UPDATE_LAST_LOGIN: update_last_login(None, self.user) return data
def validate(self, attrs): email = attrs.get('email') password = attrs.get('password') print(email, ':', password) user = authenticate(email=email, password=password) if user is None: return {'email': 'None'} try: # set token update_last_login(None, user) except User.DoesNotExist: raise serializers.ValidationError( 'User with given email and password does not exists') return { 'user': user, 'email': user.email, # 'token': jwt_token }
def sign_up(request): """ Create a new User """ JSON_RESPONSE = {STATUS: None, DATA: None, MESSAGE: None} serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.create(request.data) if (user != None): update_last_login(None, user) token = AccessToken.objects.get(user=user) token_serializer = AccessTokenSerializer(token) JSON_RESPONSE[STATUS] = SUCCESS JSON_RESPONSE[DATA] = UserSerializer(user).data JSON_RESPONSE[DATA][TOKEN] = token_serializer.data return Response(JSON_RESPONSE, status=status.HTTP_201_CREATED) JSON_RESPONSE[STATUS] = FAIL JSON_RESPONSE[MESSAGE] = "Username has been taken" return Response(JSON_RESPONSE, status=status.HTTP_400_BAD_REQUEST)
def resend_activation_email(request, user_hashid): try: user = get_object_or_404( CustomUser, pk=settings.HASHID_CUSTOM_USER.decode(user_hashid)[0]) from datetime import datetime timestamp = user.last_login or user.date_joined if not user.is_active and not user.is_disabled and ( (datetime.utcnow() - timestamp.replace(tzinfo=None)).total_seconds() > 300): # 5 min send_activation_email_task.delay(user.pk, get_current_site(request).domain) update_last_login(None, user) return render(request, 'account/inactive.html', { 'user': user, 'resent': True }) return render(request, 'account/inactive.html', {'user': user}) except: raise Http404('Page Not Found')
def social_login(request): serializer_class = SocialAuthSerializer serializer = serializer_class(data=request.data) serializer.is_valid(raise_exception=True) authenticated_user = request.user if not request.user.is_anonymous else None provider = serializer.data.get('provider') strategy = load_strategy(request) try: backend = load_backend(strategy=strategy, name=provider, redirect_uri=None) except MissingBackend: return JsonResponse({"error": "Provider invalid or not supported"}, status=status.HTTP_404_NOT_FOUND) if isinstance(backend, BaseOAuth1): token = { 'oauth_token': serializer.data.get('access_token'), 'oauth_token_secret': serializer.data.get('access_token_secret') } elif isinstance(backend, BaseOAuth2): token = serializer.data.get('access_token') try: user = backend.do_auth(token, user=authenticated_user) except BaseException as e: return JsonResponse({"error": "Invalid credentials"}, status=status.HTTP_400_BAD_REQUEST) if user: user.is_verified = True # user.token = functionto generate token payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) user.token = jwt_token print("+" * 10) print(jwt_token) user.save() update_last_login(None, user) serializer = UserSerializer(user) serializer.instance = user # import pdb;pdb.set_trace() return JsonResponse(serializer.data, status=status.HTTP_200_OK)
def validate(self, attrs): data = super().validate(attrs) if not hasattr(self.user, 'rlc_user'): raise ValidationError( "You don't have the necessary role to be able to login here.") refresh = self.get_token(self.user) data["refresh"] = str(refresh) data["access"] = str(refresh.access_token) data['user'] = RlcUserSerializer(self.user.rlc_user).data data['rlc'] = RlcSerializer(self.user.rlc).data data['permissions'] = self.user.get_all_user_permissions() if api_settings.UPDATE_LAST_LOGIN: update_last_login(None, self.user) return data
def post(self, request): result = super().post(request) serializer = self.get_serializer(data=request.data) if serializer.is_valid(): user = serializer.object.get('user') update_last_login(None, user) if 'type' in request.data: devices = user.profile.device_set.filter(type=type) if devices.count() > 0: device = devices[0] else: device = Device(fcm_token='noToken', profile=user.profile, type=request.data['type']) refresh_token = User.objects.make_random_password(length=20) device.refresh_token = refresh_token device.save() result.data['refresh_token'] = refresh_token return result
def post(self, request, *args, **kwargs): serializer = self.serializer_class(data=request.data, context={'request': request}) serializer.is_valid(raise_exception=True) user = serializer.validated_data['user'] update_last_login(None, user) token, created = Token.objects.get_or_create(user=user) try: account = user.account return Response( { 'account_id': account.id, 'account_level': account.level, 'token': token.key }, status=status.HTTP_200_OK) except Exception as e: return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST)
def validate(self, data): username = data.get('username') password = data.get('password') user = authenticate(username=username, password=password) if user is None: raise serializers.ValidationError( detail="A User with username and password is not found") try: refresh_token = RefreshToken.for_user(user) access_token = refresh_token.access_token update_last_login(None, user) return { "user_id": user.id, "access_token": str(access_token), "refresh_token": str(refresh_token) } except User.DoesNotExist: raise serializers.ValidationError( "A User with provided username does not exist.")
def user_login(self, user, password=DEFAULT_PASSWORD): self.client.login(username=user.email, password=password) update_last_login(self, user)
def jwt_response_payload_handler(token, user=None, request=None): update_last_login(None, user) # TODO why doesn't this work? return { 'token': token, 'user': UserProfileSerializer(user, context={"request": request}).data }