release / web (push) Failing after 1m29s
release / go (push) Successful in 1m55s
release / govulncheck (push) Successful in 19s
release / integration (push) Successful in 4m22s
release / android (push) Successful in 4m57s
release / Attach APK to the Release (tag releases only) (push) Canceled after 0s
release / Build + push container image (push) Canceled after 0s
release / Verify release artifacts (tag releases only) (push) Canceled after 0s
release / Build signed APK (push) Canceled after 4m23s
Request notifications (approved, declined, completed, pending) are removed
along with the request flow that produced them. A new_music kind takes the
"new music arrived" slot: when a scan or a watcher batch finishes, the
scanner claims every album not yet announced (albums.announced_at) and tells
every user about the ones that are new: an album with a track on disk and
no track older than itself. The first import into an empty library, and an
album formed only by retagging tracks already held, announce nothing. One
notice per scan, carrying up to 50 albums and the total; it is never
coalesced, so a notice already emailed can't quietly absorb later arrivals.
It feeds the daily summary email, grouped by artist. Defaults: inbox and
email on, phone off.
Migration 0103 deletes request-kind notification rows and prefs, swaps the
kind CHECKs to new_music, and adds albums.announced_at with every album
held marked announced, so the first scan after it announces nothing old.
Web and Android: labels, the Android "Requests" settings section becomes
"New music", the shade channel your_requests becomes new_music (the old one
is deleted at startup), and "/" opens Home in the app. TrackLabel moves to
the notifications package. docs/smart-music-{server,client}-spec.md are
deleted per the operator; an Android comment loses the word "exchanges".
Grimoire #7666, #7671.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
131 lines
4.8 KiB
Go
131 lines
4.8 KiB
Go
// Package notifications is the one writer of the per-user notifications
|
|
// inbox. Producers across the server call Notifier.Notify; nothing else
|
|
// inserts into user_notifications.
|
|
//
|
|
// The event bus is fire-and-forget: a client that is not connected when new
|
|
// music arrives, or when tracks go missing, never hears of it. A row here
|
|
// is the durable record. The bus only nudges open clients to come and read
|
|
// it.
|
|
package notifications
|
|
|
|
// Kind names one sort of notification. The set is CHECK-gated in the schema:
|
|
// a new kind adds its value (DROP + ADD of the CHECK) in a migration of the
|
|
// same change, and TestEveryKindPassesTheSchemaChecks fails until it does.
|
|
type Kind string
|
|
|
|
const (
|
|
// KindNewMusic: albums new to the library, one notice per scan that
|
|
// brought them in, for every user.
|
|
KindNewMusic Kind = "new_music"
|
|
KindQuarantineFlagged Kind = "quarantine_flagged"
|
|
KindScanFailed Kind = "scan_failed"
|
|
KindTracksMissing Kind = "tracks_missing"
|
|
KindDuplicatesFound Kind = "duplicates_found"
|
|
// KindDuplicatesResolved: the duplicate resolver merged copies on its
|
|
// own. This is how an automatic merge stays visible.
|
|
KindDuplicatesResolved Kind = "duplicates_resolved"
|
|
KindPlaybackErrors Kind = "playback_errors"
|
|
)
|
|
|
|
// Audience is who a kind can reach. Admin kinds are never offered to, or
|
|
// stored for, a non-admin.
|
|
type Audience int
|
|
|
|
const (
|
|
AudienceEveryone Audience = iota
|
|
AudienceAdmin
|
|
)
|
|
|
|
// EmailGroup is how a kind's emails are grouped. Nothing is emailed per event.
|
|
type EmailGroup int
|
|
|
|
const (
|
|
// EmailBatch: one email per batch window, holding everything that
|
|
// accumulated since the first un-emailed item.
|
|
EmailBatch EmailGroup = iota
|
|
// EmailSummary: at most one summary a day, at a set local hour. For new
|
|
// music arriving, which comes in bursts and is not urgent.
|
|
EmailSummary
|
|
)
|
|
|
|
// Channels are where a kind reaches a user. Inbox is the master switch: with
|
|
// it off nothing is stored, so there is nothing for the phone or email to
|
|
// deliver. Effective applies that.
|
|
type Channels struct {
|
|
Inbox bool
|
|
Phone bool
|
|
Email bool
|
|
}
|
|
|
|
// Effective is what will actually be delivered: phone and email ride on the
|
|
// inbox row, so they cannot be on without it.
|
|
func (c Channels) Effective() Channels {
|
|
return Channels{Inbox: c.Inbox, Phone: c.Inbox && c.Phone, Email: c.Inbox && c.Email}
|
|
}
|
|
|
|
type spec struct {
|
|
audience Audience
|
|
// coalesce: while one of these is unread, a new event updates it in place
|
|
// rather than adding a row. For the burst-prone admin kinds. Each event
|
|
// is "N more", so the update adds its count and names to the row's.
|
|
coalesce bool
|
|
group EmailGroup
|
|
defaults Channels
|
|
}
|
|
|
|
var (
|
|
allOn = Channels{Inbox: true, Phone: true, Email: true}
|
|
healthAlert = Channels{Inbox: true, Phone: true, Email: false}
|
|
// inboxOnly: news an admin may want to read but never needs to be
|
|
// interrupted for.
|
|
inboxOnly = Channels{Inbox: true}
|
|
// readLater: news worth a daily email but not a buzz in the pocket.
|
|
readLater = Channels{Inbox: true, Email: true}
|
|
)
|
|
|
|
var specs = map[Kind]spec{
|
|
KindNewMusic: {audience: AudienceEveryone, group: EmailSummary, defaults: readLater},
|
|
KindQuarantineFlagged: {audience: AudienceAdmin, group: EmailBatch, defaults: allOn},
|
|
KindScanFailed: {audience: AudienceAdmin, coalesce: true, group: EmailBatch, defaults: healthAlert},
|
|
KindTracksMissing: {audience: AudienceAdmin, coalesce: true, group: EmailBatch, defaults: healthAlert},
|
|
KindDuplicatesFound: {audience: AudienceAdmin, coalesce: true, group: EmailBatch, defaults: healthAlert},
|
|
KindDuplicatesResolved: {audience: AudienceAdmin, coalesce: true, group: EmailBatch, defaults: inboxOnly},
|
|
KindPlaybackErrors: {audience: AudienceAdmin, coalesce: true, group: EmailBatch, defaults: healthAlert},
|
|
}
|
|
|
|
// order is the display order for settings screens: the kind every user gets
|
|
// first, then the admin ones.
|
|
var order = []Kind{
|
|
KindNewMusic,
|
|
KindQuarantineFlagged,
|
|
KindScanFailed,
|
|
KindTracksMissing,
|
|
KindDuplicatesFound,
|
|
KindDuplicatesResolved,
|
|
KindPlaybackErrors,
|
|
}
|
|
|
|
// Kinds returns every kind in display order.
|
|
func Kinds() []Kind { return append([]Kind(nil), order...) }
|
|
|
|
// Valid reports whether k is a known kind.
|
|
func (k Kind) Valid() bool { _, ok := specs[k]; return ok }
|
|
|
|
// AdminOnly reports whether k reaches only admins.
|
|
func (k Kind) AdminOnly() bool { return specs[k].audience == AudienceAdmin }
|
|
|
|
// Defaults are the channels a user has for k until they change them.
|
|
func (k Kind) Defaults() Channels { return specs[k].defaults }
|
|
|
|
// EmailGroup is how k's emails are grouped.
|
|
func (k Kind) EmailGroup() EmailGroup { return specs[k].group }
|
|
|
|
// coalesceKey is the key k's rows coalesce on, or "" when k never coalesces.
|
|
// One key per kind: two unread "tracks missing" rows would only split a count.
|
|
func (k Kind) coalesceKey() string {
|
|
if specs[k].coalesce {
|
|
return string(k)
|
|
}
|
|
return ""
|
|
}
|