dingdanquanliucheng/backend/app/api/system.py

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session

from backend.app.api.deps import get_system_service, require_permissions, require_roles
from backend.app.db import get_db_session
from backend.app.schemas.common import success_payload
from backend.app.schemas.system import (
    AssignRoleMenusRequest,
    CreateMenuRequest,
    CreateRoleRequest,
    CreateUserRequest,
    ResetPasswordRequest,
    UpdateMenuRequest,
    UpdateRoleRequest,
    UpdateUserRequest,
)
from backend.app.services.system_service import SystemService

router = APIRouter(prefix="/api/system", tags=["system"])


@router.get("/users")
def list_users(
    username: str | None = Query(default=None),
    real_name: str | None = Query(default=None),
    mobile: str | None = Query(default=None),
    role_id: int | None = Query(default=None),
    status: int | None = Query(default=None),
    page_no: int = Query(default=1),
    page_size: int = Query(default=20),
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:user:list")),
) -> dict:
    result = system_service.list_users(
        session,
        {
            "username": username,
            "real_name": real_name,
            "mobile": mobile,
            "role_id": role_id,
            "status": status,
        },
    )
    start = max(page_no - 1, 0) * page_size
    result["list"] = result["list"][start : start + page_size]
    result["page_no"] = page_no
    result["page_size"] = page_size
    return success_payload(result)


@router.post("/users")
def create_user(
    payload: CreateUserRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:user:list")),
) -> dict:
    return success_payload(system_service.create_user(payload.model_dump(), session))


@router.put("/users/{user_id}")
def update_user(
    user_id: int,
    payload: UpdateUserRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:user:list")),
) -> dict:
    return success_payload(system_service.update_user(user_id, payload.model_dump(), session))


@router.post("/users/{user_id}/reset-password")
def reset_password(
    user_id: int,
    payload: ResetPasswordRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:user:list")),
) -> dict:
    return success_payload(system_service.reset_password(user_id, payload.new_password, session))


@router.get("/roles")
def list_roles(
    role_name: str | None = Query(default=None),
    role_code: str | None = Query(default=None),
    status: int | None = Query(default=None),
    page_no: int = Query(default=1),
    page_size: int = Query(default=20),
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:role:list")),
) -> dict:
    result = system_service.list_roles(
        session,
        {"role_name": role_name, "role_code": role_code, "status": status},
    )
    start = max(page_no - 1, 0) * page_size
    result["list"] = result["list"][start : start + page_size]
    result["page_no"] = page_no
    result["page_size"] = page_size
    return success_payload(result)


@router.post("/roles")
def create_role(
    payload: CreateRoleRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:role:list")),
) -> dict:
    return success_payload(system_service.create_role(payload.model_dump(), session))


@router.put("/roles/{role_id}")
def update_role(
    role_id: int,
    payload: UpdateRoleRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:role:list")),
) -> dict:
    return success_payload(system_service.update_role(role_id, payload.model_dump(), session))


@router.get("/roles/{role_id}/menus")
def get_role_menus(
    role_id: int,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:role:list")),
) -> dict:
    return success_payload(system_service.get_role_menu_assignment(role_id, session))


@router.put("/roles/{role_id}/menus")
def assign_role_menus(
    role_id: int,
    payload: AssignRoleMenusRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:role:list")),
) -> dict:
    return success_payload(system_service.assign_role_menus(role_id, payload.model_dump(), session))


@router.get("/menus")
def list_menus(
    status: int | None = Query(default=None),
    menu_type: str | None = Query(default=None),
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:menu:list")),
) -> dict:
    return success_payload(
        system_service.list_menus(
            session,
            {"status": status, "menu_type": menu_type},
        )
    )


@router.post("/menus")
def create_menu(
    payload: CreateMenuRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:menu:list")),
) -> dict:
    return success_payload(system_service.create_menu(payload.model_dump(), session))


@router.put("/menus/{menu_id}")
def update_menu(
    menu_id: int,
    payload: UpdateMenuRequest,
    system_service: SystemService = Depends(get_system_service),
    session: Session = Depends(get_db_session),
    current_user: dict = Depends(require_roles("admin")),
    _permission_user: dict = Depends(require_permissions("system:menu:list")),
) -> dict:
    return success_payload(system_service.update_menu(menu_id, payload.model_dump(), session))