// 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" "git.kmalloc.org/squid/sonda/internal/catalog" "git.kmalloc.org/squid/sonda/internal/mixes" "git.kmalloc.org/squid/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, "; ") }