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

608 lines
29 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
"""运行层:用真实员工账号把费用报销流程跑到每一个阶段,数据一律留在库里。
刻意不用管理员账号办业务(管理员只在两处出现:配置设计与触发一次定时器)。
每个场景跑完都会把「单据快照 + 待办 + 流转历史 + 抄送」写进 docs/expense-demo,
库里的单据、待办、已办、抄送、日志、附件全部保留,界面上可以逐条对。
场景覆盖:草稿 / 小额办结 / 差旅逐条确认 / 大额会签+指定复核人 / 特大额逐级上级+分管领导+总经理
/ 退回补正 / 转办加签催办评论抄送撤回已办 / 作废终止 / 超时自动通过 / 超时自动退回 / 空审批人转交管理员
"""
from __future__ import annotations
import os
import time
from datetime import date, timedelta
from . import common, design
from .common import (BASE, CAST, Evidence, MAIN_PROCESS, execute, job_detail, logs, ok,
read_list, todo, todos, upload, wait_activity)
NO_ROUTE_HINTS = ("退回", "退票", "作废", "高风险", "验证转交")
TOKENS: dict[int, dict] = {}
CAT: dict = {}
# --------------------------------------------------------------------------
# 登录与找人
# --------------------------------------------------------------------------
def prepare() -> None:
global ADMIN, CHILD_PID
ADMIN = common.admin()
CAT.update(common.directory(ADMIN))
CHILD_PID = design.ids(ADMIN)["child"]
for row_ in CAST:
account = CAT["by_id"][row_["id"]]["account"]
TOKENS[row_["id"]] = common.login(account)
def who(person_id: int) -> str:
return CAT["name"].get(person_id, str(person_id))
def dn_of(person_id: int) -> str:
return CAT["dn"][person_id]
def sessions() -> dict[int, dict]:
return TOKENS
def find_task(job: str, activity: str = "") -> tuple[int, dict] | None:
"""在演员们的待办箱里找这张单的待办,返回 (人员 id, 待办)。"""
for pid, session in TOKENS.items():
for item in common.todos(session, job, activity):
return pid, item
return None
def pending_map(job: str) -> dict[str, list[str]]:
"""环节名 -> 处理人姓名列表,用来留档「现在卡在谁手上」。"""
out: dict[str, list[str]] = {}
for pid, session in TOKENS.items():
for item in common.todos(session, job):
out.setdefault(item["activity_name"], []).append(who(pid))
return out
def default_route(task: dict) -> str:
names = task.get("route_name_list") or []
if not names:
return ""
for name in names:
if not any(hint in name for hint in NO_ROUTE_HINTS):
return name
return names[0]
# --------------------------------------------------------------------------
# 留档
# --------------------------------------------------------------------------
def snapshot(evidence: Evidence, stage: str, title: str, job: str, note: str = "") -> dict:
admin = common.admin()
detail = job_detail(admin, job)
payload = {
"job": job,
"title": detail.get("title"),
"status": detail.get("status_label") or detail.get("status"),
"current_activities": detail.get("current_activity_names"),
"pending": pending_map(job),
"history": [
{"环节": t.get("activity_name"), "处理人": t.get("identity_name"),
"路由": t.get("route_name"), "意见": (t.get("opinion") or "")[:120],
"完成时间": t.get("complete_time") or t.get("update_time")}
for t in detail.get("task_completed", [])
],
"children": [],
"logs": sorted(set(log_types(admin, job))),
"cc_and_share": {},
"form_data": detail.get("data"),
}
for pid, session in TOKENS.items():
rows = read_list(session, job)
if rows:
payload["cc_and_share"][who(pid)] = [
{"类型": r.get("kind_label") or r.get("kind"), "环节": r.get("activity_name"),
"需要处理": bool(r.get("requires_action"))} for r in rows]
for kid in sorted(CHILD_REGISTRY.get(job, set())):
try:
child = job_detail(ADMIN, kid)
except AssertionError:
continue
payload["children"].append({
"job": kid, "title": child.get("title"),
"status": child.get("status"),
"current": child.get("current_activity_names"),
"history": [{"环节": t.get("activity_name"), "处理人": t.get("identity_name"),
"路由": t.get("route_name")} for t in child.get("task_completed", [])],
})
evidence.save(stage, title, payload, note)
return payload
def log_types(token: str, job: str) -> list[str]:
return [row_["type"] for row_ in logs(token, job)]
# --------------------------------------------------------------------------
# 表单数据
# --------------------------------------------------------------------------
def attachment(session: dict, name: str, text: str, kind: str = "attachment") -> dict:
up = upload(session["access_token"], name, text.encode("utf-8"), kind)
return {k: up.get(k, "") for k in ("id", "name", "extension", "storage", "length")} | {"type": kind}
def line(item: str, amount: float, day: str, category: str = "travel",
invoice: str = "", remark: str = "") -> dict:
return {"item": item, "itemAmount": amount, "itemDate": day, "itemCategory": category,
"itemInvoice": invoice, "itemRemark": remark}
def base_data(session: dict, person_id: int, **over) -> dict:
today = date.today()
days = [ (today - timedelta(days=n)).isoformat() for n in (6, 5, 4) ]
data = {
"title": "客户现场交付差旅费报销",
"category": "travel",
"urgency": "normal",
"amount": 8600.0,
"costDept": CAT["by_id"][person_id].get("organization_name") or "软件开发部",
"payWay": "bank",
"invoiceType": "electronic",
"invoiceCount": 3,
"invoiceNo": "044002101234",
"items": [line("高铁往返", 2460.0, days[0], invoice="G7528"),
line("住宿费三晚", 4200.0, days[1], invoice="HOTEL-8891"),
line("出差餐补", 1940.0, days[2], remark="按 5 天包干")],
"files": [attachment(session, "差旅票据.pdf", "差旅票据扫描件(演示)")],
"photos": [attachment(session, "现场照片.jpg", "fakejpegbytes", "image")],
"tripRange": [days[0], days[2]],
"tripDays": 5,
"destination": "上海市浦东新区",
"tags": ["customer", "project"],
"crossYear": False,
"budgetAccount": ["travel", "travel_traffic"],
"vendorScore": 4,
"contact": "13800138000",
"email": "demo@example.com",
"remark": "客户现场交付期间的差旅费用,明细与票据见附件。",
"promise": "data:image/svg+xml;base64," + "Q09ERVg=",
"withdraw": False,
}
data.update(over)
return data
# --------------------------------------------------------------------------
# 推进引擎
# --------------------------------------------------------------------------
#: 这些环节把「核准金额」设成了必填,默认按申请金额核,需要核减的场景在 overrides 里覆盖
NEEDS_APPROVED = {"财务会签", "财务初审", "财务经理复核", "总经理审批", "出纳付款"}
#: 子流程表单的必填字段,默认给一份合规结论;场景要演示高风险时在 overrides 里覆盖
CHILD_DATA = {
"填写核验任务": {"subject": "费用报销单据合规核验"},
"法务出具意见": {"risk": "low", "opinion": "票据、合同与事由一致,未见合规风险。",
"sign": "data:image/svg+xml;base64,Q09ERVg="},
"外部律师复核": {"risk": "low", "opinion": "外部律师复核无异议,可以支付。"},
"核验归档": {"risk": "low", "opinion": "已归档,留档备查。"},
}
CHILD_PID = ""
ADMIN = ""
#: 父单 -> 它派出去的子单据,留档时把子单据的历史一起附上
CHILD_REGISTRY: dict[str, set] = {}
# 引擎的终态取值:completed 办结 / canceled 作废 / terminated 终止,留档标题按终态如实写
FINAL_STATUS = {"completed": "已办结", "finished": "已办结",
"canceled": "已作废", "terminated": "已终止"}
class Stuck(Exception):
pass
def push(evidence: Evidence, job: str, stage: str, title: str, note: str = "") -> dict:
return snapshot(evidence, stage, title, job, note)
def child_jobs(work_id: str) -> list[str]:
"""这张单在子流程里开出来的子单据(按 parent_work 认,不看标题)。"""
out: list[str] = []
for session in TOKENS.values():
for item in common.todos(session):
if CHILD_PID and item.get("process") == CHILD_PID and item["job"] not in out:
if job_detail(ADMIN, item["job"]).get("parent_work") == work_id:
out.append(item["job"])
return out
def any_child_task(work_id: str) -> bool:
for session in TOKENS.values():
for item in common.todos(session):
if CHILD_PID and item.get("process") == CHILD_PID:
if item.get("work") == work_id or job_detail(ADMIN, item["job"]).get("parent_work") == work_id:
return True
return False
def wake(idle_seconds: float) -> None:
"""后台定时器每 60 秒自己跑一轮;等太久就手动踢一下,等价于到点的那一轮。"""
time.sleep(5)
if idle_seconds > 70:
ok("POST", "/admin/scheduler/run", ADMIN)
def advance(evidence: Evidence, job: str, stage: str, overrides: dict | None = None,
stop_at: set | None = None, limit: int = 80, every: bool = False,
depth: int = 0) -> dict:
"""自动往下办:自动环节等引擎跑,人工环节按 overrides 或默认「同意」办掉。
子流程环节会把单据派到子流程里去,所以父单看不到待办时要接着去 driving 子单据;
延时环节靠后台定时器唤醒。overrides: ``{环节名: (路由名, 意见, 附加表单数据)}``,
``stop_at`` 里的环节只留档不办。
"""
overrides = overrides or {}
stop_at = stop_at or set()
idle = 0.0
for _ in range(limit):
detail = job_detail(ADMIN, job)
if detail["status"] != "running":
return detail
tasks = detail.get("tasks") or []
if not tasks:
# 父单没有待办:要么在子流程里,要么在等延时/定时器
kids = child_jobs(detail["id"])
if kids and depth < 3:
CHILD_REGISTRY.setdefault(job, set()).update(kids)
for kid in kids:
advance(evidence, kid, stage, overrides=overrides, stop_at=stop_at,
limit=limit, every=every, depth=depth + 1)
idle = 0.0
continue
if any_child_task(detail["id"]) and depth < 3:
idle = 0.0
time.sleep(3)
continue
if depth > 0:
return detail
idle += 8
wake(idle)
if idle > 240:
return job_detail(ADMIN, job)
continue
hit = {t["activity_name"] for t in tasks} & stop_at
if hit:
return detail
found = find_task(job)
if found is None:
idle += 8
wake(idle)
continue
idle = 0.0
pid, task = found
activity = task["activity_name"]
route, opinion, data = overrides.get(activity, ("", f"{who(pid)}已同意", {}))
data = {**CHILD_DATA.get(activity, {}), **(data or {})}
if activity in NEEDS_APPROVED and "approved" not in data:
data["approved"] = float(detail["data"].get("approved")
or detail["data"].get("amount") or 0)
execute(TOKENS[pid], task, route or default_route(task), opinion, data)
if every:
push(evidence, job, stage, f"{activity}-已办理")
wait_activity(ADMIN, job, seconds=20)
return job_detail(ADMIN, job)
def start(person_id: int, process_id: str, data: dict, title: str) -> str:
session = TOKENS[person_id]
return ok("POST", "/job", session["access_token"],
{"process": process_id, "data": data, "title": title})["job"]
# --------------------------------------------------------------------------
# 场景
# --------------------------------------------------------------------------
def s_draft(evidence: Evidence, pid: str) -> None:
print("\n--- 场景 1:草稿留在草稿箱 ---")
session = TOKENS[227]
data = base_data(session, 227, title="季度团队建设费用报销(草稿)", category="other",
amount=1500.0)
draft = ok("POST", "/draft", session["access_token"],
{"process": pid["main"], "data": data, "title": "季度团队建设费用报销(草稿)"})
mine = ok("GET", "/draft", session["access_token"])
evidence.save("场景1-草稿", "草稿箱里的报销单",
{"draft": draft, "list": mine},
"郝安琪存了草稿没提交,草稿箱能看到;提交后草稿会被自动消费")
def run_to_end(evidence: Evidence, pid: str, tag: str, person_id: int, data_over: dict,
overrides: dict | None = None, every: bool = False) -> str:
session = TOKENS[person_id]
data = base_data(session, person_id, **data_over)
job = start(person_id, pid["main"], data, data["title"])
print(f"\n--- {tag}:{data['title']} 单号 {job} ---")
push(evidence, job, tag, "01-发起提交", "发起后进入第一个待办的环节")
advance(evidence, job, tag, overrides=overrides, every=every)
detail = job_detail(common.admin(), job)
push(evidence, job, tag, FINAL_STATUS.get(detail["status"], "在途停住"),
f"最终状态:{detail.get('status_label') or detail['status']}")
return job
def s_goback(evidence: Evidence, pid: str) -> str:
print("\n--- 场景 6:财务初审退回补正 ---")
session = TOKENS[217]
data = base_data(session, 217, title="客户招待费报销(票据不齐)", category="entertain",
amount=6800.0, invoiceType="general",
budgetAccount=["entertain", "entertain_meal"],
destination="", costDept="云智销售部")
job = start(217, pid["main"], data, data["title"])
push(evidence, job, "场景6-退回补正", "01-送审到财务初审前")
# 办到财务初审被退回
advance(evidence, job, "场景6-退回补正", stop_at={"财务初审"},
overrides={"部门负责人审批": ("通过", "同意,注意这笔是招待费", {})})
task = todo(TOKENS[238], "财务初审", job)
execute(TOKENS[238], task, "退回补正", "发票张数与实际不符,请补全后重新提交",
{"approved": 6800.0})
push(evidence, job, "场景6-退回补正", "02-被财务退回", "退回后回到填写报销单,处理人变回发起人")
task = todo(TOKENS[217], "填写报销单", job)
execute(TOKENS[217], task, "提交审批", "已补全票据,发票张数改为 4 张",
{"invoiceCount": 4, "remark": "已补充餐饮招待发票一张,共 4 张。"})
advance(evidence, job, "场景6-退回补正", stop_at={"审计抽查"},
overrides={"财务初审": ("财务初审通过", "票据齐全,核准 6500 元", {"approved": 6500.0})})
push(evidence, job, "场景6-退回补正", "03-重新提交后在途", "退回重提后停在审计抽查,退回记录留在历史里")
return job
def s_collab(evidence: Evidence, pid: str) -> str:
"""协同操作:处理人一律从真实待办箱里查,不写死是谁,保证跟着组织架构走。"""
print("\n--- 场景 7:转办 / 加签 / 催办 / 评论 / 抄送 / 撤回已办 ---")
session = TOKENS[227]
data = base_data(session, 227, title="客户现场实施差旅报销", category="travel",
amount=12800.0, costDept="软件开发部")
job = start(227, pid["main"], data, data["title"])
advance(evidence, job, "场景7-协同操作", stop_at={"上级审批"})
# 1) 转办:真实的行政上级转给同部门同事,再由同事办掉
boss = find_task(job, "上级审批")
assert boss, "上级审批没有待办,转办无从做起"
boss_id, task = boss
deputy = 189 if boss_id != 189 else 173
ok("POST", f"/task/{task['id']}/transfer", TOKENS[boss_id]["access_token"],
{"identities": [dn_of(deputy)],
"opinion": f"我这周在现场,转给{who(deputy)}代为审批"})
transferred = todo(TOKENS[deputy], "上级审批", job)
execute(TOKENS[deputy], transferred, "上级已批",
f"代为审批(原处理人{who(boss_id)}):情况属实,同意")
# 2) 加签:部门负责人审批前先把审计拉进来
advance(evidence, job, "场景7-协同操作", stop_at={"部门负责人审批"})
dept = find_task(job, "部门负责人审批")
assert dept, "部门负责人审批没有待办"
dept_id, task = dept
ok("POST", f"/task/{task['id']}/addtask", TOKENS[dept_id]["access_token"],
{"identities": [dn_of(222)], "way": "before", "mode": "serial",
"opinion": "这笔金额偏大,先请审计看一下"})
addone = todo(TOKENS[222], "部门负责人审批", job)
execute(TOKENS[222], addone, default_route(addone), "金额在标准内,无异常")
# 串行加签:审计表态后待办回转给部门负责人,由他下结论
# 3) 催办:发起人在部门负责人那儿催一把
task = todo(TOKENS[dept_id], "部门负责人审批", job)
ok("POST", f"/task/{task['id']}/press", TOKENS[227]["access_token"],
{"opinion": "请今天批一下,周五要付款"})
# 4) 评论 + 抄送
work = job_detail(common.admin(), job)["id"]
ok("POST", f"/work/{work}/comments", TOKENS[227]["access_token"],
{"content": "补充:这趟是客户方临时提前的工期,票据已按人按天拆分。", "mentions": [],
"mention_action": False})
ok("POST", f"/task/{task['id']}/cc", TOKENS[dept_id]["access_token"],
{"identities": [dn_of(197)], "opinion": "抄送财务归口知悉", "requires_action": False})
push(evidence, job, "场景7-协同操作", "01-转办加签催办评论抄送",
f"上级{who(boss_id)}转办给{who(deputy)}、负责人{who(dept_id)}加签审计{who(222)}、"
f"上级{who(boss_id)}转办给{who(deputy)}、负责人{who(dept_id)}加签审计{who(222)}、"
f"发起人{who(227)}催办并评论、负责人抄送{who(197)},全部留痕")
# 5) 撤回已办:部门批完发现标准有变,把已办撤回重办
execute(TOKENS[dept_id], task, "部门已批", "同意,报财务")
# 撤回已办只能撤本人 normal 类型的那条:加签/转办产生的记录引擎不让撤
completed = [t for t in job_detail(common.admin(), job).get("task_completed") or []
if t.get("activity_name") == "部门负责人审批"
and t.get("processing_type") == "normal"
and t.get("identity_name") == who(dept_id)]
assert completed, f"没找到 {who(dept_id)} 本人的「部门负责人审批」普通已办记录,撤回无从做起"
ok("POST", f"/taskcompleted/{completed[-1]['id']}/reset", TOKENS[dept_id]["access_token"],
{"opinion": "标准有调整,撤回重看"})
push(evidence, job, "场景7-协同操作", "02-撤回已办之后",
f"{who(dept_id)}把「部门负责人审批」这条已办撤回,待办重新回到他手上")
return job
def s_void(evidence: Evidence, pid: str) -> str:
print("\n--- 场景 8:申请人撤单,归档后作废 ---")
return run_to_end(evidence, pid, "场景8-作废终止", 227,
{"title": "培训费报销(已改由公司统一结算)", "category": "train",
"amount": 3200.0, "withdraw": True, "budgetAccount": ["train", "train_course"],
"items": [line("课程费", 3200.0, date.today().isoformat(), "train")]})
def s_fallback(evidence: Evidence, pid: str) -> None:
print("\n--- 场景 9/10/11:空审批人兜底与超时自动处理 ---")
session = TOKENS[227]
def submit_fallback(job: str) -> None:
"""兜底流程第一环就是「填写验证单」,先提交才会走到验证用的环节。"""
task = todo(TOKENS[227], "填写验证单", job)
execute(TOKENS[227], task, default_route(task), "已填写验证单,提交")
wait_activity(common.admin(), job, seconds=30)
# 9) 自动链路:转交发起人 -> 自动通过 -> 超时自动通过 -> 超时自动退回
job = start(227, pid["fallback"], base_data(session, 227, title="兜底验证-自动链路"),
"兜底验证-自动链路")
submit_fallback(job)
push(evidence, job, "场景9-空审批人兜底", "01-提交后")
# 空审批人转交发起人:待办落在发起人自己手上
task = todo(TOKENS[227], "空审批人转交发起人", job)
execute(TOKENS[227], task, "继续", "兜底转交给我本人,已确认")
push(evidence, job, "场景9-空审批人兜底", "02-转交发起人后", "自动通过环节没有留下待办,说明空审批人自动放行")
detail = wait_activity(common.admin(), job, seconds=30)
evidence.save("场景9-空审批人兜底", "03-超时自动通过",
{"job": job, "note": "「超时自动通过」环节 1 分钟无人处理,由定时器放行"},
"下面触发一次定时器,等价于后台每 60 秒自己跑一轮")
ok("POST", "/admin/scheduler/run", common.admin())
deadline = time.time() + 95
while time.time() < deadline:
detail = job_detail(common.admin(), job)
names = {t["activity_name"] for t in detail.get("tasks") or []}
if "超时自动退回" in names:
break
ok("POST", "/admin/scheduler/run", common.admin())
time.sleep(20)
push(evidence, job, "场景9-空审批人兜底", "04-超时自动退回环节在途",
"超时自动已通过,停在超时自动退回;再等一轮定时器会被自动退回")
deadline = time.time() + 95
while time.time() < deadline:
detail = job_detail(common.admin(), job)
names = {t["activity_name"] for t in detail.get("tasks") or []}
if "填写验证单" in names:
break
ok("POST", "/admin/scheduler/run", common.admin())
time.sleep(20)
push(evidence, job, "场景9-空审批人兜底", "05-超时自动退回之后",
"待办被自动退回给发起人,历史里有一条超时自动处理")
# 10) 空审批人转交管理员:故意留在途
job2 = start(227, pid["fallback"],
base_data(session, 227, title="兜底验证-转交管理员", toAdmin=True),
"兜底验证-转交管理员")
submit_fallback(job2)
push(evidence, job2, "场景10-转交管理员", "01-待办落在管理员名下",
"「外部律师岗」没有人且兜底策略是转交管理员,这张单故意留在途")
def s_main_timeout(evidence: Evidence, pid: str) -> str:
"""场景 11:主流程总经理超时自动通过(拆出来才能单独重跑)。"""
print("\n--- 场景 11:主流程总经理超时自动放行 ---")
session = TOKENS[227]
big = start(227, pid["main"],
base_data(session, 227, title="特大额框架采购差旅报销(总经理超时放行)",
amount=160000.0,
items=[line("长期驻场差旅", 160000.0, date.today().isoformat())]),
"特大额框架采购差旅报销(总经理超时放行)")
print(f" 特大额单 {big} 跑到总经理环节等超时")
advance(evidence, big, "场景11-总经理超时", stop_at={"总经理审批"})
push(evidence, big, "场景11-总经理超时", "01-停在总经理审批", "总经理 2 分钟未处理会自动通过")
deadline = time.time() + 150
passed = False
while time.time() < deadline:
ok("POST", "/admin/scheduler/run", common.admin())
detail = job_detail(common.admin(), big)
names = {t["activity_name"] for t in detail.get("tasks") or []}
if "总经理审批" not in names and detail["status"] == "running":
passed = True
break
time.sleep(20)
advance(evidence, big, "场景11-总经理超时")
push(evidence, big, "场景11-总经理超时",
"02-超时自动通过之后" if passed else "02-超时未触发",
"定时器把总经理环节自动放行,流程继续走到出纳付款")
# --------------------------------------------------------------------------
# 入口
# --------------------------------------------------------------------------
def run(evidence: Evidence | None = None, only: str = "") -> None:
"""跑场景。only(或环境变量 EXPENSE_ONLY)给场景号时只跑这几个,重跑不重复前面的留档。"""
evidence = evidence or Evidence()
numbers = {x.strip() for x in (only or os.environ.get("EXPENSE_ONLY", "")).split(",") if x.strip()}
def pick(*nums: str) -> bool:
return not numbers or bool(numbers & set(nums))
print(f"目标:{BASE}" + (f" 只跑场景:{sorted(numbers)}" if numbers else ""))
prepare()
pid = design.ids(common.admin())
if pick("1"):
s_draft(evidence, pid)
if pick("2"):
run_to_end(
evidence, pid, "场景2-小额快速办结", 227,
{"title": "办公用品费报销(小额)", "category": "office", "amount": 320.0,
"invoiceType": "general", "invoiceCount": 1,
"budgetAccount": ["office", "office_supply"],
"items": [line("打印纸与墨盒", 320.0, date.today().isoformat(), "office")],
"destination": "", "tripRange": [], "tripDays": 0})
if pick("3"):
run_to_end(
evidence, pid, "场景3-差旅逐条确认", 227,
{"title": "客户现场交付差旅费报销(逐条确认)", "amount": 8600.0}, every=True)
if pick("4"):
run_to_end(
evidence, pid, "场景4-大额会签", 189,
{"title": "事业部季度市场活动费用报销", "category": "entertain", "amount": 26000.0,
"reviewer": dn_of(222), "costDept": "软件开发部",
"budgetAccount": ["entertain", "entertain_meal"], "destination": "",
"items": [line("场地与搭建", 18000.0, date.today().isoformat(), "entertain"),
line("餐饮招待", 8000.0, date.today().isoformat(), "entertain")]},
overrides={"财务初审": ("财务初审通过", "标准内,核准 25000 元", {"approved": 25000.0})})
if pick("5"):
run_to_end(
evidence, pid, "场景5-特大额逐级上级", 227,
{"title": "战略客户联合交付差旅报销", "amount": 120000.0,
"items": [line("两个月驻场差旅", 120000.0, date.today().isoformat())]},
overrides={"财务初审": ("财务初审通过", "已核对合同与预算,核准 118000 元",
{"approved": 118000.0})})
if pick("6"):
s_goback(evidence, pid)
if pick("7"):
s_collab(evidence, pid)
if pick("8"):
s_void(evidence, pid)
if pick("9", "10"):
s_fallback(evidence, pid)
if pick("11"):
s_main_timeout(evidence, pid)
report(evidence)
def report(evidence: Evidence | None = None) -> None:
"""从库里重新导出一份现状:每个流程有多少单、什么状态、谁手上有多少待办。"""
evidence = evidence or Evidence()
if not TOKENS:
# 单独跑 report 时演员还没登录,待办分布要先有会话才数得出来
prepare()
token = common.admin()
pid = design.ids(token)
print("\n=== 现状快照 ===")
summary = {}
for key, name in (("main", MAIN_PROCESS), ("fallback", design.FALLBACK_PROCESS),
("child", design.CHILD_PROCESS)):
rows = ok("GET", "/work/related", token, params={"process": pid[key], "page_size": 100})["items"]
bucket: dict[str, int] = {}
for row_ in rows:
bucket[row_.get("status_label") or row_.get("status")] = bucket.get(
row_.get("status_label") or row_.get("status"), 0) + 1
summary[name] = {"单据总数": len(rows), "按状态": bucket,
"单号": [r["job"] for r in rows][:60]}
print(f" {name}:{len(rows)} 张 {bucket}")
pending = {}
for pidx, session in TOKENS.items():
count = ok("GET", "/task/processing/count", session["access_token"])
total = count.get("total", count) if isinstance(count, dict) else count
if total:
pending[who(pidx)] = total
summary["待办分布"] = pending
print(f" 待办分布:{pending}")
evidence.save("现状", "单据与待办统计", summary, "跑完后从库里重新导出的统计,界面上可逐条对上")
if __name__ == "__main__":
run()