rest framework- serialization - long-term maintenance

############### Table Structure ###############

class Article(models.Model):
    id = models.AutoField(primary_key=True)
    title = models.CharField(max_length=64)
    create_time = models.DateField(auto_now=True)
    type = models.SmallIntegerField(
        choices = ((. 1, ' original ' ), (2, ' reproduced ' )),
        default=1
    )
    source = models.ForeignKey(to='Source', on_delete=models.CASCADE)
    tag = models.ManyToManyField(to='Tag')


class Source(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField (= 32 MAX_LENGTH, UNIQUE = True, error_messages, = { " UNIQUE " : ' district name can not be repeated ' })


class Tag(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)


class Comment(models.Model):
    content = models.CharField(max_length=255)
    article = models.ForeignKey(to='Article', on_delete=models.CASCADE)

 

############### single table GET and POST    ###############

routing:
url(r'source/', views.SourceView.as_view()),

Serialization categories:
class SourceSerializer(serializers.ModelSerializer):

    DEF validate_name (Self, value):
         IF  ' grass '  in value:
             The raise ValidationError ( ' not in line with the socialist core values ' )
         return value

    class Meta:
        model = models.Source
        fields = "__all__"


view:
class SourceView(APIView):

    def get(self, request, *args, **kwargs):
        res = {"code": 0}
        all_source = models.Source.objects.all()
        ser_obj = SourceSerializer(all_source, many=True)
        res["data"] = ser_obj.data
        return Response(res)

    def post(self, request, *args, **kwargs):
        res = {"code": 0}
        ser_obj = SourceSerializer(data=request.data)
        if ser_obj.is_valid():
            # 数据没问题
            ser_obj.save()
            return Response(res)
        else:
            res["code"] = 1
            res["error"] = ser_obj.errors
            return Response(res)
 

 

############### foreign key GET and POST     ###############

routing:
url(r'comment/', views.Comment.as_view()),
 

Serialization:
class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Comment
        Fields = " __all__ " 
        extra_kwargs = {
             " Content " : { " error_messages " : { " required " : " Comments can not be empty " }},
             " Article This article was " : { " error_messages " : { " required " : " article can not be empty " }}
        }
 

view:
class Comment(APIView):
    def get(self, request, *args, **kwargs):
        res = {"code": 0}
        all_data = models.Comment.objects.all()
        ser_obj = CommentSerializer(all_data, many=True)
        res["data"] = ser_obj.data
        return Response(res)

    def post(self, request, *args, **kwargs):
        res = {"code": 0}
        ser_obj = CommentSerializer(data=request.data)
        if ser_obj.is_valid():
            ser_obj.save()
        else:
            res["code"] = 1
            res["error"] = ser_obj.errors
        return Response(res)

 

############### many-GET and POST     ###############

routing:
url(r'article/', views.ArticleList.as_view()),
 

Serialization:
class TagSerializer(serializers.ModelSerializer):

    class Meta:
        model = models.Tag
        fields = "__all__"


class ArticleSerializer(serializers.ModelSerializer):
    type = serializers.CharField(source="get_type_display")
    tag = TagSerializer(many=True)

    class Meta:
        model = models.Article
        fields = ["id", "title", "type", "source", "tag"]


class ArticleWriteSerializer(serializers.ModelSerializer):

    class Meta:
        model = models.Article
        fields = "__all__"
        extra_kwargs = {
            "tag": {
                "error_messages": {
                    "does_not_exist": '"{pk_value}"对应的tag对象不存在。'
                }
            }
        }
 

view:
class ArticleList(APIView):
    def get(self, request, *args, **kwargs):
        res = {"code": 0}
        article_list = models.Article.objects.all()
        ser_obj = ArticleSerializer(article_list, many=True)
        res["data"] = ser_obj.data
        return Response(res)

    def post(self, request, *args, **kwargs):
        res = {"code": 0}
        ser_obj = ArticleWriteSerializer(data=request.data)
        if ser_obj.is_valid():
            ser_obj.save()
        else:
            res["code"] = 1
            res["error"] = ser_obj.errors
        return Response(res)

 

############### hyperlink sequence    ###############

routing:
urlpatterns = [
    url(r'articlelinked/', views.ArticleLinked.as_view()),,
    url(r'source/(?P<pk>\d+)', views.SourceDetailView.as_view(), name='source-detail'),
]
 

Serialization:
class ArticleHyperlinkedSerializer(serializers.HyperlinkedModelSerializer):
    source = serializers.HyperlinkedIdentityField(view_name='source-detail', lookup_field='source_id', lookup_url_kwarg='pk')

    class Meta:
        model = models.Article
        fields = ["id", "type", "title", "source"]
        depth = 1
 

view:
class ArticleLinked(APIView):
    def get(self, request, *args, **kwargs):
        res = {"code": 0}
        article_list = models.Article.objects.all()
        ser_obj = ArticleHyperlinkedSerializer(article_list, many=True, context={'request': request})
        res["data"] = ser_obj.data
        return Response(res)

 

############### serialization     ###############

 

Serialization ###############     ###############,