def test_empty_drf2(self): serializer = JSONWebTokenSerializer() expected = { 'username': '' } self.assertTrue(serializer.data, expected)
def post(self, *args, **kwargs): try: graph = GraphAPI(access_token=self.request.data['access_token'], version=settings.FACEBOOK_APP_VERSION) graph_data = graph.get_object(id='me', fields='email,first_name,last_name') except GraphAPIError: raise ParseError(detail='Invalid Facebook access token') data = { **graph_data, 'password': get_user_model().objects.make_random_password() } user, created = get_user_model().objects.get_or_create( email=data['email']) signup_ser = SignUpSerializer(instance=user, data=data) signup_ser.is_valid(raise_exception=True) user = signup_ser.save(is_active=True) token_ser = JSONWebTokenSerializer(data={ 'email': data['email'], 'password': data['password'] }) token_ser.is_valid(raise_exception=True) HistoryRecord.objects.create_history_record( user, None, HISTORY_RECORD_USER_SIGNUP_FACEBOOK) return Response( {'token': token_ser.object.get('token')}, status=status.HTTP_201_CREATED if created else status.HTTP_200_OK)
def post(request): try: serializer = JSONWebTokenSerializer(data=request.data) if serializer.is_valid(): serializer_data = serializer.validate(request.data) user = CustomUser.objects.get( username=request.data.get('username')) return Response( { 'status': True, 'token': serializer_data['token'] }, status=status.HTTP_200_OK) else: message = '' for error in serializer.errors.values(): message += " " message += error[0] return Response({ 'status': False, 'message': message }, status=status.HTTP_400_BAD_REQUEST) except (AttributeError, ObjectDoesNotExist): return Response({ 'status': False, 'message': 'User does not exist' }, status=status.HTTP_400_BAD_REQUEST)
def post(request): try: serializer = JSONWebTokenSerializer(data=request.data) if serializer.is_valid(): serialized_data = serializer.validate(request.data) # from custom_logger import DatabaseCustomLogger # d = DatabaseCustomLogger() # d.database_logger(123) user = User.objects.get(email=request.data.get('email')) return Response( { 'status': True, 'token': serialized_data['token'], }, status=status.HTTP_200_OK) else: message = '' for error in serializer.errors.values(): message += " " message += error[0] return Response({ 'status': False, 'message': message }, status=status.HTTP_400_BAD_REQUEST) except (AttributeError, ObjectDoesNotExist): return Response({ 'status': False, 'message': "User does not exist" }, status=status.HTTP_400_BAD_REQUEST)
def post(request): try: serializer = JSONWebTokenSerializer(data=request.data) if serializer.is_valid(): serialized_data = serializer.validate(request.data) # from custom_logger import DatabaseCustomLogger # d = DatabaseCustomLogger() # d.database_logger(123) email = request.data.get('email') user = User.objects.get(email=email) # if not user.is_email_verified: # return Response({ # 'status': False, # 'data': "Email Verification is pending", # }, status=status.HTTP_200_OK) user_serializer = UserListSerializer(user) return Response({ 'status': True, 'token': serialized_data['token'], 'data': user_serializer.data, }, status=status.HTTP_200_OK) else: message = '' for error in serializer.errors.values(): message += " " message += error[0] return Response({'status': False, 'message': message}, status=status.HTTP_400_BAD_REQUEST) except (AttributeError, ObjectDoesNotExist): return Response({'status': False, 'message': "User doesnot exists"}, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs): """ Register a User. If the user information already exists, an error will be returned. """ serializer = UserRegisterSerializer(data=request.data) if serializer.is_valid(): serializer.save() auth_classes = getattr(settings, "REST_FRAMEWORK", {}).get("DEFAULT_AUTHENTICATION_CLASSES", []) # TODO: ultimately should have a configurable "preferred" auth method if "rest_framework_jwt.authentication.JSONWebTokenAuthentication" in auth_classes: username_field = get_user_model().USERNAME_FIELD username = serializer.data.get(username_field) password = request.data.get("password") token_data = {"password": password} token_data[username_field] = username token_serializer = JSONWebTokenSerializer(data=token_data) if token_serializer.is_valid(): return Response( {"token": token_serializer.object.get('token')}, status=status.HTTP_201_CREATED) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_empty_drf3(self): serializer = JSONWebTokenSerializer() expected = { 'username': '', 'password': '' } self.assertEqual(serializer.data, expected)
def test_fields(self): serializer = JSONWebTokenSerializer() self.assert_fields_required(True, serializer, self.required_fields) self.assert_fields_required(False, serializer, self.not_required_fields) self.assertEqual( len(serializer.fields), len(self.required_fields) + len(self.not_required_fields))
def test_create(self): serializer = JSONWebTokenSerializer(data=self.data) is_valid = serializer.is_valid() token = serializer.object['token'] decoded_payload = utils.jwt_decode_handler(token) self.assertTrue(is_valid) self.assertEqual(decoded_payload['username'], self.username)
def mutate_and_get_payload(cls, input, context, info): serializer = JSONWebTokenSerializer(data=input) if serializer.is_valid(): token = serializer.object['token'] user = serializer.object['user'] return Login(success=True, user=user, token=token, errors=None) else: return Login( success=False, token=None, errors=['email', 'Unable to login with provided credentials.'])
def get_authenticated_user_client(): client = APIClient() User.objects.create_user(email="*****@*****.**", password="******") serializer = JSONWebTokenSerializer() attrs = { 'email': '*****@*****.**', 'password': '******', } user_credential = serializer.validate(attrs) client.credentials(HTTP_AUTHORIZATION='Bearer ' + user_credential.get('token')) return client
def post(self, request): serializer = self.serializer_class(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.save() password = self.request.data.get("password") token_serializer = JSONWebTokenSerializer(data={"username": user.username, "password": password}) token_serializer.is_valid(raise_exception=True) res = { "token": token_serializer.validated_data.get("token"), } return Response(res, status=status.HTTP_201_CREATED)
def test_disabled_user(self): self.user.is_active = False self.user.save() serializer = JSONWebTokenSerializer(data=self.data) is_valid = serializer.is_valid() expected_error = {'non_field_errors': ['User account is disabled.']} self.assertFalse(is_valid) self.assertEqual(serializer.errors, expected_error)
def test_required_fields(self): serializer = JSONWebTokenSerializer(data={}) is_valid = serializer.is_valid() expected_error = { 'username': ['This field is required.'], 'password': ['This field is required.'] } self.assertFalse(is_valid) self.assertEqual(serializer.errors, expected_error)
def login_request(request, format=None): seria = JSONWebTokenSerializer(data=request.data) seria.is_valid(raise_exception=True) user = seria.object.get('user') if user is None: return Response('', status=status.HTTP_404_NOT_FOUND) token = seria.object.get('token') info = CoinUserInfo.objects.filter(user=user.id).first() response_data = CoinUserInfoSerializer(info).data response_data['token'] = token return Response(response_data)
def test_invalid_credentials(self): self.data['password'] = '******' serializer = JSONWebTokenSerializer(data=self.data) is_valid = serializer.is_valid() expected_error = { 'non_field_errors': ['Unable to login with provided credentials.'] } self.assertFalse(is_valid) self.assertEqual(serializer.errors, expected_error)
def login_request(request, format=None): s = JSONWebTokenSerializer(data=request.data) try: s.is_valid(raise_exception=True) user = s.object.get('user') except (ValidationError, CoinUser.DoesNotExist): return Response('请输入正确的用户名和密码',) token = s.object.get('token') info = CoinUserInfo.objects.filter(user=user.id).first() response_data = CoinUserInfoSerializer(info).data response_data['token'] = token response_data['code'] = user.code return Response(response_data, status=status.HTTP_201_CREATED)
def post(self, request, *args, **kwargs): serializer = JSONWebTokenSerializer(data=request.data) # raise_exception=True,保证异常被handle_exception()处理 serializer.is_valid(raise_exception=True) user = serializer.validated_data.get('user') or request.user token = serializer.object.get('token') response_data = { 'user': UserSerializer(user).data, 'token': token, } user.last_login = timezone.now() user.save() return Response(response_data, status=status.HTTP_200_OK)
def post(self, request): sms = request.data.pop('sms_code') redis_cli = get_redis_connection('sms') sms_code = redis_cli.get(request.data.get('mobile')) if sms_code.decode() != sms: return Response({'data': {'success': False, 'message': '验证码错误'}}) serializer = UserSerializer(data=request.data) serializer.is_valid() user = serializer.save() serializer_jwt = JSONWebTokenSerializer(data=request.data) token = serializer_jwt.validate(request.data).get('token') data = jwt_response_payload_handler(token, user, request) return Response(data)
def mutate_and_get_payload(cls, root, info, **input): user = {'email': input['email'], 'password': input['password']} serializer = JSONWebTokenSerializer(data=user) if serializer.is_valid(): token = serializer.object['token'] user = serializer.object['user'] return Login(success=True, user=user, token=token, errors=None) else: return Login(success=False, token=None, errors=[ 'email', u'Non è possibile eseguire il login con le ' u'credenzili fornite.' ])
def autenticar_usuario(message_json): user = message_json['user'] password = message_json['password'] serializer_data = {'data': {'cc': user, 'password': password}} jwt_serializer = JSONWebTokenSerializer(**serializer_data) if jwt_serializer.is_valid(): user = jwt_serializer.object.get('user') token = jwt_serializer.object.get('token') else: return json.dumps({'error': True}) respuesta = {'token': token, 'user': UserSerializer(user).data} respuesta = json.dumps(respuesta) return respuesta
def post(request): serializer = JSONWebTokenSerializer(data=request.data) serializer.is_valid(raise_exception=True) serialized_data = serializer.validate(request.data) user_data = UserSerializer( User.objects.get(username=request.data['username'])).data if not user_data['groups']: return Response({'groups': "User not registered with any groups."}, status=status.HTTP_400_BAD_REQUEST) return Response( { 'status': True, 'token': serialized_data['token'], 'user': user_data, }, status=status.HTTP_200_OK)
def authenticate_user(client, user, admin_user=False, serializer_class=None): if admin_user: user.is_superuser = True user.save() serializer = JSONWebTokenSerializer() if serializer_class: serializer = serializer_class() attrs = { user.USERNAME_FIELD: user.get_username(), "password": "******", } user_credential = serializer.validate(attrs) client.credentials(HTTP_AUTHORIZATION="Bearer " + user_credential.get("token")) return client
def post(self, request): validated = RegistrationSerializer(data=request.data) validated.is_valid(True) if User.objects.filter( username=validated.validated_data["email"] ).exists(): raise ParseError("User with this email is exists") try: stripe_customer = stripe.Customer.create( email=validated.validated_data["email"], source=validated.validated_data["stripe_token"] ) except stripe.error.InvalidRequestError: raise ParseError("Invalid stripe token") user = User( email=validated.validated_data["email"], username=validated.validated_data["email"], is_subscriber=True ) user.set_password(validated.validated_data["password"]) user.stripe_token = stripe_customer.get('id') user.save() stripe_subscription = stripe.Subscription.create( customer=stripe_customer.id, items=[ { "plan": STRIPE_PLAN, }, ] ) Subscription.objects.create( user=user, stripe_token=stripe_subscription.id, till=datetime.fromtimestamp( stripe_subscription.current_period_end ) ) token = JSONWebTokenSerializer().validate( { "username": user.username, "password": validated.validated_data["password"] } ).get("token") self.registration_email(email=user.email, token=token) return Response({"token": token})
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) wx_api = WXAPPAPI(appid=APP_ID, app_secret=APP_SECRET) data = serializer.data try: session_info = wx_api.exchange_code_for_session_key(data['code']) except Exception as e: logger.warning("exchange code error:{}".format(e)) return Response(data={"code": ["登录失败"]}, status=status.HTTP_400_BAD_REQUEST) if session_info: openid = session_info['openid'] user, _ = User.objects.get_or_create( defaults={"password": make_password(PASSWORD)}, username=openid) user_profile, _ = Consumer.objects.update_or_create( user=user, defaults={ 'openid': openid, 'session_key': session_info['session_key'], 'user_name': data['user_name'], "sex": data['sex'], "avatar_url": data['avatar_url'] }) if data.get("sell_user"): # if data.get("recommend_id") and not user_profile.sell_user: sell_user = Consumer.objects.get(id=data.get("sell_user")) user_profile.sell_user = sell_user user_profile.save() logger.info("user_id:{}, sell_user_id:{}".format( user_profile, sell_user)) serializer = JSONWebTokenSerializer(data={ "username": openid, "password": PASSWORD }) serializer.is_valid(raise_exception=True) user = serializer.object.get("user") or request.user token = serializer.object.get("token") response_data = jwt_response_payload_handler(token, user, request) return Response(response_data, status=status.HTTP_200_OK) return Response(data={"code": ['认证异常']}, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs): username = request.data["username"] password = request.data["password"] keys = red_user_cache.keys() try: for single_key in keys: user_info = red_user_cache.get(single_key) redis_username, redis_password, redis_email = json.loads( user_info) if redis_username == username: return Response({"non_field_errors": ["账号未激活,请先激活账号"]}, status=status.HTTP_400_BAD_REQUEST) except Exception as e: pass user = User.objects.filter(username=username).first() if not user: return Response({"non_field_errors": ["账号或者密码错误"]}, status=status.HTTP_400_BAD_REQUEST) if not user.check_password(password): return Response({"non_field_errors": ["账号或者密码错误"]}, status=status.HTTP_400_BAD_REQUEST) if not user.has_active: return Response({"non_field_errors": ["账号未激活,请先激活账号"]}, status=status.HTTP_400_BAD_REQUEST) serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) #采用jwt模式认证 serializer_instance = JSONWebTokenSerializer(data=request.data) if serializer_instance.is_valid(): user = serializer_instance.object.get('user') or request.user token = serializer_instance.object.get('token') response_data = jwt_response_payload_handler(token, user, request) response = Response(response_data) if api_settings.JWT_AUTH_COOKIE: expiration = (datetime.utcnow() + api_settings.JWT_EXPIRATION_DELTA) response.set_cookie(api_settings.JWT_AUTH_COOKIE, token, expires=expiration, httponly=True) return response return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_auth(request): serialized = UserProfileSerializer(data=request.data) jwt = JSONWebTokenSerializer(data=request.data) data = jwt.is_valid() if serialized.is_valid(): serialized.save() result = { "success": True, "sessionId": jwt.validate(request.data)["token"] } code = status.HTTP_201_CREATED else: code = status.HTTP_400_BAD_REQUEST result = { "success": False, "message": "Wrong request data", "details": str(serialized._errors), "code": code } return Response(result, status=code)
def token(user): serializer = JSONWebTokenSerializer( data={'email': user.email, 'password': '******'}) serializer.is_valid() token = serializer.object['token'] return "JWT %s" % token
def get_jwt_token(self): serializer = JSONWebTokenSerializer( data={'email': self.user.email, 'password': '******'}) serializer.is_valid() token = serializer.object['token'] return "JWT %s" % token
def get_serializer(self, **kwargs): serializer = JSONWebTokenSerializer(**kwargs) serializer.context['request'] = Request(HttpRequest()), return serializer