Update app.py

app.py

@@ -1,11 +1,10 @@
 import streamlit as st
-import pandas as pd
 import requests
 import time
 import json
 import os
 import threading
-from datetime import datetime, timedelta, time as dt_time
+from datetime import datetime, timedelta, timezone, time as dt_time
 from collections import deque
 
 # --- 1. 配置与常量 ---
@@ -17,46 +16,48 @@ CINEMA_ID = "44001291"
 # 页面配置
 st.set_page_config(page_title="影城防撤场监控系统 Pro", page_icon="🛡️", layout="wide")
 
+# --- 2. 核心时间处理 (北京时间强制转换) ---
 
-# --- 2. 辅助工具函数 ---
-
-def get_business_date():
+def get_beijing_now():
     """
-    获取当前的营业日日期。
-    规则：凌晨 06:00 之前属于前一天。
+    获取当前的北京时间，并移除时区信息（返回 Naive Datetime）。
     """
-    now = datetime.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():
+    """获取当前的营业日日期 (凌晨06:00前算前一天)"""
+    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):
-    """
-    将营业日期字符串 + 放映时间字符串 转换为 实际的时间对象。
-    处理跨天逻辑：如果营业日是 13号，但放映时间是 01:00，则实际时间是 14号 01:00。
-    """
+    """解析排片时间为北京时间对象"""
     try:
         show_t = datetime.strptime(time_str, "%H:%M").time()
         base_date = datetime.strptime(date_str, "%Y-%m-%d")
-
-        # 如果放映时间小于 06:00，说明是次日凌晨场
+        
         if show_t < dt_time(6, 0):
             base_date += timedelta(days=1)
-
+            
         return datetime.combine(base_date.date(), show_t)
     except:
         return None
 
-
 def send_pushover(title, message, priority=0):
+    """
+    发送 Pushover 通知
+    priority: 0 = 普通 (默认), 1 = 高优先级
+    """
     url = "https://api.pushover.net/1/messages.json"
     data = {
         "token": PUSHOVER_TOKEN,
         "user": PUSHOVER_USER,
         "title": title,
         "message": message,
-        "sound": "emergency" if priority == 1 else "pushover",
+        "sound": "pushover", # 统一使用默认提示音
         "priority": priority
     }
     try:
@@ -64,8 +65,7 @@ def send_pushover(title, message, priority=0):
     except:
         pass
 
-
-# --- 3. API 模块 (带重试与熔断) ---
+# --- 3. API 模块 ---
 
 class APIManager:
     def __init__(self, logger):
@@ -89,12 +89,11 @@ class APIManager:
         return None
 
     def login(self):
-        # 检查冷却时间 (10分钟 = 600秒)
         if time.time() - self.last_login_fail_time < 600:
-            self.logger("⏳ 登录处于冷却期 (上次失败于10分钟内)，跳过重试。")
+            self.logger("⏳ 登录冷却中，跳过重试。")
             return None
 
-        self.logger("🔄 正在尝试登录获取新 Token...")
+        self.logger("🔄 尝试后台自动登录...")
         session = requests.Session()
         session.headers.update({'User-Agent': 'Mozilla/5.0'})
         login_url = 'https://app.bi.piao51.cn/cinema-app/credential/login.action'
@@ -102,323 +101,235 @@ class APIManager:
             'username': 'chenhy', 'password': '123456', 'type': '1',
             'resCode': '44001291', 'deviceid': '1517bfd3f6e7fef1333', '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("✅ 登录成功，Token 已更新。")
+                self.logger("✅ 登录成功。")
                 return info['data']['token']
             else:
-                raise Exception("API返回未登录状态")
+                raise Exception("未获取到Token")
         except Exception as e:
             self.last_login_fail_time = time.time()
-            err_msg = f"登录失败，10分钟后重试。错误: {e}"
-            self.logger(f"❌ {err_msg}")
-            send_pushover("影城监控异常", err_msg, priority=1)
+            msg = f"登录失败: {e}"
+            self.logger(f"❌ {msg}")
+            # 修改点：登录失败改为 0 级通知
+            send_pushover("监控异常", msg, priority=0)
             return None
 
     def fetch_schedule(self, date_str):
         token = self.load_token()
         if not token:
             token = self.login()
-            if not token: return None
+            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:  # Token 失效
-                self.logger("⚠️ Token 已失效，尝试重新登录...")
+            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 []
         except Exception as e:
-            self.logger(f"📡 API 请求异常: {e}")
+            self.logger(f"API请求异常: {e}")
             return None
 
