349 lines
9.9 KiB
Python
349 lines
9.9 KiB
Python
from uuid import UUID
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, status
|
|
from sqlalchemy import and_
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.auth.dependencies import get_current_user, require_roles
|
|
from app.models import (
|
|
ChannelCreate,
|
|
ChannelDB,
|
|
ChannelResponse,
|
|
ChannelUpdate,
|
|
ChannelURL,
|
|
ChannelURLCreate,
|
|
ChannelURLResponse,
|
|
Group,
|
|
)
|
|
from app.models.auth import CognitoUser
|
|
from app.models.schemas import ChannelURLUpdate
|
|
from app.utils.database import get_db
|
|
|
|
router = APIRouter(prefix="/channels", tags=["channels"])
|
|
|
|
|
|
@router.post("/", response_model=ChannelResponse, status_code=status.HTTP_201_CREATED)
|
|
@require_roles("admin")
|
|
def create_channel(
|
|
channel: ChannelCreate,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""Create a new channel"""
|
|
# Check if group exists
|
|
group = db.query(Group).filter(Group.id == channel.group_id).first()
|
|
if not group:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail="Group not found",
|
|
)
|
|
|
|
# Check for duplicate channel (same group_id + name)
|
|
existing_channel = (
|
|
db.query(ChannelDB)
|
|
.filter(
|
|
and_(
|
|
ChannelDB.group_id == channel.group_id,
|
|
ChannelDB.name == channel.name,
|
|
)
|
|
)
|
|
.first()
|
|
)
|
|
|
|
if existing_channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_409_CONFLICT,
|
|
detail="Channel with same group_id and name already exists",
|
|
)
|
|
|
|
# Create channel without URLs first
|
|
channel_data = channel.model_dump(exclude={"urls"})
|
|
urls = channel.urls
|
|
db_channel = ChannelDB(**channel_data)
|
|
db.add(db_channel)
|
|
db.commit()
|
|
db.refresh(db_channel)
|
|
|
|
# Add URLs with priority
|
|
for url in urls:
|
|
db_url = ChannelURL(
|
|
channel_id=db_channel.id,
|
|
url=url.url,
|
|
priority_id=url.priority_id,
|
|
in_use=False,
|
|
)
|
|
db.add(db_url)
|
|
|
|
db.commit()
|
|
db.refresh(db_channel)
|
|
return db_channel
|
|
|
|
|
|
@router.get("/{channel_id}", response_model=ChannelResponse)
|
|
def get_channel(channel_id: UUID, db: Session = Depends(get_db)):
|
|
"""Get a channel by id"""
|
|
channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
|
|
if not channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
|
|
)
|
|
return channel
|
|
|
|
|
|
@router.put("/{channel_id}", response_model=ChannelResponse)
|
|
@require_roles("admin")
|
|
def update_channel(
|
|
channel_id: UUID,
|
|
channel: ChannelUpdate,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""Update a channel"""
|
|
db_channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
|
|
if not db_channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
|
|
)
|
|
|
|
# Only check for duplicates if name or group_id are being updated
|
|
if channel.name is not None or channel.group_id is not None:
|
|
name = channel.name if channel.name is not None else db_channel.name
|
|
group_id = (
|
|
channel.group_id if channel.group_id is not None else db_channel.group_id
|
|
)
|
|
|
|
# Check if new group exists
|
|
if channel.group_id is not None:
|
|
group = db.query(Group).filter(Group.id == channel.group_id).first()
|
|
if not group:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail="Group not found",
|
|
)
|
|
|
|
existing_channel = (
|
|
db.query(ChannelDB)
|
|
.filter(
|
|
and_(
|
|
ChannelDB.group_id == group_id,
|
|
ChannelDB.name == name,
|
|
ChannelDB.id != channel_id,
|
|
)
|
|
)
|
|
.first()
|
|
)
|
|
|
|
if existing_channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_409_CONFLICT,
|
|
detail="Channel with same group_id and name already exists",
|
|
)
|
|
|
|
# Update only provided fields
|
|
update_data = channel.model_dump(exclude_unset=True)
|
|
for key, value in update_data.items():
|
|
setattr(db_channel, key, value)
|
|
|
|
db.commit()
|
|
db.refresh(db_channel)
|
|
return db_channel
|
|
|
|
|
|
@router.delete("/{channel_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
@require_roles("admin")
|
|
def delete_channel(
|
|
channel_id: UUID,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""Delete a channel"""
|
|
channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
|
|
if not channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
|
|
)
|
|
db.delete(channel)
|
|
db.commit()
|
|
return None
|
|
|
|
|
|
@router.get("/", response_model=list[ChannelResponse])
|
|
@require_roles("admin")
|
|
def list_channels(
|
|
skip: int = 0,
|
|
limit: int = 100,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""List all channels with pagination"""
|
|
return db.query(ChannelDB).offset(skip).limit(limit).all()
|
|
|
|
|
|
# New endpoint to get channels by group
|
|
@router.get("/groups/{group_id}/channels", response_model=list[ChannelResponse])
|
|
def get_channels_by_group(
|
|
group_id: UUID,
|
|
db: Session = Depends(get_db),
|
|
):
|
|
"""Get all channels for a specific group"""
|
|
group = db.query(Group).filter(Group.id == group_id).first()
|
|
if not group:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Group not found"
|
|
)
|
|
return db.query(ChannelDB).filter(ChannelDB.group_id == group_id).all()
|
|
|
|
|
|
# New endpoint to update a channel's group
|
|
@router.put("/{channel_id}/group", response_model=ChannelResponse)
|
|
@require_roles("admin")
|
|
def update_channel_group(
|
|
channel_id: UUID,
|
|
group_id: UUID,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""Update a channel's group"""
|
|
channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
|
|
if not channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
|
|
)
|
|
|
|
group = db.query(Group).filter(Group.id == group_id).first()
|
|
if not group:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Group not found"
|
|
)
|
|
|
|
# Check for duplicate channel name in new group
|
|
existing_channel = (
|
|
db.query(ChannelDB)
|
|
.filter(
|
|
and_(
|
|
ChannelDB.group_id == group_id,
|
|
ChannelDB.name == channel.name,
|
|
ChannelDB.id != channel_id,
|
|
)
|
|
)
|
|
.first()
|
|
)
|
|
|
|
if existing_channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_409_CONFLICT,
|
|
detail="Channel with same name already exists in target group",
|
|
)
|
|
|
|
channel.group_id = group_id
|
|
db.commit()
|
|
db.refresh(channel)
|
|
return channel
|
|
|
|
|
|
# URL Management Endpoints
|
|
@router.post(
|
|
"/{channel_id}/urls",
|
|
response_model=ChannelURLResponse,
|
|
status_code=status.HTTP_201_CREATED,
|
|
)
|
|
@require_roles("admin")
|
|
def add_channel_url(
|
|
channel_id: UUID,
|
|
url: ChannelURLCreate,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""Add a new URL to a channel"""
|
|
channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
|
|
if not channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
|
|
)
|
|
|
|
db_url = ChannelURL(
|
|
channel_id=channel_id,
|
|
url=url.url,
|
|
priority_id=url.priority_id,
|
|
in_use=False, # Default to not in use
|
|
)
|
|
db.add(db_url)
|
|
db.commit()
|
|
db.refresh(db_url)
|
|
return db_url
|
|
|
|
|
|
@router.put("/{channel_id}/urls/{url_id}", response_model=ChannelURLResponse)
|
|
@require_roles("admin")
|
|
def update_channel_url(
|
|
channel_id: UUID,
|
|
url_id: UUID,
|
|
url_update: ChannelURLUpdate,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""Update a channel URL (url, in_use, or priority_id)"""
|
|
db_url = (
|
|
db.query(ChannelURL)
|
|
.filter(and_(ChannelURL.id == url_id, ChannelURL.channel_id == channel_id))
|
|
.first()
|
|
)
|
|
|
|
if not db_url:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="URL not found"
|
|
)
|
|
|
|
if url_update.url is not None:
|
|
db_url.url = url_update.url
|
|
if url_update.in_use is not None:
|
|
db_url.in_use = url_update.in_use
|
|
if url_update.priority_id is not None:
|
|
db_url.priority_id = url_update.priority_id
|
|
|
|
db.commit()
|
|
db.refresh(db_url)
|
|
return db_url
|
|
|
|
|
|
@router.delete("/{channel_id}/urls/{url_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
@require_roles("admin")
|
|
def delete_channel_url(
|
|
channel_id: UUID,
|
|
url_id: UUID,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""Delete a URL from a channel"""
|
|
url = (
|
|
db.query(ChannelURL)
|
|
.filter(and_(ChannelURL.id == url_id, ChannelURL.channel_id == channel_id))
|
|
.first()
|
|
)
|
|
|
|
if not url:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="URL not found"
|
|
)
|
|
|
|
db.delete(url)
|
|
db.commit()
|
|
return None
|
|
|
|
|
|
@router.get("/{channel_id}/urls", response_model=list[ChannelURLResponse])
|
|
@require_roles("admin")
|
|
def list_channel_urls(
|
|
channel_id: UUID,
|
|
db: Session = Depends(get_db),
|
|
user: CognitoUser = Depends(get_current_user),
|
|
):
|
|
"""List all URLs for a channel"""
|
|
channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
|
|
if not channel:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
|
|
)
|
|
|
|
return db.query(ChannelURL).filter(ChannelURL.channel_id == channel_id).all()
|