Merge pull request #223 from Pseudo-Lab/fix/team-match

hu6r1s · web-flow · commit a0aa6104d7ba · 2025-12-08T21:38:42.000+09:00
refactor(getcloser): team match logic and cancel logic
diff --git a/getcloser/backend/app/api/v1/__init__.py b/getcloser/backend/app/api/v1/__init__.py
@@ -4,13 +4,15 @@
 from api.v1.teams import teams
 from core.dependencies import get_current_user
 from fastapi import APIRouter, Depends
+import core.websocket as websocket
 
 private_router = APIRouter(
   dependencies=[Depends(get_current_user)]
 )
 private_router.include_router(users.router, prefix="/users", tags=["users"])
 private_router.include_router(challenges.router, prefix="/challenges", tags=["challenges"])
 private_router.include_router(teams.router, prefix="/teams", tags=["teams"])
+private_router.include_router(websocket.router, prefix="/ws", tags=["ws"])
 
 public_router = APIRouter()
 public_router.include_router(auth.router, prefix="/auth", tags=["auth"])
diff --git a/getcloser/backend/app/api/v1/teams/teams.py b/getcloser/backend/app/api/v1/teams/teams.py
@@ -1,11 +1,23 @@
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 from core.database import get_db
-from schemas.team_schema import TeamCreateRequest, TeamResponse
+from schemas.team_schema import TeamCreateRequest, TeamCreateResponse, TeamStatusResponse
 from services.team_service import create_team
+from core.dependencies import get_current_user
+from core.websocket import notify_invitation
 
 router = APIRouter()
 