-
-# --- 4. 核心监控服务 (智能状态机) ---
+# --- 4. 监控服务 ---
 
 class CinemaMonitor:
     def __init__(self):
         self.logs = deque(maxlen=50)
         self.status_text = "初始化中..."
         self.next_wakeup = None
-        self.monitored_sessions = []  # 前端展示用
+        self.monitored_sessions = []
         self.alert_history = set()
         self.api = APIManager(self.log)
-
         self.current_business_date = None
-        self.daily_schedule_cache = None  # 缓存当天的排片结构
-
+        self.daily_schedule_cache = None
         self.simulation_mode = False
         self.simulation_data = []
-
+        
         self.thread = threading.Thread(target=self._run_loop, daemon=True)
         self.thread.start()
 
     def log(self, msg):
-        timestamp = datetime.now().strftime("%H:%M:%S")
+        timestamp = get_beijing_now().strftime("%H:%M:%S")
         entry = f"[{timestamp}] {msg}"
         print(entry)
         self.logs.appendleft(entry)
 
     def _run_loop(self):
-        self.log("🚀 监控服务已启动")
-
+        self.log("🚀 监控服务已启动 (BJ时间/普通通知)")
+        
         while True:
             try:
-                now = datetime.now()
+                now = get_beijing_now()
                 biz_date = get_business_date()
 
-                # --- 1. 每日 9:30 初始化或跨天重置 ---
-                # 如果缓存日期不对，或者还没有缓存，并且时间到了 9:30 之后
+                # --- 06:00 - 09:30 强制休眠 ---
                 start_check_time = now.replace(hour=9, minute=30, second=0, microsecond=0)
-
-                # 如果是凌晨 01:00，biz_date是前一天，我们也应该允许运行，只要是当天任务
-                # 简化逻辑：只要当前时间 >= 今天的 9:30，或者是次日凌晨（属于biz_date的尾巴）都可以运行
-                # 只有在 06:00 - 09:30 之间我们需要强制等待
-
-                is_early_morning = (dt_time(6, 0) <= now.time() < dt_time(9, 30))
+                is_early_morning = (dt_time(6,0) <= now.time() < dt_time(9,30))
+                
                 if is_early_morning and not self.simulation_mode:
                     self.status_text = "非监控时段 (等待 09:30)"
                     self.next_wakeup = start_check_time
                     sleep_sec = (start_check_time - now).total_seconds()
-                    self.log(f"💤 未到 09:30，系统休眠中... 预计唤醒: {start_check_time.strftime('%H:%M')}")
-                    time.sleep(min(sleep_sec, 300))  # 最多睡5分钟醒来看一眼
+                    self.log(f"💤 系统休眠中... 预计唤醒: {start_check_time.strftime('%H:%M')}")
+                    time.sleep(min(sleep_sec, 300))
                     continue
 
-                # --- 2. 获取/刷新 当日排片结构 ---
-                # 如果这是新的一天，或者是第一次运行，获取全天数据
+                # --- 获取排片 ---
                 if self.daily_schedule_cache is None or self.current_business_date != biz_date:
-                    self.log(f"📅 获取 {biz_date} 全天排片数据...")
+                    self.log(f"📅 获取 {biz_date} 全天排片...")
                     schedule = self.api.fetch_schedule(biz_date)
-
                     if schedule is None:
-                        self.log("❌ 获取排片失败，1分钟后重试")
+                        self.log("❌ 获取失败，1分钟后重试")
                         time.sleep(60)
                         continue
-
                     self.daily_schedule_cache = schedule
                     self.current_business_date = biz_date
-                    self.log(f"✅ 排片数据已获取，共 {len(schedule)} 场")
-
-                # --- 3. 智能决策：下一步做什么？ ---
-                # 我们需要找出当前所有 "值得监控" 的场次
-                # 值得监控 = (开场时间 > 现在) 且 (在这个时刻，它是 0 票 OR 我们即将进入它的 11分钟窗口)
+                    self.log(f"✅ 数据已更新，共 {len(schedule)} 场")
 
-                active_check_needed = False  # 是否需要立即进行高频轮询
-                min_sleep_seconds = 3600  # 默认睡1小时
-
-                upcoming_sessions = []  # 待处理的场次
-
-                # 注入模拟数据
+                # --- 筛选监控目标 ---
+                active_check_needed = False
+                min_sleep_seconds = 3600 
+                upcoming_sessions = []
                 current_schedule = self.daily_schedule_cache + self.simulation_data
 
                 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
 
-                    # 11分钟警戒线时刻
                     monitor_start_dt = show_dt - timedelta(minutes=11)
-
-                    # 判断：我们现在在哪里？
+                    
                     if now >= monitor_start_dt:
