Django ORM restframework学习记录

0X-1 踩坑记录

如何统一处理DRF的异常?使用custom_exception_handler:
https://stackoverflow.com/questions/28197199/how-to-change-validation-error-responses-in-drf

 

对于可以为None的值,前台不设置该key即可,可以通过序列化器的数据校验

嵌套序列化传参:

data = {
    'up_credit.username': 'root',
    'up_credit.password': 'qwe',
    'name': 'z10',
    'hosts': '192.168.2.111;',
    "exclude_hosts": "",
    "alive_test": 1,
    "port_list": 1,
    "comment": "",
    'ssh_port': ''
}

参数传递过去后,会被序列化器封装成一个字典,字典包含了被嵌套序列化对象的所有参数。

对于嵌套序列化的数据校验,如果允许None的话,那么up_credit都不传值即可,但如果up_credit.username传值了,password却没传值,那么是会引发报错的。

当POST和PUT方法提交的参数不同的时候,可以使用两个不同的URL和VIEW来提供API:

    path('remote-app/create/', views.RemoteAppCreateView.as_view(), name='remote-app-create'),
    path('remote-app//update/', views.RemoteAppUpdateView.as_view(), name='remote-app-update'),

 

serializer实例化传入data,这时data是ReturnDict类型,不可变对象,不能改变其的值。

https://stackoverflow.com/questions/37111118/update-append-serializer-data-in-django-rest-framework

https://www.django-rest-framework.org/api-guide/pagination/#pagenumberpagination  # 分页

关于serializer验证数据的机制,在进行serializer.save()之前,必须运行serializer.is_valid()方法,这个方法首先会执行默认在models或者serializer里面定义的字段约束,如果不满足该约束直接返回异常。如果通过了字段约束,会进入validate()方法,该方法默认直接返回原始值,用户可以对该方法重写,加入自己想要进行的数据验证。整个验证结束后,过滤后的值会被赋值给serializer.data

 

序列化器会将前台POST的数据转换成models中定义的数据类型,所以对于int型,不论前台传的是int还是str,都会被序列化成int类型。

 

可选字段

默认情况下,“一起唯一”验证会强制执行所有字段 required=True。在某些情况下,您可能希望显式应用于 required=False其中一个字段,在这种情况下,验证的所需行为是不明确的。

在这种情况下,您通常需要从序列化程序类中排除验证程序,而是在.validate()方法中或在视图中显式写入任何验证逻辑。

例如:

class BillingRecordSerializer(serializers.ModelSerializer):
    def validate(self, data):
        # Apply custom validation either here, or in the view.

    class Meta:
        fields = ('client', 'date', 'amount')
        extra_kwargs = {'client': {'required': False}}
        validators = []  # Remove a default "unique together" constraint.

serializers.Serializer并不支持在class meta中定义model,fields等,需要显式定义序列化字段。而ModelSerializer是支持的

关于depth参数(针对ModelSerializer):

使用该参数可以轻松获得外键或多对多关系的具体数据,而不是单单显示一个key,缺点是使用了该参数后无法使用create和update方法,存在外键关系的字段会被过滤掉。

解决方法:重写create和update方法,将使用的serializer指向另一个serializer,一个除了没有指定depth参数,其余皆和原serializer相同的序列化器。

0X-2 反向查询

方法1:
class A(models.Model):
    name = models.CharField(max_length=255, unique=True)

class B(models.Model):
    a = models.ForeignKey(A, on_delete=models.PROTECT)
    name = models.CharField(max_length=255, unique=True)

通过A的实例反向查询所有引用过A的B对象:
    A.objects.filter(id=1).values_list('blist')

输出QuerySet [None]  or  [(1,), (2,)]

方法2:

ret = PortList.objects.filter(id=1, targetlist__uniq_id__isnull=False)

返回QuerySet [] or [obj,obj],len(ret)即是id为1的PortList被引用的次数。


Django ORM restframework学习记录_第1张图片

0X-3 碰到的小知识点

获取实例的类名:
obj.__class__.__name__
  • ForeignKey字段可以设置为null=True,那么允许前端不选择关联对象,而是传递一个null。经过序列化的数据该key对应的value为None
    

