Files
navidrome/server/nativeapi/queue.go
T
Deluan Quintão e9c0efa446 chore(lint): enable staticcheck (#6485)
Enforces the default staticcheck SA, S, ST and QF checks; fixed 76 sites (54 autofixed quick fixes, 22 by hand).
Dot imports are allowed only for squirrel, the established query builder style in persistence.
SA1019 is excluded for the deprecated plugins/types.SongRef wire fields the host still reads and writes for older plugins.
Also fixes an off-by-one in the redactrus test levelThreshold helper that panicked one level past TraceLevel.
2026-11-16 22:48:42 -05:00

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 := gg.V(payload.Ids)
items := createMediaFileItems(ids)
current := gg.V(payload.Current)
if len(ids) > 0 && !validateCurrentIndex(w, current, len(ids)) {
return
}
pq := &model.PlayQueue{
UserID: user.ID,
Current: current,
Position: max(gg.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)
}
}