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