DRF filters and sorts the process records of paging exception handling

catalogue

• 1、 Filter
• 2、 Sort
• 3、 Pagination
• PageNumberPagination
• LimitOffsetPagination
• CursorPagination
• Inherit apiview usage
• 4、 Exception handling
• Source code analysis
• How
• 5、 Encapsulate the response object
• summary

#1. Register and register settings in the app py
INSTALLED_APPS = [
    'django_filters',
]

# 2、settings. Py configuration
REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': (
        'django_filters.rest_framework.DjangoFilterBackend',
    )
}

#3. Add a filter in the view_ The fields property specifies the filtered fields
class BooksView(ModelViewSet):
    queryset = Books.objects.all()
    serializer_class = BooksSerializer

    filter_ Fields = ('title ',) # configure which fields can be filtered
    
# http://127.0.0.1:8000/books/?title= The Dream of Red Mansion

#1. First, set the filter in the view_ backends=[OrderingFilter]
#2. Then add ordering in the view_ The fields property specifies the sort fields

from rest_framework.filters import OrderingFilter
class BooksView(ModelViewSet):
    queryset = Books.objects.all()
    serializer_class = BooksSerializer

    filter_ Backends = [orderingfilter] # step 1
    ordering_ Fields = ['price ','id'] # step 2
    
# http://127.0.0.1:8000/books/?ordering=id Check whether there are fields indicating sorting through ordering, and sort by fields
#- ID indicates that the ID fields are sorted in reverse order
#ID indicates ascending sorting for the ID field

from rest_framework.generics import ListAPIView
from rest_framework.pagination import PageNumberPagination
from app01.models import Books
from app01.ser import BooksSerializer

#Step 1:
class BookPageNumberPagination(PageNumberPagination):
    page_ Size = 3 # number of entries per page
    page_ query_ Param = 'page' # query the key of the page
    page_ size_ query_ Param = 'size' # number of items displayed on each page
    max_ page_ Size = 5 # maximum number of entries per page


class BookView(ListAPIView):
    queryset = Books.objects.all()
    serializer_class = BooksSerializer
    
    #Step 2: paging configuration
    pagination_class = BookPageNumberPagination
    
    
# url： http://127.0.0.1:8000/books/?page=1&size=5 Query page 1, showing five pieces of data in total

from rest_framework.generics import ListAPIView
from rest_framework.pagination import LimitOffsetPagination
from app01.models import Books
from app01.ser import BooksSerializer

#Step 1:
class BookLimitOffsetPagination(LimitOffsetPagination):
    default_ Limit = 3 # pieces per page
    limit_ query_ Param = 'limit' # take a few later
    offset_ query_ Param = 'offset' # take several benchmarks from the first one
    max_ Limit = 5 # maximum number of entries per page


class BookView(ListAPIView):
    queryset = Books.objects.all()
    serializer_class = BooksSerializer
    
    #Step 2: paging configuration
    pagination_class = BookLimitOffsetPagination
    
    
# url： http://127.0.0.1:8000/books/?limit=3&offset=4 Start with the third item and then take four pieces of data

from rest_framework.generics import ListAPIView
from rest_framework.pagination import CursorPagination
from app01.models import Books
from app01.ser import BooksSerializer

#Step 1:
class BookCursorPagination(CursorPagination):
    cursor_ query_ Param = 'cursor' # the key of each page query
    page_ Size = 3 # number of items displayed per page
    Ordering = 'ID' # sort field


class BookView(ListAPIView):
    queryset = Books.objects.all()
    serializer_class = BooksSerializer
    
    #Step 2: paging configuration
    pagination_class = BookCursorPagination
    
    
# url：http://127.0.0.1:8000/books/?cursor=cD0z

#1. Define a pager
class BookPageNumberPagination(PageNumberPagination):
    page_ Size = 3 # number of entries per page
    page_ query_ Param = 'page' # query the key of the page
    page_ size_ query_ Param = 'size' # number of items displayed on each page
    max_ page_ Size = 5 # maximum number of entries per page


class BookView(APIView):

    def get(self, request, *args, **kwargs):
        book_list = Books.objects.all()

        #2. Instantiate a pager object
        page_obj = BookPageNumberPagination()
        
        #3. Call paginate_ Queryset returns the data of each page
        book_list = page_obj.paginate_queryset(book_list, request, view=self)

        #4. Get the link from the previous page to the next page
        next_url = page_obj.get_next_link()
        previous_url = page_obj.get_previous_link()

        #5. Serialization
        book_ser = BooksSerializer(book_list, many=True)
        
        #6. Add to the response information
        data = {'next_url': next_url, 'previous_url': previous_url, 'data': book_ser.data}
        return Response(data=data)

def exception_handler(exc, context):
    #First judge whether it is 404
    If isinstance (exc, http404): # exc is the exception object of exception information
        exc = exceptions.NotFound()
    #Then judge whether it is a permission problem
    elif isinstance(exc, PermissionDenied):
        exc = exceptions. Permissiondenied() # for example, a dictionary will be returned for permission problems
        
 #When judging whether you throw API exceptions - > authentication permissions, these are exceptions that inherit the API
    if isinstance(exc, exceptions.APIException):
        headers = {}
        if getattr(exc, 'auth_header', None):
            headers['WWW-Authenticate'] = exc.auth_header
        if getattr(exc, 'wait', None):
            headers['Retry-After'] = '%d' % exc.wait

        if isinstance(exc.detail, (list, dict)):
            data = exc.detail
        else:
            data = {'detail': exc.detail}

        set_rollback()
        return Response(data, status=exc.status_code, headers=headers)
    #As long as the above exceptions are handled
   

    Return none # means that Django will handle some exceptions if they are not handled

#  app01_auth.py
from rest_framework.views import exception_handler
from rest_framework.response import Response

def app01_exception_handler(exc, context):
    response = exception_ Handler (exc, context) # we also need to handle the original DRF
    #There are two cases. One is none, DRF does not handle it, and Django handles it, but the processing does not meet the requirements
    #The response object, DRF, handles what we need


    if not response:
        #If not, we'll deal with it ourselves
        return Response(data={'status': 400, 'error': str(exc)}, status=400)
    else:
        #After DRF has processed it, take out the information it processes and reprocess it
        return Response(data={'status': 400, 'error': response.data.get('detail')}, status=400)

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'app01.app_auth.app01_exception_handler',
}

class APIResponse(Response):
    def __ init__ (self, code = 100, MSG = 'success', data = none, status = none, headers = none, * * kwargs):
        
        dic = {'code': code, 'msg': msg}
        
        if  data:
            dic = {'code': code, 'msg': msg,'data':data}
            
        dic.update(kwargs)
        
        super().__init__(data=dic, status=status,headers=headers)
        
        
#Use
return APIResponse(data={"name":'xiaoyang'},token='dsafsdfa',aa='dsafdsfdee')
return APIResponse(data={"name":'xiaoyang'})
Return apiresponse (code ='101 ', MSG =' error ', data = {"name":' Xiaoyang '}, token ='dsafsdfa', AA ='dsafdee ', header = {})