feat: add daily commission history for Web 2.0.8

This commit is contained in:
AttilaNet
2026-11-13 09:59:43 +08:00
parent ad25d5b403
commit 296653d8d3
25 changed files with 2179 additions and 96 deletions
+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 .daily import DailyLedger, DailyPolicy, selected_entries
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 .management import expansion_quote, manual_monster_actions
from .gifts import GiftPlanner
@@ -104,6 +105,10 @@ class Engine:
self._progression_state_loaded = False
self._battle_catalog_ready = False
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,
request_builder=self._battle_request, observer=self._battle_observer)
self._progression_cancel = threading.Event()
@@ -454,6 +459,10 @@ class Engine:
self.battle_journal.save()
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":
stage = SimpleNamespace(stage_id=str(value(intent, "stage_id")), level=str(value(intent, "difficulty")))
key = self.sweeper.key(self.snapshot, stage)
@@ -487,6 +496,11 @@ class Engine:
if farming:
if event == "started":
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
# snapshot govern the result; it never acknowledges a task step.
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
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
def _is_farm(intent):
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 "委托后续步骤当前无法自动完成")
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):
self._commission_offer_reason = "委托后续条件、剧情或战斗未验证支持,未消耗接取次数"
info = self.game_data.task(type_id)
if not info or info.get("type") != 4:
self._commission_offer_reason = "委托配置缺失或类型不符"
return False
for number, step in enumerate(info.get("steps", []), 1):
for name in (step.get("story"), step.get("afterStory")):
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
kind = step.get("statusType")
if kind in ("battle", "passStage"):
if not self.quest_policy.battle_tasks:
self._commission_offer_reason = "委托战斗开关未启用"
return False
intent = {"kind": "progression_battle", "task_type_id": str(type_id), "task_id": 0,
"step_number": number, "battle_kind": "passStage" if kind == "passStage" else "task",
@@ -748,12 +870,24 @@ class Engine:
return False
else:
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:
sources = self.progression_planner.farming_intents(self.snapshot, step,
{"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
if not info.get("steps"):
self._commission_offer_reason = "委托没有有效步骤"
return bool(info.get("steps"))
def _refresh_progression_cache(self, *, force=False):
@@ -770,28 +904,33 @@ class Engine:
"snapshot": self._battle_snapshot_digest, "runtime": id(self.battles.runtime)})
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),
"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:
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)
intents = self.progression_planner.plan(self.snapshot, self.progression_policy, self.policy)
commission_plan = getattr(self.progression_planner, "commission_plan", None)
self._commission_planner_available = callable(commission_plan)
if self._commission_planner_available:
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))
self._progression_rows, self._progression_intents = self._overlay_battle_capabilities(rows, intents)
self._persist_progression()
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),
"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 = ""
except (ImportError, OSError, ValueError, TypeError, KeyError, AttributeError) as error:
self._progression_error = "任务规划暂不可用:" + str(error)
self._progression_rows = [{"state": "unsupported", "supported": False, "blocked_reason": self._progression_error}]
self._progression_intents = []
self._progression_records = self.battle_journal.records(self.snapshot)
self._sync_commission_history()
@account_serial
def refresh_progression(self):
@@ -838,9 +977,15 @@ class Engine:
try:
self.last_executed = True
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):
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,
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:
message = self._execute_task_intent(intent)
if self.battle_journal.pending(self.snapshot) and kind == "progression_battle":
@@ -858,6 +1003,7 @@ class Engine:
self._persist_progression()
raise
finally:
self._sync_commission_history()
self._refresh_progression_cache(force=True)
def _execute_task_intent(self, intent):
@@ -875,12 +1021,14 @@ class Engine:
return "任务补链必须提供计算后的三个数组;未发送查询或空补链"
if self._progression_cancel.is_set():
return "任务推进已取消"
self._sync_commission_history()
record = self.battle_journal.begin(self.snapshot, intent)
self._journal_commission(record, intent)
if local:
self.progression_planner.acknowledge(self.snapshot, intent)
self._persist_progression(save=False)
self.battle_journal.finish(self.snapshot, record, "local", "已保存普通剧情的本地检查点")
return "已推进普通剧情并保存本地检查点"
return self._commission_message(record, "已推进普通剧情并保存本地检查点")
try:
self.progression_planner.mark_started(self.snapshot, intent)
self._persist_progression(save=False)
@@ -890,7 +1038,7 @@ class Engine:
except CancelledBeforeDispatch:
self._cancel_unsent_progression(intent)
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)
acknowledged = self.progression_planner.acknowledge(self.snapshot, intent, gameplay_response(response))
self._persist_progression(save=False)
@@ -898,17 +1046,30 @@ class Engine:
self.battle_journal.finish(self.snapshot, record, "task", "服务器已确认任务请求,已保存本地检查点")
else:
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:
self.battle_journal.update(record, "unknown", message="任务请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
finally:
self._sync_commission_history()
@account_serial
def read_snapshot(self, *, sync_master=True):
if self._progression_pending():
self.last_pending_check = time.monotonic()
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)
if sync_master and not self._progression_pending():
self.master_sync.settle(self.client, self.snapshot)
@@ -1223,15 +1384,20 @@ class Engine:
if str(task.get("id")) == str(payload.get("taskId"))), {})
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")}
self._sync_commission_history()
record = self.battle_journal.begin(self.snapshot, intent)
self._journal_commission(record, intent, legacy=True)
try:
self.battle_journal.update(record, "request_pending")
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
except Exception as error:
self.battle_journal.update(record, "unknown", message="委托请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
finally:
self._sync_commission_history()
def _map_policy(self):
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 .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", "支线"),
@@ -184,6 +184,8 @@ class ProgressionPlanner:
self._anonymous = uuid.uuid4().hex
self._accounts = {}
self._issued = {}
self.commission_selection = {}
self.commission_offer_rows = []
def _scope(self, snapshot):
raw, master = snapshot.raw, snapshot.raw.get("master") or {}
@@ -896,11 +898,16 @@ class ProgressionPlanner:
taskLoopReceive:{taskTypeId,city}; quotas decrement only on acceptance
acknowledgement. Current battle/passStage never become sweep intents.
"""
self.commission_selection = {}
self.commission_offer_rows = []
if not quest_policy.enabled:
return []
policy = self._commission_policy(quest_policy, battle_policy)
scope, account = self._account(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"]:
reason = "存在未确认请求,委托等待核对,禁止重发"
return [self._intent(scope, {}, 0, {}, "progression_blocked", reason, policy, block_reason=reason)]
@@ -925,30 +932,67 @@ class ProgressionPlanner:
blocked.append(action)
if blocked or not quest_policy.accept or remaining <= 0:
return blocked
ranked_offers = 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 city, offered_key in ranked_offers:
city = _integer(city)
if city <= 0 or quest_policy.city and city != quest_policy.city or not snapshot.city_unlocked(city):
continue
key, info = str(offered_key), self.data.task(offered_key)
if key in active or key in finished or not info or info.get("type") != 4:
continue
if not self._commission_offer_ready(snapshot, quest_policy, policy, ranch_policy, info)[0]:
continue
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="委托后续战斗或条件当前无法自动完成"))
rejected = []
for candidate in candidates:
city, key = candidate["city"], candidate["task_type_id"]
info = self.data.task(key)
if not candidate["eligible"]:
rejected.append(candidate)
if candidate["blocked_by_support"]:
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=candidate["reason"]))
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 {},
"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))
self._issued[action.token] = action.to_dict()
return [action]
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):
policy = self._commission_policy(quest_policy, battle_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
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):
if isinstance(value, dict):
return value.get(str(key), value.get(key, default))
@@ -84,6 +102,7 @@ class TaskPlanner:
def __init__(self, catalog):
self.catalog = catalog
self.guard = Planner(catalog)
self.commission_selection = {}
def current(self, snapshot):
infos = self.catalog.data.get("task_info", {})
@@ -161,6 +180,7 @@ class TaskPlanner:
return rows
def plan(self, snapshot, policy, ranch, *, include_active=True, accept_supported=None):
self.commission_selection = {}
if not policy.enabled:
return []
history = snapshot.raw.get("history", {})
@@ -176,31 +196,42 @@ class TaskPlanner:
index, steps = int(task.get("curStep", 1)) - 1, info.get("steps", [])
payload = {"taskId": int(task["id"]), "taskTypeId": str(task["typeId"])}
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):
ready, ids, _ = self.requirement(snapshot, steps[index], task, policy, ranch)
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:
return []
current = {str(t["typeId"]) for t in self.current(snapshot)}
offers = sorted(self.rows(snapshot, policy, ranch), key=lambda row: commission_priority(
self.catalog.data["task_info"][row[0]]))
candidates, rejected = [], []
for type_id, name, state, _, meta in offers:
if "city" not in meta or type_id in current:
continue
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]
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
steps = info.get("steps", [])
supported = accept_supported(type_id) if accept_supported else all(
(s.get("statusType") in ("passStage", "battle") and policy.battle_tasks)
or self.requirement(snapshot, s, {}, policy, ranch)[0] for s in steps)
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 []
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()