shanxia2.0/backend/app/api/admin.py

"""运营端管理接口（租户、角色下拉等）"""
import os
import uuid
from datetime import datetime
from typing import Any, List, Optional

from fastapi import APIRouter, Depends, HTTPException, Query, Request, UploadFile, File, Form
from pydantic import BaseModel, ConfigDict, Field
from sqlalchemy import and_, func, or_
from sqlalchemy.orm import Session

from app.core.config import settings
from app.core.data_scope import apply_data_scope, assert_row_in_data_scope
from app.core.database import get_db
from app.core.menu_guard import require_admin_or_super_admin, require_menu_code
from app.core.response import success_response, error_response
from app.core.attachment_biz import resolve_upload_folder
from app.core.storage import storage
from app.crud import tenant as tenant_svc
from app.crud import dict_type as dict_type_svc
from app.crud import dict_data as dict_data_svc
from app.services import dict_ensure as dict_ensure_svc
from app.crud import dept as dept_svc
from app.crud import site as site_svc
from app.crud import post as post_svc
from app.crud import menu as menu_svc
from app.crud import role as role_svc
from app.crud import user as user_svc
from app.crud import role as role_svc
from app.crud import user as user_svc
from app.crud import oss as oss_svc
from app.models.models import SysDept, SysDictData, SysDictType, SysPost, SysRole, SysTenant, SysUser, SysUserRole
from app.schemas.menu_favorite import (
    MenuFavoriteCreateBody,
    MenuFavoriteDeleteBody,
    MenuFavoriteReorderBody,
)
from app.services.web_auth_roles import _map_role_name_to_web
from app.services.column_facet import list_column_facet_values
from app.utils.excel_export import (
    EXPORT_MAX_ROWS,
    ExportColumn,
    ExportValidationError,
    export_rows_to_xlsx_response,
    filter_export_columns,
)

router = APIRouter(prefix="/web/admin", tags=["运营端管理"])


# ---------------------------------------------------------------------------
# 角色下拉（用户弹窗等）
# ---------------------------------------------------------------------------