使用ViewSet的情况下,如果再settings中设置了分页,那么默认会对数据进行分页处理。该处理继承于GenericAPIView,在APIView中是没有这样处理的,所以如果使用了APIView,需要手动进行分页,代码如下:

paginate_queryset,可以传入queryset对象或者list等,该方法计算出相关数值,get_paginated_response会将数据进行分页然后返回一个django restframework中的Response对象,不需要额外使用Response对象对其进行封装。

def get(self, request):
    data = list()
    op_return = open_vas.exec_cmd('get_tasks')
    for i in op_return['get_tasks_response']['task']:
        data.append({'uniq_id': i['@id'],'status': i['status']})
    page = LimitOffsetPagination()
    page_roles = page.paginate_queryset(data, self.request, view=self)
    result = page.get_paginated_response(page_roles)
    return result
在中间件中获取request数据出现的问题:
django request.POST / request.body
    当request.POST没有值 需要考虑下面两个要求
        1.如果请求头中的: Content-Type: application/x-www-form-urlencoded   request.POST中才会有值(才会去request.body中解析数据)
        2.若1有,也不一定有值 必须有数据格式要求: name=alex&age=18&gender=男

如果已经读取过request.body的数据,那么不能二次读取

multipart/form-data:既可以上传文件等二进制数据,也可以上传表单键值对,只是最后会转化为一条信息;

x-www-form-urlencoded:只能上传键值对,并且键值对都是间隔分开的。

0X-4 使用filter来进行查询、排序等操作

相关文档:

https://www.django-rest-framework.org/api-guide/filtering/#searchfilter

https://django-filter.readthedocs.io/en/latest/index.html

https://django-filter.readthedocs.io/en/latest/guide/rest_framework.html

DEMO:

STEP 1:下载及加载模块

pip install django-filter

INSTALLED_APPS = [
    ...
    'rest_framework',
    'django_filters',
]

REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': (
        'django_filters.rest_framework.DjangoFilterBackend',
}

STEP 2:编写fiter

from django_filters import rest_framework as filters
from .models import ActionLog


class ActionLogFilter(filters.FilterSet):
    comment = filters.CharFilter(lookup_expr='icontains')

    class Meta:
        model = ActionLog
        fields = ['user', 'status', 'dtime', 'comment']  # 若不指定具体查找内容将自动使用精确查找

STEP 3:将filter与ViewSet绑定

class ActionLogViewSet(ModelViewSet):
    permission_classes = (permissions.IsAdminUser,)
    queryset = ActionLog.objects.all()
    serializer_class = ActionLogSerializer
    filter_backends = (filters.DjangoFilterBackend,)  # !!!
    filterset_class = ActionLogFilter  # !!!

STEP 4:测试

http://192.168.2.178:8000/logs/action/?user=AnonymousUser

支持使用fields字段来简化代码:

import django_filters

class ProductFilter(django_filters.FilterSet):
    class Meta:
        model = Product
        fields = {
            'price': ['lt', 'gt'],
            'release_date': ['exact', 'year__gt'],
        }

# 以上将生成'price__lt','price__gt','release_date'和'release_date__year__gt'过滤器

使用时间过滤器:

class ActionLogFilter(filters.FilterSet):
    comment = filters.CharFilter(lookup_expr='icontains')
    dtime = filters.DateFilter(lookup_expr='exact')
    dtime_range = filters.DateFromToRangeFilter(field_name='dtime')

    class Meta:
        model = ActionLog
        fields = ['user', 'status', 'dtime', 'comment']  # 若不指定具体查找内容将自动使用精确查找


http://192.168.2.178:8000/logs/action/?dtime_range_after=2019-06-18&dtime_range_before=2019-06-17

0X-5 在APIView中使用分页器

在settings.py中针对DRF设置了默认分页器的话,那么ModelViewSet视图集会自动进行分页:

REST_FRAMEWORK = {
    #  只有使用rest_framework的API才会受到JWT的保护
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    ),
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
        #  使用rest_framework的界面需要下列认证模块
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication',
    ),
    #  以下代码会禁用掉REST自带的WEB API界面,只返回JSON
    # 'DEFAULT_RENDERER_CLASSES': (
    #     'rest_framework.renderers.JSONRenderer',
    # ),
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 50,
    'DEFAULT_FILTER_BACKENDS': (
        'django_filters.rest_framework.DjangoFilterBackend',
    ),
}

