mitlist/be/app/crud/list.py

# app/crud/list.py
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select
from sqlalchemy.orm import selectinload, joinedload
from sqlalchemy import or_, and_, delete as sql_delete, func as sql_func, desc
from sqlalchemy.exc import SQLAlchemyError, IntegrityError, OperationalError
from typing import Optional, List as PyList

from app.schemas.list import ListStatus
from app.models import List as ListModel, UserGroup as UserGroupModel, Item as ItemModel
from app.schemas.list import ListCreate, ListUpdate
from app.core.exceptions import (
    ListNotFoundError,
    ListPermissionError,
    ListCreatorRequiredError,
    DatabaseConnectionError,
    DatabaseIntegrityError,
    DatabaseQueryError,
    DatabaseTransactionError,
    ConflictError,
    ListOperationError
)

async def create_list(db: AsyncSession, list_in: ListCreate, creator_id: int) -> ListModel:
    """Creates a new list record."""
    try:
        async with db.begin_nested() if db.in_transaction() else db.begin() as transaction:
            db_list = ListModel(
                name=list_in.name,
                description=list_in.description,
                group_id=list_in.group_id,
                created_by_id=creator_id,
                is_complete=False
            )
            db.add(db_list)
            await db.flush() # Assigns ID

            # Re-fetch with relationships for the response
            stmt = (
                select(ListModel)
                .where(ListModel.id == db_list.id)
                .options(
                    selectinload(ListModel.creator),
                    selectinload(ListModel.group)
                    # selectinload(ListModel.items) # Optionally add if items are always needed in response
                )
            )
            result = await db.execute(stmt)
            loaded_list = result.scalar_one_or_none()

            if loaded_list is None:
                await transaction.rollback()
                raise ListOperationError("Failed to load list after creation.")

            await transaction.commit()
            return loaded_list
    except IntegrityError as e:
        raise DatabaseIntegrityError(f"Failed to create list: {str(e)}")
    except OperationalError as e:
        raise DatabaseConnectionError(f"Database connection error: {str(e)}")
    except SQLAlchemyError as e:
        raise DatabaseTransactionError(f"Failed to create list: {str(e)}")

async def get_lists_for_user(db: AsyncSession, user_id: int) -> PyList[ListModel]:
    """Gets all lists accessible by a user."""
    try:
        group_ids_result = await db.execute(
            select(UserGroupModel.group_id).where(UserGroupModel.user_id == user_id)
        )
        user_group_ids = group_ids_result.scalars().all()

        conditions = [
            and_(ListModel.created_by_id == user_id, ListModel.group_id.is_(None))
        ]
        if user_group_ids:
            conditions.append(ListModel.group_id.in_(user_group_ids))

        query = (
            select(ListModel)
            .where(or_(*conditions))
            .options(
                selectinload(ListModel.creator),
                selectinload(ListModel.group)
                # selectinload(ListModel.items) # Consider if items are needed for list previews
            )
            .order_by(ListModel.updated_at.desc())
        )

        result = await db.execute(query)
        return result.scalars().all()
    except OperationalError as e:
        raise DatabaseConnectionError(f"Failed to connect to database: {str(e)}")
    except SQLAlchemyError as e:
        raise DatabaseQueryError(f"Failed to query user lists: {str(e)}")

async def get_list_by_id(db: AsyncSession, list_id: int, load_items: bool = False) -> Optional[ListModel]:
    """Gets a single list by ID, optionally loading its items."""
    try:
        query = (
            select(ListModel)
            .where(ListModel.id == list_id)
            .options(
                selectinload(ListModel.creator),
                selectinload(ListModel.group)
            )
        )
        if load_items:
            query = query.options(
                selectinload(ListModel.items).options(
                    joinedload(ItemModel.added_by_user),
                    joinedload(ItemModel.completed_by_user)
                )
            )
        result = await db.execute(query)
        return result.scalars().first()
    except OperationalError as e:
        raise DatabaseConnectionError(f"Failed to connect to database: {str(e)}")
    except SQLAlchemyError as e:
        raise DatabaseQueryError(f"Failed to query list: {str(e)}")

async def update_list(db: AsyncSession, list_db: ListModel, list_in: ListUpdate) -> ListModel:
    """Updates an existing list record, checking for version conflicts."""
    try:
        async with db.begin_nested() if db.in_transaction() else db.begin() as transaction:
            if list_db.version != list_in.version: # list_db here is the one passed in, pre-loaded by API layer
                await transaction.rollback() # Rollback before raising
                raise ConflictError(
                    f"List '{list_db.name}' (ID: {list_db.id}) has been modified. "
                    f"Your version is {list_in.version}, current version is {list_db.version}. Please refresh."
                )

            update_data = list_in.model_dump(exclude_unset=True, exclude={'version'})

            for key, value in update_data.items():
                setattr(list_db, key, value)
            
            list_db.version += 1

            db.add(list_db) # Add the already attached list_db to mark it dirty for the session
            await db.flush()

            # Re-fetch with relationships for the response
            stmt = (
                select(ListModel)
                .where(ListModel.id == list_db.id)
                .options(
                    selectinload(ListModel.creator),
                    selectinload(ListModel.group)
                    # selectinload(ListModel.items) # Optionally add if items are always needed in response
                )
            )
            result = await db.execute(stmt)
            updated_list = result.scalar_one_or_none()

            if updated_list is None: # Should not happen
                await transaction.rollback()
                raise ListOperationError("Failed to load list after update.")
            
            await transaction.commit()
            return updated_list
    except IntegrityError as e:
        # Ensure rollback if not handled by context manager (though it should be)
        if db.in_transaction(): await db.rollback()
        raise DatabaseIntegrityError(f"Failed to update list due to integrity constraint: {str(e)}")
    except OperationalError as e:
        if db.in_transaction(): await db.rollback()
        raise DatabaseConnectionError(f"Database connection error while updating list: {str(e)}")
    except ConflictError:
        # Already rolled back or will be by context manager if transaction was started here
        raise
    except SQLAlchemyError as e:
        if db.in_transaction(): await db.rollback()
        raise DatabaseTransactionError(f"Failed to update list: {str(e)}")

