class UserModel(models.Model):
username = serializers.CharField(required=False, allow_blank=True)
email = serializers.EmailField(required=False, allow_blank=True)
first_name = serializers.CharField(required=True, write_only=True)
last_name = serializers.CharField(required=True, write_only=True)
phone = serializers.IntegerField()
jobIds = serializers.CharField(max_length=10000, allow_blank=True)
class UidAndTokenSerializer(serializers.Serializer):
uid = serializers.CharField()
token = serializers.CharField()
default_error_messages = {
"invalid_token": "Invalid token for given user.",
"invalid_uid": "Invalid user id or user doesn't exist.",
}
def validate(self, attrs):
validated_data = super().validate(attrs)
# uid validation have to be here, because validate_<field_name>
# doesn't work with modelserializer
try:
uid = utils.decode_uid(self.initial_data.get("uid", ""))
self.user = User.objects.get(pk=uid)
except (User.DoesNotExist, ValueError, TypeError, OverflowError):
key_error = "invalid_uid"
raise ValidationError({"uid": [self.error_messages[key_error]]},
code=key_error)
is_token_valid = default_token_generator.check_token(
self.user, self.initial_data.get("token", ""))
if is_token_valid:
return validated_data
else:
key_error = "invalid_token"
raise ValidationError({"token": [self.error_messages[key_error]]},
code=key_error)
class TicketSerializer(serializers.ModelSerializer):
serial_no = serializers.CharField(max_length=32)
remark = serializers.CharField(required=False, allow_blank=True, allow_null=True, max_length=1024)
author_id = serializers.IntegerField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
author = serializers.StringRelatedField(read_only=True)
itinerary = ItinerarySerializer(read_only=True, many=False)
itinerary_id = serializers.IntegerField(required=True)
# messages = MessageSerializer(read_only=True, many=True)
messages = serializers.SerializerMethodField()
comments = CommentSerializer(read_only=True, many=True)
uploads = UpLoadSerializer(read_only=True, many=True)
parent_id = serializers.IntegerField(required=False, allow_null=True)
class Meta:
model = models.Ticket
fields = '__all__'
def get_fields(self):
fields = super(TicketSerializer, self).get_fields()
fields['children'] = TicketSerializer(many=True, read_only=True)
return fields
def get_messages(self, obj):
query = obj.messages.filter(user_id=self.context['request'].user.id)
serializer = MessageSerializer(instance=query, many=True)
return serializer.data
class BookingSerializer(serializers.ModelSerializer):
title = serializers.CharField(max_length=64)
remark = serializers.CharField(required=False, allow_blank=True, allow_null=True, max_length=1024)
author = serializers.StringRelatedField(read_only=True)
author_id = serializers.IntegerField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
# messages = MessageSerializer(read_only=True, many=True)
messages = serializers.SerializerMethodField()
comments = CommentSerializer(read_only=True, many=True)
uploads = UpLoadSerializer(read_only=True, many=True)
itineraries = serializers.SerializerMethodField()
class Meta:
model = models.Booking
fields = '__all__'
def get_itineraries(self, obj):
query = None
if self.context['request'].user.has_perm('ticket.view_itinerary'):
query = obj.itineraries.all()
else:
query = obj.itineraries.filter(user_id=self.context['request'].user.id)
serializer = ItinerarySerializer(instance=query, many=True)
return serializer.data
def get_messages(self, obj):
query = obj.messages.filter(user_id=self.context['request'].user.id)
serializer = MessageSerializer(instance=query, many=True)
return serializer.data
def __init__(self, *args, **kwargs):
"""
Dynamically add the username field to self.fields.
"""
super().__init__(self, *args, **kwargs)
self.fields[self.username_field] = serializers.CharField(
write_only=True)
self.fields["password"] = serializers.CharField(
write_only=True, style={"input_type": "password"})
class JSONWebTokenSocialAuthSerializer(BaseJSONWebTokenAuthSerializer):
"""
Validate an access token from a social provider. Returns a JSON web
token that can be used to authenticate later calls.
"""
provider = serializers.CharField(write_only=True)
access_token = serializers.CharField(write_only=True,
style={"input_type": "password"})
social = serializers.JSONField(read_only=True)
def validate(self, attrs):
request = self.context["request"]
strategy = load_strategy(request)
try:
backend = load_backend(strategy,
attrs["provider"],
redirect_uri=None)
except MissingBackend:
raise serializers.ValidationError(_("Provider not found"))
if request.user.is_authenticated:
authenticated_user = request.user
else:
authenticated_user = None
try:
user = backend.do_auth(attrs["access_token"],
user=authenticated_user)
except AuthException as e:
raise serializers.ValidationError(_(str(e)))
if user is None:
raise serializers.ValidationError(_("Invalid token"))
user_model = strategy.storage.user.user_model()
if not isinstance(user, user_model):
raise serializers.ValidationError(
_("`{}` is not a user instance").format(type(user).__name__))
_do_login(backend, user, user.social_user)
return {
"token": get_token(user),
"social": {
"id": user.social_user.id,
"provider": user.social_user.provider,
"uid": user.social_user.uid,
"extraData": user.social_user.extra_data,
"created": user.social_user.created,
"modified": user.social_user.modified,
},
}
class BookModelSerializers(serializers.ModelSerializer):
class Meta:
model = Book
fields = '__all__'
publish = serializers.CharField(source='publish.pk')
# authors = serializers.SerializerMethodField() # 多对多
# def get_authors(self, obj):
# temp=[]
# for obj in obj.authors.all():
# temp.append(obj.name)
# return temp
def create(self, validated_data):
print(validated_data)
# book=Book.objects.create(title=validated_data['title'],price=validated_data['price'],pub_date=validated_data['pub_date'],publish=validated_data['publish']['pk'])
# book.authors.add(validated_data['authors'])
# return book
authors = validated_data.pop('authors')
obj = Book.objects.create(title=validated_data['title'],
price=validated_data['price'],
pub_date=validated_data['pub_date'],
publish_id=validated_data['publish']['pk'])
obj.authors.add(*authors)
return obj
class PasswordSerializer(serializers.Serializer):
new_password = serializers.CharField(style={"input_type": "password"})
def validate(self, attrs):
user = (self.context and self.context["request"]
and self.context["request"].user) or self.user
# why assert? There are ValidationError / fail everywhere
assert user is not None
try:
validate_password(attrs["new_password"], user)
except django_exceptions.ValidationError as e:
raise serializers.ValidationError(
{"new_password": list(e.messages)})
return super().validate(attrs)
def save(self, request, **kwargs: Any):
self.user.set_password(self.data["new_password"])
if hasattr(self.user, "last_login"):
self.user.last_login = now()
self.user.save()
if settings.PASSWORD_CHANGED_EMAIL_CONFIRMATION:
context = {"user": self.user}
to = [utils.get_user_email(self.user)]
PasswordChangedConfirmationEmail(request, context).send(to)
class ProfileSerializer(serializers.ModelSerializer):
email = serializers.CharField(max_length=200)
password = serializers.CharField(max_length=200)
class Meta:
model = Profile
fields = (
'email',
'password',
'gender',
'contact',
'image',
'created_at',
)
# fields = ('name',)
read_only_fields = ('created_at')
write_only_fields = ('password', )
class RegisterSerializer(serializers.ModelSerializer):
contact_no = serializers.CharField(max_length=200)
class Meta:
model = User
fields = ('email', 'password', 'first_name', 'last_name', 'contact_no')
read_only_fields = ('contact_no')
write_only_fields = ('password')
class SocialSerializer(serializers.Serializer):
"""
Serializer which accepts an OAuth2 access token.
"""
access_token = serializers.CharField(
allow_blank=False,
trim_whitespace=True,
)
class CourseSerialize(serializers.ModelSerializer):
'''课程序列化'''
level_name =serializers.CharField(source='get_level_display')
class Meta:
model = Course
fields = ['id','name','course_img','brief','level_name']
class FormSerializer(serializers.Serializer):
slug = serializers.CharField(max_length=20)
name = serializers.CharField(max_length=5000)
description = serializers.CharField(max_length=5000)
time = serializers.CharField(max_length=5000)
question_amount = serializers.IntegerField()
answer_amount = serializers.IntegerField()
subject = serializers.CharField(max_length=5000)
subjectID = serializers.CharField(max_length=5000)
date = serializers.CharField(max_length=50)
answers = serializers.CharField(max_length=5000000)
class StudentSerializer(serializers.Serializer):
slug = serializers.CharField(max_length=50)
firstname = serializers.CharField(max_length=100)
lastname = serializers.CharField(max_length=100)
year = serializers.CharField(max_length=100)
grade = serializers.CharField(max_length=100)
level = serializers.CharField(max_length=100)
room = serializers.CharField(max_length=50)
class VerifyJSONWebTokenSerializer(serializers.Serializer):
token = serializers.CharField(write_only=True)
payload = serializers.JSONField(read_only=True)
def validate(self, attrs):
try:
payload = get_payload(attrs["token"])
except (JSONWebTokenExpired, JSONWebTokenError) as e:
raise serializers.ValidationError(str(e))
return {"payload": payload}
class UserCreateSerializer(serializers.ModelSerializer):
password = serializers.CharField(style={"input_type": "password"},
write_only=True)
default_error_messages = {
"cannot_create_user": "******"
}
class Meta:
model = User
fields = tuple(User.REQUIRED_FIELDS) + (
User.USERNAME_FIELD,
"id",
"password",
)
def validate(self, attrs):
user = User(**attrs)
password = attrs.get("password")
try:
validate_password(password, user)
except django_exceptions.ValidationError as e:
serializer_error = serializers.as_serializer_error(e)
raise serializers.ValidationError(
{"password": serializer_error["non_field_errors"]})
return attrs
def create(self, validated_data):
try:
user = self.perform_create(validated_data)
except IntegrityError:
self.fail("cannot_create_user")
return user
def perform_create(self, validated_data):
with transaction.atomic():
user = User.objects.create_user(**validated_data)
if settings.SEND_ACTIVATION_EMAIL:
user.is_active = False
user.save(update_fields=["is_active"])
return user
def save(self, request, **kwargs: Any):
user = super().save()
context = {"user": user}
to = [utils.get_user_email(user)]
if settings.SEND_ACTIVATION_EMAIL:
ActivationEmail(request, context).send(to)
elif settings.SEND_CONFIRMATION_EMAIL:
ConfirmationEmail(request, context).send(to)
return user
class PasswordRetypeSerializer(PasswordSerializer):
re_new_password = serializers.CharField(style={"input_type": "password"})
default_error_messages = {
"password_mismatch": "The two password fields didn't match."
}
def validate(self, attrs):
attrs = super().validate(attrs)
if attrs["new_password"] == attrs["re_new_password"]:
return attrs
else:
self.fail("password_mismatch")
class ConfirmTicketSerializer(serializers.Serializer):
confirm = serializers.BooleanField()
reason = serializers.CharField(max_length=255, required=False, allow_null=True)
def validate(self, validate_data):
reason = validate_data.get('reason', None)
confirm = validate_data.get('confirm', None)
if not confirm and reason is None:
raise serializers.ValidationError({'reason': 'This field is required!'})
return validate_data
class UserBaseSerializer(serializers.ModelSerializer):
full_name = serializers.CharField(source="get_full_name", read_only=True)
class Meta:
model = User
fields = (
"id",
User.USERNAME_FIELD,
"full_name",
"first_name",
"last_name",
"is_staff",
)
read_only_fields = (User.USERNAME_FIELD, )
class ItinerarySerializer(serializers.ModelSerializer):
serial_no = serializers.CharField(max_length=32)
remark = serializers.CharField(required=False, allow_blank=True, allow_null=True, max_length=1024)
author_id = serializers.IntegerField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
booking_id = serializers.IntegerField(required=True)
ticket = serializers.StringRelatedField(read_only=True)
author = serializers.StringRelatedField(read_only=True)
class Meta:
model = models.Itinerary
fields = '__all__'
def validate(self, validate_data):
email = validate_data.get('email', None)
if email:
try:
user = UserModel.objects.get(email=email)
validate_data['user_id'] = user.id
except UserModel.DoesNotExist:
raise serializers.ValidationError({'email': 'No user for such email'})
return validate_data
def create(self, validated_data):
if not self.context['request'].user.has_perm('ticket.lock_itinerary'):
validated_data['is_lock'] = True
return super().create(validated_data)
def update(self, instance, validated_data):
if not self.context['request'].user.has_perm('ticket.lock_itinerary'):
validated_data.pop('is_lock', None)
return super().update(instance, validated_data)
class CurrentPasswordSerializer(serializers.Serializer):
current_password = serializers.CharField(style={"input_type": "password"})
default_error_messages = {"invalid_password": "******"}
def validate_current_password(self, value):
user = (self.context and self.context["request"]
and self.context["request"].user) or self.user
# why assert? There are ValidationError / fail everywhere
assert user is not None
is_password_valid = user.check_password(value)
if is_password_valid:
return value
else:
self.fail("invalid_password")
class RefreshJSONWebTokenSerializer(serializers.Serializer):
token = serializers.CharField()
payload = serializers.JSONField(read_only=True)
refresh_expires_in = serializers.IntegerField(read_only=True)
def validate(self, attrs):
# Get and check payload
try:
payload = get_payload(attrs["token"])
except (JSONWebTokenExpired, JSONWebTokenError) as e:
raise serializers.ValidationError(str(e))
# Get and check user by payload
try:
user = get_user_by_payload(payload)
except JSONWebTokenError as e:
raise serializers.ValidationError(str(e))
# Get and check "origIat"
orig_iat = payload.get("origIat")
if not orig_iat:
raise serializers.ValidationError(_("origIat field is required"))
if jwt_refresh_expired_handler(orig_iat):
raise serializers.ValidationError(_("Refresh has expired"))
new_payload = jwt_payload_handler(user)
new_payload["origIat"] = orig_iat
refresh_expires_in = (
orig_iat +
jwt_settings.JWT_REFRESH_EXPIRATION_DELTA.total_seconds())
token = jwt_encode_handler(new_payload)
return {
"token": token,
"payload": new_payload,
"refresh_expires_in": refresh_expires_in,
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["re_password"] = serializers.CharField(
style={"input_type": "password"})
class PublishSerializers(serializers.Serializer):
name = serializers.CharField()
email = serializers.CharField()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["re_new_" + User.USERNAME_FIELD] = serializers.CharField()
class BaseJSONWebTokenAuthSerializer(serializers.Serializer):
token = serializers.CharField(read_only=True)