但是APIView不会,需要手动分页,手动分页方法如下:

class TaskStatusGetView(APIView):
    permission_classes = (UserReadAdminWrite,)
    def get(self, request):
        data = list()
        op_return = open_vas.exec_cmd('get_tasks')
        for i in op_return['get_tasks_response']['task']:
            #  如果status为Done,progress为-1
            data.append({'uniq_id': i['@id'],'status': i['status'],'progress': i['progress']})
        page = LimitOffsetPagination()
        page_roles = page.paginate_queryset(data, self.request, view=self)
        result = page.get_paginated_response(page_roles)
        return result

0X-6 返回一个文件

class BackupLogView(APIView):
    permission_classes = (permissions.IsAdminUser,)
    def get(self, request):
        with open(config['BACKUP']['LINE_PATH'], 'r') as f:
            line_num = f.readline()
        query_set = ActionLog.objects.filter(id__gt=line_num)
        if len(query_set) > 0:
            example = 'ID:%s,用户:%s,操作详情:%s,操作状态:%s,时间:%s'
            with open(config['BACKUP']['LOG_PATH'], 'a') as syslog:
                for i in query_set:
                    syslog.write(example % (i.id, i.user, i.comment, i.status, i.dtime))
                    syslog.write('\n')
            with open(config['BACKUP']['LINE_PATH'], 'w') as fr:
                fr.write(str(query_set[len(query_set)-1].id))
        result = {'result': ''}
        with open(config['BACKUP']['LOG_PATH'], 'r') as file:
            for line in file:
                result['result'] = result['result'] + line + '\r\n'
        response = HttpResponse(result['result'], content_type='text/plain; charset=UTF-8')
        # response['Content-Type'] = 'application/octet-stream'
        response['Content-Disposition'] = 'attachment;filename="sys_op_log.txt"'
        return response

0X-7 上传一个文件

支持通过binary file或表单来上传文件。如果文件小于2.5MB,那么Django会将数据全部保存到内存中,如果需要对文件进行操作,操作全部在内存执行,非常快。如果文件大于2.5MB,Django会把文件存储到系统目录,然后需要使用的时候将临时文件按块读取。传送门:https://docs.djangoproject.com/en/2.2/topics/http/file-uploads/

from rest_framework.parsers import MultiPartParser


class UpdateNvtView(APIView):
    permission_classes = (permissions.IsAdminUser,)
    parser_classes = [MultiPartParser]

    def put(self, request):
        print(request.data)
        zip_file = request.data['file']
        with open('/home/rule.zip', 'wb') as f:
            for chunk in zip_file.chunks():
               f.write(chunk)
        return Response(status=status.HTTP_200_OK)

 

0X00 什么是ORM

  • MVC框架中包括一个重要的部分,就是ORM,它实现了数据模型与数据库的解耦,即数据模型的设计不需要依赖于特定的数据库,通过简单的配置就可以轻松更换数据库
  • ORM是“对象-关系-映射”的简称,主要任务是:
    • 根据对象的类型生成表结构
    • 将对象、列表的操作,转换为sql语句
    • 将sql查询到的结果转换为对象、列表
  • 这极大的减轻了开发人员的工作量,不需要面对因数据库变更而导致的无效劳动
  • Django中的模型包含存储数据的字段和约束,对应着数据库中唯一的表

Django ORM restframework学习记录_第2张图片

0X01 ORM中的属性及关系

  • 定义属性时,需要字段类型
  • 字段类型被定义在django.db.models.fields目录下,为了方便使用,被导入到django.db.models中
  • 使用方式
    1. 导入from django.db import models
    2. 通过models.Field创建字段类型的对象,赋值给属性
  • 对于重要数据都做逻辑删除,不做物理删除,实现方法是定义isDelete属性,类型为BooleanField,默认值为False

字段类型

获取choice字段的描述:

Django ORM restframework学习记录_第3张图片

如果设置了choice类型,那么非设置的值不允许传入,传入会报错:

