class UserSerializer(serializers.ModelSerializer):
# todo needs serious refactoring since UserGetSerializer is more active than UserSerializer
email = EmailField(label='Email Address')
email2 = EmailField(label='Confirm Email')
class Meta:
model = User
# todo refine user fields for signup
fields = (
'id', 'first_name', 'last_name', 'email', 'email2', 'phone', 'password', 'is_blocked', 'createdAt',
'image',
'dob')
read_only = ['id', 'email2']
extra_kwargs = {"password": {"write_only": True}}
def validate_email(self, value):
# user can only register one email address.
# verify that user inserted correct email address
# todo check if email exists by sending welcome message
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_phone(self, value):
# user can only register one phone number
user = User.objects.filter(phone=value)
if user.exists():
raise ValidationError("This user has already registered with the phone number")
return value
def validate(self, data):
return data
def create(self, validated_data):
user = User(
first_name=validated_data['first_name'],
last_name=validated_data['last_name'],
# username is a combination of first and last name
username=validated_data['first_name'] + validated_data['last_name'],
email=validated_data['email'],
# email2 is redundant. however it prevents
# 500 response when user is successfully created
email2=validated_data['email2'],
phone=validated_data['phone'],
is_blocked=validated_data['is_blocked'],
image=validated_data['image'],
dob=validated_data['dob']
)
user.set_password(validated_data['password'])
user.save()
return user
class ContactSerializer(serializers.Serializer):
"""Serializer for contact message."""
VOLUNTEER = 'volunteer'
ORGANIZATION = 'organization'
APPLICANT_CHOICES = (VOLUNTEER, ORGANIZATION)
applicant_type = ChoiceField(APPLICANT_CHOICES, required=True)
applicant_email = EmailField(required=True, max_length=150)
applicant_name = CharField(required=True, min_length=3, max_length=150)
administrator_email = EmailField(
required=True,
validators=[validate_admin_email],
)
message = CharField(required=True, min_length=10, max_length=2000)
phone_no = CharField(max_length=20)
class AdminLoginSerializer(serializers.ModelSerializer):
email = EmailField(label='Email', write_only=True)
znap_id = IntegerField(read_only=True)
class Meta:
model = Admin
fields = [
'id',
'znap_id',
'email',
'password',
]
extra_kwargs = {"password": {"write_only": True}}
def validate(self, data):
admin_obj = None
email = data.get("email", None)
password = data['password']
admin = Admin.objects.filter(email=email)
admin = admin.exclude(email__isnull=True).exclude(email__iexact='')
if admin.exists() and admin.count() == 1:
admin_obj = admin.first()
data['id'] = admin_obj.id
data['znap_id'] = admin_obj.znap_id
else:
raise serializers.ValidationError("This email is not valid")
if admin_obj:
if (password != admin_obj.password):
raise serializers.ValidationError("Incorrect password")
return data
class UserSerializer(serializers.ModelSerializer):
username = CharField(min_length=6, max_length=20)
email = EmailField()
class Meta:
model = User
fields = ('id', 'username', 'email',)
class UserAdminUpdateSerializer(UnknownFieldRaisesExceptionSerializerMixin,
ModelSerializer):
"""
Serializes a request body for updating a given user. Do not use for returning user
data as the password will be returned also.
"""
# Max length set to match django user models first_name fields max length
name = CharField(source="first_name", max_length=30, required=False)
username = EmailField(required=False)
class Meta:
model = User
fields = (
"username",
"name",
"is_active",
"is_staff",
"password",
)
extra_kwargs = {
**_USER_ADMIN_SERIALIZER_API_DOC_KWARGS,
"password": {
"required": False
},
}
class UserCreateSerializer(serializers.HyperlinkedModelSerializer):
first_name = CharField()
last_name = CharField()
email = EmailField(label='Email')
class Meta:
model = User
fields = ['first_name', 'last_name', 'email', '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 serializers.ValidationError("This user has already registered")
return data
def create(self, validated_data):
first_name = validated_data['first_name']
last_name = validated_data['last_name']
email = validated_data['email']
password = validated_data['password']
user_obj = User(
username = email,
first_name = first_name,
last_name = last_name,
email = email,
)
user_obj.set_password(password)
user_obj.save()
return validated_data
class LoginSerializer(serializers.ModelSerializer):
email = EmailField(label='Email Address', required=True, allow_blank=True)
class Meta:
model = UserSignUp
fields = (
'email',
'password',
)
extra_kwargs = {"password": {"write_only": True}}
def validate(self, data):
user_obj = None
email = data.get("email", None)
password = data.get("password", None)
if not email:
raise ValidationError("email is required to login")
user = UserSignUp.objects.filter(email=email, password=password)
if user.exists() and user.count() == 1:
user_obj = user.first()
else:
raise ValidationError("Incorrect credientials, please try again")
return data
class TutorSerializer(serializers.ModelSerializer):
name = CharField(allow_blank=True, max_length=254, required=False)
email = EmailField(allow_blank=True, max_length=254, required=False)
class Meta:
model = Tutor
fields = ('id', 'name', 'room', 'school', 'email')
class CertificateSerializer(serializers.HyperlinkedModelSerializer):
#user = UserSerializer(read_only=True)
user = CharField(source='user.uid', read_only=True)
subject_email = EmailField(source='email', read_only=True)
class Meta:
model = Certificate
fields = ('pk', 'name', 'revoked', 'subject_email', 'user')
class UserRegisterSerializer(ModelSerializer):
email = EmailField(required=True,
max_length=128,
help_text=_('email address'))
class Meta:
model = user_model
fields = ('username', 'first_name', 'last_name', 'email', 'password')
class StartupSerializer(Serializer):
id = IntegerField(read_only=True)
name = CharField(max_length=31)
slug = SlugField(max_length=31)
description = CharField()
founded_date = DateField()
contact = EmailField()
website = URLField(max_length=255)
tags = TagSerializer(many=True)
class SignupSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = ('username', 'password', 'email', 'token', 'stuid', 'stuname')
# read_only_fields = ('token', )
password = CharField(min_length=6,
max_length=100,
label='密码',
required=True)
username = CharField(min_length=3,
max_length=100,
label='用户名',
required=True)
stuid = CharField(max_length=10, label='学号', required=True)
stuname = CharField(max_length=200, label='姓名', required=True)
email = EmailField(label='邮箱', required=True)
token = CharField(read_only=True)
def validate(self, data):
email = data.get('email')
username = data.get('username')
stuid = data.get('stuid')
users = User.objects.all()
for user in users:
if user.email == email:
raise serializers.ValidationError(
'邮箱已经被注册了',
code='email_not_unique',
)
if user.username == username:
raise serializers.ValidationError(
'用户名已经被注册了',
code='username_not_unique',
)
if user.stuid == stuid:
raise serializers.ValidationError(
'这个学号已经被注册了',
code='username_not_unique',
)
return data
def create(self, validated_data):
user = super().create(validated_data)
user.set_password(validated_data['password'])
# 用已经通过数据合法性唯一性校验的用户数据生成token
user.save()
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)
user.token = token
return user
class OrganizationContactSerializer(serializers.Serializer):
"""Serializer for contact message"""
name = CharField(required=True, min_length=2, max_length=150,
trim_whitespace=True)
email = EmailField(required=True)
phone_no = CharField(required=True, min_length=9, max_length=15,
trim_whitespace=True)
message = CharField(required=True, min_length=2, max_length=500,
trim_whitespace=True)
class ResetRequestSerializer(Serializer):
"""POST"""
email = EmailField(write_only=True)
def update(self, user, _validated_data):
user.password_reset_code = randint(100000, 999999)
user.password_reset_request_time = datetime.now()
user.save()
return user
class InvitationSerializer(WritableNestedModelSerializer):
email = EmailField(validators=[
UniqueValidator(queryset=User.objects.all()),
UniqueValidator(queryset=Invitation.objects.all())
])
author = AuthorNameSerializer(required=True, allow_null=False)
class Meta:
model = Invitation
fields = ('email', 'author')
class ContactSerializer(serializers.Serializer):
name = CharField(max_length=150)
email = EmailField()
message = CharField()
if settings.DRF_RECAPTCHA_ENABLED:
recaptcha = ReCaptchaV2Field()
def validate(self, data):
data.pop("recaptcha", None)
return data
class UserSerializer(HalNestedFieldsModelSerializer):
isSuperAdmin = BooleanField(source="is_superuser", read_only=True)
isSuperReader = BooleanField(source="is_staff", read_only=True)
email = EmailField(required=True)
class Meta:
model = get_user_model()
fields = ('id', 'email', 'password', 'first_name', 'last_name',
'isSuperAdmin', 'isSuperReader')
extra_kwargs = {'password': {'write_only': True}}
read_only_fields = ('id', )
class EmailSerializer(serializers.ModelSerializer):
class Meta:
model = Email
fields = '__all__'
email = EmailField()
def validate_email(self, value):
if Email.objects.filter(email=value).exists():
raise ConflictException('Email already exists', 'email',
status.HTTP_409_CONFLICT)
return value
class AddressSerializer(serializers.Serializer):
name = CharField(required=False)
address = EmailField()
def to_representation(self, obj):
return addr_db_to_rest(obj)
def create(self, validated_data):
try:
return [validated_data["name"], validated_data["address"]]
except Exception:
return [validated_data["address"], validated_data["address"]]
class UserAlterSerializerBase(UserSerializerBase):
password = CharField(required=False,
blank=True,
widget=widgets.PasswordInput)
email = EmailField(required=False) # FIXME: help_text
class Meta:
model = User
fields = UserRoLightSerializer.Meta.fields + \
['email_md5', 'date_joined', 'is_active', 'email', 'password',]
read_only_fields = (
'email_md5',
'uuid',
'date_joined',
'is_active',
)
# FIXME: move to to_native()?
@property
def data(self):
data = super(UserAlterSerializerBase, self).data.copy()
del data['password']
return data
def validate_email(self, attrs, source):
value = attrs[source]
if not self.object or value != self.object.email:
if value and User.objects.filter(email__iexact=value).count():
raise serializers.ValidationError("Email not available.")
return attrs
def validate_password(self, attrs, source):
attrs[source] = make_password(attrs[source])
if self.object and attrs[source] == UNUSABLE_PASSWORD:
attrs[source] = self.object.password
return attrs
def validate_name(self, attrs, source):
attrs[source] = blanks_prune(attrs[source])
return attrs
class UserCreateSerializer(serializers.ModelSerializer):
#id = serializers.IntegerField(read_only=False)
email = EmailField(label='Email address')
#email2 = EmailField(label='Confirm Email')
class Meta:
model = User
fields = [
'username',
'email',
'password',
]
extra_kwargs = {'password': {'write_only': True}}
"""def validate(self, data):
email = data['email']
qs_email = User.objects.filter(email=email)
if qs_email.exists():
raise ValidationError("Email already used and registered")
return data"""
"""def email_validation(self, value):
data = self.get_initial()
email = data.get("email2")
email2 = value
if email != email2:
raise ValidationError("Unmatched email")
qs_email = User.objects.filter(email=email)
if qs_email.exists():
raise ValidationError("Email already used and registered")
return value
def email_validation2(self, value):
data = self.get_initial()
email = data.get("email")
email2 = value
if email != email2:
raise ValidationError("Unmatched email")
return value"""
def create(self, validated_data):
"""user = ptaraUsers.objects.create(
username=validated_data['username'],
email = validated_data['email'],
)"""
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(username=username, email=email)
user_obj.set_password(validated_data['password'])
user_obj.save()
return validated_data
class CreateUpdateCompanySerializer(ObjectPermissionsAssignmentMixin,
serializers.ModelSerializer):
email = EmailField(
validators=[UniqueValidator(queryset=User.objects.all())],
required=False)
password = CharField(required=False)
def get_permissions_map(self, created):
current_user = get_object_or_none(
User, email=self.validated_data.get('email'))
return default_perm_map(self.Meta.model.__name__, current_user)
class Meta:
model = Company
fields = (
'email',
'password',
'ref_first_name',
'ref_last_name',
'ref_phone_number',
'company_name',
'company_symbol',
'website',
'address',
)
def create(self, validated_data):
email = validated_data.pop('email')
password = validated_data.pop('password')
user = User.objects.create_company_user(
email=email,
password=password,
)
company = Company.objects.create(user=user, **validated_data)
return company
def update(self, instance, validated_data, **kwargs):
instance.ref_first_name = validated_data.get('ref_first_name',
instance.ref_first_name)
instance.ref_last_name = validated_data.get('ref_last_name',
instance.ref_last_name)
instance.ref_phone_number = validated_data.get(
'ref_phone_number', instance.ref_phone_number)
instance.company_name = validated_data.get('company_name',
instance.company_name)
instance.company_symbol = validated_data.get('company_symbol',
instance.company_symbol)
instance.address = validated_data.get('address', instance.address)
instance.website = validated_data.get('website', instance.website)
instance.save()
return instance
class CustomRegisterSerializer(RegisterSerializer):
email = EmailField(required=True)
password1 = CharField(write_only=True)
password2 = CharField(write_only=True)
def get_cleaned_data(self):
super(CustomRegisterSerializer, self).get_cleaned_data()
return {
'password1': self.validated_data.get('password1', ''),
'password2': self.validated_data.get('password1', ''),
'email': self.validated_data.get('email', ''),
}
class UserLoginSerializer(serializers.ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
username = CharField(allow_blank=True, required=False)
email = EmailField(label='Email Address', allow_blank=True, required=False)
phone = CharField(label='Phone Number', allow_blank=True, required=False)
class Meta:
model = User
fields = [
'username',
'email',
'phone',
'password',
'token',
]
extra_kwargs = {"password": {"write_only": True}}
def validate(self, data):
user_object = None
username = data.get('username', None)
email = data.get('email', None)
phone = data.get('phone', None)
password = data['password']
# User logs in with username, email or phone. Plus password
if username or email or phone:
# Q allows robust filtering,
# distinct returns only one object incase there are duplicates
user = User.objects.filter(
Q(username=username) |
Q(email=email) |
Q(phone=phone)
).distinct()
if user.exists() and user.count() == 1:
user_object = user.first()
if user_object:
if not user_object.check_password(password):
raise ValidationError("Incorrect credentials. Please try again")
else:
raise ValidationError("Login failure. Invalid username, email or phone number.")
data['token'] = create_token(user_object)
print(user_object.image)
data['image'] = user_object.image
data['username'] = user_object.username
data['first_name'] = user_object.first_name
data['last_name'] = user_object.last_name
return data
else:
raise ValidationError("A username, email or phone number is required to login")
class UserSerializer(WritableNestedModelSerializer):
author = AuthorSerializer(required=False, allow_null=True)
password = CharField(write_only=True, required=False)
email = EmailField(write_only=True, required=False)
class Meta:
model = User
fields = ('email', 'username', 'first_name', 'last_name', 'password',
'author')
def create(self, validated_data):
user = User(email=validated_data["email"],
username=validated_data["username"])
user.set_password(validated_data["password"])
user.save()
return user
class UserLoginSerializer(serializers.ModelSerializer):
token = CharField(allow_blank=True, read_only=True)
username = CharField()
email = EmailField()
class Meta:
model = get_user_model()
fields = (
'username',
'email',
'password',
'token',
)
extra_kwargs = {'password': {'write_only': True}}
def validate(self, data):
return data
class PasswordResetSerializer(serializers.Serializer):
email = EmailField()
def validate_email(self, value):
user = models.User.objects.filter(email=value).first()
self.object = user
if not user:
raise serializers.ValidationError('Email not found')
if not user.is_active:
raise serializers.ValidationError('User is inactive')
if not user.email_is_verified:
raise serializers.ValidationError('Email is not verified')
return value
class CommitSerializer(serializers.ModelSerializer):
_id = ObjectIdField()
modifiedFiles = serializers.SerializerMethodField()
user = CharField(max_length=128)
hashID = CharField(max_length=40)
email = EmailField()
date = DateTimeField()
message = CharField(max_length=510)
class Meta:
model = Commit
exclude = ('_id', )
def get_modifiedFiles(self, obj):
resources_serializer = ModifiedFilesSerializer(obj.modifiedFiles,
many=True)
return resources_serializer.data
class ProfileSerializer(ModelSerializer):
id = UUIDField(source="pk")
email = EmailField(source="user.email")
first_name = CharField(source="user.first_name", max_length=30)
last_name = CharField(source="user.last_name", max_length=150)
class Meta:
model = Profile
fields = [
"id",
"first_name",
"last_name",
"email",
"phone_number",
"street_address",
"date_of_birth",
"city",
"postal_code",
"contact_language",
]
@transaction.atomic
def create(self, validated_data):
_logger.info("Creating a new profile")
user = get_user_model().objects.create(**validated_data.pop("user"))
profile = Profile.objects.create(user=user, **validated_data)
_logger.info(f"Profile {profile.pk} created")
return profile
@transaction.atomic
def update(self, instance, validated_data):
_logger.info(f"Updating profile {instance.pk}")
user = instance.user
user_data = validated_data.pop("user", {})
for attr, value in user_data.items():
setattr(user, attr, value)
user.save()
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
_logger.info(f"Profile {instance.pk} updated")
return instance
class CreateResponseSerializer(Serializer):
profile_id = CharField()
password = CharField()
class UserSerializer(ModelSerializer):
email = EmailField(label='Email')
password2 = CharField(label='Confirm Password',
style={'input_type': 'password'},
write_only=True)
class Meta:
model = User
fields = ('id', 'first_name', 'last_name', 'username', 'email',
'password', 'password2')
extra_kwargs = {
"password": {
"write_only": True,
"style": {
'input_type': 'password'
}
}
}
def validate(self, data):
password1 = data.get('password')
password2 = data.get('password2')
if password1 != password2:
raise ValidationError('Password Not Matched!')
email = data['email']
user_qs = User.objects.filter(email=email)
if user_qs.exists():
raise ValidationError('This user is already registered!')
return data
def create(self, validated_data):
first_name = validated_data['first_name']
last_name = validated_data['last_name']
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
password2 = validated_data['password2']
user_obj = User(
first_name=first_name,
last_name=last_name,
username=username,
email=email,
)
user_obj.set_password(password and password2)
user_obj.save()
return validated_data