608 lines
29 KiB
Python
608 lines
29 KiB
Python
#!/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()
|