{
    "credit_type": [
        "“3” 不是合法选项。"
    ]
}
choice = (
        (1, 'up'),  # username + password
        (2, 'snmp')  # snmp community
    )
credit_type = models.IntegerField(choices=choice)
#  前台传参需要传递int类型
  • AutoField:一个根据实际ID自动增长的IntegerField,通常不指定
    • 如果不指定,一个主键字段将自动添加到模型中
  • BooleanField:true/false 字段,此字段的默认表单控制是CheckboxInput
  • NullBooleanField:支持null、true、false三种值
  • CharField(max_length=字符长度):字符串,默认的表单样式是 TextInput
  • TextField:大文本字段,一般超过4000使用,默认的表单控件是Textarea
  • IntegerField:整数
  • DecimalField(max_digits=None, decimal_places=None):使用python的Decimal实例表示的十进制浮点数
    • DecimalField.max_digits:位数总数
    • DecimalField.decimal_places:小数点后的数字位数
  • FloatField:用Python的float实例来表示的浮点数
  • DateField[auto_now=False, auto_now_add=False]):使用Python的datetime.date实例表示的日期
    • 参数DateField.auto_now:每次保存对象时,自动设置该字段为当前时间,用于"最后一次修改"的时间戳,它总是使用当前日期,默认为false
    • 参数DateField.auto_now_add:当对象第一次被创建时自动设置当前时间,用于创建的时间戳,它总是使用当前日期,默认为false
    • 该字段默认对应的表单控件是一个TextInput. 在管理员站点添加了一个JavaScript写的日历控件,和一个“Today"的快捷按钮,包含了一个额外的invalid_date错误消息键
    • auto_now_add, auto_now, and default 这些设置是相互排斥的,他们之间的任何组合将会发生错误的结果
  • TimeField:使用Python的datetime.time实例表示的时间,参数同DateField
  • DateTimeField:使用Python的datetime.datetime实例表示的日期和时间,参数同DateField
  • FileField:一个上传文件的字段
  • ImageField:继承了FileField的所有属性和方法,但对上传的对象进行校验,确保它是个有效的image

字段选项

  • 通过字段选项,可以实现对字段的约束
  • 在字段对象时通过关键字参数指定
  • null:如果为True,Django 将空值以NULL 存储到数据库中,默认值是 False
  • blank:如果为True,则该字段允许为空白,默认值是 False
  • 对比:null是数据库范畴的概念,blank是表单验证证范畴的
  • db_column:字段的名称,如果未指定,则使用属性的名称
  • db_index:若值为 True, 则在表中会为此字段创建索引
  • default:默认值
  • primary_key:若为 True, 则该字段会成为模型的主键字段
  • unique:如果为 True, 这个字段在表中必须有唯一值

关系

  • 关系的类型包括
    • ForeignKey:一对多,将字段定义在多的端中,如果一个model中有多个外键指向同一个model,需要设置related_name,避免反向访问时冲突(可以通过related_name来进行反向查询!)
    • ManyToManyField:多对多,将字段定义在两端中
    • OneToOneField:一对一,将字段定义在任意一端中
  • 可以维护递归的关联关系,使用'self'指定,详见“自关联”
  • 用一访问多:对象.模型类小写_set

使用ORM创建了表后切忌手动进入数据库删除表信息,如果删除了将导致无法再migrate提交修改到数据库。解决方法:

删除django_migrations表中的提交记录,注意,只需删除自己APP最近的一条提交记录。

 

on_delete指的是通过ForeignKey连接起来的对象被删除后,当前字段怎么变化。

常见的选项有:

  models.CASCADE,对就对象删除后,包含ForeignKey的字段也会被删除

  models.PROTECT,删除时会引起ProtectedError

  models.SET_NULL,注意只有当当前字段设置null设置为True才有效,此情况会将ForeignKey字段设置为null

  models.SET_DEFAULT ,同样,当前字段设置了default才有效,此情况会将ForeignKey 字段设置为default 值

  moels.SET,此时需要指定set的值

  models.DO_NOTHING ,什么也不做

 

