|
|
#!/usr/bin/env python3
|
|
|
"""
|
|
|
Leaflow 多账号自动签到脚本
|
|
|
变量名：LEAFLOW_ACCOUNTS
|
|
|
变量值：邮箱1:密码1,邮箱2:密码2,邮箱3:密码3
|
|
|
"""
|
|
|
|
|
|
import os
|
|
|
import time
|
|
|
import logging
|
|
|
import traceback
|
|
|
from selenium.common.exceptions import TimeoutException
|
|
|
from selenium import webdriver
|
|
|
from selenium.webdriver.common.by import By
|
|
|
from selenium.webdriver.support.ui import WebDriverWait
|
|
|
from selenium.webdriver.support import expected_conditions as EC
|
|
|
from selenium.webdriver.chrome.options import Options
|
|
|
from selenium.webdriver.common.action_chains import ActionChains
|
|
|
import requests
|
|
|
from datetime import datetime
|
|
|
|
|
|
# 配置日志
|
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class LeaflowAutoCheckin:
|
|
|
def __init__(self, email, password):
|
|
|
self.email = email
|
|
|
self.password = password
|
|
|
|
|
|
if not self.email or not self.password:
|
|
|
raise ValueError("邮箱和密码不能为空")
|
|
|
|
|
|
self.driver = None
|
|
|
self.setup_driver()
|
|
|
|
|
|
def setup_driver(self):
|
|
|
"""设置Chrome驱动选项"""
|
|
|
chrome_options = Options()
|
|
|
|
|
|
# 基础稳定配置（适用于所有环境）
|
|
|
chrome_options.add_argument('--disable-blink-features=AutomationControlled')
|
|
|
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
|
|
|
chrome_options.add_experimental_option('useAutomationExtension', False)
|
|
|
|
|
|
# 增强稳定性的通用选项
|
|
|
chrome_options.add_argument('--disable-gpu') # 禁用GPU加速，减少渲染问题
|
|
|
chrome_options.add_argument('--disable-dev-shm-usage') # 禁用/dev/shm使用，避免内存问题
|
|
|
chrome_options.add_argument('--no-sandbox') # 禁用沙箱，提高兼容性
|
|
|
chrome_options.add_argument('--disable-extensions') # 禁用扩展，减少干扰
|
|
|
chrome_options.add_argument('--disable-plugins') # 禁用插件，减少资源占用
|
|
|
chrome_options.add_argument('--disable-images') # 禁用图片加载，提高页面加载速度
|
|
|
# chrome_options.add_argument('--disable-javascript') # 启用JavaScript，签到页面功能依赖它
|
|
|
chrome_options.add_argument('--window-size=1920,1080') # 设置窗口大小
|
|
|
chrome_options.add_argument('--ignore-certificate-errors') # 忽略证书错误
|
|
|
chrome_options.add_argument('--ignore-ssl-errors') # 忽略SSL错误
|
|
|
chrome_options.add_argument('--allow-insecure-localhost') # 允许不安全的localhost连接
|
|
|
chrome_options.add_argument('--log-level=3') # 减少Chrome日志输出
|
|
|
|
|
|
# 优化资源占用的选项
|
|
|
chrome_options.add_argument('--disable-background-timer-throttling') # 禁用后台定时器节流
|
|
|
chrome_options.add_argument('--disable-backgrounding-occluded-windows') # 禁用后台遮挡窗口
|
|
|
chrome_options.add_argument('--disable-renderer-backgrounding') # 禁用渲染器后台处理
|
|
|
chrome_options.add_argument('--disable-translate') # 禁用翻译
|
|
|
chrome_options.add_argument('--disable-notifications') # 禁用通知
|
|
|
chrome_options.add_argument('--disable-popup-blocking') # 禁用弹窗拦截
|
|
|
chrome_options.add_argument('--disable-default-apps') # 禁用默认应用
|
|
|
chrome_options.add_argument('--disable-sync') # 禁用同步
|
|
|
chrome_options.add_argument('--disable-logging') # 禁用日志
|
|
|
chrome_options.add_argument('--disable-software-rasterizer') # 禁用软件光栅化
|
|
|
chrome_options.add_argument('--disable-features=site-per-process') # 禁用站点隔离
|
|
|
chrome_options.add_argument('--js-flags=--max-old-space-size=256') # 限制JavaScript内存使用
|
|
|
|
|
|
# GitHub Actions环境配置
|
|
|
if os.getenv('GITHUB_ACTIONS'):
|
|
|
chrome_options.add_argument('--headless') # 无头模式
|
|
|
chrome_options.add_argument('--disable-features=VizDisplayCompositor') # 增强无头模式稳定性
|
|
|
chrome_options.add_argument('--headless=new') # 使用新的无头模式
|
|
|
logger.info("已启用GitHub Actions环境配置")
|
|
|
|
|
|
# 使用 webdriver-manager 自动获取匹配的 ChromeDriver
|
|
|
try:
|
|
|
from webdriver_manager.chrome import ChromeDriverManager
|
|
|
from selenium.webdriver.chrome.service import Service
|
|
|
|
|
|
# 尝试获取当前Chrome版本并使用匹配的ChromeDriver
|
|
|
try:
|
|
|
import subprocess
|
|
|
chrome_version = subprocess.check_output(
|
|
|
["google-chrome", "--version"]
|
|
|
).decode("utf-8").strip()
|
|
|
major_version = chrome_version.split(" ")[2].split(".")[0]
|
|
|
logger.info(f"检测到Chrome版本: {chrome_version}")
|
|
|
logger.info(f"使用ChromeDriver主版本: {major_version}")
|
|
|
|
|
|
service = Service(ChromeDriverManager(driver_version=major_version).install())
|
|
|
self.driver = webdriver.Chrome(service=service, options=chrome_options)
|
|
|
|
|
|
# 验证ChromeDriver版本
|
|
|
chromedriver_version = self.driver.capabilities['chrome']['chromedriverVersion'].split(' ')[0]
|
|
|
logger.info(f"已使用ChromeDriver版本: {chromedriver_version}")
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.warning(f"获取Chrome版本失败，使用默认配置: {e}")
|
|
|
service = Service(ChromeDriverManager().install())
|
|
|
self.driver = webdriver.Chrome(service=service, options=chrome_options)
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.warning(f"webdriver-manager 获取 ChromeDriver 失败，使用默认配置: {e}")
|
|
|
self.driver = webdriver.Chrome(options=chrome_options)
|
|
|
|
|
|
self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
|
|
|
|
|
|
# 设置默认超时时间
|
|
|
try:
|
|
|
self.driver.set_page_load_timeout(60) # 页面加载超时
|
|
|
self.driver.set_script_timeout(60) # 脚本执行超时
|
|
|
logger.info(f"已设置超时时间: 页面加载60秒，脚本执行60秒")
|
|
|
except Exception as e:
|
|
|
logger.warning(f"设置超时时间时出错: {e}")
|
|
|
|
|
|
# 移除隐式等待，仅使用显式等待
|
|
|
# self.driver.implicitly_wait(5)
|
|
|
logger.info("浏览器驱动初始化完成")
|
|
|
|
|
|
def close_popup(self):
|
|
|
"""关闭初始弹窗"""
|
|
|
try:
|
|
|
logger.info("尝试关闭初始弹窗...")
|
|
|
time.sleep(3) # 等待弹窗加载
|
|
|
|
|
|
# 尝试关闭弹窗
|
|
|
try:
|
|
|
actions = ActionChains(self.driver)
|
|
|
actions.move_by_offset(10, 10).click().perform()
|
|
|
logger.info("已成功关闭弹窗")
|
|
|
time.sleep(2)
|
|
|
return True
|
|
|
except:
|
|
|
pass
|
|
|
return False
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.warning(f"关闭弹窗时出错: {e}")
|
|
|
return False
|
|
|
|
|
|
def wait_for_element_clickable(self, by, value, timeout=10):
|
|
|
"""等待元素可点击"""
|
|
|
return WebDriverWait(self.driver, timeout).until(
|
|
|
EC.element_to_be_clickable((by, value))
|
|
|
)
|
|
|
|
|
|
def wait_for_element_present(self, by, value, timeout=10):
|
|
|
"""等待元素出现"""
|
|
|
return WebDriverWait(self.driver, timeout).until(
|
|
|
EC.presence_of_element_located((by, value))
|
|
|
)
|
|
|
|
|
|
def login(self):
|
|
|
"""执行登录流程"""
|
|
|
logger.info(f"开始登录流程")
|
|
|
|
|
|
# 访问登录页面
|
|
|
self.driver.get("https://leaflow.net/login")
|
|
|
time.sleep(5)
|
|
|
|
|
|
# 关闭弹窗
|
|
|
self.close_popup()
|
|
|
|
|
|
# 输入邮箱
|
|
|
try:
|
|
|
logger.info("查找邮箱输入框...")
|
|
|
|
|
|
# 等待页面稳定
|
|
|
time.sleep(2)
|
|
|
|
|
|
# 尝试多种选择器找到邮箱输入框
|
|
|
email_selectors = [
|
|
|
"input[type='text']",
|
|
|
"input[type='email']",
|
|
|
"input[placeholder*='邮箱']",
|
|
|
"input[placeholder*='邮件']",
|
|
|
"input[placeholder*='email']",
|
|
|
"input[name='email']",
|
|
|
"input[name='username']"
|
|
|
]
|
|
|
|
|
|
email_input = None
|
|
|
for selector in email_selectors:
|
|
|
try:
|
|
|
email_input = self.wait_for_element_clickable(By.CSS_SELECTOR, selector, 5)
|
|
|
logger.info(f"找到邮箱输入框")
|
|
|
break
|
|
|
except:
|
|
|
continue
|
|
|
|
|
|
if not email_input:
|
|
|
raise Exception("找不到邮箱输入框")
|
|
|
|
|
|
# 清除并输入邮箱
|
|
|
email_input.clear()
|
|
|
email_input.send_keys(self.email)
|
|
|
logger.info("邮箱输入完成")
|
|
|
time.sleep(2)
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.error(f"输入邮箱时出错: {e}")
|
|
|
# 尝试使用JavaScript直接设置值
|
|
|
try:
|
|
|
self.driver.execute_script(f"document.querySelector('input[type=\"text\"], input[type=\"email\"]').value = '{self.email}';")
|
|
|
logger.info("通过JavaScript设置邮箱")
|
|
|
time.sleep(2)
|
|
|
except:
|
|
|
raise Exception(f"无法输入邮箱: {e}")
|
|
|
|
|
|
# 等待密码输入框出现并输入密码
|
|
|
try:
|
|
|
logger.info("查找密码输入框...")
|
|
|
|
|
|
# 等待密码框出现
|
|
|
password_input = self.wait_for_element_clickable(
|
|
|
By.CSS_SELECTOR, "input[type='password']", 10
|
|
|
)
|
|
|
|
|
|
password_input.clear()
|
|
|
password_input.send_keys(self.password)
|
|
|
logger.info("密码输入完成")
|
|
|
time.sleep(1)
|
|
|
|
|
|
except TimeoutException:
|
|
|
raise Exception("找不到密码输入框")
|
|
|
|
|
|
# 点击登录按钮
|
|
|
try:
|
|
|
logger.info("查找登录按钮...")
|
|
|
login_btn_selectors = [
|
|
|
"//button[contains(text(), '登录')]",
|
|
|
"//button[contains(text(), 'Login')]",
|
|
|
"//button[@type='submit']",
|
|
|
"//input[@type='submit']",
|
|
|
"button[type='submit']"
|
|
|
]
|
|
|
|
|
|
login_btn = None
|
|
|
for selector in login_btn_selectors:
|
|
|
try:
|
|
|
if selector.startswith("//"):
|
|
|
login_btn = self.wait_for_element_clickable(By.XPATH, selector, 5)
|
|
|
else:
|
|
|
login_btn = self.wait_for_element_clickable(By.CSS_SELECTOR, selector, 5)
|
|
|
logger.info(f"找到登录按钮")
|
|
|
break
|
|
|
except:
|
|
|
continue
|
|
|
|
|
|
if not login_btn:
|
|
|
raise Exception("找不到登录按钮")
|
|
|
|
|
|
login_btn.click()
|
|
|
logger.info("已点击登录按钮")
|
|
|
|
|
|
except Exception as e:
|
|
|
raise Exception(f"点击登录按钮失败: {e}")
|
|
|
|
|
|
# 等待登录完成
|
|
|
try:
|
|
|
WebDriverWait(self.driver, 20).until(
|
|
|
lambda driver: "dashboard" in driver.current_url or "workspaces" in driver.current_url or "login" not in driver.current_url
|
|
|
)
|
|
|
|
|
|
# 检查当前URL确认登录成功
|
|
|
current_url = self.driver.current_url
|
|
|
if "dashboard" in current_url or "workspaces" in current_url or "login" not in current_url:
|
|
|
logger.info(f"登录成功，当前URL: {current_url}")
|
|
|
|
|
|
# 获取并保存登录后的COOKIE
|
|
|
logger.info("获取登录后的COOKIE...")
|
|
|
self.login_cookies = self.driver.get_cookies()
|
|
|
logger.info(f"获取到 {len(self.login_cookies)} 个COOKIE")
|
|
|
for cookie in self.login_cookies:
|
|
|
logger.debug(f"COOKIE: {cookie['name']} -> {cookie['domain']}")
|
|
|
|
|
|
return True
|
|
|
else:
|
|
|
raise Exception("登录后未跳转到正确页面")
|
|
|
|
|
|
except TimeoutException:
|
|
|
# 检查是否登录失败
|
|
|
try:
|
|
|
error_selectors = [".error", ".alert-danger", "[class*='error']", "[class*='danger']"]
|
|
|
for selector in error_selectors:
|
|
|
try:
|
|
|
error_msg = self.driver.find_element(By.CSS_SELECTOR, selector)
|
|
|
if error_msg.is_displayed():
|
|
|
raise Exception(f"登录失败: {error_msg.text}")
|
|
|
except:
|
|
|
continue
|
|
|
raise Exception("登录超时，无法确认登录状态")
|
|
|
except Exception as e:
|
|
|
raise e
|
|
|
|
|
|
def get_balance(self):
|
|
|
"""获取当前账号的总余额"""
|
|
|
try:
|
|
|
logger.info("获取账号余额...")
|
|
|
|
|
|
# 跳转到仪表板页面
|
|
|
self.driver.get("https://leaflow.net/dashboard")
|
|
|
time.sleep(3)
|
|
|
|
|
|
# 等待页面加载
|
|
|
WebDriverWait(self.driver, 10).until(
|
|
|
EC.presence_of_element_located((By.TAG_NAME, "body"))
|
|
|
)
|
|
|
|
|
|
# 尝试多种选择器查找余额元素
|
|
|
balance_selectors = [
|
|
|
"//*[contains(text(), '¥') or contains(text(), '￥') or contains(text(), '元')]",
|
|
|
"//*[contains(@class, 'balance')]",
|
|
|
"//*[contains(@class, 'money')]",
|
|
|
"//*[contains(@class, 'amount')]",
|
|
|
"//button[contains(@class, 'dollar')]",
|
|
|
"//span[contains(@class, 'font-medium')]"
|
|
|
]
|
|
|
|
|
|
for selector in balance_selectors:
|
|
|
try:
|
|
|
elements = self.driver.find_elements(By.XPATH, selector)
|
|
|
for element in elements:
|
|
|
text = element.text.strip()
|
|
|
# 查找包含数字和货币符号的文本
|
|
|
if any(char.isdigit() for char in text) and ('¥' in text or '￥' in text or '元' in text):
|
|
|
# 提取数字部分
|
|
|
import re
|
|
|
numbers = re.findall(r'\d+\.?\d*', text)
|
|
|
if numbers:
|
|
|
balance = numbers[0]
|
|
|
logger.info(f"找到余额: {balance}元")
|
|
|
return f"{balance}元"
|
|
|
except:
|
|
|
continue
|
|
|
|
|
|
logger.warning("未找到余额信息")
|
|
|
return "未知"
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.warning(f"获取余额时出错: {e}")
|
|
|
return "未知"
|
|
|
|
|
|
def wait_for_checkin_page_loaded(self, max_retries=5, wait_time=30):
|
|
|
"""等待签到页面完全加载，支持重试"""
|
|
|
|
|
|
for attempt in range(max_retries):
|
|
|
logger.info(f"等待签到页面加载，尝试 {attempt + 1}/{max_retries}")
|
|
|
|
|
|
# 收集页面基本信息，便于调试
|
|
|
logger.info(f" 当前页面URL: {self.driver.current_url}")
|
|
|
logger.info(f" 当前页面标题: {self.driver.title}")
|
|
|
|
|
|
try:
|
|
|
# 检查页面是否包含签到相关元素
|
|
|
# 使用组合等待条件：DOM就绪 + 核心元素可见
|
|
|
WebDriverWait(self.driver, wait_time).until(
|
|
|
lambda d: d.execute_script("return document.readyState") == "complete"
|
|
|
)
|
|
|
|
|
|
checkin_indicators = [
|
|
|
(By.CSS_SELECTOR, "button.checkin-btn"), # 首选精确选择器
|
|
|
(By.XPATH, "//button[contains(text(), '立即签到')]"),
|
|
|
(By.XPATH, "//button[contains(text(), '已签到')]"),
|
|
|
(By.XPATH, "//button[contains(text(), '已完成')]"),
|
|
|
(By.XPATH, "//*[contains(text(), '每日签到')]"),
|
|
|
(By.XPATH, "//*[contains(text(), '签到')]")
|
|
|
]
|
|
|
|
|
|
for locator_type, selector in checkin_indicators:
|
|
|
try:
|
|
|
# 增加元素等待时间
|
|
|
element = WebDriverWait(self.driver, 15).until(
|
|
|
EC.visibility_of_element_located((locator_type, selector))
|
|
|
)
|
|
|
|
|
|
# 只要找到可见的签到相关元素，不管是否可用，都认为页面已加载成功
|
|
|
# 已签到状态下的按钮可能是禁用的，所以不能用is_enabled()判断
|
|
|
logger.info(f"检测到签到元素: {selector}")
|
|
|
logger.info(f" 元素可见性: {element.is_displayed()}")
|
|
|
logger.info(f" 元素可用性: {'启用' if element.is_enabled() else '禁用'}")
|
|
|
logger.info(f" 元素文本: '{element.text.strip()}'")
|
|
|
return True
|
|
|
except TimeoutException:
|
|
|
logger.debug(f"元素定位失败: {selector}，尝试下个策略")
|
|
|
continue
|
|
|
|
|
|
logger.warning(f"第 {attempt + 1} 次尝试未找到签到相关元素")
|
|
|
|
|
|
# 尝试获取页面源代码的前2000个字符，便于调试
|
|
|
try:
|
|
|
page_source = self.driver.page_source[:2000]
|
|
|
logger.debug(f"页面源码片段: {page_source}...")
|
|
|
except Exception as e:
|
|
|
logger.error(f"获取页面源码失败: {e}")
|
|
|
|
|
|
except TimeoutException:
|
|
|
logger.error(f"页面加载超时，重试中... (尝试 {attempt+1})")
|
|
|
except Exception as e:
|
|
|
logger.critical(f"严重错误: {str(e)}")
|
|
|
logger.error(f"错误详情: {traceback.format_exc()}")
|
|
|
if "net::ERR" in str(e):
|
|
|
logger.info("检测到网络错误，立即重试")
|
|
|
continue
|
|
|
|
|
|
return False
|
|
|
|
|
|
def find_and_click_checkin_button(self):
|
|
|
"""查找并点击签到按钮 - 处理已签到状态"""
|
|
|
logger.info("开始查找签到按钮...")
|
|
|
start_time = time.time()
|
|
|
|
|
|
try:
|
|
|
# 收集页面基本信息
|
|
|
logger.info(f"当前页面URL: {self.driver.current_url}")
|
|
|
logger.info(f"当前页面标题: {self.driver.title}")
|
|
|
|
|
|
# 先等待页面可能的重载
|
|
|
logger.info("等待页面稳定...")
|
|
|
time.sleep(5)
|
|
|
|
|
|
# 使用和单账号成功时相同的选择器
|
|
|
checkin_selectors = [
|
|
|
"button.checkin-btn",
|
|
|
"//button[contains(text(), '立即签到')]",
|
|
|
"//button[contains(@class, 'checkin')]",
|
|
|
"button[type='submit']",
|
|
|
"button[name='checkin']"
|
|
|
]
|
|
|
|
|
|
for selector in checkin_selectors:
|
|
|
logger.info(f"尝试使用选择器: {selector}")
|
|
|
try:
|
|
|
if selector.startswith("//"):
|
|
|
checkin_btn = WebDriverWait(self.driver, 15).until(
|
|
|
EC.presence_of_element_located((By.XPATH, selector))
|
|
|
)
|
|
|
else:
|
|
|
checkin_btn = WebDriverWait(self.driver, 15).until(
|
|
|
EC.presence_of_element_located((By.CSS_SELECTOR, selector))
|
|
|
)
|
|
|
|
|
|
# 详细检查按钮状态
|
|
|
logger.info(f"找到按钮，开始检查状态...")
|
|
|
logger.info(f"按钮可见性: {checkin_btn.is_displayed()}")
|
|
|
logger.info(f"按钮可用性: {checkin_btn.is_enabled()}")
|
|
|
logger.info(f"按钮文本: '{checkin_btn.text.strip()}'")
|
|
|
|
|
|
if checkin_btn.is_displayed():
|
|
|
# 检查按钮文本，如果包含"已签到"或"已完成"则说明今天已经签到过了
|
|
|
btn_text = checkin_btn.text.strip()
|
|
|
|
|
|
# 检查页面上是否有"今日已签到"文本
|
|
|
page_text = self.driver.page_source
|
|
|
|
|
|
# 综合判断已签到状态：按钮禁用或按钮文本包含"已完成"或页面包含"今日已签到"
|
|
|
if (not checkin_btn.is_enabled() or
|
|
|
"已完成" in btn_text or
|
|
|
"今日已签到" in page_text or
|
|
|
"已签到" in btn_text):
|
|
|
logger.info(f"今日已签到，状态信息：")
|
|
|
logger.info(f" - 按钮状态: {'禁用' if not checkin_btn.is_enabled() else '可用'}")
|
|
|
logger.info(f" - 按钮文本: '{btn_text}'")
|
|
|
logger.info(f" - 页面包含'今日已签到': {'是' if '今日已签到' in page_text else '否'}")
|
|
|
return "already_checked_in"
|
|
|
|
|
|
# 尝试多种点击方式
|
|
|
clicked = False
|
|
|
|
|
|
# 方式1: JavaScript点击（优先使用，避免页面阻塞）
|
|
|
try:
|
|
|
logger.info("方式1: 尝试JavaScript点击...")
|
|
|
self.driver.execute_script("arguments[0].click();", checkin_btn)
|
|
|
clicked = True
|
|
|
logger.info("方式1: JavaScript点击成功")
|
|
|
except Exception as e:
|
|
|
logger.warning(f"方式1: JavaScript点击失败: {e}")
|
|
|
clicked = False
|
|
|
|
|
|
# 方式2: ActionChains点击
|
|
|
if not clicked:
|
|
|
try:
|
|
|
logger.info("方式2: 尝试ActionChains点击...")
|
|
|
# 设置隐式等待时间，避免点击超时
|
|
|
self.driver.implicitly_wait(5)
|
|
|
actions = ActionChains(self.driver)
|
|
|
actions.move_to_element(checkin_btn).click().perform()
|
|
|
clicked = True
|
|
|
logger.info("方式2: ActionChains点击成功")
|
|
|
except Exception as e:
|
|
|
logger.warning(f"方式2: ActionChains点击失败: {e}")
|
|
|
clicked = False
|
|
|
finally:
|
|
|
# 恢复隐式等待时间
|
|
|
self.driver.implicitly_wait(0)
|
|
|
|
|
|
# 方式3: 直接点击（最后尝试，可能会阻塞）
|
|
|
if not clicked:
|
|
|
try:
|
|
|
logger.info("方式3: 尝试直接点击按钮...")
|
|
|
# 使用WebDriverWait设置点击超时
|
|
|
WebDriverWait(self.driver, 10).until(
|
|
|
EC.element_to_be_clickable((By.CSS_SELECTOR, "button.checkin-btn"))
|
|
|
).click()
|
|
|
clicked = True
|
|
|
logger.info("方式3: 直接点击成功")
|
|
|
except Exception as e:
|
|
|
logger.warning(f"方式3: 直接点击失败: {e}")
|
|
|
clicked = False
|
|
|
|
|
|
if clicked:
|
|
|
logger.info(f"成功点击签到按钮，耗时: {time.time() - start_time:.2f}秒")
|
|
|
# 点击后立即检查页面变化，确认签到是否成功
|
|
|
time.sleep(2)
|
|
|
# 检查按钮状态或页面文本变化
|
|
|
try:
|
|
|
updated_btn = self.driver.find_element(By.CSS_SELECTOR, "button.checkin-btn")
|
|
|
updated_text = updated_btn.text.strip()
|
|
|
page_text = self.driver.page_source
|
|
|
if (not updated_btn.is_enabled() or
|
|
|
"已完成" in updated_text or
|
|
|
"今日已签到" in page_text or
|
|
|
"已签到" in updated_text):
|
|
|
logger.info("签到成功，按钮状态已更新")
|
|
|
except:
|
|
|
pass
|
|
|
return True
|
|
|
else:
|
|
|
logger.error("所有点击方式均失败")
|
|
|
return False
|
|
|
else:
|
|
|
logger.warning("按钮不可见")
|
|
|
continue
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.debug(f"选择器{selector}未找到按钮: {e}")
|
|
|
continue
|
|
|
|
|
|
logger.error("遍历所有选择器后仍未找到可点击的签到按钮")
|
|
|
return False
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.error(f"查找签到按钮时出错: {e}")
|
|
|
logger.error(f"错误详情: {traceback.format_exc()}")
|
|
|
return False
|
|
|
|
|
|
def checkin(self):
|
|
|
"""执行签到流程"""
|
|
|
logger.info("执行签到流程...")
|
|
|
|
|
|
# 跳转到签到页面
|
|
|
logger.info("跳转到签到页面...")
|
|
|
|
|
|
# 只使用明确的签到页面URL，避免跳转到登录页面
|
|
|
target_url = "https://checkin.leaflow.net/index.php"
|
|
|
|
|
|
# 网络状态检查
|
|
|
try:
|
|
|
import socket
|
|
|
socket.create_connection(("checkin.leaflow.net", 443), timeout=10)
|
|
|
logger.info("网络连接正常，可以访问签到服务器")
|
|
|
except Exception as net_e:
|
|
|
logger.warning(f"网络连接检查失败: {net_e}，可能网络不稳定")
|
|
|
|
|
|
# 尝试访问签到页面，处理网络超时
|
|
|
max_retries = 8
|
|
|
retry_delay = 3
|
|
|
start_time = time.time()
|
|
|
|
|
|
for attempt in range(1, max_retries + 1):
|
|
|
try:
|
|
|
logger.info(f"尝试第 {attempt}/{max_retries} 次访问签到页面...")
|
|
|
logger.info(f"当前耗时: {time.time() - start_time:.2f} 秒")
|
|
|
|
|
|
# 重置超时设置，使用更长的超时时间
|
|
|
try:
|
|
|
self.driver.set_page_load_timeout(120)
|
|
|
self.driver.set_script_timeout(60)
|
|
|
logger.debug("已重置超时设置: 页面加载120秒，脚本执行60秒")
|
|
|
except Exception as timeout_e:
|
|
|
logger.warning(f"重置超时设置时出错: {timeout_e}")
|
|
|
|
|
|
# 记录开始访问时间
|
|
|
access_start = time.time()
|
|
|
logger.info(f"尝试访问URL: {target_url}")
|
|
|
self.driver.get(target_url)
|
|
|
access_time = time.time() - access_start
|
|
|
logger.info(f"页面访问耗时: {access_time:.2f} 秒")
|
|
|
|
|
|
# 检查当前URL和页面状态
|
|
|
current_url = self.driver.current_url
|
|
|
logger.info(f"当前URL: {current_url}")
|
|
|
|
|
|
# 获取页面标题
|
|
|
try:
|
|
|
page_title = self.driver.title
|
|
|
logger.info(f"当前页面标题: {page_title}")
|
|
|
except Exception as title_e:
|
|
|
logger.warning(f"获取页面标题失败: {title_e}")
|
|
|
|
|
|
# 检查是否跳转到了登录页面
|
|
|
if "login" in current_url and "checkin" not in current_url:
|
|
|
logger.warning(f"访问签到页面时跳转到了登录页面: {current_url}")
|
|
|
logger.info("跳过登录页面，继续执行COOKIE处理...")
|
|
|
else:
|
|
|
logger.info(f"成功访问签到页面，URL: {current_url}")
|
|
|
|
|
|
# 检查页面加载状态
|
|
|
try:
|
|
|
page_state = self.driver.execute_script("return document.readyState")
|
|
|
logger.info(f"页面加载状态: {page_state}")
|
|
|
if page_state != "complete":
|
|
|
logger.warning("页面可能未完全加载，准备继续处理")
|
|
|
except Exception as state_e:
|
|
|
logger.warning(f"获取页面状态失败: {state_e}")
|
|
|
|
|
|
break
|
|
|
|
|
|
except Exception as e:
|
|
|
error_msg = str(e)
|
|
|
logger.warning(f"访问URL {target_url}失败: {error_msg}")
|
|
|
logger.debug(f"错误详情: {traceback.format_exc()}")
|
|
|
|
|
|
# 增强错误分类处理
|
|
|
error_lower = error_msg.lower()
|
|
|
if any(keyword in error_lower for keyword in [
|
|
|
"-0.005", "-0.004", "timed out receiving message from renderer",
|
|
|
"timeout: timed out", "session not created", "chrome not reachable",
|
|
|
"no such session", "session deleted", "connection refused"
|
|
|
]):
|
|
|
logger.error("检测到ChromeDriver兼容性错误，重置浏览器会话...")
|
|
|
try:
|
|
|
self.driver.quit()
|
|
|
logger.info("已关闭旧的浏览器会话")
|
|
|
except Exception as quit_e:
|
|
|
logger.warning(f"关闭浏览器会话失败: {quit_e}")
|
|
|
|
|
|
# 重置浏览器会话
|
|
|
try:
|
|
|
self.setup_driver()
|
|
|
logger.info("浏览器会话已重置，准备重试")
|
|
|
except Exception as setup_e:
|
|
|
logger.error(f"重置浏览器会话失败: {setup_e}")
|
|
|
raise Exception(f"无法重置浏览器会话: {setup_e}")
|
|
|
|
|
|
elif "net::err" in error_lower:
|
|
|
logger.warning(f"网络错误 ({error_msg})，可能需要检查网络连接")
|
|
|
# 网络错误时增加等待时间
|
|
|
retry_delay = 5
|
|
|
elif "connection timed out" in error_lower or "timed out" in error_lower:
|
|
|
logger.warning(f"连接超时 ({error_msg})，可能网络延迟较高")
|
|
|
elif "dns_probe_finished_nxdomain" in error_lower:
|
|
|
logger.warning("DNS解析失败，可能是域名问题")
|
|
|
else:
|
|
|
logger.warning(f"其他错误: {error_msg}")
|
|
|
|
|
|
# 等待后重试，使用指数退避
|
|
|
if attempt < max_retries:
|
|
|
wait_time = retry_delay * (2 ** (attempt - 1)) # 使用2倍指数退避
|
|
|
wait_time = min(wait_time, 60) # 最大等待60秒
|
|
|
logger.info(f"等待 {wait_time:.1f} 秒后重试...")
|
|
|
time.sleep(wait_time)
|
|
|
else:
|
|
|
total_time = time.time() - start_time
|
|
|
logger.error(f"经过 {max_retries} 次重试后仍无法访问签到页面，总耗时: {total_time:.2f} 秒")
|
|
|
raise Exception(f"无法访问签到页面: {error_msg}")
|
|
|
|
|
|
# 添加登录时保存的COOKIE到当前域名
|
|
|
logger.info("添加登录COOKIE到checkin域名...")
|
|
|
if hasattr(self, 'login_cookies') and self.login_cookies:
|
|
|
# 先清除当前页面的COOKIE
|
|
|
self.driver.delete_all_cookies()
|
|
|
|
|
|
# 添加登录时保存的所有COOKIE
|
|
|
for cookie in self.login_cookies:
|
|
|
try:
|
|
|
# 适配不同域名的COOKIE
|
|
|
cookie_copy = cookie.copy()
|
|
|
# 确保COOKIE能被所有子域名使用
|
|
|
if 'domain' not in cookie_copy or not cookie_copy['domain']:
|
|
|
cookie_copy['domain'] = '.leaflow.net'
|
|
|
# 移除可能导致问题的属性
|
|
|
if 'expiry' in cookie_copy and isinstance(cookie_copy['expiry'], float):
|
|
|
cookie_copy['expiry'] = int(cookie_copy['expiry'])
|
|
|
# 添加COOKIE
|
|
|
self.driver.add_cookie(cookie_copy)
|
|
|
logger.debug(f"添加COOKIE成功: {cookie['name']} -> {cookie_copy.get('domain', '无域名')}")
|
|
|
except Exception as e:
|
|
|
logger.debug(f"添加COOKIE失败: {cookie['name']} -> {e}")
|
|
|
|
|
|
# 尝试直接访问签到首页，使用明确的URL
|
|
|
logger.info("COOKIE添加完成，直接访问签到首页...")
|
|
|
try:
|
|
|
# 使用明确的URL，避免重定向，增加超时时间
|
|
|
self.driver.set_page_load_timeout(60)
|
|
|
self.driver.get(target_url)
|
|
|
logger.info(f"成功访问签到首页，URL: {self.driver.current_url}")
|
|
|
except Exception as e:
|
|
|
logger.error(f"访问签到首页时出错: {e}")
|
|
|
# 无论是否超时，都获取当前页面信息
|
|
|
try:
|
|
|
logger.info(f"当前页面URL: {self.driver.current_url}")
|
|
|
logger.info(f"当前页面标题: {self.driver.title}")
|
|
|
# 获取页面源码（最多前2000字符）
|
|
|
page_source = self.driver.page_source[:2000]
|
|
|
logger.info(f"页面源码片段: {page_source}")
|
|
|
except Exception as info_e:
|
|
|
logger.error(f"获取页面信息失败: {info_e}")
|
|
|
|
|
|
# 获取当前页面信息，便于调试
|
|
|
logger.info(f"当前签到页面URL: {self.driver.current_url}")
|
|
|
logger.info(f"当前页面标题: {self.driver.title}")
|
|
|
|
|
|
# 简化重定向处理，直接检查当前URL
|
|
|
logger.info("检查当前页面状态...")
|
|
|
|
|
|
# 检查是否需要进行OAuth授权
|
|
|
if "oauth/authorize" in self.driver.current_url:
|
|
|
logger.info("检测到OAuth授权页面，尝试自动授权...")
|
|
|
# 查找并点击授权按钮
|
|
|
try:
|
|
|
# 尝试多种选择器找到授权按钮
|
|
|
authorize_selectors = [
|
|
|
"button[type='submit']",
|
|
|
"input[type='submit']",
|
|
|
"//button[contains(text(), '授权')]",
|
|
|
"//button[contains(text(), 'Authorize')]"
|
|
|
]
|
|
|
|
|
|
authorize_btn = None
|
|
|
for selector in authorize_selectors:
|
|
|
try:
|
|
|
if selector.startswith("//"):
|
|
|
authorize_btn = WebDriverWait(self.driver, 10).until(
|
|
|
EC.element_to_be_clickable((By.XPATH, selector))
|
|
|
)
|
|
|
else:
|
|
|
authorize_btn = WebDriverWait(self.driver, 10).until(
|
|
|
EC.element_to_be_clickable((By.CSS_SELECTOR, selector))
|
|
|
)
|
|
|
logger.info(f"找到授权按钮")
|
|
|
break
|
|
|
except:
|
|
|
continue
|
|
|
|
|
|
if authorize_btn:
|
|
|
authorize_btn.click()
|
|
|
logger.info("已点击授权按钮")
|
|
|
time.sleep(5)
|
|
|
logger.info(f"授权后URL: {self.driver.current_url}")
|
|
|
else:
|
|
|
logger.warning("未找到授权按钮，尝试等待自动跳转...")
|
|
|
time.sleep(10)
|
|
|
logger.info(f"等待后URL: {self.driver.current_url}")
|
|
|
except Exception as e:
|
|
|
logger.warning(f"自动授权失败，可能需要手动授权: {e}")
|
|
|
|
|
|
# 成功访问并处理完重定向，继续执行后续流程
|
|
|
# 注意：这里不再需要continue或break，因为我们已经在前面的代码中处理了循环退出逻辑
|
|
|
|
|
|
finally:
|
|
|
# 恢复默认页面加载超时
|
|
|
self.driver.set_page_load_timeout(60)
|
|
|
|
|
|
# 等待签到页面加载（最多重试5次，每次等待20秒）
|
|
|
retry_count = 0
|
|
|
max_retries = 5
|
|
|
success = False
|
|
|
|
|
|
while retry_count < max_retries and not success:
|
|
|
retry_count += 1
|
|
|
logger.info(f"等待签到页面加载，尝试 {retry_count}/{max_retries}")
|
|
|
|
|
|
# 检查当前URL和标题，记录详细信息
|
|
|
current_url = self.driver.current_url
|
|
|
current_title = self.driver.title
|
|
|
logger.info(f" 当前URL: {current_url}")
|
|
|
logger.info(f" 当前标题: {current_title}")
|
|
|
|
|
|
# 检查是否是502错误
|
|
|
if "502" in current_title or "Bad Gateway" in current_title:
|
|
|
logger.error(f"第 {retry_count} 次尝试遇到502 Bad Gateway错误")
|
|
|
|
|
|
# 尝试重新访问主站获取有效COOKIE（仅在需要时）
|
|
|
logger.info("尝试重新访问主站获取有效COOKIE...")
|
|
|
self.driver.get("https://leaflow.net/dashboard")
|
|
|
time.sleep(3)
|
|
|
|
|
|
# 重新跳转到签到页面
|
|
|
self.driver.get("https://checkin.leaflow.net")
|
|
|
time.sleep(5)
|
|
|
continue
|
|
|
|
|
|
# 检查是否是重定向到登录页面
|
|
|
if "login" in current_url and "checkin" not in current_url:
|
|
|
logger.error(f"第 {retry_count} 次尝试遇到登录页面，COOKIE可能失效")
|
|
|
|
|
|
# 重新执行登录流程
|
|
|
logger.info("尝试重新登录...")
|
|
|
if self.login():
|
|
|
# 重新跳转到签到页面
|
|
|
self.driver.get("https://checkin.leaflow.net")
|
|
|
time.sleep(5)
|
|
|
else:
|
|
|
raise Exception("重新登录失败")
|
|
|
continue
|
|
|
|
|
|
# 检查是否是OAuth回调页面
|
|
|
if "auth_callback.php" in current_url:
|
|
|
logger.info(f"第 {retry_count} 次尝试遇到OAuth回调页面，等待自动跳转...")
|
|
|
time.sleep(5)
|
|
|
logger.info(f" 自动跳转后URL: {self.driver.current_url}")
|
|
|
logger.info(f" 自动跳转后标题: {self.driver.title}")
|
|
|
|
|
|
# 尝试等待页面加载
|
|
|
if self.wait_for_checkin_page_loaded(max_retries=1, wait_time=15):
|
|
|
success = True
|
|
|
logger.info(f"第 {retry_count} 次尝试成功加载签到页面")
|
|
|
else:
|
|
|
logger.warning(f"第 {retry_count} 次尝试未成功加载签到页面")
|
|
|
|
|
|
# 尝试刷新页面
|
|
|
logger.info("尝试刷新页面...")
|
|
|
self.driver.refresh()
|
|
|
time.sleep(5)
|
|
|
|
|
|
if not success:
|
|
|
raise Exception(f"签到页面加载失败，经过 {max_retries} 次重试后仍无法访问")
|
|
|
|
|
|
# 查找并点击立即签到按钮
|
|
|
checkin_result = self.find_and_click_checkin_button()
|
|
|
|
|
|
if checkin_result == "already_checked_in":
|
|
|
return "今日已签到"
|
|
|
elif checkin_result is True:
|
|
|
logger.info("已点击立即签到按钮")
|
|
|
time.sleep(5) # 等待签到结果
|
|
|
|
|
|
# 获取签到结果
|
|
|
result_message = self.get_checkin_result()
|
|
|
return result_message
|
|
|
else:
|
|
|
raise Exception("找不到立即签到按钮或按钮不可点击")
|
|
|
|
|
|
def get_checkin_result(self):
|
|
|
"""获取签到结果消息"""
|
|
|
try:
|
|
|
# 给页面一些时间显示结果
|
|
|
time.sleep(3)
|
|
|
|
|
|
# 尝试查找各种可能的成功消息元素
|
|
|
success_selectors = [
|
|
|
".alert-success",
|
|
|
".success",
|
|
|
".message",
|
|
|
"[class*='success']",
|
|
|
"[class*='message']",
|
|
|
".modal-content", # 弹窗内容
|
|
|
".ant-message", # Ant Design 消息
|
|
|
".el-message", # Element UI 消息
|
|
|
".toast", # Toast消息
|
|
|
".notification" # 通知
|
|
|
]
|
|
|
|
|
|
for selector in success_selectors:
|
|
|
try:
|
|
|
element = self.driver.find_element(By.CSS_SELECTOR, selector)
|
|
|
if element.is_displayed():
|
|
|
text = element.text.strip()
|
|
|
if text:
|
|
|
return text
|
|
|
except:
|
|
|
continue
|
|
|
|
|
|
# 如果没有找到特定元素，检查页面文本
|
|
|
page_text = self.driver.find_element(By.TAG_NAME, "body").text
|
|
|
important_keywords = ["成功", "签到", "获得", "恭喜", "谢谢", "感谢", "完成", "已签到", "连续签到"]
|
|
|
|
|
|
for keyword in important_keywords:
|
|
|
if keyword in page_text:
|
|
|
# 提取包含关键词的行
|
|
|
lines = page_text.split('\n')
|
|
|
for line in lines:
|
|
|
if keyword in line and len(line.strip()) < 100: # 避免提取过长的文本
|
|
|
return line.strip()
|
|
|
|
|
|
# 检查签到按钮状态变化
|
|
|
try:
|
|
|
checkin_btn = self.driver.find_element(By.CSS_SELECTOR, "button.checkin-btn")
|
|
|
if not checkin_btn.is_enabled() or "已签到" in checkin_btn.text or "disabled" in checkin_btn.get_attribute("class"):
|
|
|
return "今日已签到完成"
|
|
|
except:
|
|
|
pass
|
|
|
|
|
|
return "签到完成，但未找到具体结果消息"
|
|
|
|
|
|
except Exception as e:
|
|
|
return f"获取签到结果时出错: {str(e)}"
|
|
|
|
|
|
def run(self):
|
|
|
"""单个账号执行流程"""
|
|
|
try:
|
|
|
logger.info(f"开始处理账号")
|
|
|
|
|
|
# 登录
|
|
|
if self.login():
|
|
|
# 签到
|
|
|
result = self.checkin()
|
|
|
|
|
|
# 获取余额
|
|
|
balance = self.get_balance()
|
|
|
|
|
|
logger.info(f"签到结果: {result}, 余额: {balance}")
|
|
|
return True, result, balance
|
|
|
else:
|
|
|
raise Exception("登录失败")
|
|
|
|
|
|
except Exception as e:
|
|
|
error_msg = f"自动签到失败: {str(e)}"
|
|
|
logger.error(error_msg)
|
|
|
return False, error_msg, "未知"
|
|
|
|
|
|
finally:
|
|
|
if self.driver:
|
|
|
self.driver.quit()
|
|
|
|
|
|
class MultiAccountManager:
|
|
|
"""多账号管理器 - 简化配置版本"""
|
|
|
|
|
|
def __init__(self):
|
|
|
self.accounts = self.load_accounts()
|
|
|
|
|
|
def load_accounts(self):
|
|
|
"""从环境变量加载多账号信息，支持冒号分隔多账号和单账号"""
|
|
|
accounts = []
|
|
|
|
|
|
logger.info("开始加载账号配置...")
|
|
|
|
|
|
# 方法1: 冒号分隔多账号格式
|
|
|
accounts_str = os.getenv('LEAFLOW_ACCOUNTS', '').strip()
|
|
|
if accounts_str:
|
|
|
try:
|
|
|
logger.info("尝试解析冒号分隔多账号配置")
|
|
|
account_pairs = [pair.strip() for pair in accounts_str.split(',')]
|
|
|
|
|
|
logger.info(f"找到 {len(account_pairs)} 个账号")
|
|
|
|
|
|
for i, pair in enumerate(account_pairs):
|
|
|
if ':' in pair:
|
|
|
email, password, token = pair.split(':', 1)
|
|
|
email = email.strip()
|
|
|
password = password.strip()
|
|
|
token = token.strip()
|
|
|
|
|
|
if email and password:
|
|
|
accounts.append({
|
|
|
'email': email,
|
|
|
'password': password,
|
|
|
'token': token
|
|
|
})
|
|
|
logger.info(f"成功添加第 {i+1} 个账号")
|
|
|
else:
|
|
|
logger.warning(f"账号对格式错误")
|
|
|
else:
|
|
|
logger.warning(f"账号对缺少冒号分隔符")
|
|
|
|
|
|
if accounts:
|
|
|
logger.info(f"从冒号分隔格式成功加载了 {len(accounts)} 个账号")
|
|
|
return accounts
|
|
|
else:
|
|
|
logger.warning("冒号分隔配置中没有找到有效的账号信息")
|
|
|
except Exception as e:
|
|
|
logger.error(f"解析冒号分隔账号配置失败: {e}")
|
|
|
|
|
|
# 方法2: 单账号格式
|
|
|
single_email = os.getenv('LEAFLOW_EMAIL', '').strip()
|
|
|
single_password = os.getenv('LEAFLOW_PASSWORD', '').strip()
|
|
|
single_token = os.getenv('LEAFLOW_TOKEN', '').strip()
|
|
|
if single_email and single_password:
|
|
|
accounts.append({
|
|
|
'email': single_email,
|
|
|
'password': single_password,
|
|
|
'token': single_token
|
|
|
})
|
|
|
logger.info("加载了单个账号配置")
|
|
|
return accounts
|
|
|
|
|
|
# 如果所有方法都失败
|
|
|
logger.error("未找到有效的账号配置")
|
|
|
logger.error("请检查以下环境变量设置:")
|
|
|
logger.error("1. LEAFLOW_ACCOUNTS: 冒号分隔多账号 (email1:pass1,email2:pass2)")
|
|
|
logger.error("2. LEAFLOW_EMAIL 和 LEAFLOW_PASSWORD: 单账号")
|
|
|
|
|
|
raise ValueError("未找到有效的账号配置")
|
|
|
|
|
|
def send_api_notification(self, message):
|
|
|
"""发送API通知"""
|
|
|
try:
|
|
|
url = "http://111.11.107.61:30005/send_private_msg"
|
|
|
# 构建请求数据
|
|
|
data = {
|
|
|
"user_id": "8739050",
|
|
|
"message": [{"type": "text", "data": {"text": message}}]
|
|
|
}
|
|
|
|
|
|
# 从环境变量读取token
|
|
|
token = os.getenv('LEAFLOW_TOKEN', '').strip()
|
|
|
headers = {
|
|
|
"Authorization": f"{token}",
|
|
|
"Content-Type": "application/json"
|
|
|
}
|
|
|
|
|
|
logger.info(f"正在发送API通知到 {url}")
|
|
|
response = requests.post(url, json=data, headers=headers, timeout=10)
|
|
|
|
|
|
logger.info(f"API通知发送结果 - 状态码: {response.status_code}, 响应: {response.text}")
|
|
|
logger.info(f"✅ API通知发送成功") if response.status_code == 200 else logger.error(f"❌ API通知发送失败")
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.error(f"❌ 发送API通知时出错: {e}")
|
|
|
logger.error(f"错误详情: {traceback.format_exc()}")
|
|
|
|
|
|
def send_notification(self, results):
|
|
|
"""发送API通知"""
|
|
|
logger.info("开始发送API通知")
|
|
|
# 确保总是发送API通知，即使发生异常
|
|
|
try:
|
|
|
# 构建通知消息
|
|
|
success_count = sum(1 for _, success, _, _ in results if success)
|
|
|
total_count = len(results)
|
|
|
current_date = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
|
|
|
|
|
|
# 构建API通知消息
|
|
|
api_message = f"🎁 Leaflow自动签到通知\n"
|
|
|
api_message += f"📊 成功: {success_count}/{total_count}\n"
|
|
|
api_message += f"📅 签到时间：{current_date}\n\n"
|
|
|
|
|
|
for email, success, result, balance in results:
|
|
|
# 隐藏邮箱部分字符以保护隐私
|
|
|
masked_email = email[:3] + "***" + email[email.find("@"):]
|
|
|
|
|
|
if success:
|
|
|
status = "✅"
|
|
|
api_message += f"账号：{masked_email}\n"
|
|
|
api_message += f"{status} {result}！\n"
|
|
|
api_message += f"💰 当前总余额：{balance}。\n\n"
|
|
|
else:
|
|
|
status = "❌"
|
|
|
api_message += f"账号：{masked_email}\n"
|
|
|
api_message += f"{status} {result}\n\n"
|
|
|
|
|
|
# 发送API通知
|
|
|
logger.info("准备发送API通知")
|
|
|
self.send_api_notification(api_message)
|
|
|
logger.info("API通知发送完成")
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.error(f"构建API通知消息时出错: {e}")
|
|
|
logger.error(f"错误详情: {traceback.format_exc()}")
|
|
|
# 即使发生异常，也要尝试发送基本的API通知
|
|
|
try:
|
|
|
success_count = sum(1 for _, success, _, _ in results if success)
|
|
|
total_count = len(results)
|
|
|
basic_message = f"签到任务完成，成功{success_count}个，失败{total_count - success_count}个"
|
|
|
logger.info(f"尝试发送基本API通知: {basic_message}")
|
|
|
self.send_api_notification(basic_message)
|
|
|
except Exception as e2:
|
|
|
logger.error(f"发送基本API通知时出错: {e2}")
|
|
|
logger.error(f"错误详情: {traceback.format_exc()}")
|
|
|
|
|
|
def run_all(self):
|
|
|
"""运行所有账号的签到流程"""
|
|
|
logger.info(f"开始执行 {len(self.accounts)} 个账号的签到任务")
|
|
|
|
|
|
results = []
|
|
|
|
|
|
for i, account in enumerate(self.accounts, 1):
|
|
|
logger.info(f"处理第 {i}/{len(self.accounts)} 个账号")
|
|
|
|
|
|
try:
|
|
|
auto_checkin = LeaflowAutoCheckin(account['email'], account['password'])
|
|
|
success, result, balance = auto_checkin.run()
|
|
|
results.append((account['email'], success, result, balance))
|
|
|
|
|
|
# 在账号之间添加间隔，避免请求过于频繁
|
|
|
if i < len(self.accounts):
|
|
|
wait_time = 5
|
|
|
logger.info(f"等待{wait_time}秒后处理下一个账号...")
|
|
|
time.sleep(wait_time)
|
|
|
|
|
|
except Exception as e:
|
|
|
error_msg = f"处理账号时发生异常: {str(e)}"
|
|
|
logger.error(error_msg)
|
|
|
results.append((account['email'], False, error_msg, "未知"))
|
|
|
|
|
|
# 发送第一次汇总通知
|
|
|
self.send_notification(results)
|
|
|
|
|
|
# 暂时关闭30分钟后重试功能
|
|
|
# 检查是否有失败的账号需要重试
|
|
|
# failed_accounts = [account for account, (email, success, _, _) in zip(self.accounts, results) if not success]
|
|
|
# if failed_accounts:
|
|
|
# logger.info(f"发现 {len(failed_accounts)} 个账号签到失败，将在30分钟后重试...")
|
|
|
#
|
|
|
# # 等待30分钟
|
|
|
# retry_wait_time = 30 * 60
|
|
|
# logger.info(f"等待{retry_wait_time}秒后重试失败的账号...")
|
|
|
# time.sleep(retry_wait_time)
|
|
|
#
|
|
|
# # 重试失败的账号
|
|
|
# retry_results = []
|
|
|
# for i, account in enumerate(failed_accounts, 1):
|
|
|
# logger.info(f"重试第 {i}/{len(failed_accounts)} 个失败账号")
|
|
|
#
|
|
|
# try:
|
|
|
# auto_checkin = LeaflowAutoCheckin(account['email'], account['password'])
|
|
|
# success, result, balance = auto_checkin.run()
|
|
|
# retry_results.append((account['email'], success, result, balance))
|
|
|
#
|
|
|
# # 在账号之间添加间隔
|
|
|
# if i < len(failed_accounts):
|
|
|
# wait_time = 5
|
|
|
# logger.info(f"等待{wait_time}秒后处理下一个重试账号...")
|
|
|
# time.sleep(wait_time)
|
|
|
#
|
|
|
# except Exception as e:
|
|
|
# error_msg = f"重试账号时发生异常: {str(e)}"
|
|
|
# logger.error(error_msg)
|
|
|
# retry_results.append((account['email'], False, error_msg, "未知"))
|
|
|
#
|
|
|
# # 发送重试结果通知
|
|
|
# if retry_results:
|
|
|
# # 构建重试通知消息
|
|
|
# retry_success_count = sum(1 for _, success, _, _ in retry_results if success)
|
|
|
# retry_total_count = len(retry_results)
|
|
|
# current_date = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
|
|
|
#
|
|
|
# retry_message = f"🔄 Leaflow自动签到重试通知\n"
|
|
|
# retry_message += f"📊 重试成功: {retry_success_count}/{retry_total_count}\n"
|
|
|
# retry_message += f"📅 重试时间：{current_date}\n\n"
|
|
|
#
|
|
|
# for email, success, result, balance in retry_results:
|
|
|
# masked_email = email[:3] + "***" + email[email.find("@"):]
|
|
|
#
|
|
|
# if success:
|
|
|
# status = "✅"
|
|
|
# retry_message += f"账号：{masked_email}\n"
|
|
|
# retry_message += f"{status} 重试成功！{result}\n"
|
|
|
# retry_message += f"💰 当前总余额：{balance}。\n\n"
|
|
|
# else:
|
|
|
# status = "❌"
|
|
|
# retry_message += f"账号：{masked_email}\n"
|
|
|
# retry_message += f"{status} 重试失败：{result}\n\n"
|
|
|
#
|
|
|
# # 发送重试通知
|
|
|
# logger.info("发送重试结果通知...")
|
|
|
# self.send_api_notification(retry_message)
|
|
|
#
|
|
|
# # 更新原始结果
|
|
|
# for email, success, result, balance in retry_results:
|
|
|
# for i, (orig_email, orig_success, orig_result, orig_balance) in enumerate(results):
|
|
|
# if orig_email == email:
|
|
|
# results[i] = (email, success, result, balance)
|
|
|
# break
|
|
|
|
|
|
# 返回总体结果
|
|
|
success_count = sum(1 for _, success, _, _ in results if success)
|
|
|
return success_count == len(self.accounts), results
|
|
|
|
|
|
def main():
|
|
|
"""主函数"""
|
|
|
try:
|
|
|
manager = MultiAccountManager()
|
|
|
overall_success, detailed_results = manager.run_all()
|
|
|
|
|
|
if overall_success:
|
|
|
logger.info("✅ 所有账号签到成功")
|
|
|
exit(0)
|
|
|
else:
|
|
|
success_count = sum(1 for _, success, _, _ in detailed_results if success)
|
|
|
logger.warning(f"⚠️ 部分账号签到失败: {success_count}/{len(detailed_results)} 成功")
|
|
|
# 即使有失败，也不退出错误状态，因为可能部分成功
|
|
|
exit(0)
|
|
|
|
|
|
except Exception as e:
|
|
|
logger.error(f"❌ 脚本执行出错: {e}")
|
|
|
exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
main()
|
|
|
|
