2020-01-20 00:21:44 +01:00
|
|
|
package subsonic
|
2016-03-04 15:09:16 +01:00
|
|
|
|
|
|
|
import (
|
2020-10-27 15:03:10 +01:00
|
|
|
"context"
|
2020-01-07 20:56:26 +01:00
|
|
|
"net/http"
|
2021-09-22 02:40:39 +02:00
|
|
|
"strconv"
|
2020-10-27 15:19:58 +01:00
|
|
|
"time"
|
2016-10-04 04:30:25 +02:00
|
|
|
|
2020-01-24 01:44:08 +01:00
|
|
|
"github.com/navidrome/navidrome/log"
|
2020-10-27 15:03:10 +01:00
|
|
|
"github.com/navidrome/navidrome/model"
|
|
|
|
"github.com/navidrome/navidrome/server/subsonic/filter"
|
2020-01-24 01:44:08 +01:00
|
|
|
"github.com/navidrome/navidrome/server/subsonic/responses"
|
|
|
|
"github.com/navidrome/navidrome/utils"
|
2022-12-19 17:00:20 +01:00
|
|
|
"github.com/navidrome/navidrome/utils/number"
|
2016-03-04 15:09:16 +01:00
|
|
|
)
|
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) getAlbumList(r *http.Request) (model.Albums, int64, error) {
|
2020-10-27 20:23:29 +01:00
|
|
|
typ, err := requiredParamString(r, "type")
|
2020-04-18 01:57:26 +02:00
|
|
|
if err != nil {
|
2021-09-22 02:40:39 +02:00
|
|
|
return nil, 0, err
|
2020-04-18 01:57:26 +02:00
|
|
|
}
|
|
|
|
|
2020-10-27 15:03:10 +01:00
|
|
|
var opts filter.Options
|
2020-04-18 01:57:26 +02:00
|
|
|
switch typ {
|
2020-04-18 02:29:10 +02:00
|
|
|
case "newest":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByNewest()
|
2020-04-18 02:29:10 +02:00
|
|
|
case "recent":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByRecent()
|
2020-04-18 02:29:10 +02:00
|
|
|
case "random":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByRandom()
|
2020-04-18 02:29:10 +02:00
|
|
|
case "alphabeticalByName":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByName()
|
2020-04-18 02:29:10 +02:00
|
|
|
case "alphabeticalByArtist":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByArtist()
|
2020-04-18 02:29:10 +02:00
|
|
|
case "frequent":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByFrequent()
|
2020-04-18 02:29:10 +02:00
|
|
|
case "starred":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByStarred()
|
2020-04-18 02:29:10 +02:00
|
|
|
case "highest":
|
2020-10-27 15:03:10 +01:00
|
|
|
opts = filter.AlbumsByRating()
|
2020-04-18 01:57:26 +02:00
|
|
|
case "byGenre":
|
2021-11-03 02:38:08 +01:00
|
|
|
genre, err := requiredParamString(r, "genre")
|
|
|
|
if err != nil {
|
|
|
|
return nil, 0, err
|
|
|
|
}
|
|
|
|
opts = filter.AlbumsByGenre(genre)
|
2020-04-18 01:57:26 +02:00
|
|
|
case "byYear":
|
2021-11-03 02:38:08 +01:00
|
|
|
fromYear, err := requiredParamInt(r, "fromYear")
|
|
|
|
if err != nil {
|
|
|
|
return nil, 0, err
|
|
|
|
}
|
|
|
|
toYear, err := requiredParamInt(r, "toYear")
|
|
|
|
if err != nil {
|
|
|
|
return nil, 0, err
|
|
|
|
}
|
|
|
|
opts = filter.AlbumsByYear(fromYear, toYear)
|
2020-04-18 01:57:26 +02:00
|
|
|
default:
|
2020-04-18 02:29:10 +02:00
|
|
|
log.Error(r, "albumList type not implemented", "type", typ)
|
2021-11-03 02:38:08 +01:00
|
|
|
return nil, 0, newError(responses.ErrorGeneric, "type '%s' not implemented", typ)
|
2020-04-18 01:57:26 +02:00
|
|
|
}
|
|
|
|
|
2020-10-27 15:03:10 +01:00
|
|
|
opts.Offset = utils.ParamInt(r, "offset", 0)
|
2022-12-19 17:00:20 +01:00
|
|
|
opts.Max = number.Min(utils.ParamInt(r, "size", 10), 500)
|
2022-11-21 18:57:56 +01:00
|
|
|
albums, err := api.ds.Album(r.Context()).GetAllWithoutGenres(opts)
|
2020-04-18 01:57:26 +02:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
log.Error(r, "Error retrieving albums", "error", err)
|
2021-11-03 02:38:08 +01:00
|
|
|
return nil, 0, newError(responses.ErrorGeneric, "internal error")
|
2021-09-22 02:40:39 +02:00
|
|
|
}
|
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
count, err := api.ds.Album(r.Context()).CountAll(opts)
|
2021-09-22 02:40:39 +02:00
|
|
|
if err != nil {
|
|
|
|
log.Error(r, "Error counting albums", "error", err)
|
2021-11-03 02:38:08 +01:00
|
|
|
return nil, 0, newError(responses.ErrorGeneric, "internal error")
|
2020-04-18 01:57:26 +02:00
|
|
|
}
|
|
|
|
|
2021-09-22 02:40:39 +02:00
|
|
|
return albums, count, nil
|
2020-04-18 01:57:26 +02:00
|
|
|
}
|
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) GetAlbumList(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
|
|
|
albums, count, err := api.getAlbumList(r)
|
2016-10-04 04:30:25 +02:00
|
|
|
if err != nil {
|
2021-11-03 02:38:08 +01:00
|
|
|
return nil, err
|
2016-03-04 15:09:16 +01:00
|
|
|
}
|
|
|
|
|
2021-09-22 02:40:39 +02:00
|
|
|
w.Header().Set("x-total-count", strconv.Itoa(int(count)))
|
|
|
|
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2020-10-27 15:03:10 +01:00
|
|
|
response.AlbumList = &responses.AlbumList{Album: childrenFromAlbums(r.Context(), albums)}
|
2020-01-07 20:56:26 +01:00
|
|
|
return response, nil
|
2016-03-04 15:09:16 +01:00
|
|
|
}
|
2016-03-14 16:35:48 +01:00
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) GetAlbumList2(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
|
|
|
albums, pageCount, err := api.getAlbumList(r)
|
2016-03-28 05:04:05 +02:00
|
|
|
if err != nil {
|
2021-11-03 02:38:08 +01:00
|
|
|
return nil, err
|
2016-03-28 05:04:05 +02:00
|
|
|
}
|
|
|
|
|
2021-09-22 02:40:39 +02:00
|
|
|
w.Header().Set("x-total-count", strconv.FormatInt(pageCount, 10))
|
|
|
|
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2020-10-27 15:03:10 +01:00
|
|
|
response.AlbumList2 = &responses.AlbumList{Album: childrenFromAlbums(r.Context(), albums)}
|
2020-01-07 20:56:26 +01:00
|
|
|
return response, nil
|
2016-03-28 05:04:05 +02:00
|
|
|
}
|
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) GetStarred(r *http.Request) (*responses.Subsonic, error) {
|
2020-10-27 15:03:10 +01:00
|
|
|
ctx := r.Context()
|
2021-07-16 23:15:34 +02:00
|
|
|
options := filter.Starred()
|
2022-11-21 18:57:56 +01:00
|
|
|
artists, err := api.ds.Artist(ctx).GetAll(options)
|
2020-10-27 15:03:10 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error(r, "Error retrieving starred artists", "error", err)
|
2020-10-27 20:23:29 +01:00
|
|
|
return nil, err
|
2020-10-27 15:03:10 +01:00
|
|
|
}
|
2022-11-21 18:57:56 +01:00
|
|
|
albums, err := api.ds.Album(ctx).GetAllWithoutGenres(options)
|
2016-03-14 16:35:48 +01:00
|
|
|
if err != nil {
|
2020-10-27 15:03:10 +01:00
|
|
|
log.Error(r, "Error retrieving starred albums", "error", err)
|
2020-10-27 20:23:29 +01:00
|
|
|
return nil, err
|
2020-10-27 15:03:10 +01:00
|
|
|
}
|
2022-11-21 18:57:56 +01:00
|
|
|
mediaFiles, err := api.ds.MediaFile(ctx).GetAll(options)
|
2020-10-27 15:03:10 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error(r, "Error retrieving starred mediaFiles", "error", err)
|
2020-10-27 20:23:29 +01:00
|
|
|
return nil, err
|
2016-03-14 16:35:48 +01:00
|
|
|
}
|
|
|
|
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2016-03-14 16:35:48 +01:00
|
|
|
response.Starred = &responses.Starred{}
|
2022-12-31 23:29:58 +01:00
|
|
|
response.Starred.Artist = toArtists(r, artists)
|
2020-10-27 15:03:10 +01:00
|
|
|
response.Starred.Album = childrenFromAlbums(r.Context(), albums)
|
|
|
|
response.Starred.Song = childrenFromMediaFiles(r.Context(), mediaFiles)
|
2020-01-07 20:56:26 +01:00
|
|
|
return response, nil
|
2016-03-14 16:35:48 +01:00
|
|
|
}
|
2016-03-17 14:34:32 +01:00
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) GetStarred2(r *http.Request) (*responses.Subsonic, error) {
|
|
|
|
resp, err := api.GetStarred(r)
|
2016-03-28 15:46:16 +02:00
|
|
|
if err != nil {
|
2020-10-27 15:03:10 +01:00
|
|
|
return nil, err
|
2016-03-28 15:46:16 +02:00
|
|
|
}
|
|
|
|
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2020-10-27 15:03:10 +01:00
|
|
|
response.Starred2 = resp.Starred
|
2020-01-07 20:56:26 +01:00
|
|
|
return response, nil
|
2016-03-28 15:46:16 +02:00
|
|
|
}
|
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) GetNowPlaying(r *http.Request) (*responses.Subsonic, error) {
|
2020-10-27 15:19:58 +01:00
|
|
|
ctx := r.Context()
|
2022-11-21 18:57:56 +01:00
|
|
|
npInfo, err := api.scrobbler.GetNowPlaying(ctx)
|
2016-03-17 15:37:19 +01:00
|
|
|
if err != nil {
|
2020-01-09 02:45:07 +01:00
|
|
|
log.Error(r, "Error retrieving now playing list", "error", err)
|
2020-10-27 20:23:29 +01:00
|
|
|
return nil, err
|
2016-03-17 15:37:19 +01:00
|
|
|
}
|
|
|
|
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2016-03-17 14:34:32 +01:00
|
|
|
response.NowPlaying = &responses.NowPlaying{}
|
2020-10-27 15:19:58 +01:00
|
|
|
response.NowPlaying.Entry = make([]responses.NowPlayingEntry, len(npInfo))
|
|
|
|
for i, np := range npInfo {
|
2023-02-12 00:52:28 +01:00
|
|
|
response.NowPlaying.Entry[i].Child = childFromMediaFile(ctx, np.MediaFile)
|
2020-10-27 15:19:58 +01:00
|
|
|
response.NowPlaying.Entry[i].UserName = np.Username
|
2023-03-14 14:48:52 +01:00
|
|
|
response.NowPlaying.Entry[i].MinutesAgo = int32(time.Since(np.Start).Minutes())
|
|
|
|
response.NowPlaying.Entry[i].PlayerId = int32(i + 1) // Fake numeric playerId, it does not seem to be used for anything
|
2020-10-27 15:19:58 +01:00
|
|
|
response.NowPlaying.Entry[i].PlayerName = np.PlayerName
|
2016-03-17 15:37:19 +01:00
|
|
|
}
|
2020-01-07 20:56:26 +01:00
|
|
|
return response, nil
|
2016-03-17 14:34:32 +01:00
|
|
|
}
|
2016-03-29 06:01:27 +02:00
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) GetRandomSongs(r *http.Request) (*responses.Subsonic, error) {
|
2022-12-19 17:00:20 +01:00
|
|
|
size := number.Min(utils.ParamInt(r, "size", 10), 500)
|
2020-02-07 00:55:38 +01:00
|
|
|
genre := utils.ParamString(r, "genre")
|
2020-04-18 03:18:04 +02:00
|
|
|
fromYear := utils.ParamInt(r, "fromYear", 0)
|
|
|
|
toYear := utils.ParamInt(r, "toYear", 0)
|
2016-03-29 06:01:27 +02:00
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
songs, err := api.getSongs(r.Context(), 0, size, filter.SongsByRandom(genre, fromYear, toYear))
|
2016-03-29 06:01:27 +02:00
|
|
|
if err != nil {
|
2020-01-09 02:45:07 +01:00
|
|
|
log.Error(r, "Error retrieving random songs", "error", err)
|
2020-10-27 20:23:29 +01:00
|
|
|
return nil, err
|
2016-03-29 06:01:27 +02:00
|
|
|
}
|
|
|
|
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2016-03-29 06:01:27 +02:00
|
|
|
response.RandomSongs = &responses.Songs{}
|
2020-10-27 15:03:10 +01:00
|
|
|
response.RandomSongs.Songs = childrenFromMediaFiles(r.Context(), songs)
|
2020-01-07 20:56:26 +01:00
|
|
|
return response, nil
|
2016-03-29 06:01:27 +02:00
|
|
|
}
|
2020-04-18 02:52:50 +02:00
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) GetSongsByGenre(r *http.Request) (*responses.Subsonic, error) {
|
2022-12-19 17:00:20 +01:00
|
|
|
count := number.Min(utils.ParamInt(r, "count", 10), 500)
|
2023-04-06 04:39:32 +02:00
|
|
|
offset := utils.ParamInt(r, "offset", 0)
|
2020-04-18 02:52:50 +02:00
|
|
|
genre := utils.ParamString(r, "genre")
|
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
songs, err := api.getSongs(r.Context(), offset, count, filter.SongsByGenre(genre))
|
2020-04-18 02:52:50 +02:00
|
|
|
if err != nil {
|
|
|
|
log.Error(r, "Error retrieving random songs", "error", err)
|
2020-10-27 20:23:29 +01:00
|
|
|
return nil, err
|
2020-04-18 02:52:50 +02:00
|
|
|
}
|
|
|
|
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2020-05-22 23:42:36 +02:00
|
|
|
response.SongsByGenre = &responses.Songs{}
|
2020-10-27 15:03:10 +01:00
|
|
|
response.SongsByGenre.Songs = childrenFromMediaFiles(r.Context(), songs)
|
2020-04-18 02:52:50 +02:00
|
|
|
return response, nil
|
|
|
|
}
|
2020-10-27 15:03:10 +01:00
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
func (api *Router) getSongs(ctx context.Context, offset, size int, opts filter.Options) (model.MediaFiles, error) {
|
2020-10-27 15:03:10 +01:00
|
|
|
opts.Offset = offset
|
|
|
|
opts.Max = size
|
2022-11-21 18:57:56 +01:00
|
|
|
return api.ds.MediaFile(ctx).GetAll(opts)
|
2020-10-27 15:03:10 +01:00
|
|
|
}
|