greater_wms/reportcenter/views.py

from rest_framework import viewsets
from utils.page import MyPageNumberPagination
from utils.md5 import Md5
from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework.response import Response
from rest_framework.exceptions import APIException
from django.http import StreamingHttpResponse
from rest_framework.settings import api_settings
from django.db import transaction  
from rest_framework import status

from reportcenter.models import flowModel as flowlist
from .models import bigScreenModel
from . import serializers
from .filter import FlowFilter, MaterialChangeHistoryFilter, batchLogFilter, ContainerDetailLogFilter,bigScreenFilter
from .files import  FileFlowListRenderCN, MaterialChangeHistoryRenderCN, batchLogRenderCN, ContainerDetailLogRenderCN

from container.models import MaterialChangeHistory,batchLogModel,ContainerDetailLogModel

"""

    path(r'MaterialChangeHistory/', views.MaterialChangeHistoryViewSet.as_view({"get": "list",  }), name="management"),
    path(r'MaterialChangeHistory/file/', views.MaterialChangeHistoryDownloadView.as_view({"get": "list"}), name="flowfile"),    

    path(r'batchLog/', views.batchLogViewSet.as_view({"get": "list",  }), name="management"),
    path(r'batchLog/file/', views.batchLogDownloadView.as_view({"get": "list"}), name="flowfile"),    

    path(r'ContainerDetailLog/', views.ContainerDetailLogViewSet.as_view({"get": "list",  }), name="management"),
    path(r'ContainerDetailLog/file/', views.ContainerDetailLogDownloadView.as_view({"get": "list"}), name="flowfile"),    

"""
from django.utils import timezone
from datetime import datetime, timedelta
from rest_framework.decorators import action
from rest_framework.response import Response
from django.db.models import Q, Max, Min
from decimal import Decimal
from django.db.models import Sum
from django.db.models import OuterRef, Subquery


    