模型中Meta配置:
  对于一些模型级别的配置。我们可以在模型中定义一个类,叫做Meta。然后在这个类中添加一些类属性来控制模型的作用。比如我们想要在数据库映射的时候使用自己指定的表名,而不是使用模型的名称。那么我们可以在Meta类中添加一个db_table的属性。示例代码如下:

  class Book(models.Model):
    name = models.CharField(max_length=20,null=False)
    desc = models.CharField(max_length=100,null=True,blank=True)

    class Meta:
      db_table = 'book_model'

  以下将对Meta类中的一些常用配置进行解释。

  1、db_table:这个模型映射到数据库中的表名。如果没有指定这个参数,那么在映射的时候将会使用模型所在app的名称加上模型名的小写来作为默认的表名。

  2、ordering:设置在提取数据的排序方式,因为可以按照多个字段以优先关系进行排序,所以需要传递一个字段的列表,在我们提取数据时,可以根据列表中字段从前到后(优先级从高到低)的方式排序,排序默认为正序,如果你需要哪个字段按倒序排列,就可以在这个字段前面加上"-"。后面章节会讲到如何查找数据。比如我想在查找数据的时候根据添加的时间排序,那么示例代码如下:

class Book(models.Model):
    name = models.CharField(max_length=20,null=False)
    desc = models.CharField(max_length=100,name='description',db_column="description1")
    pub_date = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = 'book_model'
        ordering = ['pub_date',]

       3、get_latest_by

由于Django的管理方法中有个lastest()方法,就是得到最近一行记录。如果你的数据模型中有 DateField 或 DateTimeField 类型的字段,你可以通过这个选项来指定lastest()是按照哪个字段进行选取的。

一个 DateField 或 DateTimeField 字段的名字. 若提供该选项, 该模块将拥有一个 get_latest() 函数以得到 "最新的" 对象(依据那个字段):

get_latest_by = "order_date"

       4、app_label

app_label这个选项只在一种情况下使用,就是你的模型类不在默认的应用程序包下的models.py文件中,这时候你需要指定你这个模型类是那个应用程序的。比如你在其他地方写了一个模型类,而这个模型类是属于myapp的,那么你这是需要指定为:

app_label='myapp'

     5、unique_together

unique_together这个选项用于:当你需要通过两个字段保持唯一性时使用。这会在 Django admin 层和数据库层同时做出限制(也就是相关的 UNIQUE 语句会被包括在 CREATE TABLE 语句中)。比如:一个Person的FirstName和LastName两者的组合必须是唯一的,那么需要这样设置:

unique_together = (("first_name", "last_name"),)

使用model层的validators:

https://docs.djangoproject.com/en/2.2/ref/validators/

from django.db import models
from django.core import validators

class Interface(models.Model):
    name = models.CharField(max_length=20)
    ip = models.GenericIPAddressField(protocol='IPv4')
    mask = models.IntegerField(validators=[
        validators.MinValueValidator(1),
        validators.MaxValueValidator(32),
    ])
    status = models.BooleanField()

    class Meta:
        db_table = 'net_interface'

0X02 常见的操作

增:

models.UserInfo.objects.create(name=new_name)

删:

models.UserInfo.objects.get(id=xxx,None)
models.delete()

改:

obj = models.UserInfo.objects.get(id=xx,None)
obj = new_xxx
obj.save()

查:

querylist=models.Entry.objects.all()
print([e.title for e in querylist])
print([e.title for e in querylist])

entry = models.Entry.objects.get(id=?)

0X03 rest_framework的serializer

将复杂的数据结构,例如ORM中的QuerySet或者Model实例对象转换成Python内置的数据类型,从而进一步方便数据和JSON,XML等格式的数据进行交互

1、DEMO:

models.py:

from django.db import models

# Create your models here.

class Graph(models.Model):
    id = models.AutoField(primary_key=True)
    graph_name = models.CharField(max_length=255)
    graph_content = models.TextField()
    graph_status = models.BooleanField(default=False)
    graph_conf = models.CharField(max_length=255)
    graph_position = models.IntegerField()
    create_time = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = 'graph'

serilizers.py:

# -*- coding: utf-8 -*-
# @Time    : 2019/5/8 11:07
# @Author  : Zcs
# @File    : serializers.py
from rest_framework import serializers
from .models import Graph