-@router.post("/create", response_model=TeamResponse)
-def create_team_route(req: TeamCreateRequest, db: Session = Depends(get_db)):
-    return create_team(db, req)
+@router.post("/create", response_model=TeamCreateResponse)
+async def create_team_route(req: TeamCreateRequest, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
+    res = create_team(db, int(current_user["sub"]), req.member_ids)
+    return TeamCreateResponse(**res)
+
+@router.post("/{team_id}/cancel")
+def cancel_route(team_id: int, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
+    return cancel_team(db, team_id, current_user["sub"])
+
+@router.get("/{team_id}/status", response_model=TeamStatusResponse)
+def status_route(team_id: int, db: Session = Depends(get_db), current_user=Depends(get_current_user)):
+    res = get_team_status(db, team_id, current_user["sub"])
+    return TeamStatusResponse(**res)
diff --git a/getcloser/backend/app/core/websocket.py b/getcloser/backend/app/core/websocket.py
@@ -0,0 +1,32 @@
+from fastapi import WebSocket, WebSocketDisconnect, APIRouter, Depends
+from core.dependencies import get_current_user
+from core.security import verify_access_token
+
+router = APIRouter()
+active_sockets: dict[int, WebSocket] = {}
+
+@router.websocket("/invitations")
+async def websocket_endpoint(websocket: WebSocket):
+    try:
+      user_id = verify_access_token(websocket.headers.get("Sec-Websocket-Protocol"))["sub"]
+    except HTTPException:
+        await websocket.close(code=1008)
+        return
+
+    await websocket.accept()
+    active_sockets[user_id] = websocket
+    try:
+        while True:
+            await websocket.receive_text()
+    except WebSocketDisconnect:
+        del active_sockets[user_id]
+
+async def notify_invitation(member_ids, team):
+    for uid in member_ids:
+        if uid in active_sockets:
+            await active_sockets[uid].send_json({
+                "event": "team_invitation",
+                "team_id": team.id,
+                "members": member_ids,
+                "expires_at": str(team.expires_at)
+            })
diff --git a/getcloser/backend/app/main.py b/getcloser/backend/app/main.py
@@ -31,7 +31,7 @@
 origins = os.getenv("CORS_ORIGINS", "").split(",")
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=origins,
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
diff --git a/getcloser/backend/app/models/teams.py b/getcloser/backend/app/models/teams.py
@@ -1,15 +1,37 @@
 from core.database import Base
-from sqlalchemy import Column, Integer, Boolean, UniqueConstraint
+from sqlalchemy import Column, Integer, Boolean, UniqueConstraint, Enum, DateTime, ForeignKey, String
+import enum
+from datetime import datetime, timedelta
+from sqlalchemy.orm import relationship
 
+class TeamStatus(str, enum.Enum):
+  PENDING = "PENDING"
+  ACTIVE = "ACTIVE"
+  CANCELLED = "CANCELLED"
+  FAILED = "FAILED"
+  
 
 class Team(Base):
   __tablename__ = "teams"
   
   id = Column(Integer, primary_key=True, index=True)
-  team_id = Column(Integer, index=True)
-  user_id = Column(Integer, index=True)
-  is_active = Column(Boolean, default=True)
+  group_hash = Column(String, index=True)
+  status = Column(Enum(TeamStatus), nullable=False, default=TeamStatus.PENDING)
+  created_at = Column(DateTime(timezone=True), default=datetime.utcnow)
+
+  members = relationship("TeamMember", back_populates="team", cascade="all, delete-orphan")
+  
+
+class TeamMember(Base):
+    __tablename__ = "team_members"
+
+    id = Column(Integer, primary_key=True, index=True)
+    team_id = Column(Integer, ForeignKey("teams.id", ondelete="CASCADE"), index=True, nullable=False)
+    user_id = Column(Integer, index=True, nullable=False)
+    confirmed = Column(Boolean, default=False)
+
+    team = relationship("Team", back_populates="members")
 
-  __table_args__ = (
-        UniqueConstraint('team_id', 'user_id', name='_team_user_uc'),
+    __table_args__ = (
+        UniqueConstraint("team_id", "user_id", name="u_team_user"),
     )
diff --git a/getcloser/backend/app/schemas/team_schema.py b/getcloser/backend/app/schemas/team_schema.py
@@ -1,19 +1,17 @@
 from pydantic import BaseModel, Field
-from typing import List
+from typing import List, Optional
+from datetime import datetime
 
 
 class TeamCreateRequest(BaseModel):
-    my_id: int
-    member_ids: List[int] = Field(..., min_items=4, max_items=4, description="팀원 4명의 ID")
+    member_ids: List[int] = Field(..., min_items=1, max_items=4, description="팀원 4명의 ID")
 
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "my_id": 1,
-                "member_ids": [2, 3, 4, 5]
-            }
-    }
+class TeamCreateResponse(BaseModel):
+    team_id: int
+    status: str
+    message: str
 
-class TeamResponse(BaseModel):
+class TeamStatusResponse(BaseModel):
     team_id: int
-    members_ids: List[int]
+    status: str
+    members_ready: List[int]
diff --git a/getcloser/backend/app/services/team_service.py b/getcloser/backend/app/services/team_service.py
@@ -1,58 +1,186 @@
 from models.challenges import UserChallengeStatus
 from sqlalchemy import func
 from sqlalchemy.orm import Session
-from models.teams import Team
-from schemas.team_schema import TeamCreateRequest, TeamResponse
+from models.teams import Team, TeamMember, TeamStatus
+from schemas.team_schema import TeamCreateRequest
 from fastapi import HTTPException
+from typing import List
+import os
+from datetime import datetime, timedelta
 
-def create_team(db: Session, req: TeamCreateRequest) -> TeamResponse:
-    all_ids = [req.my_id] + req.member_ids
+TEAM_SIZE = int(os.getenv("TEAM_SIZE", "0"))
+PENDING_TIMEOUT_MINUTES = int(os.getenv("PENDING_TIMEOUT_MINUTES", "0"))
 
-    records = (
-        db.query(Team.user_id, Team.is_active, UserChallengeStatus.is_correct)
-        .outerjoin(UserChallengeStatus, Team.user_id == UserChallengeStatus.user_id)
-        .filter(Team.user_id.in_(all_ids))
+def _now():
+    return datetime.utcnow()
+
+def create_team(db: Session, my_id: int, member_ids: List[int]):
+    all_ids = sorted([my_id] + member_ids)
+
+    if len(all_ids) != TEAM_SIZE:
+        raise HTTPException(status_code=400, detail="Team must have exactly 5 members (you + 4).")
+    if len(set(all_ids)) != TEAM_SIZE:
+        raise HTTPException(status_code=400, detail="Duplicate user IDs in request.")
+      
+    corrected = db.query(UserChallengeStatus.user_id).filter(
+          UserChallengeStatus.user_id.in_(all_ids),
+          UserChallengeStatus.is_correct == True
+    ).all()
+
+    if corrected:
+        corrected_ids = [r[0] for r in corrected]
+        raise HTTPException(status_code=400, detail=f"Users already corrected: {corrected_ids}")
+ 
+    blocking_users = (
+        db.query(TeamMember.user_id)
+        .join(Team)
+        .filter(
+            TeamMember.user_id.in_(all_ids),
+            Team.status == TeamStatus.ACTIVE
+        )
         .all()
     )
+    if blocking_users:
+        raise HTTPException(status_code=400,
+                            detail=f"Users already in another team: {[u[0] for u in blocking_users]}")
+ 
+    group_hash = "-".join(map(str, all_ids))
     
-    active_ids = [r.user_id for r in records if r.is_active]
-    corrected_ids = [r.user_id for r in records if r.is_correct]
+    team = (
+        db.query(Team)
+        .filter(Team.group_hash == group_hash,
+                Team.status.in_([TeamStatus.PENDING, TeamStatus.ACTIVE]))
+        .first()
+    )
     
-    if active_ids:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Users already in active team: {active_ids}",
-        )
+    target_team = None
+    
+    if team and team.status == TeamStatus.PENDING:
+        if _now() - team.created_at.replace(tzinfo=None) > timedelta(minutes=PENDING_TIMEOUT_MINUTES):
+            team.status = TeamStatus.CANCELLED
+            db.commit()
+        else:
+            me = (
+                db.query(TeamMember)
+                .filter(TeamMember.team_id == team.id, TeamMember.user_id == my_id)
+                .first()
+            )
+            if me:
+                me.confirmed = True
+            
+            db.flush()
 
-    if corrected_ids:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Users already corrected: {corrected_ids}",
-        )
+            ready_count = (
+                db.query(TeamMember)
+                .filter(TeamMember.team_id == team.id, TeamMember.confirmed == True)
+                .count()
+            )
+
+            if ready_count == TEAM_SIZE:
+                team.status = TeamStatus.ACTIVE
+                db.commit()
+                return {"status": "ACTIVE", "team_id": team.id, "message": "Team matched"}
 
