588 lines
23 KiB
Python
588 lines
23 KiB
Python
"""组织架构路由: 部门 / 职位 / 职级 / 数据字典."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import date
|
||
from typing import Annotated, Any
|
||
|
||
from fastapi import APIRouter, Depends, File, Query, UploadFile
|
||
from sqlalchemy import func, select
|
||
|
||
from ...core.deps import AuthContext, AuthCtx, Session, require_perm
|
||
from ...core.errors import AppError
|
||
from ...schemas.employee import ImportResult
|
||
from ..crud import CrudSpec, build_router
|
||
from ..helpers import parse_xlsx, xlsx_response
|
||
from ...models.employee import Employee
|
||
from ...models.org import Department, DictItem, DictType, JobLevel, Position
|
||
from ...schemas.org import (
|
||
DepartmentCreate, DepartmentRead, DepartmentUpdate,
|
||
DictItemCreate, DictItemRead, DictItemUpdate,
|
||
DictTypeCreate, DictTypeRead, DictTypeUpdate,
|
||
ExpenseStandardItem, ExpenseStandardsPayload,
|
||
JobLevelCreate, JobLevelRead, JobLevelUpdate,
|
||
PositionCreate, PositionRead, PositionUpdate,
|
||
)
|
||
|
||
router = APIRouter()
|
||
|
||
|
||
async def _parent_chain(session, department_id: int) -> set[int]:
|
||
"""给定部门的整条上级链(不含自身),沿 parent_id 上溯。
|
||
|
||
只信 parent_id:dep_path 是展示用的历史字段(播种 / 新增 / 导入三种写法都出现过),
|
||
拿它做前缀判断既会误报环,也会漏判。
|
||
"""
|
||
rows = (await session.execute(select(Department.id, Department.parent_id))).all()
|
||
parent_of = {row[0]: row[1] or 0 for row in rows}
|
||
chain: set[int] = set()
|
||
cursor = parent_of.get(department_id, 0)
|
||
while cursor and cursor not in chain:
|
||
chain.add(cursor)
|
||
cursor = parent_of.get(cursor, 0)
|
||
return chain
|
||
|
||
|
||
async def _dept_before(action, data, obj, auth, session):
|
||
parent_id = int(data.get("parent_id", (getattr(obj, "parent_id", 0) if obj else 0)) or 0)
|
||
if obj is not None and parent_id:
|
||
if parent_id == obj.id:
|
||
raise AppError("不能把部门移动到自身下", "bad_parent")
|
||
parent = await session.get(Department, parent_id)
|
||
if not parent:
|
||
raise AppError("上级部门不存在", "bad_parent")
|
||
# 环检测只能沿 parent_id 往上爬:dep_path 历史上有两套写法,顶层一律是
|
||
# `.0`,用前缀判断会把「把 7 挂到 3 下」误判成「移动到自己的下级」而拒绝。
|
||
chain = await _parent_chain(session, parent_id)
|
||
if obj.id in chain:
|
||
raise AppError("不能把部门移动到自己的下级部门", "bad_parent")
|
||
data["parent_id"] = parent_id
|
||
if parent_id:
|
||
parent = await session.get(Department, parent_id)
|
||
if not parent:
|
||
raise AppError("上级部门不存在", "bad_parent")
|
||
data["dep_path"] = f"{parent.dep_path}.{parent.id}"
|
||
data["level"] = parent.level + 1
|
||
else:
|
||
data["dep_path"] = ".0"
|
||
data["level"] = 1
|
||
return data
|
||
|
||
|
||
async def _refresh_subtree(session, node) -> None:
|
||
children = (
|
||
await session.execute(select(Department).where(Department.parent_id == node.id))
|
||
).scalars().all()
|
||
node.is_parent = bool(children)
|
||
for child in children:
|
||
new_path = f"{node.dep_path}.{node.id}"
|
||
if child.dep_path != new_path:
|
||
child.dep_path = new_path
|
||
child.level = node.level + 1
|
||
await session.flush()
|
||
await _refresh_subtree(session, child)
|
||
|
||
|
||
async def _dept_after(action, obj, auth, session):
|
||
await _refresh_subtree(session, obj)
|
||
|
||
|
||
async def _dept_delete(obj, auth, session):
|
||
children = (
|
||
await session.execute(select(func.count()).select_from(Department).where(Department.parent_id == obj.id))
|
||
).scalar_one()
|
||
if children:
|
||
raise AppError("该部门下还有子部门,请先处理下级部门", "has_children")
|
||
staff = (
|
||
await session.execute(
|
||
select(func.count()).select_from(Employee)
|
||
.where(Employee.department_id == obj.id, Employee.status != "resigned")
|
||
)
|
||
).scalar_one()
|
||
if staff:
|
||
raise AppError(f"该部门还有 {staff} 名在职员工,无法删除", "has_employees")
|
||
|
||
|
||
def _txt(value: Any) -> str:
|
||
return "" if value is None else str(value).strip()
|
||
|
||
|
||
def _flag(value: Any, default: bool = True) -> bool:
|
||
text = _txt(value).lower()
|
||
if not text:
|
||
return default
|
||
if text in ("是", "启用", "1", "true", "yes", "y", "on"):
|
||
return True
|
||
if text in ("否", "停用", "0", "false", "no", "n", "off"):
|
||
return False
|
||
raise ValueError(f"无法识别的启用状态:{value}")
|
||
|
||
|
||
def _int(value: Any, default: int = 0) -> int:
|
||
text = _txt(value)
|
||
if not text:
|
||
return default
|
||
try:
|
||
return int(float(text))
|
||
except ValueError as exc:
|
||
raise ValueError(f"不是合法数字:{value}") from exc
|
||
|
||
|
||
def _fail(result: ImportResult, row: int, name: Any, exc: Exception) -> None:
|
||
result.failed += 1
|
||
result.errors.append({"row": row, "name": _txt(name), "message": str(exc)})
|
||
|
||
|
||
async def _rebuild_department_paths(session) -> None:
|
||
"""导入后统一重算 dep_path / level / is_parent,保证树结构自洽。"""
|
||
rows = list((await session.execute(select(Department))).scalars().all())
|
||
by_id = {d.id: d for d in rows}
|
||
children: dict[int, list[Department]] = {}
|
||
for dept in rows:
|
||
parent_id = dept.parent_id or 0
|
||
if parent_id and parent_id not in by_id:
|
||
dept.parent_id, parent_id = 0, 0
|
||
children.setdefault(parent_id, []).append(dept)
|
||
for kids in children.values():
|
||
kids.sort(key=lambda d: (d.sort or 0, d.id))
|
||
|
||
visited: set[int] = set()
|
||
|
||
def walk(parent_id: int, parent_path: str, level: int) -> None:
|
||
for node in children.get(parent_id, []):
|
||
if node.id in visited:
|
||
raise AppError("部门层级存在循环引用,请检查上级部门", "bad_parent")
|
||
visited.add(node.id)
|
||
node.dep_path = f"{parent_path}.{node.id}" if parent_path else ".0"
|
||
node.level = level
|
||
node.is_parent = bool(children.get(node.id))
|
||
walk(node.id, node.dep_path, level + 1)
|
||
|
||
walk(0, "", 1)
|
||
if len(visited) != len(rows):
|
||
raise AppError("部门层级存在循环引用,请检查上级部门", "bad_parent")
|
||
|
||
|
||
departments_custom = APIRouter()
|
||
|
||
|
||
@departments_custom.get("/tree", summary="部门树")
|
||
async def department_tree(session: Session, auth: AuthCtx, only_active: bool = Query(True)):
|
||
stmt = select(Department)
|
||
if only_active:
|
||
stmt = stmt.where(Department.is_active.is_(True))
|
||
depts = list((await session.execute(stmt.order_by(Department.sort, Department.id))).scalars().all())
|
||
counts = dict(
|
||
(
|
||
await session.execute(
|
||
select(Employee.department_id, func.count())
|
||
.where(Employee.status != "resigned")
|
||
.group_by(Employee.department_id)
|
||
)
|
||
).all()
|
||
)
|
||
nodes = {
|
||
d.id: {
|
||
"id": d.id, "name": d.name, "code": d.code, "parent_id": d.parent_id,
|
||
"level": d.level, "is_parent": d.is_parent, "leader_employee_id": d.leader_employee_id,
|
||
"employee_count": int(counts.get(d.id, 0)), "is_active": d.is_active,
|
||
"cost_center": d.cost_center, "sort": d.sort, "remark": d.remark, "children": [],
|
||
}
|
||
for d in depts
|
||
}
|
||
roots: list[dict] = []
|
||
for node in nodes.values():
|
||
parent = nodes.get(node["parent_id"])
|
||
if parent:
|
||
parent["children"].append(node)
|
||
parent["is_parent"] = True
|
||
else:
|
||
roots.append(node)
|
||
|
||
def _rollup(node: dict) -> int:
|
||
node["total_count"] = node["employee_count"] + sum(_rollup(c) for c in node["children"])
|
||
return node["total_count"]
|
||
|
||
for root in roots:
|
||
_rollup(root)
|
||
return roots
|
||
|
||
|
||
DEPT_HEADERS = ["部门编码", "部门名称", "上级部门编码", "部门负责人工号", "成本中心",
|
||
"排序", "是否启用", "备注"]
|
||
|
||
|
||
@departments_custom.get("/export", summary="导出部门")
|
||
async def export_departments(
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:department:export"))],
|
||
):
|
||
rows = list((await session.execute(
|
||
select(Department).order_by(Department.level, Department.sort, Department.id)
|
||
)).scalars().all())
|
||
names = {d.id: d.name for d in rows}
|
||
codes = {d.id: d.code or "" for d in rows}
|
||
emp_rows = (await session.execute(select(Employee.id, Employee.work_no))).all()
|
||
work_nos = {row[0]: row[1] for row in emp_rows}
|
||
data = [[
|
||
d.code, d.name, codes.get(d.parent_id, ""), work_nos.get(d.leader_employee_id, ""),
|
||
d.cost_center, d.sort, "是" if d.is_active else "否", d.remark, d.level,
|
||
] for d in rows]
|
||
return xlsx_response([*DEPT_HEADERS, "层级"], data, f"组织架构_部门_{date.today()}.xlsx")
|
||
|
||
|
||
@departments_custom.get("/import-template", summary="部门导入模板")
|
||
async def department_import_template(
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:department:import"))],
|
||
):
|
||
sample = [
|
||
["D001", "研发中心", "", "", "CC-1001", 10, "是", "一级部门"],
|
||
["D002", "后端组", "D001", "", "CC-1002", 10, "是", "填上级部门编码即可挂在研发中心下"],
|
||
]
|
||
return xlsx_response(DEPT_HEADERS, sample, "组织架构_部门导入模板.xlsx")
|
||
|
||
|
||
@departments_custom.post("/import", response_model=ImportResult, summary="导入部门")
|
||
async def import_departments(
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:department:import"))],
|
||
file: UploadFile = File(...),
|
||
):
|
||
"""按「部门编码」优先、否则「部门名称」匹配:存在则更新,不存在则新建。
|
||
|
||
支持先写子部门再写上级:所有行先落库,再统一解析上级并重算树路径。
|
||
"""
|
||
raw_rows = parse_xlsx(await file.read())
|
||
result = ImportResult(total=len(raw_rows), created=0, updated=0, failed=0)
|
||
if not raw_rows:
|
||
raise AppError("导入文件为空或没有数据行", "empty_file")
|
||
|
||
existing = list((await session.execute(select(Department))).scalars().all())
|
||
by_code = {d.code: d for d in existing if d.code}
|
||
by_name = {d.name: d for d in existing}
|
||
emp_rows = (await session.execute(select(Employee.id, Employee.work_no, Employee.name))).all()
|
||
emp_by_no = {row[1]: row[0] for row in emp_rows if row[1]}
|
||
emp_by_name = {row[2]: row[0] for row in emp_rows if row[2]}
|
||
|
||
parsed: list[dict[str, Any]] = []
|
||
seen_codes: set[str] = set()
|
||
# 先扫一遍文件里的编码/名称,允许「子部门写在上级之前」
|
||
known_refs = set(by_code) | set(by_name)
|
||
for raw in raw_rows:
|
||
for key in ("部门编码", "编码", "部门名称", "名称"):
|
||
value = _txt(raw.get(key))
|
||
if value:
|
||
known_refs.add(value)
|
||
for idx, raw in enumerate(raw_rows, start=2):
|
||
try:
|
||
name = _txt(raw.get("部门名称") or raw.get("名称"))
|
||
code = _txt(raw.get("部门编码") or raw.get("编码"))
|
||
if not name:
|
||
raise ValueError("部门名称为空")
|
||
if code:
|
||
if code in seen_codes:
|
||
raise ValueError(f"文件内部门编码重复:{code}")
|
||
seen_codes.add(code)
|
||
parent_ref = _txt(raw.get("上级部门编码") or raw.get("上级部门"))
|
||
if parent_ref and parent_ref not in known_refs:
|
||
raise ValueError(f"上级部门不存在:{parent_ref}")
|
||
leader_ref = _txt(raw.get("部门负责人工号") or raw.get("部门负责人"))
|
||
if leader_ref and leader_ref not in emp_by_no and leader_ref not in emp_by_name:
|
||
raise ValueError(f"部门负责人不存在:{leader_ref}")
|
||
parsed.append({
|
||
"row": idx, "name": name, "code": code, "parent_ref": parent_ref,
|
||
"leader_ref": leader_ref,
|
||
"cost_center": _txt(raw.get("成本中心")) or None,
|
||
"sort": _int(raw.get("排序"), 0),
|
||
"is_active": _flag(raw.get("是否启用"), True),
|
||
"remark": _txt(raw.get("备注")) or None,
|
||
})
|
||
known_refs.add(name)
|
||
if code:
|
||
known_refs.add(code)
|
||
except Exception as exc: # noqa: BLE001 - 逐行汇总失败原因
|
||
_fail(result, idx, raw.get("部门名称"), exc)
|
||
|
||
for item in parsed:
|
||
dept = by_code.get(item["code"]) if item["code"] else by_name.get(item["name"])
|
||
if dept is None:
|
||
dept = Department(name=item["name"], code=item["code"] or None, parent_id=0)
|
||
session.add(dept)
|
||
result.created += 1
|
||
else:
|
||
result.updated += 1
|
||
dept.name = item["name"]
|
||
if item["code"]:
|
||
dept.code = item["code"]
|
||
dept.cost_center = item["cost_center"]
|
||
dept.sort = item["sort"]
|
||
dept.is_active = item["is_active"]
|
||
dept.remark = item["remark"]
|
||
item["dept"] = dept
|
||
by_name[dept.name] = dept
|
||
if dept.code:
|
||
by_code[dept.code] = dept
|
||
|
||
await session.flush()
|
||
|
||
for item in parsed:
|
||
dept: Department = item["dept"]
|
||
dept.parent_id = 0
|
||
if item["parent_ref"]:
|
||
parent = by_code.get(item["parent_ref"]) or by_name.get(item["parent_ref"])
|
||
if parent and parent.id != dept.id:
|
||
dept.parent_id = parent.id
|
||
dept.leader_employee_id = (
|
||
emp_by_no.get(item["leader_ref"]) or emp_by_name.get(item["leader_ref"])
|
||
if item["leader_ref"] else None
|
||
)
|
||
await session.flush()
|
||
try:
|
||
await _rebuild_department_paths(session)
|
||
except AppError:
|
||
await session.rollback()
|
||
raise
|
||
await session.commit()
|
||
return result
|
||
|
||
|
||
router.include_router(build_router(
|
||
CrudSpec(
|
||
model=Department, create=DepartmentCreate, update=DepartmentUpdate, read=DepartmentRead,
|
||
module="org", resource="department", label="部门", prefix="/departments", tag="组织架构",
|
||
search_fields=("name", "code", "cost_center"), filters=("parent_id", "is_active"),
|
||
order_by="level", order="asc", before_write=_dept_before, after_write=_dept_after,
|
||
on_delete=_dept_delete,
|
||
),
|
||
preface=[departments_custom],
|
||
))
|
||
|
||
positions_custom = APIRouter()
|
||
|
||
POSITION_HEADERS = ["职位编码", "职位名称", "职务序列", "排序", "是否启用", "备注"]
|
||
|
||
|
||
@positions_custom.get("/export", summary="导出职位")
|
||
async def export_positions(
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:position:export"))],
|
||
):
|
||
rows = list((await session.execute(
|
||
select(Position).order_by(Position.sort, Position.id)
|
||
)).scalars().all())
|
||
data = [[p.code, p.name, p.category, p.sort, "是" if p.is_active else "否", p.remark]
|
||
for p in rows]
|
||
return xlsx_response(POSITION_HEADERS, data, f"组织架构_职位_{date.today()}.xlsx")
|
||
|
||
|
||
@positions_custom.get("/import-template", summary="职位导入模板")
|
||
async def position_import_template(
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:position:import"))],
|
||
):
|
||
sample = [["P001", "后端工程师", "技术序列", 10, "是", "示例行,可删除"]]
|
||
return xlsx_response(POSITION_HEADERS, sample, "组织架构_职位导入模板.xlsx")
|
||
|
||
|
||
@positions_custom.post("/import", response_model=ImportResult, summary="导入职位")
|
||
async def import_positions(
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:position:import"))],
|
||
file: UploadFile = File(...),
|
||
):
|
||
raw_rows = parse_xlsx(await file.read())
|
||
result = ImportResult(total=len(raw_rows), created=0, updated=0, failed=0)
|
||
if not raw_rows:
|
||
raise AppError("导入文件为空或没有数据行", "empty_file")
|
||
existing = list((await session.execute(select(Position))).scalars().all())
|
||
by_code = {p.code: p for p in existing if p.code}
|
||
by_name = {p.name: p for p in existing}
|
||
seen_codes: set[str] = set()
|
||
for idx, raw in enumerate(raw_rows, start=2):
|
||
try:
|
||
name = _txt(raw.get("职位名称") or raw.get("名称"))
|
||
code = _txt(raw.get("职位编码") or raw.get("编码"))
|
||
if not name:
|
||
raise ValueError("职位名称为空")
|
||
if code and code in seen_codes:
|
||
raise ValueError(f"文件内职位编码重复:{code}")
|
||
if code:
|
||
seen_codes.add(code)
|
||
row = by_code.get(code) if code else by_name.get(name)
|
||
if row is None:
|
||
row = Position(name=name, code=code or None)
|
||
session.add(row)
|
||
result.created += 1
|
||
else:
|
||
result.updated += 1
|
||
row.name = name
|
||
if code:
|
||
row.code = code
|
||
row.category = _txt(raw.get("职务序列")) or None
|
||
row.sort = _int(raw.get("排序"), 0)
|
||
row.is_active = _flag(raw.get("是否启用"), True)
|
||
row.remark = _txt(raw.get("备注")) or None
|
||
by_name[row.name] = row
|
||
if row.code:
|
||
by_code[row.code] = row
|
||
except Exception as exc: # noqa: BLE001
|
||
_fail(result, idx, raw.get("职位名称"), exc)
|
||
await session.commit()
|
||
return result
|
||
|
||
|
||
router.include_router(build_router(CrudSpec(
|
||
model=Position, create=PositionCreate, update=PositionUpdate, read=PositionRead,
|
||
module="org", resource="position", label="职位", prefix="/positions", tag="组织架构",
|
||
search_fields=("name", "code"), filters=("is_active", "category"),
|
||
order_by="sort", order="asc",
|
||
), preface=[positions_custom]))
|
||
|
||
|
||
job_levels_custom = APIRouter()
|
||
|
||
JOBLEVEL_HEADERS = ["职级编码", "职级名称", "职等", "排序", "是否启用", "备注"]
|
||
|
||
|
||
@job_levels_custom.get("/export", summary="导出职级")
|
||
async def export_job_levels(
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:joblevel:export"))],
|
||
):
|
||
rows = list((await session.execute(
|
||
select(JobLevel).order_by(JobLevel.grade, JobLevel.sort, JobLevel.id)
|
||
)).scalars().all())
|
||
data = [[j.code, j.name, j.grade, j.sort, "是" if j.is_active else "否", j.remark]
|
||
for j in rows]
|
||
return xlsx_response(JOBLEVEL_HEADERS, data, f"组织架构_职级_{date.today()}.xlsx")
|
||
|
||
|
||
@job_levels_custom.get("/import-template", summary="职级导入模板")
|
||
async def job_level_import_template(
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:joblevel:import"))],
|
||
):
|
||
sample = [["L001", "P5", 5, 10, "是", "示例行,可删除"]]
|
||
return xlsx_response(JOBLEVEL_HEADERS, sample, "组织架构_职级导入模板.xlsx")
|
||
|
||
|
||
@job_levels_custom.post("/import", response_model=ImportResult, summary="导入职级")
|
||
async def import_job_levels(
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:joblevel:import"))],
|
||
file: UploadFile = File(...),
|
||
):
|
||
raw_rows = parse_xlsx(await file.read())
|
||
result = ImportResult(total=len(raw_rows), created=0, updated=0, failed=0)
|
||
if not raw_rows:
|
||
raise AppError("导入文件为空或没有数据行", "empty_file")
|
||
existing = list((await session.execute(select(JobLevel))).scalars().all())
|
||
by_code = {j.code: j for j in existing if j.code}
|
||
by_name = {j.name: j for j in existing}
|
||
seen_codes: set[str] = set()
|
||
for idx, raw in enumerate(raw_rows, start=2):
|
||
try:
|
||
name = _txt(raw.get("职级名称") or raw.get("名称"))
|
||
code = _txt(raw.get("职级编码") or raw.get("编码"))
|
||
if not name:
|
||
raise ValueError("职级名称为空")
|
||
if code and code in seen_codes:
|
||
raise ValueError(f"文件内职级编码重复:{code}")
|
||
if code:
|
||
seen_codes.add(code)
|
||
row = by_code.get(code) if code else by_name.get(name)
|
||
if row is None:
|
||
row = JobLevel(name=name, code=code or None)
|
||
session.add(row)
|
||
result.created += 1
|
||
else:
|
||
result.updated += 1
|
||
row.name = name
|
||
if code:
|
||
row.code = code
|
||
row.grade = _int(raw.get("职等"), 1)
|
||
row.sort = _int(raw.get("排序"), 0)
|
||
row.is_active = _flag(raw.get("是否启用"), True)
|
||
row.remark = _txt(raw.get("备注")) or None
|
||
by_name[row.name] = row
|
||
if row.code:
|
||
by_code[row.code] = row
|
||
except Exception as exc: # noqa: BLE001
|
||
_fail(result, idx, raw.get("职级名称"), exc)
|
||
await session.commit()
|
||
return result
|
||
|
||
|
||
@job_levels_custom.get(
|
||
"/{item_id:int}/expense-standards",
|
||
response_model=list[ExpenseStandardItem],
|
||
summary="读取职级报销标准",
|
||
)
|
||
async def get_expense_standards(
|
||
item_id: int,
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:joblevel:read"))],
|
||
):
|
||
level = await session.get(JobLevel, item_id)
|
||
if not level:
|
||
raise AppError("职级不存在", "not_found", 404)
|
||
return [ExpenseStandardItem.model_validate(item) for item in (level.expense_standards or [])]
|
||
|
||
|
||
@job_levels_custom.put(
|
||
"/{item_id:int}/expense-standards",
|
||
summary="保存职级报销标准",
|
||
)
|
||
async def save_expense_standards(
|
||
item_id: int,
|
||
payload: ExpenseStandardsPayload,
|
||
session: Session,
|
||
auth: Annotated[AuthContext, Depends(require_perm("org:joblevel:update"))],
|
||
):
|
||
level = await session.get(JobLevel, item_id)
|
||
if not level:
|
||
raise AppError("职级不存在", "not_found", 404)
|
||
level.expense_standards = [item.model_dump() for item in payload.items]
|
||
await session.commit()
|
||
await session.refresh(level)
|
||
return {
|
||
"message": f"已保存 {len(payload.items)} 个报销项目",
|
||
"items": level.expense_standards or [],
|
||
"count": level.expense_standard_count,
|
||
}
|
||
|
||
|
||
router.include_router(build_router(
|
||
CrudSpec(
|
||
model=JobLevel, create=JobLevelCreate, update=JobLevelUpdate, read=JobLevelRead,
|
||
module="org", resource="joblevel", label="职级", prefix="/job-levels", tag="组织架构",
|
||
search_fields=("name", "code"), filters=("is_active",), order_by="grade", order="asc",
|
||
),
|
||
preface=[job_levels_custom],
|
||
))
|
||
|
||
|
||
dict_router = APIRouter()
|
||
|
||
|
||
@dict_router.get("/dicts/{code}/items", response_model=list[DictItemRead], summary="按类型读取字典项")
|
||
async def dict_items(code: str, session: Session, auth: AuthCtx):
|
||
rows = (
|
||
await session.execute(
|
||
select(DictItem).where(DictItem.type_code == code, DictItem.is_active.is_(True))
|
||
.order_by(DictItem.sort, DictItem.id)
|
||
)
|
||
).scalars().all()
|
||
return [DictItemRead.model_validate(r) for r in rows]
|
||
|
||
|
||
dict_router.include_router(build_router(CrudSpec(
|
||
model=DictType, create=DictTypeCreate, update=DictTypeUpdate, read=DictTypeRead,
|
||
module="system", resource="dict", label="字典类型", prefix="/dict-types", tag="系统管理",
|
||
search_fields=("code", "name"), filters=("builtin",), order_by="id", order="asc",
|
||
)))
|
||
dict_router.include_router(build_router(CrudSpec(
|
||
model=DictItem, create=DictItemCreate, update=DictItemUpdate, read=DictItemRead,
|
||
module="system", resource="dict", label="字典项", prefix="/dict-items", tag="系统管理",
|
||
search_fields=("label", "value"), filters=("type_code", "is_active"),
|
||
order_by="sort", order="asc",
|
||
)))
|