unis-oa/backend/scripts/expense/common.py

389 lines
17 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

#!/usr/bin/env python3
"""费用报销演示脚本共用的一批东西:接口客户端、演员表、留档器。
演员全部取自律动同步进本系统的真实人员(紫光汇智组织树),不新建账号、不新建部门,
只补「直属上级 / 部门负责人 / 角色 / 分组」这几项维护数据。
演示账号走的是「应急账号(永远走本地口令)」这条通道:统一身份平台把
``hub_login_mode`` 设成了「只认统一身份」,Hub 同步账号在界面上本来就设不了本地密码,
所以必须先进应急名单,才能设一个演示用的本地密码。这份名单存在数据库里
(``oa_system_setting`` 的 ``config:hub`` → ``hub_local_accounts``),配置文件不写它;
``python3 -m expense.cli config`` 就是往库里加,演示结束用同一条接口把名单改回
``localadmin`` 即可,同样不用重启后端。
"""
from __future__ import annotations
import json
import os
import urllib.error
import urllib.parse
import urllib.request
import uuid
from datetime import date, datetime
from pathlib import Path
BASE = os.environ.get("EXPENSE_BASE", "http://127.0.0.1:8000/api/v1")
REPO_ROOT = Path(__file__).resolve().parents[3]
ROOT = os.environ.get("EXPENSE_EVIDENCE_DIR", str(REPO_ROOT / "docs" / "expense-demo"))
DEMO_PASSWORD = os.environ.get("EXPENSE_PASSWORD", "OaDemo@2026")
ADMIN_ACCOUNT = os.environ.get("OA_ADMIN_ACCOUNT", "localadmin")
ADMIN_PASSWORD = os.environ.get("OA_ADMIN_PASSWORD", "admin123")
MAIN_PROCESS = "费用报销审批流程"
CHILD_PROCESS = "费用合规核验子流程"
MAIN_FORM = "费用报销单"
LINE_FORM = "报销费用明细"
CHILD_FORM = "合规核验单"
DICT_TYPES = {
"category": "oa_expense_category",
"invoice": "oa_expense_invoice",
"urgency": "oa_expense_urgency",
"stage": "oa_expense_stage",
"budget": "oa_expense_budget",
}
# --------------------------------------------------------------------------
# 演员表:全部是组织树里真实存在的人(users.id 直接来自 unis_oa)
# --------------------------------------------------------------------------
CAST: list[dict] = [
# 业务发起人这条线
{"id": 227, "name": "郝安琪", "unit": "软件开发部", "title": "后端开发工程师"},
{"id": 228, "name": "姚安琪", "unit": "定制", "title": "定制交付工程师"},
{"id": 217, "name": "秦詩涵", "unit": "云智销售部", "title": "售前顾问"},
# 部门负责人与行政上级
{"id": 189, "name": "陆致远", "unit": "软件开发部", "title": "研发组长"},
{"id": 173, "name": "何子韬", "unit": "软件开发部", "title": "前端开发工程师"},
{"id": 223, "name": "袁云熙", "unit": "软件开发部", "title": "软件开发部负责人"},
{"id": 180, "name": "丁睿", "unit": "定制", "title": "定制部负责人"},
{"id": 202, "name": "林嘉伦", "unit": "云智销售部", "title": "云智销售部负责人"},
# 财务与归口
{"id": 197, "name": "何震南", "unit": "经营管理中心", "title": "经营管理中心主任"},
{"id": 184, "name": "范云熙", "unit": "经营管理中心", "title": "财务经理"},
{"id": 236, "name": "卢璐", "unit": "经营管理中心", "title": "出纳"},
{"id": 238, "name": "夏子异", "unit": "经营管理中心", "title": "费用审核"},
{"id": 239, "name": "谢詩涵", "unit": "经营管理中心", "title": "费用审核"},
# 合规与稽核
{"id": 174, "name": "苏晓明", "unit": "经营管理中心", "title": "法务"},
{"id": 222, "name": "戴震南", "unit": "经营管理中心", "title": "审计"},
# 公司与行政
{"id": 143, "name": "陶睿", "unit": "紫光汇智", "title": "总经理"},
{"id": 159, "name": "曹杰宏", "unit": "紫光汇智", "title": "总经理办公室主任"},
{"id": 175, "name": "姚璐", "unit": "紫光汇智", "title": "行政专员"},
]
# 直属上级(行政上级):``users.leader_id``,「发起人上级审批」按这条链解析
LEADERS: dict[int, int] = {
227: 189, # 郝安琪 -> 陆致远(研发组长)
228: 180, # 姚安琪 -> 丁睿(定制部负责人)
217: 202, # 秦詩涵 -> 林嘉伦(云智销售部负责人)
189: 223, # 陆致远 -> 袁云熙(软件开发部负责人)
223: 143, # 袁云熙 -> 陶睿(总经理)
202: 143, # 林嘉伦 -> 陶睿
184: 197, # 范云熙 -> 何震南(经营管理中心主任)
236: 184, # 卢璐 -> 范云熙(财务经理)
238: 197, # 夏子异 -> 何震南
239: 197, # 谢詩涵 -> 何震南
174: 197, # 苏晓明 -> 何震南
222: 143, # 戴震南 -> 陶睿(审计直报总经理)
197: 143, # 何震南 -> 陶睿
175: 159, # 姚璐 -> 曹杰宏(总经理办公室主任)
159: 143, # 曹杰宏 -> 陶睿
}
# 部门负责人:``oa_unit.manager_person_id``;紫光汇智(根部门)原本没有负责人,
# 这里补上总经理,「发起人上级部门负责人」和「指定部门负责人」才解析得出人。
UNIT_MANAGERS: dict[int, int] = {43: 143}
# 审批岗位角色(``oa_role``):kind 用 post 的是「岗位」,用 role 的是「角色」
POSITIONS: list[dict] = [
{"name": "费用审核岗", "kind": "post", "description": "费用合规性与票据初审岗",
"members": [238, 239]},
{"name": "出纳付款岗", "kind": "post", "description": "资金支付与回单登记岗",
"members": [236]},
{"name": "法务合规岗", "kind": "post", "description": "合同与票据法务核验岗",
"members": [174]},
{"name": "审计稽核岗", "kind": "post", "description": "费用事后抽查与专项审计岗",
"members": [222]},
{"name": "档案归档岗", "kind": "post", "description": "单据归档与台账登记岗",
"members": [175]},
{"name": "财务", "kind": "role", "description": "财务审批线(含财务经理与中心主任)",
"members": [184, 197]},
{"name": "总经理办公会", "kind": "role", "description": "公司总经理与办公室主任",
"members": [143, 159]},
]
# 分组(``oa_group``):按比例会签用的稽核小组
GROUPS: list[dict] = [
{"name": "费用稽核小组", "description": "大额与差旅报销的并联稽核",
"members": [238, 239, 222, 174]},
]
DICT_ITEMS: dict[str, list[tuple[str, str, int]]] = {
DICT_TYPES["category"]: [
("travel", "差旅费", 10), ("entertain", "业务招待费", 20),
("office", "办公用品费", 30), ("train", "培训发展费", 40),
("telecom", "通讯费", 50), ("other", "其他费用", 60),
],
DICT_TYPES["invoice"]: [
("special", "增值税专用发票", 10), ("general", "增值税普通发票", 20),
("electronic", "电子发票", 30), ("receipt", "行程单/车票", 40),
("none", "无票(需说明原因)", 50),
],
DICT_TYPES["urgency"]: [
("normal", "常规", 10), ("urgent", "加急", 20), ("flash", "当日必付", 30),
],
DICT_TYPES["stage"]: [
("apply", "申请", 10), ("review", "审核", 20), ("pay", "付款", 30),
("archive", "归档", 40),
],
# 预算科目是层级字典:parent 用「报销类型」的取值,表单里靠 cascadeFrom 联动
DICT_TYPES["budget"]: [
("travel", "差旅类", "", 10), ("travel_traffic", "交通费", "travel", 11),
("travel_hotel", "住宿费", "travel", 12), ("travel_meal", "出差餐补", "travel", 13),
("entertain", "招待类", "", 20), ("entertain_meal", "餐饮招待", "entertain", 21),
("office", "办公类", "", 30), ("office_supply", "办公用品", "office", 31),
("train", "培训类", "", 40), ("train_course", "课程费", "train", 41),
("telecom", "通讯类", "", 50), ("telecom_phone", "通讯费", "telecom", 51),
("other", "其他", "", 60), ("other_misc", "杂项支出", "other", 61),
],
}
def cast_ids() -> list[int]:
return [row["id"] for row in CAST if isinstance(row["id"], int)]
# --------------------------------------------------------------------------
# 接口客户端
# --------------------------------------------------------------------------
_SESSIONS: dict[str, dict] = {}
def api(method: str, path: str, token: str = "", body: dict | None = None,
params: dict | None = None) -> tuple[int, dict]:
url = f"{BASE}{path}"
if params:
query = {k: v for k, v in params.items() if v not in (None, "")}
if query:
url = f"{url}?{urllib.parse.urlencode(query)}"
payload = json.dumps(body).encode("utf-8") if body is not None else None
request = urllib.request.Request(url, data=payload, method=method)
request.add_header("Content-Type", "application/json")
if token:
request.add_header("Authorization", f"Bearer {token}")
opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
try:
with opener.open(request, timeout=120) as response:
return response.status, json.loads(response.read().decode("utf-8") or "{}")
except urllib.error.HTTPError as exc:
raw = exc.read().decode("utf-8", "ignore")
try:
return exc.code, json.loads(raw or "{}")
except json.JSONDecodeError:
return exc.code, {"code": exc.code, "message": raw[:300]}
def ok(method: str, path: str, token: str, body: dict | None = None,
params: dict | None = None):
status, payload = api(method, path, token, body, params)
if status != 200 or payload.get("code") != 0:
raise AssertionError(f"{method} {path} 失败:{json.dumps(payload, ensure_ascii=False)[:400]}")
return payload["data"]
def login(account: str, password: str = DEMO_PASSWORD) -> dict:
key = account.lower()
if key in _SESSIONS:
return _SESSIONS[key]
status, payload = api("POST", "/auth/login", body={"account": account, "password": password})
if status != 200 or payload.get("code") != 0:
raise SystemExit(f"登录失败 {account}:{json.dumps(payload, ensure_ascii=False)[:200]}")
data = payload["data"]
data["account"] = account
_SESSIONS[key] = data
return data
def admin() -> str:
return login(ADMIN_ACCOUNT, ADMIN_PASSWORD)["access_token"]
def upload(token: str, filename: str, payload: bytes, kind: str = "attachment") -> dict:
boundary = uuid.uuid4().hex
body = (
f"--{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"{filename}\"\r\n"
"Content-Type: application/octet-stream\r\n\r\n"
).encode("utf-8") + payload + (
f"\r\n--{boundary}\r\nContent-Disposition: form-data; name=\"type\"\r\n\r\n{kind}"
f"\r\n--{boundary}--\r\n"
).encode("utf-8")
request = urllib.request.Request(f"{BASE}/attachment", data=body, method="POST")
request.add_header("Content-Type", f"multipart/form-data; boundary={boundary}")
request.add_header("Authorization", f"Bearer {token}")
opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
with opener.open(request, timeout=120) as response:
return json.loads(response.read().decode("utf-8") or "{}")["data"]
# --------------------------------------------------------------------------
# 组织数据读取:按 id 拿人,顺带把身份 DN 备好
# --------------------------------------------------------------------------
def person_row(admin_token: str, person_id: int) -> dict:
rows = ok("GET", "/org/persons", admin_token, params={"page_size": 200, "keyword": ""})["items"]
for row in rows:
if int(row["id"]) == int(person_id):
return row
raise SystemExit(f"组织里找不到 users.id={person_id},演员表需要更新")
def directory(admin_token: str) -> dict:
"""id / account / 姓名的三向索引,脚本里都用它取人。
``ref`` 是**该写进配置和表单那一格的值**:登录账号(口径见
``app/service/personref.py``)。以前这里给的是身份 DN,部门一改名,脚本铺好的
审批配置和演示单子就一起瞎掉。
"""
rows = ok("GET", "/org/persons", admin_token, params={"page_size": 200})["items"]
by_id = {int(row["id"]): row for row in rows}
return {
"rows": rows,
"by_id": by_id,
"by_account": {row["account"]: row for row in rows},
"ref": {int(row["id"]): row["account"] for row in rows if row.get("account")},
"name": {int(row["id"]): row["display_name"] for row in rows},
}
def person_ref(cat: dict, person_id: int) -> str:
"""users.id -> 人员引用(登录账号);清单里没这个人就直说,不猜。"""
value = cat["ref"].get(int(person_id), "")
if not value:
raise SystemExit(f"users.id={person_id} 不在人员清单里,拿不到登录账号")
return value
def person_name(cat: dict, person_id: int) -> str:
return cat["name"].get(int(person_id), f"#{person_id}")
#: 老名字,与 :func:`person_ref` 同一个口径,留着不让调用方各写一半。
person_account = person_ref
# --------------------------------------------------------------------------
# 审批人 / 抄送 配置行
# --------------------------------------------------------------------------
def row(kind: str, *data, contains_sub: bool | None = None) -> dict:
item = {"type": kind, "data": [str(v) for v in data]}
if contains_sub is not None:
item["containsSub"] = contains_sub
return item
def cc_rule(when: str, targets: list[dict] | None = None, action: bool = False,
script: str = "", opinion: str = "") -> dict:
return {"when": when, "taskValues": targets or [], "taskScript": script,
"requiresAction": action, "opinion": opinion}
# --------------------------------------------------------------------------
# 运行期小工具
# --------------------------------------------------------------------------
def todos(session: dict, job: str = "", activity: str = "") -> list[dict]:
items = ok("GET", "/task/processing", session["access_token"], params={"page_size": 200})["items"]
return [t for t in items if (not job or t["job"] == job) and (not activity or t["activity_name"] == activity)]
def todo(session: dict, activity: str, job: str = "") -> dict:
for item in todos(session, job, activity):
return item
who = session["user"]["display_name"]
raise AssertionError(f"{who} 名下没有环节「{activity}」的待办(job={job})")
def execute(session: dict, task: dict, route: str = "", opinion: str = "",
data: dict | None = None, attachments: list | None = None) -> dict:
body = {"route_name": route, "opinion": opinion, "data": data or {}}
if attachments:
body["attachments"] = attachments
return ok("POST", f"/task/{task['id']}/execute", session["access_token"], body)
def job_detail(token: str, job: str) -> dict:
return ok("GET", f"/job/{job}", token)
def wait_activity(token: str, job: str, seconds: int = 60) -> dict:
"""等自动环节(脚本/接口/延时/子流程)跑完,出现新的人工待办或流程结束就返回。"""
import time
deadline = time.time() + seconds
while time.time() < deadline:
detail = job_detail(token, job)
if detail["status"] != "running" or detail["tasks"]:
return detail
time.sleep(2)
return job_detail(token, job)
def read_list(session: dict, job: str = "", kind: str = "", completed: bool = False) -> list[dict]:
path = "/read/completed" if completed else "/read/processing"
items = ok("GET", path, session["access_token"],
params={"kind": kind, "page_size": 200})["items"]
return [r for r in items if not job or r["job"] == job]
def logs(token: str, job: str) -> list[dict]:
work = job_detail(token, job)["id"]
data = ok("GET", "/worklog", token, params={"work": work, "page_size": 200})
return data["items"] if isinstance(data, dict) else data
def log_types(token: str, job: str) -> list[str]:
return [row_["type"] for row_ in logs(token, job)]
# --------------------------------------------------------------------------
# 留档:每一步都落一份 JSON,最后汇成一张对照表
# --------------------------------------------------------------------------
class Evidence:
def __init__(self, root: str = ROOT) -> None:
self.root = Path(root)
self.root.mkdir(parents=True, exist_ok=True)
self.rows: list[dict] = []
path = self.root / "index.json"
if path.exists():
self.rows = json.loads(path.read_text(encoding="utf-8"))
def stamp(self) -> str:
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
def save(self, stage: str, title: str, payload: object, note: str = "") -> dict:
safe = "".join(ch if ch not in '\\/:*?"<>|' else "-" for ch in f"{stage}-{title}")
name = f"{safe}.json"
body = {"stage": stage, "title": title, "note": note,
"recorded_at": self.stamp(), "base": BASE, "payload": payload}
(self.root / name).write_text(json.dumps(body, ensure_ascii=False, indent=2), encoding="utf-8")
entry = {"stage": stage, "title": title, "note": note,
"recorded_at": body["recorded_at"], "file": name}
self.rows = [r for r in self.rows if r.get("file") != name] + [entry]
(self.root / "index.json").write_text(
json.dumps(self.rows, ensure_ascii=False, indent=2), encoding="utf-8")
print(f" [留档] {stage} / {title} -> {self.root / name}")
return entry
def today(self) -> str:
return date.today().isoformat()