466 lines
17 KiB
Python
466 lines
17 KiB
Python
"""账号管理路由"""
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from sqlalchemy import func, or_
|
|
from sqlalchemy.orm import Session, defer, joinedload
|
|
|
|
from ..database import get_db
|
|
from ..models import User, Account, AuditLog, LoginTask, DouyuTask
|
|
from ..schemas import AccountBulkSelection, AccountBulkTag, AccountImport, AccountAssign, AccountTag, AccountOut, BatchAssign
|
|
from ..deps import get_current_user, require_permission
|
|
from ..permissions import user_has_permission
|
|
from ..services.account_service import (
|
|
cookie_account_ids_query, parse_and_build_accounts,
|
|
)
|
|
|
|
router = APIRouter(prefix="/api/accounts", tags=["账号管理"])
|
|
|
|
|
|
def _visible_accounts_query(db: Session, current: User):
|
|
"""返回当前用户可见的斗鱼账号查询。"""
|
|
query = db.query(Account)
|
|
if user_has_permission(current, "account:view_all"):
|
|
return query
|
|
if user_has_permission(current, "account:view_assigned"):
|
|
return query.filter(Account.assigned_to == current.id)
|
|
raise HTTPException(status_code=403, detail="无权查看账号")
|
|
|
|
|
|
def _filter_accounts_query(
|
|
db: Session,
|
|
query,
|
|
current: User,
|
|
*,
|
|
assigned_only: bool = False,
|
|
tag: str | None = None,
|
|
has_cookie: bool = False,
|
|
search: str = "",
|
|
):
|
|
"""复用列表筛选条件，供分页列表和全量批量操作保持一致。"""
|
|
if has_cookie:
|
|
query = query.filter(Account.id.in_(cookie_account_ids_query(db)))
|
|
if assigned_only and user_has_permission(current, "account:view_all"):
|
|
query = query.filter(Account.assigned_to.isnot(None))
|
|
if tag:
|
|
query = query.filter(Account.tag == tag)
|
|
search_text = (search or "").strip()
|
|
if search_text:
|
|
pattern = f"%{search_text}%"
|
|
query = query.filter(or_(
|
|
Account.username.ilike(pattern),
|
|
Account.tag.ilike(pattern),
|
|
Account.remark.ilike(pattern),
|
|
))
|
|
return query
|
|
|
|
|
|
def _selected_account_ids(db: Session, current: User, req: AccountBulkSelection) -> list[int]:
|
|
"""解析批量操作目标：当前筛选全部或显式选择的 ID。"""
|
|
if req.all_matching:
|
|
rows = (
|
|
_filter_accounts_query(
|
|
db,
|
|
_visible_accounts_query(db, current),
|
|
current,
|
|
assigned_only=req.assigned_only,
|
|
tag=req.tag,
|
|
has_cookie=req.has_cookie,
|
|
search=req.search,
|
|
)
|
|
.with_entities(Account.id)
|
|
.order_by(None)
|
|
.all()
|
|
)
|
|
return [account_id for account_id, in rows]
|
|
|
|
seen = set()
|
|
ids = []
|
|
for account_id in req.account_ids:
|
|
if account_id not in seen:
|
|
seen.add(account_id)
|
|
ids.append(account_id)
|
|
if not ids:
|
|
return []
|
|
rows = (
|
|
_visible_accounts_query(db, current)
|
|
.filter(Account.id.in_(ids))
|
|
.with_entities(Account.id)
|
|
.order_by(None)
|
|
.all()
|
|
)
|
|
allowed = {account_id for account_id, in rows}
|
|
return [account_id for account_id in ids if account_id in allowed]
|
|
|
|
|
|
@router.get("")
|
|
def list_accounts(
|
|
assigned_only: bool = Query(False),
|
|
tag: str = Query(None),
|
|
has_cookie: bool = Query(False),
|
|
search: str = Query(""),
|
|
page: int | None = Query(None, ge=1),
|
|
page_size: int = Query(20, ge=1, le=200),
|
|
include_sensitive: bool = Query(True),
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(get_current_user),
|
|
):
|
|
"""列表：按角色返回不同字段和范围。"""
|
|
query = _filter_accounts_query(
|
|
db,
|
|
_visible_accounts_query(db, current),
|
|
current,
|
|
assigned_only=assigned_only,
|
|
tag=tag,
|
|
has_cookie=has_cookie,
|
|
search=search,
|
|
)
|
|
|
|
total = None
|
|
if page is not None:
|
|
total = query.order_by(None).count()
|
|
query = query.order_by(Account.id)
|
|
if page is not None:
|
|
query = query.offset((page - 1) * page_size).limit(page_size)
|
|
|
|
can_include_sensitive = include_sensitive and user_has_permission(current, "account:view_full")
|
|
options = [joinedload(Account.assigned_user)]
|
|
if not can_include_sensitive:
|
|
options.extend([
|
|
defer(Account.password),
|
|
defer(Account.email),
|
|
defer(Account.email_password),
|
|
])
|
|
accounts = query.options(*options).all()
|
|
result = []
|
|
for acc in accounts:
|
|
item = AccountOut(
|
|
id=acc.id, username=acc.username, remark=acc.remark or "",
|
|
tag=acc.tag or "",
|
|
assigned_to=acc.assigned_to,
|
|
assigned_username=acc.assigned_user.username if acc.assigned_user else None,
|
|
created_at=acc.created_at,
|
|
)
|
|
# 只有管理员可看完整字段（密码、邮箱等）
|
|
if can_include_sensitive:
|
|
item.password = acc.password
|
|
item.email = acc.email
|
|
item.email_password = acc.email_password
|
|
result.append(item)
|
|
if page is not None:
|
|
return {"items": result, "total": total or 0, "page": page, "page_size": page_size}
|
|
return result
|
|
|
|
|
|
@router.get("/summary")
|
|
def accounts_summary(
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(get_current_user),
|
|
):
|
|
"""账号管理统计，避免前端为了卡片统计拉全量账号。"""
|
|
query = db.query(Account)
|
|
if not user_has_permission(current, "account:view_all"):
|
|
if user_has_permission(current, "account:view_assigned"):
|
|
query = query.filter(Account.assigned_to == current.id)
|
|
else:
|
|
raise HTTPException(status_code=403, detail="无权查看账号")
|
|
|
|
total = query.count()
|
|
assigned_count = query.filter(Account.assigned_to.isnot(None)).count()
|
|
tag_count = (
|
|
query.filter(Account.tag != "", Account.tag.isnot(None))
|
|
.with_entities(Account.tag)
|
|
.distinct()
|
|
.count()
|
|
)
|
|
return {
|
|
"total": total,
|
|
"assigned_count": assigned_count,
|
|
"unassigned_count": max(0, total - assigned_count),
|
|
"tag_count": tag_count,
|
|
}
|
|
|
|
|
|
@router.post("/import")
|
|
def import_accounts(
|
|
req: AccountImport,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:import")),
|
|
):
|
|
"""批量导入账号。格式：用户名|密码|邮箱|邮箱密码|标签(可选)
|
|
|
|
req.tag 为统一标签兜底：某行未单独写标签时使用该值，行内标签优先。
|
|
库中已存在的用户名（大小写不敏感）与同批重复行会自动跳过。
|
|
"""
|
|
accounts, skipped, duplicated = parse_and_build_accounts(db, req.text, req.tag)
|
|
|
|
if accounts:
|
|
db.add_all(accounts)
|
|
db.add(AuditLog(user_id=current.id, username=current.username,
|
|
action="account:import", target=f"导入{len(accounts)}个"))
|
|
db.commit()
|
|
|
|
duplicated_note = f"，重复跳过 {duplicated} 个" if duplicated else ""
|
|
return {
|
|
"message": f"导入成功 {len(accounts)} 个，跳过 {skipped} 个{duplicated_note}",
|
|
"success": True,
|
|
"count": len(accounts),
|
|
}
|
|
|
|
|
|
@router.put("/{account_id}/assign")
|
|
def assign_account(
|
|
account_id: int,
|
|
req: AccountAssign,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:assign")),
|
|
):
|
|
acc = db.query(Account).filter(Account.id == account_id).first()
|
|
if not acc:
|
|
raise HTTPException(status_code=404, detail="账号不存在")
|
|
|
|
if req.assigned_to:
|
|
target = db.query(User).filter(User.id == req.assigned_to).first()
|
|
if not target:
|
|
raise HTTPException(status_code=404, detail="目标用户不存在")
|
|
if target.role != "support":
|
|
raise HTTPException(status_code=400, detail="只能分配给客服角色")
|
|
|
|
# 只能分配已成功登录过的账号（有cookie）
|
|
has_success = db.query(LoginTask).filter(
|
|
LoginTask.account_id == account_id,
|
|
LoginTask.status == 'success',
|
|
LoginTask.cookie != '',
|
|
).first()
|
|
if not has_success:
|
|
raise HTTPException(status_code=400, detail="该账号尚未成功登录，无法分配")
|
|
|
|
acc.assigned_to = req.assigned_to
|
|
db.add(AuditLog(user_id=current.id, username=current.username,
|
|
action="account:assign", target=acc.username))
|
|
db.commit()
|
|
return {"message": "已分配", "success": True}
|
|
|
|
|
|
@router.post("/batch-assign")
|
|
def batch_assign_accounts(
|
|
req: BatchAssign,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:assign")),
|
|
):
|
|
"""批量分配/取消分配账号给客服。"""
|
|
if not req.account_ids:
|
|
raise HTTPException(status_code=400, detail="请选择账号")
|
|
|
|
# 验证目标用户
|
|
if req.assigned_to is not None:
|
|
target = db.query(User).filter(User.id == req.assigned_to).first()
|
|
if not target:
|
|
raise HTTPException(status_code=404, detail="目标用户不存在")
|
|
if target.role != "support":
|
|
raise HTTPException(status_code=400, detail="只能分配给客服角色")
|
|
|
|
# 只能分配已成功登录过的账号（有cookie）
|
|
cookie_ids_query = cookie_account_ids_query(db).subquery()
|
|
invalid_ids = db.query(Account.id).filter(
|
|
Account.id.in_(req.account_ids),
|
|
Account.id.notin_(cookie_ids_query),
|
|
).all()
|
|
if invalid_ids:
|
|
names = db.query(Account.username).filter(Account.id.in_([i[0] for i in invalid_ids])).all()
|
|
name_list = ', '.join([n[0] for n in names[:5]])
|
|
suffix = '...' if len(invalid_ids) > 5 else ''
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"以下账号尚未成功登录，无法分配：{name_list}{suffix}",
|
|
)
|
|
|
|
count = db.query(Account).filter(Account.id.in_(req.account_ids)).update(
|
|
{Account.assigned_to: req.assigned_to}, synchronize_session=False
|
|
)
|
|
db.add(AuditLog(
|
|
user_id=current.id, username=current.username,
|
|
action="account:assign",
|
|
target=f"批量{'分配' if req.assigned_to else '取消分配'}{count}个账号"
|
|
))
|
|
db.commit()
|
|
action = "分配" if req.assigned_to else "取消分配"
|
|
return {"message": f"已批量{action} {count} 个账号", "success": True, "count": count}
|
|
|
|
|
|
@router.get("/assignments/summary")
|
|
def assignments_summary(
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:assign")),
|
|
):
|
|
"""分配概览：每个客服分配了多少账号（仅统计已成功登录的账号）。"""
|
|
cookie_subq = cookie_account_ids_query(db).subquery()
|
|
cookie_accounts = db.query(Account).filter(Account.id.in_(cookie_subq)).subquery()
|
|
|
|
results = (
|
|
db.query(User.id, User.username, func.count(cookie_accounts.c.id).label("count"))
|
|
.outerjoin(cookie_accounts, cookie_accounts.c.assigned_to == User.id)
|
|
.filter(User.role == "support")
|
|
.group_by(User.id, User.username)
|
|
.order_by(func.count(cookie_accounts.c.id).desc())
|
|
.all()
|
|
)
|
|
total_unassigned = (
|
|
db.query(func.count(cookie_accounts.c.id))
|
|
.filter(cookie_accounts.c.assigned_to.is_(None))
|
|
.scalar()
|
|
) or 0
|
|
return {
|
|
"support_users": [
|
|
{"id": uid, "username": uname, "assigned_count": cnt}
|
|
for uid, uname, cnt in results
|
|
],
|
|
"unassigned_count": total_unassigned,
|
|
}
|
|
|
|
|
|
@router.put("/{account_id}/tag")
|
|
def set_account_tag(
|
|
account_id: int,
|
|
req: AccountTag,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:import")),
|
|
):
|
|
"""设置单个账号标签。"""
|
|
acc = db.query(Account).filter(Account.id == account_id).first()
|
|
if not acc:
|
|
raise HTTPException(status_code=404, detail="账号不存在")
|
|
acc.tag = (req.tag or "").strip()
|
|
db.commit()
|
|
return {"message": "标签已更新", "success": True}
|
|
|
|
|
|
@router.put("/batch-tag")
|
|
def batch_tag(
|
|
req: AccountTag,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:import")),
|
|
):
|
|
"""批量设置账号标签。"""
|
|
if not req.account_ids:
|
|
raise HTTPException(status_code=400, detail="请选择账号")
|
|
tag = (req.tag or "").strip()
|
|
count = db.query(Account).filter(Account.id.in_(req.account_ids)).update(
|
|
{Account.tag: tag}, synchronize_session=False
|
|
)
|
|
db.commit()
|
|
return {"message": f"已为 {count} 个账号设置标签", "success": True}
|
|
|
|
|
|
@router.put("/batch-tag-selection")
|
|
def batch_tag_selection(
|
|
req: AccountBulkTag,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:import")),
|
|
):
|
|
"""按显式选择或当前筛选结果批量设置账号标签。"""
|
|
ids = _selected_account_ids(db, current, req)
|
|
if not ids:
|
|
raise HTTPException(status_code=400, detail="请选择账号")
|
|
tag = (req.tag_value or "").strip()
|
|
count = (
|
|
_visible_accounts_query(db, current)
|
|
.filter(Account.id.in_(ids))
|
|
.update({Account.tag: tag}, synchronize_session=False)
|
|
)
|
|
db.commit()
|
|
scope = "当前筛选下" if req.all_matching else "选中的"
|
|
return {"message": f"已为{scope} {count} 个账号设置标签", "success": True, "count": count}
|
|
|
|
|
|
@router.get("/tags/list")
|
|
def list_tags(
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(get_current_user),
|
|
):
|
|
"""获取当前用户可见账号的标签列表。"""
|
|
query = _visible_accounts_query(db, current)
|
|
tags = (
|
|
query.filter(Account.tag != "", Account.tag.isnot(None))
|
|
.with_entities(Account.tag)
|
|
.distinct()
|
|
.all()
|
|
)
|
|
return [t[0] for t in tags if t[0]]
|
|
|
|
|
|
@router.delete("/batch/delete")
|
|
def batch_delete_accounts(
|
|
account_ids: str = Query(..., description="逗号分隔的账号ID"),
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:delete")),
|
|
):
|
|
"""批量删除账号及其关联的登录任务。"""
|
|
if not account_ids:
|
|
raise HTTPException(status_code=400, detail="请指定账号ID")
|
|
|
|
ids = [int(x) for x in account_ids.split(",") if x.strip().isdigit()]
|
|
if not ids:
|
|
raise HTTPException(status_code=400, detail="无效的账号ID")
|
|
|
|
# 先删除关联的登录任务
|
|
db.query(LoginTask).filter(LoginTask.account_id.in_(ids)).delete(synchronize_session=False)
|
|
db.query(DouyuTask).filter(DouyuTask.account_id.in_(ids)).delete(synchronize_session=False)
|
|
|
|
# 删除账号
|
|
deleted = db.query(Account).filter(Account.id.in_(ids)).delete(synchronize_session=False)
|
|
|
|
db.add(AuditLog(
|
|
user_id=current.id, username=current.username,
|
|
action="account:delete", target=f"批量删除{deleted}个账号"
|
|
))
|
|
db.commit()
|
|
return {"message": f"已删除 {deleted} 个账号", "deleted": deleted, "success": True}
|
|
|
|
|
|
@router.post("/batch-delete")
|
|
def batch_delete_accounts_selection(
|
|
req: AccountBulkSelection,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:delete")),
|
|
):
|
|
"""按显式选择或当前筛选结果批量删除账号及其关联任务。"""
|
|
ids = _selected_account_ids(db, current, req)
|
|
if not ids:
|
|
raise HTTPException(status_code=400, detail="请选择账号")
|
|
|
|
db.query(LoginTask).filter(LoginTask.account_id.in_(ids)).delete(synchronize_session=False)
|
|
db.query(DouyuTask).filter(DouyuTask.account_id.in_(ids)).delete(synchronize_session=False)
|
|
deleted = (
|
|
_visible_accounts_query(db, current)
|
|
.filter(Account.id.in_(ids))
|
|
.delete(synchronize_session=False)
|
|
)
|
|
db.add(AuditLog(
|
|
user_id=current.id, username=current.username,
|
|
action="account:delete",
|
|
target=f"{'按筛选' if req.all_matching else '批量'}删除{deleted}个账号",
|
|
))
|
|
db.commit()
|
|
return {"message": f"已删除 {deleted} 个账号", "deleted": deleted, "success": True}
|
|
|
|
|
|
@router.delete("/{account_id}")
|
|
def delete_account(
|
|
account_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("account:delete")),
|
|
):
|
|
acc = db.query(Account).filter(Account.id == account_id).first()
|
|
if not acc:
|
|
raise HTTPException(status_code=404, detail="账号不存在")
|
|
|
|
# 先删除关联的登录任务，避免外键约束失败
|
|
db.query(LoginTask).filter(LoginTask.account_id == account_id).delete(synchronize_session=False)
|
|
db.query(DouyuTask).filter(DouyuTask.account_id == account_id).delete(synchronize_session=False)
|
|
|
|
db.add(AuditLog(user_id=current.id, username=current.username,
|
|
action="account:delete", target=acc.username))
|
|
db.delete(acc)
|
|
db.commit()
|
|
return {"message": "已删除", "success": True}
|