1、后台/teams需要可以设置管理人，后台只给这个管理人分配积分，然后前台管理员自己分配积分

2、前台判断用户是管理人，左下角显示团队管理
3、团队管理可以看到团队的人员、分配人员积分、人员的积分情况的功能
4、团队管理还可以邀请用户，比如生成个链接，未注册需要注册绑定团队，已注册用户访问弹窗是否加入这个团队，然后都需要管理同意才可以加入团队

video-gen-api/app/api/admin/team.py

@@ -2,18 +2,57 @@ from __future__ import annotations
 
 import json
 
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Body, Depends, Query
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.dependencies import get_admin_user, get_db
+from app.models.team import Team
 from app.models.user import User
 from app.schemas.team import TeamCreate, TeamListOut, TeamOptionOut, TeamOut, TeamUpdate
+from app.schemas.team_manager import SetManagerRequest
 from app.services.operation_log import log_operation
+from app.services.team_manager_service import set_team_manager
 from app.services.team_service import create_team, list_team_options, list_teams, soft_delete_team, update_team
 
 router = APIRouter(prefix="/admin/teams", tags=["admin-teams"])
 
 
+async def _team_detail_payload(db: AsyncSession, team: Team) -> dict:
+    """构造返回团队详情，包含 manager_name。"""
+    payload = {
+        "id": team.id,
+        "name": team.name,
+        "code": getattr(team, "code", None),
+        "description": getattr(team, "description", None),
+        "status": getattr(team, "status", "active"),
+        "sort_order": getattr(team, "sort_order", 0) or 0,
+        "member_count": 0,
+        "created_at": team.created_at,
+        "updated_at": team.updated_at,
+        "manager_id": getattr(team, "manager_id", None),
+        "manager_name": None,
+    }
+    # 查询成员数和管理人用户名
+    from sqlalchemy import func
+    from app.enums.user import UserType
+    member_count = (await db.execute(
+        select(func.count(User.id)).where(
+            User.user_type == UserType.FRONTEND.value,
+            User.team_id == team.id,
+        )
+    )).scalar() or 0
+    payload["member_count"] = int(member_count)
+
+    if getattr(team, "manager_id", None):
+        mgr = await db.execute(
+            select(User.username).where(User.id == team.manager_id).limit(1)
+        )
+        payload["manager_name"] = mgr.scalar_one_or_none()
+
+    return payload
+
+
 @router.get("", response_model=TeamListOut)
 async def list_admin_teams(
     page: int = Query(1, ge=1),
@@ -51,17 +90,7 @@ async def create_admin_team(
         "/admin/teams",
         detail=json.dumps({"after": req.model_dump()}, ensure_ascii=False),
     )
-    return {
-        "id": team.id,
-        "name": team.name,
-        "code": team.code,
-        "description": team.description,
-        "status": team.status,
-        "sort_order": team.sort_order,
-        "member_count": 0,
-        "created_at": team.created_at,
-        "updated_at": team.updated_at,
-    }
+    return await _team_detail_payload(db, team)
 
 
 @router.put("/{team_id}", response_model=TeamOut)
@@ -81,17 +110,33 @@ async def update_admin_team(
         f"/admin/teams/{team_id}",
         detail=json.dumps({"before": before, "after": after}, ensure_ascii=False),
     )
-    return {
-        "id": team.id,
-        "name": team.name,
-        "code": team.code,
-        "description": team.description,
-        "status": team.status,
-        "sort_order": team.sort_order,
-        "member_count": 0,
-        "created_at": team.created_at,
-        "updated_at": team.updated_at,
-    }
+    return await _team_detail_payload(db, team)
+
+
+@router.put("/{team_id}/manager", response_model=TeamOut)
+async def set_team_manager_endpoint(
+    team_id: str,
+    req: SetManagerRequest = Body(...),
+    admin: User = Depends(get_admin_user),
+    db: AsyncSession = Depends(get_db),
+):
+    team = await set_team_manager(db, team_id, req.user_id)
+    manager_name = None
+    if team.manager_id:
+        mgr = await db.execute(
+            select(User.username).where(User.id == team.manager_id).limit(1)
+        )
+        manager_name = mgr.scalar_one_or_none()
+    await log_operation(
+        db,
+        admin.id,
+        admin.username,
+        f"设置团队管理人 {team.name}: {manager_name or '取消'}",
+        "PUT",
+        f"/admin/teams/{team_id}/manager",
+        detail=json.dumps({"manager_id": req.user_id}, ensure_ascii=False),
+    )
+    return await _team_detail_payload(db, team)
 
 
 @router.delete("/{team_id}")

video-gen-api/app/api/v1/__init__.py

@@ -28,6 +28,7 @@ from app.api.v1.material_consumption import router as material_consumption_route
 from app.api.v1.open_type import router as open_type_router
 from app.api.v1.resources_material import router as resources_material_router
 from app.api.v1.contact import router as contact_router
+from app.api.v1.team import router as team_router
 from app.api.v1.home_materials import router as home_materials_router
 from app.api.admin import router as admin_module_router
 
@@ -60,5 +61,6 @@ api_router.include_router(material_consumption_router)
 api_router.include_router(open_type_router)
 api_router.include_router(resources_material_router)
 api_router.include_router(contact_router)
+api_router.include_router(team_router)
 api_router.include_router(home_materials_router)
 api_router.include_router(admin_module_router)

video-gen-api/app/api/v1/auth.py

@@ -256,8 +256,23 @@ async def get_me(
     current_user.username = "用户"+current_user.username[-4:] if current_user.username == current_user.phone else current_user.username
     current_user.credits = round(current_user.credits, 2)
     resource_capacity = await get_user_resource_capacity_usage(db, current_user.id)
+
+    # 计算 is_team_manager 和 team_name
+    is_team_manager = False
+    team_name = None
+    if current_user.team_id:
+        from app.services.team_manager_service import is_team_manager, batch_get_team_name_map
+        is_team_manager = await is_team_manager(db, current_user.id, current_user.team_id)
+        name_map = await batch_get_team_name_map(db, [current_user.team_id])
+        team_name = name_map.get(current_user.team_id)
+
     return UserOut.model_validate(current_user).model_copy(
-        update={"resource_capacity": resource_capacity}
+        update={
+            "resource_capacity": resource_capacity,
+            "is_team_manager": is_team_manager,
+            "team_id": current_user.team_id,
+            "team_name": team_name,
+        }
     )
 
 

video-gen-api/app/api/v1/team.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.dependencies import get_current_user, get_db
+from app.models.team import Team
+from app.models.team_invitation import TeamInvitation
+from app.models.team_join_request import TeamJoinRequest
+from app.models.user import User
+from app.schemas.team_invitation import TeamInvitationCreate, TeamInvitationOut
+from app.schemas.team_join_request import (
+    JoinByCodeRequest,
+    JoinRequestHandle,
+    JoinRequestOut,
+    JoinTeamInfoOut,
+)
+from app.schemas.team_manager import (
+    ManagedTeamOut,
+    ManagerTransferRequest,
+    SetManagerRequest,
+    TeamMemberOut,
+)
+from app.services import team_invitation_service
+from app.services.team_manager_service import (
+    get_managed_team,
+    get_team_members,
+    is_team_manager,
+    transfer_credits_to_member,
+)
+
+router = APIRouter(prefix="/team", tags=["team"])
+
+
+def _build_invite_link(code: str) -> str:
+    base = getattr(settings, "FRONTEND_URL", "") or getattr(settings, "BASE_URL", "")
+    return f"{base}/join-team?code={code}"
+
+
+# ── 获取当前用户管理的团队 ──────────────────────────────
+@router.get("/managed", response_model=ManagedTeamOut)
+async def get_managed_team_info(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    team = await get_managed_team(db, current_user.id)
+    if not team:
+        raise HTTPException(status_code=404, detail="您不是任何团队的管理人")
+
+    from sqlalchemy import func
+    from app.enums.user import UserType
+    member_count = (await db.execute(
+        select(func.count(User.id)).where(
+            User.user_type == UserType.FRONTEND.value,
+            User.team_id == team.id,
+        )
+    )).scalar() or 0
+
+    return {
+        "id": team.id,
+        "name": team.name,
+        "code": team.code,
+        "description": team.description,
+        "status": team.status,
+        "member_count": int(member_count),
+        "manager_id": team.manager_id,
+        "manager_name": current_user.username,
+    }
+
+
+# ── 团队成员列表 ──────────────────────────────────────
+@router.get("/members")
+async def list_team_members(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    team = await get_managed_team(db, current_user.id)
+    if not team:
+        raise HTTPException(status_code=403, detail="只有团队管理人可查看")
+    return await get_team_members(db, team.id, page=page, page_size=page_size)
+
+
+# ── 转账积分给成员 ────────────────────────────────────
+@router.post("/members/{member_id}/credits")
+async def transfer_credits(
+    member_id: str,
+    req: ManagerTransferRequest,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    await transfer_credits_to_member(
+        db,
+        current_user.id,
+        req.target_user_id,
+        req.amount,
+        req.description,
+    )
+    return {"message": "ok"}
+
+
+# ── 邀请码管理 ────────────────────────────────────────
+@router.post("/invitations", response_model=TeamInvitationOut)
+async def create_invitation(
+    req: TeamInvitationCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    team = await get_managed_team(db, current_user.id)
+    if not team:
+        raise HTTPException(status_code=403, detail="只有团队管理人可创建邀请码")
+
+    expires_at = None
+    if req.expires_at:
+        try:
+            expires_at = datetime.fromisoformat(req.expires_at)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="过期时间格式错误")
+
+    invitation = await team_invitation_service.create_invitation(
+        db, team.id, current_user.id, req.max_uses, expires_at
+    )
+    return {
+        "id": invitation.id,
+        "team_id": invitation.team_id,
+        "code": invitation.code,
+        "status": invitation.status,
+        "max_uses": invitation.max_uses,
+        "use_count": invitation.use_count,
+        "expires_at": invitation.expires_at,
+        "invite_link": _build_invite_link(invitation.code),
+        "created_at": invitation.created_at,
+    }
+
+
+@router.get("/invitations", response_model=list[TeamInvitationOut])
+async def list_invitations(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    team = await get_managed_team(db, current_user.id)
+    if not team:
+        raise HTTPException(status_code=403, detail="只有团队管理人可查看")
+    invitations = await team_invitation_service.get_invitations_for_team(db, team.id)
+    return [
+        {
+            "id": inv.id,
+            "team_id": inv.team_id,
+            "code": inv.code,
+            "status": inv.status,
+            "max_uses": inv.max_uses,
+            "use_count": inv.use_count,
+            "expires_at": inv.expires_at,
+            "invite_link": _build_invite_link(inv.code),
+            "created_at": inv.created_at,
+        }
+        for inv in invitations
+    ]
+
+
+@router.delete("/invitations/{invitation_id}")
+async def revoke_invitation(
+    invitation_id: str,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    await team_invitation_service.revoke_invitation(db, invitation_id, current_user.id)
+    return {"message": "ok"}
+
+
+# ── 加入申请 ──────────────────────────────────────────
+@router.post("/join")
+async def join_by_code(
+    req: JoinByCodeRequest,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    await team_invitation_service.create_join_request(db, current_user.id, req.invitation_code)
+    return {"message": "申请已提交，请等待团队管理人审批"}
+
+
+@router.get("/join-info", response_model=JoinTeamInfoOut)
+async def get_join_info(
+    code: str = Query(...),
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """验证邀请码并返回团队信息（用于加入页面展示）。"""
+    invitation = await team_invitation_service.get_invitation_by_code(db, code)
+    if not invitation:
+        return JoinTeamInfoOut(team_name="", team_id="", valid=False)
+
+    team = await db.execute(
+        select(Team.name).where(Team.id == invitation.team_id, Team.deleted_at.is_(None)).limit(1)
+    )
+    team_name = team.scalar_one_or_none() or ""
+
+    already_in_team = current_user.team_id == invitation.team_id
+
+    return JoinTeamInfoOut(
+        team_name=team_name,
+        team_id=invitation.team_id,
+        valid=True,
+        already_in_team=already_in_team,
+    )
+
+
+@router.get("/join-requests", response_model=list[JoinRequestOut])
+async def list_join_requests(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    team = await get_managed_team(db, current_user.id)
+    if not team:
+        raise HTTPException(status_code=403, detail="只有团队管理人可查看")
+    requests = await team_invitation_service.get_pending_requests(db, team.id)
+
+    # 获取团队名
+    team_name_result = await db.execute(
+        select(Team.name).where(Team.id == team.id).limit(1)
+    )
+    team_name = team_name_result.scalar_one_or_none() or ""
+
+    return [
+        JoinRequestOut(
+            id=r["id"],
+            team_id=r["team_id"],
+            team_name=team_name,
+            user_id=r["user_id"],
+            username=r["username"],
+            phone=r.get("phone"),
+            status=r["status"],
+            note=r.get("note"),
+            created_at=r.get("created_at"),
+        )
+        for r in requests
+    ]
+
+
+@router.post("/join-requests/{request_id}")
+async def handle_join_request(
+    request_id: str,
+    req: JoinRequestHandle,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    await team_invitation_service.handle_join_request(
+        db, request_id, current_user.id, req.action, req.note
+    )
+    return {"message": "ok"}