unis-oa/backend/scripts/check_link_fill_submit.py

381 lines
21 KiB
Python
Raw 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
"""关联带出走一遍真提交(连库,跑在 backend 目录下)::
PYTHONPATH=. python3 scripts/check_link_fill_submit.py
:doc:`check_link_fill.py` 校的是纯函数那一份口径,这一份钉的是**接上引擎之后**:
1. **发起那一刻就带得出**:``create_job`` 里那趟 ``_apply_form_runtime`` 走到带出,
关联的主表字段与明细行落进 ``work.data``;
2. **明细行上的 ``_link`` 活得过整表那一趟**:``normalise_rows`` 只认配好的列,
认不出这一格就会被丢掉,下一次带出便认不得旧行,把人改过的行当新行重排;
3. **人在下一环删掉的那一行不复活**:关联没变时一行都不重排,人连配到带出的那一格都改得;
关联一变才整趟对账——该补的补(人删掉的那一行只要还挂着关联就补回来,加在末尾)、
该删的删、没配带出的那一列不动、配到带出的那一列按来源盖回去;
4. **多挂一张就多算一张**:主表那几格按当下挂着的那串单重算,与明细剩几行无关;
5. **挂着的那张单查不到了**:不替它编一行,主表那几格跳过它,不报错也不挡人;
6. **带出来的那一格参与必填**:带不出值时必填那道闸真的把这次提交挡住——带出排在必填之前;
7. **两个关联字段带同一张明细表**:报销单一格、采购单一格各配各的映射,各带各的行,
后算的那一格不许把前一格刚补的那一行删掉,主表那几格也只按自己那一格挂的单算;
8. **预览那一道可见性闸**:与 ``GET /work/summaries`` 同一分寸(不相干的静默少回),
但多认一档「确实挂在填的这一单上」——办理环节的人常常与对方那张单无关,
少了这一档,带出那一栏对他就是一片空白;引擎那一份**不带**这道闸。
跑完连自己造的应用、流程、表单、单据一起删干净。
"""
from __future__ import annotations
import sys
import time
from datetime import datetime
from sqlalchemy import delete, select
from app import models
from app.api import runtime
from app.service import linkfill
from app.db import SessionLocal
from app.engine import engine
from app.service import personref
STAMP = datetime.now().strftime("%m%d%H%M%S")
TITLE_PREFIX = f"关联带出校验 {STAMP}"
FAILS: list[str] = []
PASSED = 0
CLEAN: dict = {"jobs": [], "processes": [], "forms": []}
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} -> {detail}")
def source_fields() -> list[dict]:
return [
{"key": "amount", "type": "money", "label": "金额"},
{"key": "reason", "type": "text", "label": "事由"},
]
def target_fields() -> list[dict]:
return [
{"key": "orders", "type": "relation", "label": "关联报销单", "optionSource": "process",
"required": True,
"linkFill": {"rules": [
{"pick": "work.serial", "to": "src_serial", "agg": "join", "separator": " / "},
{"pick": "data.amount", "to": "total", "agg": "sum"},
{"pick": "data.amount", "to": "items.amount"},
{"pick": "data.reason", "to": "items.note"},
]}},
{"key": "buys", "type": "relation", "label": "关联采购单", "optionSource": "process",
"linkFill": {"rules": [{"pick": "data.reason", "to": "items.note"}]}},
{"key": "src_serial", "type": "text", "label": "来源单号"},
{"key": "total", "type": "money", "label": "合计", "required": True},
{"key": "items", "type": "table", "label": "明细", "columns": [
{"key": "amount", "type": "money", "label": "金额"},
{"key": "note", "type": "text", "label": "备注"},
{"key": "qty", "type": "number", "label": "数量"},
]},
]
def build(db, ref: str, handles: int = 5) -> tuple[str, str, list[str]]:
"""源流程(begin→end)与目标流程(begin→若干道办理→end),回 ``(源, 目标, [办理环节 id])``。
目标流程留好几道办理,是为了能在**中途**改那串关联:带出发生在每一次提交上,
「关联变了才重排、没变就不动」这件事只有连着提交两次才校得出来。
"""
forms = []
for name, fields in ((f"{TITLE_PREFIX} 源表单", source_fields()), (f"{TITLE_PREFIX} 目标表单", target_fields())):
form = models.FormElement(name=name, content={"fields": fields})
db.add(form)
forms.append(form)
db.flush()
CLEAN["forms"].extend(item.id for item in forms)
src = models.Process(name=f"{TITLE_PREFIX} 源流程", category="check", enabled=True, published=True,
latest_form=forms[0].id, latest_form_name=forms[0].name)
dst = models.Process(name=f"{TITLE_PREFIX} 目标流程", category="check", enabled=True, published=True,
latest_form=forms[1].id, latest_form_name=forms[1].name)
db.add_all([src, dst])
db.flush()
CLEAN["processes"].extend([src.id, dst.id])
begin = models.Activity(process=dst.id, type="begin", name="发起人", order_number=0)
steps_of = [
models.Activity(process=dst.id, type="manual", name=f"办理{index}", order_number=index,
form=forms[1].id,
config={"mode": "any", "taskValues": [{"type": "person", "data": [ref]}]})
for index in range(1, handles + 1)
]
db.add_all([
models.Activity(process=src.id, type="begin", name="发起人", order_number=0),
models.Activity(process=src.id, type="end", name="结束", order_number=1),
begin,
*steps_of,
models.Activity(process=dst.id, type="end", name="结束", order_number=handles + 1),
])
db.flush()
handles = steps_of
steps = [(begin.id, handles[0].id, "提交")]
steps += [(handles[index].id, handles[index + 1].id, "同意") for index in range(len(handles) - 1)]
steps.append((handles[-1].id, db.execute(
select(models.Activity).where(models.Activity.process == dst.id,
models.Activity.type == "end")).scalars().first().id, "同意"))
db.add_all([
models.Route(process=src.id, name="提交", from_activity=db.execute(
select(models.Activity).where(models.Activity.process == src.id,
models.Activity.type == "begin")).scalars().first().id,
to_activity=db.execute(select(models.Activity).where(
models.Activity.process == src.id, models.Activity.type == "end"
)).scalars().first().id),
*[models.Route(process=dst.id, name=name, from_activity=src_id, to_activity=dst_id)
for src_id, dst_id, name in steps],
])
db.commit()
return src.id, dst.id, [item.id for item in handles]
def job_of(result) -> str:
"""刚建的那张单的 ``job``。
``StepResult.work_job`` 只在**办结**那一路填(归档之后实例拿不住了才留个号),
还在跑的那一张手里是 ``work`` 本体——照着办结那条路写会把空串当成 job 传下去。
"""
work = getattr(result, "work", None)
return str(getattr(work, "job", "") or "") or str(getattr(result, "work_job", "") or "")
def serial_of(db, job: str) -> str:
"""那张单的单号:在途与归档两处都认。"""
for table in (models.Work, models.WorkCompleted):
row = db.execute(select(table).where(table.job == job)).scalars().first()
if row is not None:
return str(row.serial or "")
return ""
def pending(db, job: str):
return db.execute(select(models.Task).where(models.Task.job == job,
models.Task.status == "pending")).scalars().first()
def step(db, job: str, actor, data: dict | None = None) -> dict:
"""在当前那一环点「同意 / 提交」,带上这一环改过的表单,回提交之后的 ``data``。"""
task = pending(db, job)
if task is None:
FAILS.append(f"{job}:没有待办可点,带出这一步校不了")
return {}
engine.execute_task(db, task_id=task.id, actor=actor, route_name="", opinion="提交", data=data or {})
db.commit()
work = db.execute(select(models.Work).where(models.Work.job == job)).scalars().first()
if work is None:
archived = db.execute(select(models.WorkCompleted).where(
models.WorkCompleted.job == job)).scalars().first()
return dict(archived.data or {}) if archived is not None else {}
return dict(work.data or {})
def step_blocked(db, job: str, actor, data: dict | None = None) -> str:
"""同样点一次提交,但这回**该被校验挡住**:回那句红字;没挡住就把改动退回去回空串。"""
task = pending(db, job)
if task is None:
FAILS.append(f"{job}:没有待办可点,这一趟校不了")
return ""
try:
engine.execute_task(db, task_id=task.id, actor=actor, route_name="",
opinion="提交", data=data or {})
except engine.EngineError as exc:
db.rollback()
return str(exc)
db.rollback()
return ""
def preview(db, ref: str, *, admin: bool = False, values=None, picks=None, work: str = "") -> list[dict]:
"""填单页那一趟预览接口走一遍(直接调函数,不套 TestClient)。
接口只认 ``user.is_admin`` 与 ``user.ref`` 两样,拿一句假身份就够把它那道
可见性闸校出来——它比算法更容易错:闸太紧,办理环节的人看着带出那一栏一片空白;
闸没有,这一格就变成翻别人单据的口子。
"""
from types import SimpleNamespace
from app import schemas
body = schemas.RelationFillBody(values=list(values or []), picks=list(picks or []), work=work)
user = SimpleNamespace(ref=ref, is_admin=admin)
return list((runtime.relation_fill_values(body, user, db).get("data") or {}).get("items") or [])
def rows_of(data: dict) -> list[dict]:
return list((data or {}).get("items") or [])
def main() -> int:
db = SessionLocal()
user = db.get(models.User, 1)
if user is None:
print("[跳过] 库里没有 1 号用户,这一项校不了")
return 0
actor = engine.Actor.from_ref(db, user, personref.ref_of(user))
try:
src_process, _dst, handles = build(db, personref.ref_of(user))
# ---- 两张已办结的源单:目标流程要挂的正是「批完的单」,形状要真 ----
first = engine.create_job(db, process_id=src_process, actor=actor,
data={"amount": 120, "reason": "打车"}, title=f"{TITLE_PREFIX} 源一")
second = engine.create_job(db, process_id=src_process, actor=actor,
data={"amount": "2,300.50", "reason": "机票"}, title=f"{TITLE_PREFIX} 源二")
third = engine.create_job(db, process_id=src_process, actor=actor,
data={"amount": 777.25, "reason": "住宿"}, title=f"{TITLE_PREFIX} 源三")
db.commit()
job1, job2, job3 = job_of(first), job_of(second), job_of(third)
CLEAN["jobs"].extend([job1, job2, job3])
serial1, serial2, serial3 = serial_of(db, job1), serial_of(db, job2), serial_of(db, job3)
check("三张源单都办结归档了",
db.get(models.WorkCompleted, first.work_id) is not None
and db.get(models.WorkCompleted, second.work_id) is not None
and db.get(models.WorkCompleted, third.work_id) is not None, f"{job1} / {job2} / {job3}")
# ---- 1. 发起那一刻就带得出 ----
target = engine.create_job(db, process_id=_dst, actor=actor,
data={"orders": [job1, job2]}, title=f"{TITLE_PREFIX} 目标")
db.commit()
dst_job = job_of(target)
CLEAN["jobs"].append(dst_job)
data = dict(target.work.data or {})
check("发起时把关联的单号拼进主表那一格", data.get("src_serial") == f"{serial1} / {serial2}",
f"{data.get('src_serial')!r} ≠ {serial1} / {serial2}")
check("发起时把金额相加带进主表那一格", data.get("total") == 2420.5, data.get("total"))
rows = rows_of(data)
check("两张关联单补两行", len(rows) == 2, rows)
check("行上认得出是哪张单带来的", [row.get("_link") for row in rows] == [job1, job2], rows)
check("带出用的是对方表单里那一列", [row.get("amount") for row in rows] == [120, 2300.5], rows)
check("配到的那一列带得出值", [row.get("note") for row in rows] == ["打车", "机票"], rows)
check("没配的列也摆着,留一个形状正确的空", all(row.get("qty") == "" for row in rows), rows)
check("带出留痕落在 data 上", (data.get("_linkfill") or {}).get("orders") == [job1, job2],
data.get("_linkfill"))
check("走到了办理一环", pending(db, dst_job) is not None and pending(db, dst_job).activity == handles[0],
None if pending(db, dst_job) is None else pending(db, dst_job).activity)
# ---- 2. 下一环:人删掉一行、改了两格(一格配了带出、一格没配),提交时都不被动 ----
kept = dict(rows[0])
kept["note"] = "自己改过的" # 配了带出的那一列
kept["qty"] = 5 # 没配带出的那一列
mid = step(db, dst_job, actor, {"items": [kept]})
after = rows_of(mid)
check("人删掉的那一行不复活", [row.get("_link") for row in after] == [job1], after)
check("关联没变时,人连配到带出的那一列都改得", after and after[0].get("note") == "自己改过的", after)
check("关联没变时,人改的没配带出的那一列也不动", after and after[0].get("qty") == 5, after)
check("主表那一格按关联算,跟明细剩几行无关",
mid.get("total") == 2420.5 and mid.get("src_serial") == f"{serial1} / {serial2}", mid)
# ---- 3. 关联变了才补行:补的加在末尾,留下的行只刷配到的那一列 ----
mid = step(db, dst_job, actor, {"orders": [job1, job2, job3]})
after = rows_of(mid)
check("关联变化才补那一行,且加在末尾不打乱人排的序",
[row.get("_link") for row in after] == [job1, job2, job3], after)
readded = next((row for row in after if row.get("_link") == job2), {})
check("人删掉的那一行随关联变化补回来,带的是对方那一列",
readded.get("amount") == 2300.5 and readded.get("note") == "机票", readded)
check("新关联的那张单也补一行", len(after) == 3 and after[-1].get("amount") == 777.25, after[-1:])
kept_row = after[0] if after else {}
check("重排也不覆盖人改过的那一列(没配带出的那一格)",
kept_row.get("qty") == 5, kept_row)
check("配到带出的那一列按来源刷新,人改的会被盖回去",
kept_row.get("note") == "打车" and kept_row.get("amount") == 120, kept_row)
check("关联到三张单,主表那两格跟着三张单算",
mid.get("total") == 3197.75
and mid.get("src_serial") == f"{serial1} / {serial2} / {serial3}",
f"{mid.get('total')} / {mid.get('src_serial')}")
# ---- 4. 取消关联:那一行与主表那几格一起撤 ----
data = step(db, dst_job, actor, {"orders": [job2]})
after = rows_of(data)
check("取消关联的那一行跟着删", [row.get("_link") for row in after] == [job2], after)
check("主表那一格换成剩下的那张单", data.get("src_serial") == serial2, data.get("src_serial"))
check("合计跟着换成剩下的那张单", data.get("total") == 2300.5, data.get("total"))
# ---- 5. 挂着的那张单查不到了(未发起就删了 / 单号写歪):不替它编一行 ----
ghost = "早就不在的那张单"
data = step(db, dst_job, actor, {"orders": [job2, ghost]})
after = rows_of(data)
check("查不到的那张单不补行,认得出的那一张照旧带着",
[row.get("_link") for row in after] == [job2], after)
check("主表那一格跳过查不到的那张,不报错也不挡人",
data.get("src_serial") == serial2 and data.get("total") == 2300.5,
f"{data.get('src_serial')!r} / {data.get('total')!r}")
# ---- 6. 只剩一张查不到的单:带不出值,必填那道闸把这次提交挡住 ----
message = step_blocked(db, dst_job, actor, {"orders": [ghost]})
check("带出来的那一格参与必填:带不出值就挡住提交", "合计" in message, message)
left = pending(db, dst_job)
check("挡下来之后还停在原来那一环,单没被推走",
left is not None and left.activity == handles[-1],
None if left is None else left.activity)
# ---- 7. 两个关联字段带同一张明细表:各带各的行,谁也不删对方的行 ----
data = step(db, dst_job, actor, {"orders": [job1], "buys": [job2]})
after = rows_of(data)
by_job = {str(row.get("_link") or ""): row for row in after}
check("后算的那一格不许把前一格刚补的那一行删掉",
[row.get("_link") for row in after] == [job2, job1], after)
check("各自带各自的行:报销单那一行是报销单的值",
by_job.get(job1, {}).get("amount") == 120
and by_job.get(job1, {}).get("note") == "打车", by_job.get(job1))
check("采购单那一行只被自己那一格的映射动过(金额还是报销那趟带出来的)",
by_job.get(job2, {}).get("note") == "机票"
and by_job.get(job2, {}).get("amount") == 2300.5, by_job.get(job2))
check("主表那两格只按自己那一格挂的单算",
data.get("src_serial") == serial1 and data.get("total") == 120,
f"{data.get('src_serial')!r} / {data.get('total')!r}")
# ---- 8. 预览那一道可见性闸:与 GET /work/summaries 同一分寸,再多认"挂在这一单上" ----
mine = preview(db, personref.ref_of(user), values=[job2], picks=["data.amount"])
check("预览认得与自己相关的那几张单", [item["job"] for item in mine] == [job2], mine)
# 回的是**对方那一格里存着的原话**(金额存成 "2,300.50" 就回它),收成目标那格的
# 形状是带出那一步的事(前后端各自按目标那一格的类型整型),接口不替人猜
check("回的是配好的那一条 pick 的原值", mine and mine[0]["values"] == {"data.amount": "2,300.50"}, mine)
stranger = "跟这件事毫无关系的人"
check("不相干的人问同一张单,静默少回而不是泄出去",
preview(db, stranger, values=[job2], picks=["data.amount"]) == [],
preview(db, stranger, values=[job2], picks=["data.amount"]))
check("但那几张单确实挂在正在填的这一单上,预览就带得出来(否则这一栏全是空白)",
[item["job"] for item in preview(db, stranger, values=[job1, job2],
picks=["data.amount"], work=dst_job)] == [job1, job2],
preview(db, stranger, values=[job1, job2], picks=["data.amount"], work=dst_job))
check("引擎那一份取单压根没有「谁在看」这个参数,也就没有这道闸",
linkfill.works_by_values(db, [job2]).get(job2) is not None, job2)
finally:
_cleanup(db)
db.close()
if FAILS:
print(f"共 {len(FAILS)} 条不对")
return 1
print(f"通过:关联带出走通了真提交({PASSED} 项)")
return 0
def _cleanup(db) -> None:
"""删干净自己造的那几张单与流程。"""
for table in (models.Work, models.WorkCompleted, models.Task, models.TaskCompleted,
models.WorkLog, models.Read, models.ReadCompleted, models.Attachment):
if CLEAN["jobs"] and hasattr(table, "job"):
db.execute(delete(table).where(table.job.in_(CLEAN["jobs"])))
for process in CLEAN["processes"]:
for table in (models.Activity, models.Route, models.ProcessVersion, models.ProcessSnapshot):
db.execute(delete(table).where(table.process == process))
db.execute(delete(models.Process).where(models.Process.id == process))
for form in CLEAN["forms"]:
db.execute(delete(models.FormElement).where(models.FormElement.id == form))
db.commit()
if __name__ == "__main__":
sys.exit(main())