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