功能：新增托盘二维码与用户分配

2026-07-26 11:48:22 +08:00
parent f3eda856b0
commit 6851499be2
7 changed files with 1635 additions and 2 deletions
@@ -0,0 +1,133 @@
+from typing import Annotated
+
+from fastapi import Path, Query, Request, Response
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from common.annotation.log_annotation import Log
+from common.aspect.db_seesion import DBSessionDependency
+from common.aspect.interface_auth import UserInterfaceAuthDependency
+from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency
+from common.enums import BusinessType
+from common.router import APIRouterPro
+from common.vo import DataResponseModel, PageResponseModel, ResponseBaseModel
+from module_admin.entity.vo.user_vo import CurrentUserModel
+from module_business.entity.vo.master_vo import (
+    DeletePalletModel,
+    PalletCreateModel,
+    PalletEditModel,
+    PalletModel,
+    PalletPageQueryModel,
+)
+from module_business.service.pallet_service import PalletService
+from utils.response_util import ResponseUtil
+
+pallet_controller = APIRouterPro(
+    prefix='/master/pallet', tags=['基础资料-托盘管理'], dependencies=[PreAuthDependency()]
+)
+
+
+@pallet_controller.get(
+    '/list',
+    summary='获取托盘分页列表接口',
+    description='用于获取托盘分页列表',
+    response_model=PageResponseModel[PalletModel],
+    dependencies=[UserInterfaceAuthDependency('master:pallet:list')],
+)
+async def get_master_pallet_list(
+    request: Request,
+    pallet_page_query: Annotated[PalletPageQueryModel, Query()],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+) -> Response:
+    result = await PalletService.list_pallet(query_db, pallet_page_query, is_page=True)
+    return ResponseUtil.success(model_content=result)
+
+
+@pallet_controller.get(
+    '/{pallet_id}/qrcode',
+    summary='补打托盘二维码接口',
+    description='使用托盘原有固定标识重新生成二维码',
+    response_class=Response,
+    responses={200: {'content': {'image/png': {}}}},
+    dependencies=[UserInterfaceAuthDependency('master:pallet:print')],
+)
+async def query_master_pallet_qrcode(
+    request: Request,
+    pallet_id: Annotated[int, Path(gt=0, description='托盘ID')],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+) -> Response:
+    png = await PalletService.get_pallet_qrcode(query_db, pallet_id)
+    return Response(content=png, media_type='image/png')
+
+
+@pallet_controller.get(
+    '/{pallet_id}',
+    summary='获取托盘详情接口',
+    description='用于获取指定托盘的详细信息',
+    response_model=DataResponseModel[PalletModel],
+    dependencies=[UserInterfaceAuthDependency('master:pallet:query')],
+)
+async def query_detail_master_pallet(
+    request: Request,
+    pallet_id: Annotated[int, Path(gt=0, description='托盘ID')],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+) -> Response:
+    result = await PalletService.detail_pallet(query_db, pallet_id)
+    return ResponseUtil.success(data=result)
+
+
+@pallet_controller.post(
+    '',
+    summary='新增托盘接口',
+    description='用于新增托盘及初始库存',
+    response_model=ResponseBaseModel,
+    dependencies=[UserInterfaceAuthDependency('master:pallet:add')],
+)
+@Log(title='托盘管理', business_type=BusinessType.INSERT)
+async def add_master_pallet(
+    request: Request,
+    add_pallet: PalletCreateModel,
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
+) -> Response:
+    result = await PalletService.add_pallet(query_db, add_pallet, current_user.user.user_name)
+    return ResponseUtil.success(msg=result.message)
+
+
+@pallet_controller.put(
+    '',
+    summary='编辑托盘接口',
+    description='仅编辑托盘容量、资产状态和备注',
+    response_model=ResponseBaseModel,
+    dependencies=[UserInterfaceAuthDependency('master:pallet:edit')],
+)
+@Log(title='托盘管理', business_type=BusinessType.UPDATE)
+async def edit_master_pallet(
+    request: Request,
+    edit_pallet: PalletEditModel,
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
+) -> Response:
+    result = await PalletService.edit_pallet(query_db, edit_pallet, current_user.user.user_name)
+    return ResponseUtil.success(msg=result.message)
+
+
+@pallet_controller.delete(
+    '/{pallet_ids}',
+    summary='删除托盘接口',
+    description='用于删除尚未入库且没有流转事件的托盘',
+    response_model=ResponseBaseModel,
+    dependencies=[UserInterfaceAuthDependency('master:pallet:remove')],
+)
+@Log(title='托盘管理', business_type=BusinessType.DELETE)
+async def delete_master_pallet(
+    request: Request,
+    pallet_ids: Annotated[
+        str,
+        Path(pattern=r'^[1-9]\d*(,[1-9]\d*)*$', description='需要删除的托盘ID'),
+    ],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
+) -> Response:
+    delete_pallet = DeletePalletModel(palletIds=[int(pallet_id) for pallet_id in pallet_ids.split(',')])
+    result = await PalletService.remove_pallet(query_db, delete_pallet)
+    return ResponseUtil.success(msg=result.message)
@@ -12,13 +12,61 @@ from common.enums import BusinessType
 from common.router import APIRouterPro
 from common.vo import DataResponseModel, PageResponseModel, ResponseBaseModel
 from module_admin.entity.vo.user_vo import CurrentUserModel
