Files
myrzx_bot/ranch_assistant/commission_history.py
T

306 lines
18 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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)