minstrel/internal/api/notify_producers.go

package api

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"

	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
	"git.fabledsword.com/bvandeusen/minstrel/internal/notifications"
	"git.fabledsword.com/bvandeusen/minstrel/internal/requests"
)

// Helpers for the handlers that produce notifications (M489). Every call is
// NotifyLogged: a notification never fails the action that caused it.

// userLabel is how a user is named to someone else: their display name, or
// their username when they have none.
func userLabel(u dbq.User) string {
	if u.DisplayName != nil && *u.DisplayName != "" {
		return *u.DisplayName
	}
	return u.Username
}

func requestPayload(row dbq.Request) notifications.Payload {
	return notifications.Payload{
		RequestID:   uuidToString(row.ID),
		RequestKind: string(row.Kind),
		Name:        requests.DisplayName(row),
	}
}

// notifyRequestDecided tells the requester an admin approved or declined
// their request. An admin deciding their own request needs no notice.
func (h *handlers) notifyRequestDecided(ctx context.Context, kind notifications.Kind, admin dbq.User, row dbq.Request, reason string) {
	if row.UserID == admin.ID {
		return
	}
	p := requestPayload(row)
	p.Reason = reason
	h.notifier.NotifyLogged(ctx, kind, notifications.ToUser(row.UserID), p.Map())
}

// quarantineReasonLabel is a flag reason as the flag popover words it, in
// lower case to sit inside a sentence ("flagged X: bad rip").
func quarantineReasonLabel(reason string) string {
	switch reason {
	case "bad_rip":
		return "bad rip"
	case "wrong_file":
		return "wrong file"
	case "wrong_tags":
		return "wrong tags"
	case "duplicate":
		return "duplicate"
	default:
		return ""
	}
}

// trackLabel names a track "Artist – Title" for a notification, falling back
// to the title alone, or to nothing, rather than failing the caller.
func (h *handlers) trackLabel(ctx context.Context, trackID pgtype.UUID) string {
	q := dbq.New(h.pool)
	t, err := q.GetTrackByID(ctx, trackID)
	if err != nil {
		return ""
	}
	if a, aerr := q.GetArtistByID(ctx, t.ArtistID); aerr == nil && a.Name != "" {
		return a.Name + " – " + t.Title
	}
	return t.Title
}

// notifyPlaybackErrors tells admins how many playback errors await review.
// The notice coalesces, so while it is unread a new report only updates the
// count.
func (h *handlers) notifyPlaybackErrors(ctx context.Context) {
	n, err := dbq.New(h.pool).CountUnresolvedPlaybackErrors(ctx)
	if err != nil {
		h.logger.Warn("api: playback_error: count unresolved", "err", err)
		return
	}
	h.notifier.NotifyLogged(ctx, notifications.KindPlaybackErrors, notifications.ToAdmins(pgtype.UUID{}),
		notifications.Payload{Count: n}.Map())
}