WIP

Author: CalPinSW

backend/src/controllers/database.py

@@ -13,7 +13,7 @@
     get_playlist_albums,
     get_playlist_by_id_or_none,
     get_user_playlists,
-    update_playlist,
+    update_playlist_with_albums,
 )
 from src.database.crud.user import get_or_create_user
 from src.musicbrainz import MusicbrainzClient
@@ -59,7 +59,7 @@ def populate_user():
                                 access_token=access_token, id=simplified_playlist.id
                             ),
                         ]
-                        update_playlist(playlist, albums)
+                        update_playlist_with_albums(playlist, albums)
 
         return make_response("Playlist data populated", 201)
 

backend/src/controllers/music_data.py

@@ -1,6 +1,14 @@
 from logging import Logger
 from flask import Blueprint, jsonify, make_response, request
-from src.database.crud.playlist import get_user_playlists
+from src.database.crud.playlist import (
+    get_playlist_albums,
+    get_playlist_albums_with_genres,
+    get_playlist_by_id_or_none,
+    get_recent_user_playlists,
+    get_user_playlists,
+    update_playlist_info,
+    update_playlist_with_albums,
+)
 from src.dataclasses.playback_info import PlaybackInfo
 from src.dataclasses.playback_request import StartPlaybackRequest
 from src.dataclasses.playlist import Playlist
@@ -33,17 +41,38 @@ def index():
             )
         )
 
+    @music_controller.route("playlists/recent")
+    def recent_playlists():
+        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")
+
+        return jsonify(
+            get_recent_user_playlists(
+                user_id=user_id,
+                limit=limit,
+                offset=offset,
+                search=search
+            )
+        )
+
     @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()
+        db_playlist = get_playlist_by_id_or_none(id)
+        if db_playlist is not None:
+            return jsonify(db_playlist.__data__)
+        else:
+            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")
+        update_playlist_info(id=id, name=name, description=description)
         spotify.update_playlist(
             access_token=access_token,
             id=id,
@@ -54,13 +83,18 @@ def post_edit_playlist(id):
 
     @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
-            )
-        ]
+        db_playlist = get_playlist_by_id_or_none(id)
+        if db_playlist is not None:
+            album_info_list = get_playlist_albums_with_genres(id)
+            return jsonify(album_info_list)
+        else:
+            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():

backend/src/database/crud/playlist.py

@@ -1,8 +1,21 @@
 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.database.models import (
+    AlbumArtistRelationship,
+    AlbumGenreRelationship,
+    DbAlbum,
+    DbArtist,
+    DbGenre,
+    DbPlaylist,
+    DbUser,
+    PlaylistAlbumRelationship,
+    peewee_model_to_dict,
+)
 from src.dataclasses.album import Album
 from src.dataclasses.playlist import Playlist
+from peewee import fn
+import re
+from datetime import datetime
 
 
 def get_playlist_by_id_or_none(id: str):
@@ -27,7 +40,34 @@ def create_playlist(playlist: Playlist, albums: List[Album], user: DbUser):
     return playlist
 
 