class GraphSerializer(serializers.ModelSerializer):
    class Meta:
        model = Graph
        fields = '__all__'

可以在django shell中查看定义的序列化器的内容:

Django ORM restframework学习记录_第4张图片

2、您可以将exclude属性设置为要从序列化程序中排除的字段列表

class AccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = Account
        exclude = ('users',)

好文章:https://www.cnblogs.com/pyspark/p/8607801.html

常见问题:

1、Cannot call `.is_valid()` as no `data=` keyword argument was passed when instantiating the serializer instance.

当把query_set序列化成Python数据类型时,将data作为第一个参数传给serilizer即可,但是反序列化时,要指定data=data

https://stackoverflow.com/questions/29731013/django-rest-framework-cannot-call-is-valid-as-no-data-keyword-argument/29731923

 

使用传统的视图,需要为总体和实例个体分别实现视图函数:

from django.urls import path
from snippets import views

urlpatterns = [
    path('snippets/', views.snippet_list),
    path('snippets//', views.snippet_detail),
]
@csrf_exempt
def snippet_list(request):
    """
    List all code snippets, or create a new snippet.
    """
    if request.method == 'GET':
        snippets = Snippet.objects.all()
        serializer = SnippetSerializer(snippets, many=True)
        return JsonResponse(serializer.data, safe=False)

    elif request.method == 'POST':
        data = JSONParser().parse(request)
        serializer = SnippetSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data, status=201)
        return JsonResponse(serializer.errors, status=400)
@csrf_exempt
def snippet_detail(request, pk):
    """
    Retrieve, update or delete a code snippet.
    """
    try:
        snippet = Snippet.objects.get(pk=pk)
    except Snippet.DoesNotExist:
        return HttpResponse(status=404)

    if request.method == 'GET':
        serializer = SnippetSerializer(snippet)
        return JsonResponse(serializer.data)

    elif request.method == 'PUT':
        data = JSONParser().parse(request)
        serializer = SnippetSerializer(snippet, data=data)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data)
        return JsonResponse(serializer.errors, status=400)

    elif request.method == 'DELETE':
        snippet.delete()
        return HttpResponse(status=204)

对于snippet_list来说,只有get方法和post方法。put方法和delete方法都是针对某个实例而言的,所以放在snippet_detail中。

 

可以添加序列化字段对时间进行格式化:

date_joined = serializers.DateTimeField(format='%Y-%m-%d %H:%M:%S', read_only=True)

0X04 几种url;view;serializer的组合

命名规范:

URL: path('ports/', VIEWSET_CONF['port_list']),
     path('ports//', VIEWSET_CONF['port_detail']),

VIEWSET: class PortViewSet(ModelViewSet):

SERIALIZER: class TargetSerializer(serializers.ModelSerializer):

MODEL: class Schedule(models.Model):

1、普通URL + APIView + ModelSerializer

urlpatterns = [
    path('dev/', views.GraphView.as_view()),
]

