yonlu
97f256d67f
The GetAudioFilesByReleaseGroup SQL query only selected 6 columns, missing audio properties (sample_rate, bit_depth, channels, bitrate, file_size) and metadata (album, genre, year, composer, file_type). This caused track details opened from the album view to show dashes instead of actual values. Expanded the query to match GetAllTracksWithFullMetadata and updated GetAlbumTracks to use the shared mapTrackRow helper.
446 lines
9.2 KiB
Go
446 lines
9.2 KiB
Go
package library
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"yellowjacket/backend/coverart"
|
|
)
|
|
|
|
// Sentinel errors for library queries.
|
|
var (
|
|
errNoTracksInLibrary = errors.New("no tracks in library")
|
|
errNoTracksForAlbum = errors.New("no tracks found for album")
|
|
)
|
|
|
|
// Track represents a playable audio file in the library.
|
|
type Track struct {
|
|
TrackName string
|
|
ArtistName string
|
|
TrackLength string
|
|
FilePath string
|
|
TrackNumber int64
|
|
DiscNumber int64
|
|
Album string
|
|
Genre []string
|
|
Year int64
|
|
Composer string
|
|
FileType string
|
|
SampleRate int64
|
|
BitDepth int64
|
|
Channels int64
|
|
Bitrate int64
|
|
FileSize int64
|
|
}
|
|
|
|
// genreDelimiter is the separator used by GROUP_CONCAT in the
|
|
// GetAllTracksWithFullMetadata query.
|
|
const genreDelimiter = "||"
|
|
|
|
// splitGenres splits a GROUP_CONCAT genre string into individual
|
|
// genre names. An empty string returns nil.
|
|
func splitGenres(concatenated string) []string {
|
|
if concatenated == "" {
|
|
return nil
|
|
}
|
|
|
|
return strings.Split(concatenated, genreDelimiter)
|
|
}
|
|
|
|
// mapTrackRow converts raw database column values into a Track.
|
|
// This is shared by GetAllTracks, SearchTracks, and GetTracksByGenre
|
|
// to avoid tripling the row-mapping code.
|
|
func mapTrackRow(
|
|
filePath string,
|
|
lengthMs int64,
|
|
title, artistName string,
|
|
trackNumber, discNumber sql.NullInt64,
|
|
album, genre string,
|
|
year int64,
|
|
composer, fileType string,
|
|
sampleRate, bitDepth, channels, bitrate, fileSize int64,
|
|
) Track {
|
|
return Track{
|
|
TrackName: title,
|
|
ArtistName: artistName,
|
|
TrackLength: strconv.FormatInt(lengthMs, 10),
|
|
FilePath: filePath,
|
|
TrackNumber: trackNumber.Int64,
|
|
DiscNumber: discNumber.Int64,
|
|
Album: album,
|
|
Genre: splitGenres(genre),
|
|
Year: year,
|
|
Composer: composer,
|
|
FileType: fileType,
|
|
SampleRate: sampleRate,
|
|
BitDepth: bitDepth,
|
|
Channels: channels,
|
|
Bitrate: bitrate,
|
|
FileSize: fileSize,
|
|
}
|
|
}
|
|
|
|
// Artist represents an artist in the library.
|
|
type Artist struct {
|
|
ID int64
|
|
Name string
|
|
}
|
|
|
|
// Album represents an album for the cover grid display.
|
|
type Album struct {
|
|
ID int64
|
|
Name string
|
|
ArtistName string
|
|
CoverArtPath string
|
|
CoverArtSmall string
|
|
CoverArtMedium string
|
|
CoverArtLarge string
|
|
Year int64
|
|
}
|
|
|
|
// GetAllTracks returns an array of track structs of every file in the library.
|
|
func (l *Library) GetAllTracks() ([]Track, error) {
|
|
rows, err := l.db.Queries.GetAllTracksWithFullMetadata(
|
|
l.ctx,
|
|
)
|
|
if err != nil {
|
|
l.logger.Error(
|
|
"could not retrieve audio files",
|
|
"error", err,
|
|
)
|
|
|
|
return nil, err
|
|
}
|
|
|
|
l.logger.Info("audio file list", "count", len(rows))
|
|
|
|
if len(rows) == 0 {
|
|
l.logger.Error("no tracks in library")
|
|
|
|
return nil, errNoTracksInLibrary
|
|
}
|
|
|
|
tracks := make([]Track, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
tracks = append(tracks, mapTrackRow(
|
|
row.FilePath,
|
|
row.LengthMilliseconds,
|
|
row.Title,
|
|
row.ArtistName,
|
|
row.TrackNumber,
|
|
row.DiscNumber,
|
|
row.Album,
|
|
row.Genre,
|
|
row.Year,
|
|
row.Composer,
|
|
row.FileType,
|
|
row.SampleRate,
|
|
row.BitDepth,
|
|
row.Channels,
|
|
row.Bitrate,
|
|
row.FileSize,
|
|
))
|
|
}
|
|
|
|
l.logger.Info("formatted tracks", "count", len(tracks))
|
|
|
|
return tracks, nil
|
|
}
|
|
|
|
// searchTrackLimit is the maximum number of results returned by
|
|
// a full-text search.
|
|
const searchTrackLimit = 200
|
|
|
|
// SearchTracks performs an FTS5 full-text search and returns
|
|
// matching tracks with full metadata.
|
|
func (l *Library) SearchTracks(
|
|
query string,
|
|
) ([]Track, error) {
|
|
rows, err := l.db.SearchFTSTracks(
|
|
query, searchTrackLimit,
|
|
)
|
|
if err != nil {
|
|
l.logger.Error(
|
|
"FTS track search failed",
|
|
"query", query,
|
|
"error", err,
|
|
)
|
|
|
|
return nil, fmt.Errorf(
|
|
"search tracks failed: %w", err,
|
|
)
|
|
}
|
|
|
|
tracks := make([]Track, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
tracks = append(tracks, mapTrackRow(
|
|
row.FilePath,
|
|
row.LengthMilliseconds,
|
|
row.Title,
|
|
row.ArtistName,
|
|
row.TrackNumber,
|
|
row.DiscNumber,
|
|
row.Album,
|
|
row.Genre,
|
|
row.Year,
|
|
row.Composer,
|
|
row.FileType,
|
|
row.SampleRate,
|
|
row.BitDepth,
|
|
row.Channels,
|
|
row.Bitrate,
|
|
row.FileSize,
|
|
))
|
|
}
|
|
|
|
return tracks, nil
|
|
}
|
|
|
|
// GetAlbumTracks returns all tracks for a given album (release group), ordered by disc and track number.
|
|
func (l *Library) GetAlbumTracks(albumID int64) ([]Track, error) {
|
|
rows, err := l.db.Queries.GetAudioFilesByReleaseGroup(l.ctx, albumID)
|
|
if err != nil {
|
|
l.logger.Error("could not retrieve album tracks", "albumID", albumID, "error", err)
|
|
|
|
return nil, fmt.Errorf("could not get album tracks: %w", err)
|
|
}
|
|
|
|
if len(rows) == 0 {
|
|
return nil, fmt.Errorf("%w %d", errNoTracksForAlbum, albumID)
|
|
}
|
|
|
|
tracks := make([]Track, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
tracks = append(tracks, mapTrackRow(
|
|
row.FilePath,
|
|
row.LengthMilliseconds,
|
|
row.Title,
|
|
row.ArtistName,
|
|
row.TrackNumber,
|
|
row.DiscNumber,
|
|
row.Album,
|
|
row.Genre,
|
|
row.Year,
|
|
row.Composer,
|
|
row.FileType,
|
|
row.SampleRate,
|
|
row.BitDepth,
|
|
row.Channels,
|
|
row.Bitrate,
|
|
row.FileSize,
|
|
))
|
|
}
|
|
|
|
return tracks, nil
|
|
}
|
|
|
|
// GetAllAlbums returns all albums with cover art and artist info for the cover grid.
|
|
func (l *Library) GetAllAlbums() ([]Album, error) {
|
|
rows, err := l.db.Queries.GetAllAlbumsWithDetails(l.ctx)
|
|
if err != nil {
|
|
l.logger.Error("could not retrieve albums", "error", err)
|
|
|
|
return nil, fmt.Errorf("could not get albums: %w", err)
|
|
}
|
|
|
|
l.logger.Info("album list", "count", len(rows))
|
|
|
|
albums := make([]Album, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
album := Album{
|
|
ID: row.ID,
|
|
Name: row.Name,
|
|
ArtistName: row.ArtistName,
|
|
}
|
|
|
|
if row.Year.Valid {
|
|
album.Year = row.Year.Int64
|
|
}
|
|
|
|
// Convert filesystem path to URL path for the asset handler.
|
|
if row.CoverArtPath != "" {
|
|
urls := coverart.ResolveURLs(row.CoverArtPath)
|
|
album.CoverArtPath = urls.Original
|
|
album.CoverArtSmall = urls.Small
|
|
album.CoverArtMedium = urls.Medium
|
|
album.CoverArtLarge = urls.Large
|
|
}
|
|
|
|
albums = append(albums, album)
|
|
}
|
|
|
|
return albums, nil
|
|
}
|
|
|
|
// GetAllArtists returns artists that are credited as album artists, ordered by name.
|
|
func (l *Library) GetAllArtists() ([]Artist, error) {
|
|
rows, err := l.db.Queries.GetAlbumArtists(l.ctx)
|
|
if err != nil {
|
|
l.logger.Error(
|
|
"could not retrieve artists",
|
|
"error", err,
|
|
)
|
|
|
|
return nil, fmt.Errorf(
|
|
"could not get artists: %w",
|
|
err,
|
|
)
|
|
}
|
|
|
|
l.logger.Info("artist list", "count", len(rows))
|
|
|
|
artists := make([]Artist, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
artists = append(artists, Artist{
|
|
ID: row.ID,
|
|
Name: row.Name,
|
|
})
|
|
}
|
|
|
|
return artists, nil
|
|
}
|
|
|
|
// GetAlbumsByArtist returns all albums where the given artist is the album artist.
|
|
func (l *Library) GetAlbumsByArtist(
|
|
artistID int64,
|
|
) ([]Album, error) {
|
|
rows, err := l.db.Queries.GetAlbumsByArtist(
|
|
l.ctx,
|
|
artistID,
|
|
)
|
|
if err != nil {
|
|
l.logger.Error(
|
|
"could not retrieve albums for artist",
|
|
"artistID", artistID,
|
|
"error", err,
|
|
)
|
|
|
|
return nil, fmt.Errorf(
|
|
"could not get albums for artist: %w",
|
|
err,
|
|
)
|
|
}
|
|
|
|
l.logger.Info(
|
|
"albums for artist",
|
|
"artistID", artistID,
|
|
"count", len(rows),
|
|
)
|
|
|
|
albums := make([]Album, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
album := Album{
|
|
ID: row.ID,
|
|
Name: row.Name,
|
|
ArtistName: row.ArtistName,
|
|
}
|
|
|
|
if row.Year.Valid {
|
|
album.Year = row.Year.Int64
|
|
}
|
|
|
|
// Convert filesystem path to URL path for the asset handler.
|
|
if row.CoverArtPath != "" {
|
|
urls := coverart.ResolveURLs(row.CoverArtPath)
|
|
album.CoverArtPath = urls.Original
|
|
album.CoverArtSmall = urls.Small
|
|
album.CoverArtMedium = urls.Medium
|
|
album.CoverArtLarge = urls.Large
|
|
}
|
|
|
|
albums = append(albums, album)
|
|
}
|
|
|
|
return albums, nil
|
|
}
|
|
|
|
// GenreWithCount holds a genre name and its associated track count.
|
|
type GenreWithCount struct {
|
|
Name string `json:"Name"`
|
|
TrackCount int64 `json:"TrackCount"`
|
|
}
|
|
|
|
// GetTracksByGenre returns all tracks tagged with the given genre.
|
|
func (l *Library) GetTracksByGenre(
|
|
genreName string,
|
|
) ([]Track, error) {
|
|
rows, err := l.db.Queries.GetTracksByGenre(
|
|
l.ctx, genreName,
|
|
)
|
|
if err != nil {
|
|
l.logger.Error(
|
|
"could not retrieve tracks for genre",
|
|
"genre", genreName,
|
|
"error", err,
|
|
)
|
|
|
|
return nil, fmt.Errorf(
|
|
"could not get tracks for genre: %w", err,
|
|
)
|
|
}
|
|
|
|
tracks := make([]Track, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
tracks = append(tracks, mapTrackRow(
|
|
row.FilePath,
|
|
row.LengthMilliseconds,
|
|
row.Title,
|
|
row.ArtistName,
|
|
row.TrackNumber,
|
|
row.DiscNumber,
|
|
row.Album,
|
|
row.Genre,
|
|
row.Year,
|
|
row.Composer,
|
|
row.FileType,
|
|
row.SampleRate,
|
|
row.BitDepth,
|
|
row.Channels,
|
|
row.Bitrate,
|
|
row.FileSize,
|
|
))
|
|
}
|
|
|
|
return tracks, nil
|
|
}
|
|
|
|
// GetAllGenresWithCounts returns all genres with their track counts.
|
|
func (l *Library) GetAllGenresWithCounts() (
|
|
[]GenreWithCount, error,
|
|
) {
|
|
rows, err := l.db.Queries.GetAllGenresWithCounts(
|
|
l.ctx,
|
|
)
|
|
if err != nil {
|
|
l.logger.Error(
|
|
"could not retrieve genres with counts",
|
|
"error", err,
|
|
)
|
|
|
|
return nil, fmt.Errorf(
|
|
"could not get genres: %w", err,
|
|
)
|
|
}
|
|
|
|
genres := make([]GenreWithCount, 0, len(rows))
|
|
|
|
for _, row := range rows {
|
|
genres = append(genres, GenreWithCount{
|
|
Name: row.Name,
|
|
TrackCount: row.TrackCount,
|
|
})
|
|
}
|
|
|
|
return genres, nil
|
|
}
|