greater_wms/bound/views.py

from rest_framework import viewsets
from utils.page import MyPageNumberPagination
from utils.datasolve import sumOfList, transportation_calculate
from utils.md5 import Md5
from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend
from django.db import transaction
from rest_framework.response import Response
from rest_framework.exceptions import APIException
from django.utils import timezone
from django.db.models import Sum
from django.http import StreamingHttpResponse
from rest_framework.settings import api_settings
from .models import BoundListModel, BoundDetailModel,BoundBatchModel, BatchOperateLogModel, OutBatchModel,OutBoundDetailModel,MaterialStatistics,OutBoundDemandModel
from .files import BatchFileRenderCN

from .serializers import BoundListGetSerializer,BoundListPostSerializer,BoundBatchGetSerializer,BoundBatchPostSerializer,BoundDetailGetSerializer,BoundDetailPostSerializer
from .serializers import OutBoundDetailGetSerializer,OutBoundDetailPostSerializer,OutBatchGetSerializer,OutBatchPostSerializer,BatchLogGetSerializer
from .serializers import MaterialStatisticsSerializer,MaterialStatisticsSerializer_items
from .serializers import OutBoundDemandModelSerializer
from .filter import BoundListFilter, BoundDetailFilter,BoundBatchFilter
from .filter import OutBatchFilter,OutBoundDetailFilter,BatchlogFilter
from .filter import MaterialStatisticsFilter
from .filter import OutBoundDemandFilter
# 以后添加模块检验
from warehouse.models import ListModel as warehouse
from staff.models import ListModel as staff
from rest_framework.permissions import AllowAny
from rest_framework.views import APIView
from operation_log.views import log_operation,log_failure_operation,log_success_operation
from django.db.models import F


