connect/api/api/endpoints/list_events.py

from typing import List, Optional

from fastapi import APIRouter, Depends, HTTPException, Query, status
from orm.tables.events import EventStatus
from sqlalchemy.ext.asyncio import AsyncConnection

from api.db.connection.session import get_connection_dep
from api.db.logic.account import get_user_by_login
from api.db.logic.list_events import (
    create_list_events,
    get_list_events_by_id,
    get_list_events_by_name,
    get_list_events_page_DTO,
    update_list_events_by_id,
)
from api.schemas.base import bearer_schema
from api.schemas.endpoints.list_events import AllListEventResponse, ListEventFilterDTO, ListEventUpdate
from api.schemas.events.list_events import ListEvent
from api.services.auth import get_current_user
from api.services.user_role_validation import (
    db_user_role_validation_for_list_events_and_process_schema,
    db_user_role_validation_for_list_events_and_process_schema_by_list_event_id,
)

api_router = APIRouter(
    prefix="/list_events",
    tags=["list events"],
)


@api_router.get("", dependencies=[Depends(bearer_schema)], response_model=AllListEventResponse)
async def get_all_list_events_endpoint(
    page: int = Query(1, description="Page number", gt=0),
    limit: int = Query(10, description="Number of items per page", gt=0),
    search: Optional[str] = Query(None, description="Search term to filter by title or name"),
    order_field: Optional[str] = Query("id", description="Field to sort by"),
    order_direction: Optional[str] = Query("asc", description="Sort direction (asc/desc)"),
    status_filter: Optional[List[str]] = Query(None, description="Filter by status"),
    state_filter: Optional[List[str]] = Query(None, description="Filter by state"),
    creator_id: Optional[int] = Query(None, description="Filter by creator id"),
    connection: AsyncConnection = Depends(get_connection_dep),
    current_user=Depends(get_current_user),
):
    filters = {
        **({"status": status_filter} if status_filter else {}),
        **({"state": state_filter} if state_filter else {}),
        **({"creator_id": [str(creator_id)]} if creator_id else {}),
    }

    filter_dto = ListEventFilterDTO(
        pagination={"page": page, "limit": limit},
        search=search,
        order={"field": order_field, "direction": order_direction},
        filters=filters if filters else None,
    )

    authorize_user, page_flag = await db_user_role_validation_for_list_events_and_process_schema(
        connection, current_user
    )

    if not page_flag:
        if filter_dto.filters is None:
            filter_dto.filters = {}
        filter_dto.filters["creator_id"] = [str(authorize_user.id)]

    list_events_page = await get_list_events_page_DTO(connection, filter_dto)

    if list_events_page is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="List events not found")

    return list_events_page


@api_router.get("/{list_events_id}", dependencies=[Depends(bearer_schema)], response_model=ListEvent)
async def get_list_events_endpoint(
    list_events_id: int,
    connection: AsyncConnection = Depends(get_connection_dep),
    current_user=Depends(get_current_user),
):
    list_events_validation = await get_list_events_by_id(connection, list_events_id)

    if list_events_validation is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="List events not found")

    authorize_user = await db_user_role_validation_for_list_events_and_process_schema_by_list_event_id(
        connection, current_user, list_events_validation.creator_id
    )

    if list_events_id is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="List events not found")

    return list_events_validation


@api_router.post("", dependencies=[Depends(bearer_schema)], response_model=ListEvent)
async def create_list_events_endpoint(
    list_events: ListEventUpdate,
    connection: AsyncConnection = Depends(get_connection_dep),
    current_user=Depends(get_current_user),
):
    user_validation = await get_user_by_login(connection, current_user)
    list_events_validation = await get_list_events_by_name(connection, list_events.name)

    if list_events_validation is None:
        await create_list_events(connection, list_events, user_validation.id)
        list_events_new = await get_list_events_by_name(connection, list_events.name)
        return list_events_new

    else:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST, detail="An List events with this information already exists."
        )


@api_router.put("/{list_events_id}", dependencies=[Depends(bearer_schema)], response_model=ListEvent)
async def update_list_events(
    list_events_id: int,
    list_events_update: ListEventUpdate,
    connection: AsyncConnection = Depends(get_connection_dep),
    current_user=Depends(get_current_user),
):
    list_events_validation = await get_list_events_by_id(connection, list_events_id)

    if list_events_validation is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="List events not found")

    authorize_user = await db_user_role_validation_for_list_events_and_process_schema_by_list_event_id(
        connection, current_user, list_events_validation.creator_id
    )

    updated_values = list_events_update.model_dump(by_alias=True, exclude_none=True)

    if not updated_values:
        return list_events_validation

    await update_list_events_by_id(connection, updated_values, list_events_validation)

    list_events = await get_list_events_by_id(connection, list_events_id)

    return list_events


@api_router.delete("/{list_events_id}", dependencies=[Depends(bearer_schema)], response_model=ListEvent)
async def delete_list_events_endpoint(
    list_events_id: int,
    connection: AsyncConnection = Depends(get_connection_dep),
    current_user=Depends(get_current_user),
):
    list_events_validation = await get_list_events_by_id(connection, list_events_id)

    if list_events_validation is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="List events not found")

    authorize_user = await db_user_role_validation_for_list_events_and_process_schema_by_list_event_id(
        connection, current_user, list_events_validation.creator_id
    )

    list_events_update = ListEventUpdate(status=EventStatus.DELETED.value)

    updated_values = list_events_update.model_dump(by_alias=True, exclude_none=True)

    if not updated_values:
        return list_events_validation

    await update_list_events_by_id(connection, updated_values, list_events_validation)

    list_events = await get_list_events_by_id(connection, list_events_id)

    return list_events