Error loading tracks
")))))))
+
+ ;; Display tracks with pagination
+ (defun display-tracks (track-list)
+ (setf *filtered-tracks* track-list)
+ (setf *current-page* 1)
+ (render-page))
+
+ ;; Render current page of tracks
+ (defun render-page ()
+ (let ((container (ps:chain document (get-element-by-id "tracks-container")))
+ (pagination-controls (ps:chain document (get-element-by-id "pagination-controls"))))
+
+ (when (= (ps:@ *filtered-tracks* length) 0)
+ (when container
+ (setf (ps:@ container inner-h-t-m-l)
+ "No tracks found. Click \"Scan Library\" to add tracks.
"))
+ (when pagination-controls
+ (setf (ps:@ pagination-controls style display) "none"))
+ (return))
+
+ ;; Calculate pagination
+ (let* ((total-pages (ps:chain -math (ceil (/ (ps:@ *filtered-tracks* length) *tracks-per-page*))))
+ (start-index (* (- *current-page* 1) *tracks-per-page*))
+ (end-index (+ start-index *tracks-per-page*))
+ (tracks-to-show (ps:chain *filtered-tracks* (slice start-index end-index))))
+
+ ;; Render tracks for current page
+ (let ((tracks-html
+ (ps:chain tracks-to-show
+ (map (lambda (track)
+ (+ ""
+ "
")))
+ (join ""))))
+
+ (when container
+ (setf (ps:@ container inner-h-t-m-l) tracks-html)))
+
+ ;; Update pagination controls
+ (let ((page-info (ps:chain document (get-element-by-id "page-info"))))
+ (when page-info
+ (setf (ps:@ page-info text-content)
+ (+ "Page " *current-page* " of " total-pages " (" (ps:@ *filtered-tracks* length) " tracks)"))))
+
+ (when pagination-controls
+ (setf (ps:@ pagination-controls style display)
+ (if (> total-pages 1) "block" "none"))))))
+
+ ;; Pagination functions
+ (defun go-to-page (page)
+ (let ((total-pages (ps:chain -math (ceil (/ (ps:@ *filtered-tracks* length) *tracks-per-page*)))))
+ (when (and (>= page 1) (<= page total-pages))
+ (setf *current-page* page)
+ (render-page))))
+
+ (defun previous-page ()
+ (when (> *current-page* 1)
+ (setf *current-page* (- *current-page* 1))
+ (render-page)))
+
+ (defun next-page ()
+ (let ((total-pages (ps:chain -math (ceil (/ (ps:@ *filtered-tracks* length) *tracks-per-page*)))))
+ (when (< *current-page* total-pages)
+ (setf *current-page* (+ *current-page* 1))
+ (render-page))))
+
+ (defun go-to-last-page ()
+ (let ((total-pages (ps:chain -math (ceil (/ (ps:@ *filtered-tracks* length) *tracks-per-page*)))))
+ (setf *current-page* total-pages)
+ (render-page)))
+
+ (defun change-tracks-per-page ()
+ (let ((select-el (ps:chain document (get-element-by-id "tracks-per-page"))))
+ (when select-el
+ (setf *tracks-per-page* (parse-int (ps:@ select-el value)))
+ (setf *current-page* 1)
+ (render-page))))
+
+ ;; Scan music library
+ (defun scan-library ()
+ (let ((status-el (ps:chain document (get-element-by-id "scan-status")))
+ (scan-btn (ps:chain document (get-element-by-id "scan-library"))))
+
+ (when status-el
+ (setf (ps:@ status-el text-content) "Scanning..."))
+ (when scan-btn
+ (setf (ps:@ scan-btn disabled) t))
+
+ (ps:chain
+ (fetch "/api/asteroid/admin/scan-library" (ps:create :method "POST"))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (progn
+ (when status-el
+ (setf (ps:@ status-el text-content)
+ (+ "✅ Added " (ps:getprop data "tracks-added") " tracks")))
+ (load-tracks))
+ (when status-el
+ (setf (ps:@ status-el text-content) "❌ Scan failed"))))))
+ (catch (lambda (error)
+ (when status-el
+ (setf (ps:@ status-el text-content) "❌ Scan error"))
+ (ps:chain console (error "Error scanning library:" error))))
+ (finally (lambda ()
+ (when scan-btn
+ (setf (ps:@ scan-btn disabled) nil))
+ (set-timeout (lambda ()
+ (when status-el
+ (setf (ps:@ status-el text-content) "")))
+ 3000))))))
+
+ ;; Filter tracks based on search
+ (defun filter-tracks ()
+ (let* ((search-input (ps:chain document (get-element-by-id "track-search")))
+ (query (when search-input (ps:chain (ps:@ search-input value) (to-lower-case))))
+ (filtered (ps:chain *tracks*
+ (filter (lambda (track)
+ (or (ps:chain (or (ps:@ track title) "") (to-lower-case) (includes query))
+ (ps:chain (or (ps:@ track artist) "") (to-lower-case) (includes query))
+ (ps:chain (or (ps:@ track album) "") (to-lower-case) (includes query))))))))
+ (display-tracks filtered)))
+
+ ;; Sort tracks
+ (defun sort-tracks ()
+ (let* ((sort-select (ps:chain document (get-element-by-id "sort-tracks")))
+ (sort-by (when sort-select (ps:@ sort-select value)))
+ (sorted (ps:chain *tracks*
+ (slice)
+ (sort (lambda (a b)
+ (let ((a-val (or (ps:getprop a sort-by) ""))
+ (b-val (or (ps:getprop b sort-by) "")))
+ (ps:chain a-val (locale-compare b-val))))))))
+ (display-tracks sorted)))
+
+ ;; Initialize audio player
+ (defun init-audio-player ()
+ (unless *audio-player*
+ (setf *audio-player* (new (-audio)))
+ (ps:chain *audio-player*
+ (add-event-listener "ended" (lambda ()
+ (setf *current-track-id* nil)
+ (update-player-status))))
+ (ps:chain *audio-player*
+ (add-event-listener "error" (lambda (e)
+ (ps:chain console (error "Audio playback error:" e))
+ (alert "Error playing audio file")))))
+ *audio-player*)
+
+ ;; Player functions
+ (defun play-track (track-id)
+ (unless track-id
+ (alert "Please select a track to play")
+ (return))
+
+ (ps:chain
+ (-promise (lambda (resolve reject)
+ (let ((player (init-audio-player)))
+ (setf (ps:@ player src) (+ "/asteroid/tracks/" track-id "/stream"))
+ (ps:chain player (play))
+ (setf *current-track-id* track-id)
+ (update-player-status)
+ (resolve))))
+ (catch (lambda (error)
+ (ps:chain console (error "Play error:" error))
+ (alert "Error playing track")))))
+
+ (defun pause-player ()
+ (ps:chain
+ (-promise (lambda (resolve reject)
+ (when (and *audio-player* (not (ps:@ *audio-player* paused)))
+ (ps:chain *audio-player* (pause))
+ (update-player-status))
+ (resolve)))
+ (catch (lambda (error)
+ (ps:chain console (error "Pause error:" error))))))
+
+ (defun stop-player ()
+ (ps:chain
+ (-promise (lambda (resolve reject)
+ (when *audio-player*
+ (ps:chain *audio-player* (pause))
+ (setf (ps:@ *audio-player* current-time) 0)
+ (setf *current-track-id* nil)
+ (update-player-status))
+ (resolve)))
+ (catch (lambda (error)
+ (ps:chain console (error "Stop error:" error))))))
+
+ (defun resume-player ()
+ (ps:chain
+ (-promise (lambda (resolve reject)
+ (when (and *audio-player* (ps:@ *audio-player* paused) *current-track-id*)
+ (ps:chain *audio-player* (play))
+ (update-player-status))
+ (resolve)))
+ (catch (lambda (error)
+ (ps:chain console (error "Resume error:" error))))))
+
+ (defun update-player-status ()
+ (ps:chain
+ (fetch "/api/asteroid/player/status")
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (data)
+ (when (= (ps:@ data status) "success")
+ (let ((player (ps:@ data player))
+ (state-el (ps:chain document (get-element-by-id "player-state")))
+ (track-el (ps:chain document (get-element-by-id "current-track"))))
+ (when state-el
+ (setf (ps:@ state-el text-content) (ps:@ player state)))
+ (when track-el
+ (setf (ps:@ track-el text-content) (or (ps:getprop player "current-track") "None")))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error updating player status:" error))))))
+
+ ;; Utility functions
+ (defun stream-track (track-id)
+ (ps:chain window (open (+ "/asteroid/tracks/" track-id "/stream") "_blank")))
+
+ (defun delete-track (track-id)
+ (when (confirm "Are you sure you want to delete this track?")
+ (alert "Track deletion not yet implemented")))
+
+ (defun copy-files ()
+ (ps:chain
+ (fetch "/admin/copy-files")
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (data)
+ (if (= (ps:@ data status) "success")
+ (progn
+ (alert (ps:@ data message))
+ (load-tracks))
+ (alert (+ "Error: " (ps:@ data message))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error copying files:" error))
+ (alert "Failed to copy files")))))
+
+ (defun open-incoming-folder ()
+ (alert "Copy your MP3 files to: /home/glenn/Projects/Code/asteroid/music/incoming/\n\nThen click \"Copy Files to Library\" to add them to your music collection."))
+
+ ;; Setup live stream monitor
+ (defun setup-live-stream-monitor ()
+ (let ((live-audio (ps:chain document (get-element-by-id "live-stream-audio"))))
+ (when live-audio
+ (setf (ps:@ live-audio preload) "none"))))
+
+ ;; Live stream info update
+ (defun update-live-stream-info ()
+ ;; Don't update if stream is paused
+ (let ((live-audio (ps:chain document (get-element-by-id "live-stream-audio"))))
+ (when (and live-audio (ps:@ live-audio paused))
+ (return)))
+
+ (ps:chain
+ (fetch "/api/asteroid/partial/now-playing-inline")
+ (then (lambda (response)
+ (let ((content-type (ps:chain response headers (get "content-type"))))
+ (unless (ps:chain content-type (includes "text/plain"))
+ (ps:chain console (error "Unexpected content type:" content-type))
+ (return))
+ (ps:chain response (text)))))
+ (then (lambda (now-playing-text)
+ (let ((now-playing-el (ps:chain document (get-element-by-id "live-now-playing"))))
+ (when now-playing-el
+ (setf (ps:@ now-playing-el text-content) now-playing-text)))))
+ (catch (lambda (error)
+ (ps:chain console (error "Could not fetch stream info:" error))
+ (let ((now-playing-el (ps:chain document (get-element-by-id "live-now-playing"))))
+ (when now-playing-el
+ (setf (ps:@ now-playing-el text-content) "Error loading stream info")))))))
+
+ ;; ========================================
+ ;; Stream Queue Management
+ ;; ========================================
+
+ ;; Load current stream queue
+ (defun load-stream-queue ()
+ (ps:chain
+ (fetch "/api/asteroid/stream/queue")
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (when (= (ps:@ data status) "success")
+ (setf *stream-queue* (or (ps:@ data queue) (array)))
+ (display-stream-queue)))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading stream queue:" error))
+ (let ((container (ps:chain document (get-element-by-id "stream-queue-container"))))
+ (when container
+ (setf (ps:@ container inner-h-t-m-l)
+ ""
+ "
"
+ "" (or (ps:@ track title) "Unknown Title") "
"
+ "" (or (ps:@ track artist) "Unknown Artist") "
"
+ "" (or (ps:@ track album) "Unknown Album") "
"
+ ""
+ ""
+ ""
+ "
"
+ "Error loading queue
")))))))
+
+ ;; Display stream queue
+ (defun display-stream-queue ()
+ (let ((container (ps:chain document (get-element-by-id "stream-queue-container"))))
+ (when container
+ (if (= (ps:@ *stream-queue* length) 0)
+ (setf (ps:@ container inner-h-t-m-l)
+ "Queue is empty. Add tracks below.
")
+ (let ((html ""))
+ (ps:chain *stream-queue*
+ (for-each (lambda (item index)
+ (when item
+ (let ((is-first (= index 0))
+ (is-last (= index (- (ps:@ *stream-queue* length) 1))))
+ (setf html
+ (+ html
+ "
"))
+ (setf (ps:@ container inner-h-t-m-l) html))))))
+
+ ;; Clear stream queue
+ (defun clear-stream-queue ()
+ (unless (confirm "Clear the entire stream queue? This will stop playback until new tracks are added.")
+ (return))
+
+ (ps:chain
+ (fetch "/api/asteroid/stream/queue/clear" (ps:create :method "POST"))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (progn
+ (alert "Queue cleared successfully")
+ (load-stream-queue))
+ (alert (+ "Error clearing queue: " (or (ps:@ data message) "Unknown error")))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error clearing queue:" error))
+ (alert "Error clearing queue")))))
+
+ ;; Load queue from M3U file
+ (defun load-queue-from-m3u ()
+ (unless (confirm "Load queue from stream-queue.m3u file? This will replace the current queue.")
+ (return))
+
+ (ps:chain
+ (fetch "/api/asteroid/stream/queue/load-m3u" (ps:create :method "POST"))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (progn
+ (alert (+ "Successfully loaded " (ps:@ data count) " tracks from M3U file!"))
+ (load-stream-queue))
+ (alert (+ "Error loading from M3U: " (or (ps:@ data message) "Unknown error")))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading from M3U:" error))
+ (alert (+ "Error loading from M3U: " (ps:@ error message)))))))
+
+ ;; Move track up in queue
+ (defun move-track-up (index)
+ (when (= index 0) (return))
+
+ ;; Swap with previous track
+ (let ((new-queue (ps:chain *stream-queue* (slice))))
+ (let ((temp (ps:getprop new-queue (- index 1))))
+ (setf (ps:getprop new-queue (- index 1)) (ps:getprop new-queue index))
+ (setf (ps:getprop new-queue index) temp))
+ (reorder-queue new-queue)))
+
+ ;; Move track down in queue
+ (defun move-track-down (index)
+ (when (= index (- (ps:@ *stream-queue* length) 1)) (return))
+
+ ;; Swap with next track
+ (let ((new-queue (ps:chain *stream-queue* (slice))))
+ (let ((temp (ps:getprop new-queue index)))
+ (setf (ps:getprop new-queue index) (ps:getprop new-queue (+ index 1)))
+ (setf (ps:getprop new-queue (+ index 1)) temp))
+ (reorder-queue new-queue)))
+
+ ;; Reorder the queue
+ (defun reorder-queue (new-queue)
+ (let ((track-ids (ps:chain new-queue
+ (map (lambda (track) (ps:@ track id)))
+ (join ","))))
+ (ps:chain
+ (fetch (+ "/api/asteroid/stream/queue/reorder?track-ids=" track-ids)
+ (ps:create :method "POST"))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (load-stream-queue)
+ (alert (+ "Error reordering queue: " (or (ps:@ data message) "Unknown error")))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error reordering queue:" error))
+ (alert "Error reordering queue"))))))
+
+ ;; Remove track from queue
+ (defun remove-from-queue (track-id)
+ (ps:chain
+ (fetch "/api/asteroid/stream/queue/remove"
+ (ps:create :method "POST"
+ :headers (ps:create "Content-Type" "application/x-www-form-urlencoded")
+ :body (+ "track-id=" track-id)))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (load-stream-queue)
+ (alert (+ "Error removing track: " (or (ps:@ data message) "Unknown error")))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error removing track:" error))
+ (alert "Error removing track")))))
+
+ ;; Add track to queue
+ (defun add-to-queue (track-id &optional (position "end") (show-notification t))
+ (ps:chain
+ (fetch "/api/asteroid/stream/queue/add"
+ (ps:create :method "POST"
+ :headers (ps:create "Content-Type" "application/x-www-form-urlencoded")
+ :body (+ "track-id=" track-id "&position=" position)))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (progn
+ ;; Only reload queue if we're in the queue management section
+ (let ((queue-container (ps:chain document (get-element-by-id "stream-queue-container"))))
+ (when (and queue-container (not (= (ps:@ queue-container offset-parent) nil)))
+ (load-stream-queue)))
+
+ ;; Show brief success notification
+ (when show-notification
+ (show-toast "✓ Added to queue"))
+ t)
+ (progn
+ (alert (+ "Error adding track: " (or (ps:@ data message) "Unknown error")))
+ nil)))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error adding track:" error))
+ (alert "Error adding track")
+ nil))))
+
+ ;; Simple toast notification
+ (defun show-toast (message)
+ (let ((toast (ps:chain document (create-element "div"))))
+ (setf (ps:@ toast text-content) message)
+ (setf (ps:@ toast style css-text)
+ "position: fixed; bottom: 20px; right: 20px; background: #00ff00; color: #000; padding: 12px 20px; border-radius: 4px; font-weight: bold; z-index: 10000; animation: slideIn 0.3s ease-out;")
+ (ps:chain document body (append-child toast))
+
+ (set-timeout (lambda ()
+ (setf (ps:@ toast style opacity) "0")
+ (setf (ps:@ toast style transition) "opacity 0.3s")
+ (set-timeout (lambda () (ps:chain toast (remove))) 300))
+ 2000)))
+
+ ;; Add random tracks to queue
+ (defun add-random-tracks ()
+ (when (= (ps:@ *tracks* length) 0)
+ (alert "No tracks available. Please scan the library first.")
+ (return))
+
+ (let* ((count 10)
+ (shuffled (ps:chain *tracks* (slice) (sort (lambda () (- (ps:chain -math (random)) 0.5)))))
+ (selected (ps:chain shuffled (slice 0 (ps:chain -math (min count (ps:@ *tracks* length)))))))
+
+ (ps:chain selected
+ (for-each (lambda (track)
+ (add-to-queue (ps:@ track id) "end" nil))))
+
+ (show-toast (+ "✓ Added " (ps:@ selected length) " random tracks to queue"))))
+
+ ;; Search tracks for adding to queue
+ (defun search-tracks-for-queue (event)
+ (clear-timeout *queue-search-timeout*)
+ (let ((query (ps:chain (ps:@ event target value) (to-lower-case))))
+
+ (when (< (ps:@ query length) 2)
+ (let ((results-container (ps:chain document (get-element-by-id "queue-track-results"))))
+ (when results-container
+ (setf (ps:@ results-container inner-h-t-m-l) "")))
+ (return))
+
+ (setf *queue-search-timeout*
+ (set-timeout (lambda ()
+ (let ((results (ps:chain *tracks*
+ (filter (lambda (track)
+ (or (and (ps:@ track title)
+ (ps:chain (ps:@ track title) (to-lower-case) (includes query)))
+ (and (ps:@ track artist)
+ (ps:chain (ps:@ track artist) (to-lower-case) (includes query)))
+ (and (ps:@ track album)
+ (ps:chain (ps:@ track album) (to-lower-case) (includes query))))))
+ (slice 0 20))))
+ (display-queue-search-results results)))
+ 300))))
+
+ ;; Display search results for queue
+ (defun display-queue-search-results (results)
+ (let ((container (ps:chain document (get-element-by-id "queue-track-results"))))
+ (when container
+ (if (= (ps:@ results length) 0)
+ (setf (ps:@ container inner-h-t-m-l)
+ ""
+ "" (+ index 1) ""
+ "
")))))))
+ (setf html (+ html ""
+ "
"
+ "" (or (ps:@ item title) "Unknown") "
"
+ "" (or (ps:@ item artist) "Unknown Artist") "
"
+ ""
+ ""
+ ""
+ ""
+ "
"
+ "No tracks found
")
+ (let ((html ""))
+ (ps:chain results
+ (for-each (lambda (track)
+ (setf html
+ (+ html
+ "
"))
+ (setf (ps:@ container inner-h-t-m-l) html))))))
+
+ ;; Make functions globally accessible for onclick handlers
+ (setf (ps:@ window go-to-page) go-to-page)
+ (setf (ps:@ window previous-page) previous-page)
+ (setf (ps:@ window next-page) next-page)
+ (setf (ps:@ window go-to-last-page) go-to-last-page)
+ (setf (ps:@ window change-tracks-per-page) change-tracks-per-page)
+ (setf (ps:@ window stream-track) stream-track)
+ (setf (ps:@ window delete-track) delete-track)
+ (setf (ps:@ window move-track-up) move-track-up)
+ (setf (ps:@ window move-track-down) move-track-down)
+ (setf (ps:@ window remove-from-queue) remove-from-queue)
+ (setf (ps:@ window add-to-queue) add-to-queue)
+ ))
+ "Compiled JavaScript for admin dashboard - generated at load time")
+
+(defun generate-admin-js ()
+ "Return the pre-compiled JavaScript for admin dashboard"
+ *admin-js*)
diff --git a/parenscript/auth-ui.lisp b/parenscript/auth-ui.lisp
new file mode 100644
index 0000000..f56ede3
--- /dev/null
+++ b/parenscript/auth-ui.lisp
@@ -0,0 +1,67 @@
+;;;; auth-ui.lisp - ParenScript version of auth-ui.js
+;;;; Handle authentication UI state across all pages
+
+(in-package #:asteroid)
+
+(defparameter *auth-ui-js*
+ (ps:ps*
+ '(progn
+
+ ;; Check if user is logged in by calling the API
+ (defun check-auth-status ()
+ (ps:chain
+ (fetch "/api/asteroid/auth-status")
+ (then (lambda (response)
+ (ps:chain response (json))))
+ (then (lambda (result)
+ ;; api-output wraps response in {status, message, data}
+ (let ((data (or (ps:@ result data) result)))
+ data)))
+ (catch (lambda (error)
+ (ps:chain console (error "Error checking auth status:" error))
+ (ps:create :logged-in false
+ :is-admin false)))))
+
+ ;; Update UI based on authentication status
+ (defun update-auth-ui (auth-status)
+ ;; Show/hide elements based on login status
+ (ps:chain document
+ (query-selector-all "[data-show-if-logged-in]")
+ (for-each (lambda (el)
+ (setf (ps:@ el style display)
+ (if (ps:@ auth-status logged-in)
+ "inline-block"
+ "none")))))
+
+ (ps:chain document
+ (query-selector-all "[data-show-if-logged-out]")
+ (for-each (lambda (el)
+ (setf (ps:@ el style display)
+ (if (ps:@ auth-status logged-in)
+ "none"
+ "inline-block")))))
+
+ (ps:chain document
+ (query-selector-all "[data-show-if-admin]")
+ (for-each (lambda (el)
+ (setf (ps:@ el style display)
+ (if (ps:@ auth-status is-admin)
+ "inline-block"
+ "none"))))))
+
+ ;; Initialize auth UI on page load
+ (ps:chain document
+ (add-event-listener
+ "DOMContentLoaded"
+ (lambda ()
+ (ps:chain console (log "Auth UI initializing..."))
+ (ps:chain (check-auth-status)
+ (then (lambda (auth-status)
+ (ps:chain console (log "Auth status:" auth-status))
+ (update-auth-ui auth-status)
+ (ps:chain console (log "Auth UI updated")))))))))
+ "Compiled JavaScript for auth UI - generated at load time"))
+
+(defun generate-auth-ui-js ()
+ "Return the pre-compiled JavaScript for authentication UI"
+ *auth-ui-js*)
diff --git a/parenscript/front-page.lisp b/parenscript/front-page.lisp
new file mode 100644
index 0000000..572d818
--- /dev/null
+++ b/parenscript/front-page.lisp
@@ -0,0 +1,278 @@
+;;;; front-page.lisp - ParenScript version of front-page.js
+;;;; Stream quality, now playing, pop-out player, frameset mode
+
+(in-package #:asteroid)
+
+(defparameter *front-page-js*
+ (ps:ps*
+ '(progn
+
+ ;; Stream quality configuration
+ (defun get-stream-config (stream-base-url encoding)
+ (let ((config (ps:create
+ :aac (ps:create
+ :url (+ stream-base-url "/asteroid.aac")
+ :format "AAC 96kbps Stereo"
+ :type "audio/aac"
+ :mount "asteroid.aac")
+ :mp3 (ps:create
+ :url (+ stream-base-url "/asteroid.mp3")
+ :format "MP3 128kbps Stereo"
+ :type "audio/mpeg"
+ :mount "asteroid.mp3")
+ :low (ps:create
+ :url (+ stream-base-url "/asteroid-low.mp3")
+ :format "MP3 64kbps Stereo"
+ :type "audio/mpeg"
+ :mount "asteroid-low.mp3"))))
+ (ps:getprop config encoding)))
+
+ ;; Change stream quality
+ (defun change-stream-quality ()
+ (let* ((selector (ps:chain document (get-element-by-id "stream-quality")))
+ (stream-base-url (ps:chain document (get-element-by-id "stream-base-url")))
+ (config (get-stream-config (ps:@ stream-base-url value) (ps:@ selector value)))
+ (audio-element (ps:chain document (get-element-by-id "live-audio")))
+ (source-element (ps:chain document (get-element-by-id "audio-source")))
+ (was-playing (not (ps:@ audio-element paused)))
+ (current-time (ps:@ audio-element current-time)))
+
+ ;; Save preference
+ (ps:chain local-storage (set-item "stream-quality" (ps:@ selector value)))
+
+ ;; Update stream information
+ (update-stream-information)
+
+ ;; Update audio player
+ (setf (ps:@ source-element src) (ps:@ config url))
+ (setf (ps:@ source-element type) (ps:@ config type))
+ (ps:chain audio-element (load))
+
+ ;; Resume playback if it was playing
+ (when was-playing
+ (ps:chain (ps:chain audio-element (play))
+ (catch (lambda (e)
+ (ps:chain console (log "Autoplay prevented:" e))))))))
+
+ ;; Update now playing info from API
+ (defun update-now-playing ()
+ (ps:chain
+ (fetch "/api/asteroid/partial/now-playing")
+ (then (lambda (response)
+ (let ((content-type (ps:chain response headers (get "content-type"))))
+ (if (ps:chain content-type (includes "text/html"))
+ (ps:chain response (text))
+ (throw (ps:new (-error "Error connecting to stream")))))))
+ (then (lambda (data)
+ (setf (ps:@ (ps:chain document (get-element-by-id "now-playing")) inner-h-t-m-l)
+ data)))
+ (catch (lambda (error)
+ (ps:chain console (log "Could not fetch stream status:" error))))))
+
+ ;; Update stream information
+ (defun update-stream-information ()
+ (let* ((selector (ps:chain document (get-element-by-id "stream-quality")))
+ (stream-base-url (ps:chain document (get-element-by-id "stream-base-url")))
+ (stream-quality (or (ps:chain local-storage (get-item "stream-quality")) "aac")))
+
+ ;; Update selector if needed
+ (when (and selector (not (= (ps:@ selector value) stream-quality)))
+ (setf (ps:@ selector value) stream-quality)
+ (ps:chain selector (dispatch-event (ps:new (-event "change")))))
+
+ ;; Update stream info display
+ (when stream-base-url
+ (let ((config (get-stream-config (ps:@ stream-base-url value) stream-quality)))
+ (setf (ps:@ (ps:chain document (get-element-by-id "stream-url")) text-content)
+ (ps:@ config url))
+ (setf (ps:@ (ps:chain document (get-element-by-id "stream-format")) text-content)
+ (ps:@ config format))
+ (let ((status-quality (ps:chain document (query-selector "[data-text=\"stream-quality\"]"))))
+ (when status-quality
+ (setf (ps:@ status-quality text-content) (ps:@ config format))))))))
+
+ ;; Pop-out player functionality
+ (defvar *popout-window* nil)
+
+ (defun open-popout-player ()
+ ;; Check if popout is already open
+ (when (and *popout-window* (not (ps:@ *popout-window* closed)))
+ (ps:chain *popout-window* (focus))
+ (return))
+
+ ;; Calculate centered position
+ (let* ((width 420)
+ (height 300)
+ (left (/ (- (ps:@ screen width) width) 2))
+ (top (/ (- (ps:@ screen height) height) 2))
+ (features (+ "width=" width ",height=" height ",left=" left ",top=" top
+ ",resizable=yes,scrollbars=no,status=no,menubar=no,toolbar=no,location=no")))
+
+ ;; Open popout window
+ (setf *popout-window*
+ (ps:chain window (open "/asteroid/popout-player" "AsteroidPlayer" features)))
+
+ ;; Update button state
+ (update-popout-button t)))
+
+ (defun update-popout-button (is-open)
+ (let ((btn (ps:chain document (get-element-by-id "popout-btn"))))
+ (when btn
+ (if is-open
+ (progn
+ (setf (ps:@ btn text-content) "✓ Player Open")
+ (ps:chain btn class-list (remove "btn-info"))
+ (ps:chain btn class-list (add "btn-success")))
+ (progn
+ (setf (ps:@ btn text-content) "🗗 Pop Out Player")
+ (ps:chain btn class-list (remove "btn-success"))
+ (ps:chain btn class-list (add "btn-info")))))))
+
+ ;; Frameset mode functionality
+ (defun enable-frameset-mode ()
+ (ps:chain local-storage (set-item "useFrameset" "true"))
+ (setf (ps:@ window location href) "/asteroid/frameset"))
+
+ (defun disable-frameset-mode ()
+ (ps:chain local-storage (remove-item "useFrameset"))
+ (setf (ps:@ window location href) "/asteroid/"))
+
+ (defun redirect-when-frame ()
+ (let* ((path (ps:@ window location pathname))
+ (is-frameset-page (not (= (ps:@ window parent) (ps:@ window self))))
+ (is-content-frame (ps:chain path (includes "asteroid/content"))))
+
+ (when (and is-frameset-page (not is-content-frame))
+ (setf (ps:@ window location href) "/asteroid/content"))
+
+ (when (and (not is-frameset-page) is-content-frame)
+ (setf (ps:@ window location href) "/asteroid"))))
+
+ ;; Initialize on page load
+ (ps:chain document
+ (add-event-listener
+ "DOMContentLoaded"
+ (lambda ()
+ ;; Update stream information
+ (update-stream-information)
+
+ ;; Periodically update stream info if in frameset
+ (let ((is-frameset-page (not (= (ps:@ window parent) (ps:@ window self)))))
+ (when is-frameset-page
+ (set-interval update-stream-information 1000)))
+
+ ;; Update now playing
+ (update-now-playing)
+
+ ;; Auto-reconnect on stream errors
+ (let ((audio-element (ps:chain document (get-element-by-id "live-audio"))))
+ (when audio-element
+ (ps:chain audio-element
+ (add-event-listener
+ "error"
+ (lambda (err)
+ (ps:chain console (log "Stream error, attempting reconnect in 3 seconds..." err))
+ (set-timeout
+ (lambda ()
+ (ps:chain audio-element (load))
+ (ps:chain (ps:chain audio-element (play))
+ (catch (lambda (err)
+ (ps:chain console (log "Reconnect failed:" err))))))
+ 3000))))
+
+ (ps:chain audio-element
+ (add-event-listener
+ "stalled"
+ (lambda ()
+ (ps:chain console (log "Stream stalled, reloading..."))
+ (ps:chain audio-element (load))
+ (ps:chain (ps:chain audio-element (play))
+ (catch (lambda (err)
+ (ps:chain console (log "Reload failed:" err))))))))
+
+ (let ((pause-timestamp nil)
+ (is-reconnecting false)
+ (needs-reconnect false)
+ (pause-reconnect-threshold 10000))
+
+ (ps:chain audio-element
+ (add-event-listener "pause"
+ (lambda ()
+ (setf pause-timestamp (ps:chain |Date| (now)))
+ (ps:chain console (log "Stream paused at:" pause-timestamp)))))
+
+ (ps:chain audio-element
+ (add-event-listener "play"
+ (lambda ()
+ (when (and (not is-reconnecting)
+ pause-timestamp
+ (> (- (ps:chain |Date| (now)) pause-timestamp) pause-reconnect-threshold))
+ (setf needs-reconnect true)
+ (ps:chain console (log "Long pause detected, will reconnect when playing starts...")))
+ (setf pause-timestamp nil))))
+
+ (ps:chain audio-element
+ (add-event-listener "playing"
+ (lambda ()
+ (when (and needs-reconnect (not is-reconnecting))
+ (setf is-reconnecting true)
+ (setf needs-reconnect false)
+ (ps:chain console (log "Reconnecting stream after long pause to clear stale buffers..."))
+
+ (ps:chain audio-element (pause))
+
+ (when (ps:@ window |resetSpectrumAnalyzer|)
+ (ps:chain window (reset-spectrum-analyzer)))
+
+ (ps:chain audio-element (load))
+
+ (set-timeout
+ (lambda ()
+ (ps:chain audio-element (play)
+ (catch (lambda (err)
+ (ps:chain console (log "Reconnect play failed:" err)))))
+
+ (when (ps:@ window |initSpectrumAnalyzer|)
+ (ps:chain window (init-spectrum-analyzer))
+ (ps:chain console (log "Spectrum analyzer reinitialized after reconnect")))
+
+ (setf is-reconnecting false))
+ 200))))))))
+
+ ;; Check frameset preference
+ (let ((path (ps:@ window location pathname))
+ (is-frameset-page (not (= (ps:@ window parent) (ps:@ window self)))))
+ (when (and (= (ps:chain local-storage (get-item "useFrameset")) "true")
+ (not is-frameset-page)
+ (ps:chain path (includes "/asteroid")))
+ (setf (ps:@ window location href) "/asteroid/frameset"))
+
+ (redirect-when-frame)))))
+
+ ;; Update now playing every 10 seconds
+ (set-interval update-now-playing 10000)
+
+ ;; Listen for messages from popout window
+ (ps:chain window
+ (add-event-listener
+ "message"
+ (lambda (event)
+ (cond
+ ((= (ps:@ event data type) "popout-opened")
+ (update-popout-button t))
+ ((= (ps:@ event data type) "popout-closed")
+ (update-popout-button nil)
+ (setf *popout-window* nil))))))
+
+ ;; Check if popout is still open periodically
+ (set-interval
+ (lambda ()
+ (when (and *popout-window* (ps:@ *popout-window* closed))
+ (update-popout-button nil)
+ (setf *popout-window* nil)))
+ 1000)))
+ "Compiled JavaScript for front-page - generated at load time")
+
+(defun generate-front-page-js ()
+ "Return the pre-compiled JavaScript for front page"
+ *front-page-js*)
diff --git a/parenscript/player.lisp b/parenscript/player.lisp
new file mode 100644
index 0000000..e0e9945
--- /dev/null
+++ b/parenscript/player.lisp
@@ -0,0 +1,667 @@
+;;;; player.lisp - ParenScript version of player.js
+;;;; Web Player functionality including audio playback, playlists, queue management, and live streaming
+
+(in-package #:asteroid)
+
+(defparameter *player-js*
+ (ps:ps*
+ '(progn
+
+ ;; Global variables
+ (defvar *tracks* (array))
+ (defvar *current-track* nil)
+ (defvar *current-track-index* -1)
+ (defvar *play-queue* (array))
+ (defvar *is-shuffled* nil)
+ (defvar *is-repeating* nil)
+ (defvar *audio-player* nil)
+
+ ;; Pagination variables for track library
+ (defvar *library-current-page* 1)
+ (defvar *library-tracks-per-page* 20)
+ (defvar *filtered-library-tracks* (array))
+
+ ;; Initialize player on page load
+ (ps:chain document
+ (add-event-listener
+ "DOMContentLoaded"
+ (lambda ()
+ (setf *audio-player* (ps:chain document (get-element-by-id "audio-player")))
+ (redirect-when-frame)
+ (load-tracks)
+ (load-playlists)
+ (setup-event-listeners)
+ (update-player-display)
+ (update-volume)
+
+ ;; Setup live stream with reduced buffering and reconnect logic
+ (let ((live-audio (ps:chain document (get-element-by-id "live-stream-audio"))))
+ (when live-audio
+ ;; Reduce buffer to minimize delay
+ (setf (ps:@ live-audio preload) "none")
+
+ ;; Add reconnect logic for long pauses
+ (let ((pause-timestamp nil)
+ (is-reconnecting false)
+ (needs-reconnect false)
+ (pause-reconnect-threshold 10000))
+
+ (ps:chain live-audio
+ (add-event-listener "pause"
+ (lambda ()
+ (setf pause-timestamp (ps:chain |Date| (now)))
+ (ps:chain console (log "Live stream paused at:" pause-timestamp)))))
+
+ (ps:chain live-audio
+ (add-event-listener "play"
+ (lambda ()
+ (when (and (not is-reconnecting)
+ pause-timestamp
+ (> (- (ps:chain |Date| (now)) pause-timestamp) pause-reconnect-threshold))
+ (setf needs-reconnect true)
+ (ps:chain console (log "Long pause detected, will reconnect when playing starts...")))
+ (setf pause-timestamp nil))))
+
+ (ps:chain live-audio
+ (add-event-listener "playing"
+ (lambda ()
+ (when (and needs-reconnect (not is-reconnecting))
+ (setf is-reconnecting true)
+ (setf needs-reconnect false)
+ (ps:chain console (log "Reconnecting live stream after long pause to clear stale buffers..."))
+
+ (ps:chain live-audio (pause))
+
+ (when (ps:@ window |resetSpectrumAnalyzer|)
+ (ps:chain window (reset-spectrum-analyzer)))
+
+ (ps:chain live-audio (load))
+
+ (set-timeout
+ (lambda ()
+ (ps:chain live-audio (play)
+ (catch (lambda (err)
+ (ps:chain console (log "Reconnect play failed:" err)))))
+
+ (when (ps:@ window |initSpectrumAnalyzer|)
+ (ps:chain window (init-spectrum-analyzer))
+ (ps:chain console (log "Spectrum analyzer reinitialized after reconnect")))
+
+ (setf is-reconnecting false))
+ 200)))))
+ )))
+
+ ;; Restore user quality preference
+ (let ((selector (ps:chain document (get-element-by-id "live-stream-quality")))
+ (stream-quality (ps:chain (ps:@ local-storage (get-item "stream-quality")) "aac")))
+ (when (and selector (not (== (ps:@ selector value) stream-quality)))
+ (setf (ps:@ selector value) stream-quality)
+ (ps:chain selector (dispatch-event (new "Event" "change"))))))))
+
+ ;; Frame redirection logic
+ (defun redirect-when-frame ()
+ (let ((path (ps:@ window location pathname))
+ (is-frameset-page (not (== (ps:@ window parent) (ps:@ window self))))
+ (is-content-frame (ps:chain path (includes "player-content"))))
+
+ (when (and is-frameset-page (not is-content-frame))
+ (setf (ps:@ window location href) "/asteroid/player-content"))
+
+ (when (and (not is-frameset-page) is-content-frame)
+ (setf (ps:@ window location href) "/asteroid/player"))))
+
+ ;; Setup all event listeners
+ (defun setup-event-listeners ()
+ ;; Search
+ (ps:chain (ps:chain document (get-element-by-id "search-tracks"))
+ (add-event-listener "input" filter-tracks))
+
+ ;; Player controls
+ (ps:chain (ps:chain document (get-element-by-id "play-pause-btn"))
+ (add-event-listener "click" toggle-play-pause))
+ (ps:chain (ps:chain document (get-element-by-id "prev-btn"))
+ (add-event-listener "click" play-previous))
+ (ps:chain (ps:chain document (get-element-by-id "next-btn"))
+ (add-event-listener "click" play-next))
+ (ps:chain (ps:chain document (get-element-by-id "shuffle-btn"))
+ (add-event-listener "click" toggle-shuffle))
+ (ps:chain (ps:chain document (get-element-by-id "repeat-btn"))
+ (add-event-listener "click" toggle-repeat))
+
+ ;; Volume control
+ (ps:chain (ps:chain document (get-element-by-id "volume-slider"))
+ (add-event-listener "input" update-volume))
+
+ ;; Audio player events
+ (when *audio-player*
+ (ps:chain *audio-player*
+ (add-event-listener "loadedmetadata" update-time-display)
+ (add-event-listener "timeupdate" update-time-display)
+ (add-event-listener "ended" handle-track-end)
+ (add-event-listener "play" (lambda () (update-play-button "⏸️ Pause")))
+ (add-event-listener "pause" (lambda () (update-play-button "▶️ Play")))))
+
+ ;; Playlist controls
+ (ps:chain (ps:chain document (get-element-by-id "create-playlist"))
+ (add-event-listener "click" create-playlist))
+ (ps:chain (ps:chain document (get-element-by-id "clear-queue"))
+ (add-event-listener "click" clear-queue))
+ (ps:chain (ps:chain document (get-element-by-id "save-queue"))
+ (add-event-listener "click" save-queue-as-playlist)))
+
+ ;; Load tracks from API
+ (defun load-tracks ()
+ (ps:chain
+ (ps:chain (fetch "/api/asteroid/tracks"))
+ (then (lambda (response)
+ (if (ps:@ response ok)
+ (ps:chain response (json))
+ (progn
+ (ps:chain console (error (+ "HTTP " (ps:@ response status))))
+ (ps:create :status "error" :tracks (array))))))
+ (then (lambda (result)
+ ;; Handle RADIANCE API wrapper format
+ (let ((data (or (ps:@ result data) result)))
+ (if (== (ps:@ data status) "success")
+ (progn
+ (setf *tracks* (or (ps:@ data tracks) (array)))
+ (display-tracks *tracks*))
+ (progn
+ (ps:chain console (error "Error loading tracks:" (ps:@ data error)))
+ (setf (ps:chain (ps:chain document (get-element-by-id "track-list")) inner-html)
+ ""
+ "
")))))
+ (setf html (+ html ""
+ "
"
+ "" (or (ps:@ track title) "Unknown") "
"
+ "" (or (ps:@ track artist) "Unknown") " - " (or (ps:@ track album) "Unknown Album") "
"
+ ""
+ ""
+ ""
+ "
"
+ "Error loading tracks
"))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading tracks:" error))
+ (setf (ps:chain (ps:chain document (get-element-by-id "track-list")) inner-html)
+ "Error loading tracks
")))))
+
+ ;; Display tracks in library
+ (defun display-tracks (track-list)
+ (setf *filtered-library-tracks* track-list)
+ (setf *library-current-page* 1)
+ (render-library-page))
+
+ ;; Render current library page
+ (defun render-library-page ()
+ (let ((container (ps:chain document (get-element-by-id "track-list")))
+ (pagination-controls (ps:chain document (get-element-by-id "library-pagination-controls"))))
+
+ (if (== (ps:@ *filtered-library-tracks* length) 0)
+ (progn
+ (setf (ps:@ container inner-html) "No tracks found
")
+ (setf (ps:@ pagination-controls style display) "none")
+ (return)))
+
+ ;; Calculate pagination
+ (let ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*)))
+ (start-index (* (* *library-current-page* -1) *library-tracks-per-page* *library-tracks-per-page*))
+ (end-index (+ start-index *library-tracks-per-page*))
+ (tracks-to-show (ps:chain *filtered-library-tracks* (slice start-index end-index))))
+
+ ;; Render tracks for current page
+ (let ((tracks-html (ps:chain tracks-to-show
+ (map (lambda (track page-index)
+ ;; Find the actual index in the full tracks array
+ (let ((actual-index (ps:chain *tracks*
+ (find-index (lambda (trk) (== (ps:@ trk id) (ps:@ track id)))))))
+ (+ ""
+ "
"))))
+ (join ""))))
+
+ (setf (ps:@ container inner-html) tracks-html)
+
+ ;; Update pagination controls
+ (setf (ps:chain (ps:chain document (get-element-by-id "library-page-info")) text-content)
+ (+ "Page " *library-current-page* " of " total-pages " (" (ps:@ *filtered-library-tracks* length) " tracks)"))
+ (setf (ps:@ pagination-controls style display)
+ (if (> total-pages 1) "block" "none"))))))
+
+ ;; Library pagination functions
+ (defun library-go-to-page (page)
+ (let ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*))))
+ (when (and (>= page 1) (<= page total-pages))
+ (setf *library-current-page* page)
+ (render-library-page))))
+
+ (defun library-previous-page ()
+ (when (> *library-current-page* 1)
+ (setf *library-current-page* (- *library-current-page* 1))
+ (render-library-page)))
+
+ (defun library-next-page ()
+ (let ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*))))
+ (when (< *library-current-page* total-pages)
+ (setf *library-current-page* (+ *library-current-page* 1))
+ (render-library-page))))
+
+ (defun library-go-to-last-page ()
+ (let ((total-pages (ceiling (/ (ps:@ *filtered-library-tracks* length) *library-tracks-per-page*))))
+ (setf *library-current-page* total-pages)
+ (render-library-page)))
+
+ (defun change-library-tracks-per-page ()
+ (setf *library-tracks-per-page*
+ (parseInt (ps:chain (ps:chain document (get-element-by-id "library-tracks-per-page")) value)))
+ (setf *library-current-page* 1)
+ (render-library-page))
+
+ ;; Filter tracks based on search query
+ (defun filter-tracks ()
+ (let ((query (ps:chain (ps:chain document (get-element-by-id "search-tracks")) value (to-lower-case))))
+ (let ((filtered (ps:chain *tracks*
+ (filter (lambda (track)
+ (or (ps:chain (or (ps:@ track title 0) "") (to-lower-case) (includes query))
+ (ps:chain (or (ps:@ track artist 0) "") (to-lower-case) (includes query))
+ (ps:chain (or (ps:@ track album 0) "") (to-lower-case) (includes query))))))))
+ (display-tracks filtered))))
+
+ ;; Play a specific track by index
+ (defun play-track (index)
+ (when (and (>= index 0) (< index (ps:@ *tracks* length)))
+ (setf *current-track* (aref *tracks* index))
+ (setf *current-track-index* index)
+
+ ;; Load track into audio player
+ (setf (ps:@ *audio-player* src) (+ "/asteroid/tracks/" (ps:@ *current-track* id) "/stream"))
+ (ps:chain *audio-player* (load))
+ (ps:chain *audio-player*
+ (play)
+ (catch (lambda (error)
+ (ps:chain console (error "Playback error:" error))
+ (alert "Error playing track. The track may not be available."))))
+
+ (update-player-display)
+
+ ;; Update server-side player state
+ (ps:chain (fetch (+ "/api/asteroid/player/play?track-id=" (ps:@ *current-track* id))
+ (ps:create :method "POST"))
+ (catch (lambda (error)
+ (ps:chain console (error "API update error:" error)))))))
+
+ ;; Toggle play/pause
+ (defun toggle-play-pause ()
+ (if *current-track*
+ (if (ps:@ *audio-player* paused)
+ (ps:chain *audio-player* (play))
+ (ps:chain *audio-player* (pause)))
+ (alert "Please select a track to play")))
+
+ ;; Play previous track
+ (defun play-previous ()
+ (if (> (ps:@ *play-queue* length) 0)
+ ;; Play from queue
+ (let ((prev-index (max 0 (- *current-track-index* 1))))
+ (play-track prev-index))
+ ;; Play previous track in library
+ (let ((prev-index (if (> *current-track-index* 0)
+ (- *current-track-index* 1)
+ (- (ps:@ *tracks* length) 1))))
+ (play-track prev-index))))
+
+ ;; Play next track
+ (defun play-next ()
+ (if (> (ps:@ *play-queue* length) 0)
+ ;; Play from queue
+ (let ((next-track (ps:chain *play-queue* (shift))))
+ (play-track (ps:chain *tracks*
+ (find-index (lambda (trk) (== (ps:@ trk id) (ps:@ next-track id))))))
+ (update-queue-display))
+ ;; Play next track in library
+ (let ((next-index (if *is-shuffled*
+ (floor (* (random) (ps:@ *tracks* length))))
+ (mod (+ *current-track-index* 1) (ps:@ *tracks* length)))))
+ (play-track next-index))))
+
+ ;; Handle track end
+ (defun handle-track-end ()
+ (if *is-repeating*
+ (progn
+ (setf (ps:@ *audio-player* current-time) 0)
+ (ps:chain *audio-player* (play)))
+ (play-next)))
+
+ ;; Toggle shuffle mode
+ (defun toggle-shuffle ()
+ (setf *is-shuffled* (not *is-shuffled*))
+ (let ((btn (ps:chain document (get-element-by-id "shuffle-btn"))))
+ (setf (ps:@ btn text-content) (if *is-shuffled* "🔀 Shuffle ON" "🔀 Shuffle"))
+ (ps:chain btn (class-list toggle "active" *is-shuffled*))))
+
+ ;; Toggle repeat mode
+ (defun toggle-repeat ()
+ (setf *is-repeating* (not *is-repeating*))
+ (let ((btn (ps:chain document (get-element-by-id "repeat-btn"))))
+ (setf (ps:@ btn text-content) (if *is-repeating* "🔁 Repeat ON" "🔁 Repeat"))
+ (ps:chain btn (class-list toggle "active" *is-repeating*))))
+
+ ;; Update volume
+ (defun update-volume ()
+ (let ((volume (/ (parseInt (ps:chain (ps:chain document (get-element-by-id "volume-slider")) value)) 100)))
+ (when *audio-player*
+ (setf (ps:@ *audio-player* volume) volume))))
+
+ ;; Update time display
+ (defun update-time-display ()
+ (let ((current (format-time (ps:@ *audio-player* current-time)))
+ (total (format-time (ps:@ *audio-player* duration))))
+ (setf (ps:chain (ps:chain document (get-element-by-id "current-time")) text-content) current)
+ (setf (ps:chain (ps:chain document (get-element-by-id "total-time")) text-content) total)))
+
+ ;; Format time helper
+ (defun format-time (seconds)
+ (if (isNaN seconds)
+ "0:00"
+ (let ((mins (floor (/ seconds 60)))
+ (secs (floor (mod seconds 60))))
+ (+ mins ":" (ps:chain secs (to-string) (pad-start 2 "0"))))))
+
+ ;; Update play button text
+ (defun update-play-button (text)
+ (setf (ps:chain (ps:chain document (get-element-by-id "play-pause-btn")) text-content) text))
+
+ ;; Update player display with current track info
+ (defun update-player-display ()
+ (when *current-track*
+ (setf (ps:chain (ps:chain document (get-element-by-id "current-title")) text-content)
+ (or (ps:@ *current-track* title) "Unknown Title"))
+ (setf (ps:chain (ps:chain document (get-element-by-id "current-artist")) text-content)
+ (or (ps:@ *current-track* artist) "Unknown Artist"))
+ (setf (ps:chain (ps:chain document (get-element-by-id "current-album")) text-content)
+ (or (ps:@ *current-track* album) "Unknown Album"))))
+
+ ;; Add track to queue
+ (defun add-to-queue (index)
+ (when (and (>= index 0) (< index (ps:@ *tracks* length)))
+ (setf (aref *play-queue* (ps:@ *play-queue* length)) (aref *tracks* index))
+ (update-queue-display)))
+
+ ;; Update queue display
+ (defun update-queue-display ()
+ (let ((container (ps:chain document (get-element-by-id "play-queue"))))
+ (if (== (ps:@ *play-queue* length) 0)
+ (setf (ps:@ container inner-html) ""
+ "
"
+ "" (or (ps:@ track title 0) "Unknown Title") "
"
+ ""
+ ""
+ ""
+ ""
+ "
"
+ "Queue is empty
")
+ (let ((queue-html (ps:chain *play-queue*
+ (map (lambda (track index)
+ (+ ""
+ "
")))
+ (join ""))))
+ (setf (ps:@ container inner-html) queue-html))))
+
+ ;; Remove track from queue
+ (defun remove-from-queue (index)
+ (ps:chain *play-queue* (splice index 1))
+ (update-queue-display))
+
+ ;; Clear queue
+ (defun clear-queue ()
+ (setf *play-queue* (array))
+ (update-queue-display))
+
+ ;; Create playlist
+ (defun create-playlist ()
+ (let ((name (ps:chain (ps:chain document (get-element-by-id "new-playlist-name")) value (trim))))
+ (when (not (== name ""))
+ (let ((form-data (new "FormData")))
+ (ps:chain form-data (append "name" name))
+ (ps:chain form-data (append "description" ""))
+
+ (ps:chain (fetch "/api/asteroid/playlists/create"
+ (ps:create :method "POST" :body form-data))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ ;; Handle RADIANCE API wrapper format
+ (let ((data (or (ps:@ result data) result)))
+ (if (== (ps:@ data status) "success")
+ (progn
+ (alert (+ "Playlist \"" name "\" created successfully!"))
+ (setf (ps:chain (ps:chain document (get-element-by-id "new-playlist-name")) value) "")
+
+ ;; Wait a moment then reload playlists
+ (ps:chain (new "Promise" (lambda (resolve) (setTimeout resolve 500)))
+ (then (lambda () (load-playlists)))))
+ (alert (+ "Error creating playlist: " (ps:@ data message)))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error creating playlist:" error))
+ (alert (+ "Error creating playlist: " (ps:@ error message))))))))))
+
+ ;; Save queue as playlist
+ (defun save-queue-as-playlist ()
+ (if (> (ps:@ *play-queue* length) 0)
+ (let ((name (prompt "Enter playlist name:")))
+ (when name
+ ;; Create the playlist
+ (let ((form-data (new "FormData")))
+ (ps:chain form-data (append "name" name))
+ (ps:chain form-data (append "description" (+ "Created from queue with " (ps:@ *play-queue* length) " tracks")))
+
+ (ps:chain (fetch "/api/asteroid/playlists/create"
+ (ps:create :method "POST" :body form-data))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (create-result)
+ ;; Handle RADIANCE API wrapper format
+ (let ((create-data (or (ps:@ create-result data) create-result)))
+ (if (== (ps:@ create-data status) "success")
+ (progn
+ ;; Wait a moment for database to update
+ (ps:chain (new "Promise" (lambda (resolve) (setTimeout resolve 500)))
+ (then (lambda ()
+ ;; Get the new playlist ID by fetching playlists
+ (ps:chain (fetch "/api/asteroid/playlists")
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (playlists-result)
+ ;; Handle RADIANCE API wrapper format
+ (let ((playlist-result-data (or (ps:@ playlists-result data) playlists-result)))
+ (if (and (== (ps:@ playlist-result-data status) "success")
+ (> (ps:@ playlist-result-data playlists length) 0))
+ (progn
+ ;; Find the playlist with matching name (most recent)
+ (let ((new-playlist (or (ps:chain (ps:@ playlist-result-data playlists)
+ (find (lambda (p) (== (ps:@ p name) name))))
+ (aref (ps:@ playlist-result-data playlists)
+ (- (ps:@ playlist-result-data playlists length) 1)))))
+
+ ;; Add all tracks from queue to playlist
+ (let ((added-count 0))
+ (ps:chain *play-queue*
+ (for-each (lambda (track)
+ (let ((track-id (ps:@ track id)))
+ (when track-id
+ (let ((add-form-data (new "FormData")))
+ (ps:chain add-form-data (append "playlist-id" (ps:@ new-playlist id)))
+ (ps:chain add-form-data (append "track-id" track-id))
+
+ (ps:chain (fetch "/api/asteroid/playlists/add-track"
+ (ps:create :method "POST" :body add-form-data))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (add-result)
+ (when (== (ps:@ add-result data status) "success")
+ (setf added-count (+ added-count 1)))))
+ (catch (lambda (err)
+ (ps:chain console (log "Error adding track:" err)))))))))))
+
+ (alert (+ "Playlist \"" name "\" created with " added-count " tracks!"))
+ (load-playlists))))
+ (progn
+ (alert (+ "Playlist created but could not add tracks. Error: "
+ (or (ps:@ playlist-result-data message) "Unknown")))
+ (load-playlists))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error fetching playlists:" error))
+ (alert "Playlist created but could not add tracks"))))))))
+ (alert (+ "Error creating playlist: " (ps:@ create-data message)))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error saving queue as playlist:" error))
+ (alert (+ "Error saving queue as playlist: " (ps:@ error message)))))))))
+ (alert "Queue is empty")))
+
+ ;; Load playlists from API
+ (defun load-playlists ()
+ (ps:chain
+ (ps:chain (fetch "/api/asteroid/playlists"))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((playlists (cond
+ ((and (ps:@ result data) (== (ps:@ result data status) "success"))
+ (or (ps:@ result data playlists) (array)))
+ ((== (ps:@ result status) "success")
+ (or (ps:@ result playlists) (array)))
+ (t
+ (array)))))
+ (display-playlists playlists))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading playlists:" error))
+ (display-playlists (array))))))
+
+ ;; Display playlists
+ (defun display-playlists (playlists)
+ (let ((container (ps:chain document (get-element-by-id "playlists-container"))))
+
+ (if (or (not playlists) (== (ps:@ playlists length) 0))
+ (setf (ps:@ container inner-html) ""
+ "
"
+ ""
+ "" (or (ps:@ track title) "Unknown Title") "
"
+ ""
+ "No playlists created yet.
")
+ (let ((playlists-html (ps:chain playlists
+ (map (lambda (playlist)
+ (+ ""
+ "
"))
+ (join "")))))
+
+ (setf (ps:@ container inner-html) playlists-html)))))
+
+ ;; Load playlist into queue
+ (defun load-playlist (playlist-id)
+ (ps:chain
+ (ps:chain (fetch (+ "/api/asteroid/playlists/get?playlist-id=" playlist-id)))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ ;; Handle RADIANCE API wrapper format
+ (let ((data (or (ps:@ result data) result)))
+ (if (and (== (ps:@ data status) "success") (ps:@ data playlist))
+ (let ((playlist (ps:@ data playlist)))
+
+ ;; Clear current queue
+ (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"))))
+ (alert (+ "Error loading playlist: " (or (ps:@ data message) "Unknown error")))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading playlist:" error))
+ (alert (+ "Error loading playlist: " (ps:@ error message)))))))
+
+ ;; Stream quality configuration
+ (defun get-live-stream-config (stream-base-url quality)
+ (let ((config (ps:create
+ :aac (ps:create
+ :url (+ stream-base-url "/asteroid.aac")
+ :type "audio/aac"
+ :mount "asteroid.aac")
+ :mp3 (ps:create
+ :url (+ stream-base-url "/asteroid.mp3")
+ :type "audio/mpeg"
+ :mount "asteroid.mp3")
+ :low (ps:create
+ :url (+ stream-base-url "/asteroid-low.mp3")
+ :type "audio/mpeg"
+ :mount "asteroid-low.mp3"))))
+ (aref config quality)))
+
+ ;; Change live stream quality
+ (defun change-live-stream-quality ()
+ (let ((stream-base-url (ps:chain (ps:chain document (get-element-by-id "stream-base-url")) value))
+ (selector (ps:chain document (get-element-by-id "live-stream-quality")))
+ (config (get-live-stream-config
+ (ps:chain (ps:chain document (get-element-by-id "stream-base-url")) value)
+ (ps:chain (ps:chain document (get-element-by-id "live-stream-quality")) value))))
+
+ ;; Update audio player
+ (let ((audio-element (ps:chain document (get-element-by-id "live-stream-audio")))
+ (source-element (ps:chain document (get-element-by-id "live-stream-source")))
+ (was-playing (not (ps:chain (ps:chain document (get-element-by-id "live-stream-audio")) paused))))
+
+ (setf (ps:@ source-element src) (ps:@ config url))
+ (setf (ps:@ source-element type) (ps:@ config type))
+ (ps:chain audio-element (load))
+
+ ;; Resume playback if it was playing
+ (when was-playing
+ (ps:chain audio-element
+ (play)
+ (catch (lambda (e) (ps:chain console (log "Autoplay prevented:" e)))))))))
+
+ ;; Update now playing information
+ (defun update-now-playing ()
+ (ps:chain
+ (ps:chain (fetch "/api/asteroid/partial/now-playing"))
+ (then (lambda (response)
+ (let ((content-type (ps:chain response (headers) (get "content-type"))))
+ (if (ps:chain content-type (includes "text/html"))
+ (ps:chain response (text))
+ (progn
+ (ps:chain console (log "Error connecting to stream"))
+ "")))))
+ (then (lambda (data)
+ (setf (ps:chain (ps:chain document (get-element-by-id "now-playing")) inner-html) data)))
+ (catch (lambda (error)
+ (ps:chain console (log "Could not fetch stream status:" error))))))
+
+ ;; Initial update after 1 second
+ (ps:chain (setTimeout update-now-playing 1000))
+ ;; Update live stream info every 10 seconds
+ (ps:chain (set-interval update-now-playing 10000))
+
+ ;; Make functions globally accessible for onclick handlers
+ (defvar window (ps:@ window))
+ (setf (ps:@ window play-track) play-track)
+ (setf (ps:@ window add-to-queue) add-to-queue)
+ (setf (ps:@ window remove-from-queue) remove-from-queue)
+ (setf (ps:@ window library-go-to-page) library-go-to-page)
+ (setf (ps:@ window library-previous-page) library-previous-page)
+ (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)))
+ "Compiled JavaScript for web player - generated at load time")
+
+(defun generate-player-js ()
+ "Generate JavaScript code for the web player"
+ *player-js*)
diff --git a/parenscript/profile.lisp b/parenscript/profile.lisp
new file mode 100644
index 0000000..c5c3499
--- /dev/null
+++ b/parenscript/profile.lisp
@@ -0,0 +1,303 @@
+;;;; profile.lisp - ParenScript version of profile.js
+;;;; User profile page with listening stats and history
+
+(in-package #:asteroid)
+
+(defparameter *profile-js*
+ (ps:ps*
+ '(progn
+
+ ;; Global state
+ (defvar *current-user* nil)
+ (defvar *listening-data* nil)
+
+ ;; Utility functions
+ (defun update-element (data-text value)
+ (let ((element (ps:chain document (query-selector (+ "[data-text=\"" data-text "\"]")))))
+ (when (and element (not (= value undefined)) (not (= value null)))
+ (setf (ps:@ element text-content) value))))
+
+ (defun format-role (role)
+ (let ((role-map (ps:create
+ "admin" "👑 Admin"
+ "dj" "🎧 DJ"
+ "listener" "🎵 Listener")))
+ (or (ps:getprop role-map role) role)))
+
+ (defun format-date (date-string)
+ (let ((date (ps:new (-date date-string))))
+ (ps:chain date (to-locale-date-string "en-US"
+ (ps:create :year "numeric"
+ :month "long"
+ :day "numeric")))))
+
+ (defun format-relative-time (date-string)
+ (let* ((date (ps:new (-date date-string)))
+ (now (ps:new (-date)))
+ (diff-ms (- now date))
+ (diff-days (ps:chain -math (floor (/ diff-ms (* 1000 60 60 24)))))
+ (diff-hours (ps:chain -math (floor (/ diff-ms (* 1000 60 60)))))
+ (diff-minutes (ps:chain -math (floor (/ diff-ms (* 1000 60))))))
+ (cond
+ ((> diff-days 0)
+ (+ diff-days " day" (if (> diff-days 1) "s" "") " ago"))
+ ((> diff-hours 0)
+ (+ diff-hours " hour" (if (> diff-hours 1) "s" "") " ago"))
+ ((> diff-minutes 0)
+ (+ diff-minutes " minute" (if (> diff-minutes 1) "s" "") " ago"))
+ (t "Just now"))))
+
+ (defun format-duration (seconds)
+ (let ((hours (ps:chain -math (floor (/ seconds 3600))))
+ (minutes (ps:chain -math (floor (/ (rem seconds 3600) 60)))))
+ (if (> hours 0)
+ (+ hours "h " minutes "m")
+ (+ minutes "m"))))
+
+ (defun show-message (message &optional (type "info"))
+ (let ((toast (ps:chain document (create-element "div")))
+ (colors (ps:create
+ "info" "#007bff"
+ "success" "#28a745"
+ "error" "#dc3545"
+ "warning" "#ffc107")))
+ (setf (ps:@ toast class-name) (+ "toast toast-" type))
+ (setf (ps:@ toast text-content) message)
+ (setf (ps:@ toast style css-text)
+ "position: fixed; top: 20px; right: 20px; padding: 12px 20px; border-radius: 4px; color: white; font-weight: bold; z-index: 1000; opacity: 0; transition: opacity 0.3s ease;")
+ (setf (ps:@ toast style background-color) (or (ps:getprop colors type) (ps:getprop colors "info")))
+
+ (ps:chain document body (append-child toast))
+
+ (set-timeout (lambda () (setf (ps:@ toast style opacity) "1")) 100)
+ (set-timeout (lambda ()
+ (setf (ps:@ toast style opacity) "0")
+ (set-timeout (lambda () (ps:chain document body (remove-child toast))) 300))
+ 3000)))
+
+ (defun show-error (message)
+ (show-message message "error"))
+
+ ;; Profile data loading
+ (defun update-profile-display (user)
+ (update-element "username" (or (ps:@ user username) "Unknown User"))
+ (update-element "user-role" (format-role (or (ps:@ user role) "listener")))
+ (update-element "join-date" (format-date (or (ps:@ user created_at) (ps:new (-date)))))
+ (update-element "last-active" (format-relative-time (or (ps:@ user last_active) (ps:new (-date)))))
+
+ (let ((admin-link (ps:chain document (query-selector "[data-show-if-admin]"))))
+ (when admin-link
+ (setf (ps:@ admin-link style display)
+ (if (= (ps:@ user role) "admin") "inline" "none")))))
+
+ (defun load-listening-stats ()
+ (ps:chain
+ (fetch "/api/asteroid/user/listening-stats")
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (when (= (ps:@ data status) "success")
+ (let ((stats (ps:@ data stats)))
+ (update-element "total-listen-time" (format-duration (or (ps:@ stats total_listen_time) 0)))
+ (update-element "tracks-played" (or (ps:@ stats tracks_played) 0))
+ (update-element "session-count" (or (ps:@ stats session_count) 0))
+ (update-element "favorite-genre" (or (ps:@ stats favorite_genre) "Unknown")))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading listening stats:" error))
+ (update-element "total-listen-time" "0h 0m")
+ (update-element "tracks-played" "0")
+ (update-element "session-count" "0")
+ (update-element "favorite-genre" "Unknown")))))
+
+ (defun load-recent-tracks ()
+ (ps:chain
+ (fetch "/api/asteroid/user/recent-tracks?limit=3")
+ (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 tracks)
+ (> (ps:@ data tracks length) 0))
+ (ps:chain data tracks
+ (for-each (lambda (track index)
+ (let ((track-num (+ index 1)))
+ (update-element (+ "recent-track-" track-num "-title")
+ (or (ps:@ track title) "Unknown Track"))
+ (update-element (+ "recent-track-" track-num "-artist")
+ (or (ps:@ track artist) "Unknown Artist"))
+ (update-element (+ "recent-track-" track-num "-duration")
+ (format-duration (or (ps:@ track duration) 0)))
+ (update-element (+ "recent-track-" track-num "-played-at")
+ (format-relative-time (ps:@ track played_at)))))))
+ (loop for i from 1 to 3
+ do (let* ((track-item-selector (+ "[data-text=\"recent-track-" i "-title\"]"))
+ (track-item-el (ps:chain document (query-selector track-item-selector)))
+ (track-item (when track-item-el (ps:chain track-item-el (closest ".track-item")))))
+ (when (and track-item
+ (or (not (ps:@ data tracks))
+ (not (ps:getprop (ps:@ data tracks) (- i 1)))))
+ (setf (ps:@ track-item style display) "none"))))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading recent tracks:" error))))))
+
+ (defun load-top-artists ()
+ (ps:chain
+ (fetch "/api/asteroid/user/top-artists?limit=5")
+ (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 artists)
+ (> (ps:@ data artists length) 0))
+ (ps:chain data artists
+ (for-each (lambda (artist index)
+ (let ((artist-num (+ index 1)))
+ (update-element (+ "top-artist-" artist-num)
+ (or (ps:@ artist name) "Unknown Artist"))
+ (update-element (+ "top-artist-" artist-num "-plays")
+ (+ (or (ps:@ artist play_count) 0) " plays"))))))
+ (loop for i from 1 to 5
+ do (let* ((artist-item-selector (+ "[data-text=\"top-artist-" i "\"]"))
+ (artist-item-el (ps:chain document (query-selector artist-item-selector)))
+ (artist-item (when artist-item-el (ps:chain artist-item-el (closest ".artist-item")))))
+ (when (and artist-item
+ (or (not (ps:@ data artists))
+ (not (ps:getprop (ps:@ data artists) (- i 1)))))
+ (setf (ps:@ artist-item style display) "none"))))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading top artists:" error))))))
+
+ (defun load-profile-data ()
+ (ps:chain console (log "Loading profile data..."))
+
+ (ps:chain
+ (fetch "/api/asteroid/user/profile")
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ (let ((data (or (ps:@ result data) result)))
+ (if (= (ps:@ data status) "success")
+ (progn
+ (setf *current-user* (ps:@ data user))
+ (update-profile-display (ps:@ data user)))
+ (progn
+ (ps:chain console (error "Failed to load profile:" (ps:@ data message)))
+ (show-error "Failed to load profile data"))))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error loading profile:" error))
+ (show-error "Error loading profile data"))))
+
+ (load-listening-stats)
+ (load-recent-tracks)
+ (load-top-artists))
+
+ ;; Action functions
+ (defun load-more-recent-tracks ()
+ (ps:chain console (log "Loading more recent tracks..."))
+ (show-message "Loading more tracks..." "info"))
+
+ (defun edit-profile ()
+ (ps:chain console (log "Edit profile clicked"))
+ (show-message "Profile editing coming soon!" "info"))
+
+ (defun export-listening-data ()
+ (ps:chain console (log "Exporting listening data..."))
+ (show-message "Preparing data export..." "info")
+
+ (ps:chain
+ (fetch "/api/asteroid/user/export-data" (ps:create :method "POST"))
+ (then (lambda (response) (ps:chain response (blob))))
+ (then (lambda (blob)
+ (let* ((url (ps:chain window -u-r-l (create-object-u-r-l blob)))
+ (a (ps:chain document (create-element "a"))))
+ (setf (ps:@ a style display) "none")
+ (setf (ps:@ a href) url)
+ (setf (ps:@ a download) (+ "asteroid-listening-data-"
+ (or (ps:@ *current-user* username) "user")
+ ".json"))
+ (ps:chain document body (append-child a))
+ (ps:chain a (click))
+ (ps:chain window -u-r-l (revoke-object-u-r-l url))
+ (show-message "Data exported successfully!" "success"))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error exporting data:" error))
+ (show-message "Failed to export data" "error")))))
+
+ (defun clear-listening-history ()
+ (when (not (confirm "Are you sure you want to clear your listening history? This action cannot be undone."))
+ (return))
+
+ (ps:chain console (log "Clearing listening history..."))
+ (show-message "Clearing listening history..." "info")
+
+ (ps:chain
+ (fetch "/api/asteroid/user/clear-history" (ps:create :method "POST"))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (data)
+ (if (= (ps:@ data status) "success")
+ (progn
+ (show-message "Listening history cleared successfully!" "success")
+ (set-timeout (lambda () (ps:chain location (reload))) 1500))
+ (show-message (+ "Failed to clear history: " (ps:@ data message)) "error"))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error clearing history:" error))
+ (show-message "Failed to clear history" "error")))))
+
+ ;; Password change
+ (defun change-password (event)
+ (ps:chain event (prevent-default))
+
+ (let ((current-password (ps:@ (ps:chain document (get-element-by-id "current-password")) value))
+ (new-password (ps:@ (ps:chain document (get-element-by-id "new-password")) value))
+ (confirm-password (ps:@ (ps:chain document (get-element-by-id "confirm-password")) value))
+ (message-div (ps:chain document (get-element-by-id "password-message"))))
+
+ ;; Client-side validation
+ (cond
+ ((< (ps:@ new-password length) 8)
+ (setf (ps:@ message-div text-content) "New password must be at least 8 characters")
+ (setf (ps:@ message-div class-name) "message error")
+ (return false))
+ ((not (= new-password confirm-password))
+ (setf (ps:@ message-div text-content) "New passwords do not match")
+ (setf (ps:@ message-div class-name) "message error")
+ (return false)))
+
+ ;; Send request to API
+ (let ((form-data (ps:new (-form-data))))
+ (ps:chain form-data (append "current-password" current-password))
+ (ps:chain form-data (append "new-password" new-password))
+
+ (ps:chain
+ (fetch "/api/asteroid/user/change-password"
+ (ps:create :method "POST" :body form-data))
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (data)
+ (if (or (= (ps:@ data status) "success")
+ (and (ps:@ data data) (= (ps:@ data data status) "success")))
+ (progn
+ (setf (ps:@ message-div text-content) "Password changed successfully!")
+ (setf (ps:@ message-div class-name) "message success")
+ (ps:chain (ps:chain document (get-element-by-id "change-password-form")) (reset)))
+ (progn
+ (setf (ps:@ message-div text-content)
+ (or (ps:@ data message)
+ (ps:@ data data message)
+ "Failed to change password"))
+ (setf (ps:@ message-div class-name) "message error")))))
+ (catch (lambda (error)
+ (ps:chain console (error "Error changing password:" error))
+ (setf (ps:@ message-div text-content) "Error changing password")
+ (setf (ps:@ message-div class-name) "message error")))))
+
+ false))
+
+ ;; Initialize on page load
+ (ps:chain window
+ (add-event-listener
+ "DOMContentLoaded"
+ load-profile-data))))
+ "Compiled JavaScript for profile page - generated at load time")
+
+(defun generate-profile-js ()
+ "Return the pre-compiled JavaScript for profile page"
+ *profile-js*)
diff --git a/parenscript/recently-played.lisp b/parenscript/recently-played.lisp
new file mode 100644
index 0000000..31119d9
--- /dev/null
+++ b/parenscript/recently-played.lisp
@@ -0,0 +1,95 @@
+;;;; recently-played.lisp - ParenScript version of recently-played.js
+;;;; Recently Played Tracks functionality
+
+(in-package #:asteroid)
+
+(defparameter *recently-played-js*
+ (ps:ps
+ (progn
+
+ ;; Update recently played tracks display
+ (defun update-recently-played ()
+ (ps:chain
+ (fetch "/api/asteroid/recently-played")
+ (then (lambda (response) (ps:chain response (json))))
+ (then (lambda (result)
+ ;; Radiance wraps API responses in a data envelope
+ (let ((data (or (ps:@ result data) result)))
+ (if (and (equal (ps:@ data status) "success")
+ (ps:@ data tracks)
+ (> (ps:@ data tracks length) 0))
+ (let ((list-el (ps:chain document (get-element-by-id "recently-played-list"))))
+ (when list-el
+ ;; Build HTML for tracks
+ (let ((html ""
+ "
"
+ "" (ps:@ playlist name) "
"
+ ""
+ ""
+ ""
+ "
"
+ "- "))
+ (ps:chain (ps:@ data tracks)
+ (for-each (lambda (track index)
+ (let ((time-ago (format-time-ago (ps:@ track timestamp))))
+ (setf html
+ (+ html
+ "
- "
+ "" + "" + "" + "" (escape-html (ps:@ track artist)) "" + "" time-ago "" + " "))))))
+ (setf html (+ html "
No tracks played yet
"))))))) + (catch (lambda (error) + (ps:chain console (error "Error fetching recently played:" error)) + (let ((list-el (ps:chain document (get-element-by-id "recently-played-list")))) + (when list-el + (setf (aref list-el "innerHTML") "Error loading recently played tracks
")))))))) + + ;; Format timestamp as relative time + (defun format-time-ago (timestamp) + (let* ((now (floor (/ (ps:chain *date (now)) 1000))) + (diff (- now timestamp))) + (cond + ((< diff 60) "Just now") + ((< diff 3600) (+ (floor (/ diff 60)) "m ago")) + ((< diff 86400) (+ (floor (/ diff 3600)) "h ago")) + (t (+ (floor (/ diff 86400)) "d ago"))))) + + ;; Escape HTML to prevent XSS + (defun escape-html (text) + (when (ps:@ window document) + (let ((div (ps:chain document (create-element "div")))) + (setf (ps:@ div text-content) text) + (aref div "innerHTML")))) + + ;; Initialize on page load + (when (ps:@ window document) + (ps:chain document + (add-event-listener + "DOMContentLoaded" + (lambda () + (let ((panel (ps:chain document (get-element-by-id "recently-played-panel")))) + (if panel + (progn + (update-recently-played) + ;; Update every 30 seconds + (set-interval update-recently-played 30000)) + (let ((list (ps:chain document (get-element-by-id "recently-played-list")))) + (when list + (update-recently-played) + (set-interval update-recently-played 30000)))))))))) + "Compiled JavaScript for recently played tracks - generated at load time" +) + +(defun generate-recently-played-js () + "Generate JavaScript code for recently played tracks" + *recently-played-js*) diff --git a/parenscript/spectrum-analyzer.lisp b/parenscript/spectrum-analyzer.lisp index c284ff6..01ffd3e 100644 --- a/parenscript/spectrum-analyzer.lisp +++ b/parenscript/spectrum-analyzer.lisp @@ -89,7 +89,8 @@ (height (ps:@ *canvas* height)) (bar-width (/ width buffer-length)) (bar-height 0) - (x 0)) + (x 0) + (is-muted (and *current-audio-element* (ps:@ *current-audio-element* muted)))) (ps:chain *analyser* (get-byte-frequency-data data-array)) @@ -111,7 +112,15 @@ (setf (ps:@ *canvas-ctx* |fillStyle|) gradient) (ps:chain *canvas-ctx* (fill-rect x (- height bar-height) bar-width bar-height)) - (incf x bar-width))))) + (incf x bar-width))) + + ;; Draw MUTED indicator if audio is muted + (when is-muted + (setf (ps:@ *canvas-ctx* |fillStyle|) "rgba(255, 0, 0, 0.8)") + (setf (ps:@ *canvas-ctx* font) "bold 20px monospace") + (setf (ps:@ *canvas-ctx* |textAlign|) "right") + (setf (ps:@ *canvas-ctx* |textBaseline|) "top") + (ps:chain *canvas-ctx* (fill-text "MUTED" (- width 10) 10))))) (defun stop-spectrum-analyzer () "Stop the spectrum analyzer" diff --git a/parenscript/users.lisp b/parenscript/users.lisp new file mode 100644 index 0000000..28bad00 --- /dev/null +++ b/parenscript/users.lisp @@ -0,0 +1,221 @@ +;;;; users.lisp - ParenScript version of users.js +;;;; User management page for admins + +(in-package #:asteroid) + +(defparameter *users-js* + (ps:ps* + '(progn + + ;; Load user stats + (defun load-user-stats () + (ps:chain + (fetch "/api/asteroid/user-stats") + (then (lambda (response) (ps:chain response (json)))) + (then (lambda (result) + (let ((data (or (ps:@ result data) result))) + (when (and (= (ps:@ data status) "success") (ps:@ data stats)) + (let ((stats (ps:@ data stats))) + (setf (ps:@ (ps:chain document (get-element-by-id "total-users")) text-content) + (or (ps:getprop stats "total-users") 0)) + (setf (ps:@ (ps:chain document (get-element-by-id "active-users")) text-content) + (or (ps:getprop stats "active-users") 0)) + (setf (ps:@ (ps:chain document (get-element-by-id "admin-users")) text-content) + (or (ps:getprop stats "admins") 0)) + (setf (ps:@ (ps:chain document (get-element-by-id "dj-users")) text-content) + (or (ps:getprop stats "djs") 0))))))) + (catch (lambda (error) + (ps:chain console (error "Error loading user stats:" error)))))) + + ;; Load users list + (defun load-users () + (ps:chain + (fetch "/api/asteroid/users") + (then (lambda (response) (ps:chain response (json)))) + (then (lambda (result) + (let ((data (or (ps:@ result data) result))) + (when (= (ps:@ data status) "success") + (show-users-table (ps:@ data users)) + (setf (ps:@ (ps:chain document (get-element-by-id "users-list-section")) style display) "block"))))) + (catch (lambda (error) + (ps:chain console (error "Error loading users:" error)) + (alert "Error loading users. Please try again."))))) + + ;; Show users table + (defun show-users-table (users) + (let ((container (ps:chain document (get-element-by-id "users-container"))) + (users-html (ps:chain users + (map (lambda (user) + (+ "| Username | " + "Role | " + "Status | " + "Last Login | " + "Actions | " + "
|---|
-
${track.title || 'Unknown Title'}
-
+ ${track.title[0] || 'Unknown Title'}
+
@@ -237,9 +186,9 @@ function changeLibraryTracksPerPage() {
function filterTracks() {
const query = document.getElementById('search-tracks').value.toLowerCase();
const filtered = tracks.filter(track =>
- (track.title || '').toLowerCase().includes(query) ||
- (track.artist || '').toLowerCase().includes(query) ||
- (track.album || '').toLowerCase().includes(query)
+ (track.title[0] || '').toLowerCase().includes(query) ||
+ (track.artist[0] || '').toLowerCase().includes(query) ||
+ (track.album[0] || '').toLowerCase().includes(query)
);
displayTracks(filtered);
}
@@ -355,9 +304,9 @@ function updatePlayButton(text) {
function updatePlayerDisplay() {
if (currentTrack) {
- document.getElementById('current-title').textContent = currentTrack.title || 'Unknown Title';
- document.getElementById('current-artist').textContent = currentTrack.artist || 'Unknown Artist';
- document.getElementById('current-album').textContent = currentTrack.album || 'Unknown Album';
+ document.getElementById('current-title').textContent = currentTrack.title[0] || 'Unknown Title';
+ document.getElementById('current-artist').textContent = currentTrack.artist[0] || 'Unknown Artist';
+ document.getElementById('current-album').textContent = currentTrack.album[0] || 'Unknown Album';
}
}
@@ -379,8 +328,8 @@ function updateQueueDisplay() {
const queueHtml = playQueue.map((track, index) => `
@@ -417,10 +366,8 @@ async function createPlaylist() {
});
const result = await response.json();
- // Handle RADIANCE API wrapper format
- const data = result.data || result;
- if (data.status === 'success') {
+ if (result.status === 'success') {
alert(`Playlist "${name}" created successfully!`);
document.getElementById('new-playlist-name').value = '';
@@ -428,7 +375,7 @@ async function createPlaylist() {
await new Promise(resolve => setTimeout(resolve, 500));
loadPlaylists();
} else {
- alert('Error creating playlist: ' + data.message);
+ alert('Error creating playlist: ' + result.message);
}
} catch (error) {
console.error('Error creating playlist:', error);
@@ -457,28 +404,24 @@ async function saveQueueAsPlaylist() {
});
const createResult = await createResponse.json();
- // Handle RADIANCE API wrapper format
- const createData = createResult.data || createResult;
- if (createData.status === 'success') {
+ if (createResult.status === 'success') {
// Wait a moment for database to update
await new Promise(resolve => setTimeout(resolve, 500));
// Get the new playlist ID by fetching playlists
const playlistsResponse = await fetch('/api/asteroid/playlists');
const playlistsResult = await playlistsResponse.json();
- // Handle RADIANCE API wrapper format
- const playlistResultData = playlistsResult.data || playlistsResult;
- if (playlistResultData.status === 'success' && playlistResultData.playlists.length > 0) {
+ if (playlistsResult.status === 'success' && playlistsResult.playlists.length > 0) {
// Find the playlist with matching name (most recent)
- const newPlaylist = playlistResultData.playlists.find(p => p.name === name) ||
- playlistResultData.playlists[playlistResultData.playlists.length - 1];
+ const newPlaylist = playlistsResult.playlists.find(p => p.name === name) ||
+ playlistsResult.playlists[playlistsResult.playlists.length - 1];
// Add all tracks from queue to playlist
let addedCount = 0;
for (const track of playQueue) {
- const trackId = track.id;
+ const trackId = track.id || (Array.isArray(track.id) ? track.id[0] : null);
if (trackId) {
const addFormData = new FormData();
@@ -492,7 +435,7 @@ async function saveQueueAsPlaylist() {
const addResult = await addResponse.json();
- if (addResult.data?.status === 'success') {
+ if (addResult.status === 'success') {
addedCount++;
}
} else {
@@ -503,11 +446,10 @@ async function saveQueueAsPlaylist() {
alert(`Playlist "${name}" created with ${addedCount} tracks!`);
loadPlaylists();
} else {
- alert('Playlist created but could not add tracks. Error: ' + (playlistResultData.message || 'Unknown'));
- loadPlaylists();
+ alert('Playlist created but could not add tracks. Error: ' + (playlistsResult.message || 'Unknown'));
}
} else {
- alert('Error creating playlist: ' + createData.message);
+ alert('Error creating playlist: ' + createResult.message);
}
} catch (error) {
console.error('Error saving queue as playlist:', error);
@@ -519,11 +461,11 @@ async function loadPlaylists() {
try {
const response = await fetch('/api/asteroid/playlists');
const result = await response.json();
- // Handle RADIANCE API wrapper format
- const data = result.data || result;
- if (data && data.status === 'success') {
- displayPlaylists(data.playlists || []);
+ if (result.data && result.data.status === 'success') {
+ displayPlaylists(result.data.playlists || []);
+ } else if (result.status === 'success') {
+ displayPlaylists(result.playlists || []);
} else {
displayPlaylists([]);
}
@@ -560,11 +502,9 @@ async function loadPlaylist(playlistId) {
try {
const response = await fetch(`/api/asteroid/playlists/get?playlist-id=${playlistId}`);
const result = await response.json();
- // Handle RADIANCE API wrapper format
- const data = result.data || result;
- if (data.status === 'success' && data.playlist) {
- const playlist = data.playlist;
+ if (result.status === 'success' && result.playlist) {
+ const playlist = result.playlist;
// Clear current queue
playQueue = [];
@@ -594,7 +534,7 @@ async function loadPlaylist(playlistId) {
alert(`Playlist "${playlist.name}" is empty`);
}
} else {
- alert('Error loading playlist: ' + (data.message || 'Unknown error'));
+ alert('Error loading playlist: ' + (result.message || 'Unknown error'));
}
} catch (error) {
console.error('Error loading playlist:', error);
@@ -649,12 +589,6 @@ function changeLiveStreamQuality() {
// Live stream informatio update
async function updateNowPlaying() {
- // Don't update if stream is paused
- const liveAudio = document.getElementById('live-stream-audio');
- if (liveAudio && liveAudio.paused) {
- return;
- }
-
try {
const response = await fetch('/api/asteroid/partial/now-playing')
const contentType = response.headers.get("content-type")
diff --git a/static/js/profile.js b/static/js/profile.js.original
similarity index 100%
rename from static/js/profile.js
rename to static/js/profile.js.original
diff --git a/static/js/users.js b/static/js/users.js.original
similarity index 100%
rename from static/js/users.js
rename to static/js/users.js.original
diff --git a/template/audio-player-frame.ctml b/template/audio-player-frame.ctml
index 1890fab..88777b1 100644
--- a/template/audio-player-frame.ctml
+++ b/template/audio-player-frame.ctml
@@ -47,64 +47,15 @@
});
}
- // Track pause timestamp to detect long pauses and reconnect
- let pauseTimestamp = null;
- let isReconnecting = false;
- let needsReconnect = false;
- const PAUSE_RECONNECT_THRESHOLD = 10000; // 10 seconds
-
- audioElement.addEventListener('pause', function() {
- pauseTimestamp = Date.now();
- console.log('Frame player stream paused at:', pauseTimestamp);
- });
-
- audioElement.addEventListener('play', function() {
- // Check if we need to reconnect after long pause
- if (!isReconnecting && pauseTimestamp && (Date.now() - pauseTimestamp) > PAUSE_RECONNECT_THRESHOLD) {
- needsReconnect = true;
- console.log('Long pause detected, will reconnect when playing starts...');
- }
- pauseTimestamp = null;
- });
-
- // Intercept the playing event to stop stale audio
- audioElement.addEventListener('playing', function() {
- if (needsReconnect && !isReconnecting) {
- isReconnecting = true;
- needsReconnect = false;
- console.log('Reconnecting frame player stream after long pause to clear stale buffers...');
-
- // Stop the stale audio immediately
- audioElement.pause();
-
- // Reset spectrum analyzer before reconnect
- if (typeof resetSpectrumAnalyzer === 'function') {
- resetSpectrumAnalyzer();
- }
-
- audioElement.load(); // Force reconnect to clear accumulated buffer
-
- // Start playing the fresh stream and reinitialize spectrum analyzer
- setTimeout(function() {
- audioElement.play().catch(err => console.log('Reconnect play failed:', err));
-
- if (typeof initSpectrumAnalyzer === 'function') {
- initSpectrumAnalyzer();
- console.log('Spectrum analyzer reinitialized after reconnect');
- }
-
- isReconnecting = false;
- }, 200);
- } else {
- console.log('Audio playing');
- }
- });
-
// Add event listeners for debugging
audioElement.addEventListener('waiting', function() {
console.log('Audio buffering...');
});
+ audioElement.addEventListener('playing', function() {
+ console.log('Audio playing');
+ });
+
audioElement.addEventListener('error', function(e) {
console.error('Audio error:', e);
});
@@ -161,12 +112,6 @@
// Update mini now playing display
async function updateMiniNowPlaying() {
- // Don't update if stream is paused
- const audioElement = document.getElementById('persistent-audio');
- if (audioElement && audioElement.paused) {
- return;
- }
-
try {
const response = await fetch('/api/asteroid/partial/now-playing-inline');
if (response.ok) {
diff --git a/template/frameset-wrapper.ctml b/template/frameset-wrapper.ctml
index 0cf1f2e..648e2b4 100644
--- a/template/frameset-wrapper.ctml
+++ b/template/frameset-wrapper.ctml
@@ -1,7 +1,7 @@
- 🎵 ASTEROID RADIO 🎵
+ ASTEROID RADIO
-
${track.title || 'Unknown Title'}
-
+ ${track.title[0] || 'Unknown Title'}
+
-
+
🎵 WEB PLAYER
+
+ 
+ WEB PLAYER
+
+
Home
Profile
diff --git a/template/popout-player.ctml b/template/popout-player.ctml
index 737c75b..569182f 100644
--- a/template/popout-player.ctml
+++ b/template/popout-player.ctml
@@ -97,12 +97,6 @@
// Update now playing info for popout
async function updatePopoutNowPlaying() {
- // Don't update if stream is paused
- const audioElement = document.getElementById('live-audio');
- if (audioElement && audioElement.paused) {
- return;
- }
-
try {
const response = await fetch('/api/asteroid/partial/now-playing-inline');
const html = await response.text();
@@ -131,60 +125,8 @@
// Initial update
updatePopoutNowPlaying();
- // Auto-reconnect on stream errors and after long pauses
+ // Auto-reconnect on stream errors
const audioElement = document.getElementById('live-audio');
-
- // Track pause timestamp to detect long pauses and reconnect
- let pauseTimestamp = null;
- let isReconnecting = false;
- let needsReconnect = false;
- const PAUSE_RECONNECT_THRESHOLD = 10000; // 10 seconds
-
- audioElement.addEventListener('pause', function() {
- pauseTimestamp = Date.now();
- console.log('Popout stream paused at:', pauseTimestamp);
- });
-
- audioElement.addEventListener('play', function() {
- // Check if we need to reconnect after long pause
- if (!isReconnecting && pauseTimestamp && (Date.now() - pauseTimestamp) > PAUSE_RECONNECT_THRESHOLD) {
- needsReconnect = true;
- console.log('Long pause detected, will reconnect when playing starts...');
- }
- pauseTimestamp = null;
- });
-
- // Intercept the playing event to stop stale audio
- audioElement.addEventListener('playing', function() {
- if (needsReconnect && !isReconnecting) {
- isReconnecting = true;
- needsReconnect = false;
- console.log('Reconnecting popout stream after long pause to clear stale buffers...');
-
- // Stop the stale audio immediately
- audioElement.pause();
-
- // Reset spectrum analyzer before reconnect
- if (typeof resetSpectrumAnalyzer === 'function') {
- resetSpectrumAnalyzer();
- }
-
- audioElement.load(); // Force reconnect to clear accumulated buffer
-
- // Start playing the fresh stream and reinitialize spectrum analyzer
- setTimeout(function() {
- audioElement.play().catch(err => console.log('Reconnect play failed:', err));
-
- if (typeof initSpectrumAnalyzer === 'function') {
- initSpectrumAnalyzer();
- console.log('Spectrum analyzer reinitialized after reconnect');
- }
-
- isReconnecting = false;
- }, 200);
- }
- });
-
audioElement.addEventListener('error', function(e) {
console.log('Stream error, attempting reconnect in 3 seconds...');
setTimeout(function() {
diff --git a/template/register.ctml b/template/register.ctml
index 3d90ce0..81f1663 100644
--- a/template/register.ctml
+++ b/template/register.ctml
@@ -4,12 +4,18 @@
Asteroid Radio - Register
+
+
+
-
+