unis-oa/backend/scripts/check_embed_shared_page.py

433 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_reopen.py 管的是"同一个人再点开一次"。
PYTHONPATH=. python3 scripts/check_embed_shared_page.py # 这一份:换一个人、换一个环节
用户那句原话是在生产上试出来的:"我在后面节点打开嵌入页面查看的时候,发现又帮我新建了
一个草稿在第三方系统中。后面的节点难道不应该看的就是第一次返回的那个查看页面么?"
链路断在这儿(``check_embed_reopen.py`` 那一条修不了它,因为它整趟都是同一个人):
1. 发起页上点开那一格 → 后端为**发起人**开一趟会话,``url_mode=api`` 打一次对面那个
建页接口 → 第三方建了第一张草稿,OA 把拿到的那两条地址钉在这趟会话上;
2. 提交成单,单子走到审批环节,办理人是**另一个人**;
3. 审批人点开同一格 → :func:`embed_session.find_open` 的第一道条件就是
``EmbedSession.person == 当前这个人`` → 查不到 → 手上没有地址 →
:func:`embed.build_url` 只能再打一次那个接口 → **第三方那边第二张草稿**。
也就是说:对面那一页过去记在"哪个人的一趟"上,而它真正属于的是"哪一张单"。一张单在
第三方系统里就该只有一页,后面每一个环节、每一个来看的人都回到那一页;多出来的那几张
草稿既没人认领也没人删(``abandon`` 那几条腿只认发起页占下的号)。
修法是把"对面那一页"从会话里搬出来,单独记在**这张单**上
(``oa_embed_page``,按 ``(哪条源, 哪一格, 哪张单)`` 唯一):会话仍然是凭据与身份的载体
(每人一趟、各自的待办、各自的 scope),地址则整张单共用一份。判据落在格子那一档
``embed.reopen`` 的新默认值 ``share`` 上,翻回 ``same`` 就是原来的每人一趟。
钉这十二句,一句都对得上一种看得见的坏法:
1. 第一次打开确实建了一页(对面页号 = 1),拿回的是编辑页;
2. 提交之后发起人再点开,还是那一页,一次接口都没多打;
3. **换一个人(后一环节审批人)点开,还是那一页**——用户要的就是这一句;
4. 审批人拿的是**查看页**那一条地址,不是发起人的编辑页;
5. 换人仍然新开一趟会话:预受理号是他自己的,``decide`` 判的是他自己那条待办,
共用一页不等于共用凭据;
6. 第三个、第四个人接着点开,一次接口都不打(会话条数随人涨,对面页号不涨);
7. 单子的参数值后来变了也**不重新建页**(对面那一页是按这张单建的,``{auto:…}`` 那种
每人不同的取值不能把这一档整个顶掉);
8. 环节往前走一环,还是那一页;
9. 这一页是谁在哪一环建起来的,库答复得出(界面那句灰字与排查都靠它);
10. 这一格翻回 ``reopen=same`` 之后,换人照旧各建一页——老口径得留在手边;
11. 翻成 ``reopen=new`` 照旧每开必新建;
12. 新开一张发起页不把这张单的那一页继承过来(否则新单会显示别人的草稿)。
跑完连自己造的源、会话、页面账、单据、流程与留痕一起删干净。
"""
from __future__ import annotations
import json
import pathlib
import sys
import threading
import time
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, func, 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.main import app # noqa: E402
from app.security import create_access_token # noqa: E402
from app.service import personref # noqa: E402
FIELD = "embed_shared_page"
#: 两条老口径的对照组:同一张单、同一条源,只换那一格上的 ``reopen``
FIELD_LEGACY = "embed_reopen_same"
FIELD_EVERY = "embed_reopen_new"
STAMP = datetime.now().strftime("%m%d%H%M%S")
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 PageServer(ThreadingHTTPServer):
"""建页接口的替身。``calls`` 是它被打了几次,``pages`` 是它建出过几张页。
对面那个接口真实形状就是"每调一次建一张新页",同一个号也照建不误——生产上那几张
没人认领的草稿就是这么来的。所以这一趟只认两件事:这个接口**被打了几次**,
以及回来的地址上那个 ``page=`` 是几号。
"""
daemon_threads = True
def __init__(self, handler: type[BaseHTTPRequestHandler]) -> None:
super().__init__(("127.0.0.1", 0), handler)
self.calls = 0
self.pages = 0
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 = ""
self.server.calls += 1 # type: ignore[attr-defined]
self.server.pages += 1 # type: ignore[attr-defined]
page = int(self.server.pages) # type: ignore[attr-defined]
base = f"http://127.0.0.1:{self.server.server_address[1]}/page"
body = json.dumps({"code": 0, "data": {
"url": f"{base}/edit?no={no}&page={page}",
"viewUrl": f"{base}/view?no={no}&page={page}",
}}).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_no(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) -> str:
"""``url_mode=api`` 那条源:地址由对面那个建页接口现给,编辑页与查看页一次回两条。"""
code = f"embed_share_{STAMP}"
response = client.post("/api/v1/design/data-sources", headers=headers, json={
"code": code, "name": "后续节点回同一页·ERP 建页接口", "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.url",
"viewUrlPath": "data.viewUrl", "urlOrigins": [f"http://127.0.0.1:{port}"],
"pageMode": "none",
})
return code if response.status_code < 400 else ""
def build_process(db, approver_refs: list[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_refs[0]]}]})
second = models.Activity(process=process.id, type="manual", name="分管领导", order_number=2,
form=form_id,
config={"mode": "any",
"taskValues": [{"type": "person", "data": [approver_refs[1]]}]})
end = models.Activity(process=process.id, type="end", name="结束", order_number=3)
db.add_all([begin, first, second, 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=second.id),
models.Route(process=process.id, name="通过", from_activity=second.id, to_activity=end.id),
])
db.commit()
return str(process.id)
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 launch(client: TestClient, headers: dict, code: str, field: str, **over) -> dict:
"""发一次「打开这一格」。``over`` 决定它是发起页那一路还是单据页那一路。"""
body = {"code": code, "field": field,
"embed": {"source": code, "params": {"contractNo": "{form.contractNo}"}, "height": 480}}
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 count_rows(db, model, code: str) -> int:
# 先收掉自己的事务:MySQL 默认可重复读,接口那边刚提交的行在这个连接上看不见
db.commit()
return int(db.execute(select(func.count()).select_from(model)
.where(model.source == code)).scalar() or 0)
def task_for(db, job: str, activity_name: str):
db.commit()
return db.execute(
select(models.Task).where(models.Task.job == job, models.Task.status == "pending",
models.Task.activity_name == activity_name).order_by(models.Task.id)
).scalars().first()
def approve(db, task, label: str) -> None:
"""由这条待办的主人把环节办过去(走引擎原来那条路,不开第二条通道)。"""
from app.engine import engine
person = db.get(models.User, int(task.person))
engine.execute_task(db, task_id=str(task.id),
actor=engine.Actor.from_ref(db, person, str(task.identity or "")),
route_name="通过", opinion=f"{label}同意")
db.commit()
def purge(db, code: 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))
if code:
if hasattr(models, "EmbedPage"):
db.execute(delete(models.EmbedPage).where(models.EmbedPage.source == code))
db.execute(delete(models.EmbedSession).where(models.EmbedSession.source == code))
db.execute(delete(models.EmbedTicket).where(models.EmbedTicket.source == code))
db.execute(delete(models.DataSourceLog).where(models.DataSourceLog.source == code))
db.execute(delete(models.DataSource).where(models.DataSource.code == code))
db.commit()
def main() -> int:
# ``TestClient(app)`` 不进 lifespan,启动那一步的自动建表不会跑(别的脚本不需要,
# 它们用的表本来就在库里)。这一张是这次新加的表,自己补一下,别让第一次跑的人
# 对着一句 "Table 'oa_embed_page' doesn't exist" 猜是不是代码写坏了
from app.db import engine as db_engine
models.EmbedPage.__table__.create(bind=db_engine, checkfirst=True)
db = SessionLocal()
starter = db.get(models.User, 1)
others = db.execute(
select(models.User).where(models.User.id != 1,
models.User.status == models.UserStatus.ACTIVE)
.order_by(models.User.id).limit(2)
).scalars().all()
if starter is None or len(others) < 2:
note("库里凑不齐「发起人 + 两个不同的审批人」,这一项校不了")
db.close()
return 0
server = PageServer(Handler)
threading.Thread(target=server.serve_forever, daemon=True).start()
port = int(server.server_address[1])
client = TestClient(app, raise_server_exceptions=False)
admin_headers = {"Authorization": f"Bearer {create_access_token(str(starter.id))[0]}"}
headers_of = {str(person.id): {"Authorization": f"Bearer {create_access_token(str(person.id))[0]}"}
for person in [starter, *others]}
code = process_id = form_id = ""
jobs: list[str] = []
try:
code = make_source(client, admin_headers, port)
check("建成了这条「地址由建页接口现给」的源", bool(code), code)
if not code:
return 1
form_id = build_form(db)
refs = [personref.ref_of(starter)] + [personref.ref_of(person) for person in others]
process_id = build_process(db, refs[1:3], form_id)
data = {"contractNo": f"HT-SHARE-{STAMP}"}
# --- 1. 发起页上点开那一格:对面建了第一张页 ---
start = launch(client, headers_of[str(starter.id)], code, FIELD,
process=process_id, params={"contractNo": data["contractNo"]})
first_page = page_no(start.get("url"))
prekey_creator = str((start.get("session") or {}).get("prekey") or "")
check("第一次打开确实让对面建了一页,给的是编辑页",
bool(first_page) and start.get("link") == "edit", start)
# --- 2. 提交成单,发起人再点开:还是那一页 ---
created = client.post("/api/v1/job", headers=admin_headers,
json={"process": process_id, "data": data,
"title": f"嵌入同页校验单 {STAMP}", "prekeys": [prekey_creator]})
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_id = str(body.get("work") or "")
jobs.append(job)
check("发起了一张真单据", bool(job) and bool(work_id), created.text[:160])
again = launch(client, admin_headers, code, FIELD, job=job)
check("提交之后发起人再点开,还是对面第一次建的那一页,一次接口都没多打",
page_no(again.get("url")) == first_page and server.calls == 1,
f"页号 {page_no(again.get('url'))} vs {first_page},接口被打 {server.calls} 次")
# --- 3. 换人:后一环节的审批人点开同一格 ---
task_a = task_for(db, job, "部门审批")
check("单子走到了第一个审批环节", task_a is not None, job)
if task_a is None:
return 1
approver_a = str(task_a.person)
before = server.calls
view_a = launch(client, headers_of[approver_a], code, FIELD, job=job)
check("**换一个审批人点开,看的还是那一页**:一次接口都没打,对面没多一张草稿",
page_no(view_a.get("url")) == first_page and server.calls == before,
f"页号 {page_no(view_a.get('url'))} vs {first_page},接口 {before} → {server.calls}")
check("审批人拿的是查看页那一条地址,不是发起人的编辑页",
view_a.get("link") == "view" and "/view?" in str(view_a.get("url")), view_a)
check("界面因此说得出「这一条是沿用之前的」", view_a.get("linkReused") is True, view_a)
prekey_a = str((view_a.get("session") or {}).get("prekey") or "")
check("换人仍然新开一趟:预受理号是他自己的(共用一页不等于共用凭据)",
bool(prekey_a) and prekey_a != prekey_creator, f"{prekey_a} vs {prekey_creator}")
sessions = count_rows(db, models.EmbedSession, code)
pages_rows = count_rows(db, models.EmbedPage, code) if hasattr(models, "EmbedPage") else 0
check("会话跟着人涨(每人一趟),对面那一页始终只有一条账",
sessions >= 2 and pages_rows == 1, f"会话 {sessions} 条 / 页面账 {pages_rows} 条")
db.commit()
page_row = db.execute(select(models.EmbedPage)
.where(models.EmbedPage.source == code)).scalars().first() \
if hasattr(models, "EmbedPage") else None
check("这一页是谁在哪一环建起来的,库答复得出(界面那句灰字靠它)",
page_row is not None and str(page_row.work or "") == work_id
and str(page_row.job or "") == job and str(page_row.person or "") == "1",
None if page_row is None else (page_row.work, page_row.job, page_row.person))
# --- 4. 单子的值后来变了:不重新建页 ---
work = db.execute(select(models.Work).where(models.Work.job == job)).scalar_one_or_none()
if work is not None:
work.data = {**(work.data or {}), "contractNo": f"HT-SHARE-{STAMP}-B"}
db.commit()
before = server.calls
changed = launch(client, headers_of[approver_a], code, FIELD, job=job)
check("单子的参数值变了也不重新建页(对面那一页是按这张单建的)",
page_no(changed.get("url")) == first_page and server.calls == before,
f"页号 {page_no(changed.get('url'))},接口 {before} → {server.calls}")
# --- 5. 环节往前走 ---
approve(db, task_a, "部门审批")
task_b = task_for(db, job, "分管领导")
check("单子走到了第二个审批环节", task_b is not None, job)
if task_b is None:
return 1
approver_b = str(task_b.person)
before = server.calls
view_b = launch(client, headers_of[approver_b], code, FIELD, job=job)
check("再往后一个节点、再换一个人,看的还是那一页",
page_no(view_b.get("url")) == first_page and server.calls == before,
f"页号 {page_no(view_b.get('url'))},接口 {before} → {server.calls}")
# --- 6. 两条老口径的对照组 ---
# 对照组共用那一格的配置,只有 ``reopen`` 这一档不一样
cfg = {"source": code, "params": {"contractNo": "{form.contractNo}"}, "height": 480}
legacy_creator = launch(client, admin_headers, code, FIELD_LEGACY, job=job,
embed={**cfg, "reopen": "same"})
before = server.calls
legacy_approver = launch(client, headers_of[approver_b], code, FIELD_LEGACY, job=job,
embed={**cfg, "reopen": "same"})
check("这一格翻回 ``reopen=same`` 就照旧每人一趟:换人另建一页(老口径留在手边)",
server.calls == before + 1
and page_no(legacy_approver.get("url")) != page_no(legacy_creator.get("url")),
f"接口 {before} → {server.calls}")
before = server.calls
launch(client, admin_headers, code, FIELD_EVERY, job=job, embed={**cfg, "reopen": "new"})
every = launch(client, admin_headers, code, FIELD_EVERY, job=job,
embed={**cfg, "reopen": "new"})
check("翻成 ``reopen=new`` 照旧每开必新建一页",
server.calls == before + 2 and every.get("linkReused") is False,
f"接口 {before} → {server.calls}")
# --- 7. 新开一张发起页不许继承这张单的那一页 ---
fresh = launch(client, admin_headers, code, FIELD, process=process_id,
params={"contractNo": f"HT-SHARE-{STAMP}-C"},
serial=f"SER-SHARE-{STAMP}")
check("新开一张发起页是新的一趟:不把这张单在对面那一页继承过来",
str((fresh.get("session") or {}).get("prekey") or "") != prekey_creator
and page_no(fresh.get("url")) != first_page,
f"{(fresh.get('session') or {}).get('prekey')} 页号 {page_no(fresh.get('url'))}")
return finish()
finally:
server.shutdown()
purge(db, code, 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())