DRF-Django-通用分页器：django使用可以使用的前后端分离的分页器，自定义drf视图能够使用的分页器

一、model_to_dict实现

utils/model_to_iterable.py

from itertools import chain
from django.db.models.fields import DateTimeField, DateField, CharField, TextField
from datetime import datetime
from django.db.models import Model
import json
'''
封装django自带的将模型转成字典的方法，新增处理DateTimeField和DateField 
'''
def model_to_dict(instance, fields=None, exclude=None, replace=None, default=None):
    """
    :params instance: 模型对象，不能是queryset数据集
    :params fields: 指定要展示的字段数据，('字段1','字段2')
    :params exclude: 指定排除掉的字段数据,('字段1','字段2')
    :params replace: 将字段名字修改成需要的名字，{'数据库字段名':'前端展示名'}
    :params default: 新增不存在的字段数据，{'字段':'数据'}
    """
    # 对传递进来的模型对象校验
    if not isinstance(instance, Model):
        raise Exception('model_to_dict接收的参数必须是模型对象')
    # 对替换数据库字段名字校验
    if replace and type(replace) == dict:
        for replace_field in replace.values():
            if hasattr(instance, replace_field):
                raise Exception(f'model_to_dict,要替换成{replace_field}字段已经存在了')
    # 对要新增的默认值进行校验
    if default and type(default) == dict:
        for default_key in default.keys():
            if hasattr(instance, default_key):
                raise Exception(f'model_to_dict,要新增默认值，但字段{default_key}已经存在了')
    opts = instance._meta
    data = {}
    for f in chain(opts.concrete_fields, opts.private_fields, opts.many_to_many):
        # 源码下：这块代码会将时间字段剔除掉，我加上一层判断，让其不再剔除时间字段
        if not getattr(f, 'editable', False):
            if type(f) == DateField or type(f) == DateTimeField:
                pass
            else:
                continue
        # 如果fields参数传递了，要进行判断
        if fields is not None and f.name not in fields:
            continue
        # 如果exclude 传递了，要进行判断
        if exclude and f.name in exclude:
            continue

        key = f.name
        # 获取字段对应的数据
        if type(f) == DateTimeField:
            # 字段类型是，DateTimeFiled 使用自己的方式操作
            value = getattr(instance, key)
            value = datetime.strftime(value, '%Y-%m-%d %H:%M:%S')
        elif type(f) == DateField:
            # 字段类型是，DateFiled 使用自己的方式操作
            value = getattr(instance, key)
            value = datetime.strftime(value, '%Y-%m-%d')
        elif type(f) == CharField or type(f) == TextField:
            # 字符串数据是否可以进行序列化，转成python结构数据
            value = getattr(instance, key)
            try:
                value = json.loads(value)
            except Exception as _:
                value = value
        else:#其他类型的字段
            # value = getattr(instance, key)
            key = f.name
            value = f.value_from_object(instance)
            # data[f.name] = f.value_from_object(instance)
        # 1、替换字段名字
        if replace and key in replace.keys():
            key = replace.get(key)
        data[key] = value
    #2、新增默认的字段数据
    if default:
        data.update(default)
    return data


def model_to_list(data: list, fields=None, exclude=None, replace=None, default=None):
    '''
    将queryset转成[{},{}] 格式
    :param data:
    :return:
    '''
    all_list = []
    if len(data) == 0:
        return all_list
    if not isinstance(data[0],Model):
        #第一个如果不是模型对象就报错
        raise Exception('model_to_list,内部元素必须是模型对象')

    for dic in data:
        try:
            all_list.append(model_to_dict(dic, fields=fields, exclude=exclude, replace=replace, default=default))
        except Exception as e:
            raise ValueError(str(e))
    return all_list


'''
使用
1、model_to_dict
user = models.User.objects.filter(id=10).first()
data_dic = model_to_dict(user)

2、model_to_list
users = models.User.objects.filter(is_delete=False)
data_lis = model_to_list(users)

'''

二、自定义原生django可以使用的分页器

utils/paginator.py

对于模型对象的序列化，需要借助上面的model_to_list方法

from django.core.paginator import Paginator
from utils.model_to_iterable import model_to_list

