swingmusic-extended/app/api/favorites.py

from typing import List, TypeVar

from flask_jwt_extended import current_user
from flask_openapi3 import Tag
from flask_openapi3 import APIBlueprint
from pydantic import BaseModel, Field

from app.api.apischemas import GenericLimitSchema
from app.db.libdata import ArtistTable
from app.db.libdata import AlbumTable, TrackTable
from app.db.userdata import FavoritesTable
from app.models import FavType
from app.settings import Defaults

from app.store.albums import AlbumStore
from app.store.artists import ArtistStore
from app.store.tracks import TrackStore

from app.serializers.track import serialize_track, serialize_tracks
from app.serializers.artist import (
    serialize_for_card as serialize_artist,
    serialize_for_cards,
)
from app.utils.dates import timestamp_to_time_passed
from app.serializers.album import serialize_for_card, serialize_for_card_many

bp_tag = Tag(name="Favorites", description="Your favorite items")
api = APIBlueprint("favorites", __name__, url_prefix="/favorites", abp_tags=[bp_tag])


T = TypeVar("T")


def remove_none(items: List[T]) -> List[T]:
    return [i for i in items if i is not None]


class FavoritesAddBody(BaseModel):
    hash: str = Field(
        description="The hash of the item",
        min_length=Defaults.HASH_LENGTH,
        max_length=Defaults.HASH_LENGTH,
        example=Defaults.API_ALBUMHASH,
    )
    type: str = Field(description="The type of the item", example=FavType.album)


@api.post("/add")
def toggle_favorite(body: FavoritesAddBody):
    """
    Adds a favorite to the database.
    """

    try:
        FavoritesTable.insert_item({"hash": body.hash, "type": body.type})
    except:
        return {"msg": "Failed! An error occured"}, 500

    if body.type == FavType.track:
        entry = TrackStore.trackhashmap.get(body.hash)
        if entry is not None:
            entry.toggle_favorite_user()

    elif body.type == FavType.album:
        entry = AlbumStore.albummap.get(body.hash)

        if entry is not None:
            entry.toggle_favorite_user()
    elif body.type == FavType.artist:
        entry = ArtistStore.artistmap.get(body.hash)

        if entry is not None:
            entry.toggle_favorite_user()

    return {"msg": "Added to favorites"}


@api.post("/remove")
def remove_favorite(body: FavoritesAddBody):
    """
    Removes a favorite from the database.
    """
    FavoritesTable.remove_item({"hash": body.hash, "type": body.type})

    if body.type == FavType.track:
        TrackTable.set_is_favorite(body.hash, False)
    elif body.type == FavType.album:
        AlbumTable.set_is_favorite(body.hash, False)
    elif body.type == FavType.artist:
        ArtistTable.set_is_favorite(body.hash, False)

    return {"msg": "Removed from favorites"}


class GetAllOfTypeQuery(GenericLimitSchema):
    """
    Extending this class will give you a model with the `limit` field
    """

    start: int = Field(
        description="Where to start from",
        example=Defaults.API_CARD_LIMIT,
        default=Defaults.API_CARD_LIMIT,
    )


@api.get("/albums")
def get_favorite_albums(query: GetAllOfTypeQuery):
    """
    Get favorite albums
    """
    fav_albums, total = FavoritesTable.get_fav_albums(query.start, query.limit)
    fav_albums.reverse()

    albums = AlbumStore.get_albums_by_hashes(a.hash for a in fav_albums)
    return {"albums": serialize_for_card_many(albums), "total": total}


@api.get("/tracks")
def get_favorite_tracks(query: GetAllOfTypeQuery):
    """
    Get favorite tracks
    """
    tracks, total = FavoritesTable.get_fav_tracks(query.start, query.limit)

    tracks.reverse()
    tracks = TrackTable.get_tracks_by_trackhashes([t.hash for t in tracks])

    return {"tracks": serialize_tracks(tracks), "total": total}


