362 lines
20 KiB
Python
362 lines
20 KiB
Python
#!/usr/bin/env python3
|
||
"""「我的待办」上那颗「删除」:只开给本人创建、还没发起流转的那一张单。
|
||
|
||
PYTHONPATH=. python3 scripts/check_delete_unstarted.py
|
||
|
||
待办里有一类行是**自己发起、又停在自己手上**的单:被审批人退回给发起人重填,以及开始
|
||
环节被第三方接管、停在「等提交」(``hold_at_begin``)的那一档。这类单从没交到别人手上
|
||
办过,O2OA 那一边给它的动作叫「删除」而不是「终止」——终止要把单子办完再归档,别人的
|
||
已办与流转记录都留下;删除是这张单从头到尾不算发生过,连单带号一起从运行表里抹掉。
|
||
这一份钉的就是这条线在哪儿断:
|
||
|
||
1. 退回到发起人重填的那一行确实停在开始环节 → 待办列表回 ``deletable=true``;停在开始
|
||
环节但还没有待办的那一档不进待办列表,可在「我发起的」里按 ``activity_type`` 认出来;
|
||
2. 已经离开开始环节的单 → 那一行不亮删除钮,接口回一句「已经发起流转」,单子原样留着;
|
||
3. 同一张单上还压着**别人**的待办 → 不亮、删不掉,别把同事手上的活删没;
|
||
4. 删除真的办得成:单、待办、流转日志一起没了,「我发起的」里也找不到它;额度上压着的
|
||
占用还回去;嵌页面那本「这一趟已经发起成一张单了」的账收回,第三方拿同一个预受理号
|
||
重发不会被认成重复发起;操作日志记下删掉的是哪一张单。
|
||
|
||
跑完连自己造的表单、流程、单据、额度、嵌入会话与操作日志一起删干净。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import sys
|
||
from datetime import datetime, timedelta
|
||
|
||
from sqlalchemy import delete, select
|
||
from starlette.testclient import TestClient
|
||
|
||
from app import models
|
||
from app.db import SessionLocal
|
||
from app.engine import definition as definition_module
|
||
from app.engine import engine
|
||
from app.main import app
|
||
from app.security import create_access_token
|
||
from app.service import quota as quota_service
|
||
|
||
STAMP = datetime.now().strftime("%m%d%H%M%S")
|
||
PROCESS_NAME = f"删除未发起校验流程 {STAMP}"
|
||
#: 这一趟专用的那笔额度(按单号分维度,跑完按定义码清账)
|
||
QUOTA_CODE = f"delchk{STAMP}"
|
||
#: 待办里那三条行的标题,界面上按标题认(脚本只碰自己造的这几张单)
|
||
TITLE_HELD = f"{PROCESS_NAME}-停在开始环节"
|
||
TITLE_BACK = f"{PROCESS_NAME}-退回来重填"
|
||
TITLE_FLOW = f"{PROCESS_NAME}-在别人手上"
|
||
#: 假那条待办挂的同事账号
|
||
OTHER_REF = f"delchk-other-{STAMP}"
|
||
|
||
FAILS: list[str] = []
|
||
PASSED = 0
|
||
CLEAN: dict = {"works": [], "jobs": [], "tasks": [], "sessions": [], "logs": [],
|
||
"process": "", "form": ""}
|
||
|
||
|
||
def check(label: str, condition, detail: str = "") -> None:
|
||
global PASSED
|
||
if condition:
|
||
PASSED += 1
|
||
print(f"[通过] {label}")
|
||
else:
|
||
FAILS.append(label)
|
||
print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}")
|
||
|
||
|
||
def build_process(db) -> tuple[str, str]:
|
||
"""一张最小可用的流程:开始 → 部门审批(审批人就是发起人)→ 结束。
|
||
|
||
审批人配成发起人自己,是为了让「退回到发起人重填」真的落在同一个人手上——那正是
|
||
待办里会出现「自己创建、还没发起」这一行的那条来路。回 ``(流程 id, 开始环节 id)``。
|
||
"""
|
||
form = models.FormElement(
|
||
name=f"删除未发起校验表单 {STAMP}", alias=f"delchk-{STAMP}",
|
||
content={"fields": [{"key": "reason", "label": "事由", "type": "text"}]},
|
||
)
|
||
db.add(form)
|
||
db.flush()
|
||
CLEAN["form"] = form.id
|
||
process = models.Process(
|
||
name=PROCESS_NAME, alias=PROCESS_NAME, latest_form=form.id, latest_form_name=form.name,
|
||
enabled=True, published=True, version=1, approval_config={"skipStarter": False},
|
||
)
|
||
db.add(process)
|
||
db.flush()
|
||
CLEAN["process"] = process.id
|
||
begin = models.Activity(process=process.id, type="begin", name="开始", x=0, y=0,
|
||
order_number=0, config={})
|
||
first = models.Activity(process=process.id, type="manual", name="部门审批", x=1, y=0,
|
||
order_number=1,
|
||
config={"mode": "any", "taskValues": [{"type": "creator", "data": []}],
|
||
"formPerms": {"reason": "editable"}})
|
||
end = models.Activity(process=process.id, type="end", name="结束", x=2, y=0,
|
||
order_number=2, config={})
|
||
db.add_all([begin, first, end])
|
||
db.flush()
|
||
db.add_all([
|
||
models.Route(process=process.id, name="提交", from_activity=begin.id,
|
||
to_activity=first.id, order_number=0),
|
||
models.Route(process=process.id, name="同意", from_activity=first.id,
|
||
to_activity=end.id, order_number=0),
|
||
])
|
||
db.flush()
|
||
return process.id, begin.id
|
||
|
||
|
||
def stamp_of(result: engine.StepResult, label: str) -> dict:
|
||
"""趁实例还在这条会话里,把这张单的几样标识抄成普通字符串。
|
||
|
||
``StepResult.work_id`` 只在归档与「停在开始环节」那两条路上填,走通流转那一条要靠
|
||
``result.work``;而脚本往后要 commit,commit 之后 ORM 实例过期,再读字段就得回库。
|
||
"""
|
||
work = result.work
|
||
assert work is not None, f"{label}:这一单当场办结归档了,换一个还没配成自动跳过的设计"
|
||
return {"id": work.id, "job": work.job, "serial": str(work.serial or ""),
|
||
"title": work.title, "process": work.process,
|
||
"process_name": work.process_name, "category": work.category,
|
||
"category_name": work.category_name}
|
||
|
||
|
||
def todo_rows(client: TestClient, headers: dict) -> dict:
|
||
"""待办列表里这一趟那几行,按标题取。"""
|
||
data = client.get("/api/v1/task/processing", headers=headers,
|
||
params={"keyword": PROCESS_NAME, "page_size": 100}).json()["data"]
|
||
return {row["title"]: row for row in data["items"]}
|
||
|
||
|
||
def my_works(client: TestClient, headers: dict) -> dict:
|
||
"""「我发起的」里这一趟那几张单,按标题取。"""
|
||
data = client.get("/api/v1/work/created", headers=headers,
|
||
params={"keyword": PROCESS_NAME, "page_size": 100}).json()["data"]
|
||
return {row["title"]: row for row in data["items"]}
|
||
|
||
|
||
def main() -> int:
|
||
db = SessionLocal()
|
||
client = TestClient(app, raise_server_exceptions=False)
|
||
person = db.execute(select(models.User).where(models.User.role == models.ROLE_ADMIN)
|
||
.limit(1)).scalars().first()
|
||
if person is None:
|
||
print("跳过:库里没有人员可当发起人")
|
||
return 0
|
||
actor = engine.Actor.from_ref(db, person)
|
||
token, _ = create_access_token(str(person.id))
|
||
headers = {"Authorization": f"Bearer {token}"}
|
||
# 接口那一路走的是另一条 Session,本脚本这条事务里没提交的东西它们看不见;
|
||
# 每个要问库的结论之前都先 commit 一次,再按 id 现查(不攥着可能已失效的 ORM 实例)。
|
||
try:
|
||
process_id, begin_id = build_process(db)
|
||
|
||
# 1a 停在开始环节、还没提交出去的那一张(第三方接管开始环节提交时的建单姿势)
|
||
held = engine.create_job(db, process_id=process_id, actor=actor,
|
||
data={"reason": "停在开始环节"}, title=TITLE_HELD,
|
||
hold_at_begin=True)
|
||
# 1b 发出去之后又被审批人退回给发起人重填的那一张
|
||
back = engine.create_job(db, process_id=process_id, actor=actor,
|
||
data={"reason": "退回来重填"}, title=TITLE_BACK)
|
||
# 2 已经走到别人手上的那一张
|
||
flowed = engine.create_job(db, process_id=process_id, actor=actor,
|
||
data={"reason": "在别人手上"}, title=TITLE_FLOW)
|
||
held, back, flowed = (stamp_of(held, TITLE_HELD), stamp_of(back, TITLE_BACK),
|
||
stamp_of(flowed, TITLE_FLOW))
|
||
for item in (held, back, flowed):
|
||
CLEAN["works"].append(item["id"])
|
||
CLEAN["jobs"].append(item["job"])
|
||
back_task = db.execute(select(models.Task).where(
|
||
models.Task.work == back["id"]).limit(1)).scalars().first()
|
||
assert back_task is not None, "退回来之前,这一单上没有属于发起人的待办"
|
||
# 退回会把这一条待办结掉、换成开始环节上归发起人的那一条,所以这一行的字段要在
|
||
# 退回之前抄成字符串(commit 之后再读那个实例就是查一条已经不存在的行)
|
||
approval_activity = back_task.activity
|
||
engine.go_back(db, task_id=back_task.id, actor=actor, target=begin_id,
|
||
opinion="退回发起人重填")
|
||
db.commit()
|
||
|
||
rows = todo_rows(client, headers)
|
||
check("1 退回到发起人的那一行确实停在开始环节",
|
||
rows.get(TITLE_BACK, {}).get("activity_type") == "begin", rows.get(TITLE_BACK))
|
||
check("1 这一行的删除钮是亮的(本人创建 + 还没发起 + 没压在别人手上)",
|
||
rows.get(TITLE_BACK, {}).get("deletable") is True, rows.get(TITLE_BACK))
|
||
check("1 停在开始环节、还没有待办的那张单不进待办列表",
|
||
TITLE_HELD not in rows, sorted(rows))
|
||
works = my_works(client, headers)
|
||
check("1 「我发起的」里这两张没发起的单都标着 activity_type=begin",
|
||
works.get(TITLE_HELD, {}).get("activity_type") == "begin"
|
||
and works.get(TITLE_BACK, {}).get("activity_type") == "begin",
|
||
{key: value.get("activity_type") for key, value in works.items()})
|
||
|
||
# ---------------- 2. 已经发起流转的单删不掉 ----------------
|
||
check("2 别人手上那一行不亮删除钮",
|
||
rows.get(TITLE_FLOW, {}).get("deletable") is not True, rows.get(TITLE_FLOW))
|
||
refused = client.post(f"/api/v1/job/{flowed['job']}/delete", headers=headers, json={})
|
||
check("2 已经发起流转的单删不掉,也说清了为什么",
|
||
refused.status_code == 400 and "已经发起流转" in refused.json().get("message", ""),
|
||
refused.json())
|
||
db.commit()
|
||
check("2 被挡下之后这张单原样还在",
|
||
db.get(models.Work, flowed["id"]) is not None)
|
||
|
||
# ---------------- 3. 同一张单上还压着别人的待办 ----------------
|
||
other = models.Task(
|
||
job=back["job"], work=back["id"], title=TITLE_BACK, status="pending",
|
||
process=back["process"], process_name=back["process_name"],
|
||
category=back["category"], category_name=back["category_name"],
|
||
serial=back["serial"], activity=approval_activity,
|
||
activity_name="部门审批", activity_type="manual",
|
||
person="900000000000000001", identity=OTHER_REF, identity_name="同事",
|
||
creator_identity=actor.ref, creator_person=actor.person_name,
|
||
act="create", start_time=datetime.now(),
|
||
start_time_month=datetime.now().strftime("%Y%m"),
|
||
)
|
||
db.add(other)
|
||
db.commit()
|
||
CLEAN["tasks"] = [other.id]
|
||
check("3 同事那条待办确实挂在这张单上",
|
||
db.get(models.Task, other.id) is not None, other.id)
|
||
rows = todo_rows(client, headers)
|
||
check("3 同一张单上还压着别人的待办时,自己这一行不亮删除钮",
|
||
rows.get(TITLE_BACK, {}).get("deletable") is not True, rows.get(TITLE_BACK))
|
||
refused = client.post(f"/api/v1/job/{back['job']}/delete", headers=headers, json={})
|
||
check("3 接口也不让删(会把同事手上的活一起删没)",
|
||
refused.status_code == 400 and "别人的待办" in refused.json().get("message", ""),
|
||
refused.json())
|
||
db.execute(delete(models.Task).where(models.Task.id == other.id))
|
||
engine.suspend(db, job=back["job"], actor=actor, opinion="自检挂起")
|
||
db.commit()
|
||
# 管理员挂起是「先停在原地」:这一刻连删除都不该发生
|
||
rows = todo_rows(client, headers)
|
||
check("3b 被挂起的那张单不亮删除钮",
|
||
rows.get(TITLE_BACK, {}).get("deletable") is not True, rows.get(TITLE_BACK))
|
||
refused = client.post(f"/api/v1/job/{back['job']}/delete", headers=headers, json={})
|
||
check("3b 挂起中的单删不掉,话说清楚是挂起挡的",
|
||
refused.status_code == 400 and "挂起" in refused.json().get("message", ""),
|
||
refused.json())
|
||
engine.resume(db, job=back["job"], actor=actor, opinion="自检恢复")
|
||
db.commit()
|
||
|
||
# ---------------- 4. 删除真的办成,三样收尾一起走 ----------------
|
||
# 压一笔在途占用在这张单上:删除之后它必须回到未占用,否则这个人下次发起还被挡着
|
||
dims = {"job": held["job"]}
|
||
quota_row = models.Quota(
|
||
quota_def=QUOTA_CODE, dim_hash=quota_service.dims_hash(dims), dims=dims,
|
||
title=TITLE_HELD, person=actor.person_id, person_name=actor.person_name,
|
||
total_cents=10_000, occupied_cents=1_234,
|
||
)
|
||
db.add(quota_row)
|
||
db.flush()
|
||
CLEAN["quota"] = quota_row.id
|
||
db.add(models.QuotaLedger(
|
||
quota=quota_row.id, quota_def=QUOTA_CODE, kind=models.QuotaLedger.KIND_OCCUPY,
|
||
amount_cents=1_234, balance_after_cents=8_766, work=held["id"], job=held["job"],
|
||
person=actor.person_id, person_name=actor.person_name, reason="自检占用",
|
||
))
|
||
# 第三方那一趟记着「这一趟已经发起成一张单了」:单删了这句话要收回,
|
||
# 否则对方拿同一个预受理号重发,会被认成重复发起而永远发不出去
|
||
session = models.EmbedSession(
|
||
token_hash=f"delchk-token-{STAMP}", prekey=f"delchk-pre-{STAMP}",
|
||
person=actor.person_id, field="reason", work=held["id"], job=held["job"],
|
||
claim_job=held["job"], claim_serial=held["serial"], claim_time=datetime.now(),
|
||
expires_at=datetime.now() + timedelta(hours=1),
|
||
)
|
||
db.add(session)
|
||
db.commit()
|
||
CLEAN["sessions"] = [session.id]
|
||
done = client.post(f"/api/v1/job/{held['job']}/delete", headers=headers, json={})
|
||
check("4 删除这张停在开始环节、没提交出去的单办成了",
|
||
done.status_code == 200 and done.json().get("data", {}).get("job") == held["job"],
|
||
done.json())
|
||
db.commit()
|
||
left = {
|
||
"单据": db.execute(select(models.Work.id).where(
|
||
models.Work.id == held["id"])).scalars().all(),
|
||
"待办": db.execute(select(models.Task.id).where(
|
||
models.Task.work == held["id"])).scalars().all(),
|
||
"流转日志": db.execute(select(models.WorkLog.id).where(
|
||
models.WorkLog.work == held["id"])).scalars().all(),
|
||
}
|
||
check("4 单、待办、流转日志一起没了", not any(left.values()), str(left))
|
||
check("4 「我发起的」里再也找不到这张单", TITLE_HELD not in my_works(client, headers),
|
||
sorted(my_works(client, headers)))
|
||
db.refresh(quota_row)
|
||
check("4 额度上压着的占用还回去了", int(quota_row.occupied_cents) == 0,
|
||
quota_row.occupied_cents)
|
||
db.refresh(session)
|
||
check("4 嵌页面那本「这一趟已发起成一张单」的账收回来了",
|
||
str(session.claim_job or "") == "", session.claim_job)
|
||
logged = db.execute(select(models.OperationLog.id).where(
|
||
models.OperationLog.action == "delete_job",
|
||
models.OperationLog.target == (held["serial"] or held["job"])).limit(1)
|
||
).scalars().first()
|
||
CLEAN["logs"] = [logged] if logged else []
|
||
check("4 删掉的是哪一张单记进了操作日志", logged is not None, held["serial"])
|
||
|
||
# 5 挡条撤掉之后,退回来那一张也删得掉,且不留悬空的已办与流转日志
|
||
rows = todo_rows(client, headers)
|
||
check("5 同事那条待办撤掉之后,自己这一行又亮出删除钮",
|
||
rows.get(TITLE_BACK, {}).get("deletable") is True, rows.get(TITLE_BACK))
|
||
done = client.post(f"/api/v1/job/{back['job']}/delete", headers=headers, json={})
|
||
check("5 退回到发起人手上的那张单也删得掉", done.status_code == 200, done.json())
|
||
db.commit()
|
||
residue = {
|
||
"已办": db.execute(select(models.TaskCompleted.id).where(
|
||
models.TaskCompleted.work == back["id"])).scalars().all(),
|
||
"流转日志": db.execute(select(models.WorkLog.id).where(
|
||
models.WorkLog.work == back["id"])).scalars().all(),
|
||
"归档单": db.execute(select(models.WorkCompleted.job).where(
|
||
models.WorkCompleted.job == back["job"])).scalars().all(),
|
||
}
|
||
check("5 删掉之后不留指向没了的单的已办、流转日志与归档行",
|
||
not any(residue.values()), str(residue))
|
||
finally:
|
||
db.rollback()
|
||
if CLEAN.get("tasks"):
|
||
db.execute(delete(models.Task).where(models.Task.id.in_(CLEAN["tasks"])))
|
||
if CLEAN.get("sessions"):
|
||
db.execute(delete(models.EmbedSession).where(
|
||
models.EmbedSession.id.in_(CLEAN["sessions"])))
|
||
if CLEAN.get("quota"):
|
||
db.execute(delete(models.Quota).where(models.Quota.id == CLEAN["quota"]))
|
||
db.execute(delete(models.QuotaLedger).where(models.QuotaLedger.quota_def == QUOTA_CODE))
|
||
if CLEAN.get("logs"):
|
||
db.execute(delete(models.OperationLog).where(models.OperationLog.id.in_(CLEAN["logs"])))
|
||
if CLEAN["works"]:
|
||
for model in (models.Task, models.TaskCompleted, models.WorkLog, models.Read,
|
||
models.ReadCompleted, models.WorkComment, models.Attachment,
|
||
models.Notification, models.OutboundMessage, models.NodeDecision):
|
||
db.execute(delete(model).where(model.work.in_(CLEAN["works"])))
|
||
db.execute(delete(models.Work).where(models.Work.id.in_(CLEAN["works"])))
|
||
db.execute(delete(models.WorkCompleted).where(
|
||
models.WorkCompleted.job.in_(CLEAN["jobs"])))
|
||
if CLEAN["process"]:
|
||
db.execute(delete(models.SerialNumber).where(
|
||
models.SerialNumber.process == CLEAN["process"]))
|
||
db.execute(delete(models.ProcessSnapshot).where(
|
||
models.ProcessSnapshot.process == CLEAN["process"]))
|
||
db.execute(delete(models.Route).where(models.Route.process == CLEAN["process"]))
|
||
db.execute(delete(models.Activity).where(models.Activity.process == CLEAN["process"]))
|
||
db.execute(delete(models.Process).where(models.Process.id == CLEAN["process"]))
|
||
if CLEAN["form"]:
|
||
db.execute(delete(models.FormElement).where(models.FormElement.id == CLEAN["form"]))
|
||
db.commit()
|
||
residue = {
|
||
"单据": db.execute(select(models.Work.id).where(
|
||
models.Work.id.in_(CLEAN["works"] or ["-"]))).scalars().all(),
|
||
"待办": db.execute(select(models.Task.id).where(
|
||
models.Task.work.in_(CLEAN["works"] or ["-"]))).scalars().all(),
|
||
"额度": db.execute(select(models.Quota.id).where(
|
||
models.Quota.id == CLEAN.get("quota", "-"))).scalars().all(),
|
||
"流程": db.execute(select(models.Process.id).where(
|
||
models.Process.id == CLEAN["process"])).scalars().all(),
|
||
}
|
||
left_over = {key: list(value) for key, value in residue.items() if list(value)}
|
||
check("99 这一组没在库里留下东西", not left_over, str(left_over))
|
||
definition_module.forget_snapshots()
|
||
db.close()
|
||
|
||
print(f"\n{PASSED} 条通过,{len(FAILS)} 条失败")
|
||
return 1 if FAILS else 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|