mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-16 02:42:34 +03:00
RetrieveWithMediaFiles now returns ErrIncompleteQueue when it reads the queue but a track query fails. Before, it returned the partially loaded list with no error, and a current-only PUT /api/queue could validate and map an index against that list and store the wrong track. updateQueue already fails on any retrieval error, so it now returns 500 and writes nothing. The GET handlers (getPlayQueue, getPlayQueueByIndex and GET /api/queue) treat ErrIncompleteQueue like before and still return the tracks that loaded.
244 lines
7.2 KiB
Go
244 lines
7.2 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) && !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) //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)
|
|
}
|
|
}
|