class MaterialChangeHistoryViewSet(viewsets.ModelViewSet):
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "change_time", "create_time", "update_time", ]
    filter_class = MaterialChangeHistoryFilter
    pagination_class = MyPageNumberPagination

    def get_queryset(self):
        return MaterialChangeHistory.objects.all()

    def get_serializer_class(self):
        if self.action in ['list', 'create']:
            return serializers.MaterialChangeHistorySerializer
        else:
            return self.http_method_not_allowed(request=self.request)
        
    
    def summary_complex(self, request):
        """
        获取物料库存变动汇总数据（支持分页）
        请求参数路由上提供:
        - start_time: 开始时间（可选）
        - end_time: 结束时间（可选）
        - material_ids: 物料ID列表（可选）
        - page: 页码（可选）
        - page_size: 每页数量（可选）
        """
        # 获取请求参数 "POST /reportcenter/MaterialChangeHistory/?page=1&page_size=11&goods_code__icontains=UZ 

        start_time = request.query_params.get('start_time') if request.query_params.get('start_time') else None
        end_time = request.quary_params.get('end_time') if request.query_params.get('end_time') else None
        material_ids_code = request.query_params.get('goods_code__icontains') if request.query_params.get('goods_code__icontains') else None
        
        # 记录查询时间范围
        query_time_range = {}
        
        # 如果没有提供时间段，使用当前月份
        if not start_time or not end_time:
            today = timezone.now().date()
            start_time = datetime(today.year, today.month, 1)
            end_time = start_time + timedelta(days=32)
            end_time = datetime(end_time.year, end_time.month, 1) - timedelta(days=1)
            end_time = datetime.combine(end_time, datetime.max.time())
            query_time_range['default_time_range'] = True
        else:
            query_time_range['default_time_range'] = False
        
        # 转换为datetime对象
        if isinstance(start_time, str):
            start_time = datetime.fromisoformat(start_time)
        if isinstance(end_time, str):
            end_time = datetime.fromisoformat(end_time)
        
        # 存储查询时间范围用于返回
        query_time_range['start_time'] = start_time.isoformat()
        query_time_range['end_time'] = end_time.isoformat()
        
        # 创建基础查询集
        queryset = MaterialChangeHistory.objects.filter(
            change_time__gte=start_time,
            change_time__lte=end_time
        )
        
        # 如果有物料ID过滤
        if material_ids_code:
            queryset = queryset.filter(goods_code__icontains=material_ids_code)
            print(f"过滤物料编码包含: {material_ids_code},剩余条目数: {queryset.count()}")
        
        # 获取期初数量（时间段开始时的库存）    
        opening_subquery = MaterialChangeHistory.objects.filter(
            goods_code=OuterRef('goods_code'),
            change_time__lt=start_time
        ).order_by('-change_time').values('closing_quantity')[:1]

        
        opening_data = MaterialChangeHistory.objects.filter(
            change_time__lt=start_time
        )
        if material_ids_code:
            opening_data = opening_data.filter(goods_code__icontains=material_ids_code)
        
        opening_data = opening_data.values('goods_code').annotate(
            opening_quantity=Subquery(opening_subquery)
        )
        
        # 获取期末数量（时间段结束时的库存）
        closing_subquery = MaterialChangeHistory.objects.filter(
            goods_code=OuterRef('goods_code'),  
            change_time__lte=end_time
        ).order_by('-change_time').values('closing_quantity')[:1]
        
        closing_data = MaterialChangeHistory.objects.filter(
            change_time__lte=end_time
        )
        if material_ids_code:
            closing_data = closing_data.filter(goods_code__icontains=material_ids_code)
        
        closing_data = closing_data.values('goods_code').annotate(
            closing_quantity=Subquery(closing_subquery)
        )
        
        # 计算期间出入库总量
        period_data = queryset.values('goods_code').annotate(
            total_in=Sum('in_quantity'),
            total_out=Sum('out_quantity')
        )
        
        # 构建结果字典
        result = {}
        for item in opening_data:
            material_code = item['goods_code']
            goods=MaterialChangeHistory.objects.filter(goods_code=material_code).first()
            result.setdefault(material_code, {
                'material_code': material_code,
                'goods_code': goods.goods_code if goods else 'N/A',
                'goods_desc': goods.goods_desc if goods else 'N/A',
                'goods_unit': goods.goods_unit if goods else 'N/A',
                'opening_quantity': item['opening_quantity'] or Decimal('0'),
                'closing_quantity': Decimal('0'),
                'total_in': Decimal('0'),
                'total_out': Decimal('0'),
                'net_change': Decimal('0'),  # 新增：净含量变化
                'theoretical_change': Decimal('0'),  # 新增：理论变化量
                'is_consistent': True  # 新增：一致性校验
            })
        
        for item in closing_data:
            material_code = item['goods_code']
            goods=MaterialChangeHistory.objects.filter(goods_code=material_code).first()

            if material_code in result:
                result[material_code]['closing_quantity'] = item['closing_quantity'] or Decimal('0')
            else:
                result[material_code] = {
                    'material_code': material_code,
                    'goods_code': goods.goods_code if goods else 'N/A',
                    'goods_desc': goods.goods_desc if goods else 'N/A',
                    'goods_unit': goods.goods_unit if goods else 'N/A',
                    'opening_quantity': Decimal('0'),
                    'closing_quantity': item['closing_quantity'] or Decimal('0'),
                    'total_in': Decimal('0'),
                    'total_out': Decimal('0'),
                    'net_change': Decimal('0'),
                    'theoretical_change': Decimal('0'),
                    'is_consistent': True
                }
        
        for item in period_data:
            material_code = item['goods_code']
            goods=MaterialChangeHistory.objects.filter(goods_code=material_code).first()
            if material_code in result:
                result[material_code]['total_in'] = item['total_in'] or Decimal('0')
                result[material_code]['total_out'] = item['total_out'] or Decimal('0')
            else:
                result[material_code] = {
                    'material_code': material_code,
                    'goods_code': goods.goods_code if goods else 'N/A',
                    'goods_desc': goods.goods_desc if goods else 'N/A',
                    'goods_unit': goods.goods_unit if goods else 'N/A',
                    'opening_quantity': Decimal('0'),
                    'closing_quantity': Decimal('0'),
                    'total_in': item['total_in'] or Decimal('0'),
                    'total_out': item['total_out'] or Decimal('0'),
                    'net_change': Decimal('0'),
                    'theoretical_change': Decimal('0'),
                    'is_consistent': True
                }
        
        # 计算净含量变化和理论变化量，并进行一致性校验
        for material_code, data in result.items():
            # 计算净含量变化（期末 - 期初）
            net_change = data['closing_quantity'] - data['opening_quantity']
            data['net_change'] = net_change
            
            # 计算理论变化量（入库 - 出库）
            theoretical_change = data['total_in'] - data['total_out']
            data['theoretical_change'] = theoretical_change
            
            # 检查是否一致（允许小数点后3位的差异）
            tolerance = Decimal('0.001')
            is_consistent = abs(net_change - theoretical_change) <= tolerance
            data['is_consistent'] = is_consistent
        
        # 转换为列表格式
        result_list = list(result.values())
        
        # 应用分页
        paginator = MyPageNumberPagination()
        page = paginator.paginate_queryset(result_list, request)
        
        # 构建响应数据
        response_data = {
            'query_time_range': query_time_range,
            'count': len(result_list),
            'next': paginator.get_next_link(),
            'previous': paginator.get_previous_link(),
            'results': page
        }
        
        return Response(response_data)
    
    def summary(self, request):
        """
        获取物料库存变动汇总数据（支持分页）
        """
        # 获取请求参数
        start_time = request.query_params.get('start_time') or None
        end_time = request.query_params.get('end_time') or None
        material_ids_code = request.query_params.get('goods_code__icontains') or None
        
        # 记录查询时间范围
        query_time_range = {}
        
        # 如果没有提供时间段，使用当前月份
        if not start_time or not end_time:
            today = timezone.now().date()
            start_time = datetime(today.year, today.month, 1)
            end_time = start_time + timedelta(days=32)
            end_time = datetime(end_time.year, end_time.month, 1) - timedelta(days=1)
            end_time = datetime.combine(end_time, datetime.max.time())
            query_time_range['default_time_range'] = True
        else:
            query_time_range['default_time_range'] = False
        
        # 转换为datetime对象
        if isinstance(start_time, str):
            start_time = datetime.fromisoformat(start_time)
        if isinstance(end_time, str):
            end_time = datetime.fromisoformat(end_time)
        
        # 存储查询时间范围用于返回
        query_time_range['start_time'] = start_time.isoformat()
        query_time_range['end_time'] = end_time.isoformat()
        
        # 创建基础查询集
        queryset = MaterialChangeHistory.objects.filter(
            change_time__gte=start_time,
            change_time__lte=end_time
        )
        
        # 如果有物料ID过滤
        if material_ids_code:
            queryset = queryset.filter(goods_code__icontains=material_ids_code)
        
        # 获取每个物料的期初和期末数量（直接从过滤集中获取）
        material_codes = queryset.values_list('goods_code', flat=True).distinct()
        opening_closing_data = {}
        
        for code in material_codes:
            # 获取该物料在时间段内的第一条记录（最早记录）
            first_record = queryset.filter(goods_code=code).order_by('change_time').first()
            # 获取该物料在时间段内的最后一条记录（最晚记录）
            last_record = queryset.filter(goods_code=code).order_by('-change_time').first()
            
            # 期初数量 = 第一条记录的期初数量
            # 期末数量 = 最后一条记录的期末数量
            opening_closing_data[code] = {
                'opening_quantity': first_record.opening_quantity,
                'closing_quantity': last_record.closing_quantity
            }
        
        # 计算期间出入库总量
        period_data = queryset.values('goods_code').annotate(
            total_in=Sum('in_quantity'),
            total_out=Sum('out_quantity')
        )
        
        # 构建结果字典
        result = {}
        for item in period_data:
            material_code = item['goods_code']
            goods = MaterialChangeHistory.objects.filter(goods_code=material_code).first()
            
            # 获取该物料的期初和期末数量
            oc_data = opening_closing_data.get(material_code, {
                'opening_quantity': Decimal('0'),
                'closing_quantity': Decimal('0')
            })
            
            result[material_code] = {
                'material_code': material_code,
                'goods_code': goods.goods_code if goods else 'N/A',
                'goods_desc': goods.goods_desc if goods else 'N/A',
                'goods_unit': goods.goods_unit if goods else 'N/A',
                'opening_quantity': oc_data['opening_quantity'],
                'closing_quantity': oc_data['closing_quantity'],
                'total_in': item['total_in'] or Decimal('0'),
                'total_out': item['total_out'] or Decimal('0'),
                'net_change': Decimal('0'),  # 后面计算
                'theoretical_change': Decimal('0'),  # 后面计算
                'is_consistent': True
            }
        
        # 计算净含量变化和理论变化量，并进行一致性校验
        for material_code, data in result.items():
            # 净含量变化 = 期末 - 期初
            net_change = data['closing_quantity'] - data['opening_quantity']
            data['net_change'] = net_change
            
            # 理论变化量 = 入库 - 出库
            theoretical_change = data['total_in'] - data['total_out']
            data['theoretical_change'] = theoretical_change
            
            # 检查是否一致（允许小数点后3位的差异）
            tolerance = Decimal('0.001')
            data['is_consistent'] = abs(net_change - theoretical_change) <= tolerance
        
        # 转换为列表格式
        result_list = list(result.values())
        
        # 应用分页
        paginator = MyPageNumberPagination()
        page = paginator.paginate_queryset(result_list, request)
        
        # 构建响应数据
        response_data = {
            'query_time_range': query_time_range,
            'count': len(result_list),
            'next': paginator.get_next_link(),
            'previous': paginator.get_previous_link(),
            'results': page
        }
        
        return Response(response_data)
        
