unis-oa/backend/scripts/check_embed_reopen.py

258 lines
13 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_embed_reopen.py
用户那句原话是在**生产环境**上试出来的:"我提交后,再次打开页面又重新创建了一个页面。"
链路是这样断的:
1. 发起页上点开那一格 → 后端开一趟嵌入会话,预受理号 ``PRE-A``,第三方按这个号建草稿。
那一刻还没有单据,会话上 ``work`` / ``job`` 两列是空的——这本身是对的。
2. 那个人回到 OA 点「提交」→ OA 发起一张真单,并把这张单记回那一趟
(:func:`embed_session.apply_start`,写的只有 ``claim_job``)。
3. 提交之后界面把他送到单据页,那一页重新发一次 ``POST /embed/launch``,
带的是 ``work=<那张单的主键>``。
4. :func:`embed_session.find_open` 按 ``work`` 那一列认"同一趟"。可那一步只写了 ``claim_job``、
没把主键写进 ``work`` → 找不到 → 另起一趟、另发一个 ``PRE-B`` → 第三方照着新号
又开一张空草稿。屏幕上那句话就是这么来的。
修法是 :func:`embed_session.stamp_work`:认领走的那一刻把单据的主键与单号一并钉回这一趟。
这一趟**就是**那张单,认出它是同一趟不是宽容,是本来就该认。
为什么非得跑真流程:这个 bug 跨了发起与查看两个接口、一张真单据、一次真认领,
拿假单号(``check_embed_api.py`` 那种)根本撞不到第 4 步那次按主键的查找。
钉这六句,一句都对得上一种看得见的坏法:
1. 提交之前那一趟确实还挂不上单据(``work`` 是空的)——先把"为什么会找不到"钉住,
不然以后有人看到 ``work`` 有值,以为第 5 句是白过的;
2. 提交那一刻那一趟被认领走(``claim_job`` 就是那张单);
3. **在单据页上再点开这一格,回来的还是同一个预受理号**——这就是用户要的那一句;
4. 连着再点开两次还是那一趟,库里的会话条数不涨(每涨一条,对面就多一张草稿);
5. 那一趟现在带着那张单的主键与单号(第 3 句靠的是它,不是碰巧);
6. 新开一张发起页仍然是**新的一趟**——把旧语义改坏是另一种事故:那张全新的表单
不该继承上一张单在对面留下的那一页。
跑完连自己造的源、会话与单据一起删干净。
"""
from __future__ import annotations
import sys
import time
from datetime import datetime
from sqlalchemy import delete, func, or_, select
from starlette.testclient import TestClient
from app import models
from app.db import SessionLocal
from app.main import app
from app.security import create_access_token
#: 与 ``check_embed_decide.py`` 用同一张已发布流程与同一份能过必填校验的表单
PROCESS_NAME = "备用金申请流程"
DATA = {
"loanType": "personalLoan", "loanReason": "校验提交后回到同一趟",
"loanItems": [{"loanNote": "校验", "loanType": "personalLoan", "loanTypeName": "校验",
"loanAmount": 3000, "returnDate": "2099-12-31"}],
"loanAmountTotal": 3000,
"payItems": [{"payee": "康文靖", "bankName": "校验银行", "bankAccount": "6222020200009999",
"payAmount": 3000, "payWay": "bank"}],
}
FIELD = "embed_reopen_page"
FIELD_CFG = {"height": 480, "mode": "frame"}
#: 这一趟专用的那条源走「本系统发短码」免登,那一道闸要求先填应用密钥(与
#: ``check_embed_decide.py`` 同一个做法);这条源只活到这一趟跑完,不必是真那一份
SHARED_KEY = "check-embed-reopen-key"
FAILS: list[str] = []
PASSED = 0
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 note(text: str) -> None:
print(f"[跳过] {text}")
def make_source(client: TestClient, headers: dict) -> str:
"""这一趟专用的那条 embed 源:不带参数、不要密钥,只要发得出地址与预受理号。"""
code = f"embed_reopen_{int(time.time())}"
response = client.post("/api/v1/design/data-sources", headers=headers, json={
"code": code, "name": "提交后回同一趟·ERP 受理页", "system": "ERP", "kind": "fetch",
"provider": "embed", "url": "https://erp.invalid/accept?view=1", "pageMode": "ticket",
"authSecret": SHARED_KEY,
})
if response.status_code >= 400:
return ""
return code
def launch(client: TestClient, headers: dict, code: str, **over) -> dict:
"""发一次「打开这一格」。``over`` 决定它是发起页那一路还是单据页那一路。"""
body = {"code": code, "field": FIELD, "embed": FIELD_CFG}
body.update(over)
response = client.post("/api/v1/embed/launch", headers=headers, json=body)
if response.status_code >= 400:
return {"_status": response.status_code, "_text": response.text[:200]}
return (response.json() or {}).get("data") or {}
def session_of(job: dict) -> dict:
return dict(job.get("session") or {})
def count_sessions(db, codes: list[str]) -> int:
"""这几条源名下一共开过几趟会话。每多一条,第三方那边就多一张草稿。"""
if not codes:
return 0
return int(db.execute(select(func.count()).select_from(models.EmbedSession)
.where(models.EmbedSession.source.in_(codes))).scalar() or 0)
def row_of(db, prekey: str):
if not prekey:
return None
return db.execute(select(models.EmbedSession)
.where(models.EmbedSession.prekey == prekey)).scalars().first()
def purge(db, jobs: list[str], titles: list[str], codes: list[str]) -> None:
"""删掉自己造的单据、源、会话、短码与留痕;别人的东西一律不碰。"""
found = [job for job in jobs if job]
found += [row[0] for row in db.execute(select(models.Work.job).where(
models.Work.title.in_(titles or ["-1"]))).all()]
found += [row[0] for row in db.execute(select(models.WorkCompleted.job).where(
models.WorkCompleted.title.in_(titles or ["-1"]))).all()]
ids = list(found)
ids += [row[0] for row in db.execute(select(models.Work.id).where(models.Work.job.in_(found))).all()]
ids += [row[0] for row in db.execute(
select(models.WorkCompleted.id).where(models.WorkCompleted.job.in_(found))).all()]
for model in (models.WorkComment, models.Attachment, models.Notification, models.NotifyDelivery,
models.OutboundMessage, models.OpenEvent, models.WorkLog, models.TaskCompleted,
models.Task, models.WorkCompleted, models.Work):
columns = [getattr(model, name) for name in ("job", "work", "work_completed")
if hasattr(model, name)]
if columns and ids:
db.execute(delete(model).where(or_(*[column.in_(ids) for column in columns])))
if codes:
# 会话漏删的话,下一次跑这一趟会认到旧预受理号上,第 3 句就变成白过
db.execute(delete(models.EmbedSession).where(models.EmbedSession.source.in_(codes)))
db.execute(delete(models.EmbedTicket).where(models.EmbedTicket.source.in_(codes)))
db.execute(delete(models.DataSourceLog).where(models.DataSourceLog.source.in_(codes)))
db.execute(delete(models.DataSource).where(models.DataSource.code.in_(codes)))
db.commit()
def main() -> int:
db = SessionLocal()
process = db.execute(
select(models.Process).where(models.Process.name == PROCESS_NAME,
models.Process.enabled.is_(True))
).scalars().first()
if process is None:
note(f"没有已发布的「{PROCESS_NAME}」,这一项校不了")
db.close()
return 0
client = TestClient(app, raise_server_exceptions=False)
token, _ = create_access_token("1")
headers = {"Authorization": f"Bearer {token}"}
stamp = datetime.now().strftime("%m%d%H%M%S")
title = f"提交后回同一趟校验单 {stamp}"
code = ""
jobs: list[str] = []
try:
code = make_source(client, headers)
check("建成了这条专用的 embed 源", bool(code), code)
if not code:
return 1
db.rollback()
# --- 1. 发起页上点开那一格 ---
start = session_of(launch(client, headers, code, process=str(process.id), params={}))
prekey = str(start.get("prekey") or "")
check("发起页那一趟拿到预受理号(这一刻双方只有它)", prekey.startswith("PRE"), prekey)
# 读库前先结束自己那份只读快照:MySQL 默认可重复读,接口那边刚提交的行在这个连接上
# 看不见(开头读流程时已经开过一次事务),于是下面两句会因为"根本没查到那一行"而 FAIL
db.rollback()
before = row_of(db, prekey)
check("提交之前那一趟确实挂不上单据:work 是空的",
before is not None and str(before.work or "") == "", getattr(before, "work", None))
opened = count_sessions(db, [code])
# --- 2. 那个人回到 OA 点「提交」(带上那一格的预受理号)---
created = client.post("/api/v1/job", headers=headers,
json={"process": process.id, "data": DATA, "title": title,
"prekeys": [prekey]})
if created.status_code >= 400:
note(f"发起这张流程没成功({created.status_code}):{created.text[:160]}")
return 0
body = (created.json() or {}).get("data") or {}
job = str(body.get("job") or "")
# 这份报文里 ``work`` 是那张单的**主键**,``job`` 才是给人看的单号。单据页重新打开
# 这一格时交上去的是单号,而 ``find_open`` 找的是主键——下面那一句要拿主键比对
work_id = str(body.get("work") or "")
jobs.append(job)
check("发起了一张真单据", bool(job) and bool(work_id),
f"{created.status_code} {str(created.text)[:160]}")
db.rollback()
claimed = row_of(db, prekey)
check("提交那一刻这一趟被认领走,认领到的就是这张单",
claimed is not None and str(claimed.claim_job or "") == job,
getattr(claimed, "claim_job", None))
# --- 3./4. 单据页上再点开这一格:必须还是对面那一页 ---
again = session_of(launch(client, headers, code, job=job))
check("提交之后在单据页上再点开,回来的还是同一个预受理号(第三方据此回到同一页)",
str(again.get("prekey") or "") == prekey and bool(prekey), again)
third = session_of(launch(client, headers, code, job=job))
forth = session_of(launch(client, headers, code, job=job))
check("连着再点开两次还是那一趟:库里的会话一条都没多涨",
str(third.get("prekey") or "") == prekey and str(forth.get("prekey") or "") == prekey
and count_sessions(db, [code]) == opened,
f"原本 {opened} 条,现在 {count_sessions(db, [code])} 条")
db.rollback()
pinned = row_of(db, prekey)
check("这一趟现在带着那张单的主键与单号(上面那句靠的是它,不是碰巧)",
pinned is not None and str(pinned.work or "") == work_id
and str(pinned.job or "") == job,
(getattr(pinned, "work", None), getattr(pinned, "job", None), work_id))
check("认到单据之后,这一趟能做的事按此刻这个环节重算过",
pinned is not None and isinstance(list(pinned.scopes or []), list),
getattr(pinned, "scopes", None))
# --- 6. 新开一张发起页仍是新的一趟 ---
fresh = session_of(launch(client, headers, code, process=str(process.id),
params={}, serial=f"SER-REOPEN-{stamp}"))
check("新开一张发起页是**新的一趟**:不许把上一张单在对面那一页继承过来",
bool(fresh.get("prekey")) and str(fresh.get("prekey")) != prekey, fresh)
return finish()
finally:
purge(db, jobs, [title], [code] if code else [])
db.close()
def finish() -> int:
print(f"\n共 {PASSED + len(FAILS)} 项,失败 {len(FAILS)} 项")
if FAILS:
print("提交后回到同一趟这条路**不对**:\n " + "\n ".join(FAILS))
return 1
print("通过:提交之后再点开那一格外部页面,认回的还是第三方那边那一页")
return 0
if __name__ == "__main__":
sys.exit(main())