diff --git a/Microsoft_Rewards_v2.1.py b/Microsoft_Rewards_v2.1.py new file mode 100644 index 0000000..520af40 --- /dev/null +++ b/Microsoft_Rewards_v2.1.py @@ -0,0 +1,2759 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +# cron: 1 7 * * 7 +# const $ = new Env("微软积分"); +""" +🎯 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 + +""" + +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 + +# ==================== Bark 推送配置 ==================== +# Bark 推送地址（默认配置文件读取） +BARK_PUSH = os.getenv("BARK_PUSH") + +# Bark 推送图标和推送分组（不填则读取配置文件） +CUSTOM_BARK_ICON = "https://rewards.bing.com/rewardscdn/images/rewards.png" # 自定义图标 +CUSTOM_BARK_GROUP = "Microsoft Rewards" # 自定义分组 + +# 定义全局变量 +BARK_ICON = CUSTOM_BARK_ICON or os.getenv("BARK_ICON", "") +BARK_GROUP = CUSTOM_BARK_GROUP or os.getenv("BARK_GROUP", "") + +# 覆盖环境变量 +os.environ["BARK_ICON"] = BARK_ICON +os.environ["BARK_GROUP"] = BARK_GROUP + + +# ==================== 用户配置区域 ==================== +# 在这里修改您的配置参数 +# +# 📝 配置说明： +# 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()