class UserCreateSerializer(ModelSerializer):
user_handler = UsersHandler()
email = serializers.EmailField(label=_('Email address'))
class Meta:
model = User
fields = [
'password',
'email',
]
extra_kwargs = {"password": {'write_only': True}}
def validate(self, data):
data['username'] = data['email']
return data
def validate_email(self, value):
email1 = value
users_qs = self.user_handler.get_by_params(dict(email=email1))
if users_qs.exists():
raise ValidationError(_("This user has already been registered."))
return value
def create(self, validated_data):
self.user_handler.create_user(validated_data)
return validated_data
class ProfilesView(View):
handler = UsersHandler()
profile_handler = UserProfilesHandler()
def get(self, request, *arg, **kwargs):
context = dict()
return render(request, 'users/profile_page.html', context=context)
class UserValidateTokenAPIView(APIView):
handler = UsersHandler()
permission_classes = [AllowAny]
serializer_class = UserValidateTokenSerializer
def post(self, request, *args, **kwargs):
data = request.data
serializer = self.serializer_class(data=data)
if serializer.is_valid(raise_exception=True):
return Response(status=status.HTTP_200_OK)
class UserLogoutAPIView(APIView):
permission_classes = [
IsAuthenticated,
]
serializer_class = UserChangePasswordSerializer
handler = UsersHandler()
def get(self, request, *args, **kwargs):
self.handler.logout_user(request)
return Response(dict(result=True), status=status.HTTP_200_OK)
class UserChangePasswordSerializer(ModelSerializer):
user_handler = UsersHandler()
old_password = serializers.CharField(label=_('Old password'))
password1 = serializers.CharField(label=_('New password'))
password2 = serializers.CharField(label=_('Confirm password'))
class Meta:
model = User
fields = [
'old_password',
'password1',
'password2',
]
extra_kwargs = {
"old_password": {
'write_only': True
},
"password1": {
'write_only': True
},
"password2": {
'write_only': True
},
}
def validate_old_password(self, value):
user = self.user_handler.get_by_id(self.context.get('request').user.id)
if user.check_password('{}'.format(value)):
return value
raise ValidationError(_("Wrong password."))
def validate_password1(self, value):
data = self.get_initial()
password1 = value
password2 = data.get("password2")
if password1 != password2:
raise ValidationError(_("Passwords must match."))
return value
def validate_password2(self, value):
data = self.get_initial()
password1 = data.get("password1")
password2 = value
if password1 != password2:
raise ValidationError(_("Passwords must match."))
return value
class LoginView(View):
form_class = AuthenticationForm
handler = UsersHandler()
def get(self, request, *args, **kwargs):
context = dict(form=self.form_class, hide_authentiation=True)
return render(request, 'users/login.html', context=context)
def post(self, request, *args, **kwargs):
form = self.form_class(data=request.POST)
if form.is_valid():
self.handler.login_user(request, form.cleaned_data)
return HttpResponseRedirect(reverse('kennels:kennels_page'))
context = dict(form=form, hide_authentiation=True)
return render(request, 'users/login.html', context=context)
class UserCreateAPIView(CreateAPIView):
user_handler = UsersHandler()
permission_classes = [AllowAny]
serializer_class = UserCreateSerializer
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
serializer.save()
token = self.user_handler.login_user(request, request.data)
return Response(dict(token=token.key,
email=request.user.email,
username=request.user.username),
status=status.HTTP_201_CREATED)
return Response(self.user_handler.parse_serializer_errors(
serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
class SignUpView(View):
form_class = UserCreationForm
handler = UsersHandler()
def get(self, request, *args, **kwargs):
context = dict(form=self.form_class, hide_authentiation=True)
return render(request, 'users/signup.html', context=context)
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
if form.is_valid():
self.handler.create_user(
dict(username=form.cleaned_data.get('username'),
email=form.cleaned_data.get('username'),
password=form.cleaned_data.get('password1')))
return HttpResponseRedirect(reverse('kennels:kennels_page'))
context = dict(form=form, hide_authentiation=True)
return render(request, 'users/signup.html', context=context)
class UserValidateTokenSerializer(ModelSerializer):
user_handler = UsersHandler()
token = serializers.CharField()
class Meta:
model = User
fields = [
'token',
]
def validate_token(self, value):
try:
token_data = jwt.decode(value,
settings.SECRET_KEY,
algorithms=['HS256'])
except jwt.ExpiredSignatureError:
raise ValidationError("Signature has expired")
except jwt.InvalidSignatureError:
raise ValidationError("Invalid signature token")
class UserResetPasswordAPIView(APIView):
permission_classes = [AllowAny]
serializer_class = UserResetPasswordSerializer
handler = UsersHandler()
def post(self, request, *args, **kwargs):
data = request.data
serializer = self.serializer_class(data=data)
if serializer.is_valid():
try:
user = self.handler.reset_password(
serializer.data.get("token"),
serializer.data.get('new_password'))
return Response(dict(email=user.email, username=user.username),
status=status.HTTP_200_OK)
except AuthenticationError as error:
return Response([str(error)],
status=status.HTTP_400_BAD_REQUEST)
return Response(self.handler.parse_serializer_errors(
serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
class UserForgotPasswordAPIView(APIView):
handler = UsersHandler()
permission_classes = [AllowAny]
serializer_class = UserForgotPasswordSerializer
def post(self, request, *args, **kwargs):
data = request.data
serializer = self.serializer_class(data=data)
if serializer.is_valid():
try:
user = self.handler.get_by_params(
dict(email=serializer.data.get('email'))).first()
if user:
self.handler.send_reset_password_email(user, request)
return Response(dict(result=True),
status=status.HTTP_200_OK)
return Response(["There is no user with such email."],
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return Response([str(e)], status=status.HTTP_400_BAD_REQUEST)
return Response(self.handler.parse_serializer_errors(
serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
class UserLoginAPIView(APIView):
authentication_classes = (SessionAuthentication, BasicAuthentication)
permission_classes = [AllowAny]
serializer_class = UserLoginSerializer
handler = UsersHandler()
def post(self, request, *args, **kwargs):
data = request.data
serializer = self.serializer_class(data=data)
if serializer.is_valid():
try:
token = self.handler.login_user(request, serializer.data)
return Response(dict(token=token.key,
email=request.user.email,
username=request.user.username),
status=status.HTTP_200_OK)
except AuthenticationError:
return Response(["Login failed"],
status=status.HTTP_401_UNAUTHORIZED)
return Response(self.handler.parse_serializer_errors(
serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
class UserLoginSerializer(ModelSerializer):
token = serializers.CharField(allow_blank=True, read_only=True)
username = serializers.CharField(required=False, allow_blank=True)
email = serializers.EmailField(label=_('Email address'),
required=False,
allow_blank=True)
user_handler = UsersHandler()
class Meta:
model = User
fields = ['username', 'password', 'email', 'token']
# extra_kwargs = {"password":
# {'write_only': True}}
def validate(self, data):
email = data.get('email', None)
username = data.get('username', None)
password = data.get('password', None)
if not username and not email:
raise ValidationError(
_("A username or email is required to login."))
user = self.user_handler.get_by_username_or_email(username, email)
user.exclude(email__isnull=True).exclude(email__iexact="")
if user.exists() and user.count() == 1:
user_obj = user.first()
else:
raise ValidationError(_("This username/email is not valid."))
if user_obj:
if not user_obj.check_password(password):
raise ValidationError(
_("Incorrect credentials, please try again."))
return data