@api.get("/artists")
def get_favorite_artists(query: GetAllOfTypeQuery):
    """
    Get favorite artists
    """
    artists, total = FavoritesTable.get_fav_artists(
        start=query.start,
        limit=query.limit,
    )
    artists.reverse()

    artists = ArtistStore.get_artists_by_hashes(a.hash for a in artists)
    return {"artists": [serialize_artist(a) for a in artists], "total": total}


class GetAllFavoritesQuery(BaseModel):
    """
    Extending this class will give you a model with the `limit` field
    """

    track_limit: int = Field(
        description="The number of tracks to return",
        example=Defaults.API_CARD_LIMIT,
        default=Defaults.API_CARD_LIMIT,
    )

    album_limit: int = Field(
        description="The number of albums to return",
        example=Defaults.API_CARD_LIMIT,
        default=Defaults.API_CARD_LIMIT,
    )

    artist_limit: int = Field(
        description="The number of artists to return",
        example=Defaults.API_CARD_LIMIT,
        default=Defaults.API_CARD_LIMIT,
    )


@api.get("")
def get_all_favorites(query: GetAllFavoritesQuery):
    """
    Returns all the favorites in the database.
    """
    track_limit = query.track_limit
    album_limit = query.album_limit
    artist_limit = query.artist_limit

    # largest is x2 to accound for broken hashes if any
    largest = max(track_limit, album_limit, artist_limit)

    favs = FavoritesTable.get_all()
    favs.reverse()

    tracks = []
    albums = []
    artists = []

    track_master_hash = TrackStore.trackhashmap.keys()
    album_master_hash = AlbumStore.albummap.keys()
    artist_master_hash = ArtistStore.artistmap.keys()

    # INFO: Filter out invalid hashes (file not found or tags edited)
    for fav in favs:
        hash = fav.hash
        type = fav.type

        if type == FavType.track:
            tracks.append(hash) if hash in track_master_hash else None

        if type == FavType.artist:
            artists.append(hash) if hash in artist_master_hash else None

        if type == FavType.album:
            albums.append(hash) if hash in album_master_hash else None

    count = {
        "tracks": len(tracks),
        "albums": len(albums),
        "artists": len(artists),
    }

    tracks = TrackStore.get_tracks_by_trackhashes(tracks[:track_limit])
    albums = AlbumStore.get_albums_by_hashes(albums[:album_limit])
    artists = ArtistStore.get_artists_by_hashes(artists[:artist_limit])

    recents = []

    for fav in favs:
        if len(recents) >= largest:
            break

        if fav.type == FavType.album:
            album = next((a for a in albums if a.albumhash == fav.hash), None)

            if album is None:
                continue

            album = serialize_for_card(album)
            album["help_text"] = "album"
            album["time"] = timestamp_to_time_passed(fav.timestamp)

            recents.append(
                {
                    "type": "album",
                    "item": album,
                }
            )

        if fav.type == FavType.artist:
            artist = next((a for a in artists if a.artisthash == fav.hash), None)

            if artist is None:
                continue

            artist = serialize_artist(artist)
            artist["help_text"] = "artist"
            artist["time"] = timestamp_to_time_passed(fav.timestamp)

            recents.append(
                {
                    "type": "artist",
                    "item": artist,
                }
            )

        if fav.type == FavType.track:
            track = next((t for t in tracks if t.trackhash == fav.hash), None)

            if track is None:
                continue

            track = serialize_track(track)
            track["help_text"] = "track"
            track["time"] = timestamp_to_time_passed(fav.timestamp)

            recents.append({"type": "track", "item": track})

    return {
        "recents": recents[:album_limit],
        "tracks": serialize_tracks(tracks[:track_limit]),
        "albums": serialize_for_card_many(albums[:album_limit]),
        "artists": serialize_for_cards(artists[:artist_limit]),
        "count": count,
    }


@api.get("/check")
def check_favorite(query: FavoritesAddBody):
    """
    Checks if a favorite exists in the database.
    """
    itemhash = query.hash
    itemtype = query.type

    return {"is_favorite": FavoritesTable.check_exists(itemhash, itemtype)}