schedule-management-system/backend/app/routers/campuses.py

from uuid import UUID
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from backend.app.core.dependencies import require_any_permissions, require_permissions
from backend.app.db.session import get_db
from backend.app.models import Campus, Department, User
from backend.app.schemas.campus import CampusCreate, CampusResponse, CampusUpdate


router = APIRouter(prefix="/campuses", tags=["campuses"])


def is_limited_scope(user: User) -> bool:
    return user.role and user.role.name not in {"管理员", "排班员"}


@router.get("", response_model=list[CampusResponse])
async def list_campuses(
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(require_any_permissions(["users.view", "schedule.view"])),
):
    query = select(Campus)
    if is_limited_scope(current_user):
        if current_user.campus_id:
            query = query.where(Campus.id == current_user.campus_id)
        elif current_user.dept_id:
            dept_result = await db.execute(select(Department).where(Department.id == current_user.dept_id))
            dept = dept_result.scalar_one_or_none()
            if dept:
                query = query.where(Campus.id == dept.campus_id)
            else:
                return []
        else:
            return []
    result = await db.execute(query.order_by(Campus.name))
    return result.scalars().all()


@router.post("", response_model=CampusResponse, dependencies=[Depends(require_permissions(["users.edit"]))])
async def create_campus(payload: CampusCreate, db: AsyncSession = Depends(get_db)):
    campus = Campus(name=payload.name)
    db.add(campus)
    await db.commit()
    await db.refresh(campus)
    return campus


@router.put("/{campus_id}", response_model=CampusResponse, dependencies=[Depends(require_permissions(["users.edit"]))])
async def update_campus(campus_id: UUID, payload: CampusUpdate, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(Campus).where(Campus.id == campus_id))
    campus = result.scalar_one_or_none()
    if not campus:
        raise HTTPException(status_code=404, detail="院区不存在")
    campus.name = payload.name
    await db.commit()
    await db.refresh(campus)
    return campus


@router.delete("/{campus_id}", dependencies=[Depends(require_permissions(["users.delete"]))])
async def delete_campus(campus_id: UUID, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(Campus).where(Campus.id == campus_id))
    campus = result.scalar_one_or_none()
    if not campus:
        raise HTTPException(status_code=404, detail="院区不存在")
    await db.delete(campus)
    await db.commit()
    return {"success": True}