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