'二、（django和drf都通用的分页器）传递queryset或list都可以进行排序的'
class AllGenericPagination:
    '''
    web查询每日看护记录使用的分页器：
    1、使用的django的分页器
    2、传递的数据可以是数据集，也可以是列表套字典[{'id':,'name':},{}]
    '''
    page_query_params = 'page'  # 地址栏传递page，页码
    page_size_query_params = 'page_size'  # 地址栏传递page_size,页面大小
    page_size = 5  # 默认的页面大小

    def __init__(self, object_list, request):
        self.object_list = object_list  # 数据集
        self.request = request  # 当前请求对象
        self.current_page = None
        self.page_size = None

    def get_page(self):
        cls = AllGenericPagination
        try:
            # django视图拿地址栏数据
            page = self.request.GET.get(cls.page_query_params)
        except Exception as _:
            # drf视图拿地址栏数据
            page = self.request.query_params.get(cls.page_query_params)
        # 1、检查page的参数是否有问题
        if not page:
            # 没有携带page参数
            return f'没有携带{cls.page_query_params}参数'
        else:
            try:
                page = int(page)
            except Exception as _:
                # 携带的参数不是数值
                return f'携带参数{cls.page_query_params}不是数值字符串'
        if page <= 0:
            return f'查询页码page参数必须大于0'
        # 2、检查page是否大于最大的页数
        page_tuple = divmod(len(self.object_list), self.get_page_size())
        all_page = page_tuple[0]
        if page_tuple[1]:
            all_page += 1
        if page > all_page:
            # 查询的页码，超过最大页数了
            return f'查询的页码数是{page}超过最大页码数{all_page}'
        # 3、将当前页面数赋值给
        self.current_page = page
        return page

    def get_page_size(self) -> int:
        # page_size字符串
        cls = AllGenericPagination
        try:
            # django视图获取地址栏数据
            page_size = self.request.GET.get(cls.page_size_query_params)
        except Exception as _:
            # drf视图获取地址栏数据
            page_size = self.request.query_params.get(cls.page_size_query_params)
        if not page_size:
            self.page_size = cls.page_size
        else:
            try:
                self.page_size = int(page_size)
            except Exception as _:
                self.page_size = cls.page_size
        return self.page_size

    def _handle_data(self,data_list):
        '''
        :param data_list: 当前页的数据
        :return: 处理后的当前页数据
        '''
        #有些数据需要进一步的处理时，就可以重写这个方法，将处理逻辑放到这里

        return data_list

    def start(self):
        # 1、检查page参数是否正常
        current_page = self.get_page()
        if type(current_page) == str:
            return {'code': 400, 'error': current_page}
        # 2、获取到页面大小
        page_size = self.get_page_size()
        paginator = Paginator(object_list=self.object_list, per_page=page_size, orphans=0, allow_empty_first_page=True)

        # 3、拿到当前页结果集
        page_data = paginator.get_page(current_page)
        # 拿到最终的数据集
        res = page_data.object_list
        try:
            # all 或 filter结尾的查询数据集转成列表
            res = model_to_list(res)
        except Exception as e:
            # values结尾的查询数据集转成列表
            res = list(res)
        # 4、响应数据处理
        res = self._handle_data(res)
        # 5、处理前端需要使用到的字段数据，上一页、下一页、总页数、每页大小、总数据量、当前页
        # 当前页是否有下一页，上一页
        has_next = 0
        has_prev = 0
        # 有下一页：当前页面大于等于1，当前页*页面大小 < 总数量
        if current_page >= 1 and current_page * paginator.per_page < paginator.count:
            has_next = 1
        # 有上一页：当前页大于1，且总数据量要大于页面大小
        if current_page > 1 and paginator.count > paginator.per_page:  # 有上一页，页数大于1，page_size小于总数据量
            has_prev = 1

        dic = {
            'code': 200,
            'msg': '获取数据成功',
            'data': res,  # 当前页的数据
            'current_page': current_page,  # 当前页数
            'count': paginator.count,  # 总数据量
            'page_size': paginator.per_page,  # 每页数据量
            'pages': paginator.num_pages,  # 总页数
            'next': has_next,  # 是否有下一页
            'previous': has_prev  # 是否有上一页
        }
        return dic

'2.1、可以继承上面的分页器：（无需处理数据）'
class WebDailyCarePaginations(AllGenericPagination):
    '''
    web查询每日看护记录使用的分页器：
    1、使用的django的分页器
    2、实例化：传递数据集和request请求
    '''
    pass

'2.2、可以继承上面的分页器：(需要处理数据)'
class WebDailyCarePaginatior(AllGenericPagination):
    '''
    web查询每日看护记录使用的分页器：
    1、使用的django的分页器
    2、实例化：传递数据集和request请求
    '''
    def _handle_data(self,data_list):
        for dic in data_list:
            #处理数据的逻辑
            pass
        return data_list

'''
使用方法:
paginator = AllGenericPagination(列表套字典/queryset,request)
data = paginator.start()
'''

三、drf使用的分页器

utils/paginator.py

from rest_framework.pagination import PageNumberPagination