-    last_team_id = db.query(func.max(Team.team_id)).scalar()
-    new_team_id = (last_team_id or 0) + 1
+            db.commit()
+            return {"status": "PENDING", "team_id": team.id, "message": "Joined pending team request"}
+    
+    if team and team.status == TeamStatus.ACTIVE:
+        raise HTTPException(status_code=400, detail="This team is already active.")
+        
+    team = Team(group_hash=group_hash, status=TeamStatus.PENDING)
+    db.add(team)
+    db.flush()
 
-    teams_to_add = [
-      {"team_id": new_team_id, "user_id": uid, "is_active": True}
-      for uid in all_ids
+    members = [
+        TeamMember(team_id=team.id, user_id=uid, confirmed=(uid == my_id))
+        for uid in all_ids
     ]
+    db.bulk_save_objects(members)
+    db.commit()
+
+    return {"status": "PENDING", "team_id": team.id, "message": "New team request created"}
+
+def cancel_team(db: Session, team_id: int, user_id: int):
+  team = (
+        db.query(Team)
+        .filter(
+            Team.id == team_id, 
+            Team.status == TeamStatus.PENDING
+        ).first()
+    )
+    
+  if not team:
+      raise HTTPException(status_code=400, detail="No pending team found")
     
-    db.bulk_insert_mappings(Team, teams_to_add)
+  member = db.query(TeamMember).filter(
+    TeamMember.team_id == team_id,
+    TeamMember.user_id == user_id
+  ).first()
+  
+  if not member:
+    raise HTTPException(status_code=403, detail="You are not a member of this team")
+  
+  if member.confirmed is False:
+    return {"message": "Already cancelled"}
+  
+  member.confirmed = False
+  db.commit()
+  db.refresh(team)
+  
+  remaining_confirmed = db.query(TeamMember).filter(
+    TeamMember.team_id == team_id,
+    TeamMember.confirmed == True
+  ).count()
+  
+  if remaining_confirmed == 0:
+    team.status = TeamStatus.CANCELLED
     db.commit()
+    return {"message": "Team cancelled (last member left)"}
+  
+  return {"message": "You left the team"}
+  
+def get_team_status(db: Session, team_id: int, user_id: int):
+    last_member_entry = (
+        db.query(TeamMember)
+        .join(Team)
+        .filter(TeamMember.user_id == user_id)
+        .order_by(Team.created_at.desc())
+        .first()
+    )
 
-    return TeamResponse(team_id=new_team_id, members_ids=all_ids)
+    if not last_member_entry:
+        return {"status": "NONE"}
 
-def dissolve_team_by_user(db: Session, user_id: int):
-  team_entry = db.query(Team).filter(Team.user_id == user_id, Team.is_active == True).first()
-  if not team_entry:
-      raise HTTPException(status_code=400, detail="User not in active team")
+    team = last_member_entry.team
+
+    if team.status == TeamStatus.PENDING:
+        time_diff = datetime.now() - team.created_at
+        if time_diff > timedelta(minutes=PENDING_TIMEOUT_MINUTES):
+             team.status = TeamStatus.CANCELLED
+             db.commit()
+             return {"status": "EXPIRED"}
+
+    return {
+        "team_id": team.id,
+        "status": team.status.value,
+        "members_ready": [m.user_id for m in team.members if m.confirmed]
+    }
 
-  team_id = team_entry.team_id
-  team_members = db.query(Team).filter(Team.team_id == team_id, Team.is_active == True).all()
+def dissolve_team_by_user(db: Session, user_id: int):
+  team_entry = (
+        db.query(Team)
+        .join(TeamMember)
+        .filter(
+            TeamMember.user_id == user_id, 
+            Team.status == TeamStatus.ACTIVE
+        ).first()
+    )
 
-  for member in team_members:
-      member.is_active = False
+  if not team_entry:
+      raise HTTPException(status_code=400, detail="User is not in an active team")
 
+  team_entry.status = TeamStatus.FAILED
+  
   db.commit()
-  return {"message": f"Team {team_id} dissolved", "team_id": team_id}
+  
+  return {"message": f"Team {team_entry.id} dissolved due to quiz failure.", "team_id": team_entry.id}
diff --git a/getcloser/docker-compose.dev.yml b/getcloser/docker-compose.dev.yml
@@ -32,6 +32,8 @@ services:
       CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:3000}
       SECRET_KEY: ${SECRET_KEY:-change-me-in-prod}
       ACCESS_TOKEN_EXPIRE_MINUTES: ${ACCESS_TOKEN_EXPIRE_MINUTES:-60}
+      TEAM_SIZE: ${TEAM_SIZE}
+      PENDING_TIMEOUT_MINUTES: ${PENDING_TIMEOUT_MINUTES}
     volumes:
       - ./backend/app:/app
     depends_on:
