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>
414 lines
11 KiB
Go
414 lines
11 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: likes.sql
|
|
|
|
package dbq
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const countLikedAlbums = `-- name: CountLikedAlbums :one
|
|
SELECT count(*) FROM general_likes_albums WHERE user_id = $1
|
|
`
|
|
|
|
func (q *Queries) CountLikedAlbums(ctx context.Context, userID pgtype.UUID) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countLikedAlbums, userID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countLikedArtists = `-- name: CountLikedArtists :one
|
|
SELECT count(*) FROM general_likes_artists WHERE user_id = $1
|
|
`
|
|
|
|
func (q *Queries) CountLikedArtists(ctx context.Context, userID pgtype.UUID) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countLikedArtists, userID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countLikedTracks = `-- name: CountLikedTracks :one
|
|
SELECT count(DISTINCT t.song_key) FROM general_likes l
|
|
JOIN tracks t ON t.id = l.track_id
|
|
WHERE l.user_id = $1
|
|
`
|
|
|
|
// Liked songs, each counted once however many releases hold it.
|
|
func (q *Queries) CountLikedTracks(ctx context.Context, userID pgtype.UUID) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countLikedTracks, userID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const likeAlbum = `-- name: LikeAlbum :exec
|
|
INSERT INTO general_likes_albums (user_id, album_id)
|
|
VALUES ($1, $2)
|
|
ON CONFLICT (user_id, album_id) DO NOTHING
|
|
`
|
|
|
|
type LikeAlbumParams struct {
|
|
UserID pgtype.UUID
|
|
AlbumID pgtype.UUID
|
|
}
|
|
|
|
func (q *Queries) LikeAlbum(ctx context.Context, arg LikeAlbumParams) error {
|
|
_, err := q.db.Exec(ctx, likeAlbum, arg.UserID, arg.AlbumID)
|
|
return err
|
|
}
|
|
|
|
const likeArtist = `-- name: LikeArtist :exec
|
|
INSERT INTO general_likes_artists (user_id, artist_id)
|
|
VALUES ($1, $2)
|
|
ON CONFLICT (user_id, artist_id) DO NOTHING
|
|
`
|
|
|
|
type LikeArtistParams struct {
|
|
UserID pgtype.UUID
|
|
ArtistID pgtype.UUID
|
|
}
|
|
|
|
func (q *Queries) LikeArtist(ctx context.Context, arg LikeArtistParams) error {
|
|
_, err := q.db.Exec(ctx, likeArtist, arg.UserID, arg.ArtistID)
|
|
return err
|
|
}
|
|
|
|
const likeTrack = `-- name: LikeTrack :many
|
|
INSERT INTO general_likes (user_id, track_id)
|
|
SELECT $1::uuid, t.id
|
|
FROM tracks t
|
|
WHERE t.song_key = (SELECT s.song_key FROM tracks s WHERE s.id = $2::uuid)
|
|
ON CONFLICT (user_id, track_id) DO NOTHING
|
|
RETURNING track_id
|
|
`
|
|
|
|
type LikeTrackParams struct {
|
|
UserID pgtype.UUID
|
|
TrackID pgtype.UUID
|
|
}
|
|
|
|
// A like is on the song: every copy of it sharing the track's
|
|
// song_key is liked. Returns the tracks newly liked, for the sync log; empty
|
|
// when the song was already liked.
|
|
func (q *Queries) LikeTrack(ctx context.Context, arg LikeTrackParams) ([]pgtype.UUID, error) {
|
|
rows, err := q.db.Query(ctx, likeTrack, arg.UserID, arg.TrackID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []pgtype.UUID
|
|
for rows.Next() {
|
|
var track_id pgtype.UUID
|
|
if err := rows.Scan(&track_id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, track_id)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLikedAlbumIDs = `-- name: ListLikedAlbumIDs :many
|
|
SELECT album_id FROM general_likes_albums WHERE user_id = $1 ORDER BY liked_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListLikedAlbumIDs(ctx context.Context, userID pgtype.UUID) ([]pgtype.UUID, error) {
|
|
rows, err := q.db.Query(ctx, listLikedAlbumIDs, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []pgtype.UUID
|
|
for rows.Next() {
|
|
var album_id pgtype.UUID
|
|
if err := rows.Scan(&album_id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, album_id)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLikedAlbumRows = `-- name: ListLikedAlbumRows :many
|
|
SELECT a.id, a.title, a.sort_title, a.artist_id, a.release_date, a.mbid, a.cover_art_path, a.created_at, a.updated_at, a.cover_art_source, a.cover_art_sources_version, a.release_group_mbid, a.announced_at FROM albums a
|
|
JOIN general_likes_albums l ON l.album_id = a.id
|
|
WHERE l.user_id = $1
|
|
ORDER BY l.liked_at DESC
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
|
|
type ListLikedAlbumRowsParams struct {
|
|
UserID pgtype.UUID
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
func (q *Queries) ListLikedAlbumRows(ctx context.Context, arg ListLikedAlbumRowsParams) ([]Album, error) {
|
|
rows, err := q.db.Query(ctx, listLikedAlbumRows, arg.UserID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Album
|
|
for rows.Next() {
|
|
var i Album
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Title,
|
|
&i.SortTitle,
|
|
&i.ArtistID,
|
|
&i.ReleaseDate,
|
|
&i.Mbid,
|
|
&i.CoverArtPath,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CoverArtSource,
|
|
&i.CoverArtSourcesVersion,
|
|
&i.ReleaseGroupMbid,
|
|
&i.AnnouncedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLikedArtistIDs = `-- name: ListLikedArtistIDs :many
|
|
SELECT artist_id FROM general_likes_artists WHERE user_id = $1 ORDER BY liked_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListLikedArtistIDs(ctx context.Context, userID pgtype.UUID) ([]pgtype.UUID, error) {
|
|
rows, err := q.db.Query(ctx, listLikedArtistIDs, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []pgtype.UUID
|
|
for rows.Next() {
|
|
var artist_id pgtype.UUID
|
|
if err := rows.Scan(&artist_id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, artist_id)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLikedArtistRows = `-- name: ListLikedArtistRows :many
|
|
SELECT a.id, a.name, a.sort_name, a.mbid, a.created_at, a.updated_at, a.artist_thumb_path, a.artist_fanart_path, a.artist_art_source, a.artist_art_sources_version FROM artists a
|
|
JOIN general_likes_artists l ON l.artist_id = a.id
|
|
WHERE l.user_id = $1
|
|
ORDER BY l.liked_at DESC
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
|
|
type ListLikedArtistRowsParams struct {
|
|
UserID pgtype.UUID
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
func (q *Queries) ListLikedArtistRows(ctx context.Context, arg ListLikedArtistRowsParams) ([]Artist, error) {
|
|
rows, err := q.db.Query(ctx, listLikedArtistRows, arg.UserID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Artist
|
|
for rows.Next() {
|
|
var i Artist
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ArtistThumbPath,
|
|
&i.ArtistFanartPath,
|
|
&i.ArtistArtSource,
|
|
&i.ArtistArtSourcesVersion,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLikedTrackIDs = `-- name: ListLikedTrackIDs :many
|
|
SELECT track_id FROM general_likes WHERE user_id = $1 ORDER BY liked_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListLikedTrackIDs(ctx context.Context, userID pgtype.UUID) ([]pgtype.UUID, error) {
|
|
rows, err := q.db.Query(ctx, listLikedTrackIDs, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []pgtype.UUID
|
|
for rows.Next() {
|
|
var track_id pgtype.UUID
|
|
if err := rows.Scan(&track_id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, track_id)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLikedTrackRows = `-- name: ListLikedTrackRows :many
|
|
SELECT t.id, t.title, t.album_id, t.artist_id, t.track_number, t.disc_number, t.duration_ms, t.file_path, t.file_size, t.file_format, t.bitrate, t.mbid, t.genre, t.added_at, t.updated_at, t.tag_source, t.tag_sources_version, t.tag_read_version, t.missing_since, t.mbid_source, t.song_id, t.song_key, t.source_verdict, t.source_verdict_at, t.emptied_at FROM tracks t
|
|
JOIN (SELECT DISTINCT ON (lt.song_key) l.track_id, l.liked_at
|
|
FROM general_likes l
|
|
JOIN tracks lt ON lt.id = l.track_id
|
|
WHERE l.user_id = $1
|
|
ORDER BY lt.song_key, (lt.missing_since IS NOT NULL),
|
|
(lt.source_verdict IS NOT DISTINCT FROM 'suspect'), l.liked_at, lt.id) l
|
|
ON l.track_id = t.id
|
|
ORDER BY l.liked_at DESC, t.id
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
|
|
type ListLikedTrackRowsParams struct {
|
|
UserID pgtype.UUID
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
// One row per liked song: of its copies, the one present on disk, then one
|
|
// that is not a held-back video rip, then the one liked first.
|
|
func (q *Queries) ListLikedTrackRows(ctx context.Context, arg ListLikedTrackRowsParams) ([]Track, error) {
|
|
rows, err := q.db.Query(ctx, listLikedTrackRows, arg.UserID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Track
|
|
for rows.Next() {
|
|
var i Track
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Title,
|
|
&i.AlbumID,
|
|
&i.ArtistID,
|
|
&i.TrackNumber,
|
|
&i.DiscNumber,
|
|
&i.DurationMs,
|
|
&i.FilePath,
|
|
&i.FileSize,
|
|
&i.FileFormat,
|
|
&i.Bitrate,
|
|
&i.Mbid,
|
|
&i.Genre,
|
|
&i.AddedAt,
|
|
&i.UpdatedAt,
|
|
&i.TagSource,
|
|
&i.TagSourcesVersion,
|
|
&i.TagReadVersion,
|
|
&i.MissingSince,
|
|
&i.MbidSource,
|
|
&i.SongID,
|
|
&i.SongKey,
|
|
&i.SourceVerdict,
|
|
&i.SourceVerdictAt,
|
|
&i.EmptiedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const unlikeAlbum = `-- name: UnlikeAlbum :exec
|
|
DELETE FROM general_likes_albums WHERE user_id = $1 AND album_id = $2
|
|
`
|
|
|
|
type UnlikeAlbumParams struct {
|
|
UserID pgtype.UUID
|
|
AlbumID pgtype.UUID
|
|
}
|
|
|
|
func (q *Queries) UnlikeAlbum(ctx context.Context, arg UnlikeAlbumParams) error {
|
|
_, err := q.db.Exec(ctx, unlikeAlbum, arg.UserID, arg.AlbumID)
|
|
return err
|
|
}
|
|
|
|
const unlikeArtist = `-- name: UnlikeArtist :exec
|
|
DELETE FROM general_likes_artists WHERE user_id = $1 AND artist_id = $2
|
|
`
|
|
|
|
type UnlikeArtistParams struct {
|
|
UserID pgtype.UUID
|
|
ArtistID pgtype.UUID
|
|
}
|
|
|
|
func (q *Queries) UnlikeArtist(ctx context.Context, arg UnlikeArtistParams) error {
|
|
_, err := q.db.Exec(ctx, unlikeArtist, arg.UserID, arg.ArtistID)
|
|
return err
|
|
}
|
|
|
|
const unlikeTrack = `-- name: UnlikeTrack :many
|
|
DELETE FROM general_likes
|
|
WHERE user_id = $1::uuid
|
|
AND (track_id = $2::uuid
|
|
OR track_id IN (SELECT t.id FROM tracks t
|
|
WHERE t.song_key = (SELECT s.song_key FROM tracks s WHERE s.id = $2::uuid)))
|
|
RETURNING track_id
|
|
`
|
|
|
|
type UnlikeTrackParams struct {
|
|
UserID pgtype.UUID
|
|
TrackID pgtype.UUID
|
|
}
|
|
|
|
// Unlikes the song: every copy sharing the track's song_key. Returns the
|
|
// tracks unliked, for the sync log.
|
|
func (q *Queries) UnlikeTrack(ctx context.Context, arg UnlikeTrackParams) ([]pgtype.UUID, error) {
|
|
rows, err := q.db.Query(ctx, unlikeTrack, arg.UserID, arg.TrackID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []pgtype.UUID
|
|
for rows.Next() {
|
|
var track_id pgtype.UUID
|
|
if err := rows.Scan(&track_id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, track_id)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|