# 出库需求视图类
class OutBoundDemandViewSet(viewsets.ModelViewSet):
    """
        retrieve:
            Response a data list（get）
        list:
            Response a data list（all）
        create:
            Create a data line（post）

        delete:
            Delete a data line（delete)

    """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = OutBoundDemandFilter
    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 OutBoundDemandModel.objects.filter( is_delete=False)
            else:
                return OutBoundDemandModel.objects.filter( id=id, is_delete=False)
        else:
            return OutBoundDemandModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list' ]:
            return OutBoundDemandModelSerializer
        else:
            return OutBoundDemandModelSerializer
    
    def batch_list(self, request):
        data =self.request.data
        OutBoundDemand_all = OutBoundDemandModel.objects.filter(bound_list_id=data['bound_list_id'], is_delete=False).all()
        data = OutBoundDemandModelSerializer(OutBoundDemand_all, many=True).data
        return_data ={
                "code": 200,
                "msg": "Success Create",
            	"data": data
        }
        log_operation(
            request=self.request,
            operation_content=f"查询出库需求列表，出库单ID:{data.get('bound_list_id')}",
            operation_level="view",
            operator=self.request.auth.name if self.request.auth else None,
            module_name="出库需求"
        )
        return Response(return_data,status=200,headers={})

  
    def create(self, request, *args, **kwargs):
        data = self.request.data
        try:
            data['openid'] = self.request.auth.openid
            data['create_time'] = str(timezone.now().strftime('%Y-%m-%d %H:%M:%S'))
            data['update_time'] = str(timezone.now().strftime('%Y-%m-%d %H:%M:%S'))
            data['working'] = True
            bound_list_obj = BoundListModel.objects.get(id=data['bound_list_id'])

            OutBoundDemand_obj =OutBoundDemandModel.objects.create(
                bound_list=bound_list_obj, 
                goods_code=data['goods_code'], 
                goods_desc=data['goods_desc'], 
                goods_std=data['goods_std'], 
                goods_unit=data['goods_unit'], 
                goods_qty=data['goods_out_qty'],
                out_type = data['out_type'],
                creater=data['creater'], 
                create_time=data['create_time'],
                update_time=data['update_time'], 
                working=data['working']
                )
            return_data = OutBoundDemandModelSerializer(OutBoundDemand_obj).data
            headers = self.get_success_headers(return_data)
            log_success_operation(
                request=self.request,
                operation_content=f"创建出库需求 ID:{OutBoundDemand_obj.id},创建内容：{data}",
                operation_level="new",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=OutBoundDemand_obj.id,
                module_name="出库需求"
            )
            return Response(return_data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建出库需求失败: {str(e)}, 创建内容：{data}",
                operation_level="new",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="出库需求"
            )
            raise
    
    def batch_demanded_list(self, request):
        data =self.request.data
        OutBoundDemand_all = OutBatchModel.objects.filter(bound_list_id=data['bound_list_id'], is_delete=False).all()
        data = OutBatchGetSerializer(OutBoundDemand_all, many=True).data
        return_data = {
            "code": 200,
            "msg": "Success Create",
            "data": data
        }
        log_operation(
            request=self.request,
            operation_content=f"查询出库批次列表，出库单ID:{data.get('bound_list_id')}",
            operation_level="view",
            operator=self.request.auth.name if self.request.auth else None,
            module_name="出库批次"
        )
        return Response(return_data,status=200,headers={})

    def distribute(self, request):
        """主分配入口"""
        try:
            with transaction.atomic():
                bound_list_id, demands,out_type, creater= self.validate_distribute_request(request)

                if OutBatchModel.objects.filter(bound_list_id=bound_list_id, is_delete=False).exists():
                    log_operation(
                        request=self.request,
                        operation_content=f"出库分配失败，出库单ID:{bound_list_id} 已分配，请勿重复分配",
                        operation_level="other",
                        operator=self.request.auth.name if self.request.auth else None,
                        module_name="出库分配"
                    )
                    return_data = {
                        "code": 200,
                        "msg": "Success Create",
                        "data": {
                            "msg": "该订单已分配，请勿重复分配"
                        }
                    }
                    return Response(return_data, status=200, headers={})
                aggregated_demands = self.aggregate_demands(demands)
                result = self.process_all_goods(aggregated_demands, request, out_type, creater,bound_list_id)
                log_success_operation(
                    request=self.request,
                    operation_content=f"出库分配成功，出库单ID:{bound_list_id}，分配结果：{result}",
                    operation_level="other",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=bound_list_id,
                    module_name="出库分配"
                )
                return self.build_success_response(result)
        except APIException as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"出库分配失败，出库单ID:{request.data.get('bound_list_id')}，错误：{e.detail}",
                operation_level="other",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="出库分配"
            )
            return self.build_error_response(e.detail, 200)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"出库分配异常，出库单ID:{request.data.get('bound_list_id')}，错误：{str(e)}",
                operation_level="other",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="出库分配"
            )
            return self.build_error_response(str(e), 200)

    # 验证层方法
    def validate_distribute_request(self, request):
        """验证请求参数"""
        bound_list_id = request.data.get('bound_list_id')
        if not bound_list_id:
            raise APIException({"detail": "Missing bound_list_id"})

        demands = OutBoundDemandModel.objects.filter(
            bound_list_id=bound_list_id,
            is_delete=False
        )
        if not demands.exists():
            raise APIException({"detail": "No demands found"})
        base_info = OutBoundDemandModel.objects.filter(
            bound_list_id=bound_list_id,
            is_delete=False
        ).first()
        out_type = base_info.out_type
        creater = base_info.creater

        return bound_list_id, demands, out_type, creater

    # 数据处理层方法
    def aggregate_demands(self, demands):
        """合并相同物料需求"""
        return demands.values('goods_code').annotate(
            total_demand=Sum('goods_qty')
        )

    # 核心分配逻辑
    def process_all_goods(self, aggregated_demands, request, out_type, creater,bound_list_id):
        """处理所有物料分配"""
        return [
            self.process_single_goods(
                goods_code=item['goods_code'],
                total_demand=item['total_demand'],
                request=request,
                out_type=out_type,
                creater=creater,
                bound_list_id=bound_list_id

            )
            for item in aggregated_demands
        ]

    def process_single_goods(self, goods_code, total_demand, request,out_type, creater,bound_list_id):
        """处理单个物料分配"""
        batches = self.get_available_batches(goods_code)
        remaining, allocations = self.allocate_batches(total_demand, batches, request,out_type, creater,bound_list_id)
        
        if remaining > 0:
            raise APIException({
                "detail": f"Insufficient stock for {goods_code}",
                "required": total_demand,
                "allocated": total_demand - remaining
            })
        
        return {
            "goods_code": goods_code,
            "total_demand": total_demand,
            "allocations": allocations
        }

    def get_available_batches(self, goods_code):
        """获取可用入库批次"""
        return BoundBatchModel.objects.filter(
            goods_code=goods_code,
            is_delete=False
        ).order_by('bound_batch_order')

    # 批次分配逻辑
    def allocate_batches(self, total_demand, batches, request,out_type, creater,bound_list_id):
        """分配具体批次"""
        remaining = total_demand
        allocations = []
        
        for batch in batches:
            if remaining <= 0:
                break
            
            allocated = self.allocate_single_batch(
                batch=batch,
                remaining=remaining,
                request=request,
                out_type=out_type,
                creater=creater,
                bound_list_id=bound_list_id

            )
            
            if allocated == 0:
                continue
                
            allocations.append(allocated)
            remaining -= allocated['allocated']
        
        return remaining, allocations

    def allocate_single_batch(self, batch, remaining, request,out_type, creater,bound_list_id):
        """单个批次分配逻辑"""
        available = batch.goods_in_location_qty - batch.goods_out_qty
        if available <= 0:
            return 0

        allocate_qty = min(remaining, available)
        self.update_batch_status(batch, allocate_qty)
        out_batch = self.create_out_batch(batch, allocate_qty, request,out_type, creater,bound_list_id)
        
        return {
            "batch": batch.bound_number,
            "allocated": allocate_qty,
            "out_batch": out_batch.out_number
        }

    # 数据操作层方法
    def update_batch_status(self, batch, allocate_qty):
        """更新批次状态和数量"""
        batch.goods_out_qty += allocate_qty
        
        if batch.goods_out_qty == batch.goods_in_location_qty:
            batch.status = 6  # 已出库
        elif batch.goods_out_qty > 0:
            batch.status = 5  # 部分出库
            
        batch.save()

    def create_out_batch(self, batch, allocate_qty, request,out_type, creater,bound_list_id):
        """创建出库记录"""
        out_data = {
            'bound_list': bound_list_id,
            'out_number': self.generate_out_number(batch.goods_code),
            'batch_number': batch.id,
            'out_date': timezone.now(),
            'warehouse_code': batch.warehouse_code,
            'warehouse_name': batch.warehouse_name,
            'goods_code': batch.goods_code,
            'goods_desc': batch.goods_desc,
            'goods_out_qty': allocate_qty,
            'status': 0,
            'openid': request.auth.openid,
            'out_type': out_type,
            'creater': creater,


        }
        
        serializer = OutBatchPostSerializer(data=out_data)
        if not serializer.is_valid():
            raise APIException({
                "detail": f"Serialization error for {batch.goods_code}",
                "errors": serializer.errors
            })
            
        return serializer.save()

    # 工具方法
    def generate_out_number(self, goods_code):
        """生成唯一出库单号"""
        timestamp = timezone.now().strftime("%Y%m%d%H%M%S")
        import uuid

        return f"OUT-{goods_code}-{timestamp}-{uuid.uuid4().hex[:6]}"

    def build_success_response(self, data):
        """构建成功响应"""
        return Response({
            "code": 200,
            "msg": "Distribution completed",
            "data": data
        })

    def build_error_response(self, error, status_code):
        """构建错误响应"""
        return Response({
            "code": status_code,
            "msg": "Distribution failed" if status_code == 400 else "Server error",
            "error": error
        }, status=status_code)

