unis-oa/backend/scripts/check_embed_view_link.py

420 lines
23 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_view_link.py
两句话凑在同一条路上(都是生产上问的):
* 「我的发起」「我的已办」里点开流程,嵌进来的那一页**根本打不开**;希望这两个模块能配成
打开接口回的那个**查看页**,「我的待办」只要流程还在途也一样;
* 第三方在自己那一页点了提交,OA 库里已经多出一张已发起的单,而还开着的那张发起页停在
编辑态——"我以为没发起成"。
断在第一句的是这一处判据。生产用的那条源(``reimb_shfp``,``url_mode=api``)一次回两条
地址:填报页 ``data.fill_url`` 与审阅页 ``data.review_url``,而**单据没进审阅之前审阅页回的
是空串**(跟着 ``is_review_allowed:false`` 一起回)。``service/embed.py:_pick_link`` 原来把
"键在、值是空的"当成"这一栏配歪了、取不到",于是 :func:`embed._finish_link` 里"要的那一条
配了位置却没取到"= 整次打开失败,界面收到一句「那个接口没有回链接」。而只读场合按
``link=auto`` 的口径**一律**要审阅页——所以流程在途时谁都打不开,配得越对越打不开。
三处一起改,这一份判据钉的就是这三处:
1. 空串说的是**对方这一趟没有这一页**,不是配歪(:func:`embed._pick_link` 回 ``("", "")``)。
要的那一条没给就走退路,并在回包里说实话:``linkWanted`` 要的是哪一条、
``linkAbsent`` 是不是对方压根没回那一条。
2. 「给哪一条地址」多一档 ``start``(:data:`embed.LINK_START`):只问"这一屏手上有没有这张
单"——发起页给填报页,单据一存在(我的发起 / 我的已办 / 待办审批页 / 办结回看)一律
查看页,连发起人自己也一样。``auto`` 那一档在发起人还有代办时给他填报页,管不了这一句。
3. 沿用这一趟存过的地址之前**先看要的是哪一条**(:func:`embed.build_url` 里那一句 ``stale``):
只存过填报页而这一屏要查看页时再问一次接口,不然「等对方有了那一页,再点开就是它」是句
永远兑不了的话——那正是"已办里点开还是填报页"。问不成也照旧递手上那一页,不把门关上。
第二句的地基是 ``POST /embed/state``:发起页那一拍(``frontend/src/components/oa/
EmbedFrame.vue`` 里的 ``STATE_POLL_MS`` 与对方一有动静——包括对方那句 ``oa:submitted``——
时的追问)读的就是它。它答不出"这一趟已经是一张单了",界面那句提示与"当场换成那张单的
详情页"都不会发生。
钉这十二句,一句都对得上一种看得见的坏法:
1. 发起页那一路给填报页,且不说自己"要的是查看页"(那一屏本来就该填);
2. 单据在途、发起人在「我的发起」里点开:**打得开**,递填报页,并明说要的是查看页而对方没回
(这一句在修之前是一个 400);
3. 查看页还没到手时那一次多问,问的是同一张单、递的还是**对面第一次建好的那一页**:
多问一次既不换页,也不给按单号幂等的那头多建一张草稿(代价说清楚:这一档每开一次问一次,
一直问到对方给出查看页为止);
4. 存量口径(这一格没配 ``link``,走 ``auto``)在审批人手上同样打得开:改的是判据,
不是"只有新配的源才修好";
5. 对面进了审阅,同一个人在同一张单上再点开,拿到的就是**查看页**那一条;
6. 换一个人(审批人)也立刻是查看页:那条只读地址不属于第一个打开它的人;
7. 「我的发起」也一样换成查看页——``start`` 那一档只看有没有单据,不看站着的是谁;
8. 这一档不改发起页那一屏:新开一张发起页仍然拿填报页接着填;
9. 这条源压根没配查看页那一栏时不许空头承诺:给填报页,且说"要的就是填报页";
10. 拿发起页那个预受理号问一句「这一趟成单了吗」,答得出刚发起的那张单号(发起页那句
提示与自动跳转全靠它);
11. 两条都回空、而手上也没存货:仍然失败,但那句话点名是**哪一条地址是空的**;
12. 手上已经有填报页的那一趟,即使这一次两条都空也照样开得开——已知的那一页不该被
对面的一次哑巴挡在门外。
跑完连自己造的源、会话、页面账、单据、流程与留痕一起删干净。
"""
from __future__ import annotations
import json
import pathlib
import sys
import threading
from datetime import datetime
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
from sqlalchemy import delete, or_, select # noqa: E402
from starlette.testclient import TestClient # noqa: E402
from app import models # noqa: E402
from app.db import SessionLocal # noqa: E402
from app.db import engine as db_engine # noqa: E402
from app.main import app # noqa: E402
from app.security import create_access_token # noqa: E402
from app.service import personref # noqa: E402
STAMP = datetime.now().strftime("%m%d%H%M%S")
#: 这一档新加的那一档:发起那一屏之外一律查看页
FIELD_START = "embed_view_link"
#: 对照组:这一格什么都没配(存量表单上绝大多数就是这种),走 ``auto``
FIELD_AUTO = "embed_view_auto"
#: 对照组:同一条 ``start`` 口径,但这条源没配查看页那一栏
FIELD_NOVIEW = "embed_view_noview"
PASSED = 0
FAILS: list[str] = []
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}")
# ---------------------------------------------------------------------------
# 第三方那一头:一条"审阅之前没有审阅页"的建页接口
# ---------------------------------------------------------------------------
class LinkServer(ThreadingHTTPServer):
"""``reimb_shfp`` 那个建页接口的替身。
三件事照生产复刻:同一个号再问一次**还是那一页**(幂等,所以多问一次不多建一页)、
单据没进审阅之前 ``reviewUrl`` 回**空串**、地址挂在 ``data`` 那一层下面。
"""
daemon_threads = True
def __init__(self, handler: type[BaseHTTPRequestHandler]) -> None:
super().__init__(("127.0.0.1", 0), handler)
self.calls = 0
self.pages: dict[str, int] = {}
#: 对方那边这张单进审阅了没有:没进就没有审阅页
self.in_review = False
#: 一种更坏的答法:两条都回空串(接口活着,可这一趟什么页都没给)
self.both_empty = False
class Handler(BaseHTTPRequestHandler):
def do_POST(self) -> None: # noqa: N802 - BaseHTTPRequestHandler 的命名
length = int(self.headers.get("Content-Length") or 0)
try:
no = str(json.loads(self.rfile.read(length).decode("utf-8", "replace")).get("no") or "")
except (ValueError, AttributeError):
no = ""
server = self.server # type: ignore[attr-defined]
server.calls += 1
page = server.pages.setdefault(no, len(server.pages) + 1)
base = f"http://127.0.0.1:{server.server_address[1]}/page"
fill = "" if server.both_empty else f"{base}/fill?no={no}&page={page}"
review = ""
if server.in_review and not server.both_empty:
review = f"{base}/view?no={no}&page={page}"
body = json.dumps({"code": 0, "data": {"fillUrl": fill, "reviewUrl": review}}).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def log_message(self, *_args) -> None: # 安静:结论只由 check() 打印
return
def page_of(url: object) -> str:
"""那条地址上对面那一页的页号(拿不到回空串)。"""
text = str(url or "")
marker = "page="
return text.split(marker, 1)[1].split("&", 1)[0] if marker in text else ""
# ---------------------------------------------------------------------------
# 这一趟用的两条源、那张流程与那两个人
# ---------------------------------------------------------------------------
def make_source(client: TestClient, headers: dict, port: int, code: str, name: str,
*, with_view: bool) -> bool:
"""一条 ``url_mode=api`` 的源:两条地址都在对方那一次响应里,位置各自配一栏。"""
body = {
"code": code, "name": name, "system": "ERP", "kind": "fetch",
"provider": "embed", "url": f"http://127.0.0.1:{port}/link", "method": "POST",
"bodyTemplate": {"no": "{arg.contractNo}"}, "urlMode": "api", "urlPath": "data.fillUrl",
"urlOrigins": [f"http://127.0.0.1:{port}"], "pageMode": "none",
}
if with_view:
body["viewUrlPath"] = "data.reviewUrl"
return client.post("/api/v1/design/data-sources", headers=headers, json=body).status_code < 400
def build_form(db) -> str:
"""最小的一张表单:只有一格流程编号,够那一格嵌页面取参数用。"""
form = models.FormElement(name=f"在途查看页校验表单 {STAMP}",
content={"fields": [{"key": "contractNo", "label": "合同编号",
"type": "text"}]})
db.add(form)
db.commit()
return str(form.id)
def build_process(db, approver_ref: str, form_id: str) -> str:
"""发起 → 部门审批 → 结束。跑完这一段,那张单一直**在途**。"""
process = models.Process(name=f"在途查看页校验流程 {STAMP}", category="check",
enabled=True, published=True, latest_form=form_id,
latest_form_name=f"在途查看页校验表单 {STAMP}")
db.add(process)
db.flush()
begin = models.Activity(process=process.id, type="begin", name="发起申请",
order_number=0, form=form_id, config={})
first = models.Activity(process=process.id, type="manual", name="部门审批", order_number=1,
form=form_id,
config={"mode": "any", "taskValues": [{"type": "person",
"data": [approver_ref]}]})
end = models.Activity(process=process.id, type="end", name="结束", order_number=2)
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),
models.Route(process=process.id, name="通过", from_activity=first.id, to_activity=end.id),
])
db.commit()
return str(process.id)
def cfg_for(code: str, *, link: str = "") -> dict:
"""那一格的配置。``link`` 留空 = 这一格什么都没配(存量表单上绝大多数就是这样)。"""
cfg: dict = {"source": code, "params": {"contractNo": "{form.contractNo}"}, "height": 480}
if link:
cfg["link"] = "start" if link == "start" else link
return cfg
def launch(client: TestClient, headers: dict, code: str, field: str, embed: dict, **over) -> dict:
body = {"code": code, "field": field, "embed": embed}
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[:300]}
return (response.json() or {}).get("data") or {}
def purge(db, code: str, code2: str, process_id: str, form_id: str, jobs: list[str]) -> None:
"""删掉自己造的单据、源、会话、页面账、短码与留痕;别人的东西一律不碰。"""
ids = list(jobs)
ids += [row[0] for row in db.execute(select(models.Work.id).where(
models.Work.job.in_(jobs or ["-1"]))).all()]
ids += [row[0] for row in db.execute(select(models.WorkCompleted.id).where(
models.WorkCompleted.job.in_(jobs or ["-1"]))).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 process_id:
db.execute(delete(models.Activity).where(models.Activity.process == process_id))
db.execute(delete(models.Route).where(models.Route.process == process_id))
db.execute(delete(models.Process).where(models.Process.id == process_id))
if form_id:
db.execute(delete(models.FormElement).where(models.FormElement.id == form_id))
codes = [item for item in (code, code2) if item]
if codes:
if hasattr(models, "EmbedPage"):
db.execute(delete(models.EmbedPage).where(models.EmbedPage.source.in_(codes)))
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:
# TestClient 不进 lifespan,启动那一步的自动建表不会跑;这张表是新加的,自己补一下
models.EmbedPage.__table__.create(bind=db_engine, checkfirst=True)
db = SessionLocal()
starter = db.get(models.User, 1)
other = db.execute(
select(models.User).where(models.User.id != 1,
models.User.status == models.UserStatus.ACTIVE)
.order_by(models.User.id).limit(1)
).scalars().first()
if starter is None or other is None:
note("库里凑不齐「发起人 + 一个审批人」,这一项校不了")
db.close()
return 0
server = LinkServer(Handler)
threading.Thread(target=server.serve_forever, daemon=True).start()
port = int(server.server_address[1])
client = TestClient(app, raise_server_exceptions=False)
admin = {"Authorization": f"Bearer {create_access_token(str(starter.id))[0]}"}
approver_headers = {"Authorization": f"Bearer {create_access_token(str(other.id))[0]}"}
code = f"embed_view_{STAMP}"
code2 = f"embed_noview_{STAMP}"
process_id = form_id = ""
jobs: list[str] = []
contract = f"HT-VIEW-{STAMP}"
try:
ok1 = make_source(client, admin, port, code, "在途查看页校验·建页接口", with_view=True)
ok2 = make_source(client, admin, port, code2, "在途查看页校验·只有一条", with_view=False)
check("建成了两条源:一条配了查看页那一栏,一条没配", ok1 and ok2, f"{ok1} {ok2}")
if not (ok1 and ok2):
return 1
form_id = build_form(db)
process_id = build_process(db, personref.ref_of(other), form_id)
start_cfg = cfg_for(code, link="start")
auto_cfg = cfg_for(code)
noview_cfg = cfg_for(code2, link="start")
# --- 1. 发起页那一路:那一屏该拿到填报页,而且不该说"要的是查看页" ---
start = launch(client, admin, code, FIELD_START, start_cfg,
process=process_id, params={"contractNo": contract})
first_page = page_of(start.get("url"))
prekey = str((start.get("session") or {}).get("prekey") or "")
check("发起页那一屏给填报页,也没谎称自己要查看页(这一屏本来就该填)",
start.get("link") == "edit" and start.get("linkWanted") == "edit"
and start.get("linkAbsent") is False and bool(first_page), start)
# --- 2. 提交成单,单子停在部门审批(**在途**)---
created = client.post("/api/v1/job", headers=admin,
json={"process": process_id, "data": {"contractNo": contract},
"title": f"在途查看页校验单 {STAMP}", "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 "")
jobs.append(job)
check("发起了一张真单据,停在部门审批这一环(在途)", bool(job), created.text[:160])
db.commit()
pending = db.execute(select(models.Task).where(
models.Task.job == job, models.Task.status == "pending")).scalars().first()
check("那张单确实还没走完:待办挂在审批人手上", pending is not None, job)
# --- 3. 只读场合点开:修之前这里是一个 400 ---
mine = launch(client, admin, code, FIELD_START, start_cfg, job=job)
check("**流程在途时「我的发起」里点开打得开**:递填报页,并明说要的是查看页而对方没回",
"_status" not in mine and mine.get("link") == "edit"
and mine.get("linkWanted") == "view" and mine.get("linkAbsent") is True, mine)
check("界面念得出那一档的人话名字(「查看页」),不是键名 view",
mine.get("linkWantedName") == "查看页", mine.get("linkWantedName"))
# --- 4. 再问一次没有换来新的一页 ---
# 这一句同时钉住两头的代价与好处:只要对方还没有审阅页,只读场合每一次点开都会**多问
# 一次**(那一次问的就是"他们那边有了吗",不一直问就永远等不到);而对一个按单号幂等的
# 建页接口——生产那条就是——多问一次不多建一页,递出去的也还是原来那一页
calls_after = int(server.calls)
again = launch(client, admin, code, FIELD_START, start_cfg, job=job)
check("查看页还没有时再问一次,问的是同一张单、递的还是对面第一次建好的那一页",
page_of(again.get("url")) == first_page and again.get("link") == "edit"
and int(server.calls) == calls_after + 1,
f"页号 {page_of(again.get('url'))} vs {first_page},接口 {calls_after} → {server.calls}")
# --- 5. 存量口径(这一格没配 link)在审批人手上同样打得开 ---
approver = str(pending.person) if pending is not None else str(other.id)
headers_of = admin if approver == str(starter.id) else approver_headers
auto = launch(client, headers_of, code, FIELD_AUTO, auto_cfg, job=job)
check("这一格没配 ``link`` 的存量表单也一样修好了:只读场合不再被空审阅页关在门外",
"_status" not in auto and auto.get("link") == "edit"
and auto.get("linkWanted") == "view" and auto.get("linkAbsent") is True, auto)
# --- 6. 对面进了审阅 ---
server.in_review = True
reviewed = launch(client, headers_of, code, FIELD_AUTO, auto_cfg, job=job)
check("**对方回了查看页之后,同一张单再点开拿到的就是查看页**(不靠重新登录、不等过期)",
reviewed.get("link") == "view" and "/view?" in str(reviewed.get("url"))
and reviewed.get("linkAbsent") is False, reviewed)
check("换到查看页也还是**同一张单的那一页**(页号没换,对面没多一张草稿)",
page_of(reviewed.get("url")) == first_page,
f"{page_of(reviewed.get('url'))} vs {first_page}")
mine_view = launch(client, admin, code, FIELD_START, start_cfg, job=job)
check("「我的发起」里也一样换成查看页:那一档只看有没有单据,不看站着的是谁",
mine_view.get("link") == "view" and mine_view.get("linkWanted") == "view", mine_view)
# --- 7. 这一档不改发起页那一屏 ---
fresh = launch(client, admin, code, FIELD_START, start_cfg, process=process_id,
params={"contractNo": f"HT-VIEW-{STAMP}-B"}, serial=f"SER-VIEW-{STAMP}")
check("新开一张发起页仍然拿填报页接着填(``start`` 只问有没有单据)",
fresh.get("link") == "edit" and fresh.get("linkWanted") == "edit", fresh)
# --- 8. 这条源没配查看页那一栏时不许空头承诺 ---
noview = launch(client, admin, code2, FIELD_NOVIEW, noview_cfg, job=job)
check("源上没配查看页那一栏时不装样子:给填报页,并说「要的就是填报页」",
"_status" not in noview and noview.get("link") == "edit"
and noview.get("linkWanted") == "edit" and noview.get("linkAbsent") is False, noview)
# --- 9. 发起页那一问:这一趟成单了吗(第三件事的地基)---
state = client.post("/api/v1/embed/state", headers=admin,
json={"code": code, "field": FIELD_START, "prekey": prekey})
started = (((state.json() or {}).get("data") or {}).get("started")) or {}
check("拿发起页那个预受理号问一句「成单了吗」,答得出刚发起的那张单号",
str(started.get("job") or "") == job, f"{state.status_code} {started} vs {job}")
# --- 10./11. 两条都回空 ---
server.both_empty = True
server.in_review = False
empty_new = launch(client, admin, code, FIELD_START, start_cfg, process=process_id,
params={"contractNo": f"HT-VIEW-{STAMP}-C"},
serial=f"SER-VIEW-{STAMP}-C")
check("手上没存货、两条又都回空:照旧失败,但说的是**哪一条地址是空的**",
empty_new.get("_status") == 400 and "地址是空的" in str(empty_new.get("_text")),
empty_new)
held_open = launch(client, admin, code, FIELD_START, start_cfg, job=job)
check("手上已经有填报页的那一趟,即使这一次两条都空也照样开得开",
"_status" not in held_open
and str(held_open.get("url") or "").startswith("http://127.0.0.1"), held_open)
return finish()
finally:
server.shutdown()
purge(db, code, code2, process_id, form_id, jobs)
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())