from django.contrib.auth.models import User
from django.shortcuts import get_object_or_404
from myapps.serializers import UserSerializer
from rest_framework import viewsets
from rest_framework.response import Response
class UserViewSet(viewsets.ViewSet):
    """
    A simple ViewSet for listing or retrieving users.
    """
    def list(self, request):
        queryset = User.objects.all()
        serializer = UserSerializer(queryset, many=True)
        return Response(serializer.data)
    def retrieve(self, request, pk=None):
        queryset = User.objects.all()
        user = get_object_or_404(queryset, pk=pk)
        serializer = UserSerializer(user)
        return Response(serializer.data)

path('userlist/', UserViewSet.as_view({'get': 'list'})),
path('userdetail/', UserViewSet.as_view({'get': 'retrieve'})

class ViewSet(ViewSetMixin, views.APIView):
    """
    The base ViewSet class does not provide any actions by default.
    """
    pass

class ModelViewSet(viewsets.ViewSet):
    """
    Example empty viewset demonstrating the standard
    actions that will be handled by a router class.
    If you're using format suffixes, make sure to also include
    the `format=None` keyword argument for each action.
    """
    def list(self, request):
        pass
    def create(self, request):
        pass
    def retrieve(self, request, pk=None):
        pass
    def update(self, request, pk=None):
        pass
    def partial_update(self, request, pk=None):
        pass
    def destroy(self, request, pk=None):
        pass

path('viewset/', ModelViewSet.as_view(
    {'get': 'list', 'post': 'create'}
)),
path('viewset/<int:pk>/', ModelViewSet.as_view(
    {
        'get': 'retrieve', 
        'put','update', 
        'patch': 'partial_update',
        'destroy': 'destroy'
    }
))

class GenericViewSet(ViewSetMixin, generics.GenericAPIView):
    """
    The GenericViewSet class does not provide any actions by default,
    but does include the base set of generic view behavior, such as
    the `get_object` and `get_queryset` methods.
    """
    pass

from rest_framework.viewsets import GenericViewSet
from rest_framework import status

class ModelGenericViewSet(GenericViewSet):
    queryset = model.objects.all()
    serializer_class = Serializer
    lookup_url_kwarg = 'pk'
    lookup_field = 'pk'
    def list(self,request):
        data = self.get_queryset()
        serializer = self.get_serializer(instance=data, many=True)
        return Response(serializer.data)
        
    def retrieve(self, request):
        instance = self.get_object()
        serializer = self.get_serializer(instance=instance)
        return Response(serializer.data)
        
    def create(self, request):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(
            serializer.data, 
            status=status.HTTP_201_CREATED
        )

    def put(self,request):
        instance = self.get_object()
        serializer = self.get_serializer(instance=instance,data=request.data)
        serializer.is_valid(raise_exception=True)
        instance = serializer.save()
        return instance
        
    def destroy(self, request):
        instance = self.get_object()
        instance.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

class ModelViewSet(mixins.CreateModelMixin,
                   mixins.RetrieveModelMixin,
                   mixins.UpdateModelMixin,
                   mixins.DestroyModelMixin,
                   mixins.ListModelMixin,
                   GenericViewSet):
    """
    A viewset that provides default `create()`, `retrieve()`, `update()`,
    `partial_update()`, `destroy()` and `list()` actions.
    """
    pass

from rest_framework.viewsets import ModelViewSet
class BookModelViewSet(ModelViewSet):
   queryset = Book.objects.all()
   lookup_field = 'pk'
   lookup_url_kwarg = 'pk'
   serializer_class = BookSer

path('modelviewset/',BookModelViewSet.as_view(
    {'get':'list','post':'create'}
)),
path('modelviewset/<int:pk>/',BookModelViewSet.as_view(
    {'get':'retrieve','put':'update','detele':'destroy'}
)),

class ReadOnlyModelViewSet(mixins.RetrieveModelMixin,
                           mixins.ListModelMixin,
                           GenericViewSet):
    """
    A viewset that provides default `list()` and `retrieve()` actions.
    """
    pass

from rest_framework.viewsets import ReadOnlyModelViewSet
class BookReadOnlyModelViewSet(ReadOnlyModelViewSet):
   queryset = Book.objects.all()
   lookup_field = 'pk'
   lookup_url_kwarg = 'pk'
   serializer_class = BookSer

path('readonlymodelviewset/',             
BookReadOnlyModelViewSet.as_view(
    {'get': 'list'}
)),
path('readonlymodelviewset/<int:pk>/',             BookReadOnlyModelViewSet.as_view(
    {'get': 'retrieve'}
)),

from rest_framework import mixins
class CreateListRetrieveViewSet(mixins.CreateModelMixin,
                                mixins.ListModelMixin,
                                mixins.RetrieveModelMixin,
                                viewsets.GenericViewSet):
    """
    A viewset that provides `retrieve`, `create`, and `list` actions.
    To use it, override the class and set the `.queryset` and
    `.serializer_class` attributes.
    """
    pass

class BookModelViewSet(ModelViewSet):
    serializer_class = BookSerializer
    queryset = Book.objects.all()
    # 获取一定条件的书籍，比如ID大于5的
    def more_than_5(self, request):
        data = self.get_queryset().filter(id__gt=5)
        serializer = self.get_serializer(instance=data, many=True)
        return Response(serializer.data)

path('bookthan5/', 
    BookModelViewSet.as_view(
      {'get': 'more_than_5'})
),

class ModelView(ModelViewSet):
    ...
    def get_serializer_class(self):
        if self.action == 'list':
            return ListSer
        if self.action == 'create':
            return CreateSer

class BookModelViewSet(ModelViewSet):
    serializer_class = BookSerializer
    queryset = Book.objects.all()

from rest_framework import routers
# 1.实例化路由对象
router = routers.SimpleRouter()
# 2.注册生成路由
router.register('book', BookModelViewSet, basename='book')
# 3.添加路由
urlpatterns += router.urls

[
  <URLPattern '^book/$' [name='book-list']>,
  # 包含：获取列表get，创建一条post
  <URLPattern '^book/(?P<pk>[^/.]+)/$' [name='book-detail']>
  # 包含：获取一条get、更新一条put、删除一条delete
]

# 1.实例化路由对象
router = routers.SimpleRouter()
# 2.注册生成路由
router.register('路由命名', 视图集, basename='路由名称前缀')

from rest_framework import routers
# 1.实例化路由对象
router = routers.DefaultRouter() 
# 2.注册生成路由
router.register('book', BookModelViewSet, basename='book')
# 3.添加路由
urlpatterns += router.urls

[
    <URLPattern '^book/$' [name='book-list']>, 
    <URLPattern '^book\.(?P<format>[a-z0-9]+)/?$' [name='book-list']>, 
    <URLPattern '^book/(?P<pk>[^/.]+)/$' [name='book-detail']>, 
    <URLPattern '^book/(?P<pk>[^/.]+)\.(?P<format>[a-z0-9]+)/?$' [name='book-detail']>, 
    <URLPattern '^$' [name='api-root']>,
    <URLPattern '^\.(?P<format>[a-z0-9]+)/?$' [name='api-root']>
]

<URLPattern '^book\.(?P<format>[a-z0-9]+)/?$' 
    [name='book-list']>, 
<URLPattern '^book/(?P<pk>[^/.]+)\.(?P<format>[a-z0-9]+)/?$'  
    [name='book-detail']>, 
<URLPattern '^\.(?P<format>[a-z0-9]+)/?$' 
    [name='api-root']>

http://127.0.0.1:8000/book.json
#'^book\.(?P<format>[a-z0-9]+)/?$' [name='book-list'],

path('', include(router.urls)),

from rest_framework.decorators import action
class StuModelViewSet(ModelViewSet):
    ...
    @action(methods=["get"],detail=False)
    def id_than_1(self, request): # 获取id超过1的数据们
        queryset = self.get_queryset().filter(id__gt=1)
        serializer = self.get_serializer(instance=queryset, many=True)
        return Response(serializer.data)

'^stu/id_than_1/$'

'^stu/(?P<pk>[^/.]+)/id_than_1/$'

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS':
    # 'rest_framework.pagination.PageNumberPagination',
        'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 2  # 每页数目
}