-from module_business.entity.vo.master_vo import DeleteSiteModel, SiteModel, SitePageQueryModel
+from module_business.entity.vo.master_vo import (
+    BusinessUserOptionModel,
+    DeleteSiteModel,
+    SiteModel,
+    SitePageQueryModel,
+    UserAssignModel,
+)
 from module_business.service.master_service import MasterService
+from module_business.service.pallet_service import PalletService
 from utils.response_util import ResponseUtil

+ASSIGN_LOG = Log
+ASSIGN_CURRENT_USER = CurrentUserDependency
+
 site_controller = APIRouterPro(
    prefix='/master/site', tags=['基础资料-客户现场管理'], dependencies=[PreAuthDependency()]
 )
+site_user_controller = APIRouterPro(
+    prefix='/master/site', tags=['基础资料-客户现场用户分配'], dependencies=[PreAuthDependency()]
+)
+
+
+@site_user_controller.get(
+    '/{site_id}/users',
+    summary='获取客户现场可分配用户接口',
+    description='获取启用且未删除的用户及客户现场分配状态',
+    response_model=DataResponseModel[list[BusinessUserOptionModel]],
+    dependencies=[UserInterfaceAuthDependency('master:site:assign')],
+)
+async def get_master_site_users(
+    request: Request,
+    site_id: Annotated[int, Path(gt=0, description='客户现场ID')],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+) -> Response:
+    users = await PalletService.list_site_users(query_db, site_id)
+    return ResponseUtil.success(data=users)
+
+
+@site_user_controller.put(
+    '/{site_id}/users',
+    summary='分配客户现场用户接口',
+    description='完整替换客户现场的用户关联',
+    response_model=ResponseBaseModel,
+    dependencies=[UserInterfaceAuthDependency('master:site:assign')],
+)
+@ASSIGN_LOG(title='客户现场用户分配', business_type=BusinessType.GRANT)
+async def assign_master_site_users(
+    request: Request,
+    site_id: Annotated[int, Path(gt=0, description='客户现场ID')],
+    assignment: UserAssignModel,
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+    current_user: Annotated[CurrentUserModel, ASSIGN_CURRENT_USER()],
+) -> Response:
+    result = await PalletService.assign_site_users(query_db, site_id, assignment)
+    return ResponseUtil.success(msg=result.message)