'一、（drf通用分页器），可以对传递进来的页码进行校验，对传递的页码大小进行异常处理，实例化时，只需要传递request,模型对象集合,模型对象序列化器类'
class GenericPageNumberPagination(PageNumberPagination):
    page_size = 5  # 默认每页数据量
    page_size_query_param = 'page_size'  # 每页大小，从地址栏获取的字符串
    page_query_param = 'page'  # ?page=1跳转页，获取页码的字符串
    max_page_size = 20  # 每页最大数据量

    def __init__(self, request, serializer, queryset):
        '''
        :param request: 当前的请求
        :param serializer:  模型类的序列化器类
        :param queryset:  要操作的模型对象
        '''
        self.request = request
        self.serializer = serializer
        self.queryset = queryset
    #获取前端传递的page_size的数值，给paginate_queryset方法使用的
    def get_page_size(self, request):
        #拿到当前类
        cls = GenericPageNumberPagination
        #拿到前端地址栏中的每页大小
        page_size = request.query_params.get(cls.page_size_query_param)
        if not page_size:
            page_size = request.query_params.get('size',cls.page_size)

        try:
            page_size = int(page_size)
        except Exception as _:
            page_size = cls.page_size
        self.page_size = page_size  # 给对象的page_size赋值
        return page_size
    #检测前端要获取的页码是否有问题
    def check_page(self):
        cls = GenericPageNumberPagination
        try:
            page =self.request.GET.get(cls.page_query_param)
            if not page:
                page = self.request.query_params.get(cls.page_query_param)
        except Exception as _:
            page = self.request.query_params.get(cls.page_query_param)
        #1、检验传递从page是否有问题，None，非数值字符串
        if not page:
            return f'没有携带参数{cls.page_query_param},无法查询'
        else:
            try:
                page = int(page)
            except Exception as _:
                return f'参数{cls.page_query_param}携带的不是数值，无法查询'
            if page<1:
                return f'参数{cls.page_query_param}携带的数值必须大于0'
        #2、判断传递的页码是否超过了最大的页数了
        page_size = self.get_page_size(self.request)
        page_tuple = divmod(len(self.queryset),page_size)
        all_page = page_tuple[0]
        if page_tuple[1]:
            all_page = page_tuple[0]+1
        if page > all_page:
            return f'查询的页码数为{page},超出最大的页数{all_page}范围'
        return page
    #将对分页数据的逻辑存放到这里
    def _handle_data(self,data_list):
        '''
        :param data_list:当前页的数据
        :return: 处理后的当前页的数据
        '''
        #处理的逻辑，一般都是循环data_list,对dict进行处理操作

        return data_list
    #处理数据
    def start(self):
        #1、没有如何数据时，直接返回
        if not self.queryset:
            return {'code':400,'error':'没有相关数据'}
        cls = GenericPageNumberPagination
        #2、检测page传递的数值是否有误
        page_result = self.check_page()
        if type(page_result)==str:
            return {'code':400,'error':page_result}
        # 3、拿到分页后的数据
        page_list = self.paginate_queryset(queryset=self.queryset, request=self.request, view=self)
        # 4、对分页后的数据将进行序列化
        ser = self.serializer(instance=page_list, many=True)
        # 5、如果需要对响应的数据进行下一步的处理，重写_handle_data这个方法
        data = self._handle_data(ser.data)
        # 6、拿到前端需要知道信息，下一页、上一页、总页数、每页大小、总数据量
        count = len(self.queryset)  # 总数据量
        next_page = 1 if self.get_next_link() else 0  # 有下一页，返回1，没有返回0
        previous_page = 1 if self.get_previous_link() else 0  # 有上一页时，返回1，没有返回0
        page_size = self.page_size  # 每页大小
        pages = count // page_size  # 总页数
        current_page = self.request.query_params.get(cls.page_query_param)  # 拿到当前页数

        #对于总页数，如果有余数，就需要加1
        if count % page_size:
            pages += 1
        return {
            'code': 200,
            'msg':'获取数据成功',
            'data': data,  # 当前页的数据
            'next': next_page,  # 是否有下一页
            'previous': previous_page,  # 是否有上一页
            'count': count,  # 总数据量
            'pages': pages,  # 总页数
            'current_page': int(current_page),  # 当前的页数
            'page_size': page_size,  # 每页数据量
        }

'1.1、（继承drf通用分页器），但不需要重写_handle_data方法来处理数据'
class APISizePageNumberPaginations(GenericPageNumberPagination):
    pass

'1.2、（继承drf通用分页器）居住管理：登记老人前查询老人入住状态'
class RegisterPatiensPagination(GenericPageNumberPagination):
    #只需重写_handle_data方法，在这里对响应数据进行处理
    def _handle_data(self,data_list):
        '''
        :param data_list:当前页的数据
        :return: 处理后的当前页的数据
        '''
        #处理的逻辑，一般都是循环data_list,对dict进行处理操作
        for dic in data_list:  # 一个dic是一个老人信息
            #处理数据的逻辑
            pass
        return data_list

'''
使用方法： 内部对page和page_size进行异常处理的操作了
paginator = GenericPageNumberPagination(request,序列器类,查询数据集)
data = paginator.start()  #拿到的数据
'''