# 物料统计视图类
class MaterialStatisticsViewSet(viewsets.ModelViewSet):
    """
        retrieve:
            Response a data list（get）
        list:
            Response a data list（all）
        create:
            Create a data line（post）

        delete:
            Delete a data line（delete)

    """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = MaterialStatisticsFilter

    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 MaterialStatistics.objects.filter()
            else:
                return MaterialStatistics.objects.filter(id=id)
        else:
            return MaterialStatistics.objects.none()

    def get_serializer_class(self):
        if self.action in ['list' ]:
            return MaterialStatisticsSerializer
        elif self.action in ['retrieve']:
            return MaterialStatisticsSerializer_items
        else:
            return self.http_method_not_allowed(request=self.request)

# 汇报单类视图
class BoundListViewSet(viewsets.ModelViewSet):
    """
        retrieve:
            Response a data list（get）
        list:
            Response a data list（all）
        create:
            Create a data line（post）

        delete:
            Delete a data line（delete)

    """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = BoundListFilter

    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 BoundListModel.objects.filter( is_delete=False)
            else:
                log_operation(
                    request=self.request,
                    operation_content=f"查看入库单详情 ID:{id}",
                    operation_level="view",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=id,
                    module_name="入库单"
                )
                return BoundListModel.objects.filter( id=id, is_delete=False)
        else:
            return BoundListModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list', 'destroy','retrieve']:
            return BoundListGetSerializer
        elif self.action in ['create', 'update']:
            return BoundListPostSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def create(self, request, *args, **kwargs):

        data = self.request.data
        # if BoundListModel.objects.filter(code=data['code'], is_delete=False).exists():
        #     raise APIException({"detail": "Data exists"})
        # else:
        data['openid'] = self.request.auth.openid
        data['bound_date'] =str(timezone.now().strftime('%Y-%m-%d'))
        order_day=str(timezone.now().strftime('%Y-%m-'))
        data['bound_month'] =str(timezone.now().strftime('%Y%m'))
        if data['bound_type'] == 'in':
            data['bound_status'] = '100'
        else:
            data['bound_status'] = '200'
        

        qs_set = BoundListModel.objects.filter(bound_month=data['bound_month'], bound_code_type=data['bound_code_type'], is_delete=False)
        print('qs_set是:', len(qs_set))
        if len(qs_set) > 0:
            bound_last_code = qs_set.order_by('-id').first().bound_code
            data['bound_code'] = data['bound_code_type'] +'-'+ order_day + str(int(bound_last_code.split('-')[-1])+1).zfill(4)
        else:
            data['bound_code'] = data['bound_code_type'] +'-'+ order_day + '0001'

        serializer = self.get_serializer(data=data)
        serializer.is_valid(raise_exception=True)
        try:
            serializer.save()
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"创建入库单 ID:{serializer.data['id']},创建内容：{data}",
                operation_level="new",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="入库单"
            )
            return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建入库单失败: {str(e)}, 创建内容：{data}",
                operation_level="new",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="入库单"
            )
            raise
    
    def update(self, request, pk):
        qs = self.get_object()
        data = self.request.data
        try:
            serializer = self.get_serializer(qs, data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"更新入库单 ID:{serializer.data['id']}：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="入库单"
            )
            return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新入库单失败 ID:{qs.id}：{str(e)}, 更新内容：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="入库单"
            )
            raise


    def destroy(self, request, pk):
        qs = self.get_object()
        # if qs.openid != self.request.auth.openid:
        #     raise APIException({"detail": "该入库非您所属，禁止删除，您可以进行编辑"})
        # else:
        qs.is_delete = True
        qs.bound_code =qs.bound_code+'-delete'+str(timezone.now().strftime('%Y%m%d%H%M%S'))
        qs.save()
        if qs.bound_type == 'in':
            BoundDetailModel.objects.filter(bound_list=qs.id).update(is_delete=True)
            if qs.relate_bill:
                qs.relate_bill.bound_status = 0
                qs.relate_bill.save()
        else:
            OutBoundDemandModel.objects.filter(bound_list=qs.id).update(is_delete=True)
            if qs.relate_out_bill:
                qs.relate_out_bill.bound_status = 0
                qs.relate_out_bill.save()
        serializer = self.get_serializer(qs, many=False)
        headers = self.get_success_headers(serializer.data)
        log_success_operation(
            request=self.request,
            operation_content=f"删除入库单 ID:{qs.id}",
            operation_level="delete",
            operator=self.request.auth.name if self.request.auth else None,
            object_id=qs.id,
            module_name="入库单"
        )
        return Response(serializer.data, status=200, headers=headers)

