unis-oa/backend/scripts/check_delete_unstarted.py

362 lines
20 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
"""「我的待办」上那颗「删除」:只开给本人创建、还没发起流转的那一张单。
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())