def validate(self, attrs):
self._errors = {}
password1 = attrs['new_password1']
password2 = attrs['new_password2']
print('password1', password1)
print('password2', password2)
if password1 != password2:
print('ey joon')
raise ValidationError(
{'new_password2': ['گذرواژه ها یکسان نمی باشند.']})
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(attrs['uid']))
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({'uid': ['Invalid value']})
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(
user=self.user, data=attrs
)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs['token']):
raise ValidationError({'token': ['Invalid value']})
return attrs
def validate(self, attrs):
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(attrs['uid']))
self.user = USER_MODEL.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, USER_MODEL.DoesNotExist):
raise exceptions.ValidationError({'uid': ['Invalid value']})
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(
user=self.user,
data={
'new_password1': attrs['new_password_1'],
'new_password2': attrs['new_password_2'],
'token': attrs['token'],
'uid': attrs['uid'],
})
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs['token']):
raise exceptions.ValidationError({'token': ['Invalid value']})
return attrs
def validate(self, attrs):
uidb64 = attrs.get('uid')
token = attrs.get('token')
if uidb64 and token:
UserModel = get_user_model()
# Decode the uidb64 to uid to get User object
try:
uid = uid_decoder(uidb64)
usr = UserModel._default_manager.get(pk=uid)
if not SimpleVerificationTokenGenerator.check_token(usr.email, token):
raise ValidationError({'token': ['Invalid token']})
user = usr
user.backend = 'django.contrib.auth.backends.ModelBackend'
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({'uid': ['Invalid uid']})
else:
msg = _('Must include "uidb64" and "token".')
raise exceptions.ValidationError(msg)
# Did we get back an active user?
if user:
if not user.is_active:
msg = _('User account is disabled.')
raise exceptions.ValidationError(msg)
else:
msg = _('Unable to log in with provided credentials.')
raise exceptions.ValidationError(msg)
attrs['user'] = user
return attrs
def mutate(cls, _, info, **kwargs):
data = {
'uid': kwargs.get('uid'),
'token': kwargs.get('token'),
'new_password1': kwargs.get('password'),
'new_password2': kwargs.get('password')
}
try:
uid = force_text(uid_decoder(data['uid']))
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
raise ValueError('The uid is not valid.')
form = SetPasswordForm(user=user, data=data)
if not form.is_valid() or not token_generator.check_token(user, data['token']):
raise ValueError("The token is not valid.")
form.save()
change_password_confirmation.send(sender=User, user=user, request=info.context)
token = get_token(user, info.context)
payload = get_payload(token, info.context)
return cls(user=user, token=token, payload=payload)
def validate_reset_password(request, uid, token):
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(uid))
user = User.objects.get(pk=uid)
if default_token_generator.check_token(user, token):
data = {
"code": getattr(settings, 'SUCCESS_CODE', 1),
"message": "Password Reset Link is valid",
"data": {
"email": user.email
}
}
else:
data = {
"code": getattr(settings, 'ERROR_CODE', 0),
"message": "Password Reset Link is Invalid",
}
return Response(data, status=status.HTTP_200_OK)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
data = {
"code": getattr(settings, 'ERROR_CODE', 0),
"message": "Password Reset Link is Invalid",
}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
def validate(self, attrs):
self._errors = {}
# Get the UserModel
UserModel = get_user_model()
# Decode the uidb64 to uid to get User object
try:
uid = uid_decoder(attrs['uid'])
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({
'non_field_errors': [
self.validate_error_messages['invalid_uid']
]
})
self.custom_validation(attrs)
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
raise ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs['token']):
raise ValidationError({
'non_field_errors': [
self.validate_error_messages['invalid_token']
]
})
super(FixedPasswordResetConfirmSerializer, self).validate(attrs)
return attrs
def validate(self, attrs):
self._errors = {}
# Decode the uidb64 to uid to get User object
if 'uid' in attrs:
try:
uid = force_text(uid_decoder(attrs['uid']))
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError,
UserModel.DoesNotExist):
raise ValidationError({'uid': ['Invalid value']})
elif 'email' in attrs: # If resetting password from mobile app
try:
self.user = UserModel._default_manager.get(
email=attrs['email'])
try:
if self.user.mobile_verification_code.code == attrs[
'code']:
# Check if verification code has not expired, default is 24 hours
days = 3
try:
days = settings.PASSWORD_RESET_TIMEOUT_DAYS
except:
pass
delta = datetime.now(
tz=timezone.utc
) - self.user.mobile_verification_code.created_at
if delta.days >= days:
raise ValidationError({
'code': [
'This code has expired, please request a '
'new verification code.'
]
})
else:
raise ValidationError({'code': ['Invalid value']})
except ValidationError as e:
raise e
except:
raise ValidationError({'code': ['Invalid value']})
except (TypeError, ValueError, OverflowError,
UserModel.DoesNotExist):
raise ValidationError({'email': ['Invalid value']})
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if 'uid' in attrs and not default_token_generator.check_token(
self.user, attrs['token']):
raise ValidationError({'token': ['Invalid value']})
return attrs
def validate(self, attrs):
try:
uid = force_text(uid_decoder(attrs['uid']))
user = get_user_model().objects.get(pk=uid)
except (TypeError, ValueError, OverflowError,
get_user_model().DoesNotExist):
msg = _('Invalid uid.')
raise exceptions.ValidationError(msg)
if not default_token_generator.check_token(user, attrs['token']):
msg = _('Invalid token.')
raise exceptions.ValidationError(msg)
attrs['user'] = user
return attrs
def validate(self, attrs):
self._errors = {}
try:
uid = force_text(uid_decoder(attrs['uid']))
self.user = MyUser._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, MyUser.DoesNotExist):
raise ValidationError({'uid': ['Invalid value']})
self.custom_validation(attrs)
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs['token']):
raise ValidationError({'token': ['Invalid value']})
return attrs
def validate(self, attrs):
try:
uid = force_text(uid_decoder(attrs["uid"]))
self.user = User.on_site.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
raise serializers.ValidationError({"uid": ["Invalid value"]})
if not default_token_generator.check_token(self.user, attrs["token"]):
raise serializers.ValidationError({"token": ["Invalid value"]})
if self.user.has_confirmed_email:
raise serializers.ValidationError(
{"detail": _("Konto er allerede verifisert")})
return attrs
def post(self, request, uid=None, token=None):
# Get the UserModel
UserModel = get_user_model()
# Decode the uidb64 to uid to get User object
try:
uid = uid_decoder(uid)
user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
user = None
# If we get the User object
if user:
serializer = self.serializer_class(data=request.DATA, user=user)
if serializer.is_valid():
# Construct SetPasswordForm instance
form = SetPasswordForm(user=user, data=serializer.data)
if form.is_valid():
if default_token_generator.check_token(user, token):
form.save()
# Return the success message with OK HTTP status
return Response(
{
"success":
"Password has been reset with the new password."
},
status=status.HTTP_200_OK)
else:
return Response(
{"error": "Invalid password reset token."},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(form._errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"errors": "Couldn\'t find the user from uid."},
status=status.HTTP_400_BAD_REQUEST)
def validate(self, attrs):
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(attrs['uidb64']))
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({'uidb64': _('Invalid value')})
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs['token']):
raise ValidationError({'token': _('Invalid value')})
return attrs
def get(self, request, uidb64=None, token=None):
try:
uid = uid_decoder(uidb64)
user = User._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user = None
person =Person.objects.get(owner=user)
if person.is_email_verified ==True:
return Response({'success':'Email verified successfully'},status=status.HTTP_200_OK)
if user is not None and tg.check_token(user, token):
# profile = Profile.objects.get(owner=user)
person.is_email_verified = True
person.save()
return Response({'success': 'Email verified successfully'}, status=status.HTTP_200_OK)
else:
return Response({'error': ['Invalid email verify token.']},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, uidb64=None, token=None):
# Get the UserModel
UserModel = get_user_model()
# Decode the uidb64 to uid to get User object
try:
uid = uid_decoder(uidb64)
user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
user = None
# If we get the User object
if user:
serializer = self.serializer_class(data=request.data, user=user)
if serializer.is_valid():
person = Person.objects.get(owner=user)
person.is_email_verified = True
person.save()
# Construct SetPasswordForm instance
form = SetPasswordForm(user=user, data=serializer.data)
if form.is_valid():
if tg.check_token(user, token):
form.save()
# Return the success message with OK HTTP status
return Response(
{"success":"Password has been reset with the new password."},
status=status.HTTP_200_OK)
else:
return Response(
{'error': ['Invalid password reset token.']},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(form._errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'error': ['Couldn\'t find the user from uid.']},
status=status.HTTP_400_BAD_REQUEST)
def validate(self, attrs):
self._errors = {}
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(attrs['uid']))
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({'uid': ['Invalid value']})
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
pass
return attrs
def validate(self, attrs):
self._errors = {}
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(attrs["uid"]))
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({"uid": ["Invalid value"]})
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user, data=attrs)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs["token"]):
raise ValidationError({"token": ["Invalid value"]})
return attrs
def validate(self, attrs):
try:
uid = force_text(uid_decoder(attrs["uid"]))
self.user = User.on_site.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
raise serializers.ValidationError({"uid": ["Invalid value"]})
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs["token"]):
raise serializers.ValidationError({"token": ["Invalid value"]})
return attrs
def validate(self, attrs):
self._errors = {}
# Get the UserModel
UserModel = get_user_model()
# Decode the uidb64 to uid to get User object
try:
uid = uid_decoder(attrs['uid'])
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
self._errors['uid'] = ['Invalid value']
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
self._errors['token'] = ['Invalid value']
if not default_token_generator.check_token(self.user, attrs['token']):
self._errors['token'] = ['Invalid value']
def validate(self, attrs):
self._errors = {}
# Get the UserModel
UserModel = get_user_model()
# Decode the uidb64 to uid to get User object
try:
uid = uid_decoder(attrs['uid'])
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
self._errors['uid'] = ['Invalid value']
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
self._errors['token'] = ['Invalid value']
if not default_token_generator.check_token(self.user, attrs['token']):
self._errors['token'] = ['Invalid value']
def mutate(self, info, **kwargs):
try:
uid = force_text(uid_decoder(kwargs.get('id')))
account = AccountProfile.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, AccountProfile.DoesNotExist):
raise Exception('uid has an invalid value')
data = {
'uid': kwargs.get('id'),
'new_password1': kwargs.get('password'),
'new_password2': kwargs.get('password')
}
if token_generator.check_token(account, kwargs.get('token')):
form = SetPasswordForm(user=account, data=data)
if not form.is_valid():
raise Exception(form.errors.as_json())
form.save()
return ResetPassword(ok=True, account=account)
return ResetPassword(ok=False)
def validate(self, attrs):
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(attrs['uidb64']))
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({
'detail': _('Invalid link.'),
"status": status.HTTP_400_BAD_REQUEST}
)
if not default_token_generator.check_token(self.user, attrs['token']):
raise ValidationError({
'detail': _('Invalid link.'),
'status': status.HTTP_400_BAD_REQUEST}
)
self.user.is_verified = True
self.user.verified = timezone.now()
self.user.save()
return attrs
def validate(self, attrs):
self._errors = {}
# Decode the uidb64 to uid to get User object
try:
params = self.context.get('request').query_params
uid = force_text(uid_decoder(params.get('uid')))
self.user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
raise ValidationError({'uid': ['Invalid value']})
self.custom_validation(attrs)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(user=self.user,
data=attrs)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user,
params.get('token')):
raise ValidationError({'token': ['Invalid value']})
return attrs
def validate(self, attrs):
self._errors = {}
# Decode the uidb64 to uid to get User object
try:
uid = force_text(uid_decoder(attrs["uid"]))
self.user = User._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
raise serializers.ValidationError(EXPIRED_LINK_MESSAGE)
# Construct SetPasswordForm instance
self.set_password_form = self.set_password_form_class(
user=self.user,
data={
"new_password1": attrs["new_password"],
"new_password2": attrs["new_password"],
},
)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs["token"]):
raise serializers.ValidationError(EXPIRED_LINK_MESSAGE)
return attrs
def mutate_and_get_payload(cls, input, context, info):
quote = Quote(quote=input.get('quote'),
explanation=input.get('explanation'),
creator=context.user)
author_uuid = input.get('author', None)
external_author = input.get('external_author', None)
if author_uuid:
try:
id = force_text(uid_decoder(author_uuid))
quote.author = get_user_model.objects.get(id=id)
except (TypeError, ValueError, OverflowError):
raise Exception("'author'(ID) must be a valid user ID")
except get_user_model.DoesNotExist:
raise Exception("there is no user with this ID")
elif external_author:
quote.external_author = external_author
else:
raise Exception("you need tu set an 'author' (ID) or an 'external autor' (String)")
quote.save()
return AddQuote(ok=True, quote=quote)
def mutate_and_get_payload(root, info, **input):
Model = UserModel
try:
uid = force_text(uid_decoder(input.get('id')))
user = Model.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, Model.DoesNotExist):
raise Exception('uid has an invalid value')
data = {
'uid': input.get('id'),
'token': input.get('token'),
'new_password1': input.get('password'),
'new_password2': input.get('password')
}
reset_form = SetPasswordForm(user=user, data=data)
if not reset_form.is_valid():
raise Exception("The token is not valid")
reset_form.save()
return ResetPassword(ok=True, user=user)
def mutate_and_get_payload(cls, input, context, info):
Model = UserModel
try:
uid = force_text(uid_decoder(input.get('id')))
user = Model.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, Model.DoesNotExist):
raise Exception('uid has an invalid value')
data = {
'uid': input.get('id'),
'token': input.get('token'),
'new_password1': input.get('password'),
'new_password2': input.get('password')
}
reset_form = SetPasswordForm(user=user, data=data)
if not reset_form.is_valid():
raise Exception("The token is not valid")
reset_form.save()
return ResetPassword(ok=True, user=user)