class MaterialChangeHistoryDownloadView(viewsets.ModelViewSet):
    renderer_classes = (MaterialChangeHistoryRenderCN, ) + tuple(api_settings.DEFAULT_RENDERER_CLASSES)
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "change_time", "create_time", "update_time", ]
    filter_class = MaterialChangeHistoryFilter

    def get_project(self):
        try:
            id = self.kwargs.get('pk')
            return id
        except:
            return None

    def get_queryset(self):
        id = self.get_project()
        if self.request.user:
            if id is None:
                return MaterialChangeHistory.objects.filter()
            else:
                return MaterialChangeHistory.objects.filter(id=id)
        else:
            return MaterialChangeHistory.objects.none()

    def get_serializer_class(self):
        if self.action in ['list']:
            return serializers.MaterialChangeHistorySerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def get_render(self, data):
        # lang = self.request.META.get('HTTP_LANGUAGE')
        # if lang:
        #     if lang == 'zh-hans':
        #         return FileListRenderCN().render(data)
        #     else:
        #         return FileListRenderEN().render(data)
        # else:
        #     return FileListRenderEN().render(data)
        return MaterialChangeHistoryRenderCN().render(data)


    def list(self, request, *args, **kwargs):
        from datetime import datetime
        dt = datetime.now()
        data = (
            serializers.MaterialChangeHistorySerializer(instance).data
            for instance in self.filter_queryset(self.get_queryset())
        )
        renderer = self.get_render(data)
        response = StreamingHttpResponse(
            renderer,
            content_type="text/csv"
        )
        response['Content-Disposition'] = "attachment; filename='MaterialChangeHistory_{}.csv'".format(str(dt.strftime('%Y%m%d%H%M%S%f')))
        return response

    

class batchLogViewSet(viewsets.ModelViewSet):
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = batchLogFilter
    pagination_class = MyPageNumberPagination

    def get_queryset(self):
        return batchLogModel.objects.all()

    def get_serializer_class(self):
        if self.action in ['list', 'create']:
            return serializers.batchLogSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

class batchLogDownloadView(viewsets.ModelViewSet):
    renderer_classes = (batchLogRenderCN, ) + tuple(api_settings.DEFAULT_RENDERER_CLASSES)
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = batchLogFilter

    def get_project(self):
        try:
            id = self.kwargs.get('pk')
            return id
        except:
            return None
    def get_queryset(self):
        id = self.get_project()
        if self.request.user:
            if id is None:
                return batchLogModel.objects.filter()
            else:
                return batchLogModel.objects.filter(id=id)
        else:
            return batchLogModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list']:
            return serializers.batchLogSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def get_render(self, data):
        # lang = self.request.META.get('HTTP_LANGUAGE')
        # if lang:
        #     if lang == 'zh-hans':
        #         return FileListRenderCN().render(data)
        #     else:
        #         return FileListRenderEN().render(data)
        # else:
        #     return FileListRenderEN().render(data)
        return batchLogRenderCN().render(data)


    def list(self, request, *args, **kwargs):
        from datetime import datetime
        dt = datetime.now()
        data = (
            serializers.batchLogSerializer(instance).data
            for instance in self.filter_queryset(self.get_queryset()))
        renderer = self.get_render(data)
        response = StreamingHttpResponse(
            renderer,
            content_type="text/csv"
        )
        response['Content-Disposition'] = "attachment; filename='batchLog_{}.csv'".format(str(dt.strftime('%Y%m%d%H%M%S%f')))
        return response

class ContainerDetailLogViewSet(viewsets.ModelViewSet):
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = ContainerDetailLogFilter
    pagination_class = MyPageNumberPagination
    def get_queryset(self):
        return ContainerDetailLogModel.objects.all()

    def get_serializer_class(self):
        if self.action in ['list', 'create']:
            return serializers.ContainerDetailLogSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

class ContainerDetailLogDownloadView(viewsets.ModelViewSet):
    renderer_classes = (ContainerDetailLogRenderCN, ) + tuple(api_settings.DEFAULT_RENDERER_CLASSES)
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = ContainerDetailLogFilter

    def get_project(self):
        try:
            id = self.kwargs.get('pk')
            return id
        except:
            return None

    def get_queryset(self):
        id = self.get_project()
        if self.request.user:
            if id is None:
                return ContainerDetailLogModel.objects.filter()
            else:
                return ContainerDetailLogModel.objects.filter(id=id)
        else:
            return ContainerDetailLogModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list']:
            return serializers.ContainerDetailLogSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def get_render(self, data):
        # lang = self.request.META.get('HTTP_LANGUAGE')
        # if lang:
        #     if lang == 'zh-hans':
        #         return FileListRenderCN().render(data)
        #     else:
        #         return FileListRenderEN().render(data)
        # else:
        #     return FileListRenderEN().render(data)
        return ContainerDetailLogRenderCN().render(data)

    def list(self, request, *args, **kwargs):
        from datetime import datetime
        dt = datetime.now()
        data = (
            serializers.ContainerDetailLogSerializer(instance).data
            for instance in self.filter_queryset(self.get_queryset()))
        renderer = self.get_render(data)
        response = StreamingHttpResponse(
            renderer,
            content_type="text/csv"
        )
        response['Content-Disposition'] = "attachment; filename='ContainerDetailLog_{}.csv'".format(str(dt.strftime('%Y%m%d%H%M%S%f')))
        return response





class FileListDownloadView(viewsets.ModelViewSet):
    renderer_classes = (FileFlowListRenderCN, ) + tuple(api_settings.DEFAULT_RENDERER_CLASSES)
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "document_date" ]
    filter_class = FlowFilter

    def get_project(self):
        try:
            id = self.kwargs.get('pk')
            return id
        except:
            return None

    def get_queryset(self):
        id = self.get_project()
        if self.request.user:
            if id is None:
                return flowlist.objects.filter()
            else:
                return flowlist.objects.filter(id=id)
        else:
            return flowlist.objects.none()

    def get_serializer_class(self):
        if self.action in ['list']:
            return serializers.flowSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def get_render(self, data):
        # lang = self.request.META.get('HTTP_LANGUAGE')
        # if lang:
        #     if lang == 'zh-hans':
        #         return FileListRenderCN().render(data)
        #     else:
        #         return FileListRenderEN().render(data)
        # else:
        #     return FileListRenderEN().render(data)
        return FileFlowListRenderCN().render(data)


    def list(self, request, *args, **kwargs):
        from datetime import datetime
        dt = datetime.now()
        data = (
            serializers.flowSerializer(instance).data
            for instance in self.filter_queryset(self.get_queryset())
        )
        renderer = self.get_render(data)
        response = StreamingHttpResponse(
            renderer,
            content_type="text/csv"
        )
        response['Content-Disposition'] = "attachment; filename='stocklist_{}.csv'".format(str(dt.strftime('%Y%m%d%H%M%S%f')))
        return response

class FlowsStatsViewSet(viewsets.ModelViewSet):

    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]

    filter_class = FlowFilter
    pagination_class = MyPageNumberPagination
   


    """
        list:
            Response a data list（all）
        post:
            Create a new data（create）
    """
    

    def get_project(self):
        try:
            id = self.kwargs.get('pk')
            return id
        except:
            return None
    

    def get_queryset(self):
        id = self.get_project()

        if self.request.user:
            if id is None:
                return flowlist.objects.filter()
            else:
                return flowlist.objects.filter(id=id)
        else:
            return flowlist.objects.none()

    def get_serializer_class(self):
        if self.action in ['list', 'create', ]:
            return serializers.flowSerializer
        # elif self.action in ['retrieve','update',]:
        #     return serializers.stocklistpartialSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    # def create(self, request, *args, **kwargs):
    #     data = request.data.copy()
    #     warehouse_code = data.get('warehouse_code')
    #     warehouse_name = data.get('warehouse_name')
    #     shelf_type = data.get('shelf_type')
    #     shelf_name = data.get('shelf_name')
        
    #     rows = int(data.get('rows', 0))
    #     cols = int(data.get('cols', 0))
    #     layers = int(data.get('layers', 0))

        
    #     existing_positions = flowlist.get_existing_positions(warehouse_code,shelf_name, rows, cols, layers)

    #     # 生成所有可能的坐标
    #     instances = []
    #     for r in range(1, rows+1):
    #         for c in range(1, cols+1):
    #             for l in range(1, layers+1):
    #                 if (r, c, l) not in existing_positions  :
    #                     instances.append(flowlist(
    #                         warehouse_code=warehouse_code,
    #                         warehouse_name=warehouse_name,
    #                         shelf_type=shelf_type,
    #                         shelf_name=shelf_name,
    #                         row=r,
    #                         col=c,
    #                         layer=l,

    #                     ))
    #     try:
    #         with transaction.atomic():
    #             flowlist.objects.bulk_create(instances, batch_size=1000)
    #     except Exception as e:
    #         return Response(
    #             {"error": str(e)},
    #             status=status.HTTP_500_INTERNAL_SERVER_ERROR
    #         )

    #     return Response({
    #         "created": len(instances),
    #         "skipped": (rows*cols*layers) - len(instances)
    #     }, status=status.HTTP_201_CREATED)
        
    # def update(self, request, pk):
    #     qs = self.get_object()
    #     print(qs.id)
    #     # return Response({"detail": "暂不支持修改"}, status=status.HTTP_400_BAD_REQUEST)
       
    #     data = self.request.data
    #     print(data)
    #     serializer = self.get_serializer(qs, data=data)
    #     serializer.is_valid(raise_exception=True)
    #     serializer.save()
    #     headers = self.get_success_headers(serializer.data)
    #     return Response(serializer.data, status=200, headers=headers)

    # def retrieve(self, request, pk):
    #     qs = self.get_object()
    #     serializer = self.get_serializer(qs)
    #     return Response(serializer.data)

class bigScreenModelViewSet(viewsets.ModelViewSet):
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = bigScreenFilter
    pagination_class = MyPageNumberPagination
    def get_project(self):
        try:
            id = self.kwargs.get('pk')
            return id
        except:
            return None
    def get_queryset(self):
        id = self.get_project()
        if self.request.user:
            if id is None:
                return bigScreenModel.objects.filter()
            else:
                return bigScreenModel.objects.filter(id=id)
        else:
            return bigScreenModel.objects.none()
    def get_serializer_class(self):
        if self.action in ['list', 'create', ]:
            return serializers.bigScreenSerializer
        # elif self.action in ['retrieve','update',]:
        #     return serializers.stocklistpartialSerializer
        else:
            return self.http_method_not_allowed(request=self.request)