-def update_playlist(playlist: Playlist, albums: List[Album]):
+def update_playlist_info(
+    id: str,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    snapshot_id: Optional[str] = None,
+    uri: Optional[str] = None,
+) -> DbPlaylist | None:
+    update_data = {}
+    if name is not None:
+        update_data["name"] = name
+    if description is not None:
+        update_data["description"] = description
+    if snapshot_id is not None:
+        update_data["snapshot_id"] = snapshot_id
+    if uri is not None:
+        update_data["uri"] = uri
+
+    if update_data:
+        query = DbPlaylist.update(update_data).where(DbPlaylist.id == id)
+        query.execute()
+
+        updated_playlist = DbPlaylist.get_by_id(id)
+        return updated_playlist
+
+    return None
+
+
+def update_playlist_with_albums(playlist: Playlist, albums: List[Album]):
     playlist = DbPlaylist.update(
         id=playlist.id,
         description=playlist.description,
@@ -78,6 +118,48 @@ def get_user_playlists(
         return list(query.execute())
 
 
+def get_recent_user_playlists(
+    user_id: str,
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+    search: Optional[str] = None,
+) -> List[DbPlaylist]:
+
+    # Use TO_DATE function in PostgreSQL to convert the extracted date into a proper date
+    query = (
+        DbPlaylist.select()
+        .where(
+            (
+                DbPlaylist.name.startswith("New Albums")
+                | DbPlaylist.name.startswith("Best Albums")
+            )
+        )
+        # Convert the date string into a proper date format for ordering
+        .order_by(fn.TO_DATE(fn.RIGHT(DbPlaylist.name, 8), "DD/MM/YY").desc())
+        .limit(limit)
+        .offset(offset)
+    )
+
+    if search:
+        query = query.where(DbPlaylist.name.contains(search))
+
+    playlists = []
+    for playlist in query:
+        # Add playlist to the result with parsed date
+        playlists.append(
+            {
+                "id": playlist.id,
+                "name": playlist.name,
+                "description": playlist.description,
+                "image_url": playlist.image_url,
+                "user_id": playlist.user.id,
+                "snapshot_id": playlist.snapshot_id,
+                "uri": playlist.uri,
+            }
+        )
+    return playlists
+
+
 def get_playlist_albums(playlist_id: str) -> List[DbAlbum]:
     query = (
         DbAlbum.select()
@@ -86,3 +168,51 @@ def get_playlist_albums(playlist_id: str) -> List[DbAlbum]:
         .where(DbPlaylist.id == playlist_id)
     )
     return list(query)
+
+
+def get_playlist_albums_with_genres(playlist_id: str) -> List[dict]:
+    # Step 1: Retrieve all albums associated with the given playlist
+    albums_query = (
+        DbAlbum.select()
+        .join(
+            PlaylistAlbumRelationship,
+            on=(PlaylistAlbumRelationship.album == DbAlbum.id),
+        )
+        .join(DbPlaylist, on=(PlaylistAlbumRelationship.playlist == DbPlaylist.id))
+        .where(DbPlaylist.id == playlist_id)
+    )
+
+    # Step 2: Retrieve genres and artists for each album
+    albums_with_details = []
+    for album in albums_query:
+        genres = (
+            DbGenre.select(DbGenre.name)
+            .join(
+                AlbumGenreRelationship, on=(AlbumGenreRelationship.genre == DbGenre.id)
+            )
+            .where(AlbumGenreRelationship.album == album.id)
+            .execute()
+        )
+
+        artists = (
+            DbArtist.select()
+            .join(
+                AlbumArtistRelationship,
+                on=(AlbumArtistRelationship.artist == DbArtist.id),
+            )
+            .where(AlbumArtistRelationship.album == album.id)
+        )
+
+        album_details = {
+            "id": album.id,
+            "name": album.name,
+            "uri": album.uri,
+            "image_url": album.image_url,
+            "release_date": album.release_date,
+            "total_tracks": album.total_tracks,
+            "genres": [genre.name for genre in genres],
+            "artists": [peewee_model_to_dict(artist) for artist in artists],
+        }
+        albums_with_details.append(album_details)
+
+    return albums_with_details

backend/src/database/models.py

@@ -10,6 +10,8 @@
 
 database = PostgresqlDatabase(Config().DB_CONNECTION_STRING)
 
+def peewee_model_to_dict(model_instance):
+    return {field: getattr(model_instance, field) for field in model_instance._meta.fields}
 
 class BaseModel(Model):
     class Meta:

frontend/eslint.config.js

@@ -10,9 +10,9 @@ export default [
   pluginJs.configs.recommended,
   ...tseslint.configs.recommended,
   pluginReact.configs.flat.recommended,
-  {
-    rules: {"unused-imports/no-unused-imports": "error"}
-  },
+  // {
+  //   rules: {"unused-imports/no-unused-imports": "error"}
+  // },
   {
     ignores: ["public/bundle.js"],
   },

frontend/package-lock.json

@@ -28,6 +28,7 @@
 	"homepage": "https://github.com/CalPinSW/playlist-manager#readme",
 	"devDependencies": {
 		"@eslint/js": "^9.9.0",
+		"@types/lodash": "^4.17.7",
 		"@types/node": "^20.12.7",
 		"@types/react-dom": "^18.2.18",
 		"esbuild": "^0.23.1",
@@ -41,9 +42,11 @@
 		"typescript-eslint": "^8.2.0"
 	},
 	"dependencies": {
-		"@tanstack/react-table": "^8.20.1",
 		"@tanstack/react-query": "^5.51.21",
+		"@tanstack/react-table": "^8.20.1",
 		"dotenv": "^16.4.5",
+		"embla-carousel-react": "^8.2.1",
+		"lodash": "^4.17.21",
 		"moment": "^2.30.1",
 		"react": "^18.3.1",
 		"react-dom": "^18.3.1",

frontend/package.json

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="en" style="height: 100%">
+<html lang="en" style="height: 100%" >
   <head>
     <meta charset="UTF-8" />
     <meta