793 lines
29 KiB
Python
793 lines
29 KiB
Python
"""Storage helpers for parsed RCON AdminLog events."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import re
|
|
import sqlite3
|
|
from collections import Counter
|
|
from collections.abc import Mapping
|
|
from contextlib import closing
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
|
|
from .config import get_storage_path, use_postgres_rcon_storage
|
|
from .rcon_admin_log_parser import parse_rcon_admin_log_entry
|
|
from .rcon_admin_log_parser import parse_rcon_player_profile_snapshot
|
|
from .rcon_historical_storage import initialize_rcon_historical_storage
|
|
from .sqlite_utils import connect_sqlite_writer
|
|
|
|
CURRENT_MATCH_FALLBACK_FRESHNESS = timedelta(minutes=15)
|
|
|
|
|
|
def initialize_rcon_admin_log_storage(*, db_path: Path | None = None) -> Path:
|
|
"""Create SQLite structures for parsed RCON AdminLog events."""
|
|
if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
|
|
from .postgres_rcon_storage import initialize_postgres_rcon_storage
|
|
|
|
initialize_postgres_rcon_storage()
|
|
return get_storage_path()
|
|
|
|
resolved_path = initialize_rcon_historical_storage(db_path=db_path)
|
|
|
|
with connect_sqlite_writer(resolved_path) as connection:
|
|
connection.executescript(
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS rcon_admin_log_events (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
target_key TEXT NOT NULL,
|
|
external_server_id TEXT,
|
|
event_timestamp TEXT,
|
|
server_time INTEGER,
|
|
relative_time TEXT,
|
|
event_type TEXT NOT NULL,
|
|
raw_message TEXT NOT NULL,
|
|
canonical_message TEXT NOT NULL,
|
|
parsed_payload_json TEXT NOT NULL,
|
|
raw_entry_json TEXT NOT NULL,
|
|
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_rcon_admin_log_events_dedupe
|
|
ON rcon_admin_log_events(target_key, server_time, canonical_message);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_rcon_admin_log_events_target_time
|
|
ON rcon_admin_log_events(target_key, server_time DESC);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_rcon_admin_log_events_type
|
|
ON rcon_admin_log_events(event_type);
|
|
|
|
CREATE TABLE IF NOT EXISTS rcon_player_profile_snapshots (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
target_key TEXT NOT NULL,
|
|
external_server_id TEXT,
|
|
player_id TEXT NOT NULL,
|
|
player_name TEXT NOT NULL,
|
|
source_server_time INTEGER NOT NULL,
|
|
event_timestamp TEXT,
|
|
first_seen TEXT,
|
|
sessions INTEGER,
|
|
matches_played INTEGER,
|
|
play_time TEXT,
|
|
total_kills INTEGER,
|
|
total_deaths INTEGER,
|
|
teamkills_done INTEGER,
|
|
teamkills_received INTEGER,
|
|
kd_ratio REAL,
|
|
favorite_weapons_json TEXT NOT NULL DEFAULT '{}',
|
|
victims_json TEXT NOT NULL DEFAULT '{}',
|
|
nemesis_json TEXT NOT NULL DEFAULT '{}',
|
|
averages_json TEXT NOT NULL DEFAULT '{}',
|
|
sanctions_json TEXT NOT NULL DEFAULT '{}',
|
|
raw_content TEXT NOT NULL,
|
|
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
UNIQUE(target_key, player_id, source_server_time)
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_rcon_player_profile_snapshots_player
|
|
ON rcon_player_profile_snapshots(target_key, player_id, source_server_time DESC);
|
|
"""
|
|
)
|
|
_ensure_canonical_message_column(connection)
|
|
|
|
return resolved_path
|
|
|
|
|
|
def persist_rcon_admin_log_entries(
|
|
*,
|
|
target: Mapping[str, object],
|
|
entries: list[dict[str, object]],
|
|
db_path: Path | None = None,
|
|
) -> dict[str, int]:
|
|
"""Persist raw and parsed AdminLog entries idempotently."""
|
|
if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
|
|
return _persist_rcon_admin_log_entries_postgres(target=target, entries=entries)
|
|
|
|
resolved_path = initialize_rcon_admin_log_storage(db_path=db_path)
|
|
target_key = str(target.get("target_key") or target.get("external_server_id") or "")
|
|
if not target_key:
|
|
raise ValueError("target must include target_key or external_server_id")
|
|
|
|
external_server_id = target.get("external_server_id")
|
|
inserted = 0
|
|
duplicates = 0
|
|
|
|
with connect_sqlite_writer(resolved_path) as connection:
|
|
for entry in entries:
|
|
parsed = parse_rcon_admin_log_entry(entry)
|
|
raw_message = str(parsed.get("raw_message") or "")
|
|
canonical_message = _canonicalize_admin_log_message(raw_message)
|
|
cursor = connection.execute(
|
|
"""
|
|
INSERT INTO rcon_admin_log_events (
|
|
target_key,
|
|
external_server_id,
|
|
event_timestamp,
|
|
server_time,
|
|
relative_time,
|
|
event_type,
|
|
raw_message,
|
|
canonical_message,
|
|
parsed_payload_json,
|
|
raw_entry_json
|
|
)
|
|
SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
|
|
WHERE NOT EXISTS (
|
|
SELECT 1
|
|
FROM rcon_admin_log_events
|
|
WHERE target_key = ?
|
|
AND server_time IS ?
|
|
AND canonical_message = ?
|
|
)
|
|
""",
|
|
(
|
|
target_key,
|
|
external_server_id,
|
|
parsed.get("timestamp"),
|
|
parsed.get("server_time"),
|
|
parsed.get("relative_time"),
|
|
parsed.get("event_type") or "unknown",
|
|
raw_message,
|
|
canonical_message,
|
|
json.dumps(parsed, ensure_ascii=False, separators=(",", ":")),
|
|
json.dumps(entry, ensure_ascii=False, separators=(",", ":")),
|
|
target_key,
|
|
parsed.get("server_time"),
|
|
canonical_message,
|
|
),
|
|
)
|
|
if int(cursor.rowcount or 0):
|
|
inserted += 1
|
|
else:
|
|
duplicates += 1
|
|
_persist_profile_snapshot_if_present(
|
|
connection,
|
|
target_key=target_key,
|
|
external_server_id=external_server_id,
|
|
parsed=parsed,
|
|
)
|
|
|
|
return {
|
|
"events_seen": len(entries),
|
|
"events_inserted": inserted,
|
|
"duplicate_events": duplicates,
|
|
}
|
|
|
|
|
|
def _persist_profile_snapshot_if_present(
|
|
connection: sqlite3.Connection,
|
|
*,
|
|
target_key: str,
|
|
external_server_id: object,
|
|
parsed: dict[str, object],
|
|
) -> None:
|
|
snapshot = parse_rcon_player_profile_snapshot(parsed)
|
|
if snapshot is None:
|
|
return
|
|
connection.execute(
|
|
"""
|
|
INSERT INTO rcon_player_profile_snapshots (
|
|
target_key,
|
|
external_server_id,
|
|
player_id,
|
|
player_name,
|
|
source_server_time,
|
|
event_timestamp,
|
|
first_seen,
|
|
sessions,
|
|
matches_played,
|
|
play_time,
|
|
total_kills,
|
|
total_deaths,
|
|
teamkills_done,
|
|
teamkills_received,
|
|
kd_ratio,
|
|
favorite_weapons_json,
|
|
victims_json,
|
|
nemesis_json,
|
|
averages_json,
|
|
sanctions_json,
|
|
raw_content
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(target_key, player_id, source_server_time) DO UPDATE SET
|
|
external_server_id = excluded.external_server_id,
|
|
player_name = excluded.player_name,
|
|
event_timestamp = excluded.event_timestamp,
|
|
first_seen = excluded.first_seen,
|
|
sessions = excluded.sessions,
|
|
matches_played = excluded.matches_played,
|
|
play_time = excluded.play_time,
|
|
total_kills = excluded.total_kills,
|
|
total_deaths = excluded.total_deaths,
|
|
teamkills_done = excluded.teamkills_done,
|
|
teamkills_received = excluded.teamkills_received,
|
|
kd_ratio = excluded.kd_ratio,
|
|
favorite_weapons_json = excluded.favorite_weapons_json,
|
|
victims_json = excluded.victims_json,
|
|
nemesis_json = excluded.nemesis_json,
|
|
averages_json = excluded.averages_json,
|
|
sanctions_json = excluded.sanctions_json,
|
|
raw_content = excluded.raw_content,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
""",
|
|
(
|
|
target_key,
|
|
external_server_id,
|
|
snapshot.player_id,
|
|
snapshot.player_name,
|
|
snapshot.source_server_time,
|
|
snapshot.event_timestamp,
|
|
snapshot.first_seen,
|
|
snapshot.sessions,
|
|
snapshot.matches_played,
|
|
snapshot.play_time,
|
|
snapshot.total_kills,
|
|
snapshot.total_deaths,
|
|
snapshot.teamkills_done,
|
|
snapshot.teamkills_received,
|
|
snapshot.kd_ratio,
|
|
json.dumps(snapshot.favorite_weapons, ensure_ascii=False, separators=(",", ":")),
|
|
json.dumps(snapshot.victims, ensure_ascii=False, separators=(",", ":")),
|
|
json.dumps(snapshot.nemesis, ensure_ascii=False, separators=(",", ":")),
|
|
json.dumps(snapshot.averages, ensure_ascii=False, separators=(",", ":")),
|
|
json.dumps(snapshot.sanctions, ensure_ascii=False, separators=(",", ":")),
|
|
snapshot.raw_content,
|
|
),
|
|
)
|
|
|
|
|
|
_PREFIX_RE = re.compile(r"^\[.*?\(\d+\)\]\s+", re.DOTALL)
|
|
|
|
|
|
def _canonicalize_admin_log_message(raw_message: str) -> str:
|
|
"""Return a stable message body for deduplication across repeated AdminLog reads."""
|
|
normalized = str(raw_message or "").strip()
|
|
return _PREFIX_RE.sub("", normalized).strip()
|
|
|
|
|
|
def _ensure_canonical_message_column(connection: sqlite3.Connection) -> None:
|
|
columns = {
|
|
row["name"]
|
|
for row in connection.execute("PRAGMA table_info(rcon_admin_log_events)").fetchall()
|
|
}
|
|
if "canonical_message" not in columns:
|
|
connection.execute(
|
|
"ALTER TABLE rcon_admin_log_events ADD COLUMN canonical_message TEXT NOT NULL DEFAULT ''"
|
|
)
|
|
connection.execute(
|
|
"""
|
|
UPDATE rcon_admin_log_events
|
|
SET canonical_message = raw_message
|
|
WHERE canonical_message = ''
|
|
"""
|
|
)
|
|
connection.execute(
|
|
"""
|
|
CREATE INDEX IF NOT EXISTS idx_rcon_admin_log_events_dedupe
|
|
ON rcon_admin_log_events(target_key, server_time, canonical_message)
|
|
"""
|
|
)
|
|
|
|
|
|
def list_rcon_admin_log_event_counts(*, db_path: Path | None = None) -> list[dict[str, object]]:
|
|
"""Return event counts grouped by target and event type."""
|
|
if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
|
|
from .postgres_rcon_storage import connect_postgres_compat
|
|
|
|
with connect_postgres_compat() as connection:
|
|
rows = connection.execute(
|
|
"""
|
|
SELECT
|
|
target_key,
|
|
event_type,
|
|
COUNT(*) AS event_count,
|
|
MIN(server_time) AS first_server_time,
|
|
MAX(server_time) AS last_server_time
|
|
FROM rcon_admin_log_events
|
|
GROUP BY target_key, event_type
|
|
ORDER BY target_key ASC, event_count DESC
|
|
"""
|
|
).fetchall()
|
|
return [dict(row) for row in rows]
|
|
|
|
resolved_path = db_path or get_storage_path()
|
|
initialize_rcon_admin_log_storage(db_path=resolved_path)
|
|
|
|
with sqlite3.connect(resolved_path) as connection:
|
|
connection.row_factory = sqlite3.Row
|
|
rows = connection.execute(
|
|
"""
|
|
SELECT
|
|
target_key,
|
|
event_type,
|
|
COUNT(*) AS event_count,
|
|
MIN(server_time) AS first_server_time,
|
|
MAX(server_time) AS last_server_time
|
|
FROM rcon_admin_log_events
|
|
GROUP BY target_key, event_type
|
|
ORDER BY target_key ASC, event_count DESC
|
|
"""
|
|
).fetchall()
|
|
|
|
return [dict(row) for row in rows]
|
|
|
|
|
|
def list_current_match_kill_feed(
|
|
*,
|
|
server_key: str,
|
|
limit: int = 30,
|
|
since_event_id: str | None = None,
|
|
db_path: Path | None = None,
|
|
now: datetime | None = None,
|
|
) -> dict[str, object]:
|
|
"""Return safe recent kill rows for one AdminLog server window."""
|
|
resolved_path = initialize_rcon_admin_log_storage(db_path=db_path)
|
|
since_row_id = _parse_current_match_event_row_id(since_event_id)
|
|
if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
|
|
from .postgres_rcon_storage import connect_postgres_compat
|
|
|
|
connection_scope = connect_postgres_compat()
|
|
else:
|
|
connection_scope = closing(sqlite3.connect(resolved_path))
|
|
|
|
with connection_scope as connection:
|
|
if isinstance(connection, sqlite3.Connection):
|
|
connection.row_factory = sqlite3.Row
|
|
boundary = connection.execute(
|
|
"""
|
|
SELECT event_type, server_time
|
|
FROM rcon_admin_log_events
|
|
WHERE (target_key = ? OR external_server_id = ?)
|
|
AND event_type IN ('match_start', 'match_end')
|
|
AND server_time IS NOT NULL
|
|
ORDER BY server_time DESC, id DESC
|
|
LIMIT 1
|
|
""",
|
|
(server_key, server_key),
|
|
).fetchone()
|
|
open_start_time = (
|
|
boundary["server_time"]
|
|
if boundary is not None and boundary["event_type"] == "match_start"
|
|
else None
|
|
)
|
|
if open_start_time is None:
|
|
if since_row_id is None:
|
|
rows = connection.execute(
|
|
"""
|
|
SELECT id, target_key, external_server_id, event_timestamp, server_time,
|
|
parsed_payload_json
|
|
FROM rcon_admin_log_events
|
|
WHERE (target_key = ? OR external_server_id = ?)
|
|
AND event_type = 'kill'
|
|
ORDER BY server_time DESC, id DESC
|
|
LIMIT ?
|
|
""",
|
|
(server_key, server_key, limit),
|
|
).fetchall()
|
|
else:
|
|
rows = connection.execute(
|
|
"""
|
|
SELECT id, target_key, external_server_id, event_timestamp, server_time,
|
|
parsed_payload_json
|
|
FROM rcon_admin_log_events
|
|
WHERE (target_key = ? OR external_server_id = ?)
|
|
AND event_type = 'kill'
|
|
AND id > ?
|
|
ORDER BY server_time DESC, id DESC
|
|
LIMIT ?
|
|
""",
|
|
(server_key, server_key, since_row_id, limit),
|
|
).fetchall()
|
|
scope = "recent-admin-log-window"
|
|
confidence = "partial"
|
|
else:
|
|
if since_row_id is None:
|
|
rows = connection.execute(
|
|
"""
|
|
SELECT id, target_key, external_server_id, event_timestamp, server_time,
|
|
parsed_payload_json
|
|
FROM rcon_admin_log_events
|
|
WHERE (target_key = ? OR external_server_id = ?)
|
|
AND event_type = 'kill'
|
|
AND server_time >= ?
|
|
ORDER BY server_time DESC, id DESC
|
|
LIMIT ?
|
|
""",
|
|
(server_key, server_key, open_start_time, limit),
|
|
).fetchall()
|
|
else:
|
|
rows = connection.execute(
|
|
"""
|
|
SELECT id, target_key, external_server_id, event_timestamp, server_time,
|
|
parsed_payload_json
|
|
FROM rcon_admin_log_events
|
|
WHERE (target_key = ? OR external_server_id = ?)
|
|
AND event_type = 'kill'
|
|
AND server_time >= ?
|
|
AND id > ?
|
|
ORDER BY server_time DESC, id DESC
|
|
LIMIT ?
|
|
""",
|
|
(server_key, server_key, open_start_time, since_row_id, limit),
|
|
).fetchall()
|
|
scope = "open-admin-log-match-window"
|
|
confidence = "admin-log-boundary"
|
|
|
|
stale_events_filtered = 0
|
|
if scope == "recent-admin-log-window":
|
|
freshness_anchor = _as_utc_datetime(now) or datetime.now(timezone.utc)
|
|
fresh_rows = [
|
|
row
|
|
for row in rows
|
|
if _row_is_current_match_fallback_fresh(row, freshness_anchor)
|
|
]
|
|
stale_events_filtered = len(rows) - len(fresh_rows)
|
|
rows = fresh_rows
|
|
if not rows:
|
|
scope = "no-current-match-events"
|
|
confidence = "stale-filtered" if stale_events_filtered else "none"
|
|
|
|
return {
|
|
"scope": scope,
|
|
"confidence": confidence,
|
|
"stale_events_filtered": stale_events_filtered,
|
|
"items": [_serialize_kill_feed_row(row) for row in rows],
|
|
}
|
|
|
|
|
|
def list_current_match_player_stats(
|
|
*,
|
|
server_key: str,
|
|
db_path: Path | None = None,
|
|
now: datetime | None = None,
|
|
) -> dict[str, object]:
|
|
"""Return partial current player stats derived from safe AdminLog kill rows."""
|
|
feed = list_current_match_kill_feed(
|
|
server_key=server_key,
|
|
limit=100,
|
|
db_path=db_path,
|
|
now=now,
|
|
)
|
|
players: dict[str, dict[str, object]] = {}
|
|
weapon_counts: dict[str, Counter[str]] = {}
|
|
for item in feed["items"]:
|
|
if not isinstance(item, Mapping):
|
|
continue
|
|
killer = _ensure_current_match_player(
|
|
players,
|
|
item.get("killer_name"),
|
|
team=item.get("killer_team"),
|
|
event_timestamp=item.get("event_timestamp"),
|
|
)
|
|
victim = _ensure_current_match_player(
|
|
players,
|
|
item.get("victim_name"),
|
|
team=item.get("victim_team"),
|
|
event_timestamp=item.get("event_timestamp"),
|
|
)
|
|
if killer is not None:
|
|
weapon = _safe_event_field(item.get("weapon")) or "UNKNOWN"
|
|
weapon_counts.setdefault(str(killer["player_name"]), Counter())[weapon] += 1
|
|
if item.get("is_teamkill"):
|
|
killer["teamkills"] = int(killer["teamkills"]) + 1
|
|
else:
|
|
killer["kills"] = int(killer["kills"]) + 1
|
|
if victim is not None:
|
|
victim["deaths"] = int(victim["deaths"]) + 1
|
|
if item.get("is_teamkill"):
|
|
victim["deaths_by_teamkill"] = int(victim["deaths_by_teamkill"]) + 1
|
|
|
|
items = []
|
|
for player in players.values():
|
|
items.append(
|
|
{
|
|
**player,
|
|
"favorite_weapon": _favorite_weapon_for_player(
|
|
weapon_counts.get(str(player["player_name"]))
|
|
),
|
|
"source": "rcon-admin-log-kill-events",
|
|
"confidence": "event-derived-partial",
|
|
}
|
|
)
|
|
items.sort(
|
|
key=lambda player: (
|
|
-int(player["kills"]),
|
|
int(player["deaths"]),
|
|
str(player["player_name"]).casefold(),
|
|
)
|
|
)
|
|
return {
|
|
"scope": feed["scope"],
|
|
"confidence": "event-derived-partial" if items else feed["confidence"],
|
|
"source": "rcon-admin-log-kill-events",
|
|
"updated_at": max(
|
|
(str(item["last_seen_at"]) for item in items if item.get("last_seen_at")),
|
|
default=None,
|
|
),
|
|
"stale_events_filtered": feed["stale_events_filtered"],
|
|
"items": items,
|
|
}
|
|
|
|
|
|
def get_latest_rcon_player_profile_summaries(
|
|
*,
|
|
target_key: str,
|
|
player_ids: list[str],
|
|
db_path: Path | None = None,
|
|
) -> dict[str, dict[str, object]]:
|
|
"""Return safe latest profile summaries keyed by player id."""
|
|
requested_ids = [str(player_id).strip() for player_id in player_ids if str(player_id).strip()]
|
|
if not target_key or not requested_ids:
|
|
return {}
|
|
if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
|
|
from .postgres_rcon_storage import connect_postgres_compat
|
|
|
|
placeholders = ",".join("?" for _ in requested_ids)
|
|
with connect_postgres_compat() as connection:
|
|
rows = connection.execute(
|
|
f"""
|
|
SELECT snapshots.*
|
|
FROM rcon_player_profile_snapshots AS snapshots
|
|
INNER JOIN (
|
|
SELECT player_id, MAX(source_server_time) AS latest_source_server_time
|
|
FROM rcon_player_profile_snapshots
|
|
WHERE target_key = ?
|
|
AND player_id IN ({placeholders})
|
|
GROUP BY player_id
|
|
) AS latest
|
|
ON latest.player_id = snapshots.player_id
|
|
AND latest.latest_source_server_time = snapshots.source_server_time
|
|
WHERE snapshots.target_key = ?
|
|
""",
|
|
[target_key, *requested_ids, target_key],
|
|
).fetchall()
|
|
return {str(row["player_id"]): _build_safe_profile_summary(row) for row in rows}
|
|
|
|
resolved_path = db_path or get_storage_path()
|
|
initialize_rcon_admin_log_storage(db_path=resolved_path)
|
|
placeholders = ",".join("?" for _ in requested_ids)
|
|
with sqlite3.connect(resolved_path) as connection:
|
|
connection.row_factory = sqlite3.Row
|
|
rows = connection.execute(
|
|
f"""
|
|
SELECT snapshots.*
|
|
FROM rcon_player_profile_snapshots AS snapshots
|
|
INNER JOIN (
|
|
SELECT player_id, MAX(source_server_time) AS latest_source_server_time
|
|
FROM rcon_player_profile_snapshots
|
|
WHERE target_key = ?
|
|
AND player_id IN ({placeholders})
|
|
GROUP BY player_id
|
|
) AS latest
|
|
ON latest.player_id = snapshots.player_id
|
|
AND latest.latest_source_server_time = snapshots.source_server_time
|
|
WHERE snapshots.target_key = ?
|
|
""",
|
|
[target_key, *requested_ids, target_key],
|
|
).fetchall()
|
|
|
|
return {str(row["player_id"]): _build_safe_profile_summary(row) for row in rows}
|
|
|
|
|
|
def _build_safe_profile_summary(row: sqlite3.Row) -> dict[str, object]:
|
|
return {
|
|
"player_name": row["player_name"],
|
|
"source_server_time": row["source_server_time"],
|
|
"event_timestamp": row["event_timestamp"],
|
|
"first_seen": row["first_seen"],
|
|
"sessions": row["sessions"],
|
|
"matches_played": row["matches_played"],
|
|
"play_time": row["play_time"],
|
|
"totals": {
|
|
"kills": row["total_kills"],
|
|
"deaths": row["total_deaths"],
|
|
"teamkills_done": row["teamkills_done"],
|
|
"teamkills_received": row["teamkills_received"],
|
|
"kd_ratio": row["kd_ratio"],
|
|
},
|
|
"favorite_weapons": _json_mapping(row["favorite_weapons_json"]),
|
|
"victims": _json_mapping(row["victims_json"]),
|
|
"nemesis": _json_mapping(row["nemesis_json"]),
|
|
"averages": _json_mapping(row["averages_json"]),
|
|
"sanctions": _json_mapping(row["sanctions_json"]),
|
|
}
|
|
|
|
|
|
def _json_mapping(raw_value: object) -> dict[str, object]:
|
|
if not isinstance(raw_value, str) or not raw_value.strip():
|
|
return {}
|
|
try:
|
|
parsed = json.loads(raw_value)
|
|
except json.JSONDecodeError:
|
|
return {}
|
|
return parsed if isinstance(parsed, dict) else {}
|
|
|
|
|
|
def _serialize_kill_feed_row(row: Mapping[str, object]) -> dict[str, object]:
|
|
payload = _json_mapping(row["parsed_payload_json"])
|
|
target_key = str(row["external_server_id"] or row["target_key"] or "unknown")
|
|
killer_team = _safe_event_field(payload.get("killer_team"))
|
|
victim_team = _safe_event_field(payload.get("victim_team"))
|
|
return {
|
|
"event_id": f"rcon-admin-log:{target_key}:{row['id']}",
|
|
"event_timestamp": row["event_timestamp"],
|
|
"server_time": row["server_time"],
|
|
"killer_name": _safe_event_field(payload.get("killer_name")),
|
|
"killer_team": killer_team,
|
|
"victim_name": _safe_event_field(payload.get("victim_name")),
|
|
"victim_team": victim_team,
|
|
"weapon": _safe_event_field(payload.get("weapon")),
|
|
"is_teamkill": bool(
|
|
killer_team
|
|
and killer_team != "None"
|
|
and killer_team == victim_team
|
|
),
|
|
}
|
|
|
|
|
|
def _parse_current_match_event_row_id(value: object) -> int | None:
|
|
prefix, separator, row_id = str(value or "").rpartition(":")
|
|
if separator != ":" or not prefix.startswith("rcon-admin-log:"):
|
|
return None
|
|
try:
|
|
parsed = int(row_id)
|
|
except ValueError:
|
|
return None
|
|
return parsed if parsed > 0 else None
|
|
|
|
|
|
def _safe_event_field(value: object) -> str | None:
|
|
normalized = str(value or "").strip()
|
|
return normalized or None
|
|
|
|
|
|
def _ensure_current_match_player(
|
|
players: dict[str, dict[str, object]],
|
|
player_name: object,
|
|
*,
|
|
team: object,
|
|
event_timestamp: object,
|
|
) -> dict[str, object] | None:
|
|
safe_name = _safe_event_field(player_name)
|
|
if safe_name is None:
|
|
return None
|
|
player = players.setdefault(
|
|
safe_name,
|
|
{
|
|
"player_name": safe_name,
|
|
"team": None,
|
|
"kills": 0,
|
|
"deaths": 0,
|
|
"teamkills": 0,
|
|
"deaths_by_teamkill": 0,
|
|
"last_seen_at": None,
|
|
},
|
|
)
|
|
safe_team = _safe_event_field(team)
|
|
if safe_team:
|
|
player["team"] = safe_team
|
|
safe_timestamp = _safe_event_field(event_timestamp)
|
|
if safe_timestamp and (
|
|
player["last_seen_at"] is None or safe_timestamp > str(player["last_seen_at"])
|
|
):
|
|
player["last_seen_at"] = safe_timestamp
|
|
return player
|
|
|
|
|
|
def _favorite_weapon_for_player(weapons: Counter[str] | None) -> str | None:
|
|
if not weapons:
|
|
return None
|
|
return min(weapons.items(), key=lambda item: (-item[1], item[0]))[0]
|
|
|
|
|
|
def _row_is_current_match_fallback_fresh(
|
|
row: Mapping[str, object],
|
|
freshness_anchor: datetime,
|
|
) -> bool:
|
|
event_time = _as_utc_datetime(row["event_timestamp"])
|
|
if event_time is None:
|
|
return False
|
|
age = freshness_anchor - event_time
|
|
return timedelta(0) <= age <= CURRENT_MATCH_FALLBACK_FRESHNESS
|
|
|
|
|
|
def _as_utc_datetime(value: object) -> datetime | None:
|
|
if isinstance(value, datetime):
|
|
parsed = value
|
|
elif isinstance(value, str) and value.strip():
|
|
try:
|
|
parsed = datetime.fromisoformat(value.strip().replace("Z", "+00:00"))
|
|
except ValueError:
|
|
return None
|
|
else:
|
|
return None
|
|
if parsed.tzinfo is None:
|
|
return parsed.replace(tzinfo=timezone.utc)
|
|
return parsed.astimezone(timezone.utc)
|
|
|
|
|
|
def _persist_rcon_admin_log_entries_postgres(
|
|
*,
|
|
target: Mapping[str, object],
|
|
entries: list[dict[str, object]],
|
|
) -> dict[str, int]:
|
|
from .postgres_rcon_storage import connect_postgres_compat
|
|
|
|
target_key = str(target.get("target_key") or target.get("external_server_id") or "")
|
|
if not target_key:
|
|
raise ValueError("target must include target_key or external_server_id")
|
|
|
|
external_server_id = target.get("external_server_id")
|
|
inserted = 0
|
|
duplicates = 0
|
|
with connect_postgres_compat() as connection:
|
|
for entry in entries:
|
|
parsed = parse_rcon_admin_log_entry(entry)
|
|
raw_message = str(parsed.get("raw_message") or "")
|
|
canonical_message = _canonicalize_admin_log_message(raw_message)
|
|
cursor = connection.execute(
|
|
"""
|
|
INSERT INTO rcon_admin_log_events (
|
|
target_key,
|
|
external_server_id,
|
|
event_timestamp,
|
|
server_time,
|
|
relative_time,
|
|
event_type,
|
|
raw_message,
|
|
canonical_message,
|
|
parsed_payload_json,
|
|
raw_entry_json
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT DO NOTHING
|
|
""",
|
|
(
|
|
target_key,
|
|
external_server_id,
|
|
parsed.get("timestamp"),
|
|
parsed.get("server_time"),
|
|
parsed.get("relative_time"),
|
|
parsed.get("event_type") or "unknown",
|
|
raw_message,
|
|
canonical_message,
|
|
json.dumps(parsed, ensure_ascii=False, separators=(",", ":")),
|
|
json.dumps(entry, ensure_ascii=False, separators=(",", ":")),
|
|
),
|
|
)
|
|
if int(cursor.rowcount or 0):
|
|
inserted += 1
|
|
else:
|
|
duplicates += 1
|
|
_persist_profile_snapshot_if_present(
|
|
connection,
|
|
target_key=target_key,
|
|
external_server_id=external_server_id,
|
|
parsed=parsed,
|
|
)
|
|
return {
|
|
"events_seen": len(entries),
|
|
"events_inserted": inserted,
|
|
"duplicate_events": duplicates,
|
|
}
|