"""
from rest_framework import routers
# router = routers.DefaultRouter()
# router.register('dev', views.DeViewset)  # 为viewset注册路由

这种方式是将dev_list和dev_detail分开的注册方式,下面的方式2可以
将dev_list和dev_detail使用同一个viewset和serializer,通过请求方法的
不同调用不同的处理函数
"""
class GraphView(APIView):
    """
    GET: [{'graph_name':'', 'graph_content':'', 'graph_status':'', 'upper_limit':'', 'lower_limit':'', 'size':'',
           'graph_position':'', 'create_time'},
        ]

    POST:{'graph_name':'', 'graph_status':'', 'upper_limit':'', 'lower_limit':'', 'size':''},

    """

    def get(self, request):
        query_data = Graph.objects.all()  # 从数据库取出数据,query_set
        serializer = GraphSerializer(query_data, many=True)  # 将query_set序列化成Python数据类型
        # data = JSONRenderer().render(serializer.data)  # 将Python数据类型转成JSON
        # print(data)
        return Response(serializer.data)

    def post(self, request):
        """
        graph_conf 2|5|10000
        反序列化,将JSON形式数据转换为流的形式,然后将流数据转化为Python数据类型
        :param request:
        :return:
        """
        stream = BytesIO(request.body)  # 将JSON数据转换为流形式
        data = JSONParser().parse(stream)  # 解析流中的JSON数据并转换为Python数据结构
        serializer = GraphSerializer(data=data)
        if serializer.is_valid():  # 验证前台传过来的数据是否合法,在save前必须调用该方法
            serializer.save(**data)  # 根据是否存在instance实例来决定执行create方法或update方法,无执行create
        #  save方法可以选择传参或者不传参,不传参的话默认会从serializer实例化时传入的数据进行读取
        #  但是这样读取的话,非model定义的字段会被舍弃掉,所以如果需要传入非model定义的字段,需要在save方法传入data
            return 0

        #  print(serializer.errors)

    def patch(self, request):
        stream = BytesIO(request.body)
        data = JSONParser().parse(stream)
        serializer = GraphSerializer(data=data)
        serializer.instance = Graph.objects.get(id=data['id'])
        if serializer.is_valid():
            serializer.save(**data)
        return 0

    def delete(self, request):
        """
        RESTful默认界面的DELETE方法会将URL中的id传递给后台,如果没有使用URL传参的话,是不会传过来数据的
        自己传递JSON过来使用以下方法解析即可
        :param request:
        :return:
        """
        stream = BytesIO(request.body)
        data = JSONParser().parse(stream)
        g_id = data['id']
        obj = Graph.objects.get(id=g_id)
        obj.delete()
        return Response({"status": 0})
class GraphSerializer(serializers.ModelSerializer):

    class Meta:
        model = Graph
        fields = '__all__'
        read_only_fields = ['graph_name', 'graph_content', 'graph_conf', 'graph_position', 'create_time']
        #  read_only_fields选项,表示该字段只用作查询出结果,不需要用户传值
        #  如果未设置该字段,那么表示所有字段都需要从serializer那传值,如果未传is_valid函数会返回False

        #  extra_kwargs = {'id': {'write_only': True}}
        #  提供extra_kwargs的方式来为某个字段指定其关键字参数,而不需要去显示指定(id=serializers.IntegerField())

    @staticmethod
    def create_graph(gspace, gtime, num):
        buff = ()
        for i in range(num):
            ret1 = random.randrange(gspace[0], gspace[1] + 1)
            ret2 = random.randrange(gtime[0], gtime[1] + 1)
            buff += ((ret1, ret2),)
        return buff

    #  验证用户传到后台的数据是否合法
    # def validate(self, attrs):
    #     return attrs

    def create(self, validated_data):
        print(validated_data)
        validated_data['graph_conf'] = str(validated_data['lower_limit']) + '|' + \
                                       str(validated_data['upper_limit']) + '|' + str(validated_data['size'])
        validated_data['graph_position'] = 0
        validated_data['graph_content'] = str(self.create_graph([1,4], [validated_data['lower_limit'],validated_data['upper_limit']],10))
        kwargs = {
            'graph_name': validated_data.get('graph_name'),
            'graph_content': validated_data.get('graph_content'),
            'graph_status': validated_data.get('graph_status'),
            'graph_conf': validated_data.get('graph_conf'),
            'graph_position': validated_data.get('graph_position'),
        }
        instance = Graph.objects.create(**kwargs)
        return instance

    def update(self, instance, validated_data):
        #  只允许更新graph_status参数
        instance.graph_status = validated_data['graph_status']
        instance.save()
        return instance

2.正则URL + viewsets.ModelViewSet + ModelSerializer

from django.urls import path, include
from . import views
from rest_framework.urlpatterns import format_suffix_patterns


dev_list = views.DeViewset.as_view({
    'get': 'list',
    'post': 'create'
})
dev_detail = views.DeViewset.as_view({
    'get': 'retrieve',
    'put': 'update',
    'patch': 'partial_update',
    'delete': 'destroy'
})

urlpatterns = format_suffix_patterns([
    #path('', include(router.urls)),
    path('graph/', views.GraphView.as_view()),
    path('devs/', dev_list),
    path('devs//', dev_detail)
])
class DeViewset(viewsets.ModelViewSet):
    """
    ModelViewset继承了四个混类和一个泛类,自动会实现增删查改的方法
    viewset相当于是视图的集合,综合了多个方法
    """
    queryset = Dev.objects.all().order_by('id')
    serializer_class = DevSerializer
    lookup_field = 'id'  # 定义通过哪个参数来定位实例
