Files
jianli-boss/client/browser/applicant.py
T
2026-08-25 23:30:05 +08:00

537 lines
23 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
投递自动化模块(低痕迹 CDP 版 · 期望条件栏驱动)
真实页面行为(已实测):
- 列表页 /web/geek/jobs 顶部有"期望搜索条件"栏(如 Java(北京)),
点击某条期望即由站点自身发请求加载对应 关键词+城市 的职位列表;
找不到目标城市的期望时,告知"期望城市没有目标城市"。
- 分页为下拉加载:滚动触发站点自身 XHR(list.json),被动监听可得明文薪资
(DOM 中薪资为自定义字体加密,无法直接读取)。
- 投递:右侧详情面板点"立即沟通"→ 站点自动发送默认招呼语并弹出
"已向BOSS发送消息"对话框 → 点"留在此页"即完成一次投递。
- 沟通按钮需浏览器级可信点击(Input.dispatchMouseEvent),合成 el.click() 无效。
"""
import json
import random
import re
import time
import threading
from dataclasses import dataclass
from loguru import logger
from .cdp_lite import LiteCDP, CDPSession
from .manager import BrowserManager
from ..ai import AIClient
from ..server_api import ServerAPI
# 职位列表页(注意是 jobs 复数)
JOBS_PAGE = "https://www.zhipin.com/web/geek/jobs"
# 常见城市编码 → 名称(用于在期望条件栏匹配目标城市)
CITY_NAMES = {
"101010100": "北京", "101020100": "上海", "101280100": "广州",
"101280600": "深圳", "101190100": "杭州", "101030100": "天津",
"101200100": "武汉", "101110100": "西安", "101270100": "成都",
"101040100": "重庆", "101190400": "苏州", "101200200": "南京",
"101210100": "合肥", "101180100": "郑州", "101230100": "福州",
"101240100": "南昌", "101250100": "济南", "101260100": "贵阳",
"101290100": "昆明", "101300100": "兰州", "101050100": "哈尔滨",
"101060100": "长春", "101070100": "沈阳", "101080100": "呼和浩特",
"101090100": "石家庄", "101100100": "太原", "101120100": "青岛",
"101190500": "宁波", "101280300": "佛山", "101280200": "珠海",
"101120200": "大连", "101210200": "厦门", "101180200": "开封",
"101200300": "无锡", "101190200": "温州", "101270200": "绵阳",
}
@dataclass
class JobCard:
job_id: str
title: str
company: str
location: str
tags: str = ""
salary: str = ""
jd_text: str = ""
boss_online: bool = False
# 读取列表卡片(新版 DOM 结构)
_CARDS_JS = """(() => [...document.querySelectorAll('.job-card-wrap')].map(el => {
const a = el.querySelector('a.job-name');
const m = /\\/job_detail\\/([^.]+)\\.html/.exec(a ? (a.getAttribute('href') || '') : '');
const t = s => { const n = el.querySelector(s); return n ? n.innerText.trim() : ''; };
return {job_id: m ? m[1] : '', title: t('.job-name'), company: t('.boss-name'),
location: t('.company-location'), tags: t('.tag-list'),
online: !!el.querySelector('.boss-online-icon')};
}))()"""
# JD 正文(详情页,明文)
_JD_JS = """(() => {
const el = document.querySelector('.job-sec-text') || document.querySelector('.job-detail-section');
return el ? el.innerText.trim() : '';
})()"""
def _select_expect_js(keyword: str, city_name: str) -> str:
"""在期望条件栏查找目标期望(优先 关键词(城市) 全匹配,其次城市匹配),返回坐标供可信点击"""
return ("((kw, city) => (() => {"
"const items = [...document.querySelectorAll('.expect-item')];"
"const txt = el => ((el.querySelector('.text-content') || el).innerText || '').trim();"
"let hit = city && items.find(el => txt(el) === kw + '(' + city + ')');"
"if (!hit && city) hit = items.find(el => txt(el).endsWith('(' + city + ')'));"
"if (!hit && kw) hit = items.find(el => txt(el).toLowerCase().includes(kw.toLowerCase()));"
"if (!hit) return JSON.stringify({ok: false, list: items.map(txt)});"
"const r = hit.getBoundingClientRect();"
"return JSON.stringify({ok: true, text: txt(hit),"
" x: r.x + r.width / 2, y: r.y + r.height / 2});"
"})())(" + json.dumps(keyword, ensure_ascii=False) + ","
+ json.dumps(city_name, ensure_ascii=False) + ")")
def _click_card_js(job_id: str) -> str:
"""定位指定职位卡片并滚动到可视区,返回坐标供可信点击(右侧面板随之加载该职位)"""
return ("((id) => (() => {"
"const el = [...document.querySelectorAll('.job-card-wrap')]"
".find(c => ((c.querySelector('a.job-name') || {getAttribute: () => ''})"
".getAttribute('href') || '').includes(id));"
"if (!el) return null;"
"el.scrollIntoView({block: 'center'});"
"const r = el.getBoundingClientRect();"
"return JSON.stringify({x: r.x + r.width / 2, y: r.y + r.height / 2});"
"})())(" + json.dumps(job_id) + ")")
def _btn_xy_js(selector: str) -> str:
return (f"(() => {{ const b = document.querySelector('{selector}'); if (!b) return null;"
"const r = b.getBoundingClientRect();"
"return JSON.stringify({x: r.x + r.width / 2, y: r.y + r.height / 2}); })()")
_STAY_JS = """(() => {
const b = [...document.querySelectorAll('a,button,div,span')]
.find(e => (e.innerText || '').trim() === '留在此页' && e.offsetHeight > 0);
if (!b) return null;
const r = b.getBoundingClientRect();
return JSON.stringify({x: r.x + r.width / 2, y: r.y + r.height / 2});
})()"""
# 站点在沟通频控/处理中时会盖一层遮罩,此时点击无效,需等它消失后重试
_BLOCK_JS = "!!document.querySelector('.chat-block-layer')"
def _parse_salary(text: str) -> tuple[int, int] | None:
"""'20-30K·15薪' → (20, 30);'3K以下' → (0, 3);'50K以上' → (50, 999)"""
if not text:
return None
m = re.search(r"(\d+)\s*-\s*(\d+)\s*K", text)
if m:
return int(m.group(1)), int(m.group(2))
m = re.search(r"(\d+)\s*K以下", text)
if m:
return 0, int(m.group(1))
m = re.search(r"(\d+)\s*K以上", text)
if m:
return int(m.group(1)), 999
return None
class Applicant:
"""投递执行器(可启停)"""
def __init__(self, manager: BrowserManager, server_api: ServerAPI,
ai_client: AIClient | None):
self.manager = manager
self.server = server_api
self.ai = ai_client
self.cdp = LiteCDP()
self._stop_event = threading.Event()
self._thread: threading.Thread | None = None
self.is_running = False
self.session_id: int | None = None
self.primary_resume_content: str = ""
self.stats = {"applied": 0, "skipped": 0, "current": ""}
# 列表页会话(整个任务期间保持一个标签页)
self._tab: dict | None = None
self._sess: CDPSession | None = None
self._salary_by_id: dict[str, str] = {}
# ------------------------------------------------------------------
# 启停控制
# ------------------------------------------------------------------
def start(self, keywords: list[str], city_code: str,
salary_min: int | None, salary_max: int | None,
greeting: str, min_score: int, delay_range: tuple[int, int],
boss_online_only: bool = False, daily_limit: int = 0) -> None:
if self.is_running:
logger.warning("已有投递任务在运行")
return
session = self.server.start_session(
keywords=",".join(keywords), city_code=city_code,
salary_min=salary_min, salary_max=salary_max,
)
self.session_id = session["id"]
primary = self.server.get_primary_resume()
self.primary_resume_content = primary["content"] if primary else ""
self._stop_event.clear()
self.is_running = True
self.stats = {"applied": 0, "skipped": 0, "current": "初始化..."}
self.boss_online_only = boss_online_only
self.daily_limit = daily_limit
self._daily_base = 0
self._thread = threading.Thread(
target=self._run,
args=(keywords, city_code, salary_min, salary_max,
greeting, min_score, delay_range),
daemon=True,
)
self._thread.start()
logger.success(f"投递任务已启动,会话 ID:{self.session_id}")
def stop(self) -> None:
logger.info("收到停止投递请求...")
self._stop_event.set()
def _should_stop(self) -> bool:
return self._stop_event.is_set()
def _sleep(self, min_s: float, max_s: float) -> None:
total = random.uniform(min_s, max_s)
elapsed = 0.0
while elapsed < total and not self._should_stop():
time.sleep(0.5)
elapsed += 0.5
def _finish(self) -> None:
self.is_running = False
if self.session_id:
try:
self.server.stop_session(self.session_id)
except Exception as e:
logger.warning(f"结束会话失败:{e}")
self.stats["current"] = "已停止"
logger.info(f"投递任务结束。本次投递 {self.stats['applied']} 个,"
f"跳过 {self.stats['skipped']} 个")
# ------------------------------------------------------------------
# 主循环
# ------------------------------------------------------------------
def _run(self, keywords, city_code, salary_min, salary_max,
greeting, min_score, delay_range):
try:
self.manager.ensure_browser_started()
# 整个任务只开一个列表标签页,模拟真人持续浏览
self._tab = self.cdp.open_tab(JOBS_PAGE)
time.sleep(8) # 等 SPA 挂载
self._sess = CDPSession(self._tab["webSocketDebuggerUrl"])
self._sess.call("Network.enable")
# 每日上限:任务开始时拉取当天已投数量
if self.daily_limit:
try:
self._daily_base = self.server.today_applied_count()
except Exception as e:
logger.warning(f"获取当天投递数量失败,上限判断跳过:{e}")
self._daily_base = 0
logger.info(f"当天已投递 {self._daily_base} 个,每日上限 {self.daily_limit}")
if self._daily_base >= self.daily_limit:
logger.info("已达当日投递上限,任务直接结束")
return
city_name = CITY_NAMES.get(str(city_code), "")
for keyword in keywords:
if self._should_stop():
break
self.stats["current"] = f"匹配期望条件:{keyword}"
if not self._select_expect(keyword, city_name):
continue
self._process_list(keyword, salary_min, salary_max,
min_score, delay_range)
self._sleep(3, 6)
except Exception as e:
logger.error(f"投递任务异常:{e}")
finally:
if self._sess:
self._sess.close()
if self._tab:
self.cdp.close_tab(self._tab["id"])
self._finish()
def _select_expect(self, keyword: str, city_name: str) -> bool:
"""可信点击目标期望;找不到目标城市时告知并跳过"""
r = self._sess.eval_js(_select_expect_js(keyword, city_name))
try:
info = json.loads(r or "{}")
except Exception:
info = {}
if not info.get("ok"):
logger.warning(f"期望城市没有目标城市:{keyword}"
f"({city_name or '未配置城市名'}),"
f"现有期望:{info.get('list') or '无'}")
return False
self._sess.human_click(info["x"], info["y"])
logger.info(f"已选中期望条件:{info.get('text')}")
time.sleep(2)
# 点击后站点自发请求第一页列表,被动监听捕获明文薪资
self._pump_list_responses(4)
time.sleep(2) # 列表渲染可能滞后,留出缓冲
return True
# ------------------------------------------------------------------
# 列表读取与下拉分页
# ------------------------------------------------------------------
def _pump_list_responses(self, duration: float) -> None:
"""被动监听站点自身的 list.json 分页响应,收集明文薪资"""
reqs: dict[str, str] = {}
for msg in self._sess.pump(duration):
m = msg.get("method")
if m == "Network.responseReceived":
url = msg["params"]["response"]["url"]
if "list.json" in url:
reqs[msg["params"]["requestId"]] = url
elif m == "Network.loadingFinished":
rid = msg["params"]["requestId"]
if rid in reqs:
try:
body = self._sess.call(
"Network.getResponseBody", {"requestId": rid}).get("body", "")
jobs = json.loads(body).get("zpData", {}).get("jobList") or []
for j in jobs:
if j.get("encryptJobId"):
self._salary_by_id[j["encryptJobId"]] = j.get("salaryDesc") or ""
except Exception:
pass
def _read_cards(self) -> list[JobCard]:
raw = self._sess.eval_js(_CARDS_JS)
if isinstance(raw, str):
try:
raw = json.loads(raw or "[]")
except Exception:
raw = []
items = raw or []
cards = []
for it in items:
if not it.get("job_id"):
continue
it["salary"] = self._salary_by_id.get(it["job_id"], "")
cards.append(JobCard(
job_id=it.get("job_id", ""), title=it.get("title", ""),
company=it.get("company", ""), location=it.get("location", ""),
tags=it.get("tags", ""), salary=it.get("salary", ""),
boss_online=bool(it.get("online")),
))
return cards
def _human_scroll(self) -> None:
"""拟人分段滚动:多次随机步长 + 随机间隔,模拟真人拖滚轮,
避免一次性 scrollTo 到底的机器特征"""
for _ in range(random.randint(3, 5)):
step = random.randint(280, 560)
self._sess.eval_js(f"window.scrollBy(0, {step})")
time.sleep(random.uniform(0.3, 0.8))
self._sess.eval_js("window.scrollTo(0, document.body.scrollHeight)")
def _process_list(self, keyword, salary_min, salary_max,
min_score, delay_range, max_per_keyword: int = 15):
processed: set[str] = set()
applied = 0
no_new = 0
while applied < max_per_keyword and not self._should_stop():
cards = self._read_cards()
new_cards = [c for c in cards if c.job_id not in processed]
if not new_cards:
no_new += 1
if no_new >= 2:
logger.info(f"关键词 {keyword} 已无更多职位")
break
else:
no_new = 0
for card in new_cards:
if self._should_stop() or applied >= max_per_keyword:
break
processed.add(card.job_id)
applied += self._handle_card(card, salary_min, salary_max,
min_score, delay_range)
# 下拉加载下一页:拟人分段滚动,站点自发请求,被动监听
self._human_scroll()
self._pump_list_responses(3)
self._sleep(1, 3)
# ------------------------------------------------------------------
# 单职位处理:去重 → 薪资 → JD+AI → 投递
# ------------------------------------------------------------------
def _handle_card(self, card: JobCard, salary_min, salary_max,
min_score, delay_range) -> int:
try:
if self.server.check_applied(card.job_id):
return 0
except Exception:
pass
self.stats["current"] = f"评估:{card.company} - {card.title}"
# 薪资范围过滤(薪资来自站点分页响应明文)
if salary_min or salary_max:
rng = _parse_salary(card.salary)
if rng:
lo = salary_min or 0
hi = salary_max or 999
if rng[1] < lo or rng[0] > hi:
self._report_skip(card, f"薪资不符({card.salary})")
return 0
# 只投在线 Boss:卡片 logo 旁无绿点直接跳过
if self.boss_online_only and not card.boss_online:
self._report_skip(card, "Boss不在线")
return 0
# 每日上限:达到后结束整个任务
if self.daily_limit and self._daily_base + self.stats["applied"] >= self.daily_limit:
logger.info(f"已达当日投递上限({self.daily_limit}),任务结束")
self._stop_event.set()
return 0
# JD 详情(临时标签页,读完即关)供 AI 评分
card.jd_text = self._fetch_jd(card)
ai_score, ai_reason = -1, ""
if self.ai and self.ai.available() and self.primary_resume_content:
result = self.ai.score_job(card.jd_text, self.primary_resume_content)
ai_score, ai_reason = result.score, result.reason
logger.info(f"AI 评分 {ai_score}(及格线 {min_score}):"
f"{card.company} - {card.title} | {ai_reason}")
if not result.is_worth_applying(min_score):
self._report_skip(card, f"AI 评分低({ai_score})", ai_score, ai_reason)
return 0
else:
logger.debug(f"AI 评分不可用,跳过评分:{card.company} - {card.title}")
if self._apply(card):
self._report_apply(card, ai_score, ai_reason)
self._sleep(*delay_range)
return 1
return 0
def _fetch_jd(self, card: JobCard) -> str:
tab = None
try:
tab = self.cdp.open_tab(
f"https://www.zhipin.com/job_detail/{card.job_id}.html")
time.sleep(5)
s = CDPSession(tab["webSocketDebuggerUrl"])
try:
jd = s.eval_js(_JD_JS) or ""
finally:
s.close()
return jd.strip() or f"{card.title} {card.company}"
except Exception:
return f"{card.title} {card.company}"
finally:
if tab:
self.cdp.close_tab(tab["id"])
# 临时标签夺走了焦点,恢复列表标签前台,否则可信点击失效
if self._tab:
self.cdp.activate_tab(self._tab["id"])
time.sleep(1)
def _apply(self, card: JobCard) -> bool:
"""选中卡片 → 可信点击立即沟通 → 点留在此页,完成一次投递"""
# 1. 选中卡片(右侧面板加载该职位)
pos = self._sess.eval_js(_click_card_js(card.job_id))
if not pos:
logger.warning(f"未能在列表中选中卡片:{card.title}")
return False
p = json.loads(pos)
self._sess.human_click(p["x"], p["y"])
time.sleep(1.5)
# 2. 等右侧面板加载,拟人点击"立即沟通"(面板渲染可能滞后,重试)
xy = None
for _ in range(5):
xy = self._sess.eval_js(_btn_xy_js(".op-btn-chat"))
if xy:
break
time.sleep(1)
if not xy:
logger.warning(f"右侧面板无立即沟通按钮:{card.title}")
return False
p = json.loads(xy)
self._sess.human_click(p["x"], p["y"])
# 3. 等待"已向BOSS发送消息"弹窗,点"留在此页"
stay = self._wait_stay(10)
if not stay and self._sess.eval_js(_BLOCK_JS):
# 遮罩拦住了本次点击:等遮罩消失后重点一次
logger.info(f"沟通遮罩拦截,等待消失后重试:{card.title}")
for _ in range(10):
time.sleep(1)
if not self._sess.eval_js(_BLOCK_JS):
break
self._sess.human_click(p["x"], p["y"])
stay = self._wait_stay(10)
if stay:
q = json.loads(stay)
self._sess.human_click(q["x"], q["y"])
return True
logger.warning(f"点击立即沟通后未等到发送消息弹窗:{card.title}")
return False
def _wait_stay(self, timeout: float = 10):
"""轮询等待"留在此页"按钮出现,返回坐标 JSON 或 None"""
for _ in range(int(timeout)):
time.sleep(1)
stay = self._sess.eval_js(_STAY_JS)
if stay:
return stay
return None
# ------------------------------------------------------------------
# 服务端上报
# ------------------------------------------------------------------
def _report_apply(self, card: JobCard, ai_score: int, ai_reason: str):
try:
self.server.report_application(self.session_id, {
"job_id": card.job_id,
"job_title": card.title,
"company": card.company,
"salary": card.salary or None,
"location": card.location,
"apply_type": "chat",
"ai_score": ai_score,
"ai_reason": ai_reason[:255] if ai_reason else None,
"jd_text": card.jd_text or None,
})
self.server.update_session_stats(self.session_id, applied_delta=1, skipped_delta=0)
self.stats["applied"] += 1
logger.success(f"[{self.stats['applied']}] 投递成功:{card.company} - {card.title}")
except Exception as e:
logger.warning(f"上报投递记录失败:{e}")
def _report_skip(self, card: JobCard, reason: str, ai_score: int = -1, ai_reason: str = ""):
try:
self.server.report_application(self.session_id, {
"job_id": card.job_id,
"job_title": card.title,
"company": card.company,
"salary": card.salary or None,
"location": card.location,
"apply_type": "skipped",
"ai_score": ai_score,
"ai_reason": ai_reason[:255] if ai_reason else None,
"skip_reason": reason,
"jd_text": card.jd_text or None,
})
self.server.update_session_stats(self.session_id, applied_delta=0, skipped_delta=1)
self.stats["skipped"] += 1
logger.info(f"跳过({reason}):{card.company} - {card.title}")
except Exception as e:
logger.debug(f"上报跳过记录失败:{e}")