from django.db import models

# Create your models here.

class Book(models.Model):

    id = models.IntegerField(primary_key=True)

    title = models.CharField(max_length=255)

    desc = models.CharField(max_length=255)

    is_deleted = models.IntegerField(choices=[(1, "删除"), (0, "未删除")])

    author = models.CharField(max_length=255)

from rest_framework.serializers import Serializer

from rest_framework import serializers

class BookSerializer(Serializer):

    id = serializers.IntegerField()

    title = serializers.CharField()

    desc = serializers.CharField()

    is_deleted = serializers.ChoiceField(choices=[(1, "删除"), (0, "未删除")], source="get_is_deleted_display")

    author = serializers.CharField()

from app01.models import Book

from app01.serializer import BookSerializer

from django.http import HttpResponse, JsonResponse

# Create your views here.

def get_books(request):

    books = Book.objects.all()

    se = BookSerializer(books, many=True)

    return JsonResponse(se.data, safe=False)

[{"id": 1, "title": "活着", "desc": "讲述一代人的人生", "is_deleted": "未删除", "author": "余华"}]

serializer = CommentSerializer(data={'email': 'foobar', 'content': 'baz'})

serializer.is_valid()

# False

serializer.errors

# {'email': ['Enter a valid e-mail address.'], 'created': ['This field is required.']}

def multiple_of_ten(value):

    if value % 10 != 0:

        raise serializers.ValidationError('Not a multiple of ten')

class GameRecord(serializers.Serializer):

    score = IntegerField(validators=[multiple_of_ten])

from rest_framework import serializers

class BlogPostSerializer(serializers.Serializer):

    title = serializers.CharField(max_length=100)

    content = serializers.CharField()

    def validate_title(self, value):

        """

        Check that the blog post is about Django.

        """

        if 'django' not in value.lower():

            raise serializers.ValidationError("Blog post is not about Django")

        return value

from rest_framework import serializers

class EventSerializer(serializers.Serializer):

    description = serializers.CharField(max_length=100)

    start = serializers.DateTimeField()

    finish = serializers.DateTimeField()

    def validate(self, data):

        """

        Check that start is before finish.

        """

        if data['start'] > data['finish']:

            raise serializers.ValidationError("finish must occur after start")

        return data

class CommentSerializer(serializers.Serializer):

    email = serializers.EmailField()

    content = serializers.CharField(max_length=200)

    created = serializers.DateTimeField()

　　 def create(self, validated_data):

        return Comment.objects.create(**validated_data)

    def update(self, instance, validated_data):

        instance.email = validated_data.get('email', instance.email)

        instance.content = validated_data.get('content', instance.content)

        instance.created = validated_data.get('created', instance.created)

        instance.save()

        return instance

# .save() will create a new instance.

serializer = CommentSerializer(data=data)

serializer.save()

# .save() will update the existing `comment` instance.
 serializer = CommentSerializer(comment, data=data)

serializer.save()

serializer.save(owner=request.user)

class AccountSerializer(serializers.ModelSerializer):

    class Meta:

        model = Account

        fields = ['id', 'account_name', 'users', 'created']

from res_framework import serializers

#这个类用于被实例化，多对多字段这么写

class AuthorSerializer(serializers.Serializer):

    id = serializers.Charfield()

    name = serializers.Charfield()

    age = serializers.Charfield()

#传给views.py的主类

class BookSerializer(serializers.Serializer):

    name = serializers.Charfield()

    #source 可以指定字段 ,  id是要序列化的表名。

    id  = serializers.CharField(source='nid')

    #，source后字段用.的方式可以跨表查询。

    publish = serializer.CharField(source='publish.email')

    '''

    如果在models.py的book类中定义一个test方法。

    def test(self):

        return str(self.price)+self.name

   '''

   # 返回的结果就会有xx字段，souce不但可以指定表模型字段，还可以指定模型表方法，并且赋值给xx变量

   xx = serializers.Charfield(source='test')

   #外键的实现方法：

   #一对多字段

   #如果要通过外键字段返回出版社的所有信息，包括id,name,email...

   #obj是当前循环序列化到的数据对象

    publish = serializers.SerializerMethodField()

    def get_publish(self,obj):

        return {’id‘:obj.publish.pk,'name':obj.publish.name}

   #多对多字段

   #所有作者的详情，也展示出来

    authors = serializers.SerializermethodFiled()

    def get_authors(self,obj):

        author_list  = obj.authors.all()

        author_ser = AuthorSerializer(author_list,many=True)

        return author_ser.data

from rest_framework.views import APIView

from rest_framework.response import Response

from app01 import models

class BookView(APIview):

    def get(self,request,*args,**kwargs)：

            #获取所有图书数据

        response = {'status':100,'msg':'获取成功'}

        book_list = models.Book.objects.all()

        #实例化BookSerializer类，把要序列化的数据book_list传入

        #如果要序列化querySet对象，一定要加many = True

        book_ser = BookSerializer(book_list,many=True)

        #把序列化后的数据book_ser.data 拿出来放到response字典中返回给客户端

        response['data'] = book_ser.data

        return Response(response)

from app01 import models

class PublishSerializer(serializers.ModelSerializer):

    class Meta: #固定写法

    # 指定要序列化Book表

    model = models.Book

    #指定要序列化的字段

    fields = ['nid','name']

    #序列化所有字段

    fileds ='__all__‘

    #要排除的字段（不能与fileds连用）

    # exclude = ['name','price']

    #深度判定

    depth = 1

    #如果要不按照父类的来，想要自己定义显示的字段的话,自己定义一个，覆盖掉父类的字段属性。

    publish = serializers.SerializerMethodField()  #一对多字段

    def get_publish(self,obj):

        return {’id‘:obj.publish.pk,'name':obj.publish.name}

def to_representation(self, instance):

    """Convert `username` to lowercase."""

    ret = super().to_representation(instance)

    ret['username'] = ret['username'].lower()

    return ret

def to_internal_value(self, value):

    if value == None:

        return 0

    return value