Files
universal-web-api/app/utils/site_rules.py
T
2026-11-02 22:54:14 +08:00

185 lines
5.1 KiB
Python

"""
Site-level rule loading shared by routing, startup pages, and defaults.
"""
from __future__ import annotations
import copy
import json
import os
from pathlib import Path
from typing import Any, Dict, List, Tuple
_PROJECT_ROOT = Path(__file__).resolve().parents[2]
_SITE_RULES_FILE = Path(
os.getenv("SITE_RULES_FILE", str(_PROJECT_ROOT / "config" / "site_rules.json"))
)
_SITES_LOCAL_FILE = Path(
os.getenv("SITES_LOCAL_FILE", str(_PROJECT_ROOT / "config" / "sites.local.json"))
)
_IGNORED_SITE_ID_PARTS = {
"",
"www",
"chat",
"web",
"app",
"api",
"beta",
"console",
"new",
}
_SITE_RULES_CACHE: Dict[str, Any] = {
"signature": None,
"rules": {},
}
def _normalize_domain(value: Any) -> str:
return str(value or "").strip().lower().strip(".")
def _normalize_rule(rule: Any) -> Dict[str, Any]:
if not isinstance(rule, dict):
return {}
normalized: Dict[str, Any] = {}
display_name = str(rule.get("display_name") or "").strip()
if display_name:
normalized["display_name"] = display_name
startup_url = str(rule.get("startup_url") or "").strip()
if startup_url:
normalized["startup_url"] = startup_url
card_id = str(rule.get("card_id") or "").strip()
if card_id:
normalized["card_id"] = card_id
guide_priority = rule.get("guide_priority", None)
if isinstance(guide_priority, (int, float)) and not isinstance(guide_priority, bool):
normalized["guide_priority"] = int(guide_priority)
if isinstance(rule.get("auto_discovery"), bool):
normalized["auto_discovery"] = rule["auto_discovery"]
if "stealth_default" in rule:
normalized["stealth_default"] = bool(rule.get("stealth_default"))
route_aliases = rule.get("route_aliases", [])
if isinstance(route_aliases, list):
aliases: List[str] = []
seen = set()
for raw_alias in route_aliases:
alias = _normalize_domain(raw_alias)
if not alias or alias in seen:
continue
seen.add(alias)
aliases.append(alias)
normalized["route_aliases"] = aliases
return normalized
def _read_json_file(path: Path) -> Dict[str, Any]:
if not path.exists():
return {}
try:
with open(path, "r", encoding="utf-8-sig") as handle:
data = json.load(handle)
return data if isinstance(data, dict) else {}
except Exception:
return {}
def _build_cache_signature() -> Tuple[Tuple[str, float], ...]:
signature: List[Tuple[str, float]] = []
for path in (_SITE_RULES_FILE, _SITES_LOCAL_FILE):
try:
mtime = path.stat().st_mtime if path.exists() else 0.0
except Exception:
mtime = 0.0
signature.append((str(path), float(mtime)))
return tuple(signature)
def _load_rules_from_files() -> Dict[str, Dict[str, Any]]:
shipped = _read_json_file(_SITE_RULES_FILE).get("sites", {})
local = _read_json_file(_SITES_LOCAL_FILE).get("site_overrides", {})
merged: Dict[str, Dict[str, Any]] = {}
for source in (shipped, local):
if not isinstance(source, dict):
continue
for raw_domain, raw_rule in source.items():
domain = _normalize_domain(raw_domain)
if not domain:
continue
current = merged.setdefault(domain, {})
current.update(_normalize_rule(raw_rule))
return merged
def load_site_rules(force: bool = False) -> Dict[str, Dict[str, Any]]:
signature = _build_cache_signature()
if not force and _SITE_RULES_CACHE.get("signature") == signature:
return copy.deepcopy(_SITE_RULES_CACHE.get("rules", {}))
rules = _load_rules_from_files()
_SITE_RULES_CACHE["signature"] = signature
_SITE_RULES_CACHE["rules"] = rules
return copy.deepcopy(rules)
def get_site_rule(domain: str) -> Dict[str, Any]:
normalized = _normalize_domain(domain)
if not normalized:
return {}
return load_site_rules().get(normalized, {})
def build_route_alias_groups() -> Tuple[Tuple[str, ...], ...]:
groups: List[Tuple[str, ...]] = []
for domain, rule in load_site_rules().items():
ordered: List[str] = []
seen = set()
for item in list(rule.get("route_aliases", []) or []) + [domain]:
alias = _normalize_domain(item)
if not alias or alias in seen:
continue
seen.add(alias)
ordered.append(alias)
if len(ordered) >= 2:
groups.append(tuple(ordered))
return tuple(groups)
def derive_site_card_id(domain: str) -> str:
normalized = _normalize_domain(domain)
if not normalized:
return ""
rule = get_site_rule(normalized)
explicit = str(rule.get("card_id") or "").strip()
if explicit:
return explicit
parts = [part for part in normalized.split(".")[:-1] if part not in _IGNORED_SITE_ID_PARTS]
if parts:
return parts[0]
return normalized.split(".", 1)[0]
__all__ = [
"build_route_alias_groups",
"derive_site_card_id",
"get_site_rule",
"load_site_rules",
]