This commit is contained in:
2026-08-25 19:46:38 +08:00
parent e1416994bc
commit 4cf6b1ffbc
15 changed files with 719 additions and 108 deletions
+5
View File
@@ -36,6 +36,11 @@ class ClientSettings(BaseSettings):
# ------------------------------------------------------- # -------------------------------------------------------
TOKEN_FILE: str = "client/.token" TOKEN_FILE: str = "client/.token"
# -------------------------------------------------------
# 心跳(秒):需小于服务端在线窗口(90s)
# -------------------------------------------------------
HEARTBEAT_INTERVAL: int = 30
class Config: class Config:
env_file = "client/.env" env_file = "client/.env"
env_file_encoding = "utf-8" env_file_encoding = "utf-8"
+53 -9
View File
@@ -17,6 +17,7 @@ class ServerAPI:
self.base_url = client_settings.SERVER_URL.rstrip("/") self.base_url = client_settings.SERVER_URL.rstrip("/")
self.token: str | None = None self.token: str | None = None
self.user_id: int | None = None self.user_id: int | None = None
self.username: str | None = None
self._load_token() self._load_token()
# ------------------------------------------------------------------ # ------------------------------------------------------------------
@@ -35,42 +36,85 @@ class ServerAPI:
lines = f.read().strip().splitlines() lines = f.read().strip().splitlines()
if lines: if lines:
self.token = lines[0] self.token = lines[0]
self.user_id = int(lines[1]) if len(lines) > 1 else None self.user_id = int(lines[1]) if len(lines) > 1 and lines[1] else None
self.username = lines[2] if len(lines) > 2 else None
logger.info("已加载本地 token") logger.info("已加载本地 token")
except Exception as e: except Exception as e:
logger.warning(f"读取 token 失败:{e}") logger.warning(f"读取 token 失败:{e}")
def _save_token(self) -> None: def _save_token(self) -> None:
with open(self._token_path(), "w", encoding="utf-8") as f: with open(self._token_path(), "w", encoding="utf-8") as f:
f.write(f"{self.token}\n{self.user_id}") f.write(f"{self.token}\n{self.user_id}\n{self.username or ''}")
def _headers(self) -> dict: def _headers(self) -> dict:
return {"Authorization": f"Bearer {self.token}"} if self.token else {} return {"Authorization": f"Bearer {self.token}"} if self.token else {}
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# 认证 # 认证(账号密码体系)
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def register(self, nickname: str | None = None) -> dict: def register(self, username: str, password: str, nickname: str | None = None) -> dict:
"""用机器指纹注册/登录,返回 token""" """注册新账号,返回并保存 token"""
client_code = generate_client_code()
resp = requests.post( resp = requests.post(
f"{self.base_url}/api/auth/register", f"{self.base_url}/api/auth/register",
json={"client_code": client_code, "nickname": nickname}, json={"username": username, "password": password, "nickname": nickname},
timeout=15, timeout=15,
) )
resp.raise_for_status() resp.raise_for_status()
data = resp.json() return self._store_auth(resp.json())
def login(self, username: str, password: str) -> dict:
"""账号密码登录,返回并保存 token"""
resp = requests.post(
f"{self.base_url}/api/auth/login",
json={
"username": username,
"password": password,
"client_code": generate_client_code(), # 仅作设备审计
},
timeout=15,
)
resp.raise_for_status()
return self._store_auth(resp.json())
def _store_auth(self, data: dict) -> dict:
"""保存认证信息到内存与本地文件"""
self.token = data["token"] self.token = data["token"]
self.user_id = data["user_id"] self.user_id = data["user_id"]
self.username = data.get("username")
self._save_token() self._save_token()
logger.info(f"注册/登录成功,user_id={self.user_id},新用户={data.get('is_new')}") logger.info(f"认证成功,user_id={self.user_id},username={self.username}")
return data return data
def logout(self) -> None:
"""清除本地 token"""
self.token = None
self.user_id = None
self.username = None
try:
if os.path.exists(self._token_path()):
os.remove(self._token_path())
except Exception:
pass
def get_me(self) -> dict: def get_me(self) -> dict:
resp = requests.get(f"{self.base_url}/api/auth/me", headers=self._headers(), timeout=15) resp = requests.get(f"{self.base_url}/api/auth/me", headers=self._headers(), timeout=15)
resp.raise_for_status() resp.raise_for_status()
return resp.json() return resp.json()
def heartbeat(self) -> bool:
"""发送心跳,刷新服务端 last_seen_at;失败返回 False(不抛异常)"""
if not self.token:
return False
try:
resp = requests.post(
f"{self.base_url}/api/auth/heartbeat",
headers=self._headers(), timeout=10,
)
return resp.status_code == 200
except Exception as e:
logger.debug(f"心跳发送失败:{e}")
return False
def update_login_status(self, status: str, boss_account: str | None = None) -> dict: def update_login_status(self, status: str, boss_account: str | None = None) -> dict:
payload = {"login_status": status} payload = {"login_status": status}
if boss_account: if boss_account:
+130 -21
View File
@@ -3,6 +3,8 @@
FastAPI 应用:提供操作界面 + 编排浏览器自动化流程 FastAPI 应用:提供操作界面 + 编排浏览器自动化流程
""" """
import threading import threading
import time
import requests
from pathlib import Path from pathlib import Path
from fastapi import FastAPI, HTTPException, Request from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import HTMLResponse from fastapi.responses import HTMLResponse
@@ -14,7 +16,7 @@ from loguru import logger
from ..config import client_settings from ..config import client_settings
from ..server_api import ServerAPI from ..server_api import ServerAPI
from ..ai import AIClient from ..ai import AIClient
from ..fingerprint import generate_client_code, get_machine_summary from ..fingerprint import get_machine_summary
from ..browser.manager import BrowserManager from ..browser.manager import BrowserManager
from ..browser.resume_scraper import ResumeScraper from ..browser.resume_scraper import ResumeScraper
from ..browser.applicant import Applicant from ..browser.applicant import Applicant
@@ -37,20 +39,67 @@ class AppState:
self.applicant: Applicant | None = None self.applicant: Applicant | None = None
self.connected = False # 是否已注册/登录云端 self.connected = False # 是否已注册/登录云端
self.login_polling = False self.login_polling = False
self._heartbeat_started = False
def ensure_applicant(self) -> Applicant: def ensure_applicant(self) -> Applicant:
if self.applicant is None: if self.applicant is None:
self.applicant = Applicant(self.browser, self.server_api, self.ai) self.applicant = Applicant(self.browser, self.server_api, self.ai)
return self.applicant return self.applicant
# ------------------------------------------------------------------
# 心跳:登录成功后启动后台线程,周期性向服务端上报存活
# ------------------------------------------------------------------
def ensure_heartbeat(self) -> None:
if self._heartbeat_started or not self.server_api.token:
return
self._heartbeat_started = True
threading.Thread(target=self._heartbeat_loop, daemon=True).start()
logger.info(f"心跳线程已启动,间隔 {client_settings.HEARTBEAT_INTERVAL}s")
def _heartbeat_loop(self) -> None:
while True:
if not self.server_api.token:
# 已退出登录,停止心跳
self._heartbeat_started = False
logger.info("已退出登录,心跳停止")
break
self.server_api.heartbeat()
time.sleep(client_settings.HEARTBEAT_INTERVAL)
state = AppState() state = AppState()
# =======================================================
# 前置校验(收敛:所有需要已登录云端的路由统一走这里)
# =======================================================
def _require_auth() -> None:
"""未登录云端时统一抛 400,禁止各路由自行散落判断"""
if not state.connected:
raise HTTPException(status_code=400, detail="请先登录系统账号")
def _require_rpa_online() -> None:
"""
关键操作(开始投递)前的在线预检:
先发一次心跳刷新在线状态,再确认服务端判定为在线,
避免心跳链路异常时启动必然失败的操作。
"""
state.server_api.heartbeat()
try:
me = state.server_api.get_me()
if not me.get("is_online"):
raise HTTPException(status_code=409, detail="RPA 在线状态未确认,请检查网络后重试")
except requests.RequestException as e:
raise HTTPException(status_code=503, detail=f"无法确认在线状态:{e}")
# ======================================================= # =======================================================
# 请求模型 # 请求模型
# ======================================================= # =======================================================
class ConnectReq(BaseModel): class AuthReq(BaseModel):
username: str
password: str
nickname: str | None = None nickname: str | None = None
@@ -78,15 +127,30 @@ def index(request: Request):
# ======================================================= # =======================================================
@app.get("/api/status") @app.get("/api/status")
def get_status(): def get_status():
"""返回整体状态,供前端轮询""" """返回整体状态,供前端轮询(含本地 token 免登录校验)"""
# 若本地存有 token,尝试校验并获取用户信息(实现二次启动免登录)
me = None
if state.server_api.token:
try:
me = state.server_api.get_me()
state.connected = True
state.ensure_heartbeat() # token 有效时确保心跳线程在跑
except Exception:
state.connected = False
state.server_api.logout() # token 失效,清除本地缓存
else:
state.connected = False
result = { result = {
"client_code": generate_client_code()[:16] + "...",
"machine": get_machine_summary(), "machine": get_machine_summary(),
"username": state.server_api.username,
"server_connected": state.connected, "server_connected": state.connected,
"server_reachable": state.server_api.ping(), "server_reachable": state.server_api.ping(),
"rpa_online": me.get("is_online", False) if me else False,
"adspower_running": state.browser.is_adspower_running(), "adspower_running": state.browser.is_adspower_running(),
"ai_configured": state.ai.available(), "ai_configured": state.ai.available(),
"login_status": "unknown", "login_status": me.get("login_status", "unknown") if me else "unknown",
"boss_account": me.get("boss_account") if me else None,
"resume_count": 0, "resume_count": 0,
"has_primary": False, "has_primary": False,
"applying": False, "applying": False,
@@ -94,14 +158,11 @@ def get_status():
} }
if state.connected: if state.connected:
try: try:
me = state.server_api.get_me()
result["login_status"] = me.get("login_status", "unknown")
result["boss_account"] = me.get("boss_account")
resumes = state.server_api.list_resumes() resumes = state.server_api.list_resumes()
result["resume_count"] = len(resumes) result["resume_count"] = len(resumes)
result["has_primary"] = any(r.get("is_primary") for r in resumes) result["has_primary"] = any(r.get("is_primary") for r in resumes)
except Exception as e: except Exception as e:
logger.debug(f"获取用户状态失败:{e}") logger.debug(f"获取简历状态失败:{e}")
if state.applicant and state.applicant.is_running: if state.applicant and state.applicant.is_running:
result["applying"] = True result["applying"] = True
result["apply_stats"] = state.applicant.stats result["apply_stats"] = state.applicant.stats
@@ -109,16 +170,50 @@ def get_status():
# ======================================================= # =======================================================
# Step 0: 连接云端服务端 # Step 0: 登录 / 注册云端账号(账号密码体系)
# ======================================================= # =======================================================
@app.post("/api/connect") def _extract_error(e: requests.HTTPError) -> str:
def connect(req: ConnectReq): """从服务端错误响应中提取 detail 信息"""
try: try:
data = state.server_api.register(req.nickname) return e.response.json().get("detail", str(e))
except Exception:
return str(e)
@app.post("/api/register")
def register(req: AuthReq):
"""注册新账号"""
try:
data = state.server_api.register(req.username, req.password, req.nickname)
state.connected = True state.connected = True
return {"ok": True, "user_id": data["user_id"], "is_new": data["is_new"]} state.ensure_heartbeat()
return {"ok": True, "user_id": data["user_id"], "username": data["username"]}
except requests.HTTPError as e:
raise HTTPException(status_code=e.response.status_code, detail=_extract_error(e))
except Exception as e: except Exception as e:
raise HTTPException(status_code=500, detail=f"连接服务端失败:{e}") raise HTTPException(status_code=500, detail=f"注册失败:{e}")
@app.post("/api/login")
def login(req: AuthReq):
"""账号密码登录"""
try:
data = state.server_api.login(req.username, req.password)
state.connected = True
state.ensure_heartbeat()
return {"ok": True, "user_id": data["user_id"], "username": data["username"]}
except requests.HTTPError as e:
raise HTTPException(status_code=e.response.status_code, detail=_extract_error(e))
except Exception as e:
raise HTTPException(status_code=500, detail=f"登录失败:{e}")
@app.post("/api/logout")
def logout():
"""退出登录,清除本地 token"""
state.server_api.logout()
state.connected = False
return {"ok": True}
# ======================================================= # =======================================================
@@ -127,8 +222,7 @@ def connect(req: ConnectReq):
@app.post("/api/start-login") @app.post("/api/start-login")
def start_login(): def start_login():
"""打开 AdsPower 浏览器并跳转到 Boss直聘,等待用户手动登录""" """打开 AdsPower 浏览器并跳转到 Boss直聘,等待用户手动登录"""
if not state.connected: _require_auth()
raise HTTPException(status_code=400, detail="请先连接服务端")
try: try:
state.server_api.update_login_status("logging_in") state.server_api.update_login_status("logging_in")
page = state.browser.connect() page = state.browser.connect()
@@ -158,6 +252,22 @@ def _poll_login():
state.login_polling = False state.login_polling = False
@app.post("/api/detect-login")
def detect_login():
"""活体检测 Boss直聘 登录状态(进入登录步骤时自动调用)"""
_require_auth()
try:
logged_in = state.browser.check_boss_login()
except Exception as e:
raise HTTPException(status_code=500, detail=f"检测失败:{e}")
if logged_in:
account = state.browser.get_boss_account_name()
state.server_api.update_login_status("logged_in", account)
return {"logged_in": True, "account": account}
state.server_api.update_login_status("not_login")
return {"logged_in": False}
@app.get("/api/login-status") @app.get("/api/login-status")
def login_status(): def login_status():
"""前端轮询登录状态""" """前端轮询登录状态"""
@@ -180,8 +290,7 @@ def login_status():
@app.post("/api/scrape-resumes") @app.post("/api/scrape-resumes")
def scrape_resumes(): def scrape_resumes():
"""AI 抓取账号内所有简历并上传到云端""" """AI 抓取账号内所有简历并上传到云端"""
if not state.connected: _require_auth()
raise HTTPException(status_code=400, detail="请先连接服务端")
try: try:
scraper = ResumeScraper(state.browser, state.ai) scraper = ResumeScraper(state.browser, state.ai)
resumes = scraper.scrape_all() resumes = scraper.scrape_all()
@@ -212,8 +321,8 @@ def set_primary(resume_id: int):
# ======================================================= # =======================================================
@app.post("/api/start-apply") @app.post("/api/start-apply")
def start_apply(req: StartApplyReq): def start_apply(req: StartApplyReq):
if not state.connected: _require_auth()
raise HTTPException(status_code=400, detail="请先连接服务端") _require_rpa_online() # 在线预检:与服务端 require_online_user 前置校验呼应
if not state.server_api.get_primary_resume(): if not state.server_api.get_primary_resume():
raise HTTPException(status_code=400, detail="请先设置主简历") raise HTTPException(status_code=400, detail="请先设置主简历")
if not state.browser.is_adspower_running(): if not state.browser.is_adspower_running():
+93 -15
View File
@@ -24,8 +24,9 @@ function goToStep(step) {
for (let i = 1; i <= 5; i++) { for (let i = 1; i <= 5; i++) {
$(`panel-${i}`).classList.toggle('hidden', i !== step); $(`panel-${i}`).classList.toggle('hidden', i !== step);
} }
if (step === 5) loadHistory(); if (step === 2) detectBossLogin(); // 进入 Boss登录 步骤自动活体检测
if (step === 3) loadResumes(); if (step === 3) loadResumes();
if (step === 5) loadHistory();
} }
document.querySelectorAll('.step').forEach(el => { document.querySelectorAll('.step').forEach(el => {
el.addEventListener('click', () => goToStep(parseInt(el.dataset.step))); el.addEventListener('click', () => goToStep(parseInt(el.dataset.step)));
@@ -53,7 +54,6 @@ function badge(text, cls) {
async function refreshStatus() { async function refreshStatus() {
try { try {
const s = await api('/api/status'); const s = await api('/api/status');
$('clientCode').textContent = s.client_code;
$('serverReachable').innerHTML = badge( $('serverReachable').innerHTML = badge(
s.server_reachable ? '可连接' : '无法连接', s.server_reachable ? '可连接' : '无法连接',
s.server_reachable ? 'ok' : 'err' s.server_reachable ? 'ok' : 'err'
@@ -62,13 +62,25 @@ async function refreshStatus() {
s.adspower_running ? '运行中' : '未运行', s.adspower_running ? '运行中' : '未运行',
s.adspower_running ? 'ok' : 'warn' s.adspower_running ? 'ok' : 'warn'
); );
// 顶部徽章 // 顶部徽章与用户区
$('statusBadges').innerHTML = let badges = badge(s.server_connected ? '已连接' : '未连接', s.server_connected ? 'ok' : '');
badge(s.server_connected ? '已连接' : '未连接', s.server_connected ? 'ok' : '') + if (s.server_connected) {
badge(s.ai_configured ? 'AI已配置' : 'AI未配置', s.ai_configured ? 'ok' : 'warn'); badges += badge(s.rpa_online ? 'RPA在线' : 'RPA离线', s.rpa_online ? 'ok' : 'warn');
}
badges += badge(s.ai_configured ? 'AI已配置' : 'AI未配置', s.ai_configured ? 'ok' : 'warn');
$('statusBadges').innerHTML = badges;
const userArea = $('userArea');
if (s.server_connected && s.username) {
userArea.classList.remove('hidden');
$('userName').textContent = s.username;
} else {
userArea.classList.add('hidden');
}
if (s.server_connected) { if (s.server_connected) {
updateLoginBadge(s.login_status, s.boss_account); updateLoginBadge(s.login_status, s.boss_account);
// 本地 token 免登录:自动跳过账号步骤
if (currentStep === 1) goToStep(2);
} }
return s; return s;
} catch (e) { } catch (e) {
@@ -88,29 +100,95 @@ function updateLoginBadge(status, account) {
} }
// ========================================================== // ==========================================================
// Step 1: 连接服务端 // Step 1: 登录 / 注册系统账号
// ========================================================== // ==========================================================
$('btnConnect').addEventListener('click', async () => { let registerMode = false;
const btn = $('btnConnect');
function setAuthMode(isRegister) {
registerMode = isRegister;
$('btnLogin').classList.toggle('hidden', isRegister);
$('btnRegister').classList.toggle('hidden', !isRegister);
$('nicknameGroup').classList.toggle('hidden', !isRegister);
$('authSwitchHint').textContent = isRegister
? '已有账号?点击上方“登 录”切换为登录模式。'
: '没有账号?点击上方“注册新账号”切换为注册模式。';
}
// 登录/注册模式切换:登录模式下“注册新账号”是切换按钮;注册模式下“登 录”是切换按钮
$('btnRegister').addEventListener('click', () => { if (!registerMode) setAuthMode(true); });
$('btnLogin').addEventListener('click', () => { if (registerMode) setAuthMode(false); });
$('authSwitchHint').addEventListener('click', () => setAuthMode(!registerMode));
$('authSwitchHint').style.cursor = 'pointer';
async function submitAuth() {
const username = $('username').value.trim();
const password = $('password').value;
if (!username || !password) { toast('请输入用户名和密码'); return; }
const wasRegister = registerMode;
const btn = wasRegister ? $('btnRegister') : $('btnLogin');
btn.disabled = true; btn.disabled = true;
try { try {
const data = await api('/api/connect', { const path = wasRegister ? '/api/register' : '/api/login';
method: 'POST', const body = { username, password };
body: JSON.stringify({ nickname: $('nickname').value || null }), if (wasRegister) body.nickname = $('nickname').value || null;
}); const data = await api(path, { method: 'POST', body: JSON.stringify(body) });
toast(data.is_new ? '注册成功!' : '登录成功!'); toast(wasRegister ? '注册成功!' : `欢迎回来,${data.username}!`);
await refreshStatus(); await refreshStatus();
goToStep(2); goToStep(2);
} catch (e) { } catch (e) {
toast('连接失败:' + e.message, 5000); toast(e.message, 5000);
setAuthMode(wasRegister); // 失败时保持当前模式
} finally { } finally {
btn.disabled = false; btn.disabled = false;
} }
}
// 主按钮提交(当前模式下可见的那个)
$('btnLogin').addEventListener('click', () => { if (!registerMode) submitAuth(); });
$('btnRegister').addEventListener('click', () => { if (registerMode) submitAuth(); });
// 回车提交表单
document.addEventListener('keydown', (e) => {
if (e.key === 'Enter' && currentStep === 1) submitAuth();
});
// 退出登录
$('btnLogout').addEventListener('click', async () => {
try {
await api('/api/logout', { method: 'POST' });
toast('已退出登录');
goToStep(1);
refreshStatus();
} catch (e) { toast('退出失败:' + e.message); }
}); });
// ========================================================== // ==========================================================
// Step 2: 登录 Boss直聘 // Step 2: 登录 Boss直聘
// ========================================================== // ==========================================================
// 活体检测:进入本步骤自动调用,判断指纹浏览器中是否已登录
async function detectBossLogin() {
$('detectSpinner').classList.remove('hidden');
try {
const r = await api('/api/detect-login', { method: 'POST' });
if (r.logged_in) {
updateLoginBadge('logged_in', r.account);
$('btnSkipLogin').classList.remove('hidden');
toast(`检测到已登录:${r.account},可直接进入下一步`);
} else {
updateLoginBadge('not_login');
$('btnSkipLogin').classList.add('hidden');
toast('未检测到登录,请点击“打开浏览器登录”');
}
} catch (e) {
toast('登录检测失败:' + e.message, 5000);
} finally {
$('detectSpinner').classList.add('hidden');
}
}
$('btnRedetect').addEventListener('click', detectBossLogin);
$('btnSkipLogin').addEventListener('click', () => goToStep(3));
$('btnStartLogin').addEventListener('click', async () => { $('btnStartLogin').addEventListener('click', async () => {
const btn = $('btnStartLogin'); const btn = $('btnStartLogin');
btn.disabled = true; btn.disabled = true;
+20
View File
@@ -38,6 +38,26 @@ body {
.header h1 { font-size: 22px; } .header h1 { font-size: 22px; }
.status-badges { display: flex; gap: 8px; } .status-badges { display: flex; gap: 8px; }
/* ===== 用户区 ===== */
.user-area {
display: flex;
align-items: center;
gap: 10px;
}
.user-name {
font-weight: 600;
color: var(--primary);
}
.btn-link {
background: none;
border: none;
color: var(--text-light);
cursor: pointer;
font-size: 13px;
text-decoration: underline;
}
.btn-link:hover { color: var(--danger); }
/* ===== 步骤导航 ===== */ /* ===== 步骤导航 ===== */
.steps { .steps {
display: flex; display: flex;
+28 -8
View File
@@ -11,42 +11,62 @@
<!-- 顶部标题栏 --> <!-- 顶部标题栏 -->
<header class="header"> <header class="header">
<h1>🎯 Boss直聘 AI 智能投递</h1> <h1>🎯 Boss直聘 AI 智能投递</h1>
<div class="user-area hidden" id="userArea">
<span class="user-name" id="userName"></span>
<button class="btn-link" id="btnLogout">退出</button>
</div>
<div class="status-badges" id="statusBadges"></div> <div class="status-badges" id="statusBadges"></div>
</header> </header>
<!-- 步骤导航 --> <!-- 步骤导航 -->
<nav class="steps"> <nav class="steps">
<div class="step active" data-step="1"><span class="step-num">1</span> 连接</div> <div class="step active" data-step="1"><span class="step-num">1</span> 账号</div>
<div class="step" data-step="2"><span class="step-num">2</span> 登录</div> <div class="step" data-step="2"><span class="step-num">2</span> Boss登录</div>
<div class="step" data-step="3"><span class="step-num">3</span> 简历</div> <div class="step" data-step="3"><span class="step-num">3</span> 简历</div>
<div class="step" data-step="4"><span class="step-num">4</span> 投递</div> <div class="step" data-step="4"><span class="step-num">4</span> 投递</div>
<div class="step" data-step="5"><span class="step-num">5</span> 记录</div> <div class="step" data-step="5"><span class="step-num">5</span> 记录</div>
</nav> </nav>
<!-- Step 1: 连接服务端 --> <!-- Step 1: 登录 / 注册系统账号 -->
<section class="panel" id="panel-1"> <section class="panel" id="panel-1">
<h2>连接云端服务端</h2> <h2>登录系统账号</h2>
<p class="hint">使用本机硬件指纹作为唯一编码注册,数据将隔离存储在你的账号下。</p> <p class="hint">简历与投递记录都保存在你的账号下,换机器登录同一账号即可延续数据。</p>
<div class="info-box"> <div class="info-box">
<div><strong>机器指纹:</strong><code id="clientCode">加载中...</code></div>
<div><strong>服务端状态:</strong><span id="serverReachable" class="badge">检测中</span></div> <div><strong>服务端状态:</strong><span id="serverReachable" class="badge">检测中</span></div>
</div> </div>
<div class="form-group"> <div class="form-group">
<label>用户名</label>
<input type="text" id="username" placeholder="请输入用户名" autocomplete="username">
</div>
<div class="form-group">
<label>密码</label>
<input type="password" id="password" placeholder="请输入密码" autocomplete="current-password">
</div>
<div class="form-group hidden" id="nicknameGroup">
<label>昵称(可选)</label> <label>昵称(可选)</label>
<input type="text" id="nickname" placeholder="给自己起个名字"> <input type="text" id="nickname" placeholder="给自己起个名字">
</div> </div>
<button class="btn btn-primary" id="btnConnect">连接并注册</button> <div class="action-buttons">
<button class="btn btn-primary" id="btnLogin">登 录</button>
<button class="btn hidden" id="btnRegister">注册新账号</button>
</div>
<p class="hint" id="authSwitchHint">没有账号?点击上方“注册新账号”切换为注册模式。</p>
</section> </section>
<!-- Step 2: 登录 Boss直聘 --> <!-- Step 2: 登录 Boss直聘 -->
<section class="panel hidden" id="panel-2"> <section class="panel hidden" id="panel-2">
<h2>登录 Boss直聘</h2> <h2>登录 Boss直聘</h2>
<p class="hint">点击下方按钮,将通过 AdsPower 指纹浏览器打开 Boss直聘,请在弹出的浏览器窗口中手动完成登录(扫码或账号密码)。</p> <p class="hint">进入本步骤会自动检测指纹浏览器中的登录状态:若已登录可直接跳过;否则点击下方按钮打开 Boss直聘 手动登录(扫码或账号密码)。</p>
<div class="info-box"> <div class="info-box">
<div><strong>AdsPower 状态:</strong><span id="adspowerStatus" class="badge">检测中</span></div> <div><strong>AdsPower 状态:</strong><span id="adspowerStatus" class="badge">检测中</span></div>
<div><strong>登录状态:</strong><span id="loginStatus" class="badge">未登录</span></div> <div><strong>登录状态:</strong><span id="loginStatus" class="badge">未登录</span></div>
</div> </div>
<div class="spinner hidden" id="detectSpinner">正在检测指纹浏览器中的登录状态...</div>
<div class="action-buttons">
<button class="btn btn-primary" id="btnStartLogin">打开浏览器登录</button> <button class="btn btn-primary" id="btnStartLogin">打开浏览器登录</button>
<button class="btn hidden" id="btnSkipLogin">已登录,直接下一步</button>
<button class="btn" id="btnRedetect">重新检测</button>
</div>
<div class="spinner hidden" id="loginSpinner">正在等待登录,请在浏览器中完成操作...</div> <div class="spinner hidden" id="loginSpinner">正在等待登录,请在浏览器中完成操作...</div>
</section> </section>
+192
View File
@@ -0,0 +1,192 @@
# Boss直聘 AI 投递系统 — 优化方案
> 本文档汇总系统搭建后,通过评审讨论确定的优化项。
> 每个优化项包含:问题来源、现状缺陷、改造方案、涉及文件、验收标准与当前状态。
---
## 一、架构现状(优化前)
- **服务端**:FastAPI + MySQL + JWT,按 `client_code`(机器硬件指纹)识别用户
- **客户端**:本地 Web 控制面板 + AdsPower 指纹浏览器 + Playwright + AI 评分
- **身份模型**:以机器硬件指纹作为唯一编码注册,数据按用户隔离
本轮优化主要围绕**身份体系**与**登录健壮性**展开。
---
## 二、优化项清单
### ⭐ 优化项 1:系统登录改为「账号密码」体系(核心)
**问题来源**
- 「RPA 是不是要有一个登录步骤?要不然怎么知道这个 RPA 要登录到系统的哪一个账号?」
- 「RPA 的编码是不是应该以指纹浏览器为唯一?要不然用户切换了机器也会被认为是新的。」
**现状缺陷**
- 身份绑定在**机器硬件指纹**上:换机器 = 新用户,数据无法延续。
- 无真正的"账号"概念:无用户名、无密码、无法管理、无法找回。
- RPA 与账号无显式关系,无法明确"控制哪个 RPA 启停"。
**改造方案**(已确认:**账号密码登录**)
- 身份从"机器指纹 / Profile 编码"改为**服务端账号(用户名 + 密码)**。
- 账号存于服务端,与机器、与指纹浏览器 Profile 完全解耦。
- 指纹浏览器回归本职:仅作为访问 Boss直聘 的防检测浏览器工具(本地配置)。
- 数据(简历 / 投递记录)全部挂在账号下。
> 说明:此前讨论的"Profile localStorage 编码"方案已被账号密码体系取代,不再实施。
**涉及改动**
| 端 | 文件 | 改动内容 |
|----|------|---------|
| 服务端 | `server/auth.py` | 新增 `hash_password` / `verify_password`(PBKDF2);token payload 用 username |
| 服务端 | `server/models.py` | User 增加 `username`(唯一)、`password_hash`;`client_code` 降为可选设备标记 |
| 服务端 | `server/schemas.py` | 改造注册模型;新增登录请求/响应模型 |
| 服务端 | `server/routers/register.py` | 拆分 `/register`(注册)与 `/login`(登录)接口 |
| 客户端 | `client/server_api.py` | `register/login` 改为账密;保留 token 持久化 |
| 客户端 | `client/web/app.py` | 新增 `/api/register`、`/api/login`;替换指纹连接逻辑 |
| 客户端 | `client/web/templates/index.html` + `static/app.js` | Step1 改为登录/注册表单 |
**验收标准**
- [x] 可通过用户名密码注册新账号,密码以加盐哈希存储(不存明文)
- [x] 可通过用户名密码登录,返回 JWT token
- [x] 客户端保存 token,二次启动免登录;token 失效时引导重新登录
- [x] 换机器登录同一账号,可见原有简历与投递记录
**状态**:✅ 已完成
---
### 优化项 2:Boss直聘登录「活体检测」(重连健壮性)
**问题来源**
- 「如果 RPA 离线后再次登录,但指纹浏览器已经登录了 Boss 该怎么办?是不是应该做一个检查处理?」
**现状缺陷**
- 登录状态只存在服务端字段里(`login_status`),从不与真实浏览器做活体校验。
- 场景 A:Profile 里 Cookie 仍有效(已登录),却仍强制用户手动扫码。
- 场景 B:Cookie 已过期,但服务端仍记 `logged_in`,后续抓简历/投递会失败。
**改造方案**(已确认:**进入登录步骤自动检测**)
- 进入登录步骤时,自动调用 `BrowserManager.check_boss_login()` 做活体校验。
- 已登录 → 自动标记 `logged_in`,跳过手动登录,直接进入简历步骤。
- 未登录 → 展示手动登录引导(扫码/账密)。
- 新增 `/api/detect-login` 接口供前端触发。
**涉及改动**
| 端 | 文件 | 改动内容 |
|----|------|---------|
| 客户端 | `client/web/app.py` | 新增 `/api/detect-login`,内部调用 `check_boss_login` 并回写服务端状态 |
| 客户端 | `client/web/static/app.js` | 进入 Step2 自动触发检测,按结果决定跳过或引导登录 |
**验收标准**
- [x] Profile 已登录时,进入登录步骤自动识别并跳过手动登录
- [x] Cookie 失效时,能正确识别为未登录并引导重新登录
**状态**:✅ 已完成
---
### 优化项 3:单账号模式(范围决策,非编码项)
**问题来源**
- 「RPA 是不是需要与账号有一个关系?要不然怎么控制哪个 RPA 开始、哪个结束?」
**决策**(已确认:**单账号**)
- 一个客户端一次只服务一个账号,投递任务为该账号的全局单例。
- "启停控制"即"启停当前登录账号的投递任务",无需多账号实体。
- 多账号 / 多 Profile 独立启停为后续可扩展方向(届时引入 `RpaProfile` 实体)。
**状态**:已确认范围,本轮不做多账号改造
---
### 优化项 4:RPA 在线判定(心跳机制)
**问题来源**
- 「我们现在是怎么确认 RPA 在线的?」
**现状缺陷**(优化前)
- 无真正的在线判定:`last_seen_at` 只在登录/写操作时被动更新,客户端静默挂着不刷新。
- 前端 8 秒轮询只调只读接口 `/me`,服务端不记录为存活。
- 客户端崩溃/断网后服务端永远不知道离线,`logging_in` 状态会永久卡死。
**改造方案**
- 服务端新增 `/api/auth/heartbeat`,客户端登录后每 30s 上报一次,刷新 `last_seen_at`。
- 在线判定:`last_seen_at` 距今 ≤ 90s(= 3 个心跳周期)为在线。
- `/api/auth/me` 返回 `is_online` 字段;前端顶部展示“RPA在线/离线”徽章。
- 懒清理:客户端已离线却仍停留在 `logging_in` 时,自动重置为 `not_login`。
**涉及改动**
| 端 | 文件 | 改动内容 |
|----|------|---------|
| 服务端 | `server/schemas.py` | `UserInfo` 增加 `is_online` |
| 服务端 | `server/routers/register.py` | 新增 `/heartbeat`、`is_user_online` 判定、`/me` 懒清理 |
| 客户端 | `client/config.py` | 新增 `HEARTBEAT_INTERVAL=30` |
| 客户端 | `client/server_api.py` | 新增 `heartbeat()`(失败不抛异常) |
| 客户端 | `client/web/app.py` | 后台心跳线程(登录启动、退出停止);`/api/status` 返回 `rpa_online` |
| 客户端 | `client/web/static/app.js` | 顶部展示 RPA 在线徽章 |
**验收标准**
- [x] 登录后心跳线程自动启动,每 30s 上报;退出登录自动停止
- [x] 客户端关闭/断网 90s 后,服务端判定离线,前端徽章变为“RPA离线”
- [x] 离线时 `logging_in` 状态自动重置为 `not_login`
**业务底层收敛(重要设计约束)**
在线判定不允许在各路由里各自实现,统一收敛到 `server/online.py`:
| 服务 | 职责 | 使用方 |
|------|------|--------|
| `is_online(user)` | 纯判定,无副作用 | `/me` 返回在线状态 |
| `touch(user, db)` | 刷新活跃时间 | `/heartbeat` |
| `require_online_user` | 前置校验依赖:认证→先验在线→再刷新 | 所有需 RPA 存活的写操作 |
前置校验接入清单:
- ✅ `/api/sessions/start`(开始投递)、`/stats`(上报统计)
- ✅ `/api/auth/login-status`(Boss 登录状态变更)
- ✅ `/api/resumes/batch`(简历上传)、`/api/jobs/report`(投递上报)
- ⚠️ 特例:`/api/sessions/{id}/stop` 故意豁免在线拦截——stop 是安全清理操作,
否则离线前遗留的 running 僵尸会话永远无法关闭
- 只读查询接口(history/stats/list)不强制在线
客户端同步收敛:`client/web/app.py` 的 `_require_auth()` 统一未登录拦截,
`_require_rpa_online()` 在开始投递前先发心跳再确认服务端判定在线。
后续新增任何写操作接口,必须走 `require_online_user`,不得另起炉灶。
**状态**:✅ 已完成
---
## 三、已通过设计决策解决(无需单独实现)
| 讨论点 | 结论 |
|--------|------|
| RPA 编码唯一性(跨机器) | 由服务端账号体系解决:账号与机器/Profile 解耦 |
| RPA 与账号绑定、启停控制 | 单账号下,账号即身份,投递会话已有单实例约束 |
| 账号找回 | 使用服务端账号密码,账号常驻服务端,无需找回机制 |
---
## 四、实施顺序
1. **服务端账号密码体系**(优化项 1)
- auth.py 密码哈希 → models.py → schemas.py → register.py 路由
2. **客户端登录/注册**(优化项 1 客户端部分)
- server_api.py → web/app.py → 前端表单
3. **Boss登录活体检测**(优化项 2)
- web/app.py detect-login → 前端自动检测
4. **RPA 在线判定**(优化项 4)
- 服务端 heartbeat 接口 → 客户端心跳线程 → 前端徽章
---
## 五、决策记录
| 议题 | 选项 | 最终决定 |
|------|------|---------|
| 账号规模 | 单账号 / 多账号多开 | **单账号** |
| Boss登录检测时机 | 自动检测 / 手动按钮 / 两者 | **进入登录步骤自动检测** |
| 系统登录模式 | 纯编码自动 / 账号密码 / 混合 | **账号密码登录** |
| 账号找回 | 需要 / 不需要 | **不需要**(服务端账号密码天然解决) |
+35 -3
View File
@@ -1,6 +1,8 @@
""" """
JWT 认证工具 JWT 认证工具 + 密码哈希
""" """
import hashlib
import secrets
from datetime import datetime, timedelta from datetime import datetime, timedelta
from typing import Optional from typing import Optional
@@ -17,12 +19,42 @@ from .models import User
bearer_scheme = HTTPBearer(auto_error=False) bearer_scheme = HTTPBearer(auto_error=False)
def create_access_token(user_id: int, client_code: str) -> str: # ------------------------------------------------------------------
# 密码哈希(PBKDF2-SHA256,标准库实现,无需额外依赖)
# ------------------------------------------------------------------
_PBKDF2_ITERATIONS = 120_000
def hash_password(password: str) -> str:
"""生成 '盐$哈希' 格式的密码摘要"""
salt = secrets.token_hex(16)
digest = hashlib.pbkdf2_hmac(
"sha256", password.encode("utf-8"), salt.encode("utf-8"), _PBKDF2_ITERATIONS
).hex()
return f"{salt}${digest}"
def verify_password(password: str, stored: str) -> bool:
"""校验明文密码与存储摘要是否匹配"""
try:
salt, digest = stored.split("$", 1)
except ValueError:
return False
candidate = hashlib.pbkdf2_hmac(
"sha256", password.encode("utf-8"), salt.encode("utf-8"), _PBKDF2_ITERATIONS
).hex()
return secrets.compare_digest(candidate, digest)
# ------------------------------------------------------------------
# JWT
# ------------------------------------------------------------------
def create_access_token(user_id: int, username: str) -> str:
"""生成 JWT token""" """生成 JWT token"""
expire = datetime.utcnow() + timedelta(days=settings.ACCESS_TOKEN_EXPIRE_DAYS) expire = datetime.utcnow() + timedelta(days=settings.ACCESS_TOKEN_EXPIRE_DAYS)
payload = { payload = {
"sub": str(user_id), "sub": str(user_id),
"client_code": client_code, "username": username,
"exp": expire, "exp": expire,
} }
return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM) return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
+9 -5
View File
@@ -18,17 +18,21 @@ def utcnow() -> datetime:
class User(Base): class User(Base):
""" """
客户端用户 系统用户
以机器硬件指纹(client_code)作为唯一标识 以用户名(username)+ 密码哈希作为身份,与机器/指纹浏览器解耦
""" """
__tablename__ = "users" __tablename__ = "users"
id = Column(Integer, primary_key=True, autoincrement=True) id = Column(Integer, primary_key=True, autoincrement=True)
# 机器硬件指纹哈希(唯一) # 登录用户名(唯一)
client_code = Column(String(128), unique=True, nullable=False, index=True) username = Column(String(64), unique=True, nullable=False, index=True)
# 密码加盐哈希(PBKDF2,格式:盐$摘要),不存明文
password_hash = Column(String(255), nullable=False)
# 客户端显示昵称(可选) # 客户端显示昵称(可选)
nickname = Column(String(64), nullable=True) nickname = Column(String(64), nullable=True)
# JWT token 存储(服务端无状态校验,这里仅做记录) # 最近一次登录的客户端设备指纹(仅作审计/展示,非身份标识)
client_code = Column(String(128), nullable=True)
# 账号是否启用
is_active = Column(Boolean, default=True, nullable=False) is_active = Column(Boolean, default=True, nullable=False)
# Boss直聘 账号标识(登录成功后回填,用于区分同一 Boss 账号) # Boss直聘 账号标识(登录成功后回填,用于区分同一 Boss 账号)
boss_account = Column(String(128), nullable=True) boss_account = Column(String(128), nullable=True)
+60
View File
@@ -0,0 +1,60 @@
"""
RPA 在线状态服务(业务底层收敛)
====================================
所有与"客户端在线"相关的判定与刷新必须经由本模块,禁止在路由里各自实现:
- is_online(user) 纯判定:last_seen_at 距今是否在在线窗口内
- touch(user, db) 刷新活跃时间(心跳 / 任何业务请求)
- require_online_user 前置校验依赖:认证 + 刷新活跃 + 在线校验
使用约定:
- 心跳接口 → touch()
- 需要 RPA 存活的写操作(开始/结束投递、登录状态变更、简历上传、
投递上报等)→ require_online_user 前置校验
- 只读查询接口 → 仍用 get_current_user,不做在线强制
"""
from datetime import datetime
from fastapi import Depends, HTTPException, status
from sqlalchemy.orm import Session
from .auth import get_current_user
from .database import get_db
from .models import User
# 客户端心跳间隔 30s;连续 3 个周期(90s)无心跳即判定离线
ONLINE_WINDOW_SECONDS = 90
def is_online(user: User) -> bool:
"""判定客户端是否在线(纯函数,不产生任何写操作)"""
if not user.last_seen_at:
return False
return (datetime.utcnow() - user.last_seen_at).total_seconds() <= ONLINE_WINDOW_SECONDS
def touch(user: User, db: Session) -> None:
"""刷新活跃时间并提交(请求本身即在线信号)"""
user.last_seen_at = datetime.utcnow()
db.commit()
def require_online_user(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
) -> User:
"""
业务操作前置校验依赖(开始/结束投递、登录等必须走这里):
1. 认证(复用 get_current_user)
2. 先校验在线:若客户端已离线(心跳中断),直接拒绝操作
3. 再刷新活跃时间,让业务请求本身也成为在线信号
注意顺序:先校验后刷新。若先刷新,离线校验将永远通过,失去拦截意义。
"""
if not is_online(current_user):
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail="RPA 客户端已离线,请确认客户端正在运行后重试",
)
touch(current_user, db)
return current_user
+3 -2
View File
@@ -10,6 +10,7 @@ from sqlalchemy import func
from ..auth import get_current_user from ..auth import get_current_user
from ..database import get_db from ..database import get_db
from ..models import User, JobApplication from ..models import User, JobApplication
from ..online import require_online_user
from ..schemas import ApplicationIn, ApplicationOut, Message, StatsOut from ..schemas import ApplicationIn, ApplicationOut, Message, StatsOut
router = APIRouter(prefix="/api/jobs", tags=["投递记录"]) router = APIRouter(prefix="/api/jobs", tags=["投递记录"])
@@ -19,11 +20,11 @@ router = APIRouter(prefix="/api/jobs", tags=["投递记录"])
def report_application( def report_application(
req: ApplicationIn, req: ApplicationIn,
session_id: Optional[int] = Query(None, description="所属会话 ID"), session_id: Optional[int] = Query(None, description="所属会话 ID"),
current_user: User = Depends(get_current_user), current_user: User = Depends(require_online_user),
db: Session = Depends(get_db), db: Session = Depends(get_db),
): ):
""" """
客户端上报一条投递/跳过记录。 客户端上报一条投递/跳过记录(前置校验:RPA 必须在线)。
同一用户 + 同一职位 ID 去重,已存在则更新。 同一用户 + 同一职位 ID 去重,已存在则更新。
""" """
existing = db.query(JobApplication).filter( existing = db.query(JobApplication).filter(
+59 -27
View File
@@ -1,59 +1,91 @@
""" """
客户端注册 / 登录状态 / 用户信息路由 账号注册 / 登录 / 用户状态路由
""" """
from datetime import datetime from datetime import datetime
from fastapi import APIRouter, Depends, HTTPException from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session from sqlalchemy.orm import Session
from ..auth import create_access_token, get_current_user from ..auth import (
create_access_token, get_current_user, hash_password, verify_password,
)
from ..database import get_db from ..database import get_db
from ..models import User from ..models import User
from ..online import is_online, touch, require_online_user
from ..schemas import ( from ..schemas import (
RegisterRequest, RegisterResponse, UserInfo, LoginStatusUpdate, Message, RegisterRequest, LoginRequest, AuthResponse,
UserInfo, LoginStatusUpdate, Message,
) )
router = APIRouter(prefix="/api/auth", tags=["认证与用户"]) router = APIRouter(prefix="/api/auth", tags=["认证与用户"])
@router.post("/register", response_model=RegisterResponse) @router.post("/register", response_model=AuthResponse)
def register(req: RegisterRequest, db: Session = Depends(get_db)): def register(req: RegisterRequest, db: Session = Depends(get_db)):
""" """注册新账号(用户名 + 密码)"""
客户端注册/登录。 exists = db.query(User).filter(User.username == req.username).first()
以机器硬件指纹 client_code 作为唯一标识: if exists:
- 已存在 → 直接返回 token(视为登录) raise HTTPException(status_code=409, detail="用户名已存在")
- 不存在 → 创建新用户
"""
user = db.query(User).filter(User.client_code == req.client_code).first()
is_new = user is None
if is_new: user = User(
user = User(client_code=req.client_code, nickname=req.nickname) username=req.username,
password_hash=hash_password(req.password),
nickname=req.nickname,
)
db.add(user) db.add(user)
db.commit() db.commit()
db.refresh(user) db.refresh(user)
# 更新最后活跃时间 token = create_access_token(user.id, user.username)
return AuthResponse(user_id=user.id, username=user.username, token=token)
@router.post("/login", response_model=AuthResponse)
def login(req: LoginRequest, db: Session = Depends(get_db)):
"""账号密码登录,返回 JWT token"""
user = db.query(User).filter(User.username == req.username).first()
if user is None or not verify_password(req.password, user.password_hash):
raise HTTPException(status_code=401, detail="用户名或密码错误")
if not user.is_active:
raise HTTPException(status_code=403, detail="账号已被禁用")
# 记录登录设备与活跃时间(client_code 仅作审计)
if req.client_code:
user.client_code = req.client_code
user.last_seen_at = datetime.utcnow() user.last_seen_at = datetime.utcnow()
db.commit() db.commit()
token = create_access_token(user.id, user.client_code) token = create_access_token(user.id, user.username)
return RegisterResponse( return AuthResponse(user_id=user.id, username=user.username, token=token)
user_id=user.id,
token=token,
client_code=user.client_code, @router.post("/heartbeat", response_model=Message)
is_new=is_new, def heartbeat(
) current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""客户端心跳:刷新 last_seen_at,用于在线判定(统一走 online.touch)"""
touch(current_user, db)
return Message(msg="ok")
@router.get("/me", response_model=UserInfo) @router.get("/me", response_model=UserInfo)
def get_me(current_user: User = Depends(get_current_user)): def get_me(
"""获取当前用户信息""" current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""获取当前用户信息(含 RPA 在线状态)"""
online = is_online(current_user)
# 懒清理:客户端已离线却仍停留在“登录中”,说明登录轮询已中断,重置为未登录
if not online and current_user.login_status == "logging_in":
current_user.login_status = "not_login"
db.commit()
return UserInfo( return UserInfo(
id=current_user.id, id=current_user.id,
client_code=current_user.client_code, username=current_user.username,
nickname=current_user.nickname, nickname=current_user.nickname,
boss_account=current_user.boss_account, boss_account=current_user.boss_account,
login_status=current_user.login_status, login_status=current_user.login_status,
is_online=online,
created_at=current_user.created_at, created_at=current_user.created_at,
) )
@@ -61,10 +93,10 @@ def get_me(current_user: User = Depends(get_current_user)):
@router.put("/login-status", response_model=Message) @router.put("/login-status", response_model=Message)
def update_login_status( def update_login_status(
req: LoginStatusUpdate, req: LoginStatusUpdate,
current_user: User = Depends(get_current_user), current_user: User = Depends(require_online_user),
db: Session = Depends(get_db), db: Session = Depends(get_db),
): ):
"""更新 Boss直聘 登录状态""" """更新 Boss直聘 登录状态(前置校验:RPA 必须在线)"""
valid_status = {"not_login", "logging_in", "logged_in"} valid_status = {"not_login", "logging_in", "logged_in"}
if req.login_status not in valid_status: if req.login_status not in valid_status:
raise HTTPException(status_code=400, detail=f"登录状态必须是 {valid_status} 之一") raise HTTPException(status_code=400, detail=f"登录状态必须是 {valid_status} 之一")
+3 -2
View File
@@ -7,6 +7,7 @@ from sqlalchemy.orm import Session
from ..auth import get_current_user from ..auth import get_current_user
from ..database import get_db from ..database import get_db
from ..models import User, Resume from ..models import User, Resume
from ..online import require_online_user
from ..schemas import ResumeIn, ResumeOut, ResumeBatchIn, Message from ..schemas import ResumeIn, ResumeOut, ResumeBatchIn, Message
router = APIRouter(prefix="/api/resumes", tags=["简历管理"]) router = APIRouter(prefix="/api/resumes", tags=["简历管理"])
@@ -40,11 +41,11 @@ def get_primary_resume(
@router.post("/batch", response_model=list[ResumeOut]) @router.post("/batch", response_model=list[ResumeOut])
def upload_resumes_batch( def upload_resumes_batch(
req: ResumeBatchIn, req: ResumeBatchIn,
current_user: User = Depends(get_current_user), current_user: User = Depends(require_online_user),
db: Session = Depends(get_db), db: Session = Depends(get_db),
): ):
""" """
批量上传抓取到的简历。 批量上传抓取到的简历(前置校验:RPA 必须在线)。
以 boss_resume_id 去重:存在则更新,不存在则新增。 以 boss_resume_id 去重:存在则更新,不存在则新增。
第一份简历自动设为主简历(若当前没有主简历)。 第一份简历自动设为主简历(若当前没有主简历)。
""" """
+10 -5
View File
@@ -8,6 +8,7 @@ from sqlalchemy.orm import Session
from ..auth import get_current_user from ..auth import get_current_user
from ..database import get_db from ..database import get_db
from ..models import User, ApplySession from ..models import User, ApplySession
from ..online import require_online_user
from ..schemas import SessionStartIn, SessionOut, SessionStatsIn, Message from ..schemas import SessionStartIn, SessionOut, SessionStatsIn, Message
router = APIRouter(prefix="/api/sessions", tags=["投递会话"]) router = APIRouter(prefix="/api/sessions", tags=["投递会话"])
@@ -16,10 +17,10 @@ router = APIRouter(prefix="/api/sessions", tags=["投递会话"])
@router.post("/start", response_model=SessionOut) @router.post("/start", response_model=SessionOut)
def start_session( def start_session(
req: SessionStartIn, req: SessionStartIn,
current_user: User = Depends(get_current_user), current_user: User = Depends(require_online_user),
db: Session = Depends(get_db), db: Session = Depends(get_db),
): ):
"""开始一次投递会话""" """开始一次投递会话(前置校验:RPA 必须在线)"""
# 若已有进行中的会话,先结束它 # 若已有进行中的会话,先结束它
running = db.query(ApplySession).filter( running = db.query(ApplySession).filter(
ApplySession.user_id == current_user.id, ApplySession.user_id == current_user.id,
@@ -64,7 +65,11 @@ def stop_session(
current_user: User = Depends(get_current_user), current_user: User = Depends(get_current_user),
db: Session = Depends(get_db), db: Session = Depends(get_db),
): ):
"""结束指定会话""" """
结束指定会话。
特例:start 需在线前置校验,但 stop 是安全清理操作,故意豁免在线拦截——
否则离线前遗留的 running 僵尸会话将永远无法关闭。
"""
session = db.query(ApplySession).filter( session = db.query(ApplySession).filter(
ApplySession.id == session_id, ApplySession.id == session_id,
ApplySession.user_id == current_user.id, ApplySession.user_id == current_user.id,
@@ -82,10 +87,10 @@ def stop_session(
def update_session_stats( def update_session_stats(
session_id: int, session_id: int,
req: SessionStatsIn, req: SessionStatsIn,
current_user: User = Depends(get_current_user), current_user: User = Depends(require_online_user),
db: Session = Depends(get_db), db: Session = Depends(get_db),
): ):
"""增量上报投递/跳过数量""" """增量上报投递/跳过数量(前置校验:RPA 必须在线)"""
session = db.query(ApplySession).filter( session = db.query(ApplySession).filter(
ApplySession.id == session_id, ApplySession.id == session_id,
ApplySession.user_id == current_user.id, ApplySession.user_id == current_user.id,
+15 -7
View File
@@ -7,23 +7,30 @@ from pydantic import BaseModel, Field
# ======================================================= # =======================================================
# 认证相关 # 认证相关(账号密码体系)
# ======================================================= # =======================================================
class RegisterRequest(BaseModel): class RegisterRequest(BaseModel):
client_code: str = Field(..., min_length=8, max_length=128, description="机器硬件指纹哈希") username: str = Field(..., min_length=3, max_length=64, description="登录用户名")
password: str = Field(..., min_length=6, max_length=128, description="登录密码")
nickname: Optional[str] = Field(None, max_length=64) nickname: Optional[str] = Field(None, max_length=64)
class RegisterResponse(BaseModel): class LoginRequest(BaseModel):
username: str = Field(..., min_length=1, max_length=64)
password: str = Field(..., min_length=1, max_length=128)
# 可选:客户端设备指纹(仅作审计记录)
client_code: Optional[str] = Field(None, max_length=128)
class AuthResponse(BaseModel):
user_id: int user_id: int
username: str
token: str token: str
client_code: str
is_new: bool # 是否为新注册用户
class TokenPayload(BaseModel): class TokenPayload(BaseModel):
sub: int # user_id sub: int # user_id
client_code: str username: str
# ======================================================= # =======================================================
@@ -31,10 +38,11 @@ class TokenPayload(BaseModel):
# ======================================================= # =======================================================
class UserInfo(BaseModel): class UserInfo(BaseModel):
id: int id: int
client_code: str username: str
nickname: Optional[str] nickname: Optional[str]
boss_account: Optional[str] boss_account: Optional[str]
login_status: str login_status: str
is_online: bool # RPA 客户端是否在线(心跳判定)
created_at: datetime created_at: datetime
class Config: class Config: