" (or (ps:@ track artist) "Unknown Artist") " • " (or (ps:@ track album) "Unknown Album") "
"
""
"No playlists created yet.
")
(let ((playlists-html (ps:chain playlists
(map (lambda (playlist)
- (+ ""
+ (+ "
"
"
"
"
" (ps:@ playlist name) "
"
"
" (ps:@ playlist "track-count") " tracks
"
"
"
"
"
- ""
+ ""
+ ""
+ ""
"
"
"
")))
(join ""))))
(setf (ps:@ container inner-h-t-m-l) playlists-html)))))
+ ;; Delete playlist
+ (defun delete-playlist (playlist-id playlist-name)
+ (when (confirm (+ "Are you sure you want to delete playlist \"" playlist-name "\"?"))
+ (let ((form-data (new -Form-data)))
+ (ps:chain form-data (append "playlist-id" playlist-id))
+ (ps:chain (fetch "/api/asteroid/playlists/delete"
+ (ps:create :method "POST" :body form-data))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (progn
+ (alert (+ "Playlist \"" playlist-name "\" deleted"))
+ (load-playlists))
+ (alert (+ "Error deleting playlist: " (ps:@ data message)))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error deleting playlist:" error))
+ (alert "Error deleting playlist")))))))
+
+ ;; View playlist contents
+ (defun view-playlist (playlist-id)
+ (ps:chain
+ (fetch (+ "/api/asteroid/playlists/get?playlist-id=" playlist-id))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (and (= (ps:@ data status) "success") (ps:@ data playlist))
+ (let* ((playlist (ps:@ data playlist))
+ (tracks (or (ps:@ playlist tracks) (array)))
+ (track-list (if (> (ps:@ tracks length) 0)
+ (ps:chain tracks
+ (map (lambda (track index)
+ (+ (+ index 1) ". "
+ (or (ps:@ track artist) "Unknown") " - "
+ (or (ps:@ track title) "Unknown"))))
+ (join "\\n"))
+ "No tracks in playlist")))
+ (alert (+ "Playlist: " (ps:@ playlist name) "\\n"
+ "Tracks: " (ps:@ playlist "track-count") "\\n\\n"
+ track-list)))
+ (alert "Could not load playlist")))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error viewing playlist:" error))
+ (alert "Error viewing playlist")))))
+
;; Load playlist into queue
(defun load-playlist (playlist-id)
(ps:chain
@@ -561,28 +699,31 @@
(setf *play-queue* (array))
;; Add all playlist tracks to queue
- (when (and (ps:@ playlist tracks) (> (ps:@ playlist tracks length) 0))
- (ps:chain (ps:@ playlist tracks)
- (for-each (lambda (track)
- ;; Find the full track object from our tracks array
- (let ((full-track (ps:chain *tracks*
- (find (lambda (trk) (= (ps:@ trk id) (ps:@ track id)))))))
- (when full-track
- (setf (aref *play-queue* (ps:@ *play-queue* length)) full-track)))))
-
- (update-queue-display)
- (alert (+ "Loaded " (ps:@ *play-queue* length) " tracks from \"" (ps:@ playlist name) "\" into queue!"))
-
- ;; Optionally start playing the first track
- (when (> (ps:@ *play-queue* length) 0)
- (let ((first-track (ps:chain *play-queue* (shift)))
- (track-index (ps:chain *tracks*
- (find-index (lambda (trk) (= (ps:@ trk id) (ps:@ first-track id))))))
- )
- (when (>= track-index 0)
- (play-track track-index))))))
- (when (or (not (ps:@ playlist tracks)) (= (ps:@ playlist tracks length) 0))
- (alert (+ "Playlist \"" (ps:@ playlist name) "\" is empty"))))
+ (if (and (ps:@ playlist tracks) (> (ps:@ playlist tracks length) 0))
+ (progn
+ (ps:chain (ps:@ playlist tracks)
+ (for-each (lambda (track)
+ ;; Find the full track object from our tracks array
+ (let ((full-track (ps:chain *tracks*
+ (find (lambda (trk) (= (ps:@ trk id) (ps:@ track id)))))))
+ (when full-track
+ (setf (aref *play-queue* (ps:@ *play-queue* length)) full-track))))))
+
+ (update-queue-display)
+ (let ((loaded-count (ps:@ *play-queue* length)))
+ (alert (+ "Loaded " loaded-count " tracks from \"" (ps:@ playlist name) "\" into queue!"))
+
+ ;; Optionally start playing the first track
+ (when (> loaded-count 0)
+ (let* ((first-track (aref *play-queue* 0))
+ (track-index (ps:chain *tracks*
+ (find-index (lambda (trk) (= (ps:@ trk id) (ps:@ first-track id)))))))
+ ;; Remove first track from queue since we're playing it
+ (ps:chain *play-queue* (shift))
+ (update-queue-display)
+ (when (>= track-index 0)
+ (play-track track-index))))))
+ (alert (+ "Playlist \"" (ps:@ playlist name) "\" is empty"))))
(alert (+ "Error loading playlist: " (or (ps:@ data message) "Unknown error")))))))
(catch (lambda (error)
(ps:chain console (error "Error loading playlist:" error))
@@ -660,7 +801,11 @@
(setf (ps:@ window library-next-page) library-next-page)
(setf (ps:@ window library-go-to-last-page) library-go-to-last-page)
(setf (ps:@ window change-library-tracks-per-page) change-library-tracks-per-page)
- (setf (ps:@ window load-playlist) load-playlist)))
+ (setf (ps:@ window load-playlist) load-playlist)
+ (setf (ps:@ window delete-playlist) delete-playlist)
+ (setf (ps:@ window view-playlist) view-playlist)
+ (setf (ps:@ window show-add-to-playlist-menu) show-add-to-playlist-menu)
+ (setf (ps:@ window add-track-to-playlist) add-track-to-playlist)))
"Compiled JavaScript for web player - generated at load time")
(defun generate-player-js ()
diff --git a/playlist-management.lisp b/playlist-management.lisp
index b236157..9a7d82d 100644
--- a/playlist-management.lisp
+++ b/playlist-management.lisp
@@ -43,53 +43,72 @@
(dm:get-one "playlists" (db:query (:= '_id playlist-id))))
(defun add-track-to-playlist (playlist-id track-id)
- "Add a track to a playlist"
- (db:with-transaction ()
- (let ((playlist (get-playlist-by-id playlist-id)))
- (when playlist
- (let* ((current-track-ids (dm:field playlist "track-ids"))
- ;; Parse comma-separated string into list
- (tracks-list (if (and current-track-ids
- (stringp current-track-ids)
- (not (string= current-track-ids "")))
- (mapcar #'parse-integer
- (cl-ppcre:split "," current-track-ids))
- nil))
- (new-tracks (append tracks-list (list track-id)))
- ;; Convert back to comma-separated string
- (track-ids-str (format nil "~{~a~^,~}" new-tracks)))
- (format t "Adding track ~a to playlist ~a~%" track-id playlist-id)
- (format t "Current track-ids raw: ~a (type: ~a)~%" current-track-ids-raw (type-of current-track-ids-raw))
- (format t "Current track-ids: ~a~%" current-track-ids)
- (format t "Tracks list: ~a~%" tracks-list)
- (format t "New tracks: ~a~%" new-tracks)
- (format t "Track IDs string: ~a~%" track-ids-str)
- ;; Update using track-ids field (defined in schema)
- (setf (dm:field playlist "track-ids") track-ids-str)
- (data-model-save playlist)
- (format t "Update complete~%")
- t)))))
+ "Add a track to a playlist using the playlist_tracks junction table"
+ (format t "Adding track ~a to playlist ~a~%" track-id playlist-id)
+ (handler-case
+ (postmodern:with-connection (get-db-connection-params)
+ ;; Get the next position for this playlist
+ (let* ((max-pos-result (postmodern:query
+ (format nil "SELECT COALESCE(MAX(position), 0) FROM playlist_tracks WHERE playlist_id = ~a"
+ playlist-id)
+ :single))
+ (next-position (1+ (or max-pos-result 0))))
+ (postmodern:execute
+ (format nil "INSERT INTO playlist_tracks (playlist_id, track_id, position) VALUES (~a, ~a, ~a)"
+ playlist-id track-id next-position))
+ (format t "Added track at position ~a~%" next-position)
+ t))
+ (error (e)
+ (format t "Error adding track to playlist: ~a~%" e)
+ nil)))
(defun remove-track-from-playlist (playlist-id track-id)
- "Remove a track from a playlist"
- (let ((playlist (get-playlist-by-id playlist-id)))
- (when playlist
- (let* ((current-track-ids (dm:field playlist "track-ids"))
- ;; Parse comma-separated string into list
- (tracks-list (if (and current-track-ids
- (stringp current-track-ids)
- (not (string= current-track-ids "")))
- (mapcar #'parse-integer
- (cl-ppcre:split "," current-track-ids))
- nil))
- (new-tracks (remove track-id tracks-list :test #'equal))
- ;; Convert back to comma-separated string
- (track-ids-str (format nil "~{~a~^,~}" new-tracks)))
- (setf (dm:field playlist "track-ids") track-ids-str)
- (data-model-save playlist)
- t))))
+ "Remove a track from a playlist using the playlist_tracks junction table"
+ (format t "Removing track ~a from playlist ~a~%" track-id playlist-id)
+ (handler-case
+ (postmodern:with-connection (get-db-connection-params)
+ (postmodern:execute
+ (format nil "DELETE FROM playlist_tracks WHERE playlist_id = ~a AND track_id = ~a"
+ playlist-id track-id))
+ (format t "Track removed~%")
+ t)
+ (error (e)
+ (format t "Error removing track from playlist: ~a~%" e)
+ nil)))
-(defun delete-playlist (playlist-id)
- "Delete a playlist"
- (dm:delete "playlists" (db:query (:= '_id playlist-id)))
- t)
+(defun get-playlist-tracks (playlist-id)
+ "Get all track IDs for a playlist from the junction table, ordered by position"
+ (handler-case
+ (postmodern:with-connection (get-db-connection-params)
+ (let ((results (postmodern:query
+ (format nil "SELECT track_id FROM playlist_tracks WHERE playlist_id = ~a ORDER BY position"
+ playlist-id))))
+ (mapcar #'first results)))
+ (error (e)
+ (format t "Error getting playlist tracks: ~a~%" e)
+ nil)))
+
+(defun get-playlist-track-count (playlist-id)
+ "Get the number of tracks in a playlist"
+ (handler-case
+ (postmodern:with-connection (get-db-connection-params)
+ (let ((result (postmodern:query
+ (format nil "SELECT COUNT(*) FROM playlist_tracks WHERE playlist_id = ~a"
+ playlist-id)
+ :single)))
+ (format t "Track count for playlist ~a: ~a (type: ~a)~%" playlist-id result (type-of result))
+ ;; Ensure we return an integer
+ (if (integerp result)
+ result
+ (if result (parse-integer (format nil "~a" result) :junk-allowed t) 0))))
+ (error (e)
+ (format t "Error getting playlist track count: ~a~%" e)
+ 0)))
+
+(defun delete-playlist (playlist-id user-id)
+ "Delete a playlist (only if owned by user)"
+ (let ((playlist (get-playlist-by-id playlist-id)))
+ (when (and playlist (equal (dm:field playlist "user-id") user-id))
+ ;; Junction table entries will be deleted by CASCADE
+ (dm:delete "playlists" (db:query (:= '_id playlist-id)))
+ t)))