-                        # A. 我们已经处于 [T-11, T-0] 的窗口内
-                        # 这就是我们需要高频轮询的目标！
-                        upcoming_sessions.append({
-                            'data': item,
-                            'dt': show_dt,
-                            'status': 'ACTIVE'
-                        })
+                        upcoming_sessions.append({'data': item, 'dt': show_dt})
                         active_check_needed = True
                     else:
-                        # B. 还没到时间
-                        # 计算还有多久进入 T-11
                         seconds_until_window = (monitor_start_dt - now).total_seconds()
                         if seconds_until_window < min_sleep_seconds:
                             min_sleep_seconds = seconds_until_window
 
-                # --- 4. 执行动作 ---
-
+                # --- 执行监控 ---
                 if active_check_needed:
-                    # === 进入高频轮询模式 ===
                     self.status_text = "🔥 监控进行中 (高频轮询)"
                     self.next_wakeup = now + timedelta(seconds=60)
-
-                    # 这里必须重新请求 API，因为我们要看实时的票数变化
-                    # 注意：为了节省流量，我们其实只需要关心 upcoming_sessions 里的
-                    # 但 API 只能拉全量，所以拉下来后我们只看我们在乎的
+                    
                     realtime_schedule = self.api.fetch_schedule(biz_date)
                     if self.simulation_mode: realtime_schedule += self.simulation_data
-
-                    # 转换为字典方便查找
-                    # Key: hallId_showStartTime (防止同名电影不同厅)
                     realtime_map = {f"{x.get('hallId')}_{x.get('showStartTime')}": x for x in (realtime_schedule or [])}
 
                     display_monitors = []
-
                     for session in upcoming_sessions:
-                        # 找到最新的实时数据
                         key = f"{session['data'].get('hallId')}_{session['data'].get('showStartTime')}"
-                        latest_data = realtime_map.get(key, session['data'])  # 找不到就用缓存的(不太可能)
-
-                        movie_name = latest_data.get('movieName')
-                        hall_name = latest_data.get('hallName')
-                        sold = int(latest_data.get('soldTicketNum', 0))
-                        start_str = latest_data.get('showStartTime')
-
-                        # 倒计时
+                        latest = realtime_map.get(key, session['data'])
+                        
+                        movie_name = latest.get('movieName')
+                        hall_name = latest.get('hallName')
+                        sold = int(latest.get('soldTicketNum', 0))
+                        start_str = latest.get('showStartTime')
                         mins_left = (session['dt'] - now).total_seconds() / 60
-
-                        # 核心业务规则：
-                        # 1. 如果有人买票 (sold > 0) -> 报警 -> 并不再轮询此场次 (视为安全)
-                        # 2. 如果无人买票 (sold == 0) -> 继续轮询直到开场
-
+                        
                         if sold > 0:
-                            # 检查是否已报警
                             unique_id = f"{biz_date}_{key}"
                             if unique_id not in self.alert_history:
                                 self.log(f"🚨 发现购票！{hall_name}《{movie_name}》")
+                                # 修改点：发现有票，发送通知，优先级改为 0
                                 send_pushover(
-                                    f"禁止撤场：{hall_name}有票！",
-                                    f"《{movie_name}》{start_str}\n倒计时 {mins_left:.1f}分\n已售 {sold}张",
-                                    priority=1
+                                    f"禁止撤场：{hall_name}有票！", 
+                                    f"《{movie_name}》{start_str}\n倒计时 {mins_left:.1f}分\n已售 {sold}张", 
+                                    priority=0 
                                 )
                                 self.alert_history.add(unique_id)
-
-                            # 既然有人买了，就不需要再监控这个场次了，标记为安全
-                            display_monitors.append(f"✅ {start_str} {movie_name} (已售{sold}, 停止监控)")
-
+                            display_monitors.append(f"✅ {start_str} {movie_name} (已售{sold}, 安全)")
                         else:
-                            # 0 票，危险，继续盯着
                             display_monitors.append(f"👁️ {start_str} {movie_name} (0票, 倒计时{mins_left:.1f}分)")
-
+                    
                     self.monitored_sessions = display_monitors
-
-                    # 高频模式下，睡 60 秒
                     time.sleep(60)
-
                 else:
-                    # === 进入长休眠模式 ===
-                    # 没有任何场次处于 T-11 窗口内
-                    if min_sleep_seconds > 0 and min_sleep_seconds < 86400:  # 合理范围
+                    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')}")
+                        self.log(f"休眠 {min_sleep_seconds/60:.1f} 分钟，直到 {wakeup_dt.strftime('%H:%M')}")
                         time.sleep(min_sleep_seconds)
                     else:
