A person can mark songs, albums and artists as favourites. They are theirs
alone: never shown to a friend, never sent anywhere. Only what can be played is
listed.
- migration 0035 favorites, internal/favorites, storage.FavoritesRepo
- PUT/DELETE /me/favorites/{kind}/{id}, GET /me/favorites/{kind} and
GET /me/favorites/ids, in the OpenAPI spec
- catalog.Filter IDs now also reads artists by id
- OpenSubsonic: star, unstar, getStarred2, the starred date on songs, albums and
artists, and getAlbumList2 of type starred
358 lines
11 KiB
Go
358 lines
11 KiB
Go
package opensubsonic
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.kmalloc.org/squid/sonda/internal/catalog"
|
|
"git.kmalloc.org/squid/sonda/internal/listening"
|
|
"git.kmalloc.org/squid/sonda/internal/playlists"
|
|
)
|
|
|
|
const playlistPrefix = "pl-"
|
|
|
|
func playlistID(id int64) string { return playlistPrefix + strconv.FormatInt(id, 10) }
|
|
|
|
// Playlists keeps the playlists of a person: *playlists.Service.
|
|
type Playlists interface {
|
|
Create(ctx context.Context, userID int64, name, description string) (playlists.Playlist, error)
|
|
List(ctx context.Context, userID int64, p playlists.Page) (playlists.Listing, error)
|
|
Get(ctx context.Context, userID, id int64) (playlists.Playlist, error)
|
|
Update(ctx context.Context, userID, id int64, name, description *string) (playlists.Playlist, error)
|
|
Delete(ctx context.Context, userID, id int64) error
|
|
Items(ctx context.Context, userID, id int64, p playlists.Page) (playlists.ItemsListing, error)
|
|
AddTracks(ctx context.Context, userID, id int64, trackIDs []int64, position *int) (playlists.Playlist, error)
|
|
RemoveItem(ctx context.Context, userID, id, itemID int64) error
|
|
}
|
|
|
|
// Listens records what a person listened to: *listening.Service.
|
|
type Listens interface {
|
|
Record(ctx context.Context, e listening.Event) (listening.Result, error)
|
|
}
|
|
|
|
// Announcer is told of every listen that counts, to share it where the person asked for it (Mastodon).
|
|
type Announcer interface {
|
|
Announce(userID, trackID int64)
|
|
}
|
|
|
|
func playlistFailure(err error) *Error {
|
|
switch {
|
|
case errors.Is(err, playlists.ErrNotFound), errors.Is(err, playlists.ErrTrackNotFound), errors.Is(err, playlists.ErrItemNotFound):
|
|
return notFound()
|
|
case errors.Is(err, playlists.ErrInvalidInput), errors.Is(err, playlists.ErrPosition), errors.Is(err, playlists.ErrTooMany):
|
|
return &Error{Code: ErrGeneric, Message: err.Error()}
|
|
}
|
|
return &Error{Code: ErrGeneric, Message: "the playlist could not be changed"}
|
|
}
|
|
|
|
func playlistOf(p playlists.Playlist, owner string) Playlist {
|
|
out := Playlist{
|
|
ID: playlistID(p.ID), Name: p.Name, Comment: p.Description, Owner: owner, SongCount: p.TrackCount,
|
|
Duration: seconds(p.DurationMs), Created: stamp(p.CreatedAt), Changed: stamp(p.UpdatedAt),
|
|
}
|
|
if len(p.AlbumIDs) > 0 {
|
|
out.CoverArt = albumID(p.AlbumIDs[0])
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (h *handler) playlists(k *call) (*Response, *Error) {
|
|
var all []playlists.Playlist
|
|
for {
|
|
p, err := h.Playlists.List(k.ctx, k.principal.UserID, playlists.Page{Limit: playlists.MaxLimit, Offset: len(all)})
|
|
if err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
all = append(all, p.Items...)
|
|
if len(p.Items) == 0 || len(all) >= p.Total {
|
|
break
|
|
}
|
|
}
|
|
out := make([]Playlist, len(all))
|
|
for i, p := range all {
|
|
out[i] = playlistOf(p, k.principal.Email)
|
|
}
|
|
return &Response{Playlists: &PlaylistList{Playlist: out}}, nil
|
|
}
|
|
|
|
// entries are the songs of a playlist that can be played, in order, with the id of the item that holds each.
|
|
func (h *handler) entries(k *call, id int64) ([]playlists.Item, *Error) {
|
|
var all []playlists.Item
|
|
for {
|
|
p, err := h.Playlists.Items(k.ctx, k.principal.UserID, id, playlists.Page{Limit: playlists.MaxLimit, Offset: len(all)})
|
|
if err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
all = append(all, p.Items...)
|
|
if len(p.Items) == 0 || len(all) >= p.Total {
|
|
break
|
|
}
|
|
}
|
|
playable := all[:0]
|
|
for _, it := range all {
|
|
if it.Available {
|
|
playable = append(playable, it)
|
|
}
|
|
}
|
|
return playable, nil
|
|
}
|
|
|
|
// opened is the playlist with its songs.
|
|
func (h *handler) opened(k *call, id int64) (*Response, *Error) {
|
|
p, err := h.Playlists.Get(k.ctx, k.principal.UserID, id)
|
|
if err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
items, bad := h.entries(k, id)
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
tracks := make([]catalog.Track, len(items))
|
|
for i, it := range items {
|
|
tracks[i] = it.Track
|
|
}
|
|
songs, err := h.songs(k, tracks)
|
|
if err != nil {
|
|
return nil, failure(err)
|
|
}
|
|
out := playlistOf(p, k.principal.Email)
|
|
out.Entry = songs
|
|
return &Response{Playlist: &out}, nil
|
|
}
|
|
|
|
func (h *handler) playlist(k *call) (*Response, *Error) {
|
|
id, bad := idParam(k, playlistPrefix)
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
return h.opened(k, id)
|
|
}
|
|
|
|
// songIDs reads a parameter that may be given many times, each a song.
|
|
func songIDs(k *call, name string) ([]int64, *Error) {
|
|
var out []int64
|
|
for _, raw := range k.c.Request.Form[name] {
|
|
n, err := strconv.ParseInt(strings.TrimPrefix(raw, trackPrefix), 10, 64)
|
|
if !strings.HasPrefix(raw, trackPrefix) || err != nil || n < 1 {
|
|
return nil, notFound()
|
|
}
|
|
out = append(out, n)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// add puts songs at the end of a playlist, as many as the service takes at once.
|
|
func (h *handler) add(k *call, id int64, songs []int64) *Error {
|
|
for len(songs) > 0 {
|
|
chunk := songs[:min(len(songs), playlists.MaxAddAtOnce)]
|
|
songs = songs[len(chunk):]
|
|
if _, err := h.Playlists.AddTracks(k.ctx, k.principal.UserID, id, chunk, nil); err != nil {
|
|
return playlistFailure(err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// createPlaylist makes a playlist with songs, or, given the id of one, puts these songs in its place.
|
|
func (h *handler) createPlaylist(k *call) (*Response, *Error) {
|
|
name, rawID := k.param("name"), k.param("playlistId")
|
|
if name == "" && rawID == "" {
|
|
return nil, missing("name or playlistId")
|
|
}
|
|
songs, bad := songIDs(k, "songId")
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
var id int64
|
|
if rawID != "" {
|
|
n, bad := idOf(rawID, playlistPrefix)
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
id = n
|
|
if _, err := h.Playlists.Get(k.ctx, k.principal.UserID, id); err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
items, bad := h.allItems(k, id)
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
for _, it := range items {
|
|
if err := h.Playlists.RemoveItem(k.ctx, k.principal.UserID, id, it.ID); err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
}
|
|
if name != "" {
|
|
if _, err := h.Playlists.Update(k.ctx, k.principal.UserID, id, &name, nil); err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
}
|
|
} else {
|
|
p, err := h.Playlists.Create(k.ctx, k.principal.UserID, name, "")
|
|
if err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
id = p.ID
|
|
}
|
|
if bad := h.add(k, id, songs); bad != nil {
|
|
return nil, bad
|
|
}
|
|
return h.opened(k, id)
|
|
}
|
|
|
|
// allItems are every item of a playlist, the ones that cannot be played too.
|
|
func (h *handler) allItems(k *call, id int64) ([]playlists.Item, *Error) {
|
|
var all []playlists.Item
|
|
for {
|
|
p, err := h.Playlists.Items(k.ctx, k.principal.UserID, id, playlists.Page{Limit: playlists.MaxLimit, Offset: len(all)})
|
|
if err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
all = append(all, p.Items...)
|
|
if len(p.Items) == 0 || len(all) >= p.Total {
|
|
return all, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// updatePlaylist renames a playlist, changes its comment, takes songs out by their place in the list the app was
|
|
// shown, and adds songs at the end.
|
|
func (h *handler) updatePlaylist(k *call) (*Response, *Error) {
|
|
raw := k.param("playlistId")
|
|
if raw == "" {
|
|
return nil, missing("playlistId")
|
|
}
|
|
id, bad := idOf(raw, playlistPrefix)
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
if _, err := h.Playlists.Get(k.ctx, k.principal.UserID, id); err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
add, bad := songIDs(k, "songIdToAdd")
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
var remove []int
|
|
for _, v := range k.c.Request.Form["songIndexToRemove"] {
|
|
n, err := strconv.Atoi(v)
|
|
if err != nil || n < 0 {
|
|
return nil, &Error{Code: ErrGeneric, Message: "invalid songIndexToRemove"}
|
|
}
|
|
remove = append(remove, n)
|
|
}
|
|
|
|
var name, comment *string
|
|
if _, given := k.c.Request.Form["name"]; given {
|
|
v := k.param("name")
|
|
name = &v
|
|
}
|
|
if _, given := k.c.Request.Form["comment"]; given {
|
|
v := k.param("comment")
|
|
comment = &v
|
|
}
|
|
if name != nil || comment != nil {
|
|
if _, err := h.Playlists.Update(k.ctx, k.principal.UserID, id, name, comment); err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
}
|
|
if len(remove) > 0 {
|
|
items, bad := h.entries(k, id) // the places are those of the list the app was shown
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
gone := map[int64]bool{}
|
|
for _, n := range remove {
|
|
if n >= len(items) {
|
|
return nil, &Error{Code: ErrGeneric, Message: "songIndexToRemove is past the end of the playlist"}
|
|
}
|
|
gone[items[n].ID] = true
|
|
}
|
|
for itemID := range gone {
|
|
if err := h.Playlists.RemoveItem(k.ctx, k.principal.UserID, id, itemID); err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
}
|
|
}
|
|
if bad := h.add(k, id, add); bad != nil {
|
|
return nil, bad
|
|
}
|
|
return &Response{}, nil
|
|
}
|
|
|
|
func (h *handler) deletePlaylist(k *call) (*Response, *Error) {
|
|
id, bad := idParam(k, playlistPrefix)
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
if err := h.Playlists.Delete(k.ctx, k.principal.UserID, id); err != nil {
|
|
return nil, playlistFailure(err)
|
|
}
|
|
return &Response{}, nil
|
|
}
|
|
|
|
// nowPlaying is always empty: what a person plays is nobody else's business.
|
|
func (h *handler) nowPlaying(*call) (*Response, *Error) {
|
|
return &Response{NowPlaying: &NowPlaying{}}, nil
|
|
}
|
|
|
|
// scrobble records the songs an app says were listened to. With submission=false the app only says it started
|
|
// one: nothing is recorded, because only a listen counts. A retry of the same listen is recorded once.
|
|
func (h *handler) scrobble(k *call) (*Response, *Error) {
|
|
rawIDs := k.c.Request.Form["id"]
|
|
if len(rawIDs) == 0 {
|
|
return nil, missing("id")
|
|
}
|
|
songs, bad := songIDs(k, "id")
|
|
if bad != nil {
|
|
return nil, bad
|
|
}
|
|
submission := true
|
|
switch k.param("submission") {
|
|
case "", "true":
|
|
case "false":
|
|
submission = false
|
|
default:
|
|
return nil, &Error{Code: ErrGeneric, Message: "submission must be true or false"}
|
|
}
|
|
var times []time.Time
|
|
for _, v := range k.c.Request.Form["time"] {
|
|
ms, err := strconv.ParseInt(v, 10, 64)
|
|
if err != nil || ms < 0 {
|
|
return nil, &Error{Code: ErrGeneric, Message: "invalid time"}
|
|
}
|
|
times = append(times, time.UnixMilli(ms))
|
|
}
|
|
if !submission {
|
|
return &Response{}, nil
|
|
}
|
|
for i, id := range songs {
|
|
at := time.Now()
|
|
if i < len(times) {
|
|
at = times[i]
|
|
}
|
|
t, err := h.Catalog.Track(k.ctx, id)
|
|
if err != nil {
|
|
return nil, failure(err)
|
|
}
|
|
res, err := h.Listens.Record(k.ctx, listening.Event{
|
|
UserID: k.principal.UserID, TrackID: id, Type: listening.Complete, OccurredAt: at, DurationPlayedMs: t.DurationMs,
|
|
IdempotencyKey: "subsonic-" + strconv.FormatInt(k.principal.DeviceID, 10) + "-" + strconv.FormatInt(id, 10) + "-" + strconv.FormatInt(at.UnixMilli(), 10),
|
|
})
|
|
switch {
|
|
case errors.Is(err, listening.ErrTrackNotFound):
|
|
return nil, notFound()
|
|
case errors.Is(err, listening.ErrInvalidEvent):
|
|
return nil, &Error{Code: ErrGeneric, Message: err.Error()}
|
|
case err != nil:
|
|
return nil, &Error{Code: ErrGeneric, Message: "the listen could not be recorded"}
|
|
}
|
|
if res.Created && res.Counted && h.Announcer != nil {
|
|
h.Announcer.Announce(k.principal.UserID, id)
|
|
}
|
|
}
|
|
return &Response{}, nil
|
|
}
|