diff --git a/.env.example b/.env.example index 340165e..c0a2e27 100644 --- a/.env.example +++ b/.env.example @@ -116,6 +116,20 @@ TAILSCALE_API_KEY=请填写Tailscale_API_key # ⚠ 必须大于「应用管理」里最大的 APK（实测有 336MB 的包），否则 APK 上传会被一起卡死。 # MAX_UPLOAD_MB=2048 +# ==================== 发布计划：抖音「我」页面上的控件（抓一次填这里） ==================== +# 发布任务按**名字**发（名字 = 抖音昵称），所以平台要知道"名字在屏幕上哪个控件里"。 +# 用「抓取元素」抓一次抖音「我」页面上的**昵称**（那个 TextView），填到下面。 +# 一处配置、三处一致：任务骨架的「读取本机账号名字」步骤默认值、切号后的回读校验、 +# 以及「发布计划 → 一键推送（按名字找设备）」的实时探测。 +# 留空 = 还没抓：相关步骤会明确报错并跳过，**绝不会猜一个名字去发**。 +# DOUYIN_NAME_SELECTOR_TYPE=xpath +# DOUYIN_NAME_SELECTOR_VALUE= + +# 「我」页面 →「切换账号」列表那个入口（自动切号用，同样抓一次填这里）。 +# 留空 = 「切换账号」步骤会明确报错并跳过（不会瞎点）。 +# DOUYIN_SWITCH_SELECTOR_TYPE=xpath +# DOUYIN_SWITCH_SELECTOR_VALUE= + # ============================================================================== # 已废弃的历史配置（STF 已从代码层摘除，下列键代码不再使用，保留仅为兼容旧 .env） diff --git a/README.md b/README.md index 8100149..08aaa42 100644 --- a/README.md +++ b/README.md @@ -53,8 +53,7 @@ | **动作配置 / 录制** | 「任务 → 动作配置」：① 配**步骤默认值**（新建步骤预填：滑动时长/幅度/抖动/拟人、点击超时、等待区间…）② **录制动作**——在设备画面上点/划/按键，自动翻译成步骤（点元素记选择器、划一下记方向/幅度/时长），可存成可复用动作，也可只取一个手势回填滑动步骤 | | **公共巡检** | 任务级的守护条件（**独立于步骤画布**）：每 N 秒检查屏幕亮/熄、元素在不在、前台是不是某 App，命中就点亮/息屏/停本设备/推通知——通知标题正文自己写（见 [TASK_DEV.md](doc/TASK_DEV.md) §4.5） | | **去重账本** | 解决"**同一个号被做两次、有的号还没做**"：任务里用「条件判断→去重」+「记为已做」，把"这个身份做过了"记进一张**所有设备共享**的账本——多台手机、反复重跑都不会重复做同一个号。「任务 → 去重记录」页能看"谁做过了、还差谁"，也能删记录让它重跑（见 [TASK_DEV.md](doc/TASK_DEV.md) §4.6） | -| **账号台账** | 「账号」页维护"**哪台设备上登着哪些号**"（设备号/手机号/账号名/抖音号/注册时间/卡在机内/可发视频/简介/备注）：支持**从 Excel 粘贴批量导入**（表头识别、逐行结果、先预览后写入）。三个用处：① 任务的「条件判断」**直接从这里取号**，不用把几十个号手写进比对值；② 手机端 Agent 的**身份大字页**显示本机账号；③ 设备池里一眼看到每台登记了几个号（见 [DATA_MODEL.md](doc/DATA_MODEL.md) §2.10、[TASK_DEV.md](doc/TASK_DEV.md) §4.2） | -| **视频发布计划** | 「账号 → 发布计划」页：批量上传视频（文件名 `手机号_日期_编号`）与标题 txt → 自动按 (手机号,日期,编号) 配对到台账账号 → **按日期的时间线**看每天谁要发、发到哪一步。**平台只负责把素材推到手机**（推到 `/sdcard/DCIM/rp/`、触发相册刷新、把标题写进剪贴板），**抖音里怎么发由你自己在任务里写步骤**（步骤顺序：`推送发布视频` → 你的发布步骤 → `标记发布结果`；「发布计划」页顶部有**「发布任务」**块可一键建好骨架 + 看下次运行/启停，`输入文字` 那一步可以选**取值来源＝计划标题**自动填文案并回读校验）；发完可抓作品的**分享链接**存下来（平台不长期囤视频，链接才是长期资产，也方便后续铺评论：可一键复制、按日期/账号导出 CSV）。状态区分"**可重试**"（推送阶段失败，还没到抖音）与"**结果未知、需人工确认**"（推送之后出的岔子，绝不自动重发）（见 [DATA_MODEL.md](doc/DATA_MODEL.md) §2.11、[TASK_DEV.md](doc/TASK_DEV.md) §4.7） | +| **视频发布计划** | 「发布计划」页：批量上传视频（文件名 `名字_日期_编号`，**名字 = 抖音昵称**）与标题 txt（每行 `标题 || 正文_名字_日期_编号`）→ 自动按 (名字,日期,编号) 配对 → **按日期的时间线**看每天谁要发、发到哪一步。**平台只负责把素材推到手机**（推到 `/sdcard/DCIM/Camera/`、触发相册刷新、把标题写进剪贴板），**抖音里怎么发由你自己在任务里写步骤**（步骤顺序：`读取本机账号名字` → `条件判断`校验 → `推送发布视频` → 你的发布步骤 → `标记发布结果`；页顶部有**「发布任务」**块可一键建好骨架 + 看下次运行/启停，`输入文字` 那一步可以选**取值来源＝计划标题/正文**自动填文案并回读校验）；发完可抓作品的**分享链接**存下来（平台不长期囤视频，链接才是长期资产，也方便后续铺评论：可一键复制、按日期/名字导出 CSV）。状态区分"**可重试**"（推送阶段失败，还没到抖音）与"**结果未知、需人工确认**"（推送之后出的岔子，绝不自动重发）（见 [DATA_MODEL.md](doc/DATA_MODEL.md) §2.11、[TASK_DEV.md](doc/TASK_DEV.md) §4.7） | | **元素抓取** | 拉取设备 UI 元素树 → 点选回填选择器；支持"点一下"与"测选择器"真机验证 | | **实时看屏** | MJPEG 实时流 + 点击/滑动/按键/文字输入；全屏监控大屏（`/wall`） | | **应用管理** | APK 上传/解析/批量安装；设备已装应用与版本查询；剪贴板注入 | @@ -135,14 +134,14 @@ auto_control/ │ ├── core/ # 基础设施层 │ ├── models.py # SQLAlchemy 模型 + 建表 + 版本化迁移 + 旧 JSON 迁移 -│ ├── device_pool.py # 设备池（清单/在线状态/型号） +│ ├── device_pool.py # 设备池（清单/在线状态/型号/设备名→当前地址） │ ├── device_worker.py # BaseWorker + 设备生命周期 + 心跳看门狗 + 全局状态表 │ ├── task_manager.py # 调度器：分组/任务/APScheduler/重试/运行控制 │ ├── adb_helper.py # adb 命令封装（全局锁，红线：绝不 kill-server） │ ├── device_discovery.py # 网段扫描发现设备 → 待连接池 │ ├── device_battery.py # 设备电量采集（dumpsys 只读）+ 低电量告警 -│ ├── ledger.py # 账号台账（CRUD / 表格粘贴解析 / 给任务取号 / 设备端账号块） │ ├── video_plan.py # 视频发布计划（文件名解析配对 / 时间线 / 幂等占位 / 素材清理） +│ ├── account_probe.py # 实时探测设备当前登录的抖音号（按名字找设备用） │ ├── u2_helper.py # uiautomator2 通用辅助（等首页/安全点击等） │ ├── uiauto_helper.py # uiautodev 客户端（元素树 + XPath 建议） │ ├── ocr.py # 屏幕 OCR（RapidOCR，条件判断用） diff --git a/config.py b/config.py index 8e1e570..4dbb582 100644 --- a/config.py +++ b/config.py @@ -91,6 +91,20 @@ APK_DIR = os.path.join(DATA_DIR, "apks") # 自动化测试必须把素材目录指到临时位置，否则测试上传的视频会落进用户真实数据目录。 VIDEO_DIR = _env("DATA_VIDEO_DIR", "") or os.path.join(DATA_DIR, "videos") +# ================== 抖音「我」页面的昵称控件（发布计划按名字发） ================== +# **抓一次填这里**（用「抓取元素」抓抖音「我」页面上的昵称那个 TextView）。 +# 一处配置、三处一致：发布任务骨架的「读取本机账号名字」步骤默认值、 +# 「切换账号」的切后校验、以及「发布计划 → 一键推送（按名字找设备）」的实时探测。 +# 任务步骤里仍可单独改（存进那一步的参数），这里只是**默认值**。 +# 留空 = 还没抓：相关步骤会明确报"请抓取元素"，绝不会猜一个名字去发。 +DOUYIN_NAME_SELECTOR_TYPE = _env("DOUYIN_NAME_SELECTOR_TYPE", "xpath") +DOUYIN_NAME_SELECTOR_VALUE = _env("DOUYIN_NAME_SELECTOR_VALUE", "") + +# 「我」页面 →「切换账号」列表那个入口（同样是**抓一次填这里**）：自动切号要用。 +# 留空 = 「切换账号」步骤会明确报"请抓取元素"并跳过（不会瞎点）。 +DOUYIN_SWITCH_SELECTOR_TYPE = _env("DOUYIN_SWITCH_SELECTOR_TYPE", "xpath") +DOUYIN_SWITCH_SELECTOR_VALUE = _env("DOUYIN_SWITCH_SELECTOR_VALUE", "") + # 单次请求体上限（字节）。**必须大于现有 APK 上传的最大包**（实测 336MB）， # 否则「应用管理」的 APK 上传会被一起卡死。默认 2GiB：一个视频 + 余量。 MAX_CONTENT_LENGTH = int(_env("MAX_UPLOAD_MB", "2048")) * 1024 * 1024 diff --git a/core/account_probe.py b/core/account_probe.py new file mode 100644 index 0000000..cdc5d0d --- /dev/null +++ b/core/account_probe.py @@ -0,0 +1,158 @@ +"""实时探测"这台设备现在登的是哪个抖音号"（**按名字找设备**用）。 + +**谁用它**：人工入口 —— 「发布计划」页的「一键推送（按名字找设备）」要先知道 +"哪台在线设备现在登着这个名字"，才能把素材推过去。 +**自动任务不靠它**：任务里的「读取本机账号名字」永远是现场读屏幕（缓存旧了也不能影响发布正确性）。 + +它只做**只读/幂等**的动作：连设备 → 需要时把抖音拉到前台 → 点「我」→ 读昵称控件 → 清洗。 +**绝不登录、绝不滑块、绝不改设备设置**；连不上/读不到只报那一台，不影响别的设备。 +也绝不 `kill-server` / `disconnect`（技术约束红线）。 + +昵称控件在 `config.DOUYIN_NAME_SELECTOR_VALUE`（**抓一次填 .env**，与任务骨架同一处配置）； +没填就明确报"还没抓"，不去猜。 +""" +import time +from concurrent.futures import ThreadPoolExecutor + +from config import DOUYIN_NAME_SELECTOR_TYPE, DOUYIN_NAME_SELECTOR_VALUE +from core import u2_helper +from core.logger import get_logger + +_log = get_logger("core.account_probe") + +DOUYIN_PKG = "com.ss.android.ugc.aweme" +_CONNECT_TIMEOUT = 20 # u2.connect 超时（秒）；设备端 u2 服务没响应时别把请求挂死 +_STEP_WAIT = 2.5 # 进「我」页面后等它渲染完 + + +def _connect(serial, timeout=_CONNECT_TIMEOUT): + """带超时的 u2.connect。 + + ⚠ 用**手动 shutdown(wait=False)** —— `with ThreadPoolExecutor(...)` 退出时会 + `shutdown(wait=True)`，超时线程不死它就跟着等，30 秒的"超时"会变成真卡住 + （`core/device_worker` 里踩过这个坑）。 + """ + import uiautomator2 as u2 + pool = ThreadPoolExecutor(max_workers=1) + try: + return pool.submit(u2.connect, serial).result(timeout=timeout) + finally: + pool.shutdown(wait=False) + + +def probe_one(serial, click_me=True): + """读一台设备当前登录的抖音名字。返回 `{serial, name, error}`。 + + `name` 非空 = 读到了；`error` 非空 = 没读到（人话原因，给界面直接显示）。 + """ + if not DOUYIN_NAME_SELECTOR_VALUE: + return {"serial": serial, "name": "", + "error": "还没抓抖音昵称控件：在 .env 里填 DOUYIN_NAME_SELECTOR_VALUE" + "（抓取元素抓一下「我」页面上的昵称）"} + d = None + try: + d = _connect(serial) + except Exception as e: + return {"serial": serial, "name": "", + "error": f"连不上设备（u2 {_CONNECT_TIMEOUT}s 超时）：{type(e).__name__}"} + try: + pkg = u2_helper.current_package(d) + if pkg != DOUYIN_PKG: + # 不在抖音 → 拉到前台（幂等：已经在就什么都不做） + try: + d.app_start(DOUYIN_PKG, wait=True) + except Exception as e: + return {"serial": serial, "name": "", + "error": f"打不开抖音：{type(e).__name__}: {str(e)[:60]}"} + time.sleep(4) + if click_me: + u2_helper.find_and_click(d, timeout=3, + **{"descriptionContains": "我"}) + time.sleep(_STEP_WAIT) + from core import video_plan as vp + if DOUYIN_NAME_SELECTOR_TYPE == "xpath": + el = d.xpath(DOUYIN_NAME_SELECTOR_VALUE) + raw = el.get_text() if el.exists else "" + else: + el = d(**{DOUYIN_NAME_SELECTOR_TYPE: DOUYIN_NAME_SELECTOR_VALUE}) + raw = el.get_text(timeout=3) if el.exists(timeout=3) else "" + name = vp.clean_account_name(raw) + if not name: + return {"serial": serial, "name": "", + "error": f"读到空（元素原文 {raw!r}）—— 昵称控件的选择器可能抓错了"} + return {"serial": serial, "name": name, "error": ""} + except Exception as e: + return {"serial": serial, "name": "", + "error": f"读取失败：{type(e).__name__}: {str(e)[:80]}"} + finally: + # **不 disconnect、不 kill-server**（红线）：u2 的连接自己会超时回收 + pass + + +def busy_serials(): + """正在跑任务/正在连接的设备（探测要跳过它们：抢屏会打断任务）。""" + from core import device_worker + out = set() + try: + for s in device_worker.get_all_worker_status(): + if (s.get("status") or "") in ("running", "connecting"): + out.add(s.get("serial") or "") + except Exception as e: + _log.warning(f"读设备运行状态失败（按「都不忙」处理）: {e}") + return {x for x in out if x} + + +def probe_online(serials=None, skip_busy=True, workers=4): + """并行探测多台设备。返回 `{serial: {serial, name, error}}`。 + + · `serials=None` → 取设备池里**在线且启用**的设备（`device_pool.list_ready()`） + · `skip_busy=True`（默认）→ 跳过正在跑任务/连接中的设备（别抢它们的屏） + · 单台失败只影响那一台；顺序按传入/池里的顺序 + """ + from core import device_pool + if serials is None: + try: + serials = list(device_pool.list_ready()) + except Exception as e: + _log.warning(f"取在线设备失败: {e}") + return {} + serials = [s for s in (serials or []) if s] + if skip_busy: + busy = busy_serials() + if busy: + _log.info(f"探测跳过正在跑任务的设备：{'、'.join(sorted(busy))}") + serials = [s for s in serials if s not in busy] + out = {} + if not serials: + return out + with ThreadPoolExecutor(max_workers=max(1, min(workers, len(serials)))) as pool: + for r in pool.map(probe_one, serials): + out[r["serial"]] = r + return out + + +def cache_names(result): + """把探测结果写进 `device.cur_account_name/cur_name_at`（**只用于人工入口的设备建议**）。 + + ⚠ 必须在 **Flask app context** 里调用（web 请求线程本身就有；脚本里自己推）。 + 探测失败的那台**不清空旧值**（旧值好歹是个线索，界面上带时间戳显示）。 + """ + from core.models import Device, db + try: + now = time.strftime("%Y-%m-%d %H:%M:%S") + for serial, r in (result or {}).items(): + name = (r or {}).get("name") or "" + if not name: + continue + row = Device.query.get(serial) + if not row: + continue + row.cur_account_name = name[:80] + row.cur_name_at = now + db.session.commit() + except Exception as e: + _log.warning(f"写设备当前账号缓存失败（不影响探测结果）: {e}") + try: + db.session.rollback() + except Exception: + pass diff --git a/core/device_pool.py b/core/device_pool.py index 408f71f..2817b36 100644 --- a/core/device_pool.py +++ b/core/device_pool.py @@ -124,6 +124,33 @@ def list_devices(): return [d.to_dict() for d in Device.query.order_by(Device.serial).all()] +def serial_of(device_name): + """设备名 → **当前**地址（拿不到返回空串）。 + + 从已删掉的 `core/ledger.py` 迁过来的（账号台账停用后，那边只剩这一个函数还有用 —— + 它跟账号无关，只做"设备名 ↔ 地址"）。 + + ⚠ 为什么不能直接用计划行里的 `serial` 快照：设备地址会变（换 IP、重连）。 + 快照是"录入时"的值，久了就是错的 —— 要下发操作（推视频等）时必须现查。 + 优先设备池的**内存快照**（零 DB、已经是刷新过的），再退回 DB。 + """ + name = (device_name or "").strip() + if not name: + return "" + try: + for d in list_devices(): + if (d.get("name") or "") == name: + return d.get("serial") or "" + except Exception: + pass + try: + with _ctx(): + dev = Device.query.filter(Device.name == name).first() + return (dev.serial if dev else "") or "" + except Exception: + return "" + + # ================== 在线状态 ================== def list_online(): """本机 adb 中 state=device 的设备 + 池内 USB 设备（经 220 远程 adb server）。 diff --git a/core/ledger.py b/core/ledger.py deleted file mode 100644 index a9be584..0000000 --- a/core/ledger.py +++ /dev/null @@ -1,557 +0,0 @@ -"""账号台账：一台设备上登录着哪些账号。 - -**它解决什么**（用户场景）：一台手机登好几个抖音号、十几台手机四五十个号， -账号信息散在一张电子表格里 —— 换 IP、加号、想查"这台登的是哪几个号"都得翻表。 -台账落进平台后有三个月牙： - - 1. web「账号」页 —— 列表 / 增删改 / **从表格粘贴导入**（`web/devices_api.py` 的 `/api/ledger*`） - 2. 任务的「条件判断」取号 —— `if_el` 的 `cmp_source=device|all|group` - （比对运算符用「包含」时，纯号 `35377983067` 能匹配元素原文 `抖音号：35377983067`） - 3. 手机端 Agent 的「身份大字页」 —— 平台推 `accounts_b64`（`doc/DEVICE_AGENT.md` §5.2） - -⚠ **台账里的抖音号是纯号，绝不能拿去当去重身份**： -`done_mark.identity` 存的是**元素原文**、逐字算 key，格式不一致（`35377983067` -vs `抖音号：35377983067`）会让去重**静默失效**。取号只用于条件判断的比对值。 - -DB 访问自建 app context（照 `core/dedup.py`），调用方（任务线程 / Web 线程）不用关心。 -""" -import re -import time -import uuid - -from core.logger import get_logger -from core.models import db, Device, DeviceAccount, DeviceGroup - -_log = get_logger("core.ledger") - -# 可编辑字段（接口 / 导入 / 前端共用一份清单，避免某处漏字段） -FIELDS = ("device_name", "phone", "nickname", "douyin_id", "registered_at", - "sim_in_device", "can_post_video", "bio", "note") -# 这两列是布尔（"空=否"） -BOOL_FIELDS = ("sim_in_device", "can_post_video") - -# 粘贴导入：表头列名 → 字段（允许乱序/缺列/多列；认不出的列忽略） -HEADER_ALIASES = { - "device_name": ("设备号", "设备", "设备名", "机器", "机型"), - "phone": ("手机号", "手机", "号码", "手机号码"), - "nickname": ("账号名称", "账号名", "昵称", "账号", "名称"), - "douyin_id": ("抖音号", "抖音", "抖音id", "douyin"), - "registered_at": ("注册时间", "注册日期", "注册"), - "sim_in_device": ("卡在机内", "卡在机", "卡在", "机内"), - "can_post_video": ("可发视频", "可发", "发视频"), - "bio": ("简介", "签名", "个人简介"), - "note": ("备注", "说明"), -} -# 没有表头时按这个顺序解析（= 用户表格的列顺序，界面上要写明） -DEFAULT_ORDER = FIELDS - -_TRUE_WORDS = ("是", "有", "对", "在", "✔", "√", "✓", "1", "true", "y", "yes", "t") -_FALSE_WORDS = ("否", "无", "没有", "不在", "不", "0", "false", "n", "no", "f", "") -# 抖音号形态：纯数字。不拦（少数号可能带字母），只在导入结果里留痕 —— -# 候选值一旦是错的，任务会"正常跑完但永远不命中"，最难查 -_DOUYIN_RE = re.compile(r"^\d{6,20}$") - -_app = None - - -def init_app(app): - """web_server 启动时调用：绑 app（后台线程/任务线程访问 db 要自推 context）。""" - global _app - _app = app - - -def _ctx(): - if _app is None: - raise RuntimeError("ledger 未关联 Flask app（web_server 启动时调用 init_app）") - return _app.app_context() - - -def _now(): - return time.strftime("%Y-%m-%d %H:%M:%S") - - -def _norm_bool(v): - """是/否 → (True/False, 是否认得)。认不出的按"否"处理，但**留痕**。""" - if isinstance(v, bool): - return v, True - s = str(v or "").strip().lower() - if s in _TRUE_WORDS: - return True, True - if s in _FALSE_WORDS: - return False, True - return False, False - - -def _clean(fields): - """把接口来的字段清洗成可落库的值。只处理传进来的键。返回 (values, error)。""" - out = {} - for k in FIELDS: - if k not in (fields or {}): - continue - v = fields.get(k) - out[k] = _norm_bool(v)[0] if k in BOOL_FIELDS else str(v or "").strip() - if "device_name" in out and not out["device_name"]: - return {}, "设备号不能为空" - if "douyin_id" in out and not out["douyin_id"]: - return {}, "抖音号不能为空" - return out, "" - - -# ================== 查 ================== -def get_by_id(acc_id): - """取一条（dict）或 None。 - - **跨边界一律返回 dict**：commit 之后 ORM 行的属性会过期，出了 app context - 再读属性会抛 DetachedInstanceError（接口层 `row.to_dict()` 必炸）。 - """ - with _ctx(): - row = DeviceAccount.query.get(acc_id) - return row.to_dict() if row else None - - -def find_by_douyin(douyin_id, exclude_id=""): - """按抖音号找已存在的那条（唯一性判据；空号不参与）。返回 (id, 设备号) 或 None。 - - 只返回两个纯值，同样是为了不让 ORM 行溜出 context。 - """ - d = str(douyin_id or "").strip() - if not d: - return None - with _ctx(): - q = DeviceAccount.query.filter(DeviceAccount.douyin_id == d) - if exclude_id: - q = q.filter(DeviceAccount.id != exclude_id) - row = q.first() - return (row.id, row.device_name or "") if row else None - - -def list_accounts(device_name="", q="", limit=500): - """列表 + 统计（「账号」页用）。返回 (rows, stats)。""" - with _ctx(): - query = DeviceAccount.query - if device_name: - query = query.filter(DeviceAccount.device_name == device_name) - if q: - like = f"%{q.strip()}%" - query = query.filter(db.or_(DeviceAccount.douyin_id.like(like), - DeviceAccount.phone.like(like), - DeviceAccount.nickname.like(like))) - rows = (query.order_by(DeviceAccount.device_name, DeviceAccount.id) - .limit(max(1, min(int(limit or 500), 2000))).all()) - all_rows = DeviceAccount.query.all() - stats = { - "total": len(all_rows), - "devices": len({r.device_name for r in all_rows if r.device_name}), - "can_post_video": len([r for r in all_rows if r.can_post_video]), - "shown": len(rows), - } - return [r.to_dict() for r in rows], stats - - -def device_names(): - """台账里出现过的设备号（筛选下拉用）。""" - try: - with _ctx(): - return sorted({r.device_name for r in DeviceAccount.query.all() if r.device_name}) - except Exception: - return [] - - -def for_device(serial="", device_name=""): - """这台设备的账号。serial 优先，再按设备名（换 IP / 改名都找得到）。 - - `serial` 是**录入时的快照**：设备换 IP 后台账里那条还是旧地址， - 所以两边都查一遍并按抖音号去重。 - """ - with _ctx(): - rows, seen = [], set() - if serial: - for r in DeviceAccount.query.filter(DeviceAccount.serial == serial).all(): - rows.append(r) - seen.add(r.douyin_id) - name = device_name - if not name and serial: - dev = Device.query.get(serial) - name = (dev.name if dev else "") or "" - if name: - for r in DeviceAccount.query.filter(DeviceAccount.device_name == name).all(): - if r.douyin_id not in seen: - rows.append(r) - seen.add(r.douyin_id) - return [r.to_dict() for r in rows] - - -def resolve_device(serial="", device_name=""): - """serial/设备名 → (设备号, 账号行, 说明)。 - - "本机是哪台设备"这条链只在这一个地方定义，任务侧和设备端都走它 —— - 两套规则必然分叉（那会变成"任务取到 3 个号、页面显示 0 个号"这种鬼故事）。 - """ - name = (device_name or "").strip() - if not name and serial: - with _ctx(): - dev = Device.query.get(serial) - name = (dev.name if dev else "") or "" - rows = for_device(serial=serial, device_name=name) - # 兜底：台账里有人把"设备号"直接填成地址（手填习惯），按 serial 再认一次 - if not rows and serial: - with _ctx(): - hit = DeviceAccount.query.filter(DeviceAccount.device_name == serial).all() - if hit: - name = serial - rows = [r.to_dict() for r in hit] - if not rows: - note = (f"设备名『{name}』在台账里没有账号" if name - else f"设备 {serial or '（无地址）'} 认不出设备名（设备池里没登记或还没刷新）") - if serial and name: - note += f"，地址 {serial} 也没对上台账" - return name, [], note - return name, rows, f"设备『{name}』登记 {len(rows)} 个号" - - -def serial_of(device_name): - """设备名 → **当前**地址（拿不到返回空串）。 - - ⚠ 为什么不能直接用台账/计划行里的 `serial` 快照：设备地址会变（换 IP、重连）。 - 快照是"录入时"的值，久了就是错的 —— 要下发操作（发布视频等）时必须现查。 - 优先设备池的**内存快照**（零 DB、已经是刷新过的），再退回 DB。 - """ - name = (device_name or "").strip() - if not name: - return "" - try: - from core import device_pool - for d in device_pool.list_devices(): - if (d.get("name") or "") == name: - return d.get("serial") or "" - except Exception: - pass - try: - with _ctx(): - dev = Device.query.filter(Device.name == name).first() - return (dev.serial if dev else "") or "" - except Exception: - return "" - - -def douyin_ids(scope, serial="", device_name="", group=""): - """按范围取抖音号（任务「条件判断」取号用）。返回 (去重后的纯号列表, 说明)。 - - 说明是给日志/步骤明细看的**人话解释** —— 取不到号时它是唯一线索 - （取不到候选值的后果是"这一步永远不命中"，但任务本身会正常跑完）。 - scope: `device`=本机台账 / `all`=全部 / `group`=某设备分组 / 其他=不取 - """ - scope = (scope or "").strip() - if scope in ("", "manual", "none"): - return [], "" - try: - with _ctx(): - if scope == "device": - _, rows, note = resolve_device(serial=serial, device_name=device_name) - return _uniq([r.get("douyin_id") for r in rows]), note - if scope == "all": - ids = _uniq([r.douyin_id for r in DeviceAccount.query.all()]) - return ids, f"全部台账共 {len(ids)} 个号" - if scope == "group": - names = _device_names_of_group(group) - if not names: - return [], f"设备分组『{group}』没有设备（或分组不存在）" - rows = DeviceAccount.query.filter( - DeviceAccount.device_name.in_(list(names))).all() - ids = _uniq([r.douyin_id for r in rows]) - return ids, f"设备分组『{group}』（{len(names)} 台设备）共 {len(ids)} 个号" - return [], f"未知的取号范围 {scope!r}" - except Exception as e: - # 取号失败绝不拦住任务：返回空，由调用方回落到手填值 - _log.warning(f"台账取号失败（回落手填值）: {e}") - return [], f"台账取号失败: {e}" - - -def _uniq(ids): - out, seen = [], set() - for i in ids or []: - s = str(i or "").strip() - if s and s not in seen: - seen.add(s) - out.append(s) - return out - - -def _device_names_of_group(group_name): - """设备分组 → 设备名集合（分组里存的是 serial，这里换成台账里的设备号）。""" - g = DeviceGroup.query.filter(DeviceGroup.name == (group_name or "").strip()).first() - if not g: - return set() - serials = g.get_serials() or [] - if not serials: - return set() - devs = Device.query.filter(Device.serial.in_(list(serials))).all() - return {d.name for d in devs if d.name} - - -def counts_by_device(): - """{设备名: 号数}（设备池显示"这台几个号"用，一次拿全避免 N 次请求）。""" - try: - with _ctx(): - out = {} - for r in DeviceAccount.query.all(): - if r.device_name: - out[r.device_name] = out.get(r.device_name, 0) + 1 - return out - except Exception as e: - _log.warning(f"台账统计失败: {e}") - return {} - - -def by_device(): - """{设备名: {count, accounts[]}}（设备维度查看弹窗用）。""" - groups = {} - try: - with _ctx(): - for r in DeviceAccount.query.order_by(DeviceAccount.douyin_id).all(): - g = groups.setdefault(r.device_name or "", {"count": 0, "accounts": []}) - g["count"] += 1 - g["accounts"].append(r.to_dict()) - except Exception as e: - _log.warning(f"台账按设备分组失败: {e}") - return groups - - -def agent_accounts(serial="", device_name="", limit=50, include_phone=False): - """设备端 Agent 的账号块（身份大字页用）。 - - · **默认不带手机号**：大字页是放在机器旁的公开屏幕，手机号不该默认上屏 - · 超量**按整条丢**（`truncated=True`），绝不按字节切 —— 切了就是坏 JSON， - 设备端只能整块丢掉 - · 任何异常都返回空块（不是抛）：台账坏了不能把"显示身份"这个动作弄坏 - """ - try: - name, rows, note = resolve_device(serial=serial, device_name=device_name) - out = [] - for r in rows[:max(1, int(limit or 50))]: - # name 恒空串：账号名称已停用（设备端 APK 仍会解析这个字段， - # 直接删 key 有解析失败的风险，所以留空串） - item = {"name": "", "douyin_id": r.get("douyin_id") or "", - "device_name": r.get("device_name") or "", "device_no": name, - "sim_in_device": bool(r.get("sim_in_device")), - "can_post_video": bool(r.get("can_post_video"))} - if include_phone: - item["phone"] = r.get("phone") or "" - out.append(item) - return {"v": 1, "total": len(rows), "shown": len(out), - "truncated": len(out) < len(rows), "accounts": out, "note": note} - except Exception as e: - _log.warning(f"设备端账号块生成失败: {e}") - return {"v": 1, "total": 0, "shown": 0, "truncated": False, "accounts": [], - "note": f"读取失败: {e}"} - - -# ================== 增 / 改 / 删 ================== -def add(fields): - """新增一条。返回 (dict, error)。""" - values, err = _clean(fields) - if err: - return None, err - if not values.get("device_name"): - return None, "设备号不能为空" - if not values.get("douyin_id"): - return None, "抖音号不能为空" - # try 必须在 `with _ctx()` 里面：否则 rollback 自己会在 context 外抛 - # RuntimeError，把真正的错误盖掉（这条踩过一次，别挪出去） - with _ctx(): - try: - if find_by_douyin(values["douyin_id"]): - return None, f"抖音号 {values['douyin_id']} 已在台账里（一个号只能有一条）" - row = DeviceAccount(id=uuid.uuid4().hex[:8], created_at=_now(), updated_at=_now()) - for k in FIELDS: - # 没传的布尔列必须是 False，不能是 ""（Boolean 列收到空串会直接报 - # TypeError: Not a boolean value，整条插不进去） - setattr(row, k, values.get(k, False if k in BOOL_FIELDS else "")) - _fill_serial(row) - db.session.add(row) - db.session.commit() - _log.info(f"账号台账新增：{row.device_name} / {row.nickname} / {row.douyin_id}") - return row.to_dict(), "" # 出 context 前转成纯值 - except Exception as e: - db.session.rollback() - return None, f"保存失败: {e}" - - -def update(acc_id, fields): - """改一条（只改传进来的键）。返回 (dict, error)。""" - with _ctx(): - try: - row = DeviceAccount.query.get(acc_id) - if not row: - return None, "记录不存在" - values, err = _clean(fields) - if err: - return None, err - new_id = values.get("douyin_id", row.douyin_id) - dup = find_by_douyin(new_id, exclude_id=acc_id) - if dup: - return None, f"抖音号 {new_id} 已被 {dup[1]} 占用（一个号只能有一条）" - for k, v in values.items(): - setattr(row, k, v) - row.updated_at = _now() - _fill_serial(row) - db.session.commit() - return row.to_dict(), "" - except Exception as e: - db.session.rollback() - return None, f"保存失败: {e}" - - -def delete(acc_id): - """删一条（删掉之后任务就取不到这个号了）。""" - with _ctx(): - try: - row = DeviceAccount.query.get(acc_id) - if not row: - return False - db.session.delete(row) - db.session.commit() - _log.info(f"账号台账删除：{row.device_name} / {row.nickname} / {row.douyin_id}") - return True - except Exception as e: - db.session.rollback() - _log.warning(f"账号台账删除失败: {e}") - return False - - -def _fill_serial(row): - """按设备名补 serial 快照（台账只填设备号时，自动关联设备池那条）。""" - if row.serial: - return - if not row.device_name: - return - dev = Device.query.filter(Device.name == row.device_name).first() - if dev: - row.serial = dev.serial - - -# ================== 粘贴导入 ================== -def parse_paste(text, delimiter="\t"): - """把粘贴的表格文本解析成台账行。返回 (rows, errors)。 - - rows 里每行是 `{"_line": 3, "device_name": "...", ..., "_warns": [...]}` - （`_line` = 粘贴文本里的行号，界面把错误指回原行；`_warns` 是"能导但要注意"的提示）。 - errors 是 `[{"line": 3, "reason": "..."}]`（这些行会被跳过）。 - - 分隔符默认 Tab（Excel 直接粘贴就是 Tab）。**不做"多个空格当分隔"**—— - 账号名里本来就有双空格（实测 `有牛奶面包 你吃吗？`），按空格切会切坏。 - 带表头时按列名映射（顺序随意、缺列留空）；不带表头则按 DEFAULT_ORDER 的固定顺序。 - """ - if delimiter not in ("\t", "|", ","): - delimiter = "\t" - text = (text or "").replace("\r\n", "\n").replace("\r", "\n") - lines = [(i + 1, ln) for i, ln in enumerate(text.split("\n")) if ln.strip()] - if not lines: - return [], [{"line": 0, "reason": "没有可解析的内容"}] - - first_cells = [c.strip() for c in lines[0][1].split(delimiter)] - mapped = _map_header(first_cells) - if mapped: - body = lines[1:] - else: - mapped = {name: i for i, name in enumerate(DEFAULT_ORDER)} - body = lines - if not body: - return [], [{"line": lines[0][0], "reason": "只有表头，没有数据行"}] - - rows, errors = [], [] - for lineno, line in body: - cells = line.split(delimiter) - row = {"_line": lineno, "_warns": []} - for f in FIELDS: # 先把所有字段填上，缺列留空 - row[f] = "" - for field, idx in mapped.items(): - if field in FIELDS: - # 账号名称（nickname）**不再收录**：界面上已经去掉这一列， - # 老表格粘进来也不报错，只是这一列的值被忽略（库里的历史值不动） - if field == "nickname": - continue - row[field] = cells[idx].strip() if idx < len(cells) else "" - if not row["device_name"] and not row["douyin_id"]: - errors.append({"line": lineno, "reason": "设备号与抖音号都是空的，已跳过"}) - continue - if not row["device_name"]: - errors.append({"line": lineno, "reason": "缺设备号，已跳过"}) - continue - if not row["douyin_id"]: - errors.append({"line": lineno, "reason": "缺抖音号，已跳过"}) - continue - for f in BOOL_FIELDS: - raw = row[f] - val, known = _norm_bool(raw) - row[f] = val - if not known: - row["_warns"].append(f"『{raw}』认不出，按「否」处理") - if not _DOUYIN_RE.match(row["douyin_id"]): - row["_warns"].append(f"抖音号『{row['douyin_id']}』不是纯数字 —— " - f"任务比对时可能匹配不上") - rows.append(row) - return rows, errors - - -def _map_header(cells): - """列名 → 列下标（认不出"设备号+抖音号"时返回 {}，按固定顺序解析）。""" - mapping = {} - for idx, cell in enumerate(cells): - c = re.sub(r"\s+", "", cell or "") - if not c: - continue - for field, aliases in HEADER_ALIASES.items(): - if field in mapping: - continue - if any(c == a or c.startswith(a) for a in aliases): - mapping[field] = idx - break - if "device_name" in mapping and "douyin_id" in mapping: - return mapping - return {} - - -def import_rows(rows, mode="skip", dry_run=False): - """把解析好的行落库（或只预览）。返回逐行结果 + 汇总。 - - mode=`skip`（默认）：抖音号已在台账里 → 跳过（不动现有那条） - mode=`overwrite`：抖音号已在台账里 → 用粘贴的这行**整行覆盖**它 - dry_run=True：只判重、不写库（界面上"先预览后导入"） - """ - mode = mode if mode in ("skip", "overwrite") else "skip" - counts = {"total": 0, "added": 0, "updated": 0, "skipped": 0, "failed": 0} - out_rows = [] - for row in rows or []: - line = row.get("_line", 0) - fields = {k: v for k, v in row.items() if k not in ("_line", "_warns")} - counts["total"] += 1 - existing = find_by_douyin(fields.get("douyin_id")) - item = {"line": line, "device_name": fields.get("device_name", ""), - "douyin_id": fields.get("douyin_id", ""), - "nickname": fields.get("nickname", ""), - "warns": list(row.get("_warns") or []), "error": ""} - if existing: - if mode == "overwrite": - item["action"] = "update" - if not dry_run: - _, err = update(existing[0], fields) - if err: - item["action"], item["error"] = "fail", err - counts["updated" if item["action"] == "update" else "failed"] += 1 - else: - item["action"] = "skip" - item["error"] = f"已存在（{existing[1]}），跳过" - counts["skipped"] += 1 - else: - item["action"] = "add" - if not dry_run: - _, err = add(fields) - if err: - item["action"], item["error"] = "fail", err - counts["added" if item["action"] == "add" else "failed"] += 1 - out_rows.append(item) - if not dry_run: - _log.info(f"账号台账导入：新增 {counts['added']}、覆盖 {counts['updated']}、" - f"跳过 {counts['skipped']}、失败 {counts['failed']}") - return {"counts": counts, "rows": out_rows, "mode": mode, "dry_run": bool(dry_run)} diff --git a/core/models.py b/core/models.py index 7b5e9d8..e058880 100644 --- a/core/models.py +++ b/core/models.py @@ -250,6 +250,10 @@ class Device(db.Model): enabled = db.Column(db.Boolean, default=True) # 是否参与调度 note = db.Column(db.Text, default="") # 备注 created_at = db.Column(db.String(20), default="") # 添加时间 + # 上次探测到的**抖音当前登录账号名字**（「发布计划 → 一键推送（按名字找设备）」用）。 + # 只是**缓存**：自动任务永远现场读屏幕，不读这两列（缓存旧了也不影响发布正确性）。 + cur_account_name = db.Column(db.String(80), default="") + cur_name_at = db.Column(db.String(20), default="") # 上面那个名字是什么时候读的 # 设备指纹（ro.serialno）：识别"同一台物理设备"的稳定标识。 # 网络设备（serial=IP:5555）换 IP 后靠它认领回原记录，名称/分组/任务引用都不丢。 fingerprint = db.Column(db.String(120), default="") @@ -258,7 +262,9 @@ class Device(db.Model): return {"serial": self.serial, "name": self.name or "", "model": self.model or "", "enabled": bool(self.enabled), "note": self.note or "", "created_at": self.created_at or "", - "fingerprint": self.fingerprint or ""} + "fingerprint": self.fingerprint or "", + "cur_account_name": self.cur_account_name or "", + "cur_name_at": self.cur_name_at or ""} def __repr__(self): return f"" @@ -437,7 +443,11 @@ class DoneMark(db.Model): class DeviceAccount(db.Model): - """账号台账：一台设备上登录着哪些账号（「账号」页）。 + """账号台账（**2026-10-12 起已停用**：页面/接口/任务依赖全部下线，表和数据保留）。 + + 保留模型 = 保留表和 42 行历史数据、并继续留在备份清单（`SUMMARY_TABLES` 按模型派生）—— + 停用不等于删数据（删不可逆）。新功能**不要再读写这张表**。 + 历史用途：一台设备上登录着哪些账号（「账号」页维护）。 要解决的问题（用户场景）：一台手机登好几个抖音号、十几台手机四五十个号， 账号信息散在一张电子表格里 —— 换 IP、加号、想查"这台登的是哪几个号"都要翻表。 @@ -451,7 +461,7 @@ class DeviceAccount(db.Model): 格式不一致会让去重**静默失效**（见 `core/dedup.py`）。 `device_name` 是设备号（平台设备名，如 A01）；`serial` 是**录入时的地址快照**， - 设备换 IP 或改名后，台账靠任一侧都能找回来（见 `core/ledger.for_device`）。 + 设备换 IP 或改名后，台账靠任一侧都能找回来（账号管理已停用，这列仅留作历史数据）。 同一抖音号不允许两条 —— 唯一性由服务层保证（号可能为空，DB 层要做 "部分唯一索引"三处方言适配，人工维护的几十条不值当）。 """ @@ -506,7 +516,7 @@ class VideoPlan(db.Model): ⚠ **`failed` 与 `unknown` 必须分开**：把"不知道自己发没发"混成"知道自己没发"， 就是重复发布的来源。`stage` 记录失败发生在哪一步，是这两者互相转换的唯一依据。 - **唯一性**：`(phone, release_date, seq)` 由服务层（`core/video_plan.py`）保证， + **唯一性**：`(nickname, release_date, seq)` 由服务层（`core/video_plan.py`）保证， **不加 DB 唯一索引** —— `seq` 从 1 起、没有"空值"可言，做部分唯一索引要写三处方言适配 （见 §唯一索引那段注释与 `_ensure_unique_indexes`），收益不匹配；违反的代价只是 低频人工上传产生的重复行，可见、可删。 @@ -516,12 +526,12 @@ class VideoPlan(db.Model): """ __tablename__ = "video_plan" id = db.Column(db.String(32), primary_key=True) # uuid 前 8 位 - account_id = db.Column(db.String(32), default="", index=True) # → device_account.id（不做外键） - phone = db.Column(db.String(32), default="", index=True) # 配对键（冗余存：账号删了也留痕） - device_name = db.Column(db.String(80), default="", index=True) # 设备号快照（聚合/下发免 join） - nickname = db.Column(db.String(80), default="") # 账号名称快照（时间线卡片直接显示） - douyin_id = db.Column(db.String(64), default="") # 抖音号快照 - serial = db.Column(db.String(120), default="") # 地址快照 + account_id = db.Column(db.String(32), default="", index=True) # 老台账账号 id（已停用，保留列） + phone = db.Column(db.String(32), default="", index=True) # 老台账手机号快照（已停用，保留列） + device_name = db.Column(db.String(80), default="", index=True) # 设备号快照（**已不写入**；实际由谁发的看 posted_device_name） + nickname = db.Column(db.String(80), default="") # **识别键**：上传文件名里的名字（= 抖音昵称） + douyin_id = db.Column(db.String(64), default="") # 抖音号快照（已停用，保留列） + serial = db.Column(db.String(120), default="") # 地址快照（已停用，保留列） release_date = db.Column(db.String(10), default="", index=True) # "YYYY-MM-DD"（纯日期，等值比较） seq = db.Column(db.Integer, default=1) # 编号，从 1 起（不用 0 表示"无"） seq_auto = db.Column(db.Boolean, default=True) # 编号是自动分配出来的（界面要提示） @@ -540,6 +550,8 @@ class VideoPlan(db.Model): video_deleted_at = db.Column(db.String(20), default="") # 平台素材文件何时被清理 push_verify = db.Column(db.String(16), default="") # 推送后的相册校验：ok=进索引 / no_index=没进 / nofile=文件不在 push_remote = db.Column(db.String(200), default="") # 推到手机上的绝对路径（删它/排查用） + posted_serial = db.Column(db.String(120), default="") # **实际是哪台设备发的**（地址快照） + posted_device_name = db.Column(db.String(80), default="") # **实际是哪台设备发的**（设备名，界面显示用） last_error = db.Column(db.String(500), default="") note = db.Column(db.Text, default="") created_at = db.Column(db.String(20), default="", index=True) @@ -550,6 +562,8 @@ class VideoPlan(db.Model): db.Index("ix_video_plan_acct_date", "account_id", "release_date"), db.Index("ix_video_plan_phone_slot", "phone", "release_date", "seq"), db.Index("ix_video_plan_file", "video_file"), + # 主查询路径（按名字取待发计划/查重）——老库靠 _ensure_plain_indexes 补建 + db.Index("ix_video_plan_name_date", "nickname", "release_date"), ) def to_dict(self): @@ -566,6 +580,8 @@ class VideoPlan(db.Model): "published_at": self.published_at or "", "share_url": self.share_url or "", "link_at": self.link_at or "", "video_deleted_at": self.video_deleted_at or "", "push_verify": self.push_verify or "", "push_remote": self.push_remote or "", + "posted_serial": self.posted_serial or "", + "posted_device_name": self.posted_device_name or "", "last_error": self.last_error or "", "note": self.note or "", "created_at": self.created_at or "", "updated_at": self.updated_at or ""} @@ -603,6 +619,10 @@ SCHEMA_MIGRATIONS = [ (10, "视频发布计划：video_plan 新增 push_verify（推送后相册校验：ok/no_index/nofile）" "与 push_remote（手机上的绝对路径，删它/排查用）", None), (11, "视频发布计划：video_plan 新增 body（正文）—— 标题 txt 一行里用 || 分隔「标题 || 正文」", None), + (12, "发布计划按名字发：计划行以 nickname 为识别键，新增 posted_serial/posted_device_name" + "（**实际是哪台设备发的**）；账号台账（device_account）停用但表与数据保留", None), + (13, "按名字找设备：device 表新增 cur_account_name/cur_name_at" + "（上次探测到的抖音当前账号名字，仅供人工入口做设备建议）", None), ] # 当前 schema 版本（备份/恢复用它判断新旧，也写进 app_meta.schema_version） @@ -633,13 +653,20 @@ _MYSQL_UNIQUE_INDEXES = ( ("ux_device_fingerprint", "device", "fingerprint_uq"), ) +# 普通索引：模型里已经声明了（`__table_args__`），但那对**已有表**不生效 —— +# `create_all` 只建缺的表，不补已有表的新索引。这里按名字查了再建，老库升级也能有。 +_PLAIN_INDEXES = ( + ("ix_video_plan_name_date", "video_plan", "nickname, release_date"), +) + def init_db(app): """在 Flask app context 里初始化数据库 + 创建默认管理员。 web_server 启动时调用。自动迁移旧 groups.json/jobs.json 到数据库。 - 顺序：建表（create_all）→ 补列（_sync_columns）→ 版本账本 → 唯一索引 → 管理员/旧 JSON。 + 顺序：建表（create_all）→ 补列（_sync_columns）→ 版本账本 → 唯一索引 → 普通索引 + → 管理员/旧 JSON。 建表与补列都以模型定义为准，SQLite / MySQL 两种方言自动匹配，不再手写 DDL。 """ db.init_app(app) @@ -648,6 +675,7 @@ def init_db(app): _sync_columns() _migrate_schema() _ensure_unique_indexes() + _ensure_plain_indexes() _ensure_default_admin() _migrate_old_json() @@ -780,6 +808,26 @@ def _ensure_unique_indexes_mysql(): _log.warning(f"唯一索引 {name} 创建失败（历史数据可能有重复）: {e}") +def _ensure_plain_indexes(): + """补建模型里声明、但已有表上还没有的普通索引（幂等）。 + + SQLite / MySQL 都能跑同一条 `CREATE INDEX`（MySQL 5.7 没有 `IF NOT EXISTS`， + 所以先 inspect 查名字再建，不靠方言特有能力）。 + """ + from sqlalchemy import inspect + for name, table, cols in _PLAIN_INDEXES: + try: + have = {i["name"] for i in inspect(db.engine).get_indexes(table)} + if name in have: + continue + db.session.execute(text("CREATE INDEX {} ON {}({})".format(name, table, cols))) + db.session.commit() + _log.info(f"已建索引 {name}") + except Exception as e: + db.session.rollback() + _log.warning(f"索引 {name} 创建失败（不阻塞启动）: {e}") + + def _ensure_default_admin(): """首次启动创建默认管理员 admin/admin123。""" if not User.query.filter_by(username="admin").first(): diff --git a/core/notify_events.py b/core/notify_events.py index d766941..a4cb7b9 100644 --- a/core/notify_events.py +++ b/core/notify_events.py @@ -111,6 +111,15 @@ EVENTS = [ ["serial", "device_name", "selector", "miss_count"], "某选择器连续 10 次未命中——任务可能显示成功但什么都没做", agg_window=0, recommend=True), + _e("task.account.switch_failed", "切号失败", "业务", + ["serial", "device_name", "model", "want", "got", "attempts", "msg"], + "想切到某个账号但没切成功（列表里找不到这个名字，或切完读回来的还是别人）——" + "**本次不会发这个号的内容**。请人工到设备上确认这个号还在不在抖音的账号列表里", + agg_window=0, agg_key=_BY_SERIAL, recommend=True), + _e("task.account.need_login", "需要登录/验证码", "业务", + ["serial", "device_name", "model", "want", "msg"], + "抖音停在登录页或要验证码 —— **需要人工登录**（平台绝不代替登录/过滑块），" + "本设备已停止本轮任务", agg_window=0, agg_key=_BY_SERIAL, recommend=True), _e("task.video.published", "视频已发布", "业务", ["serial", "device_name", "model", "phone", "nickname", "release_date", "seq", "title", "share_url"], diff --git a/core/task_draft.py b/core/task_draft.py index 37f4d6c..9bb716c 100644 --- a/core/task_draft.py +++ b/core/task_draft.py @@ -59,7 +59,7 @@ NEED_SELECTOR = ("click", "long_click", "wait_el", "swipe_until", "if_el") # 需要包名的步骤类型 NEED_PACKAGE = ("open_app", "stop_app") # 需要非空 children 的容器 -NEED_CHILDREN = ("loop", "group") +NEED_CHILDREN = ("loop", "group", "foreach_account") # 有副作用的动作关键词：命中的步骤在 AI 通道只给 warning（人工复核），不拦 DESTRUCTIVE_HINTS = ("评论", "发送", "发布", "投稿", "转发", "分享到", @@ -226,19 +226,17 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None, # 所以在这里拦住，别让 AI 草稿悄悄变成"永远不命中" cmp_op = (params.get("cmp_op") or "").strip() cmp_src = (params.get("cmp_source") or "").strip() - if cmp_src not in ("", "manual", "device", "all", "group"): + if cmp_src not in ("", "manual", "release", "account_target"): errors.append(f"{here}.params.cmp_source: 不支持的候选值来源 {cmp_src!r}" - f"（可用：空/manual/device/all/group）") - if cmp_src == "group" and not (params.get("cmp_group") or "").strip(): - warnings.append(f"{here}: 候选值来源是「按设备分组」，但没填分组名 —— 取不到号") + f"（可用：空/manual/release/account_target）") if cmp_op: from tasks.generic.task import CMP_OPS if cmp_op not in CMP_OPS: errors.append(f"{here}.params.cmp_op: 不支持的比对运算符 {cmp_op!r}" f"（可用：{'、'.join(CMP_OPS)}）") elif not str(params.get("cmp_value") or "").strip() \ - and cmp_src not in ("device", "all", "group"): - # 候选值来自台账时允许手填留空（台账取号就够）； + and cmp_src not in ("release", "account_target"): + # 候选值来自发布计划 / 本次要发的名字时，允许手填留空（候选由平台给）； # 其余情况仍要求填值，否则永远不命中 errors.append(f"{here}.params.cmp_value: 选了文本比对" f"（{cmp_op}）就必须填比对的值，否则永远不命中") @@ -277,20 +275,24 @@ def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None, f"（当前 min={lo!r} max={hi!r}）") if stype == "input_text": - mode = params.get("mode", "random") - if mode not in ("random", "fixed"): - errors.append(f"{here}.params.mode: 必须是 random 或 fixed" - f"（当前 {mode!r}）") - elif mode == "fixed": - if not str(params.get("fixed_text") or "").strip(): - errors.append(f"{here}.params.fixed_text: mode=fixed 时不能为空") - else: - texts = params.get("texts") - if not isinstance(texts, str) or not texts.strip(): - errors.append(f"{here}.params.texts: mode=random 时必须给候选" - "文案（换行分隔，如 \"你好\\n不错\"）") - elif len([t for t in texts.split("\n") if t.strip()]) > MAX_TEXTS: - errors.append(f"{here}.params.texts: 候选文案最多 {MAX_TEXTS} 条") + # 文案来自「发布计划」（`text_source` 不是 manual）时 texts/fixed_text **都不参与输入** —— + # 别按"手填"的规则要求候选文案（发布任务骨架里那两步就是这么配的： + # mode 留默认、内容由计划给，靠 `release_title`/`release_body` 现取） + if str(params.get("text_source") or "manual").strip() == "manual": + mode = params.get("mode", "random") + if mode not in ("random", "fixed"): + errors.append(f"{here}.params.mode: 必须是 random 或 fixed" + f"（当前 {mode!r}）") + elif mode == "fixed": + if not str(params.get("fixed_text") or "").strip(): + errors.append(f"{here}.params.fixed_text: mode=fixed 时不能为空") + else: + texts = params.get("texts") + if not isinstance(texts, str) or not texts.strip(): + errors.append(f"{here}.params.texts: mode=random 时必须给候选" + "文案（换行分隔，如 \"你好\\n不错\"）") + elif len([t for t in texts.split("\n") if t.strip()]) > MAX_TEXTS: + errors.append(f"{here}.params.texts: 候选文案最多 {MAX_TEXTS} 条") if stype == "clipboard": if not str(params.get("text") or "").strip(): diff --git a/core/video_plan.py b/core/video_plan.py index aa85ab0..b30388e 100644 --- a/core/video_plan.py +++ b/core/video_plan.py @@ -1,13 +1,13 @@ """视频发布计划：批量上传 → 自动配对 → 时间线 → 自动发布 → 存分享链接。 **它解决什么**（用户场景）：人员在网页上批量传视频与标题 txt，文件名里写着 -`手机号_日期_编号`，标题行写着 `标题_手机号_日期_编号`。平台把它们自动配到台账里的账号上， -排成一张发布计划；到发布日期由任务把视频推到手机相册、走抖音发布流程、回写状态， +`名字_日期_编号`（名字 = 抖音上的昵称），标题行写着 `标题 || 正文_名字_日期_编号`。 +平台把它们排成一张发布计划；到发布日期由任务把视频推到手机相册、走抖音发布流程、回写状态， **发布后抓作品的分享链接存进来**（平台不长期囤视频，链接才是长期资产 —— 后续铺评论也是靠这个链接去打开视频）。 **三个使用方**： - 1. web「账号 → 发布计划」页（`web/video_plan_api.py`）—— 上传/时间线/单条操作/导出链接 + 1. web「发布计划」页（`web/video_plan_api.py`）—— 上传/时间线/单条操作/导出链接 2. 任务步骤「发布视频」（`tasks/generic/task.py` 的 `_exec_publish_video`）—— 取计划、占位、回写 3. 每日清理 job（`web_server.py`）—— 僵尸回收 + 过期行/孤儿文件清理 @@ -20,7 +20,7 @@ `post`/`verify` 阶段失败或超时 = **可能已经发出去了** → `unknown`（**绝不自动重试**， 人工到抖音确认后再裁决）。把"不知道自己发没发"当成"知道自己没发"，就是重复发布的来源。 -DB 访问自建 app context（照 `core/dedup.py` / `core/ledger.py` 的 `_ctx()`），调用方不用关心。 +DB 访问自建 app context（照 `core/dedup.py` 的 `_ctx()`），调用方不用关心。 """ import hashlib import os @@ -31,7 +31,7 @@ import uuid from config import VIDEO_DIR from core.logger import get_logger -from core.models import db, DeviceAccount, VideoPlan +from core.models import db, VideoPlan _log = get_logger("core.video_plan") @@ -66,10 +66,20 @@ ZOMBIE_MINUTES = 30 # 占位行超过这么久没动静 → 按 stage VIDEO_KEEP_DAYS = 7 # 平台素材：抓到分享链接后再留这么多天 PLAN_KEEP_DAYS = 90 # 过期（未发布/失败）的计划行保留这么多天 +# 名字（抖音昵称）没有固定形态 → 只靠"位置"认（紧挨日期的那一段），所以形态上只做三条限制： +# 不能空、不能含 `_`（那是分段符号）、不能是纯数字（会和日期/编号撞车）。 +NAME_MAX_LEN = 40 +# 只在"名字段看着像老格式的手机号"时用来给一句更有用的提示（老文件 `手机号_日期_编号` +# 会被当成"名字=手机号"→ 报"名字不能是纯数字"，太含糊） _PHONE_RE = re.compile(r"^1\d{10}$") _DATE8_RE = re.compile(r"^\d{8}$") _SEQ_RE = re.compile(r"^\d{1,3}$") _URL_RE = re.compile(r"https?://v\.douyin\.com/[A-Za-z0-9_\-]+") +# 从昵称控件文本里挑名字时要跳过的"标签行"（**整行相等**才算，前缀不算 —— +# 「关注我领福利」这种昵称不能被误跳过）；抖音号那行必须是 `抖音号：/ID：` 带分隔符的形式 +_NAME_LABELS = {"编辑资料", "编辑名片", "点击编辑", "点击编辑资料", "抖音号", "抖音ID", + "关注", "粉丝", "获赞", "作品", "喜欢", "私密", "IP属地"} +_NAME_ID_RE = re.compile(r"^抖音(号|ID)\s*[:：]") _SAFE_RE = re.compile(r"[^0-9A-Za-z_\-.一-鿿]+") _app = None @@ -110,15 +120,61 @@ def parse_date8(s): return f"{t.tm_year:04d}-{t.tm_mon:02d}-{t.tm_mday:02d}" +def clean_account_name(text): + """从昵称控件的文本里取出"名字"（纯函数）。 + + 抖音「我」页的昵称控件，抓到的可能只有昵称，也可能是**整块资料的文本** + （多行，混着「编辑资料」「抖音号：xxx」「关注/粉丝/获赞」）。规则： + 按行切，取**第一个非空行**；如果那一行整行就是个标签（`编辑资料`/`关注`…）或 + `抖音号：…`，就继续往下找，直到拿到一条不是标签的；找不到 → 返回 `""` + （= **读不到名字**，调用方按"没有这个号"处理，绝不当成某个名字去发）。 + + **不在名字内部做任何加工**：名字里的空格、表情、数字原样保留 —— + 台账里有 `有牛奶面包 你吃吗？` 这种带双空格的昵称，按空格切会把名字切坏。 + """ + if not text: + return "" + for line in str(text).replace("\r", "\n").split("\n"): + s = line.strip() + if not s or s in _NAME_LABELS or _NAME_ID_RE.match(s): + continue + return s + return "" + + +def name_error(seg): + """名字片段的合法性检查：合法返回 ""，不合法返回给人看的原因。 + + 三条限制都来自"名字只能靠**位置**认"这件事 —— 空名字、含 `_`（分段符号本身）、 + 纯数字（会和日期/编号撞车）都会让 `名字_日期_编号` 切不出唯一解。 + 其余一律放行：汉字/字母/数字混排、名字**内部**的空格、表情都可以（不做额外限制， + 抖音昵称能起什么名字，这里就认什么）。 + """ + s = (seg or "").strip() + if not s: + return "名字是空的" + if "_" in s: + return "名字里不能有下划线（下划线是文件名各段的隔开符号）" + if _PHONE_RE.match(s): + return (f"这一段（{s}）是手机号 —— 文件名第一段要填**抖音上的名字**，" + f"格式是 名字_日期_编号（现在不认手机号了）") + if s.isdigit(): + return f"名字不能是纯数字（{s} 会被当成日期/编号）—— 请填抖音上的昵称" + if len(s) > NAME_MAX_LEN: + return f"名字太长（{len(s)} 字 > {NAME_MAX_LEN} 字上限）" + return "" + + def parse_video_name(filename): - """视频文件名 `手机号_日期_编号` → (meta, error)。 + """视频文件名 `名字_日期_编号` → (meta, error)。 - meta = {"phone","date","seq"|None,"seq_given"}；error 是给人看的拒收原因。 + meta = {"name","date","seq"|None,"seq_given"}；error 是给人看的拒收原因。 - **按形态认，不按位置切**：手机号 11 位、日期 8 位、编号 1-3 位 —— 三个长度区间 - 互不相交，所以永远不会有一段同时匹配两种角色。按位置硬切的话，用户把顺序写反、 - 或文件名带下载站前缀时，会解析出一个**错误的手机号**；而它若恰好命中台账里 - 另一个账号，就**不报错**，静默地把 A 号的视频排给 B 号。 + **右锚定**：从最右边往前认 可省编号(1-3 位) → 日期(8 位) → **紧挨着日期的那一段就是名字**。 + 为什么不再"按形态扫全部分段"（手机号那套）：手机号有固定形态（11 位、1 开头）， + 名字没有 —— 长度任意、可以带数字和汉字，只有"日期前一段"这个位置是确定的。 + 代价是名字里不能有下划线：**明确拒收并说清原因**，而不是猜一个可能错的名字 + （猜错就是把 A 号的视频静默排给 B 号）。 """ name = (filename or "").strip() if not name: @@ -128,114 +184,83 @@ def parse_video_name(filename): return None, f"不是视频文件（支持 {'/'.join(e.lstrip('.') for e in VIDEO_EXTS)}）" parts = [p.strip() for p in stem.split("_")] if len(parts) < 2: - return None, "文件名格式不对，应为 手机号_日期_编号（编号可省略）" - - phone = date = seq = None - leftovers = [] - for p in parts: - if not p: - leftovers.append(p) - continue - if _PHONE_RE.match(p): - if phone is not None: - return None, f"文件名里有多个手机号（{phone}、{p}）" - phone = p - elif _DATE8_RE.match(p): - if date is not None: - return None, f"文件名里有多个日期（{date}、{p}）" - d = parse_date8(p) - if not d: - return None, f"日期 {p} 不是合法日期（应为 20260912 这种 8 位）" - date = d - elif _SEQ_RE.match(p): - if seq is not None: - return None, f"文件名里有多个编号（{seq}、{p}）" - seq = int(p) - else: - leftovers.append(p) - if leftovers: - return None, f"文件名里有多余片段 {'_'.join(leftovers)} —— 应为 手机号_日期_编号" - if not phone: - return None, "文件名里找不到手机号（11 位、1 开头）" - if not date: - return None, "文件名里找不到发布日期（8 位，如 20260912）" - return {"phone": phone, "date": date, "seq": seq, "seq_given": seq is not None}, "" + return None, "文件名格式不对，应为 名字_日期_编号（编号可省略，如 小王_20260912.mp4）" + if len(parts) >= 3 and _SEQ_RE.match(parts[-1]) and _DATE8_RE.match(parts[-2]): + seq, date8, name_parts = int(parts[-1]), parts[-2], parts[:-2] + elif _DATE8_RE.match(parts[-1]): + seq, date8, name_parts = None, parts[-1], parts[:-1] + else: + return None, (f"文件名格式不对：`{stem}` 的结尾既不是日期（8 位数字，如 20260912），" + f"也不是「日期_编号」—— 应为 名字_日期_编号") + d = parse_date8(date8) + if not d: + return None, f"日期 {date8} 不是合法日期（应为 20260912 这种 8 位）" + if len(name_parts) != 1: + return None, (f"名字里不能有下划线：`{stem}` 里日期前面有 {len(name_parts)} 段 ——" + f"应为 名字_日期_编号") + err = name_error(name_parts[0]) + if err: + return None, err + return {"name": name_parts[0], "date": d, "seq": seq, "seq_given": seq is not None}, "" def parse_title_line(line): - """标题行 → (meta, error)。**两种写法都认**，标题里都可以带下划线。 + """标题行 → (meta, error)。格式只有一种：`标题 || 正文_名字_日期_编号`。 - **一行里可以有标题和正文**：`标题 || 正文 _手机号_日期_编号`（用 `||` 分隔， - 因为标题/正文里常带下划线；只切第一处，正文里再出现 `||` 原样保留）。 - 没写 `||` 就是只有标题（老文件照收）；` || 正文_…` 这种只有正文也行。 + **一行里可以有标题和正文**：用 `||` 分隔（标题/正文里常带下划线，所以不能再用下划线分列）， + 只切**第一处**，正文里再出现 `||` 原样保留；没写 `||` 就是只有标题； + ` || 正文_…` 这种"只有正文"也行（标题留空）。 - ① 标题在前（推荐，右锚定）： - A) 标题内容_手机号_日期_编号 B) 标题内容_手机号_日期 - ② 手机号在前（左锚定，跟视频文件名同序 —— "文件名去掉扩展名 + 标题"）： - C) 手机号_日期_编号_标题 D) 手机号_日期_标题 + 名字**右锚定**，和视频文件名同一套规则（末尾可省编号 → 日期 → **紧挨日期的那一段是名字**）； + 名字之前剩下的整段（下划线连回去）就是「标题 || 正文」—— + 所以标题/正文里可以随便带下划线，**只有名字不能带**（`name_error` 统一把关）。 + 与视频文件名的差别：视频名里"名字前面多出段"要**拒收**（那里不该有内容）， + 标题行里则**都算文案**（`标题_带_下划线_小王_20260912` → 名字是最后的 `小王`，前面整段都是标题）。 - 为什么**先右后左**：右锚定是主格式（标题里带下划线也不会错配）。 - 左锚定的四种里先试带编号的 C（`手机号_日期_1_标题` —— 那个 `1` 当编号， - 不当标题的开头），保证同一行永远只有一种解释。 - - 什么时候两种都不会误判：右锚定要求"倒数第 3/2 段是手机号"，左锚定要求 - "第 1 段是手机号、第 2 段是日期" —— 一行同时满足两边时（例如 `手机号_日期_1`） - 右锚定先命中，且标题为空会被下面的校验拒掉，不会静默发出一条错文案。 + 为什么砍掉老的「名字在前」（`名字_日期_编号_标题`）写法：键从手机号换成名字后， + `小王_20260912_1` 这种一行会有两种解释（`1` 是编号还是标题的开头？）， + 只留一种写法，解析结果就没有歧义了。名字写错/漏写会在配到计划行时被**明确拒收** + （"名字 X 没有对应的视频"），不会静默发出一条文不对题的文案。 """ t = (line or "").strip() if not t: return None, "空行" parts = t.split("_") - phone = date = seq = None - title_parts = None - # ① 右锚定：先试带编号的，再试不带编号的 - if len(parts) >= 4 and _SEQ_RE.match(parts[-1]) \ - and _DATE8_RE.match(parts[-2]) and _PHONE_RE.match(parts[-3]): - seq = int(parts[-1]) - phone, date8, title_parts = parts[-3], parts[-2], parts[:-3] - elif len(parts) >= 3 and _DATE8_RE.match(parts[-1]) and _PHONE_RE.match(parts[-2]): - phone, date8, title_parts = parts[-2], parts[-1], parts[:-2] - # ② 左锚定（手机号在前，跟视频文件名同序）：同样先试带编号的 - elif len(parts) >= 4 and _PHONE_RE.match(parts[0]) and _DATE8_RE.match(parts[1]) \ - and _SEQ_RE.match(parts[2]): - phone, date8, seq = parts[0], parts[1], int(parts[2]) - title_parts = parts[3:] - elif len(parts) >= 3 and _PHONE_RE.match(parts[0]) and _DATE8_RE.match(parts[1]): - # `手机号_日期_1` 这种"只有编号、没有标题"要**拒掉**，不能被当成标题"1" - # （静默生成一条标题是"1"的文案，比拒收危险得多；标题真是纯数字就用"标题在前"的写法） - if len(parts) == 3 and _SEQ_RE.match(parts[2]): - return None, ("只有手机号/日期/编号、没有标题文字 ——" - "标题是纯数字的话请用「标题_手机号_日期」写法") - phone, date8, title_parts = parts[0], parts[1], parts[2:] + if len(parts) >= 3 and _SEQ_RE.match(parts[-1]) and _DATE8_RE.match(parts[-2]): + seq, date8, rest = int(parts[-1]), parts[-2], parts[:-2] + elif len(parts) >= 2 and _DATE8_RE.match(parts[-1]): + seq, date8, rest = None, parts[-1], parts[:-1] else: - return None, ("格式不对，应为「标题内容_手机号_日期_编号」" - "或「手机号_日期_编号_标题」（编号都可省略）") + return None, ("格式不对，应为「标题 || 正文_名字_日期_编号」" + "（编号可省略；日期是 8 位数字，如 20260912）") d = parse_date8(date8) if not d: return None, f"日期 {date8} 不是合法日期（应为 20260912 这种 8 位）" - date = d - raw = "_".join(title_parts).strip() - # 「标题 || 正文」：用 `||` 分隔（标题/正文里常带下划线，所以不能再用下划线分列）。 - # 只切第一处：正文自己再出现 `||` 也原样保留。没写 `||` 就是只有标题（老文件照收）。 + name = (rest[-1] or "").strip() + err = name_error(name) + if err: + return None, err + raw = "_".join(rest[:-1]).strip() + # 「标题 || 正文」：只切第一处；没写 `||` 就是只有标题（正文留空） title, body = raw, "" if "||" in raw: title, body = (x.strip() for x in raw.split("||", 1)) if not title and not body: - return None, "缺标题/正文内容（只有手机号/日期/编号，没有文字）" + return None, "缺标题/正文内容（只有名字/日期/编号，没有文字）" if len(title) > MAX_TITLE_LEN: return None, f"标题太长（{len(title)} 字 > {MAX_TITLE_LEN} 字上限），请改短或拆成两条" if len(body) > MAX_BODY_LEN: return None, f"正文太长（{len(body)} 字 > {MAX_BODY_LEN} 字上限），请改短或拆成两条" - return {"title": title, "body": body, "phone": phone, "date": date, + return {"title": title, "body": body, "name": name, "date": d, "seq": seq, "seq_given": seq is not None}, "" def parse_titles_text(text): """标题 txt 全文 → (rows, errors)。空行跳过；`#` 开头**只有认不出标题行时**才算注释。 - ⚠ 顺序是"先当标题解析、再当注释"：`#中秋快乐_19286456013_20260929` 是一条**正常标题** + ⚠ 顺序是"先当标题解析、再当注释"：`#中秋快乐_小王_20260929` 是一条**正常标题** （`#话题` 本来就长这样），过去的写法会把整行当注释**静默丢掉**。现在只有像 - `# 这是注释` 这种解析不出手机号/日期的行才按注释忽略。 + `# 这是注释` 这种解析不出名字/日期的行才按注释忽略。 """ rows, errors = [], [] lines = (text or "").replace("\r\n", "\n").replace("\r", "\n").split("\n") @@ -272,15 +297,14 @@ def assign_slot(explicit_seq, taken): return next_free_slot(taken) -def pair_slots(videos, titles, accounts_by_phone, db_taken=None): - """批量配对的**语义参考实现**（纯函数）：把一批视频与一批标题配成 (账号,日期,编号)。 +def pair_slots(videos, titles, db_taken=None): + """批量配对的**语义参考实现**（纯函数）：把一批视频与一批标题配成 (名字,日期,编号)。 videos / titles：`parse_video_name` / `parse_title_line` 的返回（可带 "ref" 标识来源） - accounts_by_phone：{手机号: [账号 dict, ...]} - db_taken：{(手机号,日期): {已用编号}} —— 分两批上传时不能从 1 重号 + db_taken：{(名字,日期): {已用编号}} —— 分两批上传时不能从 1 重号 - 返回 (pairs, rejected)：pairs=[{"video","title","phone","date","seq","seq_auto"}]。 - 规则：手机号在台账里 0 条或 ≥2 条 → 整组拒收；同侧编号重复 → 两条都拒收； + 返回 (pairs, rejected)：pairs=[{"video","title","name","date","seq","seq_auto"}]。 + 规则：**名字就是账号**（不再查任何台账）；同侧编号重复 → 两条都拒收； 没编号的视频填空位；**没编号的标题按号升序配到"还没有标题的视频"上** （即"第 1 个视频配第 1 条标题"，与逐条上传时 `import_titles()` 的行为一致 —— 两处必须是同一套规则，不然批量路径与日常路径会给出不同结果）； @@ -290,7 +314,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None): db_taken = db_taken or {} def _key(m): - return (m.get("phone") or "", m.get("date") or "") + return (m.get("name") or "", m.get("date") or "") def _reject(side, meta, reason): rejected.append({"side": side, "ref": meta.get("ref") or meta.get("title") @@ -302,15 +326,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None): buckets.setdefault(_key(m), {}).setdefault(side, []).append(m) for key, sides in buckets.items(): - phone, date = key - accs = accounts_by_phone.get(phone) or [] - if len(accs) != 1: - reason = (f"手机号 {phone} 不在账号台账里" if not accs - else f"手机号 {phone} 在台账里对应 {len(accs)} 个账号，无法确定是哪个") - for side in ("video", "title"): - for m in sides.get(side, []): - _reject(side, m, reason) - continue + name, date = key taken = set(db_taken.get(key) or set()) # 显式编号：先占位，同侧重复 → 两条都拒收 for side in ("video", "title"): @@ -341,7 +357,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None): vmap = {} for m in vids: s = int(m["seq"]) if m.get("seq_given") else assigned.get(id(m)) - vmap[s] = {"video": m, "title": None, "phone": phone, "date": date, + vmap[s] = {"video": m, "title": None, "name": name, "date": date, "seq": s, "seq_auto": not m.get("seq_given")} # 标题 → 槽位：有编号的精确对；没编号的填进还没配到标题的槽位（按号升序） free_slots = sorted(vmap.keys()) @@ -351,7 +367,7 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None): if s in vmap and vmap[s]["title"] is None: vmap[s]["title"] = m else: - _reject("title", m, f"编号 {s} 没有对应的视频（该账号 {date} 没有这条）") + _reject("title", m, f"编号 {s} 没有对应的视频（该名字 {date} 没有这条）") else: s = assigned.get(id(m)) if s in vmap and vmap[s]["title"] is None: @@ -360,13 +376,13 @@ def pair_slots(videos, titles, accounts_by_phone, db_taken=None): # 号被别的标题占了 → 退到第一个还没标题的槽位 target = next((x for x in free_slots if vmap[x]["title"] is None), None) if target is None: - _reject("title", m, f"没有对应视频（该账号 {date} 的视频都有标题了）") + _reject("title", m, f"没有对应视频（该名字 {date} 的视频都有标题了）") else: vmap[target]["title"] = m else: - _reject("title", m, f"没有对应视频（该账号 {date} 没有视频）") + _reject("title", m, f"没有对应视频（该名字 {date} 没有视频）") pairs.extend(vmap.values()) - pairs.sort(key=lambda p: (p["date"], p["phone"], p["seq"])) + pairs.sort(key=lambda p: (p["date"], p["name"], p["seq"])) return pairs, rejected @@ -432,14 +448,65 @@ def _has_type(steps, want): def build_push_step(label="推送发布视频（平台）"): - """「推送发布视频」步骤（骨架与「给已有任务插一步」共用这一处定义）。""" + """「推送发布视频」步骤（骨架与「给已有任务插一步」共用这一处定义）。 + + `account=name`（默认）= 用**本次要发的那个名字**（`_vars` 里的目标/刚读到的名字）取计划， + 并且**推送前会再读一次屏幕上的昵称核对**；`account=phone` 是老路径（手填手机号）。 + """ return {"id": f"step_rel_push_{uuid.uuid4().hex[:6]}", "type": "push_release", "label": label, - "params": {"date_source": "today", "fixed_date": "", "account": "device", + "params": {"date_source": "today", "fixed_date": "", "account": "name", "account_phone": "", "album_dir": "/sdcard/DCIM/Camera", "to_clipboard": True, "retry_failed": True, "max_same_run": 1}} +def build_read_name_step(label="读取本机账号名字（平台）", selector_value=None): + """「读取本机账号名字」步骤（骨架与"给已有任务插一步"共用）。 + + `selector_value=None` = 用 `config.DOUYIN_NAME_SELECTOR_VALUE`（**抓一次填 .env**， + 与「按名字找设备」的实时探测共用同一处配置）；显式传值则用它。 + 两者都为空 = **还没抓**：执行器会明确报"请抓取元素"，绝不会猜一个名字去发。 + """ + from config import DOUYIN_NAME_SELECTOR_TYPE, DOUYIN_NAME_SELECTOR_VALUE + sel = DOUYIN_NAME_SELECTOR_VALUE if selector_value is None else selector_value + return {"id": f"step_rel_name_{uuid.uuid4().hex[:6]}", "type": "read_account_name", + "label": label, + "params": {"selector_type": DOUYIN_NAME_SELECTOR_TYPE or "xpath", + "selector_value": sel, + "timeout": 8, "on_missing": "fail", "probability": 100}} + + +def build_switch_step(label="切换账号（切到本次要发的那个名字）"): + """「切换账号」步骤。 + + `switch_selector_value` 取 `config.DOUYIN_SWITCH_SELECTOR_VALUE`（**抓一次填 .env**）： + 进「账号切换」列表那一下；留空则这一步会报"请抓取元素"并跳过（不会瞎点）。 + """ + from config import DOUYIN_SWITCH_SELECTOR_TYPE, DOUYIN_SWITCH_SELECTOR_VALUE + return {"id": f"step_rel_sw_{uuid.uuid4().hex[:6]}", "type": "switch_account", + "label": label, + "params": {"target": "var:target_name", "target_value": "", + "switch_selector_type": DOUYIN_SWITCH_SELECTOR_TYPE or "xpath", + "switch_selector_value": DOUYIN_SWITCH_SELECTOR_VALUE, + "name_selector_type": "", "name_selector_value": "", + "me_selector_type": "descriptionContains", "me_selector_value": "我", + "timeout": 8, "verify": True, "max_attempts": 2, + "on_login_page": "stop", "probability": 100}} + + +def build_foreach_step(children=None, label="循环本机待发的号（一轮跑完，一直切到发完）"): + """「循环本机待发的号」容器步骤（`foreach_account`）—— 发布骨架的最外层。 + + 数据源是**计划表**（`pending_names`）：谁还有待发内容谁就被选中， + 所以"本机该发哪些号"不需要任何账号维护。 + """ + return {"id": f"step_rel_fe_{uuid.uuid4().hex[:6]}", "type": "foreach_account", + "label": label, + "params": {"date_source": "today", "fixed_date": "", "retry_failed": True, + "max_accounts": 0, "children": list(children or []), + "probability": 100}} + + def build_mark_step(label="标记发布结果（平台）"): """「标记发布结果」步骤（同上，共用一处定义）。""" return {"id": f"step_rel_mark_{uuid.uuid4().hex[:6]}", "type": "mark_release", @@ -473,14 +540,15 @@ def build_release_steps(): "等抖音号出现"必然超时，最后显示成一句误导人的"账号不符"。 屏幕亮着时冷启动 5 秒就出底部栏。 - **平台能保证的步骤都填好了**（推送 / 填标题 / 标记 + 账号校验）， + **平台能保证的步骤都填好了**（读名字 / 推送 / 填标题 / 标记 + 账号校验）， 抖音里的点击步骤只给出**空选择器的占位**（标签写清楚该抓哪个）， 因为那些是混淆 id / 结构 xpath，写死了改版就废 —— 执行时会明确提示 "selector_value 为空，请抓取元素"，不会静默跳过。 - 唯一预填了选择器的是底部「+」入口（`descriptionContains=拍摄`）与 - 「我」（`descriptionContains=我`），因为这两条我在真机上实测过、 - 且是按描述定位、跨版本相对稳。 + 预填了选择器的只有底部「+」入口（`descriptionContains=拍摄`）与 + 「我」（`descriptionContains=我`），因为这两条在真机上实测过、 + 且是按描述定位、跨版本相对稳。**「我」页面上的昵称控件留空待抓** + （`read_account_name` 与守卫都用它，抓一次两处都填）。 """ def sid(name): return f"step_rel_{name}_{uuid.uuid4().hex[:6]}" @@ -490,27 +558,51 @@ def build_release_steps(): "params": {"selector_type": sel_type or "xpath", "selector_value": sel_val, "wait_timeout": 8, "probability": 100}} - # 命中（当前登录的就是这条计划要发的号）才走发布流程；未命中走 else 只发通知。 - # 账号校验用**现成的「条件判断」+ 候选值来源=发布计划**，平台不自作主张读账号。 + # 命中（当前登的就是这次要发的那个名字）才走发布流程；未命中走 else 只发通知。 + # 账号校验用**现成的「条件判断」+ 候选值来源=本次要发的名字**（`account_target`）： + # 候选值取自 `_vars`（循环设的目标名字，或刚读到的名字），元素原文取昵称控件。 + # **只用「包含」，绝不能用「不等于」** —— 读不到名字时候选为空， + # "空 != 候选"会命中，把"读不到"误判成"可以发"。 publish_flow_steps = [ - dict(build_push_step("⑤ 推送发布视频")), - clk("open", "⑥ 点击抖音底部「+」（实测可用；改版了重新抓）", + dict(build_push_step("⑦ 推送发布视频")), + clk("open", "⑧ 点击抖音底部「+」（实测可用；改版了重新抓）", "descriptionContains", "拍摄"), - clk("album", "⑦ 点击「相册」（没命中的话用抓取元素选它）"), - clk("video", "⑧ 点击第一个视频（刚推的排最前；抓一次就行）"), - clk("next", "⑨ 点击「下一步」"), - clk("input", "⑩ 点击输入框（抖音发布页的文案框）"), + clk("album", "⑨ 点击「相册」（没命中的话用抓取元素选它）"), + clk("video", "⑩ 点击第一个视频（刚推的排最前；抓一次就行）"), + clk("next", "⑪ 点击「下一步」"), + clk("input", "⑫ 点击标题框（抖音发布页的文案框）"), {"id": sid("title"), "type": "input_text", - "label": "⑪ 填标题（自动取这一条计划的标题，会回读校验）", + "label": "⑬ 填标题（自动取这一条计划的标题，会回读校验）", "params": {"text_source": "release_title", "release_topics": "", "clear_first": True, "mode": "random", "texts": "", "fixed_text": ""}}, - clk("body", "⑫ 点击正文输入框（发布页的文案框）"), + clk("body", "⑭ 点击正文框（发布页的正文框）"), {"id": sid("bodytxt"), "type": "input_text", - "label": "⑬ 填正文（自动取这一条计划的正文，会回读校验）", + "label": "⑮ 填正文（自动取这一条计划的正文，会回读校验）", "params": {"text_source": "release_body", "release_topics": "", "clear_first": True, "mode": "random", "texts": "", "fixed_text": ""}}, - clk("publish", "⑭ 点击「发布」"), - dict(build_mark_step("⑮ 标记发布结果（成功走这里；失败分支再放一个 result=failed）")), + clk("publish", "⑯ 点击「发布」"), + dict(build_mark_step("⑰ 标记发布结果（成功走这里；失败分支再放一个 result=failed）")), + ] + # 循环体：切号 → 读名字 → 校验 → 推送 → 发布 → 标记。 + # `switch_account` 自己会先看"当前是不是已经是目标"（第一个号不用切）， + # 也会处理"本机没登这个号"（直接跳过、不重试）。 + loop_body = [ + dict(build_switch_step("③ 切换账号（切到本次要发的那个名字；已在该号则直接过）")), + dict(build_read_name_step("④ 读取本机当前账号名字（昵称控件选择器待抓）")), + {"id": sid("check"), "type": "if_el", + "label": "⑤ 校验账号：当前登的是不是这次要发的那个名字", + "params": {"selector_type": "xpath", + "selector_value": "", + "timeout": 8, "cmp_op": "包含", "cmp_source": "account_target", + "cmp_value": "", "cmp_group": "", + "ident_type": "text", "ident_value": "", + "then": publish_flow_steps, + "else": [{"id": sid("else"), "type": "notify", + "label": "账号不符/读不到：本条跳过（不发）", + "params": {"title": "发布跳过：账号不符", + "message": "设备 {device} 当前登的不是要发的号" + "（或读不到昵称），本条已跳过、没发出去", + "level": "warning"}}]}}, ] return [ {"id": sid("light"), "type": "screen_on", "label": "⓪ 亮屏", @@ -518,23 +610,9 @@ def build_release_steps(): {"id": sid("openapp"), "type": "open_app", "label": "① 打开抖音（等「首页」出来）", "params": {"package": "com.ss.android.ugc.aweme", "home_feature": "首页", "wait_home": True, "probability": 100}}, - clk("me", "② 点击「我」（实测可用；改版了重新抓）", "descriptionContains", "我"), - {"id": sid("wait"), "type": "wait", "label": "③ 等「我」页加载出来", - "params": {"min": 3, "max": 5, "vary_pace": False, "probability": 100}}, - {"id": sid("check"), "type": "if_el", - "label": "④ 校验账号：当前登录的是不是这条计划要发的号", - "params": {"selector_type": "xpath", - "selector_value": "//*[contains(@text,'抖音号')]", - "timeout": 8, "cmp_op": "包含", "cmp_source": "release", - "cmp_value": "", "cmp_group": "", - "ident_type": "text", "ident_value": "", - "then": publish_flow_steps, - "else": [{"id": sid("else"), "type": "notify", - "label": "账号不符：本条跳过（不发）", - "params": {"title": "发布跳过：账号不符", - "message": "设备 {device} 当前登录的不是要发的号" - "（计划：见「账号 → 发布计划」），本条已跳过", - "level": "warning"}}]}}, + # 一轮把本机待发的号跑完：数据源是**计划表**（谁还有待发内容谁就在里面）， + # 不需要任何账号维护；停止/超时/上限三个出口见 `_exec_foreach_account` + dict(build_foreach_step(loop_body, "② 循环本机待发的号（一直切号发，直到发完）")), ] @@ -554,21 +632,10 @@ def safe_name(name): # ================== DB 服务区 ================== -def accounts_by_phone(): - """{手机号: [账号 dict, ...]}（配对用；同号多账号要能看出来）。""" +def taken_slots(name, date): + """该名字该日期已占用的编号集合（分两批上传时不能从 1 重号）。""" with _ctx(): - out = {} - for r in DeviceAccount.query.all(): - p = (r.phone or "").strip() - if p: - out.setdefault(p, []).append(r.to_dict()) - return out - - -def taken_slots(phone, date): - """该账号该日期已占用的编号集合（分两批上传时不能从 1 重号）。""" - with _ctx(): - rows = VideoPlan.query.filter(VideoPlan.phone == phone, + rows = VideoPlan.query.filter(VideoPlan.nickname == name, VideoPlan.release_date == date).all() return {int(r.seq or 1) for r in rows} @@ -622,39 +689,25 @@ def store_video(file_storage): def upload_video(file_storage, order=None, replace=False): - """上传单个视频 → 解析 → 配对 → 落库。返回给接口用的 dict。 + """上传单个视频 → 解析名字 → 落库。返回给接口用的 dict。 - 幂等：同槽位已有行时 —— `sha1` 相同 → skip；不同 → **拒收**（除非 `replace=True`）。 + **名字就是账号**（抖音昵称），不查任何台账：`名字_日期_编号` 里的名字原样写进 + `video_plan.nickname`，运行时按这个名字找设备、取计划。 + + 幂等：同一 (名字, 日期, 编号) 已有行时 —— `sha1` 相同 → skip；不同 → **拒收**（除非 `replace=True`）。 """ name = getattr(file_storage, "filename", "") or "" meta, err = parse_video_name(name) if err: return {"ok": False, "name": name, "error": err} - phone, date = meta["phone"], meta["date"] - accs = accounts_by_phone().get(phone) or [] - if not accs: - return {"ok": False, "name": name, - "error": f"手机号 {phone} 不在「账号」台账里（先在台账登记这个号，或改文件名）"} - if len(accs) > 1: - return {"ok": False, "name": name, - "error": f"手机号 {phone} 在台账里对应 {len(accs)} 个账号（" - f"{'、'.join(a['device_name'] for a in accs)}），无法确定是哪个"} - acc = accs[0] - if not acc.get("serial"): - # 台账是粘贴导入的老记录时可能没存上地址快照（导入那一刻设备池里没匹配上）—— - # 现查一次补上，别把空快照带进计划行（发布时要用"当前地址"） - try: - from core import ledger as _ledger - acc = dict(acc, serial=_ledger.serial_of(acc.get("device_name") or "")) - except Exception: - pass + acct, date = meta["name"], meta["date"] try: with _ctx(): - taken = taken_slots(phone, date) + taken = taken_slots(acct, date) # 文件名里**写了编号就认它**（哪怕这个号已被占 —— 那正是"重复上传/要覆盖" # 的场景，交给下面的 sha1 判据处理）；没写编号才自动排到空位 seq = int(meta["seq"]) if meta["seq_given"] else next_free_slot(taken) - old = VideoPlan.query.filter(VideoPlan.phone == phone, + old = VideoPlan.query.filter(VideoPlan.nickname == acct, VideoPlan.release_date == date, VideoPlan.seq == seq).first() existed = old.to_dict() if old else None @@ -664,17 +717,16 @@ def upload_video(file_storage, order=None, replace=False): # 同一份内容：库里的行用的就是同一个（内容寻址）文件， # **绝不能删**它 —— 删了这个已引用的文件就没了 return {"ok": True, "name": name, "action": "skip", "plan": existed, - "msg": f"{phone} {date} 编号{seq} 已经传过这个文件了（跳过）"} + "msg": f"{acct} {date} 编号{seq} 已经传过这个文件了（跳过）"} if not replace: _remove_video_file(rel) # 内容不同 → 这是刚写的新文件，没人引用，删掉 return {"ok": False, "name": name, "error": f"该槽位已有视频 {existed['video_name']}（编号{seq}）——" f"要换先删掉它，或在结果里点「覆盖」"} delete_plan(existed["id"]) # 覆盖：删旧行与旧文件（旧内容若与新内容同，不会被删） - row = VideoPlan(id=uuid.uuid4().hex[:8], account_id=acc.get("id", ""), - phone=phone, device_name=acc.get("device_name", ""), - nickname=acc.get("nickname", ""), douyin_id=acc.get("douyin_id", ""), - serial=acc.get("serial", ""), release_date=date, seq=seq, + row = VideoPlan(id=uuid.uuid4().hex[:8], account_id="", + phone="", device_name="", nickname=acct, douyin_id="", + serial="", release_date=date, seq=seq, seq_auto=not meta["seq_given"], video_file=rel, video_name=name[:200], video_size=size, video_sha1=digest, status=ST_PENDING, created_at=_now(), updated_at=_now()) @@ -682,11 +734,11 @@ def upload_video(file_storage, order=None, replace=False): db.session.add(row) db.session.commit() out = row.to_dict() - _log.info(f"发布计划新增：{phone} {date} 编号{seq} {name}（{size} 字节）" + _log.info(f"发布计划新增：{acct} {date} 编号{seq} {name}（{size} 字节）" f"{'覆盖' if existed else ''}") return {"ok": True, "name": name, "action": "replace" if existed else "add", "plan": out, - "msg": f"已录入：{acc.get('device_name')} / {date} / 编号{seq}" + "msg": f"已录入：{acct} / {date} / 编号{seq}" f"（{'待标题' if not (existed or {}).get('title') else '取旧标题'}）"} except Exception as e: _log.warning(f"视频上传失败: {e}") @@ -711,23 +763,15 @@ def import_titles(text, dry_run=False): rows, errors = parse_titles_text(text) counts = {"total": len(rows) + len(errors), "attached": 0, "skipped": 0, "rejected": len(errors)} - out = [{"line": e["line"], "phone": "", "date": "", "seq": 0, "title": "", + out = [{"line": e["line"], "name": "", "date": "", "seq": 0, "title": "", "action": "reject", "error": e["reason"]} for e in errors] with _ctx(): - accs = accounts_by_phone() for m in rows: - phone, date = m["phone"], m["date"] - item = {"line": m.get("_line", 0), "phone": phone, "date": date, + acct, date = m["name"], m["date"] + item = {"line": m.get("_line", 0), "name": acct, "date": date, "seq": m.get("seq") or 0, "title": m["title"], "action": "", "error": ""} - if len(accs.get(phone) or []) != 1: - item["action"] = "reject" - item["error"] = (f"手机号 {phone} 不在账号台账里" if not accs.get(phone) - else f"手机号 {phone} 在台账里对应多个账号") - out.append(item) - counts["rejected"] += 1 - continue - q = VideoPlan.query.filter(VideoPlan.phone == phone, + q = VideoPlan.query.filter(VideoPlan.nickname == acct, VideoPlan.release_date == date) if m["seq_given"]: row = q.filter(VideoPlan.seq == int(m["seq"])).first() @@ -735,9 +779,9 @@ def import_titles(text, dry_run=False): row = (q.filter(VideoPlan.title == "").order_by(VideoPlan.seq).first()) if not row: item["action"] = "reject" - item["error"] = (f"该账号 {date} 没有编号 {m['seq']} 的视频" + item["error"] = (f"该名字 {date} 没有编号 {m['seq']} 的视频" if m["seq_given"] else - f"该账号 {date} 没有待配标题的视频（请先上传视频）") + f"该名字 {date} 没有待配标题的视频（请先上传视频）") out.append(item) counts["rejected"] += 1 continue @@ -791,10 +835,12 @@ def _sync_content_status(row): row.status = ST_PENDING -def set_title(plan_id, title, body=None): - """人工改标题 /（可选）正文，改完按"有没有内容"切 pending/ready。 +def set_title(plan_id, title, body=None, nickname=None): + """人工改标题 /（可选）正文 /（可选）**名字**，改完按"有没有内容"切 pending/ready。 `body=None` = **不动正文**（老调用方语义不变）；传空串 = 清掉正文。 + `nickname` = 改**识别键**（文件名写错了、或抖音上改了名时的**唯一补救手段**）—— + 同样走 `name_error` 那把尺子（不许含下划线/不许纯数字），不合法直接拒收。 """ title = (title or "").strip() if len(title) > MAX_TITLE_LEN: @@ -803,6 +849,12 @@ def set_title(plan_id, title, body=None): body = (body or "").strip() if len(body) > MAX_BODY_LEN: return None, f"正文太长（上限 {MAX_BODY_LEN} 字）" + new_name = None + if nickname is not None: + new_name = (nickname or "").strip() + err = name_error(new_name) + if err: + return None, f"名字不对：{err}" with _ctx(): row = VideoPlan.query.get(plan_id) if not row: @@ -810,6 +862,8 @@ def set_title(plan_id, title, body=None): row.title = title if body is not None: row.body = body + if new_name is not None: + row.nickname = new_name _sync_content_status(row) row.updated_at = _now() db.session.commit() @@ -848,7 +902,7 @@ def delete_plan(plan_id, delete_file=True): return True -def list_plans(date_from="", date_to="", status="", account_id="", q="", limit=500): +def list_plans(date_from="", date_to="", status="", q="", limit=500): """时间线用：按日期区间/状态/账号/关键词取行（按日期、设备号、编号排序）。""" with _ctx(): query = VideoPlan.query @@ -860,8 +914,6 @@ def list_plans(date_from="", date_to="", status="", account_id="", q="", limit=5 want = [s for s in status.split(",") if s in STATUSES] if want: query = query.filter(VideoPlan.status.in_(want)) - if account_id: - query = query.filter(VideoPlan.account_id == account_id) if q: like = f"%{q.strip()}%" query = query.filter(db.or_(VideoPlan.phone.like(like), @@ -870,14 +922,14 @@ def list_plans(date_from="", date_to="", status="", account_id="", q="", limit=5 VideoPlan.nickname.like(like), VideoPlan.douyin_id.like(like), VideoPlan.device_name.like(like))) - rows = (query.order_by(VideoPlan.release_date, VideoPlan.device_name, + rows = (query.order_by(VideoPlan.release_date, VideoPlan.nickname, VideoPlan.seq).limit(max(1, min(int(limit or 500), 5000))).all()) return [r.to_dict() for r in rows] -def timeline(date_from="", date_to="", status="", account_id="", q="", limit=500): +def timeline(date_from="", date_to="", status="", q="", limit=500): """时间线数据：按日期分组的卡片 + 顶部统计 + 磁盘。""" - rows = list_plans(date_from, date_to, status, account_id, q, limit) + rows = list_plans(date_from, date_to, status, q, limit) days = {} today = _today() for r in rows: @@ -913,7 +965,7 @@ def stats(rows=None): "unknown": 0, "skipped": 0, "pushing": 0, "publishing": 0, "today_ready": 0, "today_done": 0, "today_devices": 0, "published_today": 0, "overdue": 0, "no_link": 0} - today_devs = set() + today_names = set() # 今天要发的**号**（计划不绑设备了，"几个号"才是有意义的量） for r in rows: st = r["status"] if st in out: @@ -921,8 +973,8 @@ def stats(rows=None): if r["release_date"] == today: if st in (ST_PENDING, ST_READY, ST_PUSHING, ST_PUBLISHING, ST_FAILED): out["today_ready"] += 1 - if r["device_name"]: - today_devs.add(r["device_name"]) + if r["nickname"]: + today_names.add(r["nickname"]) if st == ST_DONE: out["today_done"] += 1 elif r["release_date"] < today and st in (ST_PENDING, ST_READY, ST_FAILED): @@ -931,7 +983,9 @@ def stats(rows=None): out["published_today"] += 1 if st == ST_DONE and not r["share_url"]: out["no_link"] += 1 - out["today_devices"] = len(today_devs) + # 键名保留 `today_devices`（前端在用）：口径已改成"今天要发的**名字**个数" —— + # 计划不再绑设备，"几台设备"没有意义，"几个号"才是用户看的那个数 + out["today_devices"] = len(today_names) return out @@ -957,7 +1011,7 @@ def disk_info(): "videos_count": count} -def links(date_from="", date_to="", device="", phone=""): +def links(date_from="", date_to="", name=""): """已发布作品的分享链接（导出 CSV / 界面展示用）。""" with _ctx(): query = VideoPlan.query.filter(VideoPlan.share_url != "") @@ -965,24 +1019,24 @@ def links(date_from="", date_to="", device="", phone=""): query = query.filter(VideoPlan.release_date >= date_from) if date_to: query = query.filter(VideoPlan.release_date <= date_to) - if device: - query = query.filter(VideoPlan.device_name == device) - if phone: - query = query.filter(VideoPlan.phone == phone) - rows = query.order_by(VideoPlan.release_date, VideoPlan.device_name, + if name: + query = query.filter(VideoPlan.nickname == name) + rows = query.order_by(VideoPlan.release_date, VideoPlan.nickname, VideoPlan.seq).all() return [r.to_dict() for r in rows] # ================== 发布：取计划 / 占位 / 回写 ================== -def take_for_device(phones, date, limit=1, retry_failed=True): - """本机某天可发的计划行（按发布日期、编号升序）。`phones` = 这台设备上账号的手机号。""" - if not phones: +# 取计划的**口径只在这两个内部函数里定义一次**（按列 + 日期 + 状态 + 尝试次数 + 排序）。 +# 口径分叉 = 同一个号被发两遍 或 永远发不出去，所以不许在别处再写一套 where。 +def _take(column, values, date, limit=1, retry_failed=True): + """按某一列（`nickname` / 老路径的 `phone`）取候选行 —— **只读，不占位**（占位是 `claim()`）。""" + if not values: return [] want = [ST_READY] + ([ST_FAILED] if retry_failed else []) with _ctx(): rows = (VideoPlan.query - .filter(VideoPlan.phone.in_(list(phones))) + .filter(column.in_(list(values))) .filter(VideoPlan.release_date <= date) .filter(VideoPlan.status.in_(want)) .filter(VideoPlan.attempts < MAX_ATTEMPTS) @@ -991,25 +1045,103 @@ def take_for_device(phones, date, limit=1, retry_failed=True): return [r.to_dict() for r in rows] -def peek_for_device(phones, date): +def _peek(column, values, date): + rows = _take(column, values, date, limit=1) + return rows[0] if rows else None + + +def _last_pushed(column, values): + if not values: + return None + with _ctx(): + row = (VideoPlan.query.filter(column.in_(list(values))) + .filter(VideoPlan.status == ST_PUSHING) + .order_by(VideoPlan.updated_at.desc()).first()) + return row.to_dict() if row else None + + +def take_for_name(names, date, limit=1, retry_failed=True): + """**本机某天可发的计划行（主路径：按名字）**，按 `(发布日期, 编号)` 升序。 + + 名字 = 上传文件名里的名字 = 抖音昵称；运行时的顺序是「读当前账号名 → 用它取计划」。 + 队列口径：`发布日期 <= date`（**过期会补发、未来的不发**）、`status ∈ (ready, failed)`、 + `attempts < 3`。 + """ + return _take(VideoPlan.nickname, names, date, limit, retry_failed) + + +def peek_for_name(names, date): """本机**下一条将要推送**的计划（只看不占位）——条件判断的"候选值来源=发布计划"用它。 为什么用"下一条"而不是"已推送的那条"：账号校验要放在**推送之前** （号不对就不该推），那时候还没占位、也没有 `_last_release`。 """ - rows = take_for_device(phones, date, limit=1) - return rows[0] if rows else None + return _peek(VideoPlan.nickname, names, date) + + +def last_pushed_for_name(names): + """本机最近一条"已推到手机、还没标记结果"的计划（`mark_release` 找不到上一步时的兜底）。""" + return _last_pushed(VideoPlan.nickname, names) + + +def take_for_device(phones, date, limit=1, retry_failed=True): + """老路径：按**手机号**取（账号台账停用后不再被骨架使用，留着给还在传 phones 的老任务）。""" + return _take(VideoPlan.phone, phones, date, limit, retry_failed) + + +def peek_for_device(phones, date): + return _peek(VideoPlan.phone, phones, date) def last_pushed_for_device(phones): - """本机最近一条"已推到手机、还没标记结果"的计划（`mark_release` 找不到上一步时的兜底）。""" - if not phones: - return None + return _last_pushed(VideoPlan.phone, phones) + + +def pending_names(date="", retry_failed=True, names=None, limit=0): + """**现在还有待发内容的名字**，按最早 `(发布日期, 编号)` 排序。 + + `foreach_account` 的"本机该发哪些号"就靠它 —— **直接由计划表回答**： + 谁还有待发内容谁就在列表里，不需要任何台账/账号维护。查库不读屏， + 所以已经发完的号根本不会被选中（省掉一次切号）。 + + 每个名字只返回一条（该名字下**最早**的那条待发计划），给循环按先后顺序挑号用。 + `names` 传了就只在这些名字里挑（本机"已登录的号"用它做交集）。 + """ + date = date or _today() + want = [ST_READY] + ([ST_FAILED] if retry_failed else []) with _ctx(): - row = (VideoPlan.query.filter(VideoPlan.phone.in_(list(phones))) - .filter(VideoPlan.status == ST_PUSHING) - .order_by(VideoPlan.updated_at.desc()).first()) - return row.to_dict() if row else None + q = (VideoPlan.query + .filter(VideoPlan.nickname != "") + .filter(VideoPlan.release_date <= date) + .filter(VideoPlan.status.in_(want)) + .filter(VideoPlan.attempts < MAX_ATTEMPTS)) + if names: + q = q.filter(VideoPlan.nickname.in_([n for n in names if n])) + # 名字做第三排序键：同日期同编号时给个**确定的**先后（不然每轮顺序会变） + rows = q.order_by(VideoPlan.release_date, VideoPlan.seq, VideoPlan.nickname).all() + out, seen = [], set() + for r in rows: + n = r.nickname or "" + if not n or n in seen: + continue + seen.add(n) + out.append({"name": n, "release_date": r.release_date, + "seq": r.seq, "plan_id": r.id}) + return out[:int(limit)] if limit else out + + +def pending_count(name, date="", retry_failed=True): + """某个名字现在还有几条待发（`foreach_account` 内层靠它判断"这个号还有没有得发"）。""" + if not name: + return 0 + date = date or _today() + want = [ST_READY] + ([ST_FAILED] if retry_failed else []) + with _ctx(): + return (VideoPlan.query + .filter(VideoPlan.nickname == name) + .filter(VideoPlan.release_date <= date) + .filter(VideoPlan.status.in_(want)) + .filter(VideoPlan.attempts < MAX_ATTEMPTS).count()) def claim(plan_id, status=ST_PUSHING, stage="push"): @@ -1043,12 +1175,12 @@ def pushable_plans(date="", limit=0, retry_failed=True): sts = [ST_READY] + ([ST_FAILED] if retry_failed else []) q = q.filter(VideoPlan.status.in_(sts)) q = q.filter(VideoPlan.attempts < MAX_ATTEMPTS) - q = q.order_by(VideoPlan.device_name, VideoPlan.seq) + q = q.order_by(VideoPlan.nickname, VideoPlan.seq) rows = q.limit(limit).all() if limit else q.all() return [r.to_dict() for r in rows] -def mark_pushed(plan_id, remote="", verify=""): +def mark_pushed(plan_id, remote="", verify="", serial="", device_name=""): """推送完成：状态留在 `pushing`（= 已推到手机、等人/用户的步骤去发），阶段置 `manual`。 阶段置 `manual` 是为了僵尸回收时的语义正确：**再出岔子只能算"结果未知"**， @@ -1057,6 +1189,9 @@ def mark_pushed(plan_id, remote="", verify=""): `verify` = 相册校验结果（`ok` 进索引 / `no_index` 没进 / `nofile` 文件不在）， **单独存一列**而不是混进 last_error：文件推上去了就不是失败， 但"相册里看不到它"必须能在界面上看见（后面的步骤要点它）。 + + `serial`/`device_name` = **实际推到哪里**（写进 `posted_*`）：计划不绑设备了， + "这条最后是谁发的"只能由推送时那一台现场记 —— 排查"发到哪台机器去了"全靠它。 """ with _ctx(): row = VideoPlan.query.get(plan_id) @@ -1070,6 +1205,10 @@ def mark_pushed(plan_id, remote="", verify=""): row.push_remote = remote[:200] if verify: row.push_verify = verify[:16] + if serial: + row.posted_serial = serial[:120] + if device_name: + row.posted_device_name = device_name[:80] row.updated_at = _now() db.session.commit() diff --git a/doc/API.md b/doc/API.md index c1e2811..3302847 100644 --- a/doc/API.md +++ b/doc/API.md @@ -139,13 +139,7 @@ | GET | `/api/done_marks?job=&limit=` | L | 去重记录列表 + 统计（`{marks, stats{total,devices,identities,today_devices,today_identities}}`） | | POST | `/api/done_marks/delete` | T | 删一条去重记录（`{id}`）→ 该设备/身份下次会重新执行 | | POST | `/api/done_marks/clear` | T | 清空某任务的全部去重记录（`{job}`）→ 整批重跑 | -| GET | `/api/ledger?device=&q=&limit=` | D | 账号台账列表 + 统计（`{accounts, stats{total,devices,can_post_video,shown}, device_names}`） | -| GET | `/api/ledger/by_device` | D | 按设备分组（`{devices:{设备号:{count,accounts[]}}, counts:{设备号:N}}`） | -| POST | `/api/ledger` | D | 新增账号（抖音号重复 → 400） | -| PUT | `/api/ledger/` | D | 改一条账号 | -| DELETE | `/api/ledger/` | D | 删一条账号 | -| POST | `/api/ledger/import` | D | 从表格粘贴文本批量导入（`dry_run=true` 只预览不写库） | -| POST | `/api/video_plan/upload_video` | D | 上传单个视频素材（文件名 `手机号_日期_编号`）→ 解析 + 配对 + 入计划 | +| POST | `/api/video_plan/upload_video` | D | 上传单个视频素材（文件名 `名字_日期_编号`）→ 解析名字 + 入计划 | | POST | `/api/video_plan/upload_titles` | D | 上传标题（txt 文本或文件）→ 配到已有计划行 | | GET | `/api/video_plan/timeline` | D | 发布计划时间线（按日期分组的卡片 + 统计 + 磁盘） | | GET | `/api/video_plan/stats` | D | 今天要发/已发/待标题/过期未发 + 素材占用与磁盘余量 | @@ -157,7 +151,7 @@ | POST | `/api/video_plan//skip\|retry\|resolve` | D | 跳过 / 重试 / 裁决「结果未知」 | | GET | `/api/video_plan/links` | D | 已发布作品的分享链接（`format=csv` 导出，给铺评论用） | | GET | `/api/video_plan/tasks` | T | 可编辑的任务列表（全部通用步骤任务 + `is_release` 标记：状态/调度/下次运行 + 完整步骤） | -| POST | `/api/video_plan/tasks` | T | 一键新建标准发布任务（骨架 17 步：亮屏 → 打开抖音 → 校验账号 → 推送 → 抖音点击 → 填标题 → 填正文 → 标记） | +| POST | `/api/video_plan/tasks` | T | 一键新建标准发布任务（骨架 18 步：亮屏 → 打开抖音 → 读本机账号名字 → 校验账号 → 推送 → 抖音点击 → 填标题 → 填正文 → 标记） | | GET/PUT | `/api/video_plan/tasks/` | T | **发布任务的就地编辑**（就在「发布计划」页改名字/目标/时间/启停/步骤） | | POST | `/api/video_plan/tasks//adopt` | T | 给已有任务插上平台两步（推送放最前 / 标记放最后，自己的步骤不动） | @@ -505,62 +499,33 @@ 账本表与语义见 [DATA_MODEL.md](DATA_MODEL.md) §2.9；任务侧怎么用见 [TASK_DEV.md](TASK_DEV.md) §4.6。 -### 账号台账（「账号」页） - -数据在 `device_account` 表（[DATA_MODEL.md](DATA_MODEL.md) §2.10），服务层 `core/ledger.py`， -权限 `devices`。 - -| 接口 | 请求 | 响应要点 | -|------|------|---------| -| `GET /api/ledger` | `?device=<设备号>&q=<搜索>&limit=500` | `{ok, accounts:[{id,device_name,serial,phone,nickname,douyin_id,registered_at,sim_in_device,can_post_video,bio,note,created_at,updated_at}], stats:{total,devices,can_post_video,shown}, device_names:["A01",…]}`。`q` 匹配抖音号/手机号/账号名 | -| `GET /api/ledger/by_device` | — | `{ok, devices:{A01:{count,accounts:[…]}}, counts:{A01:4}}`（设备池"账号 N"列 + 点开看明细都用它，省一次请求） | -| `POST /api/ledger` | 9 个字段（`device_name`/`douyin_id` 必填） | `{ok,msg,account}`；缺必填或抖音号重复 → **400** | -| `PUT /api/ledger/` | 局部字段 | `{ok,msg,account}`；不存在 → 404；抖音号撞车 → 400 | -| `DELETE /api/ledger/` | — | `{ok,msg}`；不存在 → 404 | -| `POST /api/ledger/import` | `{"text":"…","delimiter":"\\t","mode":"skip\|overwrite","dry_run":true}` | `{ok, counts:{total,added,updated,skipped,failed}, rows:[{line,action,device_name,douyin_id,nickname,error,warns}], errors:[{line,reason}], mode, dry_run}` | - -**导入语义**（解析规则见 `core/ledger.parse_paste`）： - -- 分隔符默认 **Tab**（Excel 直接粘贴就是 Tab）；也支持 `|` 与 `,`。**不做"多个空格当分隔"**—— - 账号名里本来就有双空格（实测 `有牛奶面包 你吃吗？`）。 -- **带表头**时按列名映射（顺序随意、缺列留空、认不出的列忽略）；**不带表头**则按 - 设备号/手机号/账号名称/抖音号/注册时间/卡在机内/可发视频/简介/备注 的固定顺序。 -- 「卡在机内 / 可发视频」认 `是/有/1/true` → True，`否/空` → False；认不出的值按"否"处理 - 并在该行 `warns` 里留痕。 -- 抖音号非纯数字也会 `warns` 留痕（不拦）——它会让任务比对匹配不上。 -- `mode=skip`：库里有同号 → 跳过；`mode=overwrite`：**整行替换**（空单元格会覆盖掉原值）。 -- `dry_run=true` 走同一条解析+判重路径但**一个字节都不写**（界面默认先预览再导入）。 -- 缺设备号或抖音号的行会被跳过，并在 `errors` 里带行号说明。 - -> ⚠ 台账里的抖音号是**纯号**，只当"比对用的候选值"；**不要**拿它填「去重」的身份元素 -> （身份是元素原文逐字算 key，格式不同会让去重**静默失效**）。 - -### 视频发布计划（「账号 → 发布计划」页） +### 视频发布计划（「发布计划」页） 表与状态机见 [DATA_MODEL.md](DATA_MODEL.md) §2.11，任务侧怎么自动发布见 [TASK_DEV.md](TASK_DEV.md) §4.7；权限 `devices`。 | 接口 | 请求 | 响应要点 | |------|------|---------| -| `POST /api/video_plan/upload_video` | multipart `file`（单文件）+ `replace` | `{ok,name,action:add\|skip\|replace,plan,msg}`；解析/配对不通过 → **400 + `error`（人话原因）**。前端**逐文件串行**发（才能给每个文件一条进度与结果） | -| `POST /api/video_plan/upload_titles` | `{text, dry_run}` 或 multipart `file`（txt） | `{ok, counts:{total,attached,skipped,rejected}, rows:[{line,phone,date,seq,title,body,action,error}], msg}`；**一行里可带正文**：`标题 || 正文 _手机号_日期_编号`（`||` 分隔，正文可省，只切第一处）；**两种写法都认**：标题在前（推荐，右锚定，标题里可带下划线）或 `手机号_日期_编号_标题 || 正文`（左锚定，跟视频文件名同序），**编号都可省略**；标题里可以有 `#话题`；空行忽略，`#` 开头的行**只有认不出手机号/日期时**才当注释；拒收条件：手机号不在台账/命中多个、日期不合法、标题为空或 >100 字、该槽位已有标题、没有对应视频 | -| `GET /api/video_plan/timeline` | `?range=today\|week\|all&from=&to=&status=&account_id=&q=&limit=` | `{ok, days:[{date,weekday,total,done,plans:[…]}], stats, disk, today}` | +| `POST /api/video_plan/upload_video` | multipart `file`（单文件）+ `replace` | `{ok,name,action:add\|skip\|replace,plan,msg}`；解析不通过 → **400 + `error`（人话原因）**。前端**逐文件串行**发（才能给每个文件一条进度与结果） | +| `POST /api/video_plan/upload_titles` | `{text, dry_run}` 或 multipart `file`（txt） | `{ok, counts:{total,attached,skipped,rejected}, rows:[{line,name,date,seq,title,body,action,error}], msg}`；**一行里可带正文**：`标题 || 正文_名字_日期_编号`（`||` 分隔，正文可省，只切第一处）；**只有这一种写法**（名字在日期前一段，右锚定）；**编号可省略**；标题/正文里可以有下划线和 `#话题`；空行忽略，`#` 开头的行**只有认不出名字/日期时**才当注释；拒收条件：名字里带下划线/是纯数字/是手机号、日期不合法、标题为空或 >100 字、该槽位已有标题、没有对应视频 | +| `GET /api/video_plan/timeline` | `?range=today\|week\|all&from=&to=&status=&q=&limit=` | `{ok, days:[{date,weekday,total,done,plans:[…]}], stats, disk, today}` | | `GET /api/video_plan/stats` | — | `{ok, stats, disk, today}`；`stats` 里**三个口径都给**：`today_ready`（今天要发几个号，按发布日期）/ `today_done`（今天完成）/ `published_today`（今天实际发的，按 `published_at`，补发也算今天） | -| `GET /api/video_plan/` · `PUT` · `DELETE` | `PUT {"title"}` | `PUT` 只改标题（改完 `pending→ready`）；`DELETE` **先删行再删素材文件** | +| `GET /api/video_plan/` · `PUT` · `DELETE` | `PUT {"title","body","nickname"}` | `PUT` 改标题/正文/**名字**（名字 = 识别键，走同一套校验：不许含下划线/不许纯数字；改完按"有没有内容"切 `pending↔ready`）；`DELETE` **先删行再删素材文件** | | `GET /api/video_plan//video` | — | 素材预览（`send_file`，支持 Range）；文件已被清理 → **410** | -| `POST /api/video_plan//push` | — | **把素材推到手机**（只推送、不发布）：推文件 → 触发相册刷新 → 标题写进剪贴板；已推送/结果未知 → 409。发布动作由你写在任务里（见 [TASK_DEV.md](TASK_DEV.md) §4.7） | -| `POST /api/video_plan/push_all` | `{date?, retry_failed?}` | **一键推送**：某天（默认今天）`ready`/`failed` 且未超尝试上限的计划，**按设备分组**推（每台设备一个线程、设备内串行；设备间并行）。返回 `{ok,count,devices,no_device,msg}`；没绑上设备地址的条数单独在 `no_device` 里报出来。全部设备都解析不到 → 400 | +| `POST /api/video_plan//push` | — | **把素材推到手机**（只推送、不发布）：**按名字找设备**（实时探测哪台在线设备登着这条计划的名字）→ 推文件 → 触发相册刷新 → 标题写进剪贴板；已推送/结果未知 → 409；没有设备登着这个名字 → **400 + 人话原因**（先去切号） | +| `POST /api/video_plan/push_by_account` | `{date?, retry_failed?, serials?}` | **一键推送（按名字找设备）**：某天（默认今天）`ready`/`failed` 且未超尝试上限的计划 → 按 `nickname` 分组 → **实时探测**在线设备当前登的号（跳过正在跑任务的设备）→ 每台设备一个线程、设备内串行。返回 `{ok,count,devices,matched:[{name,count,serial,device_name}],unmatched:[{name,count,reason}],msg}`；**全部 unmatched → 400**（`error` 里逐条说清"没有在线设备登着这个号"）。`serials` 可只探指定设备 | +| `POST /api/video_plan/push_all` | 同上 | 老入口，语义与 `push_by_account` 完全一致（都按名字找设备） | | `POST /api/video_plan//mark` | `{status: done\|failed\|unknown, why}` | 人工标记结果（推完之后用）：`done` 补 `published_at`；`failed`/`unknown` 把 `why` 记进 `last_error` | | `POST /api/video_plan//skip` | `{reason}` | 人工跳过 | | `POST /api/video_plan//retry` | — | `failed`→`ready`，`attempts` 清零 | | `POST /api/video_plan//resolve` | `{published, note}` | **`unknown` 的人工裁决**：确认真发出去了 → `done`；确认没发 → `failed`（可重试） | -| `GET /api/video_plan/links` | `?from=&to=&device=&phone=&format=csv` | 已发布作品的分享链接；CSV 带 BOM（Excel 打开中文不乱码）。列：发布日期/设备号/手机号/抖音号/编号/标题/**正文**/分享链接/发布时间（**不再导出账号名称**） | +| `GET /api/video_plan/links` | `?from=&to=&name=&format=csv` | 已发布作品的分享链接；CSV 带 BOM（Excel 打开中文不乱码）。列：发布日期/**名字**/编号/标题/**正文**/分享链接/发布时间 | | `GET /api/video_plan/tasks` | — | `{ok, tasks:[{id,name,enabled,mode,cron,next_run,target,steps,step_count,schedule,retry,is_release,has_push}], release_count, other_count}`：**全部通用步骤任务**（不止发布任务 —— 只列发布任务的话，手写的抖音发布流程会一条都不显示，人会以为"这页没有能改的地方"），界面按 `is_release`（有 `push_release` **或** `mark_release`，含嵌套）分两组。带完整 `steps` 是为**就地编辑**（抓选择器）；`step_count` 数的是**含嵌套**的总步数。权限 `T` | -| `POST /api/video_plan/tasks` | `{"name","target":{"mode":"all\|group\|serial","group_name","serial"},"time":"10:00","enabled"}` | 一键新建：骨架 **17 步**（亮屏 → 打开抖音(等首页) → 点「我」→ `if_el(cmp_source=release)` 校验账号 → then: `push_release` → 「+」(预填 `descriptionContains=拍摄`) → 相册/第一个视频/下一步/标题框/正文框/发布（**空选择器占位**）→ `input_text(text_source=release_title)` → `input_text(text_source=release_body)` → `mark_release`；else: `notify` 跳过）；**走 TaskManager 建**（内存+库一起更新，直接写库调度器不认）。⚠ `target` 分组键名是 **`group_name`**（写成 `group` 会静默解析出 0 台设备）；分组/单设备没给具体目标 → 400。权限 `T` | -| `GET/PUT /api/video_plan/tasks/` | `PUT {name?, time?, target?, steps?, enabled?}` | **发布任务的就地编辑**（「账号 → 发布计划」页里改，不用跳任务页）。只放开这几个字段，**没传的字段原样保留**；`steps` 整块替换但 `params` 里的通用参数（去重有效期、抢占…）**深合并保留**。校验：空名字/坏时间/`steps` 不是数组/什么都不传 → 400，未知任务 → 404。权限 `T`。底层仍是 `TaskManager.update_job()`（内存+库一起改） | +| `POST /api/video_plan/tasks` | `{"name","target":{"mode":"all\|group\|serial","group_name","serial"},"time":"10:00","enabled"}` | 一键新建：骨架 **18 步**（亮屏 → 打开抖音(等首页) → 点「我」→ `read_account_name` 读本机账号名字（**昵称选择器待抓**）→ `if_el(cmp_source=account_target)` 校验登的是不是要发的名字 → then: `push_release(account=name)` → 「+」(预填 `descriptionContains=拍摄`) → 相册/第一个视频/下一步/标题框/正文框/发布（**空选择器占位**）→ `input_text(text_source=release_title)` → `input_text(text_source=release_body)` → `mark_release`；else: `notify` 跳过）；**走 TaskManager 建**（内存+库一起更新，直接写库调度器不认）。⚠ `target` 分组键名是 **`group_name`**（写成 `group` 会静默解析出 0 台设备）；分组/单设备没给具体目标 → 400。权限 `T` | +| `GET/PUT /api/video_plan/tasks/` | `PUT {name?, time?, target?, steps?, enabled?}` | **发布任务的就地编辑**（「发布计划」页里改，不用跳任务页）。只放开这几个字段，**没传的字段原样保留**；`steps` 整块替换但 `params` 里的通用参数（去重有效期、抢占…）**深合并保留**。校验：空名字/坏时间/`steps` 不是数组/什么都不传 → 400，未知任务 → 404。权限 `T`。底层仍是 `TaskManager.update_job()`（内存+库一起改） | | `POST /api/video_plan/tasks//adopt` | — | 给**已有任务**插上平台那两步：`push_release` 放最前、`mark_release` 放最后（**中间你自己的步骤一步不动**；位置理由见 `core.video_plan.insert_release_steps`）。只对「通用步骤」任务；没有步骤 → 400，已经有这两步 → 409，未知任务 → 404。权限 `T` | -**逐文件上传的幂等**：同一 `(手机号,日期,编号)` 已有行时 —— 文件内容相同 → `action=skip`（不重复落盘）； +**逐文件上传的幂等**：同一 `(名字,日期,编号)` 已有行时 —— 文件内容相同 → `action=skip`（不重复落盘）； 内容不同 → **拒收**，前端给「覆盖」按钮（二次确认后带 `replace=1` 重传）。 标题同理：同槽位已有别的标题 → 拒收（不静默覆盖，文案是发出去就改不了的东西）。 diff --git a/doc/ARCHITECTURE.md b/doc/ARCHITECTURE.md index e04781e..02aa835 100644 --- a/doc/ARCHITECTURE.md +++ b/doc/ARCHITECTURE.md @@ -280,7 +280,7 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set | 顶级 Tab | `data-tab` | 权限 | 子分栏 | |---------|-----------|------|--------| | 监控 | `monitor` | 登录即可 | — | -| 账号 | `account` | `devices` | `ledger` 账号台账（列表/增删改/粘贴导入）/ `plan` **发布计划**（上传视频与标题、时间线、推送到手机、导出链接 + **发布任务就地编辑**，见 [DATA_MODEL.md](DATA_MODEL.md) §2.10 §2.11） | +| **发布计划** | `plan` | `devices` | 上传视频与标题（按**名字**配对）、时间线、推送到手机、导出链接 + **发布任务就地编辑**（见 [DATA_MODEL.md](DATA_MODEL.md) §2.11）。2026-10-12 起「账号台账」整页下线（表保留），本页从「账号」页的子分栏升为一级页签 | | 任务 | `tasks` | 登录即可（写操作需 `tasks`） | `plan` 任务计划 / `actions` 自定义动作 / `actioncfg` 动作配置 / `dedup` 去重记录 | | 日志 | `logs` | `logs` | — | | 用户 | `users` | `admin` | — | @@ -297,8 +297,7 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set | `base.js` | esc / CSRF / 权限 / API 封装 / Toast / Tab 与子分栏切换 / 模态框 / 常量表 | 所有模块的公共底座 | | `markdown.js` | 轻量 Markdown 渲染（`renderMarkdown`） | 无 CDN 依赖；**先转义再套标记** | | `list.js` | 统一列表组件：搜索 + 分页 + 排序 | 状态注册表 `_LIST_PAGERS`；`setListPager` **不重置**页码/搜索/排序（避免轮询刷新打断用户） | -| `ledger.js` | 账号台账页（列表 / 单条增删改 / 从表格粘贴导入 + 逐行结果 / 设备维度弹窗）+ `ledgerCell()` 供设备池那一列 | 服务层 `core/ledger.py`；导入默认**先预览再写**（`dry_run`） | -| `release.js` | 发布计划页（时间线按日期分组 / 多选视频**串行**上传 + 逐文件进度与结果 / 标题+正文 txt 上传（`标题 || 正文 _手机号_日期_编号`，**不显示账号名称、只显示抖音号**）/ 推送到手机 + **一键推送**（当天全部）、相册校验徽章与裁决 / 链接复制与导出 CSV / **发布任务的就地编辑**） | 服务层 `core/video_plan.py`；上传前把队列**按文件名排序**并让用户确认解析结果（顺序 = "无编号按顺序配"的依据）。就地编辑只放常用字段（名字/目标/时间/启停/逐步参数 + 抓取元素），更复杂的编排走「打开通用编辑器」→ `openTaskModal`；步骤路径里 `then/else/children` 在**步骤的 params 下**（`_rpWalk`），走错这一层会把分支当数组下标用 | +| `release.js` | 发布计划页（时间线按日期分组 / 多选视频**串行**上传 + 逐文件进度与结果 / 标题+正文 txt 上传（`标题 || 正文_名字_日期_编号`，卡片与明细**以名字为主**）/ 推送到手机 + **一键推送**（当天全部，**按名字找设备**：实时探测哪台在线设备登着这个号，逐条报出"没有设备登着"的号）、相册校验徽章与裁决 / 链接复制与导出 CSV / **发布任务的就地编辑**） | 服务层 `core/video_plan.py`（实时探测在 `core/account_probe.py`）；上传前把队列**按文件名排序**并让用户确认解析结果（顺序 = "无编号按顺序配"的依据）。就地编辑只放常用字段（名字/目标/时间/启停/逐步参数 + 抓取元素），更复杂的编排走「打开通用编辑器」→ `openTaskModal`；步骤路径里 `then/else/children` 在**步骤的 params 下**（`_rpWalk`），走错这一层会把分支当数组下标用 | | `monitor.js` | 监控页：设备表（含**电量列**，按 `battery.tier` 上色）、批量操作、异常汇总、任务概况卡片（含覆盖设备 chip） | 5s 轮询 + 脏检查（签名不变不重渲染） | | `editor.js` | 步骤编辑器（拖拽 / 参数表单 / 条件分支 / 元素抓取 / 测试此步骤）+ `saveTask` | 最大的前端文件；`_stepEditor` 单例；设备选择卡 `_devCard` 供「抓取元素」「测试此步骤」共用（**名字优先**，型号·地址作副标题） | | `tasks.js` | 任务 Tab：任务 CRUD / 调度解析 / 运行窗口 + 自定义动作 | | diff --git a/doc/DATA_MODEL.md b/doc/DATA_MODEL.md index 1694b37..bfe1028 100644 --- a/doc/DATA_MODEL.md +++ b/doc/DATA_MODEL.md @@ -46,8 +46,8 @@ | 13 | `device_install_log` | 设备端应用商店的下载/安装记录（设备上报，见 [DEVICE_AGENT.md](DEVICE_AGENT.md)） | | 14 | `task_step_log` | 任务步骤明细（每次步骤执行一条，见 §2.8；**唯一有无界增长风险的表**，靠保留期清理） | | 15 | `done_mark` | 去重账本：跨设备"已做过"标记（见 §2.9；本清单此前漏列，2026-09-24 补上） | -| 16 | `device_account` | 账号台账：一台设备上登录着哪些账号（见 §2.10；任务「条件判断」的取号来源、设备端身份页显示用） | -| 17 | `video_plan` | 视频发布计划：账号 × 发布日期 × 编号 → 素材 + 标题 + 发布状态 + 分享链接（见 §2.11） | +| 16 | `device_account` | **已停用**：账号台账（见 §2.10；2026-10-12 起页面/接口/任务依赖全部下线，**表和 42 行历史数据保留、仍在备份内**，可回滚） | +| 17 | `video_plan` | 视频发布计划：**名字** × 发布日期 × 编号 → 素材 + 标题/正文 + 发布状态 + 分享链接（见 §2.11） | > 2026-09-13 之前，`app_meta` 与 4 张 `agent_*` 表是各模块里的裸 `CREATE TABLE` > （不进模型层）。迁 MySQL 时那批 SQL 的 `AUTOINCREMENT`/`TEXT DEFAULT ''`/`TEXT PRIMARY KEY` @@ -128,6 +128,7 @@ | `note` | Text | `""` | | | `created_at` | String(20) | `""` | | | `fingerprint` | String(120) | `""` | **设备指纹**（`ro.serialno`，迁移 v5 追加）：同一台物理设备换 IP 后据此认领回原记录 | +| `cur_account_name` / `cur_name_at` | String(80)/String(20) | `""` | **上次探测到的抖音当前账号名字**（迁移 v13 追加）：只有「按名字找设备」（计划页的推送）会写它。**纯缓存** —— 自动任务永远现场读屏幕，缓存旧了也不影响发布的正确性；界面上带时间戳显示 | ### 2.7 `pending_device` — 待确认的发现设备 @@ -200,9 +201,20 @@ ⚠️ 这张表**自动进整库备份**（§6 派生规则）；接任务步骤见 [TASK_DEV.md](TASK_DEV.md) §4.6。 -### 2.10 `device_account` — 账号台账（一台设备上登录着哪些账号） +### 2.10 `device_account` — 账号台账（**已停用，表保留**） -「账号」页维护；服务层 `core/ledger.py`，接口 `/api/ledger*`（见 [API.md](API.md) §2.15）。 +> **2026-10-12：账号管理整块下线。** 页面（「账号」页）、接口（`/api/ledger*`）、 +> 服务层（`core/ledger.py` 已删）、任务取号（`cmp_source=device/all/group`）、 +> 设备端身份页的账号块（`accounts_b64`）、设备池的「账号 N」列**全部移除**。 +> +> 为什么留着表和这 42 行数据：**删数据不可逆**，而这张表在备份清单里（红线：功能涉及的数据 +> 必须纳入备份）—— 先停用、确认稳定后再单开一次清理动作。 +> 发布计划改走**名字**（见 §2.11），不再需要台账。 +> +> 唯一从 `core/ledger.py` 迁走的是 `serial_of(设备名) → 当前地址`（与账号无关）， +> 现在在 `core/device_pool.py`。 + +历史结构（停用前）：一台设备上登录着哪些账号。「账号」页维护。 | 列 | 类型 | 说明 | |----|------|------| @@ -218,44 +230,38 @@ | `bio` / `note` | Text | 简介 / 备注 | | `created_at` / `updated_at` | String(20) | 字符串时间（仓库惯例） | -**三个使用方**： +**（停用前的）三个使用方**：① web「账号」页（列表/增删改/从 Excel 粘贴导入）； +② 任务「条件判断」取号（`cmp_source=device/all/group`）；③ 手机端 Agent 的身份大字页（`accounts_b64`）。 +**三个都已移除**；发布计划现在按**名字**走（§2.11）。 -1. **web「账号」页** —— 列表 / 增删改 / 从 Excel 粘贴导入（解析规则见 `core/ledger.parse_paste`） -2. **任务的「条件判断」取号** —— `if_el` 的 `cmp_source`（`device` 本机 / `all` 全部 / `group` 按设备分组）， - 见 [TASK_DEV.md](TASK_DEV.md) §4.2 -3. **手机端 Agent 的身份大字页** —— 平台推 `accounts_b64`（见 [DEVICE_AGENT.md](DEVICE_AGENT.md) §5.2） +⚠️ 历史提醒：`douyin_id` 是纯号，**绝不能当去重身份**（`done_mark.identity` 存的是元素原文、 +逐字算 key，格式不一致会让去重静默失效）—— 这是当年 `cmp_source` 取号的边界， +现在候选值来自"本次要发的名字"，同理不得拿去填 `ident_value`。 -⚠️ **`douyin_id` 是纯号，绝不能当去重身份**：`done_mark.identity` 存的是**元素原文** -（`抖音号：35377983067`）、逐字算 key，格式不一致会让去重**静默失效**。 -它只做"比对用的候选值"（运算符用「包含」时纯号是子串）。 +这张表**仍在整库备份内**（§6 派生规则）—— 停用不等于删数据。 -**唯一性在应用层**（`core/ledger`）：同一抖音号不允许两条。没做成 DB 唯一索引的理由： -抖音号可能为空，DB 级要写"部分唯一索引"（§4.2 那套 SQLite `WHERE` + MySQL 虚拟生成列）， -而台账是人工维护的几十条 —— 三处方言适配不划算。 +### 2.11 `video_plan` — 视频发布计划（**一个名字**在某天要发的一个视频） -这张表**自动进整库备份**（§6 派生规则）。 - -### 2.11 `video_plan` — 视频发布计划（一个账号在某天要发的一个视频） - -「账号 → 发布计划」页维护；服务层 `core/video_plan.py`，接口 `/api/video_plan/*`（见 [API.md](API.md) §2.14）， +「发布计划」页维护；服务层 `core/video_plan.py`，接口 `/api/video_plan/*`（见 [API.md](API.md) §2.14）， 任务步骤「发布视频」按它自动发布（见 [TASK_DEV.md](TASK_DEV.md) §4.7）。 **素材文件**落在 `data/videos/YYYY-MM/`（文件名 `{sha1[:12]}_{安全原名}`，内容寻址），**不进整库备份**（§6）。 | 列 | 类型 | 说明 | |----|------|------| | `id` | String(32) PK | uuid 前 8 位 | -| `account_id` / `phone` | String(32) | 台账行 id（**不做外键**）/ 配对键（冗余存：账号删了也留痕） | -| `device_name` / `nickname` / `douyin_id` / `serial` | String | 账号与设备快照（时间线卡片直接显示，免 join） | +| `nickname` | String(80) | **识别键**：上传文件名里的**名字**（= 抖音昵称）。运行时就按它取计划、找设备/账号 | +| `account_id` / `phone` / `douyin_id` / `device_name` / `serial` | String | **已停用**（老台账快照，保留列不再写入）：账号 id / 手机号 / 抖音号 / 设备号 / 地址 | | `release_date` | String(10) index | **`2026-09-12`** 纯日期（等值比较走索引） | | `seq` / `seq_auto` | Integer / Boolean | 编号从 **1** 起（不用 0 表示"无"）；`seq_auto`=号是自动分配的 | | `title` | Text | **标题**（发布页的「标题」框；标题 txt 配对写入） | -| `body` | Text | **正文/文案**（发布页的文案框，可带 `#话题`）—— 标题 txt 一行里用 `||` 分隔：`标题 || 正文 _手机号_日期_编号`；**标题与正文都为空的行不会被发布** | +| `body` | Text | **正文/文案**（发布页的文案框，可带 `#话题`）—— 标题 txt 一行里用 `||` 分隔：`标题 || 正文_名字_日期_编号`；**标题与正文都为空的行不会被发布** | | `video_file` / `video_name` / `video_size` / `video_sha1` | 各自 | 落盘相对路径 / 原始名 / 大小 / 内容指纹（重复上传判据） | | `status` | String(16) index | 见下方状态机 | | `stage` | String(16) | 失败发生在哪一步：`push`/`scan`/`post`/`verify` | | `attempts` | Integer | 尝试次数（上限 3，超了不再自动取） | | `published_at` / `share_url` / `link_at` / `video_deleted_at` | String | 发布时刻 / **作品分享链接** / 抓到链接的时刻 / 素材何时清理 | | `push_verify` / `push_remote` | String(16)/String(200) | **推送后的相册校验**：`ok`=已进相册索引 / `no_index`=文件在但没进索引（相册里可能看不到）/ `nofile`=文件不在；`push_remote` = 推到手机上的绝对路径（删它、排查用）。**文件推上去了 ≠ 相册里点得到它**，所以单独存一列而不是混进 `last_error` | +| `posted_serial` / `posted_device_name` | String(120)/String(80) | **实际是哪台设备发的**（推送时现场写）。计划不再绑设备，所以"这条最后是谁发的"只能这么记 —— 排查"怎么发到那台机器上去了"全靠它 | | `last_error` / `note` / `created_at` / `updated_at` | | 失败原因 / 人工备注 / 时间 | **状态机**（本表的灵魂，别简化）： @@ -276,12 +282,14 @@ unknown 推送之后出的岔子 —— **可能已经发出去了，绝不 > 就是重复发布的来源。`stage` 是两者互相转换的唯一依据（`core/video_plan.STAGE_STATUS`）。 > 界面上的 `unknown` 卡片标橙 + 硬提示，人工到抖音确认后点「已发出 / 未发出」裁决。 -**唯一性**：`(phone, release_date, seq)` 由**服务层**保证，**不加 DB 唯一索引** —— +**唯一性**：`(nickname, release_date, seq)` 由**服务层**保证，**不加 DB 唯一索引** —— `seq` 从 1 起、没有"空值"可言，做部分唯一索引要写三处方言适配 + MySQL 生成列（§4.2）， 收益不匹配；违反的代价只是低频人工上传产生的重复行（可见、可删）。 -**索引**：`(release_date,status)` 时间线主查询 · `(account_id,release_date)` 账号视角 · -`(phone,release_date,seq)` 配对/幂等 · `(video_file)` 清理时反查引用。 +**索引**：`(release_date,status)` 时间线主查询 · `(nickname,release_date)` **按名字取计划/查重**（主路径）· +`(account_id,release_date)` · `(phone,release_date,seq)` 老台账路径（已停用，保留）· `(video_file)` 清理时反查引用。 +后三个里带 `account_id`/`phone` 的两个是历史遗留（账号台账停用后不再走），等确认稳定后一并清理。 +`ix_video_plan_name_date` 由 `_ensure_plain_indexes()` 在启动时补建（`create_all` 不管已有表的新索引）。 这张表**自动进整库备份**（§6 派生规则）；**素材文件不进备份包**，见 §6 与 §7。 diff --git a/doc/DEPLOY.md b/doc/DEPLOY.md index d2fb4f6..68ef45c 100644 --- a/doc/DEPLOY.md +++ b/doc/DEPLOY.md @@ -71,8 +71,17 @@ DB_NAME=auto_control # USB_ADB_HOST=100.100.10.1 # USB 设备所在的部署机（默认值通常可用） # TAILSCALE_API_KEY=<...> # 需要 Tailscale 管理功能时 # MCP_PLATFORM_PASS= # 改过 admin 密码必须同步，否则 MCP 登录失败 + +# 发布计划按名字发：抖音「我」页面上的**昵称控件**（用「抓取元素」抓一次，见 .env.example） +# DOUYIN_NAME_SELECTOR_VALUE= +# 自动切号：进「账号切换」列表那个入口（同样抓一次） +# DOUYIN_SWITCH_SELECTOR_VALUE= ``` +> ⚠ **发布计划相关的两个选择器必须抓一次**（`DOUYIN_NAME_SELECTOR_VALUE` / +> `DOUYIN_SWITCH_SELECTOR_VALUE`）：不填时「读取本机账号名字」「切换账号」会**明确报错并跳过** +> （不会瞎点、不会发错号），但也就发不出视频。改完 `.env` 要重启容器生效。 + **防混库**（`DEPLOY_ENV` 与库名/库标签双向校验，配置项说明见 [DEVELOPMENT.md](DEVELOPMENT.md) §4.2 与 `.env.example` 的「数据库」段）：启动时若 「`.env` 声明的环境」与「库名」或「库中登记的 `app_meta.deployment_env`」不符，**直接拒绝启动**并打印 @@ -215,7 +224,7 @@ SUMMARY_TABLES = tuple(sorted(t.name for t in db.metadata.tables.values())) 当前 17 张表：`app_meta` / `user` / `device_group` / `task_job` / `custom_action` / `apk_file` / `device` / `pending_device` / `agent_conversation` / `agent_experience` / `experience_audit` / `agent_action` / `device_install_log` / `task_step_log` / `done_mark` / -`device_account`（账号台账）/ `video_plan`（视频发布计划）。 +`device_account`（账号台账，**已停用但仍在备份内**——停用不等于删数据）/ `video_plan`（视频发布计划）。 完整说明见 [DATA_MODEL.md](DATA_MODEL.md) §6。 > ⚠ **视频素材（`data/videos/`）不进备份包**（几十 GB 会把备份搞坏）：manifest 里有 diff --git a/doc/DEVELOPMENT.md b/doc/DEVELOPMENT.md index 50b0a36..f135b30 100644 --- a/doc/DEVELOPMENT.md +++ b/doc/DEVELOPMENT.md @@ -107,6 +107,7 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \ | 后端逻辑验证 | 直接 `python -c "…"` 调用 `core/`、`tasks/` 的函数（如构造 worker 检查参数合并） | | 前端验证 | 无 npm/构建，改完强刷；浏览器控制台看报错 | | 接口 500 巡检 | `python scripts/regression_test.py`（**⚠️ 当前在 Windows 上会因 `signal.alarm` 报错**，Linux/macOS 可用） | +| 发布计划（按名字发）用例 | `python scripts/tests/run_all.py` —— 6 套：解析 / 上传配标题 / 读名字与作用域 / 切换账号 / 循环本机待发的号 / 按名字找设备推送。**纯临时库 + 假设备，不连真机**（见 `scripts/tests/run_all.py` 顶部） | | 停止设备/清异常 | 监控页「停止全部 / 停止选中 / 清除全部异常」 | | AI 建任务（designer）验证 | AI 控制台 →「AI 建任务」选**空闲**设备跑一轮；脚本方式见 [AI_TASK_GEN.md](AI_TASK_GEN.md) §10.5。草稿只落 `app_meta.agent_task_draft`（不是任务），验证完 `POST /api/agent/task_draft/clear` 清掉。**注意它会真在设备上点按**（导航类动作），且与聊天共用同一个运行槽 | @@ -200,7 +201,7 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \ | 页面结构 / 样式 / 引入脚本 | `templates/admin/monitor.html` | | 公共工具（API/权限/Toast/Tab） | `static/admin/base.js` | | 列表分页排序 | `static/admin/list.js` | -| 各功能域逻辑 | `static/admin/{monitor,editor,tasks,tools,apps,admin,agent,system,markdown,dedup,ledger,release}.js` | +| 各功能域逻辑 | `static/admin/{monitor,editor,tasks,tools,apps,admin,agent,system,markdown,dedup,release}.js` | 新增 JS 模块：建文件 → 在 `monitor.html` 里按依赖顺序加 ` - diff --git a/web/device_agent_api.py b/web/device_agent_api.py index a20be23..f1c71d2 100644 --- a/web/device_agent_api.py +++ b/web/device_agent_api.py @@ -17,9 +17,7 @@ 管理端接口在文件后半段（`/api/agent-store/*`，走正常登录 + 权限）。 """ -import base64 import hmac -import json import os import secrets import time @@ -27,7 +25,7 @@ import time from flask import Blueprint, jsonify, request, send_file from config import APK_DIR -from core import device_pool, ledger +from core import device_pool from core.db_config import meta_get, meta_set from core.logger import get_logger from web.auth import PERM_APKS, PERM_DEVICES, perm_required @@ -319,32 +317,9 @@ def api_agent_show_info(): "--es", "server", server] if ip: args += ["--es", "ip", ip] - # 本机账号台账（可选块）：身份页顺带显示"这台登的是哪几个号"。 - # **中文必须 base64**（§5.1：adb shell 直传中文/特殊字符会变形）； - # `_adb` 是 argv 形式、不过 shell，base64 里的 +/= 安全 —— 将来谁把 - # 这里改成 shell=True 就会静默坏掉，别改。 - # 台账里没有这台设备时**整个 extra 不发**（设备端"没有这个 extra"= - # 本来就没登记，跟"发了但解不开"能区分开），原因随响应体的 warn 回给操作者。 + # 账号台账块（`accounts_b64`）随账号管理一起下线了：身份页只显示 + # 名称/地址/平台地址这些设备信息。老版本 Agent 收到"没有这个 extra"照常显示。 warn = "" - try: - acc = ledger.agent_accounts(serial, device_name=name, - include_phone=bool(data.get("include_phone"))) - if acc.get("accounts"): - b64, acc = _encode_accounts(acc) - if len(b64) + sum(len(a) for a in args) < _ARGS_CMD_MAX: - args += ["--es", "accounts_b64", b64] - _log.info("身份页附账号：%s 共 %s 个号（accounts_b64 %d 字节）", - serial, acc.get("shown"), len(b64)) - else: - warn = "账号台账过大，未随身份页下发" - _log.warning("身份页未附账号：%s %s（%d 字节）", serial, warn, len(b64)) - else: - warn = f"这台设备在账号台账里没有账号（{acc.get('note') or '未匹配到设备名'}）" - _log.warning("身份页未附账号：%s %s", serial, warn) - except Exception as e: - # 台账坏了不能把"显示身份"这个动作弄坏：跳过该 extra，只回告警 - warn = f"账号台账读取失败：{e}" - _log.warning("身份页附账号失败 %s: %s", serial, e) # 先点亮屏幕、解除锁屏：设备息屏时 am start 会把大字页开在锁屏**后面**， # 人看到的还是一片黑（实测踩过）——这正是原来"定位"按钮里的"点亮屏幕"那一步 @@ -373,33 +348,6 @@ def api_agent_show_info(): return jsonify(resp) -# accounts_b64 的预算：44 条 × ~90 字节 ≈ 4KB，base64 后 ≈ 5.3KB，余量充足。 -# 再加一道**命令行总长**闸（Windows CreateProcess 上限 ~32767）。 -ACCOUNTS_PAYLOAD_MAX = 20000 -_ARGS_CMD_MAX = 28000 - - -def _encode_accounts(acc): - """把账号块压成 base64（超预算**按整条丢**，永不按字节切）。 - - 按字节切会产出破损 JSON —— 设备端解析失败只能整块丢掉， - 还不如少几条但能解开（`truncated`/`shown` 如实反映）。 - 返回 (base64 文本, 修正后的块)。 - """ - acc = dict(acc or {}) - rows = list(acc.get("accounts") or []) - total = acc.get("total", len(rows)) - while True: - block = dict(acc, accounts=rows, shown=len(rows), - truncated=len(rows) < total) - b64 = base64.b64encode( - json.dumps(block, ensure_ascii=False, separators=(",", ":")).encode("utf-8") - ).decode("ascii") - if len(b64) <= ACCOUNTS_PAYLOAD_MAX or not rows: - return b64, block - rows = rows[:-1] - - @bp.route("/api/agent-store/config", methods=["GET", "POST"]) @perm_required(PERM_APKS) def api_agent_store_config(): diff --git a/web/devices_api.py b/web/devices_api.py index d95c08a..e321822 100644 --- a/web/devices_api.py +++ b/web/devices_api.py @@ -4,7 +4,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed from flask import Blueprint, jsonify, request -from core import device_battery, device_pool, device_discovery, ledger +from core import device_battery, device_pool, device_discovery from core.adb_helper import adb_connect, adb_connect_light from core.logger import get_logger from web.auth import perm_required, PERM_DEVICES @@ -445,110 +445,6 @@ def api_devices_battery_scan(): return jsonify({"ok": True, "msg": "采集已启动（约 1-3 秒）"}) -# ================== API：账号台账（「账号」页） ================== -# -# 数据在 device_account 表（见 core/ledger.py）；任务侧怎么用它取号见 -# tasks/generic/task.py 的 `_resolve_cmp_value`（if_el 的 cmp_source）。 -# ⚠ 台账的抖音号只做「条件判断」的比对值，**不做去重身份**（格式不同会静默失效）。 - -@bp.route("/api/ledger") -@perm_required(PERM_DEVICES) -def api_ledger_list(): - """账号列表 + 统计（?device=设备号 &q=搜索 &limit=）。""" - device_name = (request.args.get("device") or "").strip() - q = (request.args.get("q") or "").strip() - try: - limit = int(request.args.get("limit") or 500) - except ValueError: - limit = 500 - try: - rows, stats = ledger.list_accounts(device_name, q, limit) - names = ledger.device_names() - except Exception as e: - _log.warning(f"读取账号台账失败: {e}") - return jsonify({"ok": False, "error": str(e)[:120]}), 503 - return jsonify({"ok": True, "accounts": rows, "stats": stats, "device_names": names}) - - -@bp.route("/api/ledger/by_device") -@perm_required(PERM_DEVICES) -def api_ledger_by_device(): - """按设备分组（设备池显示"这台几个号" + 点开看明细都走它，省一次请求）。""" - devices = ledger.by_device() - counts = {k: v["count"] for k, v in devices.items()} - return jsonify({"ok": True, "devices": devices, "counts": counts}) - - -@bp.route("/api/ledger", methods=["POST"]) -@perm_required(PERM_DEVICES) -def api_ledger_add(): - """新增一条账号。""" - row, err = ledger.add(request.json or {}) - if err: - return jsonify({"ok": False, "error": err}), 400 - return jsonify({"ok": True, "msg": "已新增", "account": row}) - - -@bp.route("/api/ledger/", methods=["PUT"]) -@perm_required(PERM_DEVICES) -def api_ledger_update(acc_id): - """改一条账号。""" - row, err = ledger.update(acc_id, request.json or {}) - if err: - code = 404 if "不存在" in err else 400 - return jsonify({"ok": False, "error": err}), code - return jsonify({"ok": True, "msg": "已保存", "account": row}) - - -@bp.route("/api/ledger/", methods=["DELETE"]) -@perm_required(PERM_DEVICES) -def api_ledger_delete(acc_id): - """删一条账号（删掉之后任务就取不到这个号了）。""" - if not ledger.delete(acc_id): - return jsonify({"ok": False, "error": "记录不存在或删除失败"}), 404 - return jsonify({"ok": True, "msg": "已删除"}) - - -@bp.route("/api/ledger/import", methods=["POST"]) -@perm_required(PERM_DEVICES) -def api_ledger_import(): - """从表格粘贴文本批量导入。 - - 请求：{"text": "设备号\\t手机号\\t…\\nA01\\t…", "delimiter": "\\t", - "mode": "skip|overwrite", "dry_run": true} - dry_run=true 只解析+判重、**一个字节都不写** —— 界面默认先预览再导入。 - 返回逐行结果（line/action/device_name/douyin_id/nickname/error/warns）+ 汇总。 - """ - data = request.json or {} - text = data.get("text") or "" - if not text.strip(): - return jsonify({"ok": False, "error": "粘贴的内容是空的"}), 400 - delim = data.get("delimiter") or "\t" - if delim == "tab": - delim = "\t" - mode = data.get("mode") or "skip" - dry_run = bool(data.get("dry_run")) - try: - rows, errors = ledger.parse_paste(text, delim) - except Exception as e: - _log.warning(f"账号台账解析失败: {e}") - return jsonify({"ok": False, "error": f"解析失败: {str(e)[:120]}"}), 400 - if not rows: - return jsonify({"ok": True, "counts": {"total": 0, "added": 0, "updated": 0, - "skipped": 0, "failed": 0}, - "rows": [], "errors": errors, "mode": mode, "dry_run": dry_run, - "msg": "没有可导入的行"}) - try: - result = ledger.import_rows(rows, mode=mode, dry_run=dry_run) - except Exception as e: - _log.warning(f"账号台账导入失败: {e}") - return jsonify({"ok": False, "error": str(e)[:120]}), 503 - result["errors"] = errors - result["msg"] = ("预览完成（未写入）" if dry_run else "导入完成") - return jsonify({"ok": True, **result}) - - -# ================== API：Tailscale 管理（仅管理员） ================== # 通过 Tailscale 官方 API v2 管理 tailnet 设备（列表/改名/授权/密钥不过期/删除/生成 auth key）。 # 设备 IP 由 tailnet 自动分配，API 无法修改，列表只读展示。 diff --git a/web/video_plan_api.py b/web/video_plan_api.py index cdc090a..5336469 100644 --- a/web/video_plan_api.py +++ b/web/video_plan_api.py @@ -1,4 +1,4 @@ -"""视频发布计划 API（「账号 → 发布计划」页）。 +"""视频发布计划 API（「发布计划」页）。 数据在 `video_plan` 表、服务层 `core/video_plan.py`；任务侧怎么自动发布见 `tasks/generic/task.py` 的 `_exec_publish_video`（本文件的「立即发布」调的是同一段逻辑）。 @@ -24,7 +24,7 @@ bp = Blueprint("video_plan", __name__) def api_vp_upload_video(): """上传单个视频（前端**逐文件**发，才能给每个文件一条结果与进度）。 - 文件名规则 `手机号_日期_编号`（编号可省略）；解析出的手机号必须**恰好**命中台账一个账号。 + 文件名规则 `名字_日期_编号`（编号可省略，名字 = 抖音昵称，不查台账）。 """ f = request.files.get("file") if not f or not f.filename: @@ -42,8 +42,8 @@ def api_vp_upload_video(): def api_vp_upload_titles(): """上传标题：`{text, dry_run}`；也接受 multipart 的 txt 文件（字段名 file）。 - 每行 `标题内容_手机号_日期_编号` 或 `手机号_日期_编号_标题`（都认；编号可省略、标题里可以有下划线）； - `#` 开头的行**只有认不出手机号/日期时才当注释**（`#话题` 开头的标题照收）。 + 每行 `标题 || 正文_名字_日期_编号`（`||` 后面是正文、可省略；编号可省略、标题里可以有下划线）； + `#` 开头的行**只有认不出名字/日期时才当注释**（`#话题` 开头的标题照收）。 """ if request.files.get("file"): raw = request.files["file"].stream.read() @@ -65,7 +65,7 @@ def api_vp_upload_titles(): @bp.route("/api/video_plan/timeline") @perm_required(PERM_DEVICES) def api_vp_timeline(): - """时间线：?range=today|week|all &from=&to=&status=&account_id=&q=&limit=""" + """时间线：?range=today|week|all &from=&to=&status=&q=&limit=""" rng = (request.args.get("range") or "").strip() today = vp._today() date_from = (request.args.get("from") or "").strip() @@ -78,7 +78,6 @@ def api_vp_timeline(): date_to = _t.strftime("%Y-%m-%d", _t.localtime(_t.time() + 7 * 86400)) data = vp.timeline(date_from, date_to, status=(request.args.get("status") or "").strip(), - account_id=(request.args.get("account_id") or "").strip(), q=(request.args.get("q") or "").strip(), limit=int(request.args.get("limit") or 500)) return jsonify({"ok": True, **data}) @@ -105,11 +104,13 @@ def api_vp_one(pid): return jsonify({"ok": False, "error": "计划不存在"}), 404 return jsonify({"ok": True, "msg": "已删除（素材文件一并删除）"}) data = request.json or {} - if "title" in data or "body" in data: - row, err = vp.set_title(pid, data.get("title") or "", body=data.get("body")) + if "title" in data or "body" in data or "nickname" in data: + row, err = vp.set_title(pid, data.get("title") or "", body=data.get("body"), + nickname=data.get("nickname") if "nickname" in data else None) if err: - return jsonify({"ok": False, "error": err}), 400 if "太长" in err else 404 - return jsonify({"ok": True, "msg": "标题/正文已改", "plan": row}) + bad = "太长" in err or "名字不对" in err + return jsonify({"ok": False, "error": err}), 400 if bad else 404 + return jsonify({"ok": True, "msg": "标题/正文/名字已改", "plan": row}) return jsonify({"ok": False, "error": "没有要改的字段"}), 400 @@ -128,94 +129,142 @@ def api_vp_video(pid): return _send(path, conditional=True) +def _push_by_name(rows, serials=None): + """**按名字找设备**：把一批计划推到"现在登着这个名字的那台设备"上。 + + ① 计划按 `nickname` 分组； + ② **实时探测**在线设备当前登的号（`core.account_probe`，跳过正在跑任务的设备）； + ③ 名字 → 设备；找到就**每台设备一个线程、设备内串行**推（同一个手机同时推两个文件 + 会互相干扰：两条 adb push 抢带宽 + 两条 `content call scan_file` 抢相册索引）； + ④ 没有在线设备登着某个名字 → 进 `unmatched`，**如实报出来**（人要先去那台设备上切号）。 + + 返回 `(matched, unmatched)`，推送本身在后台线程里跑（接口立刻返回）。 + """ + from core import account_probe, device_pool + from tasks.generic.publish_flow import push_one + + by_name = {} + for row in rows: + by_name.setdefault(row.get("nickname") or "", []).append(row) + + dev_names = {} + try: + for d in device_pool.list_devices(): + dev_names[d.get("serial") or ""] = d.get("name") or "" + except Exception: + pass + + probes = account_probe.probe_online(serials) + account_probe.cache_names(probes) # 顺手存进 device 表（人工入口的设备建议用） + name2serial = {} + for serial, r in probes.items(): + nm = (r or {}).get("name") or "" + if nm and nm not in name2serial: + name2serial[nm] = serial # 同名多机：取第一台（下面的 dup 里说明） + + by_serial, matched, unmatched = {}, [], [] + for name, plans in by_name.items(): + serial = name2serial.get(name) + if not serial: + who = "、".join(f"{s}({(v or {}).get('name')})" + for s, v in sorted(probes.items()) if (v or {}).get("name")) \ + or "没有在线设备" + unmatched.append({"name": name, "count": len(plans), + "reason": f"没有在线设备登着『{name}』——先到设备上切到它" + f"（当前探测到：{who}）"}) + continue + by_serial.setdefault(serial, []).extend(plans) + matched.append({"name": name, "count": len(plans), "serial": serial, + "device_name": dev_names.get(serial, "")}) + + def _push_device(serial, plans, dname): + for row in plans: + try: + push_one(serial, row, {"device_name": dname}) + except Exception as e: + _log.warning(f"按名字推送 {row.get('id')} 异常: {e}") + + if rows: + import threading + for serial, plans in by_serial.items(): + threading.Thread(target=_push_device, + args=(serial, plans, dev_names.get(serial, "")), + daemon=True).start() + return matched, unmatched + + @bp.route("/api/video_plan//push", methods=["POST"]) @perm_required(PERM_DEVICES) def api_vp_push(pid): """把这一条的素材**推到手机**（只推送，不在手机上发布）。 - 发布动作由你写在任务里（推送步骤后面接你自己的步骤），这里只是"人工先推一条"。 + 计划不绑设备了，所以这里**按名字找设备**：实时探测哪台在线设备现在登着这条计划的 + 名字，推给它；没有设备登着 → 400 说清"先去切号"。 """ - import threading row = vp.get_plan(pid) if not row: return jsonify({"ok": False, "error": "计划不存在"}), 404 - # 地址现查（设备名 → 当前地址）：**不能用计划行里的快照** —— 设备换 IP 后快照就是错的， - # 而且台账是粘贴导入的老记录可能压根没存上快照（实测踩过：设备池里明明有 A01， - # 却因为快照为空点不动按钮）。快照只作为兜底。 - from core import ledger - serial = ledger.serial_of(row.get("device_name") or "") or (row.get("serial") or "") - if not serial: - return jsonify({"ok": False, - "error": f"找不到设备『{row.get('device_name') or '?'}』的地址 ——" - f"确认「工具 → 设备池」里有这台设备且已连接"}), 400 - if row.get("device_name") and not row.get("serial"): - vp.set_serial(pid, serial) # 顺手把空快照补上（自愈，免得下次又踩） if row["status"] in (vp.ST_PUSHING, vp.ST_PUBLISHING): return jsonify({"ok": False, "error": "这条已经推到手机上了，别重复推"}), 409 if row["status"] == vp.ST_UNKNOWN: return jsonify({"ok": False, "error": "这条上次结果未知（可能已经发出去了）—— 先去抖音确认，" "再用「已发出 / 未发出」裁决"}), 409 - from tasks.generic.publish_flow import run_push - t = threading.Thread(target=run_push, args=(serial, pid), daemon=True) - t.start() - _log.info(f"推送素材到手机 video_plan {pid}（{row['phone']} {row['release_date']}）") - return jsonify({"ok": True, - "msg": "已开始推送到手机（推完状态会变成「已推送到手机」，" - "之后你在手机上发；发完点「标记已发布」）"}) + matched, unmatched = _push_by_name([row]) + if unmatched: + return jsonify({"ok": False, "error": unmatched[0]["reason"]}), 400 + m = matched[0] + _log.info(f"推送素材到手机 video_plan {pid}（{row.get('nickname')} " + f"{row['release_date']}）→ {m['device_name'] or m['serial']}") + return jsonify({"ok": True, "device_name": m["device_name"], + "msg": f"已开始推送到『{m['device_name'] or m['serial']}』" + f"（推完状态变「已推送到手机」，之后你在手机上发；" + f"发完点「标记已发布」）"}) -def _serial_for_plan(row): - """这条计划要推给哪台设备：**设备名现查**（设备换 IP 后快照是错的），快照兜底。""" - from core import ledger - return (ledger.serial_of(row.get("device_name") or "") or (row.get("serial") or "")).strip() +def _push_plans_by_account(): + """`push_by_account` / `push_all` 两个路由的公共实现（避免"调用另一个视图"）。""" + data = request.json or {} + date = (data.get("date") or "").strip() or vp._today() + rows = vp.pushable_plans(date, retry_failed=bool(data.get("retry_failed", True))) + if not rows: + return jsonify({"ok": True, "count": 0, "devices": 0, "matched": [], + "unmatched": [], + "msg": f"{date} 没有待推送的计划（有标题的才推）"}) + matched, unmatched = _push_by_name(rows, data.get("serials") or None) + if not matched: + return jsonify({"ok": False, "count": 0, "devices": 0, "matched": [], + "unmatched": unmatched, + "error": "没有在线设备登着这些号：" + + "、".join(f"{u['name']}({u['count']}条)" for u in unmatched) + + " —— 先到设备上切号，或到「工具 → 设备池」确认设备在线"}), 400 + _log.info(f"一键推送（按名字）{date}：{len(rows)} 条 → {len(matched)} 个名字" + f"（没设备登着的 {len(unmatched)} 个名字已跳过）") + return jsonify({"ok": True, "count": sum(m["count"] for m in matched), + "devices": len({m["serial"] for m in matched}), + "matched": matched, "unmatched": unmatched, + "msg": f"已开始推送 {sum(m['count'] for m in matched)} 条" + f"（{len(matched)} 个号）" + + (f"；{len(unmatched)} 个名字没有在线设备登着，见明细" + if unmatched else "")}) + + +@bp.route("/api/video_plan/push_by_account", methods=["POST"]) +@perm_required(PERM_DEVICES) +def api_vp_push_by_account(): + """**按名字找设备**的批量推送（「一键推送」）：某天所有待推的计划，谁登着谁推。 + + 立刻返回受理条数（推送在后台跑）——进度与结果看时间线的状态徽章 / + 「已推送·相册可见」标记。**没设备登着的名字**在 `unmatched` 里逐条说明。 + """ + return _push_plans_by_account() @bp.route("/api/video_plan/push_all", methods=["POST"]) @perm_required(PERM_DEVICES) def api_vp_push_all(): - """**一键推送**：把某天（默认今天）所有「待发布/失败」的计划推到各自的手机上。 - - 并发口径：**每台设备一个线程、设备内串行**（同一个手机同时推两个文件会互相干扰： - 两条 adb push 抢带宽 + 两条 `content call scan_file` 抢索引），设备之间并行。 - - 立刻返回受理条数（推送是后台跑的）——进度与结果看时间线的状态徽章/ - 「已推送·相册可见」标记。 - """ - import threading - from core import ledger - data = request.json or {} - date = (data.get("date") or "").strip() or vp._today() - rows = vp.pushable_plans(date, retry_failed=bool(data.get("retry_failed", True))) - if not rows: - return jsonify({"ok": True, "count": 0, "devices": 0, - "msg": f"{date} 没有待推送的计划（有标题的才推）"}) - by_dev, no_dev = {}, [] - for row in rows: - serial = (ledger.serial_of(row.get("device_name") or "") or (row.get("serial") or "")).strip() - (by_dev.setdefault(serial, []) if serial else no_dev).append(row) - by_dev.pop("", None) # 兜底：空 key 不该出现 - if not by_dev: - return jsonify({"ok": False, "error": f"{len(rows)} 条计划都没绑上设备地址 ——" - f"到「工具 → 设备池」确认设备在线"}), 400 - - from tasks.generic.publish_flow import push_one - - def _push_device(serial, plans): - for row in plans: - try: - push_one(serial, row) - except Exception as e: - _log.warning(f"一键推送 {row.get('id')} 异常: {e}") - - for serial, plans in by_dev.items(): - threading.Thread(target=_push_device, args=(serial, plans), daemon=True).start() - _log.info(f"一键推送 {date}：{len(rows)} 条 → {len(by_dev)} 台设备" - f"（没绑设备的 {len(no_dev)} 条已跳过）") - return jsonify({"ok": True, "count": len(rows), "devices": len(by_dev), - "no_device": len(no_dev), - "msg": f"已开始推送 {len(rows)} 条（{len(by_dev)} 台设备，每台串行）——" - f"推完状态会变成「已推送·相册可见/相册未见」，刷新看结果"}) + """老入口（前端旧版本还可能在调）：语义与 `push_by_account` 一致 —— 都按名字找设备。""" + return _push_plans_by_account() @bp.route("/api/video_plan//mark", methods=["POST"]) @@ -419,14 +468,14 @@ def api_vp_task_adopt(job_id): return jsonify({"ok": False, "error": f"保存失败: {str(e)[:120]}"}), 500 _log.info(f"给任务 {job.name}({job_id}) 插上平台发布步骤") return jsonify({"ok": True, "msg": "已插入「推送发布视频」（最前）与「标记发布结果」（最后）——" - "你原来的步骤没动；到「账号 → 发布计划」里核对一下顺序", + "你原来的步骤没动；到「发布计划」里核对一下顺序", "task": _job_brief(job, context.mgr)}) @bp.route("/api/video_plan/tasks/", methods=["GET", "PUT"]) @perm_required(PERM_TASKS) def api_vp_task_one(job_id): - """就地编辑发布任务（「账号 → 发布计划」页里，不用跳「任务」页）。 + """就地编辑发布任务（「发布计划」页里，不用跳「任务」页）。 只放开这一页用得上的字段：`name` / `time`(HH:MM) / `target` / `steps` / `enabled`。 **没传的字段原样保留**（深合并：`params` 里还有去重有效期、抢占等通用参数， @@ -488,17 +537,15 @@ def api_vp_links(): """已发布作品的分享链接（界面展示 / `format=csv` 导出，给后续铺评论用）。""" rows = vp.links(date_from=(request.args.get("from") or "").strip(), date_to=(request.args.get("to") or "").strip(), - device=(request.args.get("device") or "").strip(), - phone=(request.args.get("phone") or "").strip()) + name=(request.args.get("name") or "").strip()) if (request.args.get("format") or "") == "csv": buf = io.StringIO() w = csv.writer(buf) - w.writerow(["发布日期", "设备号", "手机号", "抖音号", - "编号", "标题", "正文", "分享链接", "发布时间"]) + # 按**名字**导出（手机号/抖音号随台账停用一起下线；由谁发的看 posted_device_name） + w.writerow(["发布日期", "名字", "编号", "标题", "正文", "分享链接", "发布时间"]) for r in rows: - w.writerow([r["release_date"], r["device_name"], r["phone"], - r["douyin_id"], r["seq"], r["title"], r.get("body", ""), - r["share_url"], r["published_at"]]) + w.writerow([r["release_date"], r["nickname"], r["seq"], r["title"], + r.get("body", ""), r["share_url"], r["published_at"]]) data = ("" + buf.getvalue()).encode("utf-8") # BOM：Excel 打开中文不乱码 return send_file(io.BytesIO(data), mimetype="text/csv", as_attachment=True, download_name=f"video_links_{vp._today()}.csv") diff --git a/web_server.py b/web_server.py index 11442ef..6dc74ef 100644 --- a/web_server.py +++ b/web_server.py @@ -120,9 +120,6 @@ device_battery.init_app(app) # 去重账本（跨设备幂等）：绑 app 供任务线程/Web/清理任务自推 context from core import dedup dedup.init_app(app) -# 账号台账：绑 app 供任务线程（条件判断取号）/ Web / 设备端身份页自推 context -from core import ledger -ledger.init_app(app) # 视频发布计划：绑 app 供任务线程（发布步骤）/ Web / 清理 job 自推 context from core import video_plan video_plan.init_app(app)