LQAdminPlatform/src/views/dict_item_view.py

"""
字典项管理API路由
"""
import sys
import os
import logging
from datetime import datetime, timezone

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))

from fastapi import APIRouter, Depends, HTTPException
from app.schemas.base import ApiResponse
from app.system.schemas.dict_item_schema import (
    DictItemCreate, DictItemUpdate, DictItemListRequest, DictItemBatchDeleteRequest
)
from app.services.dict_item_service import DictItemService
from app.utils.auth_dependency import get_current_user_with_refresh

logger = logging.getLogger(__name__)

router = APIRouter(prefix="/dict/item", tags=["字典项管理"])


@router.post("/list")
async def get_item_list(
    request: DictItemListRequest,
    current_user: dict = Depends(get_current_user_with_refresh)
):
    """
    获取字典项列表（分页）
    """
    try:
        service = DictItemService()
        items, total = await service.get_item_list(
            page=request.page,
            page_size=request.page_size,
            category_id=request.category_id,
            keyword=request.keyword,
            enable_flag=request.enable_flag
        )
        
        return ApiResponse(
            code="000000",
            message="成功",
            data={
                "list": items,
                "total": total,
                "page": request.page,
                "page_size": request.page_size
            },
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()
    except Exception as e:
        logger.exception("获取字典项列表错误")
        return ApiResponse(
            code="500001",
            message="服务器内部错误",
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()


@router.get("/{dict_id}")
async def get_item_detail(
    dict_id: int,
    current_user: dict = Depends(get_current_user_with_refresh)
):
    """
    获取字典项详情
    """
    try:
        service = DictItemService()
        item = await service.get_item_by_id(dict_id)
        
        if not item:
            return ApiResponse(
                code="300001",
                message="字典项不存在",
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
        
        return ApiResponse(
            code="000000",
            message="成功",
            data=item,
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()
    except Exception as e:
        logger.exception(f"获取字典项详情错误: dict_id={dict_id}")
        return ApiResponse(
            code="500001",
            message="服务器内部错误",
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()


@router.post("")
async def create_item(
    item: DictItemCreate,
    current_user: dict = Depends(get_current_user_with_refresh)
):
    """
    创建字典项
    """
    try:
        user_id = current_user.get("sub")
        service = DictItemService()
        
        success, message, dict_id = await service.create_item(
            item.model_dump(),
            user_id
        )
        
        if success:
            return ApiResponse(
                code="000000",
                message=message,
                data={"dict_id": dict_id},
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
        else:
            return ApiResponse(
                code="400001",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
    except Exception as e:
        logger.exception("创建字典项错误")
        return ApiResponse(
            code="500001",
            message="服务器内部错误",
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()


@router.put("/{dict_id}")
async def update_item(
    dict_id: int,
    item: DictItemUpdate,
    current_user: dict = Depends(get_current_user_with_refresh)
):
    """
    更新字典项
    """
    try:
        user_id = current_user.get("sub")
        service = DictItemService()
        
        success, message = await service.update_item(
            dict_id,
            item.model_dump(exclude_none=True),
            user_id
        )
        
        if success:
            return ApiResponse(
                code="000000",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
        else:
            return ApiResponse(
                code="400001",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
    except Exception as e:
        logger.exception(f"更新字典项错误: dict_id={dict_id}")
        return ApiResponse(
            code="500001",
            message="服务器内部错误",
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()


@router.delete("/{dict_id}")
async def delete_item(
    dict_id: int,
    current_user: dict = Depends(get_current_user_with_refresh)
):
    """
    删除字典项
    """
    try:
        service = DictItemService()
        success, message = await service.delete_item(dict_id)
        
        if success:
            return ApiResponse(
                code="000000",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
        else:
            return ApiResponse(
                code="400001",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
    except Exception as e:
        logger.exception(f"删除字典项错误: dict_id={dict_id}")
        return ApiResponse(
            code="500001",
            message="服务器内部错误",
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()


@router.post("/batch-delete")
async def batch_delete_items(
    request: DictItemBatchDeleteRequest,
    current_user: dict = Depends(get_current_user_with_refresh)
):
    """
    批量删除字典项
    """
    try:
        service = DictItemService()
        success, message = await service.batch_delete_items(request.dict_ids)
        
        if success:
            return ApiResponse(
                code="000000",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
        else:
            return ApiResponse(
                code="400001",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
    except Exception as e:
        logger.exception("批量删除字典项错误")
        return ApiResponse(
            code="500001",
            message="服务器内部错误",
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()


@router.put("/{dict_id}/toggle-status")
async def toggle_item_status(
    dict_id: int,
    enable_flag: str,
    current_user: dict = Depends(get_current_user_with_refresh)
):
    """
    切换字典项启用状态
    """
    try:
        user_id = current_user.get("sub")
        service = DictItemService()
        
        success, message = await service.toggle_item_status(dict_id, enable_flag, user_id)
        
        if success:
            return ApiResponse(
                code="000000",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
        else:
            return ApiResponse(
                code="400001",
                message=message,
                timestamp=datetime.now(timezone.utc).isoformat()
            ).model_dump()
    except Exception as e:
        logger.exception(f"切换字典项状态错误: dict_id={dict_id}")
        return ApiResponse(
            code="500001",
            message="服务器内部错误",
            timestamp=datetime.now(timezone.utc).isoformat()
        ).model_dump()