滑块验证
参数已自动填充，点击「开始验证」将提交到第三方滑块服务。
"""
@app.get("/auth/slider-form", response_class=HTMLResponse)
async def slider_form(
key: str = Query(..., description="Key（提交到第三方滑块）"),
data62: str = Query("", description="Data62"),
ticket: str = Query(..., description="Original Ticket"),
):
"""返回带 Key/Data62/Original Ticket 预填的表单页，提交到第三方 7765，供 iframe 加载并自动填充。"""
return HTMLResponse(content=_slider_form_html(key, data62, ticket))
# ---------- R1-2 客户画像 / R1-3 定时问候 / R1-4 分群推送 / 消息与发送 ----------
class CustomerCreate(BaseModel):
key: str
wxid: str
remark_name: Optional[str] = ""
region: Optional[str] = ""
age: Optional[str] = ""
gender: Optional[str] = ""
level: Optional[str] = "" # 拿货等级
tags: Optional[List[str]] = None
class GreetingTaskCreate(BaseModel):
key: str
name: str
send_time: str # ISO 格式触发时间，如 2026-03-11T14:30:00，必须为未来时间
customer_tags: Optional[List[str]] = None
template: str
use_qwen: Optional[bool] = False
class ProductTagCreate(BaseModel):
key: str
name: str
class PushGroupCreate(BaseModel):
key: str
name: str
customer_ids: Optional[List[str]] = None
tag_ids: Optional[List[str]] = None
class PushTaskCreate(BaseModel):
key: str
product_tag_id: str
group_id: str
content: str
send_at: Optional[str] = None
class SendMessageBody(BaseModel):
key: str
to_user_name: str
content: str
class QwenGenerateBody(BaseModel):
prompt: str
system: Optional[str] = None
@app.get("/api/customers")
async def api_list_customers(key: str = Query(..., description="账号 key")):
return {"items": store.list_customers(key)}
@app.post("/api/customers")
async def api_upsert_customer(body: CustomerCreate):
row = store.upsert_customer(
body.key, body.wxid,
remark_name=body.remark_name or "",
region=body.region or "",
age=body.age or "",
gender=body.gender or "",
level=body.level or "",
tags=body.tags,
)
return row
@app.get("/api/customers/{customer_id}")
async def api_get_customer(customer_id: str):
row = store.get_customer(customer_id)
if not row:
raise HTTPException(status_code=404, detail="customer not found")
return row
@app.get("/api/customer-tags")
async def api_list_customer_tags(key: str = Query(..., description="账号 key")):
"""返回该 key 下客户档案中出现的所有标签，供定时任务等下拉选择。"""
return {"tags": store.list_customer_tags(key)}
@app.delete("/api/customers/{customer_id}")
async def api_delete_customer(customer_id: str):
if not store.delete_customer(customer_id):
raise HTTPException(status_code=404, detail="customer not found")
return {"ok": True}
@app.get("/api/greeting-tasks")
async def api_list_greeting_tasks(key: str = Query(..., description="账号 key")):
return {"items": store.list_greeting_tasks(key)}
def _parse_send_time(s: str) -> Optional[datetime]:
"""解析 ISO 时间字符串，返回 datetime（无时区）。"""
try:
if "T" in s:
return datetime.fromisoformat(s.replace("Z", "+00:00")[:19])
return datetime.strptime(s[:19], "%Y-%m-%d %H:%M:%S")
except Exception:
return None
@app.post("/api/greeting-tasks")
async def api_create_greeting_task(body: GreetingTaskCreate):
dt = _parse_send_time(body.send_time)
if not dt:
raise HTTPException(status_code=400, detail="触发时间格式无效，请使用 日期+时分秒 选择器")
if dt <= datetime.now():
raise HTTPException(status_code=400, detail="触发时间必须是未来时间，请重新选择")
row = store.create_greeting_task(
body.key, body.name, body.send_time,
customer_tags=body.customer_tags or [],
template=body.template,
use_qwen=body.use_qwen or False,
)
return row
@app.patch("/api/greeting-tasks/{task_id}")
async def api_update_greeting_task(task_id: str, body: dict):
if "send_time" in body:
dt = _parse_send_time(body["send_time"])
if not dt:
raise HTTPException(status_code=400, detail="触发时间格式无效")
if dt <= datetime.now():
raise HTTPException(status_code=400, detail="触发时间必须是未来时间")
row = store.update_greeting_task(task_id, **{k: v for k, v in body.items() if k in ("name", "send_time", "customer_tags", "template", "use_qwen", "enabled")})
if not row:
raise HTTPException(status_code=404, detail="task not found")
return row
@app.delete("/api/greeting-tasks/{task_id}")
async def api_delete_greeting_task(task_id: str):
if not store.delete_greeting_task(task_id):
raise HTTPException(status_code=404, detail="task not found")
return {"ok": True}
@app.get("/api/product-tags")
async def api_list_product_tags(key: str = Query(..., description="账号 key")):
return {"items": store.list_product_tags(key)}
@app.post("/api/product-tags")
async def api_create_product_tag(body: ProductTagCreate):
return store.create_product_tag(body.key, body.name)
@app.delete("/api/product-tags/{tag_id}")
async def api_delete_product_tag(tag_id: str):
if not store.delete_product_tag(tag_id):
raise HTTPException(status_code=404, detail="tag not found")
return {"ok": True}
@app.get("/api/push-groups")
async def api_list_push_groups(key: str = Query(..., description="账号 key")):
return {"items": store.list_push_groups(key)}
@app.post("/api/push-groups")
async def api_create_push_group(body: PushGroupCreate):
return store.create_push_group(body.key, body.name, body.customer_ids or [], body.tag_ids or [])
@app.patch("/api/push-groups/{group_id}")
async def api_update_push_group(group_id: str, body: dict):
row = store.update_push_group(
group_id,
name=body.get("name"),
customer_ids=body.get("customer_ids"),
tag_ids=body.get("tag_ids"),
)
if not row:
raise HTTPException(status_code=404, detail="group not found")
return row
@app.delete("/api/push-groups/{group_id}")
async def api_delete_push_group(group_id: str):
if not store.delete_push_group(group_id):
raise HTTPException(status_code=404, detail="group not found")
return {"ok": True}
@app.get("/api/push-tasks")
async def api_list_push_tasks(key: str = Query(..., description="账号 key"), limit: int = Query(100, le=500)):
return {"items": store.list_push_tasks(key, limit=limit)}
@app.post("/api/push-tasks")
async def api_create_push_task(body: PushTaskCreate):
return store.create_push_task(body.key, body.product_tag_id, body.group_id, body.content, body.send_at)
@app.get("/api/messages")
async def api_list_messages(key: str = Query(..., description="账号 key"), limit: int = Query(100, le=500)):
return {"items": store.list_sync_messages(key, limit=limit)}
async def _send_message_upstream(key: str, to_user_name: str, content: str) -> dict:
"""调用上游发送文本消息；成功时写入发出记录并返回响应，失败抛 HTTPException。"""
url = f"{WECHAT_UPSTREAM_BASE_URL.rstrip('/')}{SEND_MSG_PATH}"
payload = {"MsgItem": [{"ToUserName": to_user_name, "MsgType": 1, "TextContent": content}]}
async with httpx.AsyncClient(timeout=15.0) as client:
resp = await client.post(url, params={"key": key}, json=payload)
if resp.status_code >= 400:
body_preview = resp.text[:400] if resp.text else ""
logger.warning("Send message upstream %s: %s", resp.status_code, body_preview)
raise HTTPException(
status_code=502,
detail=f"upstream_returned_{resp.status_code}: {body_preview}",
)
store.append_sent_message(key, to_user_name, content)
try:
return resp.json()
except Exception:
return {"ok": True, "raw": resp.text[:500]}
@app.post("/api/send-message")
async def api_send_message(body: SendMessageBody):
try:
return await _send_message_upstream(body.key, body.to_user_name, body.content)
except HTTPException:
raise
except Exception as exc:
logger.exception("Send message upstream error: %s", exc)
raise HTTPException(status_code=502, detail=f"upstream_error: {exc}") from exc
# ---------- 模型管理（多模型切换，API Key 按模型配置） ----------
class ModelCreate(BaseModel):
name: str
provider: str # qwen | openai
api_key: str
base_url: Optional[str] = ""
model_name: Optional[str] = ""
is_current: Optional[bool] = False
class ModelUpdate(BaseModel):
name: Optional[str] = None
api_key: Optional[str] = None
base_url: Optional[str] = None
model_name: Optional[str] = None
def _mask_api_key(m: dict) -> dict:
if not m or not isinstance(m, dict):
return m
out = dict(m)
if out.get("api_key"):
out["api_key"] = "***"
return out
@app.get("/api/models")
async def api_list_models():
return {"items": [_mask_api_key(m) for m in store.list_models()]}
@app.get("/api/models/current")
async def api_get_current_model():
m = store.get_current_model()
if not m:
return {"current": None}
return {"current": _mask_api_key(m)}
@app.post("/api/models")
async def api_create_model(body: ModelCreate):
if body.provider not in ("qwen", "openai", "doubao"):
raise HTTPException(status_code=400, detail="provider must be qwen, openai or doubao")
row = store.create_model(
name=body.name,
provider=body.provider,
api_key=body.api_key,
base_url=body.base_url or "",
model_name=body.model_name or "",
is_current=body.is_current or False,
)
return _mask_api_key(row)
@app.patch("/api/models/{model_id}")
async def api_update_model(model_id: str, body: ModelUpdate):
row = store.update_model(
model_id,
name=body.name,
api_key=body.api_key,
base_url=body.base_url,
model_name=body.model_name,
)
if not row:
raise HTTPException(status_code=404, detail="model not found")
return _mask_api_key(row)
@app.post("/api/models/{model_id}/set-current")
async def api_set_current_model(model_id: str):
row = store.set_current_model(model_id)
if not row:
raise HTTPException(status_code=404, detail="model not found")
return _mask_api_key(row)
@app.delete("/api/models/{model_id}")
async def api_delete_model(model_id: str):
if not store.delete_model(model_id):
raise HTTPException(status_code=404, detail="model not found")
return {"ok": True}
@app.post("/api/qwen/generate")
async def api_qwen_generate(body: QwenGenerateBody):
"""所有对话生成由当前选中的模型接管，不再使用环境变量兜底。"""
messages = []
if body.system:
messages.append({"role": "system", "content": body.system})
messages.append({"role": "user", "content": body.prompt})
text = await llm_chat(messages)
if text is None:
raise HTTPException(status_code=503, detail="请在「模型管理」页添加并选中模型、填写 API Key")
return {"text": text}
@app.post("/api/qwen/generate-greeting")
async def api_qwen_generate_greeting(
remark_name: str = Query(...),
region: str = Query(""),
tags: Optional[str] = Query(None),
):
"""问候语生成由当前选中的模型接管。"""
tag_list = [t.strip() for t in (tags or "").split(",") if t.strip()]
user = f"请生成一句简短的微信问候语（1-2句话），客户备注名：{remark_name}"
if region:
user += f"，地区：{region}"
if tag_list:
user += f"，标签：{','.join(tag_list)}"
user += "。不要解释，只输出问候语本身。"
text = await llm_chat([{"role": "user", "content": user}])
if text is None:
raise HTTPException(status_code=503, detail="请在「模型管理」页添加并选中模型、填写 API Key")
return {"text": text}
class LogoutBody(BaseModel):
key: str
@app.post("/auth/logout")
async def logout(body: LogoutBody):
key = body.key
if not key:
raise HTTPException(status_code=400, detail="key is required")
url = f"{WECHAT_UPSTREAM_BASE_URL}/login/LogOut"
logger.info("LogOut: key=%s, url=%s", key, url)
try:
async with httpx.AsyncClient(timeout=15.0) as client:
resp = await client.get(url, params={"key": key})
except Exception as exc:
logger.exception("Error calling upstream LogOut: %s", exc)
raise HTTPException(status_code=502, detail=f"upstream_error: {exc}") from exc
body_text = resp.text[:500]
logger.info(
"Upstream LogOut response: status=%s, body=%s",
resp.status_code,
body_text,
)
return resp.json()