@site_controller.get(
@@ -12,13 +12,61 @@ from common.enums import BusinessType
 from common.router import APIRouterPro
 from common.vo import DataResponseModel, PageResponseModel, ResponseBaseModel
 from module_admin.entity.vo.user_vo import CurrentUserModel
-from module_business.entity.vo.master_vo import DeleteWarehouseModel, WarehouseModel, WarehousePageQueryModel
+from module_business.entity.vo.master_vo import (
+    BusinessUserOptionModel,
+    DeleteWarehouseModel,
+    UserAssignModel,
+    WarehouseModel,
+    WarehousePageQueryModel,
+)
 from module_business.service.master_service import MasterService
+from module_business.service.pallet_service import PalletService
 from utils.response_util import ResponseUtil

+ASSIGN_LOG = Log
+ASSIGN_CURRENT_USER = CurrentUserDependency
+
 warehouse_controller = APIRouterPro(
    prefix='/master/warehouse', tags=['基础资料-仓库管理'], dependencies=[PreAuthDependency()]
 )
+warehouse_user_controller = APIRouterPro(
+    prefix='/master/warehouse', tags=['基础资料-仓库用户分配'], dependencies=[PreAuthDependency()]
+)
+
+
+@warehouse_user_controller.get(
+    '/{warehouse_id}/users',
+    summary='获取仓库可分配用户接口',
+    description='获取启用且未删除的用户及仓库分配状态',
+    response_model=DataResponseModel[list[BusinessUserOptionModel]],
+    dependencies=[UserInterfaceAuthDependency('master:warehouse:assign')],
+)
+async def get_master_warehouse_users(
+    request: Request,
+    warehouse_id: Annotated[int, Path(gt=0, description='仓库ID')],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+) -> Response:
+    users = await PalletService.list_warehouse_users(query_db, warehouse_id)
+    return ResponseUtil.success(data=users)
+
+
+@warehouse_user_controller.put(
+    '/{warehouse_id}/users',
+    summary='分配仓库用户接口',
+    description='完整替换仓库的用户关联',
+    response_model=ResponseBaseModel,
+    dependencies=[UserInterfaceAuthDependency('master:warehouse:assign')],
+)
+@ASSIGN_LOG(title='仓库用户分配', business_type=BusinessType.GRANT)
+async def assign_master_warehouse_users(
+    request: Request,
+    warehouse_id: Annotated[int, Path(gt=0, description='仓库ID')],
+    assignment: UserAssignModel,
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
+    current_user: Annotated[CurrentUserModel, ASSIGN_CURRENT_USER()],
+) -> Response:
+    result = await PalletService.assign_warehouse_users(query_db, warehouse_id, assignment)
+    return ResponseUtil.success(msg=result.message)


@warehouse_controller.get(
@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Any, Literal

 from pydantic import BaseModel
@@ -6,9 +7,11 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm.attributes import InstrumentedAttribute

 from common.vo import PageModel
+from module_admin.entity.do.user_do import SysUser
 from module_business.entity.do.master_do import (
    BizCustomer,
    BizCustomerSite,
+    BizPallet,
    BizProductionLine,
    BizStrain,
    BizUserSite,
@@ -29,6 +32,8 @@ from module_business.entity.vo.master_vo import (
    CustomerPageQueryModel,
    LineModel,
    LinePageQueryModel,
+    PalletEditModel,
+    PalletPageQueryModel,
    SiteModel,
    SitePageQueryModel,
    StrainModel,
@@ -357,6 +362,128 @@ class MasterDao:
    async def delete_warehouse(cls, db: AsyncSession, warehouse_id: int) -> None:
        await cls._delete(db, BizWarehouse, BizWarehouse.warehouse_id, warehouse_id)

+    @classmethod
+    async def list_pallet(
+        cls,
+        db: AsyncSession,
+        query_object: PalletPageQueryModel,
+        is_page: bool = True,
+    ) -> PageModel | list[dict[str, Any]]:
+        conditions = []
+        if query_object.pallet_code:
+            conditions.append(BizPallet.pallet_code.like(f'%{query_object.pallet_code}%'))
+        if query_object.asset_status:
+            conditions.append(BizPallet.asset_status == query_object.asset_status)
+        statement = select(BizPallet).where(*conditions).order_by(BizPallet.pallet_id)
+        return await cls._paginate(db, statement, query_object, is_page)
+
+    @classmethod
+    async def get_pallet(
+        cls,
+        db: AsyncSession,
+        pallet_id: int,
+        *,
+        for_update: bool = False,
+    ) -> BizPallet | None:
+        statement = select(BizPallet).where(BizPallet.pallet_id == pallet_id)
+        if for_update:
+            statement = statement.with_for_update()
+        result = await db.execute(statement)
+        return result.scalar_one_or_none()
+
+    @classmethod
+    async def find_pallet_by_code(cls, db: AsyncSession, pallet_code: str) -> BizPallet | None:
+        return await cls._find(db, BizPallet, BizPallet.pallet_code, pallet_code)
+
+    @classmethod
+    async def add_pallet(cls, db: AsyncSession, pallet: BizPallet) -> BizPallet:
+        db.add(pallet)
+        await db.flush()
+        return pallet
+
+    @classmethod
+    async def update_pallet(
+        cls,
+        db: AsyncSession,
+        pallet: PalletEditModel,
+        update_by: str,
+        update_time: datetime,
+    ) -> None:
+        await db.execute(
+            update(BizPallet)
+            .where(BizPallet.pallet_id == pallet.pallet_id)
+            .values(
+                capacity_packages=pallet.capacity_packages,
+                asset_status=pallet.asset_status,
+                remark=pallet.remark,
+                update_by=update_by,
+                update_time=update_time,
+            )
+        )
+
+    @classmethod
+    async def delete_pallet(cls, db: AsyncSession, pallet_id: int) -> None:
+        await cls._delete(db, BizPallet, BizPallet.pallet_id, pallet_id)
+
+    @classmethod
+    async def get_pallet_inventory(
+        cls,
+        db: AsyncSession,
+        pallet_id: int,
+        *,
+        for_update: bool = False,
+    ) -> BizPalletInventory | None:
+        statement = select(BizPalletInventory).where(BizPalletInventory.pallet_id == pallet_id)
+        if for_update:
+            statement = statement.with_for_update()
+        result = await db.execute(statement)
+        return result.scalar_one_or_none()
+
+    @classmethod
+    async def add_pallet_inventory(
+        cls,
+        db: AsyncSession,
+        inventory: BizPalletInventory,
+    ) -> BizPalletInventory:
+        db.add(inventory)
+        await db.flush()
+        return inventory
+
+    @classmethod
+    async def delete_pallet_inventory(cls, db: AsyncSession, pallet_id: int) -> None:
+        await cls._delete(db, BizPalletInventory, BizPalletInventory.pallet_id, pallet_id)
+
+    @classmethod
+    async def count_pallet_events(cls, db: AsyncSession, pallet_id: int) -> int:
+        result = await db.execute(
+            select(func.count('*')).select_from(BizPalletEvent).where(BizPalletEvent.pallet_id == pallet_id)
+        )
+        return result.scalar() or 0
+
+    @classmethod
+    async def list_assignable_users(cls, db: AsyncSession) -> list[Any]:
+        result = await db.execute(
+            select(SysUser.user_id, SysUser.user_name, SysUser.nick_name)
+            .where(SysUser.status == '0', SysUser.del_flag == '0')
+            .order_by(SysUser.user_id)
+        )
+        return list(result.all())
+
+    @classmethod
+    async def list_assignable_users_by_ids(cls, db: AsyncSession, user_ids: list[int]) -> list[Any]:
+        if not user_ids:
+            return []
+        result = await db.execute(
+            select(SysUser.user_id, SysUser.user_name, SysUser.nick_name)
+            .where(
+                SysUser.user_id.in_(user_ids),
+                SysUser.status == '0',
+                SysUser.del_flag == '0',
+            )
+            .order_by(SysUser.user_id)
+        )
+        return list(result.all())
+
    @classmethod
    async def count_references(
        cls,
@@ -389,3 +389,19 @@ class UserAssignModel(BaseModel):
    user_ids: list[PositiveId] = Field(min_length=1, description='用户ID列表')

    _validate_unique_ids = field_validator('user_ids')(_ensure_unique_ids)
+
+
+class BusinessUserOptionModel(BaseModel):
+    """仓库或客户现场可分配用户的最小只读模型。"""
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        from_attributes=True,
+        populate_by_name=True,
+        extra='forbid',
+    )
+
+    user_id: PositiveId = Field(description='用户ID')
+    user_name: str = Field(min_length=1, max_length=30, pattern=r'\S', description='用户账号')
+    nick_name: str | None = Field(default=None, max_length=30, description='用户昵称')
+    assigned: bool = Field(description='是否已分配')
@@ -0,0 +1,282 @@
+import secrets
+from datetime import datetime
+from io import BytesIO
+from typing import Any, Literal
+
+import qrcode
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from common.vo import CrudResponseModel, PageModel
+from exceptions.exception import ServiceException
+from module_business.dao.access_dao import AccessDao
+from module_business.dao.master_dao import MasterDao
+from module_business.domain.enums import PalletFlowState
+from module_business.entity.do.master_do import BizPallet
+from module_business.entity.do.operation_do import BizPalletInventory
+from module_business.entity.vo.master_vo import (
+    BusinessUserOptionModel,
+    DeletePalletModel,
+    PalletCreateModel,
+    PalletEditModel,
+    PalletModel,
+    PalletPageQueryModel,
+    UserAssignModel,
+)
+
+AssignmentResource = Literal['warehouse', 'site']
+
+_ASSIGNMENT_LABELS: dict[AssignmentResource, str] = {
+    'warehouse': '仓库',
+    'site': '客户现场',
+}
+
+
+class PalletService:
+    """托盘资产及业务用户分配服务层。"""
+
+    @staticmethod
+    def render_qr_png(qr_token: str) -> bytes:
+        """将固定二维码标识渲染为 PNG；补打不会生成新标识。"""
+        buffer = BytesIO()
+        qrcode.make(qr_token).save(buffer, format='PNG')
+        return buffer.getvalue()
+
+    @classmethod
+    async def get_pallet_qrcode(cls, db: AsyncSession, pallet_id: int) -> bytes:
+        pallet = await MasterDao.get_pallet(db, pallet_id)
+        if pallet is None:
+            raise ServiceException(message='托盘不存在')
+        return cls.render_qr_png(pallet.qr_token)
+
+    @staticmethod
+    def _extract_pallet_ids(value: int | DeletePalletModel) -> list[int]:
+        pallet_ids = [value] if isinstance(value, int) else list(value.pallet_ids)
+        if not pallet_ids or any(pallet_id <= 0 for pallet_id in pallet_ids):
+            raise ServiceException(message='托盘ID必须为正整数')
+        if len(pallet_ids) != len(set(pallet_ids)):
+            raise ServiceException(message='托盘ID不能重复')
+        return sorted(pallet_ids)
+
+    @classmethod
+    async def _can_remove(cls, db: AsyncSession, pallet_id: int) -> bool:
+        inventory = await MasterDao.get_pallet_inventory(db, pallet_id)
+        if inventory is None or inventory.flow_state != PalletFlowState.UNSTOCKED.value:
+            return False
+        return await MasterDao.count_pallet_events(db, pallet_id) == 0
+
+    @classmethod
+    async def _to_pallet_model(cls, db: AsyncSession, record: Any) -> PalletModel:
+        model = PalletModel.model_validate(record)
+        return model.model_copy(update={'can_remove': await cls._can_remove(db, model.pallet_id)})
+
+    @classmethod
+    async def _lock_pallet_inventory(cls, db: AsyncSession, pallet_id: int) -> tuple[BizPallet, BizPalletInventory]:
+        """按库存、托盘顺序加锁，避免与流转事务形成反序死锁。"""
+        inventory = await MasterDao.get_pallet_inventory(db, pallet_id, for_update=True)
+        if inventory is None:
+            if await MasterDao.get_pallet(db, pallet_id) is None:
+                raise ServiceException(message='托盘不存在')
+            raise ServiceException(message='托盘库存不存在')
+        pallet = await MasterDao.get_pallet(db, pallet_id, for_update=True)
+        if pallet is None:
+            raise ServiceException(message='托盘不存在')
+        return pallet, inventory
+
+    @classmethod
+    async def list_pallet(
+        cls,
+        db: AsyncSession,
+        query_object: PalletPageQueryModel,
+        is_page: bool = True,
+    ) -> PageModel | list[PalletModel]:
+        result = await MasterDao.list_pallet(db, query_object, is_page)
+        if isinstance(result, PageModel):
+            rows = [await cls._to_pallet_model(db, row) for row in result.rows]
+            return result.model_copy(update={'rows': rows})
+        return [await cls._to_pallet_model(db, row) for row in result]
+
+    @classmethod
+    async def detail_pallet(cls, db: AsyncSession, pallet_id: int) -> PalletModel:
+        pallet = await MasterDao.get_pallet(db, pallet_id)
+        if pallet is None:
+            raise ServiceException(message='托盘不存在')
+        return await cls._to_pallet_model(db, pallet)
+
+    @classmethod
+    async def add_pallet(
+        cls,
+        db: AsyncSession,
+        pallet: PalletCreateModel,
+        current_user_name: str,
+    ) -> CrudResponseModel:
+        try:
+            if await MasterDao.find_pallet_by_code(db, pallet.pallet_code) is not None:
+                raise ServiceException(message='托盘编号已存在')
+
+            current_time = datetime.now()
+            pallet_record = BizPallet(
+                pallet_code=pallet.pallet_code,
+                qr_token=secrets.token_urlsafe(32),
+                capacity_packages=pallet.capacity_packages,
+                asset_status='0',
+                remark=pallet.remark,
+                create_by=current_user_name,
+                create_time=current_time,
+                update_by=current_user_name,
+                update_time=current_time,
+            )
+            pallet_record = await MasterDao.add_pallet(db, pallet_record)
+            inventory = BizPalletInventory(
+                pallet_id=pallet_record.pallet_id,
+                flow_state='UNSTOCKED',
+                remaining_packages=0,
+                version=0,
+                updated_at=current_time,
+            )
+            await MasterDao.add_pallet_inventory(db, inventory)
+            await db.commit()
+            return CrudResponseModel(is_success=True, message='新增成功')
+        except IntegrityError:
+            await db.rollback()
+            raise ServiceException(message='新增托盘失败，托盘编号或二维码标识已存在') from None
+        except Exception:
+            await db.rollback()
+            raise
+
+    @classmethod
+    async def edit_pallet(
+        cls,
+        db: AsyncSession,
+        pallet: PalletEditModel,
+        current_user_name: str,
+    ) -> CrudResponseModel:
+        try:
+            _, inventory = await cls._lock_pallet_inventory(db, pallet.pallet_id)
+            if pallet.capacity_packages < inventory.remaining_packages:
+                raise ServiceException(message='托盘容量不能小于当前剩余包数')
+            await MasterDao.update_pallet(
+                db,
+                pallet,
+                update_by=current_user_name,
+                update_time=datetime.now(),
+            )
+            await db.commit()
+            return CrudResponseModel(is_success=True, message='更新成功')
+        except IntegrityError:
+            await db.rollback()
+            raise ServiceException(message='修改托盘失败，托盘状态已变化') from None
+        except Exception:
+            await db.rollback()
+            raise
+
+    @classmethod
+    async def remove_pallet(
+        cls,
+        db: AsyncSession,
+        value: int | DeletePalletModel,
+    ) -> CrudResponseModel:
+        try:
+            pallet_ids = cls._extract_pallet_ids(value)
+            for pallet_id in pallet_ids:
+                _, inventory = await cls._lock_pallet_inventory(db, pallet_id)
+                if inventory.flow_state != PalletFlowState.UNSTOCKED.value:
+                    raise ServiceException(message='托盘未处于未入库状态，不能删除')
+                if await MasterDao.count_pallet_events(db, pallet_id) > 0:
+                    raise ServiceException(message='托盘已有流转事件，不能删除')
+
+            for pallet_id in pallet_ids:
+                await MasterDao.delete_pallet_inventory(db, pallet_id)
+                await MasterDao.delete_pallet(db, pallet_id)
+            await db.commit()
+            return CrudResponseModel(is_success=True, message='删除成功')
+        except IntegrityError:
+            await db.rollback()
+            raise ServiceException(message='删除托盘失败，托盘状态或关联数据已变化') from None
+        except Exception:
+            await db.rollback()
+            raise
+
+    @classmethod
+    async def _list_resource_users(
+        cls,
+        db: AsyncSession,
+        resource: AssignmentResource,
+        resource_id: int,
+    ) -> list[BusinessUserOptionModel]:
+        if await getattr(MasterDao, f'get_{resource}')(db, resource_id) is None:
+            raise ServiceException(message=f'{_ASSIGNMENT_LABELS[resource]}不存在')
+
+        users = await MasterDao.list_assignable_users(db)
+        result = []
+        association_method = getattr(AccessDao, f'list_user_{resource}_ids')
+        for user in users:
+            assigned_ids = await association_method(db, user.user_id)
+            result.append(
+                BusinessUserOptionModel(
+                    user_id=user.user_id,
+                    user_name=user.user_name,
+                    nick_name=user.nick_name,
+                    assigned=resource_id in assigned_ids,
+                )
+            )
+        return result
+
+    @classmethod
+    async def list_warehouse_users(
+        cls,
+        db: AsyncSession,
+        warehouse_id: int,
+    ) -> list[BusinessUserOptionModel]:
+        return await cls._list_resource_users(db, 'warehouse', warehouse_id)
+
+    @classmethod
+    async def list_site_users(
+        cls,
+        db: AsyncSession,
+        site_id: int,
+    ) -> list[BusinessUserOptionModel]:
+        return await cls._list_resource_users(db, 'site', site_id)
+
+    @classmethod
+    async def _assign_resource_users(
+        cls,
+        db: AsyncSession,
+        resource: AssignmentResource,
+        resource_id: int,
+        assignment: UserAssignModel,
+    ) -> CrudResponseModel:
+        label = _ASSIGNMENT_LABELS[resource]
+        try:
+            if await getattr(MasterDao, f'get_{resource}')(db, resource_id) is None:
+                raise ServiceException(message=f'{label}不存在')
+            users = await MasterDao.list_assignable_users_by_ids(db, assignment.user_ids)
+            if {user.user_id for user in users} != set(assignment.user_ids):
+                raise ServiceException(message='存在不存在、停用或已删除的用户')
+            await getattr(AccessDao, f'replace_{resource}_users')(db, resource_id, assignment.user_ids)
+            await db.commit()
+            return CrudResponseModel(is_success=True, message='分配成功')
+        except IntegrityError:
+            await db.rollback()
+            raise ServiceException(message=f'分配{label}用户失败，关联数据无效') from None
+        except Exception:
+            await db.rollback()
+            raise
+
+    @classmethod
+    async def assign_warehouse_users(
+        cls,
+        db: AsyncSession,
+        warehouse_id: int,
+        assignment: UserAssignModel,
+    ) -> CrudResponseModel:
+        return await cls._assign_resource_users(db, 'warehouse', warehouse_id, assignment)
+
+    @classmethod
+    async def assign_site_users(
+        cls,
+        db: AsyncSession,
+        site_id: int,
+        assignment: UserAssignModel,
+    ) -> CrudResponseModel:
+        return await cls._assign_resource_users(db, 'site', site_id, assignment)