Use db for fetching all playlists

Author: CalPinSW

backend/src/app.py

@@ -2,6 +2,7 @@
 from flask_cors import CORS
 from src.controllers.database import database_controller
 from src.controllers.spotify import spotify_controller
+from src.controllers.music_data import music_controller
 from src.exceptions.Unauthorized import UnauthorizedException
 from src.flask_config import Config
 from src.musicbrainz import MusicbrainzClient
@@ -48,6 +49,7 @@ def handle_unauthorized_exception(_):
 
     app.register_blueprint(auth_controller(spotify=spotify))
     app.register_blueprint(spotify_controller(spotify=spotify))
+    app.register_blueprint(music_controller(spotify=spotify))
     app.register_blueprint(
         database_controller(spotify=spotify, musicbrainz=musicbrainz)
     )

backend/src/controllers/music_data.py

@@ -0,0 +1,78 @@
+from logging import Logger
+from flask import Blueprint, jsonify, make_response, request
+from src.database.crud.playlist import get_user_playlists
+from src.dataclasses.playback_info import PlaybackInfo
+from src.dataclasses.playback_request import StartPlaybackRequest
+from src.dataclasses.playlist import Playlist
+from src.spotify import SpotifyClient
+import sys
+
+
+def music_controller(spotify: SpotifyClient):
+    music_controller = Blueprint(
+        name="music_controller", import_name=__name__, url_prefix="/music"
+    )
+
+    @music_controller.route("playlists")
+    def index():
+        user_id = request.cookies.get("user_id")
+        limit = request.args.get("limit", type=int)
+        offset = request.args.get("offset", type=int)
+        search = request.args.get("search")
+        sort_by = request.args.get("sort_by")
+        desc = request.args.get("desc") == "True"
+        return jsonify(
+            get_user_playlists(
+                user_id=user_id,
+                limit=limit,
+                offset=offset,
+                search=search,
+                sort_by=sort_by,
+                desc=desc,
+                as_dicts=True,
+            )
+        )
+
+    @music_controller.route("playlist/<id>", methods=["GET"])
+    def get_playlist(id):
+        access_token = request.cookies.get("spotify_access_token")
+        playlist = spotify.get_playlist(access_token=access_token, id=id)
+        return playlist.model_dump()
+
+    @music_controller.route("playlist/<id>", methods=["POST"])
+    def post_edit_playlist(id):
+        access_token = request.cookies.get("spotify_access_token")
+        name = request.json.get("name")
+        description = request.json.get("description")
+        spotify.update_playlist(
+            access_token=access_token,
+            id=id,
+            name=name,
+            description=description,
+        )
+        return make_response("playlist updated", 204)
+
+    @music_controller.route("playlist/<id>/albums", methods=["GET"])
+    def get_playlist_album_info(id):
+        access_token = request.cookies.get("spotify_access_token")
+        return [
+            album.model_dump()
+            for album in spotify.get_playlist_album_info(
+                access_token=access_token, id=id
+            )
+        ]
+
+    @music_controller.route("find_associated_playlists", methods=["POST"])
+    def find_associated_playlists():
+        access_token = request.cookies.get("spotify_access_token")
+        user_id = request.cookies.get("user_id")
+        playlist = Playlist.model_validate(request.json)
+        associated_playlists = spotify.find_associated_playlists(
+            user_id=user_id, access_token=access_token, playlist=playlist
+        )
+        return [
+            associated_playlist.model_dump()
+            for associated_playlist in associated_playlists
+        ]
+
+    return music_controller

backend/src/database/crud/playlist.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 from src.database.crud.album import create_album_or_none
 from src.database.models import DbAlbum, DbPlaylist, DbUser, PlaylistAlbumRelationship
 from src.dataclasses.album import Album
@@ -46,8 +46,36 @@ def update_playlist(playlist: Playlist, albums: List[Album]):
     return playlist
 
 
-def get_user_playlists(user_id: str) -> List[DbPlaylist]:
-    return DbPlaylist.select().where(DbPlaylist.user == user_id).execute()
+def get_user_playlists(
+    user_id: str,
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+    search: Optional[str] = None,
+    sort_by: Optional[str] = None,
+    desc: bool = True,
+    as_dicts: bool = False,
+) -> List[DbPlaylist]:
+    query = DbPlaylist.select().where(DbPlaylist.user == user_id)
+
+    if search:
+        query = query.where(DbPlaylist.name.contains(search))
+
+    if sort_by:
+        sort_field = getattr(DbPlaylist, sort_by)
+        if desc:
+            query = query.order_by(sort_field.desc())
+        else:
+            query = query.order_by(sort_field.asc())
+
+    if limit is not None:
+        query = query.limit(limit)
+    if offset is not None:
+        query = query.offset(offset)
+
+    if as_dicts:
+        return list(query.dicts())
+    else:
+        return list(query.execute())
 
 
 def get_playlist_albums(playlist_id: str) -> List[DbAlbum]:

frontend/src/api/index.ts

@@ -43,7 +43,7 @@ export const getPlaylists = async (
 	offset: number,
 	limit: number,
 ): Promise<Playlist[]> => {
-	const endpoint = `spotify/playlists?limit=${encodeURIComponent(
+	const endpoint = `music/playlists?limit=${encodeURIComponent(
 		limit,
 	)}&offset=${encodeURIComponent(offset)}`;
 	return jsonRequest(endpoint, RequestMethod.GET);
@@ -54,7 +54,7 @@ export const addPlaylist = async (playlist: Playlist): Promise<Playlist> => {
 };
 
 export const getPlaylist = async (id: string): Promise<Playlist> => {
-	return jsonRequest(`spotify/edit-playlist/${id}`, RequestMethod.GET);
+	return jsonRequest(`music/playlist/${id}`, RequestMethod.GET);
 };
 
 export const updatePlaylist = async (playlist: Playlist): Promise<Playlist> => {
@@ -76,7 +76,7 @@ export const getPlaylistAlbums = async (
 	playlistId: string,
 ): Promise<Album[]> => {
 	return jsonRequest(
-		`spotify/playlist/${playlistId}/albums`,
+		`music/playlist/${playlistId}/albums`,
 		RequestMethod.GET,
 	);
 };

frontend/src/interfaces/Playlist.ts

@@ -18,7 +18,7 @@ export interface Playlist {
   };
   href: string;
   id: string;
-  images: Image[];
+  image_url: string;
   owner: User;
   public: false;
   snapshot_id: string;

frontend/src/playlistTable/PlaylistTable.tsx

@@ -29,9 +29,9 @@ const PlaylistTable: FC<IPlaylistTable> = ({ playlists }) => {
       id: "image",
       size: 20,
       cell: ({ row }) => {
-        if (row.original.images?.[0]?.url) {
+        if (row.original.image_url) {
           return (
-            <img src={row.original.images[0].url} className="w-full"></img>
+            <img src={row.original.image_url} className="w-full"></img>
           );
         }
         return <PlaylistIcon className="w-full h-full fill-primary-500" />;