mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-16 02:42:34 +03:00
Reading the play queue no longer writes the filtered queue back in the background. That save treated tracks hidden by library access like purged ones, so a user who lost a library for a while lost those tracks from the queue for good. It could also race with partial PUT /api/queue updates and leave the index out of range or on the wrong track. GET now only remaps current and position in its response. PUT /api/queue reads the same filtered queue: a current-only update is checked against it and stored as the index of the same track in the stored queue, and an ids-only update keeps the current track and position the client saw.
244 lines
7.1 KiB
Go
244 lines
7.1 KiB
Go
package nativeapi
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
|
|
"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)) (*model.PlayQueue, bool) {
|
|
existing, err := retrieve(ctx, userID)
|
|
if err != nil && !errors.Is(err, model.ErrNotFound) {
|
|
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
|
|
}
|
|
|
|
// 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) {
|
|
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) //nolint:gosec
|
|
}
|
|
}
|
|
|
|
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 {
|
|
visible, ok := retrieveQueue(ctx, w, user.ID, repo.RetrieveWithMediaFiles)
|
|
if !ok {
|
|
return
|
|
}
|
|
if visible != nil {
|
|
if !validateCurrentIndex(w, visible.Current, len(*payload.Ids)) {
|
|
return
|
|
}
|
|
pq.Current = visible.Current
|
|
cols = append(cols, "current")
|
|
if payload.Position == nil {
|
|
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 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)
|
|
}
|
|
}
|