Avoid automatic allocation of accounts with active external collaboration, require explicit manual takeover of platform leases, and add Douyu account identity search.
780 lines
25 KiB
Python
780 lines
25 KiB
Python
"""斗鱼外部单协作接口。
|
|
|
|
页面只做参数校验、权限和异常翻译;业务规则见
|
|
``web/backend/services/douyu_collab_service.py``。
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
|
|
from fastapi import (
|
|
APIRouter,
|
|
Depends,
|
|
HTTPException,
|
|
Query,
|
|
WebSocket,
|
|
WebSocketDisconnect,
|
|
)
|
|
from sqlalchemy.orm import Session
|
|
|
|
from ..database import get_db
|
|
from ..deps import authenticate_websocket, get_current_user, require_permission
|
|
from ..errors import ApiError
|
|
from ..models import User
|
|
from ..permissions import get_user_permissions
|
|
from ..schemas import (
|
|
DouyuCollabAccountLookupOut,
|
|
DouyuCollabAccountLookupRequest,
|
|
DouyuCollabAccountRequest,
|
|
DouyuCollabArchiveRequest,
|
|
DouyuCollabCkExportOut,
|
|
DouyuCollabCkExportRequest,
|
|
DouyuCollabGiftCreate,
|
|
DouyuCollabGiftOut,
|
|
DouyuCollabGiftUpdate,
|
|
DouyuCollabGoodsOut,
|
|
DouyuCollabImagesRequest,
|
|
DouyuCollabMetricOut,
|
|
DouyuCollabOrderCreate,
|
|
DouyuCollabOrderListOut,
|
|
DouyuCollabOrderOut,
|
|
DouyuCollabOrderUpdate,
|
|
DouyuCollabOwnerOut,
|
|
DouyuCollabShopCreate,
|
|
DouyuCollabShopOut,
|
|
DouyuCollabShopUpdate,
|
|
DouyuCollabStatusBatchRequest,
|
|
DouyuCollabStatusRequest,
|
|
DouyuCollabSummaryOut,
|
|
DouyuCollabTimelineOut,
|
|
DouyuCollabUsernameExportOut,
|
|
DouyuCollabUsernameExportRequest,
|
|
)
|
|
from ..services import douyu_collab_service as collab
|
|
from ..services.douyu_collab_events import collab_events
|
|
|
|
router = APIRouter(prefix="/api/douyu", tags=["斗鱼外部单协作"])
|
|
|
|
|
|
def _http_error(exc: collab.CollabError) -> ApiError:
|
|
return ApiError(
|
|
status_code=exc.status_code,
|
|
detail=exc.detail,
|
|
error_code=exc.code or "douyu_collab_error",
|
|
)
|
|
|
|
|
|
def _one(db: Session, order) -> dict:
|
|
return collab.serialize_one(db, order)
|
|
|
|
|
|
def _shop_out(shop) -> dict:
|
|
return {
|
|
"id": int(shop.id),
|
|
"name": shop.name,
|
|
"sort_order": int(shop.sort_order or 0),
|
|
"is_active": bool(shop.is_active),
|
|
"remark": shop.remark or "",
|
|
"created_by": shop.created_by,
|
|
"updated_by": shop.updated_by,
|
|
"created_at": shop.created_at,
|
|
"updated_at": shop.updated_at,
|
|
}
|
|
|
|
|
|
def _gift_out(gift) -> dict:
|
|
return {
|
|
"id": int(gift.id),
|
|
"name": gift.name,
|
|
"points": int(gift.points or 0),
|
|
"sort_order": int(gift.sort_order or 0),
|
|
"is_active": bool(gift.is_active),
|
|
"remark": gift.remark or "",
|
|
"created_by": gift.created_by,
|
|
"updated_by": gift.updated_by,
|
|
"created_at": gift.created_at,
|
|
"updated_at": gift.updated_at,
|
|
}
|
|
|
|
|
|
def _publish_change(current: User, *, scope: str, action: str) -> None:
|
|
collab_events.publish(scope=scope, action=action, actor_id=int(current.id))
|
|
|
|
|
|
def _query_result_out(db: Session, result: dict) -> dict:
|
|
return {
|
|
"order": _one(db, result["order"]),
|
|
"metric": collab.serialize_metric(result["metric"]),
|
|
"scope": result["scope"],
|
|
"verdict": result["verdict"],
|
|
"message": result["message"],
|
|
"points_reason": result["points_reason"],
|
|
"fish_fin_balance": result["fish_fin_balance"],
|
|
"points_balance": result["points_balance"],
|
|
"required_total": result["required_total"],
|
|
"surplus": result["surplus"],
|
|
"errors": result["errors"],
|
|
}
|
|
|
|
|
|
@router.websocket("/external-orders/ws")
|
|
async def ws_external_orders(websocket: WebSocket):
|
|
"""协作台账实时失效通知:前端收到后按自己的筛选静默重拉。"""
|
|
user = authenticate_websocket(websocket)
|
|
if not user or "douyu:collab:view" not in get_user_permissions(user):
|
|
await websocket.close(code=1008, reason="未授权")
|
|
return
|
|
await websocket.accept()
|
|
queue = collab_events.subscribe()
|
|
try:
|
|
await websocket.send_json(collab_events.ready_event())
|
|
while True:
|
|
try:
|
|
event = await asyncio.wait_for(queue.get(), timeout=25)
|
|
await websocket.send_json(event)
|
|
except TimeoutError:
|
|
await websocket.send_json(collab_events.ping_event())
|
|
except (WebSocketDisconnect, RuntimeError):
|
|
pass
|
|
finally:
|
|
collab_events.unsubscribe(queue)
|
|
|
|
|
|
@router.get("/external-orders/summary", response_model=DouyuCollabSummaryOut)
|
|
def external_orders_summary(
|
|
include_void: bool = Query(False),
|
|
archive_scope: str = Query("active"),
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return collab.summary(db, include_void=include_void, archive_scope=archive_scope)
|
|
|
|
|
|
@router.get("/external-orders/owners", response_model=list[DouyuCollabOwnerOut])
|
|
def external_orders_owners(
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
rows = (
|
|
db.query(User.id, User.username)
|
|
.filter(User.is_active.is_(True))
|
|
.order_by(User.username)
|
|
.all()
|
|
)
|
|
return [
|
|
{"id": int(user_id), "username": str(username)} for user_id, username in rows
|
|
]
|
|
|
|
|
|
@router.get("/external-orders/shops", response_model=list[str])
|
|
def external_orders_shops(
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return [shop.name for shop in collab.list_shops(db, active_only=False)]
|
|
|
|
|
|
@router.get("/external-orders/gifts", response_model=list[str])
|
|
def external_orders_gifts(
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return collab.list_gift_names(db)
|
|
|
|
|
|
@router.get("/external-orders/goods", response_model=list[DouyuCollabGoodsOut])
|
|
def external_orders_goods(
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return collab.serialized_goods(db)
|
|
|
|
|
|
@router.post("/external-orders/goods/refresh")
|
|
def external_orders_goods_refresh(
|
|
account_id: int | None = Query(None),
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
result = collab.refresh_activity_goods(db, current, account_id=account_id)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="shops", action="goods.refresh")
|
|
return result
|
|
|
|
|
|
@router.post(
|
|
"/external-orders/accounts/lookup",
|
|
response_model=DouyuCollabAccountLookupOut,
|
|
)
|
|
def external_orders_account_lookup(
|
|
req: DouyuCollabAccountLookupRequest,
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
return collab.lookup_account(db, req.username, with_goods=req.with_goods)
|
|
|
|
|
|
@router.get("/external-orders", response_model=DouyuCollabOrderListOut)
|
|
def list_external_orders(
|
|
page: int = Query(1, ge=1),
|
|
page_size: int = Query(20, ge=1, le=200),
|
|
include_void: bool = Query(False),
|
|
archive_scope: str = Query("active"),
|
|
status: str = Query(""),
|
|
shop: str = Query(""),
|
|
owner_id: int | None = Query(None),
|
|
gift_name: str = Query(""),
|
|
keyword: str = Query(""),
|
|
ck_status: str = Query(""),
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return collab.list_orders(
|
|
db,
|
|
page=page,
|
|
page_size=page_size,
|
|
include_void=include_void,
|
|
archive_scope=archive_scope,
|
|
status=status,
|
|
shop=shop,
|
|
owner_id=owner_id,
|
|
gift_name=gift_name,
|
|
keyword=keyword,
|
|
ck_status=ck_status,
|
|
)
|
|
|
|
|
|
@router.post("/external-orders", response_model=DouyuCollabOrderOut)
|
|
def create_external_order(
|
|
req: DouyuCollabOrderCreate,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
order = collab.create_order(
|
|
db,
|
|
current,
|
|
order_no=req.order_no,
|
|
shop=req.shop,
|
|
owner_id=req.owner_id,
|
|
account_username=req.account_username,
|
|
gift_name=req.gift_name,
|
|
commodity_id=req.commodity_id,
|
|
required_points=req.required_points,
|
|
home_images=req.home_images,
|
|
remark=req.remark,
|
|
draft=req.draft,
|
|
require_verified=req.require_verified,
|
|
takeover_platform_lease=req.takeover_platform_lease,
|
|
)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="orders", action="order.create")
|
|
return _one(db, order)
|
|
|
|
|
|
@router.get("/external-orders/{order_id}", response_model=DouyuCollabOrderOut)
|
|
def get_external_order(
|
|
order_id: int,
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
try:
|
|
return _one(db, collab.get_order(db, order_id))
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.put("/external-orders/{order_id}", response_model=DouyuCollabOrderOut)
|
|
def update_external_order(
|
|
order_id: int,
|
|
req: DouyuCollabOrderUpdate,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
collab.update_order(
|
|
db,
|
|
current,
|
|
order,
|
|
req.model_dump(exclude_unset=True),
|
|
expected_version=req.expected_version,
|
|
takeover_platform_lease=req.takeover_platform_lease,
|
|
)
|
|
_publish_change(current, scope="orders", action="order.update")
|
|
return _one(db, order)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/{order_id}/account", response_model=DouyuCollabOrderOut)
|
|
def set_external_order_account(
|
|
order_id: int,
|
|
req: DouyuCollabAccountRequest,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
collab.set_account(
|
|
db,
|
|
current,
|
|
order,
|
|
req.account_username,
|
|
expected_version=req.expected_version,
|
|
takeover_platform_lease=req.takeover_platform_lease,
|
|
)
|
|
_publish_change(current, scope="orders", action="order.account")
|
|
return _one(db, order)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/{order_id}/verify")
|
|
def verify_external_order(
|
|
order_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
result = collab.verify_order(db, current, order)
|
|
_publish_change(current, scope="orders", action="order.verify")
|
|
return {"order": _one(db, result["order"]), "probe": result["probe"]}
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/verify/batch")
|
|
def verify_external_orders_batch(
|
|
ids: list[int],
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
results: list[dict] = []
|
|
for order_id in ids:
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
result = collab.verify_order(db, current, order)
|
|
probe = result["probe"]
|
|
results.append(
|
|
{
|
|
"id": order_id,
|
|
"success": True,
|
|
"ck_status": probe.get("ck_status"),
|
|
"role": probe.get("bind_game_role"),
|
|
}
|
|
)
|
|
except Exception as exc: # noqa: BLE001 - 批量逐行隔离
|
|
db.rollback()
|
|
results.append({"id": order_id, "success": False, "message": str(exc)})
|
|
if any(item["success"] for item in results):
|
|
_publish_change(current, scope="orders", action="order.verify_batch")
|
|
return {"results": results, "success": all(item["success"] for item in results)}
|
|
|
|
|
|
@router.post("/external-orders/ck/export", response_model=DouyuCollabCkExportOut)
|
|
def export_external_orders_ck(
|
|
req: DouyuCollabCkExportRequest,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:ck_export")),
|
|
):
|
|
"""勾选多行导出关联内部账号的 CK 明文(前端写剪贴板)。
|
|
|
|
斗鱼协作单不存 CK,导出的始终是关联账号的实时 ``cookie``。逐行写审计,
|
|
但审计里只记单号/账号/CK 状态,不把 CK 本体写进审计。
|
|
"""
|
|
try:
|
|
return collab.export_cks(db, current, req.ids)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post(
|
|
"/external-orders/{order_id}/ck/copy",
|
|
response_model=DouyuCollabCkExportOut,
|
|
)
|
|
def copy_external_order_ck(
|
|
order_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(get_current_user),
|
|
):
|
|
"""复制单行 CK 明文(仅超级管理员;与虎牙协作台账口径一致)。"""
|
|
if current.role != "super_admin":
|
|
raise HTTPException(status_code=403, detail="仅超级管理员可复制 CK")
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
return collab.export_cks(db, current, [order.id])
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post(
|
|
"/external-orders/usernames/export",
|
|
response_model=DouyuCollabUsernameExportOut,
|
|
)
|
|
def export_external_order_usernames(
|
|
req: DouyuCollabUsernameExportRequest,
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
"""勾选多行导出关联的斗鱼用户名(前端写剪贴板)。
|
|
|
|
用户名不是凭据;能看列表的人本来就能看到,因此只需要查看权限。
|
|
"""
|
|
try:
|
|
return collab.export_usernames(db, req.ids)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/{order_id}/activity/query")
|
|
def query_external_order_activity(
|
|
order_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
result = collab.query_activity(db, current, order, source="manual")
|
|
_publish_change(current, scope="orders", action="order.activity")
|
|
return _query_result_out(db, result)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/{order_id}/balances/query")
|
|
def query_external_order_balances(
|
|
order_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
"""只刷新鱼翅和手册积分,不查兑换记录、不判定、不改状态。"""
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
result = collab.query_activity(
|
|
db,
|
|
current,
|
|
order,
|
|
source="balance_manual",
|
|
include_records=False,
|
|
)
|
|
_publish_change(current, scope="orders", action="order.balances")
|
|
return _query_result_out(db, result)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/{order_id}/status", response_model=DouyuCollabOrderOut)
|
|
def set_external_order_status(
|
|
order_id: int,
|
|
req: DouyuCollabStatusRequest,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
collab.set_status(
|
|
db,
|
|
current,
|
|
order,
|
|
status=req.status,
|
|
reason=req.reason,
|
|
rollback=req.rollback,
|
|
expected_version=req.expected_version,
|
|
)
|
|
_publish_change(current, scope="orders", action="order.status")
|
|
return _one(db, order)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/status/batch")
|
|
def set_external_order_status_batch(
|
|
req: DouyuCollabStatusBatchRequest,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
results: list[dict] = []
|
|
for order_id in req.ids:
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
collab.set_status(
|
|
db,
|
|
current,
|
|
order,
|
|
status=req.status,
|
|
reason=req.reason,
|
|
rollback=req.rollback,
|
|
)
|
|
results.append({"id": order_id, "success": True})
|
|
except Exception as exc: # noqa: BLE001 - 批量逐行隔离
|
|
db.rollback()
|
|
results.append({"id": order_id, "success": False, "message": str(exc)})
|
|
if any(item["success"] for item in results):
|
|
_publish_change(current, scope="orders", action="order.status_batch")
|
|
return {"results": results, "success": all(item["success"] for item in results)}
|
|
|
|
|
|
@router.post("/external-orders/balances/query")
|
|
def query_external_orders_balances(
|
|
ids: list[int],
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
"""批量刷新鱼翅和手册积分,不查兑换记录、不判定、不改状态。"""
|
|
results: list[dict] = []
|
|
for order_id in ids:
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
result = collab.query_activity(
|
|
db,
|
|
current,
|
|
order,
|
|
source="balance_batch",
|
|
include_records=False,
|
|
)
|
|
results.append(
|
|
{
|
|
"id": order_id,
|
|
"success": True,
|
|
"message": result["message"],
|
|
"fish_fin_balance": result["fish_fin_balance"],
|
|
"points_balance": result["points_balance"],
|
|
"points_reason": result["points_reason"],
|
|
}
|
|
)
|
|
except Exception as exc: # noqa: BLE001
|
|
db.rollback()
|
|
results.append({"id": order_id, "success": False, "message": str(exc)})
|
|
if any(item["success"] for item in results):
|
|
_publish_change(current, scope="orders", action="order.balances_batch")
|
|
return {"results": results, "success": all(item["success"] for item in results)}
|
|
|
|
|
|
@router.post("/external-orders/activity/query")
|
|
def query_external_orders_activity(
|
|
ids: list[int],
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
results: list[dict] = []
|
|
for order_id in ids:
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
result = collab.query_activity(db, current, order, source="batch")
|
|
results.append(
|
|
{
|
|
"id": order_id,
|
|
"success": True,
|
|
"verdict": result["verdict"],
|
|
"message": result["message"],
|
|
}
|
|
)
|
|
except Exception as exc: # noqa: BLE001
|
|
db.rollback()
|
|
results.append({"id": order_id, "success": False, "message": str(exc)})
|
|
if any(item["success"] for item in results):
|
|
_publish_change(current, scope="orders", action="order.activity_batch")
|
|
return {"results": results, "success": all(item["success"] for item in results)}
|
|
|
|
|
|
@router.post("/external-orders/{order_id}/images", response_model=DouyuCollabOrderOut)
|
|
def update_external_order_images(
|
|
order_id: int,
|
|
req: DouyuCollabImagesRequest,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
order = collab.get_order(db, order_id)
|
|
collab.update_order(
|
|
db,
|
|
current,
|
|
order,
|
|
{"home_images": req.home_images},
|
|
expected_version=req.expected_version,
|
|
)
|
|
_publish_change(current, scope="orders", action="order.images")
|
|
return _one(db, order)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.post("/external-orders/archive")
|
|
def archive_external_orders(
|
|
req: DouyuCollabArchiveRequest,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
result = collab.archive_orders(db, current, req.ids, reason=req.reason)
|
|
if result.get("archived"):
|
|
_publish_change(current, scope="orders", action="order.archive")
|
|
return result
|
|
|
|
|
|
@router.post("/external-orders/unarchive")
|
|
def unarchive_external_orders(
|
|
ids: list[int],
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
result = collab.unarchive_orders(db, current, ids)
|
|
if result.get("unarchived"):
|
|
_publish_change(current, scope="orders", action="order.unarchive")
|
|
return result
|
|
|
|
|
|
@router.get(
|
|
"/external-orders/{order_id}/timeline",
|
|
response_model=list[DouyuCollabTimelineOut],
|
|
)
|
|
def external_order_timeline(
|
|
order_id: int,
|
|
limit: int = Query(100, ge=1, le=500),
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return collab.order_timeline(db, order_id, limit=limit)
|
|
|
|
|
|
@router.get(
|
|
"/external-orders/{order_id}/metrics",
|
|
response_model=list[DouyuCollabMetricOut],
|
|
)
|
|
def external_order_metrics(
|
|
order_id: int,
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return collab.order_metrics(db, order_id)
|
|
|
|
|
|
@router.delete("/external-orders/{order_id}")
|
|
def delete_external_order(
|
|
order_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:manage")),
|
|
):
|
|
try:
|
|
result = collab.delete_order(db, current, collab.get_order(db, order_id))
|
|
_publish_change(current, scope="orders", action="order.delete")
|
|
return result
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
|
|
|
|
@router.get("/collab-shops", response_model=list[DouyuCollabShopOut])
|
|
def list_collab_shops(
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
rows = collab.list_shops(db)
|
|
return [_shop_out(shop) for shop in rows]
|
|
|
|
|
|
@router.post("/collab-shops", response_model=DouyuCollabShopOut)
|
|
def create_collab_shop(
|
|
req: DouyuCollabShopCreate,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
shop = collab.create_shop(db, current, name=req.name, remark=req.remark)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="shops", action="shop.create")
|
|
return _shop_out(shop)
|
|
|
|
|
|
@router.put("/collab-shops/{shop_id}", response_model=DouyuCollabShopOut)
|
|
def update_collab_shop(
|
|
shop_id: int,
|
|
req: DouyuCollabShopUpdate,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:edit")),
|
|
):
|
|
try:
|
|
shop = collab.get_shop(db, shop_id)
|
|
collab.update_shop(db, current, shop, req.model_dump(exclude_unset=True))
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="shops", action="shop.update")
|
|
return _shop_out(shop)
|
|
|
|
|
|
@router.delete("/collab-shops/{shop_id}")
|
|
def delete_collab_shop(
|
|
shop_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:manage")),
|
|
):
|
|
try:
|
|
result = collab.delete_shop(db, current, collab.get_shop(db, shop_id))
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="shops", action="shop.delete")
|
|
return {**result, "id": shop_id}
|
|
|
|
|
|
@router.get("/collab-gifts", response_model=list[DouyuCollabGiftOut])
|
|
def list_collab_gifts(
|
|
db: Session = Depends(get_db),
|
|
_current: User = Depends(require_permission("douyu:collab:view")),
|
|
):
|
|
return [_gift_out(gift) for gift in collab.list_gifts(db)]
|
|
|
|
|
|
@router.post("/collab-gifts", response_model=DouyuCollabGiftOut)
|
|
def create_collab_gift(
|
|
req: DouyuCollabGiftCreate,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:manage")),
|
|
):
|
|
try:
|
|
gift = collab.create_gift(
|
|
db,
|
|
current,
|
|
name=req.name,
|
|
points=req.points,
|
|
remark=req.remark,
|
|
)
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="gifts", action="gift.create")
|
|
return _gift_out(gift)
|
|
|
|
|
|
@router.put("/collab-gifts/{gift_id}", response_model=DouyuCollabGiftOut)
|
|
def update_collab_gift(
|
|
gift_id: int,
|
|
req: DouyuCollabGiftUpdate,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:manage")),
|
|
):
|
|
try:
|
|
gift = collab.get_gift(db, gift_id)
|
|
collab.update_gift(db, current, gift, req.model_dump(exclude_unset=True))
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="gifts", action="gift.update")
|
|
return _gift_out(gift)
|
|
|
|
|
|
@router.delete("/collab-gifts/{gift_id}")
|
|
def delete_collab_gift(
|
|
gift_id: int,
|
|
db: Session = Depends(get_db),
|
|
current: User = Depends(require_permission("douyu:collab:manage")),
|
|
):
|
|
try:
|
|
result = collab.delete_gift(db, current, collab.get_gift(db, gift_id))
|
|
except collab.CollabError as exc:
|
|
raise _http_error(exc) from exc
|
|
_publish_change(current, scope="gifts", action="gift.delete")
|
|
return {**result, "id": gift_id}
|