# 入库批次类视图
class BoundBatchViewSet(viewsets.ModelViewSet):
    """
        retrieve:
            Response a data list（get）
            list:
            Response a data list（all）
            create:
            Create a data line（post）
        delete:
            Delete a data line（delete)
            """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = BoundBatchFilter

    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 BoundBatchModel.objects.filter( is_delete=False)
            else:
                return BoundBatchModel.objects.filter( id=id, is_delete=False)
        else:
            return BoundBatchModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list', 'destroy','retrieve']:
            return BoundBatchGetSerializer
        elif self.action in ['create', 'update']:
            return BoundBatchPostSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def create(self, request, *args, **kwargs):
        data = self.request.data
        try:
            data['openid'] = self.request.auth.openid
            data['goods_total_weight'] = data['goods_weight']*data['goods_qty']
        
            order_day=str(timezone.now().strftime('-%Y%m'))
            order_month=str(timezone.now().strftime('%Y%m'))
            data['bound_month'] =str(timezone.now().strftime('%Y%m'))
            # print(data['order'])
            if data['order'] == 'true':
                qs_set = BoundBatchModel.objects.filter( goods_code=data['goods_code'], bound_month=order_month,  is_delete=False)
                print('qs_set是:', len(qs_set))
                if len(qs_set) > 0:
                    bound_last_code = qs_set.order_by('-bound_batch_order').first().bound_number
                    data['bound_batch_order'] = int(bound_last_code.split('-')[-1])+1
                    data['bound_number'] = data['goods_code'] + '-' + str(int(bound_last_code.split('-')[-1])+1)
                else:
                    data['bound_batch_order'] = int(order_day.split('-')[-1])*1000 +1
                    data['bound_number'] = data['goods_code'] + order_day + '001'
            else:
                data['bound_number'] = data['goods_code'] + '-' + str(data['bound_batch_order'])
            batch_obj = BoundBatchModel.objects.filter(bound_number=data['bound_number'], is_delete=False)
            if batch_obj.exists():
                # 批次号已存在,追加数据到原批次
                existing_batch = batch_obj.first()
                existing_batch.goods_qty += data['goods_qty']
                existing_batch.goods_total_weight += data['goods_total_weight']
                existing_batch.update_time = timezone.now()
                existing_batch.save()
                log_success_operation(
                    request=self.request,
                    operation_content=f"创建入库批次 ID:{existing_batch.id} 成功，追加数据：{data}",
                    operation_level="create",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=existing_batch.id,
                    module_name="入库批次"
                )
                self.add_batch_log(existing_batch.__dict__, 0, data['goods_qty'])
                serializer = self.get_serializer(existing_batch, many=False)
                headers = self.get_success_headers(serializer.data)
                return Response(serializer.data, status=200, headers=headers)
            
            else:   
            
                serializer = self.get_serializer(data=data)
                serializer.is_valid(raise_exception=True)
                serializer.save()
                headers = self.get_success_headers(serializer.data)
                self.add_batch_log(serializer.data, 0, data['goods_qty'])
                log_success_operation(
                    request=self.request,
                    operation_content=f"创建入库批次 ID:{serializer.data['id']},创建内容：{data}",
                    operation_level="create",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data['id'],
                    module_name="入库批次"
                )
                return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            print(e)
            log_failure_operation(
                request=self.request,
                operation_content=f"创建入库批次失败: {str(e)}, 创建内容：{data}",
                operation_level="new",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="入库批次"
            )
            raise APIException({"detail": "{}".format(e)})
    
    def add_batch_log(self, data, log_type, goods_qty):
        choices_dict = dict(BatchOperateLogModel.BATCH_LOG_TYPE)
        log_type_name = choices_dict.get(log_type, "未知类型")
        
        try:
            # 获取 BoundBatchModel 实例
            batch_obj = BoundBatchModel.objects.get(id=data['id'])
        except BoundBatchModel.DoesNotExist:

            return False

        log_data = {
            'batch_id': batch_obj,  
            'log_type': log_type,
            'log_date': timezone.now().strftime('%Y-%m-%d-%H:%M'),  # 直接格式化时间，无需转字符串
            'goods_code': data['goods_code'],
            'goods_desc': data['goods_desc'],
            'goods_qty': data['goods_qty'],
            'log_content': f"{log_type_name} {data['goods_qty']}件",
            'creater': data['creater'],
            'openid': data['openid'],
            'is_delete': False,
            
        }
        
        # 创建日志记录
        BatchOperateLogModel.objects.create(**log_data)
        return True


    def update(self, request, pk):
        qs = self.get_object()
        data = self.request.data
        try:
            serializer = self.get_serializer(qs, data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"更新入库批次 ID:{serializer.data['id']}：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="入库批次"
            )
            return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新入库批次失败 ID:{qs.id}：{str(e)}, 更新内容：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="入库批次"
            )
            raise

    def destroy(self, request, pk):
        qs = self.get_object()
        if qs.openid != self.request.auth.openid:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除入库批次 ID:{qs.id} 失败，非所属用户操作",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="入库批次"
            )
            raise APIException({"detail": "该入库非您所属，禁止删除，您可以进行编辑"})
        else:
            qs.is_delete = True
            qs.save()
            serializer = self.get_serializer(qs, many=False)
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"删除入库批次 ID:{qs.id}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="入库批次"
            )
            return Response(serializer.data, status=200, headers=headers)

    def batchinout(self, request, *args, **kwargs):
        from container.models import ContainerDetailModel, ContainerListModel
        from decimal import Decimal
        
        batch_number = request.data.get('batch_number')
        batch_in_qty = request.data.get('batch_in_qty')
        
        if not batch_number:
            log_failure_operation(
                request=self.request,
                operation_content=f"批次进出库失败，批次号不能为空",
                operation_level="other",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="入库批次"
            )
            return Response({"code": 200,"message": "批次号不能为空","data": "批次进出库数目：{batch_in_qty}"}, status=200)
            
        try:
            batch_obj = BoundBatchModel.objects.get(bound_number=batch_number, is_delete=False)
        except BoundBatchModel.DoesNotExist:
            log_failure_operation(
                request=self.request,
                operation_content=f"批次进出库失败，批次号不存在：{batch_number}",
                operation_level="other",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="入库批次"
            )
            return Response({"code": 200,"message": "批次号不存在","data": "批次进出库数目：{batch_in_qty}"}, status=200)


        
        if batch_in_qty:

            # 获取或创建虚拟容器
            virtual_container, created = ContainerListModel.objects.get_or_create(
                container_code=1
       
            )
            

            # 使用 update_or_create 避免并发问题
            virtual_container_detail = ContainerDetailModel.objects.create(
                month=timezone.now().strftime('%Y%m'),
                container= virtual_container,
                batch= batch_obj,
                goods_class= 1,  # 成品
                goods_code= batch_obj.goods_code,
                goods_desc= batch_obj.goods_desc,
                goods_qty= Decimal(batch_in_qty),
                goods_out_qty= Decimal(0),
                goods_weight= batch_obj.goods_weight,
                status= 2,  # 在库
                creater=  "system",
                create_time= timezone.now(),
                update_time= timezone.now(),
                is_delete= False   )

            virtual_container_detail.save()

            virtual_container_detail.goods_out_qty = batch_in_qty
            virtual_container_detail.save()

        log_success_operation(
            request=self.request,
            operation_content=f"批次进出库 ID:{batch_obj.id} 成功，进出库数目：{batch_in_qty}",
            operation_level="create",
            operator=self.request.auth.name if self.request.auth else None,
            object_id=batch_obj.id,
            module_name="入库批次"
        )
        return Response({"code": 200,"message": "操作成功","data": "批次进出库数目：{batch_in_qty}"}, status=200)


