The Playlist

This brings me to the next URL function, playlist. This is the most complex page of the three—it’s responsible for displaying the current contents of the user’s playlist as well as for providing the interface to manipulate the playlist. But with most of the tedious bookkeeping handled by define-url-function, it’s not too hard to see how playlist works. Here’s the beginning of the definition, with just the parameter list:

  1. (define-url-function playlist 
  2.     (request
  3.      (playlist-id string (playlist-id request) :package)
  4.      (action keyword)      ; Playlist manipulation action
  5.      (what keyword :file)  ; for :add-songs action
  6.      (values base-64-list) ;             "
  7.      file                  ; for :add-songs and :delete-songs actions
  8.      genre                 ; for :delete-songs action
  9.      artist                ;             "
  10.      album                 ;             "
  11.      (order-by keyword)    ; for :sort action
  12.      (shuffle keyword)     ; for :shuffle action
  13.      (repeat keyword))     ; for :set-repeat action

In addition to the obligatory request parameter, playlist takes a number of query parameters. The most important in some ways is playlist-id, which identifies which playlist object the page should display and manipulate. For this parameter, you can take advantage of define-url-function‘s “sticky parameter” feature. Normally, the playlist-id won’t be supplied explicitly, defaulting to the value returned by the playlist-id function, namely, the IP address of the client machine on which the browser is running. However, users can also manipulate their playlists from different machines than the ones running their MP3 clients by allowing this value to be explicitly specified. And if it’s specified once, define-url-function will arrange for it to “stick” by setting a cookie in the browser. Later you’ll define a URL function that generates a list of all existing playlists, which users can use to pick a playlist other than the one for the machines they’re browsing from.

The action parameter specifies some action to take on the user’s playlist object. The value of this parameter, which will be converted to a keyword symbol for you, can be :add-songs, :delete-songs, :clear, :sort, :shuffle, or :set-repeat. The :add-songs action is used by the “Add all” button in the browse page and also by the links used to add individual songs. The other actions are used by the links on the playlist page itself.

The file, what, and values parameters are used with the :add-songs action. By declaring values to be of type base-64-list, the define-url-function infrastructure will take care of decoding the value submitted by the “Add all” form. The other parameters are used with other actions as noted in the comments.

Now let’s look at the body of playlist. The first thing you need to do is use the playlist-id to look up the queue object and then acquire the playlist’s lock with the following two lines:

  1. (let ((playlist (lookup-playlist playlist-id)))
  2.   (with-playlist-locked (playlist)

Since lookup-playlist will create a new playlist if necessary, this will always return a playlist object. Then you take care of any necessary queue manipulation, dispatching on the value of the action parameter in order to call one of the playlist functions.

  1. (case action
  2.   (:add-songs      (add-songs playlist what (or values (list file))))
  3.   (:delete-songs   (delete-songs 
  4.                     playlist 
  5.                     :file file :genre genre
  6.                     :artist artist :album album))
  7.   (:clear          (clear-playlist playlist))
  8.   (:sort           (sort-playlist playlist order-by))
  9.   (:shuffle        (shuffle-playlist playlist shuffle))
  10.   (:set-repeat     (setf (repeat playlist) repeat)))

All that’s left of the playlist function is the actual HTML generation. Again, you can use the :mp3-browser-page HTML macro to make sure the basic form of the page matches the other pages in the application, though this time you pass **NIL** to the :header argument in order to leave out the H1 header. Here’s the rest of the function:

  1. (html
  2.  (:mp3-browser-page
  3.   (:title (:format "Playlist - ~a" (id playlist)) :header nil)
  4.   (playlist-toolbar playlist)
  5.   (if (empty-p playlist)
  6.     (html (:p (:i "Empty.")))
  7.     (html 
  8.       ((:table :class "playlist")
  9.        (:table-row "#" "Song" "Album" "Artist" "Genre")
  10.        (let ((idx 0)
  11.              (current-idx (current-idx playlist)))
  12.          (do-rows (row (songs-table playlist))
  13.            (with-column-values (track file song album artist genre) row
  14.              (let ((row-style (if (= idx current-idx) "now-playing" "normal")))
  15.                (html
  16.                  ((:table-row :class row-style)
  17.                   track
  18.                   (:progn song   (delete-songs-link :file file))
  19.                   (:progn album  (delete-songs-link :album album))
  20.                   (:progn artist (delete-songs-link :artist artist))
  21.                   (:progn genre  (delete-songs-link :genre genre)))))
  22.              (incf idx))))))))))))

The function playlist-toolbar generates a toolbar containing links to playlist to perform the various :action manipulations. And delete-songs-link generates a link to playlist with the :action parameter set to :delete-songs and the appropriate arguments to delete an individual file, or all files on an album, by a particular artist or in a specific genre.

  1. (defun playlist-toolbar (playlist)
  2.   (let ((current-repeat (repeat playlist))
  3.         (current-sort (ordering playlist))
  4.         (current-shuffle (shuffle playlist)))
  5.     (html
  6.      (:p :class "playlist-toolbar"
  7.          (:i "Sort by:")
  8.          " [ "
  9.          (sort-playlist-button "genre" current-sort) " | " 
  10.          (sort-playlist-button "artist" current-sort) " | " 
  11.          (sort-playlist-button "album" current-sort) " | " 
  12.          (sort-playlist-button "song" current-sort) " ] "
  13.          (:i "Shuffle by:")
  14.          " [ "
  15.          (playlist-shuffle-button "none" current-shuffle) " | "
  16.          (playlist-shuffle-button "song" current-shuffle) " | "
  17.          (playlist-shuffle-button "album" current-shuffle) " ] "
  18.          (:i "Repeat:")
  19.          " [ "
  20.          (playlist-repeat-button "none" current-repeat) " | "
  21.          (playlist-repeat-button "song" current-repeat) " | "
  22.          (playlist-repeat-button "all" current-repeat) " ] "
  23.          "[ " (:a :href (link "playlist" :action "clear") "Clear") " ] "))))
  25. (defun playlist-button (action argument new-value current-value)
  26.   (let ((label (string-capitalize new-value)))
  27.     (if (string-equal new-value current-value)
  28.       (html (:b label))
  29.       (html (:a :href (link "playlist" :action action argument new-value) label)))))
  31. (defun sort-playlist-button (order-by current-sort)
  32.   (playlist-button :sort :order-by order-by current-sort))
  34. (defun playlist-shuffle-button (shuffle current-shuffle)
  35.   (playlist-button :shuffle :shuffle shuffle current-shuffle))
  37. (defun playlist-repeat-button (repeat current-repeat)
  38.   (playlist-button :set-repeat :repeat repeat current-repeat))
  40. (defun delete-songs-link (what value)
  41.   (html " [" (:a :href (link "playlist" :action :delete-songs what value) "x") "]"))