src/db/crud.py

from typing import List, Dict, Any

from sqlalchemy.orm import Session

from . import models


def add_publics(
        db: Session, publics: List[Dict[str, str]]) -> List[models.Public]:
    """
    Add multiple public pages to the database.

    Args:
        db (Session): The database session.
        publics (List[Dict[str, str]]): List of public page data.

    Returns:
        List[models.Public]: List of added public page objects.
    """
    db_publics = [models.Public(**public) for public in publics]
    db.add_all(db_publics)
    db.commit()
    for public in db_publics:
        db.refresh(public)
    return db_publics


def add_memes(db: Session, memes: List[Dict[str, Any]]) -> List[models.Meme]:
    """
    Add multiple memes to the database.

    Args:
        db (Session): The database session.
        memes (List[Dict[str, Any]]): List of meme data.

    Returns:
        List[models.Meme]: List of added meme objects.
    """
    db_memes = [models.Meme(**meme) for meme in memes]
    db.add_all(db_memes)
    db.commit()
    for meme in db_memes:
        db.refresh(meme)
    return db_memes


def get_memes_by_publics(db: Session,
                         public_ids: List[int]) -> List[models.Meme]:
    """
    Retrieve memes associated with specific public pages.

    Args:
        db (Session): The database session.
        public_ids (List[int]): List of public page IDs.

    Returns:
        List[models.Meme]: List of meme objects.
    """
    return db.query(
        models.Meme).filter(
        models.Meme.public_id.in_(public_ids)).all()


def get_all_memes(db: Session) -> List[models.Meme]:
    """
    Retrieve all memes from the database.

    Args:
        db (Session): The database session.

    Returns:
        List[models.Meme]: List of all meme objects.
    """
    return db.query(models.Meme).all()


def get_all_publics(db: Session) -> List[models.Public]:
    """
    Retrieve all public pages from the database.

    Args:
        db (Session): The database session.

    Returns:
        List[models.Public]: List of all public page objects.
    """
    return db.query(models.Public).all()


def get_memes_by_ids(db: Session, meme_ids: List[int]) -> List[models.Meme]:
    """
    Retrieve memes by their IDs.

    Args:
        db (Session): The database session.
        meme_ids (List[int]): List of meme IDs.

    Returns:
        List[models.Meme]: List of meme objects.
    """
    return db.query(models.Meme).filter(models.Meme.id.in_(meme_ids)).all()


def get_publics_by_ids(db: Session,
                       public_ids: List[int]) -> List[models.Public]:
    """
    Retrieve public pages by their IDs.

    Args:
        db (Session): The database session.
        public_ids (List[int]): List of public page IDs.

    Returns:
        List[models.Public]: List of public page objects.
    """
    return db.query(
        models.Public).filter(
        models.Public.id.in_(public_ids)).all()


def delete_memes(db: Session, meme_ids: List[int]) -> int:
    """
    Delete memes by their IDs.

    Args:
        db (Session): The database session.
        meme_ids (List[int]): List of meme IDs to delete.

    Returns:
        int: Number of deleted memes.
    """
    deleted_count = db.query(
        models.Meme).filter(
        models.Meme.id.in_(meme_ids)).delete(
            synchronize_session='fetch')
    db.commit()
    return deleted_count


def delete_publics(db: Session, public_ids: List[int]) -> int:
    """
    Delete public pages and their associated memes.

    Args:
        db (Session): The database session.
        public_ids (List[int]): List of public page IDs to delete.

    Returns:
        int: Number of deleted public pages.
    """
    # First, delete associated memes
    db.query(
        models.Meme).filter(
        models.Meme.public_id.in_(public_ids)).delete(
            synchronize_session='fetch')

    # Then delete the publics
    deleted_count = db.query(
        models.Public).filter(
        models.Public.id.in_(public_ids)).delete(
            synchronize_session='fetch')
    db.commit()
    return deleted_count


def get_memes_with_public_info(
        db: Session, meme_ids: List[int]) -> List[tuple[models.Meme, models.Public]]:
    """
    Retrieve memes with their associated public page information.

    Args:
        db (Session): The database session.
        meme_ids (List[int]): List of meme IDs.

    Returns:
        List[tuple[models.Meme, models.Public]]: List of tuples containing meme and public page objects.
    """
    return db.query(models.Meme, models.Public).\
        join(models.Public, models.Meme.public_id == models.Public.id).\
        filter(models.Meme.id.in_(meme_ids)).all()


def update_memes(db: Session, meme_updates: List[Dict[str, Any]]) -> None:
    """
    Update multiple memes in the database.

    Args:
        db (Session): The database session.
        meme_updates (List[Dict[str, Any]]): List of meme update data.
    """
    for update in meme_updates:
        meme_id = update.pop('id')
        db.query(models.Meme).filter(models.Meme.id == meme_id). update({getattr(
            models.Meme, k): v for k, v in update.items()}, synchronize_session='fetch')
    db.commit()


def update_publics(db: Session, public_updates: List[Dict[str, Any]]) -> None:
    """
    Update multiple public pages in the database.

    Args:
        db (Session): The database session.
        public_updates (List[Dict[str, Any]]): List of public page update data.
    """
    for update in public_updates:
        public_id = update.pop('id')
        db.query(models.Public).filter(models.Public.id == public_id). update({getattr(
            models.Public, k): v for k, v in update.items()}, synchronize_session='fetch')
    db.commit()