class BatchFileDownloadView(viewsets.ModelViewSet):
    """批次文件下载视图类"""
    renderer_classes = (BatchFileRenderCN, ) + tuple(api_settings.DEFAULT_RENDERER_CLASSES)
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = BoundBatchFilter

    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:
                queryset = BoundBatchModel.objects.filter(is_delete=False)
                # 支持 goods_in_location_qty__gt 过滤器，用于只下载在库数量大于0的批次
                if self.request.query_params.get('goods_in_location_qty__gt'):
                    queryset = queryset.filter(goods_in_location_qty__gt=0)
                return queryset
            else:
                return BoundBatchModel.objects.filter(id=id, is_delete=False)
        else:
            return BoundBatchModel.objects.none()

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

    def get_render(self, data):
        return BatchFileRenderCN().render(data)

    def list(self, request, *args, **kwargs):
        from datetime import datetime
        dt = datetime.now()
        data = (
            BoundBatchGetSerializer(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='batch_剩余量_{}.csv'".format(str(dt.strftime('%Y%m%d%H%M%S%f')))
        log_operation(
            request=self.request,
            operation_content=f"下载批次剩余量文件",
            operation_level="download",
            operator=self.request.auth.name if self.request.auth else None,
            module_name="批次文件下载"
        )
        return response

   

# 入库明细类视图      
class BoundDetailViewSet(viewsets.ModelViewSet):
    """
        retrieve:
            Response a data list（get）
            list:
            Response a data list（all）
        create:
            Create a data line（post）
        delete:
            Delete a data line（delete)
            """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = BoundDetailFilter

    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 BoundDetailModel.objects.filter( is_delete=False)
            else:
                return BoundDetailModel.objects.filter( id=id, is_delete=False)
        else:
            return BoundDetailModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list', 'destroy','retrieve']:
            return BoundDetailGetSerializer
        elif self.action in ['create', 'update']:
            return BoundDetailPostSerializer
        else:
            return self.http_method_not_allowed(request=self.request)


    def create(self, request, *args, **kwargs):
        data = self.request.data
        data['openid'] = self.request.auth.openid
        data.setdefault('is_delete', False)
        # 验证并保存数据
        data['detail_code'] = f"DC-{data['bound_list']:02}{data['bound_batch']:02}"
        print(data['detail_code'])
        if BoundDetailModel.objects.filter(bound_list=data['bound_list'], bound_batch=data['bound_batch'], is_delete=False).exists():
            detail_obj = BoundDetailModel.objects.get(bound_list=data['bound_list'], bound_batch=data['bound_batch'], is_delete=False)
            serializer = self.get_serializer(detail_obj, many=False)
            headers = self.get_success_headers(serializer.data)
            log_operation(
                request=self.request,
                operation_content=f"查询入库明细，入库单ID:{data['bound_list']}, 批次ID:{data['bound_batch']}",
                operation_level="view",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=detail_obj.id,
                module_name="入库明细"
            )
            return Response(serializer.data, status=200, headers=headers)
        else:
            serializer = self.get_serializer(data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()

            # 返回响应
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"创建入库明细 ID:{serializer.data['id']},创建内容：{data}",
                operation_level="create",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="入库明细"
            )
            return Response(serializer.data, status=200, headers=headers)
    
    def update(self, request, pk):
        qs = self.get_object()
        data = self.request.data
        try:
            serializer = self.get_serializer(qs, data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"更新入库明细 ID:{serializer.data['id']}：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="入库明细"
            )
            return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新入库明细失败 ID:{qs.id}：{str(e)}, 更新内容：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="入库明细"
            )
            raise

    def destroy(self, request, pk):
        qs = self.get_object()
        if qs.openid != self.request.auth.openid:
            raise APIException({"detail": "该入库非您所属，禁止删除，您可以进行编辑"})
            log_failure_operation(
                request=self.request,
                operation_content=f"删除入库明细 ID:{qs.id} 失败，非所属用户操作",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="入库明细"
            )
        else:
            qs.is_delete = True
            qs.save()
            serializer = self.get_serializer(qs, many=False)
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"删除入库明细 ID:{qs.id}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="入库明细"
            )
            return Response(serializer.data, status=200, headers=headers)

