Init Repo

2026-02-28 03:22:04 +08:00
commit de59b57ee7
883 changed files with 156857 additions and 0 deletions
@@ -0,0 +1,294 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from typing import List
+
+from database import get_db
+from models.episode import Episode
+from models.project import Project, ProjectMember
+from models.user import User, UserRole
+from models.shot import Shot
+from schemas.episode import EpisodeCreate, EpisodeUpdate, EpisodeResponse, EpisodeListResponse
+from utils.auth import get_current_user, require_role, get_current_user_from_token
+
+router = APIRouter()
+
+
+def get_current_user_with_db(
+    token_data: dict = Depends(get_current_user_from_token),
+    db: Session = Depends(get_db)
+):
+    """Get current user with proper database dependency."""
+    from utils.auth import _get_user_from_db
+    return _get_user_from_db(db, token_data["user_id"])
+
+
+def require_coordinator_or_admin(
+    token_data: dict = Depends(get_current_user_from_token),
+    db: Session = Depends(get_db)
+):
+    """Require coordinator or admin role."""
+    from utils.auth import _get_user_from_db
+    current_user = _get_user_from_db(db, token_data["user_id"])
+    
+    if current_user.role != UserRole.COORDINATOR and not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Insufficient permissions"
+        )
+    return current_user
+
+
+@router.get("/", response_model=List[EpisodeListResponse])
+async def list_episodes(
+    project_id: int = None,
+    skip: int = 0,
+    limit: int = 100,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user_with_db)
+):
+    """List episodes, optionally filtered by project"""
+    query = db.query(Episode)
+    
+    if project_id:
+        # Check if project exists and user has access
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Project not found"
+            )
+        
+        # Check access for artists
+        if current_user.role == UserRole.ARTIST:
+            member = db.query(ProjectMember).filter(
+                ProjectMember.project_id == project_id,
+                ProjectMember.user_id == current_user.id
+            ).first()
+            if not member:
+                raise HTTPException(
+                    status_code=status.HTTP_403_FORBIDDEN,
+                    detail="Access denied to this project"
+                )
+        
+        query = query.filter(Episode.project_id == project_id)
+    else:
+        # For artists, only show episodes from projects they're members of
+        if current_user.role == UserRole.ARTIST:
+            user_project_ids = db.query(ProjectMember.project_id).filter(
+                ProjectMember.user_id == current_user.id
+            ).subquery()
+            query = query.filter(Episode.project_id.in_(user_project_ids))
+    
+    episodes = query.order_by(Episode.episode_number).offset(skip).limit(limit).all()
+    
+    # Add shot count for each episode
+    result = []
+    for episode in episodes:
+        shot_count = db.query(Shot).filter(Shot.episode_id == episode.id).count()
+        episode_data = EpisodeListResponse.model_validate(episode)
+        episode_data.shot_count = shot_count
+        result.append(episode_data)
+    
+    return result
+
+
+@router.post("/", response_model=EpisodeResponse, status_code=status.HTTP_201_CREATED)
+async def create_episode(
+    episode: EpisodeCreate,
+    project_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_coordinator_or_admin)
+):
+    """Create a new episode within a project"""
+    # Check if project exists
+    project = db.query(Project).filter(Project.id == project_id).first()
+    if not project:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Project not found"
+        )
+    
+    # Check if episode number is already used in this project
+    existing_episode = db.query(Episode).filter(
+        Episode.project_id == project_id,
+        Episode.episode_number == episode.episode_number
+    ).first()
+    
+    if existing_episode:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Episode number {episode.episode_number} already exists in this project"
+        )
+    
+    # Create new episode
+    db_episode = Episode(
+        project_id=project_id,
+        **episode.model_dump()
+    )
+    
+    db.add(db_episode)
+    db.commit()
+    db.refresh(db_episode)
+    
+    episode_data = EpisodeResponse.model_validate(db_episode)
+    episode_data.shot_count = 0  # New episode has no shots yet
+    
+    return episode_data
+
+
+@router.get("/{episode_id}", response_model=EpisodeResponse)
+async def get_episode(
+    episode_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user_with_db)
+):
+    """Get a specific episode by ID"""
+    episode = db.query(Episode).filter(Episode.id == episode_id).first()
+    
+    if not episode:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Episode not found"
+        )
+    
+    # Check access for artists
+    if current_user.role == UserRole.ARTIST:
+        member = db.query(ProjectMember).filter(
+            ProjectMember.project_id == episode.project_id,
+            ProjectMember.user_id == current_user.id
+        ).first()
+        if not member:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied to this episode"
+            )
+    
+    # Add shot count
+    shot_count = db.query(Shot).filter(Shot.episode_id == episode.id).count()
+    episode_data = EpisodeResponse.model_validate(episode)
+    episode_data.shot_count = shot_count
+    
+    return episode_data
+
+
+@router.put("/{episode_id}", response_model=EpisodeResponse)
+async def update_episode(
+    episode_id: int,
+    episode_update: EpisodeUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_coordinator_or_admin)
+):
+    """Update an episode"""
+    db_episode = db.query(Episode).filter(Episode.id == episode_id).first()
+    
+    if not db_episode:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Episode not found"
+        )
+    
+    # If updating episode number, check for conflicts
+    update_data = episode_update.model_dump(exclude_unset=True)
+    if 'episode_number' in update_data:
+        existing_episode = db.query(Episode).filter(
+            Episode.project_id == db_episode.project_id,
+            Episode.episode_number == update_data['episode_number'],
+            Episode.id != episode_id
+        ).first()
+        
+        if existing_episode:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Episode number {update_data['episode_number']} already exists in this project"
+            )
+    
+    # Update only provided fields
+    for field, value in update_data.items():
+        setattr(db_episode, field, value)
+    
+    db.commit()
+    db.refresh(db_episode)
+    
+    # Add shot count
+    shot_count = db.query(Shot).filter(Shot.episode_id == db_episode.id).count()
+    episode_data = EpisodeResponse.model_validate(db_episode)
+    episode_data.shot_count = shot_count
+    
+    return episode_data
+
+
+@router.delete("/{episode_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_episode(
+    episode_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_coordinator_or_admin)
+):
+    """Delete an episode"""
+    db_episode = db.query(Episode).filter(Episode.id == episode_id).first()
+    
+    if not db_episode:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Episode not found"
+        )
+    
+    db.delete(db_episode)
+    db.commit()
+
+
+# Project-specific episode endpoints
+
+@router.get("/projects/{project_id}/episodes", response_model=List[EpisodeListResponse])
+async def list_project_episodes(
+    project_id: int,
+    skip: int = 0,
+    limit: int = 100,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user_with_db)
+):
+    """List all episodes for a specific project"""
+    # Check if project exists
+    project = db.query(Project).filter(Project.id == project_id).first()
+    if not project:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Project not found"
+        )
+    
+    # Check access for artists
+    if current_user.role == UserRole.ARTIST:
+        member = db.query(ProjectMember).filter(
+            ProjectMember.project_id == project_id,
+            ProjectMember.user_id == current_user.id
+        ).first()
+        if not member:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Access denied to this project"
+            )
+    
+    episodes = db.query(Episode).filter(
+        Episode.project_id == project_id
+    ).order_by(Episode.episode_number).offset(skip).limit(limit).all()
+    
+    # Add shot count for each episode
+    result = []
+    for episode in episodes:
+        shot_count = db.query(Shot).filter(Shot.episode_id == episode.id).count()
+        episode_data = EpisodeListResponse.model_validate(episode)
+        episode_data.shot_count = shot_count
+        result.append(episode_data)
+    
+    return result
+
+
+@router.post("/projects/{project_id}/episodes", response_model=EpisodeResponse, status_code=status.HTTP_201_CREATED)
+async def create_project_episode(
+    project_id: int,
+    episode: EpisodeCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_coordinator_or_admin)
+):
+    """Create a new episode within a specific project"""
+    return await create_episode(episode, project_id, db, current_user)