1941 lines
85 KiB
Python
1941 lines
85 KiB
Python
import time
|
||
import random
|
||
import json
|
||
import re
|
||
import requests
|
||
from typing import Optional, Tuple, List, Dict
|
||
from playwright.sync_api import Page, ElementHandle, Response
|
||
from loguru import logger
|
||
from config import Config
|
||
from pathlib import Path
|
||
from datetime import datetime
|
||
|
||
|
||
class MIPAdAutomation:
|
||
"""MIP页面广告自动化操作"""
|
||
|
||
# 预设的咨询语句
|
||
CONSULTATION_MESSAGES = [
|
||
"我想要预约一个医生，有什么推荐吗？",
|
||
"我现在本人不在当地，医生什么时候有空，是随时能去吗？有没有推荐的医生。",
|
||
"咱们医院是周六日是否上班，随时去吗？",
|
||
"想找医生看看，有没有推荐的区生",
|
||
"最近很不舒服，也说不出来全部的症状，能不能直接对话医生？"
|
||
]
|
||
|
||
# Ada平台API端点
|
||
ADA_HEARTBEAT_API = 'ada.baidu.com/gateway/message/heartbeat'
|
||
ADA_RECOMMEND_API = 'ada.baidu.com/imlp-extend/agent/getRecommendContent'
|
||
|
||
def __init__(self, page: Page, task_index: int = None):
|
||
self.page = page
|
||
self.site_id = None # 当前站点ID
|
||
self.click_id = None # 当前点击ID
|
||
self.task_folder = None # 任务日志目录
|
||
|
||
# 医生回复相关
|
||
self.doctor_replies: List[Dict] = [] # 存储医生回复
|
||
self.recommend_replies: List[Dict] = [] # 存储推荐回复
|
||
self._response_listener_active = False # 响应监听器状态
|
||
|
||
# 聊天历史（用于AI对话上下文）
|
||
self.chat_history: List[Dict] = []
|
||
|
||
# 浮窗状态
|
||
self._overlay_injected = False
|
||
self.task_index = task_index
|
||
|
||
# 创建任务日志目录
|
||
if task_index:
|
||
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
|
||
self.task_folder = Path("./test") / f"task_{task_index}_{timestamp}"
|
||
self.task_folder.mkdir(parents=True, exist_ok=True)
|
||
logger.info(f"任务日志目录: {self.task_folder}")
|
||
|
||
def _inject_overlay(self):
|
||
"""注入浮窗到页面"""
|
||
if self._overlay_injected:
|
||
return
|
||
|
||
try:
|
||
js_code = """
|
||
(function() {
|
||
// 检查是否已存在
|
||
if (document.getElementById('mip-progress-overlay')) return;
|
||
|
||
// 创建浮窗容器
|
||
var overlay = document.createElement('div');
|
||
overlay.id = 'mip-progress-overlay';
|
||
overlay.style.cssText = `
|
||
position: fixed;
|
||
top: 10px;
|
||
right: 10px;
|
||
width: 280px;
|
||
background: rgba(0, 0, 0, 0.85);
|
||
color: #fff;
|
||
padding: 12px 15px;
|
||
border-radius: 8px;
|
||
font-family: 'Microsoft YaHei', sans-serif;
|
||
font-size: 13px;
|
||
z-index: 999999;
|
||
box-shadow: 0 4px 12px rgba(0,0,0,0.3);
|
||
line-height: 1.6;
|
||
`;
|
||
|
||
// 标题
|
||
var title = document.createElement('div');
|
||
title.style.cssText = 'font-weight: bold; font-size: 14px; margin-bottom: 8px; color: #4CAF50; border-bottom: 1px solid #444; padding-bottom: 6px;';
|
||
title.innerHTML = '🤖 自动化进度';
|
||
overlay.appendChild(title);
|
||
|
||
// 状态内容
|
||
var content = document.createElement('div');
|
||
content.id = 'mip-progress-content';
|
||
content.innerHTML = '初始化中...';
|
||
overlay.appendChild(content);
|
||
|
||
document.body.appendChild(overlay);
|
||
})();
|
||
"""
|
||
self.page.evaluate(js_code)
|
||
self._overlay_injected = True
|
||
logger.debug("浮窗已注入页面")
|
||
except Exception as e:
|
||
logger.debug(f"注入浮窗失败: {str(e)}")
|
||
|
||
def _update_overlay(self, status: str, details: str = ""):
|
||
"""
|
||
更新浮窗显示内容
|
||
|
||
Args:
|
||
status: 当前状态
|
||
details: 详细信息
|
||
"""
|
||
try:
|
||
self._inject_overlay()
|
||
|
||
task_info = f"任务 #{self.task_index}" if self.task_index else "任务"
|
||
doctor_count = len(self.doctor_replies)
|
||
recommend_count = len(self.recommend_replies)
|
||
|
||
html = f"""
|
||
<div style='margin-bottom: 6px;'><b>{task_info}</b></div>
|
||
<div style='color: #4CAF50;'>📍 {status}</div>
|
||
<div style='color: #aaa; font-size: 12px; margin-top: 4px;'>{details}</div>
|
||
<div style='margin-top: 8px; padding-top: 6px; border-top: 1px solid #444; font-size: 11px; color: #888;'>
|
||
医生消息: {doctor_count} | 推荐回复: {recommend_count}
|
||
</div>
|
||
"""
|
||
|
||
js_code = f"""
|
||
(function() {{
|
||
var content = document.getElementById('mip-progress-content');
|
||
if (content) {{
|
||
content.innerHTML = `{html}`;
|
||
}}
|
||
}})();
|
||
"""
|
||
self.page.evaluate(js_code)
|
||
except Exception as e:
|
||
logger.debug(f"更新浮窗失败: {str(e)}")
|
||
|
||
def _remove_overlay(self):
|
||
"""移除浮窗"""
|
||
try:
|
||
js_code = """
|
||
(function() {
|
||
var overlay = document.getElementById('mip-progress-overlay');
|
||
if (overlay) overlay.remove();
|
||
})();
|
||
"""
|
||
self.page.evaluate(js_code)
|
||
self._overlay_injected = False
|
||
except:
|
||
pass
|
||
|
||
def _human_click(self, element, description: str = ""):
|
||
"""
|
||
模拟真人点击（随机偏移、随机延迟）
|
||
|
||
Args:
|
||
element: 要点击的元素
|
||
description: 描述信息
|
||
"""
|
||
try:
|
||
box = element.bounding_box()
|
||
if not box:
|
||
element.click()
|
||
return
|
||
|
||
# 随机偏移（不要点在正中心）
|
||
offset_x = random.uniform(-box['width'] * 0.3, box['width'] * 0.3)
|
||
offset_y = random.uniform(-box['height'] * 0.3, box['height'] * 0.3)
|
||
|
||
click_x = box['x'] + box['width'] / 2 + offset_x
|
||
click_y = box['y'] + box['height'] / 2 + offset_y
|
||
|
||
# 先移动鼠标到目标位置（模拟真人移动）
|
||
self.page.mouse.move(click_x, click_y, steps=random.randint(5, 15))
|
||
|
||
# 随机延迟后点击
|
||
time.sleep(random.uniform(0.1, 0.3))
|
||
self.page.mouse.click(click_x, click_y)
|
||
|
||
if description:
|
||
logger.debug(f"真人点击: {description} ({click_x:.0f}, {click_y:.0f})")
|
||
|
||
except Exception as e:
|
||
logger.debug(f"真人点击失败，使用普通点击: {str(e)}")
|
||
element.click()
|
||
|
||
def _human_type(self, message: str):
|
||
"""
|
||
模拟真人输入（逐字符输入，随机延迟）
|
||
|
||
Args:
|
||
message: 要输入的消息
|
||
"""
|
||
try:
|
||
for char in message:
|
||
# 随机输入延迟（50-200ms）
|
||
delay = random.uniform(0.05, 0.2)
|
||
self.page.keyboard.type(char, delay=0)
|
||
time.sleep(delay)
|
||
|
||
# 偶尔停顿一下（模拟思考）
|
||
if random.random() < 0.05:
|
||
time.sleep(random.uniform(0.3, 0.8))
|
||
|
||
except Exception as e:
|
||
logger.debug(f"真人输入失败，使用普通输入: {str(e)}")
|
||
self.page.keyboard.type(message, delay=30)
|
||
|
||
def _clean_message_content(self, content: str) -> Optional[str]:
|
||
"""
|
||
清理消息内容，过滤HTML标签和JSON命令
|
||
|
||
Args:
|
||
content: 原始消息内容
|
||
|
||
Returns:
|
||
清理后的内容，如果是无效消息返回None
|
||
"""
|
||
if not content:
|
||
return None
|
||
|
||
# 过滤JSON命令消息
|
||
if content.strip().startswith('{') and '"type":"cmd"' in content:
|
||
return None
|
||
|
||
# 移除HTML标签
|
||
clean_content = re.sub(r'<[^>]+>', '', content)
|
||
|
||
# 去除多余空白
|
||
clean_content = clean_content.strip()
|
||
|
||
# 如果清理后为空，返回None
|
||
if not clean_content:
|
||
return None
|
||
|
||
return clean_content
|
||
|
||
def _setup_response_listener(self):
|
||
"""设置API响应监听器，监听heartbeat和recommend接口"""
|
||
if self._response_listener_active:
|
||
return
|
||
|
||
def handle_response(response: Response):
|
||
try:
|
||
url = response.url
|
||
|
||
# 调试：打印所有 ada.baidu.com 的请求
|
||
if 'ada.baidu.com' in url:
|
||
logger.debug(f"[API请求] {url[:100]}...")
|
||
|
||
# 监听heartbeat API - 获取医生回复
|
||
if self.ADA_HEARTBEAT_API in url and response.status == 200:
|
||
try:
|
||
data = response.json()
|
||
logger.debug(f"[Heartbeat] 响应: {json.dumps(data, ensure_ascii=False)[:500]}")
|
||
|
||
if data.get('status') == 0 and data.get('data', {}).get('talk'):
|
||
talks = data['data']['talk']
|
||
for talk in talks:
|
||
# 检查是否是医生/客服消息
|
||
if talk.get('source') == 'service' or talk.get('msgFrom') == 'service':
|
||
raw_content = talk.get('content', '')
|
||
msg_id = talk.get('messageId', '')
|
||
msg_time = talk.get('messageTime', '')
|
||
|
||
# 清理消息内容（过滤HTML和JSON命令）
|
||
content = self._clean_message_content(raw_content)
|
||
if not content:
|
||
logger.debug(f"[Heartbeat] 跳过无效消息: {raw_content[:50]}...")
|
||
continue
|
||
|
||
# 检查是否是新消息（避免重复）
|
||
if not any(r.get('messageId') == msg_id for r in self.doctor_replies):
|
||
reply_info = {
|
||
'content': content,
|
||
'messageId': msg_id,
|
||
'messageTime': msg_time,
|
||
'source': 'service',
|
||
'received_at': datetime.now().isoformat()
|
||
}
|
||
self.doctor_replies.append(reply_info)
|
||
logger.info(f"[医生回复] 收到新消息: {content[:100]}...")
|
||
except Exception as e:
|
||
logger.debug(f"[Heartbeat] 解析响应失败: {str(e)}")
|
||
|
||
# 监听recommend API - 获取推荐回复
|
||
elif self.ADA_RECOMMEND_API in url and response.status == 200:
|
||
try:
|
||
data = response.json()
|
||
logger.debug(f"[Recommend] 响应: {json.dumps(data, ensure_ascii=False)[:500]}")
|
||
|
||
if data.get('status') == 200 and data.get('data', {}).get('suggestInfo'):
|
||
suggest_info = data['data']['suggestInfo']
|
||
for suggest in suggest_info:
|
||
replies = suggest.get('suggestReply', [])
|
||
for reply in replies:
|
||
reply_id = reply.get('replyId', '')
|
||
# 避免重复
|
||
if not any(r.get('replyId') == reply_id for r in self.recommend_replies):
|
||
self.recommend_replies.append({
|
||
'replyId': reply_id,
|
||
'text': reply.get('text', ''),
|
||
'value': reply.get('value', ''),
|
||
'type': reply.get('type', 'text'),
|
||
'received_at': datetime.now().isoformat()
|
||
})
|
||
if self.recommend_replies:
|
||
logger.info(f"[推荐回复] 收到 {len(replies)} 条推荐: {[r['text'] for r in self.recommend_replies[-len(replies):]]}")
|
||
except Exception as e:
|
||
logger.debug(f"[Recommend] 解析响应失败: {str(e)}")
|
||
|
||
except Exception as e:
|
||
logger.debug(f"处理响应异常: {str(e)}")
|
||
|
||
self.page.on('response', handle_response)
|
||
self._response_listener_active = True
|
||
logger.info("已启用Ada平台API响应监听")
|
||
|
||
def _clear_reply_data(self):
|
||
"""清空回复数据"""
|
||
self.doctor_replies = []
|
||
self.recommend_replies = []
|
||
self.chat_history = []
|
||
self.sent_messages = [] # 记录所有发送的消息
|
||
|
||
def _call_qwen_api(self, doctor_message: str) -> Optional[str]:
|
||
"""
|
||
调用千问大模型生成回复
|
||
|
||
Args:
|
||
doctor_message: 医生/客服的消息
|
||
|
||
Returns:
|
||
生成的回复内容，失败返回None
|
||
"""
|
||
try:
|
||
# 构建系统提示词
|
||
system_prompt = """你是一个正在咨询医疗问题的普通患者。请根据对方（医生/客服）的回复，以患者身份自然地继续对话。
|
||
|
||
要求：
|
||
1. 回复要简短自然，像真实患者一样说话
|
||
2. 可以询问价格、时间、医生资质等问题
|
||
3. 表现出对治疗的关心和一些担忧
|
||
4. 不要暴露自己是AI
|
||
5. 回复长度控制在20-50字以内
|
||
6. 使用口语化的表达
|
||
7. 绝对不要提及任何联系方式，包括：微信、电话、QQ、手机号、邮箱等
|
||
8. 如果对方索要联系方式，委婉拒绝或转移话题"""
|
||
|
||
# 添加医生消息到历史
|
||
self.chat_history.append({
|
||
"role": "user", # 在API调用中，医生消息作为user角色
|
||
"content": f"[医生/客服说]: {doctor_message}"
|
||
})
|
||
|
||
# 构建消息列表
|
||
messages = [{"role": "system", "content": system_prompt}]
|
||
messages.extend(self.chat_history)
|
||
|
||
# 调用API
|
||
headers = {
|
||
"Authorization": f"Bearer {Config.QWEN_API_KEY}",
|
||
"Content-Type": "application/json"
|
||
}
|
||
|
||
payload = {
|
||
"model": "qwen-turbo",
|
||
"messages": messages,
|
||
"temperature": 0.8,
|
||
"max_tokens": 150
|
||
}
|
||
|
||
logger.info(f"调用千问API，医生消息: {doctor_message[:50]}...")
|
||
response = requests.post(
|
||
Config.QWEN_API_URL,
|
||
headers=headers,
|
||
json=payload,
|
||
timeout=30
|
||
)
|
||
|
||
if response.status_code == 200:
|
||
result = response.json()
|
||
reply = result.get('choices', [{}])[0].get('message', {}).get('content', '')
|
||
if reply:
|
||
# 检查回复是否包含敏感词（联系方式相关）
|
||
sensitive_words = ['微信', 'wx', 'WeChat', '电话', '手机', 'QQ', '邮箱', '@', '加我', '联系方式']
|
||
if any(word.lower() in reply.lower() for word in sensitive_words):
|
||
logger.warning(f"AI回复包含敏感词，已过滤: {reply}")
|
||
# 返回一个安全的默认回复
|
||
reply = "好的，我了解了，还想问一下治疗大概需要多长时间呢？"
|
||
|
||
# 添加AI回复到历史
|
||
self.chat_history.append({
|
||
"role": "assistant",
|
||
"content": reply
|
||
})
|
||
logger.info(f"千问API回复: {reply}")
|
||
return reply
|
||
else:
|
||
logger.warning("千问API返回空内容")
|
||
return None
|
||
else:
|
||
logger.error(f"千问API调用失败: {response.status_code} - {response.text}")
|
||
return None
|
||
|
||
except Exception as e:
|
||
logger.error(f"调用千问API异常: {str(e)}")
|
||
return None
|
||
|
||
def check_and_click_ad(self, url: str, site_id: int = None) -> Tuple[bool, bool]:
|
||
"""
|
||
检查并点击广告
|
||
|
||
Args:
|
||
url: MIP页面链接
|
||
site_id: 站点ID（用于数据库记录）
|
||
|
||
Returns:
|
||
(是否点击成功, 是否获得回复)
|
||
"""
|
||
self.site_id = site_id
|
||
|
||
# 清空之前的回复数据
|
||
self._clear_reply_data()
|
||
|
||
# 启用API响应监听
|
||
self._setup_response_listener()
|
||
|
||
try:
|
||
# 访问链接（带重试机制）
|
||
max_retries = 2
|
||
page_loaded = False
|
||
self._update_overlay("访问页面", url[:50] + "...")
|
||
for attempt in range(max_retries):
|
||
try:
|
||
logger.info(f"访问链接: {url} (第{attempt+1}次尝试)")
|
||
self.page.goto(url, wait_until='domcontentloaded', timeout=30000)
|
||
page_loaded = True
|
||
break
|
||
except Exception as goto_err:
|
||
if attempt < max_retries - 1:
|
||
logger.warning(f"访问超时，尝试刷新页面...")
|
||
try:
|
||
self.page.reload(wait_until='domcontentloaded', timeout=30000)
|
||
logger.info("✅ 页面刷新成功")
|
||
page_loaded = True
|
||
break
|
||
except:
|
||
logger.warning(f"刷新失败，等待2秒后重试...")
|
||
time.sleep(2)
|
||
else:
|
||
logger.error(f"访问链接失败: {str(goto_err)}")
|
||
# 记录访问失败
|
||
self._record_click_failure(url, f"访问超时: {str(goto_err)}")
|
||
return False, False
|
||
|
||
if not page_loaded:
|
||
self._record_click_failure(url, "页面加载失败")
|
||
return False, False
|
||
|
||
# 等待页面加载
|
||
time.sleep(3)
|
||
|
||
# 检查是否存在商业广告
|
||
self._update_overlay("检测广告", "扫描页面中...")
|
||
has_ad, ad_elements = self._detect_commercial_ad()
|
||
|
||
if not has_ad:
|
||
logger.info("未检测到商业广告，跳过该链接")
|
||
self._update_overlay("未检测到广告", "跳过该链接")
|
||
# 记录无广告
|
||
self._record_click_failure(url, "未检测到商业广告")
|
||
return False, False
|
||
|
||
# 逐个尝试点击广告，直到成功
|
||
self._update_overlay("点击广告", f"检测到 {len(ad_elements)} 个广告")
|
||
logger.info(f"检测到商业广告，准备点击（共 {len(ad_elements)} 个）")
|
||
click_success = False
|
||
|
||
for idx, ad_element in enumerate(ad_elements, 1):
|
||
logger.info(f"尝试点击第 {idx}/{len(ad_elements)} 个广告...")
|
||
self._update_overlay("点击广告", f"尝试第 {idx}/{len(ad_elements)} 个")
|
||
if self._click_advertisement(ad_element):
|
||
logger.info(f"✅ 第 {idx} 个广告点击成功")
|
||
click_success = True
|
||
break
|
||
else:
|
||
logger.warning(f"❌ 第 {idx} 个广告点击失败，尝试下一个...")
|
||
# 等待一下再点下一个
|
||
time.sleep(1)
|
||
|
||
if not click_success:
|
||
logger.warning("所有广告均点击失败")
|
||
self._update_overlay("点击失败", "所有广告均点击失败")
|
||
# 记录点击失败
|
||
self._record_click_failure(url, f"所有广告（{len(ad_elements)}个）均点击失败")
|
||
return False, False
|
||
|
||
# 记录点击到数据库
|
||
self._record_click(url)
|
||
|
||
# 等待聊天页面加载
|
||
self._update_overlay("进入聊天", "等待页面加载...")
|
||
logger.info("等待聊天页面加载...")
|
||
time.sleep(3)
|
||
|
||
# 检查是否跳转到非聊天页面
|
||
non_chat_domains = [
|
||
'sp.vejianzhan.com', # 微建站落地页
|
||
# 可以在这里添加更多需要跳过的域名
|
||
]
|
||
current_url = self.page.url.lower()
|
||
for domain in non_chat_domains:
|
||
if domain in current_url:
|
||
logger.info(f"检测到非聊天页面({domain})，判定为点击失败")
|
||
self._update_overlay("非聊天页面", "非聊天页面，跳过")
|
||
self._record_click_failure(url, f"跳转到非聊天页面({domain})")
|
||
return False, False
|
||
|
||
# 直接开始交互（API响应需要页面交互才会触发）
|
||
# 优先尝试点击页面上可见的推荐按钮，没有则发送初始消息
|
||
logger.info("开始首次交互...")
|
||
if not self._try_click_visible_recommend():
|
||
self._send_initial_message()
|
||
|
||
# 执行自动聊天交互（3-5轮，每轮间隔30-90秒）
|
||
self._update_overlay("自动聊天", "开始交互...")
|
||
logger.info("开始自动聊天交互流程...")
|
||
interaction_rounds = self._auto_chat_interaction()
|
||
|
||
# 检查是否收到回复
|
||
has_reply = len(self.doctor_replies) > 0
|
||
|
||
# 记录互动到数据库
|
||
self._record_interaction(has_reply)
|
||
|
||
self._update_overlay("完成", f"交互 {interaction_rounds} 轮，回复: {has_reply}")
|
||
logger.info(f"交互结束，完成 {interaction_rounds} 轮，收到回复: {has_reply}")
|
||
return True, has_reply
|
||
|
||
except Exception as e:
|
||
logger.error(f"处理链接异常: {str(e)}")
|
||
self._update_overlay("异常", str(e)[:30])
|
||
# 记录异常
|
||
try:
|
||
self._record_click_failure(url, f"异常: {str(e)}")
|
||
except:
|
||
pass
|
||
return False, False
|
||
finally:
|
||
# 等待一会再移除浮窗
|
||
time.sleep(2)
|
||
self._remove_overlay()
|
||
# 尝试关闭当前标签页，返回主窗口
|
||
self._close_current_tab()
|
||
|
||
def _detect_commercial_ad(self) -> Tuple[bool, List[ElementHandle]]:
|
||
"""
|
||
检测页面是否存在商业广告
|
||
|
||
Returns:
|
||
(是否存在商业广告, 广告元素列表)
|
||
"""
|
||
try:
|
||
# 等待评论区加载
|
||
time.sleep(2)
|
||
|
||
# 查找包含“广告”标识的元素
|
||
ad_selectors = [
|
||
"//div[contains(@class, 'ad') or contains(@class, 'advertisement')]",
|
||
"//div[contains(text(), '广告')]",
|
||
"//*[contains(text(), '广告')]//ancestor::div[contains(@class, 'card')]",
|
||
"//a[contains(@class, 'ad-link')]",
|
||
]
|
||
|
||
ad_elements = []
|
||
for selector in ad_selectors:
|
||
try:
|
||
elements = self.page.locator(f"xpath={selector}").all()
|
||
if elements:
|
||
# 检查元素是否可见
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
# 进一步验证是否是商业广告（非AI健康管家）
|
||
try:
|
||
elem_text = elem.inner_text().lower()
|
||
if '广告' in elem_text and 'ai健康' not in elem_text:
|
||
ad_elements.append(elem)
|
||
except:
|
||
continue
|
||
except Exception:
|
||
continue
|
||
|
||
if ad_elements:
|
||
logger.info(f"检测到 {len(ad_elements)} 个商业广告")
|
||
return True, ad_elements
|
||
|
||
logger.info("未检测到商业广告")
|
||
return False, []
|
||
|
||
except Exception as e:
|
||
logger.error(f"检测广告异常: {str(e)}")
|
||
return False, []
|
||
|
||
def _get_ad_info(self, ad_element) -> str:
|
||
"""
|
||
获取广告元素的详细信息
|
||
|
||
Args:
|
||
ad_element: 广告元素
|
||
|
||
Returns:
|
||
广告信息字符串
|
||
"""
|
||
try:
|
||
info_parts = []
|
||
|
||
# 获取广告文本内容
|
||
try:
|
||
text = ad_element.inner_text()
|
||
if text:
|
||
# 清理文本，只取前100字符
|
||
text = text.strip().replace('\n', ' ')[:100]
|
||
info_parts.append(f"文本: {text}")
|
||
except:
|
||
pass
|
||
|
||
# 获取广告链接
|
||
try:
|
||
href = ad_element.get_attribute('href')
|
||
if href:
|
||
info_parts.append(f"链接: {href[:80]}")
|
||
except:
|
||
pass
|
||
|
||
# 获取广告标题
|
||
try:
|
||
title = ad_element.get_attribute('title')
|
||
if title:
|
||
info_parts.append(f"标题: {title}")
|
||
except:
|
||
pass
|
||
|
||
# 尝试获取内部链接
|
||
if not any('链接' in p for p in info_parts):
|
||
try:
|
||
link = ad_element.locator('a').first
|
||
if link:
|
||
href = link.get_attribute('href')
|
||
if href:
|
||
info_parts.append(f"内链: {href[:80]}")
|
||
except:
|
||
pass
|
||
|
||
return ' | '.join(info_parts) if info_parts else "无详细信息"
|
||
|
||
except Exception as e:
|
||
return f"获取信息失败: {str(e)}"
|
||
|
||
def _click_advertisement(self, ad_element: ElementHandle) -> bool:
|
||
"""
|
||
点击广告元素（当前页面导航）
|
||
|
||
Args:
|
||
ad_element: 广告元素
|
||
|
||
Returns:
|
||
是否点击成功
|
||
"""
|
||
try:
|
||
original_url = self.page.url
|
||
|
||
# 获取广告详细信息
|
||
ad_info = self._get_ad_info(ad_element)
|
||
logger.info(f"广告信息: {ad_info}")
|
||
|
||
# 滚动到广告元素可见
|
||
ad_element.scroll_into_view_if_needed()
|
||
time.sleep(1)
|
||
|
||
# 直接点击广告（当前页面导航）
|
||
logger.info("点击广告...")
|
||
ad_element.click()
|
||
logger.info("已点击广告")
|
||
|
||
# 等待页面导航（增加等待时间，支持慢速电脑）
|
||
logger.info("等待页面跳转...")
|
||
max_wait = 10 # 最多等待10秒
|
||
check_interval = 1 # 每秒检查一次
|
||
|
||
for i in range(max_wait):
|
||
time.sleep(check_interval)
|
||
if self.page.url != original_url:
|
||
logger.info(f"✅ 页面已导航（耗时{i+1}秒）: {original_url} -> {self.page.url}")
|
||
|
||
# 尝试等待页面加载完成，但不强制要求
|
||
try:
|
||
logger.info("等待页面加载...")
|
||
self.page.wait_for_load_state('domcontentloaded', timeout=10000)
|
||
logger.info("✅ 页面加载完成")
|
||
except Exception as load_err:
|
||
# 页面加载超时不判定为失败，继续执行
|
||
# 因为聊天页面可能已经可用（API响应已经在接收）
|
||
logger.warning(f"⚠️ 页面加载超时，但URL已跳转，继续执行...")
|
||
|
||
break
|
||
else:
|
||
# 循环正常结束（未跳转）
|
||
logger.error(f"❌ 页面URL未变化（等待{max_wait}秒后），广告点击失败: {self.page.url}")
|
||
return False
|
||
|
||
# 等待聊天页面加载
|
||
time.sleep(2)
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
logger.error(f"点击广告异常: {str(e)}")
|
||
return False
|
||
|
||
def _send_consultation_message(self) -> bool:
|
||
"""
|
||
在聊天页面发送随机咨询消息
|
||
|
||
Returns:
|
||
是否发送成功
|
||
"""
|
||
try:
|
||
logger.info("准备发送咨询消息...")
|
||
|
||
# 随机选择一条消息
|
||
message = random.choice(self.CONSULTATION_MESSAGES)
|
||
logger.info(f"选择的消息: {message}")
|
||
|
||
# 等待页面加载完成
|
||
time.sleep(2)
|
||
|
||
# 打印当前页面URL
|
||
logger.info(f"当前页面: {self.page.url}")
|
||
|
||
# 常见的输入框选择器（优先通过placeholder查找）
|
||
input_selectors = [
|
||
# 优先：通过placeholder查找
|
||
"textarea[placeholder*='消息']",
|
||
"textarea[placeholder*='问题']",
|
||
"input[type='text'][placeholder*='消息']",
|
||
"input[type='text'][placeholder*='问题']",
|
||
"textarea[placeholder*='输入']",
|
||
"textarea[placeholder*='发送']",
|
||
"input[type='text'][placeholder*='输入']",
|
||
"input[type='text'][placeholder*='发送']",
|
||
# 次选：通过class查找
|
||
"textarea[class*='input']",
|
||
# 兜底：通用选择器
|
||
"div[contenteditable='true']",
|
||
"textarea",
|
||
"input[type='text']"
|
||
]
|
||
|
||
input_element = None
|
||
logger.info("开始查找输入框...")
|
||
for selector in input_selectors:
|
||
try:
|
||
elements = self.page.locator(selector).all()
|
||
logger.debug(f"选择器 {selector} 找到 {len(elements)} 个元素")
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
input_element = elem
|
||
logger.info(f"✅ 找到可见输入框: {selector}")
|
||
break
|
||
if input_element:
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
if not input_element:
|
||
logger.warning("❌ 未找到输入框")
|
||
# 尝试截图便于调试
|
||
try:
|
||
if self.task_folder:
|
||
screenshot_path = self.task_folder / "debug_no_input.png"
|
||
else:
|
||
screenshot_path = Path(f"./logs/debug_no_input_{int(time.time())}.png")
|
||
self.page.screenshot(path=str(screenshot_path))
|
||
logger.info(f"已保存调试截图: {screenshot_path}")
|
||
except Exception as e:
|
||
logger.warning(f"截图失败: {str(e)}")
|
||
|
||
# 兜底方案：尝试查找并点击任何可能的输入区域
|
||
logger.warning("尝试兜底方案：查找所有可能的输入区域...")
|
||
try:
|
||
# 先滚动到页面最底部
|
||
self.page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
|
||
time.sleep(1)
|
||
|
||
# 尝试查找所有可能的输入相关元素并点击
|
||
fallback_selectors = [
|
||
"textarea",
|
||
"input[type='text']",
|
||
"div[contenteditable='true']",
|
||
"div[class*='input']",
|
||
"div[class*='textarea']",
|
||
"div[class*='message']",
|
||
"div[class*='chat']",
|
||
"div[id*='input']",
|
||
"div[id*='message']"
|
||
]
|
||
|
||
clicked = False
|
||
for selector in fallback_selectors:
|
||
try:
|
||
elements = self.page.locator(selector).all()
|
||
logger.debug(f"兜底选择器 {selector} 找到 {len(elements)} 个元素")
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
# 滚动到元素位置
|
||
elem.scroll_into_view_if_needed()
|
||
time.sleep(0.5)
|
||
# 点击元素
|
||
elem.click()
|
||
time.sleep(1)
|
||
logger.info(f"已点击元素: {selector}")
|
||
clicked = True
|
||
break
|
||
if clicked:
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"兜底选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
if clicked:
|
||
# 使用真人模拟输入
|
||
self._human_type(message)
|
||
logger.info("✅ 已输入消息（兜底）")
|
||
|
||
# 直接按回车发送
|
||
self.page.keyboard.press('Enter')
|
||
logger.info("✅ 已按回车键发送（兜底）")
|
||
|
||
# 保存已发送的消息内容
|
||
self.sent_message = message
|
||
time.sleep(2)
|
||
return True
|
||
else:
|
||
logger.error("❌ 兜底方案未找到任何可点击的输入区域")
|
||
return False
|
||
|
||
except Exception as fallback_err:
|
||
logger.error(f"兜底方案失败: {str(fallback_err)}")
|
||
return False
|
||
|
||
# 正常流程：点击输入框获取焦点
|
||
input_element.click()
|
||
time.sleep(0.5)
|
||
|
||
# 使用真人模拟输入
|
||
self._human_type(message)
|
||
logger.info("✅ 已输入消息")
|
||
time.sleep(1)
|
||
|
||
# 尝试发送消息（优先回车，再尝试按钮）
|
||
sent = False
|
||
|
||
# 方法1（优先）：按回车键发送
|
||
try:
|
||
logger.info("尝试按回车键发送...")
|
||
input_element.press('Enter')
|
||
logger.info("✅ 已按回车键发送")
|
||
sent = True
|
||
time.sleep(1)
|
||
except Exception as e:
|
||
logger.warning(f"❌ 按回车键失败: {str(e)}")
|
||
|
||
# 方法2（兜底）: 尝试找到发送按钮并点击
|
||
if not sent:
|
||
send_button_selectors = [
|
||
"button:has-text('发送')",
|
||
"button[class*='send']",
|
||
"button[type='submit']",
|
||
"div[class*='send']",
|
||
"span:has-text('发送')"
|
||
]
|
||
|
||
logger.info("开始查找发送按钮...")
|
||
for selector in send_button_selectors:
|
||
try:
|
||
buttons = self.page.locator(selector).all()
|
||
logger.debug(f"选择器 {selector} 找到 {len(buttons)} 个按钮")
|
||
for btn in buttons:
|
||
if btn.is_visible() and btn.is_enabled():
|
||
btn.click()
|
||
logger.info(f"✅ 已点击发送按钮: {selector}")
|
||
sent = True
|
||
break
|
||
if sent:
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
if sent:
|
||
logger.info("✅ 消息发送成功")
|
||
# 保存已发送的消息内容
|
||
self.sent_message = message
|
||
time.sleep(2) # 等待消息发送完成
|
||
return True
|
||
else:
|
||
logger.warning("❌ 未能发送消息")
|
||
# 截图调试
|
||
try:
|
||
if self.task_folder:
|
||
screenshot_path = self.task_folder / "debug_send_failed.png"
|
||
else:
|
||
screenshot_path = Path(f"./logs/debug_send_failed_{int(time.time())}.png")
|
||
self.page.screenshot(path=str(screenshot_path))
|
||
logger.info(f"已保存调试截图: {screenshot_path}")
|
||
except:
|
||
pass
|
||
return False
|
||
|
||
except Exception as e:
|
||
logger.error(f"发送消息异常: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def _record_click(self, site_url: str):
|
||
"""记录点击到数据库"""
|
||
try:
|
||
if not self.site_id:
|
||
logger.warning("未设置 site_id，跳过点击记录")
|
||
return
|
||
|
||
from db_manager import ClickManager
|
||
click_mgr = ClickManager()
|
||
self.click_id = click_mgr.record_click(
|
||
site_id=self.site_id,
|
||
site_url=site_url,
|
||
user_ip=None, # 可以后续添加代理IP
|
||
device_type='pc'
|
||
)
|
||
logger.info(f"已记录点击: click_id={self.click_id}")
|
||
except Exception as e:
|
||
logger.error(f"记录点击失败: {str(e)}")
|
||
|
||
def _record_click_failure(self, site_url: str, error_message: str):
|
||
"""
|
||
记录点击失败到数据库
|
||
|
||
Args:
|
||
site_url: 站点URL
|
||
error_message: 错误信息
|
||
"""
|
||
try:
|
||
if not self.site_id:
|
||
logger.warning("未设置 site_id，跳过失败记录")
|
||
return
|
||
|
||
from db_manager import ClickManager
|
||
click_mgr = ClickManager()
|
||
# 记录点击（失败也计数）
|
||
self.click_id = click_mgr.record_click(
|
||
site_id=self.site_id,
|
||
site_url=site_url,
|
||
user_ip=None,
|
||
device_type='pc'
|
||
)
|
||
|
||
# 记录互动失败
|
||
from db_manager import InteractionManager
|
||
interaction_mgr = InteractionManager()
|
||
interaction_mgr.record_interaction(
|
||
site_id=self.site_id,
|
||
click_id=self.click_id,
|
||
interaction_type='reply',
|
||
reply_content=None,
|
||
is_successful=False,
|
||
response_received=False,
|
||
error_message=error_message
|
||
)
|
||
logger.info(f"已记录失败: {error_message}")
|
||
except Exception as e:
|
||
logger.error(f"记录失败异常: {str(e)}")
|
||
|
||
def _record_interaction(self, response_received: bool):
|
||
"""记录互动到数据库（包含医生回复内容）"""
|
||
try:
|
||
if not self.site_id:
|
||
logger.warning("未设置 site_id，跳过互动记录")
|
||
return
|
||
|
||
from db_manager import InteractionManager
|
||
interaction_mgr = InteractionManager()
|
||
|
||
# 获取完整聊天记录
|
||
full_chat_log = self._get_full_chat_log()
|
||
if full_chat_log:
|
||
logger.info(f"完整聊天记录 ({len(self.doctor_replies)}条医生消息):")
|
||
logger.debug(full_chat_log[:500])
|
||
|
||
interaction_id = interaction_mgr.record_interaction(
|
||
site_id=self.site_id,
|
||
click_id=self.click_id,
|
||
interaction_type='message', # 符合数据库ENUM定义：reply/comment/message/form_submit/follow/like/share
|
||
reply_content=getattr(self, 'sent_message', None),
|
||
is_successful=True,
|
||
response_received=response_received,
|
||
response_content=full_chat_log # 保存完整聊天记录
|
||
)
|
||
logger.info(f"已记录互动: interaction_id={interaction_id}, response={response_received}")
|
||
|
||
# 记录详细的回复信息到日志
|
||
if self.doctor_replies:
|
||
logger.info(f"本次共收到 {len(self.doctor_replies)} 条医生回复:")
|
||
for idx, reply in enumerate(self.doctor_replies, 1):
|
||
logger.info(f" [{idx}] {reply.get('content', '')[:100]}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"记录互动失败: {str(e)}")
|
||
|
||
def _wait_for_reply(self) -> bool:
|
||
"""
|
||
等待广告主回复（通过监听heartbeat API）
|
||
|
||
Returns:
|
||
是否收到回复
|
||
"""
|
||
try:
|
||
logger.info(f"等待广告主回复（最多{Config.REPLY_WAIT_TIMEOUT}秒）")
|
||
|
||
# 记录等待开始时的回复数量
|
||
initial_reply_count = len(self.doctor_replies)
|
||
|
||
# 等待并检查回复
|
||
start_time = time.time()
|
||
timeout = Config.REPLY_WAIT_TIMEOUT
|
||
check_interval = 2 # 每2秒检查一次
|
||
|
||
while time.time() - start_time < timeout:
|
||
time.sleep(check_interval)
|
||
|
||
# 检查是否有新的医生回复（通过heartbeat API监听获取）
|
||
if len(self.doctor_replies) > initial_reply_count:
|
||
new_replies = self.doctor_replies[initial_reply_count:]
|
||
logger.info(f"收到 {len(new_replies)} 条医生回复")
|
||
for reply in new_replies:
|
||
logger.info(f" - {reply.get('content', '')[:100]}")
|
||
|
||
# 尝试发送推荐回复进行二次互动
|
||
self._try_click_recommend_reply()
|
||
|
||
return True
|
||
|
||
# 打印等待进度
|
||
elapsed = int(time.time() - start_time)
|
||
if elapsed % 10 == 0 and elapsed > 0:
|
||
logger.info(f"等待中... ({elapsed}/{timeout}秒)")
|
||
|
||
logger.info("未收到广告主回复（超时）")
|
||
return False
|
||
|
||
except Exception as e:
|
||
logger.error(f"等待回复异常: {str(e)}")
|
||
return False
|
||
|
||
def _try_click_recommend_reply(self) -> bool:
|
||
"""
|
||
尝试点击推荐回复按钮
|
||
|
||
Returns:
|
||
是否点击成功
|
||
"""
|
||
try:
|
||
# 检查是否有推荐回复
|
||
if not self.recommend_replies:
|
||
logger.info("暂无推荐回复")
|
||
return False
|
||
|
||
# 需要过滤的关键词（电话相关）
|
||
filter_keywords = ['电话', '拨打', '致电', '来电', '通话', '微信', '加微', 'wx', 'WeChat', '满意度', '评价', '好评', '差评']
|
||
|
||
# 获取推荐回复文本列表（过滤电话相关）
|
||
recommend_texts = []
|
||
for recommend in self.recommend_replies:
|
||
text = recommend.get('text', '') or recommend.get('value', '')
|
||
if text:
|
||
# 过滤电话相关
|
||
if any(kw in text for kw in filter_keywords):
|
||
logger.debug(f"跳过电话相关推荐: {text}")
|
||
continue
|
||
recommend_texts.append(text)
|
||
|
||
if not recommend_texts:
|
||
logger.warning("推荐回复内容为空（或全是电话相关）")
|
||
return False
|
||
|
||
logger.info(f"查找推荐回复按钮: {recommend_texts}")
|
||
|
||
# 推荐回复按钮的选择器
|
||
button_selectors = [
|
||
# 常见的推荐回复按钮选择器
|
||
"div[class*='suggest'] button",
|
||
"div[class*='suggest'] div[class*='item']",
|
||
"div[class*='recommend'] button",
|
||
"div[class*='recommend'] div[class*='item']",
|
||
"div[class*='quick'] button",
|
||
"div[class*='quick'] div[class*='reply']",
|
||
"button[class*='suggest']",
|
||
"button[class*='recommend']",
|
||
"div[class*='bubble'] span",
|
||
"div[class*='reply-item']",
|
||
"span[class*='suggest']",
|
||
]
|
||
|
||
# 遍历选择器查找按钮
|
||
for selector in button_selectors:
|
||
try:
|
||
elements = self.page.locator(selector).all()
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
try:
|
||
elem_text = elem.inner_text().strip()
|
||
# 检查按钮文本是否匹配推荐回复
|
||
for recommend_text in recommend_texts:
|
||
if recommend_text in elem_text or elem_text in recommend_text:
|
||
logger.info(f"找到推荐回复按钮: {elem_text}")
|
||
elem.click()
|
||
logger.info(f"✅ 已点击推荐回复: {elem_text}")
|
||
self.sent_recommend_reply = elem_text
|
||
self.sent_message = f"[推荐回复] {elem_text}"
|
||
if not hasattr(self, 'sent_messages'):
|
||
self.sent_messages = []
|
||
self.sent_messages.append({'role': '我方(推荐回复)', 'content': elem_text})
|
||
time.sleep(1)
|
||
return True
|
||
except:
|
||
continue
|
||
except Exception as e:
|
||
logger.debug(f"选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
# 如果没有找到匹配的按钮，尝试通过文本内容直接查找
|
||
logger.info("尝试通过文本内容查找推荐回复按钮...")
|
||
for recommend_text in recommend_texts:
|
||
try:
|
||
# 使用XPath通过文本内容查找
|
||
xpath_selectors = [
|
||
f"//*[contains(text(), '{recommend_text[:10]}')]",
|
||
f"//button[contains(text(), '{recommend_text[:10]}')]",
|
||
f"//span[contains(text(), '{recommend_text[:10]}')]",
|
||
f"//div[contains(text(), '{recommend_text[:10]}')]",
|
||
]
|
||
|
||
for xpath in xpath_selectors:
|
||
try:
|
||
elements = self.page.locator(f"xpath={xpath}").all()
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
# 检查元素是否可点击（不是整个容器）
|
||
box = elem.bounding_box()
|
||
if box and box['width'] < 500 and box['height'] < 100:
|
||
logger.info(f"找到推荐回复元素: {recommend_text[:20]}")
|
||
elem.click()
|
||
logger.info(f"✅ 已点击推荐回复: {recommend_text}")
|
||
self.sent_recommend_reply = recommend_text
|
||
self.sent_message = f"[推荐回复] {recommend_text}"
|
||
if not hasattr(self, 'sent_messages'):
|
||
self.sent_messages = []
|
||
self.sent_messages.append({'role': '我方(推荐回复)', 'content': recommend_text})
|
||
time.sleep(1)
|
||
return True
|
||
except:
|
||
continue
|
||
except Exception as e:
|
||
logger.debug(f"文本查找失败: {str(e)}")
|
||
continue
|
||
|
||
logger.warning("未找到可点击的推荐回复按钮")
|
||
return False
|
||
|
||
except Exception as e:
|
||
logger.error(f"点击推荐回复异常: {str(e)}")
|
||
return False
|
||
|
||
def _try_click_visible_recommend(self) -> bool:
|
||
"""
|
||
遍历每条带推荐回复的消息，从中随机选一个点击
|
||
|
||
Returns:
|
||
是否点击成功
|
||
"""
|
||
try:
|
||
# 需要过滤的关键词
|
||
filter_keywords = ['电话', '拨打', '致电', '来电', '通话', '微信', '加微', 'wx', 'WeChat', '满意度', '评价', '好评', '差评']
|
||
|
||
# 查找所有推荐回复组（每组对应一条消息的推荐）
|
||
recommend_group_selectors = [
|
||
"div.gt-jmy-h5-c-msg-tag",
|
||
"div[class*='msg-tag']",
|
||
"div[class*='suggest-reply']",
|
||
"div[class*='quick-reply']",
|
||
"div[class*='recommend-reply']",
|
||
]
|
||
|
||
clicked_count = 0
|
||
|
||
for group_selector in recommend_group_selectors:
|
||
try:
|
||
groups = self.page.locator(group_selector).all()
|
||
for group in groups:
|
||
if not group.is_visible():
|
||
continue
|
||
|
||
# 获取该组内的所有推荐选项
|
||
options = group.locator("span.content-text").all()
|
||
if not options:
|
||
options = group.locator("span").all()
|
||
if not options:
|
||
options = group.locator("button").all()
|
||
if not options:
|
||
options = group.locator("div[class*='item']").all()
|
||
|
||
# 收集该组内可用的选项
|
||
available_options = []
|
||
for opt in options:
|
||
try:
|
||
if opt.is_visible():
|
||
text = opt.inner_text().strip()
|
||
# 过滤敏感词
|
||
if any(kw in text for kw in filter_keywords):
|
||
continue
|
||
if text and len(text) < 30:
|
||
available_options.append({'elem': opt, 'text': text})
|
||
except:
|
||
continue
|
||
|
||
# 从该组中随机选一个点击
|
||
if available_options:
|
||
selected = random.choice(available_options)
|
||
logger.info(f"推荐选项: {[o['text'] for o in available_options]}，选择: {selected['text']}")
|
||
self._human_click(selected['elem'], f"推荐回复: {selected['text']}")
|
||
logger.info(f"✅ 已点击推荐: {selected['text']}")
|
||
self.sent_recommend_reply = selected['text']
|
||
self.sent_message = f"[推荐回复] {selected['text']}" # 记录到sent_message
|
||
if not hasattr(self, 'sent_messages'):
|
||
self.sent_messages = []
|
||
self.sent_messages.append({'role': '我方(推荐回复)', 'content': selected['text']})
|
||
clicked_count += 1
|
||
# 随机延迟2-5秒，模拟真人操作
|
||
delay = random.uniform(2, 5)
|
||
time.sleep(delay)
|
||
except:
|
||
continue
|
||
|
||
if clicked_count > 0:
|
||
logger.info(f"共点击 {clicked_count} 个推荐回复")
|
||
return True
|
||
|
||
# 兜底：使用通用选择器查找
|
||
button_selectors = [
|
||
"div[class*='suggest'] span",
|
||
"div[class*='recommend'] span",
|
||
"div[class*='quick-reply'] span",
|
||
"button[class*='suggest']",
|
||
"div[class*='reply-item']",
|
||
"span[class*='reply']",
|
||
]
|
||
|
||
available_buttons = []
|
||
for selector in button_selectors:
|
||
try:
|
||
elements = self.page.locator(selector).all()
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
try:
|
||
text = elem.inner_text().strip()
|
||
if any(kw in text for kw in filter_keywords):
|
||
continue
|
||
if text and len(text) < 30:
|
||
box = elem.bounding_box()
|
||
if box and box['width'] < 200 and box['height'] < 60:
|
||
if not any(b['text'] == text for b in available_buttons):
|
||
available_buttons.append({'elem': elem, 'text': text})
|
||
except:
|
||
continue
|
||
except:
|
||
continue
|
||
|
||
if available_buttons:
|
||
selected = random.choice(available_buttons)
|
||
logger.info(f"找到 {len(available_buttons)} 个推荐按钮，选择: {selected['text']}")
|
||
# 随机延迟1-3秒后点击
|
||
time.sleep(random.uniform(1, 3))
|
||
self._human_click(selected['elem'], f"推荐按钮: {selected['text']}")
|
||
logger.info(f"✅ 已点击推荐按钮: {selected['text']}")
|
||
self.sent_recommend_reply = selected['text']
|
||
if not hasattr(self, 'sent_messages'):
|
||
self.sent_messages = []
|
||
self.sent_messages.append({'role': '我方(推荐回复)', 'content': selected['text']})
|
||
# 点击后随机延迟2-4秒
|
||
time.sleep(random.uniform(2, 4))
|
||
return True
|
||
|
||
logger.debug("未找到可见的推荐按钮")
|
||
return False
|
||
|
||
except Exception as e:
|
||
logger.error(f"查找推荐按钮异常: {str(e)}")
|
||
return False
|
||
|
||
def _count_dom_recommend_buttons(self) -> int:
|
||
"""
|
||
统计页面DOM中的推荐按钮数量
|
||
|
||
Returns:
|
||
推荐按钮数量
|
||
"""
|
||
try:
|
||
count = 0
|
||
# 基于实际页面结构的选择器
|
||
selectors = [
|
||
"div.gt-jmy-h5-c-msg-tag span.content-text",
|
||
"div[class*='msg-tag'] span.content-text",
|
||
]
|
||
|
||
for selector in selectors:
|
||
try:
|
||
elements = self.page.locator(selector).all()
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
count += 1
|
||
except:
|
||
continue
|
||
|
||
return count
|
||
except:
|
||
return 0
|
||
|
||
def _get_latest_doctor_message_from_dom(self) -> Optional[str]:
|
||
"""
|
||
从DOM获取最新的医生消息，并添加到doctor_replies
|
||
|
||
Returns:
|
||
最新医生消息内容
|
||
"""
|
||
try:
|
||
# 基于实际页面结构的选择器
|
||
selectors = [
|
||
"div.msg-container-normal div.mip-sjh-text",
|
||
"div[class*='msg-container'] div.mip-sjh-text",
|
||
"div[class*='bot-msg'] div.mip-sjh-text",
|
||
]
|
||
|
||
for selector in selectors:
|
||
try:
|
||
elements = self.page.locator(selector).all()
|
||
if elements:
|
||
# 获取最后一个（最新的）消息
|
||
last_elem = elements[-1]
|
||
if last_elem.is_visible():
|
||
text = last_elem.inner_text().strip()
|
||
if text:
|
||
# 检查是否已存在（避免重复）
|
||
if not any(r.get('content') == text for r in self.doctor_replies):
|
||
self.doctor_replies.append({
|
||
'content': text,
|
||
'messageId': f'dom_{len(self.doctor_replies)}',
|
||
'source': 'dom',
|
||
'received_at': datetime.now().isoformat()
|
||
})
|
||
logger.debug(f"[DOM] 添加医生消息: {text[:50]}...")
|
||
return text
|
||
except:
|
||
continue
|
||
|
||
return None
|
||
except:
|
||
return None
|
||
|
||
def _send_initial_message(self):
|
||
"""发送初始咨询消息"""
|
||
initial_message = random.choice(self.CONSULTATION_MESSAGES)
|
||
if self._send_message_to_chat(initial_message):
|
||
logger.info(f"✅ 已发送初始消息: {initial_message}")
|
||
self.sent_message = initial_message
|
||
else:
|
||
logger.warning("初始消息发送失败")
|
||
|
||
def _send_message_to_chat(self, message: str) -> bool:
|
||
"""
|
||
在聊天页面发送消息
|
||
|
||
Args:
|
||
message: 要发送的消息
|
||
|
||
Returns:
|
||
是否发送成功
|
||
"""
|
||
try:
|
||
# 查找输入框（多种选择器，按优先级排列）
|
||
input_selectors = [
|
||
# 基于实际页面结构（自定义输入框组件）
|
||
"div.gt-jmy-h5-bot-text-input",
|
||
"div.text-input",
|
||
"div.input-area",
|
||
"div.fake-input",
|
||
# 基于class名称
|
||
"textarea.chat-input",
|
||
"textarea[class*='input']",
|
||
"textarea[class*='textarea']",
|
||
"div[class*='input'] textarea",
|
||
"div[class*='chat'] textarea",
|
||
# 基于placeholder
|
||
"textarea[placeholder*='消息']",
|
||
"textarea[placeholder*='问题']",
|
||
"textarea[placeholder*='输入']",
|
||
"textarea[placeholder*='说点']",
|
||
"textarea[placeholder*='描述']",
|
||
"input[type='text'][placeholder*='消息']",
|
||
"input[type='text'][placeholder*='输入']",
|
||
# 基于contenteditable
|
||
"div[contenteditable='true']",
|
||
# 通用兜底
|
||
"textarea",
|
||
"input[type='text']"
|
||
]
|
||
|
||
# 最多重试3次
|
||
for retry in range(3):
|
||
input_element = None
|
||
is_custom_input = False # 标记是否是自定义输入框
|
||
|
||
for selector in input_selectors:
|
||
try:
|
||
elements = self.page.locator(selector).all()
|
||
for elem in elements:
|
||
if elem.is_visible():
|
||
box = elem.bounding_box()
|
||
if box and box['height'] > 20:
|
||
input_element = elem
|
||
# 检查是否是自定义输入框
|
||
if 'gt-jmy' in selector or 'fake-input' in selector or 'text-input' in selector:
|
||
is_custom_input = True
|
||
logger.debug(f"找到输入框: {selector}, 自定义: {is_custom_input}")
|
||
break
|
||
if input_element:
|
||
break
|
||
except:
|
||
continue
|
||
|
||
if input_element:
|
||
break
|
||
|
||
# 没找到，等待后重试
|
||
if retry < 2:
|
||
logger.info(f"未找到输入框，等待2秒后重试... ({retry+1}/3)")
|
||
time.sleep(2)
|
||
try:
|
||
self.page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
|
||
except:
|
||
pass
|
||
|
||
# 兜底方案：点击页面底部中心位置激活输入框
|
||
if not input_element:
|
||
logger.info("尝试兜底方案：点击页面底部中心位置...")
|
||
try:
|
||
# 获取页面尺寸
|
||
viewport = self.page.viewport_size
|
||
if viewport:
|
||
# 点击底部中心上方一点的位置（大约底部往上100px）
|
||
click_x = viewport['width'] // 2
|
||
click_y = viewport['height'] - 100
|
||
self.page.mouse.click(click_x, click_y)
|
||
logger.info(f"点击位置: ({click_x}, {click_y})")
|
||
time.sleep(0.5)
|
||
|
||
# 使用真人模拟输入
|
||
self._human_type(message)
|
||
time.sleep(0.3)
|
||
self.page.keyboard.press('Enter')
|
||
self.sent_message = message # 记录发送内容
|
||
if not hasattr(self, 'sent_messages'):
|
||
self.sent_messages = []
|
||
self.sent_messages.append({'role': '我方', 'content': message})
|
||
logger.info(f"✅ 已发送消息（兜底方案）: {message[:50]}...")
|
||
time.sleep(1)
|
||
return True
|
||
except Exception as e:
|
||
logger.warning(f"兜底方案失败: {str(e)}")
|
||
|
||
logger.warning("所有方案均失败")
|
||
return False
|
||
|
||
# 点击输入框获取焦点
|
||
input_element.click()
|
||
time.sleep(0.5)
|
||
|
||
# 使用真人模拟输入
|
||
logger.debug("使用真人模拟输入...")
|
||
self._human_type(message)
|
||
|
||
time.sleep(0.5)
|
||
|
||
# 发送消息：先尝试点击发送按钮，再尝试按回车
|
||
sent = False
|
||
|
||
# 方法1：点击发送按钮
|
||
send_btn_selectors = [
|
||
"div.send-btn",
|
||
"div.icon.send-btn",
|
||
"button.send-btn",
|
||
"span.send-btn",
|
||
"div[class*='send']",
|
||
"button[class*='send']",
|
||
]
|
||
|
||
for btn_selector in send_btn_selectors:
|
||
try:
|
||
btn = self.page.locator(btn_selector).first
|
||
if btn and btn.is_visible():
|
||
btn.click()
|
||
logger.debug(f"点击发送按钮: {btn_selector}")
|
||
sent = True
|
||
break
|
||
except:
|
||
continue
|
||
|
||
# 方法2：按回车键
|
||
if not sent:
|
||
try:
|
||
self.page.keyboard.press('Enter')
|
||
sent = True
|
||
except:
|
||
pass
|
||
|
||
if sent:
|
||
self.sent_message = message # 记录发送内容
|
||
if not hasattr(self, 'sent_messages'):
|
||
self.sent_messages = []
|
||
self.sent_messages.append({'role': '我方', 'content': message})
|
||
logger.info(f"✅ 已发送消息: {message[:50]}...")
|
||
time.sleep(1)
|
||
return True
|
||
else:
|
||
logger.warning("发送消息失败")
|
||
return False
|
||
|
||
except Exception as e:
|
||
logger.error(f"发送消息异常: {str(e)}")
|
||
return False
|
||
|
||
def _wait_for_new_doctor_reply(self, timeout: int = 60) -> Optional[str]:
|
||
"""
|
||
等待新的医生回复
|
||
|
||
Args:
|
||
timeout: 等待超时时间（秒）
|
||
|
||
Returns:
|
||
新的医生回复内容，超时返回None
|
||
"""
|
||
try:
|
||
initial_count = len(self.doctor_replies)
|
||
start_time = time.time()
|
||
|
||
while time.time() - start_time < timeout:
|
||
time.sleep(2)
|
||
|
||
# 检查是否有新回复
|
||
if len(self.doctor_replies) > initial_count:
|
||
# 获取最新的回复
|
||
new_reply = self.doctor_replies[-1]
|
||
content = new_reply.get('content', '')
|
||
if content:
|
||
logger.info(f"收到新医生回复: {content[:50]}...")
|
||
return content
|
||
|
||
# 打印等待进度
|
||
elapsed = int(time.time() - start_time)
|
||
if elapsed % 15 == 0 and elapsed > 0:
|
||
logger.info(f"等待医生回复... ({elapsed}/{timeout}秒)")
|
||
|
||
logger.info("等待医生回复超时")
|
||
return None
|
||
|
||
except Exception as e:
|
||
logger.error(f"等待医生回复异常: {str(e)}")
|
||
return None
|
||
|
||
def _auto_chat_interaction(self) -> int:
|
||
"""
|
||
自动聊天交互（3-5轮）
|
||
|
||
流程：
|
||
1. 持续监控API响应，收到推荐回复立即点击
|
||
2. 如果没有推荐回复但有医生回复，使用AI生成回复
|
||
3. 重复3-5轮，每轮间隔30-90秒
|
||
|
||
Returns:
|
||
实际完成的交互轮数
|
||
"""
|
||
try:
|
||
# 随机决定交互轮数（3-5轮）
|
||
target_rounds = random.randint(3, 5)
|
||
completed_rounds = 0
|
||
|
||
logger.info(f"开始自动聊天交互，目标轮数: {target_rounds}")
|
||
|
||
for round_num in range(1, target_rounds + 1):
|
||
logger.info(f"=== 第 {round_num}/{target_rounds} 轮交互 ===")
|
||
self._update_overlay("聊天交互", f"第 {round_num}/{target_rounds} 轮")
|
||
|
||
# 记录本轮开始时的状态
|
||
initial_recommend_count = len(self.recommend_replies)
|
||
initial_doctor_count = len(self.doctor_replies)
|
||
initial_dom_button_count = self._count_dom_recommend_buttons()
|
||
round_completed = False
|
||
last_doctor_reply = None
|
||
no_recommend_count = 0 # 连续找不到推荐按钮的次数
|
||
|
||
# 持续监控，最多等待60秒
|
||
start_time = time.time()
|
||
timeout = 60
|
||
|
||
while time.time() - start_time < timeout and not round_completed:
|
||
time.sleep(1) # 每秒检查一次
|
||
|
||
# 每次循环都尝试点击可见的推荐按钮（遍历所有消息）
|
||
clicked = self._try_click_visible_recommend()
|
||
if clicked:
|
||
logger.info(f"✅ 第 {round_num} 轮点击了推荐回复")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
no_recommend_count = 0
|
||
# 更新计数
|
||
initial_recommend_count = len(self.recommend_replies)
|
||
initial_dom_button_count = self._count_dom_recommend_buttons()
|
||
continue
|
||
else:
|
||
no_recommend_count += 1
|
||
|
||
# 检查API是否有新的推荐回复
|
||
if len(self.recommend_replies) > initial_recommend_count:
|
||
logger.info("[API] 检测到新推荐回复...")
|
||
initial_recommend_count = len(self.recommend_replies)
|
||
no_recommend_count = 0
|
||
# 尝试点击
|
||
if self._try_click_visible_recommend() or self._try_click_recommend_reply():
|
||
logger.info(f"✅ 第 {round_num} 轮使用推荐回复完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
|
||
# 检查DOM是否有新的推荐按钮
|
||
if not round_completed:
|
||
current_dom_count = self._count_dom_recommend_buttons()
|
||
if current_dom_count > initial_dom_button_count:
|
||
logger.info(f"[DOM] 检测到新推荐按钮 ({initial_dom_button_count} -> {current_dom_count})...")
|
||
initial_dom_button_count = current_dom_count
|
||
no_recommend_count = 0
|
||
if self._try_click_visible_recommend():
|
||
logger.info(f"✅ 第 {round_num} 轮通过DOM点击推荐完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
|
||
# 记录医生回复（用于AI生成）
|
||
if len(self.doctor_replies) > initial_doctor_count:
|
||
last_doctor_reply = self.doctor_replies[-1].get('content', '')
|
||
initial_doctor_count = len(self.doctor_replies)
|
||
|
||
if not last_doctor_reply:
|
||
dom_doctor_msg = self._get_latest_doctor_message_from_dom()
|
||
if dom_doctor_msg:
|
||
last_doctor_reply = dom_doctor_msg
|
||
|
||
# 如果收到医生回复但连续10秒找不到推荐按钮，提前使用AI
|
||
if not round_completed and last_doctor_reply and no_recommend_count >= 10:
|
||
logger.info(f"已收到医生回复但连续{no_recommend_count}秒无推荐按钮，使用AI回复...")
|
||
ai_reply = self._call_qwen_api(last_doctor_reply)
|
||
if ai_reply and self._send_message_to_chat(ai_reply):
|
||
logger.info(f"✅ 第 {round_num} 轮使用AI回复完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
logger.warning("AI回复发送失败，继续等待推荐按钮...")
|
||
no_recommend_count = 0 # 重置计数，继续尝试
|
||
|
||
# 如果连续25秒没有任何响应（无推荐按钮也无医生回复），主动发消息
|
||
if not round_completed and not last_doctor_reply and no_recommend_count >= 25:
|
||
# 尝试获取历史医生消息
|
||
history_doctor_msg = None
|
||
if self.doctor_replies:
|
||
history_doctor_msg = self.doctor_replies[-1].get('content', '')
|
||
if not history_doctor_msg:
|
||
history_doctor_msg = self._get_latest_doctor_message_from_dom()
|
||
|
||
if history_doctor_msg:
|
||
logger.info(f"连续{no_recommend_count}秒无新响应，使用历史消息生成AI回复...")
|
||
ai_reply = self._call_qwen_api(history_doctor_msg)
|
||
if ai_reply and self._send_message_to_chat(ai_reply):
|
||
logger.info(f"✅ 第 {round_num} 轮使用AI回复历史消息完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
no_recommend_count = 0
|
||
else:
|
||
# 完全没有历史消息，发送激活消息
|
||
logger.info(f"连续{no_recommend_count}秒无响应且无历史消息，发送激活消息...")
|
||
fallback_messages = [
|
||
"您好，请问还在吗？",
|
||
"想咨询一下具体情况",
|
||
"请问医生什么时候有空呢？",
|
||
"我想了解一下治疗方案"
|
||
]
|
||
fallback_msg = random.choice(fallback_messages)
|
||
if self._send_message_to_chat(fallback_msg):
|
||
logger.info(f"✅ 第 {round_num} 轮发送激活消息: {fallback_msg}")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
no_recommend_count = 0
|
||
|
||
# 打印等待进度
|
||
elapsed = int(time.time() - start_time)
|
||
if elapsed % 15 == 0 and elapsed > 0:
|
||
logger.info(f"等待中... ({elapsed}/{timeout}秒)")
|
||
|
||
# 如果本轮没有通过推荐回复完成，尝试使用AI
|
||
if not round_completed:
|
||
if last_doctor_reply:
|
||
logger.info("无可用推荐回复，使用千问AI生成回复...")
|
||
ai_reply = self._call_qwen_api(last_doctor_reply)
|
||
if ai_reply and self._send_message_to_chat(ai_reply):
|
||
logger.info(f"✅ 第 {round_num} 轮使用AI回复完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
logger.warning(f"第 {round_num} 轮AI回复发送失败，尝试点击推荐按钮...")
|
||
# 再次尝试点击推荐按钮
|
||
if self._try_click_visible_recommend():
|
||
logger.info(f"✅ 第 {round_num} 轮通过点击推荐按钮完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
logger.warning(f"第 {round_num} 轮失败，继续下一轮...")
|
||
else:
|
||
# 当前轮没有收到新回复，尝试用历史消息生成回复
|
||
logger.warning(f"第 {round_num} 轮未收到新回复，尝试使用历史消息...")
|
||
|
||
# 先尝试点击推荐按钮
|
||
if self._try_click_visible_recommend():
|
||
logger.info(f"✅ 第 {round_num} 轮通过点击推荐按钮完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
# 尝试获取历史医生消息
|
||
history_doctor_msg = None
|
||
if self.doctor_replies:
|
||
history_doctor_msg = self.doctor_replies[-1].get('content', '')
|
||
if not history_doctor_msg:
|
||
history_doctor_msg = self._get_latest_doctor_message_from_dom()
|
||
|
||
if history_doctor_msg:
|
||
logger.info("使用历史消息生成AI回复...")
|
||
ai_reply = self._call_qwen_api(history_doctor_msg)
|
||
if ai_reply and self._send_message_to_chat(ai_reply):
|
||
logger.info(f"✅ 第 {round_num} 轮使用AI回复历史消息完成")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
# 完全没有历史消息，发送激活消息
|
||
fallback_messages = [
|
||
"您好，请问还在吗？",
|
||
"想咨询一下具体情况",
|
||
"请问医生什么时候有空呢？",
|
||
"我想了解一下治疗方案"
|
||
]
|
||
fallback_msg = random.choice(fallback_messages)
|
||
if self._send_message_to_chat(fallback_msg):
|
||
logger.info(f"✅ 第 {round_num} 轮发送激活消息: {fallback_msg}")
|
||
completed_rounds += 1
|
||
round_completed = True
|
||
else:
|
||
logger.warning(f"第 {round_num} 轮发送消息失败")
|
||
|
||
# 如果还有下一轮，随机等待30-90秒
|
||
if round_num < target_rounds:
|
||
wait_seconds = random.randint(30, 90)
|
||
logger.info(f"等待 {wait_seconds} 秒后进行下一轮...")
|
||
time.sleep(wait_seconds)
|
||
|
||
logger.info(f"自动聊天交互完成，共 {completed_rounds}/{target_rounds} 轮")
|
||
return completed_rounds
|
||
|
||
except Exception as e:
|
||
logger.error(f"自动聊天交互异常: {str(e)}")
|
||
return completed_rounds if 'completed_rounds' in locals() else 0
|
||
|
||
def _get_doctor_reply_content(self) -> Optional[str]:
|
||
"""获取医生回复内容（合并所有回复）"""
|
||
if not self.doctor_replies:
|
||
return None
|
||
|
||
# 合并所有回复内容
|
||
contents = [r.get('content', '') for r in self.doctor_replies if r.get('content')]
|
||
return '\n'.join(contents) if contents else None
|
||
|
||
def _get_full_chat_log(self) -> Optional[str]:
|
||
"""
|
||
获取完整聊天记录（格式化为文本）
|
||
|
||
数据来源：
|
||
1. doctor_replies - API监听/DOM采集的医生消息
|
||
2. chat_history - 与千问API的对话历史（user=医生, assistant=我方AI回复）
|
||
3. sent_messages - 所有发送的消息（包括推荐回复和AI回复）
|
||
4. sent_recommend_reply - 点击的推荐回复（兼容旧代码）
|
||
5. sent_message - 最后发送的消息（兼容旧代码）
|
||
|
||
Returns:
|
||
格式化的聊天记录文本
|
||
"""
|
||
try:
|
||
chat_lines = []
|
||
seen_contents = set() # 用于去重
|
||
|
||
# 1. 从 chat_history 中提取对话（包含医生消息和AI回复）
|
||
for i, msg in enumerate(self.chat_history):
|
||
role = msg.get('role', '')
|
||
content = msg.get('content', '')
|
||
|
||
if not content:
|
||
continue
|
||
|
||
if role == 'user':
|
||
# 医生消息，去掉前缀 "[医生/客服说]: "
|
||
if content.startswith('[医生/客服说]:'):
|
||
content = content.replace('[医生/客服说]:', '').strip()
|
||
elif content.startswith('[医生/客服说]'):
|
||
content = content.replace('[医生/客服说]', '').strip()
|
||
|
||
if content and content not in seen_contents:
|
||
chat_lines.append(f"[医生] {content}")
|
||
seen_contents.add(content)
|
||
|
||
elif role == 'assistant':
|
||
# 我方AI回复
|
||
if content and content not in seen_contents:
|
||
chat_lines.append(f"[我方(AI)] {content}")
|
||
seen_contents.add(content)
|
||
|
||
# 2. 补充 doctor_replies 中的消息（可能有些消息没进入 chat_history）
|
||
for reply in self.doctor_replies:
|
||
content = reply.get('content', '')
|
||
if content and content not in seen_contents:
|
||
chat_lines.append(f"[医生] {content}")
|
||
seen_contents.add(content)
|
||
|
||
# 3. 从 sent_messages 获取所有发送的消息
|
||
if hasattr(self, 'sent_messages') and self.sent_messages:
|
||
for msg in self.sent_messages:
|
||
content = msg.get('content', '')
|
||
role = msg.get('role', '我方')
|
||
if content and content not in seen_contents:
|
||
chat_lines.append(f"[{role}] {content}")
|
||
seen_contents.add(content)
|
||
|
||
# 4. 添加发送的推荐回复（兼容旧代码）
|
||
if hasattr(self, 'sent_recommend_reply') and self.sent_recommend_reply:
|
||
content = self.sent_recommend_reply
|
||
if content not in seen_contents:
|
||
chat_lines.append(f"[我方(推荐回复)] {content}")
|
||
seen_contents.add(content)
|
||
|
||
# 5. 添加最后发送的消息（兼容旧代码）
|
||
if hasattr(self, 'sent_message') and self.sent_message:
|
||
content = self.sent_message
|
||
if not content.startswith('[推荐回复]') and content not in seen_contents:
|
||
chat_lines.append(f"[我方] {content}")
|
||
seen_contents.add(content)
|
||
|
||
result = '\n'.join(chat_lines) if chat_lines else None
|
||
|
||
# 调试日志
|
||
logger.info(f"聊天记录汇总: chat_history={len(self.chat_history)}条, doctor_replies={len(self.doctor_replies)}条, sent_messages={len(getattr(self, 'sent_messages', []))}条, 输出={len(chat_lines)}行")
|
||
|
||
return result
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取完整聊天记录失败: {str(e)}")
|
||
return None
|
||
|
||
def _count_messages(self) -> int:
|
||
"""
|
||
统计当前页面的消息数量
|
||
|
||
Returns:
|
||
消息数量
|
||
"""
|
||
try:
|
||
# 根据实际页面结构调整选择器
|
||
# 这里是示例选择器，需要根据实际情况修改
|
||
message_selectors = [
|
||
"//div[contains(@class, 'message')]",
|
||
"//div[contains(@class, 'chat-message')]",
|
||
"//div[contains(@class, 'msg-item')]",
|
||
]
|
||
|
||
for selector in message_selectors:
|
||
try:
|
||
messages = self.page.locator(f"xpath={selector}").all()
|
||
if messages:
|
||
return len(messages)
|
||
except:
|
||
continue
|
||
|
||
return 0
|
||
|
||
except Exception as e:
|
||
logger.error(f"统计消息数量异常: {str(e)}")
|
||
return 0
|
||
|
||
def _close_current_tab(self):
|
||
"""关闭当前标签页并返回主窗口"""
|
||
try:
|
||
pages = self.page.context.pages
|
||
if len(pages) > 1:
|
||
self.page.close()
|
||
self.page = pages[0]
|
||
logger.info("已关闭广告页面")
|
||
except Exception as e:
|
||
logger.error(f"关闭标签页异常: {str(e)}")
|
||
|
||
def random_delay(self, min_seconds: int = 2, max_seconds: int = 5):
|
||
"""随机延迟，模拟人工操作"""
|
||
delay = random.uniform(min_seconds, max_seconds)
|
||
time.sleep(delay)
|