Merge feature/commission-daily-history for Web 2.0.8

This commit is contained in:
AttilaNet
2026-11-13 10:00:31 +08:00
25 changed files with 2179 additions and 96 deletions
+7
View File
@@ -64,6 +64,13 @@ jobs:
ranch_assistant.tests.test_species_retention_limits \ ranch_assistant.tests.test_species_retention_limits \
ranch_assistant.tests.test_primary_cultivation \ ranch_assistant.tests.test_primary_cultivation \
ranch_assistant.tests.test_primary_resource_admission -v ranch_assistant.tests.test_primary_resource_admission -v
- name: Offline commission history and priority regression
run: |
python -B -m unittest \
ranch_assistant.tests.test_commission_history \
ranch_assistant.tests.test_commission_history_review \
ranch_assistant.tests.test_commission_priority \
ranch_web.tests.test_commission_history -v
- name: Offline updater and task log regression - name: Offline updater and task log regression
run: python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package ranch_web.tests.test_activity ranch_web.tests.test_task_logs -v run: python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package ranch_web.tests.test_activity ranch_web.tests.test_task_logs -v
- name: Offline account recovery regression - name: Offline account recovery regression
+1 -1
View File
@@ -1,6 +1,6 @@
FROM python:3.12-slim-bookworm FROM python:3.12-slim-bookworm
ARG WEB_VERSION=2.0.7 ARG WEB_VERSION=2.0.8
ARG VCS_REF=unknown ARG VCS_REF=unknown
LABEL org.opencontainers.image.source="https://github.com/attilanet/myrzx_bot" \ LABEL org.opencontainers.image.source="https://github.com/attilanet/myrzx_bot" \
org.opencontainers.image.title="myrzx_bot Web" \ org.opencontainers.image.title="myrzx_bot Web" \
+11 -8
View File
@@ -1,11 +1,11 @@
# 牧羊人之心Bot # 牧羊人之心Bot
本轮 Web 发布目标 **2.0.7**,源码入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。 Web **2.0.8**,源码发布入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。
支持多账号独立运行、牧场培养、每日事务、主线与委托推进、近似战斗模拟、探险、扫荡及本地掉落分析,能力与验证限制见下文。 支持多账号独立运行、牧场培养、每日事务、主线与委托推进、近似战斗模拟、探险、扫荡及本地掉落分析,能力与验证限制见下文。
## 运行指引 ## 运行指引
### Web 2.0.7(main) ### Web 2.0.8(源码发布入口 main)
Windows 使用 Python 3.12+,在项目根目录执行: Windows 使用 Python 3.12+,在项目根目录执行:
@@ -19,7 +19,9 @@ py -3 -m venv .venv-web
Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`。Linux Python 启动、离线演示与环境配置见 [Web 运行说明](ranch_web/README.md);单服务 Docker、`/data` 持久化、子路径反代与宿主机受控更新见 [Web 部署说明](deploy/web/README.md)。 Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`。Linux Python 启动、离线演示与环境配置见 [Web 运行说明](ranch_web/README.md);单服务 Docker、`/data` 持久化、子路径反代与宿主机受控更新见 [Web 部署说明](deploy/web/README.md)。
**2.0.7** 修复同种重复魔物被继续喂养的问题:主培养固定为已养成的高等级魔物,更优资质只作备用;自动喂养、赠礼、潜能突破仅作用于主培养。已启用孵蛋规则按主培养1只、严格更优备用最多1只整理。通过“帮助 → 检查版本更新…”安装,详见 [发布说明](analysis/RELEASE_2_0_7.md)。 **2.0.8** 自动委托提供“当前委托 / 每日记录”,跨城市按合格候选的预计氪金 **20→15→10** 排序并说明回退原因;按角色、北京时间自然日持久记录接取、推进和领奖,保留最近90天、每角色最多5000条事件。静态预计奖励与领奖回包确认金额分开,缺失金额保持未确认;旧历史仅从本地任务 journal 可证实的部分回填。详见 [2.0.8 发布说明](analysis/RELEASE_2_0_8.md)。
沿用 **2.0.7** 的主培养修复:主培养固定为已养成的高等级魔物,更优资质只作备用;自动喂养、赠礼、潜能突破仅作用于主培养。已启用孵蛋规则按主培养1只、严格更优备用最多1只整理,详见 [2.0.7 发布说明](analysis/RELEASE_2_0_7.md)。
### 桌面 1.2.0 ### 桌面 1.2.0
@@ -36,7 +38,7 @@ Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`
| 组件与版本 | 《牧羊人之心》Android 基线 | 入口与状态 | | 组件与版本 | 《牧羊人之心》Android 基线 | 入口与状态 |
| --- | --- | --- | | --- | --- | --- |
| Web 2.0.7 | 1.9.68 | 本轮发布目标;源码入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` | | Web 2.0.8 | 1.9.68 | 源码发布入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` |
| 桌面 1.2.0(`v1.2.0`) | 1.9.68 | 当前桌面版本;`Start_Ranch_Helper.cmd` / `python -m ranch_assistant` | | 桌面 1.2.0(`v1.2.0`) | 1.9.68 | 当前桌面版本;`Start_Ranch_Helper.cmd` / `python -m ranch_assistant` |
| 桌面 1.1.1(`v1.1.1`) | 1.9.68 | 历史正式版本,1.1 系列修复与界面更新 | | 桌面 1.1.1(`v1.1.1`) | 1.9.68 | 历史正式版本,1.1 系列修复与界面更新 |
| 桌面 1.1.0(`v1.1.0`) | 1.9.68 | 历史已发布版本 | | 桌面 1.1.0(`v1.1.0`) | 1.9.68 | 历史已发布版本 |
@@ -44,23 +46,24 @@ Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`
本表记录适配资料基线,不代表其他客户端版本兼容或全部功能已完成实机验收。Docker 镜像以标签流水线成功结果为准,在线更新依赖对应 GitHub Release 条目;详见 [部署说明](deploy/web/README.md)。 本表记录适配资料基线,不代表其他客户端版本兼容或全部功能已完成实机验收。Docker 镜像以标签流水线成功结果为准,在线更新依赖对应 GitHub Release 条目;详见 [部署说明](deploy/web/README.md)。
## Web 2.0.7 主要功能与分类日志 ## Web 2.0.8 主要功能与分类日志
2.0.7 保留自 2.0.3 起的单一底部日志区,切换页签只显示当前账号、当前功能的日志,不提供总日志或页内日志框。本版重点修复同种重复培养,详见 [2.0.7 发布说明](analysis/RELEASE_2_0_7.md)。 2.0.8 沿用 2.0.7 的主培养修复与现有界面,并保留自 2.0.3 起的单一底部日志区,切换页签只显示当前账号、当前功能的日志,不提供总日志或页内日志框。自动委托行为与验证状态见 [2.0.8 发布说明](analysis/RELEASE_2_0_8.md)。
- **原布局与15页**:沿用桌面页面顺序、账号页签、顶部玩家数值与统一启停、可调整日志区。 - **原布局与15页**:沿用桌面页面顺序、账号页签、顶部玩家数值与统一启停、可调整日志区。
- **多账号与独立后台**:各账号隔离并行、同账号请求串行;关闭网页或退出管理登录后,服务端继续监控及已开启的策略。 - **多账号与独立后台**:各账号隔离并行、同账号请求串行;关闭网页或退出管理登录后,服务端继续监控及已开启的策略。
- **管理登录与子路径**:独立管理登录页、HttpOnly / SameSite cookie、写请求来源校验;支持 `/ranch` 等反代子路径,游戏凭据保存在服务端。 - **管理登录与子路径**:独立管理登录页、HttpOnly / SameSite cookie、写请求来源校验;支持 `/ranch` 等反代子路径,游戏凭据保存在服务端。
- **策略与数据**:复用孵蛋、牧场、喂养、突破、赠礼、每日、主线、委托、探险和扫荡策略,支持自动保存、导入导出、执行计划及掉落分析。 - **策略与数据**:复用孵蛋、牧场、喂养、突破、赠礼、每日、主线、委托、探险和扫荡策略,支持自动保存、导入导出、执行计划及掉落分析。
- **自动委托(2.0.8)**:当前委托与每日记录分栏;符合条件的候选跨城市按20→15→10排序,说明高档回退原因,城市锁定候选显示不可接取。历史按角色、北京时间保存,预计奖励与领奖确认金额分开。运行详情使用原单一底部“自动委托”分类日志。
- **底部分类日志**:保留原底部日志区及工具栏,顶部右侧是唯一显示/隐藏入口。整页刷新或重新进入工作台默认收起,即使旧配置为显示也不自动展开;配置/状态刷新及调试模式不展开日志。手动显隐按账号保留至刷新,同账号切换功能页保持显隐并更新日志范围。 - **底部分类日志**:保留原底部日志区及工具栏,顶部右侧是唯一显示/隐藏入口。整页刷新或重新进入工作台默认收起,即使旧配置为显示也不自动展开;配置/状态刷新及调试模式不展开日志。手动显隐按账号保留至刷新,同账号切换功能页保持显隐并更新日志范围。
- **日志操作与隔离**:搜索、清空显示、下载、跟随/暂停及滚动位置按账号与页签隔离;清空不删除服务端历史,下载遵循当前范围与搜索条件,不串入其他账号或功能。日志共用同一账号拉取,浏览器缓存最多 1200 条,底部最多显示最近 600 条。 - **日志操作与隔离**:搜索、清空显示、下载、跟随/暂停及滚动位置按账号与页签隔离;清空不删除服务端历史,下载遵循当前范围与搜索条件,不串入其他账号或功能。日志共用同一账号拉取,浏览器缓存最多 1200 条,底部最多显示最近 600 条。
- **日志归属**:培育室查看孵蛋日志,其他功能页查看对应执行日志;没有匹配记录时为空,不回退到全部日志。登录仅显示登录日志,排除常规、混合旧记录及赠礼日志。已有分类及保守旧记录推断沿用原实现。 - **日志归属**:培育室查看孵蛋日志,其他功能页查看对应执行日志;没有匹配记录时为空,不回退到全部日志。登录仅显示登录日志,排除常规、混合旧记录及赠礼日志。已有分类及保守旧记录推断沿用原实现。
- **手动刷新反馈**:刷新成功仅显示简短状态,详细日志只在原底部日志区查看,不弹出诊断提示或大段浮动消息,也不自动展开日志;错误与登录认证反馈沿用原有行为。 - **手动刷新反馈**:刷新成功仅显示简短状态,详细日志只在原底部日志区查看,不弹出诊断提示或大段浮动消息,也不自动展开日志;错误与登录认证反馈沿用原有行为。
- **日志保存与更新**:普通日志按账号限量持久保存,调试详情按进程缓存;仅检查官方稳定 2.x Release,未配置执行器时仅检查,受控安装与备份/回滚由宿主机执行,自动安装默认关闭。 - **日志保存与更新**:普通日志按账号限量持久保存,调试详情按进程缓存;仅检查官方稳定 2.x Release,未配置执行器时仅检查,受控安装与备份/回滚由宿主机执行,自动安装默认关闭。
连接状态区分在线、临时故障重试、游戏会话失效与未连接,显示最后成功通信及下次重试时间,旧快照标注为缓存。临时故障先停止策略,再退避执行只读探测;会话失效时停止游戏轮询,按自动重登设置等待,或手动恢复、重新登录。手动选服、恢复会话及自动重登成功后,均自动执行已勾选功能,可在顶部停止。获取区服候选或登录失败不视为成功;未确认的写操作不自动重发,页面轮询不会清除游戏连接错误。 连接状态区分在线、临时故障重试、游戏会话失效与未连接,显示最后成功通信及下次重试时间,旧快照标注为缓存。临时故障先停止策略,再退避执行只读探测;会话失效时停止游戏轮询,按自动重登设置等待,或手动恢复、重新登录。未手动停止时,手动选服、恢复会话及自动重登成功后自动执行已勾选功能;已保存的手动暂停继续生效,可在顶部开启。获取区服候选或登录失败不视为成功;未确认的写操作不自动重发,页面轮询不会清除游戏连接错误。
战斗模拟仍为近似模型,特殊关卡并非全部支持。本版验证结果统一见 [发布说明](analysis/RELEASE_2_0_7.md#验证),历史记录见 [Web 验证说明](ranch_web/README.md#离线验证);离线验证不代表真实游戏 API 或生产升级/回滚验收。 战斗模拟仍为近似模型,特殊关卡并非全部支持。2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过,详见 [发布说明](analysis/RELEASE_2_0_8.md#验证);2.0.7 结果保留在 [历史发布说明](analysis/RELEASE_2_0_7.md#验证),其他历史记录见 [Web 验证说明](ranch_web/README.md#离线验证)。历史结果不计入 2.0.8,离线验证不代表真实游戏 API 或生产升级/回滚验收。
## 桌面 1.2.0 功能基线 ## 桌面 1.2.0 功能基线
+46
View File
@@ -0,0 +1,46 @@
# Web 2.0.8 发布说明
Web **2.0.8** 以 **2.0.7** 为基线,游戏资料 **1.9.68**,桌面正式版 **1.2.0**。
## 自动委托与每日记录
- “自动委托”分为**当前委托 / 每日记录**。当前页显示任务、原始候选、标注奖励及选择 / 阻塞原因;城市锁定的原始候选显示为不可接取,不计入可执行候选。
- 在策略允许、城市已解锁且满足次数、资源和步骤支持条件的候选中,跨城市按静态标注氪金 **20→15→10** 全局排序。选择低档时,日志记录高档缺失或不可执行的实际原因;不保证每次都有可接取的20档。
- 每日记录按账号、区服和角色隔离,以**北京时间(UTC+8)自然日**归档接取、推进、领奖及结果待核对事件,支持日期查询、刷新和服务重启后查看。每角色保留最近 **90 天、最多 5000 条事件**,任一上限达到即裁剪旧事件。
- **预计氪金**来自任务静态配置;**已确认氪金**仅取已确认的 `taskComplete` 领奖回包 `response.reward.ke`。缺失或无效金额显示“未确认”,不以预计值、余额变化或旧完成标记补算。接取和推进不计为奖励到账。
- 旧历史仅从本地任务 journal 中可证实的操作部分回填;仅有当前任务或旧完成标记不足以推定历史接取、领奖时间或金额。无本地记录不表示当天未做过委托。
- 运行详情沿用原有**单一底部“自动委托”分类日志**;每日记录是业务历史,沿用现有账号隔离、日志显隐与筛选。
## 保留的行为
沿用 [2.0.7 主培养与资质备用修复](RELEASE_2_0_7.md):已养成的高等级魔物保持主培养,更优资质只作备用;自动经验喂养、同种突破、赠礼及潜能材料仅用于主培养,满级、到上限、冷却或忙碌时等待。已启用种类保留主培养1只与严格更优备用最多1只,锁定、在队、装备、探索、委托等硬保护继续生效。
保留15页结构、账号页签、统一启停、居中加载反馈和紧凑表单。登录、恢复会话及重登成功后默认执行已勾选策略;用户手动“停止”跨掉线、重登和服务重启保留,点击“开启”恢复,导入配置保留启停意图。
## 验证
独立离线验证报告:`test-artifacts/commission-history-review-20261113/final-report.txt`(2026-11-13)。
| 范围 | 运行 | 通过 | 跳过 | 失败 / 错误 |
| --- | --- | --- | --- | --- |
| 纯核心 | 215 | 215 | 0 | 0 / 0 |
| 主培养回归 | 87 | 87 | 0 | 0 / 0 |
| Web 非浏览器 | 353 | 350 | 3 | 0 / 0 |
| 独立 Qt 任务状态 | 7 | 7 | 0 | 0 / 0 |
| 非浏览器小计 | 662 | 659 | 3 | 0 / 0 |
| 浏览器独立用例 | 77 | 77 | 0 | 0 / 0 |
| **合计** | **739** | **736** | **3** | **0 / 0** |
核心215项包含新增历史27项、独立评审23项及优先级7项,均已计入合计。3项跳过源于 Windows 的 POSIX 权限或符号链接限制。独立非浏览器验证前后170个源文件 / 测试 / CI文件哈希一致;纯核心、主培养与 Web 非浏览器组隔离 Qt,游戏操作使用合成客户端或本地 HTTP mock,未访问真实游戏 API。
浏览器77个独立用例全部验证通过:全量运行76项通过,加载模块在仅修正测试 fixture 的被动轮询竞态后3/3通过,重叠用例不重复计数。测试修复保留全部原断言,产品源码未变。浏览器证据:`test-artifacts/commission-history/final-browser-20261113T013148Z/loading-fixture-fix.report.json` 与 `fixture-race-proof.json`。
离线结果不代表真实账号奖励到账、镜像构建或生产升级 / 回滚验收。历史版本测试不计入本版。
## 更新包与发布条件
本地更新器由 `tools/build_web_updater.py` 生成:`test-artifacts/releases/v2.0.8/updater.pyz`,同目录 `SHA256SUMS` 使用 LF 换行。包内3份源文件与版本库源文件逐字节一致;构建结果可复现,版本、帮助与离线升级计划检查通过。
版本标签 `v2.0.8`,镜像 `ghcr.io/attilanet/myrzx_bot-web:v2.0.8`。在线更新以对应稳定 Release 与镜像均就绪为前提。
已有部署须等稳定 Release、正式镜像就绪且宿主机心跳有效后,通过“帮助 → 检查版本更新…”升级,完成后刷新网页;详见 [部署说明](../deploy/web/README.md)。
+2 -2
View File
@@ -1,11 +1,11 @@
name: ranch-web name: ranch-web
services: services:
web: web:
image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.7} image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.8}
build: build:
context: . context: .
args: args:
WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.7} WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.8}
user: "10001:10001" user: "10001:10001"
init: true init: true
restart: unless-stopped restart: unless-stopped
+15 -13
View File
@@ -1,8 +1,10 @@
# Web 2 Linux Docker 部署与更新 # Web 2 Linux Docker 部署与更新
当前更新示例以 `v2.0.7` 为目标;下文 2.0.1 首次初始化步骤保留历史版本。游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。镜像流水线成功、Git tag 与 GitHub Release 是不同的发布步骤:在线更新必须等对应镜像及非草稿、非预发布的 Release 均发布后才能使用。私有仓库未获授权返回 404 属于访问失败,不代表没有版本;只有成功读取列表且没有稳定 2.x 时才显示“暂无正式版”。 当前应用及更新示例为 `v2.0.8`。下文首次初始化章节保留 2.0.1 流程及历史版本示例。游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。镜像流水线成功、Git tag 与 GitHub Release 是不同的发布步骤:在线更新必须等对应镜像及非草稿、非预发布的 Release 均发布后才能使用。私有仓库未获授权返回 404 属于访问失败,不代表没有版本;只有成功读取列表且没有稳定 2.x 时才显示“暂无正式版”。
已在 2.0.1 完成私有仓库和 GHCR 认证的部署,可在 2.0.7 稳定 Release 与正式镜像就绪后直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器。尚未接入私有在线更新的宿主机才需参考下文“已有宿主机首次初始化”。 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,稳定 Release 与正式镜像发布后,可直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器。尚未接入私有在线更新的宿主机才需参考下文“已有宿主机首次初始化”。
2.0.8 自动委托提供“当前委托 / 每日记录”,合格候选跨城市按20→15→10排序并说明回退原因;历史按角色、北京时间自然日持久保存,最近90天、每角色最多5000条事件。静态预计奖励与领奖回包确认金额分开,旧历史仅回填本地任务 journal 可证实的部分;运行详情使用原单一底部分类日志。2.0.7 高等级主培养与资质备用修复继续生效,详见 [2.0.8 发布说明](../../analysis/RELEASE_2_0_8.md)。
## 容器与持久化 ## 容器与持久化
@@ -19,9 +21,9 @@ sudo install -m 0600 -o root -g root deploy/web/image.env.example .image.env
sudoedit .env .image.env sudoedit .env .image.env
``` ```
在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 选择 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.7`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。 在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 的目标示例为 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.8`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。
`/opt/ranch-web/data` 挂到容器 `/data`,包括账号、加密会话与密钥、配置、SQLite 统计和更新请求;独立于桌面数据。心跳控制目录独立只读挂到 `/run/ranch-updater`。使用 bind mount 的目录必须预先创建,Compose 不会悄悄创建 root 所有、容器无法写入的目录。默认容器用户 `10001:10001`,根文件系统只读,临时文件写到 `/tmp`。不要对现有账号目录重新初始化密钥。 `/opt/ranch-web/data` 挂到容器 `/data`,包括账号、加密会话与密钥、配置、委托历史、SQLite 统计和更新请求;独立于桌面数据。心跳控制目录独立只读挂到 `/run/ranch-updater`。使用 bind mount 的目录必须预先创建,Compose 不会悄悄创建 root 所有、容器无法写入的目录。默认容器用户 `10001:10001`,根文件系统只读,临时文件写到 `/tmp`。不要对现有账号目录重新初始化密钥。
正式版本启动: 正式版本启动:
@@ -51,9 +53,9 @@ Web 只读检查官方 GitHub Releases;默认只接受 `v2.MINOR.PATCH`,跳
### 已完成 2.0.1 初始化的宿主机 ### 已完成 2.0.1 初始化的宿主机
`v2.0.7` 稳定 Release 与正式镜像发布后,用户打开“帮助 → 检查版本更新…”,检查到 2.0.7 后手动提交更新请求,可从 2.0.1 直接安装。现有私有仓库认证、GHCR 登录与宿主机更新器继续使用;Web 按钮仍要求有效心跳及 `accept_web_requests=true`。请求显示 `pending` 只表示已提交,宿主机完成备份、安装及健康检查后才确认成功;升级完成后刷新网页以加载新版界面,底部日志默认收起。Windows 或未启用执行器时仍仅可检查版本。自动安装默认关闭。 稳定 Release 与正式镜像发布后,用户打开“帮助 → 检查版本更新…”,检查到 2.0.8 后手动提交更新请求,可从 2.0.1 直接安装。现有私有仓库认证、GHCR 登录与宿主机更新器继续使用;Web 按钮仍要求有效心跳及 `accept_web_requests=true`。请求显示 `pending` 只表示已提交,宿主机完成备份、安装及健康检查后才确认成功;升级完成后刷新网页以加载新版界面,底部日志默认收起。Windows 或未启用执行器时仍仅可检查版本。自动安装默认关闭。
### 全新宿主机准备 ### 全新宿主机安装
全新安装时,先安装 root 持有的配置,并准备独立更新器(示例的自动化开关默认关闭): 全新安装时,先安装 root 持有的配置,并准备独立更新器(示例的自动化开关默认关闭):
@@ -68,11 +70,11 @@ python3 -B /opt/ranch-web/updater.pyz --version
### 已有宿主机首次初始化(用户自行执行) ### 已有宿主机首次初始化(用户自行执行)
以下保留 2.0.1 引入私有在线更新时的初始化步骤与 Release 链接,仅供尚未初始化的宿主机参考;已完成私有仓库和 GHCR 认证的部署无需重做。步骤中的 `v2.0.1` 是首次初始化的历史目标,当前应用更新目标为 `v2.0.7`。 以下保留 2.0.1 引入私有在线更新时的初始化流程,仅供尚未初始化的宿主机参考;已完成私有仓库和 GHCR 认证的部署无需重做。本节的历史资产示例为 `v2.0.7`,第4步的 `v2.0.1` 是首次初始化的历史应用目标。当前应用升级须确认对应发布物就绪,再按上文步骤执行。
前提是原有 `/opt/ranch-web` Compose 部署、数据目录及 `/etc/ranch-web-updater.toml` 均已存在,配置仍由 root 持有。保留原有数据和配置,不重新初始化密钥;数据目录由 `10001:10001` 持有。以下仅初始化在线更新器,不需要复制项目源码或 Compose。 前提是原有 `/opt/ranch-web` Compose 部署、数据目录及 `/etc/ranch-web-updater.toml` 均已存在,配置仍由 root 持有。保留原有数据和配置,不重新初始化密钥;数据目录由 `10001:10001` 持有。以下仅初始化在线更新器,不需要复制项目源码或 Compose。
1. 用户登录有私有仓库读取权限的 GitHub 账号,从 [当前正式 Release](https://github.com/attilanet/myrzx_bot/releases/tag/v2.0.7) 下载 `updater.pyz` 和 `SHA256SUMS`,放到宿主机临时目录。确认 Release 已发布且镜像可读取,在下载目录执行 `sha256sum -c SHA256SUMS` 后安装: 1. 用户登录有私有仓库读取权限的 GitHub 账号,历史资产示例从 [2.0.7 Release](https://github.com/attilanet/myrzx_bot/releases/tag/v2.0.7) 下载 `updater.pyz` 和 `SHA256SUMS`,放到宿主机临时目录。确认 Release 已发布且镜像可读取,在下载目录执行 `sha256sum -c SHA256SUMS` 后安装:
```sh ```sh
sudo install -m 0644 -o root -g root updater.pyz /opt/ranch-web/updater.pyz sudo install -m 0644 -o root -g root updater.pyz /opt/ranch-web/updater.pyz
@@ -106,7 +108,7 @@ python3 -B /opt/ranch-web/updater.pyz --version
Docker 保存的宿主机登录配置供更新器拉镜像使用;不要复制开发机的 Git/registry 凭据,也不要把 Docker 凭据放进 GitHub Token 文件或 Web 容器。[GHCR 官方认证说明](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry) Docker 保存的宿主机登录配置供更新器拉镜像使用;不要复制开发机的 Git/registry 凭据,也不要把 Docker 凭据放进 GitHub Token 文件或 Web 容器。[GHCR 官方认证说明](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry)
4. 使用新包先检查再由用户明确发起在线更新: 4. 使用新包先检查再由用户明确发起在线更新。以下 `--apply v2.0.1` 仅保留首次初始化的历史示例,不是本轮 2.0.8 升级命令:
```sh ```sh
sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --check sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --check
@@ -161,12 +163,12 @@ Windows 或未安装执行器的 Docker 部署仍能检查版本,但按钮会
[web-image.yml](../../.github/workflows/web-image.yml) 仅对官方仓库的严格稳定 `v2.x.y` tag 推送 `ghcr.io/attilanet/myrzx_bot-web:v2.x.y`;校验 `ranch_web.__version__` 必须与 tag 一致,不能只改变镜像 label。PR 与手动运行只测试、构建,不推送。开发分支 push 不触发正式镜像发布,也没有 `latest` 滚动升级通道。CI 执行更新器、私有凭据和独立包回归,并在无外网容器中检查 healthcheck、非 root 数据写权限、无 Qt 和正常停止;镜像发布状态以对应 tag 的工作流结果为准。 [web-image.yml](../../.github/workflows/web-image.yml) 仅对官方仓库的严格稳定 `v2.x.y` tag 推送 `ghcr.io/attilanet/myrzx_bot-web:v2.x.y`;校验 `ranch_web.__version__` 必须与 tag 一致,不能只改变镜像 label。PR 与手动运行只测试、构建,不推送。开发分支 push 不触发正式镜像发布,也没有 `latest` 滚动升级通道。CI 执行更新器、私有凭据和独立包回归,并在无外网容器中检查 healthcheck、非 root 数据写权限、无 Qt 和正常停止;镜像发布状态以对应 tag 的工作流结果为准。
2.0.7 验证结果统一见 [发布说明](../../analysis/RELEASE_2_0_7.md#验证)。以下命令用于更新器离线验证;历史 Windows 离线验证与 Linux 部署烟测见 [Web 运行说明](../../ranch_web/README.md#离线验证),不计入本版验收。可在无 Docker 的机器上构建临时更新器资产并打印计划;`--dry-run` 不联网、不读取凭据、不调用 Docker,也不写文件: 2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过,详见 [发布说明](../../analysis/RELEASE_2_0_8.md#验证)。2.0.7 结果保留在 [历史发布说明](../../analysis/RELEASE_2_0_7.md#验证)。以下命令可复现本地更新器构建与离线检查;历史 Windows 离线验证与 Linux 部署烟测见 [Web 运行说明](../../ranch_web/README.md#离线验证),不计入本版验收。可在无 Docker 的机器上构建临时更新器资产并打印计划;`--dry-run` 不联网、不读取凭据、不调用 Docker,也不写文件:
```sh ```sh
python -B tools/build_web_updater.py --output test-artifacts/updater.pyz python -B tools/build_web_updater.py --output test-artifacts/releases/v2.0.8/updater.pyz
python -B test-artifacts/updater.pyz --version python -B test-artifacts/releases/v2.0.8/updater.pyz --version
python -B test-artifacts/updater.pyz --config deploy/web/updater.example.toml --apply v2.0.7 --dry-run python -B test-artifacts/releases/v2.0.8/updater.pyz --config deploy/web/updater.example.toml --apply v2.0.8 --dry-run
python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package -v python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package -v
``` ```
+2 -2
View File
@@ -1,2 +1,2 @@
# Pull only after the v2.0.7 image publishing workflow succeeds and the image is available. # Pull only after the v2.0.8 image publishing workflow succeeds and the image is available.
RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.7 RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.8
+305
View File
@@ -0,0 +1,305 @@
"""Bounded, per-role commission receipts, independent of rolling activity logs.
Only journaled operations enter this ledger. A current task or passTask flag
alone proves neither its acceptance date nor that its reward was collected.
"""
from __future__ import annotations
from copy import deepcopy
from datetime import date, datetime, timedelta
import json
import math
import os
from pathlib import Path
import threading
import time
import uuid
from .quests import CN, commission_priority
def beijing_day(timestamp=None):
return datetime.fromtimestamp(time.time() if timestamp is None else timestamp, CN).date().isoformat()
def confirmed_reward(response):
"""NetTask.finishTaskHandler -> RewardCenter -> MasterCenter.addKe: delta."""
reward = response.get("reward") if isinstance(response, dict) else None
value = reward.get("ke") if isinstance(reward, dict) else None
if type(value) not in (int, float) or not math.isfinite(value) or value < 0 or int(value) != value:
return None
return int(value)
def positive_id(value):
if isinstance(value, bool):
return None
try:
number = float(value)
return int(number) if math.isfinite(number) and number.is_integer() and number > 0 else None
except (ValueError, TypeError, OverflowError):
return None
def valid_stored_event(event):
required = {"id", "journal_id", "time", "date", "kind", "status", "description", "task_id", "task_type_id",
"name", "city", "expected_ke", "confirmed_ke", "selection_code", "selection_reason", "higher_reward_blockers"}
if not isinstance(event, dict) or not required <= event.keys():
return False
if any(not isinstance(event[key], str) for key in
("id", "journal_id", "date", "kind", "status", "description", "task_type_id", "name", "selection_code", "selection_reason")):
return False
if (type(event["time"]) not in (int, float) or not math.isfinite(event["time"])
or event["date"] != beijing_day(event["time"])):
return False
if event["task_id"] is not None and (type(event["task_id"]) is not int or event["task_id"] <= 0):
return False
if type(event["expected_ke"]) is not int or event["expected_ke"] < 0:
return False
if event["confirmed_ke"] is not None and (type(event["confirmed_ke"]) is not int or event["confirmed_ke"] < 0):
return False
return (bool(event["id"]) and bool(event["journal_id"]) and isinstance(event["higher_reward_blockers"], list)
and event["kind"] in ("accept", "complete", "reset", "step", "navigate", "dialogue", "battle", "farm", "local_step")
and event["status"] in ("confirmed", "pending", "unknown", "cancelled", "failed"))
def reconciled_accept_task(record, snapshot, today):
"""Recheck only a journal-proven acceptance from the current Beijing day."""
if (snapshot is None or record.get("outcome") != "reconciled"
or not (record.get("path") or "").endswith("taskLoopReceive")
or str(snapshot.raw.get("master", {}).get("id")) != str(record.get("role_id"))):
return None
timestamp = record.get("finished_at") or record.get("updated_at") or record.get("timestamp")
if type(timestamp) not in (int, float) or not math.isfinite(timestamp) or beijing_day(timestamp) != today:
return None
old = {str(task.get("id")) for task in (record.get("baseline") or {}).get("tasks", [])}
expected_id = positive_id(record.get("task_id"))
matches = [task for task in snapshot.raw.get("currentTasks", [])
if str(task.get("typeId")) == str(record.get("task_type_id")) and str(task.get("id")) not in old
and positive_id(task.get("id")) and positive_id(task.get("curStep"))
and (expected_id is None or positive_id(task["id"]) == expected_id)]
return {key: matches[0][key] for key in ("id", "typeId", "curStep")} if len(matches) == 1 else None
def journal_event(record, info, snapshot=None):
meta = record.get("commission") or {}
path, original = record.get("path") or "", record.get("kind") or ""
farming = bool(record.get("source_task_type_id"))
type_id = str(record.get("source_task_type_id") or record.get("task_type_id") or "")
if not (meta or (info or {}).get("type") == 4 or original.startswith("quest_")
or original in ("progression_loop_accept", "progression_loop_reset")):
return None
kind = ("farm" if farming else "accept" if path.endswith("taskLoopReceive") else
"complete" if path.endswith("taskComplete") else "reset" if path.endswith("taskLoopFlush") else
"navigate" if original == "progression_navigate" else "dialogue" if original == "progression_dialogue" else
"battle" if original == "progression_battle" else "local_step" if original == "progression_local_step" else "step")
response = record.get("response")
response_ok = isinstance(response, dict) and response.get("resCode", 0) in (0, "0")
action_response = record.get("commission_action_response")
action_receipt = record.get("commission_action_confirmed") is True and isinstance(action_response, dict) and action_response.get("resCode", 0) in (0, "0")
receipt = response_ok and (record.get("response_confirmed") is True or record.get("settlement_confirmed") is True
or record.get("phase") in ("acknowledged", "settlement_acknowledged")
or record.get("phase") == "done" and record.get("outcome") in ("task", "win"))
task_id = record.get("source_task_id") if farming else record.get("task_id")
phase, outcome = record.get("phase"), record.get("outcome")
status = "unknown" if "unknown" in str(phase) or outcome == "reconciled" else "pending"
if kind == "accept":
task = response.get("task") if receipt else None
if not isinstance(task, dict) and outcome == "reconciled":
# Bind only the snapshot that resolved this pending attempt. A
# later currentTasks entry may be another day's same-type task.
task = record.get("commission_task")
if (isinstance(task, dict) and str(task.get("typeId")) == type_id
and positive_id(task.get("id")) and positive_id(task.get("curStep"))):
task_id, status = positive_id(task["id"]), "confirmed"
elif receipt:
status = "unknown"
elif kind == "complete":
# passTask is type-level history: it cannot prove this instance's claim.
if receipt:
status = "confirmed"
elif receipt or action_receipt or phase == "done" and outcome in ("local", "win", "sweep", "event"):
status = "confirmed"
elif outcome == "reconciled" and kind in ("step", "battle", "reset"):
status = "confirmed"
if outcome in ("cancelled", "unsupported"):
status = "cancelled"
elif outcome == "loss":
status = "failed"
timestamp = (record.get("finished_at") or record.get("updated_at") or record.get("timestamp")) if status == "confirmed" else record.get("timestamp")
if type(timestamp) not in (int, float) or not math.isfinite(timestamp):
return None
name = str(meta.get("name") or (info or {}).get("name") or type_id or "每日委托")
expected = meta.get("expected_ke", -commission_priority(info or {}))
actual = confirmed_reward(response) if kind == "complete" and receipt else None
labels = {"accept": "接取委托", "complete": "领取委托奖励", "reset": "刷新每日委托",
"step": "提交委托步骤", "navigate": "委托导航", "dialogue": "委托对话", "battle": "委托战斗",
"farm": "收集委托材料", "local_step": "完成委托步骤本地收尾"}
detail = record.get("description") or ""
description = f"{labels[kind]}:{name}(预计{expected}氪金)"
if kind in ("step", "battle", "local_step") and record.get("step_number"):
description += f",第{record['step_number']}步"
if kind in ("navigate", "dialogue", "farm") and detail:
description += ";" + detail
if status == "confirmed":
if kind in ("step", "battle") and meta.get("operation_detail"):
description += ";" + meta["operation_detail"]
description += ";本地操作已完成" if outcome == "local" else ";快照已核对" if outcome == "reconciled" and not receipt else ";已确认"
if kind == "complete":
description += f",实际获得{actual}氪金" if actual is not None else ",实际氪金奖励未记录"
if kind == "accept" and meta.get("selection_reason"):
description += ";" + meta["selection_reason"]
else:
description += {"pending": ";请求待确认", "unknown": ";结果未知,等待核对,禁止重发",
"cancelled": ";未执行", "failed": ";战斗失败,未推进委托"}[status]
return {"id": str(record["attempt_id"]), "journal_id": str(record["attempt_id"]),
"time": timestamp, "date": beijing_day(timestamp), "kind": kind, "status": status,
"description": description, "task_id": positive_id(task_id), "task_type_id": type_id,
"name": name, "city": meta.get("city", (record.get("payload") or {}).get("city")),
"expected_ke": expected, "confirmed_ke": actual,
"operation_detail": meta.get("operation_detail", ""),
"confirmation": "receipt" if receipt or action_receipt else "local" if outcome == "local" else "snapshot" if outcome == "reconciled" and status == "confirmed" else "",
"selection_code": meta.get("selection_code", "unknown" if kind == "accept" else "already_accepted"),
"selection_reason": meta.get("selection_reason") or (("历史接取已确认,当时选择原因未记录" if status == "confirmed"
else "接取已取消,当时选择原因未记录" if status == "cancelled" else "接取结果待核对,当时选择原因未记录") if kind == "accept"
else "已有委托继续处理,接取时间及当时选择原因未记录"),
"higher_reward_blockers": deepcopy(meta.get("higher_reward_blockers") or [])}
class CommissionHistory:
def __init__(self, path=None, *, retention_days=90, max_events=5000, clock=None):
self.path = Path(path) if path else None
self.retention_days, self.max_events = retention_days, max_events
self.clock = clock or time.time
self.lock = threading.RLock()
self.state = {"version": 1, "roles": {}}
self.error = ""
self.warning = ""
self._dirty = False
self._seen = {}
if self.path and self.path.exists():
try:
state = json.loads(self.path.read_text(encoding="utf-8"))
if state.get("version") != 1 or not isinstance(state.get("roles"), dict):
raise ValueError("unsupported history")
for events in state["roles"].values():
if not isinstance(events, dict) or any(not valid_stored_event(event) for event in events.values()):
raise ValueError("invalid history")
self.state = state
except (OSError, ValueError, AttributeError, OverflowError) as error:
self.error = "委托历史无法读取,原文件已保留:" + type(error).__name__
def _prune(self):
cutoff = (datetime.fromtimestamp(self.clock(), CN).date() - timedelta(days=self.retention_days - 1)).isoformat()
for role, events in self.state["roles"].items():
keep = sorted((event for event in events.values() if event["date"] >= cutoff),
key=lambda event: (event["time"], event["id"]))[-self.max_events:]
self.state["roles"][role] = {event["id"]: event for event in keep}
def _save(self):
self._prune()
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
temporary = self.path.with_name(self.path.name + "." + uuid.uuid4().hex + ".tmp")
try:
with temporary.open("w", encoding="utf-8") as stream:
json.dump(self.state, stream, ensure_ascii=False, allow_nan=False)
stream.flush()
os.fsync(stream.fileno())
temporary.replace(self.path)
finally:
temporary.unlink(missing_ok=True)
def ingest(self, role_id, records, info_for, snapshot=None):
"""Upsert by existing attempt ID; never read traces or dispatch requests."""
if self.error:
return
with self.lock:
role_id = str(role_id)
events = self.state["roles"].setdefault(role_id, {})
seen = self._seen.setdefault(role_id, {})
changed = False
for record in records:
if str(record.get("role_id")) != role_id or not record.get("attempt_id"):
continue
key = str(record["attempt_id"])
acceptance = reconciled_accept_task(record, snapshot, beijing_day(self.clock()))
revision = (record.get("phase"), record.get("outcome"), record.get("updated_at"), record.get("finished_at"),
json.dumps([record.get("commission") or {}, record.get("commission_task"), acceptance], sort_keys=True, ensure_ascii=False))
if seen.get(key) == revision:
continue
info = info_for(str(record.get("source_task_type_id") or record.get("task_type_id") or ""))
evidence = record | {"commission_task": acceptance} if acceptance and not record.get("commission_task") else record
event = journal_event(evidence, info, snapshot)
if event:
previous = events.get(key)
# A previously captured receipt stays known after restart,
# even if a reconciled acceptance has left the snapshot.
if previous and previous["status"] == "confirmed" and event["status"] != "confirmed":
event = previous
if previous != event:
events[key] = event
changed = True
seen[key] = revision
current_ids = {str(record.get("attempt_id")) for record in records}
self._seen[role_id] = {key: revision for key, revision in seen.items() if key in current_ids}
self._dirty = self._dirty or changed
if self._dirty:
self._save()
self._dirty = False
self.warning = ""
def query(self, role_id, day=None):
today = beijing_day(self.clock())
if day is None:
day = today
if not isinstance(day, str):
raise ValueError("委托历史日期须为 YYYY-MM-DD")
try:
if date.fromisoformat(day).isoformat() != day:
raise ValueError(day)
except ValueError as error:
raise ValueError("委托历史日期须为 YYYY-MM-DD") from error
with self.lock:
events = sorted(self.state["roles"].get(str(role_id), {}).values(), key=lambda event: (event["time"], event["id"]))
dates = sorted({today, day, *(event["date"] for event in events)}, reverse=True)
daily = [event for event in events if event["date"] == day]
groups = {}
for event in events:
if event["date"] > day or not event["task_type_id"]:
continue
identity = f"{role_id}:{event['task_type_id']}:{event['task_id']}" if event["task_id"] else f"{role_id}:attempt:{event['id']}"
groups.setdefault(identity, []).append(event)
rows = []
for identity, timeline in groups.items():
selected = [event for event in timeline if event["date"] == day]
if not selected:
continue
accepted = next((event for event in timeline if event["kind"] == "accept" and event["status"] == "confirmed"), None)
completed = next((event for event in timeline if event["kind"] == "complete" and event["status"] == "confirmed"), None)
latest, first = timeline[-1], accepted or timeline[0]
status = (latest["status"] if latest["status"] in ("pending", "unknown", "failed", "cancelled") else "completed" if completed else
"accepted" if latest["kind"] == "accept" and accepted else "in_progress")
rows.append({"id": identity, "task_id": first["task_id"], "task_type_id": first["task_type_id"],
"name": first["name"], "city": first["city"], "status": status,
"accepted_at": accepted["time"] if accepted else None, "completed_at": completed["time"] if completed else None,
"expected_ke": first["expected_ke"], "confirmed_ke": completed["confirmed_ke"] if completed else None,
"selection_reason": first["selection_reason"], "selection_code": first["selection_code"],
"higher_reward_blockers": first["higher_reward_blockers"], "last_action": latest["description"], "events": selected})
receipts = {"accept": {}, "complete": {}}
for event in events:
if event["kind"] not in receipts or event["status"] != "confirmed":
continue
identity = (event["task_type_id"], event["task_id"]) if event["task_id"] else ("attempt", event["id"])
receipts[event["kind"]].setdefault(identity, event)
accepts = [event for event in receipts["accept"].values() if event["date"] == day]
completes = [event for event in receipts["complete"].values() if event["date"] == day]
result = {"date": day, "dates": dates, "timezone": "Asia/Shanghai", "role_id": str(role_id),
"summary": {"accepted_count": len(accepts), "completed_count": len(completes),
"pending_count": sum(row["status"] in ("pending", "unknown") for row in rows),
"expected_ke": sum(event["expected_ke"] for event in accepts),
"confirmed_ke": sum(event["confirmed_ke"] for event in completes if event["confirmed_ke"] is not None),
"unknown_reward_count": sum(event["confirmed_ke"] is None for event in completes)},
"rows": list(reversed(rows)), "events": list(reversed(daily)), "retention_days": self.retention_days,
"notice": "仅展示已记录的委托操作;缺失的旧历史未记录,不补推接取、完成或奖励。", "error": self.error or self.warning}
return deepcopy(result)
+177 -11
View File
@@ -12,7 +12,8 @@ from types import SimpleNamespace
from .model import Action, Catalog, Planner, Policy, Snapshot, seconds from .model import Action, Catalog, Planner, Policy, Snapshot, seconds
from .daily import DailyLedger, DailyPolicy, selected_entries from .daily import DailyLedger, DailyPolicy, selected_entries
from .sweeping import SweepPolicy, SweepRunner from .sweeping import SweepPolicy, SweepRunner
from .quests import QuestPolicy, TaskPlanner from .quests import QuestPolicy, TaskPlanner, commission_priority
from .commission_history import CommissionHistory
from .market import PurchaseBudget from .market import PurchaseBudget
from .management import expansion_quote, manual_monster_actions from .management import expansion_quote, manual_monster_actions
from .gifts import GiftPlanner from .gifts import GiftPlanner
@@ -104,6 +105,10 @@ class Engine:
self._progression_state_loaded = False self._progression_state_loaded = False
self._battle_catalog_ready = False self._battle_catalog_ready = False
self.battle_journal = BattleJournal(folder / "progression" / "journal.json" if folder else None) self.battle_journal = BattleJournal(folder / "progression" / "journal.json" if folder else None)
self._commission_history = CommissionHistory(folder / "progression" / "commission_history.json" if folder else None)
self._commission_history_roles = set()
self._commission_offer_diagnostics = []
self._commission_diagnostics_key = None
self.battles = BattleOrchestrator(catalog, self.battle_journal, battle_runtime, self.sweeper, self.battles = BattleOrchestrator(catalog, self.battle_journal, battle_runtime, self.sweeper,
request_builder=self._battle_request, observer=self._battle_observer) request_builder=self._battle_request, observer=self._battle_observer)
self._progression_cancel = threading.Event() self._progression_cancel = threading.Event()
@@ -454,6 +459,10 @@ class Engine:
self.battle_journal.save() self.battle_journal.save()
def _battle_observer(self, event, intent, response): def _battle_observer(self, event, intent, response):
if event == "started" and self._is_commission(intent):
record = self.battle_journal.pending(self.snapshot)
if record is not None:
self._journal_commission(record, intent)
if value(intent, "kind") == "map_battle": if value(intent, "kind") == "map_battle":
stage = SimpleNamespace(stage_id=str(value(intent, "stage_id")), level=str(value(intent, "difficulty"))) stage = SimpleNamespace(stage_id=str(value(intent, "stage_id")), level=str(value(intent, "difficulty")))
key = self.sweeper.key(self.snapshot, stage) key = self.sweeper.key(self.snapshot, stage)
@@ -487,6 +496,11 @@ class Engine:
if farming: if farming:
if event == "started": if event == "started":
planner.mark_started(self.snapshot, intent) # validates the issued ordinary intent only planner.mark_started(self.snapshot, intent) # validates the issued ordinary intent only
elif event in ("settled", "event"):
record = self.battle_journal.pending(self.snapshot)
if record is not None:
self.battle_journal.update(record, record["phase"],
commission_action_response=gameplay_response(response), commission_action_confirmed=True)
# Farming is a normal map action. Its journal and fresh server # Farming is a normal map action. Its journal and fresh server
# snapshot govern the result; it never acknowledges a task step. # snapshot govern the result; it never acknowledges a task step.
return None return None
@@ -701,6 +715,106 @@ class Engine:
info = self.game_data.task(value(intent, "source_task_type_id") or value(intent, "task_type_id")) if self.game_data else None info = self.game_data.task(value(intent, "source_task_type_id") or value(intent, "task_type_id")) if self.game_data else None
return bool(info and info.get("type") == 4) return bool(info and info.get("type") == 4)
def _commission_info(self, type_id):
info = self.game_data.task(type_id) if self.game_data and type_id else None
return info or self.catalog.data.get("task_info", {}).get(str(type_id)) or {}
def _sync_commission_history(self):
"""Use the already loaded, bounded journal; ledger failures never retry a game write."""
if self.snapshot is None or self.snapshot.raw.get("master", {}).get("id") is None:
return
role = str(self.snapshot.raw["master"]["id"])
try:
records = self.battle_journal.role(self.snapshot)["records"]
self._commission_history.ingest(role, records, self._commission_info, self.snapshot)
self._commission_history_roles.add(role)
except (OSError, ValueError, TypeError, KeyError, AttributeError):
self._commission_history.warning = "委托历史暂未写入磁盘;任务回包仍保存在原日志,稍后核对导入,请勿重发"
@account_serial
def commission_history(self, day=None):
"""Independent plain DTO; day is YYYY-MM-DD in Beijing, default wall-clock today.
summary: accepted_count/completed_count/pending_count/expected_ke/
confirmed_ke/unknown_reward_count. Unknown row rewards are None.
Only events on the selected day contribute to daily counts and rewards.
"""
role = str(self.snapshot.raw.get("master", {}).get("id", "")) if self.snapshot else ""
if role and (role not in self._commission_history_roles or self._commission_history._dirty):
self._sync_commission_history()
return self._commission_history.query(role, day)
@account_serial
def commission_offer_diagnostics(self):
"""Cached offline eligibility; no journal reload, game calls or runtime inspection."""
if self.snapshot is None:
return []
self._ensure_commission_diagnostics()
return deepcopy(self._commission_offer_diagnostics)
def _ensure_commission_diagnostics(self):
key = (id(self.snapshot), digest({"quest": vars(self.quest_policy), "ranch": vars(self.policy),
"progression": vars(self.progression_policy), "checks": self._commission_offer_checks}))
if key == self._commission_diagnostics_key:
return
if self.progression_planner is None:
self._ensure_progression()
# Reuse model checks from the worker's last planning pass. A missing
# check remains explicitly unverified until that worker runs.
self._commission_offer_diagnostics = self.progression_planner.commission_offers(
self.snapshot, self.quest_policy, self.policy, battle_policy=self.progression_policy,
accept_supported=lambda key: self._commission_offer_checks.get(str(key),
(False, "后续步骤或战斗能力尚未验证,等待后台检查")))
self._commission_diagnostics_key = key
def _journal_commission(self, record, intent, *, legacy=False):
type_id = str(value(intent, "source_task_type_id") or value(intent, "task_type_id") or "")
info = self._commission_info(type_id)
if info.get("type", 4 if legacy else None) != 4 and value(intent, "kind") not in ("progression_loop_reset", "quest_reset"):
return
selected = getattr(self.tasks if legacy else self.progression_planner, "commission_selection", {}) or {}
accepting = (record.get("path") or "").endswith("taskLoopReceive")
meta = {"name": info.get("name", type_id or "每日委托"), "expected_ke": -commission_priority(info),
"city": (record.get("payload") or {}).get("city")}
number = value(intent, "source_step_number") or value(intent, "step_number") or 0
steps = info.get("steps") or []
if 1 <= number <= len(steps):
step = steps[number - 1]
kind, required = step.get("statusType"), step.get("statusValue") or {}
remove = required.get("remove") is True
prefix = "提交" if remove else "核对持有"
type_key, count = str(required.get("type", "")), required.get("num", 0)
if kind == "getMoney":
detail = f"{prefix}金币×{required.get('money', 0)}"
elif kind == "getItem" or kind == "getMonster" and required.get("mode") == 0:
name = self.catalog.monster(type_key).get("name", type_key) + "蛋" if type_key in self.catalog.monsters else self.catalog.data.get("item_names", {}).get(type_key, f"道具#{type_key}")
detail = f"{prefix}{name}×{count}"
elif kind == "getMonster":
detail = f"{prefix}{self.catalog.monster(type_key).get('name', '魔物#' + type_key)}×{count}"
elif kind == "passStage":
stage = self.game_data.stage(required.get("stage")) if self.game_data else None
detail = f"通关{(stage or {}).get('name', required.get('stage', '指定关卡'))},难度{required.get('level', 1)}"
elif kind == "battle":
detail = "完成委托专用战斗"
elif kind == "none":
detail = "完成对话条件"
elif kind == "killMonster":
detail = f"核对{self.catalog.monster(type_key).get('name', '魔物#' + type_key)}累计击杀数量"
elif kind == "passLevel":
detail = f"核对角色等级达到{required.get('level', 0)}级"
else:
detail = str(value(intent, "description", ""))
meta["operation_detail"] = detail
if accepting and selected.get("task_type_id") == type_id:
meta.update(deepcopy(selected))
self.battle_journal.update(record, record["phase"], commission=meta)
def _commission_message(self, record, default):
self._sync_commission_history()
role = str(self.snapshot.raw["master"].get("id", ""))
event = self._commission_history.state["roles"].get(role, {}).get(str(record.get("attempt_id")))
return event["description"] if event else default
@staticmethod @staticmethod
def _is_farm(intent): def _is_farm(intent):
return bool(value(intent, "source_task_type_id")) and not value(intent, "task_id") and bool(value(intent, "stage_id")) return bool(value(intent, "source_task_type_id")) and not value(intent, "task_id") and bool(value(intent, "stage_id"))
@@ -725,18 +839,26 @@ class Engine:
"" if supported else self._commission_offer_reason or "委托后续步骤当前无法自动完成") "" if supported else self._commission_offer_reason or "委托后续步骤当前无法自动完成")
return supported return supported
def _commission_offer_eligibility(self, type_id):
self._check_commission_offer(type_id)
return self._commission_offer_checks[str(type_id)]
def _commission_offer_supported(self, type_id): def _commission_offer_supported(self, type_id):
self._commission_offer_reason = "委托后续条件、剧情或战斗未验证支持,未消耗接取次数" self._commission_offer_reason = "委托后续条件、剧情或战斗未验证支持,未消耗接取次数"
info = self.game_data.task(type_id) info = self.game_data.task(type_id)
if not info or info.get("type") != 4: if not info or info.get("type") != 4:
self._commission_offer_reason = "委托配置缺失或类型不符"
return False return False
for number, step in enumerate(info.get("steps", []), 1): for number, step in enumerate(info.get("steps", []), 1):
for name in (step.get("story"), step.get("afterStory")): for name in (step.get("story"), step.get("afterStory")):
if name and (self.game_data.script(name) or {}).get("supported") is not True: if name and (self.game_data.script(name) or {}).get("supported") is not True:
script = self.game_data.script(name) or {}
self._commission_offer_reason = f"第{number}步剧情 {name} 未验证支持" + (":" + ";".join(script.get("block_reasons") or []) if script.get("block_reasons") else "")
return False return False
kind = step.get("statusType") kind = step.get("statusType")
if kind in ("battle", "passStage"): if kind in ("battle", "passStage"):
if not self.quest_policy.battle_tasks: if not self.quest_policy.battle_tasks:
self._commission_offer_reason = "委托战斗开关未启用"
return False return False
intent = {"kind": "progression_battle", "task_type_id": str(type_id), "task_id": 0, intent = {"kind": "progression_battle", "task_type_id": str(type_id), "task_id": 0,
"step_number": number, "battle_kind": "passStage" if kind == "passStage" else "task", "step_number": number, "battle_kind": "passStage" if kind == "passStage" else "task",
@@ -748,12 +870,24 @@ class Engine:
return False return False
else: else:
policy = self._intent_policy({"task_type_id": str(type_id)}) policy = self._intent_policy({"task_type_id": str(type_id)})
ready, _, _ = self.progression_planner.requirement(self.snapshot, step, {}, policy, self.policy) ready, _, requirement_reason = self.progression_planner.requirement(self.snapshot, step, {}, policy, self.policy)
if not ready: if not ready:
sources = self.progression_planner.farming_intents(self.snapshot, step, sources = self.progression_planner.farming_intents(self.snapshot, step,
{"id": 0, "typeId": str(type_id), "curStep": number}, policy, self.policy) {"id": 0, "typeId": str(type_id), "curStep": number}, policy, self.policy)
if not any(self._is_sweep_intent(source) or self._battle_capability(source)[0] for source in sources): source_reasons = []
feasible = False
for source in sources:
supported, reason = (True, "") if self._is_sweep_intent(source) else self._battle_capability(source)
if supported:
feasible = True
break
if reason:
source_reasons.append(reason)
if not feasible:
self._commission_offer_reason = f"第{number}步:{requirement_reason}" + (";材料来源:" + ";".join(source_reasons) if source_reasons else ";没有当前可用的自动收集来源")
return False return False
if not info.get("steps"):
self._commission_offer_reason = "委托没有有效步骤"
return bool(info.get("steps")) return bool(info.get("steps"))
def _refresh_progression_cache(self, *, force=False): def _refresh_progression_cache(self, *, force=False):
@@ -770,28 +904,33 @@ class Engine:
"snapshot": self._battle_snapshot_digest, "runtime": id(self.battles.runtime)}) "snapshot": self._battle_snapshot_digest, "runtime": id(self.battles.runtime)})
key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy), key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy),
"quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot), "quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot),
"pending": self._progression_pending(), "runtime": id(self.battles.runtime), "day": int(self.snapshot.now // 86400)}) "pending": self._progression_pending(), "runtime": id(self.battles.runtime),
"day": ProgressionPlanner._loop_day(self.snapshot, self.snapshot.now - 10)})
if force or key != self._progression_cache_key: if force or key != self._progression_cache_key:
self._commission_offer_checks = {} self._commission_offer_checks = {}
self._commission_diagnostics_key = None
rows = self.progression_planner.rows(self.snapshot, self.progression_policy, self.policy, quest_policy=self.quest_policy) rows = self.progression_planner.rows(self.snapshot, self.progression_policy, self.policy, quest_policy=self.quest_policy)
intents = self.progression_planner.plan(self.snapshot, self.progression_policy, self.policy) intents = self.progression_planner.plan(self.snapshot, self.progression_policy, self.policy)
commission_plan = getattr(self.progression_planner, "commission_plan", None) commission_plan = getattr(self.progression_planner, "commission_plan", None)
self._commission_planner_available = callable(commission_plan) self._commission_planner_available = callable(commission_plan)
if self._commission_planner_available: if self._commission_planner_available:
intents += commission_plan(self.snapshot, self.quest_policy, self.policy, intents += commission_plan(self.snapshot, self.quest_policy, self.policy,
battle_policy=self.progression_policy, accept_supported=self._check_commission_offer) battle_policy=self.progression_policy, accept_supported=self._commission_offer_eligibility)
self._commission_offer_diagnostics = deepcopy(self.progression_planner.commission_offer_rows)
intents.sort(key=lambda intent: not self._is_commission(intent)) intents.sort(key=lambda intent: not self._is_commission(intent))
self._progression_rows, self._progression_intents = self._overlay_battle_capabilities(rows, intents) self._progression_rows, self._progression_intents = self._overlay_battle_capabilities(rows, intents)
self._persist_progression() self._persist_progression()
self._progression_cache_key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy), self._progression_cache_key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy),
"quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot), "quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot),
"pending": self._progression_pending(), "runtime": id(self.battles.runtime), "day": int(self.snapshot.now // 86400)}) "pending": self._progression_pending(), "runtime": id(self.battles.runtime),
"day": ProgressionPlanner._loop_day(self.snapshot, self.snapshot.now - 10)})
self._progression_error = "" self._progression_error = ""
except (ImportError, OSError, ValueError, TypeError, KeyError, AttributeError) as error: except (ImportError, OSError, ValueError, TypeError, KeyError, AttributeError) as error:
self._progression_error = "任务规划暂不可用:" + str(error) self._progression_error = "任务规划暂不可用:" + str(error)
self._progression_rows = [{"state": "unsupported", "supported": False, "blocked_reason": self._progression_error}] self._progression_rows = [{"state": "unsupported", "supported": False, "blocked_reason": self._progression_error}]
self._progression_intents = [] self._progression_intents = []
self._progression_records = self.battle_journal.records(self.snapshot) self._progression_records = self.battle_journal.records(self.snapshot)
self._sync_commission_history()
@account_serial @account_serial
def refresh_progression(self): def refresh_progression(self):
@@ -838,9 +977,15 @@ class Engine:
try: try:
self.last_executed = True self.last_executed = True
kind = value(intent, "kind") kind = value(intent, "kind")
self._sync_commission_history()
if kind in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle", "sweep") or self._is_farm(intent): if kind in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle", "sweep") or self._is_farm(intent):
previous_attempts = {record["attempt_id"] for record in self.battle_journal.role(self.snapshot)["records"]}
message = self.battles.run(self.client, self.snapshot, intent, effective_policy, message = self.battles.run(self.client, self.snapshot, intent, effective_policy,
cancel=self._progression_cancel, ranch=self.policy) cancel=self._progression_cancel, ranch=self.policy)
records = [record for record in self.battle_journal.role(self.snapshot)["records"]
if record["attempt_id"] not in previous_attempts]
if records:
message = self._commission_message(records[-1], message)
else: else:
message = self._execute_task_intent(intent) message = self._execute_task_intent(intent)
if self.battle_journal.pending(self.snapshot) and kind == "progression_battle": if self.battle_journal.pending(self.snapshot) and kind == "progression_battle":
@@ -858,6 +1003,7 @@ class Engine:
self._persist_progression() self._persist_progression()
raise raise
finally: finally:
self._sync_commission_history()
self._refresh_progression_cache(force=True) self._refresh_progression_cache(force=True)
def _execute_task_intent(self, intent): def _execute_task_intent(self, intent):
@@ -875,12 +1021,14 @@ class Engine:
return "任务补链必须提供计算后的三个数组;未发送查询或空补链" return "任务补链必须提供计算后的三个数组;未发送查询或空补链"
if self._progression_cancel.is_set(): if self._progression_cancel.is_set():
return "任务推进已取消" return "任务推进已取消"
self._sync_commission_history()
record = self.battle_journal.begin(self.snapshot, intent) record = self.battle_journal.begin(self.snapshot, intent)
self._journal_commission(record, intent)
if local: if local:
self.progression_planner.acknowledge(self.snapshot, intent) self.progression_planner.acknowledge(self.snapshot, intent)
self._persist_progression(save=False) self._persist_progression(save=False)
self.battle_journal.finish(self.snapshot, record, "local", "已保存普通剧情的本地检查点") self.battle_journal.finish(self.snapshot, record, "local", "已保存普通剧情的本地检查点")
return "已推进普通剧情并保存本地检查点" return self._commission_message(record, "已推进普通剧情并保存本地检查点")
try: try:
self.progression_planner.mark_started(self.snapshot, intent) self.progression_planner.mark_started(self.snapshot, intent)
self._persist_progression(save=False) self._persist_progression(save=False)
@@ -890,7 +1038,7 @@ class Engine:
except CancelledBeforeDispatch: except CancelledBeforeDispatch:
self._cancel_unsent_progression(intent) self._cancel_unsent_progression(intent)
self.battle_journal.finish(self.snapshot, record, "cancelled", "任务请求尚未发送,已取消") self.battle_journal.finish(self.snapshot, record, "cancelled", "任务请求尚未发送,已取消")
return record["message"] return self._commission_message(record, record["message"])
self.battle_journal.update(record, "acknowledged", response=gameplay_response(response), response_confirmed=True) self.battle_journal.update(record, "acknowledged", response=gameplay_response(response), response_confirmed=True)
acknowledged = self.progression_planner.acknowledge(self.snapshot, intent, gameplay_response(response)) acknowledged = self.progression_planner.acknowledge(self.snapshot, intent, gameplay_response(response))
self._persist_progression(save=False) self._persist_progression(save=False)
@@ -898,17 +1046,30 @@ class Engine:
self.battle_journal.finish(self.snapshot, record, "task", "服务器已确认任务请求,已保存本地检查点") self.battle_journal.finish(self.snapshot, record, "task", "服务器已确认任务请求,已保存本地检查点")
else: else:
self.battle_journal.update(record, "unknown", message="任务成功回包缺少有效状态,等待核对") self.battle_journal.update(record, "unknown", message="任务成功回包缺少有效状态,等待核对")
return value(intent, "description", "任务请求已确认") return self._commission_message(record, value(intent, "description", "任务请求已确认") if acknowledged else "任务成功回包缺少有效状态,等待核对,禁止重发")
except Exception as error: except Exception as error:
self.battle_journal.update(record, "unknown", message="任务请求结果未确认,禁止自动重试", error_type=type(error).__name__) self.battle_journal.update(record, "unknown", message="任务请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise raise
finally:
self._sync_commission_history()
@account_serial @account_serial
def read_snapshot(self, *, sync_master=True): def read_snapshot(self, *, sync_master=True):
if self._progression_pending(): if self._progression_pending():
self.last_pending_check = time.monotonic() self.last_pending_check = time.monotonic()
self.snapshot = self.client.snapshot() self.snapshot = self.client.snapshot()
self.battle_journal.reconcile(self.snapshot, trusted=True) pending = self.battle_journal.pending(self.snapshot)
pending_id = pending.get("attempt_id") if pending else None
if self.battle_journal.reconcile(self.snapshot, trusted=True) and pending_id:
record = next((row for row in self.battle_journal.role(self.snapshot)["records"]
if row["attempt_id"] == pending_id), None)
if record and (record.get("path") or "").endswith("taskLoopReceive"):
old = {str(task.get("id")) for task in record.get("baseline", {}).get("tasks", [])}
task = next((task for task in self.snapshot.raw.get("currentTasks", [])
if str(task.get("typeId")) == str(record.get("task_type_id")) and str(task.get("id")) not in old), None)
if task:
record["commission_task"] = {key: task[key] for key in ("id", "typeId", "curStep") if key in task}
self._sync_commission_history()
self.master_sync.apply(self.snapshot) self.master_sync.apply(self.snapshot)
if sync_master and not self._progression_pending(): if sync_master and not self._progression_pending():
self.master_sync.settle(self.client, self.snapshot) self.master_sync.settle(self.client, self.snapshot)
@@ -1223,15 +1384,20 @@ class Engine:
if str(task.get("id")) == str(payload.get("taskId"))), {}) if str(task.get("id")) == str(payload.get("taskId"))), {})
intent = {"kind": action.kind, "description": action.description, "path": action.path, "payload": payload, intent = {"kind": action.kind, "description": action.description, "path": action.path, "payload": payload,
"task_id": payload.get("taskId"), "task_type_id": payload.get("taskTypeId"), "step_number": task.get("curStep")} "task_id": payload.get("taskId"), "task_type_id": payload.get("taskTypeId"), "step_number": task.get("curStep")}
self._sync_commission_history()
record = self.battle_journal.begin(self.snapshot, intent) record = self.battle_journal.begin(self.snapshot, intent)
self._journal_commission(record, intent, legacy=True)
try: try:
self.battle_journal.update(record, "request_pending") self.battle_journal.update(record, "request_pending")
response = self.battles._call(self.client, action.path, payload) response = self.battles._call(self.client, action.path, payload)
self.battle_journal.update(record, "acknowledged", response=gameplay_response(response)) self.battle_journal.update(record, "acknowledged", response=gameplay_response(response), response_confirmed=True)
action.description = self._commission_message(record, action.description)
return response return response
except Exception as error: except Exception as error:
self.battle_journal.update(record, "unknown", message="委托请求结果未确认,禁止自动重试", error_type=type(error).__name__) self.battle_journal.update(record, "unknown", message="委托请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise raise
finally:
self._sync_commission_history()
def _map_policy(self): def _map_policy(self):
return SimpleNamespace(enabled=self.sweep_policy.enabled and (self.sweep_policy.allow_challenge or self.sweep_policy.allow_special), return SimpleNamespace(enabled=self.sweep_policy.enabled and (self.sweep_policy.allow_challenge or self.sweep_policy.allow_special),
+62 -18
View File
@@ -45,7 +45,7 @@ import uuid
from .game_data import ProgressionData, load_progression_data from .game_data import ProgressionData, load_progression_data
from .model import Planner, seconds from .model import Planner, seconds
from .quests import commission_priority, indexed, stage_has_level from .quests import commission_priority, commission_selection, indexed, stage_has_level
CATEGORIES = {1: ("mainline", "主线"), 2: ("sidequest", "支线"), CATEGORIES = {1: ("mainline", "主线"), 2: ("sidequest", "支线"),
@@ -184,6 +184,8 @@ class ProgressionPlanner:
self._anonymous = uuid.uuid4().hex self._anonymous = uuid.uuid4().hex
self._accounts = {} self._accounts = {}
self._issued = {} self._issued = {}
self.commission_selection = {}
self.commission_offer_rows = []
def _scope(self, snapshot): def _scope(self, snapshot):
raw, master = snapshot.raw, snapshot.raw.get("master") or {} raw, master = snapshot.raw, snapshot.raw.get("master") or {}
@@ -896,11 +898,16 @@ class ProgressionPlanner:
taskLoopReceive:{taskTypeId,city}; quotas decrement only on acceptance taskLoopReceive:{taskTypeId,city}; quotas decrement only on acceptance
acknowledgement. Current battle/passStage never become sweep intents. acknowledgement. Current battle/passStage never become sweep intents.
""" """
self.commission_selection = {}
self.commission_offer_rows = []
if not quest_policy.enabled: if not quest_policy.enabled:
return [] return []
policy = self._commission_policy(quest_policy, battle_policy) policy = self._commission_policy(quest_policy, battle_policy)
scope, account = self._account(snapshot) scope, account = self._account(snapshot)
self.reconcile(snapshot) self.reconcile(snapshot)
candidates = self.commission_offers(snapshot, quest_policy, ranch_policy,
battle_policy=battle_policy, accept_supported=accept_supported)
self.commission_offer_rows = candidates
if account["pending"]: if account["pending"]:
reason = "存在未确认请求,委托等待核对,禁止重发" reason = "存在未确认请求,委托等待核对,禁止重发"
return [self._intent(scope, {}, 0, {}, "progression_blocked", reason, policy, block_reason=reason)] return [self._intent(scope, {}, 0, {}, "progression_blocked", reason, policy, block_reason=reason)]
@@ -925,30 +932,67 @@ class ProgressionPlanner:
blocked.append(action) blocked.append(action)
if blocked or not quest_policy.accept or remaining <= 0: if blocked or not quest_policy.accept or remaining <= 0:
return blocked return blocked
ranked_offers = sorted(((city, key) for city, values in offers.items() for key in _values(values)), rejected = []
key=lambda pair: commission_priority(self.data.task(str(pair[1])) or {})) for candidate in candidates:
for city, offered_key in ranked_offers: city, key = candidate["city"], candidate["task_type_id"]
city = _integer(city) info = self.data.task(key)
if city <= 0 or quest_policy.city and city != quest_policy.city or not snapshot.city_unlocked(city): if not candidate["eligible"]:
continue rejected.append(candidate)
key, info = str(offered_key), self.data.task(offered_key) if candidate["blocked_by_support"]:
if key in active or key in finished or not info or info.get("type") != 4: blocked.append(self._intent(scope, {"id": 0, "typeId": key}, 0, info.get("startStep") or {},
continue "progression_loop_accept", "暂不接取:" + info.get("name", key), policy,
if not self._commission_offer_ready(snapshot, quest_policy, policy, ranch_policy, info)[0]: path="taskService/taskLoopReceive", payload={"taskTypeId": key, "city": city}, phase=str(today),
continue block_reason=candidate["reason"]))
if accept_supported is not None and not accept_supported(key):
blocked.append(self._intent(scope, {"id": 0, "typeId": key}, 0, info.get("startStep") or {},
"progression_loop_accept", "暂不接取:" + info.get("name", key), policy,
path="taskService/taskLoopReceive", payload={"taskTypeId": key, "city": city}, phase=str(today),
block_reason="委托后续战斗或条件当前无法自动完成"))
continue continue
self.commission_selection = {"task_type_id": key, "city": city,
**commission_selection(info, candidates, rejected)}
action = self._intent(scope, {"id": 0, "typeId": key}, 0, info.get("startStep") or {}, action = self._intent(scope, {"id": 0, "typeId": key}, 0, info.get("startStep") or {},
"progression_loop_accept", "接取城市委托:" + info.get("name", key), policy, "progression_loop_accept", f"接取城市委托:{info.get('name', key)}(预计{candidate['expected_ke']}氪金);" + self.commission_selection["selection_reason"], policy,
path="taskService/taskLoopReceive", payload={"taskTypeId": key, "city": city}, phase=str(today)) path="taskService/taskLoopReceive", payload={"taskTypeId": key, "city": city}, phase=str(today))
self._issued[action.token] = action.to_dict() self._issued[action.token] = action.to_dict()
return [action] return [action]
return blocked return blocked
def commission_offers(self, snapshot, quest_policy, ranch_policy, *, battle_policy=None, accept_supported=None):
"""Offline eligibility for every offer; raw presence never means receivable."""
policy = self._commission_policy(quest_policy, battle_policy)
_, account = self._account(snapshot)
today, recorded, remaining, offers = self._loop_view(snapshot, account)
active, _, finished = self._tasks(snapshot, account)
has_active = any((self.data.task(key) or {}).get("type") == 4 and key not in finished for key in active)
rows = []
ranked = sorted(((city, key) for city, values in offers.items() for key in _values(values)),
key=lambda pair: commission_priority(self.data.task(str(pair[1])) or {}))
for offered_city, offered_key in ranked:
city, key = _integer(offered_city), str(offered_key)
info = self.data.task(key) or {}
if info.get("type") != 4:
continue
support_blocked = False
reason = ("城市编号无效" if city <= 0 else
f"策略限定城市 {quest_policy.city}" if quest_policy.city and city != quest_policy.city else
"城市尚未解锁" if not snapshot.city_unlocked(city) else
"委托列表已跨日,等待刷新确认" if recorded is not None and recorded != today and account["commissions"]["day"] != today else
"当日接取次数已用完" if remaining <= 0 else
"自动委托未启用" if not quest_policy.enabled else "自动接取未启用" if not quest_policy.accept else
"存在未确认请求,等待核对" if account["pending"] else
"该委托已接取或已完成" if key in active or key in finished else
"已有委托优先完成" if has_active else "")
if not reason:
ready, reason = self._commission_offer_ready(snapshot, quest_policy, policy, ranch_policy, info)
if ready:
reason = ""
if accept_supported is not None:
result = accept_supported(key)
supported, detail = result if isinstance(result, tuple) else (result, "")
if not supported:
reason = detail or "委托后续战斗或条件当前无法自动完成"
support_blocked = True
rows.append({"task_type_id": key, "name": info.get("name", key), "city": city,
"expected_ke": -commission_priority(info), "eligible": not reason, "reason": reason or "可接取",
"blocked_by_support": support_blocked})
return rows
def commission_rows(self, snapshot, quest_policy, ranch_policy, *, battle_policy=None): def commission_rows(self, snapshot, quest_policy, ranch_policy, *, battle_policy=None):
policy = self._commission_policy(quest_policy, battle_policy) policy = self._commission_policy(quest_policy, battle_policy)
return [row for row in self.rows(snapshot, policy, ranch_policy, quest_policy=quest_policy) return [row for row in self.rows(snapshot, policy, ranch_policy, quest_policy=quest_policy)
+37 -6
View File
@@ -15,6 +15,24 @@ def commission_priority(info):
return -reward return -reward
def commission_selection(info, offers, rejected):
"""Explain this selection using the offers actually examined, across cities."""
reward = -commission_priority(info)
higher = [row for row in rejected if row["expected_ke"] > reward]
has_twenty = any(row["expected_ke"] == 20 for row in offers)
if reward >= 20:
code, reason = "highest_reward", f"按氪金奖励优先,选择当前可处理的 {reward} 氪金委托"
elif not has_twenty:
code, reason = "no_20_offered", f"本次候选未提供20氪金委托,按奖励优先选择 {reward} 氪金委托"
if higher:
reason += ";" + ";".join(f"{row['name']}({row['expected_ke']}氪金):{row['reason']}" for row in higher)
else:
code = "20_ineligible"
details = ";".join(f"{row['name']}({row['expected_ke']}氪金):{row['reason']}" for row in higher)
reason = f"较高奖励委托当前不可接取,选择 {reward} 氪金委托" + (";" + details if details else "")
return {"selection_code": code, "selection_reason": reason, "higher_reward_blockers": higher}
def indexed(value, key, default=None): def indexed(value, key, default=None):
if isinstance(value, dict): if isinstance(value, dict):
return value.get(str(key), value.get(key, default)) return value.get(str(key), value.get(key, default))
@@ -84,6 +102,7 @@ class TaskPlanner:
def __init__(self, catalog): def __init__(self, catalog):
self.catalog = catalog self.catalog = catalog
self.guard = Planner(catalog) self.guard = Planner(catalog)
self.commission_selection = {}
def current(self, snapshot): def current(self, snapshot):
infos = self.catalog.data.get("task_info", {}) infos = self.catalog.data.get("task_info", {})
@@ -161,6 +180,7 @@ class TaskPlanner:
return rows return rows
def plan(self, snapshot, policy, ranch, *, include_active=True, accept_supported=None): def plan(self, snapshot, policy, ranch, *, include_active=True, accept_supported=None):
self.commission_selection = {}
if not policy.enabled: if not policy.enabled:
return [] return []
history = snapshot.raw.get("history", {}) history = snapshot.raw.get("history", {})
@@ -176,31 +196,42 @@ class TaskPlanner:
index, steps = int(task.get("curStep", 1)) - 1, info.get("steps", []) index, steps = int(task.get("curStep", 1)) - 1, info.get("steps", [])
payload = {"taskId": int(task["id"]), "taskTypeId": str(task["typeId"])} payload = {"taskId": int(task["id"]), "taskTypeId": str(task["typeId"])}
if steps and index >= len(steps): if steps and index >= len(steps):
return [Action("quest_complete", f"领取委托奖励:{info['name']}", "taskService/taskComplete", payload)] return [Action("quest_complete", f"领取委托奖励:{info['name']}(预计{-commission_priority(info)}氪金)", "taskService/taskComplete", payload)]
if 0 <= index < len(steps): if 0 <= index < len(steps):
ready, ids, _ = self.requirement(snapshot, steps[index], task, policy, ranch) ready, ids, _ = self.requirement(snapshot, steps[index], task, policy, ranch)
if ready: if ready:
return [Action("quest_step", f"推进委托:{info['name']}", "taskService/taskCompleteStep", payload | {"removeIds": ids or None})] return [Action("quest_step", f"推进委托:{info['name']}(预计{-commission_priority(info)}氪金)", "taskService/taskCompleteStep", payload | {"removeIds": ids or None})]
if current_tasks or not policy.accept or int(history.get("loopTaskNum", 0)) <= 0: if current_tasks or not policy.accept or int(history.get("loopTaskNum", 0)) <= 0:
return [] return []
current = {str(t["typeId"]) for t in self.current(snapshot)} current = {str(t["typeId"]) for t in self.current(snapshot)}
offers = sorted(self.rows(snapshot, policy, ranch), key=lambda row: commission_priority( offers = sorted(self.rows(snapshot, policy, ranch), key=lambda row: commission_priority(
self.catalog.data["task_info"][row[0]])) self.catalog.data["task_info"][row[0]]))
candidates, rejected = [], []
for type_id, name, state, _, meta in offers: for type_id, name, state, _, meta in offers:
if "city" not in meta or type_id in current: if "city" not in meta or type_id in current:
continue continue
city = meta["city"] city = meta["city"]
if policy.city and city != policy.city or not snapshot.city_unlocked(city):
continue
info = self.catalog.data["task_info"][type_id] info = self.catalog.data["task_info"][type_id]
if info.get("closed") or not condition_ok((info.get("startStep") or {}).get("condition"), snapshot): candidate = {"task_type_id": type_id, "name": name, "city": city, "expected_ke": -commission_priority(info)}
candidates.append(candidate)
reason = (f"策略限定城市 {policy.city}" if policy.city and city != policy.city else
"城市尚未解锁" if not snapshot.city_unlocked(city) else "委托已关闭" if info.get("closed") else
"接取前置条件未满足" if not condition_ok((info.get("startStep") or {}).get("condition"), snapshot) else "")
if reason:
rejected.append(candidate | {"reason": reason})
continue continue
steps = info.get("steps", []) steps = info.get("steps", [])
supported = accept_supported(type_id) if accept_supported else all( supported = accept_supported(type_id) if accept_supported else all(
(s.get("statusType") in ("passStage", "battle") and policy.battle_tasks) (s.get("statusType") in ("passStage", "battle") and policy.battle_tasks)
or self.requirement(snapshot, s, {}, policy, ranch)[0] for s in steps) or self.requirement(snapshot, s, {}, policy, ranch)[0] for s in steps)
if supported: if supported:
return [Action("quest_accept", f"接取委托:{name}", "taskService/taskLoopReceive", {"taskTypeId": type_id, "city": city})] self.commission_selection = {"task_type_id": type_id, "city": city,
**commission_selection(info, candidates, rejected)}
return [Action("quest_accept", f"接取委托:{name}(预计{-commission_priority(info)}氪金);" + self.commission_selection["selection_reason"],
"taskService/taskLoopReceive", {"taskTypeId": type_id, "city": city})]
reason = next((self.requirement(snapshot, step, {}, policy, ranch)[2] for step in steps
if not self.requirement(snapshot, step, {}, policy, ranch)[0]), "委托后续步骤当前无法自动完成")
rejected.append(candidate | {"reason": reason})
return [] return []
def reservations(self, snapshot): def reservations(self, snapshot):
@@ -0,0 +1,405 @@
"""Offline commission observability; every game transport is a fake."""
from copy import deepcopy
from datetime import datetime
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.commission_history import CommissionHistory, beijing_day
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Catalog, Snapshot
from ranch_assistant.quests import CN, QuestPolicy, TaskPlanner
from ranch_assistant.progression import ProgressionPlanner
from ranch_assistant.tests.test_progression import config, snapshot, step, task
class CommissionHistoryTests(unittest.TestCase):
def setUp(self):
self.folder = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="commission-offline-")))
self.catalog = Catalog()
self.tasks = {str(400 + number): task(str(400 + number), type=4,
name=name, reward={"ke": reward}) for number, (name, reward) in
enumerate((("低奖励委托", 10), ("中等奖励委托", 15), ("高奖励委托", 20)))}
self.data = ProgressionData(config(self.tasks))
self.snapshot = snapshot(currentTasks=[])
self.snapshot.raw["history"].update(loopTaskTime=self.snapshot.now, loopTaskNum=6,
loopTask={"1": ["400", "401"], "2": ["402"]}, unlockCity={"1": True, "2": True})
self.client = Mock()
self.client.call.side_effect = AssertionError("unexpected offline game operation")
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.snapshot.raw), self.snapshot.now)
def engine(self):
engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=self.data)
engine.snapshot = self.snapshot
engine.quest_policy = QuestPolicy(enabled=True)
return engine
def record(self, engine, *, kind="progression_complete", path="taskService/taskComplete",
task_id=51, type_id="402", response=None, outcome="task"):
record = engine.battle_journal.begin(engine.snapshot, {"kind": kind, "description": "旧任务操作",
"path": path, "payload": {}, "task_id": task_id, "task_type_id": type_id, "step_number": 1})
if response is not None:
engine.battle_journal.update(record, "acknowledged", response=response, response_confirmed=True)
if outcome is not None:
engine.battle_journal.finish(engine.snapshot, record, outcome)
return record
def receipt(self, attempt, *, kind="complete", task_id=51, type_id="402", when=None, role=1,
response=None, outcome="task", phase="done", **extra):
when = self.snapshot.now if when is None else when
paths = {"accept": "taskService/taskLoopReceive", "complete": "taskService/taskComplete",
"step": "taskService/taskCompleteStep", "navigate": "", "dialogue": "", "farm": "battleService/battleEnd"}
originals = {"accept": "progression_loop_accept", "complete": "progression_complete",
"step": "progression_step", "navigate": "progression_navigate", "dialogue": "progression_dialogue", "farm": "map_battle"}
return {"attempt_id": attempt, "role_id": str(role), "kind": originals[kind], "path": paths[kind],
"task_type_id": type_id, "task_id": task_id, "step_number": 1, "phase": phase, "outcome": outcome,
"timestamp": when, "finished_at": when if phase == "done" else None, "updated_at": when,
"response": {"resCode": 0} if response is None else response,
"response_confirmed": phase == "done" and outcome == "task", "payload": {},
"baseline": {"tasks": []}, **extra}
def ledger(self, records, *, now=None, role=1, **options):
ledger = CommissionHistory(self.folder / "history.json", clock=lambda: now or self.snapshot.now, **options)
ledger.ingest(role, records, lambda key: self.tasks.get(key), self.snapshot)
return ledger
def test_early_battle_return_never_relogs_previous_commission_claim(self):
engine = self.engine()
self.record(engine, response={"resCode": 0, "reward": {"ke": 20}})
engine.battles.run = Mock(return_value="体力不足,未开始战斗")
intent = {"kind": "progression_battle", "task_type_id": "402", "task_id": 52,
"step_number": 1, "description": "下一份委托战斗"}
with patch.object(engine, "read_snapshot"), patch.object(engine, "_refresh_progression_cache"):
_, _, message = engine._run_progression_intent(intent)
self.assertEqual(message, "体力不足,未开始战斗")
self.client.call.assert_not_called()
def test_receipts_persist_instance_and_expected_reward_separately_from_actual(self):
records = [self.receipt("a", kind="accept", task_id=0, type_id="401",
response={"resCode": 0, "task": {"id": 51, "typeId": "401", "curStep": 1}}),
self.receipt("c", type_id="401", response={"resCode": 0, "reward": {"ke": 7}})]
ledger = self.ledger(records)
dto = ledger.query(1)
self.assertEqual(dto["summary"], {"accepted_count": 1, "completed_count": 1, "pending_count": 0,
"expected_ke": 15, "confirmed_ke": 7, "unknown_reward_count": 0})
self.assertEqual(len(dto["rows"]), 1)
self.assertEqual((dto["rows"][0]["expected_ke"], dto["rows"][0]["confirmed_ke"]), (15, 7))
restored = CommissionHistory(self.folder / "history.json")
restored.ingest(1, records, self.tasks.get)
self.assertEqual(restored.query(1)["summary"], dto["summary"])
self.assertIn("实际获得7氪金", dto["rows"][0]["last_action"])
def test_wallet_total_and_missing_reward_never_become_confirmed_delta(self):
self.snapshot.raw["master"]["ke"] = 9000
records = [self.receipt("c", response={"resCode": 0, "ke": 9000, "master": {"ke": 9000}})]
dto = self.ledger(records).query(1)
self.assertEqual(dto["summary"]["completed_count"], 1)
self.assertEqual(dto["summary"]["confirmed_ke"], 0)
self.assertEqual(dto["summary"]["unknown_reward_count"], 1)
self.assertIsNone(dto["rows"][0]["confirmed_ke"])
def test_step_and_farming_loot_never_count_as_final_commission_reward(self):
records = [self.receipt("s", kind="step", response={"resCode": 0, "reward": {"ke": 5}}),
self.receipt("f", kind="farm", task_id=0, type_id="", outcome="win", source_task_id=51,
source_task_type_id="402", settlement_confirmed=True,
response={"resCode": 0, "stageReward": {"ke": 20}, "reward": {"ke": 20}})]
dto = self.ledger(records).query(1)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.assertEqual(dto["summary"]["confirmed_ke"], 0)
self.assertEqual({event["kind"] for event in dto["events"]}, {"step", "farm"})
self.assertEqual(len(dto["rows"]), 1)
def test_snapshot_presence_and_pass_task_flag_create_no_history(self):
self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "402", "curStep": 2}]
self.snapshot.raw["history"]["passTask"] = {"402": True}
engine = self.engine()
dto = engine.commission_history()
self.assertEqual(dto["rows"], [])
self.assertEqual(dto["summary"]["accepted_count"], 0)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.client.call.assert_not_called()
def test_reconciled_claim_without_receipt_remains_unknown(self):
self.snapshot.raw["history"]["passTask"] = {"402": True}
dto = self.ledger([self.receipt("c", phase="done", outcome="reconciled", response=None)]).query(1)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.assertEqual(dto["rows"][0]["status"], "unknown")
self.assertIsNone(dto["rows"][0]["confirmed_ke"])
def test_reconciled_acceptance_needs_new_instance_and_does_not_invent_reason(self):
self.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "402", "curStep": 1}]
record = self.receipt("a", kind="accept", task_id=0, outcome="reconciled", response=None,
baseline={"tasks": [{"id": 51, "typeId": "402"}]},
commission_task={"id": 52, "typeId": "402", "curStep": 1})
ledger = self.ledger([record])
dto = ledger.query(1)
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertEqual(dto["rows"][0]["task_id"], 52)
self.assertEqual(dto["rows"][0]["selection_code"], "unknown")
self.snapshot.raw["currentTasks"] = []
restored = CommissionHistory(self.folder / "history.json")
restored.ingest(1, [record], self.tasks.get, self.snapshot)
self.assertEqual(restored.query(1)["summary"]["accepted_count"], 1)
def test_old_reconciled_acceptance_cannot_bind_to_unrelated_current_instance(self):
self.snapshot.raw["currentTasks"] = [{"id": 99, "typeId": "402", "curStep": 1}]
stamp = self.snapshot.now - 2 * 86400
ledger = self.ledger([self.receipt("old-a", kind="accept", task_id=0,
when=stamp, outcome="reconciled", response=None)])
dto = ledger.query(1, beijing_day(stamp))
self.assertIsNone(dto["rows"][0]["task_id"])
self.assertEqual(dto["summary"]["accepted_count"], 0)
def test_fresh_snapshot_reconciliation_captures_exact_new_acceptance_instance(self):
engine = self.engine()
record = self.record(engine, kind="progression_loop_accept", path="taskService/taskLoopReceive",
task_id=0, outcome=None)
engine.battle_journal.update(record, "unknown")
self.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "402", "curStep": 1}]
engine.read_snapshot(sync_master=False)
dto = engine.commission_history()
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertEqual(dto["rows"][0]["task_id"], 52)
self.client.call.assert_not_called()
def test_acceptance_validates_numeric_ids_and_instance_identity(self):
for identifier, valid in (("51", True), (True, False), (51.5, False), ("bad", False)):
with self.subTest(identifier=identifier):
ledger = CommissionHistory()
ledger.ingest(1, [self.receipt(str(identifier), kind="accept", task_id=0,
response={"task": {"id": identifier, "typeId": "402", "curStep": "1"}})], self.tasks.get)
self.assertEqual(ledger.query(1)["summary"]["accepted_count"], int(valid))
ledger = CommissionHistory()
ledger.ingest(1, [self.receipt("wrong", kind="accept", task_id=0,
response={"resCode": 0, "task": {"id": 52, "typeId": "401", "curStep": 1}})], self.tasks.get)
self.assertEqual(ledger.query(1)["summary"]["accepted_count"], 0)
def test_duplicate_attempts_and_receipts_deduplicate_daily_counts_by_instance(self):
records = [self.receipt("a1", kind="accept", task_id=0,
response={"task": {"id": 51, "typeId": "402", "curStep": 1}}),
self.receipt("a2", kind="accept", task_id=0,
response={"task": {"id": "51", "typeId": "402", "curStep": 1}}),
self.receipt("c1", response={"reward": {"ke": 20}}),
self.receipt("c2", task_id="51", response={"reward": {"ke": 20}})]
ledger = self.ledger(records)
ledger.ingest(1, records, self.tasks.get)
dto = ledger.query(1)
self.assertEqual(len(dto["events"]), 4)
self.assertEqual(len(dto["rows"]), 1)
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertEqual(dto["summary"]["completed_count"], 1)
self.assertEqual(dto["summary"]["expected_ke"], 20)
self.assertEqual(dto["summary"]["confirmed_ke"], 20)
def test_beijing_midnight_repeat_types_and_cross_day_duplicate_claims(self):
midnight = datetime(2026, 11, 13, tzinfo=CN).timestamp()
records = [self.receipt("old", when=midnight - 1, response={"reward": {"ke": 20}}),
self.receipt("duplicate", when=midnight + 1, response={"reward": {"ke": 20}}),
self.receipt("new", task_id=52, when=midnight + 2, response={"reward": {"ke": 20}})]
ledger = self.ledger(records, now=midnight + 10)
self.assertEqual(beijing_day(midnight - 1), "2026-11-12")
self.assertEqual(ledger.query(1)["date"], "2026-11-13")
self.assertEqual(ledger.query(1, "2026-11-12")["summary"]["confirmed_ke"], 20)
dto = ledger.query(1)
self.assertEqual(len(dto["rows"]), 2)
self.assertEqual(dto["summary"]["completed_count"], 1)
self.assertEqual(dto["summary"]["confirmed_ke"], 20)
self.assertEqual(len({row["id"] for row in dto["rows"]}), 2)
self.assertEqual(dto["dates"], ["2026-11-13", "2026-11-12"])
def test_pending_and_failure_states_never_claim_success(self):
for phase, outcome, expected in (("request_pending", "", "pending"), ("unknown", "", "unknown"),
("done", "cancelled", "cancelled"), ("done", "loss", "failed")):
with self.subTest(expected=expected):
ledger = CommissionHistory()
ledger.ingest(1, [self.receipt(expected, kind="step", phase=phase, outcome=outcome)], self.tasks.get)
dto = ledger.query(1)
self.assertEqual(dto["rows"][0]["status"], expected)
self.assertEqual(dto["summary"]["completed_count"], 0)
self.assertNotIn(";已确认", dto["events"][0]["description"])
def test_existing_task_action_is_not_counted_as_accepted_today(self):
dto = self.ledger([self.receipt("s", kind="step")]).query(1)
self.assertEqual(dto["summary"]["accepted_count"], 0)
self.assertIsNone(dto["rows"][0]["accepted_at"])
self.assertEqual(dto["rows"][0]["selection_code"], "already_accepted")
def test_role_isolation_and_dto_mutation_cannot_change_history(self):
ledger = self.ledger([self.receipt("c", response={"reward": {"ke": 20}})])
self.assertEqual(ledger.query(2)["rows"], [])
dto = ledger.query(1)
dto["rows"][0]["events"][0]["description"] = "changed"
dto["summary"]["confirmed_ke"] = 10000
self.assertEqual(ledger.query(1)["summary"]["confirmed_ke"], 20)
self.assertNotEqual(ledger.query(1)["events"][0]["description"], "changed")
def test_bounded_retention_and_journal_rollover_preserve_imported_receipts(self):
now = self.snapshot.now
records = [self.receipt(str(number), task_id=number + 1, when=now - number,
response={"reward": {"ke": 20}}) for number in range(8)]
records.append(self.receipt("ancient", task_id=99, when=now - 91 * 86400, response={"reward": {"ke": 20}}))
ledger = self.ledger(records, max_events=4)
self.assertEqual(len(ledger.query(1)["events"]), 4)
ledger.ingest(1, [], self.tasks.get)
restored = CommissionHistory(self.folder / "history.json", max_events=4)
self.assertEqual(restored.query(1)["summary"]["completed_count"], 4)
def test_history_reads_do_not_reload_journal_or_load_full_progression(self):
engine = self.engine()
engine.game_data = None
self.record(engine, type_id="100", response={"reward": {"ke": 20}})
with patch("ranch_assistant.game_data.load_progression_data", side_effect=AssertionError("unexpected full load")), \
patch.object(engine.battle_journal, "records", side_effect=AssertionError("unexpected payload copy")), \
patch.object(engine.battle_journal, "reload", side_effect=AssertionError("unexpected journal reload")):
engine.commission_history()
engine.commission_history()
self.client.call.assert_not_called()
def test_history_write_failure_preserves_success_and_recovers_without_game_retry(self):
engine = self.engine()
engine._ensure_progression()
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
self.client.call.side_effect = lambda *args: {"resCode": 0, "task": {"id": 51, "typeId": "402", "curStep": 1}}
with patch.object(engine._commission_history, "_save", side_effect=OSError("fixture disk full")):
message = engine._execute_task_intent(intent)
self.assertIn("已确认", message)
dto = engine.commission_history()
self.assertEqual(dto["summary"]["accepted_count"], 1)
self.assertIn("暂未写入磁盘", dto["error"])
self.assertEqual(self.client.call.call_count, 1)
self.assertIsNone(engine.battle_journal.pending(self.snapshot))
recovered = engine.commission_history()
self.assertEqual(recovered["error"], "")
self.assertTrue(engine._commission_history.path.exists())
self.assertEqual(self.client.call.call_count, 1)
def test_acceptance_timeout_stays_unknown_and_restart_never_replays(self):
engine = self.engine()
engine._ensure_progression()
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
self.client.call.side_effect = TimeoutError("offline timeout")
with self.assertRaises(TimeoutError):
engine._execute_task_intent(intent)
self.assertEqual(engine.commission_history()["rows"][0]["status"], "unknown")
restored = self.engine()
restored._refresh_progression_cache(force=True)
_, _, message = restored._run_progression_intent()
self.assertIn("待核对", message)
self.assertEqual(self.client.call.call_count, 1)
self.assertEqual(restored.commission_history()["summary"]["accepted_count"], 0)
def test_accepted_reply_without_task_is_unknown_in_both_log_and_history(self):
engine = self.engine()
engine._ensure_progression()
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
self.client.call.side_effect = lambda *args: {"resCode": 0}
message = engine._execute_task_intent(intent)
self.assertIn("结果未知", message)
self.assertNotIn(";已确认", message)
self.assertEqual(engine.commission_history()["summary"]["accepted_count"], 0)
self.assertIsNotNone(engine.battle_journal.pending(self.snapshot))
def test_offer_diagnostics_and_selection_explain_locked_city_and_runtime(self):
engine = self.engine()
self.snapshot.raw["history"]["unlockCity"]["2"] = False
engine._refresh_progression_cache(force=True)
selected = engine.progression_planner.commission_selection
self.assertEqual(selected["task_type_id"], "401")
self.assertEqual(selected["selection_code"], "20_ineligible")
self.assertIn("城市尚未解锁", selected["selection_reason"])
with patch.object(engine, "_battle_capability", side_effect=AssertionError("UI must not inspect runtime")):
for _ in range(3):
rows = engine.commission_offer_diagnostics()
high = next(row for row in rows if row["task_type_id"] == "402")
self.assertFalse(high["eligible"])
self.assertEqual(high["reason"], "城市尚未解锁")
self.client.call.assert_not_called()
engine._commission_offer_supported = Mock(side_effect=lambda key: str(key) != "402")
engine._commission_offer_reason = "保护目标规则暂不支持"
self.snapshot.raw["history"]["unlockCity"]["2"] = True
engine._refresh_progression_cache(force=True)
self.assertIn("保护目标规则暂不支持", engine.progression_planner.commission_selection["selection_reason"])
def test_quota_and_city_filter_diagnostics_do_not_claim_receivable(self):
engine = self.engine()
engine.quest_policy.city = 1
engine._refresh_progression_cache(force=True)
high = next(row for row in engine.commission_offer_diagnostics() if row["task_type_id"] == "402")
self.assertFalse(high["eligible"])
self.assertIn("策略限定城市", high["reason"])
self.snapshot.raw["history"]["loopTaskNum"] = 0
engine._refresh_progression_cache(force=True)
rows = engine.commission_offer_diagnostics()
self.assertTrue(all(not row["eligible"] for row in rows))
self.assertIn("当日接取次数已用完", next(row for row in rows if row["city"] == 1)["reason"])
def test_unchanged_snapshot_replans_after_beijing_midnight_grace(self):
engine = self.engine()
before = datetime(2026, 11, 13, 23, 59, 59, tzinfo=CN).timestamp()
self.snapshot.raw["history"].update(loopTaskTime=before, loopTaskNum=0)
original = deepcopy(self.snapshot.raw)
with patch("ranch_assistant.model.time.time", return_value=before):
engine._refresh_progression_cache(force=True)
self.assertFalse(any(intent.kind == "progression_loop_reset" for intent in engine._progression_intents))
with patch("ranch_assistant.model.time.time", return_value=before + 12):
engine._refresh_progression_cache()
self.assertEqual(self.snapshot.raw, original)
self.assertTrue(any(intent.kind == "progression_loop_reset" for intent in engine._progression_intents))
def test_no_twenty_fallback_still_explains_rejected_fifteen(self):
self.snapshot.raw["history"]["loopTask"] = {"1": ["400", "401"]}
self.tasks["401"]["closed"] = True
for planner in (ProgressionPlanner(self.catalog, config(self.tasks)), TaskPlanner(self.catalog)):
self.catalog.data["task_info"] = self.tasks
if isinstance(planner, TaskPlanner):
action = planner.plan(self.snapshot, QuestPolicy(enabled=True), self.engine().policy)[0]
self.assertEqual(action.payload["taskTypeId"], "400")
else:
self.assertEqual(planner.commission_plan(self.snapshot, QuestPolicy(enabled=True), self.engine().policy)[0].task_type_id, "400")
self.assertEqual(planner.commission_selection["selection_code"], "no_20_offered")
self.assertIn("未提供20", planner.commission_selection["selection_reason"])
self.assertIn("委托已关闭", planner.commission_selection["selection_reason"])
def test_step_log_names_consumed_and_only_checked_items(self):
self.catalog.data.setdefault("item_names", {})["30001"] = "石块"
for remove, expected in ((True, "提交石块×5"), (False, "核对持有石块×5")):
with self.subTest(remove=remove):
engine = Engine(self.catalog, self.client, game_data=ProgressionData(config({"402": task("402", type=4,
reward={"ke": 20}, steps=[step("getItem", statusValue={"type": "30001", "num": 5, "remove": remove})])})))
engine.snapshot = self.snapshot
intent = {"kind": "quest_step", "task_id": 51, "task_type_id": "402", "step_number": 1,
"path": "taskService/taskCompleteStep", "payload": {}, "description": "提交步骤"}
record = engine.battle_journal.begin(self.snapshot, intent)
engine._journal_commission(record, intent, legacy=True)
engine.battle_journal.update(record, "acknowledged", response={"resCode": 0}, response_confirmed=True)
engine.battle_journal.finish(self.snapshot, record, "task")
dto = engine.commission_history()
self.assertIn(expected, dto["events"][0]["description"])
self.assertIn("20氪金", dto["events"][0]["description"])
def test_navigation_and_dialogue_are_local_evidence_with_honest_labels(self):
records = [self.receipt("n", kind="navigate", outcome="local", description="前往王城市场"),
self.receipt("d", kind="dialogue", outcome="local", description="与妮娜对话")]
dto = self.ledger(records).query(1)
self.assertEqual({event["kind"] for event in dto["events"]}, {"navigate", "dialogue"})
self.assertTrue(all(event["confirmation"] == "local" for event in dto["events"]))
self.assertEqual(dto["summary"]["accepted_count"], 0)
def test_invalid_day_and_corrupt_history_preserve_file(self):
ledger = self.ledger([])
for day in ("20261113", "2026-02-30", "2026-1-1", 20261113):
with self.subTest(day=day), self.assertRaises(ValueError):
ledger.query(1, day)
damaged = self.folder / "damaged.json"
damaged.write_text("not-json", encoding="utf-8")
ledger = CommissionHistory(damaged)
ledger.ingest(1, [self.receipt("c", response={"reward": {"ke": 20}})], self.tasks.get)
self.assertIn("无法读取", ledger.query(1)["error"])
self.assertEqual(damaged.read_text(encoding="utf-8"), "not-json")
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,369 @@
"""Independent offline review repros; all records and accounts are synthetic."""
from copy import deepcopy
from datetime import datetime, timezone
import json
from pathlib import Path
import tempfile
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.battles import BattleJournal
from ranch_assistant.commission_history import CommissionHistory, journal_event
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Catalog, Policy, Snapshot
from ranch_assistant.progression import ProgressionPlanner
from ranch_assistant.quests import QuestPolicy
NOW = datetime(2026, 11, 13, 4, tzinfo=timezone.utc).timestamp()
DAY = "2026-11-13"
INFO = {"id": "review20", "type": 4, "name": "Review commission", "reward": {"ke": 20},
"startStep": {"condition": {}}, "steps": [{"statusType": "none", "statusValue": {}}]}
def review_snapshot(role=71, tasks=()):
return Snapshot({"master": {"id": role, "level": 20, "money": 2000, "ti": 50, "ke": 99999},
"currentTasks": deepcopy(list(tasks)), "history": {"unlockCity": {"1": True}},
"items": [], "monsters": [], "stacks": [], "rooms": [], "teams": []})
def review_record(attempt="review-claim", *, kind="complete", task_id=81, timestamp=NOW, **changes):
record = {"attempt_id": attempt, "role_id": "71", "task_id": task_id, "task_type_id": "review20",
"kind": {"accept": "progression_loop_accept", "complete": "progression_reward",
"step": "progression_step", "battle": "progression_battle"}[kind],
"path": {"accept": "taskService/taskLoopReceive", "complete": "taskService/taskComplete",
"step": "taskService/taskCompleteStep", "battle": ""}[kind],
"timestamp": timestamp, "updated_at": timestamp, "finished_at": timestamp,
"phase": "done", "outcome": "task", "payload": {},
"commission": {"name": INFO["name"], "expected_ke": 20, "city": 1,
"selection_code": "highest_reward", "selection_reason": "review-selected"},
"baseline": {"tasks": []}, "response_confirmed": True,
"response": {"resCode": 0, "reward": {"ke": 20}}}
if kind == "accept":
record.update(task_id=None, response={"resCode": 0,
"task": {"id": task_id, "typeId": "review20", "curStep": 1}})
record.update(changes)
return record
class CommissionHistoryIndependentReviewTests(unittest.TestCase):
def setUp(self):
self.folder = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="commission-independent-review-")))
self.enterContext(patch("socket.socket.connect", side_effect=AssertionError("offline review forbids network")))
self.history = CommissionHistory(self.folder / "history.json", clock=lambda: NOW)
def ingest(self, records, snapshot=None, history=None, role="71"):
target = history if history is not None else self.history
target.ingest(role, records, lambda key: INFO, snapshot)
return target.query(role, DAY)
def test_cancelled_accept_with_task_body_is_never_confirmed(self):
record = review_record(kind="accept", outcome="cancelled")
event = journal_event(record, INFO, review_snapshot())
self.assertEqual(event["status"], "cancelled")
result = self.ingest([record])
self.assertEqual(result["summary"]["accepted_count"], 0)
self.assertEqual(result["summary"]["expected_ke"], 0)
self.assertIsNone(result["rows"][0]["accepted_at"])
def test_pending_receipt_body_does_not_count_as_a_claim(self):
record = review_record(phase="request_pending", outcome="", response_confirmed=False)
result = self.ingest([record])
self.assertEqual(result["summary"]["completed_count"], 0)
self.assertEqual(result["summary"]["confirmed_ke"], 0)
self.assertEqual(result["summary"]["pending_count"], 1)
self.assertIsNone(result["rows"][0]["confirmed_ke"])
def test_cancelled_and_failed_outcomes_stay_terminal_in_aggregate(self):
for outcome, status in (("cancelled", "cancelled"), ("unsupported", "cancelled"), ("loss", "failed")):
with self.subTest(outcome=outcome):
ledger = CommissionHistory(clock=lambda: NOW)
result = self.ingest([review_record(kind="battle", outcome=outcome)], history=ledger)
self.assertEqual(result["events"][0]["status"], status)
self.assertEqual(result["rows"][0]["status"], status)
self.assertEqual(result["summary"]["pending_count"], 0)
self.assertEqual(result["summary"]["completed_count"], 0)
def test_unknown_result_stays_unknown_and_pending_in_summary(self):
result = self.ingest([review_record(phase="task_unknown", outcome="", response=None,
response_confirmed=False)])
self.assertEqual(result["rows"][0]["status"], "unknown")
self.assertEqual(result["summary"]["pending_count"], 1)
self.assertEqual(result["summary"]["completed_count"], 0)
def test_duplicate_claim_attempts_count_one_instance_once(self):
result = self.ingest([review_record("claim-one"), review_record("claim-two", timestamp=NOW + 1)])
self.assertEqual(len(result["events"]), 2, "retain both attempts as evidence")
self.assertEqual(len(result["rows"]), 1)
self.assertEqual(result["summary"]["completed_count"], 1)
self.assertEqual(result["summary"]["confirmed_ke"], 20)
def test_duplicate_claim_on_later_day_does_not_create_new_reward(self):
before = datetime(2026, 11, 12, 15, 59, tzinfo=timezone.utc).timestamp()
after = before + 120
result = self.ingest([review_record("claim-before", timestamp=before),
review_record("claim-after", timestamp=after)])
self.assertEqual(result["summary"]["completed_count"], 0)
self.assertEqual(result["summary"]["confirmed_ke"], 0)
self.assertEqual(self.history.query("71", "2026-11-12")["summary"]["confirmed_ke"], 20)
def test_same_type_different_instances_are_counted_separately(self):
result = self.ingest([review_record("claim-one", task_id=81),
review_record("claim-two", task_id=82, timestamp=NOW + 1)])
self.assertEqual(len(result["rows"]), 2)
self.assertEqual(result["summary"]["completed_count"], 2)
self.assertEqual(result["summary"]["confirmed_ke"], 40)
def test_reconciled_accept_is_reconsidered_when_snapshot_changes(self):
record = review_record(kind="accept", task_id=81, response=None,
response_confirmed=False, outcome="reconciled")
first = self.ingest([record], review_snapshot())
self.assertEqual(first["summary"]["accepted_count"], 0)
second = self.ingest([record], review_snapshot(tasks=[{"id": 81, "typeId": "review20", "curStep": 1}]))
self.assertEqual(second["summary"]["accepted_count"], 1)
self.assertEqual(second["rows"][0]["task_id"], 81)
def test_old_accept_today_claim_uses_beijing_day_for_each_count(self):
before = datetime(2026, 11, 12, 15, 59, tzinfo=timezone.utc).timestamp()
after = before + 120
today = self.ingest([review_record("accept-old", kind="accept", timestamp=before),
review_record("claim-today", timestamp=after)])
yesterday = self.history.query("71", "2026-11-12")
self.assertEqual(today["summary"]["accepted_count"], 0)
self.assertEqual(today["summary"]["expected_ke"], 0)
self.assertEqual(today["summary"]["completed_count"], 1)
self.assertEqual(today["summary"]["confirmed_ke"], 20)
self.assertEqual(yesterday["summary"]["accepted_count"], 1)
self.assertEqual(yesterday["summary"]["completed_count"], 0)
self.assertEqual(today["rows"][0]["accepted_at"], before)
def test_missing_historical_metadata_never_invents_reason_or_reward(self):
record = review_record(commission={}, response={"resCode": 0, "ke": 99999})
result = self.ingest([record], review_snapshot())
row = result["rows"][0]
self.assertIsNone(row["accepted_at"])
self.assertIsNone(row["confirmed_ke"])
self.assertNotIn("review-selected", row["selection_reason"])
self.assertEqual(result["summary"]["confirmed_ke"], 0)
self.assertEqual(result["summary"]["unknown_reward_count"], 1)
def test_unconfirmed_historical_accept_does_not_describe_itself_as_confirmed(self):
result = self.ingest([review_record(kind="accept", commission={}, phase="request_pending",
outcome="", response=None, response_confirmed=False)])
self.assertEqual(result["summary"]["accepted_count"], 0)
self.assertNotIn("已确认", result["rows"][0]["selection_reason"])
def test_invalid_reward_values_are_unknown_not_catalog_or_wallet_amounts(self):
for value in (None, True, "20", -1, 1.5, float("nan"), float("inf")):
with self.subTest(value=value):
ledger = CommissionHistory(clock=lambda: NOW)
result = self.ingest([review_record(response={"resCode": 0, "reward": {"ke": value}})],
history=ledger)
self.assertEqual(result["summary"]["completed_count"], 1)
self.assertEqual(result["summary"]["confirmed_ke"], 0)
self.assertIsNone(result["rows"][0]["confirmed_ke"])
def test_read_and_restart_are_idempotent_and_return_detached_data(self):
records = [review_record()]
expected = self.ingest(records)
before = self.history.path.read_bytes()
for _ in range(3):
self.assertEqual(self.ingest(records), expected)
self.assertEqual(self.history.query("71", DAY), expected)
self.assertEqual(self.history.path.read_bytes(), before)
restored = CommissionHistory(self.history.path, clock=lambda: NOW)
self.assertEqual(self.ingest(records, history=restored), expected)
copy = restored.query("71", DAY)
copy["rows"][0]["name"] = "caller mutation"
self.assertEqual(restored.query("71", DAY), expected)
def test_role_and_separate_account_paths_are_isolated(self):
self.ingest([review_record()])
other = review_record(role_id="72", response={"resCode": 0, "reward": {"ke": 15}})
self.ingest([other], role="72")
self.assertEqual(self.history.query("71", DAY)["summary"]["confirmed_ke"], 20)
self.assertEqual(self.history.query("72", DAY)["summary"]["confirmed_ke"], 15)
separate = CommissionHistory(self.folder / "other-account" / "history.json", clock=lambda: NOW)
self.assertEqual(separate.query("71", DAY)["events"], [])
def test_ledger_survives_rolling_journal_eviction_and_restart(self):
snapshot = review_snapshot()
journal = BattleJournal(self.folder / "journal.json")
journal.role(snapshot)["records"].append(review_record())
journal.save()
self.ingest(journal.role(snapshot)["records"])
journal.role(snapshot)["records"].extend({"attempt_id": f"other-{i}", "role_id": "71"}
for i in range(501))
journal.save()
self.assertEqual(len(journal.role(snapshot)["records"]), 500)
self.assertNotIn("review-claim", {r["attempt_id"] for r in journal.role(snapshot)["records"]})
self.ingest(journal.role(snapshot)["records"])
restored = CommissionHistory(self.history.path, clock=lambda: NOW)
result = restored.query("71", DAY)
self.assertEqual(result["summary"]["completed_count"], 1)
self.assertEqual(result["summary"]["confirmed_ke"], 20)
def test_event_cap_and_retention_preserve_newest_events_on_restart(self):
ledger = CommissionHistory(self.folder / "bounded.json", max_events=2, retention_days=2, clock=lambda: NOW)
self.ingest([review_record(f"event-{i}", task_id=81 + i, timestamp=NOW + i)
for i in (-3 * 86400, 0, 1, 2)], history=ledger)
restored = CommissionHistory(ledger.path, max_events=2, retention_days=2, clock=lambda: NOW)
result = restored.query("71", DAY)
self.assertEqual({e["id"] for e in result["events"]}, {"event-1", "event-2"})
def test_corrupt_history_is_reported_and_original_bytes_preserved(self):
path = self.folder / "corrupt.json"
path.write_text('{"broken":', encoding="utf-8")
before = path.read_bytes()
ledger = CommissionHistory(path, clock=lambda: NOW)
result = self.ingest([review_record()], history=ledger)
self.assertTrue(result["error"])
self.assertEqual(result["events"], [])
self.assertEqual(path.read_bytes(), before)
def test_incomplete_persisted_event_reports_error_instead_of_crashing_read(self):
path = self.folder / "incomplete-event.json"
path.write_text(json.dumps({"version": 1, "roles": {"71": {"bad-event": {
"id": "bad-event", "time": NOW, "date": DAY, "kind": "complete", "status": "confirmed"}}}}),
encoding="utf-8")
before = path.read_bytes()
ledger = CommissionHistory(path, clock=lambda: NOW)
result = ledger.query("71", DAY)
self.assertTrue(result["error"])
self.assertEqual(path.read_bytes(), before)
def test_cancelled_history_row_is_labelled_cancelled_by_web(self):
from ranch_web.policies import default_config
from ranch_web.views import build_view
history = self.ingest([review_record(kind="accept", outcome="cancelled")])
engine = Engine(Catalog())
engine.snapshot = review_snapshot()
engine.commission_history = Mock(return_value=history)
dto = build_view(engine, "commissions", default_config(), {"tab": "history", "date": DAY})
self.assertEqual(dto["rows"][0]["status_label"], "已取消")
self.assertIn("已取消", dto["details"][dto["rows"][0]["id"]]["行动记录"])
class CommissionRunMessageIndependentReviewTests(unittest.TestCase):
def test_uncertain_accept_is_not_resent_after_engine_restart(self):
with tempfile.TemporaryDirectory(prefix="commission-uncertain-review-") as directory:
client = Mock()
client.call.side_effect = TimeoutError("synthetic uncertain write")
path = Path(directory) / "budget.json"
data = ProgressionData({"task_info": {"review20": deepcopy(INFO)}, "scripts": {},
"stage_info": {}, "game_setting": {"cityInfo": {"1": {}}}})
engine = Engine(Catalog(), client, path, game_data=data)
engine.snapshot = review_snapshot()
engine.snapshot.raw["history"].update(loopTaskTime=engine.snapshot.now, loopTaskNum=6,
loopTask={"1": ["review20"]})
engine.quest_policy.enabled = True
engine._refresh_progression_cache(force=True)
intent = next(i for i in engine._progression_intents if not i.blocked)
self.assertEqual(intent.kind, "progression_loop_accept")
with self.assertRaises(TimeoutError):
engine._run_progression_intent(intent)
self.assertEqual(client.call.call_count, 1)
self.assertIsNotNone(engine.battle_journal.pending(engine.snapshot))
restored = Engine(Catalog(), client, path, game_data=data)
restored.snapshot = review_snapshot()
restored.quest_policy.enabled = True
for _ in range(3):
_, _, message = restored._run_progression_intent(intent)
self.assertIn("核对", message)
self.assertEqual(restored.commission_history()["summary"]["accepted_count"], 0)
self.assertEqual(restored.commission_history()["summary"]["completed_count"], 0)
self.assertEqual(client.call.call_count, 1)
def test_history_save_failure_recovers_without_replaying_game_request(self):
with tempfile.TemporaryDirectory(prefix="commission-storage-review-") as directory:
client = Mock()
client.call.side_effect = AssertionError("history must never replay a game write")
engine = Engine(Catalog(), client, Path(directory) / "budget.json",
game_data=ProgressionData({"task_info": {"review20": deepcopy(INFO)}}))
engine.snapshot = review_snapshot()
engine._commission_history.clock = lambda: NOW
engine.battle_journal.role(engine.snapshot)["records"].append(review_record())
engine.battle_journal.save()
with patch.object(engine._commission_history, "_save", side_effect=PermissionError("synthetic disk error")):
engine._sync_commission_history()
result = engine.commission_history(DAY)
self.assertTrue(result["error"])
self.assertEqual(result["summary"]["completed_count"], 1)
engine._sync_commission_history()
self.assertFalse(engine.commission_history(DAY)["error"])
restored = CommissionHistory(engine._commission_history.path, clock=lambda: NOW)
self.assertEqual(restored.query("71", DAY)["summary"]["completed_count"], 1)
client.call.assert_not_called()
def test_battle_early_return_cannot_replay_old_commission_success(self):
for early_return in ("resources", "cancelled", "lock"):
with self.subTest(early_return=early_return), tempfile.TemporaryDirectory(
prefix="commission-message-review-") as directory:
client = Mock()
client.call.side_effect = AssertionError("offline review forbids game writes")
client.snapshot.side_effect = AssertionError("offline review forbids game reads")
engine = Engine(Catalog(), client, Path(directory) / "budget.json",
game_data=ProgressionData({"task_info": {"review20": deepcopy(INFO)}}))
engine.snapshot = review_snapshot()
engine.quest_policy.enabled = True
engine._commission_history.clock = lambda: NOW
state = engine.battle_journal.role(engine.snapshot)
state["records"].append(review_record())
engine.battle_journal.save()
engine._sync_commission_history()
history_before = engine.commission_history(DAY)
journal_before = deepcopy(state["records"])
engine.plans = Mock(return_value=[])
engine.read_snapshot = Mock(return_value=engine.snapshot)
engine._refresh_progression_cache = Mock()
engine._intent_policy = Mock(return_value=SimpleNamespace(enabled=True, team="teamA"))
intent = {"kind": "progression_battle", "task_id": 82, "task_type_id": "review20",
"step_number": 1, "block_reason": ""}
if early_return == "resources":
expected = "review-resource-shortage"
engine.battles.resource_reason = Mock(return_value=expected)
elif early_return == "cancelled":
expected = "任务 / 战斗已取消,未开始"
def cancel_during_preflight(*args):
engine._progression_cancel.set()
return ""
engine.battles.resource_reason = Mock(side_effect=cancel_during_preflight)
else:
expected = "同账号已有任务 / 战斗正在执行"
engine.battles.run = Mock(return_value=expected)
with patch.object(engine.battle_journal, "begin", wraps=engine.battle_journal.begin) as begin:
_, _, message = engine._run_progression_intent(intent)
begin.assert_not_called()
client.call.assert_not_called()
client.snapshot.assert_not_called()
self.assertEqual(state["records"], journal_before)
self.assertEqual(engine.commission_history(DAY), history_before)
self.assertEqual(message, expected, "a previous confirmed claim must not replace the new blocked message")
class CommissionSelectionIndependentReviewTests(unittest.TestCase):
def test_fallback_to_ten_explains_rejected_fifteen_when_twenty_absent(self):
tasks = {}
for amount in (10, 15):
tasks[str(amount)] = deepcopy(INFO) | {"id": str(amount), "name": f"review-{amount}",
"closed": amount == 15, "reward": {"ke": amount}}
data = {"task_info": tasks, "scripts": {}, "stage_info": {},
"game_setting": {"cityInfo": {"1": {}, "2": {}}}}
snapshot = review_snapshot()
snapshot.raw["history"].update(loopTaskTime=snapshot.now, loopTaskNum=6,
loopTask={"1": ["10"], "2": ["15"]}, unlockCity={"1": True, "2": True})
planner = ProgressionPlanner(Catalog(), data)
actions = planner.commission_plan(snapshot, QuestPolicy(enabled=True), Policy())
self.assertEqual(actions[0].task_type_id, "10")
self.assertEqual([b["task_type_id"] for b in planner.commission_selection["higher_reward_blockers"]], ["15"])
reason = planner.commission_selection["selection_reason"]
self.assertIn("review-15", reason)
self.assertIn("关闭", reason)
self.assertIn("20", reason)
if __name__ == "__main__":
unittest.main()
+16 -4
View File
@@ -1,8 +1,8 @@
# 牧羊人之心牧场助手 · Web 2.0.7 # 牧羊人之心牧场助手 · Web 2.0.8
## 产品约束 ## 产品约束
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。本轮 Web 发布目标为 `2.0.7`,源码入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md)。 把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web `2.0.8`,源码发布入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md),功能与验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
使用者在 Windows 本机配置、验证,随后可在 Linux Docker 常驻运行。多个浏览器访问同一个管理员工作台;账号互相隔离,各账号串行执行,账号之间可以并行。 使用者在 Windows 本机配置、验证,随后可在 Linux Docker 常驻运行。多个浏览器访问同一个管理员工作台;账号互相隔离,各账号串行执行,账号之间可以并行。
@@ -17,19 +17,29 @@
## 核心操作 ## 核心操作
- 账号密码登录后选择区服进入;恢复已保存会话;退出与清除登录记录。游戏凭据仅交给同源服务端,不进入浏览器持久存储或 URL。 - 账号密码登录后选择区服进入;恢复已保存会话;退出与清除登录记录。游戏凭据仅交给同源服务端,不进入浏览器持久存储或 URL。
- 手动选服、恢复会话和自动重登成功读取角色后,均默认开启策略,自动执行已配置且已勾选的功能,可在顶部停止;不改变各子功能的勾选。获取区服候选及失败候选不视为登录成功,界面以服务端在线与运行状态为准。导入配置只替换规则并停止执行,下次成功登录仍自动开启;服务重启后未成功登录时不直接执行。 - 手动选服、恢复会话和自动重登成功读取角色后,默认执行已配置且已勾选的功能,不改变各子功能勾选。用户手动“停止”跨掉线、重登和服务重启保留,点击“开启”恢复;导入配置只替换规则,保留用户启停意图。获取区服候选及失败候选不视为登录成功,服务重启后未成功登录时不执行策略,界面以服务端状态为准。
- 配置通过中文 schema 生成原生控件;逐蛋孵化/补货规则、物品赠礼保留量、逐魔物培养目标、关卡规则等直接在对应页面编辑。自动保存显示待保存、保存中、失败与已保存状态。 - 配置通过中文 schema 生成原生控件;逐蛋孵化/补货规则、物品赠礼保留量、逐魔物培养目标、关卡规则等直接在对应页面编辑。自动保存显示待保存、保存中、失败与已保存状态。
- 培育室扩建、牧场锁定/解锁、批量派遣/喂养、上下文菜单和费用二次确认沿用核心行为。切换功能页只读取视图,不触发游戏写操作。 - 培育室扩建、牧场锁定/解锁、批量派遣/喂养、上下文菜单和费用二次确认沿用核心行为。切换功能页只读取视图,不触发游戏写操作。
- 主线默认当前主线,可切换筛选。地图按地区默认折叠,展示普通关卡、矿洞、难度、次数和工具库存。探险支持队员手选/自动与完成后自动领奖说明。 - 主线默认当前主线,可切换筛选。地图按地区默认折叠,展示普通关卡、矿洞、难度、次数和工具库存。探险支持队员手选/自动与完成后自动领奖说明。
- 数据分析用真实 DTO 绘制 SVG 条形图,保留来源筛选、体力效率、样本和不确定性说明。没有样本时明确说明。 - 数据分析用真实 DTO 绘制 SVG 条形图,保留来源筛选、体力效率、样本和不确定性说明。没有样本时明确说明。
- 策略统一导入导出;收益 CSV/XLSX 导入与可用数据下载。错误展示具体原因,不把不支持的任务伪装成可执行任务。 - 策略统一导入导出;收益 CSV/XLSX 导入与可用数据下载。错误展示具体原因,不把不支持的任务伪装成可执行任务。
- 帮助可检查 GitHub 正式版本并提交受控更新请求。未配置部署器时明确显示原因,更新提交不表示更新成功。 - 帮助可检查 GitHub 正式版本并提交受控更新请求。未配置部署器时明确显示原因,更新提交不表示更新成功。
- 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,可在 2.0.7 发布就绪后直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器;升级完成后刷新网页以加载新版界面,安装结果以宿主机健康检查为准。 - 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,稳定 Release 与正式镜像发布后,可直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器;升级完成后刷新网页以加载新版界面,安装结果以宿主机健康检查为准。
## 2.0.8 自动委托与每日历史
- 自动委托包含“当前委托 / 每日记录”。当前页展示原始候选、任务状态、标注奖励及选择 / 回退原因;城市锁定候选显示不可接取。
- 策略允许且满足城市、次数、资源与步骤支持条件的候选,跨城市按静态预计氪金20→15→10全局排序。高档不可用时日志说明原因,再选择可执行的低档,不保证全部接取20档。
- 每日记录按账号、区服、角色隔离,以北京时间(UTC+8)自然日查询接取、推进、领奖和待核对事件,刷新和服务重启后可查。每角色保留最近90天、最多5000条事件。
- 预计奖励与已确认实际奖励分别展示;实际氪金仅来自确认成功的 `taskComplete` 领奖回包 `response.reward.ke`,缺失金额显示“未确认”。接取、推进、预计奖励及旧完成标记不作为到账证据。
- 旧历史仅从本地任务 journal 可证实的操作部分回填,不推造缺失记录。每日历史用于业务进度,运行详情继续使用原单一底部“自动委托”分类日志。
## 2.0.7 主培养与资质备用 ## 2.0.7 主培养与资质备用
同种只自动培养已养成的高等级主培养;新资质更好的魔物只作为备用保留,不分配经验、礼物或潜能材料。已启用种类按主培养1只、更优备用最多1只整理,新备用严格更优才替换,同分保留已有备用。主培养到上限或冷却时等待,不向同种备用转移资源。硬保护保留,未勾选种类不扩大自动整理范围。 同种只自动培养已养成的高等级主培养;新资质更好的魔物只作为备用保留,不分配经验、礼物或潜能材料。已启用种类按主培养1只、更优备用最多1只整理,新备用严格更优才替换,同分保留已有备用。主培养到上限或冷却时等待,不向同种备用转移资源。硬保护保留,未勾选种类不扩大自动整理范围。
2.0.8 沿用上述修复及现有界面,历史功能与验证记录见 [2.0.7 发布说明](../analysis/RELEASE_2_0_7.md)。
## 表单布局(2.0.6 起) ## 表单布局(2.0.6 起)
勾选框与右侧文字组成一组;数字、文本与下拉框采用标签在上、控件在下的布局。设置区限定合理宽度,并按可用空间排为多列,每日领取项目在单独分组中排列。界面尺寸变化不改变配置路径、自动保存或策略执行规则。 勾选框与右侧文字组成一组;数字、文本与下拉框采用标签在上、控件在下的布局。设置区限定合理宽度,并按可用空间排为多列,每日领取项目在单独分组中排列。界面尺寸变化不改变配置路径、自动保存或策略执行规则。
@@ -69,6 +79,8 @@
## 安全与验证 ## 安全与验证
2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过。证据与发布门禁见 [发布说明](../analysis/RELEASE_2_0_8.md#验证);历史版本结果不计入本版。
不发真实游戏 API 测试,不读取或更改私人 `local_state` 账号。浏览器测试仅使用临时目录、fake 后端或服务端离线演示。所有游戏文本用 `textContent` 呈现;日志使用服务端脱敏数据。管理登录、同源校验与 cookie 由 API 负责。 不发真实游戏 API 测试,不读取或更改私人 `local_state` 账号。浏览器测试仅使用临时目录、fake 后端或服务端离线演示。所有游戏文本用 `textContent` 呈现;日志使用服务端脱敏数据。管理登录、同源校验与 cookie 由 API 负责。
## 技术默认假设 ## 技术默认假设
+16 -9
View File
@@ -1,19 +1,26 @@
# Web 2.0.7 运行说明 # Web 2.0.8 运行说明
本轮 Web 发布目标 **2.0.7**,源码入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。 Web **2.0.8**,源码发布入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。自动委托提供当前委托与每日记录,功能和验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
Web 采用 FastAPI / Uvicorn 和原生 HTML/CSS/ES 模块,无 Node、npm 或前端编译步骤,不安装 PySide6。页面和策略能力沿用现有核心,详细业务范围与原有限制见 [桌面使用说明](../ranch_assistant/README.md)。多浏览器连接同一个管理员工作台;一个服务实例内,各账号独立线程并行,同一账号操作串行。 Web 采用 FastAPI / Uvicorn 和原生 HTML/CSS/ES 模块,无 Node、npm 或前端编译步骤,不安装 PySide6。页面和策略能力沿用现有核心,详细业务范围与原有限制见 [桌面使用说明](../ranch_assistant/README.md)。多浏览器连接同一个管理员工作台;一个服务实例内,各账号独立线程并行,同一账号操作串行。
## 迁移清单 ## 迁移清单
- [x] 原15页:登录、培育室、背包、牧场、每日事务、自动孵蛋、自动主线、战斗记录、自动赠礼、自动委托、自动探险、自动扫荡、数据分析、执行计划、收益资料。 - [x] 原15页:登录、培育室、背包、牧场、每日事务、自动孵蛋、自动主线、战斗记录、自动赠礼、自动委托、自动探险、自动扫荡、数据分析、执行计划、收益资料。
- [x] 保留账号页签、顶部数值与统一启停、可调日志;规则自动保存,配置与统计按账号/角色隔离,每次成功登录后自动执行已配置且已勾选的功能,可在顶部停止。 - [x] 保留账号页签、顶部数值与统一启停、可调日志;规则自动保存,配置与统计按账号/角色隔离,未手动停止时,成功登录后自动执行已配置且已勾选的功能;手动暂停跨重登保留,可在顶部开启。
- [x] Windows Python 启动与离线演示;Web 导入链和依赖不使用 Qt,无 Node 构建步骤。 - [x] Windows Python 启动与离线演示;Web 导入链和依赖不使用 Qt,无 Node 构建步骤。
- [x] 提供 Linux Docker 与稳定 2.x 受控更新、停机备份及失败回滚脚本;历史 Linux Docker 部署、持久化权限、健康检查和定时更新检查烟测见下文。 - [x] 提供 Linux Docker 与稳定 2.x 受控更新、停机备份及失败回滚脚本;历史 Linux Docker 部署、持久化权限、健康检查和定时更新检查烟测见下文。
- [x] 本轮发布目标为 `2.0.7`,保留桌面兼容;战斗模拟为近似模型,特殊关卡并非全部支持,真实游戏 API 验收范围不因版本号变更而扩大。 - [x] `2.0.8` 自动委托当前 / 每日记录、持久化历史及奖励证据区分;739项独立测试中736通过、3项 Windows 跳过,浏览器77项全部验证通过。战斗模拟仍为近似模型,特殊关卡并非全部支持。
- 2.0.7 修复同种重复培养:主培养与资质备用分离,自动喂养、赠礼和潜能突破仅作用于主培养,启用种类固定主培养1只与更优备用最多1只。详见 [本版发布说明](../analysis/RELEASE_2_0_7.md)。 - 沿用 2.0.7 的同种重复培养修复:主培养与资质备用分离,自动喂养、赠礼和潜能突破仅作用于主培养,启用种类固定主培养1只与更优备用最多1只。详见 [2.0.7 发布说明](../analysis/RELEASE_2_0_7.md)。
- 2.0.3 修复 2.0.2 日志布局:所有页签复用原有底部日志区,按当前账号与功能筛选,默认收起;操作约定见 [产品说明](PRODUCT.md#203-底部分类日志),验收结果见 [发布说明](../analysis/RELEASE_2_0_3.md#验证)。 - 2.0.3 修复 2.0.2 日志布局:所有页签复用原有底部日志区,按当前账号与功能筛选,默认收起;操作约定见 [产品说明](PRODUCT.md#203-底部分类日志),验收结果见 [发布说明](../analysis/RELEASE_2_0_3.md#验证)。
## 自动委托(2.0.8)
- “当前委托”查看任务、原始候选和选择 / 回退原因;城市锁定候选显示不可接取。策略允许且满足城市、次数、资源和步骤条件的候选,跨城市按预计氪金20→15→10排序,日志说明高档不可用的原因。
- “每日记录”按账号、区服、角色及北京时间(UTC+8)自然日查询接取、推进、领奖与待核对事件。历史持久保存,刷新或重启后可查;每角色保留最近90天、最多5000条事件。
- 预计氪金来自静态任务配置,已确认氪金仅取确认成功的领奖回包 `response.reward.ke`;金额缺失显示“未确认”。接取、推进、旧完成标记和预计数额不作为实际奖励证据。
- 旧历史仅从本地任务 journal 可证实的操作部分回填,不推造缺失的过去。业务历史之外的运行详情继续使用原单一底部“自动委托”分类日志。完整行为见 [发布说明](../analysis/RELEASE_2_0_8.md)。
## Windows 本地运行 ## Windows 本地运行
使用 Python 3.12+,在项目根目录执行(本机已安装 3.13): 使用 Python 3.12+,在项目根目录执行(本机已安装 3.13):
@@ -32,7 +39,7 @@ py -3 -m venv .venv-web
.\Start_Ranch_Web.cmd --demo --data-dir "$env:TEMP\ranch-web-demo-new" --no-browser .\Start_Ranch_Web.cmd --demo --data-dir "$env:TEMP\ranch-web-demo-new" --no-browser
``` ```
健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。手动选服、恢复会话及自动重登成功读取角色后,均默认开启策略,只执行已勾选的功能,子功能不会全选。顶部“停止”暂停策略,仍保留状态监控;可用“开启”继续。登录后默认执行已勾选策略;只有手动“停止”才暂停,手动“开启”恢复。启停选择跨掉线、重新登录和服务重启保存,导入策略不会改变这个选择。 健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。手动选服、恢复会话及自动重登成功读取角色后,默认执行已勾选功能,子功能不会全选;用户手动“停止”则继续保持暂停,点击“开启”恢复。启停选择跨掉线、重登和服务重启保存,导入策略保留该选择;停止策略后仍保留状态监控。
### 后台运行与断线处理 ### 后台运行与断线处理
@@ -97,13 +104,13 @@ sh start-web.sh --no-browser
Web 检查固定官方 GitHub Releases 的稳定 `v2.x.y`,跳过桌面 1.x、未来 3.x、草稿和预发布。开发版本 `2.0.0.dev1` 可升级至同数字的正式 `v2.0.0`;没有正式 Web 2 发布时明确显示暂无更新。Windows 默认仅检查;Web “更新”按钮仅在宿主机显式启用并有有效只读心跳时可提交 `pending` 请求,安装、备份和回滚由宿主机执行。默认定时检查只通知,自动安装需操作者 opt-in。 Web 检查固定官方 GitHub Releases 的稳定 `v2.x.y`,跳过桌面 1.x、未来 3.x、草稿和预发布。开发版本 `2.0.0.dev1` 可升级至同数字的正式 `v2.0.0`;没有正式 Web 2 发布时明确显示暂无更新。Windows 默认仅检查;Web “更新”按钮仅在宿主机显式启用并有有效只读心跳时可提交 `pending` 请求,安装、备份和回滚由宿主机执行。默认定时检查只通知,自动安装需操作者 opt-in。
已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,可在 2.0.7 稳定 Release 和正式镜像就绪、宿主机心跳有效后,直接通过“帮助 → 检查版本更新…”升级 **2.0.7**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。 已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,稳定 Release 和正式镜像就绪、宿主机心跳有效后,可直接通过“帮助 → 检查版本更新…”升级 **2.0.8**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。
## 离线验证 ## 离线验证
2.0.7 验证结果统一见 [发布说明](../analysis/RELEASE_2_0_7.md#验证),以下历史记录不计入本版验收。 2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过。分组结果与证据见 [发布说明](../analysis/RELEASE_2_0_8.md#验证)。2.0.7 的结果保留在 [历史发布说明](../analysis/RELEASE_2_0_7.md#验证),以下历史记录也不计入本版验收。
### 历史验证记录(不计入 2.0.7) ### 历史验证记录(不计入 2.0.8)
2.0.2 验证记录见 [历史发布说明](../analysis/RELEASE_2_0_2.md#验证)。 2.0.2 验证记录见 [历史发布说明](../analysis/RELEASE_2_0_2.md#验证)。
+1 -1
View File
@@ -1,6 +1,6 @@
"""Headless Web workspace for the ranch assistant.""" """Headless Web workspace for the ranch assistant."""
__version__ = "2.0.7" __version__ = "2.0.8"
GAME_VERSION = "1.9.68" GAME_VERSION = "1.9.68"
__all__ = ["__version__", "GAME_VERSION"] __all__ = ["__version__", "GAME_VERSION"]
+41 -3
View File
@@ -101,6 +101,7 @@ class _Job:
workspace: str = "" workspace: str = ""
category: str = "general" category: str = "general"
due_kind: str | None = None due_kind: str | None = None
commission_failure: str = ""
def public(self): def public(self):
operation = {"__config": "set_config", "__view": "view"}.get(self.operation, self.operation) operation = {"__config": "set_config", "__view": "view"}.get(self.operation, self.operation)
@@ -450,10 +451,41 @@ class AccountWorker:
# Attribution must not prevent an otherwise valid action. # Attribution must not prevent an otherwise valid action.
category = "general" category = "general"
self._attribute_task(category) self._attribute_task(category)
return _method(*args, **kwargs) try:
return _method(*args, **kwargs)
except CancelledBeforeDispatch:
raise
except Exception:
if category == "commissions":
# Enrich the existing error entry, preserving the original
# exception and its one-time reporting on the worker.
try:
source = args[0] if args else kwargs.get("intent", kwargs.get("action"))
if source is None and _name == "_run_progression_intent":
source = intent
self._commission_failure_context(engine, source)
except Exception:
pass
raise
setattr(engine, name, routed) setattr(engine, name, routed)
def _commission_failure_context(self, engine, source):
if self._execution is None or threading.current_thread() is not getattr(self, "thread", None):
return
field = lambda key, default=None: source.get(key, default) if isinstance(source, dict) else getattr(source, key, default)
payload = field("payload") or {}
type_id = field("source_task_type_id") or field("task_type_id") or payload.get("taskTypeId")
info = engine._commission_info(type_id)
name = info.get("name") or type_id or "名称未记录"
reward = (info.get("reward") or {}).get("ke")
expected = f"标注{reward}氪金" if type(reward) in (int, float) else "标注氪金未记录"
path = field("path", "") or ""
kind = field("kind", "")
action = "接取" if path.endswith("taskLoopReceive") or kind in {"quest_accept", "progression_loop_accept"} else (
"领奖" if path.endswith("taskComplete") or kind in {"quest_complete", "progression_complete"} else "推进")
self._execution.commission_failure = f"委托「{name}」({expected}){action}异常,结果待核对"
def remember(self, value): def remember(self, value):
with self._secret_lock: with self._secret_lock:
if isinstance(value, dict): if isinstance(value, dict):
@@ -544,7 +576,13 @@ class AccountWorker:
notes = getattr(getattr(self.engine, name, None), "notes", ()) notes = getattr(getattr(self.engine, name, None), "notes", ())
sources.append((category, [self.safe_text(note) for note in notes[:512]])) sources.append((category, [self.safe_text(note) for note in notes[:512]]))
for category, text in route_message(self.safe_text(message), context=self._task_category(), hints=note_hints(sources)): for category, text in route_message(self.safe_text(message), context=self._task_category(), hints=note_hints(sources)):
self.log(text, category=category) level = "info"
if category == "commissions":
if "战斗失败" in text:
level = "error"
elif any(marker in text for marker in ("结果未知", "未确认", "待确认", "等待核对", "奖励未记录")):
level = "warning"
self.log(text, category=category, level=level)
def _trace_event(self, event): def _trace_event(self, event):
fields = [event.get("operation", "网络"), event.get("kind", "")] fields = [event.get("operation", "网络"), event.get("kind", "")]
@@ -844,7 +882,7 @@ class AccountWorker:
if (job.consuming and job.operation != "start" if (job.consuming and job.operation != "start"
and failure_sequence == self._game_failure_sequence): and failure_sequence == self._game_failure_sequence):
self._execution_failed(error) self._execution_failed(error)
self.log(message, category=job.category, level="error") self.log((job.commission_failure + ";" if job.commission_failure else "") + message, category=job.category, level="error")
finally: finally:
job.payload = {} job.payload = {}
try: try:
+2 -2
View File
@@ -415,7 +415,7 @@ async function exportYields(account=current()) {
async function command(name,account=current()) { async function command(name,account=current()) {
try { try {
if(name==='add-account'||name==='add-demo')return await addAccount(name==='add-demo'); if(name==='add-account'||name==='add-demo')return await addAccount(name==='add-demo');
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.7'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{info:true}); if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.8'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{info:true});
if(name==='updates')return await showUpdates(); if(name==='updates')return await showUpdates();
if(name==='admin-logout'){hideWorkbench();try{await api.logout();}finally{requireAuth();}return;} if(name==='admin-logout'){hideWorkbench();try{await api.logout();}finally{requireAuth();}return;}
if(!account)throw new Error('请先新增或选择账号。'); if(!account)throw new Error('请先新增或选择账号。');
@@ -640,7 +640,7 @@ async function bootstrap() {
$('#app').hidden=false; $('#app').hidden=false;
const [meta,schema]=await Promise.all([api.meta(),api.schema()]);state.meta=meta;state.schema=schema; const [meta,schema]=await Promise.all([api.meta(),api.schema()]);state.meta=meta;state.schema=schema;
if(state.redirecting)return; if(state.redirecting)return;
$('#app-version').textContent=meta.version || '2.0.7';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台'; $('#app-version').textContent=meta.version || '2.0.8';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
await syncAccounts();if(state.redirecting)return;state.ready=true;setStatus('工作台已连接'); await syncAccounts();if(state.redirecting)return;state.ready=true;setStatus('工作台已连接');
}catch(failure){if(failure.status===401||$('#app').hidden){requireAuth();return;}if(state.redirecting)return;setStatus(failure.message);$('#page-host').replaceChildren(el('div',{class:'initial-state'},el('p',{text:failure.message}),el('button',{text:'重新连接',onClick:bootstrap})));} }catch(failure){if(failure.status===401||$('#app').hidden){requireAuth();return;}if(state.redirecting)return;setStatus(failure.message);$('#page-host').replaceChildren(el('div',{class:'initial-state'},el('p',{text:failure.message}),el('button',{text:'重新连接',onClick:bootstrap})));}
} }
+1 -1
View File
@@ -26,7 +26,7 @@
</div></details> </div></details>
<details class="menu"><summary accesskey="h">帮助<span class="access-key">(H)</span></summary><div class="menu-popup"><button data-command="updates">检查版本更新…</button><button data-command="debug">调试日志</button><button data-command="about">关于…</button></div></details> <details class="menu"><summary accesskey="h">帮助<span class="access-key">(H)</span></summary><div class="menu-popup"><button data-command="updates">检查版本更新…</button><button data-command="debug">调试日志</button><button data-command="about">关于…</button></div></details>
</nav> </nav>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.7</span></span> <span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.8</span></span>
<span id="access-mode" class="muted"></span> <span id="access-mode" class="muted"></span>
</header> </header>
<div class="account-bar"><div id="account-tabs" class="account-tabs" role="tablist" aria-label="账号"></div><button id="add-account" class="compact" title="新增账号">+ 新增账号</button></div> <div class="account-bar"><div id="account-tabs" class="account-tabs" role="tablist" aria-label="账号"></div><button id="add-account" class="compact" title="新增账号">+ 新增账号</button></div>
+13 -6
View File
@@ -9,7 +9,7 @@ export const PAGES = [
['commissions', '自动委托'], ['exploration', '自动探险'], ['maps', '自动扫荡'], ['statistics', '数据分析'], ['plans', '执行计划'], ['yields', '收益资料'], ['commissions', '自动委托'], ['exploration', '自动探险'], ['maps', '自动扫荡'], ['statistics', '数据分析'], ['plans', '执行计划'], ['yields', '收益资料'],
]; ];
export const initialQuery = page => page === 'bag' ? {category: 'eggs'} : page === 'mainline' ? {category: 'mainline', state: 'current'} : page === 'ranch' ? {grouped: false} : page === 'maps' ? {category: 'all', only_unlocked: true} : {}; export const initialQuery = page => page === 'bag' ? {category: 'eggs'} : page === 'mainline' ? {category: 'mainline', state: 'current'} : page === 'commissions' ? {tab: 'current'} : page === 'ranch' ? {grouped: false} : page === 'maps' ? {category: 'all', only_unlocked: true} : {};
class LoginPage { class LoginPage {
constructor(host, page) { constructor(host, page) {
@@ -161,7 +161,7 @@ export class PageView {
filters.forEach(field => { filters.forEach(field => {
if (this.key === 'bag' && field.key === 'category') return; if (this.key === 'bag' && field.key === 'category') return;
included.add(field.key); included.add(field.key);
if (!Object.hasOwn(this.query, field.key)) this.query[field.key] = field.value; if (!Object.hasOwn(this.query, field.key) || field.type === 'date' && !this.query[field.key]) this.query[field.key] = field.value;
let item = this.filters.get(field.key); let item = this.filters.get(field.key);
const signature = JSON.stringify({...field, value: undefined}); const signature = JSON.stringify({...field, value: undefined});
if (!item || item.signature !== signature && !item.root.contains(document.activeElement)) { if (!item || item.signature !== signature && !item.root.contains(document.activeElement)) {
@@ -170,6 +170,7 @@ export class PageView {
set: (_, value) => this.setQuery(field.key, value), onError: this.error, set: (_, value) => this.setQuery(field.key, value), onError: this.error,
}); });
if (field.key === 'search') { entry.root.type = 'search'; entry.root.placeholder = this.key === 'maps' ? '关卡、名称或掉落物品' : '按名称或编号筛选'; } if (field.key === 'search') { entry.root.type = 'search'; entry.root.placeholder = this.key === 'maps' ? '关卡、名称或掉落物品' : '按名称或编号筛选'; }
if (field.type === 'date') entry.root.type = 'date';
const root = el('label', {}, el('span', {text: field.label}), entry.root); const root = el('label', {}, el('span', {text: field.label}), entry.root);
item?.root.remove(); item?.root.remove();
item = {root, entry, signature}; item = {root, entry, signature};
@@ -187,11 +188,17 @@ export class PageView {
if (this.key === 'bag') tabs = [{key:'eggs',title:'魔物蛋'}, {key:'usable',title:'可使用'}, {key:'consumables',title:'消耗品'}, {key:'materials',title:'材料'}, {key:'other',title:'其他'}, {key:'equipment',title:'装备'}]; if (this.key === 'bag') tabs = [{key:'eggs',title:'魔物蛋'}, {key:'usable',title:'可使用'}, {key:'consumables',title:'消耗品'}, {key:'materials',title:'材料'}, {key:'other',title:'其他'}, {key:'equipment',title:'装备'}];
if (!tabs.length && this.key === 'hatching') tabs = ['孵蛋策略','牧场策略','喂养策略'].map(title => ({key:title,title})); if (!tabs.length && this.key === 'hatching') tabs = ['孵蛋策略','牧场策略','喂养策略'].map(title => ({key:title,title}));
if (!tabs.length && this.key === 'mainline') tabs = [{key:'tasks',title:'任务状态'}, {key:'policy',title:'推进策略'}]; if (!tabs.length && this.key === 'mainline') tabs = [{key:'tasks',title:'任务状态'}, {key:'policy',title:'推进策略'}];
if (this.key === 'commissions') this.activeSubtab = this.query.tab || 'current';
const signature = JSON.stringify(tabs); const signature = JSON.stringify(tabs);
if (this.tabSignature !== signature) { if (this.tabSignature !== signature) {
if (!this.activeSubtab || !tabs.some(tab => tab.key === this.activeSubtab)) this.activeSubtab = this.key === 'bag' ? this.query.category || tabs[0]?.key : tabs[0]?.key; if (!this.activeSubtab || !tabs.some(tab => tab.key === this.activeSubtab)) this.activeSubtab = this.key === 'bag' ? this.query.category || tabs[0]?.key : tabs[0]?.key;
this.subtabs.replaceChildren(...tabs.map(tab => el('button', {type: 'button', class: 'subtab', role: 'tab', 'data-key': tab.key, text: tab.title || tab.label, this.subtabs.replaceChildren(...tabs.map(tab => el('button', {type: 'button', class: 'subtab', role: 'tab', 'data-key': tab.key, text: tab.title || tab.label,
onClick: () => { this.activeSubtab = tab.key; if (this.key === 'bag') this.setQuery('category', tab.key); this.render(this.data || data); }}))); onClick: () => {
this.activeSubtab = tab.key;
if (this.key === 'commissions') { this.setQuery('tab', tab.key); this.updateSubtabs(data); return; }
if (this.key === 'bag') this.setQuery('category', tab.key);
this.render(this.data || data);
}})));
this.tabSignature = signature; this.tabSignature = signature;
} }
$$('.subtab', this.subtabs).forEach(button => { const selected = button.dataset.key === this.activeSubtab; button.setAttribute('aria-selected', selected); button.tabIndex = selected ? 0 : -1; }); $$('.subtab', this.subtabs).forEach(button => { const selected = button.dataset.key === this.activeSubtab; button.setAttribute('aria-selected', selected); button.tabIndex = selected ? 0 : -1; });
@@ -220,7 +227,7 @@ export class PageView {
const currencies = action.currencies ? optionsList(action.currencies) : [null]; const currencies = action.currencies ? optionsList(action.currencies) : [null];
currencies.forEach(currency => { currencies.forEach(currency => {
const button = el('button', {type: 'button', text: `${action.label}${currency ? `(${currency.label})` : ''}`, 'data-operation': action.operation, const button = el('button', {type: 'button', text: `${action.label}${currency ? `(${currency.label})` : ''}`, 'data-operation': action.operation,
'data-selection': action.selection, onClick: () => this.options.action(this, action, currency?.value).catch(this.error)}); 'data-selection': action.selection, onClick: () => action.operation === 'reload_view' ? this.options.load(this, true).catch(this.error) : this.options.action(this, action, currency?.value).catch(this.error)});
this.actionsHost.append(button); this.actionsHost.append(button);
}); });
}); });
@@ -296,12 +303,12 @@ export class PageView {
const data = this.data.details?.[row.id] || row.details; const data = this.data.details?.[row.id] || row.details;
if (!data) return; if (!data) return;
const labels = {name:'名称',species:'种类',id:'魔物ID',level:'等级 / 当前上限',quality:'资质 攻/防/血/敏',reference_stats:'参考攻击 / 防御 / 生命 / 敏捷',growth:'成长数值',likes:'喜欢的物品',feel:'好感 / 上限',feed_exp:'喂养经验',scope:'管理范围'}; const labels = {name:'名称',species:'种类',id:'魔物ID',level:'等级 / 当前上限',quality:'资质 攻/防/血/敏',reference_stats:'参考攻击 / 防御 / 生命 / 敏捷',growth:'成长数值',likes:'喜欢的物品',feel:'好感 / 上限',feed_exp:'喂养经验',scope:'管理范围'};
const title=this.key==='ranch'?'魔物详情':this.key==='mainline'?'任务详情':this.key==='battles'?'战斗详情':'详情'; const title=this.key==='ranch'?'魔物详情':this.key==='mainline'?'任务详情':this.key==='battles'?'战斗详情':this.key==='commissions'?'委托详情':'详情';
dialog(title, el('div', {class:'detail-sections'}, detailsList(data, labels)), {info:true}); dialog(title, el('div', {class:'detail-sections'}, detailsList(data, labels)), {info:true});
} }
openContext(event, selected, row) { openContext(event, selected, row) {
const items = [{label:'刷新本页',run:()=>this.perform('refresh',{page:this.key})}]; const items = [{label:'刷新本页',run:()=>this.key === 'commissions' && this.query.tab === 'history' ? this.options.load(this, true) : this.perform('refresh',{page:this.key})}];
if (this.key === 'ranch') { if (this.key === 'ranch') {
items.push({label:'查看魔物详情',run:()=>this.showDetail(row)}); items.push({label:'查看魔物详情',run:()=>this.showDetail(row)});
(this.data.actions || []).filter(action => ['lock','unlock','sell','feed'].includes(action.operation)).forEach(action => items.push({label:action.label,disabled:!selected.length,run:()=>this.options.action(this,action)})); (this.data.actions || []).filter(action => ['lock','unlock','sell','feed'].includes(action.operation)).forEach(action => items.push({label:action.label,disabled:!selected.length,run:()=>this.options.action(this,action)}));
@@ -0,0 +1,218 @@
"""Commission subtabs, local reads and the original log region over loopback only."""
from datetime import datetime, timedelta, timezone
import json
from pathlib import Path
import time
import unittest
from unittest.mock import Mock, patch
from urllib.parse import parse_qs, urlsplit
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog
from ranch_web.tests.test_commission_history import history_fixture
from ranch_web.views import build_view
from . import test_workbench_browser as fixtures
if fixtures.AVAILABLE:
from playwright.sync_api import expect
@unittest.skipUnless(fixtures.AVAILABLE, "Python Playwright and a system Chromium browser are required")
class CommissionHistoryBrowserTests(unittest.TestCase):
setUpClass = classmethod(fixtures.WorkbenchBrowserTests.setUpClass.__func__)
tearDownClass = classmethod(fixtures.WorkbenchBrowserTests.tearDownClass.__func__)
await_job = fixtures.WorkbenchBrowserTests.await_job
open = fixtures.WorkbenchBrowserTests.open
go = fixtures.WorkbenchBrowserTests.go
fulfill = staticmethod(fixtures.WorkbenchBrowserTests.fulfill)
def setUp(self):
self.enterContext(patch("requests.sessions.Session.request", side_effect=AssertionError("Live HTTP forbidden")))
fixtures.WorkbenchBrowserTests.setUp(self)
self.context.set_default_timeout(6000)
self.today = datetime.now(timezone(timedelta(hours=8))).date()
self.external, self.writes, self.reads, self.pending = [], [], [], []
self.hold = self.fail_reads = False
self.engines = {}
for identifier, label in ((self.first, "账号一"), (self.second, "账号二")):
engine = Engine(Catalog(), budget_path=Path(self.temp.name) / identifier / "fixture-budget.json")
engine.snapshot = demo_snapshot(engine.catalog)
engine.catalog.data["task_info"] = {"test20": {"name": label + "高额候选", "reward": {"money": 123, "ke": 20}},
"test15": {"name": label + "回退候选", "reward": {"money": 456, "ke": 15}}}
engine.tasks.rows = Mock(return_value=[("test20", label + "高额候选", "城市 4 可接", "", {"city": 4}),
("test15", label + "回退候选", "城市 1 可接", "", {"city": 1})])
engine.tasks.current = Mock(return_value=[])
engine.commission_offer_diagnostics = Mock(return_value=[])
engine.progression_rows = Mock(return_value=[{"category": "commission", "task_type_id": "test20", "block_reason": "城市尚未解锁"},
{"category": "commission", "task_type_id": "test15", "selection_reason": "20氪金候选未解锁,回退15氪金"}])
engine.commission_history = lambda day=None, label=label: self.history(day, label)
engine.client = Mock()
self.engines[identifier] = engine
def local_only(route):
if route.request.url.startswith(self.base + "/"):
route.continue_()
else:
self.external.append(route.request.url)
route.abort()
self.context.route("**/*", local_only)
self.page.on("request", lambda request: self.writes.append(request) if request.method in ("POST", "PUT", "PATCH", "DELETE") else None)
def view(route):
parsed = urlsplit(route.request.url)
identifier = parsed.path.split("/")[-3]
params = parse_qs(parsed.query)
query = json.loads(params["query"][0]) if "query" in params else {key: value[0] for key, value in params.items()}
self.reads.append((identifier, query))
dto = build_view(self.engines[identifier], "commissions", self.manager.get_config(identifier)["config"], query)
if self.hold:
self.pending.append((route, dto))
elif self.fail_reads:
route.fulfill(status=503, content_type="application/json", body='{"detail":"本地记录读取失败"}')
else:
self.fulfill(route, {"loading": False, "data": dto})
self.page.route("**/api/accounts/*/views/commissions?*", view)
def history(self, day, label):
fixture = history_fixture(day)
fixture["rows"][0]["name"] = label + day + "提交魔物与道具"
return fixture
def tearDown(self):
try:
self.assertEqual(self.external, [])
self.assertEqual(self.errors, [])
for engine in self.engines.values():
engine.client.call.assert_not_called()
finally:
self.context.unroute_all(behavior="ignoreErrors")
self.context.close()
def records(self):
panel = self.go("commissions")
panel.get_by_role("tab", name="每日记录", exact=True).click()
expect(panel.locator('input[type="date"]')).to_have_value(self.today.isoformat())
expect(panel.locator("tbody tr")).to_have_count(2)
expect(panel).to_have_attribute("aria-busy", "false")
return panel
def test_history_refresh_is_get_only_and_original_single_log_stays_collapsed(self):
self.open()
expect(self.page.locator("#page-tabs [role=tab]")).to_have_count(15)
panel = self.records()
expect(panel.get_by_role("tab", name="每日记录")).to_have_attribute("aria-selected", "true")
expect(panel.locator(".policy-form")).to_be_hidden()
expect(panel.locator(".page-surface > p.page-summary")).to_contain_text("已记录接取 2 · 已记录完成 1")
expect(panel.locator(".page-surface > p.page-summary")).to_contain_text("当日领奖确认氪金 15 · 当日接取标注氪金 35")
expect(panel.locator('td[data-column="confirmed_ke"]')).to_have_text(["15", "未确认"])
expect(self.page.locator("#log-panel")).to_have_count(1)
expect(self.page.locator("#log-panel")).to_be_hidden()
before = len(self.writes)
with self.page.expect_request(lambda request: "/views/commissions?" in request.url) as seen:
panel.get_by_role("button", name="刷新记录", exact=True).click()
self.assertEqual(seen.value.method, "GET")
expect(panel).to_have_attribute("aria-busy", "false")
self.assertEqual(len(self.writes), before)
expect(self.page.locator("#log-panel")).to_be_hidden()
self.assertEqual(self.page.locator('[role="log"]').count(), 1)
panel.locator("tbody tr").first.click(button="right")
with self.page.expect_request(lambda request: "/views/commissions?" in request.url) as seen:
self.page.get_by_role("menuitem", name="刷新本页", exact=True).click()
self.assertEqual(seen.value.method, "GET")
expect(panel).to_have_attribute("aria-busy", "false")
self.assertEqual(len(self.writes), before)
artifact = Path(__file__).resolve().parents[3] / "test-artifacts" / "commission-history"
artifact.mkdir(parents=True, exist_ok=True)
self.page.screenshot(path=str(artifact / "desktop-daily-records.png"))
panel.locator("tbody tr").first.dblclick()
detail = self.page.get_by_role("dialog")
expect(detail).to_contain_text("委托详情")
for value in ("铁矿石 ×2", "1级史莱姆 ×1", "城镇守卫", "战斗胜利", "回退15氪金"):
expect(detail).to_contain_text(value)
expect(self.page.locator("#log-panel")).to_be_hidden()
def test_current_policy_autosave_and_original_log_filters_commissions_in_both_subtabs(self):
worker = self.manager._worker(self.first)
worker.log("接取委托:仅委托可见(预计20氪金);已确认", category="commissions")
worker.log("其他分类不可见", category="login")
self.open()
panel = self.go("commissions")
with self.page.expect_request(lambda request: request.method == "PUT" and "/config" in request.url):
panel.get_by_role("checkbox", name="允许提交道具(遵守保留数量)", exact=True).check()
expect(self.page.locator("#save-status")).to_have_text("策略已自动保存")
self.assertTrue(self.manager.get_config(self.first)["config"]["quest_policy"]["allow_items"])
expect(self.page.locator("#log-panel")).to_be_hidden()
self.page.locator("#log-toggle").click()
expect(self.page.locator("#log-heading")).to_have_text("自动委托日志")
expect(self.page.locator("#log-lines")).to_contain_text("仅委托可见")
expect(self.page.locator("#log-lines")).not_to_contain_text("其他分类不可见")
panel.get_by_role("tab", name="每日记录").click()
expect(panel.get_by_label("记录日期(北京时间)")).to_be_visible()
expect(self.page.locator("#log-panel")).to_be_visible()
expect(self.page.locator("#log-panel")).to_have_count(1)
expect(self.page.locator("#log-heading")).to_have_text("自动委托日志")
expect(self.page.locator("#log-lines")).not_to_contain_text("其他分类不可见")
def test_date_account_isolation_and_keyboard_subtabs(self):
self.open()
panel = self.records()
yesterday = (self.today - timedelta(days=1)).isoformat()
panel.get_by_label("记录日期(北京时间)").fill(yesterday)
expect(panel.locator("tbody tr").first).to_contain_text("账号一" + yesterday)
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
panel = self.records()
expect(panel.get_by_label("记录日期(北京时间)")).to_have_value(self.today.isoformat())
expect(panel.locator("tbody tr").first).to_contain_text("账号二" + self.today.isoformat())
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
panel = self.page.locator('.page-panel[data-page="commissions"]:not([hidden])')
expect(panel.get_by_label("记录日期(北京时间)")).to_have_value(yesterday)
expect(panel.locator("tbody tr").first).to_contain_text("账号一" + yesterday)
current = panel.get_by_role("tab", name="每日记录")
current.focus()
current.press("Home")
expect(panel.get_by_role("tab", name="当前委托")).to_have_attribute("aria-selected", "true")
expect(panel.locator('th[data-column="reward_ke"]')).to_have_text("标注氪金")
expect(panel.locator("tbody tr").first).to_contain_text("城市尚未解锁")
expect(panel.locator('td[data-column="status"]')).to_have_text(["暂不接取", "候选 / 条件待核对"])
expect(self.page.locator("#log-panel")).to_be_hidden()
def test_loading_error_and_mobile_history_keep_original_layout(self):
self.open()
panel = self.records()
self.hold = True
panel.get_by_label("记录日期(北京时间)").fill((self.today - timedelta(days=2)).isoformat())
expect(panel).to_have_attribute("aria-busy", "true")
expect(panel.locator(".page-loading")).to_be_visible()
expect(self.page.locator("#log-panel")).to_be_hidden()
deadline = time.monotonic() + 5
while not self.pending and time.monotonic() < deadline:
self.page.wait_for_timeout(30)
self.assertTrue(self.pending)
self.hold = False
route, dto = self.pending.pop(0)
self.fulfill(route, {"loading": False, "data": dto})
expect(panel).to_have_attribute("aria-busy", "false")
expect(panel.locator(".page-loading")).to_be_hidden()
self.fail_reads = True
panel.get_by_role("button", name="刷新记录").click()
expect(panel.locator(".page-error")).to_be_visible()
expect(panel).to_have_attribute("aria-busy", "false")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.fail_reads = False
self.errors[:] = [error for error in self.errors if "503 (Service Unavailable)" not in error]
panel.get_by_role("button", name="重新读取").click()
expect(panel.locator(".page-error")).to_be_hidden()
self.page.set_viewport_size({"width": 390, "height": 844})
expect(panel.get_by_label("记录日期(北京时间)")).to_be_visible()
self.assertLessEqual(self.page.evaluate("document.documentElement.scrollWidth"), 391)
artifact = Path(__file__).resolve().parents[3] / "test-artifacts" / "commission-history"
artifact.mkdir(parents=True, exist_ok=True)
self.page.screenshot(path=str(artifact / "mobile-daily-records.png"))
if __name__ == "__main__":
unittest.main()
@@ -51,8 +51,22 @@ class PageLoadingBrowserTests(unittest.TestCase):
"details": {"help": "STATIC_HELP_SENTINEL", "note": "STATIC_NOTE_SENTINEL", "details": {"help": "STATIC_HELP_SENTINEL", "note": "STATIC_NOTE_SENTINEL",
"notes": ["金币不足,等待补货"]}}} "notes": ["金币不足,等待补货"]}}}
self.hold, self.fail = False, False self.hold, self.fail = False, False
self.hold_after_real_retry_click = False
self.page.add_init_script("""(() => {
window.__loadingRetryClicked = false;
document.addEventListener('click', event => {
if (event.target instanceof Element && event.target.closest('.page-panel[data-page="bag"] .page-error button')) {
window.__loadingRetryClicked = true;
}
}, true);
})();""")
def view(route): def view(route):
if self.hold_after_real_retry_click:
if not self.page.evaluate("window.__loadingRetryClicked"):
route.fulfill(status=503, content_type="application/json", body='{"detail":"读取失败"}')
return
self.hold_after_real_retry_click = False
if self.hold: if self.hold:
self.pending.append(route) self.pending.append(route)
elif self.fail: elif self.fail:
@@ -156,8 +170,16 @@ class PageLoadingBrowserTests(unittest.TestCase):
expect(panel.locator(".page-error")).to_be_visible() expect(panel.locator(".page-error")).to_be_visible()
expect(panel).to_have_attribute("aria-busy", "false") expect(panel).to_have_attribute("aria-busy", "false")
expect(panel.locator(".page-loading")).to_be_hidden() expect(panel.locator(".page-loading")).to_be_hidden()
# Passive polling must keep returning the error until the native click.
# Holding a passive request here would hide the button before it can click.
self.hold_after_real_retry_click = True
self.hold, self.fail = True, False self.hold, self.fail = True, False
with self.page.expect_response(lambda response: "/views/bag?" in response.url and response.status == 503):
pass # Exercise a real passive refresh during this transition.
expect(panel.locator(".page-error")).to_be_visible()
self.assertEqual(self.pending, [], "Passive errors must not park a request before the retry click")
panel.get_by_role("button", name="重新读取").click() panel.get_by_role("button", name="重新读取").click()
self.assertTrue(self.page.evaluate("window.__loadingRetryClicked"))
route = self.wait_request() route = self.wait_request()
self.assert_centered(panel) self.assert_centered(panel)
self.summary.update(connection_state="offline", connected=False, connection_message="连接已中断") self.summary.update(connection_state="offline", connected=False, connection_message="连接已中断")
+196
View File
@@ -0,0 +1,196 @@
"""Commission DTO regressions with temporary engines and synthetic local history."""
from datetime import datetime, timezone
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog
from ranch_web.policies import default_config
from ranch_web.views import build_view
def history_fixture(day):
return {"date": day, "dates": [day], "summary": {
"accepted_count": 2, "completed_count": 1, "expected_ke": 35, "confirmed_ke": 15, "pending_count": 1, "unknown_reward_count": 0},
"rows": [{"id": "local-15", "task_id": 71, "task_type_id": "test15", "name": "提交魔物与道具",
"status": "completed", "accepted_at": day + "T01:02:03+00:00", "completed_at": day + "T02:03:04+00:00",
"expected_ke": 15, "confirmed_ke": 15, "selection_reason": "20氪金候选城市尚未解锁,回退15氪金",
"last_action": "服务器已确认领取15氪金", "events": [
{"time": day + "T01:02:03+00:00", "kind": "accept", "status": "confirmed", "description": "接取委托,预计15氪金"},
{"time": day + "T01:03:03+00:00", "kind": "handin_items", "status": "confirmed", "description": "已提交铁矿石 ×2"},
{"time": day + "T01:04:03+00:00", "kind": "handin_monsters", "status": "confirmed", "description": "已提交1级史莱姆 ×1"},
{"time": day + "T01:05:03+00:00", "kind": "dialogue", "status": "confirmed", "description": "已与城镇守卫对话"},
{"time": day + "T01:06:03+00:00", "kind": "battle", "status": "confirmed", "description": "委托战斗胜利,推进第4步"},
{"time": day + "T02:03:04+00:00", "kind": "claim", "status": "confirmed", "description": "服务器奖励回包确认氪金15"}]},
{"id": "local-20", "task_id": 72, "task_type_id": "test20", "name": "奖励待核对的委托",
"status": "unknown", "accepted_at": day + "T03:02:03+08:00", "completed_at": None,
"expected_ke": 20, "confirmed_ke": None, "last_action": "领奖请求超时,等待核对",
"events": [{"time": day + "T03:03:04+08:00", "kind": "claim", "status": "unknown", "description": "领奖回包未知"}]}]}
class CommissionHistoryViewTests(unittest.TestCase):
def setUp(self):
root = self.enterContext(tempfile.TemporaryDirectory(prefix="commission-web-history-"))
self.engine = Engine(Catalog(), budget_path=Path(root) / "budget.json")
self.engine.snapshot = demo_snapshot(self.engine.catalog)
self.engine.demo = False
self.engine.client = Mock()
self.engine.client.call.side_effect = AssertionError("Game calls forbidden in history views")
self.config = default_config()
self.history = history_fixture("2026-11-12")
self.engine.commission_history = Mock(return_value=self.history)
self.engine.commission_offer_diagnostics = Mock(return_value=[])
def view(self, **query):
return build_view(self.engine, "commissions", self.config, {"tab": "history", **query})
def test_history_reads_only_local_helper_and_separates_confirmed_rewards(self):
self.engine.tasks.rows = Mock(side_effect=AssertionError("Current tasks are not history"))
self.engine.progression_rows = Mock(side_effect=AssertionError("Do not plan game actions in history"))
self.engine.commission_offer_diagnostics.side_effect = AssertionError("History must not inspect current offers")
self.engine.plans = Mock(side_effect=AssertionError("Do not plan in history"))
dto = self.view(date="2026-11-12")
self.engine.commission_history.assert_called_once_with(day="2026-11-12")
self.engine.client.call.assert_not_called()
self.assertEqual([tab["title"] for tab in dto["tabs"]], ["当前委托", "每日记录"])
self.assertEqual(dto["form"], [])
self.assertEqual(dto["actions"], [{"operation": "reload_view", "label": "刷新记录"}])
self.assertIn("已记录接取 2", dto["summary"])
self.assertIn("已记录完成 1", dto["summary"])
self.assertIn("仅有本地已保存记录", dto["summary"])
self.assertIn("当日领奖确认氪金 15", dto["summary"])
self.assertIn("当日接取标注氪金 35", dto["summary"])
self.assertIn("操作待核对 1", dto["summary"])
self.assertIn("领奖金额未记录 0", dto["summary"])
self.assertEqual(dto["rows"][1]["confirmed_ke"], "未确认")
self.assertEqual(dto["rows"][1]["status_label"], "结果待核对")
self.assertEqual(dto["rows"][0]["accepted_at"], "2026-11-12 09:02:03")
self.assertEqual(dto["rows"][1]["completed_at"], "—")
json.dumps(dto, ensure_ascii=False, allow_nan=False)
def test_details_show_actual_handins_dialogue_battle_and_claim_evidence(self):
dto = self.view(date="2026-11-12")
detail = dto["details"]["local-15"]
for text in ("铁矿石 ×2", "1级史莱姆 ×1", "城镇守卫", "战斗胜利", "氪金15"):
self.assertIn(text, detail["行动记录"])
self.assertIn("回退15氪金", detail["选择 / 回退原因"])
self.assertIn("结果待核对", dto["details"]["local-20"]["行动记录"])
self.assertNotIn("已确认", dto["details"]["local-20"]["行动记录"])
def test_search_can_find_action_details_without_changing_daily_totals(self):
dto = self.view(date="2026-11-12", search="铁矿石")
self.assertEqual([row["id"] for row in dto["rows"]], ["local-15"])
self.assertIn("已记录接取 2", dto["summary"])
self.assertEqual(set(dto["details"]), {"local-15"})
def test_empty_history_does_not_invent_old_acceptance_from_current_tasks(self):
self.engine.snapshot.raw["currentTasks"] = [{"id": 3, "typeId": "test20", "curStep": 1}]
self.engine.commission_history.return_value = {"date": "2026-11-11", "summary": {}, "rows": []}
dto = self.view(date="2026-11-11")
self.assertEqual(dto["rows"], [])
self.assertIn("已记录接取 0", dto["summary"])
self.assertIn("历史接取与奖励未追溯", dto["summary"])
def test_history_available_without_snapshot(self):
self.engine.snapshot = None
dto = self.view(date="2026-11-12")
self.assertEqual(len(dto["rows"]), 2)
self.engine.client.call.assert_not_called()
current = build_view(self.engine, "commissions", self.config)
self.assertIn("请先登录", current["summary"])
self.assertEqual(len(current["tabs"]), 2)
def test_default_date_is_beijing_today_at_utc_day_boundary(self):
class FixedDatetime(datetime):
@classmethod
def now(cls, tz=None):
return cls(2026, 11, 12, 17, tzinfo=timezone.utc).astimezone(tz)
with patch("ranch_web.views.datetime", FixedDatetime):
dto = self.view()
self.engine.commission_history.assert_called_once_with(day="2026-11-13")
self.assertEqual(dto["filters"][0]["value"], "2026-11-13")
self.assertEqual(dto["filters"][0]["type"], "date")
def test_invalid_date_never_calls_history_helper(self):
for day in ("2026-11-31", "2026-1-1", "../2026-11-12", ["2026-11-12"]):
with self.subTest(day=day), self.assertRaisesRegex(ValueError, "记录日期"):
self.view(date=day)
self.engine.commission_history.assert_not_called()
def test_raw_history_fields_never_reach_public_view(self):
row = self.history["rows"][0]
row["raw_response"] = {"token": "private-response"}
row["events"][0].update(raw={"password": "private-event"}, payload={"removeIds": [1234567]})
wire = json.dumps(self.view(date="2026-11-12"), ensure_ascii=False)
for value in ("private-response", "private-event", "1234567", "raw_response", "removeIds"):
self.assertNotIn(value, wire)
def test_current_offer_presence_never_implies_receivable(self):
self.engine.catalog.data["task_info"] = {
"test20": {"name": "高额候选", "reward": {"money": 123, "ke": 20}},
"test15": {"name": "回退候选", "reward": {"money": 456, "ke": 15}}}
self.engine.tasks.rows = Mock(return_value=[
("test20", "高额候选", "城市 4 可接", "提交物品", {"city": 4}),
("test15", "回退候选", "城市 1 可接", "提交金币", {"city": 1})])
self.engine.tasks.current = Mock(return_value=[])
self.engine.progression_rows = Mock(return_value=[
{"category": "commission", "task_type_id": "test20", "block_reason": "城市尚未解锁"},
{"category": "commission", "task_type_id": "test15", "selection_reason": "20氪金候选未解锁,回退15氪金"}])
dto = build_view(self.engine, "commissions", self.config)
high, fallback = dto["rows"]
self.assertEqual(high["reward_ke"], 20)
self.assertEqual(high["reward_money"], 123)
self.assertEqual(high["status"], "暂不接取")
self.assertEqual(high["reason"], "城市尚未解锁")
self.assertNotIn("可接", fallback["status"])
self.assertIn("回退15氪金", fallback["selection_reason"])
self.assertIn("20 → 15 → 10", dto["details"][fallback["id"]]["接取优先级"])
def test_authoritative_offer_diagnostics_match_city_and_explain_fallback(self):
self.engine.catalog.data["task_info"] = {
"test20": {"name": "高额候选", "reward": {"money": 123, "ke": 20}},
"test15": {"name": "回退候选", "reward": {"money": 456, "ke": 15}}}
self.engine.tasks.rows = Mock(return_value=[
("test20", "高额候选", "城市 4 可接", "", {"city": 4}),
("test15", "回退候选", "城市 1 可接", "", {"city": 1}),
("test15", "回退候选", "城市 9 可接", "", {"city": 9})])
self.engine.tasks.current = Mock(return_value=[])
self.engine.progression_rows = Mock(return_value=[
{"category": "commission", "task_type_id": "test15", "block_reason": "错误城市的阻塞原因"}])
self.engine.commission_offer_diagnostics.return_value = [
{"task_type_id": "test20", "name": "高额候选", "city": 4, "expected_ke": 20, "eligible": False, "reason": "城市尚未解锁"},
{"task_type_id": "test15", "name": "回退候选", "city": 1, "expected_ke": 15, "eligible": True, "reason": "可接取"},
{"task_type_id": "test15", "name": "回退候选", "city": 9, "expected_ke": 15, "eligible": False, "reason": "提交魔物受保留保护"}]
dto = build_view(self.engine, "commissions", self.config)
self.assertEqual([row["status"] for row in dto["rows"]], ["暂不接取", "可接取", "暂不接取"])
self.assertIn("选择 15 氪金", dto["rows"][1]["selection_reason"])
self.assertIn("城市尚未解锁", dto["rows"][1]["selection_reason"])
self.assertNotIn("错误城市", dto["rows"][1]["reason"])
self.assertEqual(dto["rows"][2]["reason"], "提交魔物受保留保护")
self.engine.client.call.assert_not_called()
def test_pending_zero_reward_and_cross_day_totals_remain_distinct(self):
self.history["rows"][0].update(expected_ke=20, confirmed_ke=0, accepted_at="2026-11-11T01:02:03+08:00")
self.history["rows"][1]["status"] = "pending"
self.history["summary"].update(accepted_count=0, expected_ke=0, confirmed_ke=0)
dto = self.view(date="2026-11-12")
self.assertEqual(dto["rows"][0]["confirmed_ke"], 0)
self.assertEqual(dto["rows"][0]["expected_ke"], 20)
self.assertEqual(dto["rows"][1]["confirmed_ke"], "未确认")
self.assertEqual(dto["rows"][1]["status_label"], "等待核对")
self.assertIn("当日接取标注氪金 0", dto["summary"])
self.assertNotIn("损失", dto["summary"])
def test_backend_read_error_visible_without_exposing_private_fields(self):
self.history.update(error="委托历史无法读取,原文件已保留", notice="仅展示本地已保存记录")
dto = self.view(date="2026-11-12")
self.assertIn("委托历史无法读取,原文件已保留", dto["summary"])
self.assertIn("仅有本地已保存记录", dto["summary"])
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,113 @@
"""Real worker/local ledger integration; game transports are always offline fakes."""
from copy import deepcopy
from datetime import datetime, timedelta, timezone
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.engine import Engine
from ranch_web.tests import test_service as fixtures
class CommissionHistoryServiceTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
def view(self, identifier, day):
response = self.manager.view(identifier, "commissions", {"tab": "history", "date": day})
if response["loading"]:
self.job(identifier, {"id": response["job_id"]})
response = self.manager.view(identifier, "commissions", {"tab": "history", "date": day})
self.assertFalse(response["loading"])
return response["data"]
def tick(self, identifier, *, failed=False):
worker = self.manager._worker(identifier)
with patch.object(worker.schedule, "due", return_value="poll"):
self.job(identifier, worker.enqueue("__tick"), status="failed" if failed else "succeeded")
def test_real_local_ledger_history_is_account_role_day_isolated_without_game_calls(self):
first, second = self.account(), self.account()
worker = self.manager._worker(first)
engine = worker.engine
role = str(engine.snapshot.raw["master"]["id"])
today = datetime.now(timezone(timedelta(hours=8))).date()
stamp = datetime.combine(today, datetime.min.time(), timezone(timedelta(hours=8))).timestamp() + 3600
info = {"type": 4, "name": "已保存的20氪金委托", "reward": {"ke": 20}}
record = {"attempt_id": "synthetic-accept", "role_id": role, "task_type_id": "test20", "task_id": 71,
"kind": "quest_accept", "path": "taskService/taskLoopReceive", "timestamp": stamp,
"finished_at": stamp, "phase": "done", "outcome": "task", "response_confirmed": True,
"response": {"resCode": 0, "task": {"id": 71, "typeId": "test20", "curStep": 1}},
"commission": {"name": info["name"], "expected_ke": 20}}
engine._commission_history.ingest(role, [record], lambda _: info, engine.snapshot)
after = self.manager.logs(first)["next"]
with patch.object(engine, "read_snapshot", side_effect=AssertionError("history must stay local")), \
patch.object(engine, "poll", side_effect=AssertionError("history must not poll")):
dto = self.view(first, today.isoformat())
self.assertIn("已记录接取 1", dto["summary"])
self.assertEqual(dto["rows"][0]["confirmed_ke"], "未确认")
self.assertEqual(self.view(second, today.isoformat())["rows"], [])
self.assertEqual(self.view(first, (today - timedelta(days=1)).isoformat())["rows"], [])
original = engine.snapshot
engine.snapshot = deepcopy(original)
engine.snapshot.raw["master"]["id"] = "other-local-role"
worker._invalidate_views()
self.assertEqual(self.view(first, today.isoformat())["rows"], [])
engine.snapshot = original
worker._invalidate_views()
self.assertEqual(len(self.view(first, today.isoformat())["rows"]), 1)
self.assertEqual(fixtures.FakeClient.calls, [])
self.assertEqual(self.manager.logs(first, after=after)["entries"], [], "Reading history must not create activity logs")
def test_accept_step_claim_and_unknown_messages_are_chinese_categorized_and_redacted(self):
def action(engine, intent):
return engine.snapshot, [], intent["message"]
with patch.object(Engine, "_run_progression_intent", action):
identifier = self.account()
worker = self.manager._worker(identifier)
worker.engine.game_data = SimpleNamespace(task=lambda _: {"type": 4})
messages = [
("接取委托:本地测试(预计20氪金);已确认", "info"),
("提交委托步骤:本地测试(预计20氪金);已提交铁矿石 ×2", "info"),
("领取委托奖励:本地测试(预计20氪金);已确认,实际获得20氪金", "info"),
("领取委托奖励:本地测试(预计20氪金);结果未知,等待核对,禁止重发", "warning"),
("委托战斗:本地测试(预计20氪金);战斗失败,未推进委托", "error")]
for message, level in messages:
with self.subTest(message=message):
before = self.manager.logs(identifier)["next"]
intent = {"kind": "progression_complete", "task_type_id": "test20", "message": message + ";password=synthetic-password"}
with patch.object(worker.engine, "poll", side_effect=lambda **_: worker.engine._run_progression_intent(intent)):
self.tick(identifier)
entries = self.manager.logs(identifier, after=before)["entries"]
self.assertEqual(len(entries), 1)
self.assertEqual((entries[0]["category"], entries[0]["level"]), ("commissions", level))
self.assertIn("本地测试", entries[0]["message"])
self.assertIn("20氪金", entries[0]["message"])
self.assertNotIn("synthetic-password", entries[0]["message"])
def test_failed_commission_keeps_one_error_with_name_reward_and_no_success(self):
def action(engine, intent):
raise TimeoutError("token=synthetic-token 请求超时")
with patch.object(Engine, "_run_progression_intent", action):
identifier = self.account()
worker = self.manager._worker(identifier)
worker.engine.game_data = SimpleNamespace(task=lambda _: {"type": 4, "name": "受保护的提交委托", "reward": {"ke": 20}})
before = self.manager.logs(identifier)["next"]
intent = {"kind": "progression_loop_accept", "task_type_id": "test20"}
with patch.object(worker.engine, "poll", side_effect=lambda **_: worker.engine._run_progression_intent(intent)):
self.tick(identifier, failed=True)
entries = self.manager.logs(identifier, after=before)["entries"]
self.assertEqual(len(entries), 1)
self.assertEqual((entries[0]["category"], entries[0]["level"]), ("commissions", "error"))
for value in ("受保护的提交委托", "标注20氪金", "接取异常", "结果待核对"):
self.assertIn(value, entries[0]["message"])
self.assertNotIn("synthetic-token", entries[0]["message"])
self.assertNotIn("已确认", entries[0]["message"])
if __name__ == "__main__":
unittest.main()
+101 -9
View File
@@ -13,6 +13,7 @@ from ranch_assistant.drop_statistics import analyze
from ranch_assistant.presentation import monster_rows from ranch_assistant.presentation import monster_rows
from ranch_assistant.battle_messages import battle_message from ranch_assistant.battle_messages import battle_message
from ranch_assistant.resource_stages import available_item_count, item_requirements, with_resource_data from ranch_assistant.resource_stages import available_item_count, item_requirements, with_resource_data
from ranch_assistant.quests import commission_priority, commission_selection
from .policies import default_config, validate_config from .policies import default_config, validate_config
@@ -126,7 +127,10 @@ def build_view(engine, page, config, query=None):
"form": [field | {"value": _value(config, field["path"])} for field in fields], "form": [field | {"value": _value(config, field["path"])} for field in fields],
"filters": [], "details": {}, "actions": [{"operation": "refresh", "label": "刷新本页", "payload": {"page": page}}]} "filters": [], "details": {}, "actions": [{"operation": "refresh", "label": "刷新本页", "payload": {"page": page}}]}
builder = _BUILDERS.get(page) builder = _BUILDERS.get(page)
if engine.snapshot is None and page not in ("login", "yields", "statistics"): if page == "commissions":
dto["tabs"] = [{"key": "current", "title": "当前委托"}, {"key": "history", "title": "每日记录"}]
local_history = page == "commissions" and (query or {}).get("tab") == "history"
if engine.snapshot is None and page not in ("login", "yields", "statistics") and not local_history:
dto["summary"] = "请先登录或打开离线演示" dto["summary"] = "请先登录或打开离线演示"
return dto return dto
if builder is not None: if builder is not None:
@@ -562,33 +566,121 @@ def _battles(dto, engine, config, query):
dto["actions"] = [{"operation": "refresh_tasks", "label": "刷新战斗记录", "payload": {}}] dto["actions"] = [{"operation": "refresh_tasks", "label": "刷新战斗记录", "payload": {}}]
COMMISSION_STATES = {"accepted": "已接取", "active": "进行中", "in_progress": "进行中", "completed": "已完成", "pending": "等待核对",
"claimed": "已领奖", "confirmed": "已确认", "unknown": "结果待核对", "failed": "失败", "cancelled": "已取消", "observed": "仅观察到任务", "blocked": "等待条件"}
COMMISSION_EVENTS = {"accept": "接取", "step": "推进步骤", "claim": "领取奖励", "complete": "领取奖励", "dialogue": "对话", "battle": "战斗",
"navigate": "前往任务地点", "farm": "收集委托材料", "local_step": "步骤收尾", "reset": "刷新每日委托",
"handin": "交付", "handin_items": "提交道具", "handin_monsters": "提交魔物", "handin_money": "提交金币",
"quest_accept": "接取", "quest_step": "推进步骤", "quest_complete": "领取奖励", "observe": "观察到任务"}
def _commission_time(value):
if value is None or value == "":
return "—"
try:
if type(value) in (int, float):
stamp = datetime.fromtimestamp(value / 1000 if value >= 1e12 else value, CHINA_TIME)
elif isinstance(value, str):
stamp = datetime.fromisoformat(value.replace("Z", "+00:00"))
if stamp.tzinfo is None:
stamp = stamp.replace(tzinfo=CHINA_TIME)
else:
return "—"
return stamp.astimezone(CHINA_TIME).strftime("%Y-%m-%d %H:%M:%S")
except (ValueError, OverflowError, OSError):
return "时间未确认"
def _commission_history(dto, engine, query):
selected = query.get("date") or datetime.now(CHINA_TIME).date().isoformat()
try:
if not isinstance(selected, str) or datetime.strptime(selected, "%Y-%m-%d").date().isoformat() != selected:
raise ValueError
except (TypeError, ValueError):
raise ValueError("记录日期须为 YYYY-MM-DD") from None
history = engine.commission_history(day=selected)
totals = history.get("summary") or {}
dto["form"] = []
dto["actions"] = [{"operation": "reload_view", "label": "刷新记录"}]
dto["filters"] = [_filter("date", "记录日期(北京时间)", selected, kind="date")]
search = _search(dto, query)
dto["columns"] = [_column(key, label) for key, label in (("name", "委托"), ("status_label", "状态"),
("expected_ke", "预计氪金"), ("confirmed_ke", "已确认氪金"), ("accepted_at", "接取时间(北京时间)"),
("completed_at", "完成时间(北京时间)"), ("last_action", "最近行动"))]
sources = history.get("rows") or []
for index, source in enumerate(sources):
status = _text(source.get("status"), "unknown")
row = {"id": _text(source.get("id"), str(index)), "task_type_id": _text(source.get("task_type_id")),
"name": _text(source.get("name")), "status_label": COMMISSION_STATES.get(status, "结果待核对"),
"expected_ke": source.get("expected_ke") if type(source.get("expected_ke")) in (int, float) else "未记录",
"confirmed_ke": source.get("confirmed_ke") if type(source.get("confirmed_ke")) in (int, float) else "未确认",
"accepted_at": _commission_time(source.get("accepted_at")), "completed_at": _commission_time(source.get("completed_at")),
"last_action": _text(source.get("last_action"), "暂无行动记录")}
events = []
for event in source.get("events") or []:
kind, outcome = _text(event.get("kind"), "unknown"), _text(event.get("status"), "unknown")
label = {"success": "已确认", "succeeded": "已确认", "confirmed": "已确认", "completed": "已确认",
"failed": "失败", "unknown": "结果待核对", "pending": "等待核对", "cancelled": "已取消"}.get(outcome, "结果待核对")
events.append(f"{_commission_time(event.get('time'))} · {COMMISSION_EVENTS.get(kind, '委托行动')} · {label} · {_text(event.get('description'))}")
detail = {"委托": row["name"], "任务编号": row["task_type_id"], "状态": row["status_label"],
"预计氪金": row["expected_ke"], "已确认氪金": row["confirmed_ke"], "接取时间(北京时间)": row["accepted_at"],
"完成时间(北京时间)": row["completed_at"], "选择 / 回退原因": _text(source.get("selection_reason"), "未记录"),
"行动记录": "\n".join(events) or "暂无行动记录"}
if search and search not in " ".join(map(str, [*row.values(), *detail.values()])).casefold():
continue
dto["rows"].append(row)
dto["details"][row["id"]] = detail
dto["summary"] = (f"{selected} · 已记录接取 {totals.get('accepted_count', 0)} · 已记录完成 {totals.get('completed_count', 0)}"
f" · 当日领奖确认氪金 {totals.get('confirmed_ke', 0)} · 当日接取标注氪金 {totals.get('expected_ke', 0)}"
f" · 操作待核对 {totals.get('pending_count', 0)} · 领奖金额未记录 {totals.get('unknown_reward_count', 0)}")
dto["summary"] += ";仅有本地已保存记录" if sources else ";当日暂无本地记录,历史接取与奖励未追溯"
if history.get("error"):
dto["summary"] += ";" + _text(history["error"])
def _commissions(dto, engine, config, query): def _commissions(dto, engine, config, query):
if query.get("tab") == "history":
_commission_history(dto, engine, query)
return
snapshot, catalog = engine.snapshot, engine.catalog snapshot, catalog = engine.snapshot, engine.catalog
search = _search(dto, query) search = _search(dto, query)
dto["columns"] = [_column(key, label) for key, label in (("task_type_id", "编号"), ("name", "委托"), ("status", "状态"), dto["columns"] = [_column(key, label) for key, label in (("task_type_id", "编号"), ("name", "委托"), ("city", "城市"), ("status", "状态"),
("reward_money", "金币奖励"), ("reward_ke", "氪金奖励"), ("reason", "需求 / 下一步 / 阻塞原因"))] ("reward_money", "标注金币"), ("reward_ke", "标注氪金"), ("selection_reason", "选择 / 回退原因"), ("reason", "需求 / 下一步 / 阻塞原因"))]
diagnostics = {str(row.get("task_type_id")): row for row in engine.progression_rows() if _category(row.get("category")) == "commission"} diagnostics = {str(row.get("task_type_id")): row for row in engine.progression_rows() if _category(row.get("category")) == "commission"}
source = engine.tasks.rows(snapshot, engine.quest_policy, engine.policy) offer_rows = engine.commission_offer_diagnostics()
offers = {(str(row.get("task_type_id")), str(row.get("city"))): row for row in offer_rows}
selected = next((row for row in offer_rows if row.get("eligible") is True), {})
selection = commission_selection({"reward": {"ke": selected.get("expected_ke", 0)}}, offer_rows,
[row for row in offer_rows if row.get("eligible") is False]) if selected else {}
source = sorted(engine.tasks.rows(snapshot, engine.quest_policy, engine.policy), key=lambda row: (
"city" in row[4], commission_priority(catalog.data.get("task_info", {}).get(str(row[0]), {}))))
for index, (key, name, status, text, meta) in enumerate(source): for index, (key, name, status, text, meta) in enumerate(source):
diagnostic = diagnostics.get(str(key), {}) diagnostic = diagnostics.get(str(key), {})
reason = diagnostic.get("block_reason") or diagnostic.get("blocked_reason") offer = offers.get((str(key), str(meta.get("city"))), {}) if "city" in meta else {}
if "city" in meta:
status = "可接取" if offer.get("eligible") is True else "候选 / 条件待核对"
reason = (offer.get("reason") if offer.get("eligible") is False else None) if offer else diagnostic.get("block_reason") or diagnostic.get("blocked_reason")
if reason: if reason:
status = "暂不接取" if "city" in meta else "等待条件" status = "暂不接取" if "city" in meta else "等待条件"
text = reason text = reason
elif diagnostic.get("next_action"): elif not offer and diagnostic.get("next_action"):
text = diagnostic["next_action"] text = diagnostic["next_action"]
info = catalog.data.get("task_info", {}).get(str(key), {}) info = catalog.data.get("task_info", {}).get(str(key), {})
reward = info.get("reward") or {} reward = info.get("reward") or {}
row = {"id": f"{key}:{index}", "task_type_id": str(key), "name": name, "status": status, row = {"id": f"{key}:{index}", "task_type_id": str(key), "name": name, "status": status,
"reward_money": reward.get("money", 0), "reward_ke": reward.get("ke", 0), "reason": battle_message(text), "reward_money": reward.get("money", 0), "reward_ke": reward.get("ke", 0), "reason": battle_message(text),
"city": meta.get("city"), "active": "city" not in meta} "city": meta.get("city"), "active": "city" not in meta,
"selection_reason": _text(offer.get("selection_reason") or (selection.get("selection_reason") if offer and offer == selected else None)
or diagnostic.get("selection_reason") or meta.get("selection_reason") or (reason if "city" in meta else None),
"较高氪金的可执行委托优先" if offer.get("eligible") is True else "接取条件待核对" if "city" in meta else "已接取,优先推进当前委托")}
if search and search not in " ".join(map(str, row.values())).casefold(): if search and search not in " ".join(map(str, row.values())).casefold():
continue continue
dto["rows"].append(row) dto["rows"].append(row)
dto["details"][row["id"]] = {"描述": info.get("des", ""), "需求 / 下一步": row["reason"], dto["details"][row["id"]] = {"描述": info.get("des", ""), "标注奖励": reward_summary(catalog, reward),
"城市": _text(meta.get("city")), "选择 / 回退原因": row["selection_reason"], "需求 / 下一步": row["reason"],
"交付限制": {"允许物品": engine.quest_policy.allow_items, "允许魔物": engine.quest_policy.allow_monsters, "交付限制": {"允许物品": engine.quest_policy.allow_items, "允许魔物": engine.quest_policy.allow_monsters,
"单次金币上限": engine.quest_policy.max_money, "允许已支持战斗": engine.quest_policy.battle_tasks}, "单次金币上限": engine.quest_policy.max_money, "允许已支持战斗": engine.quest_policy.battle_tasks},
"接取优先级": "氪金奖励较高的委托优先;仅接取原规划器确认可支持的委托"} "接取优先级": "跨城市按标注氪金 20 → 15 → 10 优先;20 氪金均不可用时回退到可执行的 15 / 10 氪金委托"}
dto["summary"] = f"今日剩余可接次数:{snapshot.raw.get('history', {}).get('loopTaskNum', '未知')};当前委托:{len(engine.tasks.current(snapshot))}" dto["summary"] = f"今日剩余可接次数:{snapshot.raw.get('history', {}).get('loopTaskNum', '未知')};当前委托:{len(engine.tasks.current(snapshot))}"