OpenSubsonic: playlists and listens #14
9 changed files with 838 additions and 3 deletions
feat: OpenSubsonic playlists and listens
Apps can use the playlists of a person and report what they listened to. - getPlaylists, getPlaylist, createPlaylist (with songs, or in place of an existing one), updatePlaylist (name, comment, songs to add, places to remove), deletePlaylist: the same playlists as the web app - scrobble records a complete listen once however many times an app tries again, and shares it on Mastodon when the person connected it; a now playing message records nothing; getNowPlaying answers with nothing - README section on connecting other apps
commit
a0dc4458ef
34
README.md
34
README.md
|
|
@ -4,7 +4,7 @@ Sonda is a privacy-first, self-hosted music server written in Go. It streams the
|
|||
|
||||
It is a single executable, one database (SQLite by default, PostgreSQL if you prefer) and the folders that hold your music. There is no Redis, no message broker and no cloud account.
|
||||
|
||||
> **Status: early.** The local-playback part works end to end: accounts, libraries, scanning, search, and streaming with HTTP Range. Suggestions of new artists work too (Discover). Radio queues and OpenSubsonic compatibility are not built yet, and the web client in `web/`, which `sondad` serves, is young (see [What is not there yet](#what-is-not-there-yet) and [Web app](#web-app)). The API may still change.
|
||||
> **Status: early.** The local-playback part works end to end: accounts, libraries, scanning, search, and streaming with HTTP Range. Suggestions of new artists work too (Discover). Radio queues are not built yet, other apps can connect over OpenSubsonic (see [Other apps](#other-apps-opensubsonic)), and the web client in `web/`, which `sondad` serves, is young (see [What is not there yet](#what-is-not-there-yet) and [Web app](#web-app)). The API may still change.
|
||||
|
||||
## What works today
|
||||
|
||||
|
|
@ -37,9 +37,11 @@ It is a single executable, one database (SQLite by default, PostgreSQL if you pr
|
|||
- **Similar artists.** With Last.fm turned on, `GET /artists/{id}/similar` lists artists similar to an artist, and says which of them you already have. See [External providers](#external-providers). Without it, Sonda makes no outbound network requests at all.
|
||||
- **Friends (federation).** Two Sonda servers can become friends, and the listeners of one can read what the other chose to share. `PUT /federation` (admin) turns federation on, which is off by default, and gives this server a name and a public address (`https`; plain `http` only on a network of your own); the server then makes its own Ed25519 key, kept in the database and never returned. `POST /federation/invites` makes an invite that works once and expires in 24 hours (only a hash of its code is kept). The other admin uses it with `POST /federation/friends`: that server is asked to accept this one, the key it answers with must be the one named in the invite, and the friend waits as `outgoing` until the first admin approves it with `POST /federation/friends/{id}/approve` (`POST /federation/friends/{id}/check` lets the waiting side find out). Either side can remove a friend with `DELETE /federation/friends/{id}`. Nothing is shared until an admin turns on `shared` for a library (`PATCH /libraries/{id}`). A friend's server then reads, with requests signed by its key (the method, the path and query, a date, a nonce and the hash of the body), the routes under `/peer`: the artists, albums and songs that have a file in a shared library, their covers once they are built, and the audio itself with `Range`. A friend never sees a path, a library id, a listen, a taste or a user, never makes this server build a cover or ask a provider, and has a few streams at a time and a number of KiB a second to share (`max_streams`, `max_kib_per_sec`); the admin sees the last requests it made (`GET /federation/requests`, the route and the size, never what was searched for). Sharing a library lets friends play it and, in practice, copy its files. A listener browses the music of a friend with `GET /friends` (the names of the friends whose friendship both admins agreed to, never an address or a key) and `GET /friends/{friend}/artists`, `albums` and `tracks` with `q`, `limit` and `offset`, and one item at a time: this server asks the friend with a signed request, checks the shape of the answer and passes it on, and nothing is kept; the ids are the friend's own. A friend that cannot be reached or no longer takes this server for a friend is told in words. The web app has a Friends section for it, shown only when there is a friend to browse. A listener plays it with `GET /friends/{friend}/tracks/{id}/stream` and sees its covers with `GET /friends/{friend}/albums/{id}/cover`, which accept the access token in the query like the local ones: this server asks the friend with a signed request, forwards `Range` and the conditional headers, and passes on only audio (or a JPEG for a cover) with `Content-Type`, `Content-Length`, `Content-Range`, `Accept-Ranges`, `Last-Modified` and `ETag`, so the friend sees this server and never the listener, and a friend cannot make this server serve anything else. A friend's song plays in the same player as the others but is never reported as a listen and does not feed taste. The admin area has a Federation section for all of it.
|
||||
|
||||
- **Other apps.** Apps that speak OpenSubsonic (Symfonium, Feishin, Amperfy, Supersonic and others) can browse, search, play, show covers, use your playlists and report what you listened to, with a password of their own for each app (see [Other apps](#other-apps-opensubsonic)).
|
||||
|
||||
## What is not there yet
|
||||
|
||||
Radio queues, OpenSubsonic compatibility, transcoding, and the ListenBrainz integration. The web client is built into the binary (see [Web app](#web-app)), and its admin area covers everything the API can do for an admin: libraries and scanning, users, the external providers and the bulk jobs.
|
||||
Radio queues, transcoding, stars (favourites), and the ListenBrainz integration. The web client is built into the binary (see [Web app](#web-app)), and its admin area covers everything the API can do for an admin: libraries and scanning, users, the external providers and the bulk jobs.
|
||||
|
||||
## Requirements
|
||||
|
||||
|
|
@ -282,6 +284,34 @@ The key is stored in the database, in clear text, and is never returned by the A
|
|||
|
||||
The artist is sent to Last.fm by its MusicBrainz id when your files gave one (if Last.fm does not know the id, by name), otherwise by its name exactly as it is written in your library, and Sonda never lets Last.fm correct it into another artist. Names and ids from Last.fm are never written onto your own artists.
|
||||
|
||||
## Other apps (OpenSubsonic)
|
||||
|
||||
Sonda speaks [OpenSubsonic](https://opensubsonic.github.io/docs/) (Subsonic API 1.16.1 and its open extensions) at `/rest`, so the apps that speak it can play your music: Symfonium, Feishin, Amperfy, Supersonic, Tempus, Airsonic Refix and others.
|
||||
|
||||
**Connect an app.**
|
||||
|
||||
1. Open Settings, **Apps and devices**, give the app a name and press **Make password**. The password is shown once: copy it into the app.
|
||||
2. In the app, give the address of your server, your email as the user name, and that password. An app that asks for an API key takes the same password as the key.
|
||||
|
||||
The API has the same: `POST /me/devices` makes a password (and returns it once), `GET /me/devices` lists them with when each was last used, and `DELETE /me/devices/{id}` takes one back. You can have 20.
|
||||
|
||||
A device password opens your music in that app and nothing else: it cannot sign in to Sonda, change your account or make other passwords, and the password of your account does not work in apps. Make one for each app, and take it back in Settings when you lose the phone: that app stops working at once. The passwords are kept sealed with a key derived from `auth.jwt_secret` (Subsonic's token login needs the server to know the password itself, so it cannot be kept as a hash), so changing that secret makes you make them again. An app sends the password in the address of each call: give Sonda a server address on `https`, and do not put these addresses in a log you share.
|
||||
|
||||
**What an app can do.** Calls are answered in JSON (`f=json`) or XML, and a web app on another address can read the answers (`Access-Control-Allow-Origin: *`; what opens a call is the password in it, never a cookie).
|
||||
|
||||
| Calls | What they do |
|
||||
| --- | --- |
|
||||
| `ping`, `getLicense`, `getOpenSubsonicExtensions`, `tokenInfo` | The server says who it is. The extensions need no login. |
|
||||
| `getMusicFolders`, `getArtists`, `getArtist`, `getAlbum`, `getSong`, `getGenres` | Browse your libraries. |
|
||||
| `getAlbumList2` | Random, newest, frequent, recent, by name, by artist, by year, by genre. |
|
||||
| `getRandomSongs`, `getSongsByGenre`, `search3` | Find songs, albums and artists. |
|
||||
| `stream`, `download`, `getCoverArt` | The original file (with Range), and covers of albums, artists and songs. |
|
||||
| `getPlaylists`, `getPlaylist`, `createPlaylist`, `updatePlaylist`, `deletePlaylist` | Your playlists, the same ones as in the web app. |
|
||||
| `scrobble` | A listen is recorded like one made in the web app (and shared on Mastodon if you connected it). A "now playing" message is not recorded. |
|
||||
| `getStarred2`, `star`, `unstar`, `setRating`, `getNowPlaying` | Answered with nothing: there are no stars yet, and what you play is nobody else's business. |
|
||||
|
||||
Sonda does not transcode: an app always gets the original file, whatever format or bit rate it asks for. The music of friends (federation) is not shown to apps.
|
||||
|
||||
## The API at a glance
|
||||
|
||||
Everything lives under `/api/v1`. Bodies are JSON. Errors always look like `{"error":{"code":"...","message":"..."}}`.
|
||||
|
|
|
|||
|
|
@ -304,6 +304,7 @@ func run() error {
|
|||
deviceSvc := devices.NewService(storage.NewDevicesRepo(db), []byte(cfg.Auth.JWTSecret))
|
||||
catalogSvc := catalog.NewService(storage.NewCatalogRepo(db))
|
||||
streamSvc := streaming.NewService(libraryRepo)
|
||||
listeningSvc := listening.NewService(storage.NewListeningRepo(db), cfg.Listening.MinListen())
|
||||
subsonicRepo := storage.NewSubsonicRepo(db, cfg.Listening.MinListen())
|
||||
|
||||
router := httpapi.NewRouter(httpapi.Deps{
|
||||
|
|
@ -312,12 +313,13 @@ func run() error {
|
|||
Stats: stats.NewService(storage.NewStatsRepo(db), cfg.Listening.MinListen()),
|
||||
Auth: auth.NewService(storage.NewUserRepo(db), storage.NewRefreshRepo(db), tokens, cfg.Auth.RefreshTTL()),
|
||||
Tokens: tokens,
|
||||
Listening: listening.NewService(storage.NewListeningRepo(db), cfg.Listening.MinListen()),
|
||||
Listening: listeningSvc,
|
||||
Mastodon: mastodonSvc,
|
||||
Devices: deviceSvc,
|
||||
OpenSubsonic: &opensubsonic.Deps{
|
||||
Login: deviceSvc, Catalog: catalogSvc, Libraries: libraries,
|
||||
Extras: subsonicRepo, Lists: subsonicRepo, Streams: streamSvc, Covers: pictures, ArtistImages: pictures,
|
||||
Playlists: playlistSvc, Listens: listeningSvc, Announcer: mastodonSvc,
|
||||
ServerVersion: version,
|
||||
},
|
||||
Scan: scanControl{ctx: ctx, m: scans},
|
||||
|
|
|
|||
|
|
@ -148,6 +148,7 @@ func newTestEnvDB(t *testing.T, mutate func(*Deps, *bun.DB)) (http.Handler, *bun
|
|||
Libraries: deps.Libraries.(opensubsonic.Libraries), ServerVersion: "test",
|
||||
Extras: subsonic, Lists: subsonic, Streams: deps.Streams.(opensubsonic.Streams),
|
||||
Covers: deps.Images.(opensubsonic.Covers), ArtistImages: deps.ArtistImages.(opensubsonic.ArtistImages),
|
||||
Playlists: deps.Playlists.(opensubsonic.Playlists), Listens: deps.Listening.(opensubsonic.Listens), Announcer: deps.Mastodon.(opensubsonic.Announcer),
|
||||
}
|
||||
}
|
||||
if deps.About == nil {
|
||||
|
|
|
|||
|
|
@ -361,3 +361,56 @@ func errorFrom(t *testing.T, rec *httptest.ResponseRecorder) int {
|
|||
}
|
||||
return errorCode(out.R)
|
||||
}
|
||||
|
||||
func TestPlaylistsAndListensOfAnAppAreThoseOfThePerson(t *testing.T) {
|
||||
e := newCoversEnv(t)
|
||||
secret := do(t, e.h, "POST", "/api/v1/me/devices", e.token, map[string]any{"name": "Phone"}).Body["secret"].(string)
|
||||
var song int64
|
||||
if err := e.db.QueryRow("SELECT id FROM tracks WHERE title = 'With Art song'").Scan(&song); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rest := func(path string, q url.Values) map[string]any {
|
||||
q.Set("apiKey", secret)
|
||||
q.Set("f", "json")
|
||||
rec := httptest.NewRecorder()
|
||||
e.h.ServeHTTP(rec, httptest.NewRequest("GET", "/rest/"+path+"?"+q.Encode(), nil))
|
||||
var out struct {
|
||||
R map[string]any `json:"subsonic-response"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil || out.R["status"] != "ok" {
|
||||
t.Fatalf("%s: %v %s", path, err, rec.Body.String())
|
||||
}
|
||||
return out.R
|
||||
}
|
||||
|
||||
// A playlist made in the app is in the web app, and the other way round.
|
||||
made := rest("createPlaylist", url.Values{"name": {"From the phone"}, "songId": {"tr-" + itoa(song)}})["playlist"].(map[string]any)
|
||||
if made["songCount"].(float64) != 1 {
|
||||
t.Fatalf("made %v", made)
|
||||
}
|
||||
listed := do(t, e.h, "GET", "/api/v1/playlists", e.token, nil)
|
||||
items, _ := listed.Body["items"].([]any)
|
||||
if len(items) != 1 || items[0].(map[string]any)["name"] != "From the phone" {
|
||||
t.Fatalf("the web app sees %v", listed.Body)
|
||||
}
|
||||
web := do(t, e.h, "POST", "/api/v1/playlists", e.token, map[string]any{"name": "From the web"})
|
||||
if web.Code != 201 {
|
||||
t.Fatalf("%d %v", web.Code, web.Body)
|
||||
}
|
||||
if n := len(rest("getPlaylists", url.Values{})["playlists"].(map[string]any)["playlist"].([]any)); n != 2 {
|
||||
t.Fatalf("the app sees %d playlists", n)
|
||||
}
|
||||
rest("deletePlaylist", url.Values{"id": {made["id"].(string)}})
|
||||
if n := len(do(t, e.h, "GET", "/api/v1/playlists", e.token, nil).Body["items"].([]any)); n != 1 {
|
||||
t.Fatalf("after delete the web app sees %d", n)
|
||||
}
|
||||
|
||||
// A listen reported by the app is in the history of the person, once.
|
||||
for i := 0; i < 2; i++ {
|
||||
rest("scrobble", url.Values{"id": {"tr-" + itoa(song)}, "time": {"1700000000000"}})
|
||||
}
|
||||
hist := do(t, e.h, "GET", "/api/v1/listens", e.token, nil)
|
||||
if got := hist.Body["total"]; got != float64(1) {
|
||||
t.Fatalf("history %v", hist.Body)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,6 +32,11 @@ func idParam(k *call, prefix string) (int64, *Error) {
|
|||
if raw == "" {
|
||||
return 0, missing("id")
|
||||
}
|
||||
return idOf(raw, prefix)
|
||||
}
|
||||
|
||||
// idOf reads an id of the kind the prefix says.
|
||||
func idOf(raw, prefix string) (int64, *Error) {
|
||||
n, err := strconv.ParseInt(strings.TrimPrefix(raw, prefix), 10, 64)
|
||||
if !strings.HasPrefix(raw, prefix) || err != nil || n < 1 {
|
||||
return 0, notFound()
|
||||
|
|
|
|||
|
|
@ -53,6 +53,9 @@ type Deps struct {
|
|||
Streams Streams
|
||||
Covers Covers
|
||||
ArtistImages ArtistImages
|
||||
Playlists Playlists
|
||||
Listens Listens
|
||||
Announcer Announcer // optional
|
||||
ServerVersion string
|
||||
}
|
||||
|
||||
|
|
@ -95,6 +98,13 @@ func Register(r gin.IRoutes, d Deps) {
|
|||
"stream": h.stream,
|
||||
"download": h.download,
|
||||
"getCoverArt": h.coverArt,
|
||||
"getPlaylists": h.playlists,
|
||||
"getPlaylist": h.playlist,
|
||||
"createPlaylist": h.createPlaylist,
|
||||
"updatePlaylist": h.updatePlaylist,
|
||||
"deletePlaylist": h.deletePlaylist,
|
||||
"scrobble": h.scrobble,
|
||||
"getNowPlaying": h.nowPlaying,
|
||||
}
|
||||
r.GET("/rest/:method", h.serve)
|
||||
r.HEAD("/rest/:method", h.serve)
|
||||
|
|
|
|||
|
|
@ -19,6 +19,8 @@ import (
|
|||
"git.kmalloc.org/squid/sonda/internal/devices"
|
||||
"git.kmalloc.org/squid/sonda/internal/images"
|
||||
"git.kmalloc.org/squid/sonda/internal/library"
|
||||
"git.kmalloc.org/squid/sonda/internal/listening"
|
||||
"git.kmalloc.org/squid/sonda/internal/playlists"
|
||||
"git.kmalloc.org/squid/sonda/internal/streaming"
|
||||
)
|
||||
|
||||
|
|
@ -799,3 +801,349 @@ func TestSearchReadsAsManyAsAskedEvenAboveAPageOfTheCatalogue(t *testing.T) {
|
|||
t.Fatalf("%v", r)
|
||||
}
|
||||
}
|
||||
|
||||
// ---- playlists and listens ----
|
||||
|
||||
type fakePlaylists struct {
|
||||
next int64
|
||||
lists map[int64]*fakeList
|
||||
}
|
||||
|
||||
type fakeList struct {
|
||||
name, desc string
|
||||
items []playlists.Item
|
||||
nextItem int64
|
||||
}
|
||||
|
||||
func newFakePlaylists() *fakePlaylists { return &fakePlaylists{next: 1, lists: map[int64]*fakeList{}} }
|
||||
|
||||
var changedAt = time.Unix(1_700_000_500, 0)
|
||||
|
||||
func (f *fakePlaylists) view(id int64, l *fakeList) playlists.Playlist {
|
||||
p := playlists.Playlist{ID: id, Name: l.name, Description: l.desc, TrackCount: len(l.items), CreatedAt: time.Unix(1_700_000_000, 0), UpdatedAt: changedAt}
|
||||
for _, it := range l.items {
|
||||
p.DurationMs += it.Track.DurationMs
|
||||
}
|
||||
if len(l.items) > 0 && l.items[0].Track.Album != nil {
|
||||
p.AlbumIDs = []int64{l.items[0].Track.Album.ID}
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) Create(_ context.Context, _ int64, name, desc string) (playlists.Playlist, error) {
|
||||
if strings.TrimSpace(name) == "" {
|
||||
return playlists.Playlist{}, playlists.ErrInvalidInput
|
||||
}
|
||||
id := f.next
|
||||
f.next++
|
||||
f.lists[id] = &fakeList{name: name, desc: desc}
|
||||
return f.view(id, f.lists[id]), nil
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) List(_ context.Context, _ int64, p playlists.Page) (playlists.Listing, error) {
|
||||
var all []playlists.Playlist
|
||||
for id := int64(1); id < f.next; id++ {
|
||||
if l, ok := f.lists[id]; ok {
|
||||
all = append(all, f.view(id, l))
|
||||
}
|
||||
}
|
||||
if p.Offset >= len(all) {
|
||||
return playlists.Listing{Items: []playlists.Playlist{}, Total: len(all)}, nil
|
||||
}
|
||||
return playlists.Listing{Items: all[p.Offset:], Total: len(all), Limit: p.Limit, Offset: p.Offset}, nil
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) Get(_ context.Context, _, id int64) (playlists.Playlist, error) {
|
||||
l, ok := f.lists[id]
|
||||
if !ok {
|
||||
return playlists.Playlist{}, playlists.ErrNotFound
|
||||
}
|
||||
return f.view(id, l), nil
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) Update(_ context.Context, _, id int64, name, desc *string) (playlists.Playlist, error) {
|
||||
l, ok := f.lists[id]
|
||||
if !ok {
|
||||
return playlists.Playlist{}, playlists.ErrNotFound
|
||||
}
|
||||
if name != nil {
|
||||
l.name = *name
|
||||
}
|
||||
if desc != nil {
|
||||
l.desc = *desc
|
||||
}
|
||||
return f.view(id, l), nil
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) Delete(_ context.Context, _, id int64) error {
|
||||
if _, ok := f.lists[id]; !ok {
|
||||
return playlists.ErrNotFound
|
||||
}
|
||||
delete(f.lists, id)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) Items(_ context.Context, _, id int64, p playlists.Page) (playlists.ItemsListing, error) {
|
||||
l, ok := f.lists[id]
|
||||
if !ok {
|
||||
return playlists.ItemsListing{}, playlists.ErrNotFound
|
||||
}
|
||||
if p.Offset >= len(l.items) {
|
||||
return playlists.ItemsListing{Items: []playlists.Item{}, Total: len(l.items)}, nil
|
||||
}
|
||||
return playlists.ItemsListing{Items: l.items[p.Offset:], Total: len(l.items), Limit: p.Limit, Offset: p.Offset}, nil
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) AddTracks(_ context.Context, _, id int64, ids []int64, _ *int) (playlists.Playlist, error) {
|
||||
l, ok := f.lists[id]
|
||||
if !ok {
|
||||
return playlists.Playlist{}, playlists.ErrNotFound
|
||||
}
|
||||
for _, t := range ids {
|
||||
var track catalog.Track
|
||||
switch t {
|
||||
case 70:
|
||||
track = airbag
|
||||
case 71:
|
||||
track = karma
|
||||
default:
|
||||
return playlists.Playlist{}, playlists.ErrTrackNotFound
|
||||
}
|
||||
l.nextItem++
|
||||
l.items = append(l.items, playlists.Item{ID: id*100 + l.nextItem, Position: len(l.items), Track: track, Available: true})
|
||||
}
|
||||
return f.view(id, l), nil
|
||||
}
|
||||
|
||||
func (f *fakePlaylists) RemoveItem(_ context.Context, _, id, itemID int64) error {
|
||||
l, ok := f.lists[id]
|
||||
if !ok {
|
||||
return playlists.ErrNotFound
|
||||
}
|
||||
for i, it := range l.items {
|
||||
if it.ID == itemID {
|
||||
l.items = append(l.items[:i], l.items[i+1:]...)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return playlists.ErrItemNotFound
|
||||
}
|
||||
|
||||
type fakeListens struct {
|
||||
events []listening.Event
|
||||
announced [][2]int64
|
||||
}
|
||||
|
||||
func (f *fakeListens) Record(_ context.Context, e listening.Event) (listening.Result, error) {
|
||||
if e.TrackID == 99 {
|
||||
return listening.Result{}, listening.ErrTrackNotFound
|
||||
}
|
||||
for _, old := range f.events {
|
||||
if old.IdempotencyKey == e.IdempotencyKey {
|
||||
return listening.Result{Created: false, Counted: true}, nil
|
||||
}
|
||||
}
|
||||
f.events = append(f.events, e)
|
||||
return listening.Result{Created: true, Counted: true}, nil
|
||||
}
|
||||
|
||||
func (f *fakeListens) Announce(userID, trackID int64) {
|
||||
f.announced = append(f.announced, [2]int64{userID, trackID})
|
||||
}
|
||||
|
||||
type withLists struct {
|
||||
h http.Handler
|
||||
lists *fakePlaylists
|
||||
listens *fakeListens
|
||||
}
|
||||
|
||||
func newListServer() withLists {
|
||||
gin.SetMode(gin.TestMode)
|
||||
w := withLists{lists: newFakePlaylists(), listens: &fakeListens{}}
|
||||
r := gin.New()
|
||||
Register(r, Deps{
|
||||
Login: fakeLogin{}, Catalog: &fakeCatalog{}, Libraries: fakeLibraries{}, Extras: fakeExtras{}, ServerVersion: "9.9",
|
||||
Playlists: w.lists, Listens: w.listens, Announcer: w.listens,
|
||||
})
|
||||
w.h = r
|
||||
return w
|
||||
}
|
||||
|
||||
func ids(r map[string]any) []string {
|
||||
var out []string
|
||||
for _, e := range r["entry"].([]any) {
|
||||
out = append(out, e.(map[string]any)["id"].(string))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (w withLists) q(extra ...string) url.Values { return ok(extra...) }
|
||||
|
||||
func TestAPlaylistIsMadeWithItsSongs(t *testing.T) {
|
||||
w := newListServer()
|
||||
q := ok("name", "Evening")
|
||||
q.Add("songId", "tr-70")
|
||||
q.Add("songId", "tr-71")
|
||||
p := good(t, get(t, w.h, "POST", "/rest/createPlaylist", q))["playlist"].(map[string]any)
|
||||
if p["id"] != "pl-1" || p["name"] != "Evening" || p["songCount"].(float64) != 2 || p["owner"] != "tom@example.org" || p["public"] != false ||
|
||||
p["duration"].(float64) != 548 || p["coverArt"] != "al-7" {
|
||||
t.Fatalf("playlist %v", p)
|
||||
}
|
||||
if got := strings.Join(ids(p), ","); got != "tr-70,tr-71" {
|
||||
t.Fatalf("entries %s", got)
|
||||
}
|
||||
if p["changed"] != "2023-11-14T22:21:40.000Z" || p["created"] != "2023-11-14T22:13:20.000Z" {
|
||||
t.Fatalf("dates %v %v", p["created"], p["changed"])
|
||||
}
|
||||
|
||||
// With no name and no playlist there is nothing to make.
|
||||
failed(t, get(t, w.h, "GET", "/rest/createPlaylist", ok()), ErrMissingParam)
|
||||
failed(t, get(t, w.h, "GET", "/rest/createPlaylist", ok("name", " ")), ErrGeneric)
|
||||
bad := ok("name", "x")
|
||||
bad.Add("songId", "tr-99")
|
||||
failed(t, get(t, w.h, "GET", "/rest/createPlaylist", bad), ErrNotFound)
|
||||
bad = ok("name", "x")
|
||||
bad.Add("songId", "al-7")
|
||||
failed(t, get(t, w.h, "GET", "/rest/createPlaylist", bad), ErrNotFound)
|
||||
}
|
||||
|
||||
func TestAPlaylistThatExistsIsReplaced(t *testing.T) {
|
||||
w := newListServer()
|
||||
q := ok("name", "Evening")
|
||||
q.Add("songId", "tr-70")
|
||||
q.Add("songId", "tr-71")
|
||||
get(t, w.h, "GET", "/rest/createPlaylist", q)
|
||||
|
||||
q = ok("playlistId", "pl-1")
|
||||
q.Add("songId", "tr-71")
|
||||
p := good(t, get(t, w.h, "GET", "/rest/createPlaylist", q))["playlist"].(map[string]any)
|
||||
if p["name"] != "Evening" || strings.Join(ids(p), ",") != "tr-71" {
|
||||
t.Fatalf("playlist %v", p)
|
||||
}
|
||||
failed(t, get(t, w.h, "GET", "/rest/createPlaylist", ok("playlistId", "pl-9")), ErrNotFound)
|
||||
}
|
||||
|
||||
func TestPlaylistsAreListedAndOpened(t *testing.T) {
|
||||
w := newListServer()
|
||||
q := ok("name", "One")
|
||||
q.Add("songId", "tr-70")
|
||||
get(t, w.h, "GET", "/rest/createPlaylist", q)
|
||||
get(t, w.h, "GET", "/rest/createPlaylist", ok("name", "Two"))
|
||||
|
||||
list := good(t, get(t, w.h, "GET", "/rest/getPlaylists", ok()))["playlists"].(map[string]any)["playlist"].([]any)
|
||||
if len(list) != 2 || list[0].(map[string]any)["name"] != "One" || list[0].(map[string]any)["songCount"].(float64) != 1 {
|
||||
t.Fatalf("playlists %v", list)
|
||||
}
|
||||
if _, has := list[0].(map[string]any)["entry"]; has {
|
||||
t.Fatalf("the list holds the songs: %v", list[0])
|
||||
}
|
||||
|
||||
p := good(t, get(t, w.h, "GET", "/rest/getPlaylist", ok("id", "pl-1")))["playlist"].(map[string]any)
|
||||
if strings.Join(ids(p), ",") != "tr-70" || p["entry"].([]any)[0].(map[string]any)["title"] != "Airbag" {
|
||||
t.Fatalf("playlist %v", p)
|
||||
}
|
||||
empty := good(t, get(t, w.h, "GET", "/rest/getPlaylist", ok("id", "pl-2")))["playlist"].(map[string]any)
|
||||
if _, has := empty["entry"]; has || empty["songCount"].(float64) != 0 {
|
||||
t.Fatalf("empty playlist %v", empty)
|
||||
}
|
||||
for _, id := range []string{"pl-9", "tr-70", "1", "pl-x"} {
|
||||
failed(t, get(t, w.h, "GET", "/rest/getPlaylist", ok("id", id)), ErrNotFound)
|
||||
}
|
||||
failed(t, get(t, w.h, "GET", "/rest/getPlaylist", ok()), ErrMissingParam)
|
||||
}
|
||||
|
||||
func TestAPlaylistIsChangedAndDeleted(t *testing.T) {
|
||||
w := newListServer()
|
||||
q := ok("name", "One")
|
||||
q.Add("songId", "tr-70")
|
||||
q.Add("songId", "tr-71")
|
||||
get(t, w.h, "GET", "/rest/createPlaylist", q)
|
||||
|
||||
// Rename, comment, add one song, take out the first (by its place in the list).
|
||||
u := ok("playlistId", "pl-1", "name", "Renamed", "comment", "for the car")
|
||||
u.Add("songIdToAdd", "tr-70")
|
||||
u.Add("songIndexToRemove", "0")
|
||||
good(t, get(t, w.h, "GET", "/rest/updatePlaylist", u))
|
||||
p := good(t, get(t, w.h, "GET", "/rest/getPlaylist", ok("id", "pl-1")))["playlist"].(map[string]any)
|
||||
if p["name"] != "Renamed" || p["comment"] != "for the car" || strings.Join(ids(p), ",") != "tr-71,tr-70" {
|
||||
t.Fatalf("playlist %v", p)
|
||||
}
|
||||
|
||||
r := ok("playlistId", "pl-1")
|
||||
r.Add("songIndexToRemove", "5")
|
||||
failed(t, get(t, w.h, "GET", "/rest/updatePlaylist", r), ErrGeneric)
|
||||
failed(t, get(t, w.h, "GET", "/rest/updatePlaylist", ok("playlistId", "pl-9", "name", "x")), ErrNotFound)
|
||||
failed(t, get(t, w.h, "GET", "/rest/updatePlaylist", ok()), ErrMissingParam)
|
||||
|
||||
good(t, get(t, w.h, "GET", "/rest/deletePlaylist", ok("id", "pl-1")))
|
||||
failed(t, get(t, w.h, "GET", "/rest/getPlaylist", ok("id", "pl-1")), ErrNotFound)
|
||||
failed(t, get(t, w.h, "GET", "/rest/deletePlaylist", ok("id", "pl-1")), ErrNotFound)
|
||||
failed(t, get(t, w.h, "GET", "/rest/deletePlaylist", ok()), ErrMissingParam)
|
||||
}
|
||||
|
||||
func TestAListenIsRecordedOnceWhateverTheNumberOfTries(t *testing.T) {
|
||||
w := newListServer()
|
||||
q := ok("submission", "true", "time", "1700000000000")
|
||||
q.Add("id", "tr-70")
|
||||
good(t, get(t, w.h, "GET", "/rest/scrobble", q))
|
||||
good(t, get(t, w.h, "GET", "/rest/scrobble", q)) // an app tries again
|
||||
if len(w.listens.events) != 1 {
|
||||
t.Fatalf("events %+v", w.listens.events)
|
||||
}
|
||||
e := w.listens.events[0]
|
||||
if e.UserID != 1 || e.TrackID != 70 || e.Type != listening.Complete || e.OccurredAt.UnixMilli() != 1_700_000_000_000 || e.DurationPlayedMs != 284_000 || e.IdempotencyKey == "" {
|
||||
t.Fatalf("event %+v", e)
|
||||
}
|
||||
if len(w.listens.announced) != 1 || w.listens.announced[0] != [2]int64{1, 70} {
|
||||
t.Fatalf("announced %v", w.listens.announced)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSeveralListensWithTheirTimes(t *testing.T) {
|
||||
w := newListServer()
|
||||
q := ok()
|
||||
q.Add("id", "tr-70")
|
||||
q.Add("id", "tr-71")
|
||||
q.Add("time", "1700000000000")
|
||||
q.Add("time", "1700000300000")
|
||||
good(t, get(t, w.h, "GET", "/rest/scrobble", q))
|
||||
if len(w.listens.events) != 2 || w.listens.events[1].TrackID != 71 || w.listens.events[1].OccurredAt.UnixMilli() != 1_700_000_300_000 {
|
||||
t.Fatalf("events %+v", w.listens.events)
|
||||
}
|
||||
if w.listens.events[0].IdempotencyKey == w.listens.events[1].IdempotencyKey {
|
||||
t.Fatal("two listens share a key")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAListenWithNoTimeIsNow(t *testing.T) {
|
||||
w := newListServer()
|
||||
before := time.Now()
|
||||
good(t, get(t, w.h, "GET", "/rest/scrobble", ok("id", "tr-70")))
|
||||
if at := w.listens.events[0].OccurredAt; at.Before(before.Add(-time.Second)) || at.After(time.Now().Add(time.Second)) {
|
||||
t.Fatalf("occurred at %v", at)
|
||||
}
|
||||
}
|
||||
|
||||
func TestANowPlayingMessageIsNotAListen(t *testing.T) {
|
||||
w := newListServer()
|
||||
good(t, get(t, w.h, "GET", "/rest/scrobble", ok("id", "tr-70", "submission", "false")))
|
||||
if len(w.listens.events) != 0 || len(w.listens.announced) != 0 {
|
||||
t.Fatalf("events %+v", w.listens.events)
|
||||
}
|
||||
np := good(t, get(t, w.h, "GET", "/rest/getNowPlaying", ok()))["nowPlaying"].(map[string]any)
|
||||
if len(np) != 0 {
|
||||
t.Fatalf("now playing %v", np)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAListenOfWhatIsNotThereOrIsBadlyAskedFor(t *testing.T) {
|
||||
w := newListServer()
|
||||
failed(t, get(t, w.h, "GET", "/rest/scrobble", ok("id", "tr-99")), ErrNotFound)
|
||||
failed(t, get(t, w.h, "GET", "/rest/scrobble", ok("id", "al-7")), ErrNotFound)
|
||||
failed(t, get(t, w.h, "GET", "/rest/scrobble", ok()), ErrMissingParam)
|
||||
failed(t, get(t, w.h, "GET", "/rest/scrobble", ok("id", "tr-70", "time", "soon")), ErrGeneric)
|
||||
failed(t, get(t, w.h, "GET", "/rest/scrobble", ok("id", "tr-70", "submission", "maybe")), ErrGeneric)
|
||||
if len(w.listens.events) != 0 {
|
||||
t.Fatalf("events %+v", w.listens.events)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
358
internal/opensubsonic/playlists.go
Normal file
358
internal/opensubsonic/playlists.go
Normal file
|
|
@ -0,0 +1,358 @@
|
|||
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.ctx, 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
|
||||
}
|
||||
|
|
@ -34,6 +34,34 @@ type Response struct {
|
|||
SongsByGenre *SongList `xml:"songsByGenre" json:"songsByGenre,omitempty"`
|
||||
SearchResult3 *SearchResult `xml:"searchResult3" json:"searchResult3,omitempty"`
|
||||
Starred2 *SearchResult `xml:"starred2" json:"starred2,omitempty"`
|
||||
Playlists *PlaylistList `xml:"playlists" json:"playlists,omitempty"`
|
||||
Playlist *Playlist `xml:"playlist" json:"playlist,omitempty"`
|
||||
NowPlaying *NowPlaying `xml:"nowPlaying" json:"nowPlaying,omitempty"`
|
||||
}
|
||||
|
||||
// PlaylistList are the playlists of a person.
|
||||
type PlaylistList struct {
|
||||
Playlist []Playlist `xml:"playlist" json:"playlist,omitempty"`
|
||||
}
|
||||
|
||||
// Playlist is a playlist; Entry holds its songs when it is opened.
|
||||
type Playlist struct {
|
||||
ID string `xml:"id,attr" json:"id"`
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
Comment string `xml:"comment,attr,omitempty" json:"comment,omitempty"`
|
||||
Owner string `xml:"owner,attr,omitempty" json:"owner,omitempty"`
|
||||
Public bool `xml:"public,attr" json:"public"`
|
||||
SongCount int `xml:"songCount,attr" json:"songCount"`
|
||||
Duration int `xml:"duration,attr" json:"duration"`
|
||||
Created string `xml:"created,attr" json:"created"`
|
||||
Changed string `xml:"changed,attr" json:"changed"`
|
||||
CoverArt string `xml:"coverArt,attr,omitempty" json:"coverArt,omitempty"`
|
||||
Entry []Child `xml:"entry" json:"entry,omitempty"`
|
||||
}
|
||||
|
||||
// NowPlaying is what is being played now. Sonda tells nobody what a person plays, so it is always empty.
|
||||
type NowPlaying struct {
|
||||
Entry []Child `xml:"entry" json:"entry,omitempty"`
|
||||
}
|
||||
|
||||
// AlbumList2 is a list of albums.
|
||||
|
|
|
|||
Loading…
Reference in a new issue