async def delete_list(db: AsyncSession, list_db: ListModel) -> None:
    """Deletes a list record. Version check should be done by the caller (API endpoint)."""
    try:
        async with db.begin_nested() if db.in_transaction() else db.begin() as transaction: # Standardize transaction
            await db.delete(list_db)
            await transaction.commit() # Explicit commit
            # return None # Already implicitly returns None
    except OperationalError as e:
        # Rollback should be handled by the async with block on exception
        raise DatabaseConnectionError(f"Database connection error while deleting list: {str(e)}")
    except SQLAlchemyError as e:
        # Rollback should be handled by the async with block on exception
        raise DatabaseTransactionError(f"Failed to delete list: {str(e)}")

async def check_list_permission(db: AsyncSession, list_id: int, user_id: int, require_creator: bool = False) -> ListModel:
    """Fetches a list and verifies user permission."""
    try:
        list_db = await get_list_by_id(db, list_id=list_id, load_items=True)
        if not list_db:
            raise ListNotFoundError(list_id)

        is_creator = list_db.created_by_id == user_id

        if require_creator:
            if not is_creator:
                raise ListCreatorRequiredError(list_id, "access")
            return list_db

        if is_creator:
            return list_db

        if list_db.group_id:
            from app.crud.group import is_user_member
            is_member = await is_user_member(db, group_id=list_db.group_id, user_id=user_id)
            if not is_member:
                raise ListPermissionError(list_id)
            return list_db
        else:
            raise ListPermissionError(list_id)
    except OperationalError as e:
        raise DatabaseConnectionError(f"Failed to connect to database: {str(e)}")
    except SQLAlchemyError as e:
        raise DatabaseQueryError(f"Failed to check list permissions: {str(e)}")

async def get_list_status(db: AsyncSession, list_id: int) -> ListStatus:
    """Gets the update timestamps and item count for a list."""
    try:
        list_query = select(ListModel.updated_at).where(ListModel.id == list_id)
        list_result = await db.execute(list_query)
        list_updated_at = list_result.scalar_one_or_none()

        if list_updated_at is None:
            raise ListNotFoundError(list_id)

        item_status_query = (
            select(
                sql_func.max(ItemModel.updated_at).label("latest_item_updated_at"),
                sql_func.count(ItemModel.id).label("item_count")
            )
            .where(ItemModel.list_id == list_id)
        )
        item_result = await db.execute(item_status_query)
        item_status = item_result.first()

        return ListStatus(
            list_updated_at=list_updated_at,
            latest_item_updated_at=item_status.latest_item_updated_at if item_status else None,
            item_count=item_status.item_count if item_status else 0
        )
    except OperationalError as e:
        raise DatabaseConnectionError(f"Failed to connect to database: {str(e)}")
    except SQLAlchemyError as e:
        raise DatabaseQueryError(f"Failed to get list status: {str(e)}")

async def get_list_by_name_and_group(
    db: AsyncSession, 
    name: str, 
    group_id: Optional[int], 
    user_id: int # user_id is for permission check, not direct list attribute
) -> Optional[ListModel]:
    """
    Gets a list by name and group, ensuring the user has permission to access it.
    Used for conflict resolution when creating lists.
    """
    try:
        # Base query for the list itself
        base_query = select(ListModel).where(ListModel.name == name)
        
        if group_id is not None:
            base_query = base_query.where(ListModel.group_id == group_id)
        else:
            base_query = base_query.where(ListModel.group_id.is_(None))
        
        # Add eager loading for common relationships
        base_query = base_query.options(
            selectinload(ListModel.creator),
            selectinload(ListModel.group)
        )
        
        list_result = await db.execute(base_query)
        target_list = list_result.scalar_one_or_none()

        if not target_list:
            return None

        # Permission check
        is_creator = target_list.created_by_id == user_id
        
        if is_creator:
            return target_list
        
        if target_list.group_id:
            from app.crud.group import is_user_member # Assuming this is a quick check not needing its own transaction
            is_member_of_group = await is_user_member(db, group_id=target_list.group_id, user_id=user_id)
            if is_member_of_group:
                return target_list
        
        # If not creator and (not a group list or not a member of the group list)
        return None
        
    except OperationalError as e:
        raise DatabaseConnectionError(f"Failed to connect to database: {str(e)}")
    except SQLAlchemyError as e:
        raise DatabaseQueryError(f"Failed to query list by name and group: {str(e)}")