class DevSerializer(serializers.ModelSerializer):

    class Meta:
        model = Dev
        fields = '__all__'

drf中的view继承关系:

Django ORM restframework学习记录_第5张图片

0X05 当存在外键关系时,默认取出的数据只包含外键id,如何根据外键id取出其他所有数据?

models.py:定义一个私有方法

class Dev(models.Model):
    id = models.AutoField(primary_key=True)
    cpu = models.IntegerField()
    memory = models.IntegerField()
    disk = models.IntegerField()
    ip = models.CharField(max_length=15)
    dev_user = models.ForeignKey(User, on_delete=models.CASCADE, default='')

    class Meta:
        db_table = 'dev'

    @property
    def dev_user_name(self):
        return self.dev_user.username

serilizers.py:需要注意的是,dev_user_name变量名必须与model的方法名保持一致

class DevSerializer(serializers.ModelSerializer):
    dev_user_name = serializers.ReadOnlyField()

    class Meta:
        model = Dev
        fields = '__all__'

http://www.cnblogs.com/pgxpython/articles/10144398.html

 

在serializer层面也可以做到同样的事情:

class DevSerializer(serializers.ModelSerializer):
    dev_user_name = serializers.ReadOnlyField()
    is_superuser = serializers.SerializerMethodField()

    class Meta:
        model = Dev
        fields = '__all__'

    @staticmethod
    def get_is_superuser(obj):
        return obj.dev_user.is_superuser

0X06 rest_framework中的权限管理

1、向视图添加所需权限:

from rest_framework import permissions

class DeViewset(viewsets.ModelViewSet):
    """
    ModelViewset继承了四个混类和一个泛类,自动会实现增删查改的方法
    viewset相当于是视图的集合,综合了多个方法
    """
    queryset = Dev.objects.all().order_by('id')
    serializer_class = DevSerializer
    lookup_field = 'id'  # 定义通过哪个参数来定位实例
    permission_classes = (permissions.IsAuthenticatedOrReadOnly,)
    #  没有认证的情况下只有只读权限

可以通过逻辑符号组合多个permission类,前提是这些类都继承于BasePermission

# -*- coding: utf-8 -*-
# @Time    : 2019/6/13 10:44
# @Author  : Zcs
# @File    : permissions.py
from rest_framework.permissions import BasePermission


# class UserReadAdminWrite(BasePermission):
#     """
#     普通用户拥有只读权限,admin用户拥有读写权限
#     """
#     def has_permission(self, request, view):
#         if request.user and request.user.is_staff:
#             return True
#         elif request.user and request.user.is_authenticated and request.method in ['GET']:
#             return True

# 三权分立,系统管理员,安全审计员,安全管理员
class SysAdminPermission(BasePermission):

    def has_permission(self, request, view):
        if request.user.is_authenticated and request.user.user_type == 1:
            return True

class AudAdminPermission(BasePermission):

    def has_permission(self, request, view):
        if request.user.is_authenticated and request.user.user_type == 2:
            return True

class SecAdminPermission(BasePermission):

    def has_permission(self, request, view):
        if request.user.is_authenticated and request.user.user_type == 3:
            return True

class SupAdminPermission(BasePermission):

    def has_permission(self, request, view):
        if request.user.is_authenticated and request.user.user_type == 4:
            return True
permission_classes = (SecAdminPermission | AudAdminPermission,)

0X07 serializer中的几个fields属性

valid_kwargs = {
                'read_only', 'write_only',
                'required', 'default', 'initial', 'source',
                'label', 'help_text', 'style',
                'error_messages', 'validators', 'allow_null', 'allow_blank',
                'choices'
            }

read_only_fields = ['is_use', 'uniq_id', 'max_']

1.设置了read_only_fields,那么用户无法从该接口修改该字段,提交了该字段不会报错,但是不会修改该字段的值。

你可能感兴趣的:(web,Django,rest,framework)