# 出库明细类视图      
class OutBoundDetailViewSet(viewsets.ModelViewSet):
    """
        retrieve:
            Response a data list（get）
            list: Response a data list（all）
        create:
            Create a data line（post）
        delete:
            Delete a data line（delete)
    """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = OutBoundDetailFilter

    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 OutBoundDetailModel.objects.filter( is_delete=False)
            else:
                return OutBoundDetailModel.objects.filter( id=id, is_delete=False)
        else:
            return OutBoundDetailModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list', 'destroy','retrieve']:
            return OutBoundDetailGetSerializer
        elif self.action in ['create', 'update']:
            return OutBoundDetailPostSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def create(self, request, *args, **kwargs):
        data = self.request.data
        try:
            data['openid'] = self.request.auth.openid
            data.setdefault('is_delete', False)

            data['bound_batch_number'] = OutBatchModel.objects.get(id=data['bound_batch']).batch_number.id
            # 验证并保存数据
            data['detail_code'] = f"DC-{data['bound_list']:02}{data['bound_batch']:02}"
            # print(data['detail_code'])
            if OutBoundDetailModel.objects.filter(detail_code=data['detail_code'], is_delete=False).exists():
                # 这里追加数目
                detail_obj = OutBoundDetailModel.objects.filter(detail_code=data['detail_code'], is_delete=False).first()
                OutBoundDetailModel.objects.filter(detail_code=data['detail_code'], is_delete=False).update(goods_qty=F('goods_qty')+data['goods_qty'])
                log_success_operation(
                    request=self.request,
                    operation_content=f"更新出库明细 ID:{detail_obj.id}，数量追加：{data['goods_qty']}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=detail_obj.id,
                    module_name="出库明细"
                )
                return Response({"detail": "数据存在，数量追加"}, status=200)
                # raise APIException({"detail": "Data exists"})
            else:
                serializer = self.get_serializer(data=data)
                serializer.is_valid(raise_exception=True)
                serializer.save()

                # 返回响应
                headers = self.get_success_headers(serializer.data)
                log_success_operation(
                    request=self.request,
                    operation_content=f"创建出库明细 ID:{serializer.data['id']},创建内容：{data}",
                    operation_level="create",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data['id'],
                    module_name="出库明细"
                )
                return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建出库明细失败: {str(e)}, 创建内容：{data}",
                operation_level="new",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="出库明细"
            )
            raise

    def update(self, request, pk):
        qs = self.get_object()
        data = self.request.data
        try:
            serializer = self.get_serializer(qs, data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"更新出库明细 ID:{serializer.data['id']}：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="出库明细"
            )
            return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新出库明细失败 ID:{qs.id}：{str(e)}, 更新内容：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="出库明细"
            )
            raise

    def destroy(self, request, pk):
        qs = self.get_object()
        if qs.openid != self.request.auth.openid:
            raise APIException({"detail": "该入库非您所属，禁止删除，您可以进行编辑"})
            log_failure_operation(
                request=self.request,
                operation_content=f"删除出库明细 ID:{qs.id} 失败，非所属用户操作",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="出库明细"
            )
        else:
            qs.is_delete = True
            qs.save()
            serializer = self.get_serializer(qs, many=False)
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"删除出库明细 ID:{qs.id}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="出库明细"
            )
            return Response(serializer.data, status=200, headers=headers)       

