571 lines
33 KiB
Python
571 lines
33 KiB
Python
#!/usr/bin/env python3
|
||
"""第三方回写一句"我们这边审完了",OA 这边到底有没有真的把那条待办办掉。
|
||
|
||
PYTHONPATH=. python3 scripts/check_embed_decide.py
|
||
|
||
``check_embed_api.py`` 那一段只能验到"该挡的挡住了"(发起页上没有待办,回写结论必然被挡),
|
||
而这个问题真正的答案在**有一条真待办**的时候。所以这里在库里跑一张真流程,
|
||
按那个人手上那条待办开一趟嵌入会话,然后拿会话令牌调 ``POST /embed/callback``,
|
||
看的是引擎那本账:待办有没有进已办、走的出口是不是这一环真实存在的那一条。
|
||
|
||
钉这五件事,每一件都对应一种"两边日志都写着成功、单子却走错了"的失效:
|
||
|
||
1. **以打开这一页的那个人身份真的办掉了**:已办那条的办理人就是他,不是管理员、不是系统;
|
||
2. **出口由 OA 匹**:只给 ``agree``(甚至给的是他们自己那套 ``APPROVED``),
|
||
OA 按这一环真实存在的出口翻,配了对照表就不必逼对方改库里的枚举;
|
||
3. **走的是引擎原来那条路**:环节字段权限、必填那些校验一条都没因为"来的不是浏览器"少跑,
|
||
所以出口匹错、必填没齐时回的是那句人话,不是半个实例;
|
||
4. **被人先办掉了回 200 + already**:两个入口同时办是同意的正常结局,报成失败只会让对方重试;
|
||
5. **回写不重新排号也不新建单**:跑完这一趟,库里那张单还是原来那一张。
|
||
|
||
跑完连自己造的源、会话、单据一起删干净(清场口径照 ``check_write_payload.py``)。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import sys
|
||
import time
|
||
from datetime import datetime
|
||
|
||
from sqlalchemy import delete, 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
|
||
from app.service import embed, embed_session, tasktrail
|
||
|
||
#: 要驱动的那张流程与一份能过必填校验的表单(与 ``check_write_payload.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"}],
|
||
}
|
||
|
||
SHARED_KEY = "check-embed-decide-key"
|
||
#: 对方那一套状态词。这里故意用他们的写法,验的是"配了对照表之后不必逼对方改枚举"
|
||
THEIR_AGREE = "APPROVED"
|
||
FIELD_CFG = {
|
||
"height": 480,
|
||
"writeback": {"enabled": True, "fields": ["loanReason"]},
|
||
"actions": {"enabled": True, "allow": ["decide"], "decisions": {THEIR_AGREE.lower(): "agree"}},
|
||
}
|
||
|
||
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 make_source(client: TestClient, headers: dict) -> str:
|
||
"""建一条这一趟专用的 embed 源(配了密钥 + 免登短码,这两样缺一样就拿不到 decide)。"""
|
||
code = f"embed_decide_{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/approve?no={arg.no}",
|
||
"pageMode": "ticket", "authSecret": SHARED_KEY,
|
||
})
|
||
if response.status_code >= 400:
|
||
return ""
|
||
return code
|
||
|
||
|
||
def first_actionable_task(db, job: str):
|
||
"""这张单上**这一环有出口**的那条待办:回写结论要落的就是它。
|
||
|
||
创建环节那种"没有出口"的环节跳过——落在那儿只能验一句报错,而这一趟要验的是真办成。
|
||
"""
|
||
from app.engine import definition as definition_module
|
||
|
||
work = db.execute(select(models.Work).where(models.Work.job == job)).scalar_one_or_none()
|
||
if work is None:
|
||
return None, None, None
|
||
try:
|
||
definition = definition_module.load(db, work.process)
|
||
except ValueError:
|
||
return work, None, None
|
||
for task in db.execute(
|
||
select(models.Task).where(models.Task.job == job, models.Task.status == "pending")
|
||
.order_by(models.Task.id)
|
||
).scalars():
|
||
names = [str(item.name or "").strip() for item in definition.routes_from(task.activity)]
|
||
names = [item for item in names if item]
|
||
if names:
|
||
return work, task, names
|
||
return work, None, None
|
||
|
||
|
||
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:
|
||
print(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}"
|
||
second_title = f"回写办待办校验单二号 {stamp}"
|
||
code = ""
|
||
jobs: list[str] = []
|
||
try:
|
||
code = make_source(client, headers)
|
||
check("建成了这条专用的 embed 源", bool(code), code)
|
||
if not code:
|
||
return 1
|
||
|
||
created = client.post("/api/v1/job", headers=headers,
|
||
json={"process": process.id, "data": DATA, "title": title})
|
||
if created.status_code >= 400:
|
||
print(f"[跳过] 发起这张流程没成功({created.status_code}):{created.text[:160]}")
|
||
return 0
|
||
body = created.json().get("data") or {}
|
||
job = str(body.get("job") or "")
|
||
jobs.append(job)
|
||
check("发起了一张真单据", bool(job), job)
|
||
|
||
db.rollback()
|
||
work, task, routes = first_actionable_task(db, job)
|
||
if task is None:
|
||
print("[跳过] 这张单上没有「这一环有出口」的待办(流程定义变了?),这一项校不了")
|
||
return 0
|
||
check("找到一条可以回写的待办", True,
|
||
f"{task.activity_name} / 出口 {routes} / 处理人 {task.person}")
|
||
# 待办办掉之后那一行会被删掉,所以这里全部先摘成字符串,后面别再碰这个 ORM 对象
|
||
task_id = str(task.id)
|
||
task_person = str(task.person)
|
||
task_activity = str(task.activity)
|
||
task_activity_name = str(task.activity_name)
|
||
work_id = str(work.id)
|
||
|
||
row = db.execute(select(models.DataSource).where(models.DataSource.code == code)).scalar_one_or_none()
|
||
field = {"key": "approve_page", "embed": FIELD_CFG}
|
||
session, secret = embed_session.open_session(
|
||
db, row=row, field_key="approve_page", field=field,
|
||
person=task_person, work=work_id, job=job, activity=task_activity,
|
||
task=db.get(models.Task, task_id), targets=["loanReason"], decisions=embed.decision_map_of(field),
|
||
)
|
||
db.commit()
|
||
check("这一趟开放了「提交本环节」这一档", "decide" in list(session.scopes or []),
|
||
session.scopes)
|
||
|
||
key_header = {"X-Oa-Integration-Key": SHARED_KEY}
|
||
base = {"code": code, "token": secret, "kind": "decide"}
|
||
|
||
# 去重那一档先关掉:这一趟紧接着要验"已被人办掉"那一句,而不是"刚刚回写过一次"
|
||
window = embed_session.dedupe_window()
|
||
embed_session.dedupe_window = lambda: 0 # type: ignore[assignment]
|
||
|
||
wrong = client.post("/api/v1/embed/callback",
|
||
json=dict(base, decision=THEIR_AGREE),
|
||
headers={"X-Oa-Integration-Key": "the-wrong-key"})
|
||
check("密钥不对时办不掉这条待办", wrong.status_code == 400, wrong.text[:160])
|
||
pending_after = db.execute(select(models.Task).where(models.Task.id == task_id)).scalar_one_or_none()
|
||
check("被挡住的那一次什么都没改(待办还在)", pending_after is not None, task_id)
|
||
|
||
# 关键一步:对方回的是**他们自己那个词**,OA 按这一格配的对照表翻成"同意"
|
||
done = client.post("/api/v1/embed/callback",
|
||
json=dict(base, decision=THEIR_AGREE, opinion="ERP 那边已核验"),
|
||
headers=key_header)
|
||
payload = (done.json() or {}).get("data") or {}
|
||
check(f"用他们那个词({THEIR_AGREE})也把待办办掉了",
|
||
done.status_code == 200 and payload.get("handled") is True,
|
||
f"{done.status_code} {str(done.text)[:200]}")
|
||
check(f"走的是这一环真实存在的那条出口({routes})",
|
||
str(payload.get("route") or "") in routes, f"实得 {payload.get('route')},候选 {routes}")
|
||
|
||
db.rollback()
|
||
completed = db.execute(
|
||
select(models.TaskCompleted).where(models.TaskCompleted.task == task_id)
|
||
).scalars().first()
|
||
check("引擎那本账真的记上了(待办进了已办)", completed is not None, task_id)
|
||
check("以打开这一页的那个人身份办的,不是管理员也不是系统",
|
||
completed is not None and str(completed.person) == task_person,
|
||
getattr(completed, "person", None))
|
||
check("意见按对方回的那句记下",
|
||
completed is not None and "ERP 那边已核验" in str(getattr(completed, "opinion", "")),
|
||
getattr(completed, "opinion", None))
|
||
# 办完最后一环时实例会被搬进归档表并删掉,所以运行中与归档两边都找一遍
|
||
check("那张单还是原来那一张(回写不新建、不重新排号)",
|
||
tasktrail.work_of(db, work_id) is not None, job)
|
||
|
||
# 再回一次:这条待办已经没了,必须回 200 + already,而不是"失败"让对方重试
|
||
again = client.post("/api/v1/embed/callback",
|
||
json=dict(base, decision=THEIR_AGREE), headers=key_header)
|
||
second = (again.json() or {}).get("data") or {}
|
||
check("同一条待办回第二次回的是 200 + 已被办掉,不是失败",
|
||
again.status_code == 200 and second.get("already") is True,
|
||
f"{again.status_code} {str(again.text)[:200]}")
|
||
check("那句话说了是谁在什么时候办掉的",
|
||
"办掉" in str(second.get("note") or ""), second.get("note"))
|
||
|
||
embed_session.dedupe_window = lambda: window # type: ignore[assignment]
|
||
|
||
# --- 反过来的那半个问题:这一趟是**人在 OA 里**发起的,第三方还能不能认出来 ---
|
||
# 发起页上铺着一格 ERP 页面(那一趟还没有单据),人最后是在 OA 点的「发起」。
|
||
# 这一刻必须把这张新单记回那一趟上,否则 ERP 再拿同一个预受理号调开放平台,
|
||
# 就会当"这一趟还没发起过"而再建一张——去重只挡单向等于没挡。
|
||
loose = embed_session.open_session(
|
||
db, row=row, field_key="start_page", field={
|
||
"key": "start_page", "embed": {"writeback": {"enabled": True, "fields": ["loanReason"]},
|
||
"actions": {"enabled": True, "allow": ["submit"]}}},
|
||
person=str(task_person),
|
||
)[0]
|
||
db.commit()
|
||
loose_prekey = str(loose.prekey)
|
||
ok_loose = "start" in list(loose.scopes or [])
|
||
check("发起页那一趟(还没有单据)开放了「发起这张单」", ok_loose, loose.scopes)
|
||
|
||
second = client.post("/api/v1/job", headers=headers, json={
|
||
"process": process.id, "data": DATA, "title": second_title, "prekeys": [loose_prekey]})
|
||
second_job = str(((second.json() or {}).get("data") or {}).get("job") or "")
|
||
jobs.append(second_job)
|
||
check("人在 OA 里发起了这一趟那张单", bool(second_job), str(second.text)[:160])
|
||
|
||
db.rollback()
|
||
claimed = embed_session.by_prekey(db, loose_prekey)
|
||
check("发起成功就把这张单记回那一趟上(第三方再拿同一个号来发就认得出是重复)",
|
||
claimed is not None and str(claimed.claim_job) == second_job,
|
||
getattr(claimed, "claim_job", None))
|
||
claim_serial = str(getattr(claimed, "claim_serial", "") or "")
|
||
check("记上之后这一趟仍然认得(状态是 claimed,不是查无此趟)",
|
||
embed_session.find_open(db, source=code, person=str(task_person),
|
||
field="start_page") is not None,
|
||
getattr(claimed, "status", None))
|
||
by_serial = embed_session.find_open(db, source=code, person=str(task_person),
|
||
field="start_page", serial=claim_serial)
|
||
check("按这一趟自己那个流程编号也问得到这一趟:正在开着的页面就靠这一路听见「已经发起了」",
|
||
by_serial is not None and str(by_serial.prekey) == loose_prekey,
|
||
f"{getattr(by_serial, 'prekey', None)} 号 {claim_serial}")
|
||
reopened = embed_session.open_session(
|
||
db, row=row, field_key="start_page",
|
||
field={"key": "start_page", "embed": {"actions": {"enabled": True, "allow": ["submit"]}}},
|
||
person=str(task_person))[0]
|
||
db.commit()
|
||
check("新开的那一页不再捡这一趟的账:那一趟已经发起了,捡回来就是凭空一句「已经在外部系统发起(单号 上一张)」",
|
||
str(reopened.prekey) != loose_prekey, f"{reopened.prekey} vs {loose_prekey}")
|
||
other = embed_session.find_open(db, source=code, person=str(task_person),
|
||
field="start_page", serial="SER-另一趟")
|
||
check("另一趟(另占了一个流程编号)问不到这一趟的账",
|
||
other is not None and str(other.claim_job) == "",
|
||
f"{getattr(other, 'prekey', None)} claim={getattr(other, 'claim_job', None)}")
|
||
check("去重按**趟**算,不按这个人在这一格上的一辈子:第三方拿原来那个预受理号照样认得回来",
|
||
str(getattr(embed_session.by_prekey(db, loose_prekey), "claim_job", "")) == second_job,
|
||
loose_prekey)
|
||
|
||
# 这一格只勾了 decide,没勾 submit:回写"发起这张单"要能被能力清单挡下来
|
||
start_try = client.post("/api/v1/embed/callback",
|
||
json={"code": code, "token": secret, "kind": "start",
|
||
"job": "JOB_FROM_ERP_9"}, headers=key_header)
|
||
check("回写「已发起」仍然收得下(那一档不是动作清单管的,记的是同一趟的去重)",
|
||
start_try.status_code == 200, str(start_try.text)[:200])
|
||
# --- 再反过来的那半个问题:人没保存就返回,OA 得通知对方把它那张草稿删掉 ---
|
||
# 配法只有一处:那条「可嵌入页面」上说清楚往哪儿发(这里走的是"挑一条现成的
|
||
# 写回通道"那条路,费用报销接的就是这个形状)。表单那一格默认什么都不用勾。
|
||
# 外呼换成一份假记录(不打网络),看的是发出去那一句长什么样、幂等记不记得住、
|
||
# 以及什么情况下压根不该发——删错一张草稿比不删糟得多,所以"不发"那几条与
|
||
# "发对"那几条一样要紧。
|
||
sent: list[tuple[str, str, bytes, dict]] = []
|
||
|
||
def fake_request(method, url, payload, headers, timeout): # noqa: ANN001
|
||
sent.append((str(method), str(url), bytes(payload or b""), dict(headers or {})))
|
||
return 200, '{"code":0}'
|
||
|
||
channel_code = f"{code}_api"
|
||
made = client.post("/api/v1/design/data-sources", headers=headers, json={
|
||
"code": channel_code, "name": "回写校验·按 OA 单号删草稿", "system": "ERP",
|
||
"kind": "fetch", "provider": "http", "direction": "out", "method": "DELETE",
|
||
"url": "https://erp.invalid/api/loan/oa/by-flow-number",
|
||
"successPath": "code", "successValue": "0",
|
||
})
|
||
check("建成了那条写回通道(通知走它发)", made.status_code < 400, str(made.text)[:160])
|
||
|
||
# 那条通道是另一个会话提交进来的:这个会话此刻那份快照还看不见它,换一个事务再往下走
|
||
db.rollback()
|
||
row = db.execute(select(models.DataSource).where(models.DataSource.code == code)).scalar_one()
|
||
|
||
real_request = embed_session.fetch.http_request
|
||
embed_session.fetch.http_request = fake_request # type: ignore[assignment]
|
||
try:
|
||
silent = {"key": "start_page3", "embed": {}} # 那一格没表态
|
||
refused = {"key": "start_page4", "embed": {"abandon": {"enabled": False}}}
|
||
row.abandon_source = channel_code
|
||
db.flush()
|
||
fresh = embed_session.open_session(
|
||
db, row=row, field_key="start_page3", field=silent,
|
||
person=str(task_person), serial="PREABANDON9X",
|
||
abandon=embed.abandon_of(silent, row, db))[0]
|
||
db.commit()
|
||
result = embed_session.apply_abandon(db, fresh, reason="leave")
|
||
db.commit()
|
||
check("那一格什么都没勾也发得出去(源上配了就走源,默认不用每张单来勾)",
|
||
result.get("status") == "ok" and bool(sent), result)
|
||
check("走了那条写回通道:地址与方法照它",
|
||
bool(sent) and sent[0][0] == "DELETE"
|
||
and sent[0][1] == "https://erp.invalid/api/loan/oa/by-flow-number", sent[:1])
|
||
check("请求体就一个键,值是这一趟预留的 OA 单号",
|
||
bool(sent) and json.loads(sent[0][2] or b"{}") == {"oa_flow_number": "PREABANDON9X"},
|
||
sent[:1])
|
||
check("那一句不是裸着发的:拿双方共用的那把密钥当凭证",
|
||
bool(sent) and sent[0][3].get(embed_session.INTEGRATION_KEY_HEADER) == SHARED_KEY,
|
||
sent[:1] and sent[0][3])
|
||
twice = embed_session.apply_abandon(db, fresh, reason="leave")
|
||
check("同一趟报第二次不再发(幂等记在这一趟上,那一腿两处报前后脚到是常态)",
|
||
twice.get("status") == "done" and len(sent) == 1, twice)
|
||
|
||
quiet = embed_session.open_session(
|
||
db, row=row, field_key="start_page4", field=refused,
|
||
person=str(task_person), abandon=embed.abandon_of(refused, row, db))[0]
|
||
db.commit()
|
||
noop = embed_session.apply_abandon(db, quiet, reason="leave")
|
||
check("那一格说不发就不发(源上配好了也不算数)",
|
||
noop.get("status") == "noop" and len(sent) == 1, noop)
|
||
|
||
# 那一格后来要发了,而这一趟早就变成一张单了:快照即使换成"要发"的那一份,
|
||
# 该说的还是"这一趟留下了东西,不许删"。这里直接写快照而不再"重开同一格"——
|
||
# 认领走的那一趟已经翻篇,新开的一页不会再回来刷新它(见 find_open 那段),
|
||
# 真在路上的是还开着的那一页,它手上本来就有这一趟
|
||
hungry = {"key": "start_page", "embed": {"abandon": True}}
|
||
claimed = embed_session.by_prekey(db, loose_prekey)
|
||
if claimed is not None:
|
||
claimed.result = {**(claimed.result or {}),
|
||
embed_session.ABANDON_CFG_KEY: embed.abandon_of(hungry, row, db)}
|
||
db.commit()
|
||
skipped = embed_session.apply_abandon(db, claimed, reason="leave") if claimed else {}
|
||
check("这一趟已经变成一张单了就不删(那等于把人的单子删了)",
|
||
skipped.get("status") == "skipped" and len(sent) == 1, skipped)
|
||
|
||
# 老那六栏留在格子上的存量配置:源上撤干净之后,仍照快照里翻出来的那一份发
|
||
legacy_field = {"key": "start_page6", "embed": {"abandon": {
|
||
"enabled": True, "source": channel_code, "method": "DELETE",
|
||
"body": {"oa_flow_number": "{serial}"}, "missingOk": True}}}
|
||
legacy = embed_session.open_session(
|
||
db, row=row, field_key="start_page6", field=legacy_field,
|
||
person=str(task_person), serial="PREABANDON6X",
|
||
abandon=embed.abandon_of(legacy_field, row, db))[0]
|
||
db.commit()
|
||
old_shape = embed_session.apply_abandon(db, legacy, reason="leave")
|
||
check("上一版摆在格子上的那六栏存量配置不悄悄失效(这一趟照快照那份发出去了)",
|
||
old_shape.get("status") == "ok" and len(sent) == 2, old_shape)
|
||
check("那一版请求体里那个键名还认(照它发,不换成 OA 爱叫的名字)",
|
||
len(sent) > 1 and json.loads(sent[1][2] or b"{}") == {"oa_flow_number": "PREABANDON6X"},
|
||
sent[1:2])
|
||
|
||
# 值那一格配了取值写法:打开这一刻把表单上那个值算死记走,放弃那一刻照快照发,
|
||
# 而不是退回这一趟预留的单号——这是"用自己的流程编号去对面删"那一档的正路
|
||
row.abandon_expr = "{form.流程编号}"
|
||
db.flush()
|
||
valued = embed_session.open_session(
|
||
db, row=row, field_key="start_page8",
|
||
field={"key": "start_page8", "embed": {"abandon": True}},
|
||
person=str(task_person), serial="PREABANDON8X",
|
||
abandon=embed.abandon_of(
|
||
{"key": "start_page8", "embed": {"abandon": True}}, row, db,
|
||
data={"流程编号": "PC-CONFIG"}))[0]
|
||
db.commit()
|
||
valued_res = embed_session.apply_abandon(db, valued, reason="leave")
|
||
check("值照那一格配的取值写法发(读的是表单上的流程编号,不是预留单号)",
|
||
valued_res.get("status") == "ok"
|
||
and json.loads(sent[-1][2] or b"{}") == {"oa_flow_number": "PC-CONFIG"},
|
||
sent[-1:])
|
||
# 值也可以骑在地址上:按号删那类接口常把单号放进路径或查询串。地址里写 {value}
|
||
# 就把算好的那个值填进去;没写 {value} 就原样发,与只走请求体的旧行为不冲突
|
||
row.abandon_source = ""
|
||
row.abandon_url = "https://erp.invalid/api/drafts/{value}"
|
||
row.abandon_expr = "{form.流程编号}"
|
||
db.flush()
|
||
urled = embed_session.open_session(
|
||
db, row=row, field_key="start_page9",
|
||
field={"key": "start_page9", "embed": {"abandon": True}},
|
||
person=str(task_person), serial="PREABANDON9X",
|
||
abandon=embed.abandon_of(
|
||
{"key": "start_page9", "embed": {"abandon": True}}, row, db,
|
||
data={"流程编号": "PC-URL"}))[0]
|
||
db.commit()
|
||
urled_res = embed_session.apply_abandon(db, urled, reason="leave")
|
||
check("值骑在地址上:{value} 被填成算好的那个值",
|
||
urled_res.get("status") == "ok"
|
||
and sent[-1][1] == "https://erp.invalid/api/drafts/PC-URL",
|
||
sent[-1:])
|
||
row.abandon_url = ""
|
||
row.abandon_expr = ""
|
||
db.flush()
|
||
|
||
row.abandon_expr = ""
|
||
db.flush()
|
||
|
||
# 要按好几个字段去对面删(单号 + 项目号那种):配一份多键请求体,每个值各读一格格
|
||
# 表单上的值,打开那一刻逐个算死,放弃那一刻整份发出去——盖过单键那一档
|
||
row.abandon_source = ""
|
||
row.abandon_url = "https://erp.invalid/api/drafts/delete"
|
||
row.abandon_body = {"oa_flow_number": "{form.流程编号}", "project_number": "{form.项目号}"}
|
||
db.flush()
|
||
multi = embed_session.open_session(
|
||
db, row=row, field_key="start_page10",
|
||
field={"key": "start_page10", "embed": {"abandon": True}},
|
||
person=str(task_person), serial="PREABANDONAX",
|
||
abandon=embed.abandon_of(
|
||
{"key": "start_page10", "embed": {"abandon": True}}, row, db,
|
||
data={"流程编号": "PC-MK", "项目号": "PJ-7"}))[0]
|
||
db.commit()
|
||
multi_res = embed_session.apply_abandon(db, multi, reason="leave")
|
||
check("多键请求体整份发出去,每个值照那一格格表单算出来的",
|
||
multi_res.get("status") == "ok"
|
||
and json.loads(sent[-1][2] or b"{}")
|
||
== {"oa_flow_number": "PC-MK", "project_number": "PJ-7"},
|
||
sent[-1:])
|
||
check("多键那一档地址原样发(没写 {value}/{键名} 就不动它)",
|
||
sent[-1][1] == "https://erp.invalid/api/drafts/delete", sent[-1:2])
|
||
row.abandon_url = ""
|
||
row.abandon_body = {}
|
||
db.flush()
|
||
|
||
# 「这一页被放弃时通知对方」的另一条腿:存了草稿的人去草稿箱里把那份草稿真删了。
|
||
# 这一趟会一直挂着草稿——页面放弃那一路(apply_abandon)被 _abandon_skip 故意拦下,
|
||
# 那一刻不发是对的(对面那张草稿还在用);轮到草稿删除这一腿才发,发的是草稿上
|
||
# 那个号,不是会话的预受理号
|
||
row.abandon_source = ""
|
||
row.abandon_url = "https://erp.invalid/api/drafts/by-draft-serial"
|
||
db.flush()
|
||
tied_draft = models.Draft(id="DRAFTABANDON1", title="放弃校验草稿",
|
||
process="备用金申请流程", person=str(task_person),
|
||
serial="DRAFTABANDON9X", person_name="校验",
|
||
identity="", unit="")
|
||
db.add(tied_draft)
|
||
db.flush()
|
||
tied = embed_session.open_session(
|
||
db, row=row, field_key="start_page11",
|
||
field={"key": "start_page11", "embed": {"abandon": True}},
|
||
person=str(task_person), draft=tied_draft.id, serial=tied_draft.serial,
|
||
abandon=embed.abandon_of(
|
||
{"key": "start_page11", "embed": {"abandon": True}}, row, db))[0]
|
||
db.commit()
|
||
tied_skip = embed_session.apply_abandon(db, tied, reason="leave")
|
||
check("这一趟挂着草稿时页面放弃那一腿不发(对面那张草稿还在用)",
|
||
tied_skip.get("status") == "skipped" and len(sent) == 5, tied_skip)
|
||
del_res = embed_session.abandon_on_draft_deleted(db, tied_draft, actor=None)
|
||
db.commit()
|
||
check("草稿真删了的那刻通知对方也删,发出去的是草稿上那个号",
|
||
del_res.get("status") == "ok"
|
||
and json.loads(sent[-1][2] or b"{}") == {"oa_flow_number": "DRAFTABANDON9X"},
|
||
del_res)
|
||
check("账上那一句记着 draft-deleted(几条腿发的是同一本账,能分清是哪条腿)",
|
||
embed_session.abandon_record_of(tied).get("reason") == "draft-deleted"
|
||
and embed_session.abandon_record_of(tied).get("url")
|
||
== "https://erp.invalid/api/drafts/by-draft-serial",
|
||
embed_session.abandon_record_of(tied))
|
||
again = embed_session.abandon_on_draft_deleted(db, tied_draft, actor=None)
|
||
check("同一份草稿删两遍不重复发(幂等记在与会话同一本账上)",
|
||
again.get("status") == "done" and len(sent) == 6, again)
|
||
lone_draft = models.Draft(id="DRAFTABANDON2", title="放弃校验草稿(没会话)",
|
||
process="备用金申请流程", person=str(task_person),
|
||
serial="DRAFTABANDONLX", person_name="校验",
|
||
identity="", unit="")
|
||
db.add(lone_draft)
|
||
db.commit()
|
||
loose = embed_session.abandon_on_draft_deleted(db, lone_draft, actor=None)
|
||
check("没挂着打开会话的草稿不发(对面本来就没有那张草稿)",
|
||
loose.get("status") == "no-session" and len(sent) == 6, loose)
|
||
# 复用是常态:同一个人下一次打开发起页,这一趟还开着,会话被复用、重新占一个新号。
|
||
# 旧号那笔「已发」不能把新号吞了——对方按新号建的那张草稿是另一张
|
||
tied.draft = "" # 那份草稿已经删掉了(草稿删除那一腿已发完)
|
||
tied.serial = "DRAFTABANDON9Y" # 会话被下一趟复用,重新占的号
|
||
db.commit()
|
||
resent = embed_session.apply_abandon(db, tied, reason="discard")
|
||
db.commit()
|
||
check("会话被复用重新占号后再放弃,照样发(账本按号记,不按会话记)",
|
||
resent.get("status") == "ok"
|
||
and json.loads(sent[-1][2] or b"{}") == {"oa_flow_number": "DRAFTABANDON9Y"},
|
||
resent)
|
||
check("账本里也记着这个号(下一趟同号的重复报告才被挡)",
|
||
embed_session.abandon_record_of(tied).get("serial") == "DRAFTABANDON9Y"
|
||
and embed_session.abandon_record_of(tied).get("reason") == "discard",
|
||
embed_session.abandon_record_of(tied))
|
||
resent2 = embed_session.apply_abandon(db, tied, reason="discard")
|
||
check("同一个号重复报还是只发一次",
|
||
resent2.get("status") == "done" and len(sent) == 7, resent2)
|
||
row.abandon_url = ""
|
||
db.flush()
|
||
|
||
# 源上那条通道撤掉、快照里也只剩开关:这一档立刻发不出去,而且要说是为什么
|
||
row.abandon_source = ""
|
||
db.flush()
|
||
bare = embed_session.open_session(
|
||
db, row=row, field_key="start_page7",
|
||
field={"key": "start_page7", "embed": {"abandon": True}},
|
||
person=str(task_person), abandon={"enabled": True})[0]
|
||
db.commit()
|
||
missing = embed_session.apply_abandon(db, bare, reason="leave")
|
||
check("那条源上两样都没配时不发,而且说得清是没配",
|
||
missing.get("status") == "failed" and "还没配" in str(missing.get("note") or ""),
|
||
missing)
|
||
finally:
|
||
embed_session.fetch.http_request = real_request # type: ignore[assignment]
|
||
finally:
|
||
purge(db, jobs, [title, second_title], [code, f"{code}_api"],
|
||
["DRAFTABANDON1", "DRAFTABANDON2"])
|
||
db.close()
|
||
|
||
for line in FAILS:
|
||
print(f"[FAIL] {line}")
|
||
if FAILS:
|
||
print(f"共 {len(FAILS)} 条不对")
|
||
return 1
|
||
print(f"通过:第三方那句「审完了」在 OA 这边真的落到了一条真实待办上({PASSED} 项)")
|
||
return 0
|
||
|
||
|
||
def purge(db, jobs: list[str], titles: list[str], codes: list[str],
|
||
draft_ids: list[str] | None = None) -> None:
|
||
"""删掉自己造的那张单与那条源:按 job / 标题 / 编码精确删,别的单据一律不碰。"""
|
||
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 draft_ids:
|
||
db.execute(delete(models.Draft).where(models.Draft.id.in_(draft_ids)))
|
||
if codes:
|
||
# 源、会话、短码、留痕四张表都按那一条编码删;会话漏删的话,
|
||
# 下一趟会认到旧预受理号上(同 check_embed_api.py 的 sweep 那一段)
|
||
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()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|