@router.get("/roles")
def list_roles_for_select(
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """返回运营端角色下拉选项（label=库中角色名，value=Web 角色码）。"""
    rows: List[SysRole] = (
        db.query(SysRole)
        .filter(SysRole.del_flag == 0, SysRole.status == "1")
        .order_by(SysRole.create_time.desc())
        .all()
    )
    seen: set[str] = set()
    out: List[dict] = []
    for r in rows:
        name = (r.role_name or "").strip()
        if not name:
            continue
        code = _map_role_name_to_web(name)
        key = f"{code}:{name}"
        if key in seen:
            continue
        seen.add(key)
        out.append({"label": name, "value": code})
    if not out:
        out = [
            {"label": "超级管理员", "value": "super_admin"},
            {"label": "运营管理员", "value": "admin"},
        ]
    return success_response(out)


@router.get("/users/options")
def list_users_for_select(
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """返回用户下拉选项（label=昵称，value=用户ID，附带 nickName/userNo）。

    供申请人/审批人等选择场景使用，返回本租户全部有效用户，
    不做业务数据范围过滤（否则「仅本人」角色会按 create_by 滤空，连自己都选不到）。
    """
    tenant_no = _get_tenant_no(db, user)
    q = db.query(SysUser).filter(SysUser.del_flag == 0, SysUser.status == "1")
    q = q.filter(SysUser.tenant_no == tenant_no)
    rows = q.order_by(SysUser.create_time.desc()).all()
    out = [
        {
            "label": (r.nick_name or r.user_no or ""),
            "value": r.id,
            "nickName": r.nick_name or "",
            "userNo": r.user_no or "",
        }
        for r in rows
    ]
    return success_response(out)


@router.get("/roles/options")
def list_roles_for_designer(
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """返回角色下拉选项（label=角色名，value=角色ID UUID），供流程设计器审批人选择使用。
    与 /roles 不同，此端点返回角色 UUID 作为 value（引擎解析审批人需要 UUID）。
    角色为租户级主数据选项，不做 create_by 数据范围过滤。
    """
    tenant_no = _get_tenant_no(db, user)
    q = db.query(SysRole).filter(SysRole.del_flag == 0, SysRole.status == "1")
    q = q.filter(SysRole.tenant_no == tenant_no)
    rows = q.order_by(SysRole.create_time.desc()).all()
    out = [{"label": (r.role_name or "").strip(), "value": r.id} for r in rows if (r.role_name or "").strip()]
    return success_response(out)


# ---------------------------------------------------------------------------
# 租户管理
# ---------------------------------------------------------------------------


class TenantCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    tenant_no: str = Field(..., alias="tenantNo")
    tenant_name: str = Field(..., alias="tenantName")
    contact_name: Optional[str] = Field(None, alias="contactName")
    contact_phone: Optional[str] = Field(None, alias="contactPhone")
    order_num: Optional[int] = Field(0, alias="orderNum")
    remark: Optional[str] = None


class TenantUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    tenant_no: Optional[str] = Field(None, alias="tenantNo")
    tenant_name: Optional[str] = Field(None, alias="tenantName")
    contact_name: Optional[str] = Field(None, alias="contactName")
    contact_phone: Optional[str] = Field(None, alias="contactPhone")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/tenants")
def list_tenants(
    request: Request,
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=500, alias="pageSize"),
    keyword: Optional[str] = None,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    items, total = tenant_svc.list_tenants(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        tenant_no_like=request.query_params.get("tenantNo"),
        tenant_name=request.query_params.get("tenantName"),
        contact_name=request.query_params.get("contactName"),
        contact_phone=request.query_params.get("contactPhone"),
        tenant_no_in=request.query_params.get("tenantNoIn"),
        tenant_name_in=request.query_params.get("tenantNameIn"),
        contact_name_in=request.query_params.get("contactNameIn"),
        contact_phone_in=request.query_params.get("contactPhoneIn"),
        user_info=_user,
    )
    total_pages = tenant_svc.total_pages(total, pageSize)
    return success_response(
        {
            "list": items,
            "total": total,
            "page": page,
            "pageSize": pageSize,
            "totalPages": total_pages,
        }
    )


class TenantColumnFacetBody(BaseModel):
    """租户列表列头可选值（去重；可附带列表上下文）"""

    model_config = ConfigDict(populate_by_name=True, extra="allow")

    field: str = Field(..., description="tenantNo | tenantName | contactName | contactPhone")
    keyword: Optional[str] = Field(default=None, description="可选值关键字")
    limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限")


_TENANT_FACET_COLUMNS = {
    "tenantNo": SysTenant.tenant_no,
    "tenantName": SysTenant.tenant_name,
    "contactName": SysTenant.contact_name,
    "contactPhone": SysTenant.contact_phone,
}


@router.post("/tenants/column-facet-values")
def tenant_column_facet_values(
    body: TenantColumnFacetBody,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """租户列表列头可选值：在列表上下文（排除本列）下去重。"""
    from app.services.pl.facet_context import strip_simple_facet_self_params

    column = _TENANT_FACET_COLUMNS.get(body.field)
    if column is None:
        return error_response(400, "不支持的列")
    try:
        lim = min(max(1, int(body.limit or 500)), 500)
        list_keyword = (body.keyword or "").strip() or None
        params = strip_simple_facet_self_params(_facet_body_params(body), body.field)
        q = (
            db.query(column.label("value"), func.count(SysTenant.id).label("cnt"))
            .filter(
                SysTenant.del_flag == 0,
                column.isnot(None),
                column != "",
            )
        )
        q = apply_data_scope(q, SysTenant, _user, db)
        kw = list_keyword or str(_param_first(params, "keyword") or "").strip()
        if kw:
            like = f"%{kw}%"
            q = q.filter(
                or_(
                    SysTenant.tenant_no.like(like),
                    SysTenant.tenant_name.like(like),
                )
            )
        for col, camel, snake in (
            (SysTenant.tenant_no, "tenantNo", "tenant_no"),
            (SysTenant.tenant_name, "tenantName", "tenant_name"),
            (SysTenant.contact_name, "contactName", "contact_name"),
            (SysTenant.contact_phone, "contactPhone", "contact_phone"),
        ):
            values = _split_csv_param(params, f"{camel}In", f"{snake}_in")
            if values:
                q = q.filter(col.in_(values))
            else:
                single = str(_param_first(params, camel, snake) or "").strip()
                if single:
                    q = q.filter(col.like(f"%{single}%"))
        status_values = _split_csv_param(params, "statusIn", "status_in")
        if not status_values:
            st = _param_first(params, "status")
            if st:
                status_values = [str(st).strip()]
        if status_values:
            q = q.filter(SysTenant.status.in_(status_values))
        rows = q.group_by(column).order_by(column.asc()).limit(lim).all()
        out = []
        for row in rows:
            value = str(row.value).strip() if row.value is not None else ""
            if not value:
                continue
            out.append({"value": value, "label": value, "count": int(row.cnt or 0)})
        return success_response({"list": out})
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))



TENANT_EXPORT_COLUMNS = [
    ExportColumn(title="租户编号", field="tenantNo"),
    ExportColumn(title="租户名称", field="tenantName"),
    ExportColumn(title="联系人", field="contactName"),
    ExportColumn(title="联系电话", field="contactPhone"),
    ExportColumn(title="创建时间", field="createTime"),
]


class TenantExportBody(BaseModel):
    keyword: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.post("/tenants/export")
def export_tenants(
    body: TenantExportBody,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """导出租户列表（当前筛选全量，或 ids 已选）。"""
    try:
        items, _ = tenant_svc.list_tenants(
            db,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            keyword=body.keyword,
            ids=body.ids,
            max_page_size=EXPORT_MAX_ROWS,
            user_info=_user,
        )
        cols = filter_export_columns(TENANT_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=None,
            sheet_title="租户列表",
            columns=cols,
            rows=items,
            filename_stem=f"租户列表_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/tenants")
def create_tenant(
    body: TenantCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        obj = tenant_svc.create_tenant(
            db,
            tenant_no=body.tenant_no,
            tenant_name=body.tenant_name,
            contact_name=body.contact_name,
            contact_phone=body.contact_phone,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(tenant_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/tenants/{tenant_id}")
def update_tenant(
    tenant_id: str,
    body: TenantUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = tenant_svc.update_tenant(
            db,
            tenant_id,
            tenant_no=payload.get("tenant_no"),
            tenant_name=payload.get("tenant_name"),
            contact_name=payload.get("contact_name"),
            contact_phone=payload.get("contact_phone"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
        )
        return success_response(tenant_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/tenants/{tenant_id}")
def delete_tenant(
    tenant_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_svc.soft_delete_tenant(db, tenant_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# Helper: resolve tenant_no from user context
# ---------------------------------------------------------------------------


def _get_tenant_no(db: Session, user: dict) -> str:
    user_id = user.get("user_id")
    if not user_id:
        return "shanxia2.0"
    sys_user = db.query(SysUser).filter(SysUser.id == user_id).first()
    return (sys_user.tenant_no if sys_user else None) or "shanxia2.0"


# ---------------------------------------------------------------------------
# 用户管理
# ---------------------------------------------------------------------------




def _facet_body_params(body) -> dict:
    data = body.model_dump(by_alias=True, exclude_none=True)
    extra = getattr(body, "model_extra", None) or {}
    for key, value in extra.items():
        if key not in data and value not in (None, ""):
            data[key] = value
    return data


def _split_csv_param(params: dict, *keys: str):
    for key in keys:
        raw = params.get(key)
        if raw is None or raw == "":
            continue
        return [s.strip() for s in str(raw).split(",") if s.strip()]
    return []


def _param_first(params: dict, *keys: str):
    for key in keys:
        if key in params and params[key] not in (None, ""):
            return params[key]
    return None

class UserCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    user_no: str = Field(..., alias="userNo")
    nick_name: str = Field(..., alias="nickName")
    password: str = Field(..., alias="password")
    dept_id: Optional[str] = Field(None, alias="deptId")
    email: Optional[str] = Field("", alias="email")
    phone_no: Optional[str] = Field("", alias="phoneNo")
    sex: Optional[str] = Field("0", alias="sex")
    avatar: Optional[str] = Field(None, alias="avatar")
    status: Optional[str] = Field("1", alias="status")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None
    role_ids: Optional[List[str]] = Field(None, alias="roleIds")
    post_ids: Optional[List[str]] = Field(None, alias="postIds")


class UserUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    nick_name: Optional[str] = Field(None, alias="nickName")
    dept_id: Optional[str] = Field(None, alias="deptId")
    email: Optional[str] = Field(None, alias="email")
    phone_no: Optional[str] = Field(None, alias="phoneNo")
    sex: Optional[str] = Field(None, alias="sex")
    avatar: Optional[str] = Field(None, alias="avatar")
    status: Optional[str] = Field(None, alias="status")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None
    role_ids: Optional[List[str]] = Field(None, alias="roleIds")
    post_ids: Optional[List[str]] = Field(None, alias="postIds")


USER_EXPORT_COLUMNS = [
    ExportColumn(title="用户账号", field="userNo"),
    ExportColumn(title="用户名", field="nickName"),
    ExportColumn(title="所属组织", field="deptName"),
    ExportColumn(title="角色", field="roles"),
    ExportColumn(title="手机号", field="phoneNo"),
    ExportColumn(title="状态", field="status", dict_type="sys_status"),
    ExportColumn(title="创建时间", field="createTime"),
]


class UserExportBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    keyword: Optional[str] = None
    dept_id: Optional[str] = Field(None, alias="deptId")
    status: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.get("/users")
def list_users(
    request: Request,
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=500, alias="pageSize"),
    keyword: Optional[str] = None,
    deptId: Optional[str] = Query(None, alias="deptId"),
    status: Optional[str] = None,
    user: dict = Depends(require_menu_code("system:user:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    query = db.query(SysUser).filter(
        SysUser.del_flag == 0,
        SysUser.tenant_no == tenant_no,
    )
    kw = (keyword or "").strip()
    if kw:
        like = f"%{kw}%"
        query = query.filter(
            or_(
                SysUser.user_no.like(like),
                SysUser.nick_name.like(like),
                SysUser.phone_no.like(like),
            )
        )
    user_no = (request.query_params.get("userNo") or "").strip()
    if user_no:
        query = query.filter(SysUser.user_no.like(f"%{user_no}%"))
    nick_name = (request.query_params.get("nickName") or "").strip()
    if nick_name:
        query = query.filter(SysUser.nick_name.like(f"%{nick_name}%"))
    phone_no = (request.query_params.get("phoneNo") or "").strip()
    if phone_no:
        query = query.filter(SysUser.phone_no.like(f"%{phone_no}%"))
    user_no_in = (request.query_params.get("userNoIn") or "").strip()
    user_no_values = [s.strip() for s in user_no_in.split(",") if s.strip()]
    if user_no_values:
        query = query.filter(SysUser.user_no.in_(user_no_values))
    nick_name_in = (request.query_params.get("nickNameIn") or "").strip()
    nick_name_values = [s.strip() for s in nick_name_in.split(",") if s.strip()]
    if nick_name_values:
        query = query.filter(SysUser.nick_name.in_(nick_name_values))
    phone_no_in = (request.query_params.get("phoneNoIn") or "").strip()
    phone_no_values = [s.strip() for s in phone_no_in.split(",") if s.strip()]
    if phone_no_values:
        query = query.filter(SysUser.phone_no.in_(phone_no_values))
    if deptId:
        query = query.filter(SysUser.dept_id == deptId)
    status_in = (request.query_params.get("statusIn") or "").strip()
    status_values = [s.strip() for s in status_in.split(",") if s.strip()]
    if not status_values and status:
        status_values = [status]
    if status_values:
        query = query.filter(SysUser.status.in_(status_values))
    query = apply_data_scope(query, SysUser, user, db, tenant_no)
    total = query.count()
    items = query.order_by(SysUser.create_time.desc()).offset((page - 1) * pageSize).limit(pageSize).all()
    dept_ids = list({r.dept_id for r in items if r.dept_id})
    dept_map: dict[str, str] = {}
    if dept_ids:
        for d in db.query(SysDept).filter(SysDept.id.in_(dept_ids), SysDept.del_flag == 0).all():
            dept_map[d.id] = d.dept_name or ""
    result_list = [
        user_svc._row_to_dict(r, dept_name=dept_map.get(r.dept_id or "", "")) for r in items
    ]
    user_ids = [d["id"] for d in result_list if d.get("id")]
    role_map: dict[str, list[str]] = {uid: [] for uid in user_ids}
    if user_ids:
        for ur in (
            db.query(SysUserRole)
            .filter(
                SysUserRole.user_id.in_(user_ids),
                SysUserRole.del_flag == 0,
            )
            .all()
        ):
            role_map.setdefault(ur.user_id, []).append(ur.role_id)
    for d in result_list:
        d["roleIds"] = role_map.get(d["id"], [])
    tp = user_svc.total_pages(total, pageSize)
    return success_response({"list": result_list, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


class UserColumnFacetBody(BaseModel):
    """用户列表列头可选值（去重；可附带列表上下文）"""

    model_config = ConfigDict(populate_by_name=True, extra="allow")

    field: str = Field(..., description="userNo | nickName | phoneNo")
    keyword: Optional[str] = Field(default=None, description="可选值关键字")
    limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限")


_USER_FACET_COLUMNS = {
    "userNo": SysUser.user_no,
    "nickName": SysUser.nick_name,
    "phoneNo": SysUser.phone_no,
}


@router.post("/users/column-facet-values")
def user_column_facet_values(
    body: UserColumnFacetBody,
    user: dict = Depends(require_menu_code("system:user:list")),
    db: Session = Depends(get_db),
):
    """用户列表列头可选值：在列表上下文（排除本列）下去重。"""
    from app.services.pl.facet_context import strip_simple_facet_self_params

    column = _USER_FACET_COLUMNS.get(body.field)
    if column is None:
        return error_response(400, "不支持的列")
    try:
        tenant_no = _get_tenant_no(db, user)
        list_keyword = (body.keyword or "").strip() or None
        params = strip_simple_facet_self_params(_facet_body_params(body), body.field)
        extra = []
        kw = list_keyword or (_param_first(params, "keyword") or "")
        kw = str(kw).strip()
        if kw:
            like = f"%{kw}%"
            extra.append(
                or_(
                    SysUser.user_no.like(like),
                    SysUser.nick_name.like(like),
                    SysUser.phone_no.like(like),
                )
            )
        for col, camel, snake in (
            (SysUser.user_no, "userNo", "user_no"),
            (SysUser.nick_name, "nickName", "nick_name"),
            (SysUser.phone_no, "phoneNo", "phone_no"),
        ):
            values = _split_csv_param(params, f"{camel}In", f"{snake}_in")
            if values:
                extra.append(col.in_(values))
            else:
                single = (_param_first(params, camel, snake) or "")
                if str(single).strip():
                    extra.append(col.like(f"%{str(single).strip()}%"))
        dept_id = _param_first(params, "deptId", "dept_id")
        if dept_id:
            extra.append(SysUser.dept_id == dept_id)
        status_values = _split_csv_param(params, "statusIn", "status_in")
        if not status_values:
            st = _param_first(params, "status")
            if st:
                status_values = [str(st).strip()]
        if status_values:
            extra.append(SysUser.status.in_(status_values))
        rows = list_column_facet_values(
            db,
            SysUser,
            column,
            tenant_no=tenant_no,
            keyword=None,
            limit=body.limit if body.limit is not None else 500,
            apply_scope=lambda q: apply_data_scope(q, SysUser, user, db, tenant_no),
            extra_filters=extra or None,
        )
        return success_response({"list": rows})
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/users/export")
def export_users(
    body: UserExportBody,
    user: dict = Depends(require_menu_code("system:user:list")),
    db: Session = Depends(get_db),
):
    """导出用户列表（当前筛选全量，或 ids 已选）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        query = db.query(SysUser).filter(
            SysUser.del_flag == 0,
            SysUser.tenant_no == tenant_no,
        )
        kw = (body.keyword or "").strip()
        if kw:
            like = f"%{kw}%"
            query = query.filter(
                or_(
                    SysUser.user_no.like(like),
                    SysUser.nick_name.like(like),
                    SysUser.phone_no.like(like),
                )
            )
        if body.dept_id:
            query = query.filter(SysUser.dept_id == body.dept_id)
        if body.status:
            query = query.filter(SysUser.status == body.status)
        if body.ids:
            query = query.filter(SysUser.id.in_(body.ids))
        query = apply_data_scope(query, SysUser, user, db, tenant_no)
        rows_orm = query.order_by(SysUser.create_time.desc()).all()
        dept_ids = list({r.dept_id for r in rows_orm if r.dept_id})
        dept_map: dict[str, str] = {}
        if dept_ids:
            for d in db.query(SysDept).filter(SysDept.id.in_(dept_ids), SysDept.del_flag == 0).all():
                dept_map[d.id] = d.dept_name or ""
        result_list = [
            user_svc._row_to_dict(r, dept_name=dept_map.get(r.dept_id or "", "")) for r in rows_orm
        ]
        user_ids = [d["id"] for d in result_list if d.get("id")]
        role_map: dict[str, list[str]] = {uid: [] for uid in user_ids}
        role_name_by_id: dict[str, str] = {}
        if user_ids:
            for ur in (
                db.query(SysUserRole)
                .filter(
                    SysUserRole.user_id.in_(user_ids),
                    SysUserRole.del_flag == 0,
                )
                .all()
            ):
                role_map.setdefault(ur.user_id, []).append(ur.role_id)
            role_ids = list({rid for ids in role_map.values() for rid in ids})
            if role_ids:
                for role in db.query(SysRole).filter(SysRole.id.in_(role_ids), SysRole.del_flag == 0).all():
                    role_name_by_id[role.id] = role.role_name or role.id
        for d in result_list:
            names = [role_name_by_id.get(rid, rid) for rid in role_map.get(d["id"], [])]
            d["roles"] = "、".join(names)
        cols = filter_export_columns(USER_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="用户列表",
            columns=cols,
            rows=result_list,
            filename_stem=f"用户列表_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.get("/users/{user_id}")
def get_user_by_id(
    user_id: str,
    user: dict = Depends(require_menu_code("system:user:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    row = user_svc.get_user(db, user_id)
    if not row:
        return error_response(404, "用户不存在")
    if row.tenant_no != tenant_no and user.get("role") != "super_admin":
        return error_response(403, "无权查看该用户")
    try:
        assert_row_in_data_scope(db, row, SysUser, user, tenant_no)
    except HTTPException:
        return error_response(403, "无权查看该用户")
    data = user_svc.get_user_with_relations(db, user_id)
    return success_response(data)


@router.post("/users")
def create_user(
    body: UserCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        if user_svc.user_no_exists(db, body.user_no, tenant_no):
            return error_response(400, "用户账号已存在")
        obj = user_svc.create_user(
            db,
            user_no=body.user_no,
            nick_name=body.nick_name,
            password=body.password,
            dept_id=body.dept_id,
            email=body.email,
            phone_no=body.phone_no,
            sex=body.sex,
            avatar=body.avatar,
            status=body.status,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
            role_ids=body.role_ids,
            post_ids=body.post_ids,
        )
        return success_response(user_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/users/{user_id}")
def update_user(
    user_id: str,
    body: UserUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = user_svc.update_user(
            db,
            user_id,
            nick_name=payload.get("nick_name"),
            dept_id=payload.get("dept_id"),
            email=payload.get("email"),
            phone_no=payload.get("phone_no"),
            sex=payload.get("sex"),
            avatar=payload.get("avatar"),
            status=payload.get("status"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id_updater=user.get("user_id"),
            role_ids=payload.get("role_ids"),
            post_ids=payload.get("post_ids"),
        )
        return success_response(user_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/users/{user_id}")
def delete_user(
    user_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        user_svc.soft_delete_user(db, user_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/users/{user_id}/reset-password")
def reset_user_password(
    user_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        user_svc.reset_password(db, user_id, "111111")
        return success_response(None, message="密码已重置为 111111")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 字典类型管理
# ---------------------------------------------------------------------------


class DictTypeCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    dict_name: str = Field(..., alias="dictName")
    dict_type: str = Field(..., alias="dictType")
    order_num: Optional[int] = Field(0, alias="orderNum")
    remark: Optional[str] = None


class DictTypeUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    dict_name: Optional[str] = Field(None, alias="dictName")
    dict_type: Optional[str] = Field(None, alias="dictType")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/dict-types")
def list_dict_types(
    request: Request,
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=500, alias="pageSize"),
    keyword: Optional[str] = None,
    user: dict = Depends(require_menu_code("system:dict:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = dict_type_svc.list_dict_types(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        dict_name=request.query_params.get("dictName"),
        dict_type=request.query_params.get("dictType"),
        dict_name_in=request.query_params.get("dictNameIn"),
        dict_type_in=request.query_params.get("dictTypeIn"),
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = dict_type_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


class DictTypeColumnFacetBody(BaseModel):
    """字典类型列表列头可选值（去重；可附带列表上下文）"""

    model_config = ConfigDict(populate_by_name=True, extra="allow")

    field: str = Field(..., description="dictName | dictType")
    keyword: Optional[str] = Field(default=None, description="可选值关键字")
    limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限")


_DICT_TYPE_FACET_COLUMNS = {
    "dictName": SysDictType.dict_name,
    "dictType": SysDictType.dict_type,
}


@router.post("/dict-types/column-facet-values")
def dict_type_column_facet_values(
    body: DictTypeColumnFacetBody,
    user: dict = Depends(require_menu_code("system:dict:list")),
    db: Session = Depends(get_db),
):
    """字典类型列表列头可选值：在列表上下文（排除本列）下去重。"""
    from app.services.pl.facet_context import strip_simple_facet_self_params

    column = _DICT_TYPE_FACET_COLUMNS.get(body.field)
    if column is None:
        return error_response(400, "不支持的列")
    try:
        tenant_no = _get_tenant_no(db, user)
        list_keyword = (body.keyword or "").strip() or None
        params = strip_simple_facet_self_params(_facet_body_params(body), body.field)
        extra = []
        kw = list_keyword or str(_param_first(params, "keyword") or "").strip()
        if kw:
            like = f"%{kw}%"
            extra.append(or_(SysDictType.dict_name.like(like), SysDictType.dict_type.like(like)))
        for col, camel, snake in (
            (SysDictType.dict_name, "dictName", "dict_name"),
            (SysDictType.dict_type, "dictType", "dict_type"),
        ):
            values = _split_csv_param(params, f"{camel}In", f"{snake}_in")
            if values:
                extra.append(col.in_(values))
            else:
                single = str(_param_first(params, camel, snake) or "").strip()
                if single:
                    extra.append(col.like(f"%{single}%"))
        rows = list_column_facet_values(
            db,
            SysDictType,
            column,
            tenant_no=tenant_no,
            keyword=None,
            limit=body.limit if body.limit is not None else 500,
            extra_filters=extra or None,
        )
        return success_response({"list": rows})
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))



DICT_TYPE_EXPORT_COLUMNS = [
    ExportColumn(title="字典名称", field="dictName"),
    ExportColumn(title="字典类型编码", field="dictType"),
    ExportColumn(title="备注", field="remark"),
    ExportColumn(title="创建时间", field="createTime"),
]


class DictTypeExportBody(BaseModel):
    keyword: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.post("/dict-types/export")
def export_dict_types(
    body: DictTypeExportBody,
    user: dict = Depends(require_menu_code("system:dict:list")),
    db: Session = Depends(get_db),
):
    """导出字典类型列表（当前筛选全量，或 ids 已选）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items, _ = dict_type_svc.list_dict_types(
            db,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            keyword=body.keyword,
            tenant_no=tenant_no,
            ids=body.ids,
            max_page_size=EXPORT_MAX_ROWS,
            user_info=user,
        )
        cols = filter_export_columns(DICT_TYPE_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="字典类型",
            columns=cols,
            rows=items,
            filename_stem=f"字典类型_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/dict-types")
def create_dict_type(
    body: DictTypeCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = dict_type_svc.create_dict_type(
            db,
            dict_name=body.dict_name,
            dict_type=body.dict_type,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(dict_type_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/dict-types/{dict_type_id}")
def update_dict_type(
    dict_type_id: str,
    body: DictTypeUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = dict_type_svc.update_dict_type(
            db,
            dict_type_id,
            dict_name=payload.get("dict_name"),
            dict_type=payload.get("dict_type"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
            tenant_no=tenant_no,
        )
        return success_response(dict_type_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/dict-types/{dict_type_id}")
def delete_dict_type(
    dict_type_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        dict_type_svc.soft_delete_dict_type(db, dict_type_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 字典数据管理
# ---------------------------------------------------------------------------


class DictDataCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    dict_label: str = Field(..., alias="dictLabel")
    dict_value: str = Field(..., alias="dictValue")
    dict_type: str = Field(..., alias="dictType")
    tag_type: Optional[str] = Field("", alias="tagType")
    order_num: Optional[int] = Field(0, alias="orderNum")
    remark: Optional[str] = None


class DictDataUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    dict_label: Optional[str] = Field(None, alias="dictLabel")
    dict_value: Optional[str] = Field(None, alias="dictValue")
    tag_type: Optional[str] = Field(None, alias="tagType")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/dict-data")
def list_dict_data(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=500, alias="pageSize"),
    dictType: Optional[str] = None,
    keyword: Optional[str] = None,
    user: dict = Depends(require_menu_code("system:dict:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = dict_data_svc.list_dict_data(
        db, page=page, page_size=pageSize, dict_type_code=dictType, keyword=keyword, tenant_no=tenant_no, user_info=user
    )
    tp = dict_data_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


@router.post("/dict-data")
def create_dict_data(
    body: DictDataCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = dict_data_svc.create_dict_data(
            db,
            dict_label=body.dict_label,
            dict_value=body.dict_value,
            dict_type=body.dict_type,
            tag_type=body.tag_type,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(dict_data_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/dict-data/{data_id}")
def update_dict_data(
    data_id: str,
    body: DictDataUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = dict_data_svc.update_dict_data(
            db,
            data_id,
            dict_label=payload.get("dict_label"),
            dict_value=payload.get("dict_value"),
            tag_type=payload.get("tag_type"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
        )
        return success_response(dict_data_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/dict-data/{data_id}")
def delete_dict_data(
    data_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        dict_data_svc.soft_delete_dict_data(db, data_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.get("/dict-data/options")
def dict_data_options(
    dictType: str = Query(..., alias="dictType"),
    user: dict = Depends(require_menu_code("system:dict:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    # 字典选项为租户主数据，表单共用；不做数据范围过滤
    items = dict_data_svc.list_dict_data_options(
        db, dict_type_code=dictType, tenant_no=tenant_no, user_info=None
    )
    return success_response(items)


@router.get("/dict-data/all")
def dict_data_all(
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    q = db.query(SysDictData).filter(
        and_(SysDictData.tenant_no == tenant_no, SysDictData.del_flag == 0)
    )
    rows = q.order_by(SysDictData.order_num.asc()).all()
    grouped = {}
    for r in rows:
        key = r.dict_type
        if key not in grouped:
            grouped[key] = []
        grouped[key].append({
            "label": r.dict_label,
            "value": r.dict_value,
            "tagType": r.tag_type or ""
        })
    return success_response(grouped)


class DictEnsureBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    dict_type: str = Field(..., alias="dictType")
    label: str
    preferred_value: Optional[str] = Field(None, alias="preferredValue")


class DictEnsureRemoveBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    dict_type: str = Field(..., alias="dictType")
    value: str


@router.post("/dict-data/ensure")
def ensure_dict_data_api(
    body: DictEnsureBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        data = dict_ensure_svc.ensure_dict_data(
            db,
            tenant_no=tenant_no,
            dict_type=body.dict_type,
            label=body.label,
            user_id=user.get("user_id") or user.get("id") or "",
            preferred_value=body.preferred_value,
        )
        db.commit()
        return success_response(data, message="已保存")
    except dict_ensure_svc.DictEnsureError as e:
        db.rollback()
        return error_response(400, str(e))


@router.post("/dict-data/ensure-remove")
def ensure_remove_dict_data_api(
    body: DictEnsureRemoveBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        dict_ensure_svc.ensure_remove_dict_data(
            db,
            tenant_no=tenant_no,
            dict_type=body.dict_type,
            value=body.value,
            user_id=user.get("user_id") or user.get("id") or "",
        )
        db.commit()
        return success_response(None, message="已删除")
    except dict_ensure_svc.DictEnsureError as e:
        db.rollback()
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 组织管理
# ---------------------------------------------------------------------------


class DeptCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    parent_id: str = Field("0", alias="parentId")
    dept_name: str = Field(..., alias="deptName")
    dept_category_code: Optional[str] = Field(None, alias="deptCategoryCode")
    status: Optional[str] = Field("1")
    leader: Optional[str] = None
    leader_phone: Optional[str] = Field(None, alias="leaderPhone")
    order_num: Optional[int] = Field(0, alias="orderNum")
    remark: Optional[str] = None


class DeptUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    dept_name: Optional[str] = Field(None, alias="deptName")
    dept_category_code: Optional[str] = Field(None, alias="deptCategoryCode")
    status: Optional[str] = None
    leader: Optional[str] = None
    leader_phone: Optional[str] = Field(None, alias="leaderPhone")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/depts")
def list_depts(
    keyword: Optional[str] = None,
    user: dict = Depends(require_menu_code("system:dept:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    tree = dept_svc.list_depts_tree(db, keyword=keyword, tenant_no=tenant_no, user_info=user)
    return success_response(tree)



DEPT_EXPORT_COLUMNS = [
    ExportColumn(title="组织名称", field="deptName"),
    ExportColumn(title="组织类别", field="deptCategoryCode"),
    ExportColumn(title="状态", field="status", dict_type="sys_status"),
    ExportColumn(title="负责人", field="leader"),
    ExportColumn(title="联系电话", field="leaderPhone"),
    ExportColumn(title="创建时间", field="createTime"),
]


class DeptExportBody(BaseModel):
    keyword: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.post("/depts/export")
def export_depts(
    body: DeptExportBody,
    user: dict = Depends(require_menu_code("system:dept:list")),
    db: Session = Depends(get_db),
):
    """导出组织列表（扁平行；当前筛选或已选）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        rows = dept_svc.list_depts(db, keyword=body.keyword, tenant_no=tenant_no, user_info=user)
        if body.ids:
            idset = set(body.ids)
            rows = [r for r in rows if r.get("id") in idset]
        cols = filter_export_columns(DEPT_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="组织列表",
            columns=cols,
            rows=rows,
            filename_stem=f"组织列表_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/depts")
def create_dept(
    body: DeptCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = dept_svc.create_dept(
            db,
            parent_id=body.parent_id,
            dept_name=body.dept_name,
            dept_category_code=body.dept_category_code,
            status=body.status,
            leader=body.leader,
            leader_phone=body.leader_phone,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(dept_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/depts/{dept_id}")
def update_dept(
    dept_id: str,
    body: DeptUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = dept_svc.update_dept(
            db,
            dept_id,
            dept_name=payload.get("dept_name"),
            dept_category_code=payload.get("dept_category_code"),
            status=payload.get("status"),
            leader=payload.get("leader"),
            leader_phone=payload.get("leader_phone"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
        )
        return success_response(dept_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/depts/{dept_id}")
def delete_dept(
    dept_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        dept_svc.soft_delete_dept(db, dept_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 站点管理
# ---------------------------------------------------------------------------


class SiteCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    site_name: str = Field(..., alias="siteName")
    site_code: str = Field(..., alias="siteCode")
    site_type: Optional[str] = Field(None, alias="siteType")
    status: Optional[str] = Field("1")
    address: Optional[str] = None
    contact_name: Optional[str] = Field(None, alias="contactName")
    contact_phone: Optional[str] = Field(None, alias="contactPhone")
    business_scope: Optional[str] = Field(None, alias="businessScope")
    order_num: Optional[int] = Field(0, alias="orderNum")
    remark: Optional[str] = None


class SiteUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    site_name: Optional[str] = Field(None, alias="siteName")
    site_code: Optional[str] = Field(None, alias="siteCode")
    site_type: Optional[str] = Field(None, alias="siteType")
    status: Optional[str] = None
    address: Optional[str] = None
    contact_name: Optional[str] = Field(None, alias="contactName")
    contact_phone: Optional[str] = Field(None, alias="contactPhone")
    business_scope: Optional[str] = Field(None, alias="businessScope")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/sites")
def list_sites(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=500, alias="pageSize"),
    keyword: Optional[str] = None,
    user: dict = Depends(require_menu_code("system:site:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = site_svc.list_sites(db, page=page, page_size=pageSize, keyword=keyword, tenant_no=tenant_no, user_info=user)
    tp = site_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})



SITE_EXPORT_COLUMNS = [
    ExportColumn(title="站点名称", field="siteName"),
    ExportColumn(title="站点编码", field="siteCode"),
    ExportColumn(title="站点类型", field="siteType"),
    ExportColumn(title="状态", field="status", dict_type="sys_status"),
    ExportColumn(title="地址", field="address"),
    ExportColumn(title="联系人", field="contactName"),
    ExportColumn(title="联系电话", field="contactPhone"),
    ExportColumn(title="创建时间", field="createTime"),
]


class SiteExportBody(BaseModel):
    keyword: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.post("/sites/export")
def export_sites(
    body: SiteExportBody,
    user: dict = Depends(require_menu_code("system:site:list")),
    db: Session = Depends(get_db),
):
    """导出站点列表（当前筛选全量，或 ids 已选）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items, _ = site_svc.list_sites(
            db,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            keyword=body.keyword,
            tenant_no=tenant_no,
            ids=body.ids,
            max_page_size=EXPORT_MAX_ROWS,
            user_info=user,
        )
        cols = filter_export_columns(SITE_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="站点列表",
            columns=cols,
            rows=items,
            filename_stem=f"站点列表_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/sites")
def create_site(
    body: SiteCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = site_svc.create_site(
            db,
            site_name=body.site_name,
            site_code=body.site_code,
            site_type=body.site_type,
            status=body.status,
            address=body.address,
            contact_name=body.contact_name,
            contact_phone=body.contact_phone,
            business_scope=body.business_scope,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(site_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/sites/{site_id}")
def update_site(
    site_id: str,
    body: SiteUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = site_svc.update_site(
            db,
            site_id,
            site_name=payload.get("site_name"),
            site_code=payload.get("site_code"),
            site_type=payload.get("site_type"),
            status=payload.get("status"),
            address=payload.get("address"),
            contact_name=payload.get("contact_name"),
            contact_phone=payload.get("contact_phone"),
            business_scope=payload.get("business_scope"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
        )
        return success_response(site_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/sites/{site_id}")
def delete_site(
    site_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        site_svc.soft_delete_site(db, site_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 职位管理
# ---------------------------------------------------------------------------


class PostCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    post_name: str = Field(..., alias="postName")
    post_code: str = Field(..., alias="postCode")
    status: Optional[str] = Field("1")
    order_num: Optional[int] = Field(0, alias="orderNum")
    remark: Optional[str] = None


class PostUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    post_name: Optional[str] = Field(None, alias="postName")
    post_code: Optional[str] = Field(None, alias="postCode")
    status: Optional[str] = None
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/posts")
def list_posts(
    request: Request,
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=500, alias="pageSize"),
    keyword: Optional[str] = None,
    user: dict = Depends(require_menu_code("system:post:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = post_svc.list_posts(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        post_name=request.query_params.get("postName"),
        post_code=request.query_params.get("postCode"),
        post_name_in=request.query_params.get("postNameIn"),
        post_code_in=request.query_params.get("postCodeIn"),
        status=request.query_params.get("status"),
        status_in=request.query_params.get("statusIn"),
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = post_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


class PostColumnFacetBody(BaseModel):
    """职位列表列头可选值（去重；可附带列表上下文）"""

    model_config = ConfigDict(populate_by_name=True, extra="allow")

    field: str = Field(..., description="postName | postCode")
    keyword: Optional[str] = Field(default=None, description="可选值关键字")
    limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限")


_POST_FACET_COLUMNS = {
    "postName": SysPost.post_name,
    "postCode": SysPost.post_code,
}


@router.post("/posts/column-facet-values")
def post_column_facet_values(
    body: PostColumnFacetBody,
    user: dict = Depends(require_menu_code("system:post:list")),
    db: Session = Depends(get_db),
):
    """职位列表列头可选值：在列表上下文（排除本列）下去重。"""
    from app.services.pl.facet_context import strip_simple_facet_self_params

    column = _POST_FACET_COLUMNS.get(body.field)
    if column is None:
        return error_response(400, "不支持的列")
    try:
        tenant_no = _get_tenant_no(db, user)
        list_keyword = (body.keyword or "").strip() or None
        params = strip_simple_facet_self_params(_facet_body_params(body), body.field)
        extra = []
        kw = list_keyword or str(_param_first(params, "keyword") or "").strip()
        if kw:
            like = f"%{kw}%"
            extra.append(or_(SysPost.post_name.like(like), SysPost.post_code.like(like)))
        for col, camel, snake in (
            (SysPost.post_name, "postName", "post_name"),
            (SysPost.post_code, "postCode", "post_code"),
        ):
            values = _split_csv_param(params, f"{camel}In", f"{snake}_in")
            if values:
                extra.append(col.in_(values))
            else:
                single = str(_param_first(params, camel, snake) or "").strip()
                if single:
                    extra.append(col.like(f"%{single}%"))
        status_values = _split_csv_param(params, "statusIn", "status_in")
        if not status_values:
            st = _param_first(params, "status")
            if st:
                status_values = [str(st).strip()]
        if status_values:
            extra.append(SysPost.status.in_(status_values))
        rows = list_column_facet_values(
            db,
            SysPost,
            column,
            tenant_no=tenant_no,
            keyword=None,
            limit=body.limit if body.limit is not None else 500,
            extra_filters=extra or None,
        )
        return success_response({"list": rows})
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))



POST_EXPORT_COLUMNS = [
    ExportColumn(title="职位名称", field="postName"),
    ExportColumn(title="职位编码", field="postCode"),
    ExportColumn(title="状态", field="status", dict_type="sys_status"),
    ExportColumn(title="创建时间", field="createTime"),
]


class PostExportBody(BaseModel):
    keyword: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.post("/posts/export")
def export_posts(
    body: PostExportBody,
    user: dict = Depends(require_menu_code("system:post:list")),
    db: Session = Depends(get_db),
):
    """导出职位列表（当前筛选全量，或 ids 已选）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items, _ = post_svc.list_posts(
            db,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            keyword=body.keyword,
            tenant_no=tenant_no,
            ids=body.ids,
            max_page_size=EXPORT_MAX_ROWS,
            user_info=user,
        )
        cols = filter_export_columns(POST_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="职位列表",
            columns=cols,
            rows=items,
            filename_stem=f"职位列表_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/posts")
def create_post(
    body: PostCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = post_svc.create_post(
            db,
            post_name=body.post_name,
            post_code=body.post_code,
            status=body.status,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(post_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/posts/{post_id}")
def update_post(
    post_id: str,
    body: PostUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = post_svc.update_post(
            db,
            post_id,
            post_name=payload.get("post_name"),
            post_code=payload.get("post_code"),
            status=payload.get("status"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
        )
        return success_response(post_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/posts/{post_id}")
def delete_post(
    post_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        post_svc.soft_delete_post(db, post_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


class PostUsersUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    user_ids: List[str] = Field(default_factory=list, alias="userIds")


@router.get("/posts/{post_id}/users")
def list_post_bound_users(
    post_id: str,
    user: dict = Depends(require_menu_code("system:post:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    post = post_svc.get_post(db, post_id)
    if not post or post.tenant_no != tenant_no:
        return error_response(404, "职位不存在")
    ids = user_svc.list_user_ids_bound_to_post(db, post_id, tenant_no)
    return success_response({"userIds": ids})


@router.put("/posts/{post_id}/users")
def update_post_bound_users(
    post_id: str,
    body: PostUsersUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    post = post_svc.get_post(db, post_id)
    if not post or post.tenant_no != tenant_no:
        return error_response(404, "职位不存在")
    try:
        user_svc.sync_post_user_bindings(
            db, post_id, tenant_no, body.user_ids, user.get("user_id")
        )
        return success_response(None, message="保存成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 菜单管理
# ---------------------------------------------------------------------------


class MenuCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    menu_name: str = Field(..., alias="menuName")
    parent_id: str = Field("0", alias="parentId")
    menu_type: str = Field("M", alias="menuType")
    path: Optional[str] = Field("", alias="path")
    component: Optional[str] = Field(None, alias="component")
    perms: Optional[str] = Field(None, alias="perms")
    is_frame: Optional[int] = Field(1, alias="isFrame")
    visible: Optional[str] = Field("1", alias="visible")
    status: Optional[str] = Field("1", alias="status")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


class MenuUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    menu_name: Optional[str] = Field(None, alias="menuName")
    parent_id: Optional[str] = Field(None, alias="parentId")
    menu_type: Optional[str] = Field(None, alias="menuType")
    path: Optional[str] = Field(None, alias="path")
    component: Optional[str] = Field(None, alias="component")
    perms: Optional[str] = Field(None, alias="perms")
    is_frame: Optional[int] = Field(None, alias="isFrame")
    visible: Optional[str] = Field(None, alias="visible")
    status: Optional[str] = Field(None, alias="status")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/menus")
def list_menus(
    keyword: Optional[str] = None,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    tree = menu_svc.list_menus_tree(db, keyword=keyword, tenant_no=tenant_no, user_info=user)
    return success_response(tree)



MENU_EXPORT_COLUMNS = [
    ExportColumn(title="菜单名称", field="menuName"),
    ExportColumn(title="菜单类型", field="menuType"),
    ExportColumn(title="路由", field="path"),
    ExportColumn(title="组件", field="component"),
    ExportColumn(title="权限标识", field="perms"),
    ExportColumn(title="状态", field="status", dict_type="sys_status"),
    ExportColumn(title="可见", field="visible"),
    ExportColumn(title="创建时间", field="createTime"),
]


class MenuExportBody(BaseModel):
    keyword: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.post("/menus/export")
def export_menus(
    body: MenuExportBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """导出菜单列表（扁平行；当前筛选或已选）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        # list flat via tree then flatten, or use underlying list if exists
        from app.crud import menu as menu_mod
        if hasattr(menu_mod, 'list_menus'):
            rows = menu_mod.list_menus(db, keyword=body.keyword, tenant_no=tenant_no, user_info=user)
        else:
            tree = menu_svc.list_menus_tree(db, keyword=body.keyword, tenant_no=tenant_no, user_info=user)
            rows = []
            def walk(nodes):
                for n in nodes or []:
                    item = {k: v for k, v in n.items() if k != 'children'}
                    rows.append(item)
                    walk(n.get('children') or [])
            walk(tree)
        if body.ids:
            idset = set(body.ids)
            rows = [r for r in rows if r.get("id") in idset]
        cols = filter_export_columns(MENU_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="菜单列表",
            columns=cols,
            rows=rows,
            filename_stem=f"菜单列表_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/menus")
def create_menu(
    body: MenuCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = menu_svc.create_menu(
            db,
            menu_name=body.menu_name,
            parent_id=body.parent_id,
            menu_type=body.menu_type,
            path=body.path,
            component=body.component,
            perms=body.perms,
            is_frame=body.is_frame,
            visible=body.visible,
            status=body.status,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(menu_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/menus/{menu_id}")
def update_menu(
    menu_id: str,
    body: MenuUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = menu_svc.update_menu(
            db,
            menu_id,
            menu_name=payload.get("menu_name"),
            parent_id=payload.get("parent_id"),
            menu_type=payload.get("menu_type"),
            path=payload.get("path"),
            component=payload.get("component"),
            perms=payload.get("perms"),
            is_frame=payload.get("is_frame"),
            visible=payload.get("visible"),
            status=payload.get("status"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
        )
        return success_response(menu_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/menus/{menu_id}")
def delete_menu(
    menu_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        menu_svc.soft_delete_menu(db, menu_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 角色管理
# ---------------------------------------------------------------------------


class RoleCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    role_name: str = Field(..., alias="roleName")
    data_scope: Optional[str] = Field("4", alias="dataScope")
    status: Optional[str] = Field("1", alias="status")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


class RoleUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    role_name: Optional[str] = Field(None, alias="roleName")
    data_scope: Optional[str] = Field(None, alias="dataScope")
    status: Optional[str] = Field(None, alias="status")
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


class RoleMenuBody(BaseModel):
    menu_ids: List[str] = Field(..., alias="menuIds")


class RoleDataScopeBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    data_scope: str = Field(..., alias="dataScope")
    scope_details: Optional[List[dict]] = Field(None, alias="scopeDetails")


@router.get("/role-management")
def list_role_management(
    request: Request,
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=500, alias="pageSize"),
    keyword: Optional[str] = None,
    user: dict = Depends(require_menu_code("system:role:list")),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = role_svc.list_roles(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        role_name=request.query_params.get("roleName"),
        role_name_in=request.query_params.get("roleNameIn"),
        status=request.query_params.get("status"),
        status_in=request.query_params.get("statusIn"),
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = role_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


class RoleColumnFacetBody(BaseModel):
    """角色列表列头可选值（去重；可附带列表上下文）"""

    model_config = ConfigDict(populate_by_name=True, extra="allow")

    field: str = Field(..., description="roleName")
    keyword: Optional[str] = Field(default=None, description="可选值关键字")
    limit: Optional[int] = Field(default=500, ge=1, le=500, description="返回条数上限")


_ROLE_FACET_COLUMNS = {
    "roleName": SysRole.role_name,
}


@router.post("/role-management/column-facet-values")
def role_column_facet_values(
    body: RoleColumnFacetBody,
    user: dict = Depends(require_menu_code("system:role:list")),
    db: Session = Depends(get_db),
):
    """角色列表列头可选值：在列表上下文（排除本列）下去重。"""
    from app.services.pl.facet_context import strip_simple_facet_self_params

    column = _ROLE_FACET_COLUMNS.get(body.field)
    if column is None:
        return error_response(400, "不支持的列")
    try:
        tenant_no = _get_tenant_no(db, user)
        list_keyword = (body.keyword or "").strip() or None
        params = strip_simple_facet_self_params(_facet_body_params(body), body.field)
        extra = []
        kw = list_keyword or str(_param_first(params, "keyword") or "").strip()
        if kw:
            extra.append(SysRole.role_name.like(f"%{kw}%"))
        values = _split_csv_param(params, "roleNameIn", "role_name_in")
        if values:
            extra.append(SysRole.role_name.in_(values))
        else:
            single = str(_param_first(params, "roleName", "role_name") or "").strip()
            if single:
                extra.append(SysRole.role_name.like(f"%{single}%"))
        status_values = _split_csv_param(params, "statusIn", "status_in")
        if not status_values:
            st = _param_first(params, "status")
            if st:
                status_values = [str(st).strip()]
        if status_values:
            extra.append(SysRole.status.in_(status_values))
        rows = list_column_facet_values(
            db,
            SysRole,
            column,
            tenant_no=tenant_no,
            keyword=None,
            limit=body.limit if body.limit is not None else 500,
            apply_scope=lambda q: apply_data_scope(q, SysRole, user, db, tenant_no),
            extra_filters=extra or None,
        )
        return success_response({"list": rows})
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))



ROLE_EXPORT_COLUMNS = [
    ExportColumn(title="角色名称", field="roleName"),
    ExportColumn(title="数据权限", field="dataScope", dict_type="sys_data_scope"),
    ExportColumn(title="状态", field="status", dict_type="sys_status"),
    ExportColumn(title="创建时间", field="createTime"),
]


class RoleExportBody(BaseModel):
    keyword: Optional[str] = None
    ids: Optional[List[str]] = None
    columns: Optional[List[str]] = None


@router.post("/role-management/export")
def export_role_management(
    body: RoleExportBody,
    user: dict = Depends(require_menu_code("system:role:list")),
    db: Session = Depends(get_db),
):
    """导出角色列表（当前筛选全量，或 ids 已选）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items, _ = role_svc.list_roles(
            db,
            page=1,
            page_size=EXPORT_MAX_ROWS,
            keyword=body.keyword,
            tenant_no=tenant_no,
            ids=body.ids,
            max_page_size=EXPORT_MAX_ROWS,
            user_info=user,
        )
        cols = filter_export_columns(ROLE_EXPORT_COLUMNS, body.columns)
        date_str = datetime.now().strftime("%Y%m%d")
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title="角色列表",
            columns=cols,
            rows=items,
            filename_stem=f"角色列表_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(500, str(e))


@router.post("/role-management")
def create_role_management(
    body: RoleCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = role_svc.create_role(
            db,
            role_name=body.role_name,
            data_scope=body.data_scope,
            status=body.status,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=user.get("user_id"),
        )
        return success_response(role_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.get("/role-management/{role_id}")
def get_role_management(
    role_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    obj = role_svc.get_role(db, role_id)
    if not obj or obj.tenant_no != tenant_no:
        return error_response(404, "角色不存在")
    try:
        assert_row_in_data_scope(db, obj, SysRole, user, tenant_no)
    except HTTPException:
        return error_response(403, "无权查看该角色")
    return success_response(role_svc._row_to_dict(obj))


@router.put("/role-management/{role_id}")
def update_role_management(
    role_id: str,
    body: RoleUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        payload: dict[str, Any] = body.model_dump(exclude_unset=True, by_alias=False)
        obj = role_svc.update_role(
            db,
            role_id,
            role_name=payload.get("role_name"),
            data_scope=payload.get("data_scope"),
            status=payload.get("status"),
            order_num=payload.get("order_num"),
            remark=payload.get("remark"),
            user_id=user.get("user_id"),
        )
        return success_response(role_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/role-management/{role_id}")
def delete_role_management(
    role_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        role_svc.soft_delete_role(db, role_id, user_info=_user)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.get("/role-management/{role_id}/menus")
def get_role_menus(
    role_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    menu_ids = role_svc.get_role_menu_ids(db, role_id)
    return success_response({"menuIds": menu_ids})


@router.put("/role-management/{role_id}/menus")
def update_role_menus(
    role_id: str,
    body: RoleMenuBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        role_svc.update_role_menus(db, role_id, body.menu_ids, tenant_no, user_id=user.get("user_id"))
        return success_response(None, message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.get("/role-management/{role_id}/data-scope")
def get_role_data_scope(
    role_id: str,
    _user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    role = role_svc.get_role(db, role_id)
    if not role:
        return error_response(404, "角色不存在")
    details = role_svc.get_role_data_scope(db, role_id)
    return success_response({"dataScope": role.data_scope or "1", "scopeDetails": details})


@router.put("/role-management/{role_id}/data-scope")
def update_role_data_scope(
    role_id: str,
    body: RoleDataScopeBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        role_svc.update_role_data_scope(
            db,
            role_id,
            body.data_scope,
            body.scope_details,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
        )
        return success_response(None, message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 附件上传
# ---------------------------------------------------------------------------


def _format_file_size(size_bytes: int) -> str:
    if size_bytes < 1024:
        return f"{size_bytes} B"
    elif size_bytes < 1024 * 1024:
        return f"{size_bytes / 1024:.1f} KB"
    else:
        return f"{size_bytes / (1024 * 1024):.1f} MB"


@router.post("/attachment/upload")
def upload_attachment(
    file: UploadFile = File(...),
    folder: Optional[str] = Form(""),
    biz_type: Optional[str] = Form(None, alias="bizType"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    if not file or not file.filename:
        return error_response(400, "请选择文件")
    try:
        effective_folder = resolve_upload_folder(
            folder=folder or "", biz_type=biz_type or ""
        )
        file_content = file.file.read()
        full_url = storage.upload_file(file_content, file.filename, effective_folder)
        base_url = settings.MINIO_BASE_URL.rstrip("/") if settings.MINIO_BASE_URL else ""
        if base_url and full_url.startswith(base_url + "/"):
            file_url = full_url[len(base_url) + 1:]
        else:
            file_url = full_url
        file_size = len(file_content)
        file_ext = os.path.splitext(file.filename)[1].lstrip(".") if file.filename else ""
        file_type = file.content_type or ""
        tenant_no = _get_tenant_no(db, user)
        record = oss_svc.create_oss(
            db,
            tenant_no=tenant_no,
            url=file_url,
            original_name=file.filename,
            file_suffix=file_ext,
            file_size=file_size,
            file_type=file_type,
            biz_type=(biz_type or "").strip(),
            user_id=user.get("user_id"),
            ext1=effective_folder or None,
        )
        return success_response({
            "id": record.id,
            "fileName": record.original_name,
            "fileUrl": record.url,
            "fileSize": record.file_size,
            "fileSizeDisplay": _format_file_size(record.file_size or 0),
            "fileType": record.file_type,
            "bizType": record.biz_type or "",
        })
    except Exception as e:
        db.rollback()
        return error_response(500, f"上传失败: {str(e)}")


class AttachmentDownloadUrlBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    file_url: str = Field(..., alias="fileUrl")
    file_name: Optional[str] = Field(None, alias="fileName")


@router.post("/attachment/download-url")
def attachment_download_url(
    body: AttachmentDownloadUrlBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """返回带 Content-Disposition 的下载 URL，保证浏览器使用原始文件名。"""
    file_url = (body.file_url or "").strip()
    if not file_url:
        return error_response(400, "文件地址不能为空")
    tenant_no = _get_tenant_no(db, user)
    file_url, att = oss_svc.resolve_storage_path(db, tenant_no, file_url)
    if not att:
        att = oss_svc.get_oss_by_url(db, tenant_no, file_url)
    download_name = (body.file_name or "").strip()
    if not download_name and att:
        download_name = (att.original_name or "").strip()
    if not download_name:
        download_name = file_url.rsplit("/", 1)[-1] or "download"
    try:
        url = storage.presigned_download_url(file_url, download_name)
        return success_response({"downloadUrl": url})
    except Exception as e:
        return error_response(500, f"获取下载链接失败: {str(e)}")


@router.post("/attachment/preview-url")
def attachment_preview_url(
    body: AttachmentDownloadUrlBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """返回用于浏览器内联预览的 URL（PDF iframe 等）。"""
    file_url = (body.file_url or "").strip()
    if not file_url:
        return error_response(400, "文件地址不能为空")
    tenant_no = _get_tenant_no(db, user)
    file_url, _att = oss_svc.resolve_storage_path(db, tenant_no, file_url)
    try:
        url = storage.presigned_preview_url(file_url)
        return success_response({"previewUrl": url})
    except Exception as e:
        return error_response(500, f"获取预览链接失败: {str(e)}")


# ---------------------------------------------------------------------------
# 用户菜单收藏
# ---------------------------------------------------------------------------


@router.get("/menu-favorites")
def list_menu_favorites(
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    user_id = user.get("user_id")
    if not user_id:
        return error_response(401, "用户无效")
    tenant_no = _get_tenant_no(db, user)
    from app.crud import menu_favorite as fav_svc

    return success_response(fav_svc.list_favorites(db, user_id=user_id, tenant_no=tenant_no))


@router.post("/menu-favorites")
def create_menu_favorite(
    body: MenuFavoriteCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    from app.crud import menu_favorite as fav_svc

    user_id = user.get("user_id")
    if not user_id:
        return error_response(401, "用户无效")
    tenant_no = _get_tenant_no(db, user)
    try:
        data = fav_svc.add_favorite(
            db,
            user_id=user_id,
            tenant_no=tenant_no,
            menu_path=body.path,
            create_dept_id=str(user.get("dept_id") or ""),
        )
        return success_response(data)
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/menu-favorites/order")
def reorder_menu_favorites(
    body: MenuFavoriteReorderBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    from app.crud import menu_favorite as fav_svc

    user_id = user.get("user_id")
    if not user_id:
        return error_response(401, "用户无效")
    tenant_no = _get_tenant_no(db, user)
    try:
        data = fav_svc.reorder_favorites(
            db, user_id=user_id, tenant_no=tenant_no, paths=body.paths or []
        )
        return success_response(data)
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/menu-favorites")
def delete_menu_favorite(
    body: MenuFavoriteDeleteBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    from app.crud import menu_favorite as fav_svc

    user_id = user.get("user_id")
    if not user_id:
        return error_response(401, "用户无效")
    tenant_no = _get_tenant_no(db, user)
    fav_svc.soft_delete_favorite(
        db, user_id=user_id, tenant_no=tenant_no, menu_path=body.path
    )
    return success_response({"path": body.path})


# ---------------------------------------------------------------------------
# Demo 模板页：Mock 数据由前端组装行后走统一 xlsx 导出（无 Demo 业务表）
# ---------------------------------------------------------------------------


class DemoXlsxColumnSpec(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    title: str
    field: str


class DemoXlsxExportBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    sheet_title: str = Field(default="导出", alias="sheetTitle")
    filename_stem: str = Field(default="export", alias="filenameStem")
    columns: List[DemoXlsxColumnSpec]
    rows: List[dict]


@router.post("/demo/xlsx-export")
def demo_xlsx_export(
    body: DemoXlsxExportBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    """Demo 列表导出：接收已筛选行与列定义，生成 xlsx。"""
    try:
        rows = body.rows or []
        if not rows:
            raise ExportValidationError("没有可导出的数据")
        if len(rows) > EXPORT_MAX_ROWS:
            raise ExportValidationError(f"导出超过 {EXPORT_MAX_ROWS} 条，请缩小筛选范围")
        if not body.columns:
            raise ExportValidationError("没有可导出的列")
        cols = [ExportColumn(title=c.title, field=c.field) for c in body.columns]
        tenant_no = _get_tenant_no(db, user)
        date_str = datetime.now().strftime("%Y%m%d")
        stem = (body.filename_stem or "export").strip() or "export"
        return export_rows_to_xlsx_response(
            db,
            tenant_no=tenant_no,
            sheet_title=body.sheet_title or "导出",
            columns=cols,
            rows=rows,
            filename_stem=f"{stem}_{date_str}",
        )
    except ExportValidationError as e:
        return error_response(400, str(e))