greater_wms/warehouse/views.py

from rest_framework import viewsets
from .models import ListModel,DepartmentListModel,BoundTypeListModel,BoundBSListModel,BoundCodeTypeListModel,BoundStatusListModel,ProductListModel,baseset

from . import serializers
from utils.page import MyPageNumberPagination
from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework.response import Response
from .filter import Filter,DepartmentFilter,BoundTypeFilter,BoundBSFilter,BoundCodeTypeFilter,BoundStatusFilter,ProductFilter
from rest_framework.exceptions import APIException
from staff.models import ListModel as StaffListModel
from operation_log.views import log_success_operation, log_failure_operation, log_operation

class APIViewSet(viewsets.ModelViewSet):

    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = Filter

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 ListModel.objects.filter( is_delete=False)
            else:
                return ListModel.objects.filter( id=id, is_delete=False)
        else:
            return ListModel.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.WarehouseGetSerializer
        elif self.action in ['create']:
            return serializers.WarehousePostSerializer
        elif self.action in ['update']:
            return serializers.WarehouseUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.WarehousePartialUpdateSerializer
        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
            if len(data['warehouse_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建仓库失败，仓库名称超过45个字符：{data.get('warehouse_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="仓库管理"
                )
                raise APIException({"detail": "The warehouse name is set to more than 45 characters"})
            if ListModel.objects.filter( warehouse_name=data['warehouse_name'],
                                        is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建仓库失败，仓库已存在：{data.get('warehouse_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="仓库管理"
                )
                raise APIException({"detail": "Data Exists"})
            else:
                # if ListModel.objects.filter(openid=data['openid'], is_delete=False).count() >= 1:
                #     raise APIException({"detail": "You Just Can Add 1 Warehouse"})
                # 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"创建仓库成功，仓库名称：{data.get('warehouse_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="仓库管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建仓库失败：{str(e)}",
                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()
        try:
            

                data = self.request.data
                if len(data['warehouse_name']) > 45:
                    log_failure_operation(
                        request=self.request,
                        operation_content=f"更新仓库失败，仓库名称超过45个字符：{data.get('warehouse_name', '')}",
                        operation_level="update",
                        operator=self.request.auth.name if self.request.auth else None,
                        object_id=pk,
                        module_name="仓库管理"
                    )
                    raise APIException({"detail": "The warehouse name is set to more than 45 characters"})
                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"更新仓库成功，仓库名称：{data.get('warehouse_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="仓库管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新仓库失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="仓库管理"
            )
            raise

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            
            data = self.request.data
            if len(data.get('warehouse_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新仓库失败，仓库名称超过45个字符：{data.get('warehouse_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="仓库管理"
                )
                raise APIException({"detail": "The warehouse name is set to more than 45 characters"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="仓库管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新仓库失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="仓库管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        warehouse_name = getattr(qs, 'warehouse_name', '未知')
        try:
            
                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"删除仓库成功，仓库名称：{warehouse_name}",
                    operation_level="delete",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="仓库管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除仓库失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="仓库管理"
            )
            raise

class DepartmentAPIViewSet(viewsets.ModelViewSet):

    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = DepartmentFilter

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 DepartmentListModel.objects.filter( is_delete=False)
            else:
                return DepartmentListModel.objects.filter( id=id, is_delete=False)
        else:
            return DepartmentListModel.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.DepartmentGetSerializer
        elif self.action in ['create']:
            return serializers.DepartmentPostSerializer
        elif self.action in ['update']:
            return serializers.DepartmentUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.DepartmentPartialUpdateSerializer
        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
            if len(data['department_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建部门失败，部门名称超过45个字符：{data.get('department_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="部门管理"
                )
                raise APIException({"detail": "The department name is set to more than 45 characters"})
            if DepartmentListModel.objects.filter(department_name=data['department_name'],
                                                 is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建部门失败，部门已存在：{data.get('department_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="部门管理"
                )
                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"创建部门成功，部门名称：{data.get('department_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="部门管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建部门失败：{str(e)}",
                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()
        try:
            data = self.request.data
            if len(data['department_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"更新部门失败，部门名称超过45个字符：{data.get('department_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="部门管理"
                )
                raise APIException({"detail": "The department name is set to more than 45 characters"})
            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"更新部门成功，部门名称：{data.get('department_name', '')}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="部门管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新部门失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="部门管理"
            )
            raise

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            data = self.request.data
            if len(data.get('department_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新部门失败，部门名称超过45个字符：{data.get('department_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="部门管理"
                )
                raise APIException({"detail": "The department name is set to more than 45 characters"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="部门管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新部门失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="部门管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        department_name = getattr(qs, 'department_name', '未知')
        try:
            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"删除部门成功，部门名称：{department_name}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="部门管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除部门失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="部门管理"
            )
            raise

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

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 BoundTypeListModel.objects.filter( is_delete=False)
            else:
                return BoundTypeListModel.objects.filter( id=id, is_delete=False)
        else:
            return BoundTypeListModel.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.BoundTypeGetSerializer
        elif self.action in ['create']:
            return serializers.BoundTypePostSerializer
        elif self.action in ['update']:
            return serializers.BoundTypeUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.BoundTypePartialUpdateSerializer
        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
            if len(data['bound_type_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库类型失败，类型名称超过45个字符：{data.get('bound_type_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库类型管理"
                )
                raise APIException({"detail": "The bound type name is set to more than 45 characters"})
            if BoundTypeListModel.objects.filter(bound_type_name=data['bound_type_name'],
                                                 is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库类型失败，类型已存在：{data.get('bound_type_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库类型管理"
                )
                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"创建出入库类型成功，类型名称：{data.get('bound_type_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="出入库类型管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建出入库类型失败：{str(e)}",
                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()
        try:
            data = self.request.data
            if len(data['bound_type_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"更新出入库类型失败，类型名称超过45个字符：{data.get('bound_type_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库类型管理"
                )
                raise APIException({"detail": "The bound type name is set to more than 45 characters"})
            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"更新出入库类型成功，类型名称：{data.get('bound_type_name', '')}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库类型管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新出入库类型失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库类型管理"
            )
            raise

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            data = self.request.data
            if len(data.get('bound_type_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新出入库类型失败，类型名称超过45个字符：{data.get('bound_type_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库类型管理"
                )
                raise APIException({"detail": "The bound type name is set to more than 45 characters"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库类型管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新出入库类型失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库类型管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        bound_type_name = getattr(qs, 'bound_type_name', '未知')
        try:
            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"删除出入库类型成功，类型名称：{bound_type_name}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库类型管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除出入库类型失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库类型管理"
            )
            raise

class BoundBusinessAPIViewSet(viewsets.ModelViewSet):
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = BoundBSFilter
    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 BoundBSListModel.objects.filter( is_delete=False)
            else:
                return BoundBSListModel.objects.filter( id=id, is_delete=False)
        else:
            return BoundBSListModel.objects.none()
        
    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.BoundBSGetSerializer
        elif self.action in ['create']:
            return serializers.BoundBSPostSerializer
        elif self.action in ['update']:
            return serializers.BoundBSUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.BoundBSPartialUpdateSerializer
        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
            if len(data['bound_bs_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库业务失败，业务名称超过45个字符：{data.get('bound_bs_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库业务管理"
                )
                raise APIException({"detail": "The bound bs name is set to more than 45 characters"})
            if BoundBSListModel.objects.filter(bound_bs_name=data['bound_bs_name'],
                                               is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库业务失败，业务已存在：{data.get('bound_bs_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库业务管理"
                )
                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"创建出入库业务成功，业务名称：{data.get('bound_bs_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="出入库业务管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建出入库业务失败：{str(e)}",
                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()
        try:
            data = self.request.data            
            if len(data['bound_bs_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"更新出入库业务失败，业务名称超过45个字符：{data.get('bound_bs_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库业务管理"
                )
                raise APIException({"detail": "The bound bs name is set to more than 45 characters"})
            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"更新出入库业务成功，业务名称：{data.get('bound_bs_name', '')}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库业务管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新出入库业务失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库业务管理"
            )
            raise

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            data = self.request.data
            if len(data.get('bound_bs_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新出入库业务失败，业务名称超过45个字符：{data.get('bound_bs_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库业务管理"
                )
                raise APIException({"detail": "The bound bs name is set to more than 45 characters"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库业务管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新出入库业务失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库业务管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        bound_bs_name = getattr(qs, 'bound_bs_name', '未知')
        try:
            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"删除出入库业务成功，业务名称：{bound_bs_name}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库业务管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除出入库业务失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库业务管理"
            )
            raise

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

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 BoundCodeTypeListModel.objects.filter( is_delete=False)
            else:
                return BoundCodeTypeListModel.objects.filter( id=id, is_delete=False)
        else:
            return BoundCodeTypeListModel.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.BoundCodeTypeGetSerializer
        elif self.action in ['create']:
            return serializers.BoundCodeTypePostSerializer
        elif self.action in ['update']:
            return serializers.BoundCodeTypeUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.BoundCodeTypePartialUpdateSerializer
        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
            if len(data['bound_code_type_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库编码类型失败，类型名称超过45个字符：{data.get('bound_code_type_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库编码类型管理"
                )
                raise APIException({"detail": "The bound code type name is set to more than 45 characters"})
            if BoundCodeTypeListModel.objects.filter(bound_code_type_name=data['bound_code_type_name'],
                                                 is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库编码类型失败，类型已存在：{data.get('bound_code_type_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库编码类型管理"
                )
                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"创建出入库编码类型成功，类型名称：{data.get('bound_code_type_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="出入库编码类型管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建出入库编码类型失败：{str(e)}",
                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()
        try:
            data = self.request.data
            if len(data['bound_code_type_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"更新出入库编码类型失败，类型名称超过45个字符：{data.get('bound_code_type_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库编码类型管理"
                )
                raise APIException({"detail": "The bound code type name is set to more than 45 characters"})
            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"更新出入库编码类型成功，类型名称：{data.get('bound_code_type_name', '')}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库编码类型管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新出入库编码类型失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库编码类型管理"
            )
            raise

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            data = self.request.data
            if len(data.get('bound_code_type_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新出入库编码类型失败，类型名称超过45个字符：{data.get('bound_code_type_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库编码类型管理"
                )
                raise APIException({"detail": "The bound code type name is set to more than 45 characters"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库编码类型管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新出入库编码类型失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库编码类型管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        bound_code_type_name = getattr(qs, 'bound_code_type_name', '未知')
        try:
            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"删除出入库编码类型成功，类型名称：{bound_code_type_name}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库编码类型管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除出入库编码类型失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库编码类型管理"
            )
            raise

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

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 BoundStatusListModel.objects.filter( is_delete=False)
            else:
                return BoundStatusListModel.objects.filter( id=id, is_delete=False)
        else:
            return BoundStatusListModel.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.BoundStatusGetSerializer
        elif self.action in ['create']:
            return serializers.BoundStatusPostSerializer
        elif self.action in ['update']:
            return serializers.BoundStatusUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.BoundStatusPartialUpdateSerializer
        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
            if len(data['bound_status_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库状态失败，状态名称超过45个字符：{data.get('bound_status_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库状态管理"
                )
                raise APIException({"detail": "The bound status name is set to more than 45 characters"})
            if BoundStatusListModel.objects.filter(bound_status_name=data['bound_status_name'],
                                                 is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建出入库状态失败，状态已存在：{data.get('bound_status_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    module_name="出入库状态管理"
                )
                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"创建出入库状态成功，状态名称：{data.get('bound_status_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="出入库状态管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建出入库状态失败：{str(e)}",
                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()
        try:
            data = self.request.data
            if len(data['bound_status_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"更新出入库状态失败，状态名称超过45个字符：{data.get('bound_status_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库状态管理"
                )
                raise APIException({"detail": "The bound status name is set to more than 45 characters"})
            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"更新出入库状态成功，状态名称：{data.get('bound_status_name', '')}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库状态管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新出入库状态失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库状态管理"
            )
            raise

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            data = self.request.data
            if len(data.get('bound_status_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新出入库状态失败，状态名称超过45个字符：{data.get('bound_status_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if self.request.auth else None,
                    object_id=pk,
                    module_name="出入库状态管理"
                )
                raise APIException({"detail": "The bound status name is set to more than 45 characters"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库状态管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新出入库状态失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库状态管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        bound_status_name = getattr(qs, 'bound_status_name', '未知')
        try:
            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"删除出入库状态成功，状态名称：{bound_status_name}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库状态管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除出入库状态失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if self.request.auth else None,
                object_id=pk,
                module_name="出入库状态管理"
            )
            raise



class MultipleViewSet(viewsets.ModelViewSet):

    authentication_classes = []
    pagination_class = MyPageNumberPagination
    permission_classes = []
    throttle_classes = []
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['-id', ]
    filter_class = Filter

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 ListModel.objects.filter(is_delete=False)
            else:
                return ListModel.objects.filter(id=id, is_delete=False)
        else:
            return ListModel.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve']:
            return serializers.WarehouseGetSerializer
        else:
            return self.http_method_not_allowed(request=self.request)            
            
class ProductAPIViewSet(viewsets.ModelViewSet):
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id', "create_time", "update_time", ]
    filter_class = ProductFilter

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 ProductListModel.objects.filter(is_delete=False)
            else:
                return ProductListModel.objects.filter(id=id, is_delete=False)
        else:
            return ProductListModel.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.ProductGetSerializer
        elif self.action in ['create']:
            return serializers.ProductPostSerializer
        elif self.action in ['update']:
            return serializers.ProductUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.ProductPartialUpdateSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def create(self, request, *args, **kwargs):
        # 创建一个数据行
        data = self.request.data
        try:
            if len(data['product_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建产品失败，产品名称超过45个字符：{data.get('product_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    module_name="产品管理"
                )
                raise APIException({"detail": "The product name is set to more than 45 characters"})
            if ProductListModel.objects.filter(product_code=data['product_code'],
                                                 is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"创建产品失败，产品编码已存在：{data.get('product_code', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    module_name="产品管理"
                )
                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"创建产品成功，产品名称：{data.get('product_name', '')}",
                    operation_level="new",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="产品管理"
                )
                return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"创建产品失败：{str(e)}",
                operation_level="new",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                module_name="产品管理"
            )
            raise
    
    def update(self, request, pk):
        # 更新一个数据行
        qs = self.get_object()
        try:
            data = self.request.data
            if len(data['product_name']) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"更新产品失败，产品名称超过45个字符：{data.get('product_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="产品管理"
                )
                raise APIException({"detail": "The product name is set to more than 45 characters"})
            if ProductListModel.objects.filter(product_code=data['product_code'],
                                                is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"更新产品失败，产品编码已存在：{data.get('product_code', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="产品管理"
                )
                raise APIException({"detail": "Data Exists"})
            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"更新产品成功，产品名称：{data.get('product_name', '')}",
                operation_level="update",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="产品管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"更新产品失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="产品管理"
            )
            raise

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            data = self.request.data
            if len(data.get('product_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新产品失败，产品名称超过45个字符：{data.get('product_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="产品管理"
                )
                raise APIException({"detail": "The product name is set to more than 45 characters"})
            if ProductListModel.objects.filter(product_code=data.get('product_code', ''),
                                                is_delete=False).exists():
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新产品失败，产品编码已存在：{data.get('product_code', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="产品管理"
                )
                raise APIException({"detail": "Data Exists"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}",
                operation_level="update",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="产品管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新产品失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="产品管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        product_name = getattr(qs, 'product_name', '未知')
        try:
            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"删除产品成功，产品名称：{product_name}",
                operation_level="delete",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="产品管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除产品失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="产品管理"
            )
            raise

class basesetAPIViewSet(viewsets.ModelViewSet):
    pagination_class = MyPageNumberPagination
    filter_backends = [DjangoFilterBackend, OrderingFilter, ]
    ordering_fields = ['id' ]
    filter_class = Filter

    def get_project(self):
        # 获取项目ID，如果不存在则返回None
        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 baseset.objects.filter(is_delete=False)
            else:
                return baseset.objects.filter(id=id, is_delete=False)
        else:
            return baseset.objects.none()

    def get_serializer_class(self):
        # 根据操作类型选择合适的序列化器
        if self.action in ['list', 'retrieve', 'destroy']:
            return serializers.BaseGetSerializer
        elif self.action in ['create']:
            return serializers.BasePostSerializer
        elif self.action in ['update']:
            return serializers.BaseUpdateSerializer
        elif self.action in ['partial_update']:
            return serializers.BasePartialUpdateSerializer
        else:
            return self.http_method_not_allowed(request=self.request)

    def create(self, request, *args, **kwargs):
        # 创建一个数据行
        data = self.request.data
        staff_openid = self.request.auth.openid
        staff_obj = StaffListModel.objects.filter(openid=staff_openid).first()
        if staff_obj is None:
            raise APIException({"detail": "Staff not exists"})
        if staff_obj.staff_type != 'Admin' :
            raise APIException({"detail": "Permission denied"})
        if len(data['set_name']) > 45:
            raise APIException({"detail": "The base name is set to more than 45 characters"})
        if baseset.objects.filter(set_name=data['set_name'],
                                             is_delete=False).exists():
            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)
            try:
                log_success_operation(
                    request=self.request,
                    operation_content=f"创建基础设置：{data.get('set_name', '未知')}",
                    operation_level="new",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=serializer.data.get('id'),
                    module_name="仓库管理"
                )
            except Exception as e:
                pass
            return Response(serializer.data, status=200, headers=headers)

    def update(self, request, pk):
        # 更新一个数据行
        qs = self.get_object()
        staff_openid = self.request.auth.openid
        staff_obj = StaffListModel.objects.filter(openid=staff_openid).first()
        if staff_obj is None:
            raise APIException({"detail": "Staff not exists"})
        if staff_obj.staff_type != 'Admin' :
            raise APIException({"detail": "Permission denied"})
        data = self.request.data
        if len(data['set_name']) > 45:
            raise APIException({"detail": "The base name is set to more than 45 characters"})
        serializer = self.get_serializer(qs, data=data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        headers = self.get_success_headers(serializer.data)
        try:
            log_success_operation(
                request=self.request,
                operation_content=f"更新基础设置 ID:{pk}：{data.get('set_name', '未知')}",
                operation_level="update",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="仓库管理"
            )
        except Exception as e:
            pass
        return Response(serializer.data, status=200, headers=headers)

    def partial_update(self, request, pk):
        # 部分更新一个数据行
        qs = self.get_object()
        try:
            staff_openid = self.request.auth.openid
            staff_obj = StaffListModel.objects.filter(openid=staff_openid).first()
            if staff_obj is None:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新基础设置失败，员工不存在 ID:{pk}",
                    operation_level="update",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="基础设置管理"
                )
                raise APIException({"detail": "Staff not exists"})
            if staff_obj.staff_type != 'Admin':
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新基础设置失败，权限不足 ID:{pk}",
                    operation_level="update",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="基础设置管理"
                )
                raise APIException({"detail": "Permission denied"})

            data = self.request.data
            if len(data.get('set_name', '')) > 45:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"部分更新基础设置失败，设置名称超过45个字符：{data.get('set_name', '')}",
                    operation_level="update",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="基础设置管理"
                )
                raise APIException({"detail": "The base name is set to more than 45 characters"})
            serializer = self.get_serializer(qs, data=data, partial=True)
            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:{pk}：{data.get('set_name', '未知')}",
                operation_level="update",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="基础设置管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"部分更新基础设置失败 ID:{pk}：{str(e)}",
                operation_level="update",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="基础设置管理"
            )
            raise

    def destroy(self, request, pk):
        # 逻辑删除一个数据行
        qs = self.get_object()
        set_name = getattr(qs, 'set_name', '未知')
        try:
            staff_openid = self.request.auth.openid
            staff_obj = StaffListModel.objects.filter(openid=staff_openid).first()
            if staff_obj is None:
                log_failure_operation(
                    request=self.request,
                    operation_content=f"删除基础设置失败，员工不存在 ID:{pk}",
                    operation_level="delete",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="基础设置管理"
                )
                raise APIException({"detail": "Staff not exists"})
            if staff_obj.staff_type != 'Admin':
                log_failure_operation(
                    request=self.request,
                    operation_content=f"删除基础设置失败，权限不足 ID:{pk}",
                    operation_level="delete",
                    operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                    object_id=pk,
                    module_name="基础设置管理"
                )
                raise APIException({"detail": "Permission denied"})

            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"删除基础设置成功，设置名称：{set_name}",
                operation_level="delete",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="基础设置管理"
            )
            return Response(serializer.data, status=200, headers=headers)
        except APIException:
            raise
        except Exception as e:
            log_failure_operation(
                request=self.request,
                operation_content=f"删除基础设置失败 ID:{pk}：{str(e)}",
                operation_level="delete",
                operator=self.request.auth.name if hasattr(self.request, 'auth') and self.request.auth else None,
                object_id=pk,
                module_name="基础设置管理"
            )
            raise