386 lines
16 KiB
Python
386 lines
16 KiB
Python
"""
|
||
客户端 → 云端服务端 API 封装
|
||
统一管理 token 持久化与请求头
|
||
"""
|
||
import os
|
||
import time
|
||
import requests
|
||
from loguru import logger
|
||
|
||
from .config import client_settings
|
||
from .fingerprint import generate_client_code
|
||
|
||
|
||
class ServerAPI:
|
||
"""调用云端 FastAPI 服务端"""
|
||
|
||
def __init__(self):
|
||
self.base_url = client_settings.SERVER_URL.rstrip("/")
|
||
self.token: str | None = None
|
||
self.user_id: int | None = None
|
||
self.username: str | None = None
|
||
self._load_token()
|
||
|
||
# ------------------------------------------------------------------
|
||
# Token 持久化
|
||
# ------------------------------------------------------------------
|
||
def _token_path(self) -> str:
|
||
path = client_settings.TOKEN_FILE
|
||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||
return path
|
||
|
||
def _load_token(self) -> None:
|
||
path = self._token_path()
|
||
if os.path.exists(path):
|
||
try:
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
lines = f.read().strip().splitlines()
|
||
if lines:
|
||
self.token = lines[0]
|
||
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")
|
||
except Exception as e:
|
||
logger.warning(f"读取 token 失败:{e}")
|
||
|
||
def _save_token(self) -> None:
|
||
with open(self._token_path(), "w", encoding="utf-8") as f:
|
||
f.write(f"{self.token}\n{self.user_id}\n{self.username or ''}")
|
||
|
||
def _headers(self) -> dict:
|
||
return {"Authorization": f"Bearer {self.token}"} if self.token else {}
|
||
|
||
def _req(self, method: str, url: str, retries: int = 5, **kwargs) -> requests.Response:
|
||
"""云端请求统一入口:网络层异常重试(默认 5 次、每次间隔 1 秒),仍失败才抛出。
|
||
仅重试连接类异常(RequestException 发生在请求阶段);
|
||
HTTP 状态码错误由调用方 raise_for_status 抛出,不重试。
|
||
AI 代理类长调用可传小 retries,避免重试放大等待。"""
|
||
last: Exception | None = None
|
||
for i in range(retries):
|
||
try:
|
||
return requests.request(method, url, **kwargs)
|
||
except requests.RequestException as e:
|
||
last = e
|
||
logger.warning(f"云端请求失败({i + 1}/{retries}),1 秒后重试:"
|
||
f"{method.upper()} {url}:{e}")
|
||
time.sleep(1)
|
||
raise last
|
||
|
||
# ------------------------------------------------------------------
|
||
# 认证(账号密码体系)
|
||
# ------------------------------------------------------------------
|
||
def register(self, username: str, password: str, nickname: str | None = None) -> dict:
|
||
"""注册新账号,返回并保存 token"""
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/auth/register",
|
||
json={"username": username, "password": password, "nickname": nickname},
|
||
timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return self._store_auth(resp.json())
|
||
|
||
def login(self, username: str, password: str) -> dict:
|
||
"""账号密码登录,返回并保存 token"""
|
||
resp = self._req("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.user_id = data["user_id"]
|
||
self.username = data.get("username")
|
||
self._save_token()
|
||
logger.info(f"认证成功,user_id={self.user_id},username={self.username}")
|
||
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:
|
||
resp = self._req("get", f"{self.base_url}/api/auth/me", headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def heartbeat(self, payload: dict | None = None) -> bool:
|
||
"""发送心跳并携带 RPA 全量状态;失败返回 False(不抛异常)"""
|
||
if not self.token:
|
||
return False
|
||
try:
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/auth/heartbeat",
|
||
json=payload or {},
|
||
headers=self._headers(), timeout=10,
|
||
)
|
||
return resp.status_code == 200
|
||
except Exception as e:
|
||
logger.debug(f"心跳发送失败:{e}")
|
||
return False
|
||
|
||
def fetch_pending_task(self) -> dict | None:
|
||
"""轮询拉取待执行的远程控制任务(服务端已标记 running)"""
|
||
resp = self._req("get", f"{self.base_url}/api/rpa/tasks/pending",
|
||
headers=self._headers(), timeout=10)
|
||
resp.raise_for_status()
|
||
return resp.json().get("task")
|
||
|
||
def finish_task(self, task_id: int, status: str, result: str = "") -> None:
|
||
"""远程任务执行完回调:更新终态与结果"""
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/rpa/tasks/{task_id}/finish",
|
||
json={"status": status, "result": result[:500]},
|
||
headers=self._headers(), timeout=10)
|
||
resp.raise_for_status()
|
||
|
||
def update_login_status(self, status: str, boss_account: str | None = None) -> dict:
|
||
payload = {"login_status": status}
|
||
if boss_account:
|
||
payload["boss_account"] = boss_account
|
||
resp = self._req("put",
|
||
f"{self.base_url}/api/auth/login-status",
|
||
json=payload, headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
# ------------------------------------------------------------------
|
||
# 简历
|
||
# ------------------------------------------------------------------
|
||
def upload_resumes(self, resumes: list[dict]) -> list[dict]:
|
||
"""批量上传简历"""
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/resumes/batch",
|
||
json={"resumes": resumes}, headers=self._headers(), timeout=30,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def list_resumes(self) -> list[dict]:
|
||
resp = self._req("get", f"{self.base_url}/api/resumes", headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def get_primary_resume(self) -> dict | None:
|
||
resp = self._req("get", f"{self.base_url}/api/resumes/primary", headers=self._headers(), timeout=15)
|
||
if resp.status_code == 404:
|
||
return None
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def set_primary_resume(self, resume_id: int) -> dict:
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/resumes/{resume_id}/set-primary",
|
||
headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def update_resume(self, resume_id: int, data: dict) -> dict:
|
||
"""编辑简历(标题/求职意向/正文)"""
|
||
resp = self._req("put",
|
||
f"{self.base_url}/api/resumes/{resume_id}",
|
||
json=data, headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def delete_resume(self, resume_id: int) -> dict:
|
||
resp = self._req("delete",
|
||
f"{self.base_url}/api/resumes/{resume_id}",
|
||
headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
# ------------------------------------------------------------------
|
||
# 投递会话
|
||
# ------------------------------------------------------------------
|
||
def start_session(self, keywords: str, city: str,
|
||
salary_min: int | None, salary_max: int | None,
|
||
prompt: str | None = None) -> dict:
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/sessions/start",
|
||
json={
|
||
"keywords": keywords,
|
||
"city": city,
|
||
"salary_min": salary_min,
|
||
"salary_max": salary_max,
|
||
"prompt": prompt,
|
||
},
|
||
headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def stop_session(self, session_id: int) -> dict:
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/sessions/{session_id}/stop",
|
||
headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def update_session_stats(self, session_id: int, applied_delta: int, skipped_delta: int) -> dict:
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/sessions/{session_id}/stats",
|
||
json={"applied_delta": applied_delta, "skipped_delta": skipped_delta},
|
||
headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
# ------------------------------------------------------------------
|
||
# 投递记录
|
||
# ------------------------------------------------------------------
|
||
def report_application(self, session_id: int | None, data: dict) -> dict:
|
||
params = {"session_id": session_id} if session_id else {}
|
||
resp = self._req("post",
|
||
f"{self.base_url}/api/jobs/report",
|
||
json=data, params=params, headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def check_applied(self, job_id: str) -> bool:
|
||
resp = self._req("get",
|
||
f"{self.base_url}/api/jobs/check/{job_id}",
|
||
headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json().get("applied", False)
|
||
|
||
def list_blacklist(self) -> list[str]:
|
||
"""公司黑名单名单(公司名列表,拉黑后不再投递该公司)。
|
||
接口分页返回,这里翻页拉全(黑名单用于投递前过滤,必须拿到全量)"""
|
||
companies: list[str] = []
|
||
page = 1
|
||
while True:
|
||
resp = self._req("get", f"{self.base_url}/api/blacklist",
|
||
params={"page": page, "page_size": 100},
|
||
headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
data = resp.json()
|
||
companies.extend(i["company"] for i in data.get("items", []))
|
||
if page >= data.get("pages", 1) or page >= 10:
|
||
break
|
||
page += 1
|
||
return companies
|
||
|
||
# ------------------------------------------------------------------
|
||
# 投递条件模板
|
||
# ------------------------------------------------------------------
|
||
def list_templates(self) -> list[dict]:
|
||
resp = self._req("get", f"{self.base_url}/api/templates",
|
||
headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def create_template(self, data: dict) -> dict:
|
||
resp = self._req("post", f"{self.base_url}/api/templates",
|
||
json=data, headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def update_template(self, template_id: int, data: dict) -> dict:
|
||
resp = self._req("put", f"{self.base_url}/api/templates/{template_id}",
|
||
json=data, headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def delete_template(self, template_id: int) -> dict:
|
||
resp = self._req("delete", f"{self.base_url}/api/templates/{template_id}",
|
||
headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def get_stats(self) -> dict:
|
||
resp = self._req("get", f"{self.base_url}/api/jobs/stats", headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
# ------------------------------------------------------------------
|
||
# AI 代理(模型配置在服务端,客户端不持有任何密钥)
|
||
# ------------------------------------------------------------------
|
||
def start_ai_score(self, payload: dict) -> dict:
|
||
"""开始打分任务(异步)。payload 含 request_key 幂等键,
|
||
网络重试不会导致服务端重复调用大模型"""
|
||
resp = self._req("post", f"{self.base_url}/api/ai/score/start",
|
||
json=payload, headers=self._headers(),
|
||
timeout=30, retries=2)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def get_ai_score_result(self, request_key: str) -> dict:
|
||
"""轮询打分结果:{status: pending/running/success/failed, score, reason}"""
|
||
resp = self._req("get", f"{self.base_url}/api/ai/score/result/{request_key}",
|
||
headers=self._headers(), timeout=15, retries=2)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def clean_resume_via_server(self, raw_text: str) -> str:
|
||
"""经服务端 AI 代理整理简历内容(低频同步,超时对齐服务端 5 分钟阶梯)"""
|
||
resp = self._req("post", f"{self.base_url}/api/ai/clean-resume",
|
||
json={"raw_text": raw_text}, headers=self._headers(),
|
||
timeout=330, retries=1)
|
||
resp.raise_for_status()
|
||
return resp.json().get("content") or raw_text
|
||
|
||
def today_applied_count(self) -> int:
|
||
"""当天(北京时间)实际投递数量"""
|
||
resp = self._req("get", f"{self.base_url}/api/jobs/today-count", headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return int(resp.json().get("count", 0))
|
||
|
||
def get_history(self, limit: int = 50, apply_type: str | None = None) -> list[dict]:
|
||
params = {"limit": limit}
|
||
if apply_type:
|
||
params["apply_type"] = apply_type
|
||
resp = self._req("get",
|
||
f"{self.base_url}/api/jobs/history",
|
||
params=params, headers=self._headers(), timeout=15,
|
||
)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
def get_history_page(self, page: int = 1, page_size: int = 20,
|
||
apply_type: str | None = None,
|
||
start: str | None = None, end: str | None = None) -> dict:
|
||
"""投递记录分页筛选(北京时间范围 + 投递结果,时间倒序)"""
|
||
params: dict = {"page": page, "page_size": page_size}
|
||
if apply_type:
|
||
params["apply_type"] = apply_type
|
||
if start:
|
||
params["start"] = start
|
||
if end:
|
||
params["end"] = end
|
||
resp = self._req("get", f"{self.base_url}/api/jobs/page",
|
||
params=params, headers=self._headers(), timeout=15)
|
||
resp.raise_for_status()
|
||
return resp.json()
|
||
|
||
# ------------------------------------------------------------------
|
||
# 连通性
|
||
# ------------------------------------------------------------------
|
||
def ping(self) -> bool:
|
||
try:
|
||
resp = requests.get(f"{self.base_url}/", timeout=5)
|
||
return resp.status_code == 200
|
||
except Exception:
|
||
return False
|