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"),    

"""

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)
        
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)