I can now ask for songs from a year to a year, for example the eighties. - The year is read from the tags of each file (the original date first, then the date) and kept on the track: migration 0028 adds tracks.year (SQLite and PostgreSQL). - Two new rules, min_year and max_year, both included and checked (1000 to 2999, the first not after the second). The index answers them. A song with no year never matches. - Files indexed before have no year until a full rescan reads their tags again; the editor and the API description say so. - The smart playlist editor gets From year and Up to year, and the rules are described in words. - English and Italian.
758 lines
26 KiB
Go
758 lines
26 KiB
Go
// Package smart keeps the smart playlists of each user: playlists that are a set of rules instead of a
|
|
// list of songs, worked out again every time they are opened, so the songs that arrive and what the
|
|
// listener plays change them by themselves.
|
|
//
|
|
// A smart playlist is made of Rules (every rule that is set must hold), an order and a limit. Only that is
|
|
// stored. The songs come from the playable songs of the library, then from the history and the taste of the
|
|
// owner, the way the mixes are made (see package mixes): nothing here contacts anyone, and a smart playlist
|
|
// that belongs to somebody else is as if it did not exist (ErrNotFound).
|
|
//
|
|
// "Random" is not new at every request: like a mix it stays the same for a day, and a variant number asks
|
|
// for another.
|
|
package smart
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"hash/fnv"
|
|
"regexp"
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"codeberg.org/squidd/sonda/internal/catalog"
|
|
"codeberg.org/squidd/sonda/internal/mixes"
|
|
"codeberg.org/squidd/sonda/internal/taste"
|
|
)
|
|
|
|
// Limits. They keep one user from filling the database and one request from doing too much.
|
|
const (
|
|
MaxNameLen = 200
|
|
MaxDescriptionLen = 2000
|
|
MaxListed = 50 // genres, artists, albums or formats in one rule
|
|
MaxDays = 36_500
|
|
MaxPlays = 1_000_000
|
|
MaxBitrateKbps = 100_000
|
|
MaxDurationSec = 86_400
|
|
MinYear = 1000 // the first and the last year a rule can name
|
|
MaxYear = 2999
|
|
DefaultLimit = 50
|
|
MaxLimit = 500
|
|
MaxPlaylists = 200 // smart playlists of one user
|
|
MaxVariant = mixes.MaxVariant
|
|
DefaultPageLimit = 50
|
|
MaxPageLimit = 200
|
|
)
|
|
|
|
// Errors returned by the service and the store.
|
|
var (
|
|
ErrInvalidInput = errors.New("invalid input")
|
|
ErrNotFound = errors.New("smart playlist not found")
|
|
ErrTooMany = errors.New("limit reached")
|
|
)
|
|
|
|
// Sort is the order of the songs of a smart playlist, before the limit cuts the end.
|
|
type Sort string
|
|
|
|
// The orders. A tie always goes to the lower song id.
|
|
const (
|
|
SortRandom Sort = "random"
|
|
SortMostPlayed Sort = "most_played"
|
|
SortLeastPlayed Sort = "least_played"
|
|
SortRecentlyAdded Sort = "recently_added"
|
|
SortTitle Sort = "title"
|
|
)
|
|
|
|
func (s Sort) valid() bool {
|
|
switch s {
|
|
case SortRandom, SortMostPlayed, SortLeastPlayed, SortRecentlyAdded, SortTitle:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Rules say which songs a smart playlist takes. A rule that is not set (empty, false or 0) does not count;
|
|
// every rule that is set must hold. The songs of a list rule match when they are by one of the artists, in
|
|
// one of the albums, have one of the genres or are in one of the formats.
|
|
type Rules struct {
|
|
// Genres are kept as they are compared: lower case, with "+", "-", "_" and "/" taken for spaces
|
|
// ("jazz+funk" and "jazz-funk" are the same genre).
|
|
Genres []string `json:"genres,omitempty"`
|
|
NotGenres []string `json:"not_genres,omitempty"`
|
|
// Artists are the main artists of the song.
|
|
ArtistIDs []int64 `json:"artist_ids,omitempty"`
|
|
NotArtistIDs []int64 `json:"not_artist_ids,omitempty"`
|
|
AlbumIDs []int64 `json:"album_ids,omitempty"`
|
|
NotAlbumIDs []int64 `json:"not_album_ids,omitempty"`
|
|
// Formats are those of the files ("flac", "mpeg"), in lower case. A song counts when a file of it, that is
|
|
// not missing, has one of them (and, with MinBitrateKbps, that bitrate or more).
|
|
Formats []string `json:"formats,omitempty"`
|
|
MinBitrateKbps int `json:"min_bitrate_kbps,omitempty"`
|
|
// AddedWithinDays is about the date of the file, which is the best the index knows.
|
|
AddedWithinDays int `json:"added_within_days,omitempty"`
|
|
// The listening rules are about the owner's history: a listen counts when the play was completed or lasted
|
|
// the minimum listen of the server, and a skip when it came before that.
|
|
NeverPlayed bool `json:"never_played,omitempty"`
|
|
PlayedWithinDays int `json:"played_within_days,omitempty"`
|
|
NotPlayedWithinDays int `json:"not_played_within_days,omitempty"`
|
|
MinPlays int `json:"min_plays,omitempty"`
|
|
// PlaysWithinDays counts only the plays of the last N days where plays are counted: the minimum of plays and
|
|
// the most and least played orders. It does not change the other listening rules.
|
|
PlaysWithinDays int `json:"plays_within_days,omitempty"`
|
|
SkippedWithinDays int `json:"skipped_within_days,omitempty"`
|
|
NotSkippedWithinDays int `json:"not_skipped_within_days,omitempty"`
|
|
// LikedArtistsOnly keeps the songs of artists the owner likes; WithoutAvoidedArtists leaves out the ones
|
|
// the owner avoids (see package taste).
|
|
LikedArtistsOnly bool `json:"liked_artists_only,omitempty"`
|
|
WithoutAvoidedArtists bool `json:"without_avoided_artists,omitempty"`
|
|
MinDurationSec int `json:"min_duration_sec,omitempty"`
|
|
MaxDurationSec int `json:"max_duration_sec,omitempty"`
|
|
// MinYear and MaxYear are about the year the song came out, from the tags of its file: both limits count
|
|
// (1980 to 1989 is the eighties). A song whose file has no year never matches a year rule.
|
|
MinYear int `json:"min_year,omitempty"`
|
|
MaxYear int `json:"max_year,omitempty"`
|
|
}
|
|
|
|
// SmartPlaylist is a smart playlist.
|
|
type SmartPlaylist struct {
|
|
ID int64
|
|
Name string
|
|
Description string
|
|
Rules Rules
|
|
Sort Sort
|
|
Limit int
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
}
|
|
|
|
// Input is what makes a smart playlist, or the preview of one. A zero Sort is random and a zero Limit is
|
|
// DefaultLimit.
|
|
type Input struct {
|
|
Name string
|
|
Description string
|
|
Rules Rules
|
|
Sort Sort
|
|
Limit int
|
|
}
|
|
|
|
// Patch changes the smart playlist in the fields that are not nil. Rules replace the old ones whole.
|
|
type Patch struct {
|
|
Name *string
|
|
Description *string
|
|
Rules *Rules
|
|
Sort *Sort
|
|
Limit *int
|
|
}
|
|
|
|
// History is what one listener did with one song.
|
|
type History = mixes.History
|
|
|
|
// Candidate is a playable song the rules may take, with what they need to know of it.
|
|
type Candidate struct {
|
|
TrackID int64
|
|
ArtistID int64 // the main artist, 0 when there is none
|
|
Title string
|
|
DurationMs int64
|
|
AddedAt time.Time // the date of its newest file that is not missing
|
|
}
|
|
|
|
// Filter is the part of the rules that the index answers: every list that is set narrows the songs.
|
|
// Genres are spelled as the files have them.
|
|
type Filter struct {
|
|
Genres, NotGenres []string
|
|
ArtistIDs, NotArtistIDs []int64
|
|
AlbumIDs, NotAlbumIDs []int64
|
|
Formats []string
|
|
MinBitrateKbps int
|
|
MinYear, MaxYear int // 0 is no limit
|
|
}
|
|
|
|
// Store keeps the smart playlists and reads what they are made of. Every call that is about one playlist is
|
|
// for one user and gives ErrNotFound for a playlist that does not exist or is not theirs.
|
|
type Store interface {
|
|
// Create keeps a playlist (its ID is ignored), or gives ErrTooMany when the user has MaxPlaylists.
|
|
Create(ctx context.Context, userID int64, p SmartPlaylist, now time.Time) (SmartPlaylist, error)
|
|
// List returns a page of the user's smart playlists, the one changed last first, and how many there are.
|
|
List(ctx context.Context, userID int64, limit, offset int) ([]SmartPlaylist, int, error)
|
|
Get(ctx context.Context, userID, id int64) (SmartPlaylist, error)
|
|
// Update replaces name, description, rules, order and limit.
|
|
Update(ctx context.Context, userID, id int64, p SmartPlaylist, now time.Time) (SmartPlaylist, error)
|
|
Delete(ctx context.Context, userID, id int64) error
|
|
|
|
// Genres returns every genre of the playable songs, as spelled in the files.
|
|
Genres(ctx context.Context) ([]mixes.Genre, error)
|
|
// Candidates returns the playable songs of the filter.
|
|
Candidates(ctx context.Context, f Filter) ([]Candidate, error)
|
|
// History returns what the user did with the songs they did anything with; minListen is how long a
|
|
// play must last to count as a listen.
|
|
History(ctx context.Context, userID int64, minListen time.Duration) (map[int64]History, error)
|
|
// Plays returns how many listens the user has of each song since a moment, for the songs they listened to.
|
|
Plays(ctx context.Context, userID int64, minListen time.Duration, since time.Time) (map[int64]int, error)
|
|
// Tracks returns the songs in the order given, leaving out any that cannot be played.
|
|
Tracks(ctx context.Context, ids []int64) ([]catalog.Track, error)
|
|
// AlbumCovers returns, for the songs in the order given, the albums that have a cover, each once, up to limit.
|
|
AlbumCovers(ctx context.Context, trackIDs []int64, limit int) ([]int64, error)
|
|
}
|
|
|
|
// Taster says what the listener likes: *taste.Service.
|
|
type Taster interface {
|
|
Learn(ctx context.Context, userID int64) (taste.Learned, error)
|
|
}
|
|
|
|
// Service validates what it is given, keeps the smart playlists and works their songs out.
|
|
type Service struct {
|
|
store Store
|
|
taster Taster
|
|
minListen time.Duration
|
|
now func() time.Time
|
|
}
|
|
|
|
// NewService builds a Service. minListen is how long a play must last to count as a listen.
|
|
func NewService(store Store, taster Taster, minListen time.Duration) *Service {
|
|
return &Service{store: store, taster: taster, minListen: minListen, now: time.Now}
|
|
}
|
|
|
|
func invalid(format string, a ...any) error {
|
|
return fmt.Errorf("%w: %s", ErrInvalidInput, fmt.Sprintf(format, a...))
|
|
}
|
|
|
|
func cleanName(name string) (string, error) {
|
|
name = strings.TrimSpace(name)
|
|
if name == "" || utf8.RuneCountInString(name) > MaxNameLen {
|
|
return "", invalid("the name must have 1 to %d characters", MaxNameLen)
|
|
}
|
|
return name, nil
|
|
}
|
|
|
|
func cleanDescription(d string) (string, error) {
|
|
d = strings.TrimSpace(d)
|
|
if utf8.RuneCountInString(d) > MaxDescriptionLen {
|
|
return "", invalid("the description can have up to %d characters", MaxDescriptionLen)
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
var formatRe = regexp.MustCompile(`^[a-z0-9]{1,16}$`)
|
|
|
|
func cleanGenres(rule string, in []string) ([]string, error) {
|
|
if len(in) > MaxListed {
|
|
return nil, invalid("%s can have up to %d genres", rule, MaxListed)
|
|
}
|
|
var out []string
|
|
for _, g := range in {
|
|
n := mixes.NormalizeGenre(g)
|
|
if n == "" {
|
|
return nil, invalid("%q is not a genre", g)
|
|
}
|
|
if !slices.Contains(out, n) {
|
|
out = append(out, n)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func cleanFormats(in []string) ([]string, error) {
|
|
if len(in) > MaxListed {
|
|
return nil, invalid("formats can have up to %d items", MaxListed)
|
|
}
|
|
var out []string
|
|
for _, f := range in {
|
|
f = strings.ToLower(strings.TrimSpace(f))
|
|
if !formatRe.MatchString(f) {
|
|
return nil, invalid("%q is not a format", f)
|
|
}
|
|
if !slices.Contains(out, f) {
|
|
out = append(out, f)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func cleanIDs(rule string, in []int64) ([]int64, error) {
|
|
if len(in) > MaxListed {
|
|
return nil, invalid("%s can have up to %d ids", rule, MaxListed)
|
|
}
|
|
var out []int64
|
|
for _, id := range in {
|
|
if id < 1 {
|
|
return nil, invalid("%s must be ids, from 1", rule)
|
|
}
|
|
if !slices.Contains(out, id) {
|
|
out = append(out, id)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func inRange(rule string, n, max int) error {
|
|
if n < 0 || n > max {
|
|
return invalid("%s must be from 0 to %d", rule, max)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// cleanRules checks the rules and returns them in the form they are kept in.
|
|
func cleanRules(r Rules) (Rules, error) {
|
|
var err error
|
|
if r.Genres, err = cleanGenres("genres", r.Genres); err != nil {
|
|
return Rules{}, err
|
|
}
|
|
if r.NotGenres, err = cleanGenres("not_genres", r.NotGenres); err != nil {
|
|
return Rules{}, err
|
|
}
|
|
for _, l := range []struct {
|
|
name string
|
|
ids *[]int64
|
|
}{{"artist_ids", &r.ArtistIDs}, {"not_artist_ids", &r.NotArtistIDs}, {"album_ids", &r.AlbumIDs}, {"not_album_ids", &r.NotAlbumIDs}} {
|
|
if *l.ids, err = cleanIDs(l.name, *l.ids); err != nil {
|
|
return Rules{}, err
|
|
}
|
|
}
|
|
if r.Formats, err = cleanFormats(r.Formats); err != nil {
|
|
return Rules{}, err
|
|
}
|
|
for _, n := range []struct {
|
|
name string
|
|
got, max int
|
|
}{
|
|
{"min_bitrate_kbps", r.MinBitrateKbps, MaxBitrateKbps},
|
|
{"added_within_days", r.AddedWithinDays, MaxDays},
|
|
{"played_within_days", r.PlayedWithinDays, MaxDays},
|
|
{"not_played_within_days", r.NotPlayedWithinDays, MaxDays},
|
|
{"skipped_within_days", r.SkippedWithinDays, MaxDays},
|
|
{"not_skipped_within_days", r.NotSkippedWithinDays, MaxDays},
|
|
{"min_plays", r.MinPlays, MaxPlays},
|
|
{"plays_within_days", r.PlaysWithinDays, MaxDays},
|
|
{"min_duration_sec", r.MinDurationSec, MaxDurationSec},
|
|
{"max_duration_sec", r.MaxDurationSec, MaxDurationSec},
|
|
} {
|
|
if err := inRange(n.name, n.got, n.max); err != nil {
|
|
return Rules{}, err
|
|
}
|
|
}
|
|
if r.MaxDurationSec > 0 && r.MinDurationSec > r.MaxDurationSec {
|
|
return Rules{}, invalid("min_duration_sec is more than max_duration_sec")
|
|
}
|
|
for _, y := range []struct {
|
|
name string
|
|
got int
|
|
}{{"min_year", r.MinYear}, {"max_year", r.MaxYear}} {
|
|
if y.got != 0 && (y.got < MinYear || y.got > MaxYear) {
|
|
return Rules{}, invalid("%s must be 0 or a year from %d to %d", y.name, MinYear, MaxYear)
|
|
}
|
|
}
|
|
if r.MinYear > 0 && r.MaxYear > 0 && r.MinYear > r.MaxYear {
|
|
return Rules{}, invalid("min_year is more than max_year")
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
// cleanShape checks the order and the limit and gives them their defaults.
|
|
func cleanShape(sortBy Sort, limit int) (Sort, int, error) {
|
|
if sortBy == "" {
|
|
sortBy = SortRandom
|
|
}
|
|
if !sortBy.valid() {
|
|
return "", 0, invalid("sort must be random, most_played, least_played, recently_added or title")
|
|
}
|
|
if limit == 0 {
|
|
limit = DefaultLimit
|
|
}
|
|
if limit < 1 || limit > MaxLimit {
|
|
return "", 0, invalid("limit must be from 1 to %d", MaxLimit)
|
|
}
|
|
return sortBy, limit, nil
|
|
}
|
|
|
|
// clean checks everything but the name, which a preview does not have.
|
|
func clean(in Input) (Input, error) {
|
|
var err error
|
|
if in.Description, err = cleanDescription(in.Description); err != nil {
|
|
return Input{}, err
|
|
}
|
|
if in.Rules, err = cleanRules(in.Rules); err != nil {
|
|
return Input{}, err
|
|
}
|
|
if in.Sort, in.Limit, err = cleanShape(in.Sort, in.Limit); err != nil {
|
|
return Input{}, err
|
|
}
|
|
return in, nil
|
|
}
|
|
|
|
// Create keeps a smart playlist for the user.
|
|
func (s *Service) Create(ctx context.Context, userID int64, in Input) (SmartPlaylist, error) {
|
|
name, err := cleanName(in.Name)
|
|
if err != nil {
|
|
return SmartPlaylist{}, err
|
|
}
|
|
in, err = clean(in)
|
|
if err != nil {
|
|
return SmartPlaylist{}, err
|
|
}
|
|
return s.store.Create(ctx, userID, SmartPlaylist{Name: name, Description: in.Description, Rules: in.Rules, Sort: in.Sort, Limit: in.Limit}, s.now())
|
|
}
|
|
|
|
// Listing is a page of smart playlists.
|
|
type Listing struct {
|
|
Items []SmartPlaylist
|
|
Total int
|
|
Limit int
|
|
Offset int
|
|
}
|
|
|
|
// List returns a page of the user's smart playlists, the one changed last first. A limit of 0 is
|
|
// DefaultPageLimit, and one above MaxPageLimit is lowered to it, as for the playlists.
|
|
func (s *Service) List(ctx context.Context, userID int64, limit, offset int) (Listing, error) {
|
|
if limit < 0 || offset < 0 {
|
|
return Listing{}, invalid("limit and offset cannot be negative")
|
|
}
|
|
switch {
|
|
case limit == 0:
|
|
limit = DefaultPageLimit
|
|
case limit > MaxPageLimit:
|
|
limit = MaxPageLimit
|
|
}
|
|
items, total, err := s.store.List(ctx, userID, limit, offset)
|
|
if err != nil {
|
|
return Listing{}, err
|
|
}
|
|
return Listing{Items: items, Total: total, Limit: limit, Offset: offset}, nil
|
|
}
|
|
|
|
// Get returns a smart playlist of the user, without its songs.
|
|
func (s *Service) Get(ctx context.Context, userID, id int64) (SmartPlaylist, error) {
|
|
return s.store.Get(ctx, userID, id)
|
|
}
|
|
|
|
// Update changes the fields of the patch that are not nil.
|
|
func (s *Service) Update(ctx context.Context, userID, id int64, p Patch) (SmartPlaylist, error) {
|
|
cur, err := s.store.Get(ctx, userID, id)
|
|
if err != nil {
|
|
return SmartPlaylist{}, err
|
|
}
|
|
in := Input{Name: cur.Name, Description: cur.Description, Rules: cur.Rules, Sort: cur.Sort, Limit: cur.Limit}
|
|
if p.Name != nil {
|
|
in.Name = *p.Name
|
|
}
|
|
if p.Description != nil {
|
|
in.Description = *p.Description
|
|
}
|
|
if p.Rules != nil {
|
|
in.Rules = *p.Rules
|
|
}
|
|
if p.Sort != nil {
|
|
in.Sort = *p.Sort
|
|
}
|
|
if p.Limit != nil {
|
|
in.Limit = *p.Limit
|
|
}
|
|
if in.Name, err = cleanName(in.Name); err != nil {
|
|
return SmartPlaylist{}, err
|
|
}
|
|
if in, err = clean(in); err != nil {
|
|
return SmartPlaylist{}, err
|
|
}
|
|
return s.store.Update(ctx, userID, id, SmartPlaylist{Name: in.Name, Description: in.Description, Rules: in.Rules, Sort: in.Sort, Limit: in.Limit}, s.now())
|
|
}
|
|
|
|
// GenreCount is a genre as it is compared (see Rules) with the number of playable songs that have it.
|
|
type GenreCount struct {
|
|
Name string
|
|
Tracks int
|
|
}
|
|
|
|
// Genres returns the genres of the library to choose from in a rule, the one with most songs first, and
|
|
// by name among equals. The spellings the files have are one genre; "other" and the like are left out.
|
|
func (s *Service) Genres(ctx context.Context) ([]GenreCount, error) {
|
|
all, err := s.store.Genres(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read genres: %w", err)
|
|
}
|
|
byName := map[string]int{}
|
|
for _, g := range all {
|
|
if n := mixes.NormalizeGenre(g.Name); n != "" {
|
|
byName[n] += g.Tracks
|
|
}
|
|
}
|
|
out := make([]GenreCount, 0, len(byName))
|
|
for n, c := range byName {
|
|
out = append(out, GenreCount{n, c})
|
|
}
|
|
sort.Slice(out, func(i, j int) bool {
|
|
if out[i].Tracks != out[j].Tracks {
|
|
return out[i].Tracks > out[j].Tracks
|
|
}
|
|
return out[i].Name < out[j].Name
|
|
})
|
|
return out, nil
|
|
}
|
|
|
|
// Delete removes a smart playlist of the user.
|
|
func (s *Service) Delete(ctx context.Context, userID, id int64) error {
|
|
return s.store.Delete(ctx, userID, id)
|
|
}
|
|
|
|
// Tracks works the songs of a smart playlist out. variant 0 is the one of the day; with a random order,
|
|
// another number gives other songs.
|
|
func (s *Service) Tracks(ctx context.Context, userID, id int64, variant int) (SmartPlaylist, []catalog.Track, error) {
|
|
if err := checkVariant(variant); err != nil {
|
|
return SmartPlaylist{}, nil, err
|
|
}
|
|
p, err := s.store.Get(ctx, userID, id)
|
|
if err != nil {
|
|
return SmartPlaylist{}, nil, err
|
|
}
|
|
tracks, err := s.run(ctx, userID, p.ID, p.Rules, p.Sort, p.Limit, variant)
|
|
return p, tracks, err
|
|
}
|
|
|
|
// Preview works the songs out for rules that are not kept, to try them before saving.
|
|
func (s *Service) Preview(ctx context.Context, userID int64, in Input, variant int) ([]catalog.Track, error) {
|
|
if err := checkVariant(variant); err != nil {
|
|
return nil, err
|
|
}
|
|
in, err := clean(in)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.run(ctx, userID, 0, in.Rules, in.Sort, in.Limit, variant)
|
|
}
|
|
|
|
func checkVariant(v int) error {
|
|
if v < 0 || v > MaxVariant {
|
|
return invalid("variant must be from 0 to %d", MaxVariant)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// spellings returns the spellings the files have of the genres (all compared as normalized).
|
|
func spellings(all []mixes.Genre, genres []string) []string {
|
|
var out []string
|
|
for _, g := range all {
|
|
if slices.Contains(genres, mixes.NormalizeGenre(g.Name)) {
|
|
out = append(out, g.Name)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// run works the songs out: the rules, the order and the limit, then the details of the songs.
|
|
func (s *Service) run(ctx context.Context, userID, id int64, r Rules, order Sort, limit, variant int) ([]catalog.Track, error) {
|
|
picked, err := s.pick(ctx, userID, id, r, order, limit, variant)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tracks, err := s.store.Tracks(ctx, picked)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read songs: %w", err)
|
|
}
|
|
return tracks, nil
|
|
}
|
|
|
|
// pick works out which songs the rules give, in order, as their ids.
|
|
func (s *Service) pick(ctx context.Context, userID, id int64, r Rules, order Sort, limit, variant int) ([]int64, error) {
|
|
f := Filter{
|
|
ArtistIDs: r.ArtistIDs, NotArtistIDs: r.NotArtistIDs, AlbumIDs: r.AlbumIDs, NotAlbumIDs: r.NotAlbumIDs,
|
|
Formats: r.Formats, MinBitrateKbps: r.MinBitrateKbps, MinYear: r.MinYear, MaxYear: r.MaxYear,
|
|
}
|
|
if len(r.Genres) > 0 || len(r.NotGenres) > 0 {
|
|
all, err := s.store.Genres(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read genres: %w", err)
|
|
}
|
|
f.Genres, f.NotGenres = spellings(all, r.Genres), spellings(all, r.NotGenres)
|
|
if len(r.Genres) > 0 && len(f.Genres) == 0 {
|
|
return []int64{}, nil // no file has any of the genres
|
|
}
|
|
}
|
|
cands, err := s.store.Candidates(ctx, f)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read the songs: %w", err)
|
|
}
|
|
|
|
countsPlays := order == SortMostPlayed || order == SortLeastPlayed || r.MinPlays > 0
|
|
var history map[int64]History
|
|
if (countsPlays && r.PlaysWithinDays == 0) || r.NeverPlayed ||
|
|
r.PlayedWithinDays > 0 || r.NotPlayedWithinDays > 0 || r.SkippedWithinDays > 0 || r.NotSkippedWithinDays > 0 {
|
|
if history, err = s.store.History(ctx, userID, s.minListen); err != nil {
|
|
return nil, fmt.Errorf("read history: %w", err)
|
|
}
|
|
}
|
|
// The plays that are counted: all of them, or only those of the window.
|
|
plays := func(id int64) int { return history[id].Plays }
|
|
if countsPlays && r.PlaysWithinDays > 0 {
|
|
window, err := s.store.Plays(ctx, userID, s.minListen, s.now().Add(-time.Duration(r.PlaysWithinDays)*24*time.Hour))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read plays: %w", err)
|
|
}
|
|
plays = func(id int64) int { return window[id] }
|
|
}
|
|
var learned taste.Learned
|
|
if r.LikedArtistsOnly || r.WithoutAvoidedArtists {
|
|
if learned, err = s.taster.Learn(ctx, userID); err != nil {
|
|
return nil, fmt.Errorf("learn taste: %w", err)
|
|
}
|
|
}
|
|
|
|
now := s.now()
|
|
within := func(t time.Time, days int) bool {
|
|
return !t.IsZero() && now.Sub(t) <= time.Duration(days)*24*time.Hour
|
|
}
|
|
kept := make([]Candidate, 0, len(cands))
|
|
for _, c := range cands {
|
|
h := history[c.TrackID]
|
|
switch {
|
|
case r.AddedWithinDays > 0 && !within(c.AddedAt, r.AddedWithinDays),
|
|
r.MinDurationSec > 0 && c.DurationMs < int64(r.MinDurationSec)*1000,
|
|
r.MaxDurationSec > 0 && c.DurationMs > int64(r.MaxDurationSec)*1000,
|
|
r.NeverPlayed && h.Plays > 0,
|
|
r.PlayedWithinDays > 0 && !within(h.LastPlayed, r.PlayedWithinDays),
|
|
r.NotPlayedWithinDays > 0 && within(h.LastPlayed, r.NotPlayedWithinDays),
|
|
r.MinPlays > 0 && plays(c.TrackID) < r.MinPlays,
|
|
r.SkippedWithinDays > 0 && !within(h.SkippedAt, r.SkippedWithinDays),
|
|
r.NotSkippedWithinDays > 0 && within(h.SkippedAt, r.NotSkippedWithinDays),
|
|
r.LikedArtistsOnly && learned.Prefs[c.ArtistID].Preference <= 0,
|
|
r.WithoutAvoidedArtists && learned.Prefs[c.ArtistID].Preference < 0:
|
|
continue
|
|
}
|
|
kept = append(kept, c)
|
|
}
|
|
|
|
sortCandidates(kept, order, plays, func(c Candidate) uint64 {
|
|
h := fnv.New64a()
|
|
fmt.Fprintf(h, "%d|%d|%d|%d|%d", userID, id, now.Unix()/86400, variant, c.TrackID)
|
|
return h.Sum64()
|
|
})
|
|
if len(kept) > limit {
|
|
kept = kept[:limit]
|
|
}
|
|
picked := make([]int64, len(kept))
|
|
for i, c := range kept {
|
|
picked[i] = c.TrackID
|
|
}
|
|
return picked, nil
|
|
}
|
|
|
|
// MaxCoverAlbums is how many albums make the picture of a smart playlist.
|
|
const MaxCoverAlbums = 4
|
|
|
|
// Covers says which albums stand for a smart playlist: up to MaxCoverAlbums albums that have a cover, in the order of the
|
|
// songs it gives now (the ones of variant), each once. It is the picture of the playlist, and is worked out apart from its
|
|
// songs so that a list of playlists need not wait for all of them.
|
|
func (s *Service) Covers(ctx context.Context, userID, id int64, variant int) ([]int64, error) {
|
|
if err := checkVariant(variant); err != nil {
|
|
return nil, err
|
|
}
|
|
p, err := s.store.Get(ctx, userID, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
picked, err := s.pick(ctx, userID, p.ID, p.Rules, p.Sort, p.Limit, variant)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.albumCovers(ctx, picked)
|
|
}
|
|
|
|
func (s *Service) albumCovers(ctx context.Context, picked []int64) ([]int64, error) {
|
|
if len(picked) == 0 {
|
|
return []int64{}, nil
|
|
}
|
|
albums, err := s.store.AlbumCovers(ctx, picked, MaxCoverAlbums)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read covers: %w", err)
|
|
}
|
|
if albums == nil {
|
|
albums = []int64{}
|
|
}
|
|
return albums, nil
|
|
}
|
|
|
|
// sortCandidates puts the songs in the order; a tie goes to the lower id. A random order sorts by the
|
|
// hash of the song with the seed of the day, which is the same until the day or the variant changes.
|
|
func sortCandidates(c []Candidate, order Sort, plays func(int64) int, hash func(Candidate) uint64) {
|
|
var keys map[int64]uint64
|
|
if order == SortRandom {
|
|
keys = make(map[int64]uint64, len(c))
|
|
for _, x := range c {
|
|
keys[x.TrackID] = hash(x)
|
|
}
|
|
}
|
|
less := func(a, b Candidate) int {
|
|
switch order {
|
|
case SortRandom:
|
|
if ka, kb := keys[a.TrackID], keys[b.TrackID]; ka != kb {
|
|
if ka < kb {
|
|
return -1
|
|
}
|
|
return 1
|
|
}
|
|
case SortMostPlayed, SortLeastPlayed:
|
|
pa, pb := plays(a.TrackID), plays(b.TrackID)
|
|
if order == SortLeastPlayed {
|
|
pa, pb = pb, pa
|
|
}
|
|
if pa != pb {
|
|
if pa > pb {
|
|
return -1
|
|
}
|
|
return 1
|
|
}
|
|
case SortRecentlyAdded:
|
|
if !a.AddedAt.Equal(b.AddedAt) {
|
|
if a.AddedAt.After(b.AddedAt) {
|
|
return -1
|
|
}
|
|
return 1
|
|
}
|
|
case SortTitle:
|
|
if a.Title != b.Title {
|
|
if a.Title < b.Title {
|
|
return -1
|
|
}
|
|
return 1
|
|
}
|
|
}
|
|
switch {
|
|
case a.TrackID < b.TrackID:
|
|
return -1
|
|
case a.TrackID > b.TrackID:
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
sort.SliceStable(c, func(i, j int) bool { return less(c[i], c[j]) < 0 })
|
|
}
|
|
|
|
// Summary says the rules in a few words of English, for the facts about a list that a name is made from. Artists
|
|
// and albums are ids and say nothing to a reader, so they are left out.
|
|
func (r Rules) Summary() string {
|
|
var parts []string
|
|
add := func(cond bool, format string, a ...any) {
|
|
if cond {
|
|
parts = append(parts, fmt.Sprintf(format, a...))
|
|
}
|
|
}
|
|
add(len(r.Genres) > 0, "genres: %s", strings.Join(r.Genres, ", "))
|
|
add(len(r.NotGenres) > 0, "not genres: %s", strings.Join(r.NotGenres, ", "))
|
|
add(len(r.Formats) > 0, "formats: %s", strings.Join(r.Formats, ", "))
|
|
add(r.MinBitrateKbps > 0, "at least %d kbps", r.MinBitrateKbps)
|
|
add(r.AddedWithinDays > 0, "added in the last %d days", r.AddedWithinDays)
|
|
add(r.NeverPlayed, "never played")
|
|
add(r.PlayedWithinDays > 0, "played in the last %d days", r.PlayedWithinDays)
|
|
add(r.NotPlayedWithinDays > 0, "not played for %d days", r.NotPlayedWithinDays)
|
|
add(r.MinPlays > 0, "played at least %d times", r.MinPlays)
|
|
add(r.PlaysWithinDays > 0, "plays counted over the last %d days", r.PlaysWithinDays)
|
|
add(r.SkippedWithinDays > 0, "skipped in the last %d days", r.SkippedWithinDays)
|
|
add(r.NotSkippedWithinDays > 0, "not skipped in the last %d days", r.NotSkippedWithinDays)
|
|
add(r.LikedArtistsOnly, "only liked artists")
|
|
add(r.WithoutAvoidedArtists, "without avoided artists")
|
|
add(r.MinDurationSec > 0, "at least %d minutes long", r.MinDurationSec/60)
|
|
add(r.MaxDurationSec > 0, "at most %d minutes long", r.MaxDurationSec/60)
|
|
add(r.MinYear > 0, "from %d", r.MinYear)
|
|
add(r.MaxYear > 0, "up to %d", r.MaxYear)
|
|
return strings.Join(parts, "; ")
|
|
}
|