首个可运行的版本

backend/app/routers/__init__.py

@@ -0,0 +1 @@
+"""路由包"""

backend/app/routers/admin.py

@@ -0,0 +1,130 @@
+"""管理后台路由"""
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_admin_user
+from app.schemas.admin import (
+    AdminLoginRequest, AdminLoginResponse, DashboardStats,
+    UserBanRequest, SystemConfigUpdate,
+)
+from app.services.admin_service import AdminService
+from app.services.message_service import MessageService
+
+router = APIRouter()
+
+
+@router.post("/login", response_model=AdminLoginResponse)
+async def admin_login(
+    req: AdminLoginRequest,
+    db: AsyncSession = Depends(get_db),
+):
+    """管理员登录（仅密码）"""
+    service = AdminService(db)
+    token = await service.login(req.password)
+    if not token:
+        raise HTTPException(status_code=401, detail="管理员密码错误")
+    return AdminLoginResponse(access_token=token)
+
+
+@router.get("/dashboard", response_model=DashboardStats)
+async def admin_dashboard(
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """仪表盘统计数据"""
+    service = AdminService(db)
+    return await service.get_dashboard_stats()
+
+
+@router.get("/stats/{metric}")
+async def admin_stats(
+    metric: str,
+    days: int = Query(7, ge=1, le=90),
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取趋势数据 (online/messages/registrations)"""
+    if metric not in ("online", "messages", "registrations"):
+        raise HTTPException(status_code=400, detail="无效的指标类型")
+    service = AdminService(db)
+    return await service.get_trend_data(metric, days)
+
+
+@router.get("/users")
+async def admin_users(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    search: str | None = Query(None),
+    status: str | None = Query(None),
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """用户管理列表"""
+    service = AdminService(db)
+    return await service.get_users_list(page, page_size, search, status)
+
+
+@router.put("/users/{user_id}/ban")
+async def admin_ban_user(
+    user_id: str,
+    req: UserBanRequest,
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """封禁/解封用户"""
+    service = AdminService(db)
+    try:
+        await service.ban_user(user_id, req.is_banned, req.reason)
+        return {"success": True}
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.delete("/users/{user_id}")
+async def admin_delete_user(
+    user_id: str,
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """删除用户"""
+    service = AdminService(db)
+    await service.delete_user(user_id)
+    return {"success": True}
+
+
+@router.get("/messages")
+async def admin_messages(
+    user_id: str | None = Query(None),
+    conversation_id: str | None = Query(None),
+    keyword: str | None = Query(None),
+    date_from: str | None = Query(None),
+    date_to: str | None = Query(None),
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """搜索消息（管理审查）"""
+    service = MessageService(db)
+    return await service.search_messages(user_id, conversation_id, keyword, date_from, date_to)
+
+
+@router.get("/config")
+async def admin_get_config(
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取系统配置"""
+    service = AdminService(db)
+    return await service.get_all_configs()
+
+
+@router.put("/config")
+async def admin_update_config(
+    req: SystemConfigUpdate,
+    _=Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """更新系统配置"""
+    service = AdminService(db)
+    await service.update_configs(req.configs)
+    return {"success": True}

backend/app/routers/auth.py

@@ -0,0 +1,56 @@
+"""认证路由"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db
+from app.schemas.auth import RegisterRequest, LoginRequest, TokenResponse, RefreshRequest
+from app.services.auth_service import AuthService
+from app.utils.security import decode_refresh_token
+
+router = APIRouter()
+
+
+@router.post("/register", response_model=TokenResponse)
+async def register(req: RegisterRequest, db: AsyncSession = Depends(get_db)):
+    """用户注册"""
+    service = AuthService(db)
+    try:
+        result = await service.register(req.username, req.email, req.password)
+        return TokenResponse(
+            access_token=result["access_token"],
+            refresh_token=result["refresh_token"],
+            user=result["user"],
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/login", response_model=TokenResponse)
+async def login(req: LoginRequest, db: AsyncSession = Depends(get_db)):
+    """用户登录"""
+    service = AuthService(db)
+    try:
+        result = await service.login(req.username, req.password)
+        return TokenResponse(
+            access_token=result["access_token"],
+            refresh_token=result["refresh_token"],
+            user=result["user"],
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=401, detail=str(e))
+
+
+@router.post("/refresh", response_model=dict)
+async def refresh_token(req: RefreshRequest, db: AsyncSession = Depends(get_db)):
+    """刷新 Token"""
+    payload = decode_refresh_token(req.refresh_token)
+    if not payload:
+        raise HTTPException(status_code=401, detail="无效的 Refresh Token")
+
+    service = AuthService(db)
+    try:
+        result = await service.refresh_token(payload.get("sub"))
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=401, detail=str(e))

backend/app/routers/conversations.py

@@ -0,0 +1,67 @@
+"""会话路由"""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user
+from app.models.user import User
+from app.schemas.conversation import ConversationCreate, ConversationRead, ConversationDetail, GroupCreate
+from app.services.conversation_service import ConversationService
+
+router = APIRouter()
+
+
+@router.get("/", response_model=list[dict])
+async def list_conversations(
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取会话列表"""
+    service = ConversationService(db)
+    return await service.get_user_conversations(user.id)
+
+
+@router.post("/", response_model=dict)
+async def create_conversation(
+    req: ConversationCreate,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """创建会话（私聊或群聊）"""
+    service = ConversationService(db)
+    if req.type == "private":
+        if len(req.member_ids) != 1:
+            raise HTTPException(status_code=400, detail="私聊只能选择一个用户")
+        conv = await service.get_or_create_private(user.id, req.member_ids[0])
+    else:
+        conv = await service.create_group(user.id, req.name or "群聊", req.member_ids)
+
+    detail = await service.get_conversation_detail(conv.id, user.id)
+    return detail
+
+
+@router.post("/group", response_model=dict)
+async def create_group(
+    req: GroupCreate,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """创建群聊"""
+    service = ConversationService(db)
+    conv = await service.create_group(user.id, req.name, req.member_ids, req.description)
+    detail = await service.get_conversation_detail(conv.id, user.id)
+    return detail
+
+
+@router.get("/{conversation_id}", response_model=dict)
+async def get_conversation(
+    conversation_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取会话详情"""
+    service = ConversationService(db)
+    detail = await service.get_conversation_detail(conversation_id, user.id)
+    if not detail:
+        raise HTTPException(status_code=404, detail="会话不存在或无权访问")
+    return detail

backend/app/routers/friends.py

@@ -0,0 +1,88 @@
+"""好友路由"""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user
+from app.models.user import User
+from app.schemas.friend import FriendRequestCreate, FriendRead, FriendRequestRead
+from app.services.friend_service import FriendService
+
+router = APIRouter()
+
+
+@router.get("/", response_model=list[dict])
+async def list_friends(
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取好友列表"""
+    service = FriendService(db)
+    return await service.get_friends(user.id)
+
+
+@router.get("/requests", response_model=list[dict])
+async def list_requests(
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取待处理的好友请求"""
+    service = FriendService(db)
+    return await service.get_pending_requests(user.id)
+
+
+@router.post("/request")
+async def send_friend_request(
+    req: FriendRequestCreate,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """发送好友请求"""
+    service = FriendService(db)
+    try:
+        await service.send_request(user.id, req.to_user_id, req.message)
+        return {"success": True, "message": "好友请求已发送"}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.put("/request/{request_id}/accept")
+async def accept_friend_request(
+    request_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """接受好友请求"""
+    service = FriendService(db)
+    try:
+        await service.accept_request(request_id, user.id)
+        return {"success": True, "message": "已添加好友"}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.put("/request/{request_id}/reject")
+async def reject_friend_request(
+    request_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """拒绝好友请求"""
+    service = FriendService(db)
+    try:
+        await service.reject_request(request_id, user.id)
+        return {"success": True, "message": "已拒绝"}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/{friend_id}")
+async def remove_friend(
+    friend_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """删除好友"""
+    service = FriendService(db)
+    await service.remove_friend(user.id, friend_id)
+    return {"success": True, "message": "已删除好友"}

backend/app/routers/messages.py

@@ -0,0 +1,56 @@
+"""消息路由"""
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user
+from app.models.user import User
+from app.schemas.message import MessageSend, MessagePage, MarkReadRequest
+from app.services.message_service import MessageService
+
+router = APIRouter()
+
+
+@router.get("/{conversation_id}/messages", response_model=dict)
+async def get_messages(
+    conversation_id: str,
+    before: str | None = Query(None),
+    limit: int = Query(50, ge=1, le=100),
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取消息列表（游标分页）"""
+    service = MessageService(db)
+    try:
+        return await service.get_messages(conversation_id, user.id, before, limit)
+    except ValueError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+
+
+@router.put("/{conversation_id}/messages/{message_id}/read")
+async def mark_as_read(
+    conversation_id: str,
+    message_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """标记消息已读"""
+    service = MessageService(db)
+    await service.mark_as_read(conversation_id, user.id, message_id)
+    return {"success": True}
+
+
+@router.delete("/{conversation_id}/messages/{message_id}")
+async def delete_message(
+    conversation_id: str,
+    message_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """删除消息"""
+    service = MessageService(db)
+    try:
+        await service.soft_delete(message_id, user.id)
+        return {"success": True}
+    except ValueError as e:
+        raise HTTPException(status_code=403, detail=str(e))

backend/app/routers/uploads.py

@@ -0,0 +1,63 @@
+"""文件上传路由"""
+
+import os
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from app.config import settings
+from app.dependencies import get_current_user
+from app.models.user import User
+
+router = APIRouter()
+
+
+@router.post("/avatar")
+async def upload_avatar(
+    file: UploadFile = File(...),
+    user: User = Depends(get_current_user),
+):
+    """上传头像"""
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="只能上传图片文件")
+
+    # 检查文件大小
+    contents = await file.read()
+    max_size = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
+    if len(contents) > max_size:
+        raise HTTPException(status_code=400, detail=f"文件大小超过 {settings.MAX_UPLOAD_SIZE_MB}MB")
+
+    # 保存文件
+    ext = os.path.splitext(file.filename or "image.jpg")[1]
+    filename = f"avatar_{user.id}{ext}"
+    filepath = os.path.join(settings.UPLOAD_DIR, filename)
+
+    with open(filepath, "wb") as f:
+        f.write(contents)
+
+    return {"url": f"/uploads/{filename}"}
+
+
+@router.post("/file")
+async def upload_file(
+    file: UploadFile = File(...),
+    user: User = Depends(get_current_user),
+):
+    """上传文件（聊天中使用）"""
+    contents = await file.read()
+    max_size = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
+    if len(contents) > max_size:
+        raise HTTPException(status_code=400, detail=f"文件大小超过 {settings.MAX_UPLOAD_SIZE_MB}MB")
+
+    ext = os.path.splitext(file.filename or "file")[1]
+    filename = f"{uuid.uuid4().hex}{ext}"
+    filepath = os.path.join(settings.UPLOAD_DIR, filename)
+
+    with open(filepath, "wb") as f:
+        f.write(contents)
+
+    return {
+        "url": f"/uploads/{filename}",
+        "filename": file.filename,
+        "size": len(contents),
+        "content_type": file.content_type,
+    }

backend/app/routers/users.py

@@ -0,0 +1,54 @@
+"""用户路由"""
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user
+from app.models.user import User
+from app.schemas.user import UserRead, UserProfile, UserUpdate, UserSearchResult
+from app.services.user_service import UserService
+
+router = APIRouter()
+
+
+@router.get("/me", response_model=UserRead)
+async def get_me(user: User = Depends(get_current_user)):
+    """获取当前用户信息"""
+    return user
+
+
+@router.put("/me", response_model=UserRead)
+async def update_me(
+    req: UserUpdate,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """更新当前用户信息"""
+    service = UserService(db)
+    updated = await service.update_profile(user.id, **req.model_dump(exclude_none=True))
+    return updated
+
+
+@router.get("/search", response_model=list[UserSearchResult])
+async def search_users(
+    q: str = Query(..., min_length=1),
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """搜索用户"""
+    service = UserService(db)
+    users = await service.search_users(q, user.id)
+    return users
+
+
+@router.get("/{user_id}", response_model=UserProfile)
+async def get_user(
+    user_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    """获取用户公开信息"""
+    service = UserService(db)
+    user = await service.get_by_id(user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="用户不存在")
+    return user