# 出库批次类视图      
class OutBoundBatchViewSet(viewsets.ModelViewSet):
    """
        retrieve:
            Response a data list（get）
            list:
            Response a data list（all）
            create:
            Create a data line（post）
        delete:
            Delete a data line（delete)
            """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = OutBatchFilter

    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 OutBatchModel.objects.filter( is_delete=False)
            else:
                return OutBatchModel.objects.filter( id=id, is_delete=False)
        else:
            return OutBatchModel.objects.none()

    def get_serializer_class(self):
        if self.action in ['list', 'destroy','retrieve']:
            return OutBatchGetSerializer
        elif self.action in ['create', 'update']:
            return OutBatchPostSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def create(self, request, *args, **kwargs):
        data = self.request.data
        try:
            batch_obj = BoundBatchModel.objects.get(bound_number=data['out_number'])
            if batch_obj is None:
                raise APIException({"detail": "批次不存在"})

            bound_obj = BoundListModel.objects.get(id=data['bound_list_id'])
            data['bound_list'] = bound_obj.id
            data['batch_number'] = batch_obj.id
            data['out_date'] = str(timezone.now().strftime('%Y-%m-%d %H:%M:%S'))

            data['openid'] = self.request.auth.openid
            data.setdefault('is_delete', False)
            data['goods_total_weight'] = data['goods_weight']*data['goods_out_qty']
            from decimal import Decimal

            #  data['goods_out_qty'] 是一个字符串或浮点数
            data['goods_out_qty'] = Decimal(str(data['goods_out_qty']))
            from decimal import Decimal
            data['goods_out_qty'] = Decimal(str(data['goods_out_qty']))
            data['goods_qty'] = batch_obj.goods_qty - batch_obj.goods_reserve_qty - data['goods_out_qty']

            data['status'] = 0  #现在处于出库申请状态
       
            serializer = self.get_serializer(data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            headers = self.get_success_headers(serializer.data)
            self.add_batch_log(serializer.data, 1, data['goods_out_qty'])
            log_success_operation(
                request=self.request,
                operation_content=f"创建出库批次 ID:{serializer.data['id']},创建内容：{data}",
                operation_level="create",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="出库批次"
            )
            
            return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建出库批次失败: {str(e)}, 创建内容：{data}",
                operation_level="new",
                operator=self.request.auth.name if self.request.auth else None,
                module_name="出库批次"
            )
            raise

    def update(self, request, pk):        
        qs = self.get_object()
        data = self.request.data
        try:
            data['openid'] = self.request.auth.openid
            data.setdefault('is_delete', False)
            data['goods_total_weight'] = data['goods_weight']*data['goods_qty']
            serializer = self.get_serializer(qs, data=data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            headers = self.get_success_headers(serializer.data)
            self.add_batch_log(serializer.data, 1, data['goods_qty'])
            log_success_operation(
                request=self.request,
                operation_content=f"更新出库批次 ID:{serializer.data['id']}：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=serializer.data['id'],
                module_name="出库批次"
            )
            return Response(serializer.data, status=200, headers=headers)
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新出库批次失败 ID:{qs.id}：{str(e)}, 更新内容：{data}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="出库批次"
            )
            raise

    def destroy(self, request, pk):
        qs = self.get_object()
        if qs.openid != self.request.auth.openid:            
            raise APIException({"detail": "该出库非您所属，禁止删除，您可以进行编辑"})
            log_failure_operation(
                request=self.request,
                operation_content=f"删除出库批次 ID:{qs.id} 失败，非所属用户操作",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="出库批次"
            )

        else:
            qs.is_delete = True
            qs.save()
            serializer = self.get_serializer(qs, many=False)
            headers = self.get_success_headers(serializer.data)
            log_success_operation(
                request=self.request,
                operation_content=f"删除出库批次 ID:{qs.id}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=qs.id,
                module_name="出库批次"
                )
            return Response(serializer.data, status=200, headers=headers)

    def add_batch_log(self, data, log_type, goods_qty):
        choices_dict = dict(BatchOperateLogModel.BATCH_LOG_TYPE)
        log_type_name = choices_dict.get(log_type, "未知类型")

        try:
            # 获取 BoundBatchModel 实例
            batch_obj = BoundBatchModel.objects.get(id=data['batch_number'])
        except BoundBatchModel.DoesNotExist:
            # 处理批次不存在的情况（如记录日志或抛出异常）
            return False

        log_data = {            
            'batch_id': batch_obj,  # 关键修复：传入实例对象，而不是 batch_obj.id
            'log_type': log_type,
            'log_date': timezone.now().strftime('%Y-%m-%d-%H:%M'),  # 直接格式化时间，无需转字符串
            'goods_code': data['goods_code'],
            'goods_desc': data['goods_desc'],
            'goods_qty': data['goods_qty'],
            'log_content': f"{log_type_name} {goods_qty}件",
            'creater': data['creater'],
            'openid': data['openid'],
            'is_delete': False,
            # 注意：create_time 和 update_time 由模型的 auto_now_add 和 auto_now 自动处理，无需手动赋值
        }

        # 创建日志记录
        BatchOperateLogModel.objects.create(**log_data)

        return True 

