class UserCreateSerializer(ModelSerializer):
email = EmailField(label="Email Address")
email2 = EmailField(label="Confirm email")
class Meta:
model = User
fields = [
'username',
'email',
'email2',
'password',
]
#Setting the password to write only
extra_kwargs = {"password": {"write_only": True}}
#checking if email exists, General validation
def validate(self, data):
# email = data['email']
# user_qs = User.objects.filter(email = email)
# if user_qs.exists():
# raise ValidationError("This user has already registered")
return data
#validating email1
def validate_email(self, value):
data = self.get_initial()
email1 = data.get("email2")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
# Checking if email exists
user_qs = User.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError("This user has already registered")
return value
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
return value
#overwrite the create() method
def create(self, validated_data):
print validated_data #a dictionary
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
#create an isntance of the object and save it
user_obj = User(username=username, email=email)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label="Email")
email2 = EmailField(label="Re-type Email")
#password2 = CharField(label="Re-type Password", style={'input_type': 'password'})
class Meta:
model = User
fields = [
'username',
'email',
'email2',
'password',
#'password2',
]
extra_kwargs = {
"password":
{"write_only":True},
# "password2":
# {"write_only": True}
}
# def validate_email(self, value):
# data = self.get_initial()
# email = data.get("email")
# user_em = User.objects.filter(email=email)
# if user_em.exists():
# raise ValidationError("This Email already exists.")
# return value
def validate_username(self, value):
data = self.get_initial()
username = data.get("username")
user_un = User.objects.filter(username=username)
if user_un.exists():
raise ValidationError("This Username already exists.")
return value
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match!")
return value
#
# def validate_password2(self, value):
# data = self.get_initial()
# password = data.get("password")
# password2 = value
# if password != password2:
# raise ValidationError("Passwords must match!")
def create(self, validated_data):
# print(validated_data)
username = validated_data["username"]
email = validated_data["email"]
password = validated_data["password"]
user_obj = User(username=username, email=email)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
confirm_email = EmailField(label='Confirm Email')
class Meta:
model = User
fields = [
'username',
'email',
'confirm_email',
'password',
]
extra_kwargs = {"password": {"write_only": True}}
def validate_email(self, value):
data = self.get_initial()
email = data.get('confirm_email')
email_2 = value
if email != email_2:
raise ValidationError("Email must match")
user_query = User.objects.filter(email=email)
print(user_query)
if user_query:
raise ValidationError("This user has already registered")
return value
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(username=username, email=email)
user_obj.set_password(password)
user_obj.save()
return validated_data
class CadastroUsuarioSerializer(ModelSerializer):
email = EmailField(label='email')
email_confirma = EmailField(label='confirme email')
class Meta:
model = User
fields = [
'first_name', 'last_name', 'username', 'email', 'email_confirma',
'password'
]
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
senha = validated_data['password']
email_confirma = validated_data['email_confirma']
if User.objects.filter(username=username).exists():
raise ValidationError("Informar outro username")
if User.objects.filter(email=email).exists():
raise ValidationError("Email já associado a um usuário cadastrado")
if email != email_confirma:
raise ValidationError("Os emails digitados são diferentes")
usuario_novo = User(username=username, email=email)
usuario_novo.set_password(senha)
usuario_novo.first_name = validated_data['first_name']
usuario_novo.last_name = validated_data['last_name']
usuario_novo.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email')
email2 = EmailField(label='Confirm Email')
class Meta:
model = User
fields = ['username', 'email', 'email2', 'password']
extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
email = data['email']
user = User.objects.filter(email=email)
if user.exists():
raise ValidationError('User with this email already exists.')
return data
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get('email')
email2 = value
if email1 != email2:
raise ValidationError('Emails must match.')
return value
def create(self, validated_data):
username = validated_data['username']
password = validated_data['password']
email = validated_data['email']
user_obj = User(username=username, email=email)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email')
class Meta:
model = User
fields = [
'username',
'email',
'email2',
'password',
]
extra_kwargs = {
"password": {
"write_only": True
}
} #means when password is not seen in json format
# def validate(self, data):
# return data
#there are two email so i need to validate that
#for email first
def validate_email(self, value):
# value = actual value passed to email
data = self.get_initial() #give the initial data that have been passed
email1 = data.get("email2")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
user_qs = User.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError("This user has already registered.")
return value
#for email2
def validate_email2(self, value):
data = self.get_initial(
) #to show validatoin error in email confirm i need email
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
return value
#overriding create builtin method
def create(
self, validated_data
): #this logic is also akin to the normal register but we are using validate_data
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(username=username, email=email)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email') # serializers.EmailField()
class Meta:
model = User
fields = [
'username',
'email',
'email2',
'password',
]
# not show password on api page
extra_kwargs = {"password": {"write_only": True}}
# validate Email
def validate(self, data):
email = data['email']
user_qs = User.objects.filter(email=email)
if user_qs:
raise ValidationError("This user has already registered.")
return data
def validate_email(self, value):
data = self.get_initial()
email = value
email2 = data.get("email2")
user_qs = User.objects.filter(email=email)
if user_qs:
raise ValidationError("This user has already registered.")
if email != email2:
raise ValidationError("Emails must match")
return value
def validate_email2(self, value):
data = self.get_initial()
email = data.get("email")
email2 = value
if email != email2:
raise ValidationError("Emails must match")
return value
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(
username=username,
email=email,
)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email')
class Meta:
model = User
fields = [
'username',
'email',
'email2',
'password',
]
extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
#email = data['email']
#user_qs = User.objects.filter(email=email)
#if user_qs.exists():
# raise ValidationError("This user has already registered.")
return data
def validate_email(self, value):
data = self.get_initial()
email1 = data.get("email2")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
user_qs = User.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError("This user has already registered.")
return value
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
return value
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(
username=username,
email=email,
)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
email = EmailField(label='Email Address', write_only=True)
email2 = EmailField(label='Confirm Email', write_only=True)
class Meta:
model = User
fields = [
'username',
'token',
'email',
'email2',
'password',
]
extra_kwargs = {"password": {"write_only": True}}
def validate(self, data):
# email = data['email']
# user_qs = User.objects.filter(email=email)
# if user_qs.exists():
# raise ValidationError("This user has already registered.")
return data
def validate_email(self, value):
data = self.get_initial()
email1 = data.get("email2")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
user_qs = User.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError("This user has already registered.")
return value
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
return value
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(username=username, email=email)
user_obj.set_password(password)
# user_obj.active = False
# send activation email
user_obj.save()
payload = jwt_payload_handler(user_obj)
token = jwt_encode_handler(payload)
validated_data['token'] = token
return validated_data
class UserCreateUpdateDestroySerializer(ModelSerializer):
email = EmailField(label='Email')
email2 = EmailField(label='Confirm Email')
class Meta:
model = User
fields = [
'username',
'first_name',
'last_name',
'email',
'email2',
'password',
]
extra_kwargs = {"password": {"write_only": True}}
def validate_email(self, value):
data = self.get_initial()
email1 = data.get('email2')
email2 = value
if email1 != email2:
raise ValidationError('Emails must match')
user_qs = User.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError('This user has already registered')
return value
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get('email')
email2 = value
if email1 != email2:
raise ValidationError('Emails must match')
return value
def create(self, validated_data):
username = validated_data['username']
first_name = validated_data['first_name']
last_name = validated_data['last_name']
email = validated_data['email']
password = validated_data['password']
user_obj = User(username=username,
email=email,
first_name=first_name,
last_name=last_name,
is_staff=True)
group = Group.objects.get(name='authors')
user_obj.save()
user_obj.groups.add(group)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email Address')
class Meta:
model = User
fields = ('pk', 'username', 'password', 'email', 'email2', 'first_name', 'last_name')
extra_kwargs = {"password":
{"write_only": True},
"pk":
{"read_only": True},
}
def validate(self,data):
print('validated data is', data)
return data
def validate_email(self,value):
data = self.get_initial() # intial gives the initial data that been passed
email1 = data.get("email2")
email2 = value
if email1 != email2:
raise ValidationError('Emails must match')
user_qs = User.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError('This user has already registered')
return value
def validate_email2(self,value):
data = self.get_initial()
print('get initial', data)
email1 = data.get('email')
email2 = value
if email1 != email2:
raise ValidationError('emails must match')
return value
"""
create and return a new 'user' instance, given the validated data
"""
def create(self, validated_data):
print('validated_data',validated_data)
username = validated_data['username']
first_name = validated_data['first_name']
last_name = validated_data['last_name']
email = validated_data['email']
email2 = validated_data['email2']
password = validated_data['password']
user_obj = User.objects.create(
username=username,
email=email,
first_name=first_name,
last_name=last_name
)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email')
class Meta:
model = User
fields = (
'username',
'email',
'email2',
'password',
)
extra_kwargs = {'password':
{'write_only': True}
}
# def validate(self, data):
#
# email = data['email']
# user = User.object.filter(email=email)
# if user.exists():
# raise ValidationError("user already exists")
# return data
def validate_email(self, value):
data = self.initial_data
email2 = data['email2']
email = value
user = User.objects.filter(email=email)
if user.exists():
raise ValidationError("user already exists")
if email != email2:
raise ValidationError("Email must match")
return value
def validate_email2(self, value):
data = self.initial_data
email = data['email']
email2 = value
if email != email2:
raise ValidationError("Email must match")
return value
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(
email=email, username=username
)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
email = EmailField(label="Email Address", write_only=True)
email2 = EmailField(label="Confirm Email", write_only=True)
class Meta:
model = User
fields = [
"username",
"token",
"email",
"email2",
"password",
]
extra_kwargs = {"password": {"write_only": True}}
# def validate(self, data):
# email = data['email']
# user_qs = User.objects.filter(email=email2)
# if user_qs.exists():
# raise ValidationError("This email already used.")
# return data
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
user_qs = User.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError("This email already used.")
return value
def create(self, validated_data):
username = validated_data["username"]
email = validated_data["email"]
password = validated_data["password"]
user_obj = User(
username=username,
email=email,
)
user_obj.set_password(password)
user_obj.save()
payload = jwt_payload_handler(user_obj)
token = jwt_encode_handler(payload)
validated_data['token'] = token
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email address')
# overrides default nature of email being an optional field while user registration,now it's a
# mandatory field
email2 = EmailField(label='Confirm Email address')
class Meta:
model = User
fields = [
'username',
'email',
'email2',
'password',
]
extra_kwargs = {
"password":{
"write_only": True
}
}
def validate(self, data):
email = data['email']
user_qs = User.objects.filter(email=email)
if user_qs.exists():
raise ValidationError('A user with this email has already been registered.')
return data
def validate_email2(self, value): # raise a validation error only for email2 field
data = self.get_initial() # get initially filled data,whether validated or not
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError('Emails donot match!')
return value
def create(self, validated_data):
print "%s" % validated_data
username = validated_data['username']
password = validated_data['password']
email = validated_data['email']
user_obj = User(
username=username,
email=email
)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email')
class Meta:
model = MyUser
fields = [
'username', 'email', 'email2', 'password', 'date_of_birth',
'gender', 'height', 'weight', 'user_sight', 'user_hearing',
'user_touch'
]
extra_kwargs = {"password": {"write_only": True}}
def validate(self, data):
email = data['email']
user_qs = MyUser.objects.filter(email=email)
if user_qs.exists():
raise ValidationError("This user has already registered.")
return data
def validate_email(self, value):
data = self.get_initial()
email1 = data.get("email2")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
user_qs = MyUser.objects.filter(email=email2)
if user_qs.exists():
raise ValidationError("This user has already registered.")
return value
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get("email")
email2 = value
if email1 != email2:
raise ValidationError("Emails must match.")
return value
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = MyUser(username=username, email=email)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserCreateSerializer(ModelSerializer):
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email')
class Meta:
model = User
fields = [
'username',
'email',
'email2',
'password',
]
# this is to prevent us from seeing the password
extra_kwargs = {'password': {'write_only': True}}
def validate_email(self, value):
data = self.get_initial()
email2 = data.get('email2')
email1 = value
if email2 != email1:
raise ValidationError('Emails must match. ')
user_qs = User.objects.filter(email=email1)
if user_qs.exists():
raise ValidationError('This user has been registered. ')
return value
""" we are validating the email2 """
def validate_email2(self, value):
data = self.get_initial()
email1 = data.get('email')
email2 = value
if email1 != email2:
raise ValidationError('Emails must match. ')
return value
""" in here we are getting the validated data before we create the user"""
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(
username=username,
email=email,
)
user_obj.set_password(password)
user_obj.save()
return validated_data
class UserSerializer(serializers.ModelSerializer):
email = EmailField(label='Email Address')
class Meta:
model = User
fields = ('username', 'email', 'password')
extra_kwargs = {'password': {'write_only': True}}
def create(self, validated_data):
user = User(email=validated_data['email'],
username=validated_data['username'])
user.set_password(validated_data['password'])
user.save()
Token.objects.create(user=user)
return user
def validate(self, data):
# email = data['email']
# username = data['username']
# user_qs = User.objects.filter(
# email=email) or User.objects.filter(username=username)
# if user_qs.exists():
# raise ValidationError("This user has already registered.")
return data
class CompanySerializer(ModelSerializer):
required = True
name = CharField(source='first_name')
email = EmailField(
source='username',
validators=[UniqueValidator(queryset=User.objects.all())])
password = CharField(
write_only=True,
required=True,
style={'input_type': 'password'},
)
class Meta:
model = User
fields = [
'id',
'name',
'email',
'profile_image',
'password',
]
def create(self, validated_data):
"""
If profile image is not provided,
removing the field from the dictionary,
so that default image is used.
"""
if 'profile_image' in validated_data and validated_data[
'profile_image'] == None:
del validated_data['profile_image']
return User.objects.create_user(**validated_data, is_company=True)
class UserLoginSerializer(ModelSerializer):
email = EmailField(label='Email')
class Meta:
model = User
fields = ('email', 'password', 'id')
extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
user_obj = None
response = {}
email = data.get('email', None)
password = data.get('password', None)
# Fetching user with email
user = User.objects.filter(Q(email=email)).first()
if user:
# User exists
user_obj = user
else:
# User does not exist
response['message'] = "This email is not registered."
raise ValidationError(response)
if user_obj:
# Checking password is correct or not
if not user_obj.check_password(password):
# Incorrect password
response['message'] = "Password is incorrect."
raise ValidationError(response)
data['id'] = user_obj.id
return data
class UserSerializer(ModelSerializer):
id = IntegerField(required=False)
email = EmailField(required=False)
first_name = CharField(required=False)
last_name = CharField(required=False)
account = AccountSerializer(many=False, required=False)
def create(self, validated_data):
# Create user
try:
account = validated_data.pop('account')
except:
# Well d'oh.
pass
user = auth_models.User.objects.create(**validated_data)
return user
class Meta:
model = auth_models.User
fields = [
'id', 'username', 'email', 'first_name', 'last_name', 'account'
]
class UserLoginSerializer(serializers.ModelSerializer):
email = EmailField(label='Email')
password = CharField(write_only=True, style={'input_type': 'password'})
class Meta:
model = User
fields = ('email', 'password')
# extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
user_obj = None
email = data.get("email", None)
password = data["password"]
if not email:
raise exceptions.ValidationError('Email is required to login')
user = User.objects.filter(email=email)
if user.exists():
user_obj = user.first() #gives email
else:
raise exceptions.ValidationError('Email is not valid')
if user_obj:
if not user_obj.check_password(password):
raise ValidationError("Incorrect credentials")
return data
class UserLoginSerializer(ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
username = CharField(required=False, allow_blank=True)
email = EmailField(required=False, allow_blank=True)
class Meta:
model = User
fields = ['username', 'email', 'password', 'token']
extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
user_obj = None
username = data.get('username', None)
email = data.get('email', None)
password = data['password']
if not username and not email:
raise ValidationError('Username o Email es obligatorio para Login')
user = User.objects.filter(Q(email=email)
| Q(username=username)).distinct()
if user.exists() and user.count() == 1:
user_obj = user.first()
else:
raise ValidationError('El usuario o email no es valido.')
if user_obj:
if not user_obj.check_password(password):
raise ValidationError(
'Credenciales invalidas, intentelo de nuevo.')
data['token'] = 'ALGUN TOKEN'
return data
class UserLoginSerializer(ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
username = CharField(required=False, allow_blank=True)
email = EmailField(required=False, allow_blank=True)
class Meta:
model = User
fields = [
'email',
'username',
'password',
'token',
]
extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
email = data.get('email')
username = data.get('username')
password = data["password"]
if not email and not username:
raise ValidationError("A username or email is required to login.")
user = User.objects.filter(Q(email=email)
| Q(username=username)).distinct()
user = 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
class UserLoginSerializer(ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
username = CharField(required=False, allow_blank=True)
email = EmailField(label="Email Address", required=False, allow_blank=True)
class Meta:
model = User
fields = ['username', 'email', 'password', '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')
if not email and not username:
raise ValidationError("A username or email is required to login")
user = User.objects.filter(Q(email=email)
| Q(username=username)).distinct()
user = user.exclude(email__isnull=True).exclude(email__iexact='')
if user.exists() and user.count() == 1:
user_obj = user.first()
else:
raise ValidationError("This username or Email is not valid")
if user_obj:
if not user_obj.check_password(password):
raise ValidationError("Incorrect Credential please try again")
data["token"] = ObtainJSONWebToken()
return data
class UserLoginSerializer(ModelSerializer):
username = CharField(required=False, allow_blank=True)
email = EmailField(label='Email Address')
password = CharField(style={'input_type': 'password'},
label='Password',
write_only=True)
token = CharField(allow_blank=True, read_only=True)
class Meta:
model = User
fields = ['username', 'email', 'password', 'token']
extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
username = data.get('username', None)
email = data.get('email', None)
password = data['password']
if not username and not email:
raise ValidationError(
"A username or email must be needed to login")
user_obj = User.objects.filter(Q(username=username)
| Q(email=email)).distinct()
print(user_obj)
user_obj = user_obj.exclude(email__isnull=True).exclude(
email__iexact="")
if user_obj.exists() and user_obj.count() == 1:
user = user_obj.first()
if not user.check_password(password):
raise ValidationError(
"Invalid credentials for typing the password please try again."
)
data['token'] = "SOME DATA TOKEN"
else:
raise ValidationError("User not found.")
return data
class PasswordResetSerializer(Serializer):
"""
Serializer for requesting a password reset e-mail.
"""
email = EmailField()
password_reset_form_class = ResetPasswordForm
def get_email_options(self):
"""Override this method to change default e-mail options"""
return {}
def validate_email(self, value):
# Create PasswordResetForm with the serializer
self.reset_form = self.password_reset_form_class(
data=self.initial_data)
if not self.reset_form.is_valid():
raise ValidationError(self.reset_form.errors)
return value
def save(self):
request = self.context.get('request')
# Set some values to trigger the send_email method.
opts = {
'use_https': request.is_secure(),
'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'),
'request': request,
}
opts.update(self.get_email_options())
self.reset_form.save(**opts)
class UserCreateSerializer(ModelSerializer):
email = EmailField()
first_name = CharField()
last_name = CharField()
confirm_password = CharField()
class Meta:
model = User
fields = (
'id',
'username',
'first_name',
'last_name',
'email',
'password',
'confirm_password',
)
def create(self, validated_data):
user = User(username=validated_data['username'],
email=validated_data['email'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name'])
user.set_password(validated_data['password'])
user.save()
return validated_data
def validate_confirm_password(self, value):
password = self.get_initial().get('password')
if password != value:
raise ValidationError('Confirm password do not match.')
return value
class UserUpdateSerializer(ModelSerializer):
email = EmailField(label='email')
class Meta:
model = User
fields = [
'email',
'password',
]
extra_kwargs = {"password": {"write_only": True}}
# why wee need this so after the the user submit their data
# those data don't appear (password)
def validate(self, data):
if len(data['password']) < 8:
raise ValidationError({"password": "******"})
email = data['email']
user_id = self.context['request'].user.id
print(email, user_id)
user_queryset = User.objects.filter(email=email).exclude(id=user_id)
if user_queryset.exists():
raise ValidationError(
{"user": "******"})
return data
def create(self, validate_data):
#username = validate_data['username']
email = validate_data['email']
password = validate_data['password']
user_obj = User.objects.get(id=self.context['request'].user.id)
#user_obj.username = username
user_obj.email = email
user_obj.set_password(password)
user_obj.save()
return validate_data
class UserLoginSerializer(ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
username = CharField(required=False, allow_blank=True)
email = EmailField(label='Email Address', required=False, allow_blank=True)
class Meta:
model = User
fields = (
'username',
'email',
'password',
'token'
)
extra_kwargs = {'password':
{'write_only': True}
}
def validate(self, data):
user_obj = None
username = data['username']
email = data['email']
password = data['password']
if not email and not username:
raise ValidationError("Username or Email is required.")
user = User.objects.filter(Q(email=email) | Q(username=username)).distinct()
user = 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 user_obj.check_password(password):
raise ValidationError("The password is not valid.")
data['token'] = "token"
return data
class AuthorSignupSerializer(ModelSerializer):
email = EmailField(label="Email Address")
class Meta:
model = User
fields = [
'first_name',
'last_name',
'username',
'email',
'password',
]
extra_kwargs = {
"password": {
"write_only": True
}
}
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(
username=username,
email=email,
first_name=validated_data['first_name'],
last_name=validated_data['last_name']
)
user_obj.set_password(password)
user_obj.save()
role = Role.objects.filter(name='author').first()
if not role:
raise ValidationError("Something went wrong")
role.users.add(user_obj)
return validated_data
