mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-21 09:29:46 +01:00
loadTracks and the playlist-track cursor were the only entity-page paths that never hydrated artwork state, so a song reached through a playlist behaved differently from the same song in the songs list: Subsonic emitted a hashless coverArt id, which imghttp downgrades to no-cache, and advertised art even for known-absent albums; Jellyfin emitted AlbumPrimaryImageTag as the bare album id — a tag that never changes when the cover does — and no blurhash at all. The media-file hydration moves next to the other hydration helpers so both paths share one implementation rather than growing a third.
285 lines
8.5 KiB
Go
285 lines
8.5 KiB
Go
package persistence
|
|
|
|
import (
|
|
"database/sql"
|
|
|
|
. "github.com/Masterminds/squirrel"
|
|
"github.com/deluan/rest"
|
|
"github.com/navidrome/navidrome/log"
|
|
"github.com/navidrome/navidrome/model"
|
|
"github.com/navidrome/navidrome/utils/slice"
|
|
)
|
|
|
|
type playlistTrackRepository struct {
|
|
sqlRepository
|
|
playlistId string
|
|
playlist *model.Playlist
|
|
playlistRepo *playlistRepository
|
|
}
|
|
|
|
type dbPlaylistTrack struct {
|
|
dbMediaFile
|
|
*model.PlaylistTrack `structs:",flatten"`
|
|
}
|
|
|
|
func (t *dbPlaylistTrack) PostScan() error {
|
|
if err := t.dbMediaFile.PostScan(); err != nil {
|
|
return err
|
|
}
|
|
t.PlaylistTrack.MediaFile = *t.dbMediaFile.MediaFile
|
|
t.PlaylistTrack.MediaFile.ID = t.MediaFileID
|
|
return nil
|
|
}
|
|
|
|
type dbPlaylistTracks []dbPlaylistTrack
|
|
|
|
func (t dbPlaylistTracks) toModels() model.PlaylistTracks {
|
|
return slice.Map(t, func(trk dbPlaylistTrack) model.PlaylistTrack {
|
|
return *trk.PlaylistTrack
|
|
})
|
|
}
|
|
|
|
func (r *playlistRepository) Tracks(playlistId string, refreshSmartPlaylist bool) model.PlaylistTrackRepository {
|
|
p := &playlistTrackRepository{}
|
|
p.playlistRepo = r
|
|
p.playlistId = playlistId
|
|
p.ctx = r.ctx
|
|
p.db = r.db
|
|
p.tableName = "playlist_tracks"
|
|
p.registerModel(&model.PlaylistTrack{}, map[string]filterFunc{
|
|
"missing": booleanFilter,
|
|
"library_id": libraryIdFilter,
|
|
})
|
|
p.setSortMappings(
|
|
map[string]string{
|
|
"id": "playlist_tracks.id",
|
|
"artist": "order_artist_name",
|
|
"album_artist": "order_album_artist_name",
|
|
"album": "order_album_name, album_id, disc_number, track_number, order_artist_name, title",
|
|
"title": "order_title",
|
|
// To make sure these fields will be whitelisted
|
|
"duration": "duration",
|
|
"year": "year",
|
|
"bpm": "bpm",
|
|
"channels": "channels",
|
|
},
|
|
"f") // TODO I don't like this solution, but I won't change it now as it's not the focus of BFR.
|
|
|
|
pls, err := r.Get(playlistId)
|
|
if err != nil {
|
|
log.Warn(r.ctx, "Error getting playlist's tracks", "playlistId", playlistId, err)
|
|
return nil
|
|
}
|
|
if refreshSmartPlaylist {
|
|
r.refreshSmartPlaylist(pls)
|
|
}
|
|
p.playlist = pls
|
|
return p
|
|
}
|
|
|
|
func (r *playlistTrackRepository) CountAll(options ...model.QueryOptions) (int64, error) {
|
|
query := Select().
|
|
Join("media_file f on f.id = media_file_id").
|
|
Where(Eq{"playlist_id": r.playlistId})
|
|
query = r.applyLibraryFilter(query, "f")
|
|
return r.count(query, options...)
|
|
}
|
|
|
|
func (r *playlistTrackRepository) Count(options ...rest.QueryOptions) (int64, error) {
|
|
query := Select().
|
|
LeftJoin("media_file f on f.id = media_file_id").
|
|
Where(Eq{"playlist_id": r.playlistId})
|
|
return r.count(query, r.parseRestOptions(r.ctx, options...))
|
|
}
|
|
|
|
func (r *playlistTrackRepository) Read(id string) (any, error) {
|
|
userID := loggedUser(r.ctx).ID
|
|
sel := r.newSelect().
|
|
LeftJoin("annotation on ("+
|
|
"annotation.item_id = media_file_id"+
|
|
" AND annotation.item_type = 'media_file'"+
|
|
" AND annotation.user_id = '"+userID+"')").
|
|
Columns(
|
|
"coalesce(starred, 0) as starred",
|
|
"coalesce(play_count, 0) as play_count",
|
|
"coalesce(rating, 0) as rating",
|
|
"starred_at",
|
|
"play_date",
|
|
"rated_at",
|
|
"f.*",
|
|
"playlist_tracks.*",
|
|
).
|
|
Join("media_file f on f.id = media_file_id").
|
|
Where(And{Eq{"playlist_id": r.playlistId}, Eq{"playlist_tracks.id": id}})
|
|
var trk dbPlaylistTrack
|
|
err := r.queryOne(sel, &trk)
|
|
return trk.PlaylistTrack, err
|
|
}
|
|
|
|
func (r *playlistTrackRepository) GetAll(options ...model.QueryOptions) (model.PlaylistTracks, error) {
|
|
tracks, err := r.playlistRepo.loadTracks(r.newSelect(options...), r.playlistId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return tracks, err
|
|
}
|
|
|
|
func (r *playlistTrackRepository) GetCursor(options ...model.QueryOptions) (model.PlaylistTrackCursor, error) {
|
|
sel := r.playlistRepo.tracksQuery(r.newSelect(options...), r.playlistId)
|
|
cursor, err := queryWithStableResults[dbPlaylistTrack](r.sqlRepository, sel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tracks := wrapCursor(cursor, func(t dbPlaylistTrack) *model.PlaylistTrack {
|
|
return t.PlaylistTrack
|
|
})
|
|
return model.PlaylistTrackCursor(hydrateCursor(tracks, func(batch []model.PlaylistTrack) {
|
|
hydratePlaylistTrackArtwork(r.ctx, r.db, batch)
|
|
})), nil
|
|
}
|
|
|
|
// GetMediaFileIDs returns the tracks' song ids, for callers that need every id but no track data.
|
|
func (r *playlistTrackRepository) GetMediaFileIDs(options ...model.QueryOptions) ([]string, error) {
|
|
query := r.newSelect(options...).Columns("media_file_id").
|
|
Join("media_file f on f.id = media_file_id").
|
|
Where(Eq{"playlist_id": r.playlistId})
|
|
query = r.applyLibraryFilter(query, "f")
|
|
var ids []string
|
|
if err := r.queryAllSlice(query, &ids); err != nil {
|
|
return nil, err
|
|
}
|
|
return ids, nil
|
|
}
|
|
|
|
func (r *playlistTrackRepository) GetAlbumIDs(options ...model.QueryOptions) ([]string, error) {
|
|
query := r.newSelect(options...).Columns("distinct mf.album_id").
|
|
Join("media_file mf on mf.id = media_file_id").
|
|
Where(Eq{"playlist_id": r.playlistId})
|
|
var ids []string
|
|
err := r.queryAllSlice(query, &ids)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return ids, nil
|
|
}
|
|
|
|
func (r *playlistTrackRepository) ReadAll(options ...rest.QueryOptions) (any, error) {
|
|
return r.GetAll(r.parseRestOptions(r.ctx, options...))
|
|
}
|
|
|
|
func (r *playlistTrackRepository) EntityName() string {
|
|
return "playlist_tracks"
|
|
}
|
|
|
|
func (r *playlistTrackRepository) NewInstance() any {
|
|
return &model.PlaylistTrack{}
|
|
}
|
|
|
|
func (r *playlistTrackRepository) Add(mediaFileIds []string) (int, error) {
|
|
if len(mediaFileIds) > 0 {
|
|
log.Debug(r.ctx, "Adding songs to playlist", "playlistId", r.playlistId, "mediaFileIds", mediaFileIds)
|
|
} else {
|
|
return 0, nil
|
|
}
|
|
|
|
// Get next pos (ID) in playlist
|
|
sq := r.newSelect().Columns("max(id) as max").Where(Eq{"playlist_id": r.playlistId})
|
|
var res struct{ Max sql.NullInt32 }
|
|
err := r.queryOne(sq, &res)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return len(mediaFileIds), r.playlistRepo.addTracks(r.playlistId, int(res.Max.Int32+1), mediaFileIds)
|
|
}
|
|
|
|
func (r *playlistTrackRepository) addMediaFileIds(cond Sqlizer) (int, error) {
|
|
sq := Select("id").From("media_file").Where(cond).OrderBy("album_artist, album, release_date, disc_number, track_number")
|
|
var ids []string
|
|
err := r.queryAllSlice(sq, &ids)
|
|
if err != nil {
|
|
log.Error(r.ctx, "Error getting tracks to add to playlist", err)
|
|
return 0, err
|
|
}
|
|
return r.Add(ids)
|
|
}
|
|
|
|
func (r *playlistTrackRepository) AddAlbums(albumIds []string) (int, error) {
|
|
return r.addMediaFileIds(Eq{"album_id": albumIds})
|
|
}
|
|
|
|
func (r *playlistTrackRepository) AddArtists(artistIds []string) (int, error) {
|
|
return r.addMediaFileIds(Eq{"album_artist_id": artistIds})
|
|
}
|
|
|
|
func (r *playlistTrackRepository) AddDiscs(discs []model.DiscID) (int, error) {
|
|
if len(discs) == 0 {
|
|
return 0, nil
|
|
}
|
|
var clauses Or
|
|
for _, d := range discs {
|
|
clauses = append(clauses, And{Eq{"album_id": d.AlbumID}, Eq{"release_date": d.ReleaseDate}, Eq{"disc_number": d.DiscNumber}})
|
|
}
|
|
return r.addMediaFileIds(clauses)
|
|
}
|
|
|
|
func (r *playlistTrackRepository) Delete(ids ...string) error {
|
|
err := r.delete(And{Eq{"playlist_id": r.playlistId}, Eq{"id": ids}})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return r.playlistRepo.renumber(r.playlistId)
|
|
}
|
|
|
|
func (r *playlistTrackRepository) DeleteAll() error {
|
|
err := r.delete(Eq{"playlist_id": r.playlistId})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return r.playlistRepo.renumber(r.playlistId)
|
|
}
|
|
|
|
// Reorder moves a track from pos to newPos, shifting other tracks accordingly.
|
|
func (r *playlistTrackRepository) Reorder(pos int, newPos int) error {
|
|
if pos == newPos {
|
|
return nil
|
|
}
|
|
pid := r.playlistId
|
|
|
|
// Step 1: Move the source track out of the way (temporary sentinel value)
|
|
_, err := r.executeSQL(Expr(
|
|
`UPDATE playlist_tracks SET id = -999999 WHERE playlist_id = ? AND id = ?`, pid, pos))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Step 2: Shift the affected range using negative values to avoid unique constraint violations
|
|
if pos < newPos {
|
|
_, err = r.executeSQL(Expr(
|
|
`UPDATE playlist_tracks SET id = -(id - 1) WHERE playlist_id = ? AND id > ? AND id <= ?`,
|
|
pid, pos, newPos))
|
|
} else {
|
|
_, err = r.executeSQL(Expr(
|
|
`UPDATE playlist_tracks SET id = -(id + 1) WHERE playlist_id = ? AND id >= ? AND id < ?`,
|
|
pid, newPos, pos))
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Step 3: Flip the shifted range back to positive
|
|
_, err = r.executeSQL(Expr(
|
|
`UPDATE playlist_tracks SET id = -id WHERE playlist_id = ? AND id < 0 AND id != -999999`, pid))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Step 4: Place the source track at its new position
|
|
_, err = r.executeSQL(Expr(
|
|
`UPDATE playlist_tracks SET id = ? WHERE playlist_id = ? AND id = -999999`, newPos, pid))
|
|
return err
|
|
}
|
|
|
|
var _ model.PlaylistTrackRepository = (*playlistTrackRepository)(nil)
|