# 批次操作日志类视图      
class BoundBatchLogViewSet(viewsets.ModelViewSet):
    
    """
        retrieve:
            Response a data list（get）
            list:
            Response a data list（all）
     
            delete:
            Delete a data line（delete)
    """ 
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = BatchlogFilter

    def get_queryset(self):

        return BatchOperateLogModel.objects.filter( is_delete=False)
        

    def get_serializer_class(self):
        if self.action in ['list', 'destroy','retrieve']:
            return BatchLogGetSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def destroy(self, request, pk):
        qs = self.get_object()
        qs.is_delete = True
        qs.save()
        log_success_operation(
            request=self.request,
            operation_content=f"删除批次操作日志 ID:{qs.id}",
            operation_level="delete",
            operator=self.request.auth.name if self.request.auth else None,
            object_id=qs.id,
            module_name="批次操作日志"
        )
        serializer = self.get_serializer(qs, many=False)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=200, headers=headers)  

# 托盘类视图      
class BatchContainerAPIView(APIView):
    """
        post:
            返回批次对应的container列表
    """
    # authentication_classes = []  # 禁用所有认证类
    # permission_classes = [AllowAny]  # 允许任意访问
    def post(self, request):
        data = request.data
        batch_id = data.get('batch_id')
        from container.models import ContainerDetailModel
        from bin.models import LocationContainerLink


        container_detail_all = ContainerDetailModel.objects.filter(batch_id=batch_id, is_delete=False).exclude(status=3).all()
        container_dict = {}

        for container_detail in container_detail_all:
            container_id = container_detail.container_id
            link_obj = LocationContainerLink.objects.filter(container_id=container_id,is_active=True).first()


            if container_id not in container_dict:
                container_dict[container_id] = {
                    'id': container_id,
                    'goods_code': container_detail.goods_code,
                    'goods_desc': container_detail.goods_desc,
                    'container_code': container_detail.container.container_code,
                    'current_location': container_detail.container.current_location,
                    'goods_qty': container_detail.goods_qty-container_detail.goods_out_qty,
                    'class':container_detail.goods_class,
                    'location_c_number' : link_obj.location.c_number if link_obj else None,
                    'location_max_capacity': link_obj.location.max_capacity if link_obj else None,
                    'location_group': link_obj.location.location_group if link_obj else None,
                    'location_code': link_obj.location.location_code if link_obj else None,
                }
            else:
                container_dict[container_id]['goods_qty'] += container_detail.goods_qty-container_detail.goods_out_qty
        container_dict = list(container_dict.values())
        return_data = {'code': 200,'msg': 'Success Create', 'data': container_dict}
        log_success_operation(
            request=self.request,
            operation_content=f"查询批次对应托盘 ID:{batch_id} 列表",
            operation_level="view",
            operator=self.request.auth.name if self.request.auth else None,
            object_id=batch_id,
            module_name="批次对应托盘"
        )
        return Response(return_data)