登录 Boss直聘
- 点击下方按钮,将通过 AdsPower 指纹浏览器打开 Boss直聘,请在弹出的浏览器窗口中手动完成登录(扫码或账号密码)。
+ 进入本步骤会自动检测指纹浏览器中的登录状态:若已登录可直接跳过;否则点击下方按钮打开 Boss直聘 手动登录(扫码或账号密码)。
-
+ 正在检测指纹浏览器中的登录状态...
+
+
+
+
+
正在等待登录,请在浏览器中完成操作...
diff --git a/docs/优化方案.md b/docs/优化方案.md
new file mode 100644
index 0000000..daf8359
--- /dev/null
+++ b/docs/优化方案.md
@@ -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登录检测时机 | 自动检测 / 手动按钮 / 两者 | **进入登录步骤自动检测** |
+| 系统登录模式 | 纯编码自动 / 账号密码 / 混合 | **账号密码登录** |
+| 账号找回 | 需要 / 不需要 | **不需要**(服务端账号密码天然解决) |
diff --git a/server/auth.py b/server/auth.py
index 98366c9..a34359f 100644
--- a/server/auth.py
+++ b/server/auth.py
@@ -1,6 +1,8 @@
"""
-JWT 认证工具
+JWT 认证工具 + 密码哈希
"""
+import hashlib
+import secrets
from datetime import datetime, timedelta
from typing import Optional
@@ -17,12 +19,42 @@ from .models import User
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"""
expire = datetime.utcnow() + timedelta(days=settings.ACCESS_TOKEN_EXPIRE_DAYS)
payload = {
"sub": str(user_id),
- "client_code": client_code,
+ "username": username,
"exp": expire,
}
return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
diff --git a/server/models.py b/server/models.py
index 77de725..6fad8a1 100644
--- a/server/models.py
+++ b/server/models.py
@@ -18,17 +18,21 @@ def utcnow() -> datetime:
class User(Base):
"""
- 客户端用户
- 以机器硬件指纹(client_code)作为唯一标识
+ 系统用户
+ 以用户名(username)+ 密码哈希作为身份,与机器/指纹浏览器解耦
"""
__tablename__ = "users"
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)
- # JWT token 存储(服务端无状态校验,这里仅做记录)
+ # 最近一次登录的客户端设备指纹(仅作审计/展示,非身份标识)
+ client_code = Column(String(128), nullable=True)
+ # 账号是否启用
is_active = Column(Boolean, default=True, nullable=False)
# Boss直聘 账号标识(登录成功后回填,用于区分同一 Boss 账号)
boss_account = Column(String(128), nullable=True)
diff --git a/server/online.py b/server/online.py
new file mode 100644
index 0000000..2dd5eda
--- /dev/null
+++ b/server/online.py
@@ -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
diff --git a/server/routers/jobs.py b/server/routers/jobs.py
index 23152a8..7b1db02 100644
--- a/server/routers/jobs.py
+++ b/server/routers/jobs.py
@@ -10,6 +10,7 @@ from sqlalchemy import func
from ..auth import get_current_user
from ..database import get_db
from ..models import User, JobApplication
+from ..online import require_online_user
from ..schemas import ApplicationIn, ApplicationOut, Message, StatsOut
router = APIRouter(prefix="/api/jobs", tags=["投递记录"])
@@ -19,11 +20,11 @@ router = APIRouter(prefix="/api/jobs", tags=["投递记录"])
def report_application(
req: ApplicationIn,
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),
):
"""
- 客户端上报一条投递/跳过记录。
+ 客户端上报一条投递/跳过记录(前置校验:RPA 必须在线)。
同一用户 + 同一职位 ID 去重,已存在则更新。
"""
existing = db.query(JobApplication).filter(
diff --git a/server/routers/register.py b/server/routers/register.py
index 99b2b38..562d99d 100644
--- a/server/routers/register.py
+++ b/server/routers/register.py
@@ -1,59 +1,91 @@
"""
-客户端注册 / 登录状态 / 用户信息路由
+账号注册 / 登录 / 用户状态路由
"""
from datetime import datetime
from fastapi import APIRouter, Depends, HTTPException
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 ..models import User
+from ..online import is_online, touch, require_online_user
from ..schemas import (
- RegisterRequest, RegisterResponse, UserInfo, LoginStatusUpdate, Message,
+ RegisterRequest, LoginRequest, AuthResponse,
+ UserInfo, LoginStatusUpdate, Message,
)
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)):
- """
- 客户端注册/登录。
- 以机器硬件指纹 client_code 作为唯一标识:
- - 已存在 → 直接返回 token(视为登录)
- - 不存在 → 创建新用户
- """
- user = db.query(User).filter(User.client_code == req.client_code).first()
- is_new = user is None
+ """注册新账号(用户名 + 密码)"""
+ exists = db.query(User).filter(User.username == req.username).first()
+ if exists:
+ raise HTTPException(status_code=409, detail="用户名已存在")
- if is_new:
- user = User(client_code=req.client_code, nickname=req.nickname)
- db.add(user)
- db.commit()
- db.refresh(user)
+ user = User(
+ username=req.username,
+ password_hash=hash_password(req.password),
+ nickname=req.nickname,
+ )
+ db.add(user)
+ db.commit()
+ 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()
db.commit()
- token = create_access_token(user.id, user.client_code)
- return RegisterResponse(
- user_id=user.id,
- token=token,
- client_code=user.client_code,
- is_new=is_new,
- )
+ token = create_access_token(user.id, user.username)
+ return AuthResponse(user_id=user.id, username=user.username, token=token)
+
+
+@router.post("/heartbeat", response_model=Message)
+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)
-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(
id=current_user.id,
- client_code=current_user.client_code,
+ username=current_user.username,
nickname=current_user.nickname,
boss_account=current_user.boss_account,
login_status=current_user.login_status,
+ is_online=online,
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)
def update_login_status(
req: LoginStatusUpdate,
- current_user: User = Depends(get_current_user),
+ current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
- """更新 Boss直聘 登录状态"""
+ """更新 Boss直聘 登录状态(前置校验:RPA 必须在线)"""
valid_status = {"not_login", "logging_in", "logged_in"}
if req.login_status not in valid_status:
raise HTTPException(status_code=400, detail=f"登录状态必须是 {valid_status} 之一")
diff --git a/server/routers/resumes.py b/server/routers/resumes.py
index 7ccc6b6..e997d9e 100644
--- a/server/routers/resumes.py
+++ b/server/routers/resumes.py
@@ -7,6 +7,7 @@ from sqlalchemy.orm import Session
from ..auth import get_current_user
from ..database import get_db
from ..models import User, Resume
+from ..online import require_online_user
from ..schemas import ResumeIn, ResumeOut, ResumeBatchIn, Message
router = APIRouter(prefix="/api/resumes", tags=["简历管理"])
@@ -40,11 +41,11 @@ def get_primary_resume(
@router.post("/batch", response_model=list[ResumeOut])
def upload_resumes_batch(
req: ResumeBatchIn,
- current_user: User = Depends(get_current_user),
+ current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
"""
- 批量上传抓取到的简历。
+ 批量上传抓取到的简历(前置校验:RPA 必须在线)。
以 boss_resume_id 去重:存在则更新,不存在则新增。
第一份简历自动设为主简历(若当前没有主简历)。
"""
diff --git a/server/routers/sessions.py b/server/routers/sessions.py
index a5e0554..18e2493 100644
--- a/server/routers/sessions.py
+++ b/server/routers/sessions.py
@@ -8,6 +8,7 @@ from sqlalchemy.orm import Session
from ..auth import get_current_user
from ..database import get_db
from ..models import User, ApplySession
+from ..online import require_online_user
from ..schemas import SessionStartIn, SessionOut, SessionStatsIn, Message
router = APIRouter(prefix="/api/sessions", tags=["投递会话"])
@@ -16,10 +17,10 @@ router = APIRouter(prefix="/api/sessions", tags=["投递会话"])
@router.post("/start", response_model=SessionOut)
def start_session(
req: SessionStartIn,
- current_user: User = Depends(get_current_user),
+ current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
- """开始一次投递会话"""
+ """开始一次投递会话(前置校验:RPA 必须在线)"""
# 若已有进行中的会话,先结束它
running = db.query(ApplySession).filter(
ApplySession.user_id == current_user.id,
@@ -64,7 +65,11 @@ def stop_session(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
- """结束指定会话"""
+ """
+ 结束指定会话。
+ 特例:start 需在线前置校验,但 stop 是安全清理操作,故意豁免在线拦截——
+ 否则离线前遗留的 running 僵尸会话将永远无法关闭。
+ """
session = db.query(ApplySession).filter(
ApplySession.id == session_id,
ApplySession.user_id == current_user.id,
@@ -82,10 +87,10 @@ def stop_session(
def update_session_stats(
session_id: int,
req: SessionStatsIn,
- current_user: User = Depends(get_current_user),
+ current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
- """增量上报投递/跳过数量"""
+ """增量上报投递/跳过数量(前置校验:RPA 必须在线)"""
session = db.query(ApplySession).filter(
ApplySession.id == session_id,
ApplySession.user_id == current_user.id,
diff --git a/server/schemas.py b/server/schemas.py
index 1e0c0f7..37fae02 100644
--- a/server/schemas.py
+++ b/server/schemas.py
@@ -7,23 +7,30 @@ from pydantic import BaseModel, Field
# =======================================================
-# 认证相关
+# 认证相关(账号密码体系)
# =======================================================
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)
-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
+ username: str
token: str
- client_code: str
- is_new: bool # 是否为新注册用户
class TokenPayload(BaseModel):
sub: int # user_id
- client_code: str
+ username: str
# =======================================================
@@ -31,10 +38,11 @@ class TokenPayload(BaseModel):
# =======================================================
class UserInfo(BaseModel):
id: int
- client_code: str
+ username: str
nickname: Optional[str]
boss_account: Optional[str]
login_status: str
+ is_online: bool # RPA 客户端是否在线(心跳判定)
created_at: datetime
class Config: