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)