-                        # 可能今天没排片了，或者出错
                         self.log("今日无更多待监控场次，休眠 5 分钟")
                         time.sleep(300)
 
             except Exception as e:
-                self.log(f"主循环异常: {e}")
+                self.log(f"循环异常: {e}")
                 time.sleep(60)
 
     def trigger_simulation(self):
         self.simulation_mode = True
-        # 构造一个 5分钟后开场的数据
-        fake_time = (datetime.now() + timedelta(minutes=5)).strftime("%H:%M")
+        fake_time = (get_beijing_now() + timedelta(minutes=5)).strftime("%H:%M")
         self.simulation_data = [{
             'movieName': '测试影片-模拟购票',
             'hallName': '测试厅',
             'hallId': 'SIM_999',
             'showStartTime': fake_time,
-            'soldTicketNum': '0'  # 初始0票，下一轮 API 获取时如果是实战会自动更新，这里我们模拟逻辑需要配合
+            'soldTicketNum': '0'
         }]
-        # 为了模拟“中途有人买票”，我们在 API 获取不到数据时，让逻辑层认为它变成了1票
-        # 这里简化处理：直接让下一轮检测认为它有1票
         self.log(f"已注入模拟场次: {fake_time} 开场")
-        # 这里有个小 trick: 因为 fetch_schedule 不会返回 simulation_data，
-        # 所以我们在 run_loop 里手动拼接了 simulation_data。
-        # 为了模拟有人买票，我们在几秒后修改 simulation_data 的票数
-        threading.Timer(5.0, self._update_sim_ticket).start()
+        threading.Timer(5.0, lambda: self.simulation_data[0].update({'soldTicketNum': '1'}) or self.log("⚡ [测试] 模拟出票成功！")).start()
 
-    def _update_sim_ticket(self):
-        if self.simulation_data:
-            self.simulation_data[0]['soldTicketNum'] = '1'
-            self.log("⚡ [测试] 模拟观众刚刚购买了一张票！")
-
-
-# --- 5. Streamlit 前端 ---
+# --- 5. 前端显示 ---
 
 @st.cache_resource
 def get_monitor():
     return CinemaMonitor()
 
-
 def main():
     monitor = get_monitor()
-
-    # --- 顶部状态卡片 ---
     st.title("📽️ 影城排程防撤场监控终端 Pro")
-
-    # 状态指示器
-    status_color = "green" if "监控" in monitor.status_text else "blue"
-    if "非监控" in monitor.status_text: status_color = "gray"
-
+    
+    utc_now = datetime.now(timezone.utc).strftime("%H:%M:%S")
+    bj_now = get_beijing_now().strftime("%H:%M:%S")
+    
     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)
-    with c3:
-        st.metric("营业日期", monitor.current_business_date if monitor.current_business_date else "获取中")
-
+    with c1: st.metric("当前状态", monitor.status_text)
+    with c2: st.metric("下次唤醒 (北京时间)", monitor.next_wakeup.strftime("%H:%M:%S") if monitor.next_wakeup else "--")
+    with c3: st.metric("系统时间 (UTC / BJ)", f"{utc_now} / {bj_now}")
+    
     st.divider()
 
-    # --- 主要内容区 ---
     col_logs, col_list = st.columns([3, 2])
-
     with col_logs:
         st.subheader("📜 系统运行日志")
         if st.button("刷新日志"): pass
-        log_txt = "\n".join(list(monitor.logs))
-        st.text_area("Logs", log_txt, height=450, disabled=True)
-
+        st.text_area("Logs", "\n".join(list(monitor.logs)), height=450, disabled=True)
     with col_list:
         st.subheader("🎯 实时监控列表")
-        st.caption("仅显示处于开场前 11 分钟窗口内的场次")
-
         if monitor.monitored_sessions:
             for s in monitor.monitored_sessions:
-                if "停止监控" in s:
-                    st.success(s)  # 绿色，有人买票了，安全
-                else:
-                    st.warning(s)  # 黄色，0票，危险
+                if "安全" in s: st.success(s)
+                else: st.warning(s)
         else:
-            st.info("当前无正在高频监控的场次 (休眠中)")
-
+            st.info("当前休眠中")
         st.write("---")
-        st.write("🛠️ 调试工具")
-        if st.button("模拟 '撤场前有人买票' 场景"):
+        if st.button("模拟 '撤场前有人买票'"):
             monitor.trigger_simulation()
-            st.toast("已生成模拟数据：5分钟后开场的电影，将在5秒后模拟出票。请观察日志。")
-
+            st.toast("测试已触发，请观察日志")
 
 if __name__ == "__main__":
     main()