#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 🎯 Bing Rewards 自动化脚本 - 多账号分离版-v2.1 变量名： bing_ck_1、bing_ck_2、bing_ck_3、bing_ck_4... （必需） bing_token_1、bing_token_2、bing_token_3、bing_token_4... （可选，用于阅读任务） 下面url抓取CK，必须抓取到 tifacfaatcs 和认证字段，否则cookie无效 1. 登录 https://cn.bing.com/ 2. 点右侧的【查看仪表板】,会跳转到 https://rewards.bing.com/?ref=rewardspanel 3. 确认两个地址登录的是同一个账号，抓CK Cookie验证规则： - tifacfaatcs: 影响账号信息获取（必需） - 认证字段: 影响搜索任务是否加分（必须包含 .MSA.Auth） - 以上字段缺失会导致cookie无效 🔑 阅读任务需要配置刷新令牌： 1. 安装"Bing Rewards 自动获取刷新令牌"油猴脚本 2. 访问 https://login.live.com/oauth20_authorize.srf?client_id=0000000040170455&scope=service::prod.rewardsplatform.microsoft.com::MBI_SSL&response_type=code&redirect_uri=https://login.live.com/oauth20_desktop.srf 3. 登录后，使用"Bing Rewards 自动获取刷新令牌"油猴脚本，自动获取刷新令牌 4. 设置环境变量 bing_token_1、bing_token_2、bing_token_3... From:yaohuo28507 cron: 10 0-22 * * * """ import requests import random import re import time import json import os from datetime import datetime, date from urllib.parse import urlparse, parse_qs, quote import threading from typing import Dict, List, Optional, Tuple, Any from dataclasses import dataclass from functools import wraps import traceback # ==================== 用户配置区域 ==================== # 在这里修改您的配置参数 # # 📝 配置说明： # 1. 推送配置：设置Telegram和企业微信推送参数 # 2. 任务执行配置：调整搜索延迟、重试次数等执行参数 # 3. 缓存配置：设置缓存文件相关参数 # # 💡 修改建议： # - 搜索延迟建议保持在25-35秒之间，避免过于频繁 # - 任务延迟建议保持在2-4秒之间，给系统响应时间 # - 重试次数建议不超过5次，避免过度重试 # - 请求超时建议15-30秒，根据网络情况调整 # - 重复运行次数建议3-5次，避免过度重复执行 # 任务执行配置 TASK_CONFIG = { 'SEARCH_CHECK_INTERVAL': 5, # 搜索检查间隔次数 'SEARCH_DELAY_MIN': 25, # 搜索延迟最小值（秒） 'SEARCH_DELAY_MAX': 35, # 搜索延迟最大值（秒） 'TASK_DELAY_MIN': 2, # 任务延迟最小值（秒） 'TASK_DELAY_MAX': 4, # 任务延迟最大值（秒） 'MAX_RETRIES': 3, # 最大重试次数 'RETRY_DELAY': 2, # 重试延迟（秒） 'REQUEST_TIMEOUT': 15, # 请求超时时间（秒） 'HOT_WORDS_MAX_COUNT': 30, # 热搜词最大数量 'MAX_REPEAT_COUNT': 3, # 最大重复运行次数 } # 缓存配置 CACHE_CONFIG = { 'CACHE_FILE': "bing_cache.json", # 缓存文件名 'CACHE_ENABLED': True, # 是否启用缓存 } # 使用缓存配置 CACHE_ENABLED = CACHE_CONFIG['CACHE_ENABLED'] # ==================== 配置管理 ==================== @dataclass class Config: """配置类，统一管理所有配置项""" # 搜索配置 SEARCH_CHECK_INTERVAL: int = TASK_CONFIG['SEARCH_CHECK_INTERVAL'] SEARCH_DELAY_MIN: int = TASK_CONFIG['SEARCH_DELAY_MIN'] SEARCH_DELAY_MAX: int = TASK_CONFIG['SEARCH_DELAY_MAX'] TASK_DELAY_MIN: int = TASK_CONFIG['TASK_DELAY_MIN'] TASK_DELAY_MAX: int = TASK_CONFIG['TASK_DELAY_MAX'] # 重试配置 MAX_RETRIES: int = TASK_CONFIG['MAX_RETRIES'] RETRY_DELAY: int = TASK_CONFIG['RETRY_DELAY'] # 文件配置 CACHE_FILE: str = CACHE_CONFIG['CACHE_FILE'] # API配置 REQUEST_TIMEOUT: int = TASK_CONFIG['REQUEST_TIMEOUT'] HOT_WORDS_MAX_COUNT: int = TASK_CONFIG['HOT_WORDS_MAX_COUNT'] # User-Agent池配置 PC_USER_AGENTS: List[str] = None MOBILE_USER_AGENTS: List[str] = None # 热搜API配置 HOT_WORDS_APIS: List[Tuple[str, List[str]]] = None DEFAULT_HOT_WORDS: List[str] = None def __post_init__(self): if self.HOT_WORDS_APIS is None: self.HOT_WORDS_APIS = [ ("https://dailyapi.eray.cc/", ["weibo", "douyin", "baidu", "toutiao", "thepaper", "qq-news", "netease-news", "zhihu"]), ("https://hot.baiwumm.com/api/", ["weibo", "douyin", "baidu", "toutiao", "thepaper", "qq", "netease", "zhihu"]), ("https://cnxiaobai.com/DailyHotApi/", ["weibo", "douyin", "baidu", "toutiao", "thepaper", "qq-news", "netease-news", "zhihu"]), ("https://hotapi.nntool.cc/", ["weibo", "douyin", "baidu", "toutiao", "thepaper", "qq-news", "netease-news", "zhihu"]), ] if self.DEFAULT_HOT_WORDS is None: self.DEFAULT_HOT_WORDS = [ "盛年不重来，一日难再晨", "千里之行，始于足下", "少年易学老难成，一寸光阴不可轻", "敏而好学，不耻下问", "海内存知已，天涯若比邻", "三人行，必有我师焉", "莫愁前路无知已，天下谁人不识君", "人生贵相知，何用金与钱", "天生我材必有用", '海纳百川有容乃大；壁立千仞无欲则刚', "穷则独善其身，达则兼济天下", "读书破万卷，下笔如有神", ] if self.PC_USER_AGENTS is None: self.PC_USER_AGENTS = [ "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Edg/124.0.2478.131", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.2210.181", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0", ] if self.MOBILE_USER_AGENTS is None: self.MOBILE_USER_AGENTS = [ "Mozilla/5.0 (Linux; Android 14; 2210132C Build/UP1A.231005.007) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.6422.52 Mobile Safari/537.36 EdgA/125.0.2535.51", "Mozilla/5.0 (iPad; CPU OS 16_7_8 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) EdgiOS/120.0.2210.150 Version/16.0 Mobile/15E148 Safari/604.1", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) EdgiOS/123.0.2420.108 Version/18.0 Mobile/15E148 Safari/604.1", "Mozilla/5.0 (Linux; Android 12; Pixel 6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.6367.44 Mobile Safari/537.36 EdgA/124.0.2478.49", "Mozilla/5.0 (Linux; Android 14; Mi 10) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.6312.40 Mobile Safari/537.36 EdgA/123.0.2420.65", "Mozilla/5.0 (Linux; Android 9; ONEPLUS A5000 Build/PKQ1.180716.001; ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Mobile Safari/537.36 BingSapphire/32.2.430730002", ] @staticmethod def generate_random_tnTID() -> str: """生成随机的tnTID参数""" # 生成32位随机十六进制字符串 import secrets random_hex = secrets.token_hex(16).upper() return f"DSBOS_{random_hex}" @staticmethod def generate_random_tnCol() -> str: """生成1-50之间的随机数字""" return str(random.randint(1, 50)) @staticmethod def get_random_pc_ua() -> str: """获取随机PC端User-Agent""" return random.choice(config.PC_USER_AGENTS) @staticmethod def get_random_mobile_ua() -> str: """获取随机移动端User-Agent""" return random.choice(config.MOBILE_USER_AGENTS) config = Config() # ==================== 账号管理 ==================== @dataclass class AccountInfo: """账号信息类""" index: int alias: str cookies: str refresh_token: str = "" class AccountManager: """账号管理器 - 读取环境变量中的账号配置""" @staticmethod def get_accounts() -> List[AccountInfo]: """获取所有账号配置""" accounts = [] index = 1 consecutive_empty = 0 # 连续空配置计数器 max_consecutive_empty = 10 # 允许最多连续5个空配置 max_check_index = 50 # 最大检查到第50个账号 while index <= max_check_index: cookies = os.getenv(f"bing_ck_{index}") refresh_token = os.getenv(f"bing_token_{index}", "") # 如果既没有cookies也没有refresh_token if not cookies and not refresh_token: consecutive_empty += 1 # 如果连续空配置超过限制，则停止搜索 if consecutive_empty >= max_consecutive_empty: break index += 1 continue else: # 重置连续空配置计数器 consecutive_empty = 0 # 如果只有refresh_token没有cookies，跳过该账号 if not cookies: print_log("账号配置", f"账号{index} 缺少cookies配置，跳过", index) # 发送缺少cookies配置的通知 global_notification_manager.send_missing_cookies_config(index) index += 1 continue # 验证cookie是否包含必需字段 # 必须包含tifacfaatcs if 'tifacfaatcs=' not in cookies: print_log("账号配置", f"账号{index} 的cookie缺少必需字段: tifacfaatcs，cookie无效，请重新抓取", index) # 发送cookie失效通知 global_notification_manager.send_cookie_missing_required_field(index, "tifacfaatcs") index += 1 continue # 必须包含 .MSA.Auth auth_fields = ['.MSA.Auth='] has_auth_field = any(field in cookies for field in auth_fields) if not has_auth_field: print_log("账号配置", f"账号{index} 的cookie缺少认证字段（需要包含 .MSA.Auth），cookie无效，请重新抓取", index) # 发送cookie失效通知 global_notification_manager.send_cookie_missing_auth_field(index) index += 1 continue alias = f"账号{index}" accounts.append(AccountInfo( index=index, alias=alias, cookies=cookies, refresh_token=refresh_token )) index += 1 # 从令牌缓存文件加载保存的令牌 for account in accounts: cached_token = global_token_cache_manager.get_cached_token(account.alias, account.index) if cached_token: account.refresh_token = cached_token # 如果没有有效账号，发送总结性通知 if not accounts: global_notification_manager.send_no_valid_accounts() return accounts # ==================== 日志系统 ==================== class LogIcons: """日志状态图标""" # 基础状态 INFO = "📊" SUCCESS = "✅" FAILED = "❌" WARNING = "⚠️" SKIP = "⏭️" START = "🚀" COMPLETE = "🎉" # 任务类型 SEARCH_PC = "💻" SEARCH_MOBILE = "📱" SEARCH_PROGRESS = "🔍" DAILY_TASK = "📅" MORE_TASK = "🎯" READ_TASK = "📖" # 账号相关 ACCOUNT = "👤" POINTS = "💰" EMAIL = "📧" # 系统相关 INIT = "⚙️" CACHE = "💾" TOKEN = "🔑" NOTIFY = "📢" class LogFormatter: """日志格式化器""" @staticmethod def create_progress_bar(current: int, total: int, width: int = 8) -> str: """创建进度条""" if total <= 0: return "░" * width + f" 0/0" filled = int((current / total) * width) filled = min(filled, width) # 确保不超过宽度 bar = "█" * filled + "░" * (width - filled) return f"{bar} {current}/{total}" @staticmethod def format_points_change(start: int, end: int) -> str: """格式化积分变化""" change = end - start if change > 0: return f"{start} → {end} (+{change})" elif change < 0: return f"{start} → {end} ({change})" else: return f"{start} (无变化)" class LogLevel: """日志级别""" DEBUG = 0 INFO = 1 SUCCESS = 2 WARNING = 3 ERROR = 4 class EnhancedLogger: """增强的日志记录器 - 多线程安全版本""" def __init__(self, min_level: int = LogLevel.INFO): self.min_level = min_level self.formatter = LogFormatter() self.lock = threading.Lock() # 添加线程锁 def _get_timestamp(self) -> str: """获取时间戳""" return datetime.now().strftime("%H:%M:%S") def _format_account_prefix(self, account_index: Optional[int]) -> str: """格式化账号前缀""" if account_index is not None: return f"[账号{account_index}]" return "[系统]" def _log(self, level: int, icon: str, title: str, msg: str, account_index: Optional[int] = None): """内部日志方法 - 线程安全""" if level < self.min_level: return with self.lock: # 确保线程安全 timestamp = self._get_timestamp() account_prefix = self._format_account_prefix(account_index) log_message = f"{timestamp} {account_prefix} {icon} {title}: {msg or ''}" print(log_message, flush=True) # ==================== 基础日志方法 ==================== def info(self, title: str, msg: str, account_index: Optional[int] = None): """信息日志""" self._log(LogLevel.INFO, LogIcons.INFO, title, msg, account_index) def success(self, title: str, msg: str, account_index: Optional[int] = None): """成功日志""" self._log(LogLevel.SUCCESS, LogIcons.SUCCESS, title, msg, account_index) def warning(self, title: str, msg: str, account_index: Optional[int] = None): """警告日志""" self._log(LogLevel.WARNING, LogIcons.WARNING, title, msg, account_index) def error(self, title: str, msg: str, account_index: Optional[int] = None): """错误日志""" self._log(LogLevel.ERROR, LogIcons.FAILED, title, msg, account_index) def skip(self, title: str, msg: str, account_index: Optional[int] = None): """跳过日志""" self._log(LogLevel.INFO, LogIcons.SKIP, title, msg, account_index) # ==================== 任务相关日志方法 ==================== def account_start(self, email: str, initial_points: int, account_index: int): """账号开始处理""" # 邮箱脱敏显示：用户名前4位+**+完整域名 if '@' in email: username, domain = email.split('@', 1) # 用户名显示前4位+** masked_username = username[:4] + "**" if len(username) > 4 else username + "**" # 保留完整域名 masked_email = f"{masked_username}@{domain}" else: # 如果没有@符号，简单处理 masked_email = email[:4] + "**" if len(email) > 4 else email msg = f"{masked_email} ({initial_points})" self._log(LogLevel.INFO, LogIcons.START, "初始化", msg, account_index) def account_complete(self, start_points: int, end_points: int, account_index: int): """账号处理完成""" msg = self.formatter.format_points_change(start_points, end_points) self._log(LogLevel.SUCCESS, LogIcons.COMPLETE, "处理完成", msg, account_index) # ==================== 搜索相关日志方法 ==================== def search_start(self, search_type: str, required: int, max_attempts: int, account_index: int): """搜索开始""" icon = LogIcons.SEARCH_PC if search_type == "电脑" else LogIcons.SEARCH_MOBILE msg = f"理论需{required}次，预执行{max_attempts}次" self._log(LogLevel.INFO, icon, f"{search_type}搜索开始", msg, account_index) def search_progress(self, search_type: str, current: int, total: int, delay: int, account_index: int): """搜索进度""" progress_bar = self.formatter.create_progress_bar(current, total) # msg = f"{progress_bar} (第{current}次成功，等待{delay}秒...)" msg = f"{progress_bar}" self._log(LogLevel.INFO, LogIcons.SEARCH_PROGRESS, f"{search_type}搜索中", msg, account_index) def search_complete(self, search_type: str, attempts: int, account_index: int, success: bool = True): """搜索完成""" icon = LogIcons.SEARCH_PC if search_type == "电脑" else LogIcons.SEARCH_MOBILE if success: msg = f"任务已完成，执行了{attempts}次搜索" self._log(LogLevel.SUCCESS, LogIcons.SUCCESS, f"{search_type}搜索", msg, account_index) else: msg = f"任务未完成，执行了{attempts}次搜索" self._log(LogLevel.WARNING, LogIcons.WARNING, f"{search_type}搜索", msg, account_index) def search_progress_summary(self, search_type: str, count: int, start_progress: int, end_progress: int, account_index: int): """搜索进度总结""" msg = f"已完成{count}次，进度: {start_progress} → {end_progress}" self._log(LogLevel.INFO, LogIcons.SEARCH_PROGRESS, f"{search_type}搜索", msg, account_index) def search_skip(self, search_type: str, reason: str, account_index: int): """搜索跳过""" icon = LogIcons.SEARCH_PC if search_type == "电脑" else LogIcons.SEARCH_MOBILE self._log(LogLevel.INFO, LogIcons.SKIP, f"{search_type}搜索", f"跳过 ({reason})", account_index) # 创建全局日志实例 logger = EnhancedLogger() def print_log(title: str, msg: str, account_index: Optional[int] = None): """保持向后兼容的日志函数""" # 自动识别日志类型并使用对应的图标 title_lower = title.lower() msg_lower = msg.lower() if msg else "" # 根据标题和消息内容选择合适的日志方法 # 特殊处理：系统提示类消息优先识别为警告 if ("提示" in title or "建议" in title or "提示" in msg_lower or "建议" in msg_lower): logger.warning(title, msg, account_index) # 优先检查失败/错误/未完成情况 elif ("失败" in title or "错误" in title or "失败" in msg_lower or "错误" in msg_lower or "❌" in msg or ("未完成" in msg_lower and "找到" not in msg_lower) or "终止" in msg_lower or "取消" in msg_lower): logger.error(title, msg, account_index) elif ("成功" in title or "完成" in title or "成功" in msg_lower or ("完成" in msg_lower and "未完成" not in msg_lower) or "✅" in msg): logger.success(title, msg, account_index) elif ("跳过" in title or "skip" in title_lower or "跳过" in msg_lower): logger.skip(title, msg, account_index) elif ("警告" in title or "warning" in title_lower or "警告" in msg_lower): logger.warning(title, msg, account_index) # 特殊处理：包含"找到"的消息通常是信息性的，使用信息图标 elif "找到" in msg_lower: logger.info(title, msg, account_index) else: logger.info(title, msg, account_index) # ==================== 异常处理装饰器 ==================== def retry_on_failure(max_retries: int = config.MAX_RETRIES, delay: int = config.RETRY_DELAY): """重试装饰器""" def decorator(func): @wraps(func) def wrapper(*args, **kwargs): last_exception = None # 获取更友好的函数名显示 func_name = func.__name__ if func_name == 'make_request': func_name = "网络请求" elif func_name == 'get_access_token': func_name = "令牌获取" elif func_name == 'get_read_progress': func_name = "阅读进度" elif func_name == 'submit_read_activity': func_name = "阅读提交" elif func_name == 'get_rewards_points': func_name = "积分查询" elif func_name == 'get_dashboard_data': func_name = "数据获取" for attempt in range(max_retries): try: return func(*args, **kwargs) except Exception as e: last_exception = e if attempt < max_retries - 1: account_index = kwargs.get('account_index') if account_index is not None: print_log(f"{func_name}重试", f"第{attempt + 1}次尝试失败，{delay}秒后重试...", account_index) else: print_log(f"{func_name}重试", f"第{attempt + 1}次尝试失败，{delay}秒后重试...") time.sleep(delay) else: account_index = kwargs.get('account_index') if account_index is not None: print_log(f"{func_name}失败", f"重试{max_retries}次后仍失败: {e}", account_index) else: print_log(f"{func_name}失败", f"重试{max_retries}次后仍失败: {e}") raise last_exception return wrapper return decorator # ==================== 通知系统 ==================== class NotificationTemplates: """通知模板管理器 - 统一管理所有通知内容""" # Cookie获取地址 COOKIE_URLS = "https://rewards.bing.com/welcome" @staticmethod def get_cookie_urls_text() -> str: """获取Cookie获取地址的格式化文本""" return f" {NotificationTemplates.COOKIE_URLS}" @staticmethod def get_current_time() -> str: """获取当前时间格式化字符串""" return datetime.now().strftime('%Y-%m-%d %H:%M:%S') @classmethod def missing_cookies_config(cls, account_index: int) -> tuple[str, str]: """缺少cookies配置的通知模板""" title = "🚨 Microsoft Rewards 配置缺失" content = ( f"账号{account_index} 缺少cookies配置\n\n" f"错误时间: {cls.get_current_time()}\n" f"需要处理: 为账号{account_index}添加环境变量 bing_ck_{account_index}\n\n" f"配置说明:\n" f"1. 设置环境变量: bing_ck_{account_index}=你的完整cookie字符串\n" f"2. Cookie获取地址:\n" f"{cls.get_cookie_urls_text()}" ) return title, content @classmethod def cookie_missing_required_field(cls, account_index: int, field_name: str) -> tuple[str, str]: """Cookie缺少必需字段的通知模板""" title = "🚨 Microsoft Rewards Cookie配置错误" content = ( f"账号{account_index} 的Cookie缺少必需字段: {field_name}\n\n" f"错误时间: {cls.get_current_time()}\n" f"需要处理: 重新获取账号{account_index}的完整Cookie\n\n" f"Cookie获取地址:\n" f"{cls.get_cookie_urls_text()}" ) return title, content @classmethod def cookie_missing_auth_field(cls, account_index: int) -> tuple[str, str]: """Cookie缺少认证字段的通知模板""" title = "🚨 Microsoft Rewards Cookie认证字段缺失" content = ( f"账号{account_index} 的Cookie缺少认证字段（需要包含 .MSA.Auth）\n\n" f"错误时间: {cls.get_current_time()}\n" f"需要处理: 重新获取账号{account_index}的完整Cookie\n\n" f"Cookie获取地址:\n" f"{cls.get_cookie_urls_text()}" ) return title, content @classmethod def no_valid_accounts(cls) -> tuple[str, str]: """无有效账号配置的通知模板""" title = "🚨 Microsoft Rewards 无有效账号配置" content = ( "所有账号配置均存在问题，无法启动任务！\n\n" f"检查时间: {cls.get_current_time()}\n\n" "常见问题及解决方案:\n" "1. 环境变量未设置: 检查 bing_ck_1, bing_ck_2 等\n" "2. Cookie格式错误: 确保包含 tifacfaatcs 字段\n" "3. 认证字段缺失: 确保包含 .MSA.Auth 字段\n\n" f"Cookie获取地址:\n" f"{cls.get_cookie_urls_text()}" ) return title, content @classmethod def cookie_invalid(cls, account_index: Optional[int] = None) -> tuple[str, str]: """Cookie失效的通知模板""" account_info = f"账号{account_index} " if account_index else "" title = "🚨 Microsoft Rewards Cookie失效" content = ( f"{account_info}Cookie已失效，无法获取积分和邮箱，请重新获取\n\n" f"失效时间: {cls.get_current_time()}\n" f"需要处理: 重新获取{account_info}的完整Cookie\n\n" f"Cookie获取地址:\n" f"{cls.get_cookie_urls_text()}" ) return title, content @classmethod def token_invalid(cls, account_index: Optional[int] = None) -> tuple[str, str]: """Token失效的通知模板""" account_info = f"账号{account_index} " if account_index else "" title = "🚨 Microsoft Rewards Token失效" content = ( f"{account_info}Refresh Token已失效，需要重新获取\n\n" f"失效时间: {cls.get_current_time()}\n" f"需要处理: 重新获取{account_info}的Refresh Token\n\n" "获取方法:\n" "1. 访问 https://login.live.com/oauth20_authorize.srf\n" "2. 使用Microsoft账号登录\n" "3. 获取授权码并换取Refresh Token" ) return title, content @classmethod def task_summary(cls, summaries: List[str]) -> tuple[str, str]: """任务完成总结的通知模板""" title = "✅ Microsoft Rewards 任务完成" content = "\n\n".join(summaries) return title, content class NotificationManager: """通知管理器""" def __init__(self): self.notify_client = self._init_notify_client() def _init_notify_client(self): """初始化通知客户端""" try: import notify return notify except ImportError: return self._create_mock_notify() def _create_mock_notify(self): """创建模拟通知客户端""" class MockNotify: def send(self, title, content): print("\n--- [通知] ---") print(f"标题: {title}") print(f"内容:\n{content}") print("-------------------------------") return MockNotify() def send(self, title: str, content: str): """发送通知""" self.notify_client.send(title, content) # 便捷的通知方法 def send_missing_cookies_config(self, account_index: int): """发送缺少cookies配置的通知""" title, content = NotificationTemplates.missing_cookies_config(account_index) self.send(title, content) def send_cookie_missing_required_field(self, account_index: int, field_name: str): """发送Cookie缺少必需字段的通知""" title, content = NotificationTemplates.cookie_missing_required_field(account_index, field_name) self.send(title, content) def send_cookie_missing_auth_field(self, account_index: int): """发送Cookie缺少认证字段的通知""" title, content = NotificationTemplates.cookie_missing_auth_field(account_index) self.send(title, content) def send_no_valid_accounts(self): """发送无有效账号配置的通知""" title, content = NotificationTemplates.no_valid_accounts() self.send(title, content) def send_cookie_invalid(self, account_index: Optional[int] = None): """发送Cookie失效的通知""" title, content = NotificationTemplates.cookie_invalid(account_index) self.send(title, content) def send_token_invalid(self, account_index: Optional[int] = None): """发送Token失效的通知""" title, content = NotificationTemplates.token_invalid(account_index) self.send(title, content) def send_task_summary(self, summaries: List[str]): """发送任务完成总结的通知""" title, content = NotificationTemplates.task_summary(summaries) self.send(title, content) global_notification_manager = NotificationManager() # 全局通知管理器，用于账号验证阶段 # ==================== 缓存管理 ==================== class CacheManager: """缓存管理器""" def __init__(self, cache_file: str = config.CACHE_FILE): self.cache_file = cache_file self.lock = threading.Lock() def load_cache(self) -> Dict[str, Any]: """加载缓存数据（从统一缓存文件中提取推送相关数据和任务完成计数）""" all_data = self._load_unified_cache() # 过滤出推送相关的数据和任务完成计数 cache_data = {} for key, value in all_data.items(): if key.startswith('push_') or key.startswith('tasks_complete_'): cache_data[key] = value return cache_data def save_cache(self, data: Dict[str, Any]): """保存缓存数据到统一缓存文件""" try: with self.lock: # 读取现有的统一缓存数据 all_cache_data = self._load_unified_cache() # 清理整个缓存文件中的过期推送记录 today = date.today().isoformat() all_cache_data = self._clean_expired_data(all_cache_data, today) # 更新传入的数据 for key, value in data.items(): all_cache_data[key] = value # 保存到统一缓存文件 self._save_unified_cache(all_cache_data) except Exception as e: print_log("缓存错误", f"保存缓存失败: {e}") def _load_unified_cache(self) -> Dict[str, Any]: """加载统一缓存文件""" return global_token_cache_manager._load_all_cache_data() def _save_unified_cache(self, data: Dict[str, Any]): """保存到统一缓存文件""" global_token_cache_manager._save_all_cache_data(data) def _clean_expired_data(self, data: Dict[str, Any], today: str) -> Dict[str, Any]: """清理过期的缓存数据（只清理推送相关数据和任务完成计数）""" keys_to_keep = [] for k in data: # 如果是推送相关的键，检查日期 if k.startswith('push_'): date_part = k.replace('push_', '') # 只保留今天的推送记录，删除昨天及以前的 if date_part == today: keys_to_keep.append(k) # 如果是任务完成计数相关的键，检查日期 elif k.startswith('tasks_complete_'): date_part = k.replace('tasks_complete_', '') # 只保留今天的任务完成计数，删除昨天及以前的 if date_part == today: keys_to_keep.append(k) else: # 非推送相关的键（如tokens等）全部保留 keys_to_keep.append(k) return {k: data[k] for k in keys_to_keep} def has_pushed_today(self) -> bool: """检查今天是否已推送""" today = date.today().isoformat() data = self.load_cache() return data.get(f"push_{today}", False) def mark_pushed_today(self): """标记今天已推送""" today = date.today().isoformat() # 读取现有的统一缓存数据 all_cache_data = self._load_unified_cache() # 检查是否已经有今天的推送记录 if f"push_{today}" not in all_cache_data: # 如果没有今天的记录，先清理所有过期的推送记录 all_cache_data = self._clean_expired_data(all_cache_data, today) print_log("缓存清理", "已清理过期的推送记录") # 添加今天的推送记录 all_cache_data[f"push_{today}"] = True # 保存到统一缓存文件 self._save_unified_cache(all_cache_data) def get_tasks_complete_count(self) -> int: """获取今天任务完成的次数""" today = date.today().isoformat() data = self.load_cache() return data.get(f"tasks_complete_{today}", 0) def increment_tasks_complete_count(self): """增加今天任务完成的次数""" today = date.today().isoformat() # 读取现有的统一缓存数据 all_cache_data = self._load_unified_cache() # 检查是否已经有今天的任务完成计数记录 if f"tasks_complete_{today}" not in all_cache_data: # 如果没有今天的记录，先清理所有过期的记录 all_cache_data = self._clean_expired_data(all_cache_data, today) print_log("缓存清理", "已清理过期的任务完成计数记录") # 增加任务完成计数 current_count = all_cache_data.get(f"tasks_complete_{today}", 0) new_count = current_count + 1 # 限制最大计数为配置值 if new_count > TASK_CONFIG['MAX_REPEAT_COUNT']: print_log("任务完成计数", f"计数已达到上限{TASK_CONFIG['MAX_REPEAT_COUNT']}次，不再增加", None) return all_cache_data[f"tasks_complete_{today}"] = new_count # 保存到统一缓存文件 self._save_unified_cache(all_cache_data) print_log("重复运行", f"{new_count}/{TASK_CONFIG['MAX_REPEAT_COUNT']}", None) if new_count >= TASK_CONFIG['MAX_REPEAT_COUNT']: print_log("重复运行", "已达上限", None) def should_skip_execution(self) -> bool: """检查是否应该跳过脚本执行（任务已完成指定次数）""" return self.get_tasks_complete_count() >= TASK_CONFIG['MAX_REPEAT_COUNT'] global_cache_manager = CacheManager() # 全局缓存管理器，用于推送状态检查 # ==================== Refresh Token 缓存管理 ==================== class TokenCacheManager: """Refresh Token 缓存管理器""" def __init__(self, token_file: str = config.CACHE_FILE): self.token_file = token_file self.lock = threading.Lock() self._cached_tokens = {} # 内存缓存，避免重复保存 def _load_all_cache_data(self) -> Dict[str, Any]: """加载统一缓存文件的所有数据""" if not os.path.exists(self.token_file): return {} try: with open(self.token_file, "r", encoding="utf-8") as f: content = f.read().strip() if not content: # 如果文件为空，返回空字典 return {} return json.loads(content) except json.JSONDecodeError as e: print_log("缓存错误", f"JSON格式错误: {e}，尝试修复文件") # 尝试修复损坏的JSON文件 self._repair_json_file() return {} except Exception as e: print_log("缓存错误", f"读取失败: {e}") return {} def _save_all_cache_data(self, data: Dict[str, Any]): """保存数据到统一缓存文件""" try: # 使用线程安全的临时文件名（添加线程ID和随机数） thread_id = threading.get_ident() random_suffix = random.randint(1000, 9999) temp_file = f"{self.token_file}.tmp.{thread_id}.{random_suffix}" try: # 原子性保存到文件（先写临时文件，再重命名） with open(temp_file, "w", encoding="utf-8") as f: json.dump(data, f, ensure_ascii=False, indent=2) # 原子性重命名 import shutil shutil.move(temp_file, self.token_file) except Exception as file_error: # 清理临时文件 try: if os.path.exists(temp_file): os.remove(temp_file) except: pass raise file_error except Exception as e: print_log("缓存错误", f"保存失败: {e}") def save_token(self, account_alias: str, refresh_token: str, account_index: Optional[int] = None): """保存刷新令牌到统一缓存文件""" try: # 检查是否已经缓存过相同的令牌 cache_key = f"{account_alias}_{refresh_token}" if cache_key in self._cached_tokens: return # 已经缓存过，跳过 with self.lock: # 确保目录存在 os.makedirs(os.path.dirname(self.token_file) if os.path.dirname(self.token_file) else '.', exist_ok=True) # 读取现有缓存数据（包含推送状态等） all_cache_data = self._load_all_cache_data() # 获取或初始化tokens部分 if 'tokens' not in all_cache_data: all_cache_data['tokens'] = {} # 检查是否与现有令牌相同 existing_token = all_cache_data['tokens'].get(account_alias, {}).get("refreshToken") if existing_token == refresh_token: # 标记为已缓存，避免重复尝试 self._cached_tokens[cache_key] = True return # 令牌没有变化，跳过 # 更新令牌 all_cache_data['tokens'][account_alias] = { "refreshToken": refresh_token, "updatedAt": datetime.now().isoformat() } # 保存到统一缓存文件 self._save_all_cache_data(all_cache_data) # 标记为已缓存 self._cached_tokens[cache_key] = True print_log("令牌缓存", "更新成功", account_index) except Exception as e: print_log("令牌缓存", f"更新失败: {e}", account_index) def get_cached_token(self, account_alias: str, account_index: Optional[int] = None) -> Optional[str]: """获取缓存的刷新令牌""" try: all_cache_data = self._load_all_cache_data() tokens = all_cache_data.get('tokens', {}) account_data = tokens.get(account_alias) if account_data and account_data.get("refreshToken"): return account_data["refreshToken"] return None except Exception as e: print_log("令牌缓存", f"读取失败: {e}", account_index) return None def _repair_json_file(self): """尝试修复损坏的JSON文件""" try: # 备份损坏的文件 backup_file = self.token_file + f".backup_{int(time.time())}" if os.path.exists(self.token_file): import shutil shutil.copy2(self.token_file, backup_file) print_log("令牌缓存", f"已备份损坏文件到: {backup_file}") # 创建新的空文件 with open(self.token_file, "w", encoding="utf-8") as f: json.dump({}, f, ensure_ascii=False, indent=2) print_log("令牌缓存", "已重新创建令牌缓存文件") except Exception as e: print_log("令牌缓存", f"修复文件失败: {e}") global_token_cache_manager = TokenCacheManager() # 全局令牌缓存管理器，用于账号验证阶段 # ==================== 热搜词管理 ==================== class HotWordsManager: """热搜词管理器""" def __init__(self): self.hot_words = self._fetch_hot_words() @retry_on_failure(max_retries=2, delay=1) def _fetch_hot_words(self, max_count: int = config.HOT_WORDS_MAX_COUNT) -> List[str]: """获取热搜词""" apis_shuffled = config.HOT_WORDS_APIS[:] random.shuffle(apis_shuffled) for base_url, sources in apis_shuffled: sources_shuffled = sources[:] random.shuffle(sources_shuffled) for source in sources_shuffled: api_url = base_url + source try: resp = requests.get(api_url, timeout=10) if resp.status_code == 200: data = resp.json() if isinstance(data, dict) and 'data' in data and data['data']: all_titles = [item.get('title') for item in data['data'] if item.get('title')] if all_titles: print_log("热搜词", f"成功获取热搜词 {len(all_titles)} 条，来源: {api_url}") random.shuffle(all_titles) return all_titles[:max_count] except Exception: continue print_log("热搜词", "全部热搜API失效，使用默认搜索词。") default_words = config.DEFAULT_HOT_WORDS[:max_count] random.shuffle(default_words) return default_words def get_random_word(self) -> str: """获取随机热搜词""" return random.choice(self.hot_words) if self.hot_words else random.choice(config.DEFAULT_HOT_WORDS) hot_words_manager = HotWordsManager() # ==================== HTTP请求管理 ==================== class RequestManager: """HTTP请求管理器 - 支持独立Session""" def __init__(self): """初始化请求管理器，创建独立的Session""" self.session = requests.Session() @staticmethod def get_browser_headers(cookies: str) -> Dict[str, str]: """获取浏览器请求头""" return { "user-agent": config.get_random_pc_ua(), "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7", "accept-language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6", "accept-encoding": "gzip, deflate, br, zstd", "sec-ch-ua": '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"', "sec-ch-ua-mobile": "?0", "sec-ch-ua-platform": '"Windows"', "sec-fetch-site": "none", "sec-fetch-mode": "navigate", "sec-fetch-user": "?1", "sec-fetch-dest": "document", "upgrade-insecure-requests": "1", "x-edge-shopping-flag": "1", "referer": "https://rewards.bing.com/", "cookie": cookies } @staticmethod def get_mobile_headers(cookies: str) -> Dict[str, str]: """获取移动端请求头""" return { "user-agent": config.get_random_mobile_ua(), "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7", "accept-language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7", "accept-encoding": "gzip, deflate, br, zstd", "sec-ch-ua": '"Not;A=Brand";v="99", "Chromium";v="124"', "sec-ch-ua-mobile": "?1", "sec-ch-ua-platform": '"Android"', "sec-fetch-site": "none", "sec-fetch-mode": "navigate", "sec-fetch-user": "?1", "sec-fetch-dest": "document", "upgrade-insecure-requests": "1", "cookie": cookies } @retry_on_failure(max_retries=2) def make_request(self, method: str, url: str, headers: Dict[str, str], params: Optional[Dict] = None, data: Optional[str] = None, timeout: int = config.REQUEST_TIMEOUT, account_index: Optional[int] = None) -> requests.Response: """统一的HTTP请求方法 - 使用独立Session""" if method.upper() == 'GET': return self.session.get(url, headers=headers, params=params, timeout=timeout) elif method.upper() == 'POST': # 判断是否为JSON数据 if headers.get('Content-Type') == 'application/json' and data: return self.session.post(url, headers=headers, json=json.loads(data), timeout=timeout) elif isinstance(data, dict): # 表单数据 return self.session.post(url, headers=headers, data=data, timeout=timeout) else: # 字符串数据 return self.session.post(url, headers=headers, data=data, timeout=timeout) else: raise ValueError(f"不支持的HTTP方法: {method}") def close(self): """关闭Session""" if hasattr(self, 'session'): self.session.close() # ==================== 主要业务逻辑类 ==================== class RewardsService: """Microsoft Rewards服务类 - 增强版本支持令牌缓存和独立Session""" # ==================== 1. 基础设施方法 ==================== def __init__(self): """初始化服务，创建独立的请求管理器和通知管理器""" self.request_manager = RequestManager() self.notification_manager = NotificationManager() # 每个实例独立的通知管理器 # 为每个实例创建独立的缓存管理器，避免文件锁竞争 self.cache_manager = CacheManager() self.token_cache_manager = TokenCacheManager() def __del__(self): """析构函数，确保Session被正确关闭""" if hasattr(self, 'request_manager'): self.request_manager.close() # ==================== 2. 核心数据获取方法 ==================== @retry_on_failure() def get_rewards_points(self, cookies: str, account_index: Optional[int] = None) -> Optional[Dict[str, Any]]: """查询当前积分、账号信息和获取token""" headers = self.request_manager.get_browser_headers(cookies) # 添加PC端特有的头部 headers.update({ 'cache-control': 'max-age=0', 'sec-ch-ua': '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"', 'sec-ch-ua-mobile': '?0', 'sec-ch-ua-full-version': '139.0.3405.86', 'sec-ch-ua-arch': 'x86', 'sec-ch-ua-platform': '"Windows"', 'sec-ch-ua-platform-version': '19.0.0', 'sec-ch-ua-model': '""', 'sec-ch-ua-bitness': '64', 'sec-ch-ua-full-version-list': '"Not;A=Brand";v="99.0.0.0", "Microsoft Edge";v="139.0.3405.86", "Chromium";v="139.0.7258.67"', 'upgrade-insecure-requests': '1', 'x-edge-shopping-flag': '1', 'sec-ms-gec': 'F4AE7EBFE1C688D0967DE661CC98B823383760340F7B0B42D9FFA10D74621BEA', 'sec-ms-gec-version': '1-139.0.3405.86', 'x-client-data': 'eyIxIjoiMCIsIjIiOiIwIiwiMyI6IjAiLCI0IjoiLTExNzg4ODc1Mjc3OTM5NTI1MDUiLCI2Ijoic3RhYmxlIiwiOSI6ImRlc2t0b3AifQ==', 'sec-fetch-site': 'same-origin', 'sec-fetch-mode': 'navigate', 'sec-fetch-user': '?1', 'sec-fetch-dest': 'document', 'referer': 'https://rewards.bing.com/welcome' }) url = 'https://rewards.bing.com' response = self.request_manager.make_request('GET', url, headers, account_index=account_index) response.raise_for_status() content = response.text # 提取积分和邮箱 points_pattern = r'"availablePoints":(\d+)' email_pattern = r'email:\s*"([^"]+)"' points_match = re.search(points_pattern, content) email_match = re.search(email_pattern, content) available_points = int(points_match.group(1)) if points_match else None email = email_match.group(1) if email_match else None # 提取token token_match = re.search(r'name="__RequestVerificationToken".*?value="([^"]+)"', content) token = token_match.group(1) if token_match else None if available_points is None or email is None: print_log("账号信息", "Cookie可能已失效，无法获取积分和邮箱", account_index) # 立即推送Cookie失效通知 self._send_cookie_invalid_notification(account_index) return None if token is None: print_log("账号信息", "无法获取RequestVerificationToken", account_index) return { 'points': available_points, 'email': email, 'token': token } @retry_on_failure() def get_dashboard_data(self, cookies: str, account_index: Optional[int] = None, silent: bool = False) -> Optional[Dict[str, Any]]: """获取dashboard数据（从API接口）""" try: # 调用API获取dashboard数据 import time timestamp = int(time.time() * 1000) api_headers = self.request_manager.get_browser_headers(cookies) api_headers.update({ 'sec-ch-ua-full-version-list': '"Not;A=Brand";v="99.0.0.0", "Microsoft Edge";v="139.0.3405.86", "Chromium";v="139.0.7258.67"', 'sec-ch-ua-platform': '"Windows"', 'sec-ch-ua': '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"', 'sec-ch-ua-bitness': '64', 'sec-ch-ua-model': '""', 'sec-ch-ua-mobile': '?0', 'sec-ch-ua-arch': 'x86', 'correlation-context': 'v=1,ms.b.tel.market=zh-Hans', 'sec-ch-ua-full-version': '139.0.3405.86', 'accept': 'application/json, text/javascript, */*; q=0.01', 'sec-ch-ua-platform-version': '19.0.0', 'x-edge-shopping-flag': '1', 'sec-ms-gec': 'F4AE7EBFE1C688D0967DE661CC98B823383760340F7B0B42D9FFA10D74621BEA', 'sec-ms-gec-version': '1-139.0.3405.86', 'x-client-data': 'eyIxIjoiMCIsIjIiOiIwIiwiMyI6IjAiLCI0IjoiLTExNzg4ODc1Mjc3OTM5NTI1MDUiLCI2Ijoic3RhYmxlIiwiOSI6ImRlc2t0b3AifQ==', 'sec-fetch-site': 'same-origin', 'sec-fetch-mode': 'cors', 'sec-fetch-dest': 'empty', 'referer': 'https://rewards.bing.com/', 'X-Requested-With': 'XMLHttpRequest' }) # api_url = f"https://rewards.bing.com/api/getuserinfo?type=1&X-Requested-With=XMLHttpRequest&_={timestamp}" api_url = f"https://rewards.bing.com/api/getuserinfo" api_resp = self.request_manager.make_request('GET', api_url, api_headers, timeout=30, account_index=account_index) api_resp.raise_for_status() dashboard_json = api_resp.json() if not dashboard_json or 'dashboard' not in dashboard_json: if not silent: print_log('数据获取', "API返回的数据格式不正确", account_index) return None return dashboard_json except Exception as e: # 对于常见的服务器错误，使用静默模式减少日志噪音 if not silent: error_msg = str(e) # 简化常见错误信息 if "503" in error_msg: print_log('数据获取', "服务器暂时不可用，稍后重试", account_index) elif "500" in error_msg: print_log('数据获取', "服务器内部错误", account_index) elif "timeout" in error_msg.lower(): print_log('数据获取', "请求超时", account_index) else: print_log('数据获取', f"获取失败: {error_msg}", account_index) return None def get_account_level(self, dashboard_data: Dict[str, Any]) -> str: """获取账号等级""" if not dashboard_data: return "Level1" dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) level_info = user_status.get('levelInfo', {}) # 确保level_info不为None if not level_info: return "Level1" return level_info.get('activeLevel', 'Level1') # ==================== 3. 令牌相关方法 ==================== @retry_on_failure() def get_access_token(self, refresh_token: str, account_alias: str = "", account_index: Optional[int] = None, silent: bool = False) -> Optional[str]: """获取访问令牌用于阅读任务 - 支持令牌自动更新""" try: data = { 'client_id': '0000000040170455', 'refresh_token': refresh_token, 'scope': 'service::prod.rewardsplatform.microsoft.com::MBI_SSL', 'grant_type': 'refresh_token' } headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'User-Agent': config.get_random_pc_ua(), 'sec-ch-ua-platform': '"Windows"', 'sec-ch-ua': '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"', 'sec-ch-ua-mobile': '?0', 'Accept': '*/*', 'Origin': 'https://login.live.com', 'X-Edge-Shopping-Flag': '1', 'Sec-Fetch-Site': 'same-origin', 'Sec-Fetch-Mode': 'cors', 'Sec-Fetch-Dest': 'empty', 'Referer': 'https://login.live.com/oauth20_desktop.srf', 'Accept-Encoding': 'gzip, deflate, br, zstd', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6' } response = self.request_manager.make_request( 'POST', 'https://login.live.com/oauth20_token.srf', headers, data=data, account_index=account_index ) if response.status_code == 200: token_data = response.json() if 'access_token' in token_data: # print_log("令牌获取", "成功获取访问令牌", account_index) # 检查是否有新的refresh_token返回并启用了缓存（非静默模式） if (not silent and CACHE_ENABLED and 'refresh_token' in token_data and token_data['refresh_token'] != refresh_token and account_alias): # print_log("令牌更新", f"检测到新的刷新令牌，正在更新缓存", account_index) # 保存新的refresh_token到缓存 self.token_cache_manager.save_token(account_alias, token_data['refresh_token'], account_index) return token_data['access_token'] # 静默模式下不处理错误通知 if silent: return None # 检查是否为令牌失效错误 if response.status_code in [400, 401, 403]: try: error_data = response.json() error_description = error_data.get('error_description', '').lower() error_code = error_data.get('error', '').lower() # 常见的令牌失效错误标识 token_invalid_indicators = [ 'invalid_grant', 'expired_token', 'refresh_token', 'invalid_request', 'unauthorized', 'invalid refresh token' ] if any(indicator in error_description or indicator in error_code for indicator in token_invalid_indicators): print_log("令牌获取", "刷新令牌已失效，尝试读取环境变量", account_index) # 尝试从环境变量重新读取令牌 new_token = os.getenv(f"bing_token_{account_index}") if new_token and new_token.strip() and new_token != refresh_token: print_log("令牌获取", f"从环境变量获取到新令牌，重试", account_index) # 使用新令牌重试 return self.get_access_token(new_token.strip(), account_alias, account_index, silent) else: print_log("令牌获取", "环境变量中无新令牌，发送失效通知", account_index) self._send_token_invalid_notification(account_index) return None except: pass print_log("令牌获取", f"获取访问令牌失败，状态码: {response.status_code}", account_index) return None except Exception as e: # 静默模式下不处理错误通知 if silent: return None # 检查异常是否包含令牌失效的信息 error_message = str(e).lower() token_invalid_indicators = [ 'invalid_grant', 'expired_token', 'refresh_token', 'unauthorized', '401', '403', 'invalid refresh token' ] if any(indicator in error_message for indicator in token_invalid_indicators): print_log("令牌获取", "刷新令牌已失效（异常检测），尝试读取环境变量", account_index) # 尝试从环境变量重新读取令牌 new_token = os.getenv(f"bing_token_{account_index}") if new_token and new_token.strip() and new_token != refresh_token: print_log("令牌获取", f"从环境变量获取到新令牌，重试", account_index) # 使用新令牌重试 return self.get_access_token(new_token.strip(), account_alias, account_index, silent) else: print_log("令牌获取", "环境变量中无新令牌，发送失效通知", account_index) self._send_token_invalid_notification(account_index) else: print_log("令牌获取", f"获取访问令牌异常: {e}", account_index) return None @retry_on_failure() def get_read_progress(self, access_token: str, account_index: Optional[int] = None) -> Dict[str, int]: """获取阅读任务进度""" try: headers = { 'Authorization': f'Bearer {access_token}', 'User-Agent': config.get_random_mobile_ua(), 'Accept-Encoding': 'gzip', 'x-rewards-partnerid': 'startapp', 'x-rewards-appid': 'SAAndroid/32.2.430730002', 'x-rewards-country': 'cn', 'x-rewards-language': 'zh-hans', 'x-rewards-flights': 'rwgobig' } response = self.request_manager.make_request( 'GET', 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&options=613', headers, account_index=account_index ) if response.status_code == 200: data = response.json() if 'response' in data and 'promotions' in data['response']: for promotion in data['response']['promotions']: if (promotion.get('attributes', {}).get('offerid') == 'ENUS_readarticle3_30points'): # 获取max和progress值 max_value = promotion['attributes'].get('max') progress_value = promotion['attributes'].get('progress') # 检查值是否有效 if max_value is not None and progress_value is not None: try: return { 'max': int(max_value), 'progress': int(progress_value) } except (ValueError, TypeError): # 如果转换失败，继续查找其他任务或抛出异常 print_log("阅读进度", f"数据格式错误: max={max_value}, progress={progress_value}", account_index) continue else: # 如果值为空，记录日志并继续查找 print_log("阅读进度", f"数据为空: max={max_value}, progress={progress_value}", account_index) continue # 如果没有找到有效的阅读任务数据，抛出异常让重试机制处理 print_log("阅读进度", "未找到有效的阅读任务数据，将重试", account_index) raise ValueError("未找到有效的阅读任务数据") else: # 如果响应结构不正确，抛出异常 print_log("阅读进度", "API响应结构不正确，将重试", account_index) raise ValueError("API响应结构不正确") # 如果状态码不是200，抛出异常让重试机制处理 print_log("阅读进度", f"获取阅读进度失败，状态码: {response.status_code}", account_index) raise Exception(f"HTTP状态码错误: {response.status_code}") except Exception as e: # 重新抛出异常，让重试装饰器处理 print_log("阅读进度", f"获取阅读进度异常: {e}", account_index) raise # ==================== 4. 搜索任务相关方法 ==================== def is_pc_search_complete(self, dashboard_data: Dict[str, Any]) -> bool: """检查电脑搜索是否完成""" if not dashboard_data: return False dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) counters = user_status.get('counters', {}) pc_search_tasks = counters.get('pcSearch', []) # 如果没有任务数据，认为未完成 if not pc_search_tasks: return False for task in pc_search_tasks: # 明确检查complete字段，默认为False（未完成） if not task.get('complete', False): return False return True def is_mobile_search_complete(self, dashboard_data: Dict[str, Any]) -> bool: """检查移动搜索是否完成""" if not dashboard_data: return False dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) counters = user_status.get('counters', {}) mobile_search_tasks = counters.get('mobileSearch', []) # 如果没有任务数据，认为未完成 if not mobile_search_tasks: return False for task in mobile_search_tasks: # 明确检查complete字段，默认为False（未完成） if not task.get('complete', False): return False return True def _enhance_mobile_cookies(self, cookies: str) -> str: """增强移动端cookies""" enhanced_cookies = cookies # 移除桌面端特有字段 desktop_fields_to_remove = [ r'_HPVN=[^;]+', r'_RwBf=[^;]+', r'USRLOC=[^;]+', r'BFBUSR=[^;]+', r'_Rwho=[^;]+', r'ipv6=[^;]+', r'_clck=[^;]+', r'_clsk=[^;]+', r'webisession=[^;]+', r'MicrosoftApplicationsTelemetryDeviceId=[^;]+', r'MicrosoftApplicationsTelemetryFirstLaunchTime=[^;]+', r'MSPTC=[^;]+', r'vdp=[^;]+' ] for pattern in desktop_fields_to_remove: enhanced_cookies = re.sub(pattern, '', enhanced_cookies) enhanced_cookies = re.sub(r';;+', ';', enhanced_cookies).strip('; ') # 添加移动端特有字段 # 1. SRCHD字段 - 移动端必需 if 'SRCHD=' not in enhanced_cookies: enhanced_cookies += '; SRCHD=AF=NOFORM' # 2. SRCHUSR字段 - 更新为移动端格式 current_date = datetime.now().strftime('%Y%m%d') if 'SRCHUSR=' in enhanced_cookies: enhanced_cookies = re.sub(r'SRCHUSR=[^;]+', f'SRCHUSR=DOB={current_date}&DS=1', enhanced_cookies) else: enhanced_cookies += f'; SRCHUSR=DOB={current_date}&DS=1' return enhanced_cookies @retry_on_failure(max_retries=2, delay=1) def perform_pc_search(self, cookies: str, account_index: Optional[int] = None, email: Optional[str] = None) -> bool: """执行电脑搜索""" q = hot_words_manager.get_random_word() params = { "q": q, "qs": "HS", "form": "TSASDS" } headers = { "User-Agent": config.get_random_pc_ua(), "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7", "Referer": "https://rewards.bing.com/", "Accept-Language": "zh-CN,zh;q=0.9", "Cookie": cookies } try: # 第一步：执行搜索 search_url = "https://cn.bing.com/search" final_search_url = None # 发送请求但不自动跟随重定向 search_response = self.request_manager.session.get(search_url, headers=headers, params=params, timeout=config.REQUEST_TIMEOUT, allow_redirects=False) # 检查是否为重定向状态码 redirect_status_codes = {301, 302, 303, 307, 308} if search_response.status_code in redirect_status_codes: print_log("电脑搜索", f"cn.bing.com 返回重定向状态码 {search_response.status_code}，切换到 www.bing.com", account_index) # 使用 www.bing.com search_url = "https://www.bing.com/search" search_response = self.request_manager.make_request('GET', search_url, headers, params) final_search_url = search_url else: # 如果不是重定向，检查是否成功 if search_response.status_code != 200: # 如果 cn.bing.com 返回其他错误状态码，也尝试 www.bing.com print_log("电脑搜索", f"cn.bing.com 返回状态码 {search_response.status_code}，切换到 www.bing.com", account_index) search_url = "https://www.bing.com/search" search_response = self.request_manager.make_request('GET', search_url, headers, params) final_search_url = search_url else: final_search_url = "https://cn.bing.com/search" if search_response.status_code != 200: print_log("电脑搜索", f"搜索失败，最终状态码: {search_response.status_code}", account_index) return False # 提取必要的参数 html_content = search_response.text ig_match = re.search(r'IG:"([^"]+)"', html_content) iid_match = re.search(r'data_iid\s*=\s*"([^"]+)"', html_content) if not ig_match or not iid_match: print_log("电脑搜索", "无法从页面提取 IG 或 IID，跳过报告活动", account_index) return True # 搜索成功但无法报告活动，仍然返回True # 延迟 time.sleep(random.uniform(config.TASK_DELAY_MIN, config.TASK_DELAY_MAX)) # 第二步：报告活动 ig_value = ig_match.group(1) iid_value = iid_match.group(1) # 构建完整的搜索URL req = requests.Request('GET', final_search_url, params=params, headers=headers) prepared_req = req.prepare() full_search_url = prepared_req.url # 根据最终使用的域名构建报告URL if "www.bing.com" in final_search_url: report_url = (f"https://www.bing.com/rewardsapp/reportActivity?IG={ig_value}&IID={iid_value}" f"&q={quote(q)}&qs=HS&form=TSASDS&ajaxreq=1") else: report_url = (f"https://cn.bing.com/rewardsapp/reportActivity?IG={ig_value}&IID={iid_value}" f"&q={quote(q)}&qs=HS&form=TSASDS&ajaxreq=1") post_headers = { "User-Agent": headers["User-Agent"], "Accept": "*/*", "Origin": final_search_url.split('/search')[0], # 提取域名部分 "Referer": full_search_url, "Content-Type": "application/x-www-form-urlencoded", "Cookie": cookies } post_data = f"url={quote(full_search_url, safe='')}&V=web" report_response = self.request_manager.make_request('POST', report_url, post_headers, data=post_data) if 200 <= report_response.status_code < 400: return True else: print_log("电脑搜索", f"报告活动失败，状态码: {report_response.status_code}", account_index) return True # 搜索成功但报告失败，仍然返回True except Exception as e: print_log("电脑搜索", f"搜索失败: {e}", account_index) return False @retry_on_failure(max_retries=2, delay=1) def perform_mobile_search(self, cookies: str, account_index: Optional[int] = None, email: Optional[str] = None) -> bool: """执行移动搜索""" q = hot_words_manager.get_random_word() # 生成随机的tnTID和tnCol参数 random_tnTID = config.generate_random_tnTID() random_tnCol = config.generate_random_tnCol() # 处理cookie enhanced_cookies = self._enhance_mobile_cookies(cookies) params = { "q": q, "form": "NPII01", "filters": f'tnTID:"{random_tnTID}" tnVersion:"d1d6d5bcada64df7a0182f7bc3516b45" Segment:"popularnow.carousel" tnCol:"{random_tnCol}" tnScenario:"TrendingTopicsAPI" tnOrder:"4a2117a4-4237-4b9e-85d0-67fef7b5f2be"', "ssp": "1", "safesearch": "moderate", "setlang": "zh-hans", "cc": "CN", "ensearch": "0", "PC": "SANSAAND" } headers = { "user-agent": config.get_random_mobile_ua(), "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3", "x-search-market": "zh-CN", "upgrade-insecure-requests": "1", "accept-encoding": "gzip, deflate", "accept-language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7", "x-requested-with": "com.microsoft.bing", "cookie": enhanced_cookies } try: # 第一步：执行搜索 search_url = "https://cn.bing.com/search" final_search_url = None final_headers = headers.copy() # 发送请求但不自动跟随重定向 search_response = self.request_manager.session.get(search_url, headers=headers, params=params, timeout=config.REQUEST_TIMEOUT, allow_redirects=False) # 检查是否为重定向状态码 redirect_status_codes = {301, 302, 303, 307, 308} if search_response.status_code in redirect_status_codes: print_log("移动搜索", f"cn.bing.com 返回重定向状态码 {search_response.status_code}，切换到 www.bing.com", account_index) # 使用 www.bing.com，添加必要的请求头 search_url = "https://www.bing.com/search" # 添加重定向相关参数 params.update({ "rdr": "1", "rdrig": config.generate_random_tnTID()[:32] # 使用随机IG值 }) search_response = self.request_manager.make_request('GET', search_url, final_headers, params) final_search_url = search_url else: # 如果不是重定向，检查是否成功 if search_response.status_code != 200: # 如果 cn.bing.com 返回其他错误状态码，也尝试 www.bing.com print_log("移动搜索", f"cn.bing.com 返回状态码 {search_response.status_code}，切换到 www.bing.com", account_index) search_url = "https://www.bing.com/search" search_response = self.request_manager.make_request('GET', search_url, final_headers, params) final_search_url = search_url else: final_search_url = "https://cn.bing.com/search" if search_response.status_code != 200: print_log("移动搜索", f"搜索失败，最终状态码: {search_response.status_code}", account_index) return False # 延迟 time.sleep(random.uniform(config.TASK_DELAY_MIN, config.TASK_DELAY_MAX)) # 第二步：报告活动 req = requests.Request('GET', final_search_url, headers=final_headers, params=params) prepared_req = req.prepare() full_search_url = prepared_req.url # 根据最终使用的域名构建报告URL if "www.bing.com" in final_search_url: report_url = "https://www.bing.com/rewardsapp/reportActivity" else: report_url = "https://cn.bing.com/rewardsapp/reportActivity" post_data_str = f"url={quote(full_search_url, safe='')}&V=web" # 构建报告活动的请求头 post_headers = { "user-agent": final_headers["user-agent"], "accept": "*/*", "content-type": "application/x-www-form-urlencoded; charset=utf-8", "cookie": enhanced_cookies } # 根据域名设置不同的referer if "www.bing.com" in final_search_url: post_headers.update({ "referer": "https://www.bing.com/", "request_user_info": "true", "accept-encoding": "gzip", "x-search-market": "zh-CN" }) else: post_headers["referer"] = "https://cn.bing.com/" report_response = self.request_manager.make_request('POST', report_url, post_headers, data=post_data_str) if 200 <= report_response.status_code < 400: return True else: print_log("移动搜索", f"报告活动失败，状态码: {report_response.status_code}", account_index) return True # 搜索成功但报告失败，仍然返回True except Exception as e: print_log("移动搜索", f"搜索失败: {e}", account_index) return False # ==================== 5. 阅读任务相关方法 ==================== @retry_on_failure() def submit_read_activity(self, access_token: str, account_index: Optional[int] = None) -> bool: """提交阅读活动""" try: headers = { 'Content-Type': 'application/json', 'Authorization': f'Bearer {access_token}', 'User-Agent': config.get_random_mobile_ua(), 'Accept-Encoding': 'gzip', 'x-rewards-partnerid': 'startapp', 'x-rewards-appid': 'SAAndroid/32.2.430730002', 'x-rewards-country': 'cn', 'x-rewards-language': 'zh-hans', 'x-rewards-flights': 'rwgobig' } payload = { 'amount': 1, 'country': 'cn', 'id': '', 'type': 101, 'attributes': { 'offerid': 'ENUS_readarticle3_30points' } } response = self.request_manager.make_request( 'POST', 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities', headers, data=json.dumps(payload), account_index=account_index ) if response.status_code == 200: # print_log("阅读提交", "文章阅读提交成功", account_index) return True else: print_log("阅读提交", f"文章阅读提交失败，状态码: {response.status_code}", account_index) return False except Exception as e: if hasattr(e, 'response') and e.response: try: error_data = e.response.json() if (error_data.get('error', {}).get('description', '').find('already') != -1): print_log("阅读提交", "文章阅读任务已完成", account_index) return True except: pass print_log("阅读提交", f"文章阅读提交异常: {e}", account_index) return False def complete_read_tasks(self, refresh_token: str, account_alias: str = "", account_index: Optional[int] = None) -> int: """完成阅读任务 - 支持令牌缓存""" if not refresh_token: print_log("阅读任务", "未提供刷新令牌，跳过阅读任务", account_index) return 0 try: # 获取访问令牌（支持令牌自动更新） access_token = self.get_access_token(refresh_token, account_alias, account_index) if not access_token: print_log("阅读任务", "无法获取访问令牌，跳过阅读任务", account_index) return 0 # 获取阅读进度 try: progress_data = self.get_read_progress(access_token, account_index) max_reads = progress_data['max'] current_progress = progress_data['progress'] except Exception as e: print_log("阅读任务", f"获取阅读进度失败: {e}，跳过阅读任务", account_index) return 0 if current_progress >= max_reads: # print_log("阅读任务", "阅读任务已完成", account_index) return current_progress else: print_log("阅读任务", f"当前阅读进度: {current_progress}/{max_reads}", account_index) # 执行阅读任务 read_attempts = 0 max_attempts = max_reads - current_progress for i in range(max_attempts): print_log("阅读任务", f"执行第 {i + 1} 次阅读任务", account_index) if self.submit_read_activity(access_token, account_index): read_attempts += 1 # 延迟一段时间 delay = random.uniform(5, 10) print_log("阅读任务", f"阅读任务提交成功，等待 {delay:.1f} 秒", account_index) time.sleep(delay) # 再次检查进度 try: progress_data = self.get_read_progress(access_token, account_index) new_progress = progress_data['progress'] except Exception as e: print_log("阅读任务", f"重新获取进度失败: {e}，继续执行", account_index) # 如果重新获取进度失败，继续执行但不更新进度 continue if new_progress > current_progress: current_progress = new_progress print_log("阅读任务", f"阅读进度更新: {current_progress}/{max_reads}", account_index) if current_progress >= max_reads: # print_log("阅读任务", "所有阅读任务已完成", account_index) break else: print_log("阅读任务", f"第 {i + 1} 次阅读任务提交失败", account_index) time.sleep(random.uniform(2, 5)) print_log("阅读任务", f"阅读任务执行完成，最终进度: {current_progress}/{max_reads}", account_index) return current_progress except Exception as e: print_log("阅读任务", f"阅读任务执行异常: {e}", account_index) return 0 # ==================== 6. 活动任务相关方法 ==================== def complete_daily_set_tasks(self, cookies: str, token: str, account_index: Optional[int] = None) -> int: """完成每日活动任务""" completed_count = 0 try: # 获取dashboard数据 dashboard_data = self.get_dashboard_data(cookies, account_index) if not dashboard_data: return completed_count # 提取每日任务 today_str = date.today().strftime('%m/%d/%Y') dashboard = dashboard_data.get('dashboard', {}) if not dashboard: return completed_count daily_set_promotions = dashboard.get('dailySetPromotions', {}) if not daily_set_promotions: daily_set_promotions = {} daily_tasks = daily_set_promotions.get(today_str, []) if not daily_tasks: # 检查是否所有任务都已完成 dashboard = dashboard_data.get('dashboard', {}) if dashboard: all_daily_promotions = dashboard.get('dailySetPromotions', {}) if all_daily_promotions and today_str in all_daily_promotions: # 有任务数据但为空，说明可能已完成或其他原因 pass # 不输出"没有找到任务"的日志，让状态检查方法处理 else: print_log("每日活动", "没有找到今日的每日活动任务", account_index) return completed_count # 过滤未完成的任务 incomplete_tasks = [task for task in daily_tasks if not task.get('complete')] if not incomplete_tasks: return completed_count print_log("每日活动", f"找到 {len(incomplete_tasks)} 个未完成的每日活动任务", account_index) # 执行任务 for i, task in enumerate(incomplete_tasks, 1): print_log("每日活动", f"⏳ 执行任务 {i}/{len(incomplete_tasks)}: {task.get('title', '未知任务')}", account_index) if self._execute_task(task, token, cookies, account_index): completed_count += 1 print_log("每日活动", f"✅ 任务完成: {task.get('title', '未知任务')}", account_index) else: print_log("每日活动", f"❌ 任务失败: {task.get('title', '未知任务')}", account_index) # 随机延迟 time.sleep(random.uniform(config.TASK_DELAY_MIN, config.TASK_DELAY_MAX)) # print_log("每日活动", f"每日活动执行完成，成功完成 {completed_count} 个任务", account_index) except Exception as e: print_log('每日活动出错', f"异常: {e}", account_index) return completed_count def get_daily_tasks_status(self, cookies: str, account_index: Optional[int] = None) -> tuple: """获取每日活动任务状态""" try: # 获取dashboard数据 dashboard_data = self.get_dashboard_data(cookies, account_index) if not dashboard_data: return 0, 0 # 提取每日任务 today_str = date.today().strftime('%m/%d/%Y') dashboard = dashboard_data.get('dashboard', {}) if not dashboard: return 0, 0 daily_set_promotions = dashboard.get('dailySetPromotions', {}) if not daily_set_promotions: daily_set_promotions = {} daily_tasks = daily_set_promotions.get(today_str, []) if not daily_tasks: return 0, 0 # 统计已完成和总任务数 total_tasks = len(daily_tasks) completed_tasks = len([task for task in daily_tasks if task.get('complete')]) return completed_tasks, total_tasks except Exception as e: print_log('每日活动状态获取出错', f"异常: {e}", account_index) return 0, 0 def complete_more_activities_with_filtering(self, cookies: str, token: str, account_index: Optional[int] = None) -> int: """完成更多活动任务（带智能筛选）""" try: # 获取dashboard数据 dashboard_data = self.get_dashboard_data(cookies, account_index) if not dashboard_data: print_log("更多活动", "无法获取dashboard数据，跳过更多活动", account_index) return 0 # 提取更多活动任务（已内置筛选逻辑） dashboard = dashboard_data.get('dashboard', {}) if not dashboard: return 0 # 获取morePromotions和promotionalItems两个数组 more_promotions = dashboard.get('morePromotions', []) promotional_items = dashboard.get('promotionalItems', []) # 合并两个数组并提取任务 all_promotions = more_promotions + promotional_items valuable_tasks = self._extract_tasks(all_promotions) if not valuable_tasks: return 0 print_log("更多活动", f"找到 {len(valuable_tasks)} 个有价值的更多活动任务", account_index) # 执行筛选后的任务 completed_count = 0 for i, task in enumerate(valuable_tasks, 1): print_log("更多活动", f"⏳ 执行任务 {i}/{len(valuable_tasks)}: {task.get('title', '未知任务')}", account_index) if self._execute_task(task, token, cookies, account_index): completed_count += 1 print_log("更多活动", f"✅ 任务完成: {task.get('title', '未知任务')}", account_index) else: print_log("更多活动", f"❌ 任务失败: {task.get('title', '未知任务')}", account_index) # 随机延迟 time.sleep(random.uniform(config.TASK_DELAY_MIN, config.TASK_DELAY_MAX)) return completed_count except Exception as e: print_log("更多活动出错", f"异常: {e}", account_index) return 0 def get_more_activities_status(self, cookies: str, account_index: Optional[int] = None) -> tuple: """获取更多活动任务状态""" try: # 获取dashboard数据 dashboard_data = self.get_dashboard_data(cookies, account_index) if not dashboard_data: return 0, 0 # 提取更多活动任务 dashboard = dashboard_data.get('dashboard', {}) if not dashboard: return 0, 0 # 获取morePromotions和promotionalItems两个数组 more_promotions = dashboard.get('morePromotions', []) promotional_items = dashboard.get('promotionalItems', []) # 合并两个数组 all_promotions = more_promotions + promotional_items if not all_promotions: return 0, 0 # 统计所有有价值任务（包括已完成和未完成的） valuable_tasks = [] completed_count = 0 for promotion in all_promotions: complete = promotion.get('complete') priority = promotion.get('priority') attributes = promotion.get('attributes', {}) is_unlocked = attributes.get('is_unlocked') max_points = promotion.get('pointProgressMax', 0) # 跳过没有积分奖励的任务 if max_points <= 0: continue # 跳过明确被锁定的任务 if is_unlocked == 'False': continue # 统计所有有积分奖励且未明确锁定的任务 # 优先级检查：-30到7都是有效优先级，None值视为无效 if priority is not None and -30 <= priority <= 7: valuable_tasks.append(promotion) if complete: # 已完成的有价值任务 completed_count += 1 total_valuable_tasks = len(valuable_tasks) return completed_count, total_valuable_tasks except Exception as e: print_log('更多活动状态获取出错', f"异常: {e}", account_index) return 0, 0 # ==================== 7. 内部辅助方法 ==================== def _extract_tasks(self, more_promotions: List[Dict[str, Any]]) -> List[Dict[str, Any]]: """提取任务""" tasks = [] for promotion in more_promotions: complete = promotion.get('complete') priority = promotion.get('priority') attributes = promotion.get('attributes', {}) is_unlocked = attributes.get('is_unlocked') # 任务必须未完成 if complete == False: # 严格检查解锁状态，排除明确被锁定的任务 if is_unlocked == 'False': continue # 跳过明确被锁定的任务 # 跳过没有积分奖励的任务 max_points = promotion.get('pointProgressMax', 0) if max_points <= 0: continue # 只执行解锁的任务或解锁状态未知但优先级合适的任务 if (priority is not None and -30 <= priority <= 7 and (is_unlocked == 'True' or is_unlocked is None)): tasks.append(promotion) return tasks def _execute_task(self, task: Dict[str, Any], token: str, cookies: str, account_index: Optional[int] = None) -> bool: """执行单个任务""" try: destination_url = task.get('destinationUrl') or task.get('attributes', {}).get('destination') if not destination_url: print_log("任务执行", f"❌ 任务 {task.get('name')} 没有目标URL", account_index) return False # 设置任务执行请求头 headers = { 'User-Agent': config.get_random_pc_ua(), 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7', 'Cookie': cookies } # 发送请求 response = self.request_manager.make_request('GET', destination_url, headers, timeout=config.REQUEST_TIMEOUT, account_index=account_index) if response.status_code == 200: # # 添加延时，让系统有时间更新任务状态 # delay_time = random.uniform(7, 10) # # print_log("任务执行", f"⏳ 任务访问成功，等待 {delay_time:.1f} 秒让系统更新状态...", account_index) # time.sleep(delay_time) # 报告活动 if self._report_activity(task, token, cookies, account_index): return True else: print_log("任务执行", f"⚠️ 任务执行成功但活动报告失败", account_index) return False else: print_log("任务执行", f"❌ 任务执行失败，状态码: {response.status_code}", account_index) return False except Exception as e: print_log("任务执行", f"❌ 执行任务时出错: {e}", account_index) return False def _report_activity(self, task: Dict[str, Any], token: str, cookies: str, account_index: Optional[int] = None) -> bool: """报告任务活动，真正完成任务""" if not token: print_log("活动报告", "❌ 缺少token", account_index) return False try: post_url = 'https://rewards.bing.com/api/reportactivity?X-Requested-With=XMLHttpRequest' post_headers = { 'User-Agent': config.get_random_pc_ua(), 'Accept': 'application/json, text/javascript, */*; q=0.01', 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'X-Requested-With': 'XMLHttpRequest', 'Origin': 'https://rewards.bing.com', 'Referer': 'https://rewards.bing.com/', 'Cookie': cookies } payload = f"id={task.get('offerId', task.get('name'))}&hash={task.get('hash', '')}&timeZone=480&activityAmount=1&dbs=0&form=&type=&__RequestVerificationToken={token}" response = self.request_manager.make_request('POST', post_url, post_headers, data=payload, timeout=config.REQUEST_TIMEOUT, account_index=account_index) if response.status_code == 200: try: result = response.json() # print_log("活动报告", f"API响应: {result}", account_index) # 添加详细日志 if result.get("activity") and result["activity"].get("points", 0) >= 0: print_log("任务奖励", f"✅ 获得{result['activity']['points']}积分", account_index) return True else: print_log("活动报告", f"❌ 响应中没有积分信息: {result}", account_index) return False except json.JSONDecodeError as e: print_log("活动报告", f"❌ JSON解析失败: {e}, 响应内容: {response.text}", account_index) return False else: print_log("活动报告", f"❌ API状态码: {response.status_code}, 响应: {response.text}", account_index) return False except Exception as e: print_log("活动报告", f"❌ 异常: {e}", account_index) return False # ==================== 8. 通知方法 ==================== def _send_cookie_invalid_notification(self, account_index: Optional[int] = None): """发送Cookie失效的独立通知""" try: self.notification_manager.send_cookie_invalid(account_index) print_log("Cookie通知", f"已发送账号{account_index}的Cookie失效通知", account_index) except Exception as e: print_log("Cookie通知", f"发送Cookie失效通知失败: {e}", account_index) def _send_token_invalid_notification(self, account_index: Optional[int] = None): """发送刷新令牌失效的独立通知""" try: title = f"🚨 Microsoft Rewards 刷新令牌失效警告" content = f"账号{account_index} 的刷新令牌已失效，阅读任务无法执行！\n\n" content += f"失效时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n" content += f"需要处理: 重新获取账号{account_index}的刷新令牌\n\n" content += f"刷新令牌获取步骤:\n" content += f"1. 安装 油猴脚本\n" content += f"2. 访问 https://login.live.com/oauth20_authorize.srf?client_id=0000000040170455&scope=service::prod.rewardsplatform.microsoft.com::MBI_SSL&response_type=code&redirect_uri=https://login.live.com/oauth20_desktop.srf\n" content += f"3. 登录后，使用 油猴脚本，自动获取刷新令牌\n" content += f"4. 更新环境变量 bing_token_{account_index} 为获取到的刷新令牌\n" content += f"5. 重新运行脚本\n" self.notification_manager.send(title, content) print_log("令牌通知", f"已发送账号{account_index}的刷新令牌失效通知", account_index) except Exception as e: print_log("令牌通知", f"发送刷新令牌失效通知失败: {e}", account_index) def get_today_earned_points(self, dashboard_data: Dict[str, Any], account_index: Optional[int] = None) -> int: """从dashboard数据中获取今日总共获得的积分""" if not dashboard_data: return 0 # 尝试从不同位置获取pointsSummary points_summary = None # 如果根级别没有，尝试从status获取 if not points_summary: status = dashboard_data.get('status', {}) if status and 'pointsSummary' in status: points_summary = status.get('pointsSummary', []) if not points_summary: return 0 # 获取今天是周几 (0=周日, 1=周一, ..., 6=周六) import datetime today_weekday = datetime.datetime.now().weekday() # Python的weekday(): 0=周一, 6=周日 # API的dayOfWeek: 0=周日, 1=周一, ..., 6=周六 api_today = (today_weekday + 1) % 7 # 查找今日的积分记录 for day_record in points_summary: if day_record.get('dayOfWeek') == api_today: return day_record.get('pointsEarned', 0) return 0 # ==================== 主程序类 ==================== class RewardsBot: """Microsoft Rewards 自动化机器人主类 - 多账号分离版本""" def __init__(self): self.accounts = AccountManager.get_accounts() if not self.accounts: print_log("启动错误", "没有检测到任何账号配置，程序退出") print_log("配置提示", "请设置环境变量: bing_ck_1, bing_ck_2... 和可选的 bing_token_1, bing_token_2...") exit(1) # 检查是否应该跳过执行（在获取账号后检查，避免在账号配置错误时也跳过） current_complete_count = global_cache_manager.get_tasks_complete_count() # 强制检查计数是否超过设定次数 if current_complete_count >= TASK_CONFIG['MAX_REPEAT_COUNT']: print_log("脚本跳过", f"已重复运行{current_complete_count}次，跳过执行") exit(0) elif current_complete_count > 0: print_log("系统提示", f"已重复运行{current_complete_count}/{TASK_CONFIG['MAX_REPEAT_COUNT']}次", None) print_log("初始化", f"检测到 {len(self.accounts)} 个账号，即将开始...") # 统计有效刷新令牌数量 valid_tokens = sum(1 for account in self.accounts if account.refresh_token) if valid_tokens > 0: print_log("初始化", f"检测到 {valid_tokens} 个令牌，启用APP阅读...") def _calculate_required_searches(self, dashboard_data: Dict[str, Any], search_type: str) -> int: """根据dashboard数据精确计算需要的搜索次数""" if not dashboard_data: return 0 dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) counters = user_status.get('counters', {}) search_tasks = counters.get(search_type, []) if not search_tasks: return 0 task = search_tasks[0] # 通常只有一个搜索任务 if task.get('complete', False): return 0 max_points = task.get('pointProgressMax', 0) current_points = task.get('pointProgress', 0) points_needed = max_points - current_points # 每次搜索3积分，但从第3次搜索开始计分 if points_needed <= 0: return 0 # 计算需要的搜索次数（向上取整） searches_needed = (points_needed + 2) // 3 # +2是为了向上取整 return max(0, searches_needed) def _get_account_level_details(self, dashboard_data: Dict[str, Any]) -> Dict[str, Any]: """获取详细的账号等级信息""" if not dashboard_data: return {'level': 'Level1', 'name': '一级', 'progress': 0, 'max': 0} dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) level_info = user_status.get('levelInfo', {}) # 确保level_info不为None if not level_info: return {'level': 'Level1', 'name': '一级', 'progress': 0, 'max': 0} return { 'level': level_info.get('activeLevel', 'Level1'), 'name': level_info.get('activeLevelName', '一级'), 'progress': level_info.get('progress', 0), 'max': level_info.get('progressMax', 0), 'last_month_level': level_info.get('lastMonthLevel', 'Level1') } def process_single_account(self, account: AccountInfo, service: RewardsService, stop_event: threading.Event) -> Optional[str]: """处理单个账号的完整流程""" try: account_index = account.index cookies = account.cookies # 获取账号信息 initial_data = service.get_rewards_points(cookies, account_index) if not initial_data: print_log("账号处理", "获取账号信息失败，跳过此账号", account_index) return None email = initial_data.get('email', '未知邮箱') token = initial_data.get('token') current_points = initial_data['points'] # 当前即时积分 logger.account_start(email, current_points, account_index) # 执行阅读任务 read_completed = 0 if account.refresh_token: read_completed = service.complete_read_tasks(account.refresh_token, account.alias, account_index) logger.success("阅读任务", f"已完成 ({read_completed}/30)", account_index) else: logger.skip("阅读任务", "未配置刷新令牌", account_index) # 初始化变量，避免未定义错误 daily_completed = 0 daily_total = 0 more_completed = 0 more_total = 0 # 执行每日任务 if token: # 先执行任务 new_daily_completed = service.complete_daily_set_tasks(cookies, token, account_index) # 然后获取总的完成状态 daily_completed, daily_total = service.get_daily_tasks_status(cookies, account_index) logger.success("每日活动", f"已完成 ({daily_completed}/{daily_total})", account_index) else: logger.skip("每日活动", "无法获取token", account_index) # 执行更多任务 if token: # 先执行任务 new_more_completed = service.complete_more_activities_with_filtering(cookies, token, account_index) # 然后获取总的完成状态 more_completed, more_total = service.get_more_activities_status(cookies, account_index) logger.success("更多活动", f"已完成 ({more_completed}/{more_total})", account_index) else: logger.skip("更多活动", "无法获取token", account_index) # 执行搜索任务 self._perform_search_tasks(cookies, account_index, email, service, stop_event) # 获取最终积分 final_data = service.get_rewards_points(cookies, account_index) if final_data and final_data['points'] is not None: final_points = final_data['points'] # 获取dashboard数据来显示今日总积分 final_dashboard_data = service.get_dashboard_data(cookies, account_index) today_total_earned = service.get_today_earned_points(final_dashboard_data, account_index) if final_dashboard_data else 0 # 使用新的日志格式：任务完成 + 今日积分 self._log_account_complete(final_points, today_total_earned, account_index) # 生成详细的任务摘要 summary = self._format_account_summary( email, current_points, final_points, daily_completed, more_completed, read_completed, account_index, cookies, account, service, today_total_earned ) return summary else: print_log("脚本完成", "无法获取最终积分", account_index) return None except SystemExit: # 搜索任务未完成，线程被终止 #print_log("账号处理", f"搜索任务未完成，账号处理被终止", account_index) return None except Exception as e: error_details = traceback.format_exc() print_log("账号处理错误", f"处理账号时发生异常: {e}", account_index) print_log("错误详情", f"详细错误信息: {error_details}", account_index) return None def _perform_search_tasks(self, cookies: str, account_index: int, email: str, service: RewardsService, stop_event: threading.Event): """执行搜索任务""" # 获取初始dashboard数据检查任务状态 dashboard_data = service.get_dashboard_data(cookies, account_index) # 获取账号等级 account_level = service.get_account_level(dashboard_data) # print_log("账号等级", f"当前账号等级: {account_level}", account_index) # 电脑搜索 if dashboard_data: # 获取搜索状态 pc_current, pc_max = self._get_search_status(dashboard_data, 'pcSearch') # 使用双重检查确保准确性 is_complete_by_flag = service.is_pc_search_complete(dashboard_data) is_complete_by_progress = pc_current >= pc_max and pc_max > 0 if is_complete_by_flag or is_complete_by_progress: # 任务已完成 logger.success("电脑搜索", f"已完成 ({pc_current}/{pc_max})", account_index) else: # 任务确实未完成，开始执行搜索 required_searches = self._calculate_required_searches(dashboard_data, 'pcSearch') logger.search_start("电脑", required_searches, config.SEARCH_CHECK_INTERVAL, account_index) # 记录初始进度 last_progress = self._get_search_progress_sum(dashboard_data, 'pcSearch') # 执行搜索，如果任务完成则提前终止 count = 0 for i in range(config.SEARCH_CHECK_INTERVAL): count += 1 if service.perform_pc_search(cookies, account_index, email): delay = random.randint(config.SEARCH_DELAY_MIN, config.SEARCH_DELAY_MAX) logger.search_progress("电脑", i+1, config.SEARCH_CHECK_INTERVAL, delay, account_index) time.sleep(delay) else: print_log("电脑搜索", f"第{i+1}次搜索失败", account_index) # 每次搜索后检查进度（静默模式，避免错误日志干扰） dashboard_data = service.get_dashboard_data(cookies, account_index, silent=True) current_progress = self._get_search_progress_sum(dashboard_data, 'pcSearch') if dashboard_data else last_progress # 第6次搜索完成后输出进度变化 if count == config.SEARCH_CHECK_INTERVAL: logger.search_progress_summary("电脑", count, last_progress, current_progress, account_index) # 检查任务是否完成，如果完成则提前终止 if dashboard_data and service.is_pc_search_complete(dashboard_data): logger.search_complete("电脑", i+1, account_index, True) break # 如果循环正常结束（没有break），检查任务是否真正完成 else: if dashboard_data and not service.is_pc_search_complete(dashboard_data): # print_log("电脑搜索", f"执行完{config.SEARCH_CHECK_INTERVAL}次搜索后任务未完成，停止线程", account_index) stop_event.set() raise SystemExit() else: logger.warning("电脑搜索", "无法获取状态", account_index) # 移动搜索 - 只有非1级账号才执行 if account_level != "Level1": # 重新获取dashboard数据，因为电脑搜索可能已经改变了状态 dashboard_data = service.get_dashboard_data(cookies, account_index) if dashboard_data: # 获取搜索状态 mobile_current, mobile_max = self._get_search_status(dashboard_data, 'mobileSearch') # 使用双重检查确保准确性 is_complete_by_flag = service.is_mobile_search_complete(dashboard_data) is_complete_by_progress = mobile_current >= mobile_max and mobile_max > 0 if is_complete_by_flag or is_complete_by_progress: # 任务已完成 logger.success("移动搜索", f"已完成 ({mobile_current}/{mobile_max})", account_index) else: # 任务确实未完成，开始执行搜索 required_searches = self._calculate_required_searches(dashboard_data, 'mobileSearch') logger.search_start("移动", required_searches, config.SEARCH_CHECK_INTERVAL, account_index) # 执行搜索逻辑 last_progress = self._get_search_progress_sum(dashboard_data, 'mobileSearch') count = 0 for i in range(config.SEARCH_CHECK_INTERVAL): count += 1 if service.perform_mobile_search(cookies, account_index, email): delay = random.randint(config.SEARCH_DELAY_MIN, config.SEARCH_DELAY_MAX) logger.search_progress("移动", i+1, config.SEARCH_CHECK_INTERVAL, delay, account_index) time.sleep(delay) else: print_log("移动搜索", f"第{i+1}次搜索失败", account_index) # 检查进度 dashboard_data = service.get_dashboard_data(cookies, account_index, silent=True) current_progress = self._get_search_progress_sum(dashboard_data, 'mobileSearch') if dashboard_data else last_progress if count == config.SEARCH_CHECK_INTERVAL: logger.search_progress_summary("移动", count, last_progress, current_progress, account_index) # 检查是否完成 if dashboard_data and service.is_mobile_search_complete(dashboard_data): logger.search_complete("移动", i+1, account_index, True) break else: # 循环结束但任务未完成 if dashboard_data and not service.is_mobile_search_complete(dashboard_data): stop_event.set() raise SystemExit() else: logger.warning("移动搜索", "无法获取状态", account_index) else: logger.search_skip("移动", "1级账号无此任务", account_index) def _get_search_progress_sum(self, dashboard_data: Dict[str, Any], search_type: str) -> int: """获取搜索进度总和""" if not dashboard_data: return 0 dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) counters = user_status.get('counters', {}) search_tasks = counters.get(search_type, []) return sum(task.get('pointProgress', 0) for task in search_tasks) def _get_search_progress_max(self, dashboard_data: Dict[str, Any], search_type: str) -> int: """获取搜索进度最大值""" if not dashboard_data: return 0 dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) counters = user_status.get('counters', {}) search_tasks = counters.get(search_type, []) return sum(task.get('pointProgressMax', 0) for task in search_tasks) def _get_search_status(self, dashboard_data: Dict[str, Any], search_type: str) -> tuple: """获取搜索状态 (当前进度, 最大值)""" current = self._get_search_progress_sum(dashboard_data, search_type) maximum = self._get_search_progress_max(dashboard_data, search_type) return current, maximum def _log_account_complete(self, final_points: int, today_earned: int, account_index: int): """记录账号任务完成日志""" msg = f"{final_points} ({today_earned})" logger._log(2, "🎉", "任务完成", msg, account_index) # 2 = LogLevel.SUCCESS def _format_account_summary(self, email: str, start_points: int, final_points: int, daily_completed: int, more_completed: int, read_completed: int, account_index: int, cookies: str, account: AccountInfo, service: RewardsService, today_total_earned: int = 0) -> str: """格式化账号摘要""" lines = [ f"账号{account_index} - {email}", f"📊当前积分: {final_points} ({today_total_earned})" ] # 获取dashboard数据 try: dashboard_data = service.get_dashboard_data(cookies, account_index) if dashboard_data and dashboard_data.get('dashboard'): dashboard = dashboard_data.get('dashboard', {}) user_status = dashboard.get('userStatus', {}) counters = user_status.get('counters', {}) # 每日活动统计 today_str = date.today().strftime('%m/%d/%Y') daily_set_promotions = dashboard.get('dailySetPromotions', {}) if not daily_set_promotions: daily_set_promotions = {} daily_tasks = daily_set_promotions.get(today_str, []) daily_completed_count = 0 daily_total_count = 0 if daily_tasks: daily_completed_count = sum(1 for task in daily_tasks if task.get('complete')) daily_total_count = len(daily_tasks) lines.append(f"📅每日活动: {daily_completed_count}/{daily_total_count}") # 更多活动统计 - 使用与日志相同的筛选逻辑 more_tasks = dashboard.get('morePromotions', []) if not more_tasks: more_tasks = [] more_completed_count = 0 more_total_count = 0 if more_tasks: for task in more_tasks: complete = task.get('complete') priority = task.get('priority') attributes = task.get('attributes', {}) is_unlocked = attributes.get('is_unlocked') max_points = task.get('pointProgressMax', 0) # 跳过没有积分奖励的任务 if max_points <= 0: continue # 跳过明确被锁定的任务 if is_unlocked == 'False': continue # 统计所有有积分奖励且未明确锁定的任务 # 优先级检查：-1到7都是有效优先级，None值视为无效 if priority is not None and -30 <= priority <= 7: more_total_count += 1 if complete: # 已完成的有价值任务 more_completed_count += 1 lines.append(f"🎯更多活动: {more_completed_count}/{more_total_count}") # 阅读任务进度 - 获取真实进度，但避免重复缓存 read_progress_text = f"📖阅读任务: {read_completed}/30" if account.refresh_token: try: # 静默获取access_token，不触发缓存 access_token = service.get_access_token(account.refresh_token, account.alias, account_index, silent=True) if access_token: progress_data = service.get_read_progress(access_token, account_index) if progress_data and isinstance(progress_data, dict): read_progress_text = f"📖阅读任务: {progress_data.get('progress', 0)}/{progress_data.get('max', 3)}" except: pass # 如果获取失败，使用默认格式 lines.append(read_progress_text) # 搜索任务进度 # 获取详细账号等级信息 level_details = self._get_account_level_details(dashboard_data) account_level = level_details.get('level', 'Level1') if level_details else 'Level1' # 电脑搜索进度 pc_search_tasks = counters.get("pcSearch", []) if pc_search_tasks: for task in pc_search_tasks: if task: # 确保task不为None title = task.get('title', "电脑搜索") progress = f"{task.get('pointProgress', 0)}/{task.get('pointProgressMax', 0)}" lines.append(f"💻电脑搜索: {progress}") else: lines.append("💻电脑搜索: 无数据") # 移动搜索进度 - 只有非1级账号才显示 if account_level != "Level1": mobile_search_tasks = counters.get("mobileSearch", []) if mobile_search_tasks: for task in mobile_search_tasks: if task: # 确保task不为None title = task.get('title', "移动搜索") progress = f"{task.get('pointProgress', 0)}/{task.get('pointProgressMax', 0)}" lines.append(f"📱移动搜索: {progress}") else: lines.append("📱移动搜索: 无数据") else: lines.append("📱移动搜索: 1级账号无此任务") else: # 如果无法获取dashboard数据，使用简化格式 lines.extend([ f"📅每日活动: 完成 {daily_completed} 个任务", f"🎯更多活动: 完成 {more_completed} 个任务", f"📖阅读任务: 完成 {read_completed} 个任务", f"🔍搜索任务: 电脑搜索和移动搜索已执行" ]) except Exception as e: # 异常情况下使用简化格式 lines.extend([ f"📅每日活动: 完成 {daily_completed} 个任务", f"🎯更多活动: 完成 {more_completed} 个任务", f"📖阅读任务: 完成 {read_completed} 个任务", f"🔍搜索任务: 电脑搜索和移动搜索已执行" ]) return '\n'.join(lines) def run(self): """运行主程序""" account_summaries = {} # 使用字典保存账号摘要，key为账号索引 threads = [] summaries_lock = threading.Lock() # 为每个线程创建独立的停止事件，避免全局共享 thread_stop_events = {} def thread_worker(account: AccountInfo): # 为每个线程创建独立的RewardsService实例，避免共享状态 service = RewardsService() # 为每个线程创建独立的停止事件 thread_stop_events[account.index] = threading.Event() try: summary = self.process_single_account(account, service, thread_stop_events[account.index]) if summary: with summaries_lock: account_summaries[account.index] = summary except SystemExit: # 搜索任务失败导致的线程终止，不记录为错误 pass except Exception as e: print_log(f"账号{account.index}错误", f"处理账号时发生异常: {e}", account.index) finally: # 确保Service实例被正确清理 if hasattr(service, 'request_manager'): service.request_manager.close() # 启动所有账号的处理线程 for account in self.accounts: t = threading.Thread(target=thread_worker, args=(account,)) threads.append(t) t.start() # 等待所有线程完成 for t in threads: t.join() # 按账号索引排序并转换为列表 sorted_summaries = [] if account_summaries: # 按账号索引排序 for account_index in sorted(account_summaries.keys()): sorted_summaries.append(account_summaries[account_index]) # 检查是否有线程因搜索失败而停止 any_search_failed = any(event.is_set() for event in thread_stop_events.values()) # 推送结果 self._send_notification(sorted_summaries, any_search_failed) def _send_notification(self, summaries: List[str], any_search_failed: bool): """发送通知""" if any_search_failed: print(f"\n\n{'='*17} [任务未全部完成] {'='*17}") print_log(f"系统提示", f"搜索任务未全部完成") print_log(f"系统提示", f"建议每 30+ 分钟重新运行一次") print_log(f"统一推送", "任务未全部完成，取消推送") print(f"{'='*17} [任务未全部完成] {'='*17}") return else: print(f"\n\n{'='*17} [全部任务完成] {'='*17}") # 增加任务完成计数 global_cache_manager.increment_tasks_complete_count() if summaries: content = "\n\n".join(summaries) if global_cache_manager.has_pushed_today(): print_log("统一推送", "今天已经推送过，取消本次推送。") else: print_log("统一推送", "准备发送所有账号的总结报告...") try: title = f"Microsoft Rewards 任务总结 ({date.today().strftime('%Y-%m-%d')})" global_notification_manager.send(title, content) print_log("推送成功", "总结报告已发送。") global_cache_manager.mark_pushed_today() except Exception as e: print_log("推送失败", f"发送总结报告时出错: {e}") else: print_log("统一推送", "没有可供推送的账号信息。") return # 无论是否推送，都在日志末尾打印内容摘要 print(f"{'='*17} [全部任务完成] {'='*17}") # ==================== 主程序入口 ==================== def main(): """主程序入口""" try: bot = RewardsBot() bot.run() except KeyboardInterrupt: print_log("程序中断", "用户中断程序执行") except Exception as e: print_log("程序错误", f"程序执行出错: {e}") if __name__ == "__main__": main()