class RepositorySerializer(ModelSerializer):
pulp_href = DetailIdentityField(
view_name_pattern=r"repositories(-.*/.*)-detail")
versions_href = RepositoryVersionsIdentityFromRepositoryField()
latest_version_href = LatestVersionField()
name = serializers.CharField(
help_text=_("A unique name for this repository."),
validators=[UniqueValidator(queryset=models.Repository.objects.all())],
)
description = serializers.CharField(
help_text=_("An optional description."),
required=False,
allow_null=True)
remote = DetailRelatedField(
view_name_pattern=r"remotes(-.*/.*)-detail",
queryset=models.Remote.objects.all(),
required=False,
allow_null=True,
)
def validate_remote(self, value):
if value and type(value) not in self.Meta.model.REMOTE_TYPES:
raise serializers.ValidationError(
detail=_("Type for Remote '{}' does not match Repository."
).format(value.name))
return value
class Meta:
model = models.Repository
fields = ModelSerializer.Meta.fields + (
"versions_href",
"latest_version_href",
"name",
"description",
"remote",
)
class UserSerializer(serializers.ModelSerializer):
"""Serializer for the User model."""
email = serializers.EmailField(
required=True,
max_length=150,
allow_blank=False,
validators=[
validate_email,
UniqueValidator(queryset=User.objects.all())
])
class Meta:
"""Metadata for the serializer."""
model = User
fields = ('uuid', 'username', 'email', 'password')
extra_kwargs = {
'password': {
'write_only': True,
'required': False,
'style': {
'input_type': 'password'
},
'max_length': 128,
'allow_null': False
}
}
@transaction.atomic
def create(self, validated_data):
"""Create a user from validated data."""
user = _create_user(username=validated_data.get('username'),
email=validated_data.get('email'),
password=validated_data.get('password'))
return user
class UserSerializer(serializers.ModelSerializer):
first_name = serializers.CharField()
last_name = serializers.CharField(write_only=True)
email = serializers.EmailField(validators=[
UniqueValidator(User.objects.all(), _("User already registered."))
])
role = serializers.CharField()
phone_number = serializers.CharField(max_length=128, required=False)
password = serializers.CharField(write_only=True)
def create(self, validated_data):
role = validated_data.pop('role', 'employee')
password = validated_data.pop('password', None)
if not password:
raise ValidationError({'password': _("This is a required field.")})
user = super().create(validated_data)
user.role = role
user.set_password(password)
user.save()
return user
def update(self, instance, validated_data):
role = validated_data.pop('role', 'employee')
password = validated_data.pop('password', None)
user = super().update(instance, validated_data)
if password:
user.set_password(password)
user.save()
if role:
user.role = role
return user
class Meta:
model = User
fields = ('id', 'first_name', 'phone_number', 'last_name', 'role',
'email', 'is_active', 'password')
class UserRegSerializer(serializers.ModelSerializer):
'''
用户注册
'''
#验证用户名是否存在
username = serializers.CharField(label="用户名",
help_text="用户名",
required=True,
allow_blank=False,
validators=[
UniqueValidator(
queryset=User.objects.all(),
message="用户已经存在")
])
# 输入密码的时候不显示明文
password = serializers.CharField(style={'input_type': 'password'},
label=True,
write_only=True)
# 密码加密保存
def create(self, validated_data):
user = super(UserRegSerializer,
self).create(validated_data=validated_data)
user.set_password(validated_data["password"])
user.save()
return user
# 所有字段。attrs是字段验证合法之后返回的总的dict
def validate(self, attrs):
#前端没有传mobile值到后端，这里添加进来
attrs["mobile"] = attrs["username"]
#code是自己添加得，数据库中并没有这个字段，验证完就删除掉
return attrs
class Meta:
model = User
fields = ('username', 'mobile', 'password')
class UserSerializer(serializers.ModelSerializer):
account = serializers.HyperlinkedRelatedField(
required=False,
read_only=True,
view_name='Account-detail',
)
email = serializers.EmailField(
# This requires the email to be submitted
# since the default dosn't require one.
allow_blank=False,
validators=[UniqueValidator(queryset=User.objects.all())])
password = serializers.CharField(
# This protects the password from ever being
# returned over a request.
write_only=True, )
class Meta:
model = User
fields = ('id', 'username', 'email', 'password', 'account')
read_only_fields = ('account', )
def create(self, validated_data):
# Automatically populate all the data into their
# matching fields.
user = User.objects.create(**validated_data)
# This step will use the provided .set_password
# method to hash and store the user password.
user.set_password(validated_data['password'])
user.save()
# In this step we create the corresponding
# account profile for this user.
Account.objects.create(user=user)
return user
class AccountSerializer(serializers.ModelSerializer):
username = serializers.CharField(required=True,
validators=[UniqueValidator(queryset=Account.objects.all())])
password = serializers.CharField(min_length=8,
write_only=True,
required=True)
class Meta:
model = Account
fields = ['id', 'username', 'password', 'followed_genres', 'followed_artists']
def create(self, validated_data):
username = validated_data.get('username', None)
password = validated_data.get('password', None)
if username and password:
user_account = Account.objects.create_user(username=username)
user_account.set_password(password)
user_account.save()
else:
raise serializers.ValidationError('A username and password is required to sign up')
return user_account
def update(self, instance, validated_data):
password = validated_data.get('password', None)
if password:
instance.set_password(password)
followed_genres = validated_data.get('followed_genres', [])
if followed_genres:
instance.followed_genres.set(followed_genres)
followed_artists = validated_data.get('followed_artists', [])
if followed_artists:
instance.followed_artists.set(followed_artists)
instance.save()
return instance
class UserSignUpSerializer(serializers.Serializer):
email = serializers.EmailField(
validators=[UniqueValidator(queryset=User.objects.all())])
password = serializers.CharField(validators=[validate_password])
username = serializers.CharField()
full_name = serializers.CharField()
phone_number = serializers.IntegerField(validators=[phone_number_check])
address = serializers.CharField(required=False)
city = serializers.CharField(required=False)
state = serializers.CharField(required=False)
country = serializers.CharField(required=False)
pincode = serializers.CharField(validators=[validate_pincode])
def validate(self, attrs):
password = attrs.get('password')
if password:
obj = password_check(password)
if obj:
return attrs
else:
return False
def create(self, validated_data):
user = User()
user.email = validated_data.get('email')
user.password = make_password(validated_data.get('password'))
user.username = validated_data.get('username')
user.full_name = validated_data.get('full_name')
user.phone = validated_data.get('phone_number')
user.address = validated_data.get('address')
user.city = validated_data.get('city')
user.state = validated_data.get('state')
user.country = validated_data.get('country')
user.pincode = validated_data.get('pincode')
user.save()
return user
class SignupSerializer(serializers.ModelSerializer):
email = serializers.EmailField(
required=True,
validators=[UniqueValidator(queryset=User.objects.all())]
)
password = serializers.CharField(
write_only=True, required=True, validators=[validate_password])
password2 = serializers.CharField(write_only=True, required=True)
class Meta:
model = User
fields = ('username', 'email', 'password',
'password2', 'first_name', 'last_name')
write_only_fields = ('password',)
extra_kwargs = {
'first_name': {'required': False},
'last_name': {'required': False}
}
def validate(self, attrs):
if attrs['password'] != attrs['password2']:
raise serializers.ValidationError(
{'password': '******'})
return attrs
def create(self, validated_data):
user = User.objects.create(
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 user
class UserRegSerializer(serializers.ModelSerializer):
code = serializers.CharField(max_length=4, min_length=4, label="验证码", write_only=True,
required=True,
error_messages={
'required': "请输入验证码",
'blank': "请输入验证码",
'max_length': "验证码格式错误",
'min_length': "验证码格式错误",
})
username = serializers.CharField(max_length=20, label="用户名",
validators=[UniqueValidator(queryset=User.objects.all(), message="用户名已使用")],
required=True, allow_blank=False)
password = serializers.CharField(required=True, style={'input_type': 'password'}, label='密码',write_only=True)
# style = {'input_type': 'password'} 前端就会直接把密码 给 挡住
def validated_code(self, code):
# initial_data 前端form 传送过来的数据都放在这里面 我们就直接使用 debug
verify_record = VerifyCode.objects.filter(mobile=self.initial_data['username']).order_by('-add_time')
if verify_record:
last_records = verify_record[0] # 获取最后一条 最新的
five_mintes_ago = datetime.now() - timedelta(minutes=5)
if five_mintes_ago > last_records.add_time:
raise serializers.ValidationError("验证码过期")
if last_records.code != code:
raise serializers.ValidationError("验证码错误")
else:
raise serializers.ValidationError("验证码错误")
def validate(self, attrs):
attrs['mobile'] = attrs['username']
del attrs['code']
return attrs
class Meta:
model = User
fields = ["username", "mobile", 'code', 'password']
class InterfaceModelSerializer(serializers.ModelSerializer):
name = serializers.CharField(
label='接口名称',
max_length=200,
min_length=6,
help_text='接口名称',
# validators中的验证器会全部执行，如果抛异常，则不执行单字段验证器和联合字段验证器
validators=[
UniqueValidator(queryset=Interfaces.objects.all(),
message='接口名称不可重复')
],
error_messages={
'max_length': '长度不超过200字节',
'min_length': '长度不小于6字节',
})
project_id = serializers.PrimaryKeyRelatedField(
label="Project ID", queryset=Projects.objects.all())
project = serializers.StringRelatedField(label='所属项目')
class Meta:
model = Interfaces
# fields = "__all__"
fields = ("id", "project", "project_id", "name", "tester", "desc",
"create_time")
# exclude = ("is_delete", "update_time")
read_only_fields = ("create_time", )
def create(self, validated_data):
project = validated_data.pop("project_id")
validated_data["project"] = project
return Interfaces.objects.create(**validated_data)
def update(self, instance, validated_data):
if 'project_id' in validated_data:
project = validated_data.pop("project_id")
validated_data["project"] = project
return super().update(instance, validated_data)
class ProjectSerializer(serializers.ModelSerializer):
add_time = serializers.DateTimeField(format="%Y-%m-%d",
read_only=True,
default='')
owner = serializers.CharField(label="创建者",
help_text="创建者",
read_only=True,
default='测试创建人')
name = serializers.CharField(label="项目名",
help_text="项目名",
required=True,
validators=[
UniqueValidator(
queryset=Project.objects.all(),
message="用户已经存在")
])
detail = serializers.CharField(label="项目简述",
help_text="项目简述",
required=False)
# def create(self, validated_data):
# pass
# def validate_name(self, name):
# if len(name) <1:
# raise serializers.ValidationError('名字过短')
# return name
#
# def validate(self, attrs):
# attrs['order_sn'] = generate_order_sn()
# del attrs['test'] # 删除在model中没有的字段
# return attrs
class Meta:
model = Project
fields = '__all__'
class CollectionSerializer(serializers.ModelSerializer):
"""
Common serializer for all Collection actions
"""
mission = AsymetricRelatedField.from_serializer(MissionSerializer,
kwargs={'required': True})
title = serializers.CharField(required=True)
alt_title = serializers.CharField(allow_blank=True)
description = serializers.CharField(allow_blank=True)
recording_context = serializers.CharField(allow_blank=True)
recorded_from_year = serializers.CharField(allow_blank=True,
required=False)
recorded_to_year = serializers.CharField(allow_blank=True, required=False)
year_published = serializers.IntegerField(allow_null=True, required=False)
location_details = serializers.CharField(allow_blank=True)
cultural_area = serializers.CharField(allow_blank=True)
language = serializers.CharField(allow_blank=True)
# publisher_collection = serializers.CharField(required=False)
booklet_author = serializers.CharField(allow_blank=True)
metadata_author = serializers.CharField(allow_blank=True)
code = serializers.CharField(
required=True,
validators=[UniqueValidator(queryset=CollectionModel.objects.all())])
code_partner = serializers.CharField(allow_blank=True)
booklet_description = serializers.CharField(allow_blank=True)
comment = serializers.CharField(allow_blank=True)
media_type = AsymetricRelatedField.from_serializer(
MediaTypeSerializer, kwargs={'required': False})
physical_items_num = serializers.IntegerField(required=False)
auto_period_access = serializers.BooleanField(required=False)
legal_rights = AsymetricRelatedField.from_serializer(
LegalRightsSerializer, kwargs={'required': False})
class Meta:
model = CollectionModel
fields = '__all__'
class RegisterSerializer(serializers.Serializer):
email = serializers.EmailField(
required=True,
validators=[UniqueValidator(queryset=User.objects.all())])
password = serializers.CharField(write_only=True,
required=True,
validators=[validate_password])
password2 = serializers.CharField(write_only=True, required=True)
user_type = serializers.CharField(allow_null=True, allow_blank=True)
name = serializers.CharField()
def validate(self, attrs):
if attrs['password'] != attrs['password2']:
raise serializers.ValidationError(
{"password": "******"})
return attrs
def create(self, validated_data):
user_type = validated_data['user_type']
user = User.objects.create(
name=validated_data['name'],
email=validated_data['email'],
)
user.set_password(validated_data['password'])
user.save()
if user_type:
# fetch details of the group selected
try:
group_instance = Group.objects.get(name=user_type)
except Exception as e:
raise serializers.ValidationError("Group does not exist")
user.groups.add(group_instance)
return user
class UserCreateSerializer(serializers.ModelSerializer):
username = serializers.CharField(
max_length=None,
min_length=4,
allow_blank=False,
trim_whitespace=True,
validators=[UniqueValidator(queryset=User.objects.all())])
password = serializers.CharField(max_length=None,
min_length=6,
allow_blank=False,
trim_whitespace=True)
confirm_password = serializers.SerializerMethodField()
class Meta:
model = User
fields = ('id', 'username', 'password', 'confirm_password')
def create(self, validated_data):
user = User(**validated_data)
user.set_password(validated_data['password'])
user.save()
return user
def update(self, instance, validated_data):
instance.username = validated_data.get('username', instance.username)
if validated_data.get('password'):
instance.set_password(validated_data['password'])
instance.save()
return instance
def validate(self, data):
if self.initial_data.get('password') and (
self.initial_data.get('password') !=
self.initial_data.get('confirm_password')):
raise serializers.ValidationError(
{'password': '******'})
return data
def validate(self, data):
"""
Validate file by size and by all checksums provided.
Args:
data (:class:`django.http.QueryDict`): QueryDict mapping Artifact model fields to their
values
Raises:
:class:`rest_framework.exceptions.ValidationError`: When the expected file size or any
of the checksums don't match their actual values.
"""
super().validate(data)
if 'size' in data:
if data['file'].size != int(data['size']):
raise serializers.ValidationError(_("The size did not match actual size of file."))
else:
data['size'] = data['file'].size
for algorithm in hashlib.algorithms_guaranteed:
if algorithm in models.Artifact.DIGEST_FIELDS:
digest = data['file'].hashers[algorithm].hexdigest()
if algorithm in data and digest != data[algorithm]:
raise serializers.ValidationError(_("The %s checksum did not match.")
% algorithm)
else:
data[algorithm] = digest
if algorithm in UNIQUE_ALGORITHMS:
validator = UniqueValidator(models.Artifact.objects.all(),
message=_("{0} checksum must be "
"unique.").format(algorithm))
validator.field_name = algorithm
validator.instance = None
validator(digest)
return data
class UserRegisterSerializer(RegisterSerializer):
first_name = serializers.CharField(required=True)
last_name = serializers.CharField(required=True)
phone_number = PhoneNumberField(
required=True,
write_only=True,
validators=[
UniqueValidator(models.Profile.objects.all(),
message=_("Phone number already exist."))
],
)
accept_terms = serializers.BooleanField(required=True, write_only=True)
def validate_email(self, email):
email = get_adapter().clean_email(email)
if allauth_settings.UNIQUE_EMAIL:
if email and email_address_exists(email):
raise serializers.ValidationError(
_("E-mail address is taken."))
return email
def validate(self, data):
if data["password1"] != data["password2"]:
raise serializers.ValidationError(
_("The two password fields didn't match."))
return data
def create_profile_data(self, user):
user.first_name = self.validated_data.get("first_name", "")
user.last_name = self.validated_data.get("last_name", "")
user.save()
user.profile.phone_number = self.validated_data.get("phone_number")
user.profile.accept_terms = self.validated_data.get("accept_terms")
user.profile.save()
def custom_signup(self, request, user):
self.create_profile_data(user)
class Meta:
model = SiteUser
fields = (
'id',
'email',
'email_verified',
'is_superuser',
'is_active',
'date_joined',
'first_name',
'last_name',
'organization',
'provides_stock',
'needs_stock',
'street_1',
'street_2',
'city',
'county',
'state',
'zip',
'phone',
)
read_only_fields = (
'id',
'email_verified',
'is_superuser',
'is_active',
'date_joined',
)
extra_kwargs = {
'email': {
'validators':
[UniqueValidator(queryset=SiteUser.objects.all())],
}
}
class ProductSerializer(serializers.ModelSerializer):
"""Class representing the vendor serializer"""
vendor_id = serializers.PrimaryKeyRelatedField(
queryset=Vendor.objects.all(),
source='vendor',
error_messages={
"does_not_exist": "Vendor with the id '{pk_value}' does not exist."
})
title = serializers.CharField(
max_length=255,
validators=[
UniqueValidator(
queryset=Product.objects.filter(deleted=False).all(),
message=MESSAGES['DUPLICATES'].format('Product',
'product title'))
])
class Meta:
"""Meta"""
model = Product
fields = [
'id', 'title', 'price', 'description', 'availability', 'images',
'vendor_id', 'created_at', 'updated_at'
]
read_only_fields = READ_ONLY_FIELDS
extra_kwargs = {
"price": {
"error_messages": {
"invalid":
"'{value}' Value must include the Kobo denomination."
}
}
}
class UsuarioCrearActualizarSerializer(ModelSerializer):
email = serializers.EmailField(validators=[
UniqueValidator(
queryset=User.objects.all(),
message="Ya existe un usuario con este correo",
)
])
#email2 = EmailField(label = 'Confirm Email')
class Meta:
model = User
fields = ['username', 'first_name', 'email', 'password']
def create(self, validated_data):
username = validated_data['username']
first_name = validated_data['first_name']
email = validated_data['email']
password = validated_data['password']
user_obj = User(username=username, email=email, first_name=first_name)
user_obj.set_password(password)
user_obj.save()
return validated_data
class DirectoryLayoutSerializer(serializers.ModelSerializer):
name = serializers.CharField(
max_length=50,
validators=[
UniqueValidator(
queryset=DirectoryLayout.objects.all(),
message=('DUPLICATE_LAYOUT_NAME')
)
]
)
def create(self, validated_data):
dir_layout = DirectoryLayout(**validated_data)
dir_layout = self.__create_update(dir_layout)
return dir_layout
def update(self, dir_layout, validated_data):
dir_layout.name = validated_data.get('name', dir_layout.name)
dir_layout.description = validated_data.get('description', dir_layout.description)
dir_layout.banner_file = validated_data.get('banner_file', dir_layout.banner_file)
return self.__create_update(dir_layout)
def __create_update(self, dir_layout):
request = self.context['request']
if 'banner_file' in request.FILES:
dir_layout.banner_file_uploaded = True
dir_layout.save()
return dir_layout
class Meta:
model = DirectoryLayout
fields = ('id', 'url', 'name', 'description', 'banner_file', 'original_file_name')
read_only_fields = ('original_file_name',)
extra_kwargs = {
'url': {'lookup_field': 'pk'},
}
class UrlSerializer(serializers.Serializer):
user_id = serializers.CharField(max_length=16)
long_url = serializers.URLField(max_length=200)
short_url_subpart = serializers.SlugField(
allow_blank=True,
allow_unicode=False,
max_length=50,
required=False,
validators=[
UniqueValidator(queryset=Url.objects.all(),
message='Этот subpart уже занят!')
])
created = serializers.DateTimeField(read_only=True)
class Meta:
validators = [
UniqueTogetherValidator(
queryset=Url.objects.all(),
fields=['user_id', 'long_url'],
message='У вас уже есть короткая ссылка для этого url !'),
]
def create(self, validated_data):
return Url.objects.create(**validated_data)
class UserSerializer(serializers.ModelSerializer):
"""Serializer for the users object"""
name = serializers.CharField(required=True)
email = serializers.EmailField(
required=True,
validators=[UniqueValidator(queryset=get_user_model().objects.all())])
password = serializers.CharField(write_only=True,
style={'input_type': 'password'},
required=True,
validators=[validate_password])
is_active = serializers.BooleanField(required=False)
class Meta:
model = get_user_model()
fields = ('id', 'name', 'email', 'password', 'is_active', 'is_staff',
'is_cashier', 'is_manager')
read_only_fields = ('id', )
def create(self, validated_data):
"""Create a new staff user with encrypted password and return it"""
validated_data['is_staff'] = True
return get_user_model().objects.create_user(**validated_data)
def update(self, instance, validated_data):
"""Update a user's detail"""
password = validated_data.pop('password', None)
user = super().update(instance, validated_data)
if password:
user.set_password(password)
user.save()
return user
class UserSerializer(serializers.ModelSerializer):
USER_UNIQUE_VALIDATOR = UniqueValidator(
queryset=User.objects.all(),
message='User with this username/email already exists.')
username = serializers.CharField(min_length=3,
max_length=30,
validators=[USER_UNIQUE_VALIDATOR])
first_name = serializers.CharField(min_length=3, max_length=30)
last_name = serializers.CharField(min_length=3, max_length=30)
email = serializers.EmailField(max_length=100,
validators=[USER_UNIQUE_VALIDATOR])
password = serializers.CharField(write_only=True,
required=True,
min_length=8,
max_length=64,
style={'input_type': 'password'})
class Meta:
model = User
fields = ('username', 'first_name', 'last_name', 'email', 'password')
def validate_username(self, value):
username_regex = r'^(?=.{3,30}$)(?![_.])(?!.*[_.]{2})[a-zA-Z0-9._]+(?<![_.])$'
pattern = re.compile(username_regex)
if not pattern.match(value):
raise serializers.ValidationError(
'Username should be present with alphanumeric characters.')
return value
def validate_password(self, value):
auth_validate_password(value)
return value
class Meta:
model = Account
# fields = '__all__'
fields = ("id", "token", "username", "password", "telephone", "email")
extra_kwargs = {
'username': {
'min_length': 2,
'max_length': 20,
'error_messages': {
'min_length': '仅允许2-20个字符的用户名',
'max_length': '仅允许2-20个字符的用户名',
},
"validators": [UniqueValidator(queryset=Account.object.all())]
},
'password': {
'write_only': True,
'min_length': 6,
'max_length': 20,
'error_messages': {
'min_length': '仅允许6-20个字符的密码',
'max_length': '仅允许6-20个字符的密码',
}
},
}
class UserSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(read_only=True)
first_name = serializers.CharField(min_length=2)
last_name = serializers.CharField(min_length=2)
username = serializers.CharField(
validators=[UniqueValidator(queryset=User.objects.all())])
password = serializers.CharField(min_length=8)
is_superuser = serializers.BooleanField(default=False)
def create(self, validated_data):
user = User.objects.create_user(
self.validated_data['username'],
last_name=validated_data['last_name'],
password=validated_data['password'],
first_name=validated_data['first_name'],
is_superuser=validated_data['is_superuser'])
return user
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'password',
'is_superuser')
class UserSerializer(serializers.HyperlinkedModelSerializer):
username = serializers.CharField(
required=True,
validators=[UniqueValidator(queryset=User.objects.all())],
)
password = serializers.CharField(
min_length=8,
write_only=True,
)
class Meta:
model = User
fields = (
'id',
'username',
'password',
)
def create(self, validated_data):
user = User.objects.create_user(
username=validated_data['username'],
password=validated_data['password'],
)
return user
class Meta:
model = User
# fields ="__all__"
fields = ('id', 'username', 'password', 'email',
'password_confirm', 'token')
# model中没有的字段，不能在extra_kwargs 指定
#使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数---字典格式。
#如果字段已在序列化程序类中显式声明，则该extra_kwargs选项将被忽略。
extra_kwargs = {
'username':{
'label':'用户名',
'help_text':'用户名',
'min_length': 6,
'max_length': 20,
'error_messages': {'min_length': '仅允许6~20个字符',
'max_length': '仅允许6~20个字符',}
},
'email':{
'label': '邮箱',
'help_text': '邮箱',
'write_only':True,
'required':True, #必传
# 邮箱重复校验
'validators': [UniqueValidator(queryset=User.objects.all(), message='此邮箱已注册')]
},
'password': {
'label': '密码',
'help_text': '密码',
'min_length': 6,
'max_length': 20,
'write_only': True,
'error_messages': {'min_length': '仅允许6~20个字符',
'max_length': '仅允许6~20个字符', }
}
}
class UserRegisterSerializer(ModelSerializer):
username = serializers.CharField(
validators=[UniqueValidator(User.objects.all())])
password = serializers.CharField()
preferred_class = serializers.CharField()
def validate(self, attrs):
if attrs.get('password') != self.context['request'].data.pop(
'password2'):
raise ValidationError({'password2': 'Passwords mismatch'})
return attrs
def create(self, validated_data):
user = User.objects.create(
username=validated_data['username'],
preferred_class=validated_data['preferred_class'])
user.set_password(validated_data['password'])
user.save()
return user
class Meta:
model = User
fields = ('id', 'username', 'password', 'preferred_class')
class DepartmentSerializer(serializers.Serializer):
id = serializers.IntegerField(label='ID', read_only=True)
name = serializers.CharField(
max_length=100,
validators=[UniqueValidator(queryset=Department.objects.all())])
created_on = serializers.DateTimeField(read_only=True)
updated_on = serializers.DateTimeField(read_only=True)
deleted = serializers.BooleanField(required=False)
deleted_on = serializers.DateTimeField(allow_null=True, required=False)
created_by = serializers.SlugRelatedField(queryset=User.objects.all(),
required=False,
slug_field="username")
changed_by = serializers.SlugRelatedField(queryset=User.objects.all(),
slug_field="username")
def create(self, validated_data):
instance = Department.objects.create(**validated_data)
return instance
def update(self, instance, validated_data):
Department.objects.filter(id=instance.id).update(**validated_data)
return Department.objects.get(id=instance.id)
class HowHearAboutUsItemRetrieveUpdateDestroySerializer(
serializers.ModelSerializer):
is_archived = serializers.BooleanField(read_only=True)
text = serializers.CharField(
required=True,
allow_blank=False,
allow_null=False,
validators=[
UniqueValidator(queryset=HowHearAboutUsItem.objects.all(), )
],
)
class Meta:
model = HowHearAboutUsItem
fields = (
'id',
'text',
'sort_number',
'is_for_associate',
'is_for_customer',
'is_for_staff',
'is_for_partner',
'is_archived',
)
