Files
navidrome/server/nativeapi/queue.go
T

290 lines
8.9 KiB
Go

package nativeapi
import (
"context"
"encoding/json"
"errors"
"net/http"
"slices"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
. "github.com/navidrome/navidrome/utils/gg"
"github.com/navidrome/navidrome/utils/slice"
)
type updateQueuePayload struct {
Ids *[]string `json:"ids,omitempty"`
Current *int `json:"current,omitempty"`
Position *int64 `json:"position,omitempty"`
}
// validateCurrentIndex validates that the current index is within bounds of the items array.
// Returns false if validation fails (and sends error response), true if validation passes.
func validateCurrentIndex(w http.ResponseWriter, current int, itemsLength int) bool {
if current < 0 || current >= itemsLength {
http.Error(w, "current index out of bounds", http.StatusBadRequest)
return false
}
return true
}
// retrieveQueue retrieves a user's play queue with proper error handling.
// Returns the queue (nil if not found) and false if an error occurred and response was sent.
func retrieveQueue(ctx context.Context, w http.ResponseWriter, userID string, retrieve func(context.Context, string) (*model.PlayQueue, error), ignore ...error) (*model.PlayQueue, bool) {
existing, err := retrieve(ctx, userID)
if err != nil && !errors.Is(err, model.ErrNotFound) && !slices.ContainsFunc(ignore, func(e error) bool { return errors.Is(err, e) }) {
log.Error(ctx, "Error retrieving queue", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return nil, false
}
return existing, true
}
// storedIndex maps an index in the queue as GET returns it to the stored queue, which keeps the same order.
func storedIndex(stored, visible model.MediaFiles, i int) int {
kept := 0
for j, t := range stored {
if kept < len(visible) && visible[kept].ID == t.ID {
if kept == i {
return j
}
kept++
}
}
return i
}
// fallbackCurrent returns the stored index of the track GET shows in place of a stored current track the user can't see.
func fallbackCurrent(ctx context.Context, w http.ResponseWriter, ds model.DataStore, userID string) (int, bool, bool) {
repo := ds.PlayQueue()
stored, ok := retrieveQueue(ctx, w, userID, repo.Retrieve)
if !ok || stored == nil {
return 0, false, ok
}
if stored.Current >= 0 && stored.Current < len(stored.Items) {
visible, err := ds.MediaFile().Exists(ctx, stored.Items[stored.Current].ID)
if err != nil {
log.Error(ctx, "Error checking current queue track", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return 0, false, false
}
if visible {
return 0, false, true
}
}
visible, ok := retrieveQueue(ctx, w, userID, repo.RetrieveWithMediaFiles)
if !ok || visible == nil {
return 0, false, ok
}
current := storedIndex(stored.Items, visible.Items, visible.Current)
return current, current != stored.Current, true
}
// decodeUpdatePayload decodes the JSON payload from the request body.
// Returns false if decoding fails (and sends error response), true if successful.
func decodeUpdatePayload(w http.ResponseWriter, r *http.Request) (*updateQueuePayload, bool) {
var payload updateQueuePayload
if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return nil, false
}
return &payload, true
}
// createMediaFileItems converts a slice of IDs to MediaFile items.
func createMediaFileItems(ids []string) []model.MediaFile {
return slice.Map(ids, func(id string) model.MediaFile {
return model.MediaFile{ID: id}
})
}
// extractUserAndClient extracts user and client from the request context.
func extractUserAndClient(ctx context.Context) (model.User, string) {
user, _ := request.UserFrom(ctx)
client, _ := request.ClientFrom(ctx)
return user, client
}
func getQueue(ds model.DataStore) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
user, _ := request.UserFrom(ctx)
repo := ds.PlayQueue()
pq, err := repo.RetrieveWithMediaFiles(ctx, user.ID)
if err != nil && !errors.Is(err, model.ErrNotFound) && !errors.Is(err, model.ErrIncompleteQueue) {
log.Error(ctx, "Error retrieving queue", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if pq == nil {
pq = &model.PlayQueue{}
}
resp, err := json.Marshal(pq)
if err != nil {
log.Error(ctx, "Error marshalling queue", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(resp)
}
}
func saveQueue(ds model.DataStore) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
payload, ok := decodeUpdatePayload(w, r)
if !ok {
return
}
user, client := extractUserAndClient(ctx)
ids := V(payload.Ids)
items := createMediaFileItems(ids)
current := V(payload.Current)
if len(ids) > 0 && !validateCurrentIndex(w, current, len(ids)) {
return
}
pq := &model.PlayQueue{
UserID: user.ID,
Current: current,
Position: max(V(payload.Position), 0),
ChangedBy: client,
Items: items,
}
if err := ds.PlayQueue().Store(ctx, pq); err != nil {
log.Error(ctx, "Error saving queue", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusNoContent)
}
}
func updateQueue(ds model.DataStore) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
// Decode and validate the JSON payload
payload, ok := decodeUpdatePayload(w, r)
if !ok {
return
}
// Extract user and client information from request context
user, client := extractUserAndClient(ctx)
// Initialize play queue with user ID and client info
pq := &model.PlayQueue{UserID: user.ID, ChangedBy: client}
var cols []string // Track which columns to update in the database
repo := ds.PlayQueue()
// Clients index the queue as GET returns it, without the tracks the user can't see
if payload.Ids != nil {
pq.Items = createMediaFileItems(*payload.Ids)
cols = append(cols, "items")
if payload.Current == nil {
// On a load error GET shows the stored current and position, so only items get written
visible, ok := retrieveQueue(ctx, w, user.ID, repo.RetrieveWithMediaFiles, model.ErrIncompleteQueue)
if !ok {
return
}
if visible != nil {
if !validateCurrentIndex(w, visible.Current, len(*payload.Ids)) {
return
}
stored, ok := retrieveQueue(ctx, w, user.ID, repo.Retrieve)
if !ok {
return
}
// Write only what GET changed, so a concurrent position update is not overwritten
if visible.Current != stored.Current {
pq.Current = visible.Current
cols = append(cols, "current")
}
if payload.Position == nil && visible.Position != stored.Position {
pq.Position = visible.Position
cols = append(cols, "position")
}
}
}
}
// Handle current track index update
if payload.Current != nil {
pq.Current = *payload.Current
cols = append(cols, "current")
if payload.Ids != nil {
// If items are also being updated, validate current index against new items
if !validateCurrentIndex(w, *payload.Current, len(*payload.Ids)) {
return
}
} else {
visible, ok := retrieveQueue(ctx, w, user.ID, repo.RetrieveWithMediaFiles)
if !ok {
return
}
if visible != nil {
if !validateCurrentIndex(w, *payload.Current, len(visible.Items)) {
return
}
stored, ok := retrieveQueue(ctx, w, user.ID, repo.Retrieve)
if !ok {
return
}
if stored != nil {
pq.Current = storedIndex(stored.Items, visible.Items, *payload.Current)
}
}
}
}
// Handle playback position update
if payload.Position != nil {
pq.Position = max(*payload.Position, 0) // Ensure position is non-negative
cols = append(cols, "position")
if payload.Ids == nil && payload.Current == nil {
current, moved, ok := fallbackCurrent(ctx, w, ds, user.ID)
if !ok {
return
}
if moved {
pq.Current = current
cols = append(cols, "current")
}
}
}
// If no fields were specified for update, return success without doing anything
if len(cols) == 0 {
w.WriteHeader(http.StatusNoContent)
return
}
// Perform partial update of the specified columns only
if err := repo.Store(ctx, pq, cols...); err != nil {
log.Error(ctx, "Error updating queue", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusNoContent)
}
}
func clearQueue(ds model.DataStore) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
user, _ := request.UserFrom(ctx)
if err := ds.PlayQueue().Clear(ctx, user.ID); err != nil {
log.Error(ctx, "Error clearing queue", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusNoContent)
}
}