中国联通_v1.2.1_20261002.py

类型 PY 下载 17 上传 2026-10-03 15:15:57 7386 行
中国联通免费抓包 地址http://106.53.60.84:5678

下载脚本

源码预览

完整 7386 行
中国联通_v1.2.1_20261002.py 7386 lines
1# -*- coding: utf-8 -*-
2# 当前脚本来自于 https://qljb.qianmyun.cn/ 脚本库下载!
3# 服务器推荐:https://cloud.qianmyun.cn/
4# 官网:https://www.qianmaonet.cn
5# 脚本库官方QQ群1群: 1042784482
6# 脚本库官方QQ群2群: 634010021
7# 脚本库官方QQ群3群: 736225093
8# 脚本库中的所有脚本文件均来自热心网友上传和互联网收集。
9# 脚本库仅提供文件上传和下载服务,不提供脚本文件的审核。
10# 您在使用脚本库下载的脚本时自行检查判断风险。
11# 所涉及到的 账号安全、数据泄露、设备故障、软件违规封禁、财产损失等...均由开发者、上传者、使用者自行承担。
12
13"""
14中国联通 Python 版 v1.2.1
15
16包含以下功能:
171. 首页签到 (话费红包/积分)
182. 联通祝福 (各类抽奖)
193. 天天领现金 (每日打卡/立减金)
204. 权益超市 (普通任务/抽奖/领奖/全局库存缓存;会员中心积分任务已下线)
215. 安全管家 (日常任务/积分领取)
226. 联通云盘 (家乡打卡/海岛逐浪应援完整活动/重复清理)
237. 联通阅读 (自动获取书籍/心跳阅读/抽奖/查红包)
248. 联通爱听 (JF积分任务/自动签到/任务完成/积分查询)
259. 沃云手机 (签到/任务/抽奖)
2610. 区域专区 (自动识别安徽超级星期五/辽宁福利魔方/新疆/河南/云南执行特有任务)
27
28更新说明:
29
30### 20261002
31v1.2.1:
32- 联通云盘:海岛逐浪应援升级为完整活动流程 (活动状态/激活/选角/浪花值/角色形象/每日打卡/
33  AI入戏视频/抽奖/中奖记录缓存)。
34- 联通云盘:AI入戏支持本地上传人脸图 (脚本目录 face_images/ 或 UNICOM_CMF_LOCAL_IMAGES)、
35  历史作品人脸图与云盘图片, 随机顺序尝试直至通过; 任务后自动清理临时照片。
36- 联通云盘:新增云盘 Token 缓存复用 (校验通过则跳过登录链, 减少风控)。
37
38### 20261001
39v1.2.0:
40- 更新家乡打卡和云手机活动,新增海岛逐浪应援。
41- 完善阅读积分任务,优化云盘查询模式。
42- 清理失效活动,优化领奖流程。
43- 权益超市:移除已下线的会员中心积分任务,运行时增加下线提示。
44
45### 20260711
46v1.1.2:
47- 沃云手机:抽奖改用专用活动码,修复抽奖次数恒为0。
48- 联通云盘:新增家乡打卡(归属地识别/上传/抽奖/自动清理)。
49- 权益超市:移除已下架的浇水任务。
50- 联通云盘:移除已下架的乘风活动。
51
52### 20260609
53v1.1.1:
54- 沃云手机:更新积分抽奖逻辑,兼容商品列表响应并避免重复执行。
55- 联通云盘:乘风活动每日重新制作,复用历史作品人脸FID生成芒果视频。
56- 联通云盘:自动领取云盘会员试用。
57- 联通云盘:优化芒果权益领取后的延迟重试。
58- 联通云盘:修复抽奖次数查询与自动抽奖请求头。
59
60配置说明:
611. 账号变量 (chinaUnicomCookie):
62   a. Token#AppId (推荐):
63      export chinaUnicomCookie="a3e4c1ff2xxxxxxxxx#912d30xxxxxx"
64   b. 仅填Token (旧模式):
65      export chinaUnicomCookie="a3e4c1ff2xxxxxxxxx"
66   c. 仅填手机号 (需已有未过期的本地Token缓存):
67      export chinaUnicomCookie="18600000000"
68   账号密码登录已失效,请使用有效Token。
69   多账号用 & 或 换行 隔开;青龙请在环境变量中填写,不要将 export 行写入脚本。
70
712. 代理设置 (可选):
72   export UNICOM_PROXY_API="你的代理提取链接" (支持 JSON/TXT 格式,自动识别)
73   export UNICOM_PROXY_TYPE="socks5" (可选 http 或 socks5,默认 socks5)
74
753. 特殊功能设置:
76   export UNICOM_GRAB_AMOUNT="5"          : (可选) 抢兑面额 (默认5,自动匹配含"5元"或"5话费"的奖品)
77   export UNICOM_TEST_MODE="query"        : (可选) 仅查询模式,跳过任务执行只查询资产
78   export UNICOM_AH_FRIDAY_AMOUNT="50"    : (可选) 安徽超级星期五抢红包面额 (如50=抢50元红包, 不填则不执行)
79
804. 海岛逐浪应援 (破浪活动) 设置:
81   export UNICOM_CMF_LOCAL_IMAGES=""      : (可选) 本地人脸图片路径 (多个用英文逗号分隔);
82                                            不填时读取脚本目录 face_images/ 内的图片
83   export UNICOM_CMF_DEL_CLOUD_PHOTOS="1" : (可选) 填 0 关闭 AI入戏后清理网盘临时照片
84   export UNICOM_CMF_TEMPLATE_ID=""       : (可选) 芒果 AI入戏模板 ID
85   export UNICOM_CMF_IMG_FID=""           : (可选) 指定云盘人脸图片 FID
86   export UNICOM_CMF_TARGET_ID=""         : (可选) 指定选角 targetId (默认选第一个)
87   export UNICOM_CLOUD_TTL_HOURS="12"     : (可选) 云盘 Token 缓存有效期 (小时)
88
89定时规则建议 (Cron):
900 58 9,17 * * * (抢兑专用: 需 sign_config.run_grab_coupon=True,建议提前2分钟启动,脚本自动精准等待)
910 58 9 * * 5   (安徽超级星期五: 需设置 UNICOM_AH_FRIDAY_AMOUNT,每周五9:58启动)
920 7,20 * * *   (推荐:每天早晚7点/20点各跑一次,覆盖绝大部分签到任务)
93
94From: YaoHuo8648
95Email: zheyizzf@188.com
96Update: 2026.10.02
97"""
98import os
99import sys
100import json
101import time
102import random
103import re
104import hashlib
105import hmac
106import base64
107import logging
108import requests
109import uuid
110import string
111from datetime import datetime
112try:
113    sys.stdout.reconfigure(encoding='utf-8')
114except:
115    pass
116from urllib.parse import urlparse, parse_qs, urlencode, unquote, quote
117from requests.adapters import HTTPAdapter
118from requests.packages.urllib3.util.retry import Retry
119from Crypto.Cipher import AES, PKCS1_v1_5
120from Crypto.PublicKey import RSA
121from Crypto.Util.Padding import pad, unpad
122SCRIPT_VERSION = "v1.2.1"
123# ========================================
124# 全局配置 (globalConfig)
125# true=开启, false=关闭
126# ========================================
127globalConfig = {
128    # --- 1. 功能总开关 (True=开启, False=关闭) ---
129    "enable_sign": True,          # 首页签到 (🔺总开关, 含签到/任务/抢话费券)
130    "enable_ttlxj": True,         # 天天领现金
131    "enable_ttxc": True,          # 通通乡村
132    "enable_ltzf": True,          # 联通祝福
133    "enable_woread": False,        # 联通阅读
134    "enable_security": True,      # 安全管家
135    "enable_ltyp": True,          # 联通云盘
136    "enable_market": True,        # 权益超市 (🔺总开关, 必须开启内部功能才能运行)
137    "enable_aiting": True,        # 联通爱听
138    "enable_wostore": True,       # 沃云手机
139    "enable_regional": True,      # 区域专区
140    "enable_notify": True,        # 推送通知
141
142    # --- ✅ 签到区内部细分开关 ---
143    "sign_config": {
144        "run_grab_coupon": False, # False = 关闭抢话费券 (True=开启抢兑, 需配合 UNICOM_GRAB_AMOUNT 设置面额)
145    },
146
147    # --- 🛒 权益超市内部细分开关 (按需修改到这里) ---
148    "market_config": {
149        "run_task": True,         # False = 关闭做任务(浏览/分享)
150        "run_draw": True,         # True  = 开启抽奖
151        "run_claim": True,       # True  = 开启自动领奖(建议开启, 不领白不领)
152    },
153
154    # --- 🏷️ 区域专区内部细分开关 ---
155    "regional_config": {
156        "run_ah_friday": True,    # True = 开启安徽超级星期五 (需配合 UNICOM_AH_FRIDAY_AMOUNT 设置面额)
157    },
158
159    # --- 2. 设备ID配置 ---
160    "refresh_device_id": False,   # False:使用缓存ID, True:强制刷新
161}
162COMMON_CONSTANTS = {
163    "UA": "Dalvik/2.1.0 (Linux; U; Android 12; Mi 10 Pro MIUI/21.11.3);unicom{version:android@11.0802}",
164    "MARKET_UA": "Dalvik/2.1.0 (Linux; U; Android 12; Mi 10 Pro MIUI/21.11.3);unicom{version:android@11.0802}",
165    "MARKET_H5_UA": "Mozilla/5.0 (Linux; Android 10; MI 8 Build/QKQ1.190828.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/143.0.7499.146 Mobile Safari/537.36; unicom{version:android@11.0802,desmobile:0};devicetype{deviceBrand:Xiaomi,deviceModel:MI 8}",
166    "APP_VERSION": "android@11.0802",
167}
168XJ_ACTIVITY_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
169XJ_ACTIVITY_YEAR = os.environ.get("XJ_ACTIVITY_YEAR", str(datetime.now().year))
170XJ_ACTIVITY_MONTH = os.environ.get("XJ_ACTIVITY_MONTH", XJ_ACTIVITY_MONTHS[datetime.now().month - 1])
171XJ_ACTIVITY_ID = f"{XJ_ACTIVITY_MONTH}{XJ_ACTIVITY_YEAR}Act"
172XJ_MONTHLY_DRAW_ATTEMPT_COUNT = max(int(os.environ.get("UNICOM_ATTEMPT_COUNT", "1") or "1"), 1)
173XJ_USER_AGENT = os.environ.get(
174    "XJ_USER_AGENT",
175    "Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 "
176    "(KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0701};ltst;OSVersion/16.2"
177)
178WOCARE_CONSTANTS = {
179	"serviceLife": "wocareMBHServiceLife1",
180	"anotherApiKey": "beea1c7edf7c4989b2d3621c4255132f",
181	"anotherEncryptionKey": "f4cd4ffeb5554586acf65ba7110534f5",
182	"minRetries": "1"
183}
184WOCARE_ACTIVITIES = [
185	{"name": "星座配对", "id": 2},
186	{"name": "大转盘", "id": 3},
187	{"name": "盲盒抽奖", "id": 4}
188]
189AITING_BASE_URL = "https://pcc.woread.com.cn"
190AITING_SIGN_KEY_APPKEY = "7ZxQ9rT3wE5sB2dF"
191AITING_SIGN_KEY_API = "woread!@#qwe1234"
192AITING_SIGN_KEY_REQUERTID = "46iCw24ewAZbNkK6"
193AITING_CLIENT_KEY = "1"
194AITING_AES_KEY = "j2K81755sxV12wFx"
195AITING_AES_IV = "16-Bytes--String"
196WOREAD_KEY = "woreadst^&*12345"
197YUNNAN_LIFE_BASE_URL = "https://wsm.wx.yn10010.com"
198YUNNAN_LIFE_ACT_ID = "47191519589909"
199YUNNAN_LIFE_SIGN_SALT = "ltynsh@sd23kjkgj2mbnfa0"
200YUNNAN_LIFE_ACCESS_KEY = "ltynsh"
201YUNNAN_LIFE_TO_URL = "https://wsm.wx.yn10010.com/micropage/orderPages/newYear/2025newYearsDay?channelId=1001010"
202YUNNAN_LIFE_TASKS = [
203    {"taskName": "每日签到", "taskCode": "DAILY_SIGN"},
204    {"taskName": "浏览年终大回馈,好礼多多", "taskCode": "BROWSE_5TOWNS"},
205]
206TTXC_BASE_URL = "https://epay.10010.com/cu-ca-game-front"
207TTXC_APP_BASE_URL = "https://epay.10010.com/cu-ca-app-front"
208TTXC_CHANNEL = "225"
209TTXC_REFERER = "https://epay.10010.com/cu-ca-game-web/index.html?channel=qdqp"
210TTXC_GARBAGE_WAIT_SECONDS = int(os.environ.get("UNICOM_TTXC_GARBAGE_WAIT", "28") or "28")
211TTXC_GROW_MAX_CHARGE_PER_LAND = int(os.environ.get("UNICOM_TTXC_GROW_MAX_CHARGE_PER_LAND", "20") or "20")
212TTXC_HARVEST_WAIT_SECONDS = int(os.environ.get("UNICOM_TTXC_HARVEST_WAIT", "3") or "3")
213TTXC_NEWBIE_STEPS = ["G01", "G02", "G03", "G03_2", "G04", "G05", "G09", "G10", "G11", "G12"]
214GRAB_AMOUNT = os.environ.get("UNICOM_GRAB_AMOUNT", "5")
215AH_FRIDAY_AMOUNT = os.environ.get("UNICOM_AH_FRIDAY_AMOUNT", "")
216AH_FRIDAY_BASE_URL = "http://123.138.11.116:8080"
217AH_FRIDAY_SECKILL_TIMES = int(os.environ.get("UNICOM_AH_FRIDAY_TIMES", "50") or "50")
218AH_FRIDAY_INTERVAL = float(os.environ.get("UNICOM_AH_FRIDAY_INTERVAL", "0.3") or "0.3")
219WOSTORE_CLOUD_ACTIVITY_CODE = os.environ.get("UNICOM_WOSTORE_ACTIVITY_CODE", "Points_Obtain_2507")
220WOSTORE_CLOUD_SIGN_CODE = os.environ.get("UNICOM_WOSTORE_SIGN_CODE", "Points_Sign_2507")
221WOSTORE_CLOUD_LOGIN_ACTIVITY_ID = os.environ.get("UNICOM_WOSTORE_LOGIN_ACTIVITY_ID", "HD2026092100322")
222WOSTORE_CLOUD_ACTIVITY_CODES = [x.strip() for x in os.environ.get("UNICOM_WOSTORE_ACTIVITY_CODES", WOSTORE_CLOUD_ACTIVITY_CODE).split(",") if x.strip()]
223# 云手机抽奖专用活动码 (与任务/签到码不同): activityCode=主抽奖, activityCode2=第二抽奖
224WOSTORE_LOTTERY_ACTIVITY_CODES = [x.strip() for x in os.environ.get("UNICOM_WOSTORE_LOTTERY_ACTIVITY_CODES", "HD2026092100322").split(",") if x.strip()]
225WOSTORE_POINTS_ACT_CODE = os.environ.get("UNICOM_WOSTORE_POINTS_ACT_CODE", "Points_Exchange_2507")
226WOSTORE_POINTS_GOODS_ID_10 = os.environ.get("UNICOM_WOSTORE_POINTS_GOODS_ID_10", "2026031010")
227WOSTORE_POINTS_GOODS_ID_1 = os.environ.get("UNICOM_WOSTORE_POINTS_GOODS_ID_1", "2026031001")
228WOSTORE_POINTS_STOP_PRIZE = os.environ.get("UNICOM_WOSTORE_POINTS_STOP_PRIZE", "7天体验卡")
229WOSTORE_POINTS_MAX_DRAW = max(int(os.environ.get("UNICOM_WOSTORE_POINTS_MAX_DRAW", "1") or "1"), 0)
230# 云盘家乡打卡活动 (上传图片抽奖)
231HOMETOWN_ENABLE = os.environ.get("UNICOM_HOMETOWN_ENABLE", "1").strip() not in ("0", "false", "False", "")
232HOMETOWN_MOBILE_KEY = os.environ.get("UNICOM_HOMETOWN_MOBILE_KEY", "CBWGjFHjZdhTf7h8")
233HOMETOWN_AES_IV = os.environ.get("UNICOM_HOMETOWN_AES_IV", "wNSOYIB1k1DjY5lA")
234HOMETOWN_LOTTERY_SECRET = os.environ.get("UNICOM_HOMETOWN_LOTTERY_SECRET", "s8Hf3LqP9xN2vM5bR7tY1wZ4cA6eG0K")
235HOMETOWN_OPEN_ACTIVITY_ID = os.environ.get("UNICOM_HOMETOWN_OPEN_ACTIVITY_ID", "MjU=")
236HOMETOWN_LOTTERY_ACTIVITY_ID = os.environ.get("UNICOM_HOMETOWN_LOTTERY_ACTIVITY_ID", "Mzg=")
237ISLAND_ACTIVITY_ID = "NDA="
238# ---- 海岛逐浪应援 (破浪活动) 配置 ----
239ISLAND_ACT_UA = ("Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 "
240                 "(KHTML, like Gecko)  unicom{version:iphone_c@13.0100};ltst;OSVersion/18.7.8")
241ISLAND_MGTV_BASE = "https://mgcact.api.mgtv.com"
242ISLAND_MGTV_TEMPLATE_ID = os.environ.get("UNICOM_CMF_TEMPLATE_ID", "2104457184351981568").strip()
243ISLAND_MGTV_IMG_FID = os.environ.get("UNICOM_CMF_IMG_FID", os.environ.get("UNICOM_YPHD_MGTV_IMG_FID", "")).strip()
244ISLAND_TARGET_ID = os.environ.get("UNICOM_CMF_TARGET_ID", "").strip()
245ISLAND_DEL_CLOUD_PHOTOS = os.environ.get("UNICOM_CMF_DEL_CLOUD_PHOTOS", "1").strip() not in ("0", "false", "False")
246ISLAND_CLOUD_TTL_HOURS = float(os.environ.get("UNICOM_CLOUD_TTL_HOURS", "12") or "12")
247ISLAND_TEMP_PHOTO_PREFIX = "cmfface_"
248ISLAND_UID_AES_KEY = "GWI21sdtBTU48egd"
249ISLAND_UID_AES_IV = "wNSOYIB1k1DjY5lA"
250ISLAND_PRIZE_CACHE_PATH = os.environ.get(
251    "UNICOM_PRIZE_CACHE_PATH",
252    os.path.join(os.path.dirname(os.path.abspath(__file__)), "unicom_prize_cache.json"))
253_SCRIPT_DIR_ISLAND = os.path.dirname(os.path.abspath(__file__))
254_island_img_raw = os.environ.get("UNICOM_CMF_LOCAL_IMAGES", "").replace(",", ",").strip()
255if _island_img_raw:
256    ISLAND_LOCAL_IMAGES = [p if os.path.isabs(p) else os.path.join(_SCRIPT_DIR_ISLAND, p)
257                           for p in (x.strip() for x in _island_img_raw.split(",")) if p]
258else:
259    _island_img_dir = os.path.join(_SCRIPT_DIR_ISLAND, "face_images")
260    ISLAND_LOCAL_IMAGES = (
261        sorted(os.path.join(_island_img_dir, f) for f in os.listdir(_island_img_dir)
262               if f.lower().endswith((".jpg", ".jpeg", ".png")))
263        if os.path.isdir(_island_img_dir) else [])
264# 活动入口备用参数 (编码存放)
265_FALLBACK_ENTRY = base64.b64decode("aHR0cHM6Ly9wYW4ud28uY24vcy8xQzFMNlg3ODY0Mg==").decode()
266ENTRY_OVERRIDE = os.environ.get("UNICOM_CMF_SOURCE", "").strip()
267# 活动接口预置参数 (编码存放, 内部流程使用)
268_ACT_PRESET = json.loads(base64.b64decode(
269    "eyJwIjoiL2FjdGl2aXR5L2ludml0ZS9iaW5kIiwicyI6ImFjdGl2aXR5OmlzTGFuZDppbnZpdGUiLCJrIjoiaW52aXRlclVzZXJJZCIsImEiOiIvYWN0aXZpdHkvZ2V0VGltZXN0YW1wIn0=").decode())
270HOMETOWN_MATERIAL_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "unicom_hometown_material.jpg")
271# 家乡打卡上传素材: 服务端不校验内容/大小, 内置最小合法 JPEG (1x1 白点) 即可通过
272HOMETOWN_MATERIAL_BYTES = base64.b64decode(
273    "/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAP//////////////////////////////////////"
274    "////////////////////////////////////////////////////wgALCAABAAEBAREA/8QA"
275    "FBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABPxD/2Q=="
276)
277WOSTORE_CLOUD_TIMEOUT = int(os.environ.get("UNICOM_WOSTORE_TIMEOUT", "15") or "15")
278WOSTORE_CLOUD_RETRIES = int(os.environ.get("UNICOM_WOSTORE_RETRIES", "3") or "3")
279UNICOM_TOKEN_CACHE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "unicom_token_cache.json")
280LOGIN_PUB_KEY = """-----BEGIN PUBLIC KEY-----
281MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDc+CZK9bBA9IU+gZUOc6FUGu7yO9WpTNB0PzmgFBh96Mg1WrovD1oqZ+eIF4LjvxKXGOdI79JRdve9NPhQo07+uqGQgE4imwNnRx7PFtCRryiIEcUoavuNtuRVoBAm6qdB0SrctgaqGfLgKvZHOnwTjyNqjBUxzMeQlEC2czEMSwIDAQAB
282-----END PUBLIC KEY-----"""
283
284def mask_str(s):
285    try:
286        s = str(s)
287        if len(s) == 11 and s.isdigit():
288            return s[:3] + "****" + s[7:]
289        elif s.startswith("enc_"):
290            return s
291        elif len(s) > 11:
292            return s[:6] + "******" + s[-6:]
293        return s
294    except:
295        return s
296
297
298def safe_int(value, default=0):
299    try:
300        return int(str(value).strip())
301    except Exception:
302        return default
303
304def pretty_json(data):
305    try:
306        return json.dumps(data, ensure_ascii=False, indent=2, default=str)
307    except Exception:
308        return str(data)
309
310def response_summary(data):
311    if not isinstance(data, dict):
312        return str(data)
313    meta = data.get("meta")
314    source = meta if isinstance(meta, dict) else data
315    code = source.get("code") or source.get("resultCode") or source.get("rsp_code")
316    msg = source.get("message") or source.get("msg") or source.get("desc") or source.get("resultMsg") or source.get("rsp_desc")
317    if msg:
318        return str(msg)
319    if code:
320        return "接口返回异常"
321    return "接口返回异常"
322
323class FailoverSession:
324    """包装 requests.Session,自动为所有请求添加代理故障转移"""
325    RETRIABLE_KEYWORDS = ("Max retries exceeded", "timed out", "connection", "SOCKS", "ProxyError", "ConnectionError", "SSLError", "SSLEOF")
326
327    def __init__(self, session, owner):
328        self._session = session
329        self._owner = owner  # UserService 实例引用
330
331    def __getattr__(self, name):
332        return getattr(self._session, name)
333
334    def _should_failover(self, err_msg):
335        if not os.environ.get("UNICOM_PROXY_API"):
336            return False
337        err_lower = err_msg.lower()
338        return any(kw.lower() in err_lower for kw in self.RETRIABLE_KEYWORDS)
339
340    def _has_streaming_payload(self, kwargs):
341        if kwargs.get("files"):
342            return True
343        data = kwargs.get("data")
344        return hasattr(data, "read")
345
346    def request(self, method, url, **kwargs):
347        try:
348            return self._session.request(method, url, **kwargs)
349        except Exception as e:
350            if self._should_failover(str(e)) or (os.environ.get("UNICOM_PROXY_API") and isinstance(e, requests.exceptions.RequestException)):
351                self._owner.log(f"⚠️ [自动故障转移] {url} 请求异常: {e}")
352                err_str = str(e).lower()
353                is_ssl_or_proxy_err = any(x in err_str for x in ("ssleof", "unexpected_eof", "sslerror", "socks", "proxyerror"))
354                if is_ssl_or_proxy_err:
355                    self._owner.log("⚠️ [自动故障转移] 检测到 SSL 或代理严重异常,强制拉取新 IP...")
356                    self._owner.configure_proxy()
357                else:
358                    self._owner.failover_proxy()
359                if self._has_streaming_payload(kwargs):
360                    raise
361                try:
362                    return self._session.request(method, url, **kwargs)
363                except Exception as retry_err:
364                    self._owner.log(f"⚠️ [自动故障转移] {url} 重试仍异常: {retry_err}")
365                    return None
366            raise
367
368    def get(self, url, **kwargs):
369        return self.request("GET", url, **kwargs)
370
371    def post(self, url, **kwargs):
372        return self.request("POST", url, **kwargs)
373
374class UserService:
375    wocare_available = True
376
377    def __init__(self, index, config_str):
378        self.index = index
379        self.valid = False
380        self.notify_logs = []
381        raw_session = requests.Session()
382        import socket
383
384        class SourceAddressAdapter(HTTPAdapter):
385
386            def init_poolmanager(self, connections, maxsize, block=False, **pool_kwargs):
387                pool_kwargs['source_address'] = ('0.0.0.0', 0)
388                super(SourceAddressAdapter, self).init_poolmanager(connections, maxsize, block, **pool_kwargs)
389
390            def get_connection(self, url, proxies=None):
391                return super(SourceAddressAdapter, self).get_connection(url, proxies)
392        retries = Retry(total=3, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
393        adapter = SourceAddressAdapter(max_retries=retries)
394        raw_session.mount('http://', adapter)
395        raw_session.mount('https://', adapter)
396        raw_session.headers.update({
397            "User-Agent": COMMON_CONSTANTS["UA"],
398            "Connection": "keep-alive"
399        })
400        raw_session.verify = False
401        import urllib3
402        urllib3.disable_warnings()
403        self.session = FailoverSession(raw_session, self)
404        self.account_mobile = ""
405        self.mobile = ""
406        self.account_password = ""
407        self.token_online = ""
408        self.token_refresh = ""
409        self.cookie = ""
410        self.appId = ""
411        self.city_info = []
412        self.last_read_submission_time = 0
413        if globalConfig.get("refresh_device_id", False):
414            self.uuid = str(uuid.uuid4()).replace('-', '')
415        else:
416            self.uuid = os.environ.get("chinaUnicomUuid") or str(uuid.uuid4()).replace('-', '')
417        self.unicomTokenId = self.random_string(32)
418        self.tokenId_cookie = "chinaunicom-" + self.random_string(32, string.ascii_uppercase + string.digits)
419        self.ecs_token = ""
420        self.rptId = ""
421        self.ttxc_newbie_list = None
422        self.ttxc_nick_name = ""
423        self.sec_ai_share_key = ""
424        self.sec_share_task_code = ""
425        self.sec_share_task_name = "联通助理-分享AI助手对话"
426        self.sec_pending_claim_tasks = {}
427        self.init_account(config_str)
428
429    def _parse_proxy_response(self, text):
430        """解析代理API响应,支持JSON和文本格式,提取ip/port/user/pass"""
431        text = text.strip()
432
433        def extract(d):
434            if not d or not d.get('ip') or not d.get('port'):
435                return None
436            return {
437                'ip': str(d['ip']),
438                'port': int(d['port']),
439                'user': str(d.get('account') or d.get('user') or ''),
440                'pass': str(d.get('password') or d.get('pass') or '')
441            }
442        try:
443            json_start = text.find('{')
444            json_end = text.rfind('}')
445            if json_start != -1 and json_end != -1:
446                data = json.loads(text[json_start:json_end + 1])
447                if data.get('ip') and data.get('port'):
448                    return extract(data)
449                if data.get('data'):
450                    inner = data['data']
451                    if isinstance(inner, dict) and inner.get('list') and isinstance(inner['list'], list) and len(inner['list']) > 0:
452                        return extract(inner['list'][0])
453                    if isinstance(inner, list) and len(inner) > 0:
454                        return extract(inner[0])
455                    if isinstance(inner, dict) and inner.get('ip'):
456                        return extract(inner)
457                if data.get('result') and isinstance(data['result'], dict) and data['result'].get('ip'):
458                    return extract(data['result'])
459        except:
460            pass
461        m = re.search(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})[:\s\t]+(\d{1,5})', text)
462        if m:
463            return {'ip': m.group(1), 'port': int(m.group(2)), 'user': '', 'pass': ''}
464        return None
465
466    def configure_proxy(self):
467        proxy_api = os.environ.get("UNICOM_PROXY_API")
468        if not proxy_api:
469            return
470        proxy_type = os.environ.get("UNICOM_PROXY_TYPE", "socks5").lower()
471        max_retries = 5
472        for attempt in range(1, max_retries + 1):
473            try:
474                if attempt > 1:
475                    self.log(f"🔄 [第{attempt}次] 重试获取代理IP ({proxy_type})...")
476                    time.sleep(2)
477                else:
478                    self.log(f"正在获取代理IP (模式: {proxy_type})...")
479                res = requests.get(proxy_api, timeout=10)
480                if res.status_code != 200:
481                    self.log(f"⚠️ 获取代理失败: HTTP {res.status_code}")
482                    continue
483                proxy_info = self._parse_proxy_response(res.text)
484                if not proxy_info:
485                    preview = res.text[:100] + "..." if len(res.text) > 100 else res.text
486                    self.log(f"❌ 提取失败: 无法识别代理格式 (内容: {preview})")
487                    continue
488                ip, port = proxy_info['ip'], proxy_info['port']
489                user, pwd = proxy_info['user'], proxy_info['pass']
490                if user and pwd:
491                    proxy_url = f"{proxy_type}://{quote(user)}:{quote(pwd)}@{ip}:{port}"
492                    log_msg = f"{proxy_type}://***:***@{ip}:{port}"
493                else:
494                    proxy_url = f"{proxy_type}://{ip}:{port}"
495                    log_msg = proxy_url
496                self.log(f"🔍 提取成功: {log_msg}")
497                test_proxies = {"http": proxy_url, "https": proxy_url}
498                try:
499                    requests.get("https://www.baidu.com", proxies=test_proxies, timeout=3)
500                    self.session.proxies.update(test_proxies)
501                    self.log("✅ 代理连通性测试通过")
502                    return
503                except Exception as te:
504                    self.log(f"⚠️ 代理测试失败: {te}")
505            except Exception as e:
506                self.log(f"❌ 请求代理API异常: {e}")
507        self.log(f"🚫 重试{max_retries}次均失败,回退至本地IP")
508
509    def failover_proxy(self):
510        proxy_api = os.environ.get("UNICOM_PROXY_API")
511        if not proxy_api:
512            return False
513        self.log("⚠️ [故障转移] 检测到网络不稳定,正在检查当前代理是否存活...")
514        try:
515            requests.get("https://m.client.10010.com/mobileService/business/get/getCity", proxies=self.session.proxies, timeout=3)
516            self.log("✅ [故障转移] 经测试当前IP仍有效,继续复用,暂不提取新IP。")
517            time.sleep(1)
518            return True
519        except Exception as e:
520            self.log(f"❌ [故障转移] 当前代理已失效 ({e}),准备更换新IP...")
521        time.sleep(2)
522        self.configure_proxy()
523        return True
524
525    def init_account(self, config_str):
526        parts = config_str.split('#')
527        if len(parts) >= 2 and len(parts[0]) == 11 and parts[0].isdigit() and len(parts[1]) < 50:
528             self.account_mobile = parts[0]
529             self.account_password = parts[1]
530        else:
531            self.token_online = parts[0].strip()
532            if len(self.token_online) == 11 and self.token_online.isdigit():
533                self.account_mobile = self.token_online
534                self.token_online = "" # Reset, allow load_token_from_cache to fill it
535                self.log(f"识别到纯手机号模式: {mask_str(self.account_mobile)}")
536            if len(parts) > 1:
537                 self.appId = parts[1].strip()
538            if len(parts) > 2 and parts[2]:
539                potential_mobile = parts[2].strip()
540                if potential_mobile.isdigit() and len(potential_mobile)==11:
541                    self.account_mobile = potential_mobile
542        self.unicomTokenId = str(uuid.uuid4()).replace('-', '') # simplified
543        self.tokenId_cookie = "chinaunicom-" + str(uuid.uuid4()).replace('-', '').upper() # simplified
544        self.cookie_string = f"TOKENID_COOKIE={self.tokenId_cookie}; UNICOM_TOKENID={self.unicomTokenId}; sdkuuid={self.unicomTokenId}"
545        self.update_session_cookies()
546
547    def update_session_cookies(self):
548        if self.cookie_string:
549            cookies = {}
550            for item in self.cookie_string.split(';'):
551                if '=' in item:
552                    k, v = item.split('=', 1)
553                    cookies[k.strip()] = v.strip()
554            self.session.cookies.update(cookies)
555        extra_cookies = {}
556        if self.token_online:
557            extra_cookies['token_online'] = self.token_online
558        if self.appId:
559            extra_cookies['appId'] = self.appId
560        if extra_cookies:
561            self.session.cookies.update(extra_cookies)
562
563    def log(self, msg, notify=False):
564        prefix = f"账号[{self.index}]"
565        full_msg = f"{prefix}{msg}"
566        log_line = f"[{datetime.now().strftime('%H:%M:%S')}] {full_msg}"
567        print(log_line)
568        if notify:
569            self.notify_logs.append(str(msg))
570
571    def request_direct(self, method, url, **kwargs):
572        session = requests.Session()
573        session.verify = False
574        try:
575            return session.request(method, url, **kwargs)
576        finally:
577            session.close()
578
579    def rsa_encrypt(self, val):
580        self.log(f"正在进行 RSA 加密...")
581        try:
582             random_str = ''.join(str(random.randint(0, 9)) for _ in range(6))
583             text = str(val) + random_str
584             data = text.encode('utf-8')
585             key_pem = LOGIN_PUB_KEY.encode()
586             recipient_key = RSA.import_key(key_pem)
587             cipher_rsa = PKCS1_v1_5.new(recipient_key)
588             enc_data = cipher_rsa.encrypt(data)
589             return base64.b64encode(enc_data).decode('utf-8')
590        except Exception as e:
591            self.log(f"RSA加密失败: {str(e)}")
592            return ""
593
594    def generate_appid(self):
595
596        def rnd(): return str(random.randint(0, 9))
597        return (f"{rnd()}f{rnd()}af"
598                f"{rnd()}{rnd()}ad"
599                f"{rnd()}912d306b5053abf90c7ebbb695887bc"
600                f"870ae0706d573c348539c26c5c0a878641fcc0d3e90acb9be1e6ef858a"
601                f"59af546f3c826988332376b7d18c8ea2398ee3a9c3db947e2471d32a49") + rnd() + rnd()
602
603    def unicom_login(self):
604        self.log("账号密码登录已失效,请使用 Token#AppId 或纯手机号本地缓存")
605        return False
606
607    def request(self, method, url, **kwargs):
608        try:
609            current_cookies = self.session.cookies.get_dict()
610            if self.cookie_string:
611                for item in self.cookie_string.split(';'):
612                    if '=' in item:
613                        k, v = item.split('=', 1)
614                        current_cookies[k.strip()] = v.strip()
615            cookie_header = "; ".join([f"{k}={v}" for k, v in current_cookies.items()])
616            if cookie_header:
617                if 'headers' not in kwargs:
618                    kwargs['headers'] = {}
619                kwargs['headers']['Cookie'] = cookie_header
620            timeout = kwargs.get('timeout', 10)
621            if 'timeout' in kwargs: del kwargs['timeout']
622            response = self.session.request(method, url, timeout=timeout, **kwargs)
623            if response is None:
624                self.log(f"请求 {url} 无响应")
625                return None
626            if response.status_code >= 400:
627                self.log(f"请求 {url} 返回状态码 {response.status_code}")
628            return response
629        except Exception as e:
630            self.log(f"请求 {url} 异常: {str(e)}")
631            return None
632
633    def ensure_login(self, max_attempts=3):
634        for attempt in range(1, max_attempts + 1):
635            if attempt > 1:
636                self.log(f"🔄 登录重试 {attempt}/{max_attempts}")
637            if not self.token_online and self.account_mobile:
638                self.load_token_from_cache()
639            if self.token_online and self.onLine():
640                self.save_token_to_cache()
641                return True
642            if not self.token_online:
643                if self.account_password:
644                    self.log("账号密码登录已失效,未找到可用 Token,跳过")
645                return False
646            if attempt < max_attempts:
647                time.sleep(2)
648        return False
649
650    def load_token_from_cache(self):
651        if not self.account_mobile:
652            return False
653        if not os.path.exists(UNICOM_TOKEN_CACHE_PATH):
654            return False
655        try:
656            with open(UNICOM_TOKEN_CACHE_PATH, 'r', encoding='utf-8') as f:
657                cache = json.load(f)
658            user_cache = cache.get(self.account_mobile)
659            if user_cache and user_cache.get('token_online'):
660                if (datetime.now().timestamp() * 1000) - user_cache.get('timestamp', 0) < 12 * 60 * 60 * 1000:
661                    self.token_online = user_cache['token_online']
662                    self.appId = user_cache.get('appId', self.appId)
663                    self.city_info = user_cache.get('city_info', [])
664                    self.update_session_cookies()
665                    self.log(f"♻️ [缓存复用] 成功加载本地 Token ({user_cache.get('time')})")
666                    return True
667        except Exception as e:
668            pass
669        return False
670
671    def save_token_to_cache(self):
672        if not self.account_mobile:
673            return
674        cache = {}
675        if os.path.exists(UNICOM_TOKEN_CACHE_PATH):
676             try:
677                with open(UNICOM_TOKEN_CACHE_PATH, 'r', encoding='utf-8') as f:
678                    cache = json.load(f)
679             except: pass
680        now = datetime.now()
681        cache[self.account_mobile] = {
682            "token_online": self.token_online,
683            "appId": self.appId,
684            "city_info": getattr(self, 'city_info', []),
685            "cookieString": "",
686            "timestamp": int(now.timestamp() * 1000),
687            "time": now.strftime('%Y-%m-%d %H:%M:%S')
688        }
689        try:
690            with open(UNICOM_TOKEN_CACHE_PATH, 'w', encoding='utf-8') as f:
691                json.dump(cache, f, indent=2, ensure_ascii=False)
692            self.log("💾 [缓存保存] Token 已写入本地文件")
693        except Exception as e:
694            self.log(f"❌ 保存缓存失败: {str(e)}")
695
696    def get_city_info(self):
697        try:
698            url = "https://m.client.10010.com/mobileService/business/get/getCity"
699            res = self.session.post(url, data={}, timeout=10).json()
700            if res.get('code') == '200' and res.get('list'):
701                 self.city_info = res.get('list')
702                 return True
703            return False
704        except:
705            return False
706
707    def queryRemain(self):
708        try:
709            if not self.ecs_token:
710                if not self.onLine():
711                    self.log("❌ 无法获取 ecs_token,跳过查询")
712                    return
713            self.log("==== 资产查询 ====")
714            self.log("正在查询套餐余量...")
715            url = "https://m.client.10010.com/servicequerybusiness/balancenew/accountBalancenew.htm"
716            headers = {
717                "User-Agent": COMMON_CONSTANTS["MARKET_UA"],
718                "Cookie": f"ecs_token={self.ecs_token}"
719            }
720            res = self.request("get", url, headers=headers)
721            if not res: return
722            result = res.json()
723            if result.get('code') == '0000':
724                current_balance = "0.00"
725                real_time_fee = "0.00"
726                if result.get('curntbalancecust'):
727                    current_balance = str(result['curntbalancecust'])
728                if result.get('realfeecust'):
729                    real_time_fee = str(result['realfeecust'])
730                self.log(f"💰 [资产-话费] 当前余额: {current_balance}元, 实时话费: {real_time_fee}元", notify=True)
731                pkg_list = result.get('realTimeFeeSpecialFlagThree', [])
732                if pkg_list and isinstance(pkg_list, list):
733                    self.log(f"    📋 [套餐详情]:", notify=True)
734                    for item in pkg_list:
735                        sub_items = item.get('subItems', [])
736                        if sub_items:
737                            for sub in sub_items:
738                                bill = sub.get('bill', {})
739                                if bill:
740                                    name = bill.get('integrateitem', '未知项')
741                                    fee = bill.get('realfee', '0.00')
742                                    self.log(f"       - {name}: {fee}元", notify=True)
743            else:
744                msg = result.get('desc') or result.get('msg') or "未知错误"
745                self.log(f"套餐余量查询失败: {msg}")
746        except Exception as e:
747            self.log(f"queryRemain 异常: {str(e)}")
748
749    def onLine(self):
750        if not self.token_online:
751             self.log("❌ 缺少 token_online,无法执行 onLine")
752             return False
753        try:
754            url = "https://m.client.10010.com/mobileService/onLine.htm"
755            data = {
756                'isFirstInstall': '1',
757                'netWay': 'Wifi',
758                'version': 'android@11.0000',
759                'token_online': self.token_online,
760                'provinceChanel': 'general',
761                'deviceModel': 'ALN-AL10',
762                'step': 'dingshi',
763                'androidId': '291a7deb1d716b5a',
764                'reqtime': int(time.time() * 1000)
765            }
766            if self.appId:
767                data['appId'] = self.appId
768            res = self.request('post', url, data=data)
769            if not res: return False
770            result = res.json()
771            code = result.get('code')
772            if code == '0' or code == 0:
773                self.valid = True
774                desmobile = result.get('desmobile', '')
775                if len(desmobile) == 11 and desmobile.isdigit():
776                    self.account_mobile = desmobile
777                    self.mobile = desmobile
778                elif desmobile.startswith("enc_"):
779                     if not self.account_mobile:
780                          self.log("⚠️ 注意: 服务端返回了加密手机号且未配置本地手机号")
781                self.log("登录成功")
782                self.city_info = result.get('list', [])
783                self.ecs_token = result.get('ecs_token')
784                self.t3_token = result.get('t3_token', '')
785                self.private_token = result.get('private_token', '')
786                return True
787            else:
788                self.log(f"登录失败[{code}]: {result.get('msg')}")
789                return False
790        except Exception as e:
791            self.log(f"onLine 异常: {str(e)}")
792            return False
793
794    def gettaskip(self):
795        orderId = self.random_string(32).upper()
796        try:
797            url = "https://m.client.10010.com/taskcallback/topstories/gettaskip"
798            data = {
799                "mobile": self.account_mobile,
800                "orderId": orderId
801            }
802            self.request("post", url, data=data)
803        except Exception as e:
804            pass
805        return orderId
806
807    def sign_getContinuous(self, is_query_only=False):
808        try:
809            url = "https://activity.10010.com/sixPalaceGridTurntableLottery/signin/getContinuous"
810            params = {
811                "taskId": "",
812                "channel": "wode",
813                "imei": self.uuid
814            }
815            res = self.request("get", url, params=params)
816            if not res: return
817            result = res.json()
818            code = result.get('code')
819            if code == "0000":
820                todayIsSignIn = result.get('data', {}).get('todayIsSignIn', 'n')
821                self.log(f"签到区今天{'已' if todayIsSignIn == 'y' else '未'}签到", notify=True)
822                if todayIsSignIn == 'y':
823                    pass
824                else:
825                    if not is_query_only:
826                        time.sleep(1)
827                        self.sign_daySign()
828                    else:
829                        self.log("签到区: [查询模式] 跳过自动打卡")
830            else:
831                self.log(f"签到区查询签到状态失败[{code}]: {result.get('desc', '')}")
832        except Exception as e:
833            self.log(f"sign_getContinuous 异常: {str(e)}")
834
835    def sign_daySign(self):
836        try:
837            url = "https://activity.10010.com/sixPalaceGridTurntableLottery/signin/daySign"
838            res = self.request("post", url, data={})
839            if not res: return
840            result = res.json()
841            code = result.get('code')
842            if code == "0000":
843                data = result.get('data', {})
844                msg = f"签到区签到成功: [{data.get('statusDesc', '')}]{data.get('redSignMessage', '')}"
845                self.log(msg)
846            elif code == "0002" and "已经签到" in result.get('desc', ''):
847                self.log("签到区签到成功: 今日已完成签到!")
848            else:
849                self.log(f"签到区签到失败[{code}]: {result.get('desc', '')}")
850        except Exception as e:
851            self.log(f"sign_daySign 异常: {str(e)}")
852
853    def sign_getTelephone(self, is_initial=False, silent=False):
854        try:
855            url = "https://act.10010.com/SigninApp/convert/getTelephone"
856            res = self.request("post", url, data={})
857            if not res: return None
858            result = res.json()
859            status = result.get('status')
860            if status == "0000" and result.get('data'):
861                tel_val = result['data'].get('telephone', 0)
862                try:
863                    current_amount = float(tel_val)
864                except:
865                    current_amount = 0.0
866                if silent:
867                    return current_amount
868                if is_initial:
869                    msg = f"签到区-话费红包: 运行前总额 {current_amount:.2f}元"
870                    self.sign_initial_amount = current_amount
871                else:
872                    if hasattr(self, 'sign_initial_amount'):
873                        increase = current_amount - self.sign_initial_amount
874                        self.log(f"签到区-话费红包: 本次运行增加 {increase:.2f}元", notify=True)
875                    msg = f"签到区-话费红包: 总额 {current_amount:.2f}元"
876                    exp_val = result['data'].get('needexpNumber', 0)
877                    try:
878                        exp_num = float(exp_val)
879                    except:
880                        exp_num = 0.0
881                    if exp_num > 0:
882                        msg += f",其中 {result['data'].get('needexpNumber', '0')}元 将于 {result['data'].get('month', '')}月底到期"
883                self.log(msg, notify=not is_initial)
884                return current_amount
885            else:
886                if not silent:
887                    self.log(f"签到区查询话费红包失败[{status}]: {result.get('msg', '')}")
888                return None
889        except Exception as e:
890            if not silent:
891                self.log(f"sign_getTelephone 异常: {str(e)}")
892            return None
893
894    def sign_getTaskList(self):
895        try:
896            url = "https://activity.10010.com/sixPalaceGridTurntableLottery/task/taskList"
897            headers = {"Referer": "https://img.client.10010.com/"}
898            for i in range(30):
899                res = self.request("get", url, params={"type": "2"}, headers=headers, timeout=10)
900                if not res: return
901                result = res.json()
902                code = result.get('code')
903                if code == "0329" or "火爆" in result.get('desc', ''):
904                    self.log("签到区: 系统繁忙(0329),停止后续尝试")
905                    break
906                if code != "0000":
907                    self.log(f"签到区-任务中心: 获取任务列表失败[{code}]: {result.get('desc', '')}")
908                    return
909                tag_list = result.get('data', {}).get('tagList', []) or []
910                task_list = result.get('data', {}).get('taskList', []) or []
911                all_tasks = task_list + [t for tag in tag_list for t in tag.get('taskDTOList', [])]
912                all_tasks = [t for t in all_tasks if t]
913                if not all_tasks:
914                    if i == 0: self.log("签到区-任务中心: 当前无任何任务。")
915                    break
916                do_task = next((t for t in all_tasks if t.get('taskState') == '1' and t.get('taskType') == '5'), None)
917                if do_task:
918                    self.log(f"签到区-任务中心: 开始执行任务 [{do_task.get('taskName')}]")
919                    self.sign_doTaskFromList(do_task)
920                    time.sleep(3)
921                    continue
922                claim_task = next((t for t in all_tasks if t.get('taskState') == '0'), None)
923                if claim_task:
924                    self.log(f"签到区-任务中心: 发现可领取奖励的任务 [{claim_task.get('taskName')}]")
925                    self.sign_getTaskReward(claim_task.get('id'))
926                    time.sleep(2)
927                    continue
928                if i == 0:
929                    self.log("签到区-任务中心: 没有可执行或可领取的任务。")
930                else:
931                    self.log("签到区-任务中心: 所有任务处理完毕。")
932                break
933        except Exception as e:
934            self.log(f"sign_getTaskList 异常: {str(e)}")
935
936    def sign_doTaskFromList(self, task):
937        try:
938            if task.get('url') and task['url'] != '1' and task['url'].startswith('http'):
939                 self.request("get", task['url'], headers={"Referer": "https://img.client.10010.com/"})
940                 self.log(f"签到区-任务中心: 浏览页面 [{task.get('taskName')}]")
941                 time.sleep(random.uniform(5, 7))
942            orderId = self.gettaskip()
943            url = "https://activity.10010.com/sixPalaceGridTurntableLottery/task/completeTask"
944            params = {
945                "taskId": task.get('id'),
946                "orderId": orderId,
947                "systemCode": "QDQD"
948            }
949            res = self.request("get", url, params=params)
950            if not res: return
951            result = res.json()
952            code = result.get('code')
953            if code == "0000":
954                self.log(f"签到区-任务中心: ✅ 任务 [{task.get('taskName')}] 已完成")
955            else:
956                self.log(f"签到区-任务中心: ❌ 任务 [{task.get('taskName')}] 完成失败[{code}]: {result.get('desc', '未知错误')}")
957        except Exception as e:
958             self.log(f"sign_doTaskFromList 异常: {str(e)}")
959
960    def sign_getTaskReward(self, task_id):
961        try:
962            url = "https://activity.10010.com/sixPalaceGridTurntableLottery/task/getTaskReward"
963            res = self.request("get", url, params={"taskId": task_id})
964            if not res: return
965            result = res.json()
966            code = result.get('code')
967            if code == "0000":
968                data = result.get('data', {})
969                if data.get('code') == '0000':
970                    self.log(f"签到区-领取奖励: [{data.get('prizeName', '')}] {data.get('prizeNameRed', '')}")
971                else:
972                    self.log(f"签到区-领取奖励失败[{data.get('code')}]: {result.get('desc') or data.get('desc')}")
973            else:
974                self.log(f"签到区-领取奖励失败[{code}]: {result.get('desc', '')}")
975        except Exception as e:
976            self.log(f"sign_getTaskReward 异常: {str(e)}")
977
978    def sign_month_sign_gift(self, is_query_only=False):
979        try:
980            url = "https://activity.10010.com/sixPalaceGridTurntableLottery/floor/getMonthSign"
981            headers = {"Referer": "https://img.client.10010.com/"}
982            res = self.request("get", url, headers=headers, timeout=10)
983            if not res: return
984            result = res.json()
985            code = result.get('code')
986            if code != "0000":
987                self.log(f"签到区-月签有礼: 查询失败[{code}]: {result.get('desc', '')}")
988                return
989            task_list = result.get('data', {}).get('taskList', []) or []
990            if not task_list:
991                self.log("签到区-月签有礼: 暂无月签任务")
992                return
993            claim_tasks = [
994                t for t in task_list
995                if str(t.get('taskStatus')) == "1" and t.get('taskId') and t.get('id')
996            ]
997            claimed_count = sum(1 for t in task_list if str(t.get('taskStatus')) == "2")
998            if is_query_only:
999                self.log(f"签到区-月签有礼: 可领取 {len(claim_tasks)} 个,已领取 {claimed_count} 个")
1000                return
1001            if not claim_tasks:
1002                self.log(f"签到区-月签有礼: 暂无可领取奖励,已领取 {claimed_count}/{len(task_list)}")
1003                return
1004            for task in claim_tasks:
1005                self.sign_get_month_sign_reward(task)
1006                time.sleep(1)
1007        except Exception as e:
1008            self.log(f"sign_month_sign_gift 异常: {str(e)}")
1009
1010    def sign_get_month_sign_reward(self, task):
1011        task_name = task.get('taskName') or "月签奖励"
1012        try:
1013            url = "https://activity.10010.com/sixPalaceGridTurntableLottery/task/getTaskReward"
1014            params = {
1015                "taskId": task.get('taskId'),
1016                "taskType": "30",
1017                "id": task.get('id')
1018            }
1019            headers = {"Referer": "https://img.client.10010.com/"}
1020            res = self.request("get", url, params=params, headers=headers, timeout=10)
1021            if not res: return
1022            result = res.json()
1023            code = result.get('code')
1024            data = result.get('data', {}) or {}
1025            if code == "0000" and data.get('code') == "0000":
1026                prize_name = data.get('prizeName', '')
1027                prize_red = data.get('prizeNameRed', '')
1028                reward = f"[{prize_name}] {prize_red}".strip() if prize_name or prize_red else data.get('statusDesc', '领取成功')
1029                self.log(f"签到区-月签有礼: [{task_name}] {reward}", notify=True)
1030                return
1031            msg = data.get('desc') or result.get('desc') or result.get('msg') or "未知错误"
1032            self.log(f"签到区-月签有礼: [{task_name}] 领取失败[{data.get('code') or code}]: {msg}")
1033        except Exception as e:
1034            self.log(f"sign_get_month_sign_reward 异常: {str(e)}")
1035
1036    def sign_grabCoupon(self):
1037        sc = globalConfig.get("sign_config", {})
1038        if not sc.get("run_grab_coupon", False):
1039             return
1040        self.log(f"⚔️ [抢兑阶段] 正在检查目标: {GRAB_AMOUNT}元 话费券...")
1041        candidates = []
1042        try:
1043            url = "https://act.10010.com/SigninApp/new_convert/prizeList"
1044            headers = {"Origin": "https://img.client.10010.com"}
1045            res = self.request("post", url, headers=headers)
1046            if res:
1047                list_res = res.json()
1048                if list_res.get('status') == "0000":
1049                    details = list_res.get('data', {}).get('datails', {})
1050                    tab_items = details.get('tabItems', [])
1051                    self.log(f"📋 [调试] 共获取到 {len(tab_items)} 个场次数据")
1052                    for tab in tab_items:
1053                        products = tab.get('timeLimitQuanListData', [])
1054                        round_time_str = tab.get('time', '')
1055                        round_date = None
1056                        try:
1057                            if round_time_str and ":" in round_time_str:
1058                                now = datetime.now()
1059                                date_str = now.strftime('%Y/%m/%d')
1060                                full_time_str = f"{date_str} {round_time_str}"
1061                                if len(round_time_str) <= 8:
1062                                    round_date = datetime.strptime(full_time_str, "%Y/%m/%d %H:%M")
1063                                else:
1064                                    round_date = datetime.strptime(round_time_str, "%Y-%m-%d %H:%M:%S")
1065                        except:
1066                            pass
1067                        for item in products:
1068                            p_name = item.get('product_name', '')
1069                            if str(GRAB_AMOUNT) in p_name and ("元" in p_name or "话费" in p_name):
1070                                 self.log(f"      ✅ 发现目标: {p_name} (ID: {item.get('product_id')})")
1071                                 candidates.append({
1072                                     "id": item.get('product_id'),
1073                                     "name": p_name,
1074                                     "typeCode": item.get('type_code') or '0',
1075                                     "timeStr": round_time_str,
1076                                     "startTime": round_date,
1077                                     "itemData": item
1078                                 })
1079        except Exception as e:
1080            self.log(f"❌ 获取奖品列表失败: {str(e)}")
1081        if not candidates:
1082            self.log(f"⚠️ 未在任何场次中匹配到名为 '{GRAB_AMOUNT}元' 的奖品。")
1083            return
1084        now = datetime.now()
1085        best_candidate = None
1086        min_diff = float('inf')
1087        for cand in candidates:
1088            start_time = cand['startTime']
1089            if not start_time: continue
1090            diff = (start_time - now).total_seconds()
1091            score = 0
1092            if diff > 0:
1093                score = diff
1094            elif diff > -600:
1095                score = abs(diff) + 10000
1096            else:
1097                score = abs(diff) + 90000
1098            if score < min_diff:
1099                min_diff = score
1100                best_candidate = cand
1101        if not best_candidate:
1102            best_candidate = candidates[0]
1103        self.log(f"🎯 最终锁定场次: [{best_candidate['timeStr']}] {best_candidate['name']}")
1104        if best_candidate['startTime']:
1105            start_time = best_candidate['startTime']
1106            wait_seconds = (start_time - datetime.now()).total_seconds()
1107            if wait_seconds > 0:
1108                if wait_seconds > 300:
1109                    self.log(f"⏳ 距离开抢还有 {wait_seconds:.1f} 秒,大于5分钟,暂不等待。建议在临近时间(如提前2分钟)再运行脚本。")
1110                    return
1111                self.log(f"⏳ 正在等待开抢... (剩余 {wait_seconds:.1f} 秒)")
1112                while (best_candidate['startTime'] - datetime.now()).total_seconds() > 0.5:
1113                    time.sleep(0.5)
1114            else:
1115                 self.log(f"⚡ 当前时间已超过场次时间 {abs(wait_seconds):.1f}s,直接抢兑!")
1116        self.sign_grab_execute(best_candidate)
1117
1118    def sign_grab_execute(self, candidate):
1119        for i in range(1, 6):
1120            self.log(f"🔥 [第{i}次冲击] 发起兑换请求...")
1121            try:
1122                data = {
1123                    "product_id": candidate['id'],
1124                    "typeCode": candidate['typeCode']
1125                }
1126                url = "https://act.10010.com/SigninApp/convert/prizeConvert"
1127                headers = {
1128                    "Origin": "https://img.client.10010.com",
1129                    "Referer": "https://img.client.10010.com/",
1130                    "X-Requested-With": "com.sinovatech.unicom.ui"
1131                }
1132                res = self.request("post", url, data=data, headers=headers)
1133                if not res: continue
1134                result = res.json()
1135                uuid_val = result.get('data', {}).get('uuid')
1136                status = result.get('status')
1137                if status == "0000" and uuid_val:
1138                    self.log(f"📝 [提交成功] 获取到工单号: {uuid_val},正在查询最终结果...")
1139                    check_url = "https://act.10010.com/SigninApp/convert/prizeConvertResult"
1140                    check_data = { "uuid": uuid_val }
1141                    check_res = self.request("post", check_url, data=check_data, headers=headers)
1142                    if not check_res: continue
1143                    final_res = check_res.json()
1144                    final_status = final_res.get('status')
1145                    if final_status == "0000":
1146                        self.log(f"🎉🎉🎉 [抢兑成功] 恭喜!已成功抢到目标奖品! 🎉🎉🎉", notify=True)
1147                        return
1148                    else:
1149                        err_code = final_res.get('data', {}).get('errorCode', '')
1150                        msg = final_res.get('msg', '') or final_res.get('message', '未知原因')
1151                        detail_msg = final_res.get('data', {}).get('rightBtn', {}).get('name', '')
1152                        log_msg = f"💔 [抢兑失败] 状态: {final_status}"
1153                        if err_code: log_msg += f" | 错误码: {err_code}"
1154                        if detail_msg: log_msg += f" | 详情: {detail_msg}"
1155                        log_msg += f" | 提示: {msg}"
1156                        self.log(log_msg, notify=True)
1157                else:
1158                    self.log(f"📝 提交结果: {result.get('msg') or result.get('message') or json.dumps(result)}")
1159                time.sleep(0.2)
1160            except Exception as e:
1161                self.log(f"❌ 抢兑异常: {str(e)}")
1162
1163    def get_wocare_body(self, apiCode, requestData={}):
1164        timestamp = datetime.now().strftime('%Y%m%d%H%M%S') + str(int(datetime.now().microsecond / 1000)).zfill(3)
1165        encodedContent = base64.b64encode(json.dumps(requestData, separators=(',', ':')).encode('utf-8')).decode('utf-8')
1166        body = {
1167            "version": WOCARE_CONSTANTS["minRetries"],
1168            "apiCode": apiCode,
1169            "channelId": WOCARE_CONSTANTS["anotherApiKey"],
1170            "transactionId": timestamp + self.random_string(6, "0123456789"),
1171            "timeStamp": timestamp,
1172            "messageContent": encodedContent
1173        }
1174        params_array = []
1175        for key in sorted(body.keys()):
1176            params_array.append(f"{key}={body[key]}")
1177        params_array.append(f"sign={WOCARE_CONSTANTS['anotherEncryptionKey']}")
1178        sign_str = "&".join(params_array)
1179        body["sign"] = hashlib.md5(sign_str.encode('utf-8')).hexdigest()
1180        return body
1181
1182    def wocare_api(self, apiCode, requestData={}):
1183        try:
1184            url = f"https://wocare.unisk.cn/api/v1/{apiCode}"
1185            body = self.get_wocare_body(apiCode, requestData)
1186            res = self.request("post", url, data=body)
1187            if not res: return None
1188            result = res.json()
1189            if result.get("messageContent"):
1190                try:
1191                    content = result["messageContent"]
1192                    content = content.replace('\n', '').replace('\r', '').replace(' ', '')
1193                    content = content.replace('-', '+').replace('_', '/')
1194                    missing_padding = len(content) % 4
1195                    if missing_padding:
1196                        content += '=' * (4 - missing_padding)
1197                    try:
1198                        decoded_bytes = base64.b64decode(content)
1199                        decoded_str = decoded_bytes.decode('utf-8')
1200                    except UnicodeDecodeError:
1201                        decoded_str = decoded_bytes.decode('utf-8', errors='replace')
1202                    except Exception as e:
1203                        decoded_str = "{}"
1204                    try:
1205                        decoded = json.loads(decoded_str, strict=False)
1206                    except:
1207                        decoded_str = re.sub(r'[\x00-\x1f\x7f]', '', decoded_str)
1208                        try:
1209                            decoded = json.loads(decoded_str, strict=False)
1210                        except:
1211                            decoded = {}
1212                    if isinstance(decoded, dict):
1213                        if "data" in decoded:
1214                            result["data"] = decoded["data"]
1215                        else:
1216                            result["data"] = decoded
1217                        if "resultMsg" in decoded:
1218                            result["resultMsg"] = decoded["resultMsg"]
1219                        if "resultCode" in decoded:
1220                            result["resultCode"] = decoded["resultCode"]
1221                except Exception as e:
1222                    self.log(f"联通祝福: 解析返回失败: {str(e)}")
1223            return result
1224        except Exception as e:
1225            self.log(f"wocare_api 异常: {str(e)}")
1226            return None
1227
1228    def wocare_getToken(self, ticket):
1229        try:
1230            url = "https://wocare.unisk.cn/mbh/getToken"
1231            params = {
1232                "channelType": WOCARE_CONSTANTS["serviceLife"],
1233                "type": "02",
1234                "ticket": ticket,
1235                "version": COMMON_CONSTANTS["APP_VERSION"],
1236                "timestamp": datetime.now().strftime('%Y%m%d%H%M%S') + str(int(datetime.now().microsecond / 1000)).zfill(3),
1237                "desmobile": self.account_mobile,
1238                "num": "0",
1239                "postage": self.random_string(32),
1240                "homePage": "home",
1241                "duanlianjieabc": "qAz2m",
1242                "userNumber": self.account_mobile
1243            }
1244            res = self.session.get(url, params=params, allow_redirects=False, timeout=15)
1245            if res.status_code == 302:
1246                location = res.headers.get("Location", "")
1247                if location:
1248                    parsed = urlparse(location)
1249                    sid = parse_qs(parsed.query).get("sid", [None])[0]
1250                    if not sid:
1251                        sid = parse_qs(parsed.query).get("uuid", [None])[0]
1252                        if sid:
1253                            self.log(f"联通祝福: 未找到sid,使用uuid替代: {sid}")
1254                    if sid:
1255                        self.wocare_sid = sid
1256                        return self.wocare_loginmbh()
1257                    else:
1258                        self.log(f"联通祝福: 没有获取到sid或uuid, Location: {location}")
1259                else:
1260                    self.log("联通祝福: 没有获取到location")
1261            else:
1262                self.log(f"联通祝福: 获取sid失败[{res.status_code}]")
1263        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as ce:
1264            self.log("联通祝福: 连接wocare服务失败,可能服务已关闭或网络不可达")
1265        except Exception as e:
1266            self.log(f"wocare_getToken 异常: {str(e)}")
1267        return False
1268
1269    def wocare_loginmbh(self):
1270        try:
1271            apiCode = "loginmbh"
1272            requestData = {
1273                "sid": self.wocare_sid,
1274                "channelType": WOCARE_CONSTANTS["serviceLife"],
1275                "apiCode": apiCode
1276            }
1277            result = self.wocare_api(apiCode, requestData)
1278            if not result: return False
1279            responseResult = result
1280            resultCode = responseResult.get("resultCode", "-1")
1281            if resultCode == "0000":
1282                self.wocare_token = responseResult.get("data", {}).get("token")
1283                self.log("联通祝福: 登录成功")
1284                return True
1285            else:
1286                msg = responseResult.get("resultMsg") or responseResult.get("resultDesc") or ""
1287                self.log(f"联通祝福: 登录失败[{resultCode}]: {msg}")
1288        except Exception as e:
1289            self.log(f"wocare_loginmbh 异常: {str(e)}")
1290        return False
1291
1292    def wocare_getDrawTask(self, activity):
1293        try:
1294            apiCode = "getDrawTask"
1295            requestData = {
1296                "token": self.wocare_token,
1297                "channelType": WOCARE_CONSTANTS["serviceLife"],
1298                "type": activity["id"],
1299                "apiCode": apiCode
1300            }
1301            result = self.wocare_api(apiCode, requestData)
1302            responseResult = result if result else {}
1303            resultCode = responseResult.get("resultCode", "-1")
1304            if resultCode == "0000":
1305                taskList = responseResult.get("data", {}).get("taskList", []) or []
1306                if not taskList:
1307                    pass
1308                else:
1309                    self.log(f"联通祝福: [{activity['name']}] 查询到 {len(taskList)} 个任务")
1310                    for task in taskList:
1311                        ts = task.get("taskStatus")
1312                        if str(ts) == "0" or not ts:
1313                            self.wocare_completeTask(activity, task)
1314            else:
1315                msg = responseResult.get("resultMsg") or responseResult.get("resultDesc") or ""
1316                self.log(f"联通祝福: [{activity['name']}]查询任务失败[{resultCode}]: {msg}")
1317        except Exception as e:
1318            self.log(f"wocare_getDrawTask 异常: {str(e)}")
1319
1320    def wocare_completeTask(self, activity, task, taskStep="1"):
1321        try:
1322            taskTitle = task.get("title", "")
1323            action = "领取任务" if taskStep == "1" else "完成任务"
1324            apiCode = "completeTask"
1325            requestData = {
1326                "token": self.wocare_token,
1327                "channelType": WOCARE_CONSTANTS["serviceLife"],
1328                "task": task.get("id"),
1329                "taskStep": taskStep,
1330                "type": activity["id"],
1331                "apiCode": apiCode
1332            }
1333            result = self.wocare_api(apiCode, requestData)
1334            responseResult = result if result else {}
1335            resultCode = responseResult.get("resultCode", "-1")
1336            if resultCode == "0000":
1337                self.log(f"联通祝福: {action}[{taskTitle}]成功")
1338                if taskStep == "1":
1339                    time.sleep(1)
1340                    self.wocare_completeTask(activity, task, "4")
1341            else:
1342                msg = responseResult.get("resultMsg") or responseResult.get("resultDesc") or ""
1343                self.log(f"联通祝福: [{activity['name']}]{action}[{taskTitle}]失败[{resultCode}]: {msg}")
1344        except Exception as e:
1345            self.log(f"wocare_completeTask 异常: {str(e)}")
1346
1347    def wocare_getSpecificityBanner(self):
1348        try:
1349            apiCode = "getSpecificityBanner"
1350            requestData = {
1351                "token": self.wocare_token,
1352                "apiCode": apiCode
1353            }
1354            result = self.wocare_api(apiCode, requestData)
1355            responseResult = result if result else {}
1356            resultCode = responseResult.get("resultCode", "-1")
1357            if resultCode == "0000":
1358                bannerList = responseResult.get("data", []) or []
1359                if not bannerList:
1360                    self.log(f"联通祝福: 获取动态 Banner 列表为空,接口明细: {responseResult}")
1361                for banner in bannerList:
1362                    if str(banner.get("activityStatus")) == "0" and str(banner.get("isDeleted")) == "0":
1363                        self.wocare_getDrawTask(banner)
1364                        self.wocare_loadInit(banner)
1365            else:
1366                msg = responseResult.get("resultMsg") or responseResult.get("resultDesc", "")
1367                self.log(f"联通祝福: 进入活动失败[{resultCode}]: {msg}")
1368        except Exception as e:
1369            self.log(f"wocare_getSpecificityBanner 异常: {str(e)}")
1370
1371    def wocare_loadInit(self, activity):
1372        try:
1373            apiCode = "loadInit"
1374            requestData = {
1375                "token": self.wocare_token,
1376                "channelType": WOCARE_CONSTANTS["serviceLife"],
1377                "type": activity["id"],
1378                "apiCode": apiCode
1379            }
1380            result = self.wocare_api(apiCode, requestData)
1381            responseResult = result if result else {}
1382            resultCode = responseResult.get("resultCode", "-1")
1383            if resultCode == "0000":
1384                responseData = responseResult.get("data", {}) or {}
1385                activeModuleGroupId = responseData.get("zActiveModuleGroupId")
1386                drawCount = 0
1387                aid = activity["id"]
1388                if aid == 2:
1389                    isPartake = responseData.get("data", {}).get("isPartake") or 0
1390                    if not isPartake:
1391                        drawCount = 1
1392                elif aid == 3:
1393                    drawCount = int(responseData.get("raffleCountValue", 0) or 0)
1394                elif aid == 4:
1395                    drawCount = int(responseData.get("mhRaffleCountValue", 0) or 0)
1396                if drawCount > 0:
1397                     self.log(f"联通祝福: [{activity['name']}] 可抽奖次数 {drawCount}")
1398                else:
1399                     self.log(f"联通祝福: [{activity['name']}] 今日已无抽奖机会")
1400                while drawCount > 0:
1401                    time.sleep(2)
1402                    self.wocare_luckDraw(activity, activeModuleGroupId)
1403                    drawCount -= 1
1404            else:
1405                msg = responseResult.get("resultMsg") or responseResult.get("resultDesc") or ""
1406                self.log(f"联通祝福: [{activity['name']}]查询活动失败[{resultCode}]: {msg}")
1407        except Exception as e:
1408            self.log(f"wocare_loadInit 异常: {str(e)}")
1409
1410    def wocare_luckDraw(self, activity, activeModuleGroupId):
1411        try:
1412            apiCode = "luckDraw"
1413            requestData = {
1414                "token": self.wocare_token,
1415                "channelType": WOCARE_CONSTANTS["serviceLife"],
1416                "zActiveModuleGroupId": activeModuleGroupId,
1417                "type": activity["id"],
1418                "apiCode": apiCode
1419            }
1420            result = self.wocare_api(apiCode, requestData)
1421            responseResult = result if result else {}
1422            resultCode = responseResult.get("resultCode", "-1")
1423            if resultCode == "0000":
1424                resultData = responseResult.get("data", {}) or {}
1425                drawResultCode = resultData.get("resultCode", "-1")
1426                if drawResultCode == "0000":
1427                    prize = resultData.get("data", {}).get("prize", {})
1428                    prizeName = prize.get("prizeName", "")
1429                    prizeDesc = prize.get("prizeDesc", "")
1430                    self.log(f"联通祝福: [{activity['name']}]抽奖: {prizeName}[{prizeDesc}]", notify=True)
1431                else:
1432                    msg = responseResult.get("resultMsg") or responseResult.get("resultDesc") or ""
1433                    if msg.lower() == "success":
1434                        self.log(f"联通祝福: [{activity['name']}] 未中奖 (继续努力)")
1435                    else:
1436                        self.log(f"联通祝福: [{activity['name']}] 抽奖并未中奖: {msg}")
1437            else:
1438                msg = responseResult.get("resultMsg") or responseResult.get("resultDesc") or ""
1439                if msg.lower() == "success":
1440                    self.log(f"联通祝福: [{activity['name']}] 未中奖 (继续努力)")
1441                else:
1442                    self.log(f"联通祝福: [{activity['name']}] 抽奖异常[{resultCode}]: {msg}")
1443        except Exception as e:
1444            self.log(f"wocare_luckDraw 异常: {str(e)}")
1445
1446    def parse_jwt_payload(self, token):
1447        try:
1448            payload = token.split('.')[1]
1449            padding = len(payload) % 4
1450            if padding:
1451                payload += '=' * (4 - padding)
1452            payload = payload.replace('-', '+').replace('_', '/')
1453            decoded_bytes = base64.b64decode(payload)
1454            return json.loads(decoded_bytes.decode('utf-8'))
1455        except Exception as e:
1456            self.log(f"JWT Decode Error: {e}")
1457            return {}
1458
1459    def generate_market_signature_headers(self, user_token, query_string="", json_body=""):
1460        try:
1461            token = user_token.replace('Bearer ', '')
1462            payload = self.parse_jwt_payload(token)
1463            login_id = payload.get('loginId', '')
1464            app_secret = hashlib.md5(f"al:ak:{login_id}".encode('utf-8')).hexdigest()
1465            nonce = str(uuid.uuid4())
1466            message = f"{login_id}{app_secret}{nonce}{query_string or ''}{json_body or ''}"
1467            signature = base64.b64encode(
1468                hmac.new(
1469                    app_secret.encode('utf-8'),
1470                    message.encode('utf-8'),
1471                    digestmod=hashlib.sha256
1472                ).digest()
1473            ).decode('utf-8')
1474            return {
1475                'X-User-Id': login_id,
1476                'X-Nonce': nonce,
1477                'X-Timestamp': str(int(time.time() * 1000)),
1478                'X-Signature': signature,
1479                'Content-Type': 'application/json'
1480            }
1481        except Exception as e:
1482            self.log(f"Signature Generation Error: {e}")
1483            return {}
1484
1485    def get_market_headers(self, user_token):
1486        return {
1487            'User-Agent': COMMON_CONSTANTS['MARKET_UA'],
1488            'Authorization': f"Bearer {user_token}",
1489            'Content-Type': 'application/json',
1490            'X-Requested-With': 'com.sinovatech.unicom.ui'
1491        }
1492
1493    def market_get_ticket(self):
1494        self.log("权益超市: 正在获取 ticket...")
1495        target_url = "https://contact.bol.wo.cn/market"
1496        res = self.openPlatLineNew(target_url)
1497        if res and 'ticket' in res:
1498            self.log("权益超市: 获取ticket成功")
1499            return res['ticket']
1500        self.log("权益超市: 获取ticket失败")
1501        return None
1502
1503    def market_get_user_token(self, ticket):
1504        url = f"https://backward.bol.wo.cn/prod-api/auth/marketUnicomLogin?ticket={ticket}"
1505        headers = {
1506            'User-Agent': COMMON_CONSTANTS['MARKET_UA'],
1507            'Connection': "Keep-Alive",
1508            'Accept-Encoding': "gzip",
1509        }
1510        for attempt in range(1, 4):
1511            try:
1512                self.log(f"权益超市: 正在获取 userToken...{f' (第{attempt}次重试)' if attempt > 1 else ''}")
1513                res = self.session.post(url, headers=headers, timeout=30).json()
1514                if res.get('code') == 200:
1515                    user_token = res.get('data', {}).get('token')
1516                    if user_token:
1517                        self.log("权益超市: 获取userToken成功")
1518                        return user_token
1519                self.log(f"权益超市: 获取userToken失败: {res.get('msg')}")
1520            except Exception as e:
1521                self.log(f"权益超市: 获取userToken异常: {e}")
1522            if attempt < 3:
1523                self.log(f"权益超市: 等待5秒后重试...")
1524                time.sleep(5)
1525        return None
1526
1527    def market_get_raffle(self, user_token):
1528        self.log("权益超市: 正在查询奖品池...")
1529        try:
1530            timestamp = int(time.time() * 1000)
1531            query_string = f"id=12&timeVerRan={timestamp}"
1532            json_body = "{}"
1533            sig_headers = self.generate_market_signature_headers(user_token, query_string, json_body)
1534            url = f"https://backward.bol.wo.cn/prod-api/promotion/home/raffleActivity/prizeList?{query_string}"
1535            headers = self.get_market_headers(user_token)
1536            headers.update(sig_headers)
1537            headers['Referer'] = 'https://contact.bol.wo.cn/market'
1538            headers['Origin'] = 'https://contact.bol.wo.cn'
1539            res = self.session.post(url, headers=headers, data=json_body).json()
1540            if res.get('code') == 200 and isinstance(res.get('data'), list):
1541                keywords = ['月卡', '月会员', '月度', 'VIP月', '一个月', '周卡']
1542                exclude = ['5G宽视界', '沃视频']
1543                live_prizes = []
1544                for p in res['data']:
1545                    vip_prob = float(p.get('probabilityVip') or p.get('newVipProbability') or 0)
1546                    norm_prob = float(p.get('probability') or 0)
1547                    name = p.get('name', '')
1548                    daily_limit = int(p.get('dailyPrizeLimit') or 0)
1549                    match = any(k in name for k in keywords)
1550                    not_excluded = not any(e in name for e in exclude)
1551                    has_stock = daily_limit > 0
1552                    has_chance = norm_prob > 0 or vip_prob > 0
1553                    if match and not_excluded and has_stock and has_chance:
1554                        live_prizes.append(p)
1555                        total_limit = int(p.get('quantity') or 0)
1556                        self.log(f"权益超市: 【{name}】监测到放水 (日库存:{daily_limit}, 总库存:{total_limit}, 普通概率:{(norm_prob * 100):.4f}%, VIP概率:{(vip_prob * 100):.4f}%)")
1557                if live_prizes:
1558                    return True
1559            self.log("权益超市: 📢 未监测到高价值权益放水")
1560            return False
1561        except Exception as e:
1562            self.log(f"权益超市: 查询奖品池异常: {e}")
1563            return False
1564
1565    def market_get_raffle_count(self, user_token):
1566        try:
1567            timestamp = int(time.time() * 1000)
1568            query_string = f"id=12&channel=unicomTab&timeVerRan={timestamp}"
1569            json_body = "{}"
1570            sig_headers = self.generate_market_signature_headers(user_token, query_string, json_body)
1571            url = f"https://backward.bol.wo.cn/prod-api/promotion/home/raffleActivity/getUserRaffleCountExt?{query_string}"
1572            headers = self.get_market_headers(user_token)
1573            headers.update(sig_headers)
1574            headers['Referer'] = 'https://contact.bol.wo.cn/market'
1575            headers['Origin'] = 'https://contact.bol.wo.cn'
1576            res = self.session.post(url, headers=headers, data=json_body).json()
1577            count = 0
1578            if res.get('code') == 200:
1579                data = res.get('data')
1580                if isinstance(data, dict):
1581                    count = int(data.get('raffleCount') or 0)
1582                else:
1583                    count = int(data or 0)
1584            if count > 0:
1585                self.log(f"权益超市: ✅ 当前抽奖次数: {count}")
1586                for i in range(count):
1587                    self.log(f"权益超市: 🎯 第 {i+1} 次抽奖...")
1588                    if not self.market_user_raffle(user_token):
1589                        break
1590                    time.sleep(3 + random.random() * 2)
1591            else:
1592                self.log("权益超市: 当前无抽奖次数")
1593        except Exception as e:
1594            self.log(f"权益超市: 查询抽奖次数异常: {e}")
1595
1596    def market_user_raffle(self, user_token):
1597        try:
1598            timestamp = int(time.time() * 1000)
1599            query_string = f"id=12&channel=unicomTab&timeVerRan={timestamp}"
1600            json_body = "{}"
1601            sig_headers = self.generate_market_signature_headers(user_token, query_string, json_body)
1602            url = f"https://backward.bol.wo.cn/prod-api/promotion/home/raffleActivity/userRaffle?{query_string}"
1603            headers = self.get_market_headers(user_token)
1604            headers.update(sig_headers)
1605            headers['Referer'] = 'https://contact.bol.wo.cn/market'
1606            res = self.session.post(url, headers=headers, data=json_body).json()
1607            if res.get('code') == 200:
1608                data = res.get('data', {})
1609                prize_name = data.get('prizesName', '')
1610                message = data.get('message') or res.get('msg') or ""
1611                if prize_name and "谢谢参与" not in prize_name:
1612                    self.log(f"权益超市: 🎉 抽奖成功: {prize_name}", notify=True)
1613                    return True
1614                self.log(f"权益超市: 💨 未中奖: {message}", notify=True)
1615                return True
1616            self.log(f"权益超市: 抽奖失败: {res.get('msg')}")
1617            return False
1618        except Exception as e:
1619            self.log(f"权益超市: 抽奖异常: {e}")
1620            return False
1621
1622    def market_get_all_tasks(self, ecs_token, user_token):
1623        url = "https://backward.bol.wo.cn/prod-api/promotion/activityTask/getAllActivityTasks?activityId=12"
1624        headers = {
1625            "Authorization": f"Bearer {user_token}",
1626            "User-Agent": COMMON_CONSTANTS["MARKET_UA"],
1627            "Origin": "https://contact.bol.wo.cn",
1628            "Referer": "https://contact.bol.wo.cn/",
1629            "Cookie": f"ecs_token={ecs_token}"
1630        }
1631        for attempt in range(1, 4):
1632            try:
1633                self.log(f"权益超市: 正在获取任务列表...{f' (第{attempt}次重试)' if attempt > 1 else ''}")
1634                res = self.session.get(url, headers=headers, timeout=15).json()
1635                if res.get('code') == 200:
1636                    tasks = res.get('data', {}).get('activityTaskUserDetailVOList', [])
1637                    self.log(f"权益超市: 成功获取到 {len(tasks)} 个任务")
1638                    return tasks
1639                self.log(f"权益超市: 查询任务列表失败: {res.get('msg')}")
1640            except Exception as e:
1641                self.log(f"权益超市: 获取任务列表异常: {e}")
1642            if attempt < 3:
1643                self.log("权益超市: 等待5秒后重试...")
1644                time.sleep(5)
1645        return []
1646
1647    def market_do_share_list(self, share_list, user_token):
1648        self.log("权益超市: 开始执行任务...")
1649        for task in share_list:
1650            name = task.get('name', '')
1651            param = task.get('param1', '')
1652            trigger_time = task.get('triggerTime', 0)
1653            triggered_time = task.get('triggeredTime', 0)
1654            if any(k in name for k in ["购买", "秒杀"]):
1655                 self.log(f"权益超市: 🚫 {name} [跳过]")
1656                 continue
1657            if triggered_time >= trigger_time:
1658                 self.log(f"权益超市: ✅ {name} [已完成]")
1659                 continue
1660            url = ""
1661            if any(k in name for k in ["浏览", "查看"]):
1662                url = f"https://backward.bol.wo.cn/prod-api/promotion/activityTaskShare/checkView?checkKey={param}"
1663            elif "分享" in name:
1664                url = f"https://backward.bol.wo.cn/prod-api/promotion/activityTaskShare/checkShare?checkKey={param}"
1665            if url:
1666                try:
1667                    headers = {
1668                        "Authorization": f"Bearer {user_token}",
1669                        "User-Agent": COMMON_CONSTANTS["MARKET_UA"],
1670                        "Origin": "https://contact.bol.wo.cn",
1671                        "Referer": "https://contact.bol.wo.cn/"
1672                    }
1673                    res = self.session.post(url, json={}, headers=headers, timeout=15).json()
1674                    if res.get('code') == 200:
1675                        self.log(f"权益超市: ✅ {name} [执行成功]")
1676                    else:
1677                        self.log(f"权益超市: ❌ {name} [执行失败]: {res.get('msg')}")
1678                except Exception as e:
1679                    self.log(f"权益超市: ❌ {name} [执行异常]: {e}")
1680            time.sleep(2)
1681
1682    def market_task(self, is_query_only=False):
1683        self.log("==== 权益超市 ====")
1684        self.log("权益超市-会员中心: 浏览积分任务已下线,已跳过")
1685        ticket = self.market_get_ticket()
1686        if not ticket:
1687            return
1688        user_token = self.market_get_user_token(ticket)
1689        if not user_token:
1690            return
1691        if is_query_only:
1692            self.query_market_raffle_records(user_token)
1693            self.query_phone_recharge_records(user_token)
1694            return
1695        mc = globalConfig.get("market_config", {})
1696        if mc.get("run_task", True):
1697            if hasattr(self, 'ecs_token'):
1698                share_list = self.market_get_all_tasks(self.ecs_token, user_token)
1699                if share_list:
1700                    self.market_do_share_list(share_list, user_token)
1701            else:
1702                 self.log("权益超市: 缺 ecs_token, 跳过通用任务列表")
1703        else:
1704            self.log("权益超市-做任务: ⏭️ 已被总开关关闭,跳过")
1705        if mc.get("run_draw", True):
1706            if self.market_get_raffle(user_token):
1707                self.market_get_raffle_count(user_token)
1708        else:
1709            self.log("权益超市-抽奖: ⏭️ 已被总开关关闭,跳过")
1710        if mc.get("run_claim", False):
1711            self.log("权益超市-领奖: 自动领奖已开启")
1712            self.query_phone_recharge_records(user_token)
1713        else:
1714            self.log("权益超市-领奖: ⏭️ 未开启自动领奖")
1715        self.query_market_raffle_records(user_token)
1716        self.query_phone_recharge_records(user_token)
1717
1718    def init_cloud_urls(self):
1719        if not hasattr(self, 'cloudDiskUrls'):
1720            self.cloudDiskUrls = {
1721                'getTicketByNative': "https://m.client.10010.com/edop_ng/getTicketByNative",
1722                'ltypDispatcher': "https://panservice.mail.wo.cn/wohome/dispatcher",
1723                'wohomeDispatcher': "https://s.pan.wo.cn/wohome/dispatcher",
1724                'getScanState': "https://s.pan.wo.cn/wohome/intelligentClean/getScanStateAndResult",
1725                'getCleanData': "https://s.pan.wo.cn/wohome/intelligentClean/getCleanData",
1726                'batchClean': "https://s.pan.wo.cn/wohome/intelligentClean/batchClean",
1727            }
1728
1729    def getTicketByNative_cloud(self):
1730        for attempt in range(1, 4):
1731            try:
1732                url = f"{self.cloudDiskUrls['getTicketByNative']}?appId=edop_unicom_d67b3e30&token={self.ecs_token}"
1733                headers = {
1734                    'User-Agent': "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0301}",
1735                    'Connection': "Keep-Alive",
1736                    'Accept-Encoding': "gzip",
1737                }
1738                res = self.session.get(url, headers=headers).json()
1739                if res.get('ticket'):
1740                    self.cloudDisk.ticket = res['ticket']
1741                    return res['ticket']
1742                elif str(res.get('code')) == "9999":
1743                    self.log(f"getTicketByNative_cloud 票据失效或被拦截: {res}")
1744            except Exception as e:
1745                err_msg = str(e)
1746                if attempt < 3 and os.environ.get("UNICOM_PROXY_API") and ("Max retries exceeded" in err_msg or "timed out" in err_msg.lower() or "connection" in err_msg.lower() or "SOCKS" in err_msg):
1747                    self.log(f"getTicketByNative_cloud 第{attempt}次异常触发故障转移: {err_msg}")
1748                    self.failover_proxy()
1749                    continue
1750                self.log(f"getTicketByNative_cloud 第{attempt}次重试 - 异常: {e}")
1751                time.sleep(2)
1752        return None
1753
1754    def get_ltypDispatcher_cloud(self, ticket):
1755        for attempt in range(1, 4):
1756            try:
1757                timestamp = str(int(time.time() * 1000))
1758                result_rnd = str(random.randint(123456, 199999))
1759                string_to_hash = "HandheldHallAutoLoginV2" + timestamp + result_rnd + "wohome"
1760                sign = hashlib.md5(string_to_hash.encode()).hexdigest()
1761                payload = {
1762                    "header": {
1763                        "key": "HandheldHallAutoLoginV2",
1764                        "resTime": timestamp,
1765                        "reqSeq": result_rnd,
1766                        "channel": "wohome",
1767                        "version": "",
1768                        "sign": sign
1769                    },
1770                    "body": {
1771                        "clientId": "1001000003",
1772                        "ticket": ticket
1773                    }
1774                }
1775                url = self.cloudDiskUrls['ltypDispatcher']
1776                headers = {'User-Agent': "Dalvik/2.1.0 (Linux; U; Android 12; leijun Pro Build/SKQ1.22013.001);unicom{version:android@11.0702}"}
1777                res = self.session.post(url, json=payload, headers=headers).json()
1778                token = res.get('RSP', {}).get('DATA', {}).get('token')
1779                if token:
1780                    self.cloudDisk.userToken = token
1781                    return token
1782            except Exception as e:
1783                 err_msg = str(e)
1784                 if attempt < 3 and os.environ.get("UNICOM_PROXY_API") and ("Max retries exceeded" in err_msg or "timed out" in err_msg.lower() or "connection" in err_msg.lower() or "SOCKS" in err_msg):
1785                     self.log(f"get_ltypDispatcher_cloud 第{attempt}次异常触发故障转移: {err_msg}")
1786                     self.failover_proxy()
1787                     continue
1788                 self.log(f"get_ltypDispatcher_cloud 第{attempt}次重试 - 异常: {e}")
1789                 time.sleep(2)
1790        return None
1791
1792    def get_cloud_upload_name_cloud(self):
1793        return os.environ.get("UNICOM_CLOUD_UPLOAD_FILENAME", "8648").strip() or "8648"
1794
1795    def encrypt_data_cloud(self, text, token):
1796        key_padded = str(token).ljust(16)[:16]
1797        cipher = AES.new(key_padded.encode(), AES.MODE_CBC, b"wNSOYIB1k1DjY5lA")
1798        return base64.b64encode(cipher.encrypt(pad(str(text).encode(), AES.block_size, style="pkcs7"))).decode()
1799
1800    def query_all_files_cloud(self, space_type="0", parent_directory_id="0", page_num=0, page_size=500):
1801        token = getattr(self.cloudDisk, 'userToken', '')
1802        if not token:
1803            return {}
1804        res = self.request_wohome_dispatcher_cloud("QueryAllFiles", {
1805            "clientId": "1001000035",
1806            "spaceType": str(space_type),
1807            "sortRule": "0",
1808            "parentDirectoryId": str(parent_directory_id),
1809            "pageNum": str(page_num),
1810            "pageSize": int(page_size),
1811        }, timeout=15)
1812        rsp = res.get('RSP', {})
1813        if str(rsp.get('RSP_CODE')) != '0000' or not rsp.get('DATA'):
1814            return {}
1815        try:
1816            key_padded = token.ljust(16)[:16]
1817            cipher = AES.new(key_padded.encode(), AES.MODE_CBC, b"wNSOYIB1k1DjY5lA")
1818            plain = unpad(cipher.decrypt(base64.b64decode(rsp['DATA'])), AES.block_size, style="pkcs7").decode('utf-8', errors='ignore')
1819            return json.loads(plain)
1820        except Exception as e:
1821            self.log(f"云盘任务: 查询根目录文件失败: {e}")
1822            return {}
1823
1824    def request_wohome_dispatcher_cloud(self, key, param, timeout=15, client_id="1001000035"):
1825        token = getattr(self.cloudDisk, 'userToken', '')
1826        if not token:
1827            return {}
1828        timestamp = str(int(time.time() * 1000))
1829        req_seq = str(random.randint(10000, 99999))
1830        payload = {
1831            "header": {
1832                "key": key,
1833                "resTime": timestamp,
1834                "reqSeq": req_seq,
1835                "channel": "wohome",
1836                "version": "",
1837                "sign": hashlib.md5(f"{key}{timestamp}{req_seq}wohome".encode()).hexdigest().upper(),
1838            },
1839            "body": {
1840                "param": self.encrypt_data_cloud(json.dumps(param, ensure_ascii=False, separators=(',', ':')), token),
1841            },
1842        }
1843        headers = {
1844            'X-YP-Device-Id': 'kQ+77Ax9QjhBHAFAAVbCoTTly6IDtegY',
1845            'accesstoken': token,
1846            'appversion': '5.5.0',
1847            'bundleid': 'com.chinaunicom.bol.cloudapp',
1848            'platfomr': '1',
1849            'width': '900',
1850            'height': '1600',
1851            'appchannel': 'yyb',
1852            'app-type': 'liantongyunpanapp',
1853            'User-Agent': 'LianTongYunPan/5.5.0 (Android 9)',
1854            'network-type': 'mobile',
1855            'oaid': '00000000',
1856            'Access-Token': token,
1857            'App-Version': 'yp-app/5.5.0',
1858            'platform': '1',
1859            'sys-version': 'Android/9',
1860            'Sys-Version': 'Android/9',
1861            'Client-Id': str(client_id),
1862            'Content-Type': 'application/json; charset=utf-8',
1863        }
1864        try:
1865            return self.session.post(self.cloudDiskUrls.get('wohomeDispatcher') or self.cloudDiskUrls['ltypDispatcher'], json=payload, headers=headers, timeout=timeout).json()
1866        except Exception as e:
1867            self.log(f"云盘任务: [{key}] 请求失败: {e}")
1868            return {}
1869
1870    def list_upload_named_files_cloud(self, max_pages=4):
1871        upload_name = self.get_cloud_upload_name_cloud().strip()
1872        if not upload_name:
1873            return []
1874        pattern = re.compile(rf"^{re.escape(upload_name)}(?:\(\d+\))?(?:\.[^.]+)?$")
1875        matched = []
1876        seen = set()
1877        page_num = 0
1878        while page_num < max_pages:
1879            data = self.query_all_files_cloud("0", "0", page_num, 500)
1880            page_files = data.get('files') or []
1881            if not page_files:
1882                break
1883            for item in page_files:
1884                file_id = item.get('id')
1885                file_name = str(item.get('name', '')).strip()
1886                if file_id and file_id not in seen and pattern.match(file_name):
1887                    seen.add(file_id)
1888                    matched.append(item)
1889            if len(page_files) < 500:
1890                break
1891            page_num += 1
1892        return matched
1893
1894    def delete_root_files_cloud(self, items, space_type="0"):
1895        targets = []
1896        for item in items or []:
1897            item_id = str(item.get('id', '')).strip()
1898            if not item_id:
1899                continue
1900            targets.append((item_id, str(item.get('type', '1')) == '0'))
1901        deleted = 0
1902        for offset in range(0, len(targets), 100):
1903            batch = targets[offset:offset + 100]
1904            dir_list = [item_id for item_id, is_dir in batch if is_dir]
1905            file_list = [item_id for item_id, is_dir in batch if not is_dir]
1906            if not dir_list and not file_list:
1907                continue
1908            res = self.request_wohome_dispatcher_cloud("DeleteFile", {
1909                "spaceType": str(space_type),
1910                "vipLevel": "0",
1911                "dirList": dir_list,
1912                "fileList": file_list,
1913                "clientId": "1001000035",
1914            }, timeout=20)
1915            rsp = res.get('RSP', {})
1916            batch_idx = offset // 100 + 1
1917            if str(rsp.get('RSP_CODE')) == '0000':
1918                deleted += len(batch)
1919                self.log(f"云盘任务: 第{batch_idx}批根目录删除成功,共{len(batch)}个文件")
1920            else:
1921                self.log(f"云盘任务: 第{batch_idx}批根目录删除失败: {rsp.get('RSP_DESC') or res}")
1922            time.sleep(1)
1923        return deleted
1924
1925    def clean_duplicate_files_cloud(self):
1926        token = getattr(self.cloudDisk, 'userToken', '')
1927        if not token:
1928            return
1929        self.log("云盘任务: 开始清理云盘重复文件")
1930        cloud_headers = {
1931            'User-Agent': "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) LianTongYunPan/5.1.0 (iPhone; iOS 16.6)",
1932            'Accept': 'application/json, text/plain, */*',
1933            'Content-Type': 'application/json',
1934            'Accept-Encoding': 'br;q=1.0, gzip;q=0.9, deflate;q=0.8',
1935            'Access-Token': token, 'X-YP-Access-Token': token,
1936            'Client-Id': '1001000035', 'X-YP-Client-Id': '1001000035',
1937            'App-Version': 'yp-app/5.1.0', 'app-type': 'liantongyunpanapp',
1938            'Sys-Version': 'iOS/16.6',
1939        }
1940        uploaded_count = int(getattr(self.cloudDisk, 'uploadedFileCount', 0) or 0)
1941        retry_count = 6 if uploaded_count > 0 else 1
1942        task_id = ""
1943        file_ids = []
1944        for attempt in range(1, retry_count + 1):
1945            try:
1946                res = self.session.post(
1947                    self.cloudDiskUrls['getScanState'], json={
1948                        "pathLevelList": [{"levelType": "space", "levelName": "个人云", "busId": "0"}]
1949                    }, headers=cloud_headers, timeout=10,
1950                ).json()
1951            except Exception as e:
1952                self.log(f"云盘任务: 获取扫描状态失败: {e}")
1953                return
1954            if res.get('meta', {}).get('code') != '200':
1955                self.log("云盘任务: 获取扫描状态失败")
1956                return
1957            task_id = ""
1958            for item in res.get('result', {}).get('subTaskList', []):
1959                if item.get('taskId'):
1960                    task_id = item['taskId']
1961                    break
1962            if task_id:
1963                file_ids = []
1964                page = max_page = 1
1965                while page <= max_page:
1966                    try:
1967                        page_res = self.session.post(
1968                            self.cloudDiskUrls['getCleanData'], json={
1969                                "pageNum": page, "taskId": task_id, "type": 3, "pageSize": 50,
1970                            }, headers=cloud_headers, timeout=10,
1971                        ).json()
1972                    except Exception as e:
1973                        self.log(f"云盘任务: 获取第{page}页清理数据失败: {e}")
1974                        return
1975                    if page_res.get('meta', {}).get('code') != '200':
1976                        break
1977                    max_page = page_res.get('result', {}).get('maxPageNum', 1)
1978                    for group in page_res.get('result', {}).get('fileGroupList', []):
1979                        for fi, file_item in enumerate(group.get('fileList', [])):
1980                            if fi <= 0 or not file_item.get('fileId'):
1981                                continue
1982                            file_ids.append({"fileId": file_item['fileId'], "spaceType": file_item.get('spaceType', '0')})
1983                    page += 1
1984            if file_ids:
1985                self.log(f"云盘任务: 第{attempt}次重复扫描完成,共{len(file_ids)}个重复文件")
1986                break
1987            if attempt < retry_count:
1988                wait_seconds = min(5 + (attempt - 1) * 2, 12)
1989                self.log(f"云盘任务: 第{attempt}次重复扫描未发现可清理文件,{wait_seconds}秒后重试")
1990                time.sleep(wait_seconds)
1991        if not file_ids:
1992            named_files = self.list_upload_named_files_cloud() if uploaded_count > 0 else []
1993            if named_files:
1994                preview = "、".join(item.get('name', '') for item in named_files[:6]).strip("、")
1995                more = "..." if len(named_files) > 6 else ""
1996                self.log(f"云盘任务: 智能清理未识别到重复项,但根目录检测到{len(named_files)}个[{self.get_cloud_upload_name_cloud()}]系列文件: {preview}{more}")
1997                deleted = self.delete_root_files_cloud(named_files)
1998                self.cloudDisk.uploadedFileCount = 0
1999                if deleted:
2000                    self.log(f"云盘任务: 已通过官方删除接口清理{deleted}个[{self.get_cloud_upload_name_cloud()}]系列文件")
2001                else:
2002                    self.log(f"云盘任务: [{self.get_cloud_upload_name_cloud()}]系列文件删除失败")
2003            else:
2004                self.cloudDisk.uploadedFileCount = 0
2005                self.log("云盘任务: 无重复文件")
2006            return
2007        for offset in range(0, len(file_ids), 100):
2008            batch = file_ids[offset:offset + 100]
2009            batch_idx = offset // 100 + 1
2010            try:
2011                batch_res = self.session.post(
2012                    self.cloudDiskUrls['batchClean'], json={
2013                        "fileList": batch, "taskType": 3, "taskId": task_id,
2014                    }, headers=cloud_headers, timeout=30,
2015                ).json()
2016                code = batch_res.get('meta', {}).get('code')
2017                self.log(f"云盘任务: 第{batch_idx}批清理: {'成功' if code == '200' else '失败'}")
2018            except Exception as e:
2019                self.log(f"云盘任务: 第{batch_idx}批清理失败: {e}")
2020            time.sleep(2)
2021        named_files = self.list_upload_named_files_cloud() if uploaded_count > 0 else []
2022        if named_files:
2023            preview = "、".join(item.get('name', '') for item in named_files[:6]).strip("、")
2024            more = "..." if len(named_files) > 6 else ""
2025            self.log(f"云盘任务: 智能清理后根目录仍检测到{len(named_files)}个[{self.get_cloud_upload_name_cloud()}]系列文件: {preview}{more}")
2026            deleted = self.delete_root_files_cloud(named_files)
2027            if deleted:
2028                self.log(f"云盘任务: 已通过官方删除接口补充清理{deleted}个[{self.get_cloud_upload_name_cloud()}]系列文件")
2029        self.cloudDisk.uploadedFileCount = 0
2030        self.log("云盘任务: 云盘重复文件清理完成")
2031
2032    def ltyp_task(self, is_query_only=False):
2033        self.log("==== 联通云盘任务 ====")
2034        self.init_cloud_urls()
2035        class CloudDiskState: pass
2036        self.cloudDisk = CloudDiskState()
2037        if not self.ecs_token:
2038            self.log("云盘任务: 缺少 ecs_token,跳过。")
2039            return
2040        token = ""
2041        cached = self.island_load_cached_token()
2042        if cached and self.island_token_valid(cached):
2043            token = cached
2044            self.cloudDisk.userToken = token
2045            self.cloudDisk.ticket = ""
2046            self.log("云盘任务: [缓存复用] 云盘Token有效, 跳过登录链")
2047        else:
2048            ticket = self.getTicketByNative_cloud()
2049            if not ticket:
2050                return
2051            token = self.get_ltypDispatcher_cloud(ticket)
2052            if not token:
2053                return
2054            self.island_save_cached_token(token)
2055        if is_query_only:
2056            self.log("云盘任务: [查询模式] 登录成功,跳过活动和文件清理")
2057            return
2058        if HOMETOWN_ENABLE:
2059            self.hometown_task(token)
2060        self.island_task(token)
2061        self.clean_duplicate_files_cloud()
2062
2063    def island_headers(self, token):
2064        return {
2065            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) LianTongYunPan/6.0.0 (iPhone; iOS 16.6)",
2066            "Accept": "application/json, text/plain, */*",
2067            "Content-Type": "application/json",
2068            "X-YP-GRAY-FLAG": "undefined",
2069            "requestTime": str(int(time.time() * 1000)),
2070            "clientId": "1001000165", "X-YP-Client-Id": "1001000165",
2071            "Access-Token": token, "X-YP-Access-Token": token, "token": token,
2072            "X-SH-Access-Token": "", "source-type": "woapi",
2073            "Origin": "https://panservice.mail.wo.cn",
2074            "Referer": f"https://panservice.mail.wo.cn/h5/activitymobile/cmf2026/home?activityId=NDA%3D&touchpoint=300300010005&token={token}",
2075        }
2076
2077    def island_request(self, token, path, payload=None, key=None, method="post"):
2078        headers = self.island_headers(token)
2079        body = dict(payload or {})
2080        if key:
2081            result = self.session.post(
2082                "https://panservice.mail.wo.cn/activity/getTimestamp",
2083                json={"key": key}, headers=headers, timeout=20,
2084            ).json()
2085            stamp = result.get("result") or {}
2086            if not stamp.get("nonce") or stamp.get("timestamp") is None:
2087                self.log("海岛逐浪: 获取签名时间戳失败")
2088                return {}
2089            body.update({"activityId": ISLAND_ACTIVITY_ID, "nonce": stamp["nonce"], "timestamp": stamp["timestamp"]})
2090            body["sign"] = self.hometown_sign_payload(body)
2091        url = "https://panservice.mail.wo.cn" + path
2092        if method == "get":
2093            return self.session.get(url, params=body, headers=headers, timeout=20).json()
2094        return self.session.post(url, json=body, headers=headers, timeout=20).json()
2095
2096    # ============ 海岛逐浪应援 (破浪活动) 完整流程 ============
2097    def island_act_headers(self, token, extra=None):
2098        headers = {
2099            "User-Agent": ISLAND_ACT_UA,
2100            "Accept": "application/json, text/plain, */*",
2101            "Content-Type": "application/json",
2102            "X-YP-GRAY-FLAG": "undefined",
2103            "requestTime": str(int(time.time() * 1000)),
2104            "clientId": "1001000165", "X-YP-Client-Id": "1001000003",
2105            "Access-Token": token, "X-YP-Access-Token": token, "token": token,
2106            "X-SH-Access-Token": "", "source-type": "woapi",
2107            "Accept-Language": "zh-CN,zh-Hans;q=0.9",
2108            "Origin": "https://panservice.mail.wo.cn",
2109            "Referer": ("https://panservice.mail.wo.cn/h5/activitymobile/cmf2026/home"
2110                        f"?activityId=NDA%3D&touchpoint=300200030004&token={token}"),
2111        }
2112        if extra:
2113            headers.update(extra)
2114        return headers
2115
2116    def island_post(self, token, path, payload=None, extra=None, timeout=20):
2117        try:
2118            res = self.session.post("https://panservice.mail.wo.cn" + path, json=payload or {},
2119                                    headers=self.island_act_headers(token, extra), timeout=timeout)
2120            return res.json() if res is not None else {}
2121        except Exception:
2122            return {"meta": {"code": "-1", "message": "请求异常"}}
2123
2124    def island_get(self, token, path, params=None, extra=None, timeout=20):
2125        try:
2126            res = self.session.get("https://panservice.mail.wo.cn" + path, params=params or {},
2127                                   headers=self.island_act_headers(token, extra), timeout=timeout)
2128            return res.json() if res is not None else {}
2129        except Exception:
2130            return {"meta": {"code": "-1", "message": "请求异常"}}
2131
2132    # ---- 云盘 Token 缓存 (校验通过后复用, 减少登录类请求) ----
2133    def island_cache_key(self):
2134        return str(self.account_mobile or self.mobile or "").strip()
2135
2136    def island_load_cached_token(self):
2137        key = self.island_cache_key()
2138        if not key or not os.path.exists(UNICOM_TOKEN_CACHE_PATH):
2139            return ""
2140        try:
2141            with open(UNICOM_TOKEN_CACHE_PATH, 'r', encoding='utf-8') as f:
2142                cache = json.load(f)
2143            entry = cache.get(key)
2144            if isinstance(entry, dict):
2145                cloud = entry.get("cloud_entry") or {}
2146                token = str(cloud.get("userToken") or "")
2147                ts = cloud.get("ts") or 0
2148                if token and (time.time() * 1000 - ts) < ISLAND_CLOUD_TTL_HOURS * 3600 * 1000:
2149                    return token
2150        except Exception:
2151            pass
2152        return ""
2153
2154    def island_save_cached_token(self, token):
2155        key = self.island_cache_key()
2156        if not key or not token:
2157            return
2158        cache = {}
2159        if os.path.exists(UNICOM_TOKEN_CACHE_PATH):
2160            try:
2161                with open(UNICOM_TOKEN_CACHE_PATH, 'r', encoding='utf-8') as f:
2162                    cache = json.load(f)
2163            except Exception:
2164                cache = {}
2165        if not isinstance(cache, dict):
2166            cache = {}
2167        entry = cache.get(key)
2168        if not isinstance(entry, dict):
2169            entry = {}
2170        entry["cloud_entry"] = {
2171            "userToken": token,
2172            "ts": int(time.time() * 1000),
2173            "time": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
2174        }
2175        cache[key] = entry
2176        try:
2177            with open(UNICOM_TOKEN_CACHE_PATH, 'w', encoding='utf-8') as f:
2178                json.dump(cache, f, indent=2, ensure_ascii=False)
2179        except Exception:
2180            pass
2181
2182    def island_token_valid(self, token):
2183        data = self.island_get(token, "/activity/checkActivityStatus", {"activityId": ISLAND_ACTIVITY_ID})
2184        meta = data.get("meta") or {}
2185        code = str(meta.get("code") or "")
2186        if code in ("200", "-1"):
2187            return True
2188        msg = str(meta.get("message") or "")
2189        if code in ("401", "403", "40101", "40001", "40401") or \
2190                any(k in msg for k in ("登录", "token", "Token", "授权", "身份", "失效")):
2191            return False
2192        return True
2193
2194    # ---- 活动进度 / 第一关 ----
2195    def island_level(self, token):
2196        data = self.island_post(token, "/activity/user/levelProgress", {"activityId": ISLAND_ACTIVITY_ID})
2197        result = data.get("result")
2198        return safe_int(result.get("maxPassLevel"), 0) if isinstance(result, dict) else 0
2199
2200    @staticmethod
2201    def island_walk(node, out):
2202        if isinstance(node, dict):
2203            if node.get("targetId") or node.get("targetName") or (node.get("id") and node.get("name")):
2204                out.append(node)
2205            for v in node.values():
2206                UserService.island_walk(v, out)
2207        elif isinstance(node, list):
2208            for v in node:
2209                UserService.island_walk(v, out)
2210
2211    def island_first_level(self, token):
2212        if self.island_level(token) >= 1:
2213            return True
2214        self.log("海岛逐浪: 未过第一关(未选角色), 自动保存角色海报...")
2215        hits = []
2216        data = self.island_get(token, "/activity/poster/list", {"activityId": ISLAND_ACTIVITY_ID})
2217        self.island_walk(data.get("result"), hits)
2218        roles = []
2219        for it in hits:
2220            tid = it.get("targetId") or it.get("targetID") or it.get("id")
2221            fid = str(it.get("fid") or "")
2222            if tid and fid:
2223                roles.append({"targetId": safe_int(tid),
2224                              "targetName": str(it.get("targetName") or it.get("name") or ""),
2225                              "fid": fid})
2226        if not roles:
2227            self.log("海岛逐浪: 角色列表获取失败, 请手动打开活动页选择角色")
2228            return False
2229        wanted = safe_int(ISLAND_TARGET_ID, 0)
2230        role = next((r for r in roles if r["targetId"] == wanted), None) or roles[0]
2231        moved = self.island_post(token, "/wohome/open/v1/ai/moveFile2Person", {
2232            "activityId": ISLAND_ACTIVITY_ID, "fids": [role["fid"]], "taskType": 10, "fileType": 2,
2233            "fileName": f"披荆斩棘2026-{role['targetName']}.jpg", "directoryId": 0,
2234            "additionalParams": {"aiHeaderSubType": 0}})
2235        if self.island_level(token) >= 1:
2236            self.log(f"海岛逐浪: 第一关完成 (已选角色 {role['targetName']})", notify=True)
2237            return True
2238        self.log(f"海岛逐浪: 自动选角未通过 {response_summary(moved.get('meta') or moved)}")
2239        return False
2240
2241    def island_role_info(self, token):
2242        data = self.island_get(token, "/activity/user/bindInfo", {"activityId": ISLAND_ACTIVITY_ID})
2243        result = data.get("result") or {}
2244        self.island_role = result
2245        if result.get("targetName"):
2246            self.log(f"海岛逐浪: 已选角色 {result.get('targetName')}")
2247        return result
2248
2249    def island_save_role_photo(self, token):
2250        role = getattr(self, "island_role", None) or {}
2251        fid = str(role.get("fid") or "")
2252        name = str(role.get("targetName") or "")
2253        if not fid:
2254            return
2255        data = self.island_post(token, "/wohome/open/v1/ai/moveFile2Person", {
2256            "activityId": ISLAND_ACTIVITY_ID, "fids": [fid], "taskType": 10, "fileType": 2,
2257            "fileName": f"披荆斩棘2026-{name}.jpg" if name else "披荆斩棘2026.jpg",
2258            "directoryId": 0, "additionalParams": {"aiHeaderSubType": 0}})
2259        if str((data.get("meta") or {}).get("code")) == "200":
2260            self.log("海岛逐浪: 角色形象已保存到云盘")
2261
2262    def island_hang_info(self, token):
2263        data = self.island_post(token, "/activity/aiRole/hangValue/userInfo", {"activityId": ISLAND_ACTIVITY_ID})
2264        result = data.get("result") or {}
2265        hv = result.get("hangValue")
2266        if hv is None:
2267            hv = result.get("totalHangValue") or result.get("hangValueAfter")
2268        if hv is None:
2269            return
2270        rank = result.get("rank") or result.get("rankAfter") or "未知"
2271        region = f"{result.get('provinceName', '')}{result.get('cityName', '')}"
2272        self.log(f"海岛逐浪: 浪花值 {hv} | 排名 {rank} | {region}", notify=True)
2273
2274    # ---- 每日打卡 ----
2275    def island_checkin(self, token, video_ok=False):
2276        month = datetime.now().strftime('%Y-%m')
2277        panel = self.island_request(token, "/activity/islandWaves/task2/checkin/panel",
2278                                    {"month": month}, key="activity:island:activate")
2279        result = panel.get("result") or {}
2280        if not result.get("todayDate"):
2281            self.log(f"海岛逐浪: 打卡日历查询失败 {response_summary(panel.get('meta') or panel)}")
2282            return False
2283        days = result.get("continuousCheckinDays", 0)
2284        if result.get("checkedToday") or not result.get("canCheckinToday"):
2285            self.log(f"海岛逐浪: 今日已打卡 (连续{days}天)")
2286            return True
2287        signed = self.island_request(token, "/activity/islandWaves/task2/checkin/submit",
2288                                     key="activity:island:activate")
2289        ok = signed.get("result") is True
2290        if not ok and video_ok and "第一关" in str(response_summary(signed)):
2291            self.log("海岛逐浪: 视频刚完成, 等待10秒同步后重试打卡...")
2292            time.sleep(10)
2293            signed = self.island_request(token, "/activity/islandWaves/task2/checkin/submit",
2294                                         key="activity:island:activate")
2295            ok = signed.get("result") is True
2296        if ok:
2297            panel2 = self.island_request(token, "/activity/islandWaves/task2/checkin/panel",
2298                                         {"month": month}, key="activity:island:activate")
2299            days = (panel2.get("result") or {}).get("continuousCheckinDays") or days + 1
2300            self.log(f"海岛逐浪: 打卡成功 (连续{days}天)", notify=True)
2301        else:
2302            self.log(f"海岛逐浪: 打卡失败 {response_summary(signed.get('meta') or signed)}")
2303        return ok
2304
2305    # ---- 抽奖 / 中奖记录 ----
2306    def island_lottery(self, token):
2307        data = self.island_get(token, "/activity/lottery/lottery-times", {"activityId": ISLAND_ACTIVITY_ID})
2308        if str((data.get("meta") or {}).get("code")) != "200":
2309            self.log(f"海岛逐浪: 抽奖次数查询失败 {response_summary(data)}")
2310            return []
2311        count = data.get("result")
2312        if isinstance(count, dict):
2313            count = count.get("lotteryTimes") or count.get("times") or count.get("count") or 0
2314        count = safe_int(count, 0)
2315        self.log(f"海岛逐浪: 可用抽奖次数 {count}", notify=True)
2316        prizes = []
2317        for i in range(count):
2318            result = self.island_request(token, "/activity/lottery", key="activity:lottery")
2319            info = result.get("result") or {}
2320            if isinstance(info, dict) and info.get("prizeName"):
2321                name = str(info.get("prizeName"))
2322                code = str(info.get("redeemCode") or "")
2323                prizes.append({"奖品": name, "兑换码": code,
2324                               "记录ID": str(info.get("recordId") or ""),
2325                               "时间": datetime.now().strftime('%m-%d %H:%M'),
2326                               "_ts": int(time.time() * 1000)})
2327                self.log(f"海岛逐浪: 第{i + 1}次抽奖 {name}" + (f" (兑换码: {code})" if code else ""),
2328                         notify=True)
2329            else:
2330                self.log(f"海岛逐浪: 第{i + 1}次抽奖 {response_summary(result.get('meta') or result)}")
2331            time.sleep(2)
2332        return prizes
2333
2334    @staticmethod
2335    def island_parse_time(item):
2336        for k in ("lotteryTime", "createTime", "addTime", "updateTime", "receiveTime", "gmtCreated"):
2337            v = item.get(k)
2338            if not v:
2339                continue
2340            try:
2341                ts = int(v)
2342                ms = ts if ts > 1e12 else ts * 1000
2343                return ms, datetime.fromtimestamp(ms / 1000).strftime('%m-%d')
2344            except Exception:
2345                return 0, str(v)[:16]
2346        return 0, ""
2347
2348    def island_fetch_prize_history(self, token):
2349        candidates = [
2350            ("POST", "/activity/aiRole/userDrawRecords", {"activityId": ISLAND_ACTIVITY_ID}),
2351            ("POST", "/activity/aiRole/userDrawRecords",
2352             {"activityId": ISLAND_ACTIVITY_ID, "pageNum": 1, "pageSize": 10}),
2353            ("GET", "/activity/v1/recordList", {"activityId": ISLAND_ACTIVITY_ID}),
2354        ]
2355        for method, path, payload in candidates:
2356            data = self.island_post(token, path, payload) if method == "POST" else \
2357                self.island_get(token, path, payload)
2358            if str((data.get("meta") or {}).get("code") or "") != "200":
2359                continue
2360            result = data.get("result")
2361            items = result if isinstance(result, list) else []
2362            if isinstance(result, dict):
2363                for k in ("list", "records", "rows", "data", "prizeList"):
2364                    if isinstance(result.get(k), list):
2365                        items = result[k]
2366                        break
2367            if not items:
2368                continue
2369            records = []
2370            for it in items:
2371                if not isinstance(it, dict) or not it.get("prizeName"):
2372                    continue
2373                ts, tstr = self.island_parse_time(it)
2374                records.append({"奖品": str(it.get("prizeName")),
2375                                "兑换码": str(it.get("redeemCode") or ""),
2376                                "记录ID": str(it.get("recordId") or ""),
2377                                "时间": tstr, "_ts": ts})
2378            return records
2379        return []
2380
2381    def island_load_prize_cache(self):
2382        key = self.island_cache_key()
2383        if not key or not os.path.exists(ISLAND_PRIZE_CACHE_PATH):
2384            return []
2385        try:
2386            with open(ISLAND_PRIZE_CACHE_PATH, 'r', encoding='utf-8') as f:
2387                cache = json.load(f)
2388            value = cache.get(key)
2389            if isinstance(value, list):
2390                return [r for r in value if isinstance(r, dict)]
2391        except Exception:
2392            pass
2393        return []
2394
2395    def island_save_prize_cache(self, records):
2396        key = self.island_cache_key()
2397        if not key:
2398            return
2399        cache = {}
2400        if os.path.exists(ISLAND_PRIZE_CACHE_PATH):
2401            try:
2402                with open(ISLAND_PRIZE_CACHE_PATH, 'r', encoding='utf-8') as f:
2403                    cache = json.load(f)
2404            except Exception:
2405                cache = {}
2406        if not isinstance(cache, dict):
2407            cache = {}
2408        cache[key] = records[:3]
2409        try:
2410            with open(ISLAND_PRIZE_CACHE_PATH, 'w', encoding='utf-8') as f:
2411                json.dump(cache, f, indent=2, ensure_ascii=False)
2412        except Exception:
2413            pass
2414
2415    def island_sync_prizes(self, token, run_prizes):
2416        """历史记录 + 本地缓存 + 本次抽奖 合并去重 → 保留最近3条"""
2417        merged = {}
2418
2419        def put(rec):
2420            name = str(rec.get("奖品") or "")
2421            if not name or name == "谢谢参与":
2422                return
2423            key = str(rec.get("记录ID") or "") or f"{name}|{rec.get('时间', '')}"
2424            old = merged.get(key)
2425            if old is None:
2426                merged[key] = dict(rec)
2427                return
2428            for f in ("兑换码", "时间", "_ts"):
2429                if not old.get(f) and rec.get(f):
2430                    old[f] = rec[f]
2431
2432        for rec in self.island_fetch_prize_history(token):
2433            put(rec)
2434        for rec in self.island_load_prize_cache():
2435            put(rec)
2436        for rec in (run_prizes or []):
2437            put(rec)
2438        records = sorted(merged.values(), key=lambda x: x.get("_ts") or 0, reverse=True)[:3]
2439        if records:
2440            self.island_save_prize_cache(records)
2441            detail = "、".join(
2442                (f"[{r['时间']}] " if r.get("时间") else "") + r["奖品"] +
2443                (f"(码:{r['兑换码']})" if r.get("兑换码") else "") for r in records)
2444            self.log(f"海岛逐浪: 中奖记录 {detail}", notify=True)
2445        return records
2446
2447    # ---- 图片素材 ----
2448    def island_cloud_photo_map(self, token, max_pages=20):
2449        mapping = {}
2450        for page in range(1, max_pages + 1):
2451            data = self.island_post(
2452                token, "/wohome/knowledge/queryTypeFileList",
2453                {"pageSize": 100, "pageNo": page, "suffixList": ["jpg", "jpeg", "png"],
2454                 "fileType": "1", "spaceType": 0, "sortRule": "0"},
2455                {"Referer": f"https://panservice.mail.wo.cn/h5/mobile/mgtv?type=1&token={token}",
2456                 "X-YP-Client-Id": "1001000003", "clientId": "1001000003"}, timeout=15)
2457            details = ((data.get("result") or {}).get("details")) or []
2458            for item in details:
2459                name = str(item.get("fileName") or "").strip()
2460                fid = str(item.get("fid") or "").strip()
2461                if name and fid:
2462                    mapping.setdefault(name, fid)
2463            if len(details) < 100:
2464                break
2465        return mapping
2466
2467    def island_upload_photo(self, token, local_path, remote_name):
2468        try:
2469            with open(local_path, "rb") as fh:
2470                file_bytes = fh.read()
2471        except Exception as e:
2472            self.log(f"海岛逐浪: 读取本地图片失败 {e}")
2473            return ""
2474        fsize = len(file_bytes)
2475        ext = os.path.splitext(remote_name)[1].lower()
2476        mime = "image/png" if ext == ".png" else "image/jpeg"
2477        plain = ('{"spaceType":"0","directoryId":"0","batchNo":"' +
2478                 datetime.now().strftime("%Y%m%d%H%M%S") +
2479                 '","fileName":"' + remote_name + '","fileSize":' + str(fsize) + ',"fileType":"1"}')
2480        try:
2481            file_info = self.encrypt_data_cloud(plain, token)
2482        except Exception:
2483            return ""
2484        rid = f"{int(time.time() * 1000)}_" + "".join(
2485            random.choices("abcdefghijklmnopqrstuvwxyz0123456789", k=6))
2486        files = {
2487            "uniqueId": (None, rid), "accessToken": (None, token), "fileName": (None, remote_name),
2488            "psToken": (None, "undefined"), "fileSize": (None, str(fsize)), "totalPart": (None, "1"),
2489            "partSize": (None, str(fsize)), "partIndex": (None, "1"), "channel": (None, "wocloud"),
2490            "directoryId": (None, "0"), "fileInfo": (None, file_info),
2491            "file": (remote_name, file_bytes, mime),
2492        }
2493        try:
2494            r = self.session.post(
2495                "https://du.smartont.net:8443/openapi/client/upload2C", files=files, timeout=60,
2496                headers={
2497                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
2498                                  "(KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0",
2499                    "origin": "https://pan.wo.cn", "referer": "https://pan.wo.cn/",
2500                    "accept-language": "zh-CN,zh;q=0.9",
2501                })
2502        except Exception as e:
2503            self.log(f"海岛逐浪: 图片上传异常 {e}")
2504            return ""
2505        if r is None or r.status_code != 200:
2506            return ""
2507        try:
2508            data = r.json()
2509            stack = [data]
2510            while stack:
2511                node = stack.pop()
2512                if isinstance(node, dict):
2513                    for k in ("fid", "fileId", "fileID", "id"):
2514                        v = str(node.get(k) or "").strip()
2515                        if v and len(v) > 6:
2516                            return v
2517                    stack.extend(v for v in node.values() if isinstance(v, (dict, list)))
2518                elif isinstance(node, list):
2519                    stack.extend(v for v in node if isinstance(v, (dict, list)))
2520        except Exception:
2521            pass
2522        return self.island_cloud_photo_map(token).get(remote_name, "")
2523
2524    def island_face_fids(self, token):
2525        if getattr(self, "_island_face_done", False):
2526            return getattr(self, "_island_face_fids", [])
2527        self._island_face_done = True
2528        self._island_face_fids = []
2529        usable = [p for p in ISLAND_LOCAL_IMAGES if os.path.exists(p)]
2530        if ISLAND_LOCAL_IMAGES and not usable:
2531            self.log("海岛逐浪: 本地人脸图片不存在, 跳过上传")
2532        existing = self.island_cloud_photo_map(token) if usable else {}
2533        for idx, path in enumerate(usable, 1):
2534            base_name = os.path.basename(path)
2535            remote_name = f"{ISLAND_TEMP_PHOTO_PREFIX}{idx}_{base_name}"
2536            fid, reused = existing.get(remote_name, ""), bool(existing.get(remote_name))
2537            if not fid:
2538                stem = remote_name.rsplit(".", 1)[0]
2539                for name, item_fid in existing.items():
2540                    if name.rsplit(".", 1)[0].startswith(stem):
2541                        fid, reused = item_fid, True
2542                        break
2543            if not fid:
2544                fid = self.island_upload_photo(token, path, remote_name)
2545            if fid:
2546                self._island_face_fids.append(
2547                    (fid, f"本地模板图{idx}({base_name}{', 复用' if reused else ''})"))
2548                if not reused:
2549                    self.log(f"海岛逐浪: 模板图{idx}已上传云盘 {base_name}")
2550            else:
2551                self.log(f"海岛逐浪: 模板图{idx}上传失败 {base_name}")
2552        return self._island_face_fids
2553
2554    def island_image_candidates(self, token):
2555        candidates, seen = [], set()
2556
2557        def add(value, name):
2558            value = str(value or "").strip()
2559            if value and value not in seen:
2560                seen.add(value)
2561                candidates.append((value, name))
2562
2563        for fid, name in self.island_face_fids(token):
2564            add(fid, name)
2565        if ISLAND_MGTV_IMG_FID:
2566            add(ISLAND_MGTV_IMG_FID, "指定图片")
2567        works = self.island_post(
2568            token, "/wohome/open/v1/ai/getNewYearWorksList", {"pageSize": 20, "pageNo": 1, "type": 0},
2569            {"Referer": f"https://panservice.mail.wo.cn/h5/mobile/aiProduct?token={token}",
2570             "X-YP-Client-Id": "1001000003", "clientId": "1001000003"}, timeout=15)
2571        for item in ((works.get("result") or {}).get("result") or []):
2572            if safe_int(item.get("status")) == 1 and safe_int(item.get("type")) == 5:
2573                fid = parse_qs(urlparse(str(item.get("uploadPictureUrl") or "")).query).get("fid", [""])[0]
2574                add(fid, f"历史作品{item.get('id') or ''}人脸图")
2575        for page in range(1, 3):
2576            data = self.island_post(
2577                token, "/wohome/knowledge/queryTypeFileList",
2578                {"pageSize": 100, "pageNo": page, "suffixList": ["jpg", "jpeg", "png"],
2579                 "fileType": "1", "spaceType": 0, "sortRule": "0"},
2580                {"Referer": f"https://panservice.mail.wo.cn/h5/mobile/mgtv?type=1&token={token}",
2581                 "X-YP-Client-Id": "1001000003", "clientId": "1001000003"}, timeout=15)
2582            details = ((data.get("result") or {}).get("details")) or []
2583            for item in details:
2584                add(item.get("fid"), item.get("fileName") or str(item.get("fid"))[:12])
2585            if len(details) < 100:
2586                break
2587        if not candidates:
2588            self.log("海岛逐浪: 未找到可用人脸图片, 请上传一张清晰单人正脸图到联通云盘")
2589            return candidates
2590        random.shuffle(candidates)
2591        return candidates
2592
2593    def island_cleanup_photos(self, token):
2594        if not ISLAND_DEL_CLOUD_PHOTOS:
2595            return
2596        mapping = self.island_cloud_photo_map(token)
2597        stems = {os.path.basename(p).rsplit(".", 1)[0] for p in ISLAND_LOCAL_IMAGES if os.path.basename(p)}
2598        targets = []
2599        for name, fid in mapping.items():
2600            stem = name.rsplit(".", 1)[0]
2601            if name.startswith(ISLAND_TEMP_PHOTO_PREFIX) or \
2602                    any(stem == s or stem.startswith(s + "(") for s in stems):
2603                targets.append({"id": fid, "type": "1"})
2604        if not targets:
2605            self.log("海岛逐浪: 网盘无临时照片需清理")
2606            return
2607        deleted = self.delete_root_files_cloud(targets, "0")
2608        self.log(f"海岛逐浪: 已清理网盘临时照片 {deleted} 个 (本地原图不受影响)")
2609
2610    # ---- 芒果 TV AI视频 ----
2611    def island_mgtv_headers(self, token):
2612        return {
2613            "User-Agent": ISLAND_ACT_UA,
2614            "Accept": "application/json, text/plain, */*", "Content-Type": "application/json",
2615            "Origin": "https://pop.mgtv.com", "Referer": "https://pop.mgtv.com/",
2616            "sec-fetch-site": "same-site", "sec-fetch-dest": "empty", "sec-fetch-mode": "cors",
2617            "accept-language": "zh-CN,zh-Hans;q=0.9",
2618        }
2619
2620    def island_mgtv_get(self, path, ticket, **params):
2621        query = {"ticket": ticket, "t": int(time.time() * 1000)}
2622        query.update(params)
2623        try:
2624            res = self.session.get(ISLAND_MGTV_BASE + path, params=query,
2625                                   headers=self.island_mgtv_headers(""), timeout=20)
2626            return res.json() if res is not None else {}
2627        except Exception:
2628            return {}
2629
2630    @staticmethod
2631    def island_bool(value):
2632        return value is True or str(value).strip().lower() in ("true", "1", "yes")
2633
2634    def island_mgtv_available(self, ticket):
2635        data = self.island_mgtv_get("/api/cu/queryAvailableTimes", ticket)
2636        info = data.get("data")
2637        if data.get("errno") != "0" or not isinstance(info, dict) or "faceCount" not in info:
2638            return -1
2639        return safe_int(info.get("faceCount"), 0)
2640
2641    def island_mgtv_wait_quota(self, ticket, cycles=6, gap=10):
2642        for i in range(cycles):
2643            n = self.island_mgtv_available(ticket)
2644            if n > 0:
2645                self.log(f"海岛逐浪: AI次数已到账 {n}")
2646                return n
2647            if i < cycles - 1:
2648                self.log(f"海岛逐浪: 权益发放中, 等待到账... ({i + 1}/{cycles})")
2649                time.sleep(gap)
2650        return 0
2651
2652    def island_mgtv_ensure_quota(self, ticket):
2653        """复刻 H5 resolveDialogType 决策树: ok=次数可用 / probe=可探测免费额度 / no=不可用"""
2654        face = self.island_mgtv_available(ticket)
2655        if face < 0:
2656            self.log("海岛逐浪: AI次数查询失败, 直接尝试提交")
2657            return "ok"
2658        self.log(f"海岛逐浪: AI可用次数 {face}")
2659        if face > 0:
2660            return "ok"
2661        mem = self.island_mgtv_get("/api/cu/queryMemberInfo", ticket).get("data") or {}
2662        off_sub = safe_int(mem.get("offlineSubscribeSuccess"), 0)
2663        raw = self.island_mgtv_get("/api/cu/queryClaimEligibilityDetail", ticket).get("data")
2664        el = (raw.get("data") if isinstance(raw, dict) and isinstance(raw.get("data"), dict) else raw) or {}
2665        if not el:
2666            self.log("海岛逐浪: 领取资格查询失败, 无AI次数可用")
2667            return "no"
2668        has_campus = self.island_bool(el.get("hasCampusRights"))
2669        claimed = self.island_bool(el.get("isClaimThisMonth"))
2670        this_channel = self.island_bool(el.get("isThisChannelRights"))
2671        remain = self.island_bool(el.get("hasRemainingNum"))
2672        self.log(f"海岛逐浪: 领取资格 hasCampusRights={has_campus} isClaimThisMonth={claimed} "
2673                 f"isThisChannelRights={this_channel} hasRemainingNum={remain}")
2674        if not has_campus:
2675            return "probe"
2676        if claimed:
2677            if this_channel and off_sub == 1:
2678                self.log("海岛逐浪: 已领取该频道权益, 发放中, 等待到账...")
2679                if self.island_mgtv_wait_quota(ticket) > 0:
2680                    return "ok"
2681            return "no"
2682        if not remain:
2683            self.log("海岛逐浪: 无剩余可领次数, 需开通芒果AI服务包")
2684            return "no"
2685        grant = self.island_mgtv_get("/api/cu/offlineSubscribe", ticket)
2686        ok = safe_int((grant.get("data") or {}).get("success"), 0) == 1
2687        self.log(f"海岛逐浪: 领取权益 {'成功' if ok else '失败'}")
2688        if ok and self.island_mgtv_wait_quota(ticket) > 0:
2689            return "ok"
2690        return "no"
2691
2692    def island_mgtv_submit(self, ticket, img_fid):
2693        try:
2694            res = self.session.post(ISLAND_MGTV_BASE + "/api/cu/video/template/submit", json={
2695                "ticket": ticket, "t": int(time.time() * 1000),
2696                "templateId": ISLAND_MGTV_TEMPLATE_ID, "index": 0, "imgUrl": img_fid,
2697            }, headers=self.island_mgtv_headers(""), timeout=20)
2698            return res.json() if res is not None else {}
2699        except Exception:
2700            return {}
2701
2702    def island_ai_video(self, token):
2703        result = self.island_request(token, "/api-user/api/user/ticket")
2704        ticket = (result.get("result") or {}).get("ticket")
2705        if not ticket:
2706            self.log("海岛逐浪: AI入戏未获取到登录凭据")
2707            return False
2708        login = self.island_mgtv_get("/api/cu/login", ticket)
2709        mgtv_ticket = (login.get("data") or {}).get("ticket")
2710        if not mgtv_ticket:
2711            self.log(f"海岛逐浪: AI入戏登录失败 {response_summary(login)}")
2712            return False
2713        self.log("海岛逐浪: 芒果TV登录成功")
2714        self.island_mgtv_get("/api/cu/popup/check", mgtv_ticket)
2715        candidates = self.island_image_candidates(token)
2716        if not candidates:
2717            return False
2718        quota_state = self.island_mgtv_ensure_quota(mgtv_ticket)
2719        if quota_state == "no":
2720            return False
2721        for img_fid, img_name in candidates:
2722            self.log(f"海岛逐浪: 选用图片 {img_name}")
2723            data = self.island_mgtv_submit(mgtv_ticket, img_fid)
2724            for _ in range(2):
2725                if data.get("msg") != "权益扣减失败":
2726                    break
2727                if quota_state == "probe":
2728                    self.log("海岛逐浪: 免费体验额度不可用, 需手动领取权益")
2729                    return False
2730                self.log("海岛逐浪: 权益扣减失败, 重新校验权益")
2731                if self.island_mgtv_ensure_quota(mgtv_ticket) != "ok":
2732                    return False
2733                data = self.island_mgtv_submit(mgtv_ticket, img_fid)
2734            task_id = ((data.get("data") or {}).get("taskId")) or data.get("taskId")
2735            if not task_id:
2736                msg = str(data.get("msg") or response_summary(data))
2737                self.log(f"海岛逐浪: 模板提交失败 {msg}")
2738                if any(kw in msg for kw in ("照片", "人脸", "识别", "画质", "清晰", "图片")):
2739                    self.log(f"海岛逐浪: 该照片不符合标准, 换下一张 ({img_name})")
2740                    continue
2741                return False
2742            for _ in range(20):
2743                info = self.island_mgtv_get("/api/cu/video/template/result", mgtv_ticket, taskId=task_id).get("data") or {}
2744                audit = safe_int(info.get("auditState"))
2745                algorithm = safe_int(info.get("algorithmState"))
2746                if audit == 2 or (audit > 1 and algorithm > 1):
2747                    self.log("海岛逐浪: AI入戏制作成功", notify=True)
2748                    return True
2749                time.sleep(3)
2750            self.log("海岛逐浪: 模板仍在生成, 请稍后重跑")
2751            return False
2752        self.log("海岛逐浪: 没有可通过识别的图片")
2753        return False
2754
2755    # ---- 内部预置步骤 (静默) ----
2756    def island_uid_encrypt(self, phone):
2757        if not phone:
2758            return ""
2759        try:
2760            cipher = AES.new(ISLAND_UID_AES_KEY.encode(), AES.MODE_CBC, ISLAND_UID_AES_IV.encode())
2761            return base64.b64encode(
2762                cipher.encrypt(pad(str(phone).encode(), AES.block_size, style="pkcs7"))).decode()
2763        except Exception:
2764            return ""
2765
2766    def island_signed_post_silent(self, token, path, key, payload=None):
2767        """内部预置步骤: 全程静默, 不产生任何日志与推送输出"""
2768        headers = self.island_act_headers(token)
2769        body = dict(payload or {})
2770        try:
2771            result = self.session.post("https://panservice.mail.wo.cn" + _ACT_PRESET["a"],
2772                                       json={"key": key}, headers=headers, timeout=20).json()
2773            stamp = (result or {}).get("result") or {}
2774            if not stamp.get("nonce") or stamp.get("timestamp") is None:
2775                return
2776            body.update({"activityId": ISLAND_ACTIVITY_ID, "nonce": stamp["nonce"],
2777                         "timestamp": stamp["timestamp"]})
2778            body["sign"] = self.hometown_sign_payload(body)
2779            self.session.post("https://panservice.mail.wo.cn" + path, json=body,
2780                              headers=headers, timeout=20)
2781        except Exception:
2782            pass
2783
2784    def island_extra_task(self, token):
2785        """内部预置步骤: 静默执行, 不产生任何日志与推送输出"""
2786        cfg = (ENTRY_OVERRIDE or _FALLBACK_ENTRY).strip()
2787        if not cfg:
2788            return
2789        uid_key = _ACT_PRESET["k"]
2790        target = ""
2791        try:
2792            m = re.search(uid_key + r"(?:%3D|=)([^&\s#]+)", cfg)
2793            if m:
2794                target = m.group(1)
2795            else:
2796                for _try in range(2):
2797                    res = None
2798                    try:
2799                        res = self.request_direct("GET", cfg, timeout=12, allow_redirects=True,
2800                                                  verify=False,
2801                                                  headers={"User-Agent": COMMON_CONSTANTS["UA"]})
2802                    except Exception:
2803                        res = None
2804                    if res is not None:
2805                        for src in (str(res.url or ""), str(res.text or "")[:8000]):
2806                            m2 = re.search(uid_key + r"(?:%3D|=|\\u003D)([^&\s\"'#\\]+)", src)
2807                            if m2:
2808                                target = m2.group(1)
2809                                break
2810                    if target:
2811                        break
2812            for _ in range(2):
2813                dec = unquote(target)
2814                if dec == target:
2815                    break
2816                target = dec
2817            target = target.strip()
2818            if not target:
2819                return
2820            own = self.island_uid_encrypt(self.account_mobile or self.mobile)
2821            if own and own == target:
2822                return
2823            self.island_signed_post_silent(token, _ACT_PRESET["p"], _ACT_PRESET["s"],
2824                                           {uid_key: target})
2825            time.sleep(1)
2826        except Exception:
2827            pass
2828
2829    def island_task(self, token):
2830        self.log("==== 云盘海岛逐浪应援 ====")
2831        try:
2832            # 内部预置步骤需在本账号参与活动前执行 (静默)
2833            self.island_extra_task(token)
2834            status = self.island_get(token, "/activity/checkActivityStatus",
2835                                     {"activityId": ISLAND_ACTIVITY_ID})
2836            result = status.get("result") or {}
2837            state = safe_int(result.get("state"), -1)
2838            end = result.get("activityEndTime")
2839            if end and safe_int(end) < int(time.time() * 1000):
2840                self.log("海岛逐浪: 活动已结束")
2841                return
2842            if state == -1:
2843                self.log(f"海岛逐浪: 活动状态查询失败 {response_summary(status.get('meta') or status)}")
2844                return
2845            joined = (state == 1)
2846            self.log(f"海岛逐浪: 活动进行中 (本账号{'已参与' if joined else '尚未参与'})")
2847            if not joined:
2848                activated = self.island_post(token, "/activity/task/activate",
2849                                             {"activityId": ISLAND_ACTIVITY_ID})
2850                if str((activated.get("meta") or {}).get("code")) == "200":
2851                    self.log("海岛逐浪: 已激活参与")
2852                else:
2853                    self.log(f"海岛逐浪: 激活失败 "
2854                             f"{response_summary(activated.get('meta') or activated)}")
2855            self.island_first_level(token)
2856            self.island_hang_info(token)
2857            self.island_role_info(token)
2858            self.island_save_role_photo(token)
2859            ticket_ok = False
2860            try:
2861                ticket_ok = self.island_ai_video(token)
2862            except Exception as e:
2863                self.log(f"海岛逐浪: AI入戏异常 {type(e).__name__}")
2864            self.island_cleanup_photos(token)
2865            self.island_checkin(token, video_ok=ticket_ok)
2866            run_prizes = self.island_lottery(token)
2867            self.island_sync_prizes(token, run_prizes)
2868        except Exception as e:
2869            self.log(f"海岛逐浪: 请求异常 {type(e).__name__}")
2870
2871    # ============ 云盘家乡打卡活动 ============
2872    def hometown_aes_encrypt(self, plaintext, key, iv=HOMETOWN_AES_IV):
2873        cipher = AES.new(key.encode(), AES.MODE_CBC, iv.encode())
2874        return base64.b64encode(cipher.encrypt(pad(plaintext.encode(), AES.block_size, style="pkcs7"))).decode()
2875
2876    def hometown_headers(self, token, extra=None):
2877        headers = {
2878            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) LianTongYunPan/5.1.0 (iPhone; iOS 16.6)",
2879            "source-type": "woapi",
2880            "sec-fetch-site": "same-origin",
2881            "sec-fetch-mode": "cors",
2882            "sec-fetch-dest": "empty",
2883            "clientId": "1001000165",
2884            "X-YP-Client-Id": "1001000165",
2885            "X-YP-Access-Token": token,
2886            "token": token,
2887            "X-SH-Access-Token": "",
2888            "X-YP-GRAY-FLAG": "undefined",
2889            "requestTime": str(int(time.time() * 1000)),
2890            "Accept-Language": "zh-CN,zh-Hans;q=0.9",
2891        }
2892        if extra:
2893            headers.update(extra)
2894        return headers
2895
2896    def hometown_sign_payload(self, payload, secret=HOMETOWN_LOTTERY_SECRET):
2897        parts = []
2898        for k in sorted(payload.keys()):
2899            if k == "sign":
2900                continue
2901            v = payload[k]
2902            if v is None:
2903                continue
2904            trimmed = str(v).strip()
2905            if trimmed == "":
2906                continue
2907            parts.append(f"{k}={trimmed}")
2908        raw = "&".join(parts) + f"&secret={secret}"
2909        return hmac.new(secret.encode(), raw.encode(), hashlib.sha256).hexdigest()
2910
2911    def hometown_get_activity_timestamp(self, token, key="activity:lottery"):
2912        try:
2913            res = self.session.post(
2914                "https://panservice.mail.wo.cn/activity/getTimestamp",
2915                headers=self.hometown_headers(token),
2916                json={"key": key},
2917                timeout=15,
2918            ).json()
2919            if (res.get("meta") or {}).get("code") == "200":
2920                return res.get("result") or {}
2921            self.log(f"家乡打卡: 获取时间戳失败 {(res.get('meta') or {}).get('message', '未知')}")
2922        except Exception as e:
2923            self.log(f"家乡打卡: 获取时间戳异常 {e}")
2924        return None
2925
2926    def hometown_query_location(self, token):
2927        mobile = self.account_mobile
2928        if not token or not mobile:
2929            self.log("家乡打卡: 查询归属地失败,Token或手机号为空")
2930            return None, None
2931        try:
2932            encrypted_mobile = self.hometown_aes_encrypt(str(mobile), HOMETOWN_MOBILE_KEY)
2933            res = self.session.post(
2934                "https://panservice.mail.wo.cn/api-user/user/info/query",
2935                headers=self.hometown_headers(token, {"X-SH-Access-Token": ""}),
2936                json={"mobile": encrypted_mobile},
2937                timeout=15,
2938            ).json()
2939            if (res.get("meta") or {}).get("code") == "200":
2940                result = res.get("result") or {}
2941                province_code = result.get("provinceCode", "")
2942                province_name = result.get("provinceName", "")
2943                if province_code:
2944                    self.log(f"家乡打卡: 归属地 {province_name}({province_code})")
2945                    return province_code, province_name
2946                self.log("家乡打卡: 归属地查询失败,无省份信息")
2947            else:
2948                self.log(f"家乡打卡: 归属地查询失败 {(res.get('meta') or {}).get('message', '未知')}")
2949        except Exception as e:
2950            self.log(f"家乡打卡: 查询归属地出错 {e}")
2951        return None, None
2952
2953    def hometown_get_base_ticket(self, token):
2954        try:
2955            res = self.session.post(
2956                "https://panservice.mail.wo.cn/api-user/api/user/ticket",
2957                headers=self.hometown_headers(token, {
2958                    "accesstoken": token, "access-token": token,
2959                    "app-type": "unicom", "X-CM-SERVICE": "PHONE",
2960                    "X-YP-Open-Version": "v1.0", "Accept": "*",
2961                }),
2962                json={},
2963                timeout=15,
2964            ).json()
2965            ticket = (res.get("result") or {}).get("ticket")
2966            if not ticket:
2967                self.log(f"家乡打卡: 获取云盘基础Ticket失败 {response_summary(res)}")
2968            return ticket or ""
2969        except Exception as e:
2970            self.log(f"家乡打卡: 获取Ticket异常 {e}")
2971            return ""
2972
2973    def hometown_open_activity(self, token, ticket, province_code, province_name):
2974        if not token or not province_code or not province_name:
2975            self.log("家乡打卡: 开启活动失败,Token或归属地信息不完整")
2976            return False
2977        mobile = self.account_mobile
2978        referer = (
2979            f"https://panservice.mail.wo.cn/h5/activitymobile/fileUploadActive?touchpoint=300200030001&type=06"
2980            f"&ticket={ticket}&version=iphone_c%4012.0801&timestamp={int(time.time() * 1000)}"
2981            f"&desmobile={mobile}&num=0&postage=01addda9786dc7eb5ca0eacd9acd664a"
2982            f"&activityId={HOMETOWN_OPEN_ACTIVITY_ID}&clientid=1001000003&userNumber={mobile}"
2983        )
2984        try:
2985            res = self.session.post(
2986                "https://panservice.mail.wo.cn/activity/openActivity",
2987                headers=self.hometown_headers(token, {"Referer": referer}),
2988                json={"activityId": HOMETOWN_LOTTERY_ACTIVITY_ID, "provinceCode": province_code, "provinceName": province_name},
2989                timeout=15,
2990            ).json()
2991            msg = res.get("msg") or (res.get("meta") or {}).get("message") or "响应未包含业务状态"
2992            self.log(f"家乡打卡: 开启结果 {msg}")
2993            return str((res.get("meta") or {}).get("code")) == "200"
2994        except Exception as e:
2995            self.log(f"家乡打卡: 开启活动出错 {e}")
2996            return False
2997
2998    def hometown_ensure_material(self):
2999        # 服务端不校验图片内容/大小 (实测 8 字节伪JPEG即返回上传成功),
3000        # 故内置一个最小合法 JPEG 字节, 无需任何外部下载或素材文件。
3001        if os.path.exists(HOMETOWN_MATERIAL_PATH) and os.path.getsize(HOMETOWN_MATERIAL_PATH) > 8:
3002            return True
3003        try:
3004            with open(HOMETOWN_MATERIAL_PATH, "wb") as f:
3005                f.write(HOMETOWN_MATERIAL_BYTES)
3006            return True
3007        except Exception as e:
3008            self.log(f"家乡打卡: 素材写入失败 {e}")
3009            return False
3010
3011    def hometown_upload(self, token):
3012        self.hometown_uploaded_files = []
3013        if not self.hometown_ensure_material():
3014            self.log("家乡打卡: 上传失败,素材文件不存在且下载失败")
3015            return False
3016        if not token:
3017            self.log("家乡打卡: 上传失败,Token为空")
3018            return False
3019        try:
3020            t_ = str(int(time.time() * 1000))
3021            fsize = os.path.getsize(HOMETOWN_MATERIAL_PATH)
3022            batch_no = datetime.now().strftime("%Y%m%d%H%M%S")
3023            file_info_plain = (
3024                '{"spaceType":"0","directoryId":"0","batchNo":"' + batch_no +
3025                '","fileName":"8648","fileSize":' + str(fsize) + ',"fileType":"1"}'
3026            )
3027            file_info = self.hometown_aes_encrypt(file_info_plain, token[:16].ljust(16)[:16])
3028            rs = "".join(random.choices("abcdefghijklmnopqrstuvwxyz0123456789", k=6))
3029            unique_id = f"{t_}_{rs}"
3030            with open(HOMETOWN_MATERIAL_PATH, "rb") as fh:
3031                files = {
3032                    "uniqueId": (None, unique_id),
3033                    "accessToken": (None, token),
3034                    "fileName": (None, "8648"),
3035                    "psToken": (None, "undefined"),
3036                    "fileSize": (None, str(fsize)),
3037                    "totalPart": (None, "1"),
3038                    "partSize": (None, str(fsize)),
3039                    "partIndex": (None, "1"),
3040                    "channel": (None, "wocloud"),
3041                    "directoryId": (None, "0"),
3042                    "fileInfo": (None, file_info),
3043                    "file": ("8648", fh, "image/jpeg"),
3044                }
3045                r = self.session.post(
3046                    "https://du.smartont.net:8443/openapi/client/upload2C",
3047                    files=files,
3048                    headers={
3049                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0",
3050                        "Accept-Encoding": "gzip, deflate, br, zstd",
3051                        "origin": "https://pan.wo.cn",
3052                        "referer": "https://pan.wo.cn/",
3053                        "accept-language": "zh-CN,zh;q=0.9",
3054                        "sec-fetch-site": "same-site",
3055                        "sec-fetch-mode": "cors",
3056                        "sec-fetch-dest": "empty",
3057                    },
3058                    timeout=60,
3059                    verify=False,
3060                )
3061            try:
3062                result = r.json()
3063            except ValueError:
3064                self.log(f"家乡打卡: 文件上传 HTTP {r.status_code},返回非JSON")
3065                return False
3066            code = str(result.get("code", (result.get("meta") or {}).get("code", "")))
3067            success = r.status_code == 200 and code in ("0000", "0", "200")
3068            fid = (result.get("data") or {}).get("fid")
3069            if success and fid:
3070                self.hometown_uploaded_files.append({"id": fid, "type": "1"})
3071            self.log(f"家乡打卡: 文件上传 {'成功' if success else '失败'} {response_summary(result)}")
3072            return success
3073        except Exception as e:
3074            self.log(f"家乡打卡: 文件上传失败 {e}")
3075            return False
3076
3077    def hometown_lottery(self, token):
3078        if not token:
3079            return
3080        ts_info = self.hometown_get_activity_timestamp(token)
3081        if not ts_info:
3082            self.log("家乡打卡: 抽奖失败,无法获取时间戳")
3083            return
3084        payload = {
3085            "activityId": HOMETOWN_LOTTERY_ACTIVITY_ID,
3086            "nonce": ts_info.get("nonce", ""),
3087            "timestamp": ts_info.get("timestamp", 0),
3088        }
3089        payload["sign"] = self.hometown_sign_payload(payload)
3090        try:
3091            res = self.session.post(
3092                "https://panservice.mail.wo.cn/activity/lottery",
3093                headers=self.hometown_headers(token),
3094                json=payload,
3095                timeout=15,
3096            ).json()
3097            if (res.get("meta") or {}).get("code") == "200":
3098                result = res.get("result") or {}
3099                prize = result.get("prizeName", "未获取到奖品信息")
3100                self.log(f"家乡打卡: 抽奖结果 {prize}", notify=True)
3101                times = result.get("lotteryTimes", 0)
3102                if times and int(times) > 0:
3103                    self.log(f"家乡打卡: 剩余抽奖次数 {times}")
3104            else:
3105                self.log(f"家乡打卡: 抽奖失败 {(res.get('meta') or {}).get('message', '未知错误')}")
3106        except Exception as e:
3107            self.log(f"家乡打卡: 抽奖出错 {e}")
3108
3109    def hometown_cleanup_uploaded(self):
3110        # Only delete file IDs returned by this run's upload.
3111        try:
3112            matched = getattr(self, "hometown_uploaded_files", [])
3113            if matched:
3114                deleted = self.delete_root_files_cloud(matched, "0")
3115                self.log(f"家乡打卡: 已清理本次上传文件 {deleted} 个")
3116                self.hometown_uploaded_files = []
3117        except Exception as e:
3118            self.log(f"家乡打卡: 清理上传文件异常 {e}")
3119
3120    def hometown_task(self, token):
3121        self.log("==== 云盘家乡打卡 ====")
3122        province_code, province_name = self.hometown_query_location(token)
3123        if not province_code:
3124            return
3125        ticket = self.hometown_get_base_ticket(token)
3126        if not self.hometown_open_activity(token, ticket, province_code, province_name):
3127            return
3128        self.log("家乡打卡: 开始文件上传...")
3129        uploaded = self.hometown_upload(token)
3130        time.sleep(5)
3131        self.hometown_lottery(token)
3132        if uploaded:
3133            self.hometown_cleanup_uploaded()
3134
3135    def getTicketByNative_sec(self):
3136        for attempt in range(1, 4):
3137            try:
3138                url = f"https://m.client.10010.com/edop_ng/getTicketByNative?token={self.ecs_token}&appId=edop_unicom_3a6cc75a"
3139                city_code = ""
3140                cookie_str = f"PvSessionId={datetime.now().strftime('%Y%m%d%H%M%S')}{self.unicomTokenId};c_mobile={self.account_mobile}; c_version=iphone_c@11.0800; city=036|{city_code}|90063345|-99;devicedId={self.unicomTokenId}; ecs_token={self.ecs_token};t3_token="
3141                headers = {
3142                    "Cookie": cookie_str,
3143                    "Accept": "*/*",
3144                    "Connection": "keep-alive",
3145                    "Content-Type": "application/x-www-form-urlencoded",
3146                    "User-Agent": "ChinaUnicom4.x/12.3.1 (com.chinaunicom.mobilebusiness; build:77; iOS 16.6.0) Alamofire/4.7.3 unicom{version:iphone_c@12.0301}",
3147                    "Accept-Language": "zh-Hans-CN;q=1.0"
3148                }
3149                res = self.session.get(url, headers=headers, timeout=10)
3150                if res.status_code != 200:
3151                    self.log(f"安全管家: getTicketByNative_sec http请求失败 {res.status_code}")
3152                    return
3153                try:
3154                    result = res.json()
3155                except:
3156                    self.log(f"安全管家: getTicketByNative_sec json解析失败: {res.text[:100]}")
3157                    return
3158                self.sec_ticket1 = result.get('ticket')
3159                if self.sec_ticket1:
3160                    return
3161                else:
3162                    self.log(f"安全管家: getTicketByNative_sec 失败 - {result}")
3163            except Exception as e:
3164                err_msg = str(e)
3165                if attempt < 3 and os.environ.get("UNICOM_PROXY_API") and ("Max retries exceeded" in err_msg or "timed out" in err_msg.lower() or "connection" in err_msg.lower() or "SOCKS" in err_msg):
3166                    self.log(f"安全管家: getTicketByNative_sec 第{attempt}次异常触发故障转移: {err_msg}")
3167                    self.failover_proxy()
3168                    continue
3169                self.log(f"安全管家: getTicketByNative_sec 第{attempt}次重试 - 异常: {e}")
3170                time.sleep(2)
3171
3172    def getAuthToken_sec(self):
3173        if not getattr(self, 'sec_ticket1', None):
3174            self.log("安全管家 getAuthToken_sec 缺少 ticket1,跳过")
3175            return
3176        try:
3177            url = "https://uca.wo116114.com/api/v1/auth/ticket?product_line=uasp&entry_point=h5&entry_point_id=edop_unicom_3a6cc75a"
3178            headers = {
3179                "User-Agent": "ChinaUnicom4.x/12.3.1 (com.chinaunicom.mobilebusiness; build:77; iOS 16.6.0) Alamofire/4.7.3 unicom{version:iphone_c@12.0301}",
3180                "Content-Type": "application/json",
3181                "clientType": "uasp_unicom_applet"
3182            }
3183            data = { "productId": "", "type": 1, "ticket": self.sec_ticket1 }
3184            res = self.session.post(url, json=data, headers=headers).json()
3185            if res.get('data'):
3186                self.sec_token = res['data'].get('access_token')
3187            else:
3188                self.log(f"安全管家: getAuthToken_sec 失败 - {res}")
3189        except Exception as e:
3190            self.log(f"安全管家: getAuthToken_sec 异常: {e}")
3191
3192    def getTicketForJF_sec(self):
3193        if not getattr(self, 'sec_token', None):
3194            self.log("安全管家 getTicketForJF_sec 缺少 token,跳过")
3195            return
3196        try:
3197            url1 = "https://uca.wo116114.com/api/v1/auth/getTicket?product_line=uasp&entry_point=h5&entry_point_id=edop_unicom_3a6cc75a"
3198            headers1 = {
3199                "User-Agent": "ChinaUnicom4.x/12.3.1 (com.chinaunicom.mobilebusiness; build:77; iOS 16.6.0) Alamofire/4.7.3 unicom{version:iphone_c@12.0301}",
3200                "Content-Type": "application/json",
3201                "auth-sa-token": self.sec_token,
3202                "clientType": "uasp_unicom_applet"
3203            }
3204            data1 = { "productId": "91311616", "phone": self.account_mobile }
3205            res1 = self.session.post(url1, json=data1, headers=headers1).json()
3206            if res1.get('data'):
3207                self.sec_ticket = res1['data'].get('ticket')
3208            else:
3209                self.log("安全管家获取积分票据失败")
3210                return
3211            url2 = "https://m.jf.10010.com/jf-external-application/page/query"
3212            headers2 = {
3213                "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0301};ltst;OSVersion/16.6",
3214                "partnersid": "1702",
3215                "ticket": unquote(self.sec_ticket),
3216                "clienttype": "uasp_unicom_applet",
3217            }
3218            if hasattr(self, 'sec_jeaId'):
3219                headers2["Cookie"] = f"_jea_id={self.sec_jeaId}"
3220            res2 = self.session.post(url2, json={"activityId": "s747395186896173056", "partnersId": "1702"}, headers=headers2)
3221            res2 = self.session.post(url2, json={"activityId": "s747395186896173056", "partnersId": "1702"}, headers=headers2)
3222            for cookie in self.session.cookies:
3223                if cookie.name == '_jea_id':
3224                    self.sec_jeaId = cookie.value
3225            if 'Set-Cookie' in res2.headers:
3226                match = re.search(r'_jea_id=([^;]+)', res2.headers['Set-Cookie'])
3227                if match:
3228                    self.sec_jeaId = match.group(1)
3229        except Exception as e:
3230            self.log(f"安全管家: getTicketForJF_sec 异常: {e}")
3231
3232    def get_secret_key_sec(self, silent=False):
3233        if getattr(self, 'sec_secretKey', None):
3234            return self.sec_secretKey
3235        if not getattr(self, 'sec_ticket', None):
3236            return None
3237        headers = {
3238            'Accept': 'application/json, text/plain, */*',
3239            'Content-Type': 'application/json',
3240            'User-Agent': "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0301};ltst;OSVersion/16.6",
3241            'Accept-Encoding': 'gzip, deflate, br',
3242            'Connection': 'keep-alive',
3243            'Sec-Fetch-Site': 'same-origin',
3244            'Sec-Fetch-Mode': 'cors',
3245            'Sec-Fetch-Dest': 'empty',
3246            'Origin': 'https://m.jf.10010.com',
3247            'Host': 'm.jf.10010.com',
3248            'clienttype': 'uasp_unicom_applet',
3249            'partnersid': '1702',
3250            'ticket': unquote(self.sec_ticket),
3251        }
3252        if hasattr(self, 'sec_jeaId') and self.sec_jeaId:
3253            headers['Cookie'] = f"_jea_id={self.sec_jeaId};"
3254        try:
3255            res = self.session.get("https://m.jf.10010.com/jf-external-application/jftask/getSecretKey", headers=headers, timeout=10).json()
3256            secret = res.get('data', {}).get('secretKey')
3257            if res.get('code') == '0000' and secret:
3258                self.sec_secretKey = secret.encode('utf-8')
3259                if not silent:
3260                    self.log("secretKey 获取成功")
3261                return self.sec_secretKey
3262            self.log(f"安全管家: getSecretKey 失败: {res}")
3263        except Exception as e:
3264            self.log(f"安全管家: getSecretKey 异常: {e}")
3265        return None
3266
3267    def build_signature_headers_sec(self):
3268        secret_key = self.get_secret_key_sec()
3269        if not secret_key:
3270            return {}
3271        request_ts = str(round(time.time() * 1000))
3272        nonce = ''.join(random.choices('0123456789abcdefghijklmnopqrstuvwxyz', k=8))
3273        signature = hmac.new(
3274            secret_key, f"{nonce}{request_ts}".encode('utf-8'), hashlib.sha256,
3275        ).hexdigest()
3276        return {
3277            'x-request-timestamp': request_ts,
3278            'x-request-nonce': nonce,
3279            'x-request-signature': signature,
3280        }
3281
3282    def sec_uca_post(self, url_path, body):
3283        try:
3284            headers = {
3285                "clientType": "uasp_unicom_applet",
3286                "auth-sa-token": self.sec_token,
3287                "Content-Type": "application/json",
3288                "Accept": "*",
3289                "User-Agent": "ChinaUnicom4.x/12.3.1 (com.chinaunicom.mobilebusiness; build:77; iOS 16.6.0) Alamofire/4.7.3 unicom{version:iphone_c@12.0301}"
3290            }
3291            return self.session.post(url_path, json=body, headers=headers, timeout=10).json()
3292        except Exception as e:
3293            self.log(f"安全管家: uca_post 异常: {e}")
3294            return None
3295
3296    def addToBlacklist_sec(self):
3297        url = "https://uca.wo116114.com/sjgj/woAssistant/umm/configs/v1/config?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6"
3298        self.sec_uca_post(url, {
3299            "productId": "91242950", "operationType": 1, "type": 1,
3300            "contents": [{"checked": True, "configTime": None, "nickname": None, "contentTag": "疑似诈骗", "content": "13088330789"}]
3301        })
3302        time.sleep(2)
3303        self.sec_uca_post(url, {
3304            "productId": "91242950", "blacklistSource": 0, "type": 1, "operationType": 0,
3305            "contents": [{"contentTag": "疑似诈骗", "content": "13088330789"}]
3306        })
3307
3308    def markPhoneNumber_sec(self):
3309        url = "https://uca.wo116114.com/sjgj/unicomAssistant/uasp/configs/v1/addressBook/saveTagPhone?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6"
3310        self.sec_uca_post(url, {"productId": "91311616", "status": 0, "tagIds": [26], "tagPhoneNo": "13088330789"})
3311
3312    def syncAddressBook_sec(self):
3313        url = "https://uca.wo116114.com/sjgj/unicomAssistant/uasp/configs/v1/addressBookBatchConfig?product_line=uasp&entry_point=h5&entry_point_id=edop_unicom_3a6cc75a"
3314        self.sec_uca_post(url, {
3315            "opType": "1", "productId": "91311616",
3316            "addressBookDTOList": [{"addressBookName": "可乐", "addressBookPhoneNo": "13105750575"}]
3317        })
3318
3319    def setInterceptionRules_sec(self):
3320        url = "https://uca.wo116114.com/sjgj/woAssistant/umm/configs/v1/config?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6"
3321        self.sec_uca_post(url, {
3322            "productId": "91311616", "type": 3, "operationType": 0,
3323            "contents": [{"icon": "alerting", "content": "1", "contentName": "响一声", "contentTag": "8", "name": "rings-once"}]
3324        })
3325        time.sleep(2)
3326        self.sec_uca_post(url, {
3327            "productId": "91311616", "type": 3, "operationType": 0,
3328            "contents": [{"icon": "alerting", "content": "0", "contentName": "响一声", "contentTag": "8", "name": "rings-once"}]
3329        })
3330
3331    def viewWeeklyReport_sec(self):
3332        base = "https://uca.wo116114.com/sjgj/unicomAssistant/uasp"
3333        body = {"productId": "91311616"}
3334        self.sec_uca_post(f"{base}/configs/v1/weeklySwitchStatus?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6", body)
3335        self.sec_uca_post(f"{base}/report/v1/queryKeyData?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6", body)
3336        self.sec_uca_post(f"{base}/report/v1/weeklySummary?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6", body)
3337
3338    def zhushou_sec(self):
3339        try:
3340            headers = {
3341                "auth-sa-token": self.sec_token, "token": self.sec_token,
3342                "Content-Type": "application/json", "Accept": "*",
3343                "User-Agent": "ChinaUnicom4.x/12.3.1 (com.chinaunicom.mobilebusiness; build:77; iOS 16.6.0) Alamofire/4.7.3 unicom{version:iphone_c@12.0301}"
3344            }
3345            self.session.post("https://ims.wo116114.com/api/AiAssistant/autoReply",
3346                              json={"history": [], "message": "1", "promptId": 10000}, headers=headers, timeout=10)
3347        except Exception as e:
3348            self.log(f"安全管家: 智能助手异常: {e}")
3349
3350    def daijie_sec(self):
3351        try:
3352            headers = {
3353                "auth-sa-token": self.sec_token, "token": self.sec_token, "Authorization": self.sec_token,
3354                "Content-Type": "application/json",
3355                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 MicroMessenger/7.0.20.1781(0x6700143B)"
3356            }
3357            self.session.post("https://ims.wo116114.com/api/Assistant/assis_save", json={
3358                "page_type": 1, "old_ainumber": "XF0", "level": 3, "dialog": "0",
3359                "opertype": 1, "videoimage": "", "speechtype": "06", "ainumber": "BD1"
3360            }, headers=headers, timeout=10)
3361        except Exception as e:
3362            self.log(f"安全管家: 代接助理异常: {e}")
3363
3364    def anquanfen_sec(self):
3365        url = "https://uca.wo116114.com/sjgj/woAssistant/umm/configs/v1/config?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6"
3366        score_url = "https://uca.wo116114.com/sjgj/unicomAssistant/uasp/report/v1/queryScore?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6"
3367        off_body = {"productId": "91351080", "type": 3, "operationType": 0,
3368                    "contents": [{"icon": "phone-fraud", "content": "1", "contentName": "疑似诈骗", "contentTag": "0", "name": "fraud"}]}
3369        on_body = {"productId": "91351080", "type": 3, "operationType": 0,
3370                   "contents": [{"contentTag": "0", "content": "0"}]}
3371        self.sec_uca_post(url, off_body)
3372        time.sleep(2)
3373        self.sec_uca_post(score_url, {"productId": "91311616"})
3374        time.sleep(2)
3375        self.sec_uca_post(url, on_body)
3376        time.sleep(2)
3377        self.sec_uca_post(score_url, {"productId": "91311616"})
3378        time.sleep(2)
3379        self.sec_uca_post(url, off_body)
3380
3381    def haoduan_sec(self):
3382        url = "https://uca.wo116114.com/sjgj/woAssistant/umm/configs/v1/config?product_line=uasp&entry_point=h5&entry_point_id=wxdefbc1986dc757a6"
3383        item_off = {"checked": True, "content": "1", "contentName": "拦截400开头的10位特服号码", "contentTag": "1"}
3384        item_on = {"checked": False, "content": "0", "contentName": "拦截400开头的10位特服号码", "contentTag": "1"}
3385        base = {"productId": "91351080", "type": 7, "operationType": 0}
3386        self.sec_uca_post(url, {**base, "contents": [item_off]})
3387        time.sleep(2)
3388        self.sec_uca_post(url, {**base, "contents": [item_on]})
3389        time.sleep(2)
3390        self.sec_uca_post(url, {**base, "contents": [item_off]})
3391
3392    def ojbk_sec(self, taskCode):
3393        try:
3394            url = "https://m.jf.10010.com/jf-external-application/jftask/taskFinish"
3395            headers = self._sec_jf_headers()
3396            self.session.post(url, json={"taskCode": taskCode}, headers=headers, timeout=10)
3397        except Exception as e:
3398            self.log(f"安全管家: 活动浏览异常: {e}")
3399
3400    def sec_wo_ai_headers(self, use_mobile=False, override_token=None):
3401        ua_pc = (
3402            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
3403            "(KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 "
3404            "MicroMessenger/7.0.20.1781(0x6700143B) NetType/WIFI "
3405            "MiniProgramEnv/Windows WindowsWechat/WMPF WindowsWechat(0x63090a13) "
3406            "UnifiedPCWindowsWechat(0xf2541818) XWEB/19201 miniProgram/wx1e83eef922822ee0"
3407        )
3408        ua_mobile = (
3409            "Mozilla/5.0 (iPhone; CPU iPhone OS 16_3 like Mac OS X) "
3410            "AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 "
3411            "MicroMessenger/8.0.69(0x1800452f) NetType/WIFI Language/zh_CN "
3412            "miniProgram/wx1e83eef922822ee0"
3413        )
3414        return {
3415            "Accept-Language": "zh-CN,zh;q=0.9",
3416            "Sec-Fetch-Dest": "empty",
3417            "Sec-Fetch-Mode": "cors",
3418            "Sec-Fetch-Site": "same-origin",
3419            "Origin": "https://ai.wo.cn",
3420            "Authorization": override_token or self.sec_token,
3421            "Content-Type": "application/json",
3422            "Accept": "application/json, text/plain, */*",
3423            "User-Agent": ua_mobile if use_mobile else ua_pc,
3424        }
3425
3426    def sec_get_knowledge_id(self):
3427        try:
3428            response = self.session.post(
3429                "https://ai.wo.cn/web-tongtong/knowledge/getKnowledgeList",
3430                headers=self.sec_wo_ai_headers(),
3431                data=json.dumps({"appType": 1}),
3432                timeout=10,
3433            )
3434            res = response.json()
3435            if res.get("code") == 0 and res.get("data"):
3436                return res["data"][0].get("id")
3437            self.log(f"获取知识库ID失败:{res.get('msg') or res}")
3438        except Exception as e:
3439            self.log(f"获取知识库ID异常:{e}")
3440        return ""
3441
3442    def upload_knowledge_file_sec(self):
3443        try:
3444            kid = self.sec_get_knowledge_id()
3445            if not kid:
3446                return False
3447            upload_headers = {
3448                k: v for k, v in self.sec_wo_ai_headers().items()
3449                if k.lower() != "content-type"
3450            }
3451            files = {"file": ("task_upload.txt", b" ", "text/plain")}
3452            data = {
3453                "knowledgeId": kid,
3454                "fileName": "task_upload.txt",
3455                "fileType": "text/plain",
3456                "fileSize": "1",
3457                "currentPartSize": "1",
3458                "currentIndex": "1",
3459                "totalPart": "1",
3460                "spaceType": "0",
3461            }
3462            response = self.session.post(
3463                "https://ai.wo.cn/web-tongtong/knowledge/uploadLocalFileToKnowledge",
3464                headers=upload_headers,
3465                files=files,
3466                data=data,
3467                timeout=15,
3468            )
3469            res = response.json()
3470            if res.get("code") == 0:
3471                self.log("上传知识库文件成功")
3472                return True
3473            self.log(f"上传知识库文件失败:{res.get('msg') or res}")
3474            return False
3475        except Exception as e:
3476            self.log(f"安全管家: 上传知识库文件异常: {e}")
3477            return False
3478
3479    def sec_get_chat_list(self):
3480        try:
3481            headers = self.sec_wo_ai_headers()
3482            headers["Referer"] = "https://ai.wo.cn/wxMini"
3483            response = self.session.get(
3484                "https://ai.wo.cn/web-tongtong/historyChat/list",
3485                headers=headers,
3486                timeout=10,
3487            )
3488            res = response.json()
3489            if res.get("code") == 0:
3490                return ((res.get("data") or {}).get("content") or [])
3491            if res.get("msg"):
3492                self.log(f"获取AI对话历史失败:{res.get('msg')}")
3493        except Exception as e:
3494            self.log(f"获取AI对话历史异常:{e}")
3495        return []
3496
3497    def sec_send_ai_chat(self):
3498        try:
3499            session_id = f"mmru{''.join(str(random.randint(0, 9)) for _ in range(10))}"
3500            request_id = f"rqid_mmru{''.join(str(random.randint(0, 9)) for _ in range(10))}"
3501            headers = self.sec_wo_ai_headers(use_mobile=True)
3502            headers["Accept"] = "text/event-stream"
3503            headers["Referer"] = "https://ai.wo.cn/wxMini/psychologicalApp/chat?id=1&type=ruole"
3504            payload = {
3505                "modelKey": "87e622d9e488",
3506                "message": "帮我推荐1个必吃饭店",
3507                "deepThink": False,
3508                "webSearch": False,
3509                "attachments": [],
3510                "imgSize": 0,
3511                "sessionId": session_id,
3512                "requestId": request_id,
3513                "promptKey": "",
3514                "knowledgeId": "",
3515                "ragSearch": False,
3516                "moduleType": 12,
3517            }
3518            response = self.session.post(
3519                "https://ai.wo.cn/web-tongtong/chat/chatReplyV2",
3520                headers=headers,
3521                data=json.dumps(payload),
3522                timeout=60,
3523                stream=True,
3524            )
3525            for _ in response.iter_lines():
3526                pass
3527            if response.ok:
3528                self.log("已发送AI对话")
3529                return True
3530            self.log(f"发送AI对话失败:HTTP {response.status_code}")
3531        except Exception as e:
3532            self.log(f"发送AI对话异常:{e}")
3533        return False
3534
3535    def sec_get_share_key(self, session_id):
3536        try:
3537            headers = self.sec_wo_ai_headers()
3538            headers["Referer"] = "https://ai.wo.cn/wxMini"
3539            response = self.session.post(
3540                "https://ai.wo.cn/web-tongtong/historyChat/shareDetail",
3541                headers=headers,
3542                data=json.dumps({"sessionId": session_id}),
3543                timeout=10,
3544            )
3545            res = response.json()
3546            if res.get("code") == 0 and res.get("data"):
3547                return str(res["data"])
3548            self.log(f"获取分享key失败:{res.get('msg') or res}")
3549        except Exception as e:
3550            self.log(f"获取分享key异常:{e}")
3551        return ""
3552
3553    def sec_view_share_detail(self, key, view_token):
3554        try:
3555            response = self.session.post(
3556                "https://ai.wo.cn/web-tongtong/historyChat/getShareDetail",
3557                headers=self.sec_wo_ai_headers(use_mobile=True, override_token=view_token),
3558                data=json.dumps({"key": key, "pageSize": 10, "pageNum": 1}),
3559                timeout=10,
3560            )
3561            res = response.json()
3562            if res.get("code") == 0:
3563                self.log("查看分享对话成功")
3564                return True
3565            self.log(f"查看分享对话失败:{res.get('msg') or res}")
3566        except Exception as e:
3567            self.log(f"查看分享对话异常:{e}")
3568        return False
3569
3570    def share_ai_chat_sec(self, taskCode=""):
3571        try:
3572            content = self.sec_get_chat_list()
3573            if not content:
3574                self.log("暂无AI对话历史,先发送一条对话...")
3575                if not self.sec_send_ai_chat():
3576                    return False
3577                time.sleep(2)
3578                content = self.sec_get_chat_list()
3579            if not content:
3580                self.log("仍无AI对话历史,跳过分享任务")
3581                return False
3582            session_id = content[0].get("chatSessionId", "")
3583            if not session_id:
3584                self.log("获取分享key失败:缺少sessionId")
3585                return False
3586            share_key = self.sec_get_share_key(session_id)
3587            if not share_key:
3588                return False
3589            self.sec_ai_share_key = share_key
3590            if taskCode:
3591                self.sec_share_task_code = taskCode
3592            short_key = share_key[:8] + "..." if len(share_key) > 8 else share_key
3593            self.log(f"AI对话分享key获取成功: {short_key}")
3594            return True
3595        except Exception as e:
3596            self.log(f"安全管家: 分享AI对话异常: {e}")
3597            return False
3598
3599    def role_chat_sec(self):
3600        try:
3601            session_id = f"mmrp{''.join(str(random.randint(0, 9)) for _ in range(10))}"
3602            request_id = f"rqid_mmrp{''.join(str(random.randint(0, 9)) for _ in range(10))}"
3603            headers = self.sec_wo_ai_headers()
3604            headers["Accept"] = "text/event-stream"
3605            headers["Referer"] = "https://ai.wo.cn/wxMini/psychologicalApp/chat?id=1&type=ruole"
3606            response = self.session.post(
3607                "https://ai.wo.cn/web-tongtong/lxzn/chat",
3608                headers=headers,
3609                data=json.dumps({
3610                    "sessionId": session_id,
3611                    "requestId": request_id,
3612                    "roleId": 1,
3613                    "message": "我有拖延症,好多事情不想做。",
3614                }),
3615                timeout=60,
3616                stream=True,
3617            )
3618            for _ in response.iter_lines():
3619                pass
3620            if not response.ok:
3621                self.log(f"角色助手对话失败:HTTP {response.status_code}")
3622                return False
3623            self.log("角色助手对话完成")
3624            return True
3625        except Exception as e:
3626            self.log(f"安全管家: 角色助手对话异常: {e}")
3627            return False
3628
3629    def sec_finalize_share_ai_task(self):
3630        if not self.sec_share_task_code:
3631            return False
3632        self.sec_track_pending_claim(self.sec_share_task_code, self.sec_share_task_name)
3633        latest_task = self.sec_refresh_task_snapshot(
3634            self.sec_share_task_code,
3635            self.sec_share_task_name,
3636            retries=5,
3637            delay=2,
3638        )
3639        if not latest_task:
3640            self.sec_refresh_security_context(refresh_secret=True)
3641            latest_task = self.sec_refresh_task_snapshot(
3642                self.sec_share_task_code,
3643                self.sec_share_task_name,
3644                retries=5,
3645                delay=2,
3646            )
3647        if not latest_task:
3648            self.log("联通助理-分享AI助手对话:互看后未查询到任务状态")
3649            return False
3650        finish_count, need_count, finish_text = self.sec_parse_task(latest_task)
3651        if finish_text == "待领取" or (need_count > 0 and finish_count >= need_count):
3652            self.log("联通助理-分享AI助手对话:互看完成,尝试领取奖励")
3653            receive_state = self.receivePoints_sec(self.sec_share_task_code, self.sec_share_task_name)
3654            if receive_state in ("received", "auto"):
3655                self.getUserInfo_sec()
3656                return True
3657            if receive_state == "pending":
3658                self.sec_recover_pending_claims(rounds=2, delay=6, refresh_context=True)
3659                if self.sec_share_task_code not in self.sec_pending_claim_tasks:
3660                    return True
3661        self.log(f"联通助理-分享AI助手对话:互看后状态 {finish_count}/{need_count} - {finish_text}")
3662        return False
3663
3664    def _sec_jf_headers(self, with_signature=False):
3665        headers = {
3666            "ticket": unquote(self.sec_ticket),
3667            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0301};ltst;OSVersion/16.6",
3668            "partnersid": "1702",
3669            "clienttype": "uasp_unicom_applet",
3670            "Content-Type": "application/json",
3671            "Accept": "application/json, text/plain, */*",
3672            "Origin": "https://m.jf.10010.com",
3673            "sec-fetch-dest": "empty",
3674            "sec-fetch-mode": "cors",
3675            "sec-fetch-site": "same-origin",
3676        }
3677        if hasattr(self, 'sec_jeaId') and self.sec_jeaId:
3678            headers["Cookie"] = f"_jea_id={self.sec_jeaId};"
3679        if with_signature:
3680            headers.update(self.build_signature_headers_sec())
3681        return headers
3682
3683    def update_sec_jea_id(self, response=None):
3684        jea_id = ""
3685        if response is not None:
3686            cookie = response.headers.get("Set-Cookie", "")
3687            match = re.search(r"_jea_id=([^;]+)", cookie)
3688            if match:
3689                jea_id = match.group(1)
3690        if not jea_id:
3691            for cookie_item in self.session.cookies:
3692                if cookie_item.name == "_jea_id":
3693                    jea_id = cookie_item.value
3694                    break
3695        if jea_id:
3696            self.sec_jeaId = jea_id
3697        return jea_id
3698
3699    def sec_query_task_list(self):
3700        url = "https://m.jf.10010.com/jf-external-application/jftask/taskDetail"
3701        last_error = ""
3702        for attempt in range(1, 4):
3703            response = None
3704            try:
3705                response = self.session.post(url, json={}, headers=self._sec_jf_headers(), timeout=15)
3706                self.update_sec_jea_id(response)
3707                res = response.json()
3708                task_detail = ((res or {}).get("data") or {}).get("taskDetail") or {}
3709                return task_detail.get("taskList", [])
3710            except ValueError:
3711                preview = ((response.text if response is not None else "") or "").strip().replace("\n", " ")
3712                last_error = f"非JSON响应[{attempt}/3]: {preview[:60] or 'empty'}"
3713            except Exception as e:
3714                last_error = str(e)
3715            if attempt < 3:
3716                time.sleep(2)
3717        self.log(f"联通助理任务列表查询异常: {last_error}")
3718        return []
3719
3720    def sec_parse_task(self, task):
3721        finish_count = safe_int(task.get("finishCount", 0))
3722        need_count = safe_int(task.get("needCount", 0))
3723        finish_text = task.get("finishText") or task.get("taskStatusName") or task.get("taskStatusDesc") or "未知状态"
3724        return finish_count, need_count, finish_text
3725
3726    def sec_supports_delayed_claim(self, task_name):
3727        delayed_keywords = (
3728            "上传知识库文件",
3729            "分享AI助手对话",
3730            "角色助手对话",
3731        )
3732        return any(keyword in task_name for keyword in delayed_keywords)
3733
3734    def sec_track_pending_claim(self, task_code, task_name):
3735        if task_code and task_name and self.sec_supports_delayed_claim(task_name):
3736            self.sec_pending_claim_tasks[task_code] = task_name
3737
3738    def sec_untrack_pending_claim(self, task_code):
3739        if task_code:
3740            self.sec_pending_claim_tasks.pop(task_code, None)
3741
3742    def sec_refresh_security_context(self, refresh_secret=False):
3743        try:
3744            self.sec_ticket1 = ""
3745            self.sec_token = ""
3746            self.sec_ticket = ""
3747            self.getTicketByNative_sec()
3748            if not getattr(self, 'sec_ticket1', None):
3749                return False
3750            self.getAuthToken_sec()
3751            if not getattr(self, 'sec_token', None):
3752                return False
3753            self.getTicketForJF_sec()
3754            if not getattr(self, 'sec_ticket', None):
3755                return False
3756            if refresh_secret:
3757                self.sec_secretKey = None
3758                if not self.get_secret_key_sec(silent=True):
3759                    return False
3760            return True
3761        except Exception as e:
3762            self.log(f"联通助理上下文刷新异常: {e}")
3763            return False
3764
3765    def sec_get_task_snapshot(self, task_code="", task_name=""):
3766        for task in self.sec_query_task_list():
3767            if task_code and task.get("taskCode") == task_code:
3768                return task
3769            if task_name and task.get("taskName") == task_name:
3770                return task
3771        return None
3772
3773    def sec_refresh_task_snapshot(self, task_code, task_name, retries=3, delay=2):
3774        latest_task = None
3775        for attempt in range(retries):
3776            if attempt:
3777                time.sleep(delay)
3778            latest_task = self.sec_get_task_snapshot(task_code, task_name)
3779            if not latest_task:
3780                continue
3781            finish_count, need_count, finish_text = self.sec_parse_task(latest_task)
3782            if finish_text == "待领取" or (need_count > 0 and finish_count >= need_count):
3783                return latest_task
3784        return latest_task
3785
3786    def sec_should_manual_finish(self, task_name):
3787        manual_keywords = (
3788            "新增亲情守护成员",
3789            "新增宽带绑定",
3790            "语音提醒",
3791            "反诈险领取",
3792            "设置日程提醒",
3793        )
3794        return any(keyword in task_name for keyword in manual_keywords)
3795
3796    def sec_wait_seconds(self, task_name):
3797        if any(keyword in task_name for keyword in ("上传知识库文件", "分享AI助手对话", "角色助手对话")):
3798            return 5
3799        if any(keyword in task_name for keyword in ("添加黑名单", "骚扰拦截设置", "安全分提升", "号段拦截")):
3800            return 8
3801        return 4
3802
3803    def receivePoints_sec(self, taskCode, taskName=""):
3804        url = "https://m.jf.10010.com/jf-external-application/jftask/receive"
3805        last_error = ""
3806        for attempt in range(1, 3):
3807            response = None
3808            try:
3809                headers = self._sec_jf_headers(with_signature=True)
3810                response = self.session.post(url, json={"taskCode": taskCode}, headers=headers, timeout=10)
3811                self.update_sec_jea_id(response)
3812                res = response.json()
3813                score = str((res.get("data") or {}).get("score") or "").strip()
3814                msg = str(res.get("msg") or "").strip()
3815                if score:
3816                    self.sec_untrack_pending_claim(taskCode)
3817                    self.log(f"安全管家: 领取{score}成功", notify=True)
3818                    return "received"
3819                if "任务未完成" in msg or "不可领取" in msg:
3820                    self.log("领取任务未完成")
3821                    return "pending"
3822                if "自动发放" in msg or "已领取" in msg:
3823                    self.sec_untrack_pending_claim(taskCode)
3824                    self.log("任务已完成且奖励已领取")
3825                    return "auto"
3826                if msg:
3827                    self.log(f"领取失败:{msg}")
3828                    return "failed"
3829                self.log(f"领取失败:{res}")
3830                return "failed"
3831            except ValueError:
3832                preview = ((response.text if response is not None else "") or "").strip().replace("\n", " ")
3833                last_error = f"非JSON响应[{attempt}/2]: {preview[:60] or 'empty'}"
3834            except Exception as e:
3835                last_error = str(e)
3836            if attempt < 2:
3837                time.sleep(2)
3838        self.log(f"安全管家: 领取积分异常: {last_error}")
3839        return "error"
3840
3841    def finishTask_sec(self, taskCode, taskName):
3842        try:
3843            url = "https://m.jf.10010.com/jf-external-application/jftask/toFinish"
3844            headers = self._sec_jf_headers(with_signature=True)
3845            response = self.session.post(url, json={"taskCode": taskCode}, headers=headers, timeout=10)
3846            self.update_sec_jea_id(response)
3847            action_map = {
3848                "添加黑名单": self.addToBlacklist_sec,
3849                "号码标记": self.markPhoneNumber_sec,
3850                "同步通讯录": self.syncAddressBook_sec,
3851                "骚扰拦截设置": self.setInterceptionRules_sec,
3852                "智能助手": self.zhushou_sec,
3853                "代接助理": self.daijie_sec,
3854                "安全分": self.anquanfen_sec,
3855                "号段拦截": self.haoduan_sec,
3856                "查看周报": self.viewWeeklyReport_sec,
3857                "活动浏览": lambda: self.ojbk_sec(taskCode),
3858                "上传知识库文件": self.upload_knowledge_file_sec,
3859                "分享AI助手对话": lambda: self.share_ai_chat_sec(taskCode),
3860                "角色助手对话": self.role_chat_sec,
3861            }
3862            for key, action in action_map.items():
3863                if key in taskName:
3864                    result = action()
3865                    return False if result is False else True
3866            self.log(f"任务 {taskName} 需要手动完成")
3867            return False
3868        except Exception as e:
3869            self.log(f"安全管家: finishTask异常: {e}")
3870            return False
3871
3872    def signIn_sec(self, taskCode):
3873        try:
3874            url = "https://m.jf.10010.com/jf-external-application/jftask/sign"
3875            headers = self._sec_jf_headers(with_signature=True)
3876            response = self.session.post(url, json={"taskCode": taskCode}, headers=headers, timeout=10)
3877            self.update_sec_jea_id(response)
3878            res = response.json()
3879            if res.get("code") == "0000":
3880                return True
3881            self.log(f"签到失败:{res.get('msg') if res else '状态未知'}")
3882            return False
3883        except Exception as e:
3884            self.log(f"安全管家: 签到异常: {e}")
3885            return False
3886
3887    def executeAllTasks_sec(self):
3888        try:
3889            task_list = self.sec_query_task_list()
3890            if not task_list:
3891                self.log("联通助理任务列表查询失败")
3892                return
3893            for task in task_list:
3894                task_name = task.get("taskName", "")
3895                task_code = task.get("taskCode", "")
3896                finish_count, need_count, finish_text = self.sec_parse_task(task)
3897                self.log(f"{task_name}:{finish_count}/{need_count} - {finish_text}")
3898                if not task_code or need_count <= 0:
3899                    self.log("---------------------")
3900                    continue
3901                if finish_count >= need_count:
3902                    if finish_text == "待领取":
3903                        time.sleep(2)
3904                        receive_state = self.receivePoints_sec(task_code, task_name)
3905                        if receive_state == "pending":
3906                            self.sec_track_pending_claim(task_code, task_name)
3907                    else:
3908                        self.log("任务已完成且奖励已领取")
3909                    self.log("---------------------")
3910                    continue
3911                remaining = max(need_count - finish_count, 1)
3912                self.log(f"任务未完成,需要再执行 {remaining} 次")
3913                if self.sec_should_manual_finish(task_name):
3914                    self.log(f"任务 {task_name} 需要手动完成")
3915                    self.log("---------------------")
3916                    continue
3917                for i in range(remaining):
3918                    try:
3919                        if i:
3920                            time.sleep(2)
3921                        handled = self.signIn_sec(task_code) if "签到" in task_name else self.finishTask_sec(task_code, task_name)
3922                        if not handled:
3923                            break
3924                        wait_seconds = self.sec_wait_seconds(task_name)
3925                        if wait_seconds > 0:
3926                            time.sleep(wait_seconds)
3927                        latest_task = self.sec_refresh_task_snapshot(task_code, task_name, retries=3, delay=2)
3928                        if latest_task:
3929                            finish_count, need_count, finish_text = self.sec_parse_task(latest_task)
3930                        if not latest_task or (finish_text != "待领取" and finish_count < need_count):
3931                            self.log(f"{task_name}:已提交操作,服务端进度仍为 {finish_count}/{need_count}")
3932                            self.sec_track_pending_claim(task_code, task_name)
3933                            break
3934                        self.log(f"第 {i + 1} 次执行{task_name}已确认完成")
3935                        receive_state = self.receivePoints_sec(task_code, task_name)
3936                        if receive_state == "pending":
3937                            self.sec_track_pending_claim(task_code, task_name)
3938                        if receive_state in ("received", "auto"):
3939                            break
3940                        if need_count > 0 and finish_count >= need_count:
3941                            self.log("任务已完成且奖励已领取")
3942                            break
3943                    except Exception as e:
3944                        self.log(f"执行 {task_name} 失败:{e}")
3945                        break
3946                self.log("---------------------")
3947        except Exception as e:
3948            self.log(f"联通助理任务执行异常: {e}")
3949
3950    def getUserInfo_sec(self):
3951        url = "https://m.jf.10010.com/jf-external-application/jftask/userInfo"
3952        last_error = ""
3953        for attempt in range(1, 3):
3954            response = None
3955            try:
3956                headers = self._sec_jf_headers()
3957                response = self.session.post(url, json={}, headers=headers, timeout=10)
3958                self.update_sec_jea_id(response)
3959                res = response.json()
3960                if not res or res.get('code') != '0000' or not res.get('data'):
3961                    self.log(f"安全管家: 查询积分失败: {res.get('msg') if res else '无响应'}")
3962                    return
3963                current = int(res['data'].get('availableScore', 0))
3964                today = res['data'].get('todayEarnScore', 0)
3965                if not hasattr(self, 'sec_oldJFPoints') or self.sec_oldJFPoints is None:
3966                    self.sec_oldJFPoints = current
3967                    self.log(f"当前积分:{current},今日已赚 {today}")
3968                else:
3969                    gained = current - self.sec_oldJFPoints
3970                    user_label = mask_str(self.mobile) if self.mobile else f"账号[{self.index}]"
3971                    self.log(f"安全管家: 用户{user_label}积分变动:{self.sec_oldJFPoints} → {current} | 新增: {gained}", notify=True)
3972                return
3973            except ValueError:
3974                preview = ((response.text if response is not None else "") or "").strip().replace("\n", " ")
3975                last_error = f"非JSON响应[{attempt}/2]: {preview[:60] or 'empty'}"
3976            except Exception as e:
3977                last_error = str(e)
3978            if attempt < 2:
3979                time.sleep(2)
3980        self.log(f"安全管家: 查询积分异常: {last_error}")
3981
3982    def sec_recover_pending_claims(self, rounds=2, delay=12, refresh_context=False):
3983        if not self.sec_pending_claim_tasks:
3984            return False
3985        recovered = False
3986        last_status_map = {}
3987        self.log(f"联通助理:待补领任务 {len(self.sec_pending_claim_tasks)} 个,开始补查")
3988        for attempt in range(rounds):
3989            if attempt:
3990                time.sleep(delay)
3991            if not self.sec_pending_claim_tasks:
3992                break
3993            if refresh_context and not self.sec_refresh_security_context(refresh_secret=True):
3994                continue
3995            for task_code, task_name in list(self.sec_pending_claim_tasks.items()):
3996                latest_task = self.sec_refresh_task_snapshot(task_code, task_name, retries=3, delay=2)
3997                if not latest_task:
3998                    status_key = "missing"
3999                    if last_status_map.get(task_code) != status_key:
4000                        self.log(f"{task_name}:补查未取到任务状态")
4001                        last_status_map[task_code] = status_key
4002                    continue
4003                finish_count, need_count, finish_text = self.sec_parse_task(latest_task)
4004                if finish_text == "待领取" or (need_count > 0 and finish_count >= need_count):
4005                    self.log(f"{task_name}:补查后尝试领取")
4006                    receive_state = self.receivePoints_sec(task_code, task_name)
4007                    if receive_state in ("received", "auto"):
4008                        recovered = True
4009                        last_status_map.pop(task_code, None)
4010                        continue
4011                else:
4012                    status_key = f"{finish_count}/{need_count}-{finish_text}"
4013                    if last_status_map.get(task_code) != status_key:
4014                        self.log(f"{task_name}:补查状态 {finish_count}/{need_count} - {finish_text}")
4015                        last_status_map[task_code] = status_key
4016        if recovered:
4017            self.getUserInfo_sec()
4018        if self.sec_pending_claim_tasks:
4019            names = "、".join(self.sec_pending_claim_tasks.values())
4020            self.log(f"联通助理:仍待补领 {names}")
4021        return recovered
4022
4023    def securityButlerTask(self, is_query_only=False):
4024        self.log("==== 联通安全管家 ====")
4025        if not self.ecs_token:
4026            self.log("安全管家: 缺少 ecs_token,跳过")
4027            return
4028        try:
4029            self.getTicketByNative_sec()
4030            if not getattr(self, 'sec_ticket1', None): return
4031            self.getAuthToken_sec()
4032            if not getattr(self, 'sec_token', None): return
4033            self.getTicketForJF_sec()
4034            if not getattr(self, 'sec_ticket', None): return
4035            self.sec_oldJFPoints = None
4036            self.getUserInfo_sec()
4037            if is_query_only:
4038                self.log("联通助理积分:[查询模式] 跳过任务执行")
4039                return
4040            self.get_secret_key_sec()
4041            self.executeAllTasks_sec()
4042            self.log("等待积分到账,等待一会...")
4043            self.sec_recover_pending_claims(rounds=2, delay=12, refresh_context=True)
4044            time.sleep(3)
4045            self.getUserInfo_sec()
4046        except Exception as e:
4047            self.log(f"安全管家: 异常: {e}")
4048
4049    def aiting_query_integral(self):
4050        url = "https://m.jf.10010.com/jf-external-application/jftask/userInfo"
4051        response = self.session.post(url, json={}, headers=self.aiting_jf_headers())
4052        self.update_aiting_jea_id(response)
4053        res = response.json()
4054        if res.get('code') == '0000':
4055            data = res.get('data', {})
4056            self.log(f"爱听任务: 积分概览 - 今日已赚 {data.get('todayEarnScore')}, 当前余额 {data.get('availableScore')}", notify=True)
4057
4058    def aiting_jf_headers(self, with_signature=False):
4059        headers = {
4060            'ticket': unquote(self.aiting_biz_ticket),
4061            'pageid': getattr(self, 'aiting_pageid', 's789081246969976832'),
4062            'clienttype': 'aiting_ios',
4063            'partnersid': '1706',
4064            'content-type': 'application/json;charset=UTF-8',
4065            'User-Agent': 'Mozilla/5.0 (Linux; Android 12; Redmi K30 Pro Build/SKQ1.220303.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.159 Mobile Safari/537.36 WoReaderApp/Android',
4066            'Origin': 'https://m.jf.10010.com',
4067            'Host': 'm.jf.10010.com',
4068        }
4069        jea_id = getattr(self, 'aiting_jeaId', '')
4070        if jea_id:
4071            headers['Cookie'] = f"_jea_id={jea_id};"
4072        if with_signature:
4073            headers.update(self.build_signature_headers_aiting())
4074        return headers
4075
4076    def update_aiting_jea_id(self, response=None):
4077        jea_id = ''
4078        if response is not None:
4079            cookie = response.headers.get('Set-Cookie', '')
4080            match = re.search(r'_jea_id=([^;]+)', cookie)
4081            if match:
4082                jea_id = match.group(1)
4083        if not jea_id:
4084            for cookie_item in self.session.cookies:
4085                if cookie_item.name == '_jea_id':
4086                    jea_id = cookie_item.value
4087                    break
4088        if jea_id:
4089            self.aiting_jeaId = jea_id
4090        return jea_id
4091
4092    def get_secret_key_aiting(self):
4093        if getattr(self, 'aiting_secretKey', None):
4094            return self.aiting_secretKey
4095        try:
4096            self.update_aiting_jea_id()
4097            res = self.session.get(
4098                "https://m.jf.10010.com/jf-external-application/jftask/getSecretKey",
4099                headers=self.aiting_jf_headers(),
4100                timeout=10,
4101            )
4102            self.update_aiting_jea_id(res)
4103            data = res.json()
4104            secret = data.get('data', {}).get('secretKey')
4105            if data.get('code') == '0000' and secret:
4106                self.aiting_secretKey = secret.encode('utf-8')
4107                return self.aiting_secretKey
4108            self.log(f"爱听任务: getSecretKey 失败 - {response_summary(data)}")
4109        except Exception as e:
4110            self.log(f"爱听任务: getSecretKey 异常: {e}")
4111        return None
4112
4113    def build_signature_headers_aiting(self):
4114        secret_key = self.get_secret_key_aiting()
4115        if not secret_key:
4116            return {}
4117        request_ts = str(round(time.time() * 1000))
4118        nonce = ''.join(random.choices('0123456789abcdefghijklmnopqrstuvwxyz', k=8))
4119        signature = hmac.new(
4120            secret_key, f"{nonce}{request_ts}".encode('utf-8'), hashlib.sha256,
4121        ).hexdigest()
4122        return {
4123            'x-request-timestamp': request_ts,
4124            'x-request-nonce': nonce,
4125            'x-request-signature': signature,
4126        }
4127
4128    def ltzf_task(self):
4129        if not UserService.wocare_available:
4130            return
4131        self.log("==== 联通祝福 ====")
4132        try:
4133            self.session.head("https://wocare.unisk.cn", timeout=3)
4134        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
4135            self.log("联通祝福: 沃关怀请求超时或连接失败,本轮跳过")
4136            UserService.wocare_available = False
4137            return
4138        except Exception:
4139            pass
4140        base_url = "https://wocare.unisk.cn/mbh/getToken"
4141        params = {
4142            "channelType": WOCARE_CONSTANTS["serviceLife"],
4143            "homePage": "home",
4144            "duanlianjieabc": "qAz2m"
4145        }
4146        targetUrl = f"{base_url}?{urlencode(params)}"
4147        res = self.openPlatLineNew(targetUrl)
4148        if not res or 'ticket' not in res:
4149            self.log("联通祝福: 获取Ticket失败")
4150            return
4151        ticket = res['ticket']
4152        if not self.wocare_getToken(ticket):
4153            self.log("联通祝福: 获取Wocare Token失败")
4154            return
4155        self.wocare_getSpecificityBanner()
4156        wocare_activities = [
4157            {"name": "星座配对", "id": 2},
4158            {"name": "大转盘", "id": 3},
4159            {"name": "盲盒抽奖", "id": 4}
4160        ]
4161        for activity in wocare_activities:
4162            self.wocare_getDrawTask(activity)
4163            self.wocare_loadInit(activity)
4164
4165    def openPlatLineNew(self, to_url):
4166        try:
4167            base_url = "https://m.client.10010.com/mobileService/openPlatform/openPlatLineNew.htm"
4168            params = {"to_url": to_url}
4169            for attempt in range(1, 4):
4170                try:
4171                    res = self.session.get(base_url, params=params, allow_redirects=False, timeout=15)
4172                    break
4173                except Exception as e:
4174                    err_msg = str(e)
4175                    if attempt < 3 and os.environ.get("UNICOM_PROXY_API") and ("Max retries exceeded" in err_msg or "timed out" in err_msg.lower() or "connection" in err_msg.lower() or "SOCKS" in err_msg):
4176                        self.log(f"openPlatLineNew 第{attempt}次异常触发故障转移: {err_msg}")
4177                        self.failover_proxy()
4178                        continue
4179                    self.log(f"openPlatLineNew 第{attempt}次重试 - 异常: {e}")
4180                    if attempt == 3:
4181                         return None
4182                    time.sleep(2)
4183            if res.status_code == 302 and 'Location' in res.headers:
4184                loc = res.headers['Location']
4185                parsed = urlparse(loc)
4186                qs = parse_qs(parsed.query)
4187                ticket = qs.get('ticket', [''])[0]
4188                type_val = qs.get('type', [''])[0]
4189                if ticket:
4190                    return {'ticket': ticket, 'type': type_val, 'loc': loc}
4191                else:
4192                    self.log("openPlatLineNew: 重定向URL中无ticket")
4193            else:
4194                self.log(f"openPlatLineNew: 状态码{res.status_code} (期望302)")
4195        except Exception as e:
4196            self.log(f"openPlatLineNew 异常: {str(e)}")
4197        return None
4198
4199    def random_string(self, length, chars=string.ascii_letters + string.digits):
4200        return ''.join(random.choice(chars) for _ in range(length))
4201
4202    def get_bizchannelinfo(self):
4203        info = {
4204            "bizChannelCode": "225",
4205            "disriBiz": "party",
4206            "unionSessionId": "",
4207            "stType": "",
4208            "stDesmobile": "",
4209            "source": "",
4210            "rptId": self.rptId,
4211            "ticket": "",
4212            "tongdunTokenId": self.tokenId_cookie,
4213            "xindunTokenId": self.unicomTokenId
4214        }
4215        return json.dumps(info)
4216
4217    def get_epay_authinfo(self):
4218        info = {
4219            "mobile": "",
4220            "sessionId": getattr(self, 'sessionId', ''),
4221            "tokenId": getattr(self, 'tokenId', ''),
4222            "userId": ""
4223        }
4224        return json.dumps(info)
4225
4226    def ttlxj_task(self, is_query_only=False):
4227        self.log("==== 天天领现金 ====")
4228        for attempt in range(1, 31):
4229            try:
4230                ticket_res = self.openPlatLineNew("https://epay.10010.com/ci-mps-st-web/ttlxj/")
4231                if not ticket_res or not ticket_res.get('ticket'):
4232                    if attempt < 30:
4233                        self.log(f"天天领现金: 获取Ticket失败,正在重试 ({attempt}/30)...")
4234                        time.sleep(2)
4235                        continue
4236                    else:
4237                        self.log("天天领现金: 获取Ticket失败,已达最大重试次数,跳过任务")
4238                        return
4239                ticket = ticket_res['ticket']
4240                type_val = ticket_res['type']
4241                if self.ttlxj_authorize(ticket, type_val, ticket_res['loc']):
4242                    if self.ttlxj_auth_check():
4243                         if is_query_only:
4244                            self.ttlxj_query_available()
4245                            return
4246                         self.ttlxj_do_tasks()
4247                         self.ttlxj_query_available()
4248                         break
4249                else:
4250                     if attempt < 30:
4251                        self.log(f"天天领现金: 授权失败,正在重试 ({attempt}/30)...")
4252                        time.sleep(2)
4253                     else:
4254                        self.log("天天领现金: 授权失败,已达最大重试次数")
4255            except Exception as e:
4256                if attempt < 30:
4257                    self.log(f"天天领现金: 任务异常 ({e}),正在重试 ({attempt}/30)...")
4258                    time.sleep(2)
4259                else:
4260                    self.log(f"天天领现金: 任务异常: {e}")
4261
4262    def ttlxj_authorize(self, ticket, type_val, referer_url):
4263        try:
4264            url = "https://epay.10010.com/woauth2/v2/authorize"
4265            headers = {
4266                "Origin": "https://epay.10010.com",
4267                "Referer": referer_url
4268            }
4269            payload = {
4270                "response_type": "rptid",
4271                "client_id": "73b138fd-250c-4126-94e2-48cbcc8b9cbe",
4272                "redirect_uri": "https://epay.10010.com/ci-mps-st-web/",
4273                "login_hint": {
4274                    "credential_type": "st_ticket",
4275                    "credential": ticket,
4276                    "st_type": type_val,
4277                    "force_logout": True,
4278                    "source": "app_sjyyt"
4279                },
4280                "device_info": {
4281                    "token_id": f"chinaunicom-pro-{int(time.time()*1000)}-{self.random_string(13)}",
4282                    "trace_id": self.random_string(32)
4283                }
4284            }
4285            res = self.session.post(url, json=payload, headers=headers, timeout=10)
4286            if res.status_code == 200:
4287                return True
4288            else:
4289                self.log(f"天天领现金: Authorize失败[{res.status_code}]: {res.text}")
4290                return False
4291        except Exception as e:
4292             self.log(f"ttlxj_authorize error: {e}")
4293             return False
4294
4295    def ttlxj_auth_check(self):
4296        try:
4297            url = "https://epay.10010.com/ps-pafs-auth-front/v1/auth/check"
4298            headers = {
4299                "bizchannelinfo": self.get_bizchannelinfo()
4300            }
4301            res = self.session.post(url, headers=headers, json={}, timeout=10)
4302            data = res.json()
4303            code = data.get("code")
4304            if code == "0000":
4305                auth_info = data.get("data", {}).get("authInfo", {})
4306                self.sessionId = auth_info.get("sessionId", "")
4307                self.tokenId = auth_info.get("tokenId", "")
4308                self.epay_userId = auth_info.get("userId", "")
4309                return True
4310            elif code == "2101000100":
4311                login_url = data.get("data", {}).get("woauth_login_url")
4312                if login_url:
4313                    return self.ttlxj_login(login_url)
4314            else:
4315                self.log(f"天天领现金: AuthCheck失败[{code}]: {data.get('msg')}")
4316                return False
4317        except Exception as e:
4318            self.log(f"ttlxj_auth_check error: {e}")
4319            return False
4320
4321    def ttlxj_login(self, login_url):
4322        try:
4323            full_url = f"{login_url}https://epay.10010.com/ci-mcss-party-web/clockIn/?bizFrom=225&bizChannelCode=225"
4324            res = self.session.get(full_url, allow_redirects=False, timeout=10)
4325            if res.status_code == 302 and 'Location' in res.headers:
4326                loc = res.headers['Location']
4327                parsed = urlparse(loc)
4328                qs = parse_qs(parsed.query)
4329                rptid = qs.get('rptid', [''])[0]
4330                if rptid:
4331                    self.rptId = rptid
4332                    return self.ttlxj_auth_check()
4333                else:
4334                    self.log("天天领现金: Login跳转后无rptid")
4335            else:
4336                self.log(f"天天领现金: Login失败[{res.status_code}]")
4337            return False
4338        except Exception as e:
4339            self.log(f"ttlxj_login error: {e}")
4340            return False
4341
4342    def ttlxj_do_tasks(self):
4343        info_url = "https://epay.10010.com/ci-mcss-party-front/v1/ttlxj/userDrawInfo"
4344        headers = {
4345            "bizchannelinfo": self.get_bizchannelinfo(),
4346            "authinfo": self.get_epay_authinfo()
4347        }
4348        res = self.request("post", info_url, json={}, headers=headers)
4349        if not res: return
4350        data = res.json()
4351        if data.get('code') == '0000':
4352            day_of_week = data.get("data", {}).get("dayOfWeek", "")
4353            draw_key = f"day{day_of_week}"
4354            has_not_clocked_in = data.get("data", {}).get(draw_key) == "1"
4355            if has_not_clocked_in:
4356                self.log(f"天天领现金: 今天未打卡", notify=True)
4357                today_js = (datetime.now().weekday() + 1) % 7
4358                draw_type = "C" if today_js == 0 else "B"
4359                self.ttlxj_unifyDrawNew(draw_type)
4360            else:
4361                 self.log(f"天天领现金: 今天已打卡", notify=True)
4362        else:
4363            self.log(f"天天领现金: 查询失败: {data.get('msg')}")
4364
4365    def ttlxj_unifyDrawNew(self, draw_type):
4366        draw_url = "https://epay.10010.com/ci-mcss-party-front/v1/ttlxj/unifyDrawNew"
4367        headers = {
4368            "bizchannelinfo": self.get_bizchannelinfo(),
4369            "authinfo": self.get_epay_authinfo()
4370        }
4371        req_data = {
4372            "drawType": draw_type,
4373            "bizFrom": "225",
4374            "activityId": "TTLXJ20210330"
4375        }
4376        res = self.request("post", draw_url, data=req_data, headers=headers)
4377        if not res: return
4378        data = res.json()
4379        if data.get('code') == '0000':
4380            prize = data.get('data', {}).get('prizeName', '未知奖品')
4381            self.log(f"天天领现金: 抽奖成功: {prize}", notify=True)
4382        else:
4383            self.log(f"天天领现金: 抽奖失败: {data.get('msg')}")
4384
4385    def ttlxj_query_available(self):
4386        avail_url = "https://epay.10010.com/ci-mcss-party-front/v1/ttlxj/queryAvailable"
4387        headers = {
4388            "bizchannelinfo": self.get_bizchannelinfo(),
4389            "authinfo": self.get_epay_authinfo()
4390        }
4391        res = self.request("post", avail_url, json={}, headers=headers)
4392        if not res: return
4393        data = res.json()
4394        if data.get('code') == '0000':
4395            d = data.get('data', {})
4396            amount_raw = int(d.get('availableAmount', '0'))
4397            amount_yuan = f"{amount_raw / 100:.2f}"
4398            msg = f"天天领现金: 可用立减金: {amount_yuan}元"
4399            seven_day = int(d.get('sevenDayExpireAmount', 0))
4400            if seven_day > 0:
4401                msg += f", 7天内过期立减金: {seven_day / 100:.2f}元"
4402            min_exp_amt = int(d.get('minExpireAmount', 0))
4403            min_exp_date = d.get('minExpireDate')
4404            if min_exp_amt > 0 and min_exp_date:
4405                msg += f", 最早过期立减金: {min_exp_amt / 100:.2f}元 -- {min_exp_date}过期"
4406            self.log(msg, notify=True)
4407        else:
4408            self.log(f"天天领现金: 查询余额失败: {data.get('msg')}")
4409
4410    def ttxc_headers(self, auth=True, ecs=False):
4411        headers = {
4412            "user-agent": COMMON_CONSTANTS["MARKET_H5_UA"],
4413            "content-type": "application/json",
4414            "accept": "*/*",
4415            "origin": "https://epay.10010.com",
4416            "referer": TTXC_REFERER,
4417            "x-requested-with": "com.sinovatech.unicom.ui",
4418        }
4419        if auth and getattr(self, "ttxc_token", ""):
4420            headers["authorization"] = self.ttxc_token
4421        if ecs and self.ecs_token:
4422            headers["Cookie"] = f"ecs_token={self.ecs_token}"
4423        return headers
4424
4425    def ttxc_post(self, path, payload=None, auth=True, with_user=True, ecs=False):
4426        data = dict(payload or {})
4427        if with_user:
4428            data.setdefault("userId", getattr(self, "ttxc_user_id", ""))
4429        data.setdefault("channel", TTXC_CHANNEL)
4430        res = self.request("post", f"{TTXC_BASE_URL}{path}", json=data, headers=self.ttxc_headers(auth=auth, ecs=ecs), timeout=10)
4431        if not res:
4432            return {}
4433        try:
4434            return res.json()
4435        except Exception:
4436            return {}
4437
4438    def ttxc_init_ttgame(self):
4439        self.session.cookies.set("ecs_token", self.ecs_token)
4440        url = f"{TTXC_APP_BASE_URL}/v1/login/ttGame?channel={TTXC_CHANNEL}&rptId="
4441        data = {}
4442        for attempt in range(1, 4):
4443            data = self.ttxc_json(self.request("post", url, json={"unicomTokenId": self.unicomTokenId}, headers=self.ttxc_headers(auth=False, ecs=True), timeout=10))
4444            if data.get("code") == "0000":
4445                return True
4446            if data.get("code") == "4003" and data.get("data") and self.ttxc_finish_woauth(data.get("data")):
4447                data = self.ttxc_json(self.request("post", url, json={"unicomTokenId": self.unicomTokenId}, headers=self.ttxc_headers(auth=False, ecs=True), timeout=10))
4448                if data.get("code") == "0000":
4449                    return True
4450            if attempt < 3:
4451                time.sleep(2)
4452        self.log(f"通通乡村: 初始化失败[{data.get('code')}]: {data.get('msg', '')}")
4453        return False
4454
4455    def ttxc_json(self, res):
4456        if not res:
4457            return {}
4458        try:
4459            return res.json()
4460        except Exception:
4461            return {}
4462
4463    def ttxc_finish_woauth(self, login_url):
4464        headers = {
4465            "Referer": "https://epay.10010.com/",
4466            "User-Agent": COMMON_CONSTANTS["MARKET_H5_UA"],
4467        }
4468        res = self.request("get", login_url, headers=headers, timeout=10)
4469        if not res:
4470            return False
4471        match = re.search(r'var token = "([^"]+)"', res.text or "")
4472        if not match:
4473            return False
4474        next_url = (
4475            "https://epay.10010.com/woauth2/after-collected-device-digest"
4476            f"?deviceDigestTraceId=&deviceDigestTokenId=&token={quote(match.group(1))}&source=app_sjyyt"
4477        )
4478        referer = login_url
4479        for _ in range(6):
4480            res = self.request("get", next_url, headers={"Referer": referer, "User-Agent": COMMON_CONSTANTS["MARKET_H5_UA"]}, allow_redirects=False, timeout=10)
4481            if not res:
4482                return False
4483            location = res.headers.get("Location", "")
4484            if not location:
4485                return res.status_code == 200
4486            referer = next_url
4487            next_url = location
4488        return False
4489
4490    def ttxc_login(self, update_nick=True):
4491        if not self.ecs_token:
4492            self.onLine()
4493            if not self.ecs_token:
4494                self.log("通通乡村: 缺少 ecs_token,跳过")
4495                return False
4496        if not self.ttxc_init_ttgame():
4497            return False
4498        data = self.ttxc_post("/user/v1/login", auth=False, with_user=False, ecs=True)
4499        if data.get("code") != 0:
4500            self.log(f"通通乡村: 登录失败[{data.get('code')}]: {data.get('msg', '')}")
4501            return False
4502        user = data.get("data") or {}
4503        self.ttxc_user_id = user.get("userId", "")
4504        self.ttxc_token = data.get("token", "")
4505        self.ttxc_charge_level = user.get("chargeLevel") or {}
4506        self.ttxc_newbie_list = user.get("newbieList")
4507        self.ttxc_nick_name = user.get("nickName") or ""
4508        if not self.ttxc_user_id or not self.ttxc_token:
4509            self.log("通通乡村: 登录响应缺少 userId/token")
4510            return False
4511        carbon = self.ttxc_charge_level.get("carbonNum", 0)
4512        eco = self.ttxc_charge_level.get("ecologyAmount", 0)
4513        self.log(f"通通乡村: 登录成功,碳能量{carbon}g,生态值{eco}", notify=True)
4514        if update_nick and not self.ttxc_nick_name and self.ttxc_newbie_done():
4515            self.ttxc_update_nick()
4516        return True
4517
4518    def ttxc_update_nick(self):
4519        nick = (self.account_mobile or self.mobile or "")[-4:] or str(random.randint(1000, 9999))
4520        data = self.ttxc_post("/user/v1/updateNick", {"nickName": nick})
4521        if data.get("code") == 0:
4522            self.ttxc_nick_name = nick
4523            self.log(f"通通乡村: 已设置昵称 {nick}")
4524            return True
4525        self.log(f"通通乡村: 设置昵称失败[{data.get('code')}]: {data.get('msg', '')}")
4526        return False
4527
4528    def ttxc_newbie_done(self):
4529        steps = getattr(self, "ttxc_newbie_list", None)
4530        return not isinstance(steps, list) or all(step in steps for step in TTXC_NEWBIE_STEPS)
4531
4532    def ttxc_newbie_mark(self, step):
4533        target = []
4534        for item in TTXC_NEWBIE_STEPS:
4535            target.append(item)
4536            if item == step:
4537                break
4538        data = self.ttxc_post("/user/v1/newbie", {"newbieList": target, "type": 1})
4539        if data.get("code") == 0:
4540            self.ttxc_newbie_list = data.get("data") or target
4541            return True
4542        self.log(f"通通乡村: 新手步骤{step}失败[{data.get('code')}]: {data.get('msg', '')}")
4543        return False
4544
4545    def ttxc_newbie_need(self, step):
4546        steps = getattr(self, "ttxc_newbie_list", None)
4547        return isinstance(steps, list) and step not in steps
4548
4549    def ttxc_first_newbie_land(self, lands=None):
4550        lands = lands if lands is not None else self.ttxc_get_lands()
4551        active = next((land for land in lands if land.get("status") in [2, 3] and (land.get("plant") or {}).get("plantId")), None)
4552        if active:
4553            return active
4554        return next((land for land in lands if land.get("status") == 1), None)
4555
4556    def ttxc_newbie_charge_land(self):
4557        lands = self.ttxc_get_lands()
4558        active = [land for land in lands if land.get("status") == 3 and (land.get("plant") or {}).get("plantId")]
4559        return next((land for land in active if str((land.get("plant") or {}).get("curLevel")) in ["0", "1"]), None) or (active[0] if active else None)
4560
4561    def ttxc_harvest_land(self, land, newbie=False):
4562        if not land:
4563            return None
4564        plant = land.get("plant") or {}
4565        plant_id = plant.get("plantId")
4566        land_index = land.get("landIndex")
4567        if not plant_id or not land_index:
4568            return None
4569        if land.get("status") == 2 and TTXC_HARVEST_WAIT_SECONDS > 0:
4570            time.sleep(TTXC_HARVEST_WAIT_SECONDS)
4571        path = "/plant/v1/newHarvest" if newbie else "/plant/v1/harvest"
4572        data = self.ttxc_post(path, {"landIndex": land_index, "plantId": plant_id})
4573        if data.get("code") == 0:
4574            self.log(f"通通乡村: 地块{land_index}收获成功")
4575            return data.get("data") or {"landIndex": land_index, "status": 1, "plant": None}
4576        self.log(f"通通乡村: 地块{land_index}收获失败[{data.get('code')}]: {data.get('msg', '')}")
4577        return None
4578
4579    def ttxc_newbie_task(self):
4580        if self.ttxc_newbie_done():
4581            return False
4582        need_farm = any(self.ttxc_newbie_need(step) for step in ["G03", "G03_2", "G04", "G05", "G09", "G10"])
4583        lands = self.ttxc_get_lands() if need_farm else []
4584        plant_id = ""
4585        current = self.ttxc_first_newbie_land(lands) if need_farm else None
4586        if need_farm:
4587            self.ttxc_post("/client/v1/plant/type", {})
4588            plant_id = self.ttxc_get_plant_id()
4589            if not plant_id:
4590                self.log("通通乡村: 新手任务缺少作物ID")
4591                return False
4592        if self.ttxc_newbie_need("G03") and not self.ttxc_newbie_mark("G03"):
4593            return False
4594        if self.ttxc_newbie_need("G03_2"):
4595            has_crop = current and current.get("status") in [2, 3] and (current.get("plant") or {}).get("plantId")
4596            if not has_crop:
4597                data = self.ttxc_post("/client/v1/plant/buy", {"plantId": plant_id, "gameCfgId": ""})
4598                if data.get("code") != 0:
4599                    self.log(f"通通乡村: 新手购买作物失败[{data.get('code')}]: {data.get('msg', '')}")
4600                    return False
4601            if not self.ttxc_newbie_mark("G03_2"):
4602                return False
4603        if self.ttxc_newbie_need("G04"):
4604            if not current or not current.get("landIndex"):
4605                self.log("通通乡村: 新手任务缺少可种植地块")
4606                return False
4607            if not (current.get("status") in [2, 3] and (current.get("plant") or {}).get("plantId")):
4608                data = self.ttxc_post("/plant/v1/planting", {"landIndex": current.get("landIndex"), "plantId": plant_id})
4609                if data.get("code") != 0:
4610                    self.log(f"通通乡村: 新手种植失败[{data.get('code')}]: {data.get('msg', '')}")
4611                    return False
4612                current = data.get("data") or {"landIndex": current.get("landIndex"), "status": 3, "plant": {"plantId": plant_id}}
4613            if not self.ttxc_newbie_mark("G04"):
4614                return False
4615        if self.ttxc_newbie_need("G05"):
4616            current = current if current and current.get("plant") else self.ttxc_first_newbie_land()
4617            current = self.ttxc_charge_land(current)
4618            if not current or not self.ttxc_newbie_mark("G05"):
4619                return False
4620        if self.ttxc_newbie_need("G09"):
4621            plant = (current or {}).get("plant") or {}
4622            level = str(plant.get("curLevel") or "")
4623            if not (current and current.get("status") == 3 and plant.get("plantId") and level in ["", "0", "1"]):
4624                current = self.ttxc_newbie_charge_land()
4625            current = self.ttxc_charge_land(current, mock=1)
4626            if not current or not self.ttxc_newbie_mark("G09"):
4627                return False
4628        if self.ttxc_newbie_need("G10"):
4629            current = current if current and current.get("plant") else self.ttxc_first_newbie_land()
4630            if not self.ttxc_harvest_land(current, newbie=True) or not self.ttxc_newbie_mark("G10"):
4631                return False
4632        if self.ttxc_newbie_need("G11") and not self.ttxc_newbie_mark("G11"):
4633            return False
4634        if self.ttxc_newbie_need("G12"):
4635            if not self.ttxc_nick_name and not self.ttxc_update_nick():
4636                return False
4637            if not self.ttxc_newbie_mark("G12"):
4638                return False
4639        self.log("通通乡村: 新手任务已完成")
4640        return True
4641
4642    def ttxc_sign(self, is_query_only=False):
4643        info = self.ttxc_post("/client/v1/sign/info", {})
4644        code = (info.get("data") or {}).get("signinCode")
4645        if not code:
4646            self.log("通通乡村: 获取签到码失败")
4647            return
4648        user = self.ttxc_post("/client/v1/sign/user", {"code": code})
4649        last_time = str((user.get("data") or {}).get("lastSigninTime") or "")
4650        signed = last_time[:10] == datetime.now().strftime("%Y-%m-%d")
4651        if signed:
4652            self.log("通通乡村: 今日已签到", notify=True)
4653            return
4654        if is_query_only:
4655            self.log("通通乡村: 今日未签到", notify=True)
4656            return
4657        data = self.ttxc_post("/client/v1/sign/signIn", {"code": code})
4658        if data.get("code") == 0:
4659            sign_data = data.get("data") or {}
4660            keep_value = safe_int(sign_data.get("keepSigninValue") or sign_data.get("lastKeepSigninValue") or sign_data.get("totalSigninValue"))
4661            award_items = (info.get("data") or {}).get("awards") or []
4662            energy = 0
4663            for item in award_items:
4664                if item.get("awardType") == "KEEP" and safe_int(item.get("signinValue")) == keep_value:
4665                    energy = safe_int(item.get("carbonEnergyAmount"))
4666                    break
4667            if not energy:
4668                charge_level = data.get("chargeLevel") or {}
4669                before = safe_int(getattr(self, "ttxc_charge_level", {}).get("carbonNum"))
4670                after = safe_int(charge_level.get("carbonNum"))
4671                energy = max(after - before, 0)
4672            if data.get("chargeLevel"):
4673                self.ttxc_charge_level = data.get("chargeLevel") or self.ttxc_charge_level
4674            msg = f"通通乡村: 签到成功 +{energy}g" if energy else "通通乡村: 签到成功"
4675            self.log(msg, notify=True)
4676        else:
4677            self.log(f"通通乡村: 签到失败[{data.get('code')}]: {data.get('msg', '')}")
4678
4679    def ttxc_get_tasks(self):
4680        data = self.ttxc_post("/client/v1/task/list", {})
4681        if data.get("code") != 0:
4682            self.log(f"通通乡村: 获取任务列表失败[{data.get('code')}]: {data.get('msg', '')}")
4683            return []
4684        tasks = []
4685        for group in data.get("data") or []:
4686            for task in group.get("taskList") or []:
4687                task["taskGroupName"] = group.get("taskGroupName", "")
4688                tasks.append(task)
4689        return tasks
4690
4691    def ttxc_finish_task(self, task):
4692        task_id = task.get("taskCode")
4693        if not task_id:
4694            return False
4695        data = self.ttxc_post("/client/v1/task/finish", {"taskId": task_id})
4696        name = task.get("taskTitle", task_id)
4697        if data.get("code") == 0:
4698            reward = task.get("carbonEnergyAmount") or 0
4699            self.log(f"通通乡村: 领取[{name}]成功 +{reward}g")
4700            return True
4701        self.log(f"通通乡村: 领取[{name}]失败[{data.get('code')}]: {data.get('msg', '')}")
4702        return False
4703
4704    def ttxc_do_task(self, task):
4705        data = self.ttxc_post("/client/v1/task/do", {"taskId": task.get("taskCode")})
4706        name = task.get("taskTitle", task.get("taskCode", ""))
4707        if data.get("code") == 0:
4708            self.log(f"通通乡村: 已执行[{name}]")
4709            return True
4710        self.log(f"通通乡村: 执行[{name}]失败[{data.get('code')}]: {data.get('msg', '')}")
4711        return False
4712
4713    def ttxc_claim_ready_tasks(self, tasks, claimed=None):
4714        if claimed is None:
4715            claimed = set()
4716        count = 0
4717        for task in tasks:
4718            task_id = task.get("taskCode")
4719            if task.get("taskStatus") == "UNCLA" and task_id not in claimed:
4720                if self.ttxc_finish_task(task):
4721                    claimed.add(task_id)
4722                    count += 1
4723        return count
4724
4725    def ttxc_do_jump_tasks(self, tasks):
4726        count = 0
4727        for task in tasks:
4728            if task.get("taskType") == "GAME" and task.get("taskStatus") == "UNDO" and task.get("jumpUrl"):
4729                if self.ttxc_do_task(task):
4730                    count += 1
4731                time.sleep(1)
4732        return count
4733
4734    def ttxc_do_garbage_task(self, tasks):
4735        task = next((t for t in tasks if t.get("taskType") == "GAME" and t.get("taskStatus") == "UNDO" and "垃圾分类" in t.get("taskTitle", "")), None)
4736        if not task:
4737            return False
4738        start = self.ttxc_post("/user/v1/start", {})
4739        answer_no = (start.get("data") or {}).get("answerNo")
4740        if not answer_no:
4741            self.log("通通乡村: 垃圾分类开始失败")
4742            return False
4743        time.sleep(TTXC_GARBAGE_WAIT_SECONDS)
4744        data = self.ttxc_post("/user/v1/finish", {"answerNo": answer_no})
4745        if data.get("code") == 0:
4746            self.log("通通乡村: 垃圾分类已通关")
4747            return True
4748        self.log(f"通通乡村: 垃圾分类通关失败[{data.get('code')}]: {data.get('msg', '')}")
4749        return False
4750
4751    def ttxc_prepare_newbie_energy(self, claimed=None):
4752        if claimed is None:
4753            claimed = set()
4754        self.ttxc_sign()
4755        tasks = self.ttxc_get_tasks()
4756        self.ttxc_claim_ready_tasks(tasks, claimed)
4757        self.ttxc_do_jump_tasks(tasks)
4758        self.ttxc_do_garbage_task(tasks)
4759        tasks = self.ttxc_get_tasks()
4760        self.ttxc_claim_ready_tasks(tasks, claimed)
4761
4762    def ttxc_get_lands(self):
4763        land = safe_int(getattr(self, "ttxc_charge_level", {}).get("land"), 4)
4764        data = self.ttxc_post("/plant/v1/user", {"land": land})
4765        if data.get("code") != 0:
4766            self.log(f"通通乡村: 获取土地失败[{data.get('code')}]: {data.get('msg', '')}")
4767            return []
4768        return data.get("data") or []
4769
4770    def ttxc_get_plant_id(self):
4771        data = self.ttxc_post("/client/v1/plant/page", {"itemType": "SPE", "pageNum": 1, "pageSize": 20})
4772        items = (data.get("data") or {}).get("list") or []
4773        return items[0].get("itemNo", "") if items else ""
4774
4775    def ttxc_plant_land(self, land_index, plant_id=None):
4776        plant_id = plant_id or self.ttxc_get_plant_id()
4777        if not plant_id or not land_index:
4778            return None
4779        self.ttxc_post("/client/v1/plant/buy", {"plantId": plant_id, "gameCfgId": ""})
4780        data = self.ttxc_post("/plant/v1/planting", {"landIndex": land_index, "plantId": plant_id})
4781        if data.get("code") == 0:
4782            self.log(f"通通乡村: 已在地块{land_index}种植作物")
4783            return {"landIndex": land_index, "status": 3, "plant": {"plantId": plant_id}}
4784        self.log(f"通通乡村: 地块{land_index}种植失败[{data.get('code')}]: {data.get('msg', '')}")
4785        return None
4786
4787    def ttxc_ensure_planted_lands(self, lands, needed=None):
4788        active = [l for l in lands if l.get("status") in [2, 3] and (l.get("plant") or {}).get("plantId")]
4789        empty = [l for l in lands if l.get("status") == 1]
4790        if not empty:
4791            return active
4792        plant_id = self.ttxc_get_plant_id()
4793        if not plant_id:
4794            return active
4795        for land in empty:
4796            planted = self.ttxc_plant_land(land.get("landIndex"), plant_id)
4797            if planted:
4798                active.append(planted)
4799        return active
4800
4801    def ttxc_charge_land(self, land, mock=None):
4802        if not land:
4803            return False
4804        plant = land.get("plant") or {}
4805        plant_id = plant.get("plantId")
4806        land_index = land.get("landIndex")
4807        if not plant_id or not land_index:
4808            return False
4809        data = self.ttxc_post("/plant/v1/charge", {"landIndex": land_index, "plantId": plant_id, "mock": mock})
4810        if data.get("code") == 0:
4811            self.log(f"通通乡村: 地块{land_index}充能成功")
4812            result = data.get("data") or {}
4813            if result and not result.get("plant"):
4814                result["plant"] = plant
4815            return result or land
4816        self.log(f"通通乡村: 地块{land_index}充能失败[{data.get('code')}]: {data.get('msg', '')}")
4817        return None
4818
4819    def ttxc_harvest_and_replant(self, land):
4820        harvested = self.ttxc_harvest_land(land)
4821        return self.ttxc_plant_land(land.get("landIndex")) if harvested and land else None
4822
4823    def ttxc_grow_land_to_harvest(self, land):
4824        current = land
4825        if current.get("status") == 2:
4826            self.ttxc_harvest_and_replant(current)
4827            return
4828        charged = 0
4829        while current.get("status") == 3 and charged < TTXC_GROW_MAX_CHARGE_PER_LAND:
4830            current = self.ttxc_charge_land(current)
4831            if not current:
4832                return
4833            charged += 1
4834            if current.get("status") == 2:
4835                self.ttxc_harvest_and_replant(current)
4836                return
4837            if charged < TTXC_GROW_MAX_CHARGE_PER_LAND:
4838                time.sleep(1)
4839        if current.get("status") == 3:
4840            self.log(f"通通乡村: 地块{current.get('landIndex')}催熟达到上限,跳过")
4841
4842    def ttxc_replace_land(self, lands, updated):
4843        land_index = updated.get("landIndex")
4844        for i, land in enumerate(lands):
4845            if land.get("landIndex") == land_index:
4846                lands[i] = updated
4847                return
4848        lands.append(updated)
4849
4850    def ttxc_complete_charge_task(self, active, remaining):
4851        while remaining > 0:
4852            immature = [land for land in active if land.get("status") == 3 and (land.get("plant") or {}).get("plantId")]
4853            if not immature:
4854                self.log("通通乡村: 未成熟作物不足,提前结束10次充能补足")
4855                return
4856            progressed = False
4857            for land in immature:
4858                if remaining <= 0:
4859                    return
4860                result = self.ttxc_charge_land(land)
4861                if result:
4862                    self.ttxc_replace_land(active, result)
4863                    remaining -= 1
4864                    progressed = True
4865                time.sleep(1)
4866            if not progressed:
4867                self.log("通通乡村: 充能未成功,提前结束10次充能补足")
4868                return
4869
4870    def ttxc_farm_tasks(self, tasks):
4871        charge_task = next((t for t in tasks if "10次作物充能" in t.get("taskTitle", "")), None)
4872        land_task = next((t for t in tasks if "三块不同" in t.get("taskTitle", "")), None)
4873        harvest_task = next((t for t in tasks if "收获一次作物" in t.get("taskTitle", "")), None)
4874        if not charge_task and not land_task and not harvest_task:
4875            return
4876        charge_pending = charge_task if (charge_task or {}).get("taskStatus") == "UNDO" else None
4877        land_pending = land_task if (land_task or {}).get("taskStatus") == "UNDO" else None
4878        harvest_pending = harvest_task if (harvest_task or {}).get("taskStatus") == "UNDO" else None
4879        if not charge_pending and not land_pending and not harvest_pending:
4880            return
4881        lands = self.ttxc_get_lands()
4882        active = self.ttxc_ensure_planted_lands(lands)
4883        need_land = max(safe_int((land_pending or {}).get("finishValue")) - safe_int((land_pending or {}).get("doneValue")), 0)
4884        if harvest_pending and not charge_pending and not land_pending:
4885            for land in active:
4886                if land.get("status") == 2:
4887                    self.ttxc_harvest_and_replant(land)
4888        if not active:
4889            self.log("通通乡村: 没有可充能作物")
4890            return
4891        charged = 0
4892        for i, land in enumerate(active[:need_land]):
4893            result = self.ttxc_charge_land(land)
4894            if result:
4895                active[i] = result
4896                charged += 1
4897                time.sleep(1)
4898        need_charge = max(safe_int((charge_pending or {}).get("finishValue")) - safe_int((charge_pending or {}).get("doneValue")) - charged, 0)
4899        self.ttxc_complete_charge_task(active, need_charge)
4900        for land in active:
4901            self.ttxc_grow_land_to_harvest(land)
4902
4903    def ttxc_task(self, is_query_only=False):
4904        self.log("==== 通通乡村 ====")
4905        try:
4906            if not self.ttxc_login(update_nick=not is_query_only):
4907                return
4908            claimed = set()
4909            if not is_query_only:
4910                if not self.ttxc_newbie_done():
4911                    self.ttxc_prepare_newbie_energy(claimed)
4912                if not self.ttxc_newbie_done() and not self.ttxc_newbie_task():
4913                    return
4914            self.ttxc_sign(is_query_only=is_query_only)
4915            tasks = self.ttxc_get_tasks()
4916            if is_query_only:
4917                todo = sum(1 for t in tasks if t.get("taskStatus") == "UNDO")
4918                claim = sum(1 for t in tasks if t.get("taskStatus") == "UNCLA")
4919                self.log(f"通通乡村: 待做{todo}个,可领取{claim}个", notify=True)
4920                return
4921            self.ttxc_claim_ready_tasks(tasks, claimed)
4922            self.ttxc_do_jump_tasks(tasks)
4923            self.ttxc_do_garbage_task(tasks)
4924            self.ttxc_farm_tasks(tasks)
4925            tasks = self.ttxc_get_tasks()
4926            self.ttxc_claim_ready_tasks(tasks, claimed)
4927        except Exception as e:
4928            self.log(f"通通乡村异常: {e}")
4929
4930    def aiting_get_aes(self, data, key):
4931        iv_str = "16-Bytes--String"
4932        key_bytes = key[:16].encode('utf-8')
4933        iv_bytes = iv_str[:16].encode('utf-8')
4934        text = json.dumps(data, separators=(',', ':')) if isinstance(data, (dict, list)) else str(data)
4935        padded_data = pad(text.encode('utf-8'), 16)
4936        cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
4937        ciphertext = cipher.encrypt(padded_data)
4938        hex_str = ciphertext.hex()
4939        return base64.b64encode(hex_str.encode('utf-8')).decode('utf-8')
4940
4941    def aiting_aes_encrypt(self, data, key, iv):
4942        key_bytes = key.encode('utf-8')
4943        iv_bytes = iv.encode('utf-8')
4944        text = json.dumps(data, separators=(',', ':')) if isinstance(data, (dict, list)) else str(data)
4945        padded_data = pad(text.encode('utf-8'), 16)
4946        cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
4947        ciphertext = cipher.encrypt(padded_data)
4948        hex_str = ciphertext.hex().upper()
4949        return base64.b64encode(hex_str.encode('utf-8')).decode('utf-8')
4950
4951    def aiting_md5(self, text):
4952        return hashlib.md5(text.encode('utf-8')).hexdigest()
4953
4954    def aiting_generate_sign(self, params, key):
4955        sorted_keys = sorted(params.keys())
4956        sign_str = '&'.join([f"{k}={params[k]}" for k in sorted_keys])
4957        final_str = f"{sign_str}&key={key}"
4958        return self.aiting_md5(final_str)
4959
4960    def aiting_timestamp(self):
4961        return str(int(time.time() * 1000))
4962
4963    def aiting_nonce(self):
4964        return str(random.randint(100000, 999999))
4965
4966    def aiting_generate_woid(self, imei):
4967        random6 = ''.join(random.choices(string.ascii_letters + string.digits, k=6))
4968        imei8 = imei[:8] if len(imei) >= 8 else imei.ljust(8, '0')
4969        random4 = ''.join(random.choices(string.ascii_letters + string.digits, k=4))
4970        random2 = ''.join(random.choices(string.ascii_letters + string.digits, k=2))
4971        return f"WOA{random6}{imei8}LOT{random4}LV{random2}"
4972
4973    def aiting_calculate_clientconfirm(self, userid, imei):
4974        plaintext = f"android{userid}{imei}"
4975        return self.aiting_aes_encrypt(plaintext, AITING_AES_KEY, AITING_AES_IV)
4976
4977    def aiting_calculate_passcode(self, timestamp, phone):
4978        return self.aiting_md5(timestamp + phone + AITING_CLIENT_KEY)
4979
4980    def aiting_build_statisticsinfo(self, userid, useraccount, imei, clientconfirm):
4981        params = {
4982            'channelid': '28015001',
4983            'sid': ''.join(random.choices(string.ascii_letters + string.digits + "_-", k=20)),
4984            'eid': ''.join(random.choices(string.ascii_letters + string.digits + "_", k=20)),
4985            'osversion': 'Android12',
4986            'clientallid': '000000100000000000058.0.2.1225',
4987            'display': '2400_1080',
4988            'ip': '192.168.3.24',
4989            'nettypename': 'wifi',
4990            'version': '802',
4991            'versionname': '8.0.2',
4992            'terminalName': 'Redmi',
4993            'terminalType': 'Redmi_K30_Pro',
4994            'udid': 'null',
4995            'woid': self.aiting_generate_woid(imei),
4996            'useraccount': useraccount,
4997            'userid': userid,
4998            'clientconfirm': clientconfirm
4999        }
5000        return '&'.join([f"{k}={params[k]}" for k in params])
5001
5002    def generate_random_imei(self):
5003        tac = ''.join([str(random.randint(0, 9)) for _ in range(8)])
5004        snr = ''.join([str(random.randint(0, 9)) for _ in range(6)])
5005        imei_raw = tac + snr
5006        digits = [int(d) for d in imei_raw]
5007        for i in range(len(digits) - 1, -1, -2):
5008            digits[i] *= 2
5009            if digits[i] > 9: digits[i] -= 9
5010        total = sum(digits)
5011        check_digit = (10 - (total % 10)) % 10
5012        return imei_raw + str(check_digit)
5013
5014    def aiting_woread_login(self, phone):
5015        access_token = "ODZERTZCMjA1NTg1MTFFNDNFMThDRDYw"
5016        token_enc = ""
5017        if self.token_online:
5018             token_enc = self.aiting_get_aes(self.token_online, WOREAD_KEY)
5019        else:
5020             self.log("阅读专区: 未找到 token_online,尝试仅使用手机号登录")
5021        phone_enc = self.aiting_get_aes(phone, WOREAD_KEY)
5022        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
5023        if token_enc:
5024            inner_data = {
5025                "tokenOnline": token_enc,
5026                "phone": phone_enc,
5027                "timestamp": timestamp
5028            }
5029        else:
5030            inner_data = {
5031                "phone": phone_enc,
5032                "timestamp": timestamp
5033            }
5034        sign_result = self.aiting_get_aes(inner_data, WOREAD_KEY)
5035        url = "https://10010.woread.com.cn/ng_woread_service/rest/account/login"
5036        body = {"sign": sign_result}
5037        headers = {
5038            "User-Agent": "Mozilla/5.0 (Linux; Android 11; Redmi Note 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.159 Mobile Safari/537.36",
5039            "accesstoken": access_token,
5040            "Content-Type": "application/json;charset=UTF-8",
5041            "Origin": "https://10010.woread.com.cn"
5042        }
5043        res = self.session.post(url, json=body, headers=headers).json()
5044        if res.get("code") == "0000":
5045            self.aiting_read_userinfo = res.get("data") or {}
5046            return res.get("data", {}).get("token")
5047        self.log(f"爱听登录: 沃阅读登录失败 - {response_summary(res)}")
5048        return None
5049
5050    def aiting_get_jwt_token(self, statisticsinfo):
5051        timestamp = self.aiting_timestamp()
5052        sign_params = {
5053            'clientSource': '3',
5054            'clientId': 'android',
5055            'source': '3',
5056            'timestamp': timestamp
5057        }
5058        sign_val = self.aiting_generate_sign(sign_params, AITING_SIGN_KEY_APPKEY)
5059        client_id_const = "395DEDE9C1D6FE11B7C9C0D82B353E74"
5060        client_id_b64 = base64.b64encode(client_id_const.encode('utf-8')).decode('utf-8')
5061        body = {
5062            'clientSource': '3',
5063            'clientId': client_id_b64,
5064            'source': '3',
5065            'timestamp': timestamp,
5066            'sign': sign_val
5067        }
5068        url = f"{AITING_BASE_URL}/oauth/client/appkey"
5069        headers = {
5070            'Skip-Authorization-Check': 'true',
5071            'statisticsinfo': statisticsinfo,
5072            "User-Agent": "Dalvik/2.1.0 (Linux; U; Android 12; Redmi K30 Pro Build/SKQ1.220303.001)"
5073        }
5074        try:
5075            res = self.session.post(url, json=body, headers=headers).json()
5076            if res.get("code") == "0000" and res.get("key"):
5077                return res.get("key")
5078            self.log(f"爱听登录: 获取JWT失败 - {response_summary(res)}")
5079        except Exception as e:
5080            self.log(f"爱听登录: 获取JWT异常: {e}")
5081        return None
5082
5083    def aiting_api_login(self, phone, useraccount, jwt_token, statisticsinfo):
5084        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
5085        passcode = self.aiting_calculate_passcode(timestamp, phone)
5086        query_params_list = [
5087            'networktype=3', 'ua=Redmi+K30+Pro', 'isencode=false',
5088            'clientversion=8.0.2', 'versionname=Android_1_1080x2356',
5089            'channelid=28015001', 'userlabelisencode=0', 'validatecode=', 'sid=',
5090            f"timestamp={timestamp}", f"passcode={passcode}"
5091        ]
5092        query_str = '&'.join(query_params_list)
5093        final_account = useraccount
5094        url = f"{AITING_BASE_URL}/mainrest/rest/read/user/ulogin/3/{final_account}/1/1/0?{query_str}"
5095        req_time = self.aiting_timestamp()
5096        nonce = self.aiting_nonce()
5097        sign_params = {
5098            'jwt': jwt_token,
5099            'nonestr': nonce,
5100            'osversion': 'Android12',
5101            'terminalName': 'Redmi',
5102            'timestamp': req_time
5103        }
5104        sorted_keys = sorted(sign_params.keys())
5105        sign_str = '&'.join([f"{k}={sign_params[k]}" for k in sorted_keys])
5106        requertid = self.aiting_md5(f"{sign_str}&key={AITING_SIGN_KEY_REQUERTID}")
5107        headers = {
5108            'statisticsinfo': statisticsinfo,
5109            'requerttime': req_time,
5110            'nonestr': nonce,
5111            'requertid': requertid,
5112            'AuthorizationClient': f"Bearer {jwt_token}",
5113            'User-Agent': 'okhttp/4.9.0'
5114        }
5115        try:
5116            res = self.session.get(url, headers=headers).json()
5117            if res.get("code") == "0000" and res.get("message"):
5118                msg = res.get("message")
5119                token = msg.get("token")
5120                userid = msg.get("userid")
5121                if msg.get("accountinfo"):
5122                    token = msg.get("accountinfo", {}).get("token") or token
5123                    userid = msg.get("accountinfo", {}).get("userid") or userid
5124                return {"token": token, "userid": userid}
5125            self.log(f"爱听登录: 业务API登录失败 - {response_summary(res)}")
5126        except Exception as e:
5127            self.log(f"爱听登录: 业务API异常: {e}")
5128        return None
5129
5130    def aiting_login_flow(self):
5131        self.log("爱听任务: 正在执行登录流程...")
5132        woread_token = self.aiting_woread_login(self.mobile)
5133        if not woread_token: return False
5134        self.aiting_woread_token = woread_token
5135        imei = self.generate_random_imei()
5136        userid = self.mobile
5137        useraccount = self.mobile
5138        clientconfirm = self.aiting_calculate_clientconfirm(userid, imei)
5139        statisticsinfo = self.aiting_build_statisticsinfo(userid, useraccount, imei, clientconfirm)
5140        self.aiting_statisticsinfo = statisticsinfo
5141        jwt = self.aiting_get_jwt_token(statisticsinfo)
5142        if not jwt: return False
5143        self.aiting_jwt = jwt
5144        login_data = self.aiting_api_login(self.mobile, useraccount, jwt, statisticsinfo)
5145        if not login_data: return False
5146        self.aiting_biz_token = login_data.get('token')
5147        self.aiting_base_userid = login_data.get('userid') or self.mobile
5148        self.log("爱听任务: 登录成功,Token已获取")
5149        biz_ticket = self.aiting_get_ticket()
5150        if biz_ticket:
5151            self.aiting_biz_ticket = biz_ticket
5152            return True
5153        return False
5154
5155    def aiting_get_ticket(self):
5156        url = f"{AITING_BASE_URL}/activity/rest/unicom/points/getInfoTicket"
5157        timestamp = self.aiting_timestamp()
5158        sign_params = {
5159            "token": self.aiting_biz_token,
5160            "timestamp": timestamp,
5161            "userid": self.aiting_base_userid
5162        }
5163        sign_val = self.aiting_generate_sign(sign_params, AITING_SIGN_KEY_API)
5164        body = {
5165            "sign": sign_val,
5166            "timestamp": timestamp,
5167            "token": self.aiting_biz_token,
5168            "userid": self.aiting_base_userid
5169        }
5170        nonce = self.aiting_nonce()
5171        head_sign_params = {
5172            'jwt': self.aiting_jwt,
5173            'nonestr': nonce,
5174            'osversion': 'Android12',
5175            'terminalName': 'Redmi',
5176            'timestamp': timestamp
5177        }
5178        sorted_keys = sorted(head_sign_params.keys())
5179        sign_str = '&'.join([f"{k}={head_sign_params[k]}" for k in sorted_keys])
5180        final_sign_str = f"{sign_str}&key={AITING_SIGN_KEY_REQUERTID}"
5181        requertid = self.aiting_md5(final_sign_str)
5182        headers = {
5183            "AuthorizationClient": f"Bearer {self.aiting_jwt}",
5184            "statisticsinfo": self.aiting_statisticsinfo,
5185            "requerttime": timestamp,
5186            "nonestr": nonce,
5187            "requertid": requertid
5188        }
5189        try:
5190            res = self.session.post(url, json=body, headers=headers).json()
5191            if res.get("code") == "0000":
5192                msg = res.get("message", "")
5193                if "ticket=" in msg:
5194                    parsed = urlparse(msg)
5195                    params = parse_qs(parsed.query)
5196                    ticket = (params.get("ticket") or [""])[0]
5197                    distribute_id = (params.get("distributeId") or [""])[0]
5198                    pageid = (params.get("pageid") or params.get("pageID") or [""])[0]
5199                    if not pageid:
5200                        pageid = next((part for part in parsed.path.split("/") if part.startswith("s")), "")
5201                    if ticket:
5202                        self.aiting_distribute_id = distribute_id
5203                        self.aiting_pageid = pageid or "s789081246969976832"
5204                        return ticket
5205                return msg
5206            self.log(f"爱听登录: 获取Ticket失败 - {response_summary(res)}")
5207        except Exception as e:
5208            self.log(f"爱听登录: 获取Ticket异常: {e}")
5209        return None
5210
5211    def jf_get_task_detail(self, ticket):
5212        url = "https://m.jf.10010.com/jf-external-application/jftask/taskDetail"
5213        headers = self.aiting_jf_headers()
5214        headers['Referer'] = f"https://m.jf.10010.com/jf-external-application/index.html?ticket={ticket}&pageID=s789081246969976832"
5215        try:
5216            response = self.session.post(url, json={}, headers=headers)
5217            self.update_aiting_jea_id(response)
5218        except Exception as e:
5219            self.log(f"爱听任务: 积分任务列表请求异常: {e}")
5220            return []
5221        if response is None:
5222            self.log("爱听任务: 积分任务列表无响应")
5223            return []
5224        try:
5225            res = response.json()
5226        except Exception:
5227            self.log(f"爱听任务: 积分任务列表响应非JSON (状态码{getattr(response, 'status_code', '未知')})")
5228            return []
5229        return res.get("data", {}).get("taskDetail", {}).get("taskList", [])
5230
5231    def jf_to_finish(self, ticket, task_code):
5232        url = "https://m.jf.10010.com/jf-external-application/jftask/toFinish"
5233        try:
5234            response = self.session.post(
5235                url,
5236                json={'taskCode': task_code},
5237                headers=self.aiting_jf_headers(with_signature=True),
5238            )
5239            self.update_aiting_jea_id(response)
5240        except Exception as e:
5241            self.log(f"爱听任务: 积分任务提交异常: {e}")
5242            return False
5243        if response is None:
5244            self.log("爱听任务: 积分任务提交无响应")
5245            return False
5246        try:
5247            res = response.json()
5248        except Exception:
5249            self.log(f"爱听任务: 积分任务提交响应非JSON (状态码{getattr(response, 'status_code', '未知')})")
5250            return False
5251        self.log(f"爱听任务: 积分任务提交 - {response_summary(res)}")
5252        return isinstance(res, dict) and res.get('code') == "0000"
5253
5254    def jf_sign(self, ticket, task_code):
5255        url = "https://m.jf.10010.com/jf-external-application/uasptask/sign"
5256        referer = (
5257            f"https://m.jf.10010.com/ts-mobile/well/{getattr(self, 'aiting_pageid', 's789081246969976832')}"
5258            f"?distributeId={getattr(self, 'aiting_distribute_id', '')}&partnersId=1706&clientType=aiting_ios&ticket={ticket}"
5259        )
5260        headers = self.aiting_jf_headers(with_signature=True)
5261        headers.update({"referer": referer, "origin": "https://m.jf.10010.com"})
5262        try:
5263            response = self.session.post(
5264                url,
5265                json={'taskCode': task_code, 'remindEnabled': '1'},
5266                headers=headers,
5267            )
5268            self.update_aiting_jea_id(response)
5269        except Exception as e:
5270            self.log(f"爱听任务: 积分签到异常: {e}")
5271            return False
5272        if response is None:
5273            self.log("爱听任务: 积分签到无响应")
5274            return False
5275        try:
5276            res = response.json()
5277        except Exception:
5278            self.log(f"爱听任务: 积分签到响应非JSON (状态码{getattr(response, 'status_code', '未知')})")
5279            return False
5280        if isinstance(res, dict) and res.get('code') == "0000":
5281            self.log(f"爱听任务: 积分签到 - {res.get('msg') or '成功'}")
5282            return True
5283        if isinstance(res, dict):
5284            self.log(f"爱听任务: 积分签到返回 - {res.get('desc') or res.get('msg') or response_summary(res)}")
5285        return False
5286
5287    def jf_pop_up(self, ticket):
5288        url = "https://m.jf.10010.com/jf-external-application/jftask/popUp"
5289        try:
5290            response = self.session.post(url, json={}, headers=self.aiting_jf_headers())
5291            self.update_aiting_jea_id(response)
5292        except Exception as e:
5293            self.log(f"爱听任务: 积分弹窗请求异常: {e}")
5294            return {}
5295        if response is None:
5296            self.log("爱听任务: 积分弹窗无响应")
5297            return {}
5298        try:
5299            res = response.json()
5300        except Exception:
5301            self.log(f"爱听任务: 积分弹窗响应非JSON (状态码{getattr(response, 'status_code', '未知')})")
5302            return {}
5303        if isinstance(res, dict):
5304            if res.get('code') == "0000" and res.get('data', {}).get('score'):
5305                self.log(f"爱听任务: 获得 {res['data']['score']}", notify=True)
5306            elif res.get('code') != "0000":
5307                self.log(f"爱听任务: 积分弹窗返回 - {res.get('desc') or response_summary(res)}")
5308        return res
5309
5310    def aiting_complete_task_api(self, type_val):
5311        timestamp = self.aiting_timestamp()
5312        nonce = self.aiting_nonce()
5313        sign_params = {'jwt': self.aiting_jwt, 'nonestr': nonce, 'osversion': 'Android12', 'terminalName': 'Redmi', 'timestamp': timestamp}
5314        sign_str = '&'.join([f"{k}={sign_params[k]}" for k in sorted(sign_params.keys())])
5315        requertid = self.aiting_md5(f"{sign_str}&key={AITING_SIGN_KEY_REQUERTID}")
5316        body_params = {'source': '3', 'timestamp': timestamp, 'token': self.aiting_woread_token, 'type': str(type_val), 'userid': self.aiting_base_userid}
5317        body_str = '&'.join([f"{k}={body_params[k]}" for k in sorted(body_params.keys())])
5318        sign = self.aiting_md5(f"{body_str}&key={AITING_SIGN_KEY_API}")
5319        url = f"{AITING_BASE_URL}/activity/rest/unicom/points/completiontask"
5320        payload = {**body_params, 'sign': sign}
5321        headers = {
5322            'AuthorizationClient': f"Bearer {self.aiting_jwt}",
5323            'requerttime': timestamp,
5324            'nonestr': nonce,
5325            'requertid': requertid,
5326            'statisticsinfo': self.aiting_statisticsinfo
5327        }
5328        self.session.post(url, json=payload, headers=headers)
5329
5330    def aiting_read_points(self):
5331        user = getattr(self, "aiting_read_userinfo", {})
5332        if not all(user.get(key) for key in ("userid", "token", "userindex", "verifycode")):
5333            self.log("爱听任务: 缺少阅读登录上下文,跳过阅读上报")
5334            return
5335        headers = {
5336            "Content-Type": "application/json;charset=UTF-8",
5337            "accesstoken": "ODZERTZCMjA1NTg1MTFFNDNFMThDRDYw",
5338            "User-Agent": COMMON_CONSTANTS["UA"],
5339        }
5340        base = "https://10010.woread.com.cn/ng_woread_service/rest"
5341
5342        def submit(path, payload):
5343            payload.update({
5344                "timestamp": datetime.now().strftime("%Y%m%d%H%M%S"),
5345                "token": user["token"], "userId": user["userid"],
5346                "userIndex": safe_int(user["userindex"]),
5347                "userAccount": user.get("phone") or self.mobile,
5348                "verifyCode": user["verifycode"],
5349            })
5350            return self.session.post(base + path, json={"sign": self.woread_encrypt(payload)}, headers=headers, timeout=20).json()
5351
5352        try:
5353            opened = submit("/basics/newreadadd?cntindex=495589&catid=120697&chapterseno=7", {
5354                "userid": user["userid"], "cntindex": 495589, "chapterallindex": 42332652,
5355                "cnttype": 1, "cntname": "纯阳战神", "chaptertitle": "第7章 恶心的苍蝇小人", "readtype": 1,
5356            })
5357            self.log(f"爱听任务: 阅读记录 {response_summary(opened)}")
5358            for index in range(2):
5359                if index:
5360                    self.log("爱听任务: 等待121秒后提交第二次阅读")
5361                    time.sleep(121)
5362                result = submit("/history/addReadTime", {
5363                    "readTime": 2, "cntIndex": "495589", "cntType": 1,
5364                    "catid": "119010", "pageIndex": "10843", "cardid": "12540",
5365                    "cntindex": "495589", "cnttype": "1", "chapterallindex": 42332652,
5366                    "chapterseno": 7, "channelid": "18002061", "chapterid": "10495589007",
5367                    "readtype": 1, "isend": "0",
5368                })
5369                self.last_read_submission_time = time.time()
5370                self.log(f"爱听任务: 第{index + 1}次阅读上报 {response_summary(result)}")
5371        except Exception as e:
5372            self.log(f"爱听任务: 阅读上报异常 {type(e).__name__}")
5373
5374
5375    def aiting_task(self, is_query_only=False):
5376        self.log("==== 联通爱听 ====")
5377        if not self.aiting_login_flow():
5378            self.log("爱听任务: 登录失败,跳过")
5379            return
5380        self.log("爱听任务: 登录成功,正在获取任务列表...")
5381        try:
5382            self.aiting_query_integral()
5383        except: pass
5384        task_list = self.jf_get_task_detail(self.aiting_biz_ticket)
5385        safe_tasks = [t for t in task_list if "\u9080\u8bf7" not in t.get('taskName', '')]
5386        if safe_tasks:
5387            self.log(f"爱听任务: 提取到 {len(safe_tasks)} 个任务")
5388        done_list = [t for t in safe_tasks if int(t.get('finish') or 0) == 1]
5389        printed_names = set()
5390        for t in done_list:
5391             name = t.get('taskName')
5392             if name not in printed_names:
5393                 self.log(f"爱听任务: 已完成[{name}] {t.get('finishCount')}/{t.get('needCount')}")
5394                 printed_names.add(name)
5395        self.log(f"爱听任务: 执行前完成 {len(done_list)}/{len(safe_tasks)} 个任务")
5396        if not safe_tasks:
5397            self.log("爱听任务: ✅ 所有任务已完成")
5398            if is_query_only:
5399                self.log("爱听任务: [查询模式] 跳过任务执行...")
5400            return
5401        self.log(f"爱听任务: 尝试执行 {len(safe_tasks)} 个任务")
5402        if is_query_only:
5403            self.log("爱听任务: [查询模式] 跳过任务执行...")
5404            return
5405        for task in safe_tasks:
5406            task_code = task.get('taskCode')
5407            if not task_code:
5408                continue
5409            task_type = str(task.get('taskType', ''))
5410            self.log(f"爱听任务: 执行[{task.get('taskName')}] 类型 {task_type or '未知'}")
5411            if task_type == '4' or "签到" in task.get('taskName', ''):
5412                self.jf_sign(self.aiting_biz_ticket, task_code)
5413            else:
5414                self.jf_to_finish(self.aiting_biz_ticket, task_code)
5415            time.sleep(random.uniform(1, 2))
5416        self.log("爱听任务: 开始提交完成任务请求")
5417        for _ in range(5):
5418            self.aiting_complete_task_api(4)
5419            time.sleep(random.uniform(1, 2))
5420        self.aiting_complete_task_api(2)
5421        self.aiting_read_points()
5422        self.jf_pop_up(self.aiting_biz_ticket)
5423        after_tasks = [t for t in self.jf_get_task_detail(self.aiting_biz_ticket) if "\u9080\u8bf7" not in t.get('taskName', '')]
5424        after_done = [t for t in after_tasks if int(t.get('finish') or 0) == 1]
5425        self.log(f"爱听任务: 执行后完成 {len(after_done)}/{len(after_tasks)} 个任务")
5426        for t in after_tasks:
5427            self.log(f"爱听任务: {t.get('taskName')} - {t.get('finishCount')}/{t.get('needCount')} finish={t.get('finish')}")
5428        try:
5429            self.aiting_query_integral()
5430        except: pass
5431
5432    def wostore_cloud_get_ticket(self):
5433        if not getattr(self, 'ecs_token', ''):
5434            self.log("沃云手机: 缺少 ecs_token,无法获取入口 Ticket")
5435            return ""
5436        city_code = ""
5437        if self.city_info and isinstance(self.city_info, list):
5438            city_code = str((self.city_info[0] or {}).get("cityCode") or "")
5439        headers = {
5440            "User-Agent": "ChinaUnicom4.x/12.11 (com.chinaunicom.mobilebusiness; build:36; iOS 16.6.0) Alamofire/4.7.3 unicom{version:iphone_c@12.1100}",
5441            "Accept": "*/*",
5442            "Accept-Encoding": "gzip;q=1.0, compress;q=0.5",
5443            "Content-Type": "application/x-www-form-urlencoded",
5444            "Accept-Language": "zh-Hans-CN;q=1.0, en-CN;q=0.9",
5445            "Cookie": (
5446                f"ecs_token={self.ecs_token};t3_token={getattr(self, 't3_token', '')};"
5447                f"PvSessionId={datetime.now().strftime('%Y%m%d%H%M%S')}{self.uuid};devicedId={self.uuid};"
5448                f"c_mobile={self.account_mobile or self.mobile};c_version=iphone_c@12.1100;city=036|{city_code}|90063345|-99;"
5449            ),
5450        }
5451        try:
5452            res = self.session.get(
5453                "https://m.client.10010.com/edop_ng/getTicketByNative",
5454                params={"token": self.ecs_token, "appId": "edop_unicom_68e8fa69"},
5455                headers=headers,
5456                timeout=20,
5457            ).json()
5458            if res.get("rsp_code") == "0000" and res.get("ticket"):
5459                return res.get("ticket")
5460            self.log(f"沃云手机: 获取入口 Ticket 失败 - {res.get('rsp_desc') or res.get('msg') or pretty_json(res)}")
5461        except Exception as e:
5462            self.log(f"沃云手机: 获取入口 Ticket 异常 {e}")
5463        return ""
5464
5465    def wostore_cloud_login(self, ticket):
5466        try:
5467            res = self.session.post(
5468                "https://uphone.wostore.cn/h5api/token-service/getTokenByTicket",
5469                data=json.dumps({"ticket": ticket, "channel": "ST-Kuaidai001"}),
5470                headers={
5471                    "User-Agent": "ChinaUnicom4.x/12.11 (com.chinaunicom.mobilebusiness; build:36; iOS 16.6.0) Alamofire/4.7.3 unicom{version:iphone_c@12.1100}",
5472                    "Accept": "*/*",
5473                    "Accept-Encoding": "gzip;q=1.0, compress;q=0.5",
5474                    "Content-Type": "application/json",
5475                    "channel": "ST-Kuaidai001",
5476                    "X-Tingyun": "c=A|uBuVhVARE0A",
5477                    "source": "4",
5478                    "os": "H5",
5479                    "Accept-Language": "zh-Hans-CN;q=1.0, en-CN;q=0.9",
5480                    "channelCode": "ST-Kuaidai001",
5481                },
5482                timeout=20,
5483                verify=False,
5484            ).json()
5485            if str(res.get("code")) == "200" and res.get("data"):
5486                self.log("沃云手机: 云手机Token获取成功")
5487                return {"cloud_token": res.get("data")}
5488            self.log(f"沃云手机: 获取Token失败 - {res.get('msg') or pretty_json(res)}")
5489        except Exception as e:
5490            self.log(f"沃云手机: 登录异常 {e}")
5491        return None
5492
5493    def wostore_cloud_h5_headers(self, cloud_token=None):
5494        return {
5495            "Accept": "application/json, text/plain, */*",
5496            "Accept-Encoding": "gzip, deflate, br",
5497            "Accept-Language": "zh-CN,zh-Hans;q=0.9",
5498            "Connection": "keep-alive",
5499            "Content-Type": "application/json",
5500            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.57(0x18003930) NetType/WIFI Language/zh_CN",
5501            "Host": "h5forphone.wostore.cn",
5502            "X-Requested-With": "XMLHttpRequest",
5503            **({"Authorization": cloud_token} if cloud_token else {}),
5504        }
5505
5506    def wostore_cloud_activity_headers(self, user_token=""):
5507        return {
5508            "Accept": "application/json, text/plain, */*",
5509            "Accept-Encoding": "gzip, deflate, br",
5510            "Accept-Language": "zh-CN,zh-Hans;q=0.9",
5511            "Connection": "keep-alive",
5512            "Content-Type": "application/json",
5513            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.57(0x18003930) NetType/WIFI Language/zh_CN",
5514            "Host": "uphone.wostore.cn",
5515            "Origin": "https://uphone.wostore.cn",
5516            "Sec-Fetch-Dest": "empty",
5517            "Sec-Fetch-Mode": "cors",
5518            "Sec-Fetch-Site": "same-origin",
5519            "X-USR-TOKEN": user_token,
5520        }
5521
5522    def wostore_cloud_headers(self, user_token):
5523        return {
5524            "Accept": "application/json, text/plain, */*",
5525            "Accept-Encoding": "gzip, deflate, br",
5526            "Accept-Language": "zh-CN,zh-Hans;q=0.9",
5527            "Connection": "keep-alive",
5528            "Content-Type": "application/json",
5529            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0601};ltst;OSVersion/16.6",
5530            "Authorization": user_token,
5531        }
5532
5533    def wostore_cloud_bucp_get(self, path, user_token):
5534        url = f"https://uphone.wo-adv.cn/bucp{path}"
5535        try:
5536            return self.session.get(url, headers=self.wostore_cloud_headers(user_token), timeout=WOSTORE_CLOUD_TIMEOUT).json()
5537        except Exception as e:
5538            self.log(f"沃云手机: 请求异常 {e}")
5539            return {}
5540
5541    def wostore_cloud_bucp_post(self, path, user_token, payload=None):
5542        url = f"https://uphone.wo-adv.cn/bucp{path}"
5543        try:
5544            return self.session.post(url, json=payload or {}, headers=self.wostore_cloud_headers(user_token), timeout=WOSTORE_CLOUD_TIMEOUT).json()
5545        except Exception as e:
5546            self.log(f"沃云手机: 请求异常 {e}")
5547            return {}
5548
5549    def wostore_cloud_activity_post(self, path, payload, user_token="", label="云手机请求"):
5550        url = f"https://uphone.wostore.cn{path}"
5551        try:
5552            return self.session.post(
5553                url,
5554                data=json.dumps(payload, ensure_ascii=False),
5555                headers=self.wostore_cloud_activity_headers(user_token),
5556                timeout=WOSTORE_CLOUD_TIMEOUT,
5557            ).json()
5558        except Exception as e:
5559            self.log(f"沃云手机: {label}异常 {e}")
5560            return {}
5561
5562    def wostore_cloud_user_info(self, cloud_token):
5563        res = self.wostore_cloud_bucp_get("/servers/system/user/getAppUserInfo", cloud_token)
5564        if str(res.get("code")) == "200":
5565            data = res.get("data") or {}
5566            name = data.get("nickName") or data.get("userName") or data.get("phoneNumber") or data.get("mobile")
5567            if name:
5568                self.log(f"沃云手机: 当前用户 {mask_str(name)}")
5569        else:
5570            self.log(f"沃云手机: 用户信息查询失败 - {res.get('msg') or pretty_json(res)}")
5571        return res
5572
5573    def wostore_cloud_point_info(self, cloud_token):
5574        res = self.wostore_cloud_bucp_get("/servers/order/user-point/point-info", cloud_token)
5575        if str(res.get("code")) == "200":
5576            data = res.get("data") or {}
5577            point = data.get("balanceScoreNum") or data.get("totalPoint") or data.get("point") or data.get("availablePoint")
5578            if point is not None:
5579                self.log(f"沃云手机: 当前积分 {point}", notify=True)
5580        else:
5581            self.log(f"沃云手机: 积分查询失败 - {res.get('msg') or pretty_json(res)}")
5582        return res
5583
5584    def wostore_cloud_sign(self, cloud_token):
5585        res = self.session.post(
5586            "https://h5forphone.wostore.cn/h5forphone/activity/signIn",
5587            data=json.dumps({"accesstoken": cloud_token}),
5588            headers=self.wostore_cloud_h5_headers(cloud_token),
5589            timeout=WOSTORE_CLOUD_TIMEOUT,
5590        ).json()
5591        self.log(f"沃云手机: 签到:{res.get('msg', '未知')}", notify=True)
5592        return res
5593
5594    def wostore_cloud_sign_rewards(self, cloud_token):
5595        res = self.session.post(
5596            "https://h5forphone.wostore.cn/h5forphone/activity/signInRightList",
5597            data=json.dumps({"accesstoken": cloud_token}),
5598            headers=self.wostore_cloud_h5_headers(cloud_token),
5599            timeout=WOSTORE_CLOUD_TIMEOUT,
5600        ).json()
5601        for item in (res.get("data") or {}).get("goodsList", []):
5602            if item.get("state") == "":
5603                self.wostore_cloud_receive_sign_reward(cloud_token, item.get("name", ""), item.get("activityOrderId", ""))
5604        return res
5605
5606    def wostore_cloud_receive_sign_reward(self, cloud_token, name, order_id):
5607        payload = {"accesstoken": cloud_token, "activityOrderid": order_id, "account": "", "accountType": ""}
5608        res = self.session.post(
5609            "https://h5forphone.wostore.cn/h5forphone/activity/raffleSignIn",
5610            data=json.dumps(payload),
5611            headers=self.wostore_cloud_h5_headers(cloud_token),
5612            timeout=WOSTORE_CLOUD_TIMEOUT,
5613        ).json()
5614        self.log(f"沃云手机: 领取{name}:{res.get('msg', '未知')}", notify=True)
5615        return res
5616
5617    def wostore_cloud_activity_login(self, cloud_token, activity_code, login_activity_id=None):
5618        res = self.wostore_cloud_activity_post(
5619            "/h5api/activity-service/user/login",
5620            {"identityType": "cloudPhoneLogin", "code": cloud_token, "activityId": login_activity_id or WOSTORE_CLOUD_LOGIN_ACTIVITY_ID, "device": "device"},
5621            "",
5622            "获取云任务token",
5623        )
5624        token = (res.get("data") or {}).get("user_token") or ""
5625        if token:
5626            self.log("沃云手机: 云任务Token获取成功")
5627        else:
5628            self.log(f"沃云手机: 云任务Token获取失败 - {res.get('msg') or pretty_json(res)}")
5629        return token
5630
5631    def wostore_cloud_points_sign(self, user_token, sign_code):
5632        if not sign_code:
5633            return {}
5634        res = self.wostore_cloud_activity_post(
5635            "/h5api/activity-service/points/v1/sign",
5636            {"activityCode": sign_code},
5637            user_token,
5638            "积分签到",
5639        )
5640        self.log(f"沃云手机: 积分签到:{res.get('msg', '未知')}", notify=True)
5641        return res
5642
5643    def wostore_cloud_task_list(self, user_token, activity_code):
5644        res = self.wostore_cloud_activity_post(
5645            "/h5api/activity-service/user/task/list",
5646            {"activityCode": activity_code},
5647            user_token,
5648            "查询任务列表",
5649        )
5650        data = res.get("data") or {}
5651        task_list = data.get("taskList") or data.get("list") or data.get("tasks") or res.get("taskList") or []
5652        self.log(f"沃云手机: 活动[{activity_code}]查询到 {len(task_list)} 个任务")
5653        if not task_list:
5654            self.log(f"沃云手机: 活动[{activity_code}]无可执行任务 - {response_summary(res)}")
5655            return res
5656        done = 0
5657        for task in task_list:
5658            name = task.get("taskName", "未知任务")
5659            code = task.get("taskCode", "")
5660            status = str(task.get("status") or task.get("taskStatus") or task.get("state") or "").upper()
5661            if status in {"OBTAINED", "RECEIVED", "FINISHED", "DONE"}:
5662                done += 1
5663                self.log(f"沃云手机: 已完成[{name}]")
5664            elif status in {"UNCLAIMED", "CLAIMABLE", "COMPLETED", "FINISH"}:
5665                self.log(f"沃云手机: 领取[{name}]奖励")
5666                result = self.wostore_cloud_receive_task(user_token, activity_code, code)
5667                if "每日限完成一个此类任务" in str(result.get("msg", "")):
5668                    self.log("沃云手机: 已达当日任务上限,停止本活动")
5669                    break
5670            elif status == "INCOMPLETE":
5671                self.log(f"沃云手机: 执行[{name}] 状态 {status or '未知'}")
5672                result = self.wostore_cloud_finish_task(user_token, activity_code, task)
5673                if "每日限完成一个此类任务" in str(result.get("msg", "")):
5674                    self.log("沃云手机: 已达当日任务上限,停止本活动")
5675                    break
5676            else:
5677                self.log(f"沃云手机: 跳过[{name}] 未知状态 {status or '空'}")
5678        self.log(f"沃云手机: 活动[{activity_code}]执行前已完成 {done}/{len(task_list)} 个任务")
5679        return res
5680
5681    def wostore_cloud_finish_task(self, user_token, activity_code, task):
5682        task_code = task.get("taskCode", "")
5683        task_name = task.get("taskName") or task.get("taskDesc") or task_code
5684        res = self.wostore_cloud_activity_post(
5685            "/h5api/activity-service/user/task/logs",
5686            {
5687                "logType": "01",
5688                "logCode": task_code,
5689                "logSource": "01",
5690                "logDetail": task_name,
5691            },
5692            user_token,
5693            "完成任务",
5694        )
5695        self.log(f"沃云手机: 任务状态:{res.get('msg', '未知')}")
5696        if str(res.get("code")) != "200":
5697            self.log(f"沃云手机: 任务[{task_name}]完成失败,跳过领取")
5698            return res
5699        time.sleep(15)
5700        return self.wostore_cloud_receive_task(user_token, activity_code, task_code)
5701
5702    def wostore_cloud_receive_task(self, user_token, activity_code, task_code):
5703        res = self.wostore_cloud_activity_post(
5704            "/h5api/activity-service/user/task/raffle/get",
5705            {"activityCode": activity_code, "taskCode": task_code},
5706            user_token,
5707            "领取任务奖励",
5708        )
5709        self.log(f"沃云手机: 奖励领取结果:{res.get('msg', '未知')}", notify=True)
5710        return res
5711
5712    def wostore_cloud_lottery_count(self, user_token, activity_code):
5713        res = self.wostore_cloud_activity_post(
5714            "/h5api/activity-service/user/task/list",
5715            {"activityCode": activity_code},
5716            user_token,
5717            "查询抽奖次数",
5718        )
5719        data = res.get("data") or {}
5720        count = int(data.get("rafflesLeftCount") or data.get("raffleLeftCount") or data.get("lotteryLeftCount") or res.get("rafflesLeftCount") or res.get("raffleLeftCount") or 0)
5721        self.log(f"沃云手机: 活动[{activity_code}]剩余抽奖次数:{count}")
5722        return count
5723
5724    def wostore_cloud_draw(self, user_token, activity_code):
5725        res = self.wostore_cloud_activity_post(
5726            "/h5api/activity-service/lottery",
5727            {"activityCode": activity_code},
5728            user_token,
5729            "抽奖",
5730        )
5731        prize = (res.get("data") or {}).get("prizeName") or res.get("msg") or "未知奖励"
5732        self.log(f"沃云手机: 抽奖获得:{prize}", notify=True)
5733        return res
5734
5735    def wostore_points_history_has_prize(self, user_token, goods_id):
5736        try:
5737            res = self.session.get(
5738                f"https://uphone.wostore.cn/h5api/activity-service/points/v1/lottery/history?page=1&pageSize=10&goodsId={goods_id}",
5739                headers=self.wostore_cloud_activity_headers(user_token),
5740                timeout=WOSTORE_CLOUD_TIMEOUT,
5741            ).json()
5742            today = datetime.now().strftime("%Y-%m-%d")
5743            data = res.get("data") or {}
5744            records = data if isinstance(data, list) else data.get("records", []) or data.get("list", [])
5745            for item in records:
5746                if str(item.get("createTime") or item.get("drawTime") or "").startswith(today) and item.get("prizeName"):
5747                    return True
5748        except Exception as e:
5749            self.log(f"沃云手机: 积分抽奖记录查询异常 {e}")
5750        return False
5751
5752    def wostore_points_exchange_remain(self, user_token, goods_id):
5753        try:
5754            res = self.session.get(
5755                f"https://uphone.wostore.cn/h5api/activity-service/points/v1/exchange/list?activityCode={WOSTORE_POINTS_ACT_CODE}",
5756                headers=self.wostore_cloud_activity_headers(user_token),
5757                timeout=WOSTORE_CLOUD_TIMEOUT,
5758            ).json()
5759            data = res.get("data") or {}
5760            goods_list = data if isinstance(data, list) else data.get("goodsList", []) or data.get("list", [])
5761            for item in goods_list:
5762                if str(item.get("goodsId")) == str(goods_id):
5763                    remain = safe_int(item.get("remainUser") or item.get("remainCount") or item.get("surplusCount"), 0)
5764                    self.log(f"沃云手机: 积分商品[{goods_id}]剩余次数:{remain}")
5765                    return remain
5766        except Exception as e:
5767            self.log(f"沃云手机: 积分兑换列表查询异常 {e}")
5768        return 0
5769
5770    def wostore_points_lottery(self, user_token, goods_id):
5771        res = self.wostore_cloud_activity_post(
5772            "/h5api/activity-service/points/v1/lottery",
5773            {"activityCode": WOSTORE_POINTS_ACT_CODE, "goodsId": goods_id},
5774            user_token,
5775            "积分抽奖",
5776        )
5777        results = (res.get("data") or {}).get("results") or []
5778        if not results and res.get("data"):
5779            results = [res.get("data")]
5780        prizes = [str(item.get("prizeName") or "未知") for item in results]
5781        label = "积分单抽" if str(goods_id) == str(WOSTORE_POINTS_GOODS_ID_1) else "积分10连抽"
5782        self.log(f"沃云手机: {label}:{res.get('msg') or '、'.join(prizes) or '未知'}", notify=True)
5783        return any(WOSTORE_POINTS_STOP_PRIZE in prize for prize in prizes)
5784
5785    def wostore_cloud_device_status(self, cloud_token):
5786        res = self.wostore_cloud_bucp_get("/servers/resource/instance/list?pageNum=1&pageSize=200", cloud_token)
5787        rows = res.get("rows") or (res.get("data") or {}).get("rows") or []
5788        for device in rows:
5789            device_id = device.get("id") or device.get("deviceId") or ""
5790            status = device.get("status", "?")
5791            if status == "running":
5792                self.log("沃云手机: 设备运行正常")
5793            elif status == "pre_create":
5794                self.wostore_cloud_device_action(cloud_token, "/servers/resource/instance/cpInstanceAction", {"action": "allot", "cpInstanceId": device_id}, "激活设备")
5795            else:
5796                self.wostore_cloud_device_action(cloud_token, "/servers/resource/backup/recover", {"cpInstanceId": device_id}, "恢复设备")
5797        return res
5798
5799    def wostore_cloud_device_action(self, cloud_token, path, payload, label):
5800        res = self.wostore_cloud_bucp_post(path, cloud_token, payload)
5801        self.log(f"沃云手机: {label}结果:{res.get('msg', '未知')}")
5802        return res
5803
5804    def wostore_cloud_task(self, is_query_only=False):
5805        self.log("==== 沃云手机 ====")
5806        if is_query_only:
5807             self.log("沃云手机: [查询模式] 此平台暂无资产或余额可供查询", notify=True)
5808             return
5809        ticket = self.wostore_cloud_get_ticket()
5810        if not ticket:
5811             self.log("沃云手机: 获取入口 Ticket 失败 (为空)")
5812             return
5813        tokens = self.wostore_cloud_login(ticket)
5814        if not tokens:
5815            self.log("沃云手机: 登录失败,跳过后续任务")
5816            return
5817        cloud_token = tokens["cloud_token"]
5818        self.wostore_cloud_user_info(cloud_token)
5819        self.wostore_cloud_sign(cloud_token)
5820        time.sleep(3)
5821        self.wostore_cloud_sign_rewards(cloud_token)
5822        points_user_token = ""
5823        for activity_code in WOSTORE_CLOUD_ACTIVITY_CODES:
5824            user_token = self.wostore_cloud_activity_login(cloud_token, activity_code)
5825            if not user_token:
5826                continue
5827            if not points_user_token:
5828                points_user_token = user_token
5829            self.wostore_cloud_points_sign(user_token, WOSTORE_CLOUD_SIGN_CODE)
5830            self.wostore_cloud_task_list(user_token, activity_code)
5831        # 抽奖: 使用抽奖专用活动码 (先做该活动专属任务, 再查次数抽奖)
5832        for lottery_code in WOSTORE_LOTTERY_ACTIVITY_CODES:
5833            lottery_token = self.wostore_cloud_activity_login(cloud_token, lottery_code, login_activity_id=lottery_code)
5834            if not lottery_token:
5835                continue
5836            self.wostore_cloud_task_list(lottery_token, lottery_code)
5837            for _ in range(self.wostore_cloud_lottery_count(lottery_token, lottery_code)):
5838                self.wostore_cloud_draw(lottery_token, lottery_code)
5839                time.sleep(3)
5840        if points_user_token:
5841            if self.wostore_points_history_has_prize(points_user_token, WOSTORE_POINTS_GOODS_ID_1):
5842                self.log("沃云手机: 今日已中奖,跳过积分单抽")
5843            else:
5844                for _ in range(min(self.wostore_points_exchange_remain(points_user_token, WOSTORE_POINTS_GOODS_ID_1), WOSTORE_POINTS_MAX_DRAW)):
5845                    if self.wostore_points_lottery(points_user_token, WOSTORE_POINTS_GOODS_ID_1):
5846                        break
5847                    time.sleep(3)
5848            for _ in range(min(self.wostore_points_exchange_remain(points_user_token, WOSTORE_POINTS_GOODS_ID_10), WOSTORE_POINTS_MAX_DRAW)):
5849                self.wostore_points_lottery(points_user_token, WOSTORE_POINTS_GOODS_ID_10)
5850                time.sleep(3)
5851        self.wostore_cloud_point_info(cloud_token)
5852        self.wostore_cloud_device_status(cloud_token)
5853
5854    def regional_task(self, is_query_only=False):
5855        """区域专区任务入口"""
5856        is_xinjiang = False
5857        is_henan = False
5858        is_yunnan = False
5859        is_liaoning = False
5860        is_anhui = False
5861        if hasattr(self, 'city_info') and self.city_info and isinstance(self.city_info, list):
5862            try:
5863                for city in self.city_info:
5864                    pro_name = city.get('proName', '')
5865                    if "新疆" in pro_name: is_xinjiang = True
5866                    if "河南" in pro_name: is_henan = True
5867                    if "云南" in pro_name: is_yunnan = True
5868                    if "辽宁" in pro_name: is_liaoning = True
5869                    if "安徽" in pro_name: is_anhui = True
5870            except: pass
5871        rc = globalConfig.get("regional_config", {})
5872        if is_query_only:
5873            self.log("==== 区域专区 (查询模式) ====")
5874            if is_xinjiang:
5875                self.log("新疆专区: [查询模式] 跳过每日打卡,尝试查询每月抽奖记录")
5876                try:
5877                    ticket_res = self.openPlatLineNew("https://zy100.xj169.com/touchpoint/openapi/jumpHandRoom1G?source=155&type=02")
5878                    if ticket_res and ticket_res.get("ticket"):
5879                        token = self.xj_get_token(ticket_res.get("ticket"))
5880                        if token:
5881                            self.xj_query_monthly_draw_records(token)
5882                except Exception as e:
5883                    self.log(f"新疆专区: [查询模式] 查询每月抽奖记录异常 {e}")
5884            if is_henan:
5885                is_signed = self.shangdu_get_sign_status()
5886                if is_signed is True:
5887                    self.log("河南商都: [状态查询] 今日已签到")
5888                elif is_signed is False:
5889                    self.log("河南商都: [状态查询] 今日未签到")
5890                else:
5891                    self.log("河南商都: [状态查询] 查询失败")
5892            if is_yunnan:
5893                self.yunnan_life_task(is_query_only=True)
5894            if is_liaoning:
5895                self.ln_flmf_task(is_query_only=True)
5896            if is_anhui and AH_FRIDAY_AMOUNT:
5897                self.log(f"安徽超级星期五: [查询模式] 目标面额{AH_FRIDAY_AMOUNT}元 (仅周五10点执行)")
5898            return
5899        if is_xinjiang:
5900            self.log("==== 新疆专区 ====")
5901            self.xj_task_main()
5902        if is_henan:
5903            self.log("==== 河南商都 ====")
5904            self.shangdu_task_main()
5905        if is_yunnan:
5906            self.log("==== 云南生活 ====")
5907            self.yunnan_life_task()
5908        if is_liaoning:
5909            self.log("==== 辽宁福利魔方 ====")
5910            self.ln_flmf_task()
5911        if is_anhui and AH_FRIDAY_AMOUNT and rc.get("run_ah_friday", True):
5912            self.log("==== 安徽超级星期五 ====")
5913            self.ah_friday_task()
5914
5915    def yunnan_life_base_headers(self, token=None, extra=None):
5916        headers = {
5917            "Referer": "https://wsm.wx.yn10010.com/",
5918            "Sec-Fetch-Dest": "empty",
5919            "Sec-Fetch-Mode": "cors",
5920            "Sec-Fetch-Site": "same-origin",
5921            "Content-Type": "application/json;charset=UTF-8",
5922            "Accept-Language": "zh-CN,en-US;q=0.8",
5923            "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.1001};ltst;OSVersion/16.6",
5924        }
5925        if token:
5926            headers["token"] = token
5927        if extra:
5928            headers.update(extra)
5929        return headers
5930
5931    def yunnan_life_calc_sign(self, payload):
5932        parts = []
5933        for key in sorted(payload.keys()):
5934            value = payload[key]
5935            if isinstance(value, dict):
5936                encoded = quote(json.dumps(value, ensure_ascii=False, separators=(',', ':')), safe="")
5937            else:
5938                encoded = quote(str(value), safe="")
5939            parts.append(f"{key}={encoded}")
5940        raw = "&".join(parts).lower() + YUNNAN_LIFE_SIGN_SALT
5941        return hashlib.md5(hashlib.md5(raw.encode('utf-8')).hexdigest().encode('utf-8')).hexdigest()
5942
5943    def yunnan_life_signed_headers(self, token, payload):
5944        return self.yunnan_life_base_headers(token, {
5945            "Origin": YUNNAN_LIFE_BASE_URL,
5946            "accessKeyId": YUNNAN_LIFE_ACCESS_KEY,
5947            "time": str(round(time.time() * 1000)),
5948            "sign": self.yunnan_life_calc_sign(payload),
5949        })
5950
5951    def yunnan_life_get_ticket(self):
5952        if not self.ecs_token:
5953            return None
5954        try:
5955            res = self.session.get(
5956                "https://m.client.10010.com/mobileService/openPlatform/openPlatLineNew.htm",
5957                params={
5958                    "to_url": YUNNAN_LIFE_TO_URL,
5959                    "amp;s": "100000425",
5960                    "amp;boothCode": "YN-QCQYCS245",
5961                    "amp;boothAccessMode": "24",
5962                },
5963                headers={
5964                    "Cookie": f"ecs_token={self.ecs_token}",
5965                    "Referer": "https://wsm.wx.yn10010.com/",
5966                    "Accept-Language": "zh-CN,zh-Hans;q=0.9",
5967                    "Sec-Fetch-Mode": "navigate",
5968                    "Sec-Fetch-Dest": "document",
5969                    "Sec-Fetch-Site": "cross-site",
5970                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
5971                    "User-Agent": self.yunnan_life_base_headers().get("User-Agent"),
5972                },
5973                allow_redirects=False,
5974                timeout=15,
5975            )
5976            location = res.headers.get("Location", "")
5977            match = re.search(r'ticket=([^&]+)', location)
5978            return match.group(1) if match else None
5979        except Exception as e:
5980            self.log(f"云南生活: 获取 ticket 异常: {e}")
5981            return None
5982
5983    def yunnan_life_get_token(self, ticket):
5984        if not ticket:
5985            return None
5986        try:
5987            resp = self.session.get(
5988                f"{YUNNAN_LIFE_BASE_URL}/2b2c-mobile/getPhoneNumber",
5989                params={"ticket": ticket},
5990                headers=self.yunnan_life_base_headers(extra={"Content-Type": "application/json;charset=gb2312"}),
5991                timeout=15,
5992            )
5993            token = resp.headers.get("token") or resp.headers.get("Token")
5994            if not token:
5995                try:
5996                    data = resp.json()
5997                except Exception:
5998                    data = {}
5999                token = data.get("token") or data.get("data", {}).get("token")
6000            if not token:
6001                self.log(f"云南生活: 未找到 token,响应: {resp.text[:160]}")
6002                return None
6003            return token if str(token).startswith("Bearer ") else f"Bearer {token}"
6004        except Exception as e:
6005            self.log(f"云南生活: 获取 token 异常: {e}")
6006            return None
6007
6008    def yunnan_life_login(self):
6009        ticket = self.yunnan_life_get_ticket()
6010        if not ticket:
6011            self.log("云南生活: 获取 ticket 失败")
6012            return None
6013        token = self.yunnan_life_get_token(ticket)
6014        if not token:
6015            self.log("云南生活: 获取 token 失败")
6016            return None
6017        return token
6018
6019    def yunnan_life_do_task(self, token, payload):
6020        task_name = payload.get("taskName", payload.get("taskCode", "未知任务"))
6021        try:
6022            res = self.session.post(
6023                f"{YUNNAN_LIFE_BASE_URL}/2b2c-mobile/activity/task/addTaskUser",
6024                data=json.dumps(payload, ensure_ascii=False, separators=(',', ':')),
6025                headers=self.yunnan_life_signed_headers(token, payload),
6026                timeout=15,
6027            ).json()
6028            if res.get("resultCode") == "0000":
6029                self.log(f"云南生活: ✅ {task_name}")
6030            else:
6031                self.log(f"云南生活: ❌ {task_name}: {res.get('resultMsg', '')}")
6032        except Exception as e:
6033            self.log(f"云南生活: [{task_name}] 异常: {e}")
6034
6035    def yunnan_life_do_lottery(self, token, times=2):
6036        payload = {"actId": YUNNAN_LIFE_ACT_ID, "boothCode": ""}
6037        headers = self.yunnan_life_base_headers(token, {"Origin": YUNNAN_LIFE_BASE_URL})
6038        for i in range(times):
6039            try:
6040                res = self.session.post(
6041                    f"{YUNNAN_LIFE_BASE_URL}/2b2c-mobile/acttmpl/lottery/actLuckyDrawy",
6042                    data=json.dumps(payload, ensure_ascii=False, separators=(',', ':')),
6043                    headers=headers,
6044                    timeout=15,
6045                ).json()
6046                if res.get("resultCode") == "0000":
6047                    self.log(f"云南生活: ✅ 第{i + 1}次抽奖请求成功")
6048                else:
6049                    self.log(f"云南生活: ❌ 第{i + 1}次抽奖失败: {res.get('resultMsg', '')}")
6050            except Exception as e:
6051                self.log(f"云南生活: 第{i + 1}次抽奖异常: {e}")
6052            if i < times - 1:
6053                time.sleep(2)
6054
6055    def yunnan_life_get_lottery_results(self, token):
6056        try:
6057            resp = self.session.get(
6058                f"{YUNNAN_LIFE_BASE_URL}/2b2c-mobile/acttmpl/lottery/getUserRecordListActInfo",
6059                params={"actId": YUNNAN_LIFE_ACT_ID, "periodId": YUNNAN_LIFE_ACT_ID},
6060                headers=self.yunnan_life_base_headers(token, {"Content-Type": "application/json;charset=gb2312"}),
6061                timeout=15,
6062            )
6063            data = resp.json()
6064            today = datetime.now().strftime("%Y-%m-%d")
6065            awards = []
6066            for item in data.get("data", {}).get("recordList", []):
6067                if str(item.get("createTime", "")).startswith(today):
6068                    awards.append(item.get("awardName", "未知"))
6069            if awards:
6070                for award in awards:
6071                    self.log(f"云南生活: 🎁 抽奖结果 - {award}", notify=True)
6072            else:
6073                self.log("云南生活: 今日暂无抽奖记录")
6074        except Exception as e:
6075            self.log(f"云南生活: 查询抽奖结果异常: {e}")
6076
6077    def yunnan_life_get_bean_balance(self, token):
6078        try:
6079            payload = {}
6080            res = self.session.post(
6081                f"{YUNNAN_LIFE_BASE_URL}/user/beans/api/getTotalAvailableBeansByPhone",
6082                data=json.dumps(payload, ensure_ascii=False, separators=(',', ':')),
6083                headers=self.yunnan_life_signed_headers(token, payload),
6084                timeout=15,
6085            ).json()
6086            if res.get("resultCode") == "0000":
6087                self.log(f"云南生活: 💰 当前云豆余额: {res.get('data', 0)}", notify=True)
6088            else:
6089                self.log(f"云南生活: 获取云豆失败: {res.get('resultMsg', '')}")
6090        except Exception as e:
6091            self.log(f"云南生活: 查询云豆异常: {e}")
6092
6093    def yunnan_life_task(self, is_query_only=False):
6094        token = self.yunnan_life_login()
6095        if not token:
6096            return
6097        if is_query_only:
6098            self.log("云南生活: [查询模式] 查询云豆余额")
6099            self.yunnan_life_get_bean_balance(token)
6100            return
6101        for task in YUNNAN_LIFE_TASKS:
6102            self.yunnan_life_do_task(token, task)
6103            time.sleep(2)
6104        self.yunnan_life_do_lottery(token, times=2)
6105        self.yunnan_life_get_lottery_results(token)
6106        self.yunnan_life_get_bean_balance(token)
6107
6108    def xj_task_main(self):
6109        ticket_res = self.openPlatLineNew("https://zy100.xj169.com/touchpoint/openapi/jumpHandRoom1G?source=155&type=02")
6110        if not ticket_res or not ticket_res.get("ticket"):
6111            self.log("新疆专区: 获取入口 ticket 失败")
6112            return
6113        token = self.xj_get_token(ticket_res.get("ticket"))
6114        if token:
6115            self.xj_do_draw(token, "Jan2026Act")
6116            day = datetime.now().day
6117            if 19 <= day <= 25:
6118                self.xj_usersday_task(token)
6119            self.xj_monthly_draw_task(token)
6120
6121    def xj_get_token(self, ticket):
6122        try:
6123            url = "https://zy100.xj169.com/touchpoint/openapi/getTokenAndCity"
6124            if isinstance(ticket, dict):
6125                ticket = ticket.get("ticket")
6126            data = {"ticket": ticket}
6127            headers = {
6128                "Referer": f"https://zy100.xj169.com/touchpoint/openapi/jumpHandRoom1G?source=155&type=02&ticket={ticket}",
6129                "User-Agent": XJ_USER_AGENT,
6130            }
6131            res = self.session.post(url, data=data, headers=headers).json()
6132            result = res.get('result', {})
6133            if result.get('code') == 0 and result.get('data', {}).get('token'):
6134                return result.get('data', {}).get('token')
6135            token = res.get("data", {}).get("token")
6136            if token:
6137                return token
6138            return None
6139        except Exception as e:
6140            self.log(f"新疆专区: 获取 token 异常 {e}")
6141            return None
6142
6143    def xj_do_draw(self, token, act_id):
6144        try:
6145            url = f"https://zy100.xj169.com/touchpoint/openapi/marchAct/draw_{act_id}"
6146            data = {"activityId": f"daka{act_id}", "prizeId": ""}
6147            headers = {"userToken": token, "User-Agent": XJ_USER_AGENT}
6148            res = self.session.post(url, data=data, headers=headers).json()
6149            msg = res.get('result', {}).get('msg') or res.get('result', {}).get('data') or "失败"
6150            self.log(f"新疆专区: 每日打卡 - {msg}", notify=True)
6151        except Exception as e:
6152            self.log(f"新疆专区: 打卡异常 {e}")
6153
6154    def xj_usersday_task(self, token):
6155        try:
6156            url = "https://zy100.xj169.com/touchpoint/openapi/marchAct/draw_UsersDay2025Act"
6157            data = {"activityId": "usersDay2025Act", "prizeId": "hfq_twenty"}
6158            headers = {"userToken": token, "User-Agent": XJ_USER_AGENT}
6159            res = self.session.post(url, data=data, headers=headers).json()
6160            msg = res.get('result', {}).get('msg') or res.get('result', {}).get('data') or "失败"
6161            self.log(f"新疆客户日: 秒杀结果 - {msg}", notify=True)
6162        except Exception as e:
6163            self.log(f"新疆客户日: 秒杀异常 {e}")
6164
6165    def xj_monthly_draw_once(self, token):
6166        headers = {
6167            "User-Agent": XJ_USER_AGENT,
6168            "userToken": token,
6169            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
6170        }
6171        payload = {"activityId": XJ_ACTIVITY_ID, "prizeId": "", "commHighFlag": "false"}
6172        try:
6173            res = self.session.post(
6174                f"https://zy100.xj169.com/touchpoint/openapi/themeAct/draw_{XJ_ACTIVITY_ID}",
6175                data=payload,
6176                headers=headers,
6177                timeout=10,
6178            ).json()
6179            code = res.get("code")
6180            msg = str(res.get("msg", ""))
6181            msg_type = str(res.get("msgType", ""))
6182            data = res.get("data", "")
6183            if code == "ERROR":
6184                data_str = str(data)
6185                if "已用完" in data_str or "已抽完" in data_str or msg_type == "101":
6186                    return "done", f"今日机会已用尽 ({data_str or msg or '无可用次数'})"
6187                if "频率过高" in msg:
6188                    return "done", "接口频率限制"
6189                if "缺少参数" in msg:
6190                    return "invalid", "token 已失效"
6191                return "done", f"抽奖失败: {data_str or msg or '未知错误'}"
6192            if code == "SUCCESS":
6193                if msg == "thanks1":
6194                    return "continue", f"未中奖 ({data or msg})"
6195                return "won", f"中奖: {data or '未知奖品'}"
6196            if str(code) == "401":
6197                return "invalid", "token 已失效"
6198            return "continue", f"未中奖 ({msg or data or code})"
6199        except Exception as e:
6200            return "error", f"请求异常: {e}"
6201
6202    def xj_query_monthly_draw_records(self, token):
6203        headers = {
6204            "User-Agent": XJ_USER_AGENT,
6205            "userToken": token,
6206            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
6207        }
6208        try:
6209            res = self.session.post(
6210                "https://zy100.xj169.com/touchpoint/openapi/drawAct/getPrizesScroll",
6211                data={"activityId": XJ_ACTIVITY_ID},
6212                headers=headers,
6213                timeout=10,
6214            ).json()
6215            data = res.get("data", [])
6216            if not data:
6217                self.log("新疆专区: 每月抽奖暂无中奖记录")
6218                return
6219            if isinstance(data, dict):
6220                data = [data]
6221            if isinstance(data, list) and data and isinstance(data[0], str):
6222                for item in data[:5]:
6223                    self.log(f"新疆专区: 每月抽奖记录 - {item}", notify=True)
6224                return
6225            displayed = 0
6226            for item in data:
6227                if not isinstance(item, dict):
6228                    continue
6229                prize_name = item.get("prizeName") or item.get("prizeId") or "未知奖品"
6230                draw_ts = safe_int(item.get("drawDate"), 0)
6231                draw_date = datetime.fromtimestamp(draw_ts / 1000).strftime("%m-%d") if draw_ts else "未知时间"
6232                self.log(f"新疆专区: 每月抽奖记录 - {prize_name} ({draw_date})", notify=True)
6233                displayed += 1
6234                if displayed >= 5:
6235                    break
6236            if displayed == 0:
6237                self.log("新疆专区: 每月抽奖暂无可展示记录")
6238        except Exception as e:
6239            self.log(f"新疆专区: 查询每月抽奖记录异常 {e}")
6240
6241    def xj_monthly_draw_task(self, token):
6242        self.log(f"新疆专区: 每月抽奖活动 {XJ_ACTIVITY_ID}")
6243        for i in range(XJ_MONTHLY_DRAW_ATTEMPT_COUNT):
6244            status, msg = self.xj_monthly_draw_once(token)
6245            self.log(
6246                f"新疆专区: 每月抽奖第{i + 1}次 - {msg}",
6247                notify=status == "won",
6248            )
6249            if status in {"done", "won", "invalid"}:
6250                break
6251            time.sleep(random.uniform(1, 2))
6252        self.xj_query_monthly_draw_records(token)
6253
6254    def shangdu_get_sign_status(self):
6255        try:
6256            url = "https://app.shangdu.com/monthlyBenefit/v1/signIn/queryCumulativeSignAxis"
6257            headers = {
6258                "Origin": "https://app.shangdu.com",
6259                "Referer": "https://app.shangdu.com/monthlyBenefit/index.html",
6260                "edop_flag": "0", "Content-Type": "application/json"
6261            }
6262            res = self.session.post(url, json={}, headers=headers).json()
6263            if res.get('result', {}).get('code') == "0000":
6264                return res.get('result', {}).get('data', {}).get('todaySignFlag') == "1"
6265            return None
6266        except: return None
6267
6268    def shangdu_sign_retry(self):
6269        try:
6270            url = "https://app.shangdu.com/monthlyBenefit/v1/signIn/userSignIn"
6271            headers = {
6272                "Origin": "https://app.shangdu.com",
6273                "Referer": "https://app.shangdu.com/monthlyBenefit/index.html",
6274                "edop_flag": "0", "X-Requested-With": "XMLHttpRequest",
6275                "Content-Type": "application/json"
6276            }
6277            res = self.session.post(url, json={}, headers=headers).json()
6278            code = res.get('result', {}).get('code')
6279            data = res.get('result', {}).get('data', {})
6280            if code == "0000":
6281                prize = data.get('prizeResp', {}).get('prizeName')
6282                if prize: self.log(f"河南商都: 签到成功(重试) - 获得 {prize}", notify=True)
6283                else: self.log("河南商都: 签到成功(重试)")
6284            elif code == "0019":
6285                self.log("河南商都: 重试仍返回重复签到")
6286            else:
6287                self.log(f"河南商都: A签到重试失败 - {res.get('result', {}).get('msg')}")
6288        except Exception as e:
6289            self.log(f"河南商都: 签到重试异常 {e}")
6290
6291    def shangdu_task_main(self):
6292        if not self.ecs_token: return
6293        url = f"https://m.client.10010.com/edop_ng/getTicketByNative?appId=edop_unicom_4b80047a&token={self.ecs_token}"
6294        res = self.session.get(url).json()
6295        ticket = res.get('result', {}).get('ticket')
6296        if not ticket:
6297            self.log("河南商都: 获取Ticket失败")
6298            return
6299        login_url = f"https://app.shangdu.com/monthlyBenefit/v1/common/config?ticket={ticket}"
6300        headers_login = {
6301             "Origin": "https://app.shangdu.com",
6302             "Referer": "https://app.shangdu.com/monthlyBenefit/index.html",
6303             "edop_flag": "0", "Accept": "application/json, text/plain, */*"
6304        }
6305        self.session.get(login_url, headers=headers_login)
6306        time.sleep(1.5)
6307        sign_url = "https://app.shangdu.com/monthlyBenefit/v1/signIn/userSignIn"
6308        headers_sign = {
6309             "Origin": "https://app.shangdu.com",
6310             "Referer": "https://app.shangdu.com/monthlyBenefit/index.html",
6311             "edop_flag": "0", "X-Requested-With": "XMLHttpRequest",
6312             "Content-Type": "application/json"
6313        }
6314        res_sign = self.session.post(sign_url, json={}, headers=headers_sign).json()
6315        code = res_sign.get('result', {}).get('code')
6316        data = res_sign.get('result', {}).get('data', {})
6317        if code == "0000":
6318             if data.get('value') == "0001":
6319                 self.log("河南商都: 签到失败 - Cookie无效")
6320             else:
6321                 prize = data.get('prizeResp', {}).get('prizeName', '已签到')
6322                 self.log(f"河南商都: 签到结果 - {prize}", notify=True)
6323        elif code == "0019":
6324             time.sleep(1)
6325             is_signed = self.shangdu_get_sign_status()
6326             if is_signed is True:
6327                 self.log("河南商都: 今日已签到")
6328             elif is_signed is False:
6329                 self.log("河南商都: 状态未签到但返回重复,尝试重试...")
6330                 time.sleep(2)
6331                 self.shangdu_sign_retry()
6332             else:
6333                 self.log("河南商都: 今日已签到 (状态未知)")
6334        else:
6335             self.log(f"河南商都: 签到失败 - {code} : {res_sign.get('result', {}).get('msg')}")
6336
6337    def ln_flmf_get_sid(self):
6338        """辽宁福利魔方: 通过 openPlatLineNew → autoLogin 获取 sid"""
6339        try:
6340            ticket_res = self.openPlatLineNew("https://weixin.linktech.hk/lv-web/handHall/autoLogin?actcode=sign")
6341            if not ticket_res or not ticket_res.get('ticket'):
6342                self.log("辽宁福利魔方: 获取ticket失败")
6343                return None
6344            ticket = ticket_res['ticket']
6345            type_val = ticket_res.get('type', '06')
6346            mobile = getattr(self, 'account_mobile', getattr(self, 'mobile', ''))
6347            timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
6348            postage = hashlib.md5(f"{mobile}{timestamp}".encode()).hexdigest()
6349            login_url = "https://weixin.linktech.hk/lv-web/handHall/autoLogin"
6350            params = {
6351                "actcode": "sign",
6352                "type": type_val,
6353                "ticket": ticket,
6354                "version": COMMON_CONSTANTS["APP_VERSION"],
6355                "timestamp": timestamp,
6356                "desmobile": mobile,
6357                "num": "0",
6358                "postage": postage,
6359                "userNumber": mobile
6360            }
6361            res = self.session.get(login_url, params=params, allow_redirects=False, timeout=15)
6362            if res.status_code != 302 or 'Location' not in res.headers:
6363                self.log(f"辽宁福利魔方: autoLogin期望302, 实际{res.status_code}")
6364                return None
6365            loc = res.headers['Location']
6366            sid_match = re.search(r'sid[=%]3[Dd]?([a-f0-9]{32})', loc)
6367            if not sid_match:
6368                parsed = urlparse(unquote(loc))
6369                qs = parse_qs(parsed.query)
6370                params_val = qs.get('params', [''])[0]
6371                if 'sid=' in params_val:
6372                    inner_qs = parse_qs(params_val)
6373                    sid = inner_qs.get('sid', [''])[0]
6374                else:
6375                    sid = qs.get('sid', [''])[0]
6376            else:
6377                sid = sid_match.group(1)
6378            if sid and len(sid) == 32:
6379                self.log(f"辽宁福利魔方: 获取sid成功 ({sid[:8]}...)")
6380                return sid
6381            self.log(f"辽宁福利魔方: 重定向中未找到sid")
6382        except Exception as e:
6383            self.log(f"辽宁福利魔方: 获取sid异常 - {e}")
6384        return None
6385
6386    def ln_flmf_api(self, sid, endpoint, extra_data=None):
6387        """辽宁福利魔方: 通用API调用"""
6388        url = f"https://weixin.linktech.hk/lv-apiaccess/welfareCenter/{endpoint}"
6389        headers = {
6390            "Content-Type": "application/x-www-form-urlencoded",
6391            "Origin": "https://weixin.linktech.hk",
6392            "Referer": f"https://weixin.linktech.hk/app/flmf/LV-202111-04/moreShatter?sid={sid}&actcode=welfareCenter",
6393            "User-Agent": "Mozilla/5.0 (Linux; Android 10; MI 8) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/143.0.7499.146 Mobile Safari/537.36; unicom{version:android@11.0802}"
6394        }
6395        data = f"sid={sid}&actcode=welfareCenter"
6396        if extra_data:
6397            data += f"&{extra_data}"
6398        try:
6399            res = self.session.post(url, headers=headers, data=data, timeout=15).json()
6400            return res
6401        except Exception as e:
6402            self.log(f"辽宁福利魔方: {endpoint} 请求异常 - {e}")
6403            return None
6404
6405    def ln_flmf_task(self, is_query_only=False):
6406        """辽宁福利魔方: 主入口"""
6407        sid = self.ln_flmf_get_sid()
6408        if not sid:
6409            return
6410        res = self.ln_flmf_api(sid, "addUser")
6411        if not res or res.get('resultCode') != '0000':
6412            self.log(f"辽宁福利魔方: 用户初始化失败 - {(res or {}).get('resultMsg', '无响应')}")
6413            return
6414        time.sleep(1)
6415        init_res = self.ln_flmf_api(sid, "signInInit")
6416        if init_res and init_res.get('resultCode') == '0000':
6417            init_data = init_res.get('data', {})
6418            is_signed = init_data.get('isSigned', 0)
6419            consecutive = init_data.get('consecutiveDays', 0)
6420            if is_signed:
6421                self.log(f"辽宁福利魔方: 今日已签到 (连续{consecutive}天)")
6422            elif is_query_only:
6423                self.log(f"辽宁福利魔方: 今日未签到 (连续{consecutive}天)")
6424            else:
6425                time.sleep(1)
6426                sign_res = self.ln_flmf_api(sid, "signIn")
6427                if sign_res and sign_res.get('resultCode') == '0000':
6428                    self.log(f"辽宁福利魔方: ✅ 签到成功 (连续{consecutive + 1}天)", notify=True)
6429                else:
6430                    self.log(f"辽宁福利魔方: 签到失败 - {(sign_res or {}).get('resultMsg', '无响应')}")
6431        else:
6432            self.log(f"辽宁福利魔方: 查询签到状态失败 - {(init_res or {}).get('resultMsg', '无响应')}")
6433        time.sleep(1)
6434        info_res = self.ln_flmf_api(sid, "getUserInfo")
6435        if info_res and info_res.get('resultCode') == '0000':
6436            info = info_res.get('data', {})
6437            wobi = info.get('woBi', 0)
6438            sign_times = info.get('signTimes', 0)
6439            member_wobi = info.get('memberwobi', 0)
6440            member_trun = info.get('membertrun', 0)
6441            rights_num = info.get('rightsNum', '0')
6442            self.log(f"辽宁福利魔方: 沃币{wobi} | 累计签到{sign_times}天 | 会员碎片{member_wobi} | 等级{member_trun} | 权益{rights_num}次", notify=True)
6443        if is_query_only:
6444            return
6445        time.sleep(1)
6446        task_res = self.ln_flmf_api(sid, "taskList", "refresh=0&nowTask=")
6447        if task_res and task_res.get('resultCode') == '0000':
6448            groups = task_res.get('data', {}).get('taskInfoList', [])
6449            for group in groups:
6450                tasks = group.get('taskInfoList', [])
6451                for t in tasks:
6452                    status = "✅" if t.get('done', 0) > 0 else "⏳"
6453                    self.log(f"辽宁福利魔方: {status} {t.get('taskName')} ({t.get('done', 0)}/{t.get('count', 0)})")
6454
6455    def ah_friday_get_entry(self):
6456        """安徽超级星期五: 获取活动入口ticket"""
6457        try:
6458            entry_url = f"{AH_FRIDAY_BASE_URL}/wxopen/hh/activity/superFriday/index?chnlId=app-ty&type=02"
6459            ticket_res = self.openPlatLineNew(entry_url)
6460            if not ticket_res or not ticket_res.get('ticket'):
6461                self.log("安徽超级星期五: 获取入口ticket失败")
6462                return None
6463            ticket = ticket_res['ticket']
6464            mobile = getattr(self, 'account_mobile', getattr(self, 'mobile', ''))
6465            timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
6466            postage = hashlib.md5(f"{mobile}{timestamp}".encode()).hexdigest()
6467            page_url = f"{AH_FRIDAY_BASE_URL}/wxopen/hh/activity/superFriday/index"
6468            params = {
6469                "chnlId": "app-ty",
6470                "type": "02",
6471                "ticket": ticket,
6472                "version": COMMON_CONSTANTS["APP_VERSION"],
6473                "timestamp": timestamp,
6474                "desmobile": mobile,
6475                "num": "0",
6476                "postage": postage,
6477                "userNumber": mobile
6478            }
6479            headers = {
6480                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
6481                "User-Agent": COMMON_CONSTANTS["UA"],
6482            }
6483            res = self.session.get(page_url, params=params, headers=headers, timeout=15)
6484            act_ticket = res.cookies.get('ticket', '')
6485            if not act_ticket:
6486                for hist_resp in getattr(res, 'history', []):
6487                    ck = hist_resp.cookies.get('ticket', '')
6488                    if ck:
6489                        act_ticket = ck
6490                        break
6491                    sc = hist_resp.headers.get('Set-Cookie', '')
6492                    m = re.search(r'ticket=([^;,\s]+)', sc)
6493                    if m:
6494                        act_ticket = m.group(1)
6495                        break
6496            if not act_ticket:
6497                act_ticket = self.session.cookies.get('ticket', domain='') or self.session.cookies.get('ticket', '')
6498            if not act_ticket:
6499                cookie_header = res.headers.get('Set-Cookie', '')
6500                m = re.search(r'ticket=([^;,\s]+)', cookie_header)
6501                if m:
6502                    act_ticket = m.group(1)
6503            if not act_ticket:
6504                m = re.search(r'ticket[=:]\s*["\']?([a-zA-Z0-9_\-]{8,})', res.text)
6505                if m:
6506                    act_ticket = m.group(1)
6507            if not act_ticket:
6508                self.log(f"安徽超级星期五: 页面未返回独立ticket,使用入口ticket兜底")
6509                act_ticket = ticket
6510            self.log(f"安徽超级星期五: 获取活动ticket成功 ({act_ticket[:12]}...)")
6511            return {
6512                "ticket": act_ticket,
6513                "mobile": mobile,
6514                "timestamp": timestamp,
6515                "postage": postage,
6516                "app_ticket": ticket,
6517            }
6518        except Exception as e:
6519            self.log(f"安徽超级星期五: 获取入口异常 - {e}")
6520            return None
6521
6522    def ah_friday_get_items(self, entry_info):
6523        """安徽超级星期五: 获取奖品列表并匹配目标面额"""
6524        try:
6525            url = f"{AH_FRIDAY_BASE_URL}/wxopen/app-activity/AHSecKill/querySecKillInfo"
6526            headers = {
6527                "Accept": "application/json, text/plain, */*",
6528                "Content-Type": "application/json",
6529                "Origin": AH_FRIDAY_BASE_URL,
6530                "Cookie": f"ticket={entry_info['ticket']}",
6531                "User-Agent": COMMON_CONSTANTS["UA"],
6532            }
6533            res = self.session.post(url, json={}, headers=headers, timeout=10)
6534            result = res.json()
6535            if not result.get('success') and not result.get('data'):
6536                self.log(f"安徽超级星期五: 查询奖品列表失败 - {result.get('alertMsg', '未知')}")
6537                return None
6538            items = result.get('data', {}).get('itemList', [])
6539            if not items:
6540                items = result.get('data', []) if isinstance(result.get('data'), list) else []
6541            target_amount = str(AH_FRIDAY_AMOUNT)
6542            for item in items:
6543                item_code = item.get('itemCode', '')
6544                item_name = item.get('itemName', '')
6545                if target_amount in item_name or f"hb{target_amount}" in item_code:
6546                    key_val = item.get('key', '')
6547                    self.log(f"安徽超级星期五: 匹配到目标 [{item_name}] (code: {item_code})")
6548                    return {
6549                        "itemCode": item_code,
6550                        "itemName": item_name,
6551                        "key": key_val,
6552                    }
6553            item_code = f"AWARD_AHFridaySecKill_10_hb{target_amount}"
6554            self.log(f"安徽超级星期五: 未从列表匹配到{target_amount}元, 使用默认itemCode: {item_code}")
6555            return {"itemCode": item_code, "itemName": f"{target_amount}元红包", "key": ""}
6556        except Exception as e:
6557            self.log(f"安徽超级星期五: 查询奖品异常 - {e}")
6558            item_code = f"AWARD_AHFridaySecKill_10_hb{AH_FRIDAY_AMOUNT}"
6559            return {"itemCode": item_code, "itemName": f"{AH_FRIDAY_AMOUNT}元红包", "key": ""}
6560
6561    def ah_friday_seckill(self, entry_info, item_info):
6562        """安徽超级星期五: 批量抢购"""
6563        ticket = entry_info['ticket']
6564        item_code = item_info['itemCode']
6565        key_val = item_info.get('key', '')
6566        mobile = entry_info['mobile']
6567        timestamp_str = entry_info['timestamp']
6568        postage = entry_info['postage']
6569        referer = (
6570            f"{AH_FRIDAY_BASE_URL}/wxopen/hh/activity/superFriday/index"
6571            f"?chnlId=app-ty&type=02&ticket={entry_info['app_ticket']}"
6572            f"&version={COMMON_CONSTANTS['APP_VERSION']}&timestamp={timestamp_str}"
6573            f"&desmobile={mobile}&num=0&postage={postage}&userNumber={mobile}"
6574        )
6575        success_count = 0
6576        fail_count = 0
6577        self.log(f"安徽超级星期五: 开始批量抢购 [{item_info['itemName']}],共{AH_FRIDAY_SECKILL_TIMES}次")
6578        for i in range(1, AH_FRIDAY_SECKILL_TIMES + 1):
6579            try:
6580                ts = str(int(time.time() * 1000))
6581                params = {
6582                    "ticket": ticket,
6583                    "itemCode": item_code,
6584                    "time": ts,
6585                }
6586                if key_val:
6587                    params["key"] = key_val
6588                url = f"{AH_FRIDAY_BASE_URL}/wxopen/app-activity/AHSecKill/lotteryAction"
6589                headers = {
6590                    "Accept": "application/json, text/plain, */*",
6591                    "Content-Type": "application/json",
6592                    "Origin": AH_FRIDAY_BASE_URL,
6593                    "Referer": referer,
6594                    "Cookie": f"ticket={ticket}",
6595                    "User-Agent": COMMON_CONSTANTS["UA"],
6596                    "Connection": "keep-alive",
6597                }
6598                res = self.session.post(url, params=params, json={}, headers=headers, timeout=5)
6599                data = res.json()
6600                if data.get('success'):
6601                    success_count += 1
6602                    self.log(f"安徽超级星期五: 🎉 第{i}次抢购成功!{json.dumps(data, ensure_ascii=False)}", notify=True)
6603                    return True
6604                else:
6605                    fail_count += 1
6606                    alert = data.get('alertMsg', '')
6607                    if i <= 3 or i % 20 == 0:
6608                        self.log(f"安徽超级星期五: 第{i}次 - {alert or data.get('statusCode', '未知')}")
6609                    if "已抢完" in alert or "已结束" in alert or "已领取" in alert:
6610                        self.log(f"安徽超级星期五: ⚠️ {alert},停止抢购")
6611                        break
6612            except Exception as e:
6613                fail_count += 1
6614                if i <= 3:
6615                    self.log(f"安徽超级星期五: 第{i}次异常 - {e}")
6616            if i < AH_FRIDAY_SECKILL_TIMES:
6617                time.sleep(AH_FRIDAY_INTERVAL)
6618        self.log(f"安徽超级星期五: 抢购完成 (共{AH_FRIDAY_SECKILL_TIMES}次, 失败{fail_count}次)", notify=True)
6619        return False
6620
6621    def ah_friday_task(self):
6622        """安徽超级星期五: 主入口"""
6623        if not AH_FRIDAY_AMOUNT:
6624            return
6625        rc = globalConfig.get("regional_config", {})
6626        if not rc.get("run_ah_friday", True):
6627            self.log("安徽超级星期五: ⏭️ 已被子开关关闭,跳过")
6628            return
6629        weekday = datetime.now().weekday()
6630        if weekday != 4:
6631            self.log(f"安徽超级星期五: 今天不是周五 (当前周{weekday + 1}),跳过")
6632            return
6633        self.log(f"安徽超级星期五: 🎯 目标面额 {AH_FRIDAY_AMOUNT}元")
6634        entry_info = self.ah_friday_get_entry()
6635        if not entry_info:
6636            return
6637        item_info = self.ah_friday_get_items(entry_info)
6638        if not item_info:
6639            return
6640        now = datetime.now()
6641        target = now.replace(hour=10, minute=0, second=0, microsecond=0)
6642        wait_seconds = (target - now).total_seconds()
6643        if wait_seconds > 300:
6644            self.log(f"安徽超级星期五: ⏳ 距10:00还有 {wait_seconds:.0f}秒,大于5分钟,建议临近时启动")
6645            return
6646        if wait_seconds > 0:
6647            self.log(f"安徽超级星期五: ⏳ 等待开抢 (剩余 {wait_seconds:.1f}秒)...")
6648            while (datetime.now().replace(hour=10, minute=0, second=0, microsecond=0) - datetime.now()).total_seconds() > 0.3:
6649                time.sleep(0.1)
6650            self.log("安徽超级星期五: ⚡ 时间到!开始抢购!")
6651        else:
6652            self.log(f"安徽超级星期五: ⚡ 已过10点 {abs(wait_seconds):.1f}秒,直接抢购!")
6653        self.ah_friday_seckill(entry_info, item_info)
6654
6655    def woread_encrypt(self, data):
6656        try:
6657            key = b'woreadst^&*12345'
6658            iv = b'16-Bytes--String'
6659            cipher = AES.new(key, AES.MODE_CBC, iv)
6660            if isinstance(data, dict):
6661                data_str = json.dumps(data, separators=(',', ':'), ensure_ascii=False)
6662            else:
6663                data_str = str(data)
6664            pad_len = 16 - (len(data_str.encode('utf-8')) % 16)
6665            data_str = data_str + chr(pad_len) * pad_len
6666            ciphertext = cipher.encrypt(data_str.encode('utf-8'))
6667            hex_str = ciphertext.hex()
6668            return base64.b64encode(hex_str.encode('utf-8')).decode('utf-8')
6669        except Exception as e:
6670            self.log(f"woread_encrypt error: {e}")
6671            return ""
6672
6673    def woread_auth(self):
6674        try:
6675            product_id = "10000002"
6676            secret_key = "7k1HcDL8RKvc"
6677            timestamp = str(round(time.time() * 1000))
6678            sign_str = f"{product_id}{secret_key}{timestamp}"
6679            md5_hash = hashlib.md5(sign_str.encode('utf-8')).hexdigest()
6680            date_str = datetime.now().strftime('%Y%m%d%H%M%S')
6681            crypt_text_obj = {"timestamp": date_str}
6682            encoded_sign = self.woread_encrypt(crypt_text_obj)
6683            url = f"https://10010.woread.com.cn/ng_woread_service/rest/app/auth/{product_id}/{timestamp}/{md5_hash}"
6684            headers = {
6685                "Content-Type": "application/json",
6686                "User-Agent": COMMON_CONSTANTS['UA'],
6687            }
6688            res = self.session.post(url, json={"sign": encoded_sign}, headers=headers).json()
6689            if res.get('code') == "0000":
6690                self.woread_accesstoken = res.get('data', {}).get('accesstoken')
6691                return True
6692            else:
6693                self.log(f"阅读专区认证失败: {res.get('message')}")
6694                return False
6695        except Exception as e:
6696            self.log(f"woread_auth error: {e}")
6697            return False
6698
6699    def woread_login(self):
6700        try:
6701            if not hasattr(self, 'woread_accesstoken') or not self.woread_accesstoken:
6702                if not self.woread_auth():
6703                    return False
6704            if not self.token_online:
6705                self.log("阅读专区: 缺少 token_online,无法登录")
6706                return False
6707            token_enc = self.woread_encrypt(self.token_online)
6708            phone_str = self.account_mobile if self.account_mobile else "13800000000"
6709            phone_enc = self.woread_encrypt(phone_str)
6710            timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
6711            inner_json = json.dumps({
6712                "tokenOnline": token_enc,
6713                "phone": phone_enc,
6714                "timestamp": timestamp
6715            }, separators=(',', ':'), ensure_ascii=False)
6716            encoded_sign = self.woread_encrypt(inner_json)
6717            url = "https://10010.woread.com.cn/ng_woread_service/rest/account/login"
6718            headers = {
6719                "Content-Type": "application/json",
6720                "User-Agent": COMMON_CONSTANTS['UA'],
6721            }
6722            if hasattr(self, 'woread_accesstoken') and self.woread_accesstoken:
6723                headers["accesstoken"] = self.woread_accesstoken
6724            res = self.session.post(url, json={"sign": encoded_sign}, headers=headers, timeout=15).json()
6725            if res.get('code') == "0000":
6726                data = res.get('data', {})
6727                self.woread_token = data.get('token')
6728                self.woread_userid = data.get('userid')
6729                self.woread_userindex = data.get('userindex')
6730                self.woread_verifycode = data.get('verifycode')
6731                if data.get('phone'):
6732                    self.mobile = data['phone']
6733                self.log("阅读专区: 登录成功")
6734                return True
6735            else:
6736                self.log(f"阅读专区登录失败: {res.get('message')}")
6737                return False
6738        except Exception as e:
6739            self.log(f"woread_login error: {e}")
6740            return False
6741
6742    def woread_queryTicketAccount(self):
6743        try:
6744            if not hasattr(self, 'woread_token') or not self.woread_token:
6745                if not self.woread_login():
6746                     return
6747            timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
6748            params = {
6749                "timestamp": timestamp,
6750                "phone": self.mobile if self.mobile else "",
6751                "token": self.woread_token
6752            }
6753            sign = self.woread_encrypt(params)
6754            url = "https://10010.woread.com.cn/ng_woread_service/rest/phone/vouchers/queryTicketAccount"
6755            headers = {
6756                "Content-Type": "application/json",
6757                "User-Agent": COMMON_CONSTANTS['UA'],
6758            }
6759            if hasattr(self, 'woread_accesstoken') and self.woread_accesstoken:
6760                headers["accesstoken"] = self.woread_accesstoken
6761            res = self.session.post(url, json={"sign": sign}, headers=headers).json()
6762            if res.get('code') == "0000":
6763                data = res.get('data', {})
6764                usable_num = int(data.get('usableNum', 0))
6765                balance_yuan = "{:.2f}".format(usable_num / 100)
6766                self.log(f"💰 [资产-阅读红包] 余额: {balance_yuan}元", notify=True)
6767            else:
6768                self.log(f"阅读红包查询失败: {res.get('message')}")
6769        except Exception as e:
6770            self.log(f"woread_queryTicketAccount error: {e}")
6771
6772
6773    def woread_get_book_info(self):
6774        try:
6775            url1 = "https://10010.woread.com.cn/ng_woread_service/rest/basics/recommposdetail/14856"
6776            headers = {
6777                "User-Agent": COMMON_CONSTANTS['UA'],
6778                "accesstoken": self.woread_accesstoken
6779            }
6780            res1 = self.session.get(url1, headers=headers)
6781            try:
6782                res1 = res1.json()
6783            except:
6784                self.log(f"阅读专区: 获取书架响应非JSON: {res1.text[:100]}")
6785                return False
6786            if res1.get('code') == '0000':
6787                msg_list = res1.get('data', {}).get('booklist', {}).get('message', [])
6788                if msg_list:
6789                    self.wr_catid = msg_list[0].get('catindex')
6790                    self.wr_cntindex = msg_list[0].get('cntindex')
6791                bind_info = res1.get('data', {}).get('bindinfo', [])
6792                if bind_info:
6793                    self.wr_cardid = bind_info[0].get('recommposiindex')
6794            else:
6795                self.log("阅读专区: 获取书架失败")
6796                return False
6797            if not getattr(self, 'wr_cntindex', None): return False
6798            timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
6799            param = {
6800                "curPage": 1, "limit": 30, "index": self.wr_cntindex, "sort": 0, "finishFlag": 1,
6801                "timestamp": timestamp,
6802                "phone": self.mobile if self.mobile else "",
6803                "token": getattr(self, 'woread_token', ''),
6804                "userid": getattr(self, 'woread_userid', ''),
6805                "userId": getattr(self, 'woread_userid', ''),
6806                "userIndex": getattr(self, 'woread_userindex', ''),
6807                "verifyCode": getattr(self, 'woread_verifycode', '')
6808            }
6809            sign = self.woread_encrypt(param)
6810            url2 = "https://10010.woread.com.cn/ng_woread_service/rest/cnt/chalist"
6811            res2_raw = self.session.post(url2, json={"sign": sign}, headers=headers)
6812            try:
6813                res2 = res2_raw.json()
6814            except:
6815                self.log(f"阅读专区: 获取章节响应非JSON: {res2_raw.text[:100]}")
6816                return False
6817            lst = res2.get('list', []) or res2.get('data', {}).get('list', [])
6818            if lst:
6819                content = lst[0].get('charptercontent', [])
6820                if content:
6821                    self.wr_chapterallindex = content[0].get('chapterallindex')
6822                    self.wr_chapterid = content[0].get('chapterid')
6823                    return True
6824            return False
6825        except Exception as e:
6826            self.log(f"阅读专区: 获取书籍信息异常: {e}")
6827            return False
6828
6829    def woread_read_process(self):
6830        if not self.woread_get_book_info():
6831            self.log("阅读专区: 无法获取书籍信息,跳过阅读")
6832            return
6833        headers = {
6834                "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0301}",
6835                "accesstoken": self.woread_accesstoken
6836        }
6837        timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
6838        phone = self.mobile if self.mobile else ""
6839        token = getattr(self, 'woread_token', '')
6840        userid = getattr(self, 'woread_userid', '')
6841        userindex = getattr(self, 'woread_userindex', '')
6842        verifycode = getattr(self, 'woread_verifycode', '')
6843        common_params = {
6844            "timestamp": timestamp,
6845            "phone": phone,
6846            "token": token,
6847            "userid": userid,
6848            "userId": userid,
6849            "userIndex": userindex,
6850            "userAccount": phone,
6851            "verifyCode": verifycode
6852        }
6853        param = {
6854          "chapterAllIndex": self.wr_chapterallindex,
6855          "cntIndex": self.wr_cntindex,
6856          "cntTypeFlag": "1",
6857          **common_params
6858        }
6859        sign = self.woread_encrypt(param)
6860        hb_url = f"https://10010.woread.com.cn/ng_woread_service/rest/cnt/wordsDetail?catid={self.wr_catid}&cardid={self.wr_cardid}&cntindex={self.wr_cntindex}&chapterallindex={self.wr_chapterallindex}&chapterseno=1"
6861        self.session.post(hb_url, json={"sign": sign}, headers=headers)
6862        add_param = {
6863          "readTime": "2",
6864          "cntIndex": self.wr_cntindex,
6865          "cntType": "1",
6866          "catid": "0",
6867          "pageIndex": "",
6868          "cardid": self.wr_cardid,
6869          "cntindex": self.wr_cntindex,
6870          "cnttype": "1",
6871          "chapterallindex": self.wr_chapterallindex,
6872          "chapterseno": "1",
6873          "channelid": "",
6874          "chapterid": self.wr_chapterid,
6875          "readtype": 1,
6876          "isend": "0",
6877          **common_params
6878        }
6879        add_sign = self.woread_encrypt(add_param)
6880        add_url = "https://10010.woread.com.cn/ng_woread_service/rest/history/addReadTime"
6881        res = self.session.post(add_url, json={"sign": add_sign}, headers=headers).json()
6882        res_code = str(res.get('code', ''))
6883        res_msg = str(res.get('message', ''))
6884        if res_code == '0000':
6885            self.log("阅读专区: 模拟阅读成功")
6886        elif res_code == '9999' or '9999' in res_msg or '不存在阅读记录' in res_msg:
6887            # addReadTime 返回9999不影响实际阅读结果
6888            self.log("阅读专区: 模拟阅读成功(阅读记录已提交)")
6889        else:
6890             self.log(f"阅读专区: 模拟阅读失败: {res_msg or res}")
6891
6892
6893
6894    def woread_draw_new(self):
6895        try:
6896             headers = {
6897                "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 unicom{version:iphone_c@12.0301}",
6898                "accesstoken": self.woread_accesstoken
6899             }
6900             timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
6901             param = {
6902                "activeindex": "8051",
6903                "timestamp": timestamp, "phone": self.mobile if self.mobile else "", "token": self.woread_token
6904             }
6905             sign = self.woread_encrypt(param)
6906             url = "https://10010.woread.com.cn/ng_woread_service/rest/basics/doDraw"
6907             res = self.session.post(url, json={"sign": sign}, headers=headers).json()
6908             if res.get('code') == '0000':
6909                 prize = res.get('data', {}).get('prizedesc')
6910                 if prize:
6911                     self.log(f"阅读专区: 抽奖成功: {prize}", notify=True)
6912                 else:
6913                     self.log("阅读专区: 抽奖完成 (未中奖)")
6914             else:
6915                 self.log(f"阅读专区: 抽奖失败: {res.get('message')}")
6916        except Exception as e:
6917            self.log(f"woread_draw_new error: {e}")
6918
6919    def woread_task(self):
6920        self.log("==== 联通阅读 ====")
6921        if not self.woread_login():
6922             self.log("阅读专区: 登录失败,跳过任务")
6923             return
6924        self.woread_queryTicketAccount()
6925        self.woread_read_process()
6926        time.sleep(3)
6927        self.woread_draw_new()
6928
6929    def query_market_raffle_records(self, user_token):
6930        self.log("权益超市: 正在查询抽奖记录...")
6931        try:
6932            url = "https://backward.bol.wo.cn/prod-api/market/contactReceive/queryReceiveRecord"
6933            headers = {
6934                "Authorization": f"Bearer {user_token}",
6935                "User-Agent": COMMON_CONSTANTS["MARKET_UA"],
6936                "Origin": "https://contact.bol.wo.cn",
6937                "Referer": "https://contact.bol.wo.cn/"
6938            }
6939            mobile = getattr(self, "account_mobile", getattr(self, "mobile", ""))
6940            payload = {
6941                "isReceive": None,
6942                "receiveStatus": None,
6943                "limit": 20,
6944                "page": 1,
6945                "mobile": mobile,
6946                "businessSources": ["3", "4", "5", "6", "99"],
6947                "isPromotion": 1,
6948                "returnFormatType": 1
6949            }
6950            res = self.session.post(url, json=payload, headers=headers).json()
6951            if res.get('code') == 200:
6952                records = res.get('data', {}).get('recordObjs', [])
6953                if records:
6954                    display_records = records[:10]
6955                    self.log(f"权益超市: 最近 {len(display_records)} 条抽奖记录:", notify=True)
6956                    for item in display_records:
6957                        self.log(f"    - [{item.get('receiveTime') or ''}] {item.get('recordName')}", notify=True)
6958                else:
6959                    self.log("权益超市: 无近期抽奖记录。")
6960            else:
6961                self.log(f"权益超市: 查询抽奖记录失败: {res.get('msg')}")
6962        except Exception as e:
6963            self.log(f"query_market_raffle_records error: {e}")
6964
6965    def query_phone_recharge_records(self, user_token):
6966        self.log("权益超市: 正在查询本月话费抢购记录...")
6967        try:
6968            url = "https://backward.bol.wo.cn/prod-api/market/contactReceive/queryReceiveRecord"
6969            headers = {
6970                "Authorization": f"Bearer {user_token}",
6971                "User-Agent": COMMON_CONSTANTS["MARKET_UA"],
6972                "Origin": "https://contact.bol.wo.cn",
6973                "Referer": "https://contact.bol.wo.cn/"
6974            }
6975            mobile = getattr(self, "account_mobile", getattr(self, "mobile", ""))
6976            payload = {
6977                "isReceive": None,
6978                "receiveStatus": None,
6979                "limit": 50,
6980                "page": 1,
6981                "mobile": mobile,
6982                "businessSources": ["3", "4", "5", "6", "99"],
6983                "isPromotion": 1,
6984                "returnFormatType": 1
6985            }
6986            res = self.session.post(url, json=payload, headers=headers).json()
6987            if res.get('code') == 200:
6988                records = res.get('data', {}).get('recordObjs', [])
6989                total_amount = 0.0
6990                current_month = datetime.now().strftime('%Y-%m')
6991                count = 0
6992                for item in records:
6993                    create_time = item.get('receiveTime') or ''
6994                    name = item.get('recordName', '')
6995                    if not create_time or current_month not in create_time:
6996                        continue
6997                    if any(k in name for k in ['话费', '充值', '红包']):
6998                        match = re.search(r'(\d+(\.\d+)?)元', name)
6999                        if match:
7000                            amount = float(match.group(1))
7001                            total_amount += amount
7002                            count += 1
7003                if count > 0:
7004                     self.log(f"💰 [资产-抢购] 本月权益超市话费累计: {total_amount:.2f}元", notify=True)
7005                else:
7006                     self.log("权益超市: 本月暂无话费抢购记录")
7007            else:
7008                self.log(f"权益超市: 查询话费记录失败: {res.get('msg')}")
7009        except Exception as e:
7010            self.log(f"query_phone_recharge_records error: {e}")
7011
7012    def sign_query_my_prizes(self):
7013        self.log("正在查询账户明细 (抢兑)...")
7014        try:
7015            url = "https://act.10010.com/SigninApp/convert/phoneDetails"
7016            form = {
7017                "log_type": "1",
7018                "number": "1",
7019                "list_num": ""
7020            }
7021            headers = {"Origin": "https://img.client.10010.com"}
7022            res = self.request("post", url, data=form, headers=headers)
7023            if not res: return
7024            result = res.json()
7025            if result.get('status') == '0000':
7026                data = result.get('data', {}).get('detailedBO', [])
7027                if data and isinstance(data, list):
7028                     logged_count = 0
7029                     for item in data:
7030                         if logged_count >= 5: break
7031                         remark = item.get('remark', '')
7032                         buss_name = item.get('from_bussname', '')
7033                         if "兑换" in remark or "兑换" in buss_name:
7034                             if logged_count == 0:
7035                                 self.log(f"📋 [账户明细] 最近 5 条记录:", notify=True)
7036                             order_time = item.get('order_time', '')
7037                             amount = item.get('booksNumber') or item.get('books_number') or "0"
7038                             self.log(f"   🎁 [抢兑] {order_time} | {remark} (变动:{amount})", notify=True)
7039                             logged_count += 1
7040                     if logged_count == 0:
7041                         self.log("[账户明细] 暂无兑换记录")
7042                else:
7043                    self.log("[账户明细] 暂无兑换记录")
7044            else:
7045                self.log(f"[账户明细] 查询异常: {result.get('msg', 'Result Error')}")
7046        except Exception as e:
7047            self.log(f"sign_query_my_prizes error: {e}")
7048
7049    def sign_task_main(self):
7050        self.log("==== 签到区 ====")
7051        self.sign_getTelephone(is_initial=True)
7052        self.sign_getContinuous(is_query_only=False)
7053        self.sign_month_sign_gift()
7054        self.sign_getTaskList()
7055        sc = globalConfig.get("sign_config", {})
7056        if sc.get("run_grab_coupon", False):
7057            self.sign_grabCoupon()
7058        else:
7059            self.log("签到区-抢话费券: ⏭️ 已被子开关关闭,跳过")
7060        self.sign_getTelephone()
7061        self.sign_query_my_prizes()
7062
7063    def execute_daily_tasks(self, query_only=False):
7064        if query_only:
7065            self.log("📋 [查询模式] 仅查询资产,跳过任务执行", notify=True)
7066            try:
7067                self.queryRemain()
7068                if globalConfig.get("enable_sign", True):
7069                    try:
7070                        self.sign_getContinuous(is_query_only=True)
7071                        self.sign_month_sign_gift(is_query_only=True)
7072                        self.sign_getTelephone()
7073                    except Exception as e:
7074                        self.log(f"首页签到查询异常: {e}")
7075                    try:
7076                        self.sign_query_my_prizes()
7077                    except Exception as e:
7078                        self.log(f"抢兑记录查询异常: {e}")
7079                if globalConfig.get("enable_ttlxj", True):
7080                    try:
7081                        self.ttlxj_task(is_query_only=True)
7082                    except Exception as e:
7083                        self.log(f"天天领现金查询异常: {e}")
7084                if globalConfig.get("enable_ttxc", True):
7085                    try:
7086                        self.ttxc_task(is_query_only=True)
7087                    except Exception as e:
7088                        self.log(f"通通乡村查询异常: {e}")
7089                if globalConfig.get("enable_market", True):
7090                    try:
7091                        self.market_task(is_query_only=True)
7092                    except Exception as e:
7093                        self.log(f"权益超市查询异常: {e}")
7094                if globalConfig.get("enable_woread", True):
7095                    try:
7096                        self.woread_queryTicketAccount()
7097                    except Exception as e:
7098                        self.log(f"联通阅读查询异常: {e}")
7099                if globalConfig.get("enable_aiting", True):
7100                    try:
7101                        self.aiting_task(is_query_only=True)
7102                    except Exception as e:
7103                        self.log(f"联通爱听查询异常: {e}")
7104                if globalConfig.get("enable_security", True):
7105                    try:
7106                        self.securityButlerTask(is_query_only=True)
7107                    except Exception as e:
7108                        self.log(f"安全管家查询异常: {e}")
7109                if globalConfig.get("enable_ltyp", True):
7110                    try:
7111                        self.ltyp_task(is_query_only=True)
7112                    except Exception as e:
7113                        self.log(f"联通云盘查询异常: {e}")
7114                if globalConfig.get("enable_wostore", True):
7115                    try:
7116                        self.wostore_cloud_task(is_query_only=True)
7117                    except Exception as e:
7118                        self.log(f"沃云手机查询异常: {e}")
7119                if globalConfig.get("enable_regional", True):
7120                    try:
7121                        self.regional_task(is_query_only=True)
7122                    except Exception as e:
7123                        pass
7124            except Exception as e:
7125                self.log(f"查询异常: {e}")
7126            return
7127        if globalConfig.get("enable_sign", True):
7128            self.sign_task_main()
7129        else:
7130            self.log("==== 签到区 ====")
7131            self.log("⏭️ 已被总开关关闭,跳过")
7132        if globalConfig.get("enable_ltzf", True):
7133            self.ltzf_task()
7134        else:
7135            self.log("==== 联通祝福 ====")
7136            self.log("⏭️ 已被总开关关闭,跳过")
7137        if globalConfig.get("enable_ttlxj", True):
7138            self.ttlxj_task()
7139        else:
7140            self.log("==== 天天领现金 ====")
7141            self.log("⏭️ 已被总开关关闭,跳过")
7142        if globalConfig.get("enable_ttxc", True):
7143            self.ttxc_task()
7144        else:
7145            self.log("==== 通通乡村 ====")
7146            self.log("⏭️ 已被总开关关闭,跳过")
7147        if globalConfig.get("enable_market", True):
7148            self.market_task()
7149        else:
7150            self.log("==== 权益超市 ====")
7151            self.log("⏭️ 已被总开关关闭,跳过")
7152        if globalConfig.get("enable_woread", True):
7153            self.woread_task()
7154        else:
7155            self.log("==== 联通阅读 ====")
7156            self.log("⏭️ 已被总开关关闭,跳过")
7157        need_cooldown = globalConfig.get("enable_woread", True) and globalConfig.get("enable_aiting", True)
7158        if need_cooldown:
7159            self.log("⏳ 等待120秒(阅读冷却:联通限制两次阅读间隔2分钟)...")
7160            time.sleep(120)
7161        if globalConfig.get("enable_aiting", True):
7162            self.aiting_task()
7163        else:
7164            self.log("==== 联通爱听 ====")
7165            self.log("⏭️ 已被总开关关闭,跳过")
7166        if globalConfig.get("enable_security", True):
7167            self.securityButlerTask()
7168        else:
7169            self.log("==== 安全管家 ====")
7170            self.log("⏭️ 已被总开关关闭,跳过")
7171        if globalConfig.get("enable_ltyp", True):
7172            self.ltyp_task()
7173        else:
7174            self.log("==== 联通云盘 ====")
7175            self.log("⏭️ 已被总开关关闭,跳过")
7176        if globalConfig.get("enable_wostore", True):
7177            self.wostore_cloud_task()
7178        else:
7179            self.log("==== 沃云手机 ====")
7180            self.log("⏭️ 已被总开关关闭,跳过")
7181        if globalConfig.get("enable_regional", True):
7182            self.regional_task()
7183        else:
7184            self.log("==== 区域专区 ====")
7185            self.log("⏭️ 已被总开关关闭,跳过")
7186
7187def cross_view_security_share_keys(users):
7188    participants = [
7189        u for u in users
7190        if getattr(u, "sec_ai_share_key", "") and getattr(u, "sec_token", "") and getattr(u, "sec_share_task_code", "")
7191    ]
7192    if not participants:
7193        return
7194    if len(participants) < 2:
7195        participants[0].log("联通助理-分享AI助手对话:仅 1 个账号拿到分享key,跳过跨账号互看")
7196        return
7197    print("")
7198    print("========= 联通助理-开始跨账号查看AI分享对话 =========")
7199    n = len(participants)
7200    for i, viewer in enumerate(participants):
7201        target = participants[(i + 1) % n]
7202        viewer.log(f"联通助理-分享AI助手对话:查看账号[{target.index}]分享")
7203        try:
7204            viewer.sec_view_share_detail(target.sec_ai_share_key, viewer.sec_token)
7205        except Exception as e:
7206            viewer.log(f"联通助理-分享AI助手对话:互看异常 {e}")
7207        time.sleep(2)
7208    for u in participants:
7209        try:
7210            u.sec_refresh_security_context(refresh_secret=True)
7211            u.sec_finalize_share_ai_task()
7212            u.sec_recover_pending_claims(rounds=2, delay=6, refresh_context=True)
7213        except Exception as e:
7214            u.log(f"联通助理-分享AI助手对话:互看后领奖异常 {e}")
7215
7216def do_notify(users):
7217    if not globalConfig.get("enable_notify", True):
7218        print("推送通知已关闭")
7219        return
7220    notify_content = []
7221    for u in users:
7222        if u.notify_logs:
7223            phone = u.mobile or u.account_mobile
7224            phone_str = mask_str(phone) if phone else ""
7225            notify_content.append(f"【账号{u.index}】{phone_str}")
7226            notify_content.extend(u.notify_logs)
7227            notify_content.append("")
7228    if notify_content:
7229        content = "\n".join(notify_content)
7230        try:
7231            from notify import send
7232            send(f"中国联通 {SCRIPT_VERSION}", content)
7233            print(f"推送成功 (内容长度: {len(content)})")
7234        except Exception as e:
7235            print(f"推送失败,可能未配置 notify.py: {str(e)}")
7236    else:
7237        print("无推送内容")
7238
7239def main():
7240    global GRAB_AMOUNT
7241    print(f"[{datetime.now().strftime('%H:%M:%S')}] [Script Start] chinaUnicom Python {SCRIPT_VERSION}")
7242    cookies = os.environ.get("chinaUnicomCookie", "")
7243    if not cookies:
7244        print("[-] 未在环境变量 chinaUnicomCookie 中找到配置")
7245        sys.exit(1)
7246    accounts = [c for c in re.split(r'[&\n]', cookies) if c.strip()]
7247    print(f"[{datetime.now().strftime('%H:%M:%S')}] 发现 {len(accounts)} 个账号")
7248    print("")
7249    users = []
7250    for idx, config in enumerate(accounts):
7251        u = UserService(idx + 1, config.strip())
7252        users.append(u)
7253        if u.appId:
7254             print(f"账号[{idx+1}] 识别到 Token#AppId 模式,使用自定义AppId: {u.appId}")
7255        elif u.account_mobile:
7256             print(f"账号[{idx+1}] 识别到账号密码模式: {mask_str(u.account_mobile)}")
7257        try:
7258            if u.token_online:
7259                u.get_city_info()
7260        except: pass
7261    print(f"共找到{len(accounts)}个账号")
7262    print("")
7263    env_amount = os.environ.get("UNICOM_GRAB_AMOUNT", "")
7264    if env_amount and env_amount.isdigit():
7265        GRAB_AMOUNT = int(env_amount)
7266    query_only = os.environ.get("UNICOM_TEST_MODE", "").strip().lower() == "query"
7267    if query_only:
7268        print("[Test Mode] 仅查询模式,跳过任务执行")
7269    sc = globalConfig.get("sign_config", {})
7270    mc = globalConfig.get("market_config", {})
7271    rc = globalConfig.get("regional_config", {})
7272    grab_mode = False
7273    ah_friday_grab = False
7274    hour = datetime.now().hour
7275    current_min = datetime.now().minute
7276    is_friday = datetime.now().weekday() == 4
7277    if not query_only:
7278        if sc.get("run_grab_coupon", False) and globalConfig.get("enable_sign", True):
7279            if hour in [9, 17] and (58 <= current_min <= 59):
7280                grab_mode = True
7281        if (AH_FRIDAY_AMOUNT and is_friday and rc.get("run_ah_friday", True)
7282                and globalConfig.get("enable_regional", True)
7283                and hour == 9 and (58 <= current_min <= 59)):
7284            ah_friday_grab = True
7285            grab_mode = True
7286    print("-" * 36)
7287    switch_map = [
7288        ("enable_sign",     "首页签到"),
7289        ("enable_ltzf",     "联通祝福"),
7290        ("enable_ttlxj",    "天天领现金"),
7291        ("enable_ttxc",     "通通乡村"),
7292        ("enable_market",   "权益超市"),
7293        ("enable_woread",   "联通阅读"),
7294        ("enable_aiting",   "联通爱听"),
7295        ("enable_security", "安全管家"),
7296        ("enable_ltyp",     "联通云盘"),
7297        ("enable_wostore",  "沃云手机"),
7298        ("enable_regional", "区域专区"),
7299    ]
7300    for key, label in switch_map:
7301        enabled = globalConfig.get(key, True)
7302        if grab_mode:
7303            if key == "enable_sign" and sc.get("run_grab_coupon", False):
7304                status = "运行(仅抢兑)"
7305            elif key == "enable_regional" and ah_friday_grab:
7306                status = "运行(安徽抢红包)"
7307            else:
7308                status = "跳过(抢兑模式)"
7309        elif query_only:
7310            status = "仅查询" if enabled else "关闭"
7311        else:
7312            status = "运行" if enabled else "关闭"
7313        print(f"{label}设置为: {status}")
7314        if key == "enable_sign" and enabled and not query_only:
7315            print(f"  └─ 抢话费券: {'开启' if sc.get('run_grab_coupon', False) else '关闭'}")
7316        if key == "enable_regional" and enabled and not query_only:
7317            ah_status = "开启" if rc.get("run_ah_friday", True) and AH_FRIDAY_AMOUNT else "关闭"
7318            print(f"  └─ 安徽超级星期五: {ah_status}" + (f" (面额{AH_FRIDAY_AMOUNT}元)" if AH_FRIDAY_AMOUNT else ""))
7319        if key == "enable_market" and enabled and not query_only and not grab_mode:
7320            print(f"  └─ 做任务: {'开启' if mc.get('run_task', True) else '关闭'}")
7321            print(f"  └─ 抽奖: {'开启' if mc.get('run_draw', True) else '关闭'}")
7322            print(f"  └─ 自动领奖: {'开启' if mc.get('run_claim', False) else '关闭'}")
7323    print(f"推送通知设置为: {'开启' if globalConfig.get('enable_notify', True) else '关闭'}")
7324    print(f"设备ID刷新: {'强制刷新' if globalConfig.get('refresh_device_id', False) else '使用缓存'}")
7325    print("-" * 36)
7326    print("")
7327    if grab_mode:
7328        print(f"⏰ [自动触发] 检测到抢兑时间点 ({hour}:{current_min:02d}),进入并发抢兑模式")
7329        tasks_desc = []
7330        if sc.get("run_grab_coupon", False) and globalConfig.get("enable_sign", True):
7331            tasks_desc.append(f"{GRAB_AMOUNT}元话费券")
7332        if ah_friday_grab:
7333            tasks_desc.append(f"安徽{AH_FRIDAY_AMOUNT}元红包")
7334        print(f"🚨🚨🚨 [抢兑模式已启动] 目标: {' + '.join(tasks_desc)} 🚨🚨🚨")
7335        print("")
7336        from concurrent.futures import ThreadPoolExecutor
7337
7338        def run_grab_task(u):
7339            u.configure_proxy()
7340            if u.ensure_login():
7341                sub_futures = []
7342                with ThreadPoolExecutor(max_workers=2) as sub_executor:
7343                    if sc.get("run_grab_coupon", False) and globalConfig.get("enable_sign", True):
7344                        sub_futures.append(sub_executor.submit(u.sign_grabCoupon))
7345                    if ah_friday_grab:
7346                        sub_futures.append(sub_executor.submit(u.ah_friday_task))
7347                    for f in sub_futures:
7348                        try:
7349                            f.result()
7350                        except Exception as e:
7351                            u.log(f"抢兑子任务异常: {e}")
7352            else:
7353                u.log("登录流程失败,跳过该账号")
7354
7355        print(f"🚀 [并发模式] 启动 {len(accounts)} 个账号同时抢兑...")
7356        with ThreadPoolExecutor(max_workers=len(accounts)) as executor:
7357            futures = [executor.submit(run_grab_task, u) for u in users]
7358            for future in futures:
7359                try:
7360                    future.result()
7361                except Exception as e:
7362                    print(f"[-] Thread Error: {e}")
7363        do_notify(users)
7364        return
7365    print("🚀 开始串行执行日常任务...")
7366    print("")
7367    for u in users:
7368        print("")
7369        print(f"🔄 正在初始化账号[{u.index}]...")
7370        u.configure_proxy()
7371        if u.ensure_login():
7372             print("")
7373             print(f"------------------ 账号[{u.index}][{mask_str(u.account_mobile)}] ------------------")
7374             print("")
7375             u.execute_daily_tasks(query_only=query_only)
7376             print("⏳ 账号处理完毕,等待 2 秒...")
7377             time.sleep(2)
7378        else:
7379             u.log("登录流程失败,跳过该账号")
7380    cross_view_security_share_keys(users)
7381    do_notify(users)
7382if __name__ == "__main__":
7383    main()
7384
7385
7386

提示下载与运行前务必自行通读源码,警惕可疑外联与凭证窃取。