class View(...):
    pagination_class = None

http://127.0.0.1:8000/user/?limit=2&page=2
# limit：每页的数据大小
# page：当前的页码

http://127.0.0.1:8000/path/?limit=2&offset=2"
# limit：每页的数据大小
# offset：从某一个数据位置开始偏移

from rest_framework.pagination import PageNumberPagination
class StandardResultsSetPagination(PageNumberPagination):
    page_size = 2 # 每页数据量
    page_size_query_param = 'page_size' # 每页大小连接传递参数
    max_page_size = 5 # 每页数据量最多
    page_query_param = 'page' # 路由传递获取的页码参数 key 值

class SomeModelViewSet(ModelViewSet):
    ...
    pagination_class = StandardResultsSetPagination

from rest_framework.utils.urls import replace_query_param
class CustomPagination(PageNumberPagination):
    def get_paginated_response(self, data):
        url = self.request.build_absolute_uri()
        num_pages = self.page.paginator.num_pages
        return Response({
            'links': {
                'next': self.get_next_link(),
                'previous': self.get_previous_link()
            },
            'count': self.page.paginator.count,
            # 'num_pages': self.page.paginator.num_pages,
            'num_pages': [
                  replace_query_param(
                      url, # 接口主机地址
                      self.page_query_param, # get传参时的页码标示
                      num_page # 带拼接的页码
                  )
                  for num_page in range(1, num_pages + 1) # 推导式
            ],
            'results': data
        })

pip3 install django-filter

REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': 
    ['django_filters.rest_framework.DjangoFilterBackend']
}

from django_filters.rest_framework import DjangoFilterBackend
class UserListView(generics.ListAPIView):
    ...
    filter_backends = [DjangoFilterBackend]

class List(generics.ListAPIView):
    queryset = model.objects.all()
    serializer_class = Serializer
    filter_backends = [DjangoFilterBackend]
    filterset_fields = ['name',...]

from django_filters import FilterSet, rest_framework
class UserFilter(FilterSet):
    name = rest_framework.CharFilter(
        field_name="name", # 模型类中的字段
        lookup_expr='contains' # 过滤链式条件
    )
    class Meta:
        model = User  # 模型
        fields = ['name']

filter_class = UserFilter

from rest_framework import filters
class List(generics.ListAPIView):
    queryset = model.objects.all()
    serializer_class = Serializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['name',...]

search_fields = ['username', 'foreignkey__field']

...?search=char

pip install django-cors-headers

INSTALLED_APPS = [
    ...
    'corsheaders',  # 跨域
     ...
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',  # 添加跨域中间件
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',  # 关闭csrf验证
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

CORS_ORIGIN_ALLOW_ALL = True

import axios from 'axios'  // 导入axios

axios.defaults.baseURL = "http://127.0.0.1:8000/"  // 设置axios请求的默认域名，即django服务的域名
Vue.prototype.$axios = axios  // 全局挂载axios

<template>
  <div>
    <!--  三、循环展示所有作者  -->
    <table>
      <tr v-for="author in authorList" :key="author.id">
        <td>{{ author.id }}</td>
        <td>{{ author.name }}</td>
        <td>{{ author.gender }}</td>
        <td>{{ author.age }}</td>
        <td>
          <!--
          内层元素的事件会从内向外依次触发， 叫做冒泡机制
          想要阻止冒泡事件，需要 使用 事件修饰符 .stop
          -->
          <button @click.stop="delAuthor">删除</button>
        </td>
      </tr>
    </table>

  </div>
</template>

<script>
export default {
  name: "AuthorList",
  data() {
    return {
      authorList: []
    }
  },
  methods: {
    // 一、get请求所有作者
    getAuthorList() {
      this.$axios.get('author/')
        .then(resp => {
          console.log(resp.data)
          this.authorList = resp.data
        })
    },
    delAuthor(id) {
      this.$axios.delete('author/' + id + '/')
        .then(resp => {
          // 删除成功，重新请求数据，刷新页面
          this.getAuthorList();
        })
        .catch(err => {
          console.log('删除失败')
        })
    },  
  },
  mounted() {
    //  二、挂载，让请求自动执行
    this.getAuthorList();
  }
}
</script>

<template>
  <div>
    <!--   1. 使用v-model指定从表单获取数据 -->
    图书标题： <input type="text" v-model="title">
    图书价格： <input type="text" v-model="price">
    <!--  3. 使用事件绑定，将 方法和按钮进行绑定  -->
    <button @click="btn">添加</button>
  </div>
</template>

<script>
export default {
  name: "Book",
  data() {
    return {
      title: '',
      price: ''
    }
  },
  methods: {
    btn() {
      // 2. 定义方法， 使用axios发送post请求，并携带参数
      this.$axios.post('book/', {'title': this.title, 'price': this.price})
        .then(resp => {
          // 添加成功，输出响应数据
          console.log(resp.data)
        })
        .catch(err => {
          // 添加失败，输出错误信息
          console.log(err.response.data)
        })
    }
  }
}
</script>

<template>
  <div>
    <!-- 修改之前，需要有原始数据   -->
    <!-- 一、修改图书之前，给表单设置默认值， 原本的图书数据   -->
    
    <!-- 二.修改同样也需要获取用户输入的新数据  -->
    图书标题： <input type="text" v-model="book.title">
    图书价格： <input type="text" v-model="book.price">

    <!--  四、对按钮绑定事件  -->
    <button @click="updateBook">修改</button>
  </div>
</template>

<script>
export default {
  name: "BookUpdate",
  data() {
    return {
      id: 1,
      book: {
        title: '',
        price: ''
      }
    }
  },
  methods: {
    // 1.1 获取id对应的图书数据
    getBook() {
      this.$axios.get('book/' + this.id + '/')
        .then(resp => {
          // 请求成功，将请求到的图书数据赋值给data中的变量，
          // 而表单和data中的数据进行双向绑定
          // 给data中的数据设置默认值，表单也会有默认值
          this.book.title = resp.data.title
          this.book.price = resp.data.price
        })
    },

    // 三. 定义方法，使用put提交数据
    updateBook() {
      this.$axios.put('book/' + this.id + '/', this.book)
        .then(resp => {
          console.log(resp.data)
        })
    }
  },
  mounted() {
    //  1.3 挂载
    this.getBook();
  }
}
</script>