Overwrite Space with local hengdian app

.dockerignore

@@ -0,0 +1,20 @@
+.git
+.gitignore
+.DS_Store
+__pycache__/
+*.py[cod]
+
+.env
+.env.*
+.streamlit/secrets.toml
+.claude/
+**/.claude/
+
+.venv/
+venv/
+cinema_cache/
+token_data.json
+
+test/
+tests/
+API-test/

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.xlsx filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,20 @@
+.DS_Store
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+
+.env
+.env.*
+!.env.example
+.streamlit/secrets.toml
+.claude/
+**/.claude/
+
+cinema_cache/
+!cinema_cache/.gitkeep
+token_data.json
+
+test/
+tests/
+API-test/

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    STREAMLIT_SERVER_HEADLESS=true \
+    STREAMLIT_BROWSER_GATHER_USAGE_STATS=false \
+    PORT=7860
+
+WORKDIR /app
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        chromium \
+        fontconfig \
+        fonts-noto-cjk \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --upgrade pip \
+    && pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD streamlit run app.py --server.address=0.0.0.0 --server.port=${PORT}

README.md

@@ -0,0 +1,13 @@
+---
+title: 影城工作便捷工具
+emoji: 🔧
+colorFrom: pink
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# 影城工作便捷工具
+
+Streamlit app packaged as a Docker Space.

cinema_api_client.py

@@ -0,0 +1,373 @@
+import json
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import requests
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+ROOT_DIR = Path(__file__).resolve().parent
+TOKEN_FILE = ROOT_DIR / "token_data.json"
+CINEMA_ID = os.getenv("CINEMA_ID")
+SCHEDULE_API_TIMEOUT_SECONDS = 30
+SCHEDULE_API_RETRY_ATTEMPTS = 2
+API_BASE_URL = "https://cawapi.yinghezhong.com"
+COMMON_HEADERS = {
+    "Host": "cawapi.yinghezhong.com",
+    "Accept": "*/*",
+    "Origin": "https://caw.yinghezhong.com",
+    "Connection": "keep-alive",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "same-site",
+    "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+    "Referer": "https://caw.yinghezhong.com/",
+    "Sec-Fetch-Dest": "empty",
+    "Accept-Language": "zh-CN,zh-Hans;q=0.9",
+}
+
+
+class RetryableAPIError(RuntimeError):
+    """适合重试的接口异常。"""
+
+
+def load_token() -> Optional[dict]:
+    if not TOKEN_FILE.exists():
+        return None
+    try:
+        return json.loads(TOKEN_FILE.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def save_token(token_data: dict) -> bool:
+    try:
+        TOKEN_FILE.write_text(json.dumps(token_data, ensure_ascii=False, indent=2), encoding="utf-8")
+        return True
+    except OSError:
+        return False
+
+
+def login_and_get_token() -> dict:
+    username = os.getenv("CINEMA_USERNAME")
+    password = os.getenv("CINEMA_PASSWORD")
+    res_code = os.getenv("CINEMA_RES_CODE")
+    device_id = os.getenv("CINEMA_DEVICE_ID")
+
+    if not all([username, password, res_code]):
+        raise RuntimeError("未配置 CINEMA_USERNAME / CINEMA_PASSWORD / CINEMA_RES_CODE。")
+
+    session = requests.Session()
+    session.headers.update(
+        {
+            "Host": "app.bi.piao51.cn",
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+        }
+    )
+
+    login_url = "https://app.bi.piao51.cn/cinema-app/credential/login.action"
+    login_headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "Origin": "https://app.bi.piao51.cn",
+    }
+    login_data = {
+        "username": username,
+        "password": password,
+        "type": "1",
+        "resCode": res_code,
+        "deviceid": device_id,
+        "dtype": "ios",
+    }
+
+    try:
+        response_login = session.post(
+            login_url,
+            headers=login_headers,
+            data=login_data,
+            allow_redirects=False,
+            timeout=15,
+        )
+        if not (300 <= response_login.status_code < 400 and "token" in session.cookies):
+            raise RetryableAPIError(f"票务登录失败，状态码：{response_login.status_code}")
+
+        user_info_url = "https://app.bi.piao51.cn/cinema-app/security/logined.action"
+        response_user_info = session.get(user_info_url, timeout=10)
+        response_user_info.raise_for_status()
+        user_info = response_user_info.json()
+
+        if user_info.get("success") and user_info.get("data", {}).get("token"):
+            token_data = user_info["data"]
+            save_token(token_data)
+            return token_data
+        raise RetryableAPIError(f"票务登录未获取到 Token：{user_info.get('msg')}")
+    except RetryableAPIError:
+        raise
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"票务登录接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"票务登录处理异常：{exc}") from exc
+
+
+def get_valid_cinema_token() -> str:
+    token_data = load_token()
+    token = token_data.get("token") if token_data else None
+    if token:
+        return token
+    token_data = login_and_get_token()
+    token = token_data.get("token") if token_data else None
+    if not token:
+        raise RetryableAPIError("未获取到票务 Token。")
+    return token
+
+
+def fetch_hall_info(token: str) -> Dict[str, int]:
+    url = "https://cawapi.yinghezhong.com/showInfo/getShowHallInfo"
+    params = {"token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        response.raise_for_status()
+        payload = response.json()
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"获取影厅信息接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"获取影厅信息处理异常：{exc}") from exc
+
+    if payload.get("code") == 1 and payload.get("data") is not None:
+        return {str(item["hallId"]): int(item.get("seatNum") or 0) for item in payload["data"]}
+    if payload.get("code") == 500:
+        raise ValueError("Token 可能已失效")
+    raise RetryableAPIError(f"获取影厅信息失败：{payload.get('msg', '未知错误')}")
+
+
+def fetch_schedule_data(token: str, show_date: str) -> List[dict]:
+    url = "https://cawapi.yinghezhong.com/showInfo/getHallShowInfo"
+    params = {"showDate": show_date, "token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+    last_request_error = None
+
+    for attempt in range(1, SCHEDULE_API_RETRY_ATTEMPTS + 1):
+        try:
+            response = requests.get(
+                url,
+                params=params,
+                headers=headers,
+                timeout=SCHEDULE_API_TIMEOUT_SECONDS,
+            )
+            response.raise_for_status()
+            payload = response.json()
+        except requests.exceptions.RequestException as exc:
+            last_request_error = exc
+            if attempt < SCHEDULE_API_RETRY_ATTEMPTS:
+                time.sleep(2)
+                continue
+            raise RetryableAPIError(f"获取 {show_date} 排片接口异常：{exc}") from exc
+        except Exception as exc:
+            raise RetryableAPIError(f"获取 {show_date} 排片处理异常：{exc}") from exc
+
+        if payload.get("code") == 1:
+            return payload.get("data", [])
+        if payload.get("code") == 500:
+            raise ValueError("Token 可能已失效")
+        if attempt < SCHEDULE_API_RETRY_ATTEMPTS:
+            time.sleep(2)
+            continue
+        raise RetryableAPIError(f"获取 {show_date} 排片失败：{payload.get('msg', '未知错误')}")
+
+    raise RetryableAPIError(f"获取 {show_date} 排片接口异常：{last_request_error}")
+
+
+def fetch_schedule_data_by_cinema(token: str, cinema_id: str, show_date: str) -> List[dict]:
+    cinema_id = str(cinema_id or "").strip()
+    self_cinema_id = (CINEMA_ID or "").strip()
+    if self_cinema_id and cinema_id == self_cinema_id:
+        return fetch_schedule_data(token, show_date)
+
+    url = f"{API_BASE_URL}/competition/play/showInfoList"
+    params = {
+        "date": datetime.strptime(show_date, "%Y-%m-%d").strftime("%Y/%m/%d"),
+        "cinemaNum": cinema_id,
+        "token": token,
+        "_": str(int(time.time() * 1000)),
+    }
+    last_request_error = None
+
+    for attempt in range(1, SCHEDULE_API_RETRY_ATTEMPTS + 1):
+        try:
+            response = requests.get(
+                url,
+                params=params,
+                headers=COMMON_HEADERS,
+                timeout=SCHEDULE_API_TIMEOUT_SECONDS,
+            )
+            response.raise_for_status()
+            payload = response.json()
+        except requests.exceptions.RequestException as exc:
+            last_request_error = exc
+            if attempt < SCHEDULE_API_RETRY_ATTEMPTS:
+                time.sleep(2)
+                continue
+            raise RetryableAPIError(f"获取影院 {cinema_id} 在 {show_date} 的竞对排片接口异常：{exc}") from exc
+        except Exception as exc:
+            raise RetryableAPIError(f"获取影院 {cinema_id} 在 {show_date} 的竞对排片处理异常：{exc}") from exc
+
+        if payload.get("code") == 1:
+            return payload.get("data", []) or []
+        if payload.get("code") == 500:
+            raise ValueError("Token 可能已失效")
+        if attempt < SCHEDULE_API_RETRY_ATTEMPTS:
+            time.sleep(2)
+            continue
+        raise RetryableAPIError(
+            f"获取影院 {cinema_id} 在 {show_date} 的竞对排片失败：{payload.get('msg', '未知错误')}"
+        )
+
+    raise RetryableAPIError(f"获取影院 {cinema_id} 在 {show_date} 的竞对排片接口异常：{last_request_error}")
+
+
+def fetch_available_movie_info(token: str, show_date: str) -> List[dict]:
+    url = "https://cawapi.yinghezhong.com/show/getMovieInfo"
+    params = {
+        "showDate": show_date,
+        "token": token,
+        "_": int(time.time() * 1000),
+    }
+    headers = {
+        "Origin": "https://caw.yinghezhong.com",
+        "Referer": "https://caw.yinghezhong.com/",
+        "User-Agent": "Mozilla/5.0",
+    }
+
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=15)
+        response.raise_for_status()
+        payload = response.json()
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"获取可排片池接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"获取可排片池处理异常：{exc}") from exc
+
+    if payload.get("code") == 1:
+        return payload.get("data", [])
+    if payload.get("code") == 500:
+        raise ValueError("Token 可能已失效")
+    raise RetryableAPIError(f"获取可排片池失败：{payload.get('msg', '未知错误')}")
+
+
+def fetch_realtime_box_office(token: str, date_str: str) -> dict:
+    url = "https://app.bi.piao51.cn/cinema-app/market/realtimeDailyBoxOffice.action"
+    params = {
+        "qTime": date_str,
+        "token": token,
+    }
+    headers = {
+        "Host": "app.bi.piao51.cn",
+        "X-Requested-With": "XMLHttpRequest",
+        "jwt": "0",
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+    }
+
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=15)
+        response.raise_for_status()
+        payload = response.json()
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"获取 {date_str} 全国大盘接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"获取 {date_str} 全国大盘处理异常：{exc}") from exc
+
+    if payload.get("code") == "A00000":
+        return payload.get("results", {}) or {}
+    if "login" in response.text or payload.get("code") in {500, "500"}:
+        raise ValueError("Token 可能已失效")
+    raise RetryableAPIError(f"获取 {date_str} 全国大盘失败：{payload.get('msg', '未知错误')}")
+
+
+def fetch_canonical_movie_names(token: str, date_str: str) -> List[str]:
+    if not CINEMA_ID:
+        return []
+
+    url = "https://app.bi.piao51.cn/cinema-app/mycinema/movieSellGross.action"
+    params = {
+        "token": token,
+        "startDate": date_str,
+        "endDate": date_str,
+        "dateType": "day",
+        "cinemaId": CINEMA_ID,
+    }
+    headers = {
+        "Host": "app.bi.piao51.cn",
+        "X-Requested-With": "XMLHttpRequest",
+        "jwt": "0",
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+    }
+
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        if data.get("code") == "A00000" and data.get("results"):
+            return [item["movieName"] for item in data["results"] if item.get("movieName") and item["movieName"] != "总计"]
+    except Exception:
+        return []
+    return []
+
+
+def get_schedule_and_hall_info(show_date: str) -> Tuple[List[dict], Dict[str, int], str]:
+    token = get_valid_cinema_token()
+    try:
+        schedule = fetch_schedule_data(token, show_date)
+        hall_map = fetch_hall_info(token)
+        return schedule, hall_map, token
+    except ValueError:
+        token_data = login_and_get_token()
+        token = token_data.get("token") if token_data else None
+        if not token:
+            raise RetryableAPIError("重新登录后仍未获取到票务 Token。")
+        schedule = fetch_schedule_data(token, show_date)
+        hall_map = fetch_hall_info(token)
+        return schedule, hall_map, token
+
+
+def get_schedule_by_cinema_with_token_management(cinema_id: str, show_date: str) -> Tuple[List[dict], str]:
+    token = get_valid_cinema_token()
+    try:
+        return fetch_schedule_data_by_cinema(token, cinema_id, show_date), token
+    except ValueError:
+        token_data = login_and_get_token()
+        token = token_data.get("token") if token_data else None
+        if not token:
+            raise RetryableAPIError("重新登录后仍未获取到票务 Token。")
+        return fetch_schedule_data_by_cinema(token, cinema_id, show_date), token
+
+
+def get_available_movies_with_token_management(show_date: str) -> Tuple[List[dict], str]:
+    token = get_valid_cinema_token()
+    try:
+        return fetch_available_movie_info(token, show_date), token
+    except ValueError:
+        token_data = login_and_get_token()
+        token = token_data.get("token") if token_data else None
+        if not token:
+            raise RetryableAPIError("重新登录后仍未获取到票务 Token。")
+        return fetch_available_movie_info(token, show_date), token
+
+
+def get_realtime_box_office_with_token_management(date_str: str) -> Tuple[dict, str]:
+    token = get_valid_cinema_token()
+    try:
+        return fetch_realtime_box_office(token, date_str), token
+    except ValueError:
+        token_data = login_and_get_token()
+        token = token_data.get("token") if token_data else None
+        if not token:
+            raise RetryableAPIError("重新登录后仍未获取到票务 Token。")
+        return fetch_realtime_box_office(token, date_str), token

data/efficiency_at_each_time_point.json

@@ -0,0 +1,169 @@
+{
+  "09:45": 0.894733,
+  "09:50": 0.524336,
+  "09:55": 0.398518,
+  "10:00": 0.436228,
+  "10:05": 0.326204,
+  "10:10": 0.400775,
+  "10:15": 0.368501,
+  "10:20": 0.378284,
+  "10:25": 0.341553,
+  "10:30": 0.520815,
+  "10:35": 0.3353,
+  "10:40": 0.377738,
+  "10:45": 0.374873,
+  "10:50": 0.36036,
+  "10:55": 0.305426,
+  "11:00": 0.358998,
+  "11:05": 0.301232,
+  "11:10": 0.348796,
+  "11:15": 0.426774,
+  "11:20": 0.338455,
+  "11:25": 0.31732,
+  "11:30": 0.399561,
+  "11:35": 0.313701,
+  "11:40": 0.367346,
+  "11:45": 0.305961,
+  "11:50": 0.336273,
+  "11:55": 0.227869,
+  "12:00": 0.396251,
+  "12:05": 0.292967,
+  "12:10": 0.340811,
+  "12:15": 0.338903,
+  "12:20": 0.359726,
+  "12:25": 0.334413,
+  "12:30": 0.552494,
+  "12:35": 0.343258,
+  "12:40": 0.438833,
+  "12:45": 0.398147,
+  "12:50": 0.425803,
+  "12:55": 0.4308,
+  "13:00": 0.639481,
+  "13:05": 0.43584,
+  "13:10": 0.585951,
+  "13:15": 0.607589,
+  "13:20": 0.814758,
+  "13:25": 0.622502,
+  "13:30": 0.939956,
+  "13:35": 0.655399,
+  "13:40": 0.753667,
+  "13:45": 0.697589,
+  "13:50": 0.925888,
+  "13:55": 0.825692,
+  "14:00": 1.112837,
+  "14:05": 0.939885,
+  "14:10": 1.139797,
+  "14:15": 1.15655,
+  "14:20": 1.201916,
+  "14:25": 1.093155,
+  "14:30": 1.337946,
+  "14:35": 1.014206,
+  "14:40": 1.322562,
+  "14:45": 1.119861,
+  "14:50": 1.205953,
+  "14:55": 1.076064,
+  "15:00": 1.436359,
+  "15:05": 1.167116,
+  "15:10": 1.258112,
+  "15:15": 1.282796,
+  "15:20": 1.180998,
+  "15:25": 1.099845,
+  "15:30": 1.264543,
+  "15:35": 1.176416,
+  "15:40": 1.1762,
+  "15:45": 1.103772,
+  "15:50": 1.047339,
+  "15:55": 0.959803,
+  "16:00": 0.898111,
+  "16:05": 0.822474,
+  "16:10": 0.928322,
+  "16:15": 0.879823,
+  "16:20": 0.862768,
+  "16:25": 0.731169,
+  "16:30": 0.837509,
+  "16:35": 0.8335,
+  "16:40": 0.893883,
+  "16:45": 0.789401,
+  "16:50": 0.705589,
+  "16:55": 0.645867,
+  "17:00": 0.553473,
+  "17:05": 0.632969,
+  "17:10": 0.669639,
+  "17:15": 0.53453,
+  "17:20": 0.626554,
+  "17:25": 0.542131,
+  "17:30": 0.621175,
+  "17:35": 0.528622,
+  "17:40": 0.497968,
+  "17:45": 0.486565,
+  "17:50": 0.652411,
+  "17:55": 0.345271,
+  "18:00": 0.613171,
+  "18:05": 0.653778,
+  "18:10": 0.604403,
+  "18:15": 0.645896,
+  "18:20": 0.656057,
+  "18:25": 0.616838,
+  "18:30": 0.705481,
+  "18:35": 0.836565,
+  "18:40": 0.861882,
+  "18:45": 0.759541,
+  "18:50": 0.740935,
+  "18:55": 0.790371,
+  "19:00": 1.360146,
+  "19:05": 1.104657,
+  "19:10": 1.332044,
+  "19:15": 1.41697,
+  "19:20": 1.383817,
+  "19:25": 1.354397,
+  "19:30": 1.859736,
+  "19:35": 1.500996,
+  "19:40": 1.61648,
+  "19:45": 1.383858,
+  "19:50": 1.519501,
+  "19:55": 1.730771,
+  "20:00": 2.510784,
+  "20:05": 1.51142,
+  "20:10": 2.019814,
+  "20:15": 1.954568,
+  "20:20": 2.177169,
+  "20:25": 2.067442,
+  "20:30": 2.53507,
+  "20:35": 1.94052,
+  "20:40": 2.593103,
+  "20:45": 2.222822,
+  "20:50": 2.369975,
+  "20:55": 2.626353,
+  "21:00": 1.893128,
+  "21:05": 1.755495,
+  "21:10": 2.216455,
+  "21:15": 1.558653,
+  "21:20": 2.00998,
+  "21:25": 1.510278,
+  "21:30": 1.903993,
+  "21:35": 1.659127,
+  "21:40": 1.622959,
+  "21:45": 1.544068,
+  "21:50": 1.666697,
+  "21:55": 1.452239,
+  "22:00": 1.053099,
+  "22:05": 0.926646,
+  "22:10": 1.147177,
+  "22:15": 1.007091,
+  "22:20": 1.217177,
+  "22:25": 1.013732,
+  "22:30": 0.934037,
+  "22:35": 0.846258,
+  "22:40": 1.009769,
+  "22:45": 0.935017,
+  "22:50": 1.022347,
+  "22:55": 0.898928,
+  "23:00": 0.712869,
+  "23:05": 0.56042,
+  "23:10": 0.758855,
+  "23:15": 0.876,
+  "23:20": 0.747069,
+  "23:25": 0.929663,
+  "23:30": 0.828234,
+  "23:35": 0.641205
+}

gantt_export.py

@@ -0,0 +1,118 @@
+"""
+将甘特图完整 HTML 文档渲染为 PNG（headless Chrome），再转 JPG，并写入本地缓存目录供下载。
+依赖：html2image（需本机已安装 Chrome/Chromium）、Pillow。
+"""
+import io
+import os
+from datetime import datetime
+from typing import Optional, Tuple
+
+
+def _build_export_html(html_document: str) -> str:
+    """注入导出专用样式：关闭滚动裁切，避免截图只保留可视区域。"""
+    export_css = """
+<style>
+html, body {
+    margin: 0 !important;
+    padding: 0 !important;
+    background: #fff !important;
+    width: max-content !important;
+    display: inline-block !important;
+}
+.scroll-wrapper { overflow: visible !important; width: max-content !important; }
+.schedule-container { width: max-content !important; }
+</style>
+"""
+    if "</head>" in html_document:
+        return html_document.replace("</head>", f"{export_css}\n</head>", 1)
+    return f"{export_css}\n{html_document}"
+
+
+def _trim_png_whitespace(png_bytes: bytes, threshold: int = 250, padding: int = 8) -> bytes:
+    """裁切四周近白空白区域，让图像内容尽量铺满画面。"""
+    from PIL import Image
+
+    im = Image.open(io.BytesIO(png_bytes)).convert("RGB")
+    gray = im.convert("L")
+    mask = gray.point(lambda x: 255 if x < threshold else 0)
+    bbox = mask.getbbox()
+    if not bbox:
+        return png_bytes
+
+    left, top, right, bottom = bbox
+    left = max(0, left - padding)
+    top = max(0, top - padding)
+    right = min(im.width, right + padding)
+    bottom = min(im.height, bottom + padding)
+
+    cropped = im.crop((left, top, right, bottom))
+    out = io.BytesIO()
+    cropped.save(out, format="PNG", optimize=True)
+    return out.getvalue()
+
+
+def html_document_to_png_bytes(html_document: str, width: int = 1680, height: int = 5000) -> bytes:
+    """使用 html2image 将完整 HTML 页面渲染为高分辨率 PNG 字节。"""
+    import tempfile
+
+    from html2image import Html2Image
+
+    prepared_html = _build_export_html(html_document)
+
+    with tempfile.TemporaryDirectory() as td:
+        hti = Html2Image(
+            output_path=td,
+            size=(width, height),
+            custom_flags=[
+                "--hide-scrollbars",
+                "--force-device-scale-factor=3",
+                "--default-background-color=ffffff",
+            ],
+        )
+        hti.screenshot(html_str=prepared_html, save_as="gantt.png")
+        path = os.path.join(td, "gantt.png")
+        with open(path, "rb") as f:
+            raw = f.read()
+    return _trim_png_whitespace(raw)
+
+
+def png_bytes_to_jpeg_bytes(png_bytes: bytes, quality: int = 95) -> bytes:
+    from PIL import Image
+
+    im = Image.open(io.BytesIO(png_bytes)).convert("RGB")
+    buf = io.BytesIO()
+    im.save(buf, format="JPEG", quality=quality, optimize=True, subsampling=0)
+    return buf.getvalue()
+
+
+def save_png_jpeg_to_cache(
+    png_bytes: bytes,
+    jpg_bytes: bytes,
+    base_name: str,
+    cache_dir: Optional[str] = None,
+) -> Tuple[str, str]:
+    """后台保存 PNG/JPG 到 cinema_cache/gantt_exports/，返回文件路径。"""
+    if cache_dir is None:
+        cache_dir = os.path.join("cinema_cache", "gantt_exports")
+    os.makedirs(cache_dir, exist_ok=True)
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe = "".join(c if c.isalnum() or c in "-_" else "_" for c in base_name)[:80]
+    png_path = os.path.join(cache_dir, f"{safe}_{ts}.png")
+    jpg_path = os.path.join(cache_dir, f"{safe}_{ts}.jpg")
+    with open(png_path, "wb") as f:
+        f.write(png_bytes)
+    with open(jpg_path, "wb") as f:
+        f.write(jpg_bytes)
+    return png_path, jpg_path
+
+
+def build_png_and_jpeg_for_gantt(html_document: str, num_hall_rows: int) -> Tuple[bytes, bytes]:
+    """
+    根据影厅行数估算截图尺寸，生成更清晰且内容占满画面的 PNG/JPG 字节。
+    """
+    nrows = max(1, num_hall_rows)
+    width = 1680
+    height = min(22000, max(2200, 360 + nrows * 120))
+    png = html_document_to_png_bytes(html_document, width=width, height=height)
+    jpg = png_bytes_to_jpeg_bytes(png)
+    return png, jpg

historical_sessions.py

@@ -0,0 +1,408 @@
+import json
+import os
+from datetime import date, datetime, time as dt_time, timedelta
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+import numpy as np
+import pandas as pd
+
+from cinema_api_client import fetch_canonical_movie_names
+
+
+ROOT_DIR = Path(__file__).resolve().parent
+STATE_DIR = ROOT_DIR / "cinema_cache"
+LOCAL_HISTORY_FILE = STATE_DIR / "historical_sessions.csv"
+LOCAL_HISTORY_MANIFEST_FILE = STATE_DIR / "historical_sessions_manifest.json"
+LEGACY_HISTORY_FILE = ROOT_DIR / "persistent_data.csv"
+
+HISTORY_COLUMNS = [
+    "showId",
+    "影片名称",
+    "影片名称_清理后",
+    "放映日期",
+    "放映时间",
+    "影厅",
+    "座位数",
+    "总收入",
+    "总人次",
+    "场次",
+    "影片时长(分钟)",
+    "影片时长档位",
+    "影片时长类型",
+    "影片编码",
+    "影片语言",
+    "影片制式",
+]
+
+
+def ensure_state_dir() -> None:
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def clean_movie_title(raw_title, canonical_names=None):
+    if not isinstance(raw_title, str):
+        return raw_title
+
+    base_name = None
+    if canonical_names:
+        sorted_names = sorted(canonical_names, key=len, reverse=True)
+        for name in sorted_names:
+            if name in raw_title:
+                base_name = name
+                break
+
+    if not base_name:
+        base_name = raw_title.split(" ", 1)[0]
+
+    raw_upper = raw_title.upper()
+    suffix = ""
+    if "HDR LED" in raw_upper:
+        suffix = "（HDR LED）"
+    elif "CINITY" in raw_upper:
+        suffix = "（CINITY）"
+    elif "杜比" in raw_upper or "DOLBY" in raw_upper:
+        suffix = "（杜比视界）"
+    elif "IMAX" in raw_upper:
+        suffix = "（数字IMAX3D）" if "3D" in raw_upper else "（数字IMAX）"
+    elif "巨幕" in raw_upper:
+        suffix = "（中国巨幕立体）" if "立体" in raw_upper else "（中国巨幕）"
+    elif "3D" in raw_upper:
+        suffix = "（数字3D）"
+
+    if suffix and suffix not in base_name:
+        return f"{base_name}{suffix}"
+    return base_name
+
+
+def round_minutes_to_10min(minutes):
+    numeric_value = pd.to_numeric(minutes, errors="coerce")
+    if pd.isna(numeric_value) or float(numeric_value) <= 0:
+        return np.nan
+    return int(np.floor((float(numeric_value) + 5) / 10) * 10)
+
+
+def create_duration_label(minutes):
+    if pd.isna(minutes):
+        return np.nan
+    return f"{int(minutes)}分钟档"
+
+
+def create_empty_history_df() -> pd.DataFrame:
+    data = {column: pd.Series(dtype="object") for column in HISTORY_COLUMNS}
+    data["放映日期"] = pd.Series(dtype="datetime64[ns]")
+    data["座位数"] = pd.Series(dtype="int64")
+    data["总收入"] = pd.Series(dtype="float64")
+    data["总人次"] = pd.Series(dtype="int64")
+    data["场次"] = pd.Series(dtype="int64")
+    data["影片时长(分钟)"] = pd.Series(dtype="float64")
+    data["影片时长档位"] = pd.Series(dtype="float64")
+    return pd.DataFrame(data)
+
+
+def normalize_time_value(value):
+    if pd.isna(value):
+        return None
+    if isinstance(value, datetime):
+        return value.time().replace(second=0, microsecond=0)
+    if isinstance(value, dt_time):
+        return value.replace(second=0, microsecond=0)
+
+    numeric_value = pd.to_numeric(pd.Series([value]), errors="coerce").iloc[0]
+    if pd.notna(numeric_value) and 0 <= float(numeric_value) < 1:
+        total_minutes = int(round(float(numeric_value) * 24 * 60)) % (24 * 60)
+        return (datetime.min + timedelta(minutes=total_minutes)).time()
+
+    parsed = pd.to_datetime(str(value), errors="coerce")
+    if pd.isna(parsed):
+        return None
+    return parsed.time().replace(second=0, microsecond=0)
+
+
+def _normalize_history_df(df: Optional[pd.DataFrame]) -> pd.DataFrame:
+    if df is None or df.empty:
+        return create_empty_history_df()
+
+    normalized = df.copy()
+    for column in HISTORY_COLUMNS:
+        if column not in normalized.columns:
+            normalized[column] = np.nan
+
+    normalized["影片名称"] = normalized["影片名称"].astype(str).str.strip()
+    normalized = normalized[normalized["影片名称"].ne("") & normalized["影片名称"].ne("nan")].copy()
+    normalized["影片名称_清理后"] = normalized["影片名称_清理后"].where(
+        normalized["影片名称_清理后"].notna(),
+        normalized["影片名称"].apply(clean_movie_title),
+    )
+    normalized["影片名称_清理后"] = normalized["影片名称_清理后"].astype(str).str.strip()
+
+    normalized["放映日期"] = pd.to_datetime(normalized["放映日期"], errors="coerce").dt.normalize()
+    normalized["放映时间"] = normalized["放映时间"].apply(normalize_time_value)
+
+    for column in ["座位数", "总人次", "场次"]:
+        normalized[column] = pd.to_numeric(normalized[column], errors="coerce").fillna(0).round().astype(int)
+    normalized["总收入"] = pd.to_numeric(normalized["总收入"], errors="coerce").fillna(0.0).astype(float)
+    normalized["影片时长(分钟)"] = pd.to_numeric(normalized["影片时长(分钟)"], errors="coerce")
+    normalized = normalized[
+        (normalized["影片时长(分钟)"].isna()) |
+        ((normalized["影片时长(分钟)"] > 0) & (normalized["影片时长(分钟)"] <= 400))
+    ].copy()
+    normalized["影片时长档位"] = normalized["影片时长(分钟)"].apply(round_minutes_to_10min)
+    normalized["影片时长类型"] = normalized["影片时长档位"].apply(create_duration_label)
+
+    normalized["影厅"] = normalized["影厅"].fillna("").astype(str).str.strip()
+    normalized["showId"] = normalized["showId"].fillna("").astype(str).str.strip()
+    normalized["影片编码"] = normalized["影片编码"].fillna("").astype(str).str.strip()
+    normalized["影片语言"] = normalized["影片语言"].fillna("").astype(str).str.strip()
+    normalized["影片制式"] = normalized["影片制式"].fillna("").astype(str).str.strip()
+
+    normalized = normalized.dropna(subset=["放映日期", "放映时间"]).copy()
+    normalized["放映时间_str"] = normalized["放映时间"].apply(lambda value: value.strftime("%H:%M:%S") if isinstance(value, dt_time) else "")
+
+    with_show_id = normalized[normalized["showId"].ne("")].copy()
+    without_show_id = normalized[normalized["showId"].eq("")].copy()
+
+    if not with_show_id.empty:
+        with_show_id = with_show_id.drop_duplicates(subset=["showId"], keep="last")
+    if not without_show_id.empty:
+        without_show_id = without_show_id.drop_duplicates(
+            subset=["影片名称", "放映日期", "放映时间_str", "影厅"],
+            keep="last",
+        )
+
+    normalized = pd.concat([with_show_id, without_show_id], ignore_index=True)
+    normalized = normalized.sort_values(["放映日期", "放映时间_str", "影厅", "影片名称"]).reset_index(drop=True)
+    normalized.drop(columns=["放映时间_str"], inplace=True)
+    return normalized[HISTORY_COLUMNS]
+
+
+def load_history_df() -> pd.DataFrame:
+    ensure_state_dir()
+
+    if LOCAL_HISTORY_FILE.exists():
+        try:
+            return _normalize_history_df(pd.read_csv(LOCAL_HISTORY_FILE))
+        except Exception:
+            return create_empty_history_df()
+
+    if LEGACY_HISTORY_FILE.exists():
+        try:
+            legacy_df = pd.read_csv(LEGACY_HISTORY_FILE)
+            history_df = _normalize_history_df(legacy_df)
+            save_history_df(history_df)
+            return history_df
+        except Exception:
+            return create_empty_history_df()
+
+    return create_empty_history_df()
+
+
+def save_history_df(df: pd.DataFrame) -> pd.DataFrame:
+    ensure_state_dir()
+    normalized = _normalize_history_df(df)
+    normalized.to_csv(LOCAL_HISTORY_FILE, index=False)
+    return normalized
+
+
+def merge_history_df(existing_df: Optional[pd.DataFrame], new_df: Optional[pd.DataFrame]) -> pd.DataFrame:
+    frames = []
+    if existing_df is not None and not existing_df.empty:
+        frames.append(existing_df)
+    if new_df is not None and not new_df.empty:
+        frames.append(new_df)
+    merged = pd.concat(frames, ignore_index=True) if frames else create_empty_history_df()
+    return save_history_df(merged)
+
+
+def prepare_manual_report_history_df(raw_df: pd.DataFrame) -> pd.DataFrame:
+    if raw_df is None or raw_df.empty:
+        return create_empty_history_df()
+
+    prepared = raw_df.copy()
+    prepared["场次"] = 1
+    prepared.rename(
+        columns={
+            0: "影片名称",
+            1: "放映日期",
+            2: "放映时间",
+            5: "总人次",
+            6: "总收入",
+            7: "座位数",
+        },
+        inplace=True,
+    )
+    required_cols = ["影片名称", "放映日期", "放映时间", "座位数", "总收入", "总人次", "场次"]
+    prepared = prepared[required_cols]
+    prepared.dropna(subset=["影片名称", "放映日期", "放映时间"], inplace=True)
+    prepared["影片名称_清理后"] = prepared["影片名称"].apply(clean_movie_title)
+    prepared["影厅"] = ""
+    prepared["showId"] = ""
+    prepared["影片编码"] = ""
+    prepared["影片语言"] = ""
+    prepared["影片制式"] = ""
+    prepared["影片时长(分钟)"] = np.nan
+    prepared["影片时长档位"] = np.nan
+    prepared["影片时长类型"] = np.nan
+    return _normalize_history_df(prepared)
+
+
+def prepare_history_df_from_schedule(schedule_list: List[dict], show_date: str, hall_seat_map=None, token: Optional[str] = None) -> pd.DataFrame:
+    if not schedule_list:
+        return create_empty_history_df()
+
+    hall_seat_map = {str(key): value for key, value in (hall_seat_map or {}).items()}
+    canonical_names = fetch_canonical_movie_names(token, show_date) if token else []
+    rows = []
+
+    for item in schedule_list:
+        movie_name = item.get("movieName")
+        start_time = item.get("showStartTime")
+        if not movie_name or not start_time:
+            continue
+
+        movie_length = pd.to_numeric(item.get("movieLength"), errors="coerce")
+        cleaned_name = clean_movie_title(movie_name, canonical_names if canonical_names else None)
+        hall_id = str(item.get("hallId") or "").strip()
+        rows.append(
+            {
+                "showId": str(item.get("showId") or "").strip(),
+                "影片名称": cleaned_name,
+                "影片名称_清理后": cleaned_name,
+                "放映日期": show_date,
+                "放映时间": start_time,
+                "影厅": item.get("hallName") or "",
+                "座位数": hall_seat_map.get(hall_id, 0),
+                "总收入": pd.to_numeric(item.get("soldBoxOffice"), errors="coerce"),
+                "总人次": pd.to_numeric(item.get("soldTicketNum"), errors="coerce"),
+                "场次": 1,
+                "影片时长(分钟)": movie_length,
+                "影片时长档位": round_minutes_to_10min(movie_length),
+                "影片时长类型": create_duration_label(round_minutes_to_10min(movie_length)),
+                "影片编码": str(item.get("movieNum") or "").strip(),
+                "影片语言": str(item.get("movieLanguage") or "").strip(),
+                "影片制式": str(item.get("movieMediaType") or "").strip(),
+            }
+        )
+
+    return _normalize_history_df(pd.DataFrame(rows))
+
+
+def get_available_date_set(df: Optional[pd.DataFrame]) -> set:
+    if df is None or df.empty or "放映日期" not in df.columns:
+        return set()
+    return {value.date() for value in pd.to_datetime(df["放映日期"], errors="coerce").dropna()}
+
+
+def find_missing_dates(df: Optional[pd.DataFrame], start_date: date, end_date: date) -> List[date]:
+    if start_date > end_date:
+        return []
+    existing_dates = get_available_date_set(df)
+    missing_dates = []
+    current = start_date
+    while current <= end_date:
+        if current not in existing_dates:
+            missing_dates.append(current)
+        current += timedelta(days=1)
+    return missing_dates
+
+
+def build_duration_reference_from_history(df: Optional[pd.DataFrame]) -> pd.DataFrame:
+    if df is None or df.empty or "影片时长(分钟)" not in df.columns:
+        return pd.DataFrame(
+            columns=["影片", "影片名称_清理后", "影片时长(分钟)", "影片时长档位", "影片时长类型", "记录场次"]
+        )
+
+    duration_df = df.copy()
+    duration_df["影片时长(分钟)"] = pd.to_numeric(duration_df["影片时长(分钟)"], errors="coerce")
+    duration_df = duration_df.dropna(subset=["影片名称_清理后", "影片时长(分钟)"]).copy()
+    if duration_df.empty:
+        return pd.DataFrame(
+            columns=["影片", "影片名称_清理后", "影片时长(分钟)", "影片时长档位", "影片时长类型", "记录场次"]
+        )
+
+    duration_df["影片时长(分钟)"] = duration_df["影片时长(分钟)"].round().astype(int)
+    duration_df["影片时长档位"] = duration_df["影片时长(分钟)"].apply(round_minutes_to_10min)
+    duration_df["影片时长类型"] = duration_df["影片时长档位"].apply(create_duration_label)
+    duration_df["影片"] = duration_df["影片名称"]
+
+    summary = (
+        duration_df.groupby(["影片名称_清理后", "影片时长(分钟)", "影片时长档位", "影片时长类型"], as_index=False)
+        .agg(影片=("影片", "first"), 记录场次=("场次", "sum"))
+        .sort_values(["影片名称_清理后", "影片时长(分钟)"])
+        .reset_index(drop=True)
+    )
+    return summary[["影片", "影片名称_清理后", "影片时长(分钟)", "影片时长档位", "影片时长类型", "记录场次"]]
+
+
+def summarize_total_box_office_by_movies(df: Optional[pd.DataFrame], movie_names: Iterable[str]) -> pd.DataFrame:
+    requested_names = [str(name).strip() for name in (movie_names or []) if str(name).strip()]
+    if not requested_names:
+        return pd.DataFrame(columns=["影片", "总票房"])
+
+    if df is None or df.empty:
+        return pd.DataFrame({"影片": requested_names, "总票房": [0.0] * len(requested_names)})
+
+    history_df = df.copy()
+    history_df["总收入"] = pd.to_numeric(history_df["总收入"], errors="coerce").fillna(0.0)
+    totals = history_df.groupby("影片名称_清理后")["总收入"].sum().to_dict()
+    output_df = pd.DataFrame(
+        {
+            "影片": requested_names,
+            "总票房": [float(totals.get(name, 0.0)) for name in requested_names],
+        }
+    )
+    return output_df.sort_values(["总票房", "影片"], ascending=[False, True]).reset_index(drop=True)
+
+
+def default_history_manifest() -> dict:
+    return {
+        "synced_dates": [],
+        "updated_at": "",
+        "last_successful_target_date": "",
+    }
+
+
+def load_history_manifest() -> dict:
+    ensure_state_dir()
+    manifest = default_history_manifest()
+
+    if LOCAL_HISTORY_MANIFEST_FILE.exists():
+        try:
+            payload = json.loads(LOCAL_HISTORY_MANIFEST_FILE.read_text(encoding="utf-8"))
+            if isinstance(payload, dict):
+                manifest.update(payload)
+        except Exception:
+            pass
+
+    synced_dates = manifest.get("synced_dates", [])
+    if not isinstance(synced_dates, list):
+        synced_dates = []
+    manifest["synced_dates"] = sorted({str(item).strip() for item in synced_dates if str(item).strip()})
+    return manifest
+
+
+def save_history_manifest(manifest: Optional[dict]) -> dict:
+    ensure_state_dir()
+    final_manifest = default_history_manifest()
+    if isinstance(manifest, dict):
+        final_manifest.update(manifest)
+
+    synced_dates = final_manifest.get("synced_dates", [])
+    if not isinstance(synced_dates, list):
+        synced_dates = []
+    final_manifest["synced_dates"] = sorted({str(item).strip() for item in synced_dates if str(item).strip()})
+
+    LOCAL_HISTORY_MANIFEST_FILE.write_text(
+        json.dumps(final_manifest, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    return final_manifest
+
+
+def get_synced_date_set(manifest: Optional[dict]) -> set:
+    if not isinstance(manifest, dict):
+        return set()
+    synced_dates = manifest.get("synced_dates", [])
+    if not isinstance(synced_dates, list):
+        return set()
+    return {str(item).strip() for item in synced_dates if str(item).strip()}

legacy_pages/tms-2.py

@@ -0,0 +1,372 @@
+import streamlit as st
+import pandas as pd
+import requests
+import time
+import os
+import re
+import urllib3
+from collections import defaultdict
+from dotenv import load_dotenv
+from tms_proxy import TMS_ORIGIN, build_tms_url, get_tms_proxy_base_url, tms_verify_ssl, with_tms_proxy_headers
+
+# --- 基础配置 ---
+st.set_page_config(page_title="TMS 影片查询", page_icon="🎬", layout="wide")
+
+# 屏蔽 HTTPS 证书警告
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# 加载环境变量
+load_dotenv()
+
+# --- 工具函数 ---
+
+def get_circled_number(hall_name):
+    """
+    将影厅数字转换为带圈数字，例如 1 -> ①
+    """
+    mapping = {'1': '①', '2': '②', '3': '③', '4': '④', '5': '⑤', '6': '⑥', '7': '⑦', '8': '⑧', '9': '⑨'}
+    # 提取字符串中的数字
+    num_str = ''.join(filter(str.isdigit, str(hall_name)))
+    return mapping.get(num_str, num_str)
+
+
+def format_play_time(time_str):
+    """
+    格式化时长字符串，例如 "01:30" -> 90
+    """
+    if not time_str or not isinstance(time_str, str): return None
+    try:
+        parts = time_str.split(':')
+        hours = int(parts[0])
+        minutes = int(parts[1])
+        return hours * 60 + minutes
+    except (ValueError, IndexError):
+        return None
+
+
+def format_content_name_with_explanation(content_name):
+    raw = str(content_name or '').strip()
+    if not raw:
+        return ''
+
+    lang_map = {
+        'CMN': '国语/普通话', 'YUE': '粤语', 'EN': '英语', 'JP': '日语/或简化命名中的加密标记',
+        'KO': '韩语', 'FR': '法语', 'ES': '西班牙语', 'TH': '泰语', 'HI': '印地语', 'RU': '俄语',
+        'PTH': '普通话', 'GDH': '广东话', 'YS': '原声', 'YZ': '译制', 'SCH': '四川话',
+        'NAN': '闽南语', 'WU': '吴语/上海话', 'XX': '无字幕', 'QMS': '简中字幕',
+        'QMT': '繁中字幕', 'CCAP': '听障字幕'
+    }
+    audio_map = {'20': '2.0', '51': '5.1', '71': '7.1', 'ATMOS': 'Dolby Atmos', 'DTSX': 'DTS:X'}
+    type_map = {'FTR': '正片', 'TLR': '预告片', 'TSR': '先导预告'}
+    pack_map = {'OV': '原始版本包', 'VF': '版本增量包'}
+
+    notes = []
+    parts = raw.split('_')
+    first_tokens = parts[0].split('-') if parts else []
+    if first_tokens:
+        notes.append(f"[片名/标识:{first_tokens[0]}]")
+        for token in first_tokens[1:]:
+            up = token.upper()
+            if up in type_map:
+                notes.append(f"[内容类型:{type_map[up]}({token})]")
+            elif up in {'2D', '3D'}:
+                notes.append(f"[制式:{up}]")
+            elif up in {'4FL', '24FPS', '48FPS', '60FPS', '120FPS'}:
+                notes.append(f"[技术参数:{token}]")
+            elif re.fullmatch(r'\d+', up):
+                notes.append(f"[版本号:{token}]")
+            else:
+                notes.append(f"[{token}]")
+
+    for token in parts[1:]:
+        up = token.upper()
+        if '-' in up:
+            a, b = up.split('-', 1)
+            if a in lang_map and b in lang_map:
+                notes.append(f"[音频:{lang_map[a]}({a})]")
+                notes.append(f"[字幕:{lang_map[b]}({b})]")
+                continue
+        if up in {'F', 'S', 'C', 'F-178', 'C-19', '235', '185'}:
+            notes.append(f"[画幅:{token}]")
+        elif re.fullmatch(r'\d{2,3}M', up):
+            notes.append(f"[时长:{token}]")
+        elif up in audio_map:
+            notes.append(f"[音效:{audio_map[up]}({token})]")
+        elif up in {'2K', '4K'}:
+            notes.append(f"[分辨率:{up}]")
+        elif up in {'SMPTE', 'IOP'}:
+            notes.append(f"[封装标准:{up}]")
+        elif re.fullmatch(r'\d{8}', up):
+            notes.append(f"[打包日期:{token}]")
+        elif re.fullmatch(r'\d{4}', up):
+            notes.append(f"[月日批次:{token}]")
+        elif up in pack_map:
+            notes.append(f"[包类型:{pack_map[up]}({up})]")
+        elif up in lang_map:
+            notes.append(f"[语言/标记:{lang_map[up]}({up})]")
+        elif up.startswith('CN'):
+            notes.append(f"[地区/分级:{token}]")
+        else:
+            notes.append(f"[{token}]")
+
+    return f"{raw} / {' '.join(notes)}"
+
+
+def clean_movie_title(raw_title, canonical_names=None):
+    """
+    电影名称标准化清洗函数
+    """
+    if not isinstance(raw_title, str):
+        return raw_title
+
+    base_name = None
+
+    # 1. 尝试匹配标准名称
+    if canonical_names:
+        # 按长度倒序排序，确保最长匹配优先
+        sorted_names = sorted(canonical_names, key=len, reverse=True)
+        for name in sorted_names:
+            if name in raw_title:
+                base_name = name
+                break
+
+    # 2. 回退逻辑：如果没传列表或没匹配到，使用空格分割
+    if not base_name:
+        base_name = raw_title.split(' ', 1)[0]
+
+    # 3. 后缀追加逻辑
+    raw_upper = raw_title.upper()
+    suffix = ""
+
+    if "HDR LED" in raw_upper:
+        suffix = "（HDR LED）"
+    elif "CINITY" in raw_upper:
+        suffix = "（CINITY）"
+    elif "杜比" in raw_upper or "DOLBY" in raw_upper:
+        suffix = "（杜比视界）"
+    elif "IMAX" in raw_upper:
+        if "3D" in raw_upper:
+            suffix = "（数字IMAX3D）"
+        else:
+            suffix = "（数字IMAX）"
+    elif "巨幕" in raw_upper:
+        if "立体" in raw_upper:
+            suffix = "（中国巨幕立体）"
+        else:
+            suffix = "（中国巨幕）"
+    elif "3D" in raw_upper:
+        suffix = "（数字3D）"
+
+    # 只有当 base_name 自身不包含该后缀时才添加
+    if suffix and suffix not in base_name:
+        return f"{base_name}{suffix}"
+
+    return base_name
+
+
+# --- 核心功能模块 ---
+
+# @st.cache_data(show_spinner=False, ttl=600)
+def fetch_and_process_server_movies(priority_movie_titles=None):
+    if priority_movie_titles is None: priority_movie_titles = []
+    tms_proxy_base_url = get_tms_proxy_base_url()
+
+    # 获取环境变量
+    app_secret = os.getenv("TMS_APP_SECRET")
+    ticket = os.getenv("TMS_TICKET")
+    theater_id_str = os.getenv("TMS_THEATER_ID")
+    x_session_id = os.getenv("TMS_X_SESSION_ID")
+
+    # 转换 ID 为整数
+    try:
+        theater_id = int(theater_id_str) if theater_id_str else 0
+    except ValueError:
+        st.error("环境变量 TMS_THEATER_ID 格式错误，应为数字。")
+        return {}, []
+
+    token_headers = {
+        'Accept': 'application/json, text/javascript, */*; q=0.01',
+        'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6',
+        'Content-Type': 'application/json',
+        'Cookie': f'JSESSIONID={x_session_id}',
+        'DNT': '1',
+        'Origin': 'https://tms.hengdianfilm.com',
+        'Priority': 'u=0, i',
+        'Referer': f'https://tms.hengdianfilm.com/hd/oalogin?ticket={ticket}',
+        'Sec-CH-UA': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
+        'Sec-CH-UA-Mobile': '?0',
+        'Sec-CH-UA-Platform': '"macOS"',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin',
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36',
+        'X-Requested-With': 'XMLHttpRequest',
+    }
+
+    # 使用变量
+    token_json_data = {'appId': 'hd', 'appSecret': app_secret, 'timeStamp': int(time.time() * 1000)}
+    # 动态构建 URL
+    token_url = build_tms_url(
+        f'{TMS_ORIGIN}/cinema-api/admin/generateToken?token=hd&murl=?token=hd&murl=ticket={ticket}',
+        tms_proxy_base_url,
+    )
+    token_headers = with_tms_proxy_headers(token_headers, tms_proxy_base_url)
+
+    try:
+        response = requests.post(token_url, headers=token_headers, json=token_json_data, timeout=10)
+        response.raise_for_status()
+        token_data = response.json()
+        if token_data.get('error_code') != '0000': 
+            raise Exception(f"获取Token失败: {token_data.get('error_desc')}")
+        auth_token = token_data['param']
+    except Exception as e:
+        st.error(f"连接 TMS 认证服务失败: {e}")
+        return {}, []
+
+    all_movies, page_index = [], 1
+    while True:
+        list_headers = {
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6',
+            'Content-Type': 'application/json; charset=UTF-8',
+            'Cookie': f'JSESSIONID={x_session_id}',
+            'DNT': '1',
+            'Origin': 'https://tms.hengdianfilm.com',
+            'Priority': 'u=1, i',
+            'Referer': f'https://tms.hengdianfilm.com/hd/index?ContentMovie&THEATER_ID={theater_id}&SOURCE=SERVER&ASSERT_TYPE=2&PAGE_CAPACITY=20&PAGE_INDEX=1',
+            'Sec-CH-UA': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
+            'Sec-CH-UA-Mobile': '?0',
+            'Sec-CH-UA-Platform': '"macOS"',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Token': auth_token,
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36',
+            'X-Requested-With': 'XMLHttpRequest',
+            'X-SESSIONID': x_session_id,
+        }
+        list_params = {'token': 'hd', 'murl': 'ContentMovie'}
+        list_json_data = {'THEATER_ID': theater_id, 'SOURCE': 'SERVER', 'ASSERT_TYPE': 2, 'PAGE_CAPACITY': 20,
+                          'PAGE_INDEX': page_index}
+
+        list_url = build_tms_url(f'{TMS_ORIGIN}/cinema-api/cinema/server/dcp/list', tms_proxy_base_url)
+        list_headers = with_tms_proxy_headers(list_headers, tms_proxy_base_url)
+        try:
+            response = requests.post(
+                list_url,
+                params=list_params,
+                headers=list_headers,
+                json=list_json_data,
+                verify=tms_verify_ssl(default=False, proxy_url=tms_proxy_base_url),
+                timeout=15,
+            )
+            response.raise_for_status()
+            movie_data = response.json()
+            if movie_data.get("RSPCD") != "000000": 
+                raise Exception(f"获取影片列表失败: {movie_data.get('RSPMSG')}")
+            
+            body = movie_data.get("BODY", {})
+            movies_on_page = body.get("LIST", [])
+            if not movies_on_page: break
+            all_movies.extend(movies_on_page)
+            if len(all_movies) >= body.get("COUNT", 0): break
+            page_index += 1
+            time.sleep(0.5)
+        except Exception as e:
+            st.error(f"获取影片列表页 {page_index} 失败: {e}")
+            break
+
+    # 处理数据
+    movie_details = {m.get('CONTENT_NAME'): {'assert_name': m.get('ASSERT_NAME'),
+                                             'halls': sorted([h.get('HALL_NAME') for h in m.get('HALL_INFO', [])]),
+                                             'play_time': m.get('PLAY_TIME')} for m in all_movies if
+                     m.get('CONTENT_NAME')}
+    
+    by_hall = defaultdict(list)
+    for content_name, details in movie_details.items():
+        for hall_name in details['halls']:
+            by_hall[hall_name].append({'content_name': content_name, 'details': details})
+            
+    for hall_name in by_hall:
+        by_hall[hall_name].sort(
+            key=lambda item: (item['details']['assert_name'] is None or item['details']['assert_name'] == '',
+                              item['details']['assert_name'] or item['content_name']))
+            
+    view2_list = [{'assert_name': d['assert_name'], 'content_name': c, 'halls': d['halls'], 'play_time': d['play_time']}
+                  for c, d in movie_details.items() if d.get('assert_name')]
+                  
+    priority_list = [item for item in view2_list if
+                     any(p_title in item['assert_name'] for p_title in priority_movie_titles)]
+    other_list_items = [item for item in view2_list if item not in priority_list]
+    
+    priority_list.sort(key=lambda x: x['assert_name'])
+    other_list_items.sort(key=lambda x: x['assert_name'])
+    final_sorted_list = priority_list + other_list_items
+    
+    return dict(sorted(by_hall.items())), final_sorted_list
+
+
+# --- 主界面 ---
+
+def main():
+    st.title("🎬 TMS 服务器影片内容查询")
+    st.info("查询 TMS 服务器上的 DCP 内容及分布情况。")
+
+    # 尝试从 Session State 获取优先显示的影片（如果在主页加载了排片）
+    priority_titles = []
+    if 'api_df' in st.session_state and not st.session_state.api_df.empty:
+        df = st.session_state.api_df
+        if '影片名称_清理后' in df.columns:
+            priority_titles = df['影片名称_清理后'].unique().tolist()
+        elif '影片名称' in df.columns:
+            priority_titles = df['影片名称'].apply(lambda x: clean_movie_title(x)).unique().tolist()
+    
+    # 也可以检查 file_df
+    elif 'file_df' in st.session_state and not st.session_state.file_df.empty:
+        df = st.session_state.file_df
+        if '影片名称_清理后' in df.columns:
+            priority_titles = df['影片名称_清理后'].unique().tolist()
+        elif '影片名称' in df.columns:
+            priority_titles = df['影片名称'].apply(lambda x: clean_movie_title(x)).unique().tolist()
+
+    if st.button('点击查询 TMS 服务器', key="query_tms", type="primary", icon="🔍"):
+        with st.spinner("正在从 TMS 服务器获取数据中..."):
+            try:
+                halls_data, movie_list_sorted = fetch_and_process_server_movies(priority_titles)
+                
+                if not movie_list_sorted:
+                    st.warning("未获取到任何影片数据，请检查 TMS 连接配置。")
+                else:
+                    st.success("TMS 服务器数据获取成功！")
+                    
+                    # 1. 按影片查看
+                    st.markdown("### 🎥 按影片查看所在影厅")
+                    view2_data = [{'影片名称': item['assert_name'],
+                                   '所在影厅': " ".join(sorted([get_circled_number(h) for h in item['halls']])),
+                                   '时长(分钟)': format_play_time(item['play_time']),
+                                   '文件名': format_content_name_with_explanation(item['content_name'])}
+                                  for item in movie_list_sorted]
+                    st.dataframe(pd.DataFrame(view2_data), hide_index=True, width="stretch")
+                    
+                    st.divider()
+
+                    # 2. 按影厅查看
+                    st.markdown("### 🏢 按影厅查看影片内容")
+                    if halls_data:
+                        hall_tabs = st.tabs(list(halls_data.keys()))
+                        for tab, hall_name in zip(hall_tabs, halls_data.keys()):
+                            with tab:
+                                view1_data = [{'影片名称': item['details']['assert_name'], 
+                                               '所在影厅': " ".join(sorted([get_circled_number(h) for h in item['details']['halls']])),
+                                               '时长(分钟)': format_play_time(item['details']['play_time']),
+                                               '文件名': format_content_name_with_explanation(item['content_name'])} for item in
+                                              halls_data[hall_name]]
+                                st.dataframe(pd.DataFrame(view1_data), hide_index=True, width="stretch")
+                    else:
+                        st.info("暂无影厅数据。")
+
+            except Exception as e:
+                st.error(f"查询 TMS 服务器时出错: {e}")
+
+if __name__ == "__main__":
+    main()

new_api_proxy.py

@@ -0,0 +1,65 @@
+import os
+from urllib.parse import urlsplit, urlunsplit
+
+
+NEW_API_PROXY_URL_ENV = "NEW_API_PROXY_URL"
+NEW_API_PROXY_TOKEN_ENV = "NEW_API_PROXY_TOKEN"
+NEW_API_PROXY_AUTH_QUERY_ENV = "NEW_API_PROXY_AUTH_QUERY"
+NEW_API_PROXY_DIRECT_FALLBACK_ENV = "NEW_API_PROXY_DIRECT_FALLBACK"
+NEW_API_PROXY_TOKEN_HEADER = "X-New-API-Proxy-Token"
+
+
+def get_new_api_proxy_base_url(proxy_url=None):
+    raw = proxy_url if proxy_url is not None else os.getenv(NEW_API_PROXY_URL_ENV, "")
+    raw = str(raw or "").strip().strip('"').strip("'")
+    if not raw:
+        return ""
+    if "://" not in raw:
+        raw = f"https://{raw}"
+    return raw.rstrip("/")
+
+
+def build_new_api_proxy_url(path, proxy_url=None):
+    proxy_base_url = get_new_api_proxy_base_url(proxy_url)
+    if not proxy_base_url:
+        return ""
+
+    path = str(path or "")
+    if not path.startswith("/"):
+        path = f"/{path}"
+
+    base_parts = urlsplit(proxy_base_url)
+    path_part, _, path_query = path.partition("?")
+    base_path = base_parts.path.rstrip("/")
+    if base_path and base_path != "/" and not base_path.endswith(path_part.rstrip("/")):
+        final_path = f"{base_path}{path_part}"
+    elif base_path and base_path.endswith(path_part.rstrip("/")):
+        final_path = base_path
+    else:
+        final_path = path_part
+
+    extra_query = os.getenv(NEW_API_PROXY_AUTH_QUERY_ENV, "").strip().lstrip("?")
+    query_parts = [q for q in (base_parts.query, extra_query, path_query) if q]
+    return urlunsplit(
+        (
+            base_parts.scheme,
+            base_parts.netloc,
+            final_path,
+            "&".join(query_parts),
+            base_parts.fragment,
+        )
+    )
+
+
+def with_new_api_proxy_headers(headers=None, proxy_url=None):
+    headers = dict(headers or {})
+    if get_new_api_proxy_base_url(proxy_url):
+        proxy_token = os.getenv(NEW_API_PROXY_TOKEN_ENV, "").strip()
+        if proxy_token:
+            headers[NEW_API_PROXY_TOKEN_HEADER] = proxy_token
+    return headers
+
+
+def new_api_proxy_direct_fallback_enabled():
+    raw = os.getenv(NEW_API_PROXY_DIRECT_FALLBACK_ENV, "1").strip().lower()
+    return raw not in {"0", "false", "no", "off"}

pages/🆕 新API卖品销售总额测试.py

@@ -0,0 +1,1028 @@
+"""新 API（center.hengdianfilm.com / jmu/jmreport/show）卖品销售总额测试页面。
+
+完整鉴权链路（与浏览器抓包一致）：
+1. **OA SSO 取 ticket**：`GET oa.hengdianfilm.com/seeyon/thirdpartyController.do?method=show&id=<固定应用ID>&pageUrl=...`
+   - 需要 OA 已登录（携带 OA 的 `JSESSIONID` cookie）
+   - 响应里会带回跳 URL 或 HTML，其中包含 `ticket=<一次性凭证>` 或旧版 `mobile=<一次性凭证>`
+2. **换 Bearer Token**：`POST center.hengdianfilm.com/auth/oauth/token?mobile=<ticket>&code=1234&grant_type=oa`
+   - Header 必须带 `Authorization: Basic b2E6b2E=` 和 `tenant-id: 1`
+3. **调报表**：`POST center.hengdianfilm.com/jimu/jmreport/show`
+   - Token 通过 `token` / `x-access-token` Header 和 `bruts_token` Cookie 同时传递
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import date as dt_date, datetime, timedelta
+from typing import Any, Optional
+from urllib.parse import parse_qs, urljoin, urlparse
+
+import pandas as pd
+import requests
+import streamlit as st
+from dotenv import load_dotenv
+from new_api_proxy import (
+    NEW_API_PROXY_AUTH_QUERY_ENV,
+    NEW_API_PROXY_DIRECT_FALLBACK_ENV,
+    NEW_API_PROXY_TOKEN_ENV,
+    NEW_API_PROXY_URL_ENV,
+    build_new_api_proxy_url,
+    get_new_api_proxy_base_url,
+    new_api_proxy_direct_fallback_enabled,
+    with_new_api_proxy_headers,
+)
+
+
+# ---------------------------------------------------------------------------
+# 页面配置 & 环境变量
+# ---------------------------------------------------------------------------
+load_dotenv(override=True)
+
+st.set_page_config(layout="wide", page_title="🆕 新 API 卖品销售总额测试")
+st.title("🆕 新 API 卖品销售总额测试")
+st.caption(
+    "测试 OA SSO → ticket → bearer token → jmreport 完整链路。"
+    "用于核对当日卖品 **实付金额（real_amount）** 总额。"
+)
+
+
+# ---------------------------------------------------------------------------
+# 常量
+# ---------------------------------------------------------------------------
+CENTER_BASE_URL = "https://center.hengdianfilm.com"
+TOKEN_URL = f"{CENTER_BASE_URL}/auth/oauth/token"
+JMREPORT_URL = f"{CENTER_BASE_URL}/jimu/jmreport/show"
+GOODS_SALES_REPORT_ID = "1153597763885797376"  # 售卖员报表 2
+
+OA_BASE_URL = os.getenv("OA_BASE_URL", "https://oa.hengdianfilm.com")
+SSO_APP_ID = os.getenv("CENTER_SSO_APP_ID", "-28746303884891748910")
+SSO_PAGE_URL = os.getenv("CENTER_SSO_PAGE_URL", "https://center.hengdianfilm.com/")
+SSO_URL = f"{OA_BASE_URL}/seeyon/thirdpartyController.do"
+
+DEFAULT_OA_JSESSIONID = os.getenv("OA_JSESSIONID", "")
+DEFAULT_OA_COOKIE = os.getenv("OA_COOKIE", "")
+DEFAULT_OAUTH_CODE = os.getenv("CENTER_OAUTH_CODE", "1234")
+DEFAULT_OAUTH_GRANT = os.getenv("CENTER_OAUTH_GRANT_TYPE", "oa")
+DEFAULT_OAUTH_BASIC = os.getenv("CENTER_OAUTH_BASIC", "Basic b2E6b2E=")
+
+USER_AGENT = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36"
+)
+
+
+# ---------------------------------------------------------------------------
+# Session State
+# ---------------------------------------------------------------------------
+def _init_state() -> None:
+    defaults = {
+        "sales_token": "",
+        "sales_token_meta": {},
+        "sales_token_fetched_at": None,
+        "sales_ticket": "",
+        "sales_ticket_fetched_at": None,
+        "sales_query_date": dt_date.today(),
+        "sales_last_payload": None,
+        "sales_last_summary": None,
+    }
+    for k, v in defaults.items():
+        st.session_state.setdefault(k, v)
+
+
+_init_state()
+
+
+# ---------------------------------------------------------------------------
+# 工具函数
+# ---------------------------------------------------------------------------
+TICKET_PATTERNS = [
+    re.compile(r"(?:mobile|ticket)=(-?\d{6,})"),
+    re.compile(r'"(?:mobile|ticket)"\s*:\s*"(-?\d{6,})"'),
+    re.compile(r"name=['\"](?:mobile|ticket)['\"][^>]*value=['\"](-?\d{6,})['\"]"),
+    re.compile(r"value=['\"](-?\d{6,})['\"][^>]*name=['\"](?:mobile|ticket)['\"]"),
+]
+
+
+def _format_sso_ticket_proxy_error(data: dict) -> Optional[str]:
+    if not isinstance(data, dict) or data.get("error") != "ticket-not-found":
+        return None
+
+    debug = data.get("debug") or {}
+    body_preview = str(debug.get("body_preview") or "")
+    upstream_status = data.get("upstreamStatus") or debug.get("status") or "-"
+    location = debug.get("location") or "-"
+    if "请重新登录" in body_preview:
+        return (
+            "OA 登录态已失效：OA 返回“请重新登录后再试”。"
+            "请在浏览器重新登录 OA，复制最新完整 Cookie 写入 `.env` 的 `OA_COOKIE`"
+            "（或至少更新 `OA_JSESSIONID`），然后重启 Streamlit。"
+            f"上游状态码={upstream_status}。"
+        )
+    return (
+        "未能从 OA SSO 响应中提取到 ticket。"
+        f"上游状态���={upstream_status}，Location={location}，响应预览={body_preview or data}"
+    )
+
+
+def _cookie_names(cookies: dict[str, str]) -> list[str]:
+    """只暴露 cookie 名称，避免调试信息泄露会话值。"""
+    return sorted(cookies.keys())
+
+
+def _domain_cookies(cookie_jar: requests.cookies.RequestsCookieJar, domain: str) -> dict[str, str]:
+    """从 Session CookieJar 中提取指定域的 cookies。"""
+    return {
+        cookie.name: cookie.value
+        for cookie in cookie_jar
+        if cookie.domain and domain in cookie.domain
+    }
+
+
+class NewApiProxyPlatformError(RuntimeError):
+    """EdgeOne Pages 外层鉴权错误；此时请求还没有进入 edge-functions。"""
+
+    def __init__(self, step: str, message: str) -> None:
+        super().__init__(
+            f"{step} 被 EdgeOne Pages 外层鉴权拦截：{message}。"
+            "请求没有进入 edge-functions。请关闭该 Pages 域名的 URL 鉴权/访问保护，"
+            f"或把 Preview 链接中的 `eo_time` 等签名参数放入 `{NEW_API_PROXY_URL_ENV}` / "
+            f"`{NEW_API_PROXY_AUTH_QUERY_ENV}`，也可以改用没有 `eo_time` 鉴权的专用代理域名。"
+        )
+
+
+class NewApiProxyMethodError(RuntimeError):
+    """代理函数收到非 POST 请求；常见于 Preview 跳转把 POST 改成 GET。"""
+
+    def __init__(self, step: str, message: str) -> None:
+        super().__init__(
+            f"{step} 到达了 edge-functions，但方法不对：{message}。"
+            "通常是 EdgeOne Preview 链接发生 302/303 跳转后，HTTP 客户端把 POST 改成了 GET；"
+            "也可能是直接在浏览器地址栏打开了代理接口。"
+        )
+
+
+class NewApiProxyFunctionMissingError(RuntimeError):
+    """代理路径没有命中 edge-functions，通常是新增函数还没部署。"""
+
+    def __init__(self, step: str, path: str) -> None:
+        super().__init__(
+            f"{step} 没有命中 EdgeOne edge-functions：{path}。"
+            "请把 `new-api-edgeone-pages` 重新部署到 EdgeOne Pages，确认线上包含这个函数路径。"
+        )
+
+
+def _raise_for_new_api_proxy_platform_error(resp: requests.Response, step: str) -> None:
+    eop_msg = resp.headers.get("X-EOP-MSG")
+    server = resp.headers.get("Server", "")
+    looks_like_edgeone_gate = "edgeone-pages" in server.lower()
+    if resp.status_code in {401, 403} and (eop_msg or looks_like_edgeone_gate):
+        raise NewApiProxyPlatformError(step, eop_msg or "Access Restricted or Authentication Expired")
+
+
+def _raise_for_new_api_proxy_method_error(resp: requests.Response, step: str) -> None:
+    if resp.status_code == 405 and "method-not-allowed" in (resp.text or ""):
+        try:
+            data = resp.json()
+        except ValueError:
+            data = {}
+        seen_method = data.get("method") or resp.headers.get("X-New-API-Request-Method") or "非 POST"
+        raise NewApiProxyMethodError(step, f"代理函数收到 {seen_method}")
+
+
+def _raise_for_new_api_proxy_missing_function(resp: requests.Response, step: str, path: str) -> None:
+    has_proxy_header = bool(resp.headers.get("X-New-API-Proxy"))
+    body = resp.text or ""
+    if not has_proxy_header and resp.status_code in {404, 405} and (
+        "<Code>MethodNotAllowed</Code>" in body or "<Code>NoSuchKey</Code>" in body
+    ):
+        raise NewApiProxyFunctionMissingError(step, path)
+
+
+def _direct_fallback_note(exc: NewApiProxyPlatformError) -> str:
+    return (
+        f"{exc}\n\n已自动改用本机直连继续请求。"
+        f"如需禁用自动回退，可设置 `{NEW_API_PROXY_DIRECT_FALLBACK_ENV}=0`。"
+    )
+
+
+def _method_fallback_note(exc: NewApiProxyMethodError) -> str:
+    return (
+        f"{exc}\n\n已自动改用本机直连继续请求。"
+        "如果你只是在浏览器里打开代理 URL 测试，看到 405 是正常的；"
+        "OAuth 中转必须由页面用 POST 调用。"
+    )
+
+
+def _post_new_api_proxy_json(
+    path: str,
+    proxy_base_url: str,
+    payload: dict[str, Any],
+    timeout: int,
+) -> requests.Response:
+    """POST 到 EdgeOne Pages 代理，并在 Preview 跳转时保持 POST 方法和预览 Cookie。"""
+    headers = with_new_api_proxy_headers({"accept": "application/json"}, proxy_base_url)
+    session = requests.Session()
+    resp = session.post(
+        build_new_api_proxy_url(path, proxy_base_url),
+        headers=headers,
+        json=payload,
+        timeout=timeout,
+        allow_redirects=False,
+    )
+    if resp.status_code in {301, 302, 303, 307, 308} and resp.headers.get("Location"):
+        resp = session.post(
+            urljoin(resp.url, resp.headers["Location"]),
+            headers=headers,
+            json=payload,
+            timeout=timeout,
+            allow_redirects=False,
+        )
+    return resp
+
+
+def _fetch_with_proxy_recoverable_fallback(
+    proxy_call,
+    direct_call,
+) -> tuple[dict, Optional[str]]:
+    try:
+        return proxy_call(), None
+    except NewApiProxyPlatformError as exc:
+        if not new_api_proxy_direct_fallback_enabled():
+            raise
+        return direct_call(), _direct_fallback_note(exc)
+    except NewApiProxyMethodError as exc:
+        if not new_api_proxy_direct_fallback_enabled():
+            raise
+        return direct_call(), _method_fallback_note(exc)
+
+
+def fetch_sso_ticket(
+    jsessionid: str,
+    app_id: str = SSO_APP_ID,
+    page_url: str = SSO_PAGE_URL,
+    proxy_url: str = "",
+) -> tuple[str, dict, dict[str, str]]:
+    """通过 OA SSO 获取一次性 ticket。
+
+    返回 (ticket, debug_info, center_cookies)。debug_info 包含响应链路 / 状态码 / 命中模式等信息。
+    """
+    if not jsessionid.strip() and not DEFAULT_OA_COOKIE.strip():
+        raise ValueError("OA_JSESSIONID / OA_COOKIE 至少需要配置一个。")
+
+    proxy_base_url = get_new_api_proxy_base_url(proxy_url)
+    if proxy_base_url:
+        payload = {
+            "jsessionid": jsessionid.strip(),
+            "oaCookie": DEFAULT_OA_COOKIE.strip(),
+            "appId": app_id,
+            "pageUrl": page_url,
+        }
+        resp = _post_new_api_proxy_json("/new-api/sso-ticket", proxy_base_url, payload, timeout=25)
+        _raise_for_new_api_proxy_platform_error(resp, "OA SSO ticket 中转")
+        _raise_for_new_api_proxy_missing_function(resp, "OA SSO ticket 中转", "/new-api/sso-ticket")
+        _raise_for_new_api_proxy_method_error(resp, "OA SSO ticket 中转")
+        if not resp.ok:
+            try:
+                error_data = resp.json()
+            except ValueError:
+                error_data = {}
+            error_message = _format_sso_ticket_proxy_error(error_data)
+            if error_message:
+                raise RuntimeError(error_message)
+        resp.raise_for_status()
+        data = resp.json()
+        ticket = str(data.get("ticket") or "").strip()
+        if not ticket:
+            error_message = _format_sso_ticket_proxy_error(data)
+            if error_message:
+                raise RuntimeError(error_message)
+            debug = data.get("debug") or {}
+            raise RuntimeError(
+                "未能从 OA SSO 代理响应中提取到 ticket。"
+                f"代理状态码={resp.status_code}，上游状态码={data.get('upstreamStatus') or debug.get('status') or '-'}，"
+                f"响应预览={debug.get('body_preview') or data}"
+            )
+        return ticket, data.get("debug") or {}, data.get("centerCookies") or {}
+
+    headers = {
+        "accept": (
+            "text/html,application/xhtml+xml,application/xml;q=0.9,"
+            "image/avif,image/webp,image/apng,*/*;q=0.8"
+        ),
+        "accept-language": "zh-CN,zh;q=0.9",
+        "referer": f"{OA_BASE_URL}/seeyon/main.do?method=main",
+        "upgrade-insecure-requests": "1",
+        "user-agent": USER_AGENT,
+    }
+    session = requests.Session()
+    if DEFAULT_OA_COOKIE.strip():
+        headers["cookie"] = DEFAULT_OA_COOKIE.strip()
+    else:
+        session.cookies.set("JSESSIONID", jsessionid.strip(), domain="oa.hengdianfilm.com", path="/")
+        session.cookies.set("login_locale", "zh_CN", domain="oa.hengdianfilm.com", path="/")
+    params = {"method": "show", "id": app_id, "pageUrl": page_url}
+
+    # 不自动跟随跳转：ticket 通常出现在 302 的 Location 中
+    resp = session.get(
+        SSO_URL,
+        headers=headers,
+        params=params,
+        allow_redirects=False,
+        timeout=15,
+    )
+
+    debug: dict[str, Any] = {
+        "status": resp.status_code,
+        "location": resp.headers.get("Location"),
+        "history": [],
+        "matched_via": None,
+        "proxy_enabled": False,
+        "proxy_note": "OA SSO uses local direct request because NEW_API_PROXY_URL is empty.",
+        "center_cookie_names": [],
+        "body_preview": (resp.text[:600] if resp.text else ""),
+    }
+
+    candidate_strings: list[str] = []
+    if debug["location"]:
+        candidate_strings.append(debug["location"])
+
+    # 如果是 3xx 重定向，手动跟一次链;有些环境会 200 直接返回 HTML
+    if 300 <= resp.status_code < 400 and debug["location"]:
+        try:
+            follow_url = urljoin(resp.url, debug["location"])
+            follow_headers = dict(headers)
+            if follow_url.startswith(CENTER_BASE_URL):
+                follow_headers.pop("cookie", None)
+            follow = session.get(
+                follow_url,
+                headers=follow_headers,
+                allow_redirects=False,
+                timeout=15,
+            )
+            debug["history"].append(
+                {
+                    "url": follow_url,
+                    "status": follow.status_code,
+                    "location": follow.headers.get("Location"),
+                }
+            )
+            if follow.headers.get("Location"):
+                candidate_strings.append(follow.headers["Location"])
+            if follow.text:
+                candidate_strings.append(follow.text)
+        except requests.RequestException as exc:
+            debug["history"].append({"error": str(exc)})
+    if resp.text:
+        candidate_strings.append(resp.text)
+
+    ticket: Optional[str] = None
+    for source in candidate_strings:
+        for pattern in TICKET_PATTERNS:
+            m = pattern.search(source)
+            if m:
+                ticket = m.group(1)
+                debug["matched_via"] = pattern.pattern
+                break
+        if ticket:
+            break
+
+    # 尝试解析 query string / hash fragment 形式：
+    # https://center.../?mobile=xxxxx 或 https://center.../#/loginOa?ticket=xxxxx
+    if not ticket:
+        for source in candidate_strings:
+            try:
+                parsed = urlparse(source)
+                fragment_query = ""
+                if "?" in (parsed.fragment or ""):
+                    fragment_query = parsed.fragment.split("?", 1)[1]
+                for raw_query in (parsed.query, fragment_query):
+                    qs = parse_qs(raw_query or "")
+                    for key in ("mobile", "ticket"):
+                        if key in qs and qs[key]:
+                            ticket = qs[key][0]
+                            debug["matched_via"] = f"urlparse:{key}"
+                            break
+                    if ticket:
+                        break
+                if ticket:
+                    break
+            except Exception:  # noqa: BLE001
+                continue
+
+    if not ticket:
+        body_preview = re.sub(r"\s+", " ", debug["body_preview"] or "").strip()
+        raise RuntimeError(
+            "未能从 OA SSO 响应中提取到 ticket。"
+            f"OA 状态码={debug['status']}，Location={debug['location'] or '-'}，"
+            f"响应预览={body_preview or '-'}"
+        )
+    center_cookies = _domain_cookies(session.cookies, "center.hengdianfilm.com")
+    debug["center_cookie_names"] = _cookie_names(center_cookies)
+    return ticket, debug, center_cookies
+
+
+def _fetch_oauth_token_direct(
+    mobile: str,
+    code: str,
+    grant_type: str,
+    basic_auth: str,
+    cookies: Optional[dict[str, str]] = None,
+) -> dict:
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "authorization": basic_auth,
+        "channel": "4",
+        "content-length": "0",
+        "istoken": "false",
+        "origin": CENTER_BASE_URL,
+        "tenant-id": "1",
+        "user-agent": USER_AGENT,
+    }
+    params = {"mobile": mobile, "code": code, "grant_type": grant_type}
+    resp = requests.post(
+        TOKEN_URL,
+        headers=headers,
+        params=params,
+        cookies=cookies,
+        timeout=15,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+def _fetch_oauth_token_via_proxy(
+    mobile: str,
+    code: str,
+    grant_type: str,
+    basic_auth: str,
+    cookies: Optional[dict[str, str]],
+    proxy_base_url: str,
+) -> dict:
+    payload: dict[str, Any] = {
+        "mobile": mobile,
+        "code": code,
+        "grantType": grant_type,
+        "basicAuth": basic_auth,
+    }
+    if cookies:
+        payload["cookies"] = cookies
+
+    resp = _post_new_api_proxy_json("/new-api/oauth-token", proxy_base_url, payload, timeout=20)
+    _raise_for_new_api_proxy_platform_error(resp, "OAuth token 中转")
+    _raise_for_new_api_proxy_method_error(resp, "OAuth token 中转")
+    resp.raise_for_status()
+    return resp.json()
+
+
+def fetch_oauth_token(
+    mobile: str,
+    code: str,
+    grant_type: str,
+    basic_auth: str,
+    cookies: Optional[dict[str, str]] = None,
+    proxy_url: str = "",
+) -> tuple[dict, Optional[str]]:
+    """用 ticket（mobile 参数）换取 Bearer Token。"""
+    proxy_base_url = get_new_api_proxy_base_url(proxy_url)
+    if proxy_base_url:
+        return _fetch_with_proxy_recoverable_fallback(
+            proxy_call=lambda: _fetch_oauth_token_via_proxy(
+                mobile=mobile,
+                code=code,
+                grant_type=grant_type,
+                basic_auth=basic_auth,
+                cookies=cookies,
+                proxy_base_url=proxy_base_url,
+            ),
+            direct_call=lambda: _fetch_oauth_token_direct(
+                mobile=mobile,
+                code=code,
+                grant_type=grant_type,
+                basic_auth=basic_auth,
+                cookies=cookies,
+            ),
+        )
+
+    return (
+        _fetch_oauth_token_direct(
+            mobile=mobile,
+            code=code,
+            grant_type=grant_type,
+            basic_auth=basic_auth,
+            cookies=cookies,
+        ),
+        None,
+    )
+
+
+def _fetch_jmreport_show_direct(
+    token: str,
+    start: str,
+    end: str,
+    page_no: int = 1,
+    page_size: int = 100,
+) -> dict:
+    headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "content-type": "application/json;charset=UTF-8",
+        "origin": CENTER_BASE_URL,
+        "referer": (
+            f"{CENTER_BASE_URL}/jimu/jmreport/shareView/{GOODS_SALES_REPORT_ID}"
+            f"?token={token}"
+        ),
+        "token": token,
+        "user-agent": USER_AGENT,
+        "x-access-token": token,
+    }
+    cookies = {"bruts_token": token}
+    inner_params = {
+        "token": token,
+        "pageNo": page_no,
+        "pageSize": page_size,
+        "start": start,
+        "end": end,
+        "customTableTitleSorts": [],
+    }
+    body = {
+        "id": GOODS_SALES_REPORT_ID,
+        "apiUrl": "",
+        "jmRecordId": "",
+        "sheetId": "",
+        "params": json.dumps(inner_params, ensure_ascii=False),
+    }
+    resp = requests.post(
+        JMREPORT_URL,
+        headers=headers,
+        cookies=cookies,
+        json=body,
+        timeout=20,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+def _fetch_jmreport_show_via_proxy(
+    token: str,
+    start: str,
+    end: str,
+    page_no: int,
+    page_size: int,
+    proxy_base_url: str,
+) -> dict:
+    resp = _post_new_api_proxy_json(
+        "/new-api/jmreport-show",
+        proxy_base_url,
+        {
+            "token": token,
+            "reportId": GOODS_SALES_REPORT_ID,
+            "start": start,
+            "end": end,
+            "pageNo": page_no,
+            "pageSize": page_size,
+        },
+        timeout=30,
+    )
+    _raise_for_new_api_proxy_platform_error(resp, "jmreport 中转")
+    _raise_for_new_api_proxy_method_error(resp, "jmreport 中转")
+    resp.raise_for_status()
+    return resp.json()
+
+
+def fetch_jmreport_show(
+    token: str,
+    start: str,
+    end: str,
+    page_no: int = 1,
+    page_size: int = 100,
+    proxy_url: str = "",
+) -> tuple[dict, Optional[str]]:
+    """调用 jmreport/show 拉取售卖员报表 2 数据。
+
+    注意：该接口的鉴权方式 **不是** `Authorization: Bearer`，而是：
+    - 请求头 `token` / `x-access-token`
+    - Cookie 中的 `bruts_token`
+    - 请求体 params 内嵌的 `token`
+    """
+    proxy_base_url = get_new_api_proxy_base_url(proxy_url)
+    if proxy_base_url:
+        return _fetch_with_proxy_recoverable_fallback(
+            proxy_call=lambda: _fetch_jmreport_show_via_proxy(
+                token=token,
+                start=start,
+                end=end,
+                page_no=page_no,
+                page_size=page_size,
+                proxy_base_url=proxy_base_url,
+            ),
+            direct_call=lambda: _fetch_jmreport_show_direct(
+                token=token,
+                start=start,
+                end=end,
+                page_no=page_no,
+                page_size=page_size,
+            ),
+        )
+
+    return (
+        _fetch_jmreport_show_direct(
+            token=token,
+            start=start,
+            end=end,
+            page_no=page_no,
+            page_size=page_size,
+        ),
+        None,
+    )
+
+
+def _to_float(value: Any, default: float = 0.0) -> float:
+    try:
+        if value is None or value == "":
+            return default
+        return float(str(value).replace(",", "").strip())
+    except (TypeError, ValueError):
+        return default
+
+
+def summarize_payload(payload: dict) -> dict:
+    """从 jmreport 返回数据中提取 real_amount 等汇总信息。"""
+    summary: dict[str, Any] = {
+        "report_total_real_amount": None,
+        "report_total_sales_amount": None,
+        "report_total_sales_num": None,
+        "list_total_real_amount": 0.0,
+        "list_total_sales_amount": 0.0,
+        "list_total_sales_num": 0.0,
+        "list_count": 0,
+        "page_total_records": 0,
+        "page_total_real_count": 0,
+        "payment_breakdown": {},
+        "items": pd.DataFrame(),
+    }
+
+    if not isinstance(payload, dict):
+        return summary
+
+    result = payload.get("result") or {}
+    data_list = result.get("dataList") or {}
+    exp_data = data_list.get("expData") or {}
+
+    # expData 的 key 大小写不一致，做规范化处理
+    normalized_exp = {str(k).lower(): v for k, v in exp_data.items()}
+
+    def _exp(key: str):
+        return normalized_exp.get(key.lower())
+
+    summary["report_total_real_amount"] = _to_float(_exp("=DBSUM(#{goods_sales_2.real_amount})"))
+    summary["report_total_sales_amount"] = _to_float(_exp("=DBSUM(#{goods_sales_2.sales_amount})"))
+    summary["report_total_sales_num"] = _to_float(_exp("=DBSUM(#{goods_sales_2.sales_num})"))
+
+    pay_keys = {
+        "现金": "cash_pay",
+        "网络支付": "online_pay",
+        "扫码支付": "scan_pay",
+        "银行卡": "bank_pay",
+        "数字人民币": "dcep_pay",
+        "会员卡": "card_pay",
+        "券": "quan_pay",
+        "收银券": "cashier_quan_pay",
+        "支付宝": "ali_pay",
+        "微信": "wx_pay",
+        "总部聚合": "zb_jh_pay",
+        "影城聚合": "yc_jh_pay",
+        "绿云会员": "ly_pay",
+        "其他支付": "other_pay",
+    }
+    for label, field in pay_keys.items():
+        summary["payment_breakdown"][label] = _to_float(
+            _exp(f"=DBSUM(#{{goods_sales_2.{field}}})")
+        )
+
+    goods_sales = data_list.get("goods_sales_2") or {}
+    items = goods_sales.get("list") or []
+    summary["page_total_records"] = int(_to_float(goods_sales.get("count")))
+    summary["page_total_real_count"] = int(_to_float(goods_sales.get("total")))
+
+    if items:
+        df = pd.DataFrame(items)
+        summary["items"] = df
+        summary["list_count"] = len(df)
+        if "real_amount" in df.columns:
+            summary["list_total_real_amount"] = pd.to_numeric(df["real_amount"], errors="coerce").fillna(0).sum()
+        if "sales_amount" in df.columns:
+            summary["list_total_sales_amount"] = pd.to_numeric(df["sales_amount"], errors="coerce").fillna(0).sum()
+        if "sales_num" in df.columns:
+            summary["list_total_sales_num"] = pd.to_numeric(df["sales_num"], errors="coerce").fillna(0).sum()
+
+    return summary
+
+
+def build_business_window(query_date: dt_date) -> tuple[str, str]:
+    """卖品报表口径：当日 06:00 - 次日 06:00。"""
+    start = datetime.combine(query_date, datetime.min.time()).replace(hour=6)
+    end = start + timedelta(days=1)
+    fmt = "%Y-%m-%d %H:%M:%S"
+    return start.strftime(fmt), end.strftime(fmt)
+
+
+# ---------------------------------------------------------------------------
+# UI - 步骤 1：OA JSESSIONID + 自动换 Token
+# ---------------------------------------------------------------------------
+st.subheader("① 通过 OA SSO 自动获取 Bearer Token")
+
+with st.expander("🔑 如何获取 OA 的 JSESSIONID（一次粘贴，用一整天）", expanded=False):
+    st.markdown(
+        """
+1. 浏览器登录 [https://oa.hengdianfilm.com/seeyon/main.do?method=main](https://oa.hengdianfilm.com/seeyon/main.do?method=main)。
+2. 按 **F12** 打开开发者工具 → **Application(应用)** → **Cookies** → 选 `https://oa.hengdianfilm.com`。
+3. 找到 `JSESSIONID`（一串大写字母数字），写入系统环境变量或 `.env` 的 `OA_JSESSIONID`。
+   如中转仍提示重新登录，可改用完整 Cookie 字符串写入 `OA_COOKIE`。
+4. 页面只读取系统变量，不再接受手动输入；修改后请重启 Streamlit 让变量生效。
+        """
+    )
+
+proxy_base_url = get_new_api_proxy_base_url()
+proxy_display_url = proxy_base_url.split("?", 1)[0] + ("?..." if "?" in proxy_base_url else "")
+if proxy_base_url:
+    fallback_label = "开启" if new_api_proxy_direct_fallback_enabled() else "关闭"
+    st.caption(
+        f"当前 OA SSO / OAuth / jmreport 全链路都将通过专用中转代理访问：{proxy_display_url}；"
+        f"OAuth 和 jmreport 的本机直连回退：{fallback_label}。境外服务器建议关闭回退。"
+    )
+    if not os.getenv(NEW_API_PROXY_TOKEN_ENV, "").strip():
+        st.warning(f"已配置 `{NEW_API_PROXY_URL_ENV}`，但未配置 `{NEW_API_PROXY_TOKEN_ENV}`，中转请求会被代理拒绝。")
+    if os.getenv(NEW_API_PROXY_AUTH_QUERY_ENV, "").strip():
+        st.info(f"已配置 `{NEW_API_PROXY_AUTH_QUERY_ENV}`，代理请求会自动附加 EdgeOne URL 鉴权参数。")
+else:
+    st.caption(f"当前 OA SSO / OAuth / jmreport 均为直连；配置 `{NEW_API_PROXY_URL_ENV}` 后会自动启用全链路中转代理。")
+
+with st.expander("⚙️ SSO / OAuth 高级参数（一般无需改动）", expanded=False):
+    col_a, col_b = st.columns(2)
+    with col_a:
+        sso_app_id_input = st.text_input("SSO 应用 ID（id 参数，固定）", value=SSO_APP_ID, key="sales_sso_app_id")
+        sso_page_url_input = st.text_input("SSO 回跳 URL（pageUrl 参数）", value=SSO_PAGE_URL, key="sales_sso_page_url")
+    with col_b:
+        oauth_code_input = st.text_input("oauth code", value=DEFAULT_OAUTH_CODE, key="sales_oauth_code")
+        oauth_grant_input = st.text_input("oauth grant_type", value=DEFAULT_OAUTH_GRANT, key="sales_oauth_grant")
+        oauth_basic_input = st.text_input("oauth Basic Auth", value=DEFAULT_OAUTH_BASIC, key="sales_oauth_basic")
+
+env_jsessionid = DEFAULT_OA_JSESSIONID.strip()
+env_oa_cookie = DEFAULT_OA_COOKIE.strip()
+if env_oa_cookie:
+    st.success("已从系统变量 `OA_COOKIE` 读取完整 OA Cookie。")
+elif env_jsessionid:
+    st.success("已从系统变量 `OA_JSESSIONID` 读取 OA 会话。")
+else:
+    st.error("未配置系统变量 `OA_JSESSIONID` 或 `OA_COOKIE`，无法自动获取 Token。")
+
+col_btn, col_info = st.columns([1, 3])
+with col_btn:
+    go_clicked = st.button("🚀 一键获取 Token", type="primary", use_container_width=True)
+
+if go_clicked:
+    jsessionid = env_jsessionid
+    if not jsessionid and not env_oa_cookie:
+        st.error("请先配置系统变量 `OA_JSESSIONID` 或 `OA_COOKIE`。")
+    else:
+        # ① SSO 取 ticket
+        with st.spinner("Step 1/2 调用 OA SSO 获取 ticket…"):
+            try:
+                ticket, sso_debug, center_cookies = fetch_sso_ticket(
+                    jsessionid,
+                    app_id=sso_app_id_input.strip() or SSO_APP_ID,
+                    page_url=sso_page_url_input.strip() or SSO_PAGE_URL,
+                    proxy_url=proxy_base_url,
+                )
+            except requests.HTTPError as exc:
+                st.error(f"SSO HTTP 错误：{exc.response.status_code} {exc.response.reason}")
+                if exc.response is not None:
+                    st.code(exc.response.text[:1000])
+                ticket = None
+                sso_debug = None
+                center_cookies = {}
+            except Exception as exc:  # noqa: BLE001
+                st.error(f"SSO 调用失败：{exc}")
+                ticket = None
+                sso_debug = None
+                center_cookies = {}
+
+        if ticket:
+            st.session_state.sales_ticket = ticket
+            st.session_state.sales_ticket_fetched_at = datetime.now()
+            with st.expander("🔍 SSO 调试信息", expanded=False):
+                st.json(sso_debug)
+
+            # ② 用 ticket 换 token
+            with st.spinner("Step 2/2 用 ticket 换 Bearer Token…"):
+                try:
+                    token_data, proxy_warning = fetch_oauth_token(
+                        mobile=ticket,
+                        code=oauth_code_input.strip(),
+                        grant_type=oauth_grant_input.strip(),
+                        basic_auth=oauth_basic_input.strip(),
+                        cookies=center_cookies,
+                        proxy_url=proxy_base_url,
+                    )
+                    if proxy_warning:
+                        st.warning(proxy_warning)
+                except requests.HTTPError as exc:
+                    st.error(f"OAuth HTTP 错误：{exc.response.status_code} {exc.response.reason}")
+                    if exc.response is not None:
+                        st.code(exc.response.text[:500])
+                    token_data = None
+                except Exception as exc:  # noqa: BLE001
+                    st.error(f"OAuth 调用失败：{exc}")
+                    token_data = None
+
+            if token_data:
+                access_token = token_data.get("access_token") or ""
+                if access_token:
+                    st.session_state.sales_token = access_token
+                    st.session_state.sales_token_meta = token_data
+                    st.session_state.sales_token_fetched_at = datetime.now()
+                    st.toast("Token 获取成功 ✅")
+                else:
+                    st.error("OAuth 响应中未找到 access_token。")
+                    st.json(token_data)
+
+with col_info:
+    if st.session_state.sales_token:
+        meta = st.session_state.sales_token_meta or {}
+        fetched_at = st.session_state.sales_token_fetched_at
+        ticket_at = st.session_state.sales_ticket_fetched_at
+        expires_in = int(meta.get("expires_in") or 0)
+        token_preview = st.session_state.sales_token[:8] + "…" + st.session_state.sales_token[-4:]
+        ticket_preview = (st.session_state.sales_ticket or "")[:6] + "…"
+        info_lines = [
+            f"**Token**：`{token_preview}`",
+            f"**Ticket**：`{ticket_preview}`（一次性，已用完）",
+            f"**用户**：{meta.get('name', '-')}（{meta.get('username', '-')}）",
+            f"**影城**：{meta.get('userdomainname', '-')}",
+        ]
+        if fetched_at:
+            info_lines.append(f"**Token 获取时间**：{fetched_at.strftime('%Y-%m-%d %H:%M:%S')}")
+        if expires_in:
+            info_lines.append(f"**Token 有效期**：约 {expires_in // 3600} 小时 {expires_in % 3600 // 60} 分钟")
+        st.success("\n\n".join(info_lines))
+    elif st.session_state.sales_ticket:
+        st.warning(f"已拿到 ticket（{st.session_state.sales_ticket[:6]}…），但 token 换取失败。")
+    else:
+        st.info("尚未获取 Token，确认 `OA_JSESSIONID` 已配置后点左侧按钮。")
+
+
+# ---------------------------------------------------------------------------
+# UI - 步骤 2：拉取销售数据
+# ---------------------------------------------------------------------------
+st.divider()
+st.subheader("② 查询当日卖品销售数据")
+
+col_date, col_size, col_btn = st.columns([2, 1, 1])
+with col_date:
+    query_date = st.date_input(
+        "营业日（06:00 ~ 次日 06:00）",
+        value=st.session_state.sales_query_date,
+        key="sales_date_input",
+    )
+with col_size:
+    page_size = st.number_input("pageSize", min_value=10, max_value=500, value=100, step=10)
+with col_btn:
+    st.write("")
+    fetch_clicked = st.button("📊 查询销售总额", type="primary", use_container_width=True)
+
+start_str, end_str = build_business_window(query_date)
+st.caption(f"时间范围：`{start_str}` → `{end_str}`")
+
+if fetch_clicked:
+    if not st.session_state.sales_token:
+        st.error("请先完成步骤 ① 获取 Token。")
+    else:
+        st.session_state.sales_query_date = query_date
+        with st.spinner("调用 jmreport 接口中…"):
+            try:
+                payload, proxy_warning = fetch_jmreport_show(
+                    token=st.session_state.sales_token,
+                    start=start_str,
+                    end=end_str,
+                    page_no=1,
+                    page_size=int(page_size),
+                    proxy_url=proxy_base_url,
+                )
+                if proxy_warning:
+                    st.warning(proxy_warning)
+            except requests.HTTPError as exc:
+                st.error(f"HTTP 错误：{exc.response.status_code} {exc.response.reason}")
+                if exc.response is not None:
+                    st.code(exc.response.text[:1000])
+                payload = None
+            except Exception as exc:  # noqa: BLE001
+                st.error(f"调用失败：{exc}")
+                payload = None
+
+        if payload:
+            if not payload.get("success", True):
+                st.error(f"接口业务失败：{payload.get('message') or payload}")
+            st.session_state.sales_last_payload = payload
+            st.session_state.sales_last_summary = summarize_payload(payload)
+
+
+# ---------------------------------------------------------------------------
+# UI - 步骤 3：展示结果
+# ---------------------------------------------------------------------------
+summary = st.session_state.sales_last_summary
+if summary:
+    st.divider()
+    st.subheader("③ 销售汇总结果")
+
+    real_amount = summary["report_total_real_amount"] or 0.0
+    sales_amount = summary["report_total_sales_amount"] or 0.0
+    sales_num = int(summary["report_total_sales_num"] or 0)
+
+    st.markdown(
+        f"""
+        <div style="margin: 12px 0 18px; padding: 18px 22px; border-left: 6px solid #D83B01;
+                    background: #FFF4ED; border-radius: 4px;">
+            <div style="font-size: 16px; color: #5C1F00; margin-bottom: 6px;">
+                {query_date.strftime('%Y-%m-%d')} 卖品 <b>实付金额</b> 总额
+            </div>
+            <span style="font-size: 38px; font-weight: 800; color: #D83B01;">¥ {real_amount:,.2f}</span>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    m1, m2, m3, m4 = st.columns(4)
+    m1.metric("实付金额（汇总）", f"¥ {real_amount:,.2f}")
+    m2.metric("销售额（柜台价）", f"¥ {sales_amount:,.2f}")
+    m3.metric("销售件数", f"{sales_num:,}")
+    m4.metric(
+        "本页明细行数",
+        f"{summary['list_count']} / {summary['page_total_records']}",
+        help="当前页明细行数 / 全量记录数",
+    )
+
+    list_real = summary["list_total_real_amount"]
+    if summary["list_count"]:
+        diff = real_amount - list_real
+        st.caption(
+            f"本页明细 real_amount 累计：¥ {list_real:,.2f}　|　与汇总差额：¥ {diff:,.2f}"
+            "（差额非 0 表示当日数据超出当前页，可调大 pageSize 或翻页）"
+        )
+
+    pay_df = (
+        pd.DataFrame(
+            [
+                {"支付方式": label, "金额": amount}
+                for label, amount in summary["payment_breakdown"].items()
+            ]
+        )
+        .sort_values("金额", ascending=False)
+        .reset_index(drop=True)
+    )
+    pay_df_nonzero = pay_df[pay_df["金额"] > 0]
+
+    col_pay, col_chart = st.columns([1, 1])
+    with col_pay:
+        st.markdown("**支付方式拆分（全量）**")
+        if pay_df_nonzero.empty:
+            st.info("无支付方式数据。")
+        else:
+            st.dataframe(
+                pay_df_nonzero.style.format({"金额": "¥ {:,.2f}"}),
+                hide_index=True,
+                width="stretch",
+            )
+    with col_chart:
+        if not pay_df_nonzero.empty:
+            st.markdown("**金额占比**")
+            st.bar_chart(pay_df_nonzero.set_index("支付方式")["金额"], height=240)
+
+    items_df = summary["items"]
+    if isinstance(items_df, pd.DataFrame) and not items_df.empty:
+        with st.expander(f"📋 当前页明细（{summary['list_count']} 行）", expanded=False):
+            preferred_cols = [
+                "sales_time",
+                "order_code",
+                "channel",
+                "sales_address",
+                "goods_name",
+                "goods_category_level1",
+                "sales_num",
+                "counter_price",
+                "sales_amount",
+                "real_amount",
+                "pay_type",
+                "pay_detail",
+                "salesman",
+            ]
+            cols = [c for c in preferred_cols if c in items_df.columns]
+            display_df = items_df[cols] if cols else items_df
+            st.dataframe(display_df, hide_index=True, width="stretch")
+
+    with st.expander("🐛 原始 payload（result.dataList 结构）", expanded=False):
+        st.json(st.session_state.sales_last_payload)
+else:
+    st.info("尚无查询结果。请完成上面两步后查看汇总。")

pages/🆕 新API影片映出日累计报表测试.py

@@ -0,0 +1,767 @@
+"""新 API（center.hengdianfilm.com / cinema/movieshow/page）测试页面。
+
+复用 app.py 的「影片映出日累计报表」生成逻辑，但数据来源切换为：
+1. 直接调用新 API 拉取（需 Bearer Token）
+2. 手动粘贴 API 返回 JSON 文本
+
+最终生成同样格式的报表，并支持下载 XLSX。
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import re
+from datetime import date as dt_date, datetime, time as dt_time, timedelta
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import requests
+import streamlit as st
+from dotenv import load_dotenv
+from new_api_proxy import (
+    NEW_API_PROXY_AUTH_QUERY_ENV,
+    NEW_API_PROXY_TOKEN_ENV,
+    NEW_API_PROXY_URL_ENV,
+    build_new_api_proxy_url,
+    get_new_api_proxy_base_url,
+    with_new_api_proxy_headers,
+)
+
+
+load_dotenv(override=True)
+
+
+# ---------------------------------------------------------------------------
+# 页面配置
+# ---------------------------------------------------------------------------
+st.set_page_config(layout="wide", page_title="🆕 新 API 影片映出日累计报表测试")
+st.title("🆕 新 API 影片映出日累计报表测试")
+st.caption(
+    "测试 `https://center.hengdianfilm.com/cinema/movieshow/page` 接口，"
+    "数据可由 API 抓取或直接粘贴 JSON 返回。生成与 `app.py` 一致格式的「影片映出日累计报表」。"
+)
+
+
+# ---------------------------------------------------------------------------
+# 常量与路径
+# ---------------------------------------------------------------------------
+ROOT_DIR = Path(__file__).resolve().parent.parent
+CINEMA_CACHE_DIR = ROOT_DIR / "cinema_cache"
+MOVIE_NUM_NAME_MAP_FILE = CINEMA_CACHE_DIR / "movie_num_name_map.json"
+NEW_API_URL = "https://center.hengdianfilm.com/cinema/movieshow/page"
+DEFAULT_PAGE_SIZE = 200
+DEFAULT_BEARER_TOKEN = ""
+
+SSO_APP_ID = os.getenv("CENTER_SSO_APP_ID", "-28746303884891748910")
+SSO_PAGE_URL = os.getenv("CENTER_SSO_PAGE_URL", "https://center.hengdianfilm.com/")
+DEFAULT_OA_JSESSIONID = os.getenv("OA_JSESSIONID", "")
+DEFAULT_OA_COOKIE = os.getenv("OA_COOKIE", "")
+DEFAULT_OAUTH_CODE = os.getenv("CENTER_OAUTH_CODE", "1234")
+DEFAULT_OAUTH_GRANT = os.getenv("CENTER_OAUTH_GRANT_TYPE", "oa")
+DEFAULT_OAUTH_BASIC = os.getenv("CENTER_OAUTH_BASIC", "Basic b2E6b2E=")
+
+
+# ---------------------------------------------------------------------------
+# 工具函数（与 app.py 保持一致；为保持本页独立，做了最小复制）
+# ---------------------------------------------------------------------------
+def _format_sso_ticket_proxy_error(data):
+    if not isinstance(data, dict) or data.get("error") != "ticket-not-found":
+        return None
+
+    debug = data.get("debug") or {}
+    body_preview = str(debug.get("body_preview") or "")
+    upstream_status = data.get("upstreamStatus") or debug.get("status") or "-"
+    location = debug.get("location") or "-"
+    if "请重新登录" in body_preview:
+        return (
+            "OA 登录态已失效：OA 返回“请重新登录后再试”。"
+            "请在浏览器重新登录 OA，复制最新完整 Cookie 写入 `.env` 的 `OA_COOKIE`"
+            "（或至少更新 `OA_JSESSIONID`），然后重启 Streamlit。"
+            f"上游状态码={upstream_status}。"
+        )
+    return (
+        "未能从 OA SSO 响应中提取到 ticket。"
+        f"上游状态码={upstream_status}，Location={location}，响应预览={body_preview or data}"
+    )
+
+
+def _normalize_movie_num_key(movie_num) -> str:
+    return re.sub(r"[^A-Z0-9]", "", str(movie_num or "").strip().upper())
+
+
+@st.cache_data(show_spinner=False, ttl=120)
+def _load_movie_num_name_map() -> dict:
+    """读取 cinema_cache/movie_num_name_map.json，返回 {规范化 movieNum: 官方名称}。"""
+    if not MOVIE_NUM_NAME_MAP_FILE.exists():
+        return {}
+    try:
+        with open(MOVIE_NUM_NAME_MAP_FILE, "r", encoding="utf-8") as f:
+            payload = json.load(f)
+    except Exception:
+        return {}
+    movie_num_map = payload.get("movie_num_map", {})
+    if not isinstance(movie_num_map, dict):
+        return {}
+    result = {}
+    for movie_num, entry in movie_num_map.items():
+        key = _normalize_movie_num_key(movie_num)
+        if not key:
+            continue
+        if isinstance(entry, str):
+            name = entry.strip()
+        elif isinstance(entry, dict):
+            name = str(entry.get("official_name") or "").strip()
+        else:
+            continue
+        if name:
+            result[key] = name
+    return result
+
+
+def clean_movie_title(raw_title, canonical_names=None):
+    """与 app.py 同名函数完全一致的精简版。"""
+    if not isinstance(raw_title, str):
+        return raw_title
+    base_name = None
+    if canonical_names:
+        sorted_names = sorted(canonical_names, key=len, reverse=True)
+        for name in sorted_names:
+            if name in raw_title:
+                base_name = name
+                break
+    if not base_name:
+        base_name = raw_title.split(" ", 1)[0]
+
+    raw_upper = raw_title.upper()
+    suffix = ""
+    if "HDR LED" in raw_upper:
+        suffix = "（HDR LED）"
+    elif "CINITY" in raw_upper:
+        suffix = "（CINITY）"
+    elif "杜比" in raw_upper or "DOLBY" in raw_upper:
+        suffix = "（杜比视界）"
+    elif "IMAX" in raw_upper:
+        suffix = "（数字IMAX3D）" if "3D" in raw_upper else "（数字IMAX）"
+    elif "巨幕" in raw_upper:
+        suffix = "（中国巨幕立体）" if "立体" in raw_upper else "（中国巨幕）"
+    elif "3D" in raw_upper:
+        suffix = "（数字3D）"
+
+    if suffix and suffix not in base_name:
+        return f"{base_name}{suffix}"
+    return base_name
+
+
+def resolve_movie_name_from_schedule_item(raw_movie_name, movie_num=None, canonical_names=None):
+    """与 app.py 同名函数一致：优先用 movieNum 映射，回退到 canonical_names / 空格分割。"""
+    if not isinstance(raw_movie_name, str):
+        return raw_movie_name
+    if movie_num:
+        key = _normalize_movie_num_key(movie_num)
+        if key:
+            official = _load_movie_num_name_map().get(key)
+            if official:
+                return official
+
+    if canonical_names:
+        for name in sorted(canonical_names, key=len, reverse=True):
+            if name in raw_movie_name:
+                return name
+    return raw_movie_name.split(" ", 1)[0]
+
+
+def normalize_report_time_value(value):
+    if pd.isna(value):
+        return None
+    if isinstance(value, datetime):
+        return value.time().replace(second=0, microsecond=0)
+    if isinstance(value, dt_time):
+        return value.replace(second=0, microsecond=0)
+    parsed = pd.to_datetime(str(value).strip(), errors="coerce")
+    if pd.isna(parsed):
+        return None
+    return parsed.time().replace(second=0, microsecond=0)
+
+
+def infer_daily_report_date(date_series, fallback_date_str=None):
+    parsed = pd.to_datetime(date_series, errors="coerce").dropna()
+    if not parsed.empty:
+        return parsed.dt.date.mode().iloc[0]
+    if fallback_date_str:
+        fb = pd.to_datetime(fallback_date_str, errors="coerce")
+        if pd.notna(fb):
+            return fb.date()
+    return None
+
+
+def build_daily_report_from_source_df(source_df, selected_date_str=None, canonical_names=None):
+    """与 app.py 中 build_daily_report_from_source_df 一致，返回 (df, display_date)。"""
+    if source_df is None or source_df.empty:
+        return pd.DataFrame(), infer_daily_report_date(pd.Series(dtype=object), selected_date_str)
+
+    required_cols = ["影片名称", "放映时间", "影厅名称", "总人次", "座位数"]
+    missing = [c for c in required_cols if c not in source_df.columns]
+    if missing:
+        st.error(f"数据缺少必要列: {', '.join(missing)}")
+        return pd.DataFrame(), None
+
+    df = source_df.copy()
+    if "放映日期" not in df.columns:
+        df["放映日期"] = selected_date_str
+
+    display_date = infer_daily_report_date(df["放映日期"], selected_date_str)
+    display_date_str = display_date.strftime("%Y-%m-%d") if display_date else selected_date_str
+
+    df["影片名称"] = df["影片名称"].astype(str).str.strip()
+    df["影厅名称"] = df["影厅名称"].fillna("未知影厅").astype(str).str.strip()
+    df["总人次"] = pd.to_numeric(df["总人次"], errors="coerce").fillna(0).round().astype(int)
+    df["座位数"] = pd.to_numeric(df["座位数"], errors="coerce").fillna(0).round().astype(int)
+    df["_放映时间对象"] = df["放映时间"].apply(normalize_report_time_value)
+    df["放映日期"] = pd.to_datetime(df["放映日期"], errors="coerce").dt.strftime("%Y-%m-%d")
+    if display_date_str:
+        df["放映日期"] = df["放映日期"].fillna(display_date_str)
+
+    df.dropna(subset=["影片名称", "_放映时间对象"], inplace=True)
+    df = df[df["影片名称"].ne("") & df["影片名称"].ne("nan")].copy()
+    df = df[df["总人次"] > 0].copy()
+
+    if df.empty:
+        st.info("所有场次的观影人数均为 0，没有可显示的数据。")
+        return pd.DataFrame(), display_date
+
+    if "movieNum" in df.columns:
+        df["影片"] = df.apply(
+            lambda row: resolve_movie_name_from_schedule_item(
+                row["影片名称"],
+                movie_num=row.get("movieNum"),
+                canonical_names=canonical_names,
+            ),
+            axis=1,
+        )
+    else:
+        df["影片"] = df["影片名称"].apply(lambda x: clean_movie_title(x, canonical_names))
+    df["影厅"] = df["影厅名称"]
+    df["人数合计"] = df["总人次"]
+
+    with np.errstate(divide="ignore", invalid="ignore"):
+        df["上座率%"] = np.divide(df["人数合计"], df["座位数"]) * 100
+        df["上座率%"] = df["上座率%"].replace([np.inf, -np.inf], 0).fillna(0)
+
+    df["放映时间"] = df["_放映时间对象"].apply(lambda x: x.strftime("%H:%M:%S"))
+    result = df[["影片", "放映日期", "放映时间", "影厅", "人数合计", "座位数", "上座率%"]].copy()
+    result = result.sort_values(by=["放映日期", "放映时间", "影厅", "影片"]).reset_index(drop=True)
+    return result, display_date
+
+
+# ---------------------------------------------------------------------------
+# 新 API 数据获取与解析
+# ---------------------------------------------------------------------------
+class NewApiProxyPlatformError(RuntimeError):
+    def __init__(self, step: str, message: str) -> None:
+        super().__init__(
+            f"{step} 被 EdgeOne Pages 外层鉴权拦截：{message}。"
+            f"请确认 `{NEW_API_PROXY_AUTH_QUERY_ENV}` 里的 `eo_time` / `eo_token` 仍有效。"
+        )
+
+
+class NewApiProxyFunctionMissingError(RuntimeError):
+    def __init__(self, step: str, path: str) -> None:
+        super().__init__(
+            f"{step} 没有命中 EdgeOne edge-functions：{path}。"
+            "请把 `new-api-edgeone-pages` 重新部署到 EdgeOne Pages。"
+        )
+
+
+def _raise_for_proxy_platform_error(resp: requests.Response, step: str) -> None:
+    eop_msg = resp.headers.get("X-EOP-MSG")
+    server = resp.headers.get("Server", "")
+    if resp.status_code in {401, 403} and (eop_msg or "edgeone-pages" in server.lower()):
+        raise NewApiProxyPlatformError(step, eop_msg or "Access Restricted or Authentication Expired")
+
+
+def _raise_for_proxy_missing_function(resp: requests.Response, step: str, path: str) -> None:
+    body = resp.text or ""
+    if not resp.headers.get("X-New-API-Proxy") and resp.status_code in {404, 405} and (
+        "<Code>MethodNotAllowed</Code>" in body or "<Code>NoSuchKey</Code>" in body
+    ):
+        raise NewApiProxyFunctionMissingError(step, path)
+
+
+def _post_new_api_proxy_json(path: str, payload: dict, timeout: int = 25) -> requests.Response:
+    proxy_base_url = get_new_api_proxy_base_url()
+    if not proxy_base_url:
+        raise RuntimeError(f"未配置 `{NEW_API_PROXY_URL_ENV}`，无法通过中转代理访问境内接口。")
+
+    headers = with_new_api_proxy_headers({"accept": "application/json"}, proxy_base_url)
+    session = requests.Session()
+    resp = session.post(
+        build_new_api_proxy_url(path, proxy_base_url),
+        headers=headers,
+        json=payload,
+        timeout=timeout,
+        allow_redirects=False,
+    )
+    if resp.status_code in {301, 302, 303, 307, 308} and resp.headers.get("Location"):
+        resp = session.post(
+            requests.compat.urljoin(resp.url, resp.headers["Location"]),
+            headers=headers,
+            json=payload,
+            timeout=timeout,
+            allow_redirects=False,
+        )
+    return resp
+
+
+def fetch_center_token_auto() -> tuple[str, dict]:
+    """通过 EdgeOne 中转自动完成 OA SSO -> ticket -> OAuth token。"""
+    if not DEFAULT_OA_COOKIE.strip() and not DEFAULT_OA_JSESSIONID.strip():
+        raise ValueError("请先在 `.env` 配置 `OA_COOKIE` 或 `OA_JSESSIONID`。")
+
+    sso_payload = {
+        "jsessionid": DEFAULT_OA_JSESSIONID.strip(),
+        "oaCookie": DEFAULT_OA_COOKIE.strip(),
+        "appId": SSO_APP_ID,
+        "pageUrl": SSO_PAGE_URL,
+    }
+    sso_resp = _post_new_api_proxy_json("/new-api/sso-ticket", sso_payload, timeout=25)
+    _raise_for_proxy_platform_error(sso_resp, "OA SSO ticket 中转")
+    _raise_for_proxy_missing_function(sso_resp, "OA SSO ticket 中转", "/new-api/sso-ticket")
+    if not sso_resp.ok:
+        try:
+            error_data = sso_resp.json()
+        except ValueError:
+            error_data = {}
+        error_message = _format_sso_ticket_proxy_error(error_data)
+        if error_message:
+            raise RuntimeError(error_message)
+    sso_resp.raise_for_status()
+    sso_data = sso_resp.json()
+    ticket = str(sso_data.get("ticket") or "").strip()
+    if not ticket:
+        error_message = _format_sso_ticket_proxy_error(sso_data)
+        if error_message:
+            raise RuntimeError(error_message)
+        raise RuntimeError(f"OA SSO 中转未返回 ticket：{sso_data}")
+
+    oauth_payload = {
+        "mobile": ticket,
+        "code": DEFAULT_OAUTH_CODE,
+        "grantType": DEFAULT_OAUTH_GRANT,
+        "basicAuth": DEFAULT_OAUTH_BASIC,
+        "cookies": sso_data.get("centerCookies") or {},
+    }
+    oauth_resp = _post_new_api_proxy_json("/new-api/oauth-token", oauth_payload, timeout=25)
+    _raise_for_proxy_platform_error(oauth_resp, "OAuth token 中转")
+    _raise_for_proxy_missing_function(oauth_resp, "OAuth token 中转", "/new-api/oauth-token")
+    oauth_resp.raise_for_status()
+    token_data = oauth_resp.json()
+    access_token = str(token_data.get("access_token") or "").strip()
+    if not access_token:
+        raise RuntimeError(f"OAuth 响应中未找到 access_token：{token_data}")
+
+    debug = {
+        "sso": sso_data.get("debug") or {},
+        "oauth": {
+            k: v
+            for k, v in token_data.items()
+            if k not in {"access_token", "refresh_token"}
+        },
+    }
+    return access_token, debug
+
+
+def _build_request_headers(bearer_token: str) -> dict:
+    return {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:115.0) Gecko/20100101 Firefox/115.0",
+        "Accept": "application/json, text/plain, */*",
+        "Accept-Language": "zh-CN,zh;q=0.9",
+        "Content-Type": "application/json;charset=utf-8",
+        "Authorization": f"Bearer {bearer_token.strip()}",
+        "TENANT-ID": "1",
+        "Channel": "4",
+        "Origin": "https://center.hengdianfilm.com",
+        "Referer": "https://center.hengdianfilm.com/",
+        "Connection": "keep-alive",
+    }
+
+
+def fetch_movieshow_page(bearer_token: str, show_date: str, current: int = 1, size: int = DEFAULT_PAGE_SIZE):
+    """单次拉取一页排片数据。返回原始 JSON dict。"""
+    payload = {
+        "size": size,
+        "current": current,
+        "entity": {"cinemaMovieShowDate": show_date},
+    }
+    proxy_base_url = get_new_api_proxy_base_url()
+    if proxy_base_url:
+        resp = _post_new_api_proxy_json(
+            "/new-api/movieshow-page",
+            {
+                "token": bearer_token,
+                "showDate": show_date,
+                "current": current,
+                "size": size,
+            },
+            timeout=25,
+        )
+        _raise_for_proxy_platform_error(resp, "movieshow/page 中转")
+        _raise_for_proxy_missing_function(resp, "movieshow/page 中转", "/new-api/movieshow-page")
+        resp.raise_for_status()
+        return resp.json()
+
+    resp = requests.post(
+        NEW_API_URL,
+        headers=_build_request_headers(bearer_token),
+        data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+        timeout=20,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+def fetch_all_movieshow(bearer_token: str, show_date: str, size: int = DEFAULT_PAGE_SIZE) -> list:
+    """自动翻页拉取所有场次记录。"""
+    all_records: list = []
+    current = 1
+    while True:
+        data = fetch_movieshow_page(bearer_token, show_date, current=current, size=size)
+        if data.get("code") != 0:
+            raise RuntimeError(f"接口返回失败：{data.get('msg') or data}")
+        body = data.get("data") or {}
+        records = body.get("records") or []
+        all_records.extend(records)
+        total = int(body.get("total") or 0)
+        if len(all_records) >= total or not records:
+            break
+        current += 1
+        if current > 50:  # 安全阈值
+            break
+    return all_records
+
+
+def parse_pasted_response(raw_text: str) -> list:
+    """解析用户粘贴的 JSON 响应文本，返回 records 列表。"""
+    text = (raw_text or "").strip()
+    if not text:
+        raise ValueError("粘贴内容为空。")
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"JSON 解析失败：{exc}") from exc
+
+    # 用户既可能粘贴整个响应，也可能直接粘贴 records 列表
+    if isinstance(payload, list):
+        return payload
+    if not isinstance(payload, dict):
+        raise ValueError("无法识别的 JSON 结构，期望对象或数组。")
+
+    if "data" in payload and isinstance(payload["data"], dict):
+        records = payload["data"].get("records")
+        if isinstance(records, list):
+            return records
+    if "records" in payload and isinstance(payload["records"], list):
+        return payload["records"]
+    raise ValueError("未在 JSON 中找到 records 数组。请粘贴接口完整返回或 records 列表。")
+
+
+def records_to_source_df(records: list) -> pd.DataFrame:
+    """将新 API 返回的场次列表转换成 build_daily_report_from_source_df 期望的列结构。"""
+    if not records:
+        return pd.DataFrame()
+    rows = []
+    for item in records:
+        if not isinstance(item, dict):
+            continue
+        rows.append(
+            {
+                "影片名称": item.get("cinemaMovieName") or "",
+                "放映时间": item.get("cinemaMovieShowStartTime") or "",
+                "影厅名称": item.get("cinemaHallName") or "",
+                "总人次": item.get("cinemaMovieShowSoldNum") or 0,
+                "座位数": item.get("cinemaHallSeatNum") or 0,
+                "放映日期": item.get("cinemaMovieShowDate") or "",
+                "movieNum": item.get("cinemaMovieNum") or "",
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+# ---------------------------------------------------------------------------
+# Session State 初始化
+# ---------------------------------------------------------------------------
+def _init_state():
+    defaults = {
+        "new_api_bearer_token": os.getenv("HENGDIAN_CENTER_TOKEN", DEFAULT_BEARER_TOKEN),
+        "new_api_token_debug": {},
+        "new_api_token_fetched_at": None,
+        "new_api_query_date": dt_date.today() + timedelta(days=1),
+        "new_api_records": [],
+        "new_api_report_df": pd.DataFrame(),
+        "new_api_display_date": None,
+        "new_api_data_source": "",
+        "new_api_paste_text": "",
+    }
+    for key, value in defaults.items():
+        st.session_state.setdefault(key, value)
+
+
+_init_state()
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+with st.expander("📘 接口说明", expanded=False):
+    st.markdown(
+        f"""
+- **接口**：`POST {NEW_API_URL}`
+- **必备 Header**：`Authorization: Bearer <token>`、`TENANT-ID: 1`、`Channel: 4`、`Content-Type: application/json;charset=utf-8`
+- **请求体**：`{{"size": 100, "current": 1, "entity": {{"cinemaMovieShowDate": "YYYY-MM-DD"}}}}`
+- **关键返回字段**：
+  - `cinemaMovieName` → 影片名称（含制式）
+  - `cinemaMovieNum` → 影片编号（用于 `movie_num_name_map.json` 标准名映射）
+  - `cinemaMovieShowStartTime` → 放映开始时间
+  - `cinemaHallName` / `cinemaHallSeatNum` → 影厅名称 / 座位数
+  - `cinemaMovieShowSoldNum` → 已售人次
+        """
+    )
+
+with st.expander("🔑 手动 Bearer Token 备用获取方式", expanded=False):
+    st.markdown(
+        """
+> 本页默认会通过 OA SSO 自动获取 Token；下面的方法只用于自动获取失败时临时排查。
+> Token 是登录后由浏览器临时保存的身份凭证,**有效期通常只有几小时到一天**,失效后需要重新抓取。
+
+#### 方法 A:从「Network(网络)」面板抓取(推荐,最准确)
+
+1. 用 Chrome / Edge / Firefox 打开 [https://center.hengdianfilm.com/](https://center.hengdianfilm.com/) 并**正常登录**。
+2. 按 **F12**(或右键 → **检查 / Inspect**)打开开发者工具,切换到 **Network(网络)** 面板。
+3. 勾选 **Preserve log(保留日志)**,在过滤框里输入关键字 `movieshow` 或 `cinema/`,过滤出业务接口。
+4. 在网页上**点击任意会触发刷新数据的操作**(例如切换日期、点查询),让接口重新发一次请求。
+5. 在过滤结果里点击一条形如 `movieshow/page` 的请求 → 切到 **Headers(标头)** 子面板 → 找到 **Request Headers(请求标头)**。
+6. 复制 `Authorization:` 这一行后面的内容,**去掉开头的 `Bearer `**,只保留后面那串形如 `40ea061e-598e-4e6f-8f98-...` 的字符串,粘贴到下方输入框即可。
+
+#### 方法 B:从「Application / 存储」面板里直接读取
+
+1. 同样打开开发者工具,切到 **Application(应用)** 面板(Firefox 叫 **Storage / 存储**)。
+2. 左侧依次点开 **Local Storage** 和 **Cookies**,目标域名选 `https://center.hengdianfilm.com`。
+3. 在右侧的键值对里搜索关键字: `token`、`access_token`、`Authorization`、`auth`、`satoken`。
+4. 找到形如 UUID(`xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`)的值,复制粘贴到下方输入框。
+
+#### 方法 C:Console(控制台)一键提取
+
+打开 **Console(控制台)** 面板,粘贴下面任意一行回车,即可直接打印出 token:
+
+```js
+// 如果存在 localStorage 里
+copy(localStorage.getItem('Authorization') || localStorage.getItem('token') || localStorage.getItem('access_token'));
+```
+
+```js
+// 一键查找所有可能键
+Object.keys(localStorage).filter(k => /token|auth/i.test(k)).forEach(k => console.log(k, '=', localStorage.getItem(k)));
+```
+
+执行 `copy(...)` 后 token 会被复制到剪贴板,直接粘贴即可。
+
+#### 常见问题
+
+- **过期 / 401 Unauthorized** → 重新登录 hengdianfilm 后台,再次按上面步骤抓取。
+- **找不到 `Authorization` 头** → 确认你已经登录,并且过滤的是业务接口(URL 含 `/cinema/`),而不是登录接口本身。
+- **复制时多了 `Bearer ` 前缀** → 输入框里**不要**带 `Bearer `,代码里会自动拼接。
+        """
+    )
+
+proxy_base_url = get_new_api_proxy_base_url()
+if proxy_base_url:
+    proxy_display_url = proxy_base_url.split("?", 1)[0] + ("?..." if "?" in proxy_base_url else "")
+    st.caption(f"当前自动 token 与 movieshow/page 均通过中转代理访问：{proxy_display_url}")
+    if not os.getenv(NEW_API_PROXY_TOKEN_ENV, "").strip():
+        st.warning(f"已配置 `{NEW_API_PROXY_URL_ENV}`，但未配置 `{NEW_API_PROXY_TOKEN_ENV}`，中转请求会被代理拒绝。")
+    if os.getenv(NEW_API_PROXY_AUTH_QUERY_ENV, "").strip():
+        st.info(f"已配置 `{NEW_API_PROXY_AUTH_QUERY_ENV}`，代理请求会自动附加 EdgeOne Preview 鉴权参数。")
+else:
+    st.warning(f"未配置 `{NEW_API_PROXY_URL_ENV}`。境外服务器需要配置代理后才能自动获取 token 并拉取 API。")
+
+input_tab_api, input_tab_paste = st.tabs(["🌐 API 拉取", "📋 粘贴 JSON"])
+
+
+with input_tab_api:
+    col_auth, col_date = st.columns([3, 2])
+    with col_auth:
+        auto_token = st.checkbox("自动通过 OA SSO 获取 Token", value=True, key="new_api_auto_token")
+        token_value = st.session_state.new_api_bearer_token or ""
+        if token_value:
+            token_preview = token_value[:8] + "..." + token_value[-4:]
+            fetched_at = st.session_state.new_api_token_fetched_at
+            fetched_label = fetched_at.strftime("%Y-%m-%d %H:%M:%S") if fetched_at else "本次会话"
+            st.success(f"当前 Token：`{token_preview}`（{fetched_label}）")
+        else:
+            st.info("当前会话尚未获取 Token。点击下方按钮会自动获取。")
+
+        if st.button("🔐 只获取 / 刷新 Token", use_container_width=False):
+            with st.spinner("正在通过代理完成 OA SSO -> OAuth token..."):
+                try:
+                    token, debug = fetch_center_token_auto()
+                except Exception as exc:  # noqa: BLE001
+                    st.error(f"自动获取 Token 失败：{exc}")
+                else:
+                    st.session_state.new_api_bearer_token = token
+                    st.session_state.new_api_token_debug = debug
+                    st.session_state.new_api_token_fetched_at = datetime.now()
+                    st.toast("Token 获取成功", icon="✅")
+
+        with st.expander("手动 Token 备用输入", expanded=False):
+            manual_token = st.text_input(
+                "Bearer Token",
+                value=st.session_state.new_api_bearer_token,
+                help="通常不需要填写；自动获取失败时可临时手动输入。",
+                key="new_api_bearer_input",
+            )
+            if manual_token.strip() != st.session_state.new_api_bearer_token:
+                st.session_state.new_api_bearer_token = manual_token.strip()
+
+        if st.session_state.new_api_token_debug:
+            with st.expander("自动获取 Token 调试信息", expanded=False):
+                st.json(st.session_state.new_api_token_debug)
+
+    with col_date:
+        query_date = st.date_input(
+            "查询排片日期",
+            value=st.session_state.new_api_query_date,
+            key="new_api_date_input",
+        )
+
+    page_size = st.slider("每页大小（自动翻页直到取完）", min_value=50, max_value=500, value=DEFAULT_PAGE_SIZE, step=50)
+
+    if st.button("🫵 拉取并生成报表", type="primary", use_container_width=False):
+        token = (st.session_state.new_api_bearer_token or "").strip()
+        if auto_token or not token:
+            with st.spinner("正在自动获取 Token..."):
+                try:
+                    token, debug = fetch_center_token_auto()
+                except Exception as exc:  # noqa: BLE001
+                    st.error(f"自动获取 Token 失败：{exc}")
+                    token = ""
+                else:
+                    st.session_state.new_api_bearer_token = token
+                    st.session_state.new_api_token_debug = debug
+                    st.session_state.new_api_token_fetched_at = datetime.now()
+
+        if token:
+            st.session_state.new_api_bearer_token = token
+            st.session_state.new_api_query_date = query_date
+            date_str = query_date.strftime("%Y-%m-%d")
+            with st.spinner(f"正在调用接口拉取 {date_str} 的场次..."):
+                try:
+                    records = fetch_all_movieshow(token, date_str, size=page_size)
+                except requests.HTTPError as exc:
+                    st.error(f"HTTP 错误：{exc.response.status_code} {exc.response.reason}")
+                    records = []
+                except Exception as exc:  # noqa: BLE001
+                    st.error(f"调用接口失败：{exc}")
+                    records = []
+
+            if records:
+                st.session_state.new_api_records = records
+                st.session_state.new_api_data_source = f"API 拉取（{len(records)} 条）"
+                source_df = records_to_source_df(records)
+                report_df, display_date = build_daily_report_from_source_df(
+                    source_df,
+                    selected_date_str=date_str,
+                )
+                st.session_state.new_api_report_df = report_df
+                st.session_state.new_api_display_date = display_date or query_date
+                if not report_df.empty:
+                    st.toast(f"成功生成 {len(report_df)} 条报表数据。", icon="✅")
+
+
+with input_tab_paste:
+    st.markdown("将接口返回的整个 JSON 文本（或 `data.records` 数组）粘贴到下方：")
+    paste_text = st.text_area(
+        "JSON 文本",
+        value=st.session_state.new_api_paste_text,
+        height=260,
+        placeholder='{"code":0,"data":{"records":[ ... ]}}',
+        key="new_api_paste_textarea",
+    )
+    fallback_date = st.date_input(
+        "用于补充缺失日期的回退值",
+        value=st.session_state.new_api_query_date,
+        key="new_api_paste_fallback_date",
+    )
+
+    if st.button("📥 解析并生成报表", key="new_api_parse_btn"):
+        st.session_state.new_api_paste_text = paste_text
+        try:
+            records = parse_pasted_response(paste_text)
+        except ValueError as exc:
+            st.error(str(exc))
+            records = []
+
+        if records:
+            st.session_state.new_api_records = records
+            st.session_state.new_api_data_source = f"粘贴 JSON（{len(records)} 条）"
+            source_df = records_to_source_df(records)
+            fallback_str = fallback_date.strftime("%Y-%m-%d")
+            report_df, display_date = build_daily_report_from_source_df(
+                source_df,
+                selected_date_str=fallback_str,
+            )
+            st.session_state.new_api_report_df = report_df
+            st.session_state.new_api_display_date = display_date or fallback_date
+            if not report_df.empty:
+                st.toast(f"成功生成 {len(report_df)} 条报表数据。", icon="✅")
+
+
+# ---------------------------------------------------------------------------
+# 报表展示与下载
+# ---------------------------------------------------------------------------
+st.divider()
+
+report_df: pd.DataFrame = st.session_state.new_api_report_df
+display_date = st.session_state.new_api_display_date
+
+if isinstance(report_df, pd.DataFrame) and not report_df.empty:
+    if display_date is None:
+        display_date = dt_date.today()
+    st.caption(f"当前数据来源：{st.session_state.new_api_data_source}")
+    st.markdown(f"#### {display_date.strftime('%Y-%m-%d')} 影片映出日累计报表")
+
+    st.dataframe(
+        report_df.style.format(
+            {"人数合计": "{:,.0f}", "座位数": "{:,.0f}", "上座率%": "{:.2f}%"}
+        ),
+        width="stretch",
+        hide_index=True,
+    )
+
+    total_attendance = pd.to_numeric(report_df.get("人数合计", 0), errors="coerce").fillna(0).sum()
+    st.markdown(
+        f"""
+        <div style="margin: 12px 0 18px; padding: 14px 18px; border-left: 6px solid #D83B01; background: #FFF4ED;">
+            <span style="font-size: 18px; font-weight: 700; color: #5C1F00;">已售人次：</span>
+            <span style="font-size: 26px; font-weight: 800; color: #D83B01;">{total_attendance:,.0f}</span>
+            <span style="font-size: 18px; font-weight: 700; color: #5C1F00;"> 人</span>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    output_buffer = io.BytesIO()
+    report_df.to_excel(output_buffer, index=False, engine="openpyxl")
+    st.download_button(
+        label="📥 下载 XLSX 报表文件",
+        data=output_buffer.getvalue(),
+        file_name=f"{display_date.strftime('%Y-%m-%d')}_影片映出日累计报表.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    )
+
+    with st.expander("查看原始接口数据（最多 10 条）"):
+        sample = st.session_state.new_api_records[:10]
+        st.json(sample)
+else:
+    st.info("尚无数据。请通过「API 拉取」或「粘贴 JSON」生成报表。")

pages/🎟️ 售票时间集中监控.py

@@ -0,0 +1,1341 @@
+import json
+import os
+import re
+import threading
+import time
+from collections import deque
+from datetime import datetime, time as dt_time, timedelta, timezone
+from pathlib import Path
+from string import Template
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+import requests
+import streamlit as st
+from dotenv import load_dotenv
+
+try:
+    from streamlit_autorefresh import st_autorefresh
+except ImportError:
+    st_autorefresh = None
+
+
+st.set_page_config(page_title="售票时间集中监控", page_icon="🎟️", layout="wide")
+
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+STATE_DIR = ROOT_DIR / "cinema_cache"
+
+load_dotenv(dotenv_path=str(ROOT_DIR / ".env"), override=True)
+
+
+def env_str(name: str, default: str = "") -> str:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return str(value).strip()
+
+
+def env_int(name: str, default: int, min_value: Optional[int] = None) -> int:
+    try:
+        value = int(str(os.getenv(name, "")).strip())
+    except (TypeError, ValueError):
+        value = default
+    if min_value is not None:
+        value = max(min_value, value)
+    return value
+
+
+def env_flag(name: str, default: bool = False) -> bool:
+    raw = str(os.getenv(name, "")).strip().lower()
+    if not raw:
+        return default
+    return raw not in {"0", "false", "no", "off"}
+
+
+POS_BASE_URL = env_str("POS_CASHIER_BASE_URL", "https://pos.hengdianfilm.com").rstrip("/")
+POS_TOKEN_COOKIE_NAME = env_str("POS_CASHIER_TOKEN_COOKIE_NAME", "cashier_token") or "cashier_token"
+POS_CASHIER_BASIC_AUTH = env_str("POS_CASHIER_BASIC_AUTH")
+POS_INTERNAL_SELLER_NAME = env_str("POS_CASHIER_INTERNAL_SELLER_NAME", "横店平台") or "横店平台"
+
+CONFIG = {
+    "domain": env_str("POS_CASHIER_DOMAIN"),
+    "login_domain": env_str("POS_CASHIER_LOGIN_DOMAIN"),
+    "selling_point": env_str("POS_CASHIER_SELLING_POINT"),
+    "lead_minutes": env_int("POS_SEAT_MONITOR_LEAD_MINUTES", 20, 1),
+    "cluster_window_minutes": env_int("POS_SEAT_CLUSTER_WINDOW_MINUTES", 1, 0),
+    "cluster_threshold": env_int("POS_SEAT_CLUSTER_THRESHOLD", 4, 1),
+    "max_seats_per_session": env_int("POS_SEAT_MONITOR_MAX_SEATS", 160, 1),
+    "seat_status_path": os.getenv(
+        "POS_CASHIER_SEAT_STATUS_PATH",
+        "/api/cinema/mobile/cashier/cinemaSeatStatus",
+    ).strip(),
+    "seat_status_method": os.getenv("POS_CASHIER_SEAT_STATUS_METHOD", "POST").strip().upper() or "POST",
+    "use_default_seat_status": env_flag("POS_CASHIER_USE_DEFAULT_SEAT_STATUS", True),
+    "seat_api_url_template": os.getenv("POS_CASHIER_SOLD_SEATS_URL_TEMPLATE", "").strip(),
+    "seat_api_method": os.getenv("POS_CASHIER_SOLD_SEATS_METHOD", "GET").strip().upper() or "GET",
+    "seat_api_body_template": os.getenv("POS_CASHIER_SOLD_SEATS_BODY_TEMPLATE", "").strip(),
+    "seat_api_assume_all": env_flag("POS_CASHIER_SOLD_SEATS_ASSUME_ALL", False),
+    "refresh_grant_type": os.getenv("POS_CASHIER_REFRESH_GRANT_TYPE", "refresh_token").strip() or "refresh_token",
+    "show_business_ids": env_flag("POS_SEAT_MONITOR_SHOW_BUSINESS_IDS", False),
+    "show_seat_details": env_flag("POS_SEAT_MONITOR_SHOW_SEAT_DETAILS", True),
+    "include_alert_sellers": env_flag("POS_SEAT_MONITOR_ALERT_INCLUDE_SELLERS", True),
+    "include_alert_seats": env_flag("POS_SEAT_MONITOR_ALERT_INCLUDE_SEATS", True),
+}
+
+WEWORK_BOT_WEBHOOK = env_str("WEWORK_BOT_WEBHOOK")
+MONITOR_RESOURCE_VERSION = "2026-07-10-seller-filter-v7"
+
+
+def redact_sensitive_text(value: Any) -> str:
+    text = str(value)
+    replacements = (
+        (r"(?i)([?&](?:access_token|refresh_token|token|cashier_token|mobile|code|key)=)[^&\s]+", r"\1***"),
+        (r"(?i)(Bearer\s+)[A-Za-z0-9._~+/=-]+", r"\1***"),
+        (r"(?i)(Basic\s+)[A-Za-z0-9+/=-]+", r"\1***"),
+        (
+            r"(?i)(['\"]?(?:access_token|refresh_token|cashier_token|Authorization|Cookie|mobile|code)['\"]?\s*[:=]\s*['\"]?)[^,'\"\s}]+",
+            r"\1***",
+        ),
+    )
+    for pattern, replacement in replacements:
+        text = re.sub(pattern, replacement, text)
+    return text
+
+
+def get_beijing_now() -> datetime:
+    utc_now = datetime.now(timezone.utc)
+    return utc_now.astimezone(timezone(timedelta(hours=8))).replace(tzinfo=None)
+
+
+def get_business_date() -> str:
+    now = get_beijing_now()
+    if now.time() < dt_time(6, 0):
+        return (now - timedelta(days=1)).strftime("%Y-%m-%d")
+    return now.strftime("%Y-%m-%d")
+
+
+def parse_datetime_value(value: Any) -> Optional[datetime]:
+    if not value:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M", "%Y/%m/%d %H:%M:%S", "%Y/%m/%d %H:%M"):
+        try:
+            return datetime.strptime(text, fmt)
+        except ValueError:
+            pass
+    parsed = pd.to_datetime(text, errors="coerce")
+    if pd.isna(parsed):
+        return None
+    return parsed.to_pydatetime().replace(tzinfo=None)
+
+
+def parse_session_start(session: dict, business_date: str) -> Optional[datetime]:
+    for key in ("startLocaleDateTime", "start", "startDateTime"):
+        parsed = parse_datetime_value(session.get(key))
+        if parsed:
+            return parsed
+
+    start_time = str(session.get("startTime") or "").strip()
+    if not start_time:
+        return None
+    try:
+        parsed_time = datetime.strptime(start_time, "%H:%M").time()
+        base_date = datetime.strptime(str(session.get("businessDate") or business_date), "%Y-%m-%d").date()
+        if parsed_time < dt_time(6, 0):
+            base_date = base_date + timedelta(days=1)
+        return datetime.combine(base_date, parsed_time)
+    except Exception:
+        return None
+
+
+def clean_hall_name(raw_name: Any) -> str:
+    text = str(raw_name or "").strip()
+    match = re.search(r"(\d+)号", text)
+    if match:
+        return f"{match.group(1)}号厅"
+    return text or "未知影厅"
+
+
+def session_display_name(session: dict, business_date: str) -> str:
+    start_dt = parse_session_start(session, business_date)
+    start_text = start_dt.strftime("%H:%M") if start_dt else str(session.get("startTime") or "--")
+    return f"{clean_hall_name(session.get('hallName'))} {start_text}《{session.get('cineMovieName') or session.get('movieName') or '未知影片'}》"
+
+
+def render_template(text: str, context: dict, allow_brace_format: bool = True) -> str:
+    rendered = Template(text).safe_substitute({k: str(v or "") for k, v in context.items()})
+    if allow_brace_format:
+        class SafeDict(dict):
+            def __missing__(self, key):
+                return "{" + key + "}"
+
+        rendered = rendered.format_map(SafeDict({k: str(v or "") for k, v in context.items()}))
+    return rendered
+
+
+class WeWorkBotPusher:
+    def __init__(self, webhook_url: str):
+        self.webhook_url = webhook_url
+
+    def send_text(self, content: str) -> bool:
+        if not self.webhook_url:
+            return False
+        try:
+            resp = requests.post(
+                self.webhook_url,
+                json={"msgtype": "text", "text": {"content": content}},
+                headers={"Content-Type": "application/json"},
+                timeout=10,
+            )
+            payload = resp.json()
+            return payload.get("errcode") == 0
+        except Exception:
+            return False
+
+
+class PosCashierAPI:
+    def __init__(self, config: dict, logger):
+        self.config = config
+        self.logger = logger
+        self.last_login_fail = 0.0
+        self.token_data = self._read_token_env()
+
+    @property
+    def domain(self) -> str:
+        return self.config["domain"]
+
+    def _default_headers(self, token: Optional[str] = None, json_content: bool = False) -> dict:
+        headers = {
+            "Accept": "application/json, text/plain, */*",
+            "Accept-Language": "zh-CN,zh;q=0.9",
+            "Channel": "2",
+            "Origin": POS_BASE_URL,
+            "Referer": f"{POS_BASE_URL}/index",
+            "User-Agent": "Mozilla/5.0",
+            "X-Platform": "cashier",
+        }
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+            headers["Cookie"] = f"{POS_TOKEN_COOKIE_NAME}={token}"
+        if json_content:
+            headers["Content-Type"] = "application/json;charset=UTF-8"
+        return headers
+
+    def _read_token_env(self) -> dict:
+        payload = {}
+        access_token = env_str("POS_CASHIER_ACCESS_TOKEN") or env_str("POS_CASHIER_TOKEN") or env_str("CASHIER_TOKEN")
+        refresh_token = env_str("POS_CASHIER_REFRESH_TOKEN")
+        if access_token:
+            payload["access_token"] = access_token
+        if refresh_token:
+            payload["refresh_token"] = refresh_token
+
+        optional_env_fields = {
+            "token_type": "POS_CASHIER_TOKEN_TYPE",
+            "expires_at": "POS_CASHIER_TOKEN_EXPIRES_AT",
+            "expires_in": "POS_CASHIER_TOKEN_EXPIRES_IN",
+            "scope": "POS_CASHIER_TOKEN_SCOPE",
+            "client_id": "POS_CASHIER_CLIENT_ID",
+        }
+        for field, env_name in optional_env_fields.items():
+            value = env_str(env_name)
+            if value:
+                payload[field] = value
+        return payload
+
+    def _read_token_state(self) -> Optional[dict]:
+        if self.token_data:
+            return dict(self.token_data)
+        payload = self._read_token_env()
+        self.token_data = dict(payload)
+        return payload or None
+
+    def _write_token_state(self, token_data: dict) -> None:
+        existing = self._read_token_state() or {}
+        merged = dict(token_data)
+        if not merged.get("refresh_token") and existing.get("refresh_token"):
+            merged["refresh_token"] = existing["refresh_token"]
+        self.token_data = merged
+
+    def _cache_token_payload(self, payload: dict) -> Optional[str]:
+        token = str(payload.get("access_token") or payload.get("token") or "").strip()
+        if not token:
+            return None
+
+        try:
+            expires_in = int(payload.get("expires_in") or 0)
+        except (TypeError, ValueError):
+            expires_in = 0
+
+        payload["saved_at"] = int(time.time())
+        if expires_in > 0:
+            payload["expires_at"] = int(time.time()) + expires_in
+        self._write_token_state(payload)
+        return token
+
+    def load_token(self) -> Optional[str]:
+        token_data = self._read_token_state()
+        if not token_data:
+            return None
+        token = str(token_data.get("access_token") or token_data.get("token") or "").strip()
+        expires_at = float(token_data.get("expires_at") or 0)
+        if expires_at and expires_at < time.time() + 60:
+            return None
+        return token or None
+
+    def refresh_access_token(self) -> Optional[str]:
+        token_data = self._read_token_state() or {}
+        refresh_token = (
+            os.getenv("POS_CASHIER_REFRESH_TOKEN", "").strip()
+            or str(token_data.get("refresh_token") or "").strip()
+        )
+        if not refresh_token:
+            return None
+        if not POS_CASHIER_BASIC_AUTH:
+            self.logger("POS Token 自动续期缺少 POS_CASHIER_BASIC_AUTH。")
+            return None
+        if not self.config["login_domain"] or not self.config["selling_point"]:
+            self.logger("POS Token 自动续期缺少 POS_CASHIER_LOGIN_DOMAIN / POS_CASHIER_SELLING_POINT。")
+            return None
+
+        headers = self._default_headers()
+        headers.update(
+            {
+                "Authorization": POS_CASHIER_BASIC_AUTH,
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Referer": f"{POS_BASE_URL}/index",
+            }
+        )
+        params = {
+            "grant_type": self.config["refresh_grant_type"],
+            "refresh_token": refresh_token,
+        }
+        data = {
+            "domain": self.config["login_domain"],
+            "sellingPoint": self.config["selling_point"],
+        }
+
+        try:
+            resp = requests.post(
+                f"{POS_BASE_URL}/api/auth/oauth/token",
+                params=params,
+                data=data,
+                headers=headers,
+                timeout=15,
+            )
+            resp.raise_for_status()
+            payload = resp.json()
+            token = self._cache_token_payload(payload)
+            if not token:
+                raise RuntimeError(f"刷新 Token 未返回 access_token：{payload}")
+            self.logger("POS Token 已通过 refresh_token 自动续期。")
+            return token
+        except Exception as exc:
+            self.logger(f"POS Token 自动续期失败：{exc}")
+            return None
+
+    def login(self) -> Optional[str]:
+        if time.time() - self.last_login_fail < 300:
+            return None
+
+        mobile = os.getenv("POS_CASHIER_MOBILE", "").strip()
+        code = os.getenv("POS_CASHIER_SMS_CODE", "").strip()
+        if not mobile or not code:
+            self.logger("POS 登录缺少 POS_CASHIER_MOBILE / POS_CASHIER_SMS_CODE，改用已缓存或手工配置的 token。")
+            return None
+        if not POS_CASHIER_BASIC_AUTH:
+            self.logger("POS 登录缺少 POS_CASHIER_BASIC_AUTH，改用已缓存或手工配置的 token。")
+            return None
+        if not self.config["login_domain"] or not self.config["selling_point"]:
+            self.logger("POS 登录缺少 POS_CASHIER_LOGIN_DOMAIN / POS_CASHIER_SELLING_POINT。")
+            return None
+
+        params = {
+            "mobile": f"SMS@{mobile}",
+            "code": code,
+            "grant_type": os.getenv("POS_CASHIER_GRANT_TYPE", "password").strip() or "password",
+        }
+        data = {
+            "domain": self.config["login_domain"],
+            "sellingPoint": self.config["selling_point"],
+        }
+        headers = self._default_headers()
+        headers.update(
+            {
+                "Authorization": POS_CASHIER_BASIC_AUTH,
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Referer": f"{POS_BASE_URL}/login?redirect=%2Findex",
+            }
+        )
+
+        try:
+            resp = requests.post(
+                f"{POS_BASE_URL}/api/auth/oauth/token",
+                params=params,
+                data=data,
+                headers=headers,
+                timeout=15,
+            )
+            resp.raise_for_status()
+            payload = resp.json()
+            token = self._cache_token_payload(payload)
+            if not token:
+                raise RuntimeError(f"POS 登录未返回 access_token：{payload}")
+            self.logger("POS 登录成功，Token 已缓存。")
+            return token
+        except Exception as exc:
+            self.last_login_fail = time.time()
+            self.logger(f"POS 登录失败：{exc}")
+            return None
+
+    def get_token(self, force_refresh: bool = False, force_login: bool = False) -> Optional[str]:
+        token = None if (force_refresh or force_login) else self.load_token()
+        if token:
+            return token
+        if not force_login:
+            refreshed_token = self.refresh_access_token()
+            if refreshed_token:
+                return refreshed_token
+        return self.login()
+
+    def request_json(
+        self,
+        method: str,
+        path_or_url: str,
+        *,
+        params: Optional[dict] = None,
+        json_body: Optional[dict] = None,
+        retry_auth: bool = True,
+    ) -> dict:
+        token = self.get_token()
+        if not token:
+            raise RuntimeError("没有可用的 POS Token。")
+        if not self.domain:
+            raise RuntimeError("缺少 POS_CASHIER_DOMAIN。")
+
+        url = path_or_url if path_or_url.startswith("http") else f"{POS_BASE_URL}{path_or_url}"
+        headers = self._default_headers(token=token, json_content=json_body is not None)
+        resp = requests.request(
+            method,
+            url,
+            params=params,
+            json=json_body,
+            headers=headers,
+            timeout=20,
+        )
+        if resp.status_code in {401, 403} and retry_auth:
+            token = self.get_token(force_refresh=True)
+            if token:
+                headers = self._default_headers(token=token, json_content=json_body is not None)
+                resp = requests.request(
+                    method,
+                    url,
+                    params=params,
+                    json=json_body,
+                    headers=headers,
+                    timeout=20,
+                )
+        resp.raise_for_status()
+        return resp.json()
+
+    def fetch_sessions(self, show_date: str) -> List[dict]:
+        payload = self.request_json(
+            "GET",
+            "/api/cinema/mobile/cashier/cinemaPlays3",
+            params={"domain": self.domain, "showDate": show_date, "type": "1"},
+        )
+        if payload.get("code") != 0:
+            raise RuntimeError(f"排片接口返回异常：{payload}")
+        return payload.get("data") or []
+
+    def fetch_seat_order_info(self, play_id: str, seat_id: str) -> Optional[dict]:
+        payload = self.request_json(
+            "POST",
+            "/api/order/order/getDxSeatOrderInfo",
+            json_body={"domain": self.domain, "id": str(play_id), "seatIds": [str(seat_id)]},
+        )
+        if payload.get("code") != 0:
+            return None
+        data = payload.get("data")
+        return data if isinstance(data, dict) else None
+
+    def fetch_sold_seat_infos(self, session: dict) -> List[dict]:
+        env_json = os.getenv("POS_CASHIER_SOLD_SEAT_IDS_JSON", "").strip()
+        if env_json:
+            try:
+                mapping = json.loads(env_json)
+                for key in (
+                    str(session.get("id") or ""),
+                    f"{session.get('businessDate')}_{session.get('id')}",
+                    f"{session.get('hallId')}_{session.get('startTime')}",
+                ):
+                    if key and isinstance(mapping, dict) and key in mapping:
+                        return [{"seat_id": seat_id, "seat": seat_id} for seat_id in normalize_seat_ids(mapping[key])]
+            except Exception as exc:
+                self.logger(f"解析 POS_CASHIER_SOLD_SEAT_IDS_JSON 失败：{exc}")
+
+        context = {
+            "domain": self.domain,
+            "id": session.get("id"),
+            "play_id": session.get("id"),
+            "hall_id": session.get("hallId"),
+            "dx_hall_id": session.get("dxHallId"),
+            "show_date": session.get("businessDate"),
+            "start_time": session.get("startTime"),
+            "movie_id": session.get("movieId"),
+            "cine_movie_id": session.get("cineMovieId"),
+        }
+
+        url_template = self.config.get("seat_api_url_template") or ""
+        if url_template:
+            url = render_template(url_template, context, allow_brace_format=True)
+            body_template = self.config.get("seat_api_body_template") or ""
+            json_body = None
+            if body_template:
+                rendered_body = render_template(body_template, context, allow_brace_format=False)
+                json_body = json.loads(rendered_body)
+
+            payload = self.request_json(
+                self.config.get("seat_api_method") or "GET",
+                url,
+                json_body=json_body,
+            )
+            return extract_sold_seat_infos(payload, assume_all=self.config.get("seat_api_assume_all", False))
+
+        if not self.config.get("use_default_seat_status", True):
+            return []
+
+        seat_status_path = self.config.get("seat_status_path") or ""
+        if not seat_status_path:
+            return []
+
+        method = self.config.get("seat_status_method") or "GET"
+        seat_status_payload = {
+            "domain": self.domain,
+            "cinemaId": str(session.get("cinemaId") or self.domain),
+            "hallId": str(session.get("hallId") or ""),
+            "dxHallId": str(session.get("dxHallId") or ""),
+            "id": str(session.get("id") or ""),
+        }
+        if method == "GET":
+            payload = self.request_json(
+                method,
+                seat_status_path,
+                params=seat_status_payload,
+            )
+        else:
+            payload = self.request_json(
+                method,
+                seat_status_path,
+                json_body=seat_status_payload,
+            )
+        return extract_sold_seat_infos(payload, assume_all=self.config.get("seat_api_assume_all", False))
+
+
+def normalize_seat_ids(value: Any) -> List[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        raw_items = re.split(r"[,，\s]+", value)
+    elif isinstance(value, (list, tuple, set)):
+        raw_items = list(value)
+    else:
+        raw_items = [value]
+    result = []
+    seen = set()
+    for item in raw_items:
+        text = str(item).strip()
+        if text and text not in seen:
+            seen.add(text)
+            result.append(text)
+    return result
+
+
+SEAT_ID_FIELDS = (
+    "cinemaDxId",
+    "cinemaDxSeatId",
+    "dxSeatId",
+    "dxSeatID",
+    "seatId",
+    "seatID",
+    "seat_id",
+    "seatNo",
+    "seatNum",
+    "seatCode",
+)
+SEAT_NAME_FIELDS = (
+    "seat",
+    "seatName",
+    "seat_name",
+    "seatLabel",
+    "seatText",
+    "seatNoName",
+    "name",
+)
+SELL_TIME_FIELDS = (
+    "sellTime",
+    "soldTime",
+    "saleTime",
+    "orderTime",
+    "payTime",
+    "ticketTime",
+    "printTime",
+    "createTime",
+    "createdTime",
+    "updateTime",
+)
+STATUS_FIELDS = (
+    "playSeatStatus",
+    "printStatus",
+    "statusName",
+    "seatStatusName",
+    "saleStatusName",
+    "seatStatus",
+    "saleStatus",
+    "status",
+    "isSold",
+    "sold",
+    "isSale",
+)
+SOLD_TEXT_MARKERS = ("selled", "已售", "售出", "已出票", "锁定", "已锁", "sold", "sale")
+FREE_STATUS_VALUES = {"ok", "free", "empty", "available", "可售", "空闲", "未售"}
+
+
+def object_looks_sold(obj: dict) -> bool:
+    for key in ("isSold", "sold"):
+        if obj.get(key) is True:
+            return True
+
+    play_seat_status = str(obj.get("playSeatStatus") or "").strip().lower()
+    if play_seat_status:
+        if play_seat_status == "selled":
+            return True
+        if play_seat_status in FREE_STATUS_VALUES:
+            return False
+
+    status_values = []
+    for key in STATUS_FIELDS:
+        if key in obj and obj.get(key) is not None:
+            status_values.append(str(obj.get(key)).strip().lower())
+    if not status_values:
+        return False
+
+    status_text = " ".join(status_values)
+    if any(marker.lower() in status_text for marker in SOLD_TEXT_MARKERS):
+        return True
+
+    configured_values = {
+        item.strip().lower()
+        for item in os.getenv("POS_CASHIER_SOLD_STATUS_VALUES", "").split(",")
+        if item.strip()
+    }
+    return bool(configured_values and any(value in configured_values for value in status_values))
+
+
+def extract_seat_id_from_object(obj: dict) -> Optional[str]:
+    for field in SEAT_ID_FIELDS:
+        value = obj.get(field)
+        if value not in (None, ""):
+            return str(value).strip()
+
+    if "id" in obj:
+        keys_text = " ".join(str(key).lower() for key in obj.keys())
+        if "seat" in keys_text or any(field in obj for field in STATUS_FIELDS):
+            return str(obj.get("id")).strip()
+    return None
+
+
+def extract_seat_name_from_object(obj: dict) -> str:
+    for field in SEAT_NAME_FIELDS:
+        value = obj.get(field)
+        if value not in (None, ""):
+            return str(value).strip()
+
+    row = obj.get("rowName") or obj.get("row") or obj.get("seatRow")
+    col = obj.get("colName") or obj.get("columnName") or obj.get("col") or obj.get("seatCol")
+    if row not in (None, "") and col not in (None, ""):
+        row_text = str(row).strip()
+        col_text = str(col).strip()
+        if "排" in row_text or "座" in col_text:
+            return f"{row_text}{col_text}"
+        return f"{row_text}排{col_text}座"
+
+    seat_id = extract_seat_id_from_object(obj)
+    return seat_id or "未知座位"
+
+
+def extract_sell_time_from_object(obj: dict) -> str:
+    for field in SELL_TIME_FIELDS:
+        value = obj.get(field)
+        if value not in (None, ""):
+            return str(value).strip()
+    return ""
+
+
+def extract_sold_seat_ids(payload: Any, assume_all: bool = False) -> List[str]:
+    seat_ids = []
+
+    def walk(node: Any):
+        if isinstance(node, dict):
+            seat_id = extract_seat_id_from_object(node)
+            if seat_id and (assume_all or object_looks_sold(node)):
+                seat_ids.append(seat_id)
+            for value in node.values():
+                walk(value)
+        elif isinstance(node, list):
+            for value in node:
+                if assume_all and isinstance(value, (str, int)):
+                    seat_ids.append(str(value))
+                else:
+                    walk(value)
+
+    walk(payload)
+    return normalize_seat_ids(seat_ids)
+
+
+def extract_sold_seat_infos(payload: Any, assume_all: bool = False) -> List[dict]:
+    seat_infos = []
+
+    def walk(node: Any):
+        if isinstance(node, dict):
+            if assume_all or object_looks_sold(node):
+                seat_id = extract_seat_id_from_object(node)
+                if seat_id:
+                    item = dict(node)
+                    item["seat_id"] = seat_id
+                    item["seat"] = extract_seat_name_from_object(node)
+                    item["sellTime"] = extract_sell_time_from_object(node)
+                    seat_infos.append(item)
+            for value in node.values():
+                walk(value)
+        elif isinstance(node, list):
+            for value in node:
+                walk(value)
+
+    walk(payload)
+
+    result = []
+    seen = set()
+    for item in seat_infos:
+        seat_id = str(item.get("seat_id") or "").strip()
+        if not seat_id or seat_id in seen:
+            continue
+        seen.add(seat_id)
+        result.append(item)
+    return result
+
+
+def build_sell_time_clusters(seat_infos: List[dict], window_minutes: int, threshold: int) -> List[List[dict]]:
+    enriched = []
+    for info in seat_infos:
+        sell_dt = parse_datetime_value(info.get("sellTime"))
+        if sell_dt:
+            item = dict(info)
+            item["_sell_dt"] = sell_dt
+            enriched.append(item)
+
+    enriched.sort(key=lambda item: item["_sell_dt"])
+    if len(enriched) < threshold:
+        return []
+
+    window_seconds = max(0, window_minutes) * 60
+    candidates = []
+    for start_index in range(len(enriched)):
+        group = []
+        first_dt = enriched[start_index]["_sell_dt"]
+        for item in enriched[start_index:]:
+            if (item["_sell_dt"] - first_dt).total_seconds() <= window_seconds:
+                group.append(item)
+            else:
+                break
+        if len(group) >= threshold:
+            candidates.append(group)
+
+    clusters = []
+    selected_key_sets = []
+    candidates.sort(key=lambda group: (-len(group), group[0]["_sell_dt"]))
+    for group in candidates:
+        key_set = {
+            str(item.get("seat_id") or item.get("seatIds") or item.get("seat") or "")
+            for item in group
+            if str(item.get("seat_id") or item.get("seatIds") or item.get("seat") or "").strip()
+        }
+        if not key_set:
+            continue
+        if any(key_set.issubset(selected) for selected in selected_key_sets):
+            continue
+        selected_key_sets.append(key_set)
+        clusters.append(group)
+    clusters.sort(key=lambda group: group[0]["_sell_dt"])
+    return clusters
+
+
+def format_cluster_seats(cluster: List[dict]) -> str:
+    parts = []
+    for item in cluster:
+        seat_name = str(item.get("seat") or item.get("seatName") or item.get("seatIds") or item.get("seat_id") or "未知座位")
+        sell_time = str(item.get("sellTime") or "")
+        seller = str(item.get("seller") or "").strip()
+        time_part = sell_time[-8:] if len(sell_time) >= 8 else sell_time
+        if seller:
+            parts.append(f"{seat_name}({time_part} {seller})")
+        else:
+            parts.append(f"{seat_name}({time_part})")
+    return "、".join(parts)
+
+
+def normalize_seller_name(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def cluster_has_non_hengdian_seller(cluster: List[dict]) -> bool:
+    for item in cluster:
+        seller = normalize_seller_name(item.get("seller"))
+        if seller and seller != POS_INTERNAL_SELLER_NAME:
+            return True
+    return False
+
+
+def format_cluster_sellers(cluster: List[dict]) -> str:
+    sellers = []
+    seen = set()
+    for item in cluster:
+        seller = normalize_seller_name(item.get("seller")) or "未知售票员"
+        if seller in seen:
+            continue
+        seen.add(seller)
+        sellers.append(seller)
+    return "、".join(sellers)
+
+
+class SeatClusterMonitor:
+    def __init__(self, config: dict):
+        self.config = dict(config)
+        self.logs = deque(maxlen=80)
+        self.status_text = "初始化中"
+        self.next_wakeup: Optional[datetime] = None
+        self.active_targets: List[str] = []
+        self.recent_results: List[dict] = []
+        self.daily_schedule_cache: List[dict] = []
+        self.current_business_date = ""
+        self.processed_checks = set()
+        self.alerted_clusters = set()
+        self.stats = {
+            "checked_sessions": 0,
+            "alert_count": 0,
+            "api_fails": 0,
+            "notify_fails": 0,
+            "missing_seat_api": 0,
+        }
+        self.lock = threading.RLock()
+        self.api = PosCashierAPI(self.config, self.log)
+        self.pusher = WeWorkBotPusher(WEWORK_BOT_WEBHOOK)
+        self.thread = threading.Thread(target=self._run_loop, daemon=True)
+        self.thread.start()
+
+    def log(self, message: str) -> None:
+        entry = f"[{get_beijing_now().strftime('%H:%M:%S')}] {redact_sensitive_text(message)}"
+        with self.lock:
+            self.logs.appendleft(entry)
+        print(entry)
+
+    def snapshot(self) -> dict:
+        with self.lock:
+            return {
+                "logs": list(self.logs),
+                "status_text": self.status_text,
+                "next_wakeup": self.next_wakeup,
+                "active_targets": list(self.active_targets),
+                "recent_results": list(self.recent_results),
+                "daily_schedule_cache": list(self.daily_schedule_cache),
+                "current_business_date": self.current_business_date,
+                "stats": dict(self.stats),
+            }
+
+    def get_config(self) -> dict:
+        with self.lock:
+            return dict(self.config)
+
+    def update_config(self, updates: dict) -> None:
+        allowed_int_fields = {
+            "lead_minutes": 1,
+            "cluster_window_minutes": 0,
+            "cluster_threshold": 1,
+            "max_seats_per_session": 1,
+        }
+        cleaned = {}
+        for key, min_value in allowed_int_fields.items():
+            if key not in updates:
+                continue
+            try:
+                cleaned[key] = max(min_value, int(updates[key]))
+            except (TypeError, ValueError):
+                continue
+        if not cleaned:
+            return
+        with self.lock:
+            self.config.update(cleaned)
+
+    def _set_status(self, status: str, next_wakeup: Optional[datetime] = None, active_targets: Optional[List[str]] = None):
+        with self.lock:
+            self.status_text = status
+            self.next_wakeup = next_wakeup
+            if active_targets is not None:
+                self.active_targets = active_targets
+
+    def _refresh_schedule(self, business_date: str) -> bool:
+        try:
+            schedule = self.api.fetch_sessions(business_date)
+        except Exception as exc:
+            with self.lock:
+                self.stats["api_fails"] += 1
+            self.log(f"获取 POS 排片失败：{exc}")
+            return False
+
+        with self.lock:
+            self.daily_schedule_cache = schedule
+            self.current_business_date = business_date
+        self.log(f"POS 排片已更新：{business_date} 共 {len(schedule)} 场。")
+        return True
+
+    def _session_check_time(self, session: dict, business_date: str) -> Optional[datetime]:
+        start_dt = parse_session_start(session, business_date)
+        if not start_dt:
+            return None
+        return start_dt - timedelta(minutes=self.config["lead_minutes"])
+
+    def _run_loop(self):
+        self.log("售票时间集中监控服务已启动。")
+        while True:
+            try:
+                now = get_beijing_now()
+                business_date = get_business_date()
+
+                need_refresh = (
+                    not self.daily_schedule_cache
+                    or self.current_business_date != business_date
+                )
+                if need_refresh:
+                    self._set_status("同步排片中", active_targets=[])
+                    if not self._refresh_schedule(business_date):
+                        self._set_status("排片同步失败", next_wakeup=now + timedelta(minutes=1))
+                        time.sleep(60)
+                        continue
+                    with self.lock:
+                        self.processed_checks.clear()
+                        self.alerted_clusters.clear()
+
+                schedule = list(self.daily_schedule_cache)
+                active_sessions = []
+                next_check_time = None
+
+                for session in schedule:
+                    play_id = str(session.get("id") or "")
+                    if not play_id or play_id in self.processed_checks:
+                        continue
+                    start_dt = parse_session_start(session, business_date)
+                    check_time = self._session_check_time(session, business_date)
+                    if not start_dt or not check_time:
+                        continue
+                    if now >= start_dt:
+                        self.processed_checks.add(play_id)
+                        continue
+                    if now >= check_time:
+                        active_sessions.append(session)
+                    elif next_check_time is None or check_time < next_check_time:
+                        next_check_time = check_time
+
+                if active_sessions:
+                    labels = [session_display_name(item, business_date) for item in active_sessions[:8]]
+                    self._set_status("正在检查", next_wakeup=now + timedelta(minutes=1), active_targets=labels)
+                    self._process_sessions(active_sessions, business_date)
+                    time.sleep(10)
+                    continue
+
+                if next_check_time:
+                    seconds = max(10, (next_check_time - now).total_seconds())
+                    self._set_status("休眠中", next_wakeup=next_check_time, active_targets=[])
+                    time.sleep(min(seconds, 300))
+                else:
+                    self._set_status("今日待检查场次已结束", next_wakeup=now + timedelta(minutes=5), active_targets=[])
+                    time.sleep(300)
+
+            except Exception as exc:
+                with self.lock:
+                    self.stats["api_fails"] += 1
+                self.log(f"主循环异常：{exc}")
+                self._set_status("异常重试中", next_wakeup=get_beijing_now() + timedelta(minutes=1))
+                time.sleep(60)
+
+    def _process_sessions(self, sessions: List[dict], business_date: str) -> None:
+        latest_map = {}
+        try:
+            latest_schedule = self.api.fetch_sessions(business_date)
+            latest_map = {str(item.get("id") or ""): item for item in latest_schedule}
+            with self.lock:
+                self.daily_schedule_cache = latest_schedule
+        except Exception as exc:
+            with self.lock:
+                self.stats["api_fails"] += 1
+            self.log(f"检查前刷新 POS 排片失败，沿用缓存：{exc}")
+
+        for original in sessions:
+            play_id = str(original.get("id") or "")
+            session = latest_map.get(play_id, original)
+            if not play_id or play_id in self.processed_checks:
+                continue
+            try:
+                self._process_one_session(session, business_date)
+            finally:
+                with self.lock:
+                    self.processed_checks.add(play_id)
+
+    def _fill_missing_sell_times(self, play_id: str, seat_infos: List[dict], display_name: str) -> List[dict]:
+        result = []
+        for item in seat_infos:
+            if parse_datetime_value(item.get("sellTime")):
+                result.append(item)
+                continue
+
+            seat_id = str(item.get("seat_id") or "").strip()
+            if not seat_id:
+                result.append(item)
+                continue
+
+            try:
+                detail = self.api.fetch_seat_order_info(play_id, seat_id)
+                if detail:
+                    merged = dict(item)
+                    merged.update(detail)
+                    merged["seat_id"] = seat_id
+                    if not merged.get("seat"):
+                        merged["seat"] = item.get("seat") or detail.get("seat") or seat_id
+                    result.append(merged)
+                else:
+                    result.append(item)
+            except Exception as exc:
+                with self.lock:
+                    self.stats["api_fails"] += 1
+                self.log(f"{display_name} 补查已售座位 {seat_id} 售出时间失败：{exc}")
+                result.append(item)
+            time.sleep(0.03)
+        return result
+
+    def _process_one_session(self, session: dict, business_date: str) -> None:
+        play_id = str(session.get("id") or "")
+        sold_count = int(session.get("seatSaleNum") or 0)
+        display_name = session_display_name(session, business_date)
+
+        if sold_count < self.config["cluster_threshold"]:
+            self._record_result(session, business_date, "未达到售票张数阈值", sold_count, [])
+            self.log(f"{display_name} 已售 {sold_count} 张，低于阈值。")
+            return
+
+        seat_infos = self.api.fetch_sold_seat_infos(session)
+        if not seat_infos:
+            with self.lock:
+                self.stats["missing_seat_api"] += 1
+            self._record_result(session, business_date, "未解析到已售座位", sold_count, [])
+            self.log(f"{display_name} 已售 {sold_count} 张，但 cinemaSeatStatus 未解析到 playSeatStatus=selled 的座位。")
+            return
+
+        seat_infos = seat_infos[: self.config["max_seats_per_session"]]
+        timed_seat_count = sum(1 for item in seat_infos if parse_datetime_value(item.get("sellTime")))
+        if timed_seat_count < min(len(seat_infos), self.config["cluster_threshold"]):
+            seat_infos = self._fill_missing_sell_times(play_id, seat_infos, display_name)
+            timed_seat_count = sum(1 for item in seat_infos if parse_datetime_value(item.get("sellTime")))
+
+        if timed_seat_count < self.config["cluster_threshold"]:
+            self._record_result(session, business_date, "已售座位缺少售出时间", sold_count, [])
+            self.log(
+                f"{display_name} 解析到 {len(seat_infos)} 个已售座位，"
+                f"但只有 {timed_seat_count} 个带售出时间，无法达到阈值。"
+            )
+            return
+
+        clusters = build_sell_time_clusters(
+            seat_infos,
+            self.config["cluster_window_minutes"],
+            self.config["cluster_threshold"],
+        )
+        with self.lock:
+            self.stats["checked_sessions"] += 1
+
+        if not clusters:
+            self._record_result(session, business_date, "未命中集中售票", sold_count, [])
+            self.log(f"{display_name} 已检查 {len(seat_infos)} 个已售座位，未命中集中售票。")
+            return
+
+        self._record_result(session, business_date, "命中集���售票", sold_count, clusters)
+        for cluster in clusters:
+            alert_key = f"{play_id}|" + "|".join(sorted(str(item.get("seat") or item.get("seat_id") or "") for item in cluster))
+            if alert_key in self.alerted_clusters:
+                continue
+            self.alerted_clusters.add(alert_key)
+            if not cluster_has_non_hengdian_seller(cluster):
+                self.log(
+                    f"{display_name} 命中集中售票，但售票员均为横店平台，跳过推送："
+                    f"{format_cluster_seats(cluster)}"
+                )
+                continue
+            self._send_alert(session, business_date, sold_count, cluster)
+
+    def _record_result(self, session: dict, business_date: str, status: str, sold_count: int, clusters: List[List[dict]]):
+        start_dt = parse_session_start(session, business_date)
+        hit_seats = "；".join(format_cluster_seats(cluster) for cluster in clusters)
+        if clusters and not self.config.get("show_seat_details", True):
+            hit_seats = f"已隐藏（{sum(len(cluster) for cluster in clusters)} 座）"
+        row = {
+            "检查时间": get_beijing_now().strftime("%Y-%m-%d %H:%M:%S"),
+            "场次": session_display_name(session, business_date),
+            "开场时间": start_dt.strftime("%Y-%m-%d %H:%M") if start_dt else "--",
+            "已售": sold_count,
+            "状态": status,
+            "命中组数": len(clusters),
+            "命中座位": hit_seats,
+        }
+        with self.lock:
+            self.recent_results.insert(0, row)
+            self.recent_results = self.recent_results[:80]
+
+    def _send_alert(self, session: dict, business_date: str, sold_count: int, cluster: List[dict]) -> None:
+        start_dt = parse_session_start(session, business_date)
+        movie_name = session.get("cineMovieName") or session.get("movieName") or "未知影片"
+        hall_name = clean_hall_name(session.get("hallName"))
+        start_text = start_dt.strftime("%Y-%m-%d %H:%M") if start_dt else str(session.get("startTime") or "--")
+        times = [item["_sell_dt"] for item in cluster if item.get("_sell_dt")]
+        if times:
+            window_text = f"{min(times).strftime('%H:%M:%S')} - {max(times).strftime('%H:%M:%S')}"
+        else:
+            window_text = "--"
+        msg_lines = [
+            "发现疑似集中购票",
+            "",
+            f"场次：{start_text}《{movie_name}》",
+            f"影厅：{hall_name}",
+            f"已售：{sold_count} 张",
+            f"命中：{self.config['cluster_window_minutes']} 分钟内 {len(cluster)} 个座位",
+            f"售出时间：{window_text}",
+        ]
+        if self.config.get("include_alert_sellers", True):
+            msg_lines.append(f"售票员：{format_cluster_sellers(cluster)}")
+        if self.config.get("include_alert_seats", True):
+            msg_lines.append(f"座位：{format_cluster_seats(cluster)}")
+        msg = "\n".join(msg_lines)
+        if self.pusher.send_text(msg):
+            with self.lock:
+                self.stats["alert_count"] += 1
+            self.log(f"已推送集中购票告警：{hall_name}《{movie_name}》。")
+        else:
+            with self.lock:
+                self.stats["notify_fails"] += 1
+            self.log(f"集中购票告警发送失败：{hall_name}《{movie_name}》。")
+
+
+@st.cache_resource
+def get_monitor(resource_version: str = MONITOR_RESOURCE_VERSION):
+    return SeatClusterMonitor(CONFIG)
+
+
+def build_schedule_preview(schedule: List[dict], business_date: str, config: dict) -> pd.DataFrame:
+    rows = []
+    now = get_beijing_now()
+    for item in schedule:
+        start_dt = parse_session_start(item, business_date)
+        if not start_dt:
+            continue
+        check_dt = start_dt - timedelta(minutes=int(config.get("lead_minutes") or CONFIG["lead_minutes"]))
+        row = {
+            "检查时间": check_dt.strftime("%H:%M"),
+            "开场": start_dt.strftime("%H:%M"),
+            "影厅": clean_hall_name(item.get("hallName")),
+            "影片": item.get("cineMovieName") or item.get("movieName") or "",
+            "已售": int(item.get("seatSaleNum") or 0),
+            "状态": "已检查/过期" if start_dt <= now else ("待检查" if check_dt > now else "检查窗口内"),
+        }
+        if config.get("show_business_ids"):
+            row["play_id"] = item.get("id")
+        rows.append(row)
+    return pd.DataFrame(rows).sort_values(["检查时间", "开场"]) if rows else pd.DataFrame()
+
+
+def has_sold_seat_source() -> bool:
+    return bool(
+        CONFIG["seat_api_url_template"]
+        or os.getenv("POS_CASHIER_SOLD_SEAT_IDS_JSON", "").strip()
+        or (CONFIG.get("use_default_seat_status", True) and CONFIG.get("seat_status_path"))
+    )
+
+
+def sold_seat_source_label() -> str:
+    if CONFIG["seat_api_url_template"]:
+        return "自定义已售座位接口"
+    if os.getenv("POS_CASHIER_SOLD_SEAT_IDS_JSON", "").strip():
+        return "手工 seatIds JSON"
+    if CONFIG.get("use_default_seat_status", True) and CONFIG.get("seat_status_path"):
+        return f"cinemaSeatStatus ({CONFIG.get('seat_status_method', 'GET')})"
+    return "未配置"
+
+
+def main():
+    monitor = get_monitor()
+    if (
+        not hasattr(monitor, "get_config")
+        or not hasattr(monitor, "update_config")
+        or not hasattr(getattr(monitor, "api", None), "fetch_sold_seat_infos")
+    ):
+        get_monitor.clear()
+        monitor = get_monitor()
+    if st_autorefresh:
+        st_autorefresh(interval=30 * 1000, key="pos_seat_cluster_refresh")
+
+    current_config = monitor.get_config()
+    st.title("🎟️ 售票时间集中监控")
+
+    with st.container():
+        st.subheader("阈值参数")
+        col_a, col_b, col_c = st.columns(3)
+        with col_a:
+            lead_minutes = st.number_input(
+                "开场前检查（分钟）",
+                min_value=1,
+                max_value=180,
+                value=int(current_config.get("lead_minutes") or 20),
+                step=1,
+                help="例如 20 表示开场前 20 分钟开始检查该场次。",
+                key="pos_monitor_lead_minutes",
+            )
+        with col_b:
+            cluster_window_minutes = st.number_input(
+                "售出时间接近阈值（分钟）",
+                min_value=0,
+                max_value=30,
+                value=int(
+                    current_config.get("cluster_window_minutes")
+                    if current_config.get("cluster_window_minutes") is not None
+                    else 1
+                ),
+                step=1,
+                help="例如 5 表示同一批座位售出时间相差不超过 5 分钟；0 表示必须同一秒。",
+                key="pos_monitor_cluster_window_minutes",
+            )
+        with col_c:
+            cluster_threshold = st.number_input(
+                "命中座位数阈值（含）",
+                min_value=1,
+                max_value=50,
+                value=int(current_config.get("cluster_threshold") or 4),
+                step=1,
+                help="例如 4 表示同/近时间售出的座位数大于等于 4 就推送。",
+                key="pos_monitor_cluster_threshold",
+            )
+        monitor.update_config(
+            {
+                "lead_minutes": lead_minutes,
+                "cluster_window_minutes": cluster_window_minutes,
+                "cluster_threshold": cluster_threshold,
+            }
+        )
+
+    active_config = monitor.get_config()
+    domain_label = active_config["domain"] if active_config.get("show_business_ids") else "已隐藏"
+    st.caption(
+        f"影城 domain：{domain_label} | "
+        f"已售座位来源：{sold_seat_source_label()} | "
+        f"企业微信推送：{'已配置' if WEWORK_BOT_WEBHOOK else '未配置'} | "
+        "Token：从环境变量读取，刷新结果仅缓存在当前进程内"
+    )
+
+    snapshot = monitor.snapshot()
+    active_config = monitor.get_config()
+
+    if not has_sold_seat_source():
+        st.warning("还缺少“已售座位 ID 列表/座位图”接口；当前能获取场次和单座详情，但无法自动枚举每场已售 seatIds。")
+
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("运行状态", snapshot["status_text"])
+    c2.metric("下次唤醒", snapshot["next_wakeup"].strftime("%H:%M:%S") if snapshot["next_wakeup"] else "--")
+    c3.metric("检查阈值", f"{active_config['cluster_window_minutes']} 分钟 / {active_config['cluster_threshold']} 座")
+    c4.metric("今日告警", snapshot["stats"].get("alert_count", 0))
+
+    tab_live, tab_schedule, tab_api = st.tabs(["运行", "今日场次", "接口状态"])
+
+    with tab_live:
+        col_logs, col_results = st.columns([3, 2])
+        with col_logs:
+            st.subheader("运行日志")
+            st.text_area("logs", "\n".join(snapshot["logs"]), height=520, disabled=True, label_visibility="collapsed")
+        with col_results:
+            st.subheader("当前目标")
+            if snapshot["active_targets"]:
+                for target in snapshot["active_targets"]:
+                    st.info(target)
+            else:
+                st.caption("暂无正在检查的场次")
+
+            st.subheader("统计")
+            stats = snapshot["stats"]
+            stats_df = pd.DataFrame(
+                [
+                    {"指标": "已检查场次", "数值": stats.get("checked_sessions", 0)},
+                    {"指标": "告警次数", "数值": stats.get("alert_count", 0)},
+                    {"指标": "接口失败", "数值": stats.get("api_fails", 0)},
+                    {"指标": "推送失败", "数值": stats.get("notify_fails", 0)},
+                    {"指标": "未解析座位", "数值": stats.get("missing_seat_api", 0)},
+                ]
+            )
+            st.dataframe(stats_df, width="stretch", hide_index=True)
+
+        st.subheader("最近检查结果")
+        if snapshot["recent_results"]:
+            st.dataframe(pd.DataFrame(snapshot["recent_results"]), width="stretch", height=300, hide_index=True)
+        else:
+            st.caption("暂无检查结果")
+
+    with tab_schedule:
+        schedule = snapshot["daily_schedule_cache"]
+        business_date = snapshot["current_business_date"] or get_business_date()
+        c1, c2 = st.columns([1, 4])
+        c1.metric("营业日", business_date)
+        c2.metric("已缓存场次", len(schedule))
+        preview_df = build_schedule_preview(schedule, business_date, active_config)
+        if not preview_df.empty:
+            st.dataframe(preview_df, width="stretch", height=620, hide_index=True)
+        else:
+            st.info("尚未加载到今日场次。")
+
+    with tab_api:
+        used_rows = [
+            {"接口": "auth/oauth/token", "用途": "用环境变量里的 POS token / refresh_token 鉴权；刷新结果只保存在内存，不再写 pos_cashier_token.json。", "状态": "已接入"},
+            {"接口": "cinemaPlays3", "用途": "获取全天场次、play_id、影厅、影片、开场时间、已售张数。", "状态": "已接入"},
+            {"接口": "cinemaSeatStatus", "用途": "一次性获取座位状态；直接筛 playSeatStatus=selled 作为已售座位。", "状态": "已接入"},
+            {"接口": "getDxSeatOrderInfo", "用途": "仅对 selled 座位补查 sellTime；不再扫描全场每个座位。", "状态": "按需补查"},
+            {"接口": "cinemaPlays2", "用途": "按影厅取场次；cinemaPlays3 已包含全天场次，暂时不必用。", "状态": "暂不需要"},
+        ]
+        st.dataframe(pd.DataFrame(used_rows), width="stretch", hide_index=True)
+
+        missing_rows = [
+            {
+                "需要确认": "cinemaSeatStatus 售出时间字段",
+                "原因": "已售判断使用 playSeatStatus=selled；如果 cinemaSeatStatus 不带售出时间，会仅对 selled 座位补查 getDxSeatOrderInfo。",
+                "希望字段": "如果 cinemaSeatStatus 未来能直接返回 sellTime，可省掉补查。",
+            },
+            {
+                "需要确认": "refresh_token 续期实测结果",
+                "原因": "已按标准 OAuth grant_type=refresh_token 接入，并改为从系统变量读取 refresh_token；需要验证 POS refresh_token 能活多久。",
+                "希望字段": "access_token 过期后刷新接口的 curl，或确认当前实现能刷新成功。",
+            },
+        ]
+        st.dataframe(pd.DataFrame(missing_rows), width="stretch", hide_index=True)
+
+        st.caption(
+            "自定义接口仍可通过 POS_CASHIER_SOLD_SEATS_URL_TEMPLATE 覆盖；"
+            "默认流程使用 cinemaSeatStatus 的 playSeatStatus 字段。"
+        )
+
+
+if __name__ == "__main__":
+    main()

pages/💸 空场防空转监控.py

@@ -0,0 +1,787 @@
+import streamlit as st
+import requests
+import time
+import json
+import os
+import threading
+import re
+import urllib3
+from datetime import datetime, timedelta, timezone, time as dt_time
+from collections import deque
+from dotenv import load_dotenv
+from tms_proxy import build_tms_url, get_tms_proxy_base_url, tms_verify_ssl, with_tms_proxy_headers
+
+# --- 0. 基础配置 ---
+st.set_page_config(page_title="空场防空转监控", page_icon="💸", layout="wide")
+
+# 屏蔽 HTTPS 证书警告 (TMS 系统通常使用自签名证书)
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+try:
+    from streamlit_autorefresh import st_autorefresh
+except ImportError:
+    st_autorefresh = None
+
+# --- 1. 配置与常量 ---
+load_dotenv()
+
+# 企业微信机器人配置
+WEWORK_BOT_WEBHOOK = os.getenv("WEWORK_BOT_WEBHOOK")
+
+# 影城系统配置
+CINEMA_ID = os.getenv("CINEMA_ID")
+TMS_APP_SECRET = os.getenv("TMS_APP_SECRET")
+TMS_TICKET = os.getenv("TMS_TICKET")
+TMS_X_SESSION_ID = os.getenv("TMS_X_SESSION_ID")
+TMS_THEATER_ID = os.getenv("TMS_THEATER_ID") # 新增：影院ID
+
+HALL_ID_MAP = {
+    "1": "79181753", "2": "87350725", "3": "93340931",
+    "4": "98009245", "5": "02194530", "6": "07183751",
+    "7": "11314566", "8": "15532561", "9": "20079450"
+}
+
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT_DIR = os.path.dirname(CURRENT_DIR)
+TOKEN_FILE = os.path.join(ROOT_DIR, 'token_data.json')
+
+
+# --- 2. 统计与工具类 ---
+
+class DailyStats:
+    """每日运行数据统计"""
+    def __init__(self):
+        self.reset()
+        self.yesterday_stats = {
+            'zero_sessions': 0,
+            'triggers': 0,
+            'notify_fails': 0,
+            'api_fails': 0,
+            'date': '未知'
+        }
+
+    def reset(self):
+        self.zero_sessions = 0  # 0票总场次
+        self.triggers = 0       # 触发通知次数
+        self.notify_fails = 0   # 发送通知失败次数
+        self.api_fails = 0      # API获取失败次数
+
+    def snapshot_as_yesterday(self, date_str):
+        self.yesterday_stats = {
+            'zero_sessions': self.zero_sessions,
+            'triggers': self.triggers,
+            'notify_fails': self.notify_fails,
+            'api_fails': self.api_fails,
+            'date': date_str
+        }
+        self.reset()
+
+
+# 全局统计实例
+daily_stats = DailyStats()
+
+
+def get_beijing_now():
+    utc_now = datetime.now(timezone.utc)
+    return utc_now.astimezone(timezone(timedelta(hours=8))).replace(tzinfo=None)
+
+
+def get_business_date():
+    now = get_beijing_now()
+    if now.time() < dt_time(6, 0):
+        return (now - timedelta(days=1)).strftime("%Y-%m-%d")
+    return now.strftime("%Y-%m-%d")
+
+
+def parse_show_datetime(date_str, time_str):
+    try:
+        show_t = datetime.strptime(time_str, "%H:%M").time()
+        base_date = datetime.strptime(date_str, "%Y-%m-%d")
+        if show_t < dt_time(6, 0):
+            base_date += timedelta(days=1)
+        return datetime.combine(base_date.date(), show_t)
+    except:
+        return None
+
+
+def extract_hall_number_raw(hall_name):
+    """仅提取数字ID，用于API映射"""
+    match = re.search(r'(\d+)', str(hall_name))
+    return match.group(1) if match else str(hall_name)
+
+
+def format_hall_name(hall_name):
+    """格式化影厅名称：【和成天下1号厅】 -> 1号厅"""
+    match = re.search(r'(\d+)号', str(hall_name))
+    if match:
+        return f"{match.group(1)}号厅"
+    return str(hall_name)
+
+
+# --- 3. 企业微信机器人推送模块 ---
+class WeWorkBotPusher:
+    def __init__(self, webhook_url):
+        self.webhook_url = webhook_url
+
+    def send_text(self, content):
+        """发送纯文本消息"""
+        if not self.webhook_url:
+            return
+
+        headers = {"Content-Type": "application/json"}
+        data = {
+            "msgtype": "text",
+            "text": {
+                "content": content
+            }
+        }
+        
+        try:
+            resp = requests.post(self.webhook_url, json=data, headers=headers, timeout=10)
+            result = resp.json()
+            if result.get("errcode") != 0:
+                print(f"❌ 企业微信机器人发送失败: {result}")
+                daily_stats.notify_fails += 1
+        except Exception as e:
+            print(f"❌ 企业微信机器人发送异常: {e}")
+            daily_stats.notify_fails += 1
+
+
+# --- 4. 通知管理系统 ---
+class NotificationManager:
+    def __init__(self):
+        self.bot = WeWorkBotPusher(WEWORK_BOT_WEBHOOK)
+
+    def send_idle_alert(self, hall_name, movie_name, show_time, count_info, remark_text=""):
+        """发送空转告警 (企业微信机器人)"""
+        daily_stats.triggers += 1
+        
+        msg = (
+            f"发现 {hall_name} 空场空转！\n\n"
+            f"{hall_name} {show_time}《{movie_name}》\n"
+            f"无人购票但服务器上有排程，未撤场，或许正在播放，请检查。\n"
+            f"{count_info}，{remark_text}"
+        )
+        self.bot.send_text(msg)
+
+    def send_daily_report(self, today_date_cn):
+        """发送每日报告 (企业微信机器人)"""
+        y_stats = daily_stats.yesterday_stats
+        
+        msg = (
+            f"影城“空转”检查服务就绪\n\n"
+            f"{today_date_cn}，今日排片数据已加载，开始智能检查。\n\n"
+            f"昨日情况：\n"
+            f"0票总场次：{y_stats['zero_sessions']}\n"
+            f"触发通知次数：{y_stats['triggers']}\n"
+            f"发送通知失败次数：{y_stats['notify_fails']}\n"
+            f"API获取失败次数：{y_stats['api_fails']}\n"
+            f"服务正常运行中。"
+        )
+        self.bot.send_text(msg)
+
+notifier = NotificationManager()
+
+
+# --- 5. API 管理模块 ---
+class TicketAPIManager:
+    def __init__(self, logger_func):
+        self.logger = logger_func
+        self.last_login_fail = 0
+
+    def load_token(self):
+        if os.path.exists(TOKEN_FILE):
+            try:
+                with open(TOKEN_FILE, 'r', encoding='utf-8') as f:
+                    return json.load(f).get('token')
+            except:
+                pass
+        return None
+
+    def login(self):
+        if time.time() - self.last_login_fail < 300: return None
+        username = os.getenv("CINEMA_USERNAME")
+        password = os.getenv("CINEMA_PASSWORD")
+        res_code = os.getenv("CINEMA_RES_CODE")
+        device_id = os.getenv("CINEMA_DEVICE_ID")
+
+        if not all([username, password, res_code]):
+            self.logger("❌ 票务系统环境变量缺失")
+            daily_stats.api_fails += 1
+            return None
+
+        try:
+            session = requests.Session()
+            login_url = 'https://app.bi.piao51.cn/cinema-app/credential/login.action'
+            login_data = {'username': username, 'password': password, 'type': '1', 'resCode': res_code,
+                          'deviceid': device_id, 'dtype': 'ios'}
+            session.post(login_url, data=login_data, timeout=15)
+            resp = session.get('https://app.bi.piao51.cn/cinema-app/security/logined.action', timeout=10)
+            info = resp.json()
+            if info.get("success") and info.get("data", {}).get("token"):
+                with open(TOKEN_FILE, 'w', encoding='utf-8') as f:
+                    json.dump(info['data'], f)
+                return info['data']['token']
+        except Exception as e:
+            self.last_login_fail = time.time()
+            self.logger(f"❌ 票务登录失败: {e}")
+            daily_stats.api_fails += 1
+        return None
+
+    def fetch_schedule(self, date_str):
+        token = self.load_token()
+        if not token:
+            token = self.login()
+            if not token:
+                daily_stats.api_fails += 1
+                return None
+
+        url = 'https://cawapi.yinghezhong.com/showInfo/getHallShowInfo'
+        params = {'showDate': date_str, 'token': token, '_': int(time.time() * 1000)}
+        headers = {'User-Agent': 'Mozilla/5.0'}
+
+        try:
+            res = requests.get(url, params=params, headers=headers, timeout=10)
+            data = res.json()
+            if data.get('code') == 1:
+                return data.get('data', [])
+            elif data.get('code') == 500:
+                token = self.login()
+                if token:
+                    params['token'] = token
+                    res = requests.get(url, params=params, headers=headers, timeout=10)
+                    return res.json().get('data', [])
+        except Exception as e:
+            self.logger(f"⚠️ 票务API异常: {e}")
+            daily_stats.api_fails += 1
+        return None
+
+
+class TMSAPIManager:
+    def __init__(self, logger_func):
+        self.logger = logger_func
+        self.auth_token = None
+        self.last_token_time = 0
+
+    def get_token(self):
+        if self.auth_token and (time.time() - self.last_token_time < 1800):
+            return self.auth_token
+
+        if not all([TMS_APP_SECRET, TMS_TICKET]): return None
+
+        # 获取 OA 系统 Token
+        tms_proxy_base_url = get_tms_proxy_base_url()
+        url = build_tms_url(
+            f'https://tms.hengdianfilm.com/cinema-api/admin/generateToken?token=hd&murl=?token=hd&murl=ticket={TMS_TICKET}',
+            tms_proxy_base_url,
+        )
+        headers = {
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6',
+            'Content-Type': 'application/json',
+            'Cookie': f'JSESSIONID={TMS_X_SESSION_ID}',
+            'DNT': '1',
+            'Origin': 'https://tms.hengdianfilm.com',
+            'Priority': 'u=0, i',
+            'Referer': f'https://tms.hengdianfilm.com/hd/oalogin?ticket={TMS_TICKET}',
+            'Sec-CH-UA': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
+            'Sec-CH-UA-Mobile': '?0',
+            'Sec-CH-UA-Platform': '"macOS"',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36',
+            'X-Requested-With': 'XMLHttpRequest',
+        }
+        headers = with_tms_proxy_headers(headers, tms_proxy_base_url)
+        payload = {'appId': 'hd', 'appSecret': TMS_APP_SECRET, 'timeStamp': int(time.time() * 1000)}
+
+        try:
+            res = requests.post(url, json=payload, headers=headers, timeout=10)
+            data = res.json()
+            if data.get('error_code') == '0000':
+                self.auth_token = data['param']
+                self.last_token_time = time.time()
+                return self.auth_token
+        except:
+            pass
+        daily_stats.api_fails += 1
+        return None
+
+    def fetch_hall_schedule_list(self, hall_number):
+        token = self.get_token()
+        if not token: return None
+
+        tms_hall_id = HALL_ID_MAP.get(str(hall_number))
+        if not tms_hall_id: return None
+
+        tms_proxy_base_url = get_tms_proxy_base_url()
+        url = build_tms_url('https://tms.hengdianfilm.com/cinema-api/cinema/schedule/server/list', tms_proxy_base_url)
+        session_id = TMS_X_SESSION_ID or ''
+        
+        headers = {
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6',
+            'Content-Type': 'application/json; charset=UTF-8',
+            'Cookie': f'JSESSIONID={session_id}',
+            'DNT': '1',
+            'Origin': 'https://tms.hengdianfilm.com',
+            'Priority': 'u=1, i',
+            'Referer': f'https://tms.hengdianfilm.com/hd/index?CinemaMonitorEdit&HALL_ID%3D{tms_hall_id}',
+            'Sec-CH-UA': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
+            'Sec-CH-UA-Mobile': '?0',
+            'Sec-CH-UA-Platform': '"macOS"',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Token': token,
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36',
+            'X-Requested-With': 'XMLHttpRequest',
+            'X-SESSIONID': session_id
+        }
+        headers = with_tms_proxy_headers(headers, tms_proxy_base_url)
+        params = {'token': 'hd', 'murl': 'CinemaMonitor'}
+        json_data = {
+            'THEATER_ID': 38205954,
+            'STATE': 0,
+            'HALL_ID': tms_hall_id,
+            'START_TIME': int(time.time() * 1000),
+            'PAGE_CAPACITY': 20,
+            'PAGE_INDEX': 1,
+        }
+
+        try:
+            res = requests.post(url, params=params, headers=headers, json=json_data, timeout=10,
+                                verify=tms_verify_ssl(default=False, proxy_url=tms_proxy_base_url))
+            data = res.json()
+            if data.get("RSPCD") == "000000":
+                return data.get("BODY", {}).get("LIST", [])
+            else:
+                return None
+        except Exception as e:
+            self.logger(f"⚠️ TMS 请求异常: {e}")
+            daily_stats.api_fails += 1
+            return None
+
+    def trigger_schedule_refresh(self):
+        """触发 TMS 排期刷新"""
+        token = self.get_token()
+        if not token or not TMS_THEATER_ID: return
+
+        try:
+            # 动态生成时间戳
+            now_tm = time.localtime()
+            today_midnight = time.mktime((now_tm.tm_year, now_tm.tm_mon, now_tm.tm_mday, 0, 0, 0, 0, 0, 0))
+            start_date = int(today_midnight * 1000)
+            end_date = start_date + (24 * 60 * 60 * 1000)
+
+            tms_proxy_base_url = get_tms_proxy_base_url()
+            url = build_tms_url('https://tms.hengdianfilm.com/cinema-api/tms/cmd/show/schedule', tms_proxy_base_url)
+            session_id = TMS_X_SESSION_ID or ''
+            
+            headers = {
+                'accept': 'application/json, text/javascript, */*; q=0.01',
+                'content-type': 'application/json; charset=UTF-8',
+                'origin': 'https://tms.hengdianfilm.com',
+                'referer': f'https://tms.hengdianfilm.com/hd/index?Scheduling&THEATER_ID={TMS_THEATER_ID}&DATE={start_date}&PAGE_CAPACITY=20&PAGE_INDEX=1',
+                'token': token, # 这里的 token 由 get_token() 动态获取
+                'user-agent': 'Mozilla/5.0',
+                'x-requested-with': 'XMLHttpRequest',
+                'x-sessionid': session_id
+            }
+            headers = with_tms_proxy_headers(headers, tms_proxy_base_url)
+            
+            params = {
+                'token': 'hd',
+                'murl': 'Scheduling',
+            }
+
+            cookies = {'JSESSIONID': session_id}
+            
+            json_data = {
+                'THEATER_LIST': [
+                    {
+                        'THEATER_ID': int(TMS_THEATER_ID),
+                        'START_DATE': start_date,
+                        'END_DATE': end_date,
+                    },
+                ],
+            }
+
+            # 发送请求，非阻塞，忽略证书错误
+            requests.post(
+                url,
+                params=params,
+                headers=headers,
+                cookies=cookies,
+                json=json_data,
+                timeout=5,
+                verify=tms_verify_ssl(default=False, proxy_url=tms_proxy_base_url),
+            )
+            self.logger("🔄 TMS 排期刷新指令已发送")
+
+        except Exception as e:
+            # 刷新失败不影响主程序
+            self.logger(f"⚠️ TMS 排期刷新失败: {e}")
+
+
+# --- 6. 智能监控主逻辑 ---
+class PlaybackMonitor:
+    def __init__(self):
+        self.logs = deque(maxlen=50)
+        self.status_text = "初始化中..."
+        self.next_wakeup_str = "--:--:--"
+        self.active_monitors = []
+
+        self.cleared_sessions = set()
+        self.processed_checks = set()
+
+        self.ticket_api = TicketAPIManager(self.log)
+        self.tms_api = TMSAPIManager(self.log)
+
+        self.current_business_date = None
+        self.daily_schedule_cache = None
+        self.last_daily_report_date = None
+
+        self.thread = threading.Thread(target=self._run_loop, daemon=True)
+        self.thread.start()
+
+    def log(self, msg):
+        ts = get_beijing_now().strftime("%H:%M:%S")
+        entry = f"[{ts}] {msg}"
+        self.logs.appendleft(entry)
+        print(entry)
+
+    def _get_target_check_points(self, schedule_list, business_date):
+        check_points = []
+        zero_count = 0
+        for item in schedule_list:
+            sold = int(item.get('soldTicketNum') or 0)
+            if sold == 0:
+                zero_count += 1
+                start_str = item.get('showStartTime')
+                if not start_str: continue
+
+                show_dt = parse_show_datetime(business_date, start_str)
+                if not show_dt: continue
+
+                for i in range(3):
+                    check_time = show_dt + timedelta(minutes=i * 5)
+                    check_points.append({
+                        'time': check_time,
+                        'type': 'CHECK',
+                        'check_index': i,
+                        'data': item
+                    })
+
+        daily_stats.zero_sessions = zero_count
+
+        check_points.sort(key=lambda x: x['time'])
+        return check_points
+
+    def _run_loop(self):
+        self.log("🚀 空场防空转监控服务已启动")
+        is_first_run = True
+
+        while True:
+            try:
+                now = get_beijing_now()
+                biz_date = get_business_date()
+                today_str = now.strftime("%Y-%m-%d")
+
+                if is_first_run:
+                    if now.time() >= dt_time(9, 0):
+                        self.last_daily_report_date = today_str
+                        self.log(f"🟡 首次运行，跳过当日即时通知: {today_str}")
+                    else:
+                        self.log("🟡 首次运行完成初始化，等待 09:00 后再发送每日报告")
+                    is_first_run = False
+
+                # --- 初始化与日期变更 ---
+                need_refresh = False
+                if self.daily_schedule_cache is None:
+                    need_refresh = True
+                    self.log("🆕 初始化：获取全天排片...")
+                    self.current_business_date = biz_date
+                elif self.current_business_date != biz_date:
+                    if now.time() >= dt_time(9, 0):
+                        need_refresh = True
+
+                        daily_stats.snapshot_as_yesterday(self.current_business_date)
+                        self.cleared_sessions.clear()
+                        self.processed_checks.clear()
+                        self.log(f"🌞 新营业日 ({biz_date})：刷新排片...")
+
+                if need_refresh:
+                    schedule = self.ticket_api.fetch_schedule(biz_date)
+                    if schedule:
+                        self.daily_schedule_cache = schedule
+                        self.current_business_date = biz_date
+                        self.log(f"✅ 排片已更新，共 {len(schedule)} 场。")
+                    else:
+                        self.log("⚠️ 获取排片失败，5分钟后重试")
+                        daily_stats.api_fails += 1
+                        time.sleep(300)
+                        continue
+
+                if now.time() >= dt_time(9, 0) and self.last_daily_report_date != today_str and self.daily_schedule_cache is not None:
+                    try:
+                        d_obj = datetime.strptime(biz_date, "%Y-%m-%d")
+                        date_cn = f"{d_obj.year}年{d_obj.month}月{d_obj.day}日"
+                    except:
+                        date_cn = biz_date
+
+                    self.log(f"🔔 发送每日统计报告: {date_cn}")
+                    notifier.send_daily_report(date_cn)
+                    self.last_daily_report_date = today_str
+
+                # --- 任务计算 ---
+                check_points = self._get_target_check_points(self.daily_schedule_cache, biz_date)
+
+                next_target = None
+                for cp in check_points:
+                    hall_id = extract_hall_number_raw(cp['data']['hallName'])
+                    start_str = cp['data']['showStartTime']
+                    check_idx = cp['check_index']
+                    dedup_key = f"{biz_date}_{hall_id}_{start_str}_{check_idx}"
+
+                    if dedup_key in self.processed_checks:
+                        continue
+
+                    if cp['time'] > (now - timedelta(seconds=30)):
+                        next_target = cp
+                        break
+
+                if next_target:
+                    target_time = next_target['time']
+
+                    # 09:00 拦截器
+                    nine_am_today = datetime.combine(now.date(), dt_time(9, 0))
+                    force_wake_for_daily_reset = False
+                    if now < nine_am_today and target_time > nine_am_today:
+                        target_time = nine_am_today
+                        force_wake_for_daily_reset = True
+
+                    sleep_seconds = max(0, (target_time - now).total_seconds())
+
+                    self.status_text = "💤 休眠中"
+                    self.next_wakeup_str = target_time.strftime('%H:%M:%S')
+
+                    if force_wake_for_daily_reset:
+                        self.active_monitors = ["等待 09:00 日报刷新..."]
+                    else:
+                        raw_hall = next_target['data']['hallName']
+                        clean_hall = format_hall_name(raw_hall)
+                        self.active_monitors = [
+                            f"下个任务: {clean_hall} {next_target['data']['showStartTime']} (第{next_target['check_index'] + 1}次检查)"]
+
+                    self.log(f"💤 智能休眠 {int(sleep_seconds)}秒，将在 {self.next_wakeup_str} 唤醒...")
+
+                    time.sleep(sleep_seconds)
+
+                    if force_wake_for_daily_reset:
+                        continue
+
+                    # --- 正常唤醒检查 ---
+                    self.status_text = "🔥 正在检查"
+                    self.log("⏰ 唤醒！正在同步最新票务数据...")
+
+                    latest_schedule = self.ticket_api.fetch_schedule(biz_date)
+                    if latest_schedule:
+                        self.daily_schedule_cache = latest_schedule
+                    else:
+                        self.log("⚠️ 同步排片失败，使用旧数据")
+                        daily_stats.api_fails += 1
+                        latest_schedule = self.daily_schedule_cache
+
+                    check_now = get_beijing_now()
+                    current_targets = []
+                    latest_check_points = self._get_target_check_points(latest_schedule, biz_date)
+
+                    for cp in latest_check_points:
+                        time_diff = abs((cp['time'] - check_now).total_seconds())
+                        if time_diff < 120:
+                            current_targets.append(cp)
+
+                    if current_targets:
+                        self._process_targets(current_targets, biz_date)
+
+                    time.sleep(5)
+
+                else:
+                    self.status_text = "🌙 今日监控结束"
+                    self.active_monitors = []
+                    tmr_9am = datetime.combine(datetime.strptime(biz_date, "%Y-%m-%d").date() + timedelta(days=1),
+                                               dt_time(9, 0))
+                    seconds_to_tmr = (tmr_9am - now).total_seconds()
+
+                    if seconds_to_tmr > 3600:
+                        self.log("暂无目标，休眠 1 小时...")
+                        time.sleep(3600)
+                    else:
+                        self.log(f"休眠至明日 09:00...")
+                        time.sleep(seconds_to_tmr)
+
+            except Exception as e:
+                self.log(f"❌ 主循环异常: {e}")
+                time.sleep(60)
+
+    def _process_targets(self, targets, biz_date):
+        halls_to_check = {}
+        for t in targets:
+            hall_id = extract_hall_number_raw(t['data']['hallName'])
+            start_str = t['data']['showStartTime']
+            check_idx = t['check_index']
+
+            dedup_key = f"{biz_date}_{hall_id}_{start_str}_{check_idx}"
+            if dedup_key in self.processed_checks:
+                continue
+
+            if hall_id not in halls_to_check:
+                halls_to_check[hall_id] = []
+            halls_to_check[hall_id].append(t)
+
+        if not halls_to_check: return
+
+        self.log(f"🔍 核查 {len(halls_to_check)} 个影厅 TMS 状态...")
+        display_results = []
+
+        for hall_id, target_list in halls_to_check.items():
+
+            all_cleared = True
+            for target in target_list:
+                start_str = target['data'].get('showStartTime')
+                key = f"{biz_date}_{hall_id}_{start_str}"
+                if key not in self.cleared_sessions:
+                    all_cleared = False
+                    break
+
+            if all_cleared:
+                for target in target_list:
+                    dedup_key = f"{biz_date}_{hall_id}_{target['data']['showStartTime']}_{target['check_index']}"
+                    self.processed_checks.add(dedup_key)
+
+                clean_name = format_hall_name(target_list[0]['data']['hallName'])
+                display_results.append(f"{clean_name} ✅ [已跳过 (已确认撤场)]")
+                continue
+
+            tms_list = self.tms_api.fetch_hall_schedule_list(hall_id)
+
+            for target in target_list:
+                session = target['data']
+                check_idx = target['check_index']
+                hall_name_raw = session.get('hallName')
+                movie_name = session.get('movieName')
+                ticket_start_str = session.get('showStartTime')
+                ticket_start_dt = parse_show_datetime(biz_date, ticket_start_str)
+
+                unique_key = f"{biz_date}_{hall_id}_{ticket_start_str}"
+                dedup_key = f"{biz_date}_{hall_id}_{ticket_start_str}_{check_idx}"
+
+                if dedup_key in self.processed_checks: continue
+                if unique_key in self.cleared_sessions:
+                    self.processed_checks.add(dedup_key)
+                    continue
+
+                hall_name_clean = format_hall_name(hall_name_raw)
+                status_desc = f"{hall_name_clean} {ticket_start_str} (第{check_idx + 1}/3次)"
+
+                if tms_list is not None:
+                    match_found = False
+                    for tms_item in tms_list:
+                        t_start_str = tms_item.get('START_TIME')
+                        if not t_start_str: continue
+                        t_start_dt = parse_show_datetime(biz_date, t_start_str)
+                        if not t_start_dt: continue
+                        if abs((t_start_dt - ticket_start_dt).total_seconds()) < 1800:
+                            match_found = True
+                            break
+
+                    if match_found:
+                        status_desc += " ⚠️ [空转! TMS未撤]"
+                        self.log(f"🚨 发现空转: {hall_name_clean}《{movie_name}》")
+                        
+                        # 调用新的告警接口
+                        count_info = f"第 {check_idx + 1}/3 次检查"
+                        remark = "仅停止播放未撤排程下次检查依然会推送通知。"
+                        notifier.send_idle_alert(hall_name_clean, movie_name, ticket_start_str, count_info, remark)
+                        
+                        # --- NEW: 第一次发现后，触发TMS刷新 ---
+                        if check_idx == 0:
+                            self.tms_api.trigger_schedule_refresh()
+
+                    else:
+                        status_desc += " ✅ [正常 (TMS无排期)]"
+                        self.cleared_sessions.add(unique_key)
+                else:
+                    status_desc += " ❓ [TMS查询失败]"
+                    daily_stats.api_fails += 1
+
+                self.processed_checks.add(dedup_key)
+                display_results.append(status_desc)
+
+        self.active_monitors = display_results
+
+
+# --- 7. Streamlit 前端 ---
+@st.cache_resource
+def get_monitor():
+    return PlaybackMonitor()
+
+
+def main():
+    monitor = get_monitor()
+
+    if st_autorefresh:
+        st_autorefresh(interval=30 * 1000, key="pb_refresh")
+
+    st.title("💸 空场防空转监控")
+
+    remaining_zero_count = 0
+    remaining_total_count = 0
+    if monitor.daily_schedule_cache:
+        now = get_beijing_now()
+        biz_date = monitor.current_business_date or get_business_date()
+
+        for item in monitor.daily_schedule_cache:
+            start_str = item.get('showStartTime')
+            if not start_str: continue
+
+            show_dt = parse_show_datetime(biz_date, start_str)
+            if show_dt and show_dt > now:
+                remaining_total_count += 1
+                if int(item.get('soldTicketNum') or 0) == 0:
+                    remaining_zero_count += 1
+
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        st.metric("运行状态", monitor.status_text)
+    with c2:
+        st.metric("下次唤醒", monitor.next_wakeup_str)
+    with c3:
+        st.metric("剩余 0 票场次 / 剩余总场次", f"{remaining_zero_count} / {remaining_total_count}")
+
+    st.divider()
+
+    col_logs, col_mon = st.columns([3, 2])
+
+    with col_logs:
+        st.subheader("📜 运行日志")
+        st.text_area("Logs", "\n".join(list(monitor.logs)), height=450, disabled=True)
+
+    with col_mon:
+        st.subheader("🎯 实时检查结果")
+        if monitor.active_monitors:
+            for m in monitor.active_monitors:
+                if "⚠️" in m:
+                    st.error(m)
+                elif "✅" in m:
+                    st.success(m)
+                else:
+                    st.info(m)
+        else:
+            st.caption("暂无检查结果")
+
+
+if __name__ == "__main__":
+    main()

pages/📡 次日排片 TMS 文件核对.py

@@ -0,0 +1,705 @@
+import json
+import os
+import re
+import time
+from collections import defaultdict
+from datetime import date, timedelta
+
+import requests
+import streamlit as st
+import urllib3
+from dotenv import load_dotenv
+from tms_proxy import build_tms_url, get_tms_proxy_base_url, tms_verify_ssl, with_tms_proxy_headers
+
+
+st.set_page_config(page_title="次日排片TMS核对（日期范围）", page_icon="📡", layout="wide")
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+load_dotenv()
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+TOKEN_FILE = os.path.join(ROOT_DIR, "token_data.json")
+
+
+def load_token():
+    if os.path.exists(TOKEN_FILE):
+        try:
+            with open(TOKEN_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return None
+    return None
+
+
+def save_token(token_data):
+    try:
+        with open(TOKEN_FILE, "w", encoding="utf-8") as f:
+            json.dump(token_data, f, ensure_ascii=False, indent=4)
+        return True
+    except Exception as e:
+        st.error(f"保存 Token 失败：{e}")
+        return False
+
+
+def login_and_get_token():
+    username = os.getenv("CINEMA_USERNAME")
+    password = os.getenv("CINEMA_PASSWORD")
+    res_code = os.getenv("CINEMA_RES_CODE")
+    device_id = os.getenv("CINEMA_DEVICE_ID")
+
+    if not all([username, password, res_code]):
+        st.error("登录失败：未配置 CINEMA_USERNAME / CINEMA_PASSWORD / CINEMA_RES_CODE。")
+        return None
+
+    session = requests.Session()
+    session.headers.update({
+        "Host": "app.bi.piao51.cn",
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+    })
+
+    login_url = "https://app.bi.piao51.cn/cinema-app/credential/login.action"
+    login_headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "Origin": "https://app.bi.piao51.cn",
+    }
+    login_data = {
+        "username": username,
+        "password": password,
+        "type": "1",
+        "resCode": res_code,
+        "deviceid": device_id,
+        "dtype": "ios",
+    }
+
+    try:
+        response_login = session.post(login_url, headers=login_headers, data=login_data, allow_redirects=False, timeout=15)
+        if not (300 <= response_login.status_code < 400 and "token" in session.cookies):
+            st.error(f"登录步骤 1 失败，未能获取 Session Token。状态码：{response_login.status_code}")
+            return None
+
+        user_info_url = "https://app.bi.piao51.cn/cinema-app/security/logined.action"
+        response_user_info = session.get(user_info_url, timeout=10)
+        response_user_info.raise_for_status()
+
+        user_info = response_user_info.json()
+        if user_info.get("success") and user_info.get("data", {}).get("token"):
+            token_data = user_info["data"]
+            if save_token(token_data):
+                st.toast("登录成功，已获取并保存新 Token。", icon="🔑")
+            return token_data
+
+        st.error(f"登录步骤 2 失败：{user_info.get('msg')}")
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"登录请求过程中发生网络错误：{e}")
+        return None
+
+
+def fetch_hall_info(token):
+    url = "https://cawapi.yinghezhong.com/showInfo/getShowHallInfo"
+    params = {"token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+    response = requests.get(url, params=params, headers=headers, timeout=10)
+    response.raise_for_status()
+    data = response.json()
+    if data.get("code") == 1 and data.get("data"):
+        return {item["hallId"]: item["seatNum"] for item in data["data"]}
+    raise RuntimeError(f"获取影厅信息失败：{data.get('msg', '未知错误')}")
+
+
+def fetch_schedule_data(token, show_date):
+    url = "https://cawapi.yinghezhong.com/showInfo/getHallShowInfo"
+    params = {"showDate": show_date, "token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+    response = requests.get(url, params=params, headers=headers, timeout=15)
+    response.raise_for_status()
+    data = response.json()
+    if data.get("code") == 1:
+        return data.get("data", [])
+    if data.get("code") == 500:
+        raise ValueError("Token 可能已失效")
+    raise RuntimeError(f"获取排片数据失败：{data.get('msg', '未知错误')}")
+
+
+def get_api_data_with_token_management(show_date):
+    token_data = load_token()
+    token = token_data.get("token") if token_data else None
+    if not token:
+        token_data = login_and_get_token()
+        if not token_data:
+            return None, None
+        token = token_data.get("token")
+
+    try:
+        schedule_list = fetch_schedule_data(token, show_date)
+        hall_seat_map = fetch_hall_info(token)
+        return schedule_list, hall_seat_map
+    except ValueError:
+        st.toast("Token 已失效，正在重新登录并重试...", icon="🔄")
+        token_data = login_and_get_token()
+        if not token_data:
+            return None, None
+        token = token_data.get("token")
+        try:
+            schedule_list = fetch_schedule_data(token, show_date)
+            hall_seat_map = fetch_hall_info(token)
+            return schedule_list, hall_seat_map
+        except Exception as e:
+            st.error(f"重试获取排片数据失败：{e}")
+            return None, None
+    except Exception as e:
+        st.error(f"获取排片数据时发生错误：{e}")
+        return None, None
+
+
+def _get_tms_env_and_auth():
+    """读取 TMS 环境变量并完成 generateToken 认证，返回 (theater_id, x_session_id, ticket, auth_token, proxy_base_url)。"""
+    app_secret = os.getenv("TMS_APP_SECRET")
+    ticket = os.getenv("TMS_TICKET")
+    theater_id_str = os.getenv("TMS_THEATER_ID")
+    x_session_id = os.getenv("TMS_X_SESSION_ID")
+
+    if not all([app_secret, ticket, theater_id_str, x_session_id]):
+        raise ValueError("TMS 环境变量不完整，请检查 TMS_APP_SECRET/TMS_TICKET/TMS_THEATER_ID/TMS_X_SESSION_ID")
+
+    theater_id = int(str(theater_id_str))
+    tms_proxy_base_url = get_tms_proxy_base_url()
+
+    token_headers = {
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "Content-Type": "application/json",
+        "Cookie": f"JSESSIONID={x_session_id}",
+        "Origin": "https://tms.hengdianfilm.com",
+        "Referer": f"https://tms.hengdianfilm.com/hd/oalogin?ticket={ticket}",
+        "User-Agent": "Mozilla/5.0",
+        "X-Requested-With": "XMLHttpRequest",
+    }
+    token_json_data = {
+        "appId": "hd",
+        "appSecret": app_secret,
+        "timeStamp": int(time.time() * 1000),
+    }
+    token_url = build_tms_url(
+        f"https://tms.hengdianfilm.com/cinema-api/admin/generateToken?token=hd&murl=?token=hd&murl=ticket={ticket}",
+        tms_proxy_base_url,
+    )
+    token_headers = with_tms_proxy_headers(token_headers, tms_proxy_base_url)
+
+    token_resp = requests.post(token_url, headers=token_headers, json=token_json_data, timeout=12)
+    token_resp.raise_for_status()
+    token_data = token_resp.json()
+    if token_data.get("error_code") != "0000":
+        raise RuntimeError(f"TMS 认证失败: {token_data.get('error_desc')}")
+    auth_token = token_data.get("param")
+    return theater_id, x_session_id, ticket, auth_token, tms_proxy_base_url
+
+
+def fetch_tms_hall_status():
+    """拉取 TMS 影厅设备列表，返回按厅号排序的列表。STATUS==1 视为在线。"""
+    theater_id, x_session_id, ticket, auth_token, tms_proxy_base_url = _get_tms_env_and_auth()
+
+    list_url = build_tms_url(
+        "https://tms.hengdianfilm.com/cinema-api/cinema/hall/list",
+        tms_proxy_base_url,
+    )
+
+    halls = []
+    page_index = 1
+    while True:
+        list_headers = {
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Content-Type": "application/json; charset=UTF-8",
+            "Cookie": f"JSESSIONID={x_session_id}",
+            "Origin": "https://tms.hengdianfilm.com",
+            "Referer": f"https://tms.hengdianfilm.com/hd/index?CinemaListEdit&THEATER_ID={theater_id}",
+            "Token": auth_token,
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "X-SESSIONID": x_session_id,
+        }
+        list_headers = with_tms_proxy_headers(list_headers, tms_proxy_base_url)
+        list_params = {"token": "hd", "murl": "CinemaList"}
+        list_json = {
+            "PAGE_INDEX": page_index,
+            "THEATER_ID": str(theater_id),
+            "PAGE_CAPACITY": 20,
+        }
+
+        resp = requests.post(
+            list_url,
+            params=list_params,
+            headers=list_headers,
+            json=list_json,
+            timeout=15,
+            verify=tms_verify_ssl(default=False, proxy_url=tms_proxy_base_url),
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("RSPCD") != "000000":
+            raise RuntimeError(f"TMS 影厅列表接口失败: {data.get('RSPMSG')}")
+
+        body = data.get("BODY", {}) or {}
+        items = body.get("LIST", []) or []
+        if not items:
+            break
+        halls.extend(items)
+        if len(halls) >= body.get("COUNT", 0):
+            break
+        page_index += 1
+        time.sleep(0.2)
+
+    halls.sort(key=lambda h: get_hall_sort_key(h.get("NAME") or h.get("OUTER_ID") or ""))
+    return halls
+
+
+def fetch_tms_server_movies_by_hall():
+    theater_id, x_session_id, ticket, auth_token, tms_proxy_base_url = _get_tms_env_and_auth()
+
+    all_movies = []
+    page_index = 1
+    while True:
+        list_headers = {
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Content-Type": "application/json; charset=UTF-8",
+            "Cookie": f"JSESSIONID={x_session_id}",
+            "Origin": "https://tms.hengdianfilm.com",
+            "Referer": f"https://tms.hengdianfilm.com/hd/index?ContentMovie&THEATER_ID={theater_id}",
+            "Token": auth_token,
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "X-SESSIONID": x_session_id,
+        }
+        list_params = {"token": "hd", "murl": "ContentMovie"}
+        list_json = {
+            "THEATER_ID": theater_id,
+            "SOURCE": "SERVER",
+            "ASSERT_TYPE": 2,
+            "PAGE_CAPACITY": 20,
+            "PAGE_INDEX": page_index,
+        }
+        list_url = build_tms_url(
+            "https://tms.hengdianfilm.com/cinema-api/cinema/server/dcp/list",
+            tms_proxy_base_url,
+        )
+        list_headers = with_tms_proxy_headers(list_headers, tms_proxy_base_url)
+
+        resp = requests.post(
+            list_url,
+            params=list_params,
+            headers=list_headers,
+            json=list_json,
+            timeout=15,
+            verify=tms_verify_ssl(default=False, proxy_url=tms_proxy_base_url),
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("RSPCD") != "000000":
+            raise RuntimeError(f"TMS 列表接口失败: {data.get('RSPMSG')}")
+
+        body = data.get("BODY", {})
+        items = body.get("LIST", [])
+        if not items:
+            break
+        all_movies.extend(items)
+        if len(all_movies) >= body.get("COUNT", 0):
+            break
+        page_index += 1
+        time.sleep(0.3)
+
+    movie_details = {
+        m.get("CONTENT_NAME"): {
+            "assert_name": m.get("ASSERT_NAME"),
+            "assert_id": m.get("ASSERT_ID"),
+            "source_format": m.get("SOURCE_FORMAT"),
+            "halls": sorted([h.get("HALL_NAME") for h in m.get("HALL_INFO", [])]),
+        }
+        for m in all_movies
+        if m.get("CONTENT_NAME")
+    }
+
+    by_hall = defaultdict(list)
+    for content_name, details in movie_details.items():
+        for hall_name in details.get("halls", []):
+            by_hall[hall_name].append({"content_name": content_name, "details": details})
+
+    return dict(by_hall)
+
+
+def format_movie_display_name(movie_name, movie_language, movie_media_type):
+    """统一的影片展示名：``片名 语言 制式``，缺失部分自动跳过。"""
+    name = str(movie_name or "").strip() or "未知影片"
+    parts = [name]
+    language = str(movie_language or "").strip()
+    if language:
+        parts.append(language)
+    media = str(movie_media_type or "").strip()
+    if media:
+        parts.append(media)
+    return " ".join(parts)
+
+
+def check_tms_file_availability(schedule_list, tms_data, date_str):
+    if not schedule_list:
+        return {"issue_text": "未获取到排片数据，无法检查。", "issues": []}
+    if not tms_data:
+        return {"issue_text": "未获取到 TMS 数据，无法检查。", "issues": []}
+
+    def clean_hall_display_name(raw_name):
+        hall_name = str(raw_name or "").strip("【】[] ").strip()
+        hall_num_match = re.search(r"(\d+)\s*号", hall_name)
+        if hall_num_match:
+            return f"{hall_num_match.group(1)}号厅"
+        return hall_name
+
+    def get_hall_key_num(name):
+        nums = re.findall(r"\d+", str(name))
+        return nums[0] if nums else str(name)
+
+    def normalize_id_code(value):
+        s = str(value or "").strip().upper()
+        if not s or s == "NAN":
+            return ""
+        if re.fullmatch(r"[A-Z0-9]+\.0", s):
+            s = s[:-2]
+        return re.sub(r"[^A-Z0-9]", "", s)
+
+    def to_12_digit_movie_num(movie_num):
+        s = normalize_id_code(movie_num)
+        return s[:12] if len(s) >= 12 else ""
+
+    def normalize_media_type(media_type):
+        v = str(media_type or "").upper()
+        if "3D" in v:
+            return "3D"
+        if "2D" in v:
+            return "2D"
+        return ""
+
+    def normalize_source_format(source_format, content_name):
+        sf = str(source_format or "").upper()
+        cn = str(content_name or "").upper()
+        if "3D" in sf or re.search(r"(^|_)FTR-3D([_-]|$)", cn):
+            return "3D"
+        if "2D" in sf or re.search(r"(^|_)FTR-2D([_-]|$)", cn):
+            return "2D"
+        return ""
+
+    def normalize_language(movie_language):
+        v = str(movie_language or "").strip().upper()
+        if not v:
+            return ""
+        if "粤" in v or "YUE" in v:
+            return "YUE"
+        if "英语" in v or "原版" in v or "原声" in v or v == "EN":
+            return "EN"
+        if "国语" in v or "普通话" in v or "中文" in v or "CMN" in v or "ZH" in v:
+            return "CMN"
+        return ""
+
+    def language_match(lang_key, content_name, assert_name):
+        if not lang_key:
+            return True
+        cn = str(content_name or "").upper()
+        an = str(assert_name or "")
+
+        if lang_key == "YUE":
+            return bool(re.search(r"(^|_)YUE([-_]|$)", cn)) or ("粤语" in an)
+        if lang_key == "EN":
+            return bool(re.search(r"(^|_)EN([-_]|$)", cn)) or ("英语" in an) or ("原版" in an) or ("原声" in an)
+        if lang_key == "CMN":
+            return bool(re.search(r"(^|_)(CMN|ZH)([-_]|$)", cn)) or ("国语" in an) or ("中文" in an)
+        return True
+
+    tms_by_hall = defaultdict(list)
+    for hall_name, movies in tms_data.items():
+        hall_key = get_hall_key_num(hall_name)
+        for movie in movies:
+            details = movie.get("details", {}) or {}
+            content_name = str(movie.get("content_name") or "")
+            assert_name = str(details.get("assert_name") or "")
+            assert_id_raw = str(details.get("assert_id") or "")
+            assert_id_norm = normalize_id_code(assert_id_raw)
+            source_format = str(details.get("source_format") or "")
+
+            tms_by_hall[hall_key].append({
+                "content_name": content_name,
+                "assert_name": assert_name,
+                "assert_id": assert_id_raw,
+                "assert_id_norm": assert_id_norm,
+                "assert_12": assert_id_norm[:12] if len(assert_id_norm) >= 12 else "",
+                "media": normalize_source_format(source_format, content_name),
+            })
+
+    issue_records = []
+    checked = set()
+
+    def append_issue(issue_type, hall_num, hall_display, movie_name, message, item):
+        issue_records.append({
+            "issue_type": issue_type,
+            "date": date_str,
+            "hall_num": str(hall_num),
+            "hall_display": str(hall_display),
+            "movie_name": str(movie_name),
+            "movie_num": str(item.get("movieNum") or ""),
+            "movie_language": str(item.get("movieLanguage") or ""),
+            "movie_media_type": str(item.get("movieMediaType") or ""),
+            "message": message,
+        })
+
+    for item in schedule_list:
+        hall_raw = item.get("hallName") or item.get("Hall")
+        movie_raw = item.get("movieName") or item.get("Movie")
+        if not hall_raw or not movie_raw:
+            continue
+
+        hall_num = get_hall_key_num(hall_raw)
+        hall_display = clean_hall_display_name(hall_raw)
+        movie_name = str(movie_raw)
+        movie_language_raw = str(item.get("movieLanguage") or "").strip()
+        movie_media_raw = str(item.get("movieMediaType") or "").strip()
+        movie_display = format_movie_display_name(movie_name, movie_language_raw, movie_media_raw)
+        movie_num_12 = to_12_digit_movie_num(item.get("movieNum"))
+        language_key = normalize_language(item.get("movieLanguage"))
+        media_key = normalize_media_type(item.get("movieMediaType"))
+
+        combo_key = (hall_num, movie_num_12, language_key, media_key, movie_name)
+        if combo_key in checked:
+            continue
+        checked.add(combo_key)
+
+        hall_candidates = tms_by_hall.get(hall_num, [])
+        if not hall_candidates:
+            continue
+
+        coarse_candidates = [c for c in hall_candidates if c.get("assert_12") == movie_num_12] if movie_num_12 else hall_candidates[:]
+        if not coarse_candidates:
+            append_issue(
+                "missing_assert12",
+                hall_num,
+                hall_display,
+                movie_name,
+                f"【{hall_display}】《{movie_display}》movieNum={item.get('movieNum')} 未命中同厅 ASSERT_ID 前12位。",
+                item,
+            )
+            continue
+
+        lang_candidates = coarse_candidates
+        if language_key:
+            lang_filtered = [
+                c for c in coarse_candidates
+                if language_match(language_key, c.get("content_name"), c.get("assert_name"))
+            ]
+            if lang_filtered:
+                lang_candidates = lang_filtered
+
+        media_candidates = lang_candidates
+        if media_key:
+            media_filtered = [c for c in lang_candidates if c.get("media") == media_key]
+            if media_filtered:
+                media_candidates = media_filtered
+
+        id_display_map = {}
+        for c in media_candidates:
+            assert_id_norm = c.get("assert_id_norm")
+            if not assert_id_norm:
+                continue
+            if assert_id_norm not in id_display_map:
+                id_display_map[assert_id_norm] = str(c.get("assert_id") or assert_id_norm).strip().upper()
+
+        unique_assert_id_norms = sorted(id_display_map.keys())
+        if not unique_assert_id_norms:
+            append_issue(
+                "missing_assert_id",
+                hall_num,
+                hall_display,
+                movie_name,
+                f"【{hall_display}】《{movie_display}》已命中前12位，但未找到可确权的 ASSERT_ID（语言={item.get('movieLanguage')}，制式={item.get('movieMediaType')}）。",
+                item,
+            )
+            continue
+
+        if len(unique_assert_id_norms) > 1:
+            sample_names = " | ".join([c.get("content_name", "") for c in media_candidates[:3]])
+            display_ids = [id_display_map[i] for i in unique_assert_id_norms[:5]]
+            append_issue(
+                "ambiguous_assert_id",
+                hall_num,
+                hall_display,
+                movie_name,
+                f"【{hall_display}】《{movie_display}》命中多个 ASSERT_ID（{', '.join(display_ids)}），未唯一确权。样本：{sample_names}",
+                item,
+            )
+
+    if not issue_records:
+        return {"issue_text": None, "issues": []}
+
+    lines = [f"{idx}. ⚠️ TMS核对警告：{issue['message']}" for idx, issue in enumerate(issue_records, 1)]
+    return {"issue_text": "\n".join(lines), "issues": issue_records}
+
+
+def iter_dates(start_dt: date, end_dt: date):
+    d = start_dt
+    while d <= end_dt:
+        yield d
+        d += timedelta(days=1)
+
+
+def format_short_day(value):
+    text = str(value or "").strip()
+    if not text:
+        return "--"
+
+    try:
+        return date.fromisoformat(text).strftime("%m%d")
+    except ValueError:
+        return text
+
+
+def get_hall_sort_key(name):
+    nums = re.findall(r"\d+", str(name))
+    if nums:
+        return 0, int(nums[0]), str(name)
+    return 1, 0, str(name)
+
+
+def build_missing_file_summary(issue_records):
+    missing_issue_types = {"missing_assert12", "missing_assert_id"}
+    # 以 (片名, 语言, 制式) 作为聚合键，避免不同语言/制式版本被合并到同一条
+    hall_movie_dates = defaultdict(lambda: defaultdict(set))
+    movie_display_map = defaultdict(dict)
+
+    for issue in issue_records:
+        if issue.get("issue_type") not in missing_issue_types:
+            continue
+        hall_display = str(issue.get("hall_display") or "未知影厅")
+        movie_name = str(issue.get("movie_name") or "未知影片")
+        movie_language = str(issue.get("movie_language") or "").strip()
+        movie_media_type = str(issue.get("movie_media_type") or "").strip()
+        movie_key = (movie_name, movie_language, movie_media_type)
+        movie_display_map[hall_display][movie_key] = format_movie_display_name(
+            movie_name, movie_language, movie_media_type
+        )
+
+        issue_date = format_short_day(issue.get("date"))
+        if issue_date and issue_date != "--":
+            hall_movie_dates[hall_display][movie_key].add(issue_date)
+        else:
+            hall_movie_dates[hall_display][movie_key]
+
+    summary_lines = []
+    for hall_display in sorted(hall_movie_dates.keys(), key=get_hall_sort_key):
+        movie_parts = []
+        movie_keys_sorted = sorted(
+            hall_movie_dates[hall_display].keys(),
+            key=lambda k: movie_display_map[hall_display][k],
+        )
+        for movie_key in movie_keys_sorted:
+            display_name = movie_display_map[hall_display][movie_key]
+            dates = [day for day in sorted(hall_movie_dates[hall_display][movie_key]) if day and day != "--"]
+            if dates:
+                movie_parts.append(f"《{display_name}》（{'/'.join(dates)}）")
+            else:
+                movie_parts.append(f"《{display_name}》")
+        summary_lines.append(f"{hall_display} 缺少{' '.join(movie_parts)}的文件")
+
+    return summary_lines
+
+
+st.title("📡 次日排片 TMS 文件核对")
+st.caption("默认从明天开始到未来第5天。点击按钮后自动拉取排程与TMS数据并逐日核对。")
+
+
+default_start = date.today() + timedelta(days=1)
+default_end = date.today() + timedelta(days=5)
+
+c1, c2 = st.columns(2)
+with c1:
+    start_date = st.date_input("开始日期", value=default_start, key="tms_check_start_date")
+with c2:
+    end_date = st.date_input("结束日期", value=default_end, key="tms_check_end_date")
+
+if start_date > end_date:
+    st.error("开始日期不能晚于结束日期。")
+else:
+    if st.button("开始范围核对", type="primary", key="tms_range_check_btn"):
+        with st.spinner("正在连接 TMS 并拉取排程数据..."):
+            try:
+                tms_hall_data = fetch_tms_server_movies_by_hall()
+            except Exception as e:
+                st.error(f"获取 TMS 数据失败：{e}")
+                st.stop()
+
+            try:
+                tms_hall_status = fetch_tms_hall_status()
+            except Exception as e:
+                tms_hall_status = None
+                st.warning(f"获取 TMS 影厅设备状态失败：{e}")
+
+            all_results = []
+            all_issue_records = []
+            issue_total = 0
+            for current_date in iter_dates(start_date, end_date):
+                date_str = current_date.strftime("%Y-%m-%d")
+                schedule_data, _ = get_api_data_with_token_management(date_str)
+
+                if not schedule_data:
+                    issue_text = "未获取到排片数据，无法核对。"
+                    status = "异常"
+                    issue_total += 1
+                else:
+                    check_result = check_tms_file_availability(schedule_data, tms_hall_data, date_str)
+                    issue_text_value = check_result.get("issue_text")
+                    issue_list_value = check_result.get("issues")
+                    issue_text = issue_text_value if isinstance(issue_text_value, str) else None
+                    if isinstance(issue_list_value, list):
+                        all_issue_records.extend(issue_list_value)
+                    status = "正常" if issue_text is None else "异常"
+                    if issue_text:
+                        issue_total += 1
+
+                all_results.append({
+                    "日期": date_str,
+                    "状态": status,
+                    "问题详情": issue_text,
+                })
+
+        if issue_total == 0:
+            st.success(f"✅ 核对完成：{len(all_results)} 天全部正常，无需处理。")
+        else:
+            st.warning(f"⚠️ 核对完成：共 {len(all_results)} 天，其中 {issue_total} 天存在问题。")
+
+        if tms_hall_status is not None:
+            st.subheader("🖥️ 影厅设备 TMS 在线状态")
+            online_halls = [h for h in tms_hall_status if h.get("STATUS") == 1]
+            offline_halls = [h for h in tms_hall_status if h.get("STATUS") != 1]
+
+            m1, m2, m3 = st.columns(3)
+            m1.metric("影厅总数", len(tms_hall_status))
+            m2.metric("在线", len(online_halls))
+            m3.metric("离线", len(offline_halls))
+
+            if offline_halls:
+                offline_names = "、".join(
+                    str(h.get("NAME") or h.get("OUTER_ID") or "未知厅") for h in offline_halls
+                )
+                st.error(f"以下影厅 TMS 离线：{offline_names}")
+            else:
+                st.success("全部影厅 TMS 在线。")
+
+        missing_summary_lines = build_missing_file_summary(all_issue_records)
+        if missing_summary_lines:
+            st.subheader("按影厅汇总缺少文件")
+            st.caption("仅汇总未命中同厅 ASSERT_ID 前12位，或命中后仍无法找到可确权 ASSERT_ID 的影片。")
+            st.code(
+                "\n".join([f"{idx}. {line}" for idx, line in enumerate(missing_summary_lines, 1)]),
+                language="text",
+            )
+        elif issue_total > 0:
+            st.info("本次异常中未发现可归类为“缺少影片文件”的问题，或异常仅为排片数据缺失/ASSERT_ID 不唯一。")
+
+        for result in all_results:
+            if result["状态"] == "正常":
+                st.success(f"{result['日期']}：无问题")
+            else:
+                st.error(f"{result['日期']}：发现问题")
+                st.code(result["问题详情"], language="text")

pages/📢 突发购票监控.py

@@ -0,0 +1,499 @@
+import streamlit as st
+import requests
+import time
+import json
+import os
+import threading
+import re
+import urllib3
+from datetime import datetime, timedelta, timezone, time as dt_time
+from collections import deque
+from dotenv import load_dotenv
+
+# --- 0. 基础配置 ---
+st.set_page_config(page_title="突发购票监控", page_icon="🛡️", layout="wide")
+
+# 屏蔽 HTTPS 证书警告
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# 尝试导入自动刷新组件
+try:
+    from streamlit_autorefresh import st_autorefresh
+except ImportError:
+    st_autorefresh = None
+
+# --- 1. 配置与常量 ---
+load_dotenv()
+
+# 企业微信机器人配置
+WEWORK_BOT_WEBHOOK = os.getenv("WEWORK_BOT_WEBHOOK")
+
+# 影城配置
+CINEMA_ID = os.getenv("CINEMA_ID")
+
+# 获取 Token 文件路径
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT_DIR = os.path.dirname(CURRENT_DIR)
+TOKEN_FILE = os.path.join(ROOT_DIR, 'token_data.json')
+
+
+# --- 2. 工具函数 ---
+def get_beijing_now():
+    """获取当前的北京时间"""
+    utc_now = datetime.now(timezone.utc)
+    beijing_now = utc_now.astimezone(timezone(timedelta(hours=8)))
+    return beijing_now.replace(tzinfo=None)
+
+
+def get_business_date():
+    """获取当前的营业日日期"""
+    now = get_beijing_now()
+    if now.time() < dt_time(6, 0):
+        return (now - timedelta(days=1)).strftime("%Y-%m-%d")
+    return now.strftime("%Y-%m-%d")
+
+
+def parse_show_datetime(date_str, time_str):
+    """解析排片时间 (处理跨天)"""
+    try:
+        show_t = datetime.strptime(time_str, "%H:%M").time()
+        base_date = datetime.strptime(date_str, "%Y-%m-%d")
+        if show_t < dt_time(6, 0):
+            base_date += timedelta(days=1)
+        return datetime.combine(base_date.date(), show_t)
+    except:
+        return None
+
+
+def simplify_hall_name(raw_name):
+    """
+    影厅名称简化
+    例如：'【和成天下1号厅】...' -> '1号厅'
+          '6号激光厅' -> '6号厅'
+    """
+    if not raw_name:
+        return "未知影厅"
+    match = re.search(r'(\d+)号', raw_name)
+    if match:
+        return f"{match.group(1)}号厅"
+    return raw_name
+
+
+# --- 3. 企业微信机器人推送模块 ---
+class WeWorkBotPusher:
+    def __init__(self, webhook_url):
+        self.webhook_url = webhook_url
+
+    def send_text(self, content):
+        """发送纯文本消息"""
+        if not self.webhook_url:
+            return False
+
+        headers = {"Content-Type": "application/json"}
+        data = {
+            "msgtype": "text",
+            "text": {
+                "content": content
+            }
+        }
+        
+        try:
+            resp = requests.post(self.webhook_url, json=data, headers=headers, timeout=10)
+            result = resp.json()
+            if result.get("errcode") == 0:
+                return True
+            else:
+                print(f"❌ 企业微信机器人发送失败: {result}")
+                return False
+        except Exception as e:
+            print(f"❌ 企业微信机器人发送异常: {e}")
+            return False
+
+
+# --- 4. API 管理模块 ---
+class APIManager:
+    def __init__(self, logger):
+        self.last_login_fail_time = 0
+        self.logger = logger
+
+    def save_token(self, token_data):
+        try:
+            with open(TOKEN_FILE, 'w', encoding='utf-8') as f:
+                json.dump(token_data, f, ensure_ascii=False, indent=4)
+        except:
+            pass
+
+    def load_token(self):
+        if os.path.exists(TOKEN_FILE):
+            try:
+                with open(TOKEN_FILE, 'r', encoding='utf-8') as f:
+                    return json.load(f).get('token')
+            except:
+                pass
+        return None
+
+    def login(self):
+        if time.time() - self.last_login_fail_time < 600:
+            self.logger("⏳ 登录冷却中，跳过重试。")
+            return None
+
+        self.logger("🔄 尝试后台自动登录...")
+        username = os.getenv("CINEMA_USERNAME")
+        password = os.getenv("CINEMA_PASSWORD")
+        res_code = os.getenv("CINEMA_RES_CODE")
+        device_id = os.getenv("CINEMA_DEVICE_ID")
+
+        if not all([username, password, res_code]):
+            self.logger("❌ 环境变量缺失，无法自动登录")
+            return None
+
+        session = requests.Session()
+        session.headers.update({'User-Agent': 'Mozilla/5.0'})
+        login_url = 'https://app.bi.piao51.cn/cinema-app/credential/login.action'
+        login_data = {
+            'username': username, 'password': password, 'type': '1',
+            'resCode': res_code, 'deviceid': device_id, 'dtype': 'ios',
+        }
+
+        try:
+            session.post(login_url, data=login_data, timeout=15)
+            resp = session.get('https://app.bi.piao51.cn/cinema-app/security/logined.action', timeout=10)
+            info = resp.json()
+            if info.get("success") and info.get("data", {}).get("token"):
+                self.save_token(info['data'])
+                self.logger("✅ 登录成功。")
+                return info['data']['token']
+            else:
+                raise Exception("未获取到Token")
+        except Exception as e:
+            self.last_login_fail_time = time.time()
+            self.logger(f"❌ 登录失败: {e}")
+            return None
+
+    def fetch_schedule(self, date_str):
+        token = self.load_token()
+        if not token:
+            token = self.login()
+            if not token: return None
+
+        url = 'https://cawapi.yinghezhong.com/showInfo/getHallShowInfo'
+        params = {'showDate': date_str, 'token': token, '_': int(time.time() * 1000)}
+        headers = {'Origin': 'https://caw.yinghezhong.com', 'User-Agent': 'Mozilla/5.0'}
+
+        try:
+            response = requests.get(url, params=params, headers=headers, timeout=15)
+            data = response.json()
+            if data.get('code') == 1:
+                return data.get('data', [])
+            elif data.get('code') == 500:
+                self.logger("⚠️ Token失效，重试中...")
+                token = self.login()
+                if token:
+                    params['token'] = token
+                    response = requests.get(url, params=params, headers=headers, timeout=15)
+                    return response.json().get('data', [])
+            return None
+        except Exception as e:
+            self.logger(f"API请求异常: {e}")
+            return None
+
+
+# --- 5. 监控服务主逻辑 ---
+class CinemaMonitor:
+    def __init__(self):
+        self.logs = deque(maxlen=50)
+        self.status_text = "初始化中..."
+        self.next_wakeup = None
+        self.monitored_sessions = []
+
+        self.api = APIManager(self.log)
+        self.bot = WeWorkBotPusher(WEWORK_BOT_WEBHOOK)
+        
+        self.current_business_date = None
+        self.daily_schedule_cache = None
+
+        self.zero_ticket_candidates = set()
+        self.alerted_sessions = set()
+        self.last_daily_report_date = None
+
+        # 统计数据 (用于每日报告)
+        self.stats = {
+            "zero_total": 0,  # 纳入监控的0票总场次
+            "alert_count": 0,  # 触发通知次数
+            "api_fails": 0,  # API获取失败次数
+            "notify_fails": 0  # 发送通知失败次数
+        }
+
+        self.thread = threading.Thread(target=self._run_loop, daemon=True)
+        self.thread.start()
+
+    def log(self, msg):
+        timestamp = get_beijing_now().strftime("%H:%M:%S")
+        entry = f"[{timestamp}] {msg}"
+        print(entry)
+        self.logs.appendleft(entry)
+
+    def send_ticket_alert(self, hall_name, movie_name, show_time, ticket_count):
+        """
+        发送突发购票告警 (企业微信机器人)
+        """
+        msg = (
+            f"发现 {hall_name} {show_time} 场次有票！\n\n"
+            f"{hall_name} {show_time}《{movie_name}》\n"
+            f"突增至 {ticket_count} 张\n"
+            f"请尽快处理。"
+        )
+        
+        if not self.bot.send_text(msg):
+            self.stats["notify_fails"] += 1
+
+    def send_daily_report(self, date_str):
+        """
+        发送每日统计报告 (企业微信机器人)
+        """
+        stats_text_full = (
+            f"0票总场次：{self.stats['zero_total']}\n"
+            f"触发通知次数：{self.stats['alert_count']}\n"
+            f"发送通知失败次数：{self.stats['notify_fails']}\n"
+            f"API获取失败次数：{self.stats['api_fails']}"
+        )
+        
+        msg = (
+            f"0票场次开场前10分钟内突发购票检查就绪\n\n"
+            f"{date_str}，今日排片数据已加载，开始智能检查。\n\n"
+            f"昨日情况：\n{stats_text_full}\n"
+            f"服务正常运行中。"
+        )
+        if not self.bot.send_text(msg):
+            self.stats["notify_fails"] += 1
+
+    def _run_loop(self):
+        self.log("🚀 突发购票监控服务已启动")
+        is_first_run = True
+
+        while True:
+            try:
+                now = get_beijing_now()
+                biz_date = get_business_date()
+                today_str = now.strftime("%Y-%m-%d")
+
+                if is_first_run:
+                    if now.time() >= dt_time(9, 0):
+                        self.last_daily_report_date = today_str
+                        self.log(f"🟡 首次运行，跳过当日即时通知: {today_str}")
+                    else:
+                        self.log("🟡 首次运行完成初始化，等待 09:00 后再发送每日报告")
+                    is_first_run = False
+
+                # --- 每日健康检查 (09:00 后发送一次) ---
+                if now.time() >= dt_time(9, 0) and self.last_daily_report_date != today_str:
+                    report_date_str = now.strftime("%Y年%m月%d日")
+                    self.log(f"🔔 发送每日统计报告: {today_str}")
+
+                    # 发送报告
+                    self.send_daily_report(report_date_str)
+
+                    # 重置统计数据 & 更新日期
+                    self.last_daily_report_date = today_str
+                    self.stats = {
+                        "zero_total": 0, "alert_count": 0,
+                        "api_fails": 0, "notify_fails": 0
+                    }
+
+                # 休眠逻辑 (06:00 - 09:30)
+                start_check_time = now.replace(hour=9, minute=30, second=0, microsecond=0)
+                is_early_morning = (dt_time(6, 0) <= now.time() < dt_time(9, 30))
+
+                if is_early_morning:
+                    self.status_text = "非监控时段 (等待 09:30)"
+                    self.next_wakeup = start_check_time
+                    self.zero_ticket_candidates.clear()
+                    self.alerted_sessions.clear()
+                    time.sleep(60)
+                    continue
+
+                # 缓存刷新
+                if self.daily_schedule_cache is None or self.current_business_date != biz_date:
+                    self.log(f"📅 获取 {biz_date} 全天排片...")
+                    schedule = self.api.fetch_schedule(biz_date)
+                    if schedule is None:
+                        self.log("❌ 初始化获取失败，1分钟后重试")
+                        self.stats["api_fails"] += 1
+                        time.sleep(60)
+                        continue
+                    self.daily_schedule_cache = schedule
+                    self.current_business_date = biz_date
+                    self.zero_ticket_candidates.clear()
+                    self.alerted_sessions.clear()
+                    self.log(f"✅ 数据已更新，共 {len(schedule)} 场")
+
+                # 筛选窗口期
+                active_check_needed = False
+                min_sleep_seconds = 3600
+                sessions_in_window = []
+                current_schedule = self.daily_schedule_cache
+
+                for item in current_schedule:
+                    start_time_str = item.get('showStartTime')
+                    if not start_time_str: continue
+                    show_dt = parse_show_datetime(biz_date, start_time_str)
+                    if not show_dt: continue
+
+                    if now >= show_dt: continue  # 已开场
+
+                    monitor_start_dt = show_dt - timedelta(minutes=11)
+
+                    if now >= monitor_start_dt:
+                        sessions_in_window.append({'data': item, 'dt': show_dt})
+                        active_check_needed = True
+                    else:
+                        seconds_until_window = (monitor_start_dt - now).total_seconds()
+                        if seconds_until_window < min_sleep_seconds:
+                            min_sleep_seconds = seconds_until_window
+
+                # 执行监控
+                if active_check_needed:
+                    self.status_text = "🔥 正在监控"
+                    self.next_wakeup = now + timedelta(seconds=60)
+
+                    realtime_schedule = self.api.fetch_schedule(biz_date)
+                    if realtime_schedule is None:
+                        self.log("⚠️ API请求失败，跳过本次判定")
+                        self.stats["api_fails"] += 1
+                        time.sleep(60)
+                        continue
+
+                    realtime_map = {f"{x.get('hallId')}_{x.get('showStartTime')}": x for x in realtime_schedule}
+                    display_monitors = []
+
+                    for session in sessions_in_window:
+                        key = f"{session['data'].get('hallId')}_{session['data'].get('showStartTime')}"
+                        unique_id = f"{biz_date}_{key}"
+
+                        latest = realtime_map.get(key)
+                        if not latest: continue
+
+                        movie = latest.get('movieName')
+                        hall_raw = latest.get('hallName')
+                        # 影厅名简化
+                        hall_short = simplify_hall_name(hall_raw)
+
+                        sold = int(latest.get('soldTicketNum') or 0)
+                        start = latest.get('showStartTime')
+
+                        if sold == 0:
+                            # 统计新加入的0票场次
+                            if unique_id not in self.zero_ticket_candidates:
+                                self.stats["zero_total"] += 1
+
+                            self.zero_ticket_candidates.add(unique_id)
+                            display_monitors.append(f"👁️ {start} {movie} (0票)")
+                        else:
+                            if unique_id in self.zero_ticket_candidates:
+                                if unique_id not in self.alerted_sessions:
+                                    self.log(f"🚨 突发购票！{hall_short}《{movie}》")
+
+                                    # 统计触发次数
+                                    self.stats["alert_count"] += 1
+
+                                    # 发送通知 (Pushover + WeChat)
+                                    self.send_ticket_alert(hall_short, movie, start, sold)
+
+                                    self.alerted_sessions.add(unique_id)
+                                    self.zero_ticket_candidates.remove(unique_id)
+                                display_monitors.append(f"✅ {start} {movie} (新售出)")
+                            else:
+                                display_monitors.append(f"🛡️ {start} {movie} (原有票)")
+
+                    self.monitored_sessions = display_monitors
+                    time.sleep(60)
+
+                else:
+                    if 0 < min_sleep_seconds < 86400:
+                        wakeup_dt = now + timedelta(seconds=min_sleep_seconds)
+                        self.status_text = "💤 休眠中"
+                        self.next_wakeup = wakeup_dt
+                        self.monitored_sessions = []
+                        self.log(f"休眠 {min_sleep_seconds / 60:.1f} 分钟，直到 {wakeup_dt.strftime('%H:%M')}")
+                        time.sleep(min_sleep_seconds)
+                    else:
+                        self.log("今日监控结束，长休眠")
+                        time.sleep(300)
+
+            except Exception as e:
+                self.log(f"主循环异常: {e}")
+                time.sleep(60)
+
+
+# --- 6. Streamlit 前端 ---
+
+@st.cache_resource
+def get_monitor():
+    return CinemaMonitor()
+
+
+def main():
+    monitor = get_monitor()
+
+    # 自动刷新：30秒
+    if st_autorefresh:
+        st_autorefresh(interval=30 * 1000, key="monitor_refresh")
+
+    st.title("📢 突发购票监控")
+
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        st.metric("运行状态", monitor.status_text)
+    with c2:
+        wakeup_str = monitor.next_wakeup.strftime("%H:%M:%S") if monitor.next_wakeup else "--"
+        st.metric("下次唤醒", wakeup_str)
+
+    # --- 统计逻辑 ---
+    remaining_zero_count = 0
+    remaining_total_count = 0
+
+    if monitor.daily_schedule_cache:
+        now = get_beijing_now()
+        biz_date = monitor.current_business_date or get_business_date()
+
+        for item in monitor.daily_schedule_cache:
+            start_str = item.get('showStartTime')
+            if not start_str: continue
+
+            # 解析时间
+            show_dt = parse_show_datetime(biz_date, start_str)
+
+            # 只统计“当前时间之后”的场次
+            if show_dt and show_dt > now:
+                remaining_total_count += 1
+                if int(item.get('soldTicketNum') or 0) == 0:
+                    remaining_zero_count += 1
+
+    with c3:
+        st.metric("剩余 0 票场次 / 剩余总场次", f"{remaining_zero_count} / {remaining_total_count}")
+
+    st.divider()
+
+    col_logs, col_list = st.columns([3, 2])
+
+    with col_logs:
+        st.subheader("📜 运行日志")
+        log_text = "\n".join(list(monitor.logs))
+        st.text_area("Logs", log_text, height=500, disabled=True)
+
+    with col_list:
+        st.subheader("🎯 实时监控列表")
+        if monitor.monitored_sessions:
+            for s in monitor.monitored_sessions:
+                if "✅" in s:
+                    st.success(s)
+                elif "👁️" in s:
+                    st.error(s)
+                else:
+                    st.info(s)
+        else:
+            st.caption("暂无监控目标")
+
+
+if __name__ == "__main__":
+    main()

pages/📨 排片检查与 TMS 内容核对监控.py

@@ -0,0 +1,1153 @@
+import json
+import os
+import re
+import threading
+import time
+from collections import defaultdict, deque
+from datetime import date, datetime, timedelta, timezone, time as dt_time
+
+import requests
+import streamlit as st
+import urllib3
+from dotenv import load_dotenv
+from tms_proxy import build_tms_url, get_tms_proxy_base_url, tms_verify_ssl, with_tms_proxy_headers
+
+try:
+    from streamlit_autorefresh import st_autorefresh
+except ImportError:
+    st_autorefresh = None
+
+
+st.set_page_config(page_title="排片检查与 TMS 内容核对监控", page_icon="📨", layout="wide")
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+load_dotenv()
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+TOKEN_FILE = os.path.join(ROOT_DIR, "token_data.json")
+STATE_DIR = os.path.join(ROOT_DIR, "cinema_cache")
+STATE_FILE = os.path.join(STATE_DIR, "tms_morning_summary_monitor_state.json")
+
+WEWORK_BOT_WEBHOOK = os.getenv("WEWORK_BOT_WEBHOOK")
+WEEKDAY_RANGE_OFFSETS = {
+    0: 3,
+    1: 2,
+    2: 3,
+    3: 3,
+    4: 3,
+    5: 5,
+    6: 4,
+}
+WEEKDAY_NAMES = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"]
+MISSING_ISSUE_TYPES = {"missing_assert12", "missing_assert_id"}
+MAX_RETRY_ATTEMPTS = 3
+RETRY_DELAY_SECONDS = 300
+
+
+class RetryableAPIError(RuntimeError):
+    pass
+
+
+def ensure_state_dir():
+    os.makedirs(STATE_DIR, exist_ok=True)
+
+
+def get_beijing_now():
+    utc_now = datetime.now(timezone.utc)
+    return utc_now.astimezone(timezone(timedelta(hours=8))).replace(tzinfo=None)
+
+
+def format_datetime_text(dt_obj):
+    if not dt_obj:
+        return "--"
+    return dt_obj.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def format_short_day(value):
+    if isinstance(value, datetime):
+        return value.strftime("%m%d")
+    if isinstance(value, date):
+        return value.strftime("%m%d")
+
+    text = str(value or "").strip()
+    if not text:
+        return "--"
+
+    for fmt in ("%Y-%m-%d", "%m%d"):
+        try:
+            return datetime.strptime(text, fmt).strftime("%m%d")
+        except ValueError:
+            continue
+    return text
+
+
+def format_day_with_weekday(day_value):
+    if isinstance(day_value, datetime):
+        day_obj = day_value.date()
+    elif isinstance(day_value, date):
+        day_obj = day_value
+    else:
+        day_obj = datetime.strptime(str(day_value), "%Y-%m-%d").date()
+    return f"{day_obj.strftime('%m%d')}({WEEKDAY_NAMES[day_obj.weekday()]})"
+
+
+def get_check_date_range(base_date=None):
+    today = base_date or get_beijing_now().date()
+    end_date = today + timedelta(days=WEEKDAY_RANGE_OFFSETS[today.weekday()])
+    return today, end_date
+
+
+def default_monitor_state():
+    return {
+        "last_completed_date": "",
+        "completed_at": "",
+        "run_status": "未完成",
+        "result_status": "未执行",
+        "range_start": "",
+        "range_end": "",
+        "hall_count": 0,
+        "expected_sessions_per_day": 0,
+        "min_sessions_threshold": 0,
+        "notification_sent": False,
+        "summary_text": "",
+        "daily_results": [],
+        "tms_summary_lines": [],
+        "tms_hall_total": 0,
+        "tms_hall_online": 0,
+        "tms_hall_offline_names": [],
+        "failure_message": "",
+    }
+
+
+def load_monitor_state():
+    ensure_state_dir()
+    state = default_monitor_state()
+    if os.path.exists(STATE_FILE):
+        try:
+            with open(STATE_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict):
+                state.update(data)
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    legacy_status = state.get("status")
+    if not state.get("result_status") and isinstance(legacy_status, str) and legacy_status:
+        state["result_status"] = legacy_status
+    if not state.get("run_status"):
+        state["run_status"] = "未完成"
+    if not isinstance(state.get("daily_results"), list):
+        state["daily_results"] = []
+    if not isinstance(state.get("tms_summary_lines"), list):
+        state["tms_summary_lines"] = []
+    if not isinstance(state.get("tms_hall_offline_names"), list):
+        state["tms_hall_offline_names"] = []
+    return state
+
+
+def save_monitor_state(state):
+    ensure_state_dir()
+    final_state = default_monitor_state()
+    final_state.update(state or {})
+    with open(STATE_FILE, "w", encoding="utf-8") as f:
+        json.dump(final_state, f, ensure_ascii=False, indent=2)
+    return final_state
+
+
+def load_token():
+    if os.path.exists(TOKEN_FILE):
+        try:
+            with open(TOKEN_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return None
+    return None
+
+
+def save_token(token_data):
+    try:
+        with open(TOKEN_FILE, "w", encoding="utf-8") as f:
+            json.dump(token_data, f, ensure_ascii=False, indent=4)
+        return True
+    except Exception:
+        return False
+
+
+def login_and_get_token():
+    username = os.getenv("CINEMA_USERNAME")
+    password = os.getenv("CINEMA_PASSWORD")
+    res_code = os.getenv("CINEMA_RES_CODE")
+    device_id = os.getenv("CINEMA_DEVICE_ID")
+
+    if not all([username, password, res_code]):
+        raise RuntimeError("未配置 CINEMA_USERNAME / CINEMA_PASSWORD / CINEMA_RES_CODE")
+
+    session = requests.Session()
+    session.headers.update({
+        "Host": "app.bi.piao51.cn",
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+    })
+
+    login_url = "https://app.bi.piao51.cn/cinema-app/credential/login.action"
+    login_headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "Origin": "https://app.bi.piao51.cn",
+    }
+    login_data = {
+        "username": username,
+        "password": password,
+        "type": "1",
+        "resCode": res_code,
+        "deviceid": device_id,
+        "dtype": "ios",
+    }
+
+    try:
+        response_login = session.post(
+            login_url,
+            headers=login_headers,
+            data=login_data,
+            allow_redirects=False,
+            timeout=15,
+        )
+        if not (300 <= response_login.status_code < 400 and "token" in session.cookies):
+            raise RetryableAPIError(f"票务登录失败，状态码：{response_login.status_code}")
+
+        user_info_url = "https://app.bi.piao51.cn/cinema-app/security/logined.action"
+        response_user_info = session.get(user_info_url, timeout=10)
+        response_user_info.raise_for_status()
+        user_info = response_user_info.json()
+
+        if user_info.get("success") and user_info.get("data", {}).get("token"):
+            token_data = user_info["data"]
+            save_token(token_data)
+            return token_data
+
+        raise RetryableAPIError(f"票务登录未获取到 Token：{user_info.get('msg')}")
+    except RetryableAPIError:
+        raise
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"票务登录接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"票务登录处理异常：{exc}") from exc
+
+
+def get_valid_cinema_token():
+    token_data = load_token()
+    token = token_data.get("token") if token_data else None
+    if token:
+        return token
+    token_data = login_and_get_token()
+    return token_data.get("token") if token_data else None
+
+
+def fetch_hall_info(token):
+    url = "https://cawapi.yinghezhong.com/showInfo/getShowHallInfo"
+    params = {"token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"获取影厅信息接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"获取影厅信息处理异常：{exc}") from exc
+
+    if data.get("code") == 1 and data.get("data") is not None:
+        return {item["hallId"]: item["seatNum"] for item in data["data"]}
+    if data.get("code") == 500:
+        raise ValueError("Token 可能已失效")
+    raise RetryableAPIError(f"获取影厅信息失败：{data.get('msg', '未知错误')}")
+
+
+def fetch_schedule_data(token, show_date):
+    url = "https://cawapi.yinghezhong.com/showInfo/getHallShowInfo"
+    params = {"showDate": show_date, "token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=15)
+        response.raise_for_status()
+        data = response.json()
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"获取 {show_date} 排片接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"获取 {show_date} 排片处理异常：{exc}") from exc
+
+    if data.get("code") == 1:
+        return data.get("data", [])
+    if data.get("code") == 500:
+        raise ValueError("Token 可能已失效")
+    raise RetryableAPIError(f"获取 {show_date} 排片失败：{data.get('msg', '未知错误')}")
+
+
+def get_hall_info_with_token_management():
+    token = get_valid_cinema_token()
+    if not token:
+        raise RetryableAPIError("未获取到票务 Token")
+
+    try:
+        return fetch_hall_info(token)
+    except ValueError:
+        token_data = login_and_get_token()
+        token = token_data.get("token") if token_data else None
+        if not token:
+            raise RetryableAPIError("重新登录后仍未获取到票务 Token")
+        return fetch_hall_info(token)
+
+
+def get_schedule_data_with_token_management(show_date):
+    token = get_valid_cinema_token()
+    if not token:
+        raise RetryableAPIError("未获取到票务 Token")
+
+    try:
+        return fetch_schedule_data(token, show_date)
+    except ValueError:
+        token_data = login_and_get_token()
+        token = token_data.get("token") if token_data else None
+        if not token:
+            raise RetryableAPIError("重新登录后仍未获取到票务 Token")
+        return fetch_schedule_data(token, show_date)
+
+
+def _get_tms_env_and_auth():
+    """读取 TMS 环境变量并完成 generateToken 认证，返回 (theater_id, x_session_id, ticket, auth_token, proxy_base_url)。"""
+    app_secret = os.getenv("TMS_APP_SECRET")
+    ticket = os.getenv("TMS_TICKET")
+    theater_id_str = os.getenv("TMS_THEATER_ID")
+    x_session_id = os.getenv("TMS_X_SESSION_ID")
+
+    if not all([app_secret, ticket, theater_id_str, x_session_id]):
+        raise RuntimeError("TMS 环境变量不完整，请检查 TMS_APP_SECRET/TMS_TICKET/TMS_THEATER_ID/TMS_X_SESSION_ID")
+
+    theater_id = int(str(theater_id_str))
+    tms_proxy_base_url = get_tms_proxy_base_url()
+    token_headers = {
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "Content-Type": "application/json",
+        "Cookie": f"JSESSIONID={x_session_id}",
+        "Origin": "https://tms.hengdianfilm.com",
+        "Referer": f"https://tms.hengdianfilm.com/hd/oalogin?ticket={ticket}",
+        "User-Agent": "Mozilla/5.0",
+        "X-Requested-With": "XMLHttpRequest",
+    }
+    token_json_data = {
+        "appId": "hd",
+        "appSecret": app_secret,
+        "timeStamp": int(time.time() * 1000),
+    }
+    token_url = build_tms_url(
+        f"https://tms.hengdianfilm.com/cinema-api/admin/generateToken?token=hd&murl=?token=hd&murl=ticket={ticket}",
+        tms_proxy_base_url,
+    )
+    token_headers = with_tms_proxy_headers(token_headers, tms_proxy_base_url)
+
+    try:
+        token_resp = requests.post(token_url, headers=token_headers, json=token_json_data, timeout=12)
+        token_resp.raise_for_status()
+        token_data = token_resp.json()
+    except requests.exceptions.RequestException as exc:
+        raise RetryableAPIError(f"TMS 认证接口异常：{exc}") from exc
+    except Exception as exc:
+        raise RetryableAPIError(f"TMS 认证处理异常：{exc}") from exc
+
+    if token_data.get("error_code") != "0000":
+        raise RetryableAPIError(f"TMS 认证失败：{token_data.get('error_desc')}")
+    auth_token = token_data.get("param")
+    return theater_id, x_session_id, ticket, auth_token, tms_proxy_base_url
+
+
+def fetch_tms_hall_status():
+    """拉取 TMS 影厅设备列表，返回所有影厅记录（包含 STATUS 字段，1 表示在线）。"""
+    theater_id, x_session_id, ticket, auth_token, tms_proxy_base_url = _get_tms_env_and_auth()
+
+    list_url = build_tms_url(
+        "https://tms.hengdianfilm.com/cinema-api/cinema/hall/list",
+        tms_proxy_base_url,
+    )
+
+    halls = []
+    page_index = 1
+    while True:
+        list_headers = {
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Content-Type": "application/json; charset=UTF-8",
+            "Cookie": f"JSESSIONID={x_session_id}",
+            "Origin": "https://tms.hengdianfilm.com",
+            "Referer": f"https://tms.hengdianfilm.com/hd/index?CinemaListEdit&THEATER_ID={theater_id}",
+            "Token": auth_token,
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "X-SESSIONID": x_session_id,
+        }
+        list_headers = with_tms_proxy_headers(list_headers, tms_proxy_base_url)
+        list_params = {"token": "hd", "murl": "CinemaList"}
+        list_json = {
+            "PAGE_INDEX": page_index,
+            "THEATER_ID": str(theater_id),
+            "PAGE_CAPACITY": 20,
+        }
+
+        try:
+            resp = requests.post(
+                list_url,
+                params=list_params,
+                headers=list_headers,
+                json=list_json,
+                timeout=15,
+                verify=tms_verify_ssl(default=False, proxy_url=tms_proxy_base_url),
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.exceptions.RequestException as exc:
+            raise RetryableAPIError(f"TMS 影厅列表接口异常：{exc}") from exc
+        except Exception as exc:
+            raise RetryableAPIError(f"TMS 影厅列表处理异常：{exc}") from exc
+
+        if data.get("RSPCD") != "000000":
+            raise RetryableAPIError(f"TMS 影厅列表接口失败：{data.get('RSPMSG')}")
+
+        body = data.get("BODY", {}) or {}
+        items = body.get("LIST", []) or []
+        if not items:
+            break
+        halls.extend(items)
+        if len(halls) >= body.get("COUNT", 0):
+            break
+        page_index += 1
+        time.sleep(0.2)
+
+    return halls
+
+
+def fetch_tms_server_movies_by_hall():
+    theater_id, x_session_id, ticket, auth_token, tms_proxy_base_url = _get_tms_env_and_auth()
+
+    all_movies = []
+    page_index = 1
+    while True:
+        list_headers = {
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Content-Type": "application/json; charset=UTF-8",
+            "Cookie": f"JSESSIONID={x_session_id}",
+            "Origin": "https://tms.hengdianfilm.com",
+            "Referer": f"https://tms.hengdianfilm.com/hd/index?ContentMovie&THEATER_ID={theater_id}",
+            "Token": auth_token,
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "X-SESSIONID": x_session_id,
+        }
+        list_params = {"token": "hd", "murl": "ContentMovie"}
+        list_json = {
+            "THEATER_ID": theater_id,
+            "SOURCE": "SERVER",
+            "ASSERT_TYPE": 2,
+            "PAGE_CAPACITY": 20,
+            "PAGE_INDEX": page_index,
+        }
+        list_url = build_tms_url(
+            "https://tms.hengdianfilm.com/cinema-api/cinema/server/dcp/list",
+            tms_proxy_base_url,
+        )
+        list_headers = with_tms_proxy_headers(list_headers, tms_proxy_base_url)
+
+        try:
+            resp = requests.post(
+                list_url,
+                params=list_params,
+                headers=list_headers,
+                json=list_json,
+                timeout=15,
+                verify=tms_verify_ssl(default=False, proxy_url=tms_proxy_base_url),
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.exceptions.RequestException as exc:
+            raise RetryableAPIError(f"TMS 列表接口异常：{exc}") from exc
+        except Exception as exc:
+            raise RetryableAPIError(f"TMS 列表处理异常：{exc}") from exc
+
+        if data.get("RSPCD") != "000000":
+            raise RetryableAPIError(f"TMS 列表接口失败：{data.get('RSPMSG')}")
+
+        body = data.get("BODY", {})
+        items = body.get("LIST", [])
+        if not items:
+            break
+        all_movies.extend(items)
+        if len(all_movies) >= body.get("COUNT", 0):
+            break
+        page_index += 1
+        time.sleep(0.3)
+
+    movie_details = {
+        movie.get("CONTENT_NAME"): {
+            "assert_name": movie.get("ASSERT_NAME"),
+            "assert_id": movie.get("ASSERT_ID"),
+            "source_format": movie.get("SOURCE_FORMAT"),
+            "halls": sorted([hall.get("HALL_NAME") for hall in movie.get("HALL_INFO", [])]),
+        }
+        for movie in all_movies
+        if movie.get("CONTENT_NAME")
+    }
+
+    by_hall = defaultdict(list)
+    for content_name, details in movie_details.items():
+        for hall_name in details.get("halls", []):
+            by_hall[hall_name].append({"content_name": content_name, "details": details})
+
+    return dict(by_hall)
+
+
+def format_movie_display_name(movie_name, movie_language, movie_media_type):
+    """统一的影片展示名：``片名 语言 制式``，缺失部分自动跳过。"""
+    name = str(movie_name or "").strip() or "未知影片"
+    parts = [name]
+    language = str(movie_language or "").strip()
+    if language:
+        parts.append(language)
+    media = str(movie_media_type or "").strip()
+    if media:
+        parts.append(media)
+    return " ".join(parts)
+
+
+def check_tms_file_availability(schedule_list, tms_data, date_str):
+    if schedule_list is None:
+        return {"issue_text": "未获取到排片数据，无法检查。", "issues": []}
+    if not tms_data:
+        return {"issue_text": "未获取到 TMS 数据，无法检查。", "issues": []}
+    if not schedule_list:
+        return {"issue_text": None, "issues": []}
+
+    def clean_hall_display_name(raw_name):
+        hall_name = str(raw_name or "").strip("【】[] ").strip()
+        hall_num_match = re.search(r"(\d+)\s*号", hall_name)
+        if hall_num_match:
+            return f"{hall_num_match.group(1)}号厅"
+        return hall_name
+
+    def get_hall_key_num(name):
+        nums = re.findall(r"\d+", str(name))
+        return nums[0] if nums else str(name)
+
+    def normalize_id_code(value):
+        s = str(value or "").strip().upper()
+        if not s or s == "NAN":
+            return ""
+        if re.fullmatch(r"[A-Z0-9]+\.0", s):
+            s = s[:-2]
+        return re.sub(r"[^A-Z0-9]", "", s)
+
+    def to_12_digit_movie_num(movie_num):
+        s = normalize_id_code(movie_num)
+        return s[:12] if len(s) >= 12 else ""
+
+    def normalize_media_type(media_type):
+        v = str(media_type or "").upper()
+        if "3D" in v:
+            return "3D"
+        if "2D" in v:
+            return "2D"
+        return ""
+
+    def normalize_source_format(source_format, content_name):
+        sf = str(source_format or "").upper()
+        cn = str(content_name or "").upper()
+        if "3D" in sf or re.search(r"(^|_)FTR-3D([_-]|$)", cn):
+            return "3D"
+        if "2D" in sf or re.search(r"(^|_)FTR-2D([_-]|$)", cn):
+            return "2D"
+        return ""
+
+    def normalize_language(movie_language):
+        v = str(movie_language or "").strip().upper()
+        if not v:
+            return ""
+        if "粤" in v or "YUE" in v:
+            return "YUE"
+        if "英语" in v or "原版" in v or "原声" in v or v == "EN":
+            return "EN"
+        if "国语" in v or "普通话" in v or "中文" in v or "CMN" in v or "ZH" in v:
+            return "CMN"
+        return ""
+
+    def language_match(lang_key, content_name, assert_name):
+        if not lang_key:
+            return True
+        cn = str(content_name or "").upper()
+        an = str(assert_name or "")
+
+        if lang_key == "YUE":
+            return bool(re.search(r"(^|_)YUE([-_]|$)", cn)) or ("粤语" in an)
+        if lang_key == "EN":
+            return bool(re.search(r"(^|_)EN([-_]|$)", cn)) or ("英语" in an) or ("原版" in an) or ("原声" in an)
+        if lang_key == "CMN":
+            return bool(re.search(r"(^|_)(CMN|ZH)([-_]|$)", cn)) or ("国语" in an) or ("中文" in an)
+        return True
+
+    tms_by_hall = defaultdict(list)
+    for hall_name, movies in tms_data.items():
+        hall_key = get_hall_key_num(hall_name)
+        for movie in movies:
+            details = movie.get("details", {}) or {}
+            content_name = str(movie.get("content_name") or "")
+            assert_name = str(details.get("assert_name") or "")
+            assert_id_raw = str(details.get("assert_id") or "")
+            assert_id_norm = normalize_id_code(assert_id_raw)
+            source_format = str(details.get("source_format") or "")
+
+            tms_by_hall[hall_key].append({
+                "content_name": content_name,
+                "assert_name": assert_name,
+                "assert_id": assert_id_raw,
+                "assert_id_norm": assert_id_norm,
+                "assert_12": assert_id_norm[:12] if len(assert_id_norm) >= 12 else "",
+                "media": normalize_source_format(source_format, content_name),
+            })
+
+    issue_records = []
+    checked = set()
+
+    def append_issue(issue_type, hall_num, hall_display, movie_name, message, item):
+        issue_records.append({
+            "issue_type": issue_type,
+            "date": date_str,
+            "hall_num": str(hall_num),
+            "hall_display": str(hall_display),
+            "movie_name": str(movie_name),
+            "movie_num": str(item.get("movieNum") or ""),
+            "movie_language": str(item.get("movieLanguage") or ""),
+            "movie_media_type": str(item.get("movieMediaType") or ""),
+            "message": message,
+        })
+
+    for item in schedule_list:
+        hall_raw = item.get("hallName") or item.get("Hall")
+        movie_raw = item.get("movieName") or item.get("Movie")
+        if not hall_raw or not movie_raw:
+            continue
+
+        hall_num = get_hall_key_num(hall_raw)
+        hall_display = clean_hall_display_name(hall_raw)
+        movie_name = str(movie_raw)
+        movie_language_raw = str(item.get("movieLanguage") or "").strip()
+        movie_media_raw = str(item.get("movieMediaType") or "").strip()
+        movie_display = format_movie_display_name(movie_name, movie_language_raw, movie_media_raw)
+        movie_num_12 = to_12_digit_movie_num(item.get("movieNum"))
+        language_key = normalize_language(item.get("movieLanguage"))
+        media_key = normalize_media_type(item.get("movieMediaType"))
+
+        combo_key = (hall_num, movie_num_12, language_key, media_key, movie_name)
+        if combo_key in checked:
+            continue
+        checked.add(combo_key)
+
+        hall_candidates = tms_by_hall.get(hall_num, [])
+        if not hall_candidates:
+            continue
+
+        coarse_candidates = [candidate for candidate in hall_candidates if candidate.get("assert_12") == movie_num_12] if movie_num_12 else hall_candidates[:]
+        if not coarse_candidates:
+            append_issue(
+                "missing_assert12",
+                hall_num,
+                hall_display,
+                movie_name,
+                f"【{hall_display}】《{movie_display}》movieNum={item.get('movieNum')} 未命中同厅 ASSERT_ID 前12位。",
+                item,
+            )
+            continue
+
+        lang_candidates = coarse_candidates
+        if language_key:
+            lang_filtered = [
+                candidate for candidate in coarse_candidates
+                if language_match(language_key, candidate.get("content_name"), candidate.get("assert_name"))
+            ]
+            if lang_filtered:
+                lang_candidates = lang_filtered
+
+        media_candidates = lang_candidates
+        if media_key:
+            media_filtered = [candidate for candidate in lang_candidates if candidate.get("media") == media_key]
+            if media_filtered:
+                media_candidates = media_filtered
+
+        id_display_map = {}
+        for candidate in media_candidates:
+            assert_id_norm = candidate.get("assert_id_norm")
+            if not assert_id_norm:
+                continue
+            if assert_id_norm not in id_display_map:
+                id_display_map[assert_id_norm] = str(candidate.get("assert_id") or assert_id_norm).strip().upper()
+
+        unique_assert_id_norms = sorted(id_display_map.keys())
+        if not unique_assert_id_norms:
+            append_issue(
+                "missing_assert_id",
+                hall_num,
+                hall_display,
+                movie_name,
+                f"【{hall_display}】《{movie_display}》已命中前12位，但未找到可确权的 ASSERT_ID（语言={item.get('movieLanguage')}，制式={item.get('movieMediaType')}）。",
+                item,
+            )
+            continue
+
+        if len(unique_assert_id_norms) > 1:
+            sample_names = " | ".join([candidate.get("content_name", "") for candidate in media_candidates[:3]])
+            display_ids = [id_display_map[key] for key in unique_assert_id_norms[:5]]
+            append_issue(
+                "ambiguous_assert_id",
+                hall_num,
+                hall_display,
+                movie_name,
+                f"【{hall_display}】《{movie_display}》命中多个 ASSERT_ID（{', '.join(display_ids)}），未唯一确权。样本：{sample_names}",
+                item,
+            )
+
+    if not issue_records:
+        return {"issue_text": None, "issues": []}
+
+    lines = [f"{idx}. ⚠️ TMS核对警告：{issue['message']}" for idx, issue in enumerate(issue_records, 1)]
+    return {"issue_text": "\n".join(lines), "issues": issue_records}
+
+
+def iter_dates(start_dt: date, end_dt: date):
+    current = start_dt
+    while current <= end_dt:
+        yield current
+        current += timedelta(days=1)
+
+
+def get_hall_sort_key(name):
+    nums = re.findall(r"\d+", str(name))
+    if nums:
+        return 0, int(nums[0]), str(name)
+    return 1, 0, str(name)
+
+
+def build_tms_issue_summary(issue_records):
+    # 以 (片名, 语言, 制式) 作为聚合键，避免不同语言/制式版本被合并为同一条
+    missing_map = defaultdict(lambda: defaultdict(set))
+    ambiguous_map = defaultdict(lambda: defaultdict(set))
+    missing_display_map = defaultdict(dict)
+    ambiguous_display_map = defaultdict(dict)
+
+    for issue in issue_records:
+        hall_display = str(issue.get("hall_display") or "未知影厅")
+        movie_name = str(issue.get("movie_name") or "未知影片")
+        movie_language = str(issue.get("movie_language") or "").strip()
+        movie_media_type = str(issue.get("movie_media_type") or "").strip()
+        movie_key = (movie_name, movie_language, movie_media_type)
+        display_name = format_movie_display_name(movie_name, movie_language, movie_media_type)
+        issue_date = format_short_day(issue.get("date"))
+        issue_type = issue.get("issue_type")
+
+        if issue_type in MISSING_ISSUE_TYPES:
+            missing_map[hall_display][movie_key].add(issue_date)
+            missing_display_map[hall_display][movie_key] = display_name
+        elif issue_type == "ambiguous_assert_id":
+            ambiguous_map[hall_display][movie_key].add(issue_date)
+            ambiguous_display_map[hall_display][movie_key] = display_name
+
+    summary_lines = []
+
+    for hall_display in sorted(missing_map.keys(), key=get_hall_sort_key):
+        movie_parts = []
+        movie_keys_sorted = sorted(
+            missing_map[hall_display].keys(),
+            key=lambda k: missing_display_map[hall_display][k],
+        )
+        for movie_key in movie_keys_sorted:
+            display_name = missing_display_map[hall_display][movie_key]
+            dates = [day for day in sorted(missing_map[hall_display][movie_key]) if day and day != "--"]
+            if dates:
+                movie_parts.append(f"《{display_name}》（{'、'.join(dates)}）")
+            else:
+                movie_parts.append(f"《{display_name}》")
+        summary_lines.append(f"{hall_display} 缺少{' '.join(movie_parts)}的文件")
+
+    for hall_display in sorted(ambiguous_map.keys(), key=get_hall_sort_key):
+        movie_parts = []
+        movie_keys_sorted = sorted(
+            ambiguous_map[hall_display].keys(),
+            key=lambda k: ambiguous_display_map[hall_display][k],
+        )
+        for movie_key in movie_keys_sorted:
+            display_name = ambiguous_display_map[hall_display][movie_key]
+            dates = [day for day in sorted(ambiguous_map[hall_display][movie_key]) if day and day != "--"]
+            if dates:
+                movie_parts.append(f"《{display_name}》（{'/'.join(dates)}）")
+            else:
+                movie_parts.append(f"《{display_name}》")
+        summary_lines.append(f"{hall_display} {' '.join(movie_parts)}存在 ASSERT_ID 不唯一")
+
+    return summary_lines
+
+
+def build_notification_message(run_result):
+    lines = ["排片场次数量检查与TMS内容核对监控", ""]
+    lines.append(
+        f"检查范围：{format_day_with_weekday(run_result.get('range_start'))} 至 {format_day_with_weekday(run_result.get('range_end'))}"
+    )
+    lines.append("每日结果：")
+
+    daily_results = run_result.get("daily_results") or []
+    failure_message = str(run_result.get("failure_message") or "").strip()
+
+    if daily_results:
+        for item in daily_results:
+            schedule_count = item.get("schedule_count")
+            schedule_display = "--" if schedule_count is None else str(schedule_count)
+            lines.append(f"- {format_short_day(item.get('date'))}：{schedule_display} 场，{item.get('status', '未知')}")
+    elif failure_message:
+        lines.append(f"- 未完成：{failure_message}")
+    else:
+        lines.append("- 暂无结果")
+
+    lines.append("与TMS内容核对：")
+    tms_summary_lines = run_result.get("tms_summary_lines") or []
+    if tms_summary_lines:
+        for idx, line in enumerate(tms_summary_lines, 1):
+            lines.append(f"{idx}. {line}")
+    else:
+        lines.append("- 正常" if not failure_message else "- 未完成")
+
+    if failure_message:
+        lines.append(f"接口异常：{failure_message}")
+
+    tms_hall_total = run_result.get("tms_hall_total") or 0
+    tms_hall_online = run_result.get("tms_hall_online") or 0
+    if tms_hall_total:
+        lines.append(f"TMS服务器在线状态：{tms_hall_online}/{tms_hall_total}")
+
+    return "\n".join(lines)
+
+
+def build_failed_run_result(run_date, failure_message):
+    start_date, end_date = get_check_date_range(run_date)
+    run_result = {
+        "completed_at": format_datetime_text(get_beijing_now()),
+        "range_start": start_date.strftime("%Y-%m-%d"),
+        "range_end": end_date.strftime("%Y-%m-%d"),
+        "hall_count": 0,
+        "expected_sessions_per_day": 0,
+        "min_sessions_threshold": 0,
+        "daily_results": [],
+        "tms_summary_lines": [],
+        "tms_hall_total": 0,
+        "tms_hall_online": 0,
+        "tms_hall_offline_names": [],
+        "failure_message": failure_message,
+        "result_status": "未完成",
+    }
+    run_result["summary_text"] = build_notification_message(run_result)
+    return run_result
+
+
+def send_wework_text(content):
+    if not WEWORK_BOT_WEBHOOK:
+        return False
+
+    headers = {"Content-Type": "application/json"}
+    data = {
+        "msgtype": "text",
+        "text": {
+            "content": content,
+        },
+    }
+    try:
+        resp = requests.post(WEWORK_BOT_WEBHOOK, json=data, headers=headers, timeout=10)
+        result = resp.json()
+        return result.get("errcode") == 0
+    except Exception:
+        return False
+
+
+def run_daily_check(run_date, logger):
+    start_date, end_date = get_check_date_range(run_date)
+    completed_at = format_datetime_text(get_beijing_now())
+
+    logger(f"📡 开始晨检，范围：{format_day_with_weekday(start_date)} 至 {format_day_with_weekday(end_date)}")
+
+    hall_info = get_hall_info_with_token_management()
+    hall_count = len(hall_info or {})
+    expected_sessions_per_day = hall_count * 6
+    min_sessions_threshold = expected_sessions_per_day / 2 if hall_count > 0 else 0
+    logger(f"✅ 影厅数量：{hall_count}，总场次阈值：少于 {int(min_sessions_threshold) if min_sessions_threshold else 0} 场")
+
+    tms_hall_data = fetch_tms_server_movies_by_hall()
+    logger("✅ TMS 服务器影片数据获取成功")
+
+    tms_hall_total = 0
+    tms_hall_online = 0
+    tms_hall_offline_names = []
+    try:
+        tms_hall_status = fetch_tms_hall_status()
+        tms_hall_total = len(tms_hall_status)
+        for hall in tms_hall_status:
+            if hall.get("STATUS") == 1:
+                tms_hall_online += 1
+            else:
+                tms_hall_offline_names.append(str(hall.get("NAME") or hall.get("OUTER_ID") or "未知厅"))
+        offline_text = "全部在线" if not tms_hall_offline_names else f"离线：{'、'.join(tms_hall_offline_names)}"
+        logger(f"✅ TMS 影厅设备状态：在线 {tms_hall_online}/{tms_hall_total}（{offline_text}）")
+    except Exception as exc:
+        logger(f"⚠️ 获取 TMS 影厅设备状态失败：{exc}")
+
+    daily_results = []
+    all_issue_records = []
+
+    date_list = list(iter_dates(start_date, end_date))
+    for idx, current_date in enumerate(date_list):
+        date_str = current_date.strftime("%Y-%m-%d")
+        logger(f"🔍 检查 {date_str} 排片")
+        schedule_data = get_schedule_data_with_token_management(date_str)
+        schedule_count = len(schedule_data)
+        day_status = "正常"
+
+        if hall_count > 0 and schedule_count < min_sessions_threshold:
+            day_status = "异常"
+
+        check_result = check_tms_file_availability(schedule_data, tms_hall_data, date_str)
+        issue_list = check_result.get("issues") or []
+        if issue_list:
+            all_issue_records.extend(issue_list)
+
+        daily_results.append({
+            "date": date_str,
+            "schedule_count": schedule_count,
+            "status": day_status,
+        })
+
+        if idx < len(date_list) - 1:
+            logger("⏱️ 30 秒后继续检查下一天排片，降低接口访问频率")
+            time.sleep(30)
+
+    tms_summary_lines = build_tms_issue_summary(all_issue_records)
+    result_status = "异常" if any(item.get("status") == "异常" for item in daily_results) or tms_summary_lines else "正常"
+
+    run_result = {
+        "completed_at": completed_at,
+        "range_start": start_date.strftime("%Y-%m-%d"),
+        "range_end": end_date.strftime("%Y-%m-%d"),
+        "hall_count": hall_count,
+        "expected_sessions_per_day": expected_sessions_per_day,
+        "min_sessions_threshold": int(min_sessions_threshold) if min_sessions_threshold else 0,
+        "daily_results": daily_results,
+        "tms_summary_lines": tms_summary_lines,
+        "tms_hall_total": tms_hall_total,
+        "tms_hall_online": tms_hall_online,
+        "tms_hall_offline_names": tms_hall_offline_names,
+        "failure_message": "",
+        "result_status": result_status,
+    }
+    run_result["summary_text"] = build_notification_message(run_result)
+    return run_result
+
+
+class DailyTMSSummaryMonitor:
+    def __init__(self):
+        self.logs = deque(maxlen=100)
+        self.status_text = "未完成"
+        self.next_run_str = "--"
+        self.last_state = load_monitor_state()
+        self.thread = threading.Thread(target=self._run_loop, daemon=True)
+        self.thread.start()
+
+    def log(self, message):
+        timestamp = get_beijing_now().strftime("%H:%M:%S")
+        entry = f"[{timestamp}] {message}"
+        self.logs.appendleft(entry)
+        print(entry)
+
+    def _save_run_result(self, run_result, notification_sent):
+        state = {
+            "last_completed_date": get_beijing_now().strftime("%Y-%m-%d"),
+            "completed_at": run_result.get("completed_at", ""),
+            "run_status": "已完成",
+            "result_status": run_result.get("result_status", "未执行"),
+            "range_start": run_result.get("range_start", ""),
+            "range_end": run_result.get("range_end", ""),
+            "hall_count": run_result.get("hall_count", 0),
+            "expected_sessions_per_day": run_result.get("expected_sessions_per_day", 0),
+            "min_sessions_threshold": run_result.get("min_sessions_threshold", 0),
+            "notification_sent": notification_sent,
+            "summary_text": run_result.get("summary_text", ""),
+            "daily_results": run_result.get("daily_results", []),
+            "tms_summary_lines": run_result.get("tms_summary_lines", []),
+            "tms_hall_total": run_result.get("tms_hall_total", 0),
+            "tms_hall_online": run_result.get("tms_hall_online", 0),
+            "tms_hall_offline_names": run_result.get("tms_hall_offline_names", []),
+            "failure_message": run_result.get("failure_message", ""),
+        }
+        self.last_state = save_monitor_state(state)
+
+    def _execute_today_check(self):
+        run_date = get_beijing_now().date()
+        self.status_text = "进行中"
+        self.next_run_str = "--"
+
+        for attempt in range(1, MAX_RETRY_ATTEMPTS + 1):
+            try:
+                self.log(f"🚀 开始执行晨检，第 {attempt}/{MAX_RETRY_ATTEMPTS} 次尝试")
+                run_result = run_daily_check(run_date, self.log)
+                notification_sent = send_wework_text(run_result.get("summary_text", ""))
+
+                if notification_sent:
+                    self.log("✅ 汇总通知发送成功")
+                elif WEWORK_BOT_WEBHOOK:
+                    self.log("⚠️ 汇总通知发送失败")
+                else:
+                    self.log("⚠️ 未配置企业微信机器人，未发送通知")
+
+                self._save_run_result(run_result, notification_sent)
+                self.status_text = "已完成"
+                return
+            except RetryableAPIError as exc:
+                self.log(f"⚠️ 第 {attempt}/{MAX_RETRY_ATTEMPTS} 次获取数据失败：{exc}")
+                if attempt < MAX_RETRY_ATTEMPTS:
+                    retry_at = get_beijing_now() + timedelta(seconds=RETRY_DELAY_SECONDS)
+                    self.next_run_str = format_datetime_text(retry_at)
+                    self.log(f"⏳ 5 分钟后重试，预计 {self.next_run_str}")
+                    time.sleep(RETRY_DELAY_SECONDS)
+                    self.status_text = "进行中"
+                    continue
+
+                run_result = build_failed_run_result(run_date, str(exc))
+                notification_sent = send_wework_text(run_result.get("summary_text", ""))
+                if notification_sent:
+                    self.log("✅ 连续失败后已发送异常通知")
+                elif WEWORK_BOT_WEBHOOK:
+                    self.log("⚠️ 连续失败后异常通知发送失败")
+                else:
+                    self.log("⚠️ 未配置企业微信机器人，未发送异常通知")
+                self._save_run_result(run_result, notification_sent)
+                self.status_text = "已完成"
+                return
+            except Exception as exc:
+                self.log(f"❌ 执行失败：{exc}")
+                run_result = build_failed_run_result(run_date, str(exc))
+                notification_sent = send_wework_text(run_result.get("summary_text", ""))
+                if notification_sent:
+                    self.log("✅ 执行失败后已发送异常通知")
+                elif WEWORK_BOT_WEBHOOK:
+                    self.log("⚠️ 执行失败后异常通知发送失败")
+                else:
+                    self.log("⚠️ 未配置企业微信机器人，未发送异常通知")
+                self._save_run_result(run_result, notification_sent)
+                self.status_text = "已完成"
+                return
+
+    def _run_loop(self):
+        self.log("🕤 排片检查与 TMS 内容核对监控已启动")
+        while True:
+            try:
+                now = get_beijing_now()
+                today_str = now.strftime("%Y-%m-%d")
+                state = load_monitor_state()
+                self.last_state = state
+                today_run_time = datetime.combine(now.date(), dt_time(9, 55))
+
+                if state.get("last_completed_date") != today_str and now >= today_run_time:
+                    self._execute_today_check()
+                    time.sleep(5)
+                    continue
+
+                if state.get("last_completed_date") == today_str:
+                    self.status_text = "已完成"
+                    next_run_dt = datetime.combine(now.date() + timedelta(days=1), dt_time(9, 55))
+                else:
+                    self.status_text = "未完成"
+                    next_run_dt = today_run_time if now < today_run_time else now
+
+                self.next_run_str = format_datetime_text(next_run_dt if next_run_dt > now else datetime.combine(now.date() + timedelta(days=1), dt_time(9, 55)))
+                time.sleep(30 if state.get("last_completed_date") != today_str and now < today_run_time else 60)
+            except Exception as exc:
+                self.log(f"❌ 主循环异常：{exc}")
+                time.sleep(60)
+
+
+@st.cache_resource
+def get_monitor():
+    return DailyTMSSummaryMonitor()
+
+
+def main():
+    monitor = get_monitor()
+    state = monitor.last_state or load_monitor_state()
+
+    if st_autorefresh:
+        st_autorefresh(interval=30 * 1000, key="tms_morning_summary_refresh")
+
+    start_date, end_date = get_check_date_range(get_beijing_now().date())
+
+    st.title("📨 排片检查与 TMS 内容核对监控")
+    st.caption("每天北京时间 09:55 自动执行一次。若接口异常，5 分钟后重试，最多 3 次；成功后当天只发送一次汇总通知。")
+
+    c1, c2 = st.columns(2)
+    with c1:
+        st.metric("运行状态", monitor.status_text)
+    with c2:
+        st.metric("今日计划范围", f"{format_short_day(start_date)} ~ {format_short_day(end_date)}")
+
+    st.divider()
+
+    info_col, log_col = st.columns([2, 3])
+
+    with info_col:
+        daily_results_value = state.get("daily_results")
+        daily_results = daily_results_value if isinstance(daily_results_value, list) else []
+        st.subheader("每日结果")
+        if daily_results:
+            for item in daily_results:
+                if not isinstance(item, dict):
+                    continue
+                text = f"{format_short_day(item.get('date'))}：{item.get('schedule_count', '--')} 场，{item.get('status', '未知')}"
+                if item.get("status") == "异常":
+                    st.error(text)
+                else:
+                    st.success(text)
+        elif state.get("failure_message"):
+            st.error(f"未完成：{state.get('failure_message')}")
+        else:
+            st.caption("暂无结果")
+
+        st.subheader("与TMS内容核对")
+        tms_summary_lines_value = state.get("tms_summary_lines")
+        tms_summary_lines = tms_summary_lines_value if isinstance(tms_summary_lines_value, list) else []
+        if tms_summary_lines:
+            st.code("\n".join([f"{idx}. {line}" for idx, line in enumerate(tms_summary_lines, 1)]), language="text")
+        elif state.get("failure_message"):
+            st.error("未完成")
+        else:
+            st.success("正常")
+
+        st.subheader("TMS 影厅设备在线状态")
+        tms_hall_total = state.get("tms_hall_total") or 0
+        tms_hall_online = state.get("tms_hall_online") or 0
+        offline_names_value = state.get("tms_hall_offline_names")
+        offline_names = offline_names_value if isinstance(offline_names_value, list) else []
+        if tms_hall_total:
+            mc1, mc2, mc3 = st.columns(3)
+            mc1.metric("影厅总数", tms_hall_total)
+            mc2.metric("在线", tms_hall_online)
+            mc3.metric("离线", tms_hall_total - tms_hall_online)
+            if offline_names:
+                st.error(f"离线影厅：{'、'.join(offline_names)}")
+            else:
+                st.success("全部影厅 TMS 在线")
+        else:
+            st.caption("暂无 TMS 影厅设备状态数据")
+
+    with log_col:
+        st.subheader("运行日志")
+        st.text_area("Logs", "\n".join(list(monitor.logs)), height=700, disabled=True)
+
+
+if __name__ == "__main__":
+    main()

pages/🔍 TMS 服务器影片内容查询.py

@@ -0,0 +1,559 @@
+import streamlit as st
+import pandas as pd
+import requests
+import time
+import os
+import re
+import urllib3
+from collections import defaultdict
+from datetime import date, timedelta
+from pathlib import Path
+from dotenv import load_dotenv
+from cinema_api_client import get_schedule_and_hall_info
+from tms_proxy import (
+    TMS_ORIGIN,
+    TMS_PROXY_URL_ENV,
+    build_tms_url,
+    get_tms_proxy_base_url,
+    tms_verify_ssl,
+    with_tms_proxy_headers,
+)
+
+# --- 基础配置 ---
+st.set_page_config(page_title="TMS 影片查询", page_icon="🎬", layout="wide")
+
+# 屏蔽 HTTPS 证书警告
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# 加载环境变量
+load_dotenv()
+
+# --- TMS 内容统计缓存路径 ---
+_TMS_CONTENT_STATS_FILE = Path(__file__).resolve().parent.parent / "cinema_cache" / "tms_server_content_stats.csv"
+
+# --- 工具函数 ---
+
+
+def format_tms_http_error(prefix, response):
+    if response is None:
+        return prefix
+
+    proxy_error = response.headers.get("X-TMS-Proxy-Error") or "-"
+    proxy_region = (
+        response.headers.get("X-TMS-Proxy-Region")
+        or response.headers.get("X-SB-Edge-Region")
+        or "-"
+    )
+    upstream_status = response.headers.get("X-TMS-Upstream-Status") or "-"
+    body_preview = re.sub(r"\s+", " ", response.text or "").strip()[:240] or "-"
+    return (
+        f"{prefix}: HTTP {response.status_code}; "
+        f"代理错误={proxy_error}; 代理区域={proxy_region}; "
+        f"TMS上游状态={upstream_status}; 响应={body_preview}"
+    )
+
+
+def get_circled_number(hall_name):
+    """
+    将影厅数字转换为带圈数字，例如 1 -> ①
+    """
+    mapping = {'1': '①', '2': '②', '3': '③', '4': '④', '5': '⑤', '6': '⑥', '7': '⑦', '8': '⑧', '9': '⑨'}
+    # 提取字符串中的数字
+    num_str = ''.join(filter(str.isdigit, str(hall_name)))
+    return mapping.get(num_str, num_str)
+
+
+def format_play_time(time_str):
+    """
+    格式化时长字符串，例如 "01:30" -> 90
+    """
+    if not time_str or not isinstance(time_str, str): return None
+    try:
+        parts = time_str.split(':')
+        hours = int(parts[0])
+        minutes = int(parts[1])
+        return hours * 60 + minutes
+    except (ValueError, IndexError):
+        return None
+
+
+def format_content_name_with_explanation(content_name):
+    raw = str(content_name or '').strip()
+    if not raw:
+        return ''
+
+    lang_map = {
+        'CMN': '国语/普通话', 'YUE': '粤语', 'EN': '英语', 'JP': '日语/或简化命名中的加密标记',
+        'KO': '韩语', 'FR': '法语', 'ES': '西班牙语', 'TH': '泰语', 'HI': '印地语', 'RU': '俄语',
+        'PTH': '普通话', 'GDH': '广东话', 'YS': '原声', 'YZ': '译制', 'SCH': '四川话',
+        'NAN': '闽南语', 'WU': '吴语/上海话', 'XX': '无字幕', 'QMS': '简中字幕',
+        'QMT': '繁中字幕', 'CCAP': '听障字幕'
+    }
+    audio_map = {'20': '2.0', '51': '5.1', '71': '7.1', 'ATMOS': 'Dolby Atmos', 'DTSX': 'DTS:X'}
+    type_map = {'FTR': '正片', 'TLR': '预告片', 'TSR': '先导预告'}
+    pack_map = {'OV': '原始版本包', 'VF': '版本增量包'}
+
+    notes = []
+    parts = raw.split('_')
+    first_tokens = parts[0].split('-') if parts else []
+    if first_tokens:
+        notes.append(f"[片名/标识:{first_tokens[0]}]")
+        for token in first_tokens[1:]:
+            up = token.upper()
+            if up in type_map:
+                notes.append(f"[内容类型:{type_map[up]}({token})]")
+            elif up in {'2D', '3D'}:
+                notes.append(f"[制式:{up}]")
+            elif up in {'4FL', '24FPS', '48FPS', '60FPS', '120FPS'}:
+                notes.append(f"[技术参数:{token}]")
+            elif re.fullmatch(r'\d+', up):
+                notes.append(f"[版本号:{token}]")
+            else:
+                notes.append(f"[{token}]")
+
+    for token in parts[1:]:
+        up = token.upper()
+        if '-' in up:
+            a, b = up.split('-', 1)
+            if a in lang_map and b in lang_map:
+                notes.append(f"[音频:{lang_map[a]}({a})]")
+                notes.append(f"[字幕:{lang_map[b]}({b})]")
+                continue
+        if up in {'F', 'S', 'C', 'F-178', 'C-19', '235', '185'}:
+            notes.append(f"[画幅:{token}]")
+        elif re.fullmatch(r'\d{2,3}M', up):
+            notes.append(f"[时长:{token}]")
+        elif up in audio_map:
+            notes.append(f"[音效:{audio_map[up]}({token})]")
+        elif up in {'2K', '4K'}:
+            notes.append(f"[分辨率:{up}]")
+        elif up in {'SMPTE', 'IOP'}:
+            notes.append(f"[封装标准:{up}]")
+        elif re.fullmatch(r'\d{8}', up):
+            notes.append(f"[打包日期:{token}]")
+        elif re.fullmatch(r'\d{4}', up):
+            notes.append(f"[月日批次:{token}]")
+        elif up in pack_map:
+            notes.append(f"[包类型:{pack_map[up]}({up})]")
+        elif up in lang_map:
+            notes.append(f"[语言/标记:{lang_map[up]}({up})]")
+        elif up.startswith('CN'):
+            notes.append(f"[地区/分级:{token}]")
+        else:
+            notes.append(f"[{token}]")
+
+    return f"{raw} / {' '.join(notes)}"
+
+
+def normalize_id_code(value):
+    text = str(value or '').strip().upper()
+    if not text or text == 'NAN':
+        return ''
+    if re.fullmatch(r'[A-Z0-9]+\.0', text):
+        text = text[:-2]
+    return re.sub(r'[^A-Z0-9]', '', text)
+
+
+def to_12_digit_movie_num(value):
+    normalized = normalize_id_code(value)
+    return normalized[:12] if len(normalized) >= 12 else ''
+
+
+def get_hall_key_num(name):
+    nums = re.findall(r'\d+', str(name or ''))
+    return nums[0] if nums else str(name or '').strip()
+
+
+def load_tms_content_stats_map():
+    """加载 TMS 内容统计缓存，返回 {内容文件名: {对应影片, 该影院总票房, 全国总票房, 该影片在该影院总场次, 当前影厅该影片场次}} 字典"""
+    if not _TMS_CONTENT_STATS_FILE.exists():
+        return {}
+    try:
+        df = pd.read_csv(_TMS_CONTENT_STATS_FILE)
+    except Exception:
+        return {}
+    if df.empty or '内容文件名' not in df.columns:
+        return {}
+
+    stats_map = {}
+    for _, row in df.iterrows():
+        content_name = str(row.get('内容文件名') or '').strip()
+        if not content_name:
+            continue
+        stats_map[content_name] = {
+            '对应影片': str(row.get('对应影片') or '').strip(),
+            '该影院总票房': row.get('该影院总票房', ''),
+            '全国总票房': str(row.get('全国总票房') or '').strip(),
+            '该影片在该影院总场次': row.get('该影片在该影院总场次', ''),
+            '当前影厅该影片场次': str(row.get('当前影厅该影片场次') or '').strip(),
+        }
+    return stats_map
+
+
+def build_tms_content_movie_map(movie_list_sorted):
+    content_assert_map = defaultdict(lambda: {'assert_ids': set(), 'hall_keys': set()})
+    for item in movie_list_sorted or []:
+        content_name = str(item.get('content_name') or '')
+        assert_id_12 = to_12_digit_movie_num(item.get('assert_id'))
+        if content_name and assert_id_12:
+            content_assert_map[content_name]['assert_ids'].add(assert_id_12)
+            content_assert_map[content_name]['hall_keys'].update(
+                {get_hall_key_num(hall_name) for hall_name in item.get('halls', []) if get_hall_key_num(hall_name)}
+            )
+
+    if not content_assert_map:
+        return {}
+
+    movie_map = defaultdict(set)
+    start_date = date.today() + timedelta(days=1)
+    for day_offset in range(5):
+        show_date = (start_date + timedelta(days=day_offset)).strftime('%Y-%m-%d')
+        try:
+            schedule_list, _hall_map, _token = get_schedule_and_hall_info(show_date)
+        except Exception:
+            continue
+
+        for schedule in schedule_list or []:
+            movie_num_12 = to_12_digit_movie_num(schedule.get('movieNum'))
+            if not movie_num_12:
+                continue
+            movie_name = clean_movie_title(str(schedule.get('movieName') or '').strip())
+            if not movie_name:
+                continue
+            hall_key = get_hall_key_num(schedule.get('hallName') or schedule.get('Hall'))
+            for content_name, content_meta in content_assert_map.items():
+                hall_keys = content_meta.get('hall_keys') or set()
+                if movie_num_12 in content_meta.get('assert_ids', set()) and (not hall_keys or hall_key in hall_keys):
+                    movie_map[content_name].add(movie_name)
+
+    return {
+        content_name: " / ".join(sorted(movie_names))
+        for content_name, movie_names in movie_map.items()
+    }
+
+
+def clean_movie_title(raw_title, canonical_names=None):
+    """
+    电影名称标准化清洗函数
+    """
+    if not isinstance(raw_title, str):
+        return raw_title
+
+    base_name = None
+
+    # 1. 尝试匹配标准名称
+    if canonical_names:
+        # 按长度倒序排序，确保最长匹配优先
+        sorted_names = sorted(canonical_names, key=len, reverse=True)
+        for name in sorted_names:
+            if name in raw_title:
+                base_name = name
+                break
+
+    # 2. 回退逻辑：如果没传列表或没匹配到，使用空格分割
+    if not base_name:
+        base_name = raw_title.split(' ', 1)[0]
+
+    # 3. 后缀追加逻辑
+    raw_upper = raw_title.upper()
+    suffix = ""
+
+    if "HDR LED" in raw_upper:
+        suffix = "（HDR LED）"
+    elif "CINITY" in raw_upper:
+        suffix = "（CINITY）"
+    elif "杜比" in raw_upper or "DOLBY" in raw_upper:
+        suffix = "（杜比视界）"
+    elif "IMAX" in raw_upper:
+        if "3D" in raw_upper:
+            suffix = "（数字IMAX3D）"
+        else:
+            suffix = "（数字IMAX）"
+    elif "巨幕" in raw_upper:
+        if "立体" in raw_upper:
+            suffix = "（中国巨幕立体）"
+        else:
+            suffix = "（中国巨幕）"
+    elif "3D" in raw_upper:
+        suffix = "（数字3D）"
+
+    # 只有当 base_name 自身不包含该后缀时才添加
+    if suffix and suffix not in base_name:
+        return f"{base_name}{suffix}"
+
+    return base_name
+
+
+# --- 核心功能模块 ---
+
+@st.cache_data(show_spinner=False, ttl=600)
+def fetch_and_process_server_movies(priority_movie_titles=None, tms_proxy_base_url=""):
+    if priority_movie_titles is None: priority_movie_titles = []
+    proxy_base_url = get_tms_proxy_base_url(tms_proxy_base_url)
+
+    # 获取环境变量
+    app_secret = os.getenv("TMS_APP_SECRET")
+    ticket = os.getenv("TMS_TICKET")
+    theater_id_str = os.getenv("TMS_THEATER_ID")
+    x_session_id = os.getenv("TMS_X_SESSION_ID")
+
+    # 转换 ID 为整数
+    try:
+        theater_id = int(theater_id_str) if theater_id_str else 0
+    except ValueError:
+        st.error("环境变量 TMS_THEATER_ID 格式错误，应为数字。")
+        return {}, []
+
+    token_headers = {
+        'Accept': 'application/json, text/javascript, */*; q=0.01',
+        'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6',
+        'Content-Type': 'application/json',
+        'Cookie': f'JSESSIONID={x_session_id}',
+        'DNT': '1',
+        'Origin': 'https://tms.hengdianfilm.com',
+        'Priority': 'u=0, i',
+        'Referer': f'https://tms.hengdianfilm.com/hd/oalogin?ticket={ticket}',
+        'Sec-CH-UA': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
+        'Sec-CH-UA-Mobile': '?0',
+        'Sec-CH-UA-Platform': '"macOS"',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin',
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36',
+        'X-Requested-With': 'XMLHttpRequest',
+    }
+
+    # 使用变量
+    token_json_data = {'appId': 'hd', 'appSecret': app_secret, 'timeStamp': int(time.time() * 1000)}
+    # 动态构建 URL
+    token_url = build_tms_url(
+        f'{TMS_ORIGIN}/cinema-api/admin/generateToken?token=hd&murl=?token=hd&murl=ticket={ticket}',
+        proxy_base_url,
+    )
+    token_headers = with_tms_proxy_headers(token_headers, proxy_base_url)
+
+    try:
+        response = requests.post(token_url, headers=token_headers, json=token_json_data, timeout=10)
+        response.raise_for_status()
+        token_data = response.json()
+        if token_data.get('error_code') != '0000': 
+            raise Exception(f"获取Token失败: {token_data.get('error_desc')}")
+        auth_token = token_data['param']
+    except requests.exceptions.HTTPError as e:
+        st.error(format_tms_http_error("连接 TMS 认证服务失败", e.response))
+        return {}, []
+    except Exception as e:
+        st.error(f"连接 TMS 认证服务失败: {e}")
+        return {}, []
+
+    all_movies, page_index = [], 1
+    while True:
+        list_headers = {
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6',
+            'Content-Type': 'application/json; charset=UTF-8',
+            'Cookie': f'JSESSIONID={x_session_id}',
+            'DNT': '1',
+            'Origin': 'https://tms.hengdianfilm.com',
+            'Priority': 'u=1, i',
+            'Referer': f'https://tms.hengdianfilm.com/hd/index?ContentMovie&THEATER_ID={theater_id}&SOURCE=SERVER&ASSERT_TYPE=2&PAGE_CAPACITY=20&PAGE_INDEX=1',
+            'Sec-CH-UA': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
+            'Sec-CH-UA-Mobile': '?0',
+            'Sec-CH-UA-Platform': '"macOS"',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Token': auth_token,
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36',
+            'X-Requested-With': 'XMLHttpRequest',
+            'X-SESSIONID': x_session_id,
+        }
+        list_params = {'token': 'hd', 'murl': 'ContentMovie'}
+        list_json_data = {'THEATER_ID': theater_id, 'SOURCE': 'SERVER', 'ASSERT_TYPE': 2, 'PAGE_CAPACITY': 20,
+                          'PAGE_INDEX': page_index}
+
+        list_url = build_tms_url(f'{TMS_ORIGIN}/cinema-api/cinema/server/dcp/list', proxy_base_url)
+        list_headers = with_tms_proxy_headers(list_headers, proxy_base_url)
+        try:
+            response = requests.post(
+                list_url,
+                params=list_params,
+                headers=list_headers,
+                json=list_json_data,
+                verify=tms_verify_ssl(default=False, proxy_url=proxy_base_url),
+                timeout=15,
+            )
+            response.raise_for_status()
+            movie_data = response.json()
+            if movie_data.get("RSPCD") != "000000": 
+                raise Exception(f"获取影片列表失��: {movie_data.get('RSPMSG')}")
+            
+            body = movie_data.get("BODY", {})
+            movies_on_page = body.get("LIST", [])
+            if not movies_on_page: break
+            all_movies.extend(movies_on_page)
+            if len(all_movies) >= body.get("COUNT", 0): break
+            page_index += 1
+            time.sleep(0.5)
+        except requests.exceptions.HTTPError as e:
+            st.error(format_tms_http_error(f"获取影片列表页 {page_index} 失败", e.response))
+            break
+        except Exception as e:
+            st.error(f"获取影片列表页 {page_index} 失败: {e}")
+            break
+
+    return process_tms_movies(all_movies, priority_movie_titles)
+
+
+def process_tms_movies(all_movies, priority_movie_titles=None):
+    if priority_movie_titles is None:
+        priority_movie_titles = []
+
+    # 处理数据
+    movie_details = {m.get('CONTENT_NAME'): {'assert_name': m.get('ASSERT_NAME'),
+                                             'assert_id': m.get('ASSERT_ID'),
+                                             'halls': sorted([h.get('HALL_NAME') for h in m.get('HALL_INFO', [])]),
+                                             'play_time': m.get('PLAY_TIME')} for m in all_movies if
+                     m.get('CONTENT_NAME')}
+    
+    by_hall = defaultdict(list)
+    for content_name, details in movie_details.items():
+        for hall_name in details['halls']:
+            by_hall[hall_name].append({'content_name': content_name, 'details': details})
+            
+    for hall_name in by_hall:
+        by_hall[hall_name].sort(
+            key=lambda item: (item['details']['assert_name'] is None or item['details']['assert_name'] == '',
+                              item['details']['assert_name'] or item['content_name']))
+            
+    view2_list = [{'assert_name': d['assert_name'], 'assert_id': d.get('assert_id'), 'content_name': c, 'halls': d['halls'], 'play_time': d['play_time']}
+                  for c, d in movie_details.items() if d.get('assert_name')]
+                  
+    priority_list = [item for item in view2_list if
+                     any(p_title in item['assert_name'] for p_title in priority_movie_titles)]
+    other_list_items = [item for item in view2_list if item not in priority_list]
+    
+    priority_list.sort(key=lambda x: x['assert_name'])
+    other_list_items.sort(key=lambda x: x['assert_name'])
+    final_sorted_list = priority_list + other_list_items
+    
+    return dict(sorted(by_hall.items())), final_sorted_list
+
+
+# --- 主界面 ---
+
+def main():
+    st.title("🔍 TMS 服务器影片内容查询")
+    st.info("查询 TMS 服务器上的 DCP 内容及分布情况。")
+    proxy_base_url = get_tms_proxy_base_url()
+    if proxy_base_url:
+        st.caption(f"当前 TMS 请求将通过中转代理访问：{proxy_base_url}")
+    else:
+        st.caption(f"当前 TMS 请求为直连；配置 `{TMS_PROXY_URL_ENV}` 后会自动启用中转代理。")
+
+    # 尝试从 Session State 获取优先显示的影片（如果在主页加载了排片）
+    priority_titles = []
+    if 'api_df' in st.session_state and not st.session_state.api_df.empty:
+        df = st.session_state.api_df
+        if '影片名称_清理后' in df.columns:
+            priority_titles = df['影片名称_清理后'].unique().tolist()
+        elif '影片名称' in df.columns:
+            priority_titles = df['影片名称'].apply(lambda x: clean_movie_title(x)).unique().tolist()
+    
+    # 也可以检查 file_df
+    elif 'file_df' in st.session_state and not st.session_state.file_df.empty:
+        df = st.session_state.file_df
+        if '影片名称_清理后' in df.columns:
+            priority_titles = df['影片名称_清理后'].unique().tolist()
+        elif '影片名称' in df.columns:
+            priority_titles = df['影片名称'].apply(lambda x: clean_movie_title(x)).unique().tolist()
+
+    if st.button('点击查询 TMS 服务器', key="query_tms", type="primary", icon="🔍"):
+        with st.spinner("正在从 TMS 服务器获取数据中..."):
+            try:
+                halls_data, movie_list_sorted = fetch_and_process_server_movies(priority_titles, proxy_base_url)
+                
+                if not movie_list_sorted:
+                    st.warning("未获取到任何影片数据，请检查 TMS 连接配置。")
+                else:
+                    st.success("TMS 服务器数据获取成功！")
+                    content_movie_map = build_tms_content_movie_map(movie_list_sorted)
+                    tms_stats_map = load_tms_content_stats_map()
+                    
+                    # 1. 按影片查看
+                    st.markdown("### 🎥 按影片查看所在影厅")
+                    view2_data = []
+                    for item in movie_list_sorted:
+                        content_name = item['content_name']
+                        stats = tms_stats_map.get(content_name, {})
+                        view2_data.append({
+                            '影片名称': item['assert_name'],
+                            '所在影厅': " ".join(sorted([get_circled_number(h) for h in item['halls']])),
+                            '时长(分钟)': format_play_time(item['play_time']),
+                            '对应影片': stats.get('对应影片') or content_movie_map.get(content_name, ''),
+                            '该影院总票房': stats.get('该影院总票房', ''),
+                            '全国总票房': stats.get('全国总票房', ''),
+                            '该影片在该影院总场次': stats.get('该影片在该影院总场次', ''),
+                            '当前影厅该影片场次': stats.get('当前影厅该影片场次', ''),
+                            '文件名': format_content_name_with_explanation(content_name),
+                        })
+                    view2_df = pd.DataFrame(view2_data)
+                    for num_col in ['该影院总票房', '该影片在该影院总场次']:
+                        if num_col in view2_df.columns:
+                            view2_df[num_col] = pd.to_numeric(view2_df[num_col], errors='coerce')
+                    view2_format = {
+                        '该影院总票房': '{:,.2f}',
+                        '该影片在该影院总场次': '{:,.0f}',
+                    }
+                    st.dataframe(
+                        view2_df.style.format(
+                            {k: v for k, v in view2_format.items() if k in view2_df.columns},
+                            na_rep="",
+                        ),
+                        hide_index=True,
+                        width="stretch",
+                    )
+                    
+                    st.divider()
+
+                    # 2. 按影厅查看
+                    st.markdown("### 🏢 按影厅查看影片内容")
+                    if halls_data:
+                        hall_tabs = st.tabs(list(halls_data.keys()))
+                        for tab, hall_name in zip(hall_tabs, halls_data.keys()):
+                            with tab:
+                                view1_data = []
+                                for item in halls_data[hall_name]:
+                                    content_name = item['content_name']
+                                    stats = tms_stats_map.get(content_name, {})
+                                    view1_data.append({
+                                        '影片名称': item['details']['assert_name'],
+                                        '所在影厅': " ".join(sorted([get_circled_number(h) for h in item['details']['halls']])),
+                                        '时长(分钟)': format_play_time(item['details']['play_time']),
+                                        '对应影片': stats.get('对应影片') or content_movie_map.get(content_name, ''),
+                                        '该影院总票房': stats.get('该影院总票房', ''),
+                                        '全国总票房': stats.get('全国总票房', ''),
+                                        '该影片在该影院总场次': stats.get('该影片在该影院总场次', ''),
+                                        '当前影厅该影片场次': stats.get('当前影厅该影片场次', ''),
+                                        '文件名': format_content_name_with_explanation(content_name),
+                                    })
+                                view1_df = pd.DataFrame(view1_data)
+                                for num_col in ['该影院总票房', '该影片在该影院总场次']:
+                                    if num_col in view1_df.columns:
+                                        view1_df[num_col] = pd.to_numeric(view1_df[num_col], errors='coerce')
+                                st.dataframe(
+                                    view1_df.style.format(
+                                        {k: v for k, v in view2_format.items() if k in view1_df.columns},
+                                        na_rep="",
+                                    ),
+                                    hide_index=True,
+                                    width="stretch",
+                                )
+                    else:
+                        st.info("暂无影厅数据。")
+
+            except Exception as e:
+                st.error(f"查询 TMS 服务器时出错: {e}")
+
+if __name__ == "__main__":
+    main()

pages/🔦 影片放映时间表统计.py

@@ -0,0 +1,409 @@
+import re
+from io import StringIO
+from math import floor
+
+import pandas as pd
+import streamlit as st
+
+DISPLAY_COLUMNS = ['测试时长（分）', '广告时长（分）', '影片播放时长（分）', '剩余激光时长（小时）']
+REMAINING_COLUMN = '剩余激光时长（小时）'
+
+st.set_page_config(layout="wide")
+st.title('🔦 影片放映时间表统计')
+
+
+def build_table_styles():
+    return [
+        {
+            'selector': 'th.col_heading',
+            'props': [
+                ('background-color', '#4a4a4a'),
+                ('color', 'white'),
+                ('text-align', 'center'),
+            ],
+        },
+        {
+            'selector': 'th.row_heading',
+            'props': [('text-align', 'center')],
+        },
+        {
+            'selector': 'td',
+            'props': [('text-align', 'center')],
+        },
+    ]
+
+
+def clean_hall_name(name):
+    if isinstance(name, str):
+        match = re.search(r'(\d+)号', name)
+        if match:
+            return f"{match.group(1)}号厅"
+    return name
+
+
+def get_hall_sort_key(name):
+    numbers = re.findall(r'\d+', str(name))
+    if numbers:
+        return 0, int(numbers[0]), str(name)
+    return 1, 0, str(name)
+
+
+def normalize_text(value):
+    return str(value or '').strip().replace('（', '(').replace('）', ')').replace(' ', '')
+
+
+def parse_number(value):
+    text = str(value).strip().replace(',', '')
+    if not text:
+        return None
+    try:
+        return float(text)
+    except ValueError:
+        return None
+
+
+def format_number(value):
+    if value == '':
+        return ''
+    number = parse_number(value)
+    if number is None:
+        return value
+    if abs(number - round(number)) < 1e-9:
+        return int(round(number))
+    return round(number, 2)
+
+
+def floor_display_hours(value):
+    return int(floor(float(value) + 1e-9))
+
+
+def is_metric_header(value):
+    normalized = normalize_text(value)
+    return any(keyword in normalized for keyword in ['测试时长', '广告时长', '影片播放时长', '剩余激光时长'])
+
+
+def format_table_for_display(table):
+    display_table = table.copy().astype(object)
+    for column in display_table.columns:
+        display_table[column] = display_table[column].map(format_number)
+    return display_table
+
+
+def render_table(table, style_df=None):
+    styler = format_table_for_display(table).style.set_table_styles(build_table_styles())
+    if style_df is not None:
+        styler = styler.apply(lambda _: style_df, axis=None)
+    table_height = min(1200, (len(table) + 3) * 35)
+    st.dataframe(styler, height=table_height, width="stretch")
+
+
+def build_excel_copy_text(table):
+    export_df = format_table_for_display(table).reset_index(drop=True)
+    return export_df.to_csv(sep='\t', index=False, header=False).rstrip('\n')
+
+
+def build_schedule_pivot_table(df, ad_duration, test_duration):
+    df = df.copy()
+    df['影片'] = df['影片'].astype(str)
+    df['影厅'] = df['影厅'].apply(clean_hall_name)
+    df['放映日期'] = pd.to_datetime(df['放映日期'])
+    df['日期'] = df['放映日期'].dt.strftime('%m月%d日')
+    df.dropna(subset=['影厅', '片长'], inplace=True)
+
+    summary = df.groupby(['日期', '影厅']).agg(
+        影片数量=('影片', 'count'),
+        原始影片时长=('片长', 'sum'),
+    ).reset_index()
+    summary['测试时长（分）'] = test_duration
+    summary['广告时长（分）'] = summary['影片数量'] * ad_duration
+    summary['影片播放时长（分）'] = summary['原始影片时长']
+
+    pivot_table = summary.pivot_table(
+        index='日期',
+        columns='影厅',
+        values=['测试时长（分）', '广告时长（分）', '影片播放时长（分）'],
+    ).fillna(0).astype(int)
+
+    if pivot_table.empty:
+        return pivot_table
+
+    pivot_table = pivot_table.swaplevel(0, 1, axis=1).sort_index(axis=1)
+    halls = sorted(pivot_table.columns.get_level_values(0).unique(), key=get_hall_sort_key)
+    new_columns = pd.MultiIndex.from_product([halls, DISPLAY_COLUMNS], names=['影厅', None])
+    pivot_table = pivot_table.reindex(columns=new_columns).fillna('')
+    return pivot_table
+
+
+def detect_date_column(raw_df):
+    for row_index in range(min(3, len(raw_df))):
+        if '日期' in normalize_text(raw_df.iat[row_index, 0]):
+            return True
+
+    for row_index in range(len(raw_df)):
+        first_value = str(raw_df.iat[row_index, 0]).strip()
+        rest_values = [str(value).strip() for value in raw_df.iloc[row_index, 1:].tolist()]
+        non_empty_rest = [value for value in rest_values if value]
+        if first_value and parse_number(first_value) is None and len(non_empty_rest) >= 4:
+            if all(parse_number(value) is not None for value in non_empty_rest):
+                return True
+    return False
+
+
+def find_first_data_row(raw_df, start_col):
+    for row_index in range(len(raw_df)):
+        row_values = [str(value).strip() for value in raw_df.iloc[row_index, start_col:].tolist()]
+        non_empty_values = [value for value in row_values if value]
+        if len(non_empty_values) >= 4 and all(parse_number(value) is not None for value in non_empty_values):
+            return row_index
+    return None
+
+
+def extract_hall_names(raw_df, first_data_row, start_col, group_count) -> list[str]:
+    hall_names: list[str] = []
+    for group_index in range(group_count):
+        hall_name = ''
+        group_start_col = start_col + group_index * 4
+        for row_index in range(first_data_row):
+            candidate = str(raw_df.iat[row_index, group_start_col]).strip()
+            if candidate and not is_metric_header(candidate):
+                hall_name = clean_hall_name(candidate)
+                break
+        if not hall_name:
+            hall_name = f'{group_index + 1}号厅'
+        hall_names.append(hall_name)
+    return hall_names
+
+
+def parse_pasted_laser_text(pasted_text):
+    raw_df = pd.read_csv(StringIO(pasted_text), sep='\t', header=None, dtype=str, keep_default_na=False)
+    raw_df = raw_df.replace(r'^\s*$', pd.NA, regex=True).dropna(axis=0, how='all').dropna(axis=1, how='all')
+    raw_df = raw_df.fillna('').reset_index(drop=True)
+
+    if raw_df.empty:
+        raise ValueError('未识别到任何数据。')
+
+    has_date_column = detect_date_column(raw_df)
+    start_col = 1 if has_date_column else 0
+    first_data_row = find_first_data_row(raw_df, start_col)
+    if first_data_row is None:
+        raise ValueError('未识别到可计算的数据行，请检查粘贴内容。')
+
+    value_col_count = raw_df.shape[1] - start_col
+    if value_col_count <= 0 or value_col_count % 4 != 0:
+        raise ValueError(f'检测到 {value_col_count} 列有效数据，无法按每 4 列一个影厅进行解析。')
+
+    group_count = value_col_count // 4
+    hall_names: list[str] = extract_hall_names(raw_df, first_data_row, start_col, group_count)
+    parsed_rows: list[list[float]] = []
+    row_labels: list[str] = []
+
+    for row_index in range(first_data_row, len(raw_df)):
+        label = str(raw_df.iat[row_index, 0]).strip() if has_date_column else f'第{len(row_labels) + 1}天'
+        if not label:
+            label = f'第{len(row_labels) + 1}天'
+
+        numeric_row = []
+        row_values = [str(value).strip() for value in raw_df.iloc[row_index, start_col:].tolist()]
+        non_empty_values = [value for value in row_values if value]
+        if not non_empty_values:
+            continue
+
+        if not all(parse_number(value) is not None for value in non_empty_values):
+            continue
+
+        if len(row_values) != value_col_count:
+            raise ValueError(f'第 {row_index + 1} 行列数不完整。')
+
+        for col_index, raw_value in enumerate(row_values, start=1):
+            number = parse_number(raw_value)
+            if number is None:
+                raise ValueError(f'第 {row_index + 1} 行第 {col_index + start_col} 列不是数字：{raw_value}')
+            numeric_row.append(number)
+
+        row_labels.append(label)
+        parsed_rows.append(numeric_row)
+
+    if not parsed_rows:
+        raise ValueError('未识别到可计算的数据行，请检查粘贴内容。')
+
+    columns = pd.MultiIndex.from_product([hall_names, DISPLAY_COLUMNS], names=['影厅', None])
+    table = pd.DataFrame(parsed_rows, index=pd.Index(row_labels), columns=columns)
+    table.index.name = '日期' if has_date_column else '天次'
+    return table
+
+
+def find_best_recharge_count(previous_remaining, usage_hours, actual_remaining, recharge_hours):
+    theoretical_without_recharge = previous_remaining - usage_hours
+    if recharge_hours <= 0:
+        theoretical_display = floor_display_hours(theoretical_without_recharge)
+        return 0, theoretical_display
+
+    approx_count = max(0, int(round((actual_remaining - theoretical_without_recharge) / recharge_hours)))
+    candidate_counts = range(max(0, approx_count - 2), approx_count + 3)
+    best_count = 0
+    best_display = floor_display_hours(theoretical_without_recharge)
+    best_gap = abs(actual_remaining - best_display)
+
+    for recharge_count in candidate_counts:
+        theoretical_display = floor_display_hours(theoretical_without_recharge + recharge_count * recharge_hours)
+        gap = abs(actual_remaining - theoretical_display)
+        if gap < best_gap or (gap == best_gap and recharge_count < best_count):
+            best_count = recharge_count
+            best_display = theoretical_display
+            best_gap = gap
+
+    return best_count, best_display
+
+
+def build_laser_check_style(table, recharge_hours):
+    style_df = pd.DataFrame('', index=table.index, columns=table.columns)
+    abnormal_count = 0
+    halls = list(dict.fromkeys(table.columns.get_level_values(0)))
+
+    for hall_name in halls:
+        previous_remaining = None
+        for row_label in table.index:
+            actual_remaining = float(table.loc[row_label, (hall_name, REMAINING_COLUMN)])
+            if previous_remaining is None:
+                previous_remaining = actual_remaining
+                continue
+
+            ad_minutes = float(table.loc[row_label, (hall_name, '广告时长（分）')])
+            movie_minutes = float(table.loc[row_label, (hall_name, '影片播放时长（分）')])
+            usage_hours = (ad_minutes + movie_minutes) / 60
+            _, theoretical_display = find_best_recharge_count(previous_remaining, usage_hours, actual_remaining, recharge_hours)
+            diff_hours = actual_remaining - theoretical_display
+
+            if abs(diff_hours) > 1:
+                abnormal_count += 1
+                text_color = '#d32f2f' if diff_hours < 0 else '#2e7d32'
+                style_df.loc[row_label, (hall_name, REMAINING_COLUMN)] = (
+                    f'background-color: #fff3b0; color: {text_color}; font-weight: 700'
+                )
+
+            previous_remaining = actual_remaining
+
+    return style_df, abnormal_count
+
+
+def build_laser_gap_summary(table, recharge_hours):
+    records = []
+    halls = list(dict.fromkeys(table.columns.get_level_values(0)))
+
+    for hall_name in halls:
+        previous_remaining = None
+        total_content_hours = 0.0
+        total_laser_hours = 0.0
+
+        for row_label in table.index:
+            actual_remaining = float(table.loc[row_label, (hall_name, REMAINING_COLUMN)])
+            if previous_remaining is None:
+                previous_remaining = actual_remaining
+                continue
+
+            ad_minutes = float(table.loc[row_label, (hall_name, '广告时长（分）')])
+            movie_minutes = float(table.loc[row_label, (hall_name, '影片播放时长（分）')])
+            content_hours = (ad_minutes + movie_minutes) / 60
+            recharge_count, _ = find_best_recharge_count(previous_remaining, content_hours, actual_remaining, recharge_hours)
+            actual_laser_hours = previous_remaining + recharge_count * recharge_hours - actual_remaining
+
+            total_content_hours += content_hours
+            total_laser_hours += actual_laser_hours
+            previous_remaining = actual_remaining
+
+        diff_hours = total_content_hours - total_laser_hours
+        if diff_hours > 1e-9:
+            result_text = f'节省 {diff_hours:.2f} 小时'
+        elif diff_hours < -1e-9:
+            result_text = f'浪费 {abs(diff_hours):.2f} 小时'
+        else:
+            result_text = '无差额'
+
+        records.append({
+            '影厅': hall_name,
+            '广告+影片时长（小时）': round(total_content_hours, 2),
+            '激光时长（小时）': round(total_laser_hours, 2),
+            '差额（小时）': round(diff_hours, 2),
+            '结果': result_text,
+        })
+
+    return pd.DataFrame(records)
+
+
+def render_schedule_summary():
+    st.subheader('上传文件生成统计')
+    uploaded_file = st.file_uploader('上传“影片放映时间表.xlsx”文件', type=['xlsx'], key='laser_upload_file')
+
+    col1, col2 = st.columns(2)
+    with col1:
+        ad_duration = st.number_input('输入每个广告的时长（分钟）', min_value=0, value=5, key='laser_ad_duration')
+    with col2:
+        test_duration = st.number_input('输入测试时长（分）', min_value=0, value=5, key='laser_test_duration')
+
+    if uploaded_file is None:
+        return
+
+    try:
+        df = pd.read_excel(uploaded_file, header=3)
+        st.subheader('上传的原始数据')
+        st.dataframe(df, width="stretch")
+
+        pivot_table = build_schedule_pivot_table(df, ad_duration, test_duration)
+        if pivot_table.empty:
+            st.warning('没有可用于生成统计信息的数据。')
+            return
+
+        st.subheader('影厅播放统计')
+        render_table(pivot_table)
+
+        st.subheader('复制到 Excel')
+        st.caption('以下内容从“测试时长（分）”第一个数据开始，到最后一个数据结束；不包含日期和表头。')
+        st.code(build_excel_copy_text(pivot_table), language='text')
+    except Exception as e:
+        st.error(f'处理文件时出错: {e}')
+
+
+def render_laser_checker():
+    st.divider()
+    st.subheader('粘贴文本校验剩余激光时长')
+    st.caption('支持直接粘贴 Excel 文本。黄色底色表示差异绝对值超过 1 小时；红字表示实际值低于正常值，绿字表示实际值高于正常值。')
+
+    recharge_hours = st.number_input('激光默认充值小时数', min_value=0, value=1000, step=100, key='laser_recharge_hours')
+    pasted_text = st.text_area(
+        '粘贴需要校验的文本',
+        height=260,
+        placeholder='日期\t1号厅\t\t\t\n\t测试时长(分）\t广告时长(分）\t影片播放时长（分）\t剩余激光时长（小时）\n3月1日\t5\t30\t750\t665\n3月2日\t5\t25\t625\t654',
+        key='laser_pasted_text',
+    )
+
+    if not pasted_text.strip():
+        return
+
+    try:
+        pasted_table = parse_pasted_laser_text(pasted_text)
+        style_df, abnormal_count = build_laser_check_style(pasted_table, float(recharge_hours))
+    except Exception as e:
+        st.error(f'校验失败：{e}')
+        return
+
+    hall_count = int(pasted_table.columns.get_level_values(0).nunique())
+    if abnormal_count > 0:
+        st.warning(f'共识别 {hall_count} 个影厅，发现 {abnormal_count} 个异常检查点。')
+    else:
+        st.success(f'共识别 {hall_count} 个影厅，所有检查点都在 1 小时以内。')
+
+    render_table(pasted_table, style_df=style_df)
+
+    st.divider()
+    st.subheader('各影厅激光差额汇总')
+    st.caption('按当前输入的全部数据逐行累计计算：广告时长 + 影片时长 大于 激光时长 记为节省，反之记为浪费。')
+
+    gap_summary_df = build_laser_gap_summary(pasted_table, float(recharge_hours))
+    if gap_summary_df.empty:
+        st.info('当前数据不足以计算各影厅差额汇总。')
+    else:
+        st.dataframe(gap_summary_df, width="stretch", hide_index=True)
+
+
+render_schedule_summary()
+render_laser_checker()

pages/🧐 影片效率分析.py

@@ -0,0 +1,916 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import datetime
+import altair as alt
+import json
+import tempfile
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from historical_sessions import (
+    LOCAL_HISTORY_FILE,
+    LOCAL_HISTORY_MANIFEST_FILE,
+    build_duration_reference_from_history,
+    create_duration_label,
+    create_empty_history_df,
+    default_history_manifest,
+    load_history_df,
+    load_history_manifest,
+    merge_history_df,
+    round_minutes_to_10min,
+    save_history_df,
+    save_history_manifest,
+)
+from r2_storage import R2Storage
+
+# --- 全局设置 ---
+st.set_page_config(layout="wide", page_title="影片效率分析")
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+load_dotenv(dotenv_path=str(ROOT_DIR / ".env"), override=True)
+
+
+# --- 自动数据获取（本地 + R2）---
+def build_default_prefix():
+    cinema_id = (os.getenv("CINEMA_ID") or "").strip() or "default"
+    return f"{cinema_id}/sessions_total"
+
+
+def build_r2_history_keys():
+    object_prefix = build_default_prefix().rstrip("/")
+    return (
+        f"{object_prefix}/historical_sessions.csv",
+        f"{object_prefix}/historical_sessions_manifest.json",
+    )
+
+
+def load_history_df_from_path(csv_path: Path) -> pd.DataFrame:
+    """从指定 CSV 路径加载历史场次数据，失败时返回空 DataFrame。"""
+    try:
+        from historical_sessions import _normalize_history_df
+        return _normalize_history_df(pd.read_csv(csv_path))
+    except Exception:
+        return create_empty_history_df()
+
+
+@st.cache_data(show_spinner=False)
+def _cached_load_local_history(path_str: str, mtime: float, size: int) -> pd.DataFrame:
+    """
+    进程级缓存：本地 CSV 一旦解析成功，后续所有会话直接复用。
+    mtime / size 参与 cache key，文件被覆盖时自动失效。
+    """
+    return load_history_df()
+
+
+def load_local_history_cached() -> pd.DataFrame:
+    if LOCAL_HISTORY_FILE.exists():
+        stat = LOCAL_HISTORY_FILE.stat()
+        return _cached_load_local_history(str(LOCAL_HISTORY_FILE), stat.st_mtime, stat.st_size)
+    return load_history_df()
+
+
+def load_manifest_from_path(manifest_path: Path) -> dict:
+    manifest = default_history_manifest()
+    if manifest_path.exists():
+        try:
+            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+            if isinstance(payload, dict):
+                manifest.update(payload)
+        except Exception:
+            pass
+    return manifest
+
+
+def auto_load_history_dataset(force_r2_sync: bool = False):
+    """
+    自动获取历史场次数据。
+    1. 优先读取本地缓存 `cinema_cache/historical_sessions.csv`。
+    2. 当本地缺失或用户强制刷新时，尝试从 R2 下载，并合并保存。
+    返回 (history_df, source_label, message)。
+    """
+    csv_key, manifest_key = build_r2_history_keys()
+    local_exists = LOCAL_HISTORY_FILE.exists()
+    storage = None
+    storage_error = None
+
+    try:
+        storage = R2Storage()
+    except Exception as exc:
+        storage_error = str(exc)
+
+    # 情况 1：本地存在且无需强制 R2 同步
+    if local_exists and not force_r2_sync:
+        df = load_local_history_cached()
+        msg = f"已加载本地历史库（{len(df)} 条记录）。"
+        if storage_error:
+            msg += f" R2 暂不可用：{storage_error}"
+        return df, "local", msg
+
+    # 情况 2：本地不存在但 R2 不可用
+    if not local_exists and storage is None:
+        return (
+            create_empty_history_df(),
+            "empty",
+            f"本地历史库不存在，且 R2 不可用：{storage_error or '未配置'}",
+        )
+
+    # 情况 3：需要从 R2 下载
+    if storage is not None:
+        try:
+            remote_csv_exists = storage.exists(csv_key)
+            remote_manifest_exists = storage.exists(manifest_key)
+        except Exception as exc:
+            df = load_history_df() if local_exists else create_empty_history_df()
+            return df, "local" if local_exists else "empty", f"R2 检查失败：{exc}"
+
+        if not remote_csv_exists:
+            df = load_local_history_cached() if local_exists else create_empty_history_df()
+            source = "local" if local_exists else "empty"
+            return df, source, "R2 上暂无历史库文件。" + ("" if local_exists else "等待管理员先在监控页同步数据。")
+
+        try:
+            with tempfile.TemporaryDirectory(prefix="xiaolv_history_") as temp_dir:
+                temp_dir_path = Path(temp_dir)
+                remote_csv_path = temp_dir_path / "historical_sessions.csv"
+                remote_manifest_path = temp_dir_path / "historical_sessions_manifest.json"
+                storage.download_file(csv_key, remote_csv_path)
+                if remote_manifest_exists:
+                    storage.download_file(manifest_key, remote_manifest_path)
+                remote_df = load_history_df_from_path(remote_csv_path)
+                remote_manifest = load_manifest_from_path(remote_manifest_path)
+        except Exception as exc:
+            df = load_local_history_cached() if local_exists else create_empty_history_df()
+            return df, "local" if local_exists else "empty", f"从 R2 下载失败：{exc}"
+
+        if local_exists:
+            local_df = load_local_history_cached()
+            local_manifest = load_history_manifest()
+            merged_df = merge_history_df(local_df, remote_df)
+            merged_manifest = local_manifest.copy()
+            merged_manifest.setdefault("synced_dates", [])
+            merged_manifest["synced_dates"] = sorted(
+                set(merged_manifest.get("synced_dates", [])) | set(remote_manifest.get("synced_dates", []))
+            )
+            save_history_manifest(merged_manifest)
+            return (
+                merged_df,
+                "local+r2",
+                f"已把 R2 历史库与本地合并（合并后 {len(merged_df)} 条记录）。",
+            )
+        else:
+            saved_df = save_history_df(remote_df)
+            save_history_manifest(remote_manifest)
+            return (
+                saved_df,
+                "r2",
+                f"本地无历史库，已从 R2 下载（{len(saved_df)} 条记录）。",
+            )
+
+    # 兜底
+    return create_empty_history_df(), "empty", "未能加载任何历史数据。"
+
+
+def render_analysis_overview(df, start_date, end_date):
+    total_revenue = float(pd.to_numeric(df.get('总收入'), errors='coerce').fillna(0).sum()) if not df.empty else 0.0
+    total_people = float(pd.to_numeric(df.get('总人次'), errors='coerce').fillna(0).sum()) if not df.empty else 0.0
+    total_sessions = int(len(df))
+    movie_count = int(df['影片名称_清理后'].nunique()) if '影片名称_清理后' in df.columns and not df.empty else 0
+    date_label = f"{start_date.strftime('%Y-%m-%d')} 至 {end_date.strftime('%Y-%m-%d')}"
+    st.markdown(
+        f"""
+        <div style="margin: 8px 0 18px 0; padding: 18px 22px; border-radius: 10px; background: #fff7ed; border: 1px solid #fed7aa;">
+            <div style="font-size: 16px; font-weight: 700; color: #7c2d12; margin-bottom: 10px;">{date_label} 数据总览</div>
+            <div style="display: flex; gap: 26px; flex-wrap: wrap; align-items: baseline;">
+                <div><span style="font-size: 18px; font-weight: 700; color: #5C1F00;">总票房：</span><span style="font-size: 34px; font-weight: 900; color: #c2410c;">¥{total_revenue:,.2f}</span></div>
+                <div><span style="font-size: 18px; font-weight: 700; color: #5C1F00;">总人次：</span><span style="font-size: 34px; font-weight: 900; color: #c2410c;">{total_people:,.0f}</span></div>
+                <div><span style="font-size: 18px; font-weight: 700; color: #5C1F00;">总场次：</span><span style="font-size: 34px; font-weight: 900; color: #c2410c;">{total_sessions:,.0f}</span></div>
+                <div><span style="font-size: 18px; font-weight: 700; color: #5C1F00;">影片数：</span><span style="font-size: 34px; font-weight: 900; color: #c2410c;">{movie_count:,.0f}</span></div>
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def process_and_analyze_data(df):
+    if df.empty:
+        return pd.DataFrame()
+    analysis_df = df.groupby('影片名称_清理后').agg(
+        座位数=('座位数', 'sum'), 场次=('影片名称_清理后', 'size'),
+        票房=('总收入', 'sum'), 人次=('总人次', 'sum')
+    ).reset_index()
+    analysis_df.rename(columns={'影片名称_清理后': '影片'}, inplace=True)
+    analysis_df = analysis_df.sort_values(by='票房', ascending=False).reset_index(drop=True)
+
+    total_seats = analysis_df['座位数'].sum()
+    total_sessions = analysis_df['场次'].sum()
+    total_revenue = analysis_df['票房'].sum()
+
+    if total_revenue == 0:
+        analysis_df[['均价', '座次比', '场次比', '票房比', '座次效率', '场次效率']] = 0
+    else:
+        analysis_df['均价'] = np.divide(analysis_df['票房'], analysis_df['人次']).fillna(0)
+        analysis_df['座次比'] = np.divide(analysis_df['座位数'], total_seats).fillna(0) if total_seats > 0 else 0
+        analysis_df['场次比'] = np.divide(analysis_df['场次'], total_sessions).fillna(0) if total_sessions > 0 else 0
+        analysis_df['票房比'] = np.divide(analysis_df['票房'], total_revenue).fillna(0)
+        analysis_df['座次效率'] = np.divide(analysis_df['票房比'], analysis_df['座次比']).fillna(0)
+        analysis_df['场次效率'] = np.divide(analysis_df['票房比'], analysis_df['场次比']).fillna(0)
+
+    final_columns = ['影片', '座位数', '场次', '票房', '人次', '均价', '座次比', '场次比', '票房比', '座次效率',
+                     '场次效率']
+    analysis_df = analysis_df[final_columns]
+    return analysis_df
+
+
+def get_chinese_holidays_2025():
+    holidays = set()
+    holidays.add(datetime.date(2025, 1, 1))
+    holidays.update([datetime.date(2025, 1, 28) + datetime.timedelta(days=i) for i in range(7)])
+    holidays.update([datetime.date(2025, 4, 4) + datetime.timedelta(days=i) for i in range(3)])
+    holidays.update([datetime.date(2025, 5, 1) + datetime.timedelta(days=i) for i in range(5)])
+    holidays.update([datetime.date(2025, 5, 30) + datetime.timedelta(days=i) for i in range(3)])
+    holidays.add(datetime.date(2025, 10, 6))
+    holidays.update([datetime.date(2025, 10, 1) + datetime.timedelta(days=i) for i in range(7)])
+    return holidays
+
+
+def plot_daily_box_office(df, selected_movie='全部影片'):
+    if df.empty:
+        return None
+    plot_df = df[df['影片名称_清理后'] == selected_movie].copy() if selected_movie != '全部影片' else df.copy()
+    if plot_df.empty:
+        st.warning(f"影片《{selected_movie}》在所选日期范围内没有找到数据。")
+        return None
+    daily_revenue = plot_df.groupby('放映日期')['总收入'].sum().reset_index()
+    daily_revenue.rename(columns={'放映日期': '日期', '总收入': '票房'}, inplace=True)
+    total_box_office = daily_revenue['票房'].sum()
+    chart_title = f'每日票房表现 - {selected_movie} | 总票房: {total_box_office:,.0f} 元'
+    start_date = pd.to_datetime(df['放映日期'].min())
+    end_date = pd.to_datetime(df['放映日期'].max())
+    full_date_range = pd.to_datetime(pd.date_range(start=start_date, end=end_date, freq='D'))
+    daily_revenue['日期'] = pd.to_datetime(daily_revenue['日期'])
+    daily_revenue = pd.merge(pd.DataFrame({'日期': full_date_range}), daily_revenue, on='日期', how='left').fillna(0)
+    holidays = get_chinese_holidays_2025()
+    daily_revenue['day_of_week'] = daily_revenue['日期'].dt.dayofweek
+    daily_revenue['类型'] = daily_revenue.apply(
+        lambda row: '节假日' if row['日期'].date() in holidays else (
+            '周末' if row['day_of_week'] in [4, 5, 6] else '工作日'),
+        axis=1,
+    )
+    chart = alt.Chart(daily_revenue).mark_bar().encode(
+        x=alt.X('日期:T', title='日期', axis=alt.Axis(labelAngle=-45, format='%m-%d')),
+        y=alt.Y('票房:Q', title='票房 (元)', scale=alt.Scale(domainMin=0)),
+        color=alt.Color('类型:N',
+                        scale=alt.Scale(domain=['工作日', '周末', '节假日'], range=['#87CEEB', '#FFA500', '#FF4500']),
+                        legend=alt.Legend(title="日期类型")),
+        tooltip=[alt.Tooltip('日期:T', format='%Y-%m-%d', title='日期'),
+                 alt.Tooltip('票房:Q', format=',.2f', title='票房'),
+                 alt.Tooltip('类型:N', title='类型')]
+    ).properties(title=chart_title).interactive()
+    return chart
+
+
+def round_time_to_5min(t_datetime):
+    delta = t_datetime - datetime.datetime.min
+    intervals = delta.total_seconds() // 300
+    return (datetime.datetime.min + datetime.timedelta(seconds=intervals * 300)).time()
+
+
+def enrich_df_with_duration_types(df, duration_df):
+    if df.empty:
+        return pd.DataFrame(), []
+
+    enriched_df = df.copy()
+    if '影片时长(分钟)' not in enriched_df.columns:
+        enriched_df['影片时长(分钟)'] = np.nan
+
+    enriched_df['影片时长(分钟)'] = pd.to_numeric(enriched_df['影片时长(分钟)'], errors='coerce')
+
+    if duration_df is not None and not duration_df.empty:
+        fallback_df = duration_df.copy()
+        if '记录场次' not in fallback_df.columns:
+            fallback_df['记录场次'] = 0
+        fallback_df['影片时长(分钟)'] = pd.to_numeric(fallback_df['影片时长(分钟)'], errors='coerce')
+        fallback_df = fallback_df.dropna(subset=['影片名称_清理后', '影片时长(分钟)']).copy()
+        fallback_df = fallback_df.sort_values(['记录场次', '影片时长(分钟)'], ascending=[False, False])
+        fallback_df = fallback_df.drop_duplicates(subset=['影片名称_清理后'], keep='first')
+        fallback_map = fallback_df.set_index('影片名称_清理后')['影片时长(分钟)'].to_dict()
+
+        missing_mask = enriched_df['影片时长(分钟)'].isna()
+        enriched_df.loc[missing_mask, '影片时长(分钟)'] = enriched_df.loc[missing_mask, '影片名称_清理后'].map(fallback_map)
+
+    enriched_df = enriched_df[
+        (enriched_df['影片时长(分钟)'].isna()) |
+        ((enriched_df['影片时长(分钟)'] > 0) & (enriched_df['影片时长(分钟)'] <= 400))
+    ].copy()
+    enriched_df['影片时长(分钟)'] = pd.to_numeric(enriched_df['影片时长(分钟)'], errors='coerce')
+    enriched_df['影片时长档位'] = enriched_df['影片时长(分钟)'].apply(round_minutes_to_10min)
+    enriched_df['影片时长类型'] = enriched_df['影片时长档位'].apply(create_duration_label)
+
+    missing_movies = sorted(
+        enriched_df.loc[enriched_df['影片时长类型'].isna(), '影片名称_清理后'].dropna().unique().tolist()
+    )
+    enriched_df = enriched_df.dropna(subset=['影片时长档位', '影片时长类型']).copy()
+    return enriched_df, missing_movies
+
+
+def get_all_5min_time_labels():
+    return [t.strftime('%H:%M') for t in pd.to_datetime(pd.date_range('09:30', '23:55', freq='5min')).time]
+
+
+def build_missing_movies_text(missing_movies, limit=8):
+    if not missing_movies:
+        return ''
+    preview = '、'.join(missing_movies[:limit])
+    suffix = ' 等' if len(missing_movies) > limit else ''
+    return f"以下影片暂未匹配到有效时长，未纳入时长效率分析：{preview}{suffix}。"
+
+
+def calculate_duration_bucket_time_efficiency(df, duration_df=None, benchmark_scope='bucket'):
+    if df.empty:
+        return pd.DataFrame(), pd.DataFrame(), []
+
+    enriched_df, missing_movies = enrich_df_with_duration_types(df, duration_df)
+    if enriched_df.empty:
+        return pd.DataFrame(), pd.DataFrame(), missing_movies
+
+    df_filtered = enriched_df[(enriched_df['放映时间'] >= datetime.time(9, 30)) & (enriched_df['放映时间'] <= datetime.time(23, 59))].copy()
+    if df_filtered.empty:
+        return pd.DataFrame(), pd.DataFrame(), missing_movies
+
+    df_filtered['时间点'] = df_filtered['放映时间'].apply(
+        lambda t: round_time_to_5min(datetime.datetime.combine(datetime.date.today(), t))
+    )
+
+    time_analysis = df_filtered.groupby(['放映日期', '影片时长类型', '影片时长档位', '时间点']).agg(
+        座位数=('座位数', 'sum'),
+        场次=('场次', 'sum'),
+        票房=('总收入', 'sum')
+    ).reset_index()
+
+    bucket_stats = enriched_df.groupby(['影片时长类型', '影片时长档位']).agg(
+        总场次=('场次', 'sum'),
+        总票房=('总收入', 'sum'),
+        涉及影片数=('影片名称_清理后', 'nunique')
+    ).reset_index().sort_values(['影片时长档位', '影片时长类型']).reset_index(drop=True)
+
+    if benchmark_scope == 'bucket':
+        compare_totals = enriched_df.groupby(['影片时长类型', '影片时长档位']).agg(
+            对比票房=('总收入', 'sum'),
+            对比座位数=('座位数', 'sum'),
+            对比场次=('场次', 'sum')
+        ).reset_index()
+        time_analysis = pd.merge(time_analysis, compare_totals, on=['影片时长类型', '影片时长档位'], how='left')
+    else:
+        total_revenue_full_day = df['总收入'].sum()
+        total_seats_full_day = df['座位数'].sum()
+        total_sessions_full_day = df['场次'].sum()
+        if total_revenue_full_day == 0 or total_seats_full_day == 0 or total_sessions_full_day == 0:
+            return pd.DataFrame(), bucket_stats, missing_movies
+        time_analysis['对比票房'] = total_revenue_full_day
+        time_analysis['对比座位数'] = total_seats_full_day
+        time_analysis['对比场次'] = total_sessions_full_day
+
+    time_analysis = time_analysis[(time_analysis['对比票房'] > 0) & (time_analysis['对比座位数'] > 0) & (time_analysis['对比场次'] > 0)].copy()
+    if time_analysis.empty:
+        return pd.DataFrame(), bucket_stats, missing_movies
+
+    time_analysis['票房比'] = time_analysis['票房'] / time_analysis['对比票房']
+    time_analysis['座次比'] = time_analysis['座位数'] / time_analysis['对比座位数']
+    time_analysis['场次比'] = time_analysis['场次'] / time_analysis['对比场次']
+    time_analysis['座次效率'] = (time_analysis['票房比'] / time_analysis['座次比']).fillna(0).replace([np.inf, -np.inf], 0)
+    time_analysis['场次效率'] = (time_analysis['票房比'] / time_analysis['场次比']).fillna(0).replace([np.inf, -np.inf], 0)
+
+    avg_efficiency = time_analysis.groupby(['影片时长类型', '影片时长档位', '时间点'])[['座次效率', '场次效率']].mean().reset_index()
+    avg_efficiency['时间点'] = avg_efficiency['时间点'].apply(lambda t: t.strftime('%H:%M'))
+    avg_efficiency = avg_efficiency.sort_values(['影片时长档位', '时间点']).reset_index(drop=True)
+    return avg_efficiency, bucket_stats, missing_movies
+
+
+def plot_duration_bucket_same_type_efficiency(df, duration_df=None):
+    st.markdown("##### 影片时长效率分析（同档对比）")
+    st.write("影片时长优先使用历史场次 API 自带的 `movieLength`，按每 10 分钟四舍五入分档；少量缺时长的旧记录，会尝试按该影片历史主时长补齐。")
+
+    avg_efficiency, bucket_stats, missing_movies = calculate_duration_bucket_time_efficiency(df, duration_df, benchmark_scope='bucket')
+    if avg_efficiency.empty or bucket_stats.empty:
+        st.warning("暂无足够的影片时长数据，无法进行同档效率分析。")
+        missing_text = build_missing_movies_text(missing_movies)
+        if missing_text:
+            st.caption(missing_text)
+        return
+
+    bucket_options = bucket_stats['影片时长类型'].tolist()
+    default_bucket = bucket_stats.sort_values('总场次', ascending=False)['影片时长类型'].iloc[0]
+    selected_bucket = st.selectbox('选择影片时长类型', options=bucket_options,
+                                   index=bucket_options.index(default_bucket), key='auto_duration_bucket_same_selector')
+
+    bucket_meta = bucket_stats[bucket_stats['影片时长类型'] == selected_bucket].iloc[0]
+    st.caption(f"当前查看 {selected_bucket}：共 {int(bucket_meta['总场次'])} 场，涉及 {int(bucket_meta['涉及影片数'])} 部影片。")
+    missing_text = build_missing_movies_text(missing_movies)
+    if missing_text:
+        st.caption(missing_text)
+
+    all_times = pd.DataFrame({'时间点': get_all_5min_time_labels()})
+    selected_df = avg_efficiency[avg_efficiency['影片时长类型'] == selected_bucket][['时间点', '座次效率', '场次效率']].copy()
+    selected_df = pd.merge(all_times, selected_df, on='时间点', how='left').fillna(0)
+    selected_df['标注'] = np.where((selected_df['座次效率'] == 0) & (selected_df['场次效率'] == 0), '此时间点无排片', '有排片')
+
+    source = selected_df.melt(id_vars=['时间点', '标注'], value_vars=['座次效率', '场次效率'],
+                              var_name='效率类型', value_name='效率值')
+    chart = alt.Chart(source).mark_bar().encode(
+        x=alt.X('时间点:N', title='时间点', sort=get_all_5min_time_labels(), axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y('效率值:Q', title='平均效率'),
+        color=alt.Color('效率类型:N', title='效率类型'),
+        xOffset='效率类型:N',
+        tooltip=[alt.Tooltip('时间点:N', title='时间点'), alt.Tooltip('效率类型:N', title='效率类型'),
+                 alt.Tooltip('效率值:Q', title='平均效率', format='.2f'), alt.Tooltip('标注:N', title='备注')]
+    ).properties(title=f'{selected_bucket} 各时间点平均效率（对比同时长档）').interactive()
+    st.altair_chart(chart, width="stretch")
+
+
+def plot_duration_bucket_market_efficiency(df, duration_df=None):
+    st.markdown("##### 影片时长效率分析（全市场对比）")
+    st.write("影片时长优先使用历史场次 API 自带的 `movieLength`，不同档位在每个 5 分钟开场点的效率对比全部影片。")
+
+    avg_efficiency, bucket_stats, missing_movies = calculate_duration_bucket_time_efficiency(df, duration_df, benchmark_scope='market')
+    if avg_efficiency.empty or bucket_stats.empty:
+        st.warning("暂无足够的影片时长数据，无法进行全市场效率分析。")
+        missing_text = build_missing_movies_text(missing_movies)
+        if missing_text:
+            st.caption(missing_text)
+        return
+
+    bucket_options = bucket_stats['影片时长类型'].tolist()
+    default_buckets = bucket_stats.sort_values('总场次', ascending=False)['影片时长类型'].head(min(4, len(bucket_options))).tolist()
+    selected_buckets = st.multiselect('选择要对比的影片时长类型', options=bucket_options,
+                                      default=default_buckets, key='auto_duration_bucket_market_selector')
+    metric = st.radio('选择效率指标', options=['座次效率', '场次效率'], horizontal=True,
+                      key='auto_duration_bucket_market_metric')
+
+    missing_text = build_missing_movies_text(missing_movies)
+    if missing_text:
+        st.caption(missing_text)
+
+    if not selected_buckets:
+        st.info('请至少选择一个影片时长类型。')
+        return
+
+    all_times = get_all_5min_time_labels()
+    full_grid = pd.MultiIndex.from_product([selected_buckets, all_times], names=['影片时长类型', '时间点']).to_frame(index=False)
+    plot_df = pd.merge(
+        full_grid,
+        avg_efficiency[avg_efficiency['影片时长类型'].isin(selected_buckets)][['影片时长类型', '时间点', '座次效率', '场次效率']],
+        on=['影片时长类型', '时间点'],
+        how='left'
+    ).fillna(0)
+    plot_df = pd.merge(plot_df, bucket_stats[['影片时长类型', '影片时长档位']], on='影片时长类型', how='left')
+    plot_df = plot_df.sort_values(['影片时长档位', '时间点']).reset_index(drop=True)
+
+    chart = alt.Chart(plot_df).mark_line(point=True).encode(
+        x=alt.X('时间点:N', title='时间点', sort=all_times, axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y(f'{metric}:Q', title=metric),
+        color=alt.Color('影片时长类型:N', title='影片时长类型'),
+        tooltip=[alt.Tooltip('影片时长类型:N', title='影片时长类型'),
+                 alt.Tooltip('时间点:N', title='时间点'),
+                 alt.Tooltip(f'{metric}:Q', title=metric, format='.2f')]
+    ).properties(title=f'不同影片时长类型各时间点 {metric}（对比全部影片）').interactive()
+    st.altair_chart(chart, width="stretch")
+
+
+def plot_daily_timeslot_box_office(df, selected_movie='全部影片'):
+    if df.empty:
+        return None
+    plot_df = df[df['影片名称_清理后'] == selected_movie].copy() if selected_movie != '全部影片' else df.copy()
+    if plot_df.empty:
+        return None
+    plot_df['时间点'] = plot_df['放映时间'].apply(
+        lambda t: round_time_to_5min(datetime.datetime.combine(datetime.date.today(), t)))
+    time_revenue = plot_df.groupby('时间点').agg(票房=('总收入', 'sum'), 场次=('影片名称_清理后', 'size')).reset_index()
+    full_time_range = pd.to_datetime(pd.date_range("09:30", "23:55", freq="5min")).time
+    full_time_df = pd.DataFrame({'时间点': full_time_range})
+    merged_df = pd.merge(full_time_df, time_revenue, on='时间点', how='left')
+    merged_df['场均票房'] = (merged_df['票房'] / merged_df['场次']).fillna(0)
+
+    def apply_conditions_avg(row):
+        if pd.isna(row['场次']):
+            return -1
+        return row['场均票房']
+
+    merged_df['展示值'] = merged_df.apply(apply_conditions_avg, axis=1)
+    merged_df['时间点_str'] = merged_df['时间点'].apply(lambda t: t.strftime('%H:%M'))
+    merged_df[['票房', '场次']] = merged_df[['票房', '场次']].fillna(0)
+    chart_title = f'影城每日时间段场均票房表现 - {selected_movie}'
+    chart = alt.Chart(merged_df).mark_bar().encode(
+        x=alt.X('时间点_str:N', title='时间点', sort=None, axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y('展示值:Q', title='场均票房 (元)', scale=alt.Scale(domainMin=0)),
+        tooltip=[alt.Tooltip('时间点_str:N', title='时间点'),
+                 alt.Tooltip('场均票房:Q', format=',.2f', title='场均票房'),
+                 alt.Tooltip('票房:Q', format=',.2f', title='总票房'),
+                 alt.Tooltip('场次:Q', format='.0f', title='总场次')]
+    ).properties(title=chart_title).interactive()
+    return chart
+
+
+def plot_time_efficiency_analysis(df):
+    if df.empty:
+        return
+    df_filtered = df[(df['放映时间'] >= datetime.time(9, 30)) & (df['放映时间'] <= datetime.time(23, 59))].copy()
+    if df_filtered.empty:
+        st.warning("在 9:30 - 23:59 时间段内没有找到场次数据。")
+        return
+    df_filtered['时间点'] = df_filtered['放映时间'].apply(
+        lambda t: round_time_to_5min(datetime.datetime.combine(datetime.date.today(), t)))
+    total_revenue_full_day = df['总收入'].sum()
+    total_seats_full_day = df['座位数'].sum()
+    total_sessions_full_day = df['场次'].sum()
+    if total_revenue_full_day == 0 or total_seats_full_day == 0 or total_sessions_full_day == 0:
+        st.warning("总收入、总座位数或总场次数为零，无法计算效率。")
+        return
+    time_analysis = df_filtered.groupby(['放映日期', '时间点']).agg(座位数=('座位数', 'sum'),
+                                                                    场次=('影片名称_清理后', 'size'),
+                                                                    票房=('总收入', 'sum')).reset_index()
+    time_analysis['票房比'] = time_analysis['票房'] / total_revenue_full_day
+    time_analysis['座次比'] = time_analysis['座位数'] / total_seats_full_day
+    time_analysis['场次比'] = time_analysis['场次'] / total_sessions_full_day
+    time_analysis['座次效率'] = (time_analysis['票房比'] / time_analysis['座次比']).fillna(0)
+    time_analysis['场次效率'] = (time_analysis['票房比'] / time_analysis['场次比']).fillna(0)
+    avg_time_efficiency = time_analysis.groupby('时间点')[['座次效率', '场次效率']].mean().reset_index()
+    avg_time_efficiency['时间点'] = avg_time_efficiency['时间点'].apply(lambda t: t.strftime('%H:%M'))
+    source = avg_time_efficiency.melt(id_vars=['时间点'], value_vars=['座次效率', '场次效率'], var_name='效率类型',
+                                      value_name='效率值')
+    chart = alt.Chart(source).mark_bar().encode(
+        x=alt.X('时间点:N', title='时间点', sort=None, axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y('效率值:Q', title='平均效率'), color=alt.Color('效率类型:N', title='效率类型'), xOffset='效率类型:N',
+        tooltip=[alt.Tooltip('时间点:N', title='时间点'), alt.Tooltip('效率类型:N', title='效率类型'),
+                 alt.Tooltip('效率值:Q', title='平均效率', format='.2f')]
+    ).properties(title='每日时间点平均效率分析 (9:30-23:59)').interactive()
+    st.altair_chart(chart, width="stretch")
+
+
+def plot_movie_time_efficiency_analysis(df, selected_movie):
+    if df.empty:
+        return
+    if selected_movie == '全部影片':
+        st.info("请选择一部具体的影片进行分析。")
+        return
+    df_movie = df[df['影片名称_清理后'] == selected_movie].copy()
+    df_movie = df_movie[
+        (df_movie['放映时间'] >= datetime.time(9, 30)) & (df_movie['放映时间'] <= datetime.time(23, 59))]
+    if df_movie.empty:
+        st.warning(f"在 9:30 - 23:59 时间段内没有找到影片《{selected_movie}》的场次数据。")
+        return
+    df_movie['时间点'] = df_movie['放映时间'].apply(
+        lambda t: round_time_to_5min(datetime.datetime.combine(datetime.date.today(), t)))
+    daily_totals = df.groupby('放映日期').agg(总票房=('总收入', 'sum'), 总座位数=('座位数', 'sum'),
+                                              总场次数=('场次', 'sum')).reset_index()
+    if daily_totals.empty:
+        return
+    df_movie = pd.merge(df_movie, daily_totals, on='放映日期')
+    df_movie = df_movie[(df_movie['总票房'] > 0) & (df_movie['总座位数'] > 0) & (df_movie['总场次数'] > 0)]
+    df_movie['票房比'] = df_movie['总收入'] / df_movie['总票房']
+    df_movie['座次比'] = df_movie['座位数'] / df_movie['总座位数']
+    df_movie['场次比'] = 1 / df_movie['总场次数']
+    df_movie['座次效率'] = (df_movie['票房比'] / df_movie['座次比']).fillna(0)
+    df_movie['场次效率'] = (df_movie['票房比'] / df_movie['场次比']).fillna(0)
+    avg_movie_time_efficiency = df_movie.groupby('时间点')[['座次效率', '场次效率']].mean().reset_index()
+    avg_movie_time_efficiency['时间点'] = avg_movie_time_efficiency['时间点'].apply(lambda t: t.strftime('%H:%M'))
+    all_times = pd.DataFrame(
+        {'时间点': [t.strftime('%H:%M') for t in pd.to_datetime(pd.date_range("09:30", "23:55", freq="5min")).time]})
+    avg_movie_time_efficiency = pd.merge(all_times, avg_movie_time_efficiency, on='时间点', how='left').fillna(0)
+    avg_movie_time_efficiency['标注'] = np.where(
+        (avg_movie_time_efficiency['座次效率'] == 0) & (avg_movie_time_efficiency['场次效率'] == 0), '此时间点无排片',
+        '有排片')
+    source = avg_movie_time_efficiency.melt(id_vars=['时间点', '标注'], value_vars=['座次效率', '场次效率'],
+                                            var_name='效率类型', value_name='效率值')
+    chart = alt.Chart(source).mark_bar().encode(
+        x=alt.X('时间点:N', title='时间点', sort=None, axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y('效率值:Q', title='平均效率'), color=alt.Color('效率类型:N', title='效率类型'), xOffset='效率类型:N',
+        tooltip=[alt.Tooltip('时间点:N', title='时间点'), alt.Tooltip('效率类型:N', title='效率类型'),
+                 alt.Tooltip('效率值:Q', title='平均效率', format='.2f'), alt.Tooltip('标注:N', title='备注')]
+    ).properties(title=f'影片《{selected_movie}》各时间点平均效率分析').interactive()
+    st.altair_chart(chart, width="stretch")
+
+
+def plot_segmented_time_efficiency(df):
+    if df.empty:
+        return
+    st.markdown("##### 每日时间效率分析 (分时间段)")
+    st.write("按指定的时间间隔（分钟）分割 09:30-23:59 时段，计算每个时间段内所有影片作为一个整体的座次效率和场次效率。")
+    interval = st.number_input("选择时间间隔 (分钟):", min_value=5, max_value=120, value=30, step=5,
+                               key='auto_segment_interval')
+    df_filtered = df[(df['放映时间'] >= datetime.time(9, 30)) & (df['放映时间'] <= datetime.time(23, 59))].copy()
+    if df_filtered.empty:
+        return
+    total_revenue_full_day = df['总收入'].sum()
+    total_seats_full_day = df['座位数'].sum()
+    total_sessions_full_day = df['场次'].sum()
+    if total_revenue_full_day == 0 or total_seats_full_day == 0 or total_sessions_full_day == 0:
+        return
+    df_filtered['minutes_from_midnight'] = df_filtered['放映时间'].apply(lambda t: t.hour * 60 + t.minute)
+    start_minute = 9 * 60 + 30
+    end_minute = 24 * 60
+    bins = list(range(start_minute, end_minute, interval))
+    if end_minute not in bins:
+        bins.append(end_minute)
+
+    def to_hm_str(minutes):
+        return (datetime.datetime.min + datetime.timedelta(minutes=minutes)).strftime('%H:%M')
+
+    labels = [f"{to_hm_str(bins[i])} - {to_hm_str(bins[i + 1])}" for i in range(len(bins) - 1)]
+    df_filtered['时间段'] = pd.cut(df_filtered['minutes_from_midnight'], bins=bins, labels=labels, right=False,
+                                   include_lowest=True)
+    segment_analysis = df_filtered.groupby('时间段', observed=True).agg(区间票房=('总收入', 'sum'),
+                                                                        区间座位数=('座位数', 'sum'),
+                                                                        区间场次=('场次', 'sum')).reset_index()
+
+    segment_analysis['时间段'] = segment_analysis['时间段'].astype(str)
+
+    segment_analysis['票房比'] = segment_analysis['区间票房'] / total_revenue_full_day
+    segment_analysis['座次比'] = segment_analysis['区间座位数'] / total_seats_full_day
+    segment_analysis['场次比'] = segment_analysis['区间场次'] / total_sessions_full_day
+    segment_analysis['座次效率'] = (segment_analysis['票房比'] / segment_analysis['座次比']).fillna(0).replace(
+        [np.inf, -np.inf], 0)
+    segment_analysis['场次效率'] = (segment_analysis['票房比'] / segment_analysis['场次比']).fillna(0).replace(
+        [np.inf, -np.inf], 0)
+    source = segment_analysis.melt(id_vars=['时间段'], value_vars=['座次效率', '场次效率'], var_name='效率类型',
+                                   value_name='效率值')
+    chart = alt.Chart(source).mark_bar().encode(
+        x=alt.X('时间段:N', title='时间段', sort=None, axis=alt.Axis(labelAngle=-45)),
+        y=alt.Y('效率值:Q', title='效率值'), color=alt.Color('效率类型:N', title='效率类型'), xOffset='效率类型:N',
+        tooltip=[alt.Tooltip('时间段:N', title='时间段'), alt.Tooltip('效率类型:N', title='效率类型'),
+                 alt.Tooltip('效率值:Q', title='效率值', format='.2f')]
+    ).properties(title=f'每日时间效率分析 (每 {interval} 分钟)').interactive()
+    st.altair_chart(chart, width="stretch")
+
+
+def plot_movie_efficiency_in_window(df):
+    if df.empty:
+        return
+    st.markdown("##### 单片时间效率分析 (分时间段)")
+    st.write("选择一个中心时间点和一个前后时长，分析在该时间窗口内各影片的相对效率。")
+    col1, col2 = st.columns(2)
+    with col1:
+        center_time = st.time_input("选择中心时间点:", value=datetime.time(19, 30), step=datetime.timedelta(minutes=5),
+                                    key='auto_window_center_time')
+    with col2:
+        duration = st.number_input("选择前后时长 (分钟):", min_value=5, value=20, step=5, key='auto_window_duration')
+    center_dt = datetime.datetime.combine(datetime.date.today(), center_time)
+    start_dt = center_dt - datetime.timedelta(minutes=duration)
+    end_dt = center_dt + datetime.timedelta(minutes=duration)
+    start_time = start_dt.time()
+    end_time = end_dt.time()
+    st.info(f"分析时间窗口: {start_time.strftime('%H:%M')} - {end_time.strftime('%H:%M')}")
+    df_window = df[df['放映时间'].between(start_time, end_time)].copy() if start_time <= end_time else df[
+        (df['放映时间'] >= start_time) | (df['放映时间'] <= end_time)].copy()
+    if df_window.empty:
+        st.warning("所选时间窗口内没有场次数据。")
+        return
+    total_revenue_w = df_window['总收入'].sum()
+    total_seats_w = df_window['座位数'].sum()
+    total_sessions_w = df_window['场次'].sum()
+    if total_revenue_w == 0 or total_seats_w == 0 or total_sessions_w == 0:
+        st.warning("所选时间窗口内总票房、总座位数或总场次数为零，无法计算效率。")
+        return
+    movie_analysis = df_window.groupby('影片名称_清理后').agg(票房=('总收入', 'sum'), 座位数=('座位数', 'sum'),
+                                                              场次=('场次', 'sum')).reset_index()
+    movie_analysis.rename(columns={'影片名称_清理后': '影片'}, inplace=True)
+    movie_analysis['票房比'] = movie_analysis['票房'] / total_revenue_w
+    movie_analysis['座次比'] = movie_analysis['座位数'] / total_seats_w
+    movie_analysis['场次比'] = movie_analysis['场次'] / total_sessions_w
+    movie_analysis['座次效率'] = (movie_analysis['票房比'] / movie_analysis['座次比']).fillna(0).replace(
+        [np.inf, -np.inf], 0)
+    movie_analysis['场次效率'] = (movie_analysis['票房比'] / movie_analysis['场次比']).fillna(0).replace(
+        [np.inf, -np.inf], 0)
+    movie_analysis = movie_analysis.sort_values(by='座次效率', ascending=False).reset_index(drop=True)
+    source = movie_analysis.melt(id_vars=['影片'], value_vars=['座次效率', '场次效率'], var_name='效率类型',
+                                 value_name='效率值')
+    chart = alt.Chart(source).mark_bar().encode(
+        x=alt.X('效率值:Q', title='效率值'), y=alt.Y('影片:N', title='影片', sort='-x'),
+        color=alt.Color('效率类型:N', title='效率类型'),
+        tooltip=[alt.Tooltip('影片:N', title='影片'), alt.Tooltip('效率类型:N', title='效率类型'),
+                 alt.Tooltip('效率值:Q', title='效率值', format='.2f')]
+    ).properties(title=f'窗口 {start_time.strftime("%H:%M")}-{end_time.strftime("%H:%M")} 内单片效率对比').interactive()
+    st.altair_chart(chart, width="stretch")
+    st.dataframe(movie_analysis.style.format(
+        {'票房': '{:,.2f}', '座位数': '{:,.0f}', '场次': '{:,.0f}', '票房比': '{:.2%}', '座次比': '{:.2%}',
+         '场次比': '{:.2%}', '座次效率': '{:.2f}', '场次效率': '{:.2f}'}), width="stretch", hide_index=True)
+
+
+def get_duration_source_df_cached(filtered_df, cache_key):
+    """
+    根据筛选后的场次数据计算影片时长档位汇总表，并按 cache_key 缓存到 session_state。
+    cache_key 通常由 (start_date, end_date, weekday_filter, time_filter, master_len) 组成。
+    """
+    cache = st.session_state.get('auto_duration_cache')
+    if cache and cache.get('key') == cache_key:
+        return cache['df']
+    duration_df = build_duration_reference_from_history(filtered_df)
+    st.session_state.auto_duration_cache = {'key': cache_key, 'df': duration_df}
+    return duration_df
+
+
+def render_duration_tab(filtered_df, cache_key, plot_func, button_key):
+    """通用渲染：按需触发时长档位计算，结果按 cache_key 缓存。"""
+    cache = st.session_state.get('auto_duration_cache') or {}
+    cached_df = cache.get('df') if cache.get('key') == cache_key else None
+
+    if cached_df is None:
+        st.info("影片时长档位需要按当前日期范围 / 过滤条件计算。点击下方按钮开始分析。")
+        if st.button("开始计算影片时长效率", key=button_key, type="primary"):
+            with st.spinner("正在统计影片时长档位……"):
+                cached_df = get_duration_source_df_cached(filtered_df, cache_key)
+            st.rerun()
+        return
+
+    if cached_df.empty:
+        st.warning("当前筛选条件下没有可用的影片时长数据。")
+        return
+
+    plot_func(filtered_df.copy(), cached_df.copy())
+
+
+# --- Streamlit Main UI ---
+st.title('🧐 影片效率分析')
+
+# 初始化数据加载（只加载一次，除非用户主动刷新）
+if 'auto_master_df' not in st.session_state:
+    df_loaded, source, message = auto_load_history_dataset(force_r2_sync=False)
+    st.session_state.auto_master_df = df_loaded
+    st.session_state.auto_data_source = source
+    st.session_state.auto_data_message = message
+
+with st.expander("数据状态与同步", expanded=True):
+    st.caption("本页历史场次数据自动从本地缓存读取，必要时会从 R2 拉取并合并，无需手动上传 Excel。")
+    source_label_map = {
+        "local": "本地缓存",
+        "r2": "R2 远程",
+        "local+r2": "本地 + R2 合并",
+        "empty": "暂无数据",
+    }
+    info_cols = st.columns([2, 2, 1])
+    with info_cols[0]:
+        st.metric("数据来源", source_label_map.get(st.session_state.auto_data_source, "未知"))
+    with info_cols[1]:
+        st.metric("当前记录数", f"{len(st.session_state.auto_master_df):,}")
+    with info_cols[2]:
+        if st.button("从 R2 重新同步", help="忽略本地缓存，强制从 R2 下载并合并", key="auto_refresh_from_r2"):
+            with st.spinner("正在从 R2 下载并合并历史数据……"):
+                df_loaded, source, message = auto_load_history_dataset(force_r2_sync=True)
+            st.session_state.auto_master_df = df_loaded
+            st.session_state.auto_data_source = source
+            st.session_state.auto_data_message = message
+            # 数据更新后清掉旧的时长缓存，下次打开时长 tab 会按新数据重算
+            st.session_state.pop('auto_duration_cache', None)
+            st.success(message)
+            st.rerun()
+
+    st.caption(st.session_state.auto_data_message)
+
+    # 数据库覆盖范围概览
+    if not st.session_state.auto_master_df.empty:
+        date_min = st.session_state.auto_master_df['放映日期'].min()
+        date_max = st.session_state.auto_master_df['放映日期'].max()
+        date_min_text = date_min.strftime('%Y-%m-%d') if pd.notna(date_min) else '--'
+        date_max_text = date_max.strftime('%Y-%m-%d') if pd.notna(date_max) else '--'
+        st.caption(f"覆盖日期：{date_min_text} 至 {date_max_text}")
+
+    # 影片时长数据按需计算：仅在打开时长 tab 时才会调用 build_duration_reference_from_history
+
+if not st.session_state.auto_master_df.empty:
+    st.divider()
+    st.header("数据分析区")
+    min_date = st.session_state.auto_master_df['放映日期'].min().date()
+    max_date = st.session_state.auto_master_df['放映日期'].max().date()
+    default_start = max(min_date, max_date - datetime.timedelta(days=6))
+    selected_date_range = st.date_input("请选择要分析的日期范围:", value=(default_start, max_date),
+                                        min_value=min_date, max_value=max_date,
+                                        key='auto_date_range_selector')
+    if len(selected_date_range) == 2:
+        start_date, end_date = selected_date_range
+        mask = (st.session_state.auto_master_df['放映日期'].dt.date >= start_date) & (
+                st.session_state.auto_master_df['放映日期'].dt.date <= end_date)
+        df = st.session_state.auto_master_df[mask].copy()
+
+        # 时间过滤器
+        filter_invalid_times = st.checkbox("过滤掉 9:45 前和 23:35 后的无效场次", value=True,
+                                           key='auto_filter_invalid_times')
+        if filter_invalid_times:
+            original_rows = len(df)
+            df = df[df['放映时间'].between(datetime.time(9, 45), datetime.time(23, 35))]
+            filtered_rows = len(df)
+            st.info(
+                f"已应用时间过滤器 (09:45 - 23:35)。所选日期范围内场次数从 {original_rows} 减少到 {filtered_rows}。")
+
+        # --- 星期过滤器 ---
+        st.markdown("---")
+        weekdays_chinese = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
+        weekday_map = {"星期一": 0, "星期二": 1, "星期三": 2, "星期四": 3,
+                       "星期五": 4, "星期六": 5, "星期日": 6}
+
+        selected_weekdays = st.multiselect(
+            "请选择要分析的星期:",
+            options=weekdays_chinese,
+            default=weekdays_chinese,
+            key='auto_weekday_selector'
+        )
+
+        if selected_weekdays:
+            selected_weekday_numbers = [weekday_map[day] for day in selected_weekdays]
+            original_rows_before_weekday_filter = len(df)
+            df = df[df['放映日期'].dt.dayofweek.isin(selected_weekday_numbers)]
+            filtered_rows_after_weekday_filter = len(df)
+            if len(selected_weekdays) < 7:
+                st.info(
+                    f"已应用星期过滤器。场次数从 {original_rows_before_weekday_filter} "
+                    f"减少到 {filtered_rows_after_weekday_filter}。")
+        else:
+            df = pd.DataFrame(columns=df.columns)
+            st.warning("您没有选择任何星期，因此没有数据可供分析。")
+
+        if df.empty:
+            st.warning("在您选择的日期范围和过滤条件下，没有找到任何数据。请尝试调整日期或过滤选项。")
+        else:
+            st.toast("数据已根据所选日期和星期范围更新！", icon="📅")
+            render_analysis_overview(df, start_date, end_date)
+            format_config = {'座位数': '{:,.0f}', '场次': '{:,.0f}', '人次': '{:,.0f}', '票房': '{:,.2f}',
+                             '均价': '{:.2f}', '座次比': '{:.2%}', '场次比': '{:.2%}', '票房比': '{:.2%}',
+                             '座次效率': '{:.2f}', '场次效率': '{:.2f}'}
+            full_day_analysis = process_and_analyze_data(df.copy())
+            prime_time_analysis = process_and_analyze_data(
+                df[df['放映时间'].between(datetime.time(14, 0), datetime.time(21, 0))].copy())
+            st.markdown("### 全天排片效率分析")
+            if not full_day_analysis.empty:
+                st.dataframe(full_day_analysis.style.format(format_config),
+                             width="stretch", hide_index=True)
+            st.markdown("#### 黄金时段排片效率分析 (14:00-21:00)")
+            if not prime_time_analysis.empty:
+                st.dataframe(prime_time_analysis.style.format(format_config),
+                             width="stretch", hide_index=True)
+            with st.expander("影城每日票房表现", expanded=True):
+                movie_options = ['全部影片'] + full_day_analysis['影片'].unique().tolist()
+                selected_movie_for_chart = st.selectbox(
+                    '选择影片查看其每日票房（默认为影城全部）', options=movie_options,
+                    key='auto_daily_box_office_selector'
+                )
+                daily_chart = plot_daily_box_office(df.copy(), selected_movie_for_chart)
+                if daily_chart:
+                    st.altair_chart(daily_chart, width="stretch")
+                timeslot_chart = plot_daily_timeslot_box_office(df.copy(), selected_movie_for_chart)
+                if timeslot_chart:
+                    st.altair_chart(timeslot_chart, width="stretch")
+            with st.expander("每日时间效率分析", expanded=False):
+                tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
+                    "每日时间效率分析",
+                    "单片时间效率分析",
+                    "每日时间效率分析（分时间段）",
+                    "单片时间效率分析（分时间段）",
+                    "影片时长效率分析（同档对比）",
+                    "影片时长效率分析（全市场对比）"
+                ])
+                with tab1:
+                    plot_time_efficiency_analysis(df.copy())
+                with tab2:
+                    movie_options_for_time = ['全部影片'] + full_day_analysis['影片'].unique().tolist()
+                    default_index = 0
+                    if not full_day_analysis.empty:
+                        top_movie = full_day_analysis['影片'].iloc[0]
+                        if top_movie in movie_options_for_time:
+                            default_index = movie_options_for_time.index(top_movie)
+                    selected_movie_for_time_chart = st.selectbox(
+                        '选择影片进行分析', options=movie_options_for_time,
+                        key='auto_movie_time_efficiency_selector', index=default_index
+                    )
+                    plot_movie_time_efficiency_analysis(df.copy(), selected_movie_for_time_chart)
+                with tab3:
+                    plot_segmented_time_efficiency(df.copy())
+                with tab4:
+                    plot_movie_efficiency_in_window(df.copy())
+
+                duration_cache_key = (
+                    start_date.isoformat(),
+                    end_date.isoformat(),
+                    tuple(sorted(selected_weekdays)),
+                    bool(filter_invalid_times),
+                    int(len(df)),
+                )
+                with tab5:
+                    render_duration_tab(
+                        df,
+                        duration_cache_key,
+                        plot_duration_bucket_same_type_efficiency,
+                        button_key='auto_duration_compute_same',
+                    )
+                with tab6:
+                    render_duration_tab(
+                        df,
+                        duration_cache_key,
+                        plot_duration_bucket_market_efficiency,
+                        button_key='auto_duration_compute_market',
+                    )
+    else:
+        st.info("请选择一个有效的日期范围以开始分析。")
+else:
+    st.info("当前历史库为空，请先在 “历史场次自动同步监控” 页执行同步，或点击上方 “从 R2 重新同步” 拉取数据。")

pages/🧰 工具大全.py

@@ -0,0 +1,87 @@
+"""工具大全 - 汇总常用外部小工具与油猴脚本链接。
+
+本页面通过 Streamlit 多页面机制自动出现在侧边栏导航中，
+点击任一卡片按钮会在新的浏览器标签页打开对应的外部网址。
+"""
+
+import streamlit as st
+
+
+st.set_page_config(page_title="工具大全", page_icon="🧰", layout="wide")
+
+
+# --- 链接数据 ---
+EXTERNAL_TOOLS = [
+    {
+        "name": "外卖订单价格计算工具",
+        "url": "https://ethscriptions-waimai.static.hf.space",
+        "icon": "🍱",
+        "desc": "快速计算外卖订单的实际单价/分摊价格，便于对账与员工餐统计。",
+    },
+    {
+        "name": "水印批量添加助手",
+        "url": "https://ethscriptions-shuiyin.static.hf.space",
+        "icon": "💧",
+        "desc": "批量给图片添加自定义文字/图片水印，适合宣传素材整理。",
+    },
+]
+
+USERSCRIPTS = [
+    {
+        "name": "查询排程时自动填写影城名字",
+        "url": "https://openuserjs.org/scripts/pzt/%E6%9F%A5%E8%AF%A2%E6%8E%92%E7%A8%8B%E6%97%B6%E8%87%AA%E5%8A%A8%E5%A1%AB%E5%86%99%E5%BD%B1%E5%9F%8E%E5%90%8D%E5%AD%97",
+        "icon": "🎬",
+        "desc": "在排程查询页面自动填入影城名字，省去重复输入。",
+    },
+    {
+        "name": "KDM 批量下载助手",
+        "url": "https://openuserjs.org/scripts/pzt/KDM_%E6%89%B9%E9%87%8F%E4%B8%8B%E8%BD%BD%E5%8A%A9%E6%89%8B",
+        "icon": "🔑",
+        "desc": "一键批量下载 KDM 密钥文件，无需逐个点击。",
+    },
+    {
+        "name": "TMS 服务器影片内容查询助手",
+        "url": "https://openuserjs.org/scripts/pzt/TMS_%E6%9C%8D%E5%8A%A1%E5%99%A8%E5%BD%B1%E7%89%87%E5%86%85%E5%AE%B9%E6%9F%A5%E8%AF%A2%E5%8A%A9%E6%89%8B",
+        "icon": "🗄️",
+        "desc": "在 TMS 后台快速查询服务器上的影片内容，方便核对文件状态。",
+    },
+]
+
+
+def render_link_cards(items, columns_per_row=2):
+    """以网格卡片形式渲染链接条目。"""
+    for row_start in range(0, len(items), columns_per_row):
+        row_items = items[row_start:row_start + columns_per_row]
+        cols = st.columns(columns_per_row)
+        for col, item in zip(cols, row_items):
+            with col:
+                with st.container(border=True):
+                    st.markdown(f"#### {item['icon']} {item['name']}")
+                    st.caption(item["desc"])
+                    st.link_button(
+                        "🔗 打开",
+                        item["url"],
+                        use_container_width=True,
+                    )
+                    st.caption(f"<small>{item['url']}</small>", unsafe_allow_html=True)
+
+
+# --- 页面主体 ---
+st.title("🧰 工具大全")
+st.write("汇总日常工作中常用的外部小工具与浏览器脚本，点击卡片即可在新标签页打开。")
+
+st.divider()
+
+st.subheader("🔗 外部小工具")
+st.caption("基于网页的在线工具，打开即用，无需安装。")
+render_link_cards(EXTERNAL_TOOLS)
+
+st.subheader("🐒 油猴脚本（Userscript）")
+st.caption(
+    "以下脚本需先在浏览器安装 "
+    "[Tampermonkey](https://www.tampermonkey.net/) 或 "
+    "[Violentmonkey](https://violentmonkey.github.io/) 扩展，"
+    "然后点击「打开」进入脚本页面，再点击页面上的 *Install* 完成安装。"
+)
+render_link_cards(USERSCRIPTS)
+

print_settings.json

@@ -0,0 +1,13 @@
+{
+    "led_font": "思源黑体-常规 (推荐 LED 屏)",
+    "png_led": false,
+    "led_start_cutoff_time": "17:00",
+    "led_end_cutoff_time": "01:00",
+    "times_font": "思源黑体-粗体 (推荐散场表)",
+    "font_size_multiplier": 1.2,
+    "split_time": "17:00",
+    "time_adjustment": 0,
+    "times_end_cutoff_time": "01:00",
+    "hall_display_format": "Default",
+    "png_times": false
+}

r2_config_sync.py

@@ -0,0 +1,140 @@
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from r2_storage import R2Storage
+
+
+ROOT_DIR = Path(__file__).resolve().parent
+
+
+def build_settings_prefix() -> str:
+    cinema_id = (os.getenv("CINEMA_ID") or "").strip() or "default"
+    return f"{cinema_id}/app_settings"
+
+
+def build_settings_key(file_name: str) -> str:
+    return f"{build_settings_prefix().rstrip('/')}/{str(file_name).lstrip('/')}"
+
+
+def get_local_settings_path(file_name: str | Path) -> Path:
+    path = Path(file_name)
+    if path.is_absolute():
+        return path
+    return ROOT_DIR / path
+
+
+def get_local_settings_mtime(file_name: str | Path) -> Optional[float]:
+    try:
+        return get_local_settings_path(file_name).stat().st_mtime
+    except OSError:
+        return None
+
+
+def get_r2_storage_or_none() -> Optional[R2Storage]:
+    try:
+        return R2Storage()
+    except Exception:
+        return None
+
+
+def upload_settings_file_to_r2(file_name: str | Path) -> bool:
+    storage = get_r2_storage_or_none()
+    if storage is None:
+        return False
+
+    local_path = get_local_settings_path(file_name)
+    if not local_path.exists():
+        return False
+
+    try:
+        storage.upload_file(local_path, build_settings_key(local_path.name), content_type="application/json")
+        return True
+    except Exception:
+        return False
+
+
+def ensure_settings_file_from_r2(file_name: str | Path, force_download: bool = False) -> bool:
+    storage = get_r2_storage_or_none()
+    if storage is None:
+        return False
+
+    local_path = get_local_settings_path(file_name)
+    key = build_settings_key(local_path.name)
+
+    try:
+        remote_exists = storage.exists(key)
+    except Exception:
+        return False
+
+    if not remote_exists:
+        return False
+
+    if local_path.exists() and not force_download:
+        return False
+
+    try:
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        storage.download_file(key, local_path)
+        return True
+    except Exception:
+        return False
+
+
+def ensure_settings_file_synced(file_name: str | Path) -> str:
+    """本地优先：只有本地缺失时才尝试从 R2 恢复。"""
+    local_path = get_local_settings_path(file_name)
+    if local_path.exists():
+        return "local_exists"
+
+    storage = get_r2_storage_or_none()
+    if storage is None:
+        return "r2_unavailable"
+
+    key = build_settings_key(local_path.name)
+
+    try:
+        remote_exists = storage.exists(key)
+    except Exception:
+        return "r2_check_failed"
+
+    if remote_exists:
+        try:
+            local_path.parent.mkdir(parents=True, exist_ok=True)
+            storage.download_file(key, local_path)
+            return "downloaded"
+        except Exception:
+            return "download_failed"
+
+    return "missing_both"
+
+
+def write_json_file(file_name: str | Path, payload: dict) -> Path:
+    local_path = get_local_settings_path(file_name)
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+
+    temp_path = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=local_path.parent,
+            prefix=f".{local_path.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as temp_file:
+            json.dump(payload, temp_file, ensure_ascii=False, indent=4)
+            temp_file.write("\n")
+            temp_path = Path(temp_file.name)
+        temp_path.replace(local_path)
+    except Exception:
+        if temp_path is not None:
+            try:
+                temp_path.unlink(missing_ok=True)
+            except Exception:
+                pass
+        raise
+
+    return local_path

r2_storage.py

@@ -0,0 +1,178 @@
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple
+from urllib.parse import urlparse, urlunparse
+
+
+def _split_endpoint_bucket(endpoint: str) -> Tuple[str, str, str]:
+    parsed = urlparse(endpoint)
+    if not parsed.scheme or not parsed.netloc:
+        return endpoint, "", ""
+
+    path = (parsed.path or "").strip("/")
+    if not path:
+        return urlunparse((parsed.scheme, parsed.netloc, "", "", "", "")), "", ""
+
+    parts = [part for part in path.split("/") if part]
+    bucket = parts[0] if parts else ""
+    base_prefix = "/".join(parts[1:]) if len(parts) > 1 else ""
+    base_endpoint = urlunparse((parsed.scheme, parsed.netloc, "", "", "", ""))
+    return base_endpoint, bucket, base_prefix
+
+
+def _join_key(prefix: str, key: str) -> str:
+    prefix = (prefix or "").strip("/")
+    key = (key or "").lstrip("/")
+    if not prefix:
+        return key
+    if not key:
+        return prefix
+    return f"{prefix}/{key}"
+
+
+@dataclass(frozen=True)
+class R2Config:
+    endpoint_url: str
+    bucket: str
+    access_key_id: str
+    secret_access_key: str
+    base_prefix: str = ""
+
+
+class R2Storage:
+    def __init__(self, config: Optional[R2Config] = None):
+        self.config = config or self._load_config_from_env()
+        self._client = None
+
+    @staticmethod
+    def _load_config_from_env() -> R2Config:
+        endpoint_raw = (os.getenv("R2_ENDPOINT") or os.getenv("R2_Endpoint") or "").strip()
+        access_key_id = (os.getenv("R2_ACCESS_KEY_ID") or os.getenv("R2_ID") or "").strip()
+        secret_access_key = (os.getenv("R2_SECRET_ACCESS_KEY") or os.getenv("R2_API") or "").strip()
+        bucket = (os.getenv("R2_BUCKET") or "").strip()
+        base_prefix = (os.getenv("R2_PREFIX") or "").strip()
+
+        if endpoint_raw and not bucket:
+            endpoint_url, bucket_from_path, prefix_from_path = _split_endpoint_bucket(endpoint_raw)
+            bucket = bucket or bucket_from_path
+            endpoint_raw = endpoint_url
+            base_prefix = base_prefix or prefix_from_path
+
+        endpoint_url = endpoint_raw
+        if not endpoint_url or not bucket or not access_key_id or not secret_access_key:
+            missing = []
+            if not endpoint_url:
+                missing.append("R2_ENDPOINT / R2_Endpoint")
+            if not bucket:
+                missing.append("R2_BUCKET (或把 bucket 放到 R2_Endpoint 的路径里)")
+            if not access_key_id:
+                missing.append("R2_ACCESS_KEY_ID / R2_ID")
+            if not secret_access_key:
+                missing.append("R2_SECRET_ACCESS_KEY / R2_API")
+            raise ValueError(f"R2 配置缺失: {', '.join(missing)}")
+
+        if secret_access_key.startswith("cfat_"):
+            raise ValueError("R2_SECRET_ACCESS_KEY 看起来是 Cloudflare API Token（cfat_），不是 R2 的 S3 Secret Access Key。请在 Cloudflare 控制台生成 R2 的 S3 API 访问密钥并替换。")
+
+        return R2Config(
+            endpoint_url=endpoint_url,
+            bucket=bucket,
+            access_key_id=access_key_id,
+            secret_access_key=secret_access_key,
+            base_prefix=base_prefix,
+        )
+
+    def _get_client(self):
+        if self._client is not None:
+            return self._client
+
+        try:
+            import boto3
+            from botocore.client import Config
+        except Exception as exc:
+            raise RuntimeError("缺少依赖 boto3，请先安装 requirements.txt") from exc
+
+        self._client = boto3.client(
+            "s3",
+            endpoint_url=self.config.endpoint_url,
+            aws_access_key_id=self.config.access_key_id,
+            aws_secret_access_key=self.config.secret_access_key,
+            region_name="auto",
+            config=Config(signature_version="s3v4", s3={"addressing_style": "path"}),
+        )
+        return self._client
+
+    def resolve_key(self, key: str) -> str:
+        return _join_key(self.config.base_prefix, key)
+
+    def exists(self, key: str) -> bool:
+        client = self._get_client()
+        resolved_key = self.resolve_key(key)
+        try:
+            client.head_object(Bucket=self.config.bucket, Key=resolved_key)
+            return True
+        except Exception as exc:
+            try:
+                from botocore.exceptions import ClientError
+            except Exception:
+                raise
+
+            if isinstance(exc, ClientError):
+                error = (exc.response or {}).get("Error") or {}
+                code = str(error.get("Code") or "")
+                if code in {"404", "NoSuchKey", "NotFound"}:
+                    return False
+            raise
+
+    def upload_file(self, local_path: str | Path, key: str, content_type: Optional[str] = None) -> str:
+        client = self._get_client()
+        resolved_key = self.resolve_key(key)
+        path = Path(local_path)
+        if not path.exists():
+            raise FileNotFoundError(str(path))
+
+        kwargs = {}
+        if content_type:
+            kwargs["ContentType"] = content_type
+
+        with path.open("rb") as handle:
+            client.put_object(Bucket=self.config.bucket, Key=resolved_key, Body=handle, **kwargs)
+        return resolved_key
+
+    def download_file(self, key: str, local_path: str | Path) -> Path:
+        client = self._get_client()
+        resolved_key = self.resolve_key(key)
+        path = Path(local_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        response = client.get_object(Bucket=self.config.bucket, Key=resolved_key)
+        body = response.get("Body")
+        try:
+            with path.open("wb") as handle:
+                handle.write(body.read())
+        finally:
+            if body is not None:
+                try:
+                    body.close()
+                except Exception:
+                    pass
+        return path
+
+    def list_keys(self, prefix: str = "", max_keys: int = 20) -> list[str]:
+        client = self._get_client()
+        resolved_prefix = self.resolve_key(prefix) if prefix else ""
+        params = {"Bucket": self.config.bucket, "MaxKeys": int(max_keys)}
+        if resolved_prefix:
+            params["Prefix"] = resolved_prefix
+        response = client.list_objects_v2(**params)
+        contents = response.get("Contents") or []
+        return [item.get("Key", "") for item in contents if isinstance(item, dict) and item.get("Key")]
+
+    def presign_get_url(self, key: str, expires_in: int = 3600) -> str:
+        client = self._get_client()
+        resolved_key = self.resolve_key(key)
+        return client.generate_presigned_url(
+            ClientMethod="get_object",
+            Params={"Bucket": self.config.bucket, "Key": resolved_key},
+            ExpiresIn=int(expires_in),
+        )

requirements.txt

@@ -0,0 +1,15 @@
+pandas
+matplotlib
+xlrd
+pypinyin
+openpyxl
+numpy
+streamlit-autorefresh
+html2image
+Pillow
+flask
+streamlit
+python-dotenv
+boto3
+requests
+altair

schedule_api_client.py

@@ -0,0 +1,337 @@
+"""
+与 app.py 一致的票务排程 API（Token、影厅排片），供多页面复用，避免 import app 时执行整站 UI。
+"""
+import json
+import os
+import time
+
+import pandas as pd
+import requests
+from dotenv import load_dotenv
+
+
+class _NoopStreamlit:
+    @staticmethod
+    def error(*args, **kwargs):
+        return None
+
+    @staticmethod
+    def toast(*args, **kwargs):
+        return None
+
+    @staticmethod
+    def cache_data(*args, **kwargs):
+        def _decorator(func):
+            return func
+
+        return _decorator
+
+
+def _resolve_streamlit():
+    """
+    - Streamlit 页面内：保留原能力（toast/cache_data）
+    - 非 Streamlit 运行（如 Flask/FastAPI）：使用 no-op，避免无运行时警告
+    """
+    try:
+        import streamlit as _st
+        from streamlit.runtime.scriptrunner import get_script_run_ctx
+
+        if get_script_run_ctx(suppress_warning=True) is None:
+            return _NoopStreamlit()
+        return _st
+    except Exception:
+        return _NoopStreamlit()
+
+
+st = _resolve_streamlit()
+
+load_dotenv()
+
+TOKEN_FILE = "token_data.json"
+CINEMA_ID = os.getenv("CINEMA_ID")
+
+
+def load_token():
+    if os.path.exists(TOKEN_FILE):
+        try:
+            with open(TOKEN_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return None
+    return None
+
+
+def save_token(token_data):
+    try:
+        with open(TOKEN_FILE, "w", encoding="utf-8") as f:
+            json.dump(token_data, f, ensure_ascii=False, indent=4)
+        return True
+    except Exception as e:
+        st.error(f"保存Token失败: {e}")
+        return False
+
+
+def login_and_get_token():
+    username = os.getenv("CINEMA_USERNAME")
+    password = os.getenv("CINEMA_PASSWORD")
+    res_code = os.getenv("CINEMA_RES_CODE")
+    device_id = os.getenv("CINEMA_DEVICE_ID")
+
+    if not all([username, password, res_code]):
+        st.error("登录失败：未配置用户名、密码或影院编码环境变量。")
+        return None
+
+    session = requests.Session()
+    session.headers.update({
+        "Host": "app.bi.piao51.cn",
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+    })
+
+    login_url = "https://app.bi.piao51.cn/cinema-app/credential/login.action"
+    login_headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "Origin": "https://app.bi.piao51.cn",
+    }
+    login_data = {
+        "username": username,
+        "password": password,
+        "type": "1",
+        "resCode": res_code,
+        "deviceid": device_id,
+        "dtype": "ios",
+    }
+
+    try:
+        response_login = session.post(login_url, headers=login_headers, data=login_data, allow_redirects=False, timeout=15)
+        if not (300 <= response_login.status_code < 400 and "token" in session.cookies):
+            st.error(f"登录步骤 1 失败，未能获取 Session Token。状态码: {response_login.status_code}")
+            return None
+
+        user_info_url = "https://app.bi.piao51.cn/cinema-app/security/logined.action"
+        response_user_info = session.get(user_info_url, timeout=10)
+        response_user_info.raise_for_status()
+
+        user_info = response_user_info.json()
+        if user_info.get("success") and user_info.get("data", {}).get("token"):
+            token_data = user_info["data"]
+            if save_token(token_data):
+                st.toast("登录成功，已获取并保存新 Token！", icon="🔑")
+            return token_data
+        st.error(f"登录步骤 2 失败，未能从 JSON 中提取 Token。响应: {user_info.get('msg')}")
+        return None
+
+    except requests.exceptions.RequestException as e:
+        st.error(f"登录请求过程中发生网络错误: {e}")
+        return None
+
+
+def fetch_hall_info(token):
+    url = "https://cawapi.yinghezhong.com/showInfo/getShowHallInfo"
+    params = {"token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+    response = requests.get(url, params=params, headers=headers, timeout=10)
+    response.raise_for_status()
+    data = response.json()
+    if data.get("code") == 1 and data.get("data"):
+        return {item["hallId"]: item["seatNum"] for item in data["data"]}
+    raise Exception(f"获取影厅信息失败: {data.get('msg', '未知错误')}")
+
+
+def fetch_schedule_data(token, show_date):
+    url = "https://cawapi.yinghezhong.com/showInfo/getHallShowInfo"
+    params = {"showDate": show_date, "token": token, "_": int(time.time() * 1000)}
+    headers = {"Origin": "https://caw.yinghezhong.com", "User-Agent": "Mozilla/5.0"}
+    response = requests.get(url, params=params, headers=headers, timeout=15)
+    response.raise_for_status()
+    data = response.json()
+    if data.get("code") == 1:
+        return data.get("data", [])
+    if data.get("code") == 500:
+        raise ValueError("Token 可能已失效")
+    raise Exception(f"获取排片数据失败: {data.get('msg', '未知错误')}")
+
+
+def get_api_data_with_token_management(show_date):
+    token_data = load_token()
+    token = token_data.get("token") if token_data else None
+    if not token:
+        token_data = login_and_get_token()
+        if not token_data:
+            return None, None
+        token = token_data.get("token")
+
+    try:
+        schedule_list = fetch_schedule_data(token, show_date)
+        hall_seat_map = fetch_hall_info(token)
+        return schedule_list, hall_seat_map
+    except ValueError:
+        st.toast("Token 已失效，正在尝试重新登录并重试...", icon="🔄")
+        token_data = login_and_get_token()
+        if not token_data:
+            return None, None
+        token = token_data.get("token")
+        try:
+            schedule_list = fetch_schedule_data(token, show_date)
+            hall_seat_map = fetch_hall_info(token)
+            return schedule_list, hall_seat_map
+        except Exception as e:
+            st.error(f"重试获取数据失败: {e}")
+            return None, None
+    except Exception as e:
+        st.error(f"获取 API 数据时发生错误: {e}")
+        return None, None
+
+
+@st.cache_data(show_spinner=False, ttl=600)
+def fetch_canonical_movie_names(token, date_str):
+    if not CINEMA_ID:
+        return []
+    url = "https://app.bi.piao51.cn/cinema-app/mycinema/movieSellGross.action"
+    params = {
+        "token": token,
+        "startDate": date_str,
+        "endDate": date_str,
+        "dateType": "day",
+        "cinemaId": CINEMA_ID,
+    }
+    headers = {
+        "Host": "app.bi.piao51.cn",
+        "X-Requested-With": "XMLHttpRequest",
+        "jwt": "0",
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148",
+    }
+
+    try:
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        if data.get("code") == "A00000" and data.get("results"):
+            return [
+                item["movieName"]
+                for item in data["results"]
+                if item.get("movieName") and item["movieName"] != "总计"
+            ]
+    except Exception as e:
+        print(f"获取标准电影名称失败: {e}")
+    return []
+
+
+def clean_movie_title(raw_title, canonical_names=None):
+    if not isinstance(raw_title, str):
+        return raw_title
+
+    base_name = None
+
+    if canonical_names:
+        sorted_names = sorted(canonical_names, key=len, reverse=True)
+        for name in sorted_names:
+            if name in raw_title:
+                base_name = name
+                break
+
+    if not base_name:
+        base_name = raw_title.split(" ", 1)[0]
+
+    raw_upper = raw_title.upper()
+    suffix = ""
+
+    if "HDR LED" in raw_upper:
+        suffix = "（HDR LED）"
+    elif "CINITY" in raw_upper:
+        suffix = "（CINITY）"
+    elif "杜比" in raw_upper or "DOLBY" in raw_upper:
+        suffix = "（杜比视界）"
+    elif "IMAX" in raw_upper:
+        suffix = "（数字IMAX3D）" if "3D" in raw_upper else "（数字IMAX）"
+    elif "巨幕" in raw_upper:
+        suffix = "（中国巨幕立体）" if "立体" in raw_upper else "（中国巨幕）"
+    elif "3D" in raw_upper:
+        suffix = "（数字3D）"
+
+    if suffix and suffix not in base_name:
+        return f"{base_name}{suffix}"
+
+    return base_name
+
+
+def get_valid_token(force_refresh=False):
+    token_data = None if force_refresh else load_token()
+    if not token_data:
+        token_data = login_and_get_token()
+    if not token_data:
+        return None
+    return token_data.get("token")
+
+
+def fetch_schedule_api_bundle(show_date):
+    """
+    一次性获取排程相关 API 原始数据：
+    - getHallShowInfo（场次列表）
+    - getShowHallInfo（影厅座位映射）
+    - movieSellGross（标准影片名称）
+    """
+    schedule_list, hall_seat_map = get_api_data_with_token_management(show_date)
+    if schedule_list is None or hall_seat_map is None:
+        return None
+
+    token_data = load_token()
+    token = token_data.get("token") if token_data else None
+    canonical_names = fetch_canonical_movie_names(token, show_date) if token else []
+
+    return {
+        "show_date": show_date,
+        "token": token,
+        "schedule_list": schedule_list,
+        "hall_seat_map": hall_seat_map,
+        "canonical_names": canonical_names,
+    }
+
+
+def process_schedule_dataframe(schedule_list, hall_seat_map, canonical_names=None):
+    """将排程 API 原始数据整理成便于展示的表格。"""
+    if not schedule_list:
+        return pd.DataFrame()
+
+    df = pd.DataFrame(schedule_list)
+    if df.empty:
+        return pd.DataFrame()
+
+    df["座位数"] = df["hallId"].map(hall_seat_map or {}).fillna(0).astype(int)
+    df.rename(
+        columns={
+            "movieName": "影片名称",
+            "showStartTime": "放映时间",
+            "soldBoxOffice": "总收入",
+            "soldTicketNum": "总人次",
+            "hallName": "影厅名称",
+            "showEndTime": "散场时间",
+        },
+        inplace=True,
+    )
+
+    if "影片名称" in df.columns:
+        df["影片名称_清洗后"] = df["影片名称"].apply(
+            lambda x: clean_movie_title(x, canonical_names)
+        )
+
+    required_cols = [
+        "影片名称",
+        "影片名称_清洗后",
+        "放映时间",
+        "散场时间",
+        "影厅名称",
+        "座位数",
+        "总收入",
+        "总人次",
+    ]
+    for col in required_cols:
+        if col not in df.columns:
+            df[col] = None
+
+    df = df[required_cols]
+    for col in ["座位数", "总收入", "总人次"]:
+        df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0)
+
+    return df

schedule_api_data.py

@@ -0,0 +1,89 @@
+from datetime import datetime
+
+import pandas as pd
+import streamlit as st
+
+from schedule_api_client import fetch_schedule_api_bundle, process_schedule_dataframe
+
+
+st.set_page_config(layout="wide", page_title="排程 API 数据")
+st.title("🧩 排程 API 数据查看")
+st.caption("统一展示排程相关 API：场次、影厅座位、标准影片名。")
+
+col1, col2 = st.columns([2, 1])
+with col1:
+    selected_date = st.date_input("排程日期", value=datetime.now().date(), key="schedule_api_date")
+with col2:
+    st.write("")
+    st.write("")
+    fetch_btn = st.button("获取并展示", type="primary", key="schedule_api_fetch")
+
+date_str = selected_date.strftime("%Y-%m-%d")
+
+if fetch_btn:
+    with st.spinner(f"正在获取 {date_str} 的排程 API 数据..."):
+        bundle = fetch_schedule_api_bundle(date_str)
+    if not bundle:
+        st.error("获取失败，请检查 .env、网络或 token。")
+    else:
+        st.session_state["schedule_api_bundle"] = bundle
+        st.toast("排程 API 数据加载成功", icon="✅")
+
+bundle = st.session_state.get("schedule_api_bundle")
+if bundle:
+    schedule_list = bundle.get("schedule_list") or []
+    hall_seat_map = bundle.get("hall_seat_map") or {}
+    canonical_names = bundle.get("canonical_names") or []
+
+    c1, c2, c3 = st.columns(3)
+    c1.metric("场次数", len(schedule_list))
+    c2.metric("影厅数", len(hall_seat_map))
+    c3.metric("标准影片名数量", len(canonical_names))
+
+    tidy_df = process_schedule_dataframe(schedule_list, hall_seat_map, canonical_names)
+
+    tab1, tab2, tab3, tab4 = st.tabs(
+        [
+            "整理后表格",
+            "原始场次 API",
+            "影厅座位 API",
+            "标准影片名 API",
+        ]
+    )
+
+    with tab1:
+        if tidy_df.empty:
+            st.warning("暂无可展示的排程数据。")
+        else:
+            st.dataframe(tidy_df, width="stretch", height=600)
+
+    with tab2:
+        if schedule_list:
+            raw_schedule_df = pd.DataFrame(schedule_list)
+            st.dataframe(raw_schedule_df, width="stretch", height=500)
+            with st.expander("查看原始 JSON"):
+                st.json(schedule_list)
+        else:
+            st.info("API 返回空场次列表。")
+
+    with tab3:
+        if hall_seat_map:
+            hall_df = pd.DataFrame(
+                [{"hallId": k, "seatNum": v} for k, v in hall_seat_map.items()]
+            ).sort_values("hallId")
+            st.dataframe(hall_df, width="stretch", height=500)
+            with st.expander("查看原始 JSON"):
+                st.json(hall_seat_map)
+        else:
+            st.info("未获取到影厅座位数据。")
+
+    with tab4:
+        if canonical_names:
+            canonical_df = pd.DataFrame({"movieName": canonical_names})
+            st.dataframe(canonical_df, width="stretch", height=500)
+            with st.expander("查看原始 JSON"):
+                st.json(canonical_names)
+        else:
+            st.info("未获取到标准影片名数据（可能是 CINEMA_ID 未配置或接口返回为空）。")
+else:
+    st.info("请选择日期并点击「获取并展示」。")

schedule_check_settings.json

@@ -0,0 +1,78 @@
+{
+    "rule1_enabled": true,
+    "rule1_min_interval_minutes": 30,
+    "rule2_enabled": true,
+    "rule2_threshold_sessions": 4,
+    "rule2_window_minutes": 20,
+    "rule2_exempt_ranges": [
+        "14:00-16:00",
+        "19:00-21:00"
+    ],
+    "rule3_enabled": true,
+    "rule3_gap_threshold_minutes": 30,
+    "rule4_enabled": true,
+    "rule4_first_show_latest_time": "10:00",
+    "rule4_last_show_earliest_time": "22:30",
+    "rule5_enabled": true,
+    "rule5_idle_threshold_minutes": 60,
+    "rule5_window_start_time": "10:00",
+    "rule5_window_end_time": "23:00",
+    "rule6_enabled": true,
+    "rule6_min_conversion_minutes": 10,
+    "rule7_enabled": true,
+    "rule7_window_minutes": 10,
+    "rule7_step_minutes": 5,
+    "rule7_total_peak_threshold": 5,
+    "rule7_same_time_threshold": 3,
+    "rule8_enabled": true,
+    "rule8_last_end_threshold_time": "23:00",
+    "rule11_hot_top_n": 3,
+    "rule11_late_start_time": "22:00",
+    "rule9_enabled": true,
+    "rule9_hot_top_n": 3,
+    "rule9_density_min_ratio": 0.2,
+    "rule9_density_max_ratio": 0.55,
+    "rule10_enabled": true,
+    "rule11_enabled": true,
+    "rule12_enabled": true,
+    "rule12_top_n": 5,
+    "rule12_golden_start_time": "14:00",
+    "rule12_golden_end_time": "21:00",
+    "rule13_enabled": true,
+    "rule13_restricted_halls_text": "2,8,9",
+    "rule14_enabled": true,
+    "rule14_start_score_threshold": 4,
+    "rule14_end_score_threshold": 4,
+    "rule15_enabled": true,
+    "rule15_special_hall_text": "9",
+    "rule15_price_delta_yuan": 6.0,
+    "guide_enabled": true,
+    "guide_movie_session_rules": [
+        {
+            "enabled": true,
+            "movie": "续范亭将军",
+            "start_date": "2026-07-09",
+            "end_date": "2026-07-25",
+            "min_sessions": 28
+        }
+    ],
+    "guide_idle_window_rules": [
+        {
+            "enabled": true,
+            "start_date": "2026-07-01",
+            "end_date": "2026-09-01",
+            "weekdays_text": "周一,周二,周三,周四,周五,周六,周日",
+            "time_range": "09:30-12:00"
+        }
+    ],
+    "guide_required_show_rules": [
+        {
+            "enabled": true,
+            "start_date": "2026-07-01",
+            "end_date": "2026-09-01",
+            "weekdays_text": "周六,周日",
+            "time_point": "15:00",
+            "movie": ""
+        }
+    ]
+}

tms_proxy.py

@@ -0,0 +1,47 @@
+import os
+from urllib.parse import urlparse
+
+
+TMS_ORIGIN = "https://tms.hengdianfilm.com"
+TMS_PROXY_URL_ENV = "TMS_CF_WORKER_URL"
+TMS_PROXY_TOKEN_ENV = "TMS_CF_WORKER_TOKEN"
+TMS_PROXY_TOKEN_HEADER = "X-TMS-Proxy-Token"
+
+
+def get_tms_proxy_base_url(proxy_url=None):
+    raw = proxy_url if proxy_url is not None else os.getenv(TMS_PROXY_URL_ENV, "")
+    raw = str(raw or "").strip()
+    if not raw:
+        return ""
+    if "://" not in raw:
+        raw = f"https://{raw}"
+    return raw.rstrip("/")
+
+
+def build_tms_url(origin_url, proxy_url=None):
+    proxy_base_url = get_tms_proxy_base_url(proxy_url)
+    if not proxy_base_url:
+        return origin_url
+
+    parsed = urlparse(origin_url)
+    origin = f"{parsed.scheme}://{parsed.netloc}"
+    if origin != TMS_ORIGIN:
+        return origin_url
+
+    query = f"?{parsed.query}" if parsed.query else ""
+    return f"{proxy_base_url}{parsed.path}{query}"
+
+
+def with_tms_proxy_headers(headers=None, proxy_url=None):
+    headers = dict(headers or {})
+    if get_tms_proxy_base_url(proxy_url):
+        proxy_token = os.getenv(TMS_PROXY_TOKEN_ENV, "").strip()
+        if proxy_token:
+            headers[TMS_PROXY_TOKEN_HEADER] = proxy_token
+    return headers
+
+
+def tms_verify_ssl(default=False, proxy_url=None):
+    if get_tms_proxy_base_url(proxy_url):
+        return True
+    return default

waterbar_goods_settings.json

@@ -0,0 +1,41 @@
+{
+    "selected_goods": [
+        "福满百香（500ml冷）",
+        "红豆椰椰冰",
+        "粉荔知夏",
+        "粉荔知夏700ml",
+        "青羽椰椰冰",
+        "加珍珠",
+        "芭乐莓莓鲜果茶700ml",
+        "樱为有你·啵啵冰（大杯）",
+        "大红袍珍珠吨吨桶（1L）",
+        "大红袍珍珠奶茶（大杯）",
+        "樱为有你·啵啵奶（大杯）",
+        "加3Q魔芋",
+        "大杯韩式柚子茶22oz",
+        "樱为有你·啵啵茶（中杯）",
+        "福满百香（700ml）",
+        "清香茉莉500ml",
+        "樱为有你·啵啵茶（大杯）",
+        "耙耙柑茉莉冰茶（中杯）",
+        "一颗爆C柠"
+    ],
+    "selected_package_goods": [
+        "大杯柠檬可乐22oz",
+        "大杯酸甜檬太奇22oz",
+        "双人套餐C｜大杯酸甜檬太奇22oz",
+        "双人套餐C｜樱为有你·啵啵冰（大杯）",
+        "单人套餐D｜中杯柠檬可乐16oz",
+        "双人套餐C｜大杯柠檬可乐22oz",
+        "儿童乐享套餐｜中杯柠檬可乐16oz",
+        "单人套餐A｜中杯柠檬可乐16oz",
+        "单人套餐B｜大杯柠檬可乐22oz",
+        "单人套餐D｜大杯柠檬可乐22oz",
+        "双人套餐C｜耙耙柑栀香轻乳茶（大杯）",
+        "多拼家庭套餐｜大杯柠檬可乐22oz",
+        "新柠单人套餐｜大杯柠檬可乐22oz",
+        "新柠双人套餐｜大杯柠檬可乐22oz",
+        "电影美食套餐｜大杯柠檬可乐22oz",
+        "空心薯双人套餐｜大杯柠檬可乐22oz"
+    ]
+}