def post(self, request):
data = request.data
try:
credentials = dict(username=data['username'],
password=data['password'])
except KeyError as e:
data = {
'message': 'username or password not present in the data.',
'error': e
}
return StandardResponse(status=status.HTTP_400_BAD_REQUEST,
message='credentials not provided',
data=data)
user = authenticate(**credentials)
if user:
login(request, user)
user_serializer = serializers.UserSerializer(
user, context={'request': request})
return StandardResponse(status=status.HTTP_200_OK,
message='login successful',
data=user_serializer.data)
else:
return StandardResponse(status=status.HTTP_401_UNAUTHORIZED,
message='invalid credentials',
data={'user': '******'})
def login(request):
try:
data = json.loads(request.body)
username = data['username']
password = data['password']
if username == "" or password == "":
return Response({"status": "failure"})
if username is not None or password is not None:
user = authenticate(username=username, password=password)
print(user)
if user is not None:
token, _ = Token.objects.get_or_create(user=user)
print(token.key)
# u = UserProfile()
# priv = u.objects.get(user = username)
# print(priv)
response = Response({
"status": "success",
"user": username,
"token": token.key
})
response.set_cookie(key="token", value=token, max_age=900)
return response
else:
return Response({"status": "failure"})
else:
return Response({"status": "Enter User name and password"})
except json.decoder.JSONDecodeError as e:
return Response({"status": "failed", "exception": str(e)})
except Exception as e:
return Response({"status": "failed", "exception": str(e)})
def post(self, request, format=None):
serializer = CustomUserSerializer(request.data)
if serializer.is_valid():
user = authenticate(email=serializer.validated_data['email'],
password=serializer.validated_data['password'])
if user is not None:
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return Response(
{
'msg': 'Login Success',
'token': token,
'user': user
},
status=status.HTTP_200_OK)
else:
return Response({'msg': 'Credentials are not valid!'},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def validate(self, attrs):
username = attrs.get('username')
password = attrs.get('password')
if username and password:
user = authenticate(request=self.context.get('request'),
username=username,
password=password)
if user:
# From Django 1.10 onwards the `authenticate` call simply
# returns `None` for is_active=False users.
# (Assuming the default `ModelBackend` authentication backend.)
if not user.is_active:
raise serializers.ValidationError(
_('User account is disabled.'))
else:
raise serializers.ValidationError(
_('Unable to log in with provided credentials.'))
else:
raise serializers.ValidationError(
_('Must include "username" and "password".'))
attrs['user'] = user
return attrs
def login_user(request):
''' Handle user authentication
Method arguments:
request -- full HTTP request object
'''
# load JSON string of request body into a dict
req_body = json.loads(request.body.decode())
if request.method == 'POST':
username = req_body['username']
password = req_body['password']
authenticated_user = authenticate(username=username, password=password)
print(authenticated_user)
if authenticated_user is not None:
token = Token.objects.get(user=authenticated_user)
data = json.dumps({
'valid': True,
'token': token.key,
'user': {
'username': username,
'email': authenticated_user.email
}
})
return HttpResponse(data, content_type='application/json')
else:
# invalid login credentials
data = json.dumps({'valid': False})
return HttpResponse(data, content_type='application/json')
def create(self, request, *args, **kwargs):
data = json.loads(json.loads(request.body)["data"])
if data.get("email", False):
# signup, as email is present (email isn't used in login)
try:
user = get_user_model().objects.create_user(
username=data["username"],
email=data["email"],
password=data["password"])
except IntegrityError:
return Response({
"success": False,
"info": "Username is taken"
})
token = Token.objects.create(user=user)
return Response({"success": True, "token": token.key})
else:
user = authenticate(username=data["username"],
password=data["password"])
if user:
token = Token.objects.get(user=user)
return Response({"success": True, "token": token.key})
else:
return Response({
"success": False,
})
def login(request):
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(username=username, password=password)
if user is None:
return Response({'error': 'INVALID Data'})
token, created = Token.objects.get_or_create(user=user)
return Response({'token': token.key})
def post(self, request):
data = request['POST']
username = data.get('username')
password = data.get('password')
authenticater = authenticate(username=username, password=password)
if authenticater:
pass
return Response(authenticater, status=HTTP_200_OK)
return Response({'msg': '认证失败!'}, status=HTTP_400_BAD_REQUEST)
def get_token(request):
username = request.data.get("username")
password = request.data.get("password")
user = authenticate(username=username, password=password)
if user:
token, created = Token.objects.get_or_create(user=user)
return response_handle(data=token.key)
else:
return response_handle(data="Cannot login!")
def login(request):
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(username=username, password=password)
if user is None:
return Response({"error": "invalid data"})
token, created = Token.objects.get_or_create(user=user)
return Response({"token": token.key})
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
instance.set_password(instance.password)
instance.save()
user = authenticate(email=instance.email, password=request.data.get('password'))
data = generate_token(user)
return data
def get_user_if_valid(data):
username = data["username"]
password = data["password"]
user = authenticate(username=username, password=password)
if not user:
raise InvalidCredentialsException
else:
return user
def post(self, request):
username = request.data.get("username")
password = request.data.get("password")
user = authenticate(username=username, password=password)
if user:
token, created = Token.objects.get_or_create(user=user)
return response_handle(data=token.key)
else:
return response_handle(data="Wrong username or password!")
def put(self, request, *args, **kwargs):
data = request.data
username = data.get('username', None)
password = data.get('old_password', None)
user = authenticate(username=username, password=password)
if user is not None:
return super(ProfileUpdatePassword, self).put(request, *args, **kwargs)
return HTTP404Response(ErrorCodes.USER_OR_PASSWORD_NOT_MATCH)
def get_user_if_valid(self, data):
email = data["email"].lower()
password = data["password"]
user = authenticate(email=email, password=password)
if not user:
raise InvalidCredentialsException
elif user.is_verified is False:
raise EmailNotVerifiedException
else:
return user
def post(self, request, *args, **kwargs):
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
user = authenticate(username=self.request.data.get('username'), password=self.request.data.get('password'))
if user is not None:
punished_user = PunishUser.objects.filter(punished_user=user.pk, status='publish').first()
today = timezone.now().date()
if punished_user and today < punished_user.punish_finish_date:
return Response({'error_message': str(punished_user.punish_finish_date) + ' tarihine kadar cezalısınız.', "status_code": status.HTTP_401_UNAUTHORIZED})
else:
return Response({"user": LoginUserSerializer(user, many=False).data, "status_code": status.HTTP_200_OK})
return Response({'error_message': 'Username or password incorrect', "status_code": status.HTTP_400_BAD_REQUEST})
def login(request):
username = request.data.get('username')
password = request.data.get('password')
user = authentication.authenticate(username=username, password=password)
if user is None:
return Response({'user': user}, status=status.HTTP_400_BAD_REQUEST)
token, _ = Token.objects.get_or_create(user=user)
context = {
'key': token.key,
}
return Response(context)
def validate(self, attrs):
email = attrs.get("email")
password = attrs.get("password")
user = authenticate(email=email, password=password)
if user:
attrs["user"] = user
return attrs
else:
raise serializers.ValidationError(
"Unable to login with credentials provided.")
def _validate_email(self, email, password):
user = None
if email and password:
user = authenticate(self.context['request'],
email=email,
password=password)
else:
msg = _('Must include "email" and "password".')
raise exceptions.ValidationError(msg)
return user
def post(self, request, *args, **kwargs):
data = request.data
username = data.get('username', None)
password = data.get('password', None)
user = authenticate(username=username, password=password)
if user is not None:
res = login(request, user)
return Response({'status': 'OK', 'user': user.pk, 'CSRF_token': get_token(request)}, status=200)
else:
return HTTP404Response(ErrorCodes.USER_OR_PASSWORD_NOT_MATCH)
def validate(self, attrs):
email = attrs.get('email')
password = attrs.get('password')
if email and password:
# Check if user sent email
user = authenticate(email=email, password=password)
if user is None:
msg = ('Invalid email or password')
raise exceptions.AuthenticationFailed(msg)
else:
raise exceptions.ValidationError('Emal and Password are required')
attrs['user'] = user
return attrs
def validate(self, data):
"""Validate and authenticate the user."""
email = data.get('email')
password = data.get('password')
user = authenticate(
request=self.context.get('request'),
username=email,
password=password,
)
if not user:
msg = _('Unable to authenticate with provided credentials.')
raise serializers.ValidationError(msg, code='authentication')
data['user'] = user
return data
def validate(self, args):
email = args.get('email')
password = args.get('password')
developer = authenticate(request=self.context.get('request'),
username=email,
password=password)
if not developer:
msg = 'Unable to authenticate with provided credentials'
raise serializers.ValidationError(msg, code='authorization')
args['user'] = developer
args['is_staff'] = developer.is_staff
return args
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
instance = serializer.save()
instance.set_password(instance.password)
instance.save()
try:
PaymentService.create_customer(user=instance)
except Exception as e:
return Response({'error_msg': str(e)},
status=status.HTTP_400_BAD_REQUEST)
user = authenticate(email=instance.email,
password=request.data['password'])
data = generate_token(user)
return data
def post(self, request):
"""
http://127.0.0.1:8000/api-auth/login
"""
username = request.data.get('phone')
password = request.data.get('password')
print(username)
print(password)
user = authenticate(username=username, password=password)
if user is not None:
# the password verified for the user
if user.is_active:
login(request, user)
ret_json = {"error_code": 0, "detail": "login successfully"}
return Response(ret_json, status=status.HTTP_200_OK)
return Response('failed', status=status.HTTP_400_BAD_REQUEST)
def login(request):
username = request.data.get("username")
password = request.data.get("password")
if username is None or password is None:
return Response({'error': 'Please provide both username and password'},
status=HTTP_400_BAD_REQUEST)
user = authenticate(username=username, password=password)
if not user:
return Response({'error': 'Invalid credentials'},
status=HTTP_404_NOT_FOUND)
token, _ = Token.objects.get_or_create(user=user)
return Response({'token': token.key}, status=HTTP_200_OK)
def post(self, request):
data = request.data
username = data.get("username", None)
password = data.get("password", None)
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return Response(status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None):
username = request.data.get('username', None)
password = request.data.get('password', None)
db_username = UserProfile.objects.filter(username=username).first()
if db_username is not None:
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
logger.info("login successfull")
return JsonResponse({'msg': 'login successfull'},
status=200)
else:
return Response({'msg': 'user is not active'}, status=400)
else:
return JsonResponse({'msg': 'Invalid Credentials'}, status=401)
else:
return JsonResponse({'msg': 'Invalid Credentials'}, status=401)
def post(self, request):
errors = check_required_fields(request.data, ["mobile", "password"])
if len(errors.keys()):
return Response(gen_response(True, False, errors),
status=status.HTTP_400_BAD_REQUEST)
mobile = request.data["mobile"]
password = request.data["password"]
user = authenticate(mobile=mobile, password=password)
print(user, mobile, password)
if user is not None:
token = Token.objects.get_or_create(user=user)
token = token[0]
data = {"auth_token": token.key}
return Response(gen_response(False, True, "", data),
status=status.HTTP_200_OK)
else:
return Response(gen_response(
True, False, "Please Signup or Enter Valid Credentials"),
status=status.HTTP_400_BAD_REQUEST)
def validate(self, data):
email = data.get("email").lower()
password = data.get("password")
if email and password:
user = authenticate(email=email, password=password)
if user:
if not user.is_active:
raise InactiveAccountException
elif not user.is_verified:
raise EmailNotVerifiedException
else:
raise InvalidCredentialsException
else:
raise InvalidCredentialsException
data["user"] = user
return data
