unis-oa/backend/scripts/check_embed_decide.py

571 lines
33 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
"""第三方回写一句"我们这边审完了",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())