mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-18 02:52:36 +03:00
errchkjson flags json.Marshal/MarshalIndent/Encoder.Encode calls whose error is discarded.
Fixed all 27 sites by hand: errors are returned where the caller already returns one, logged
in HTTP handlers and string-returning helpers, and asserted in tests.
check-error-free-encoding stays off so every encode error is handled, even for safe types.
report-no-exported is on, to catch structs that would silently encode as {}.
150 lines
5.2 KiB
Go
150 lines
5.2 KiB
Go
package persistence
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
. "github.com/Masterminds/squirrel"
|
|
"github.com/navidrome/navidrome/model"
|
|
"github.com/navidrome/navidrome/utils/slice"
|
|
)
|
|
|
|
type participant struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
SubRole string `json:"subRole,omitempty"`
|
|
}
|
|
|
|
// flatParticipant represents a flattened participant structure for SQL processing
|
|
type flatParticipant struct {
|
|
ArtistID string `json:"artist_id"`
|
|
Role string `json:"role"`
|
|
SubRole string `json:"sub_role,omitempty"`
|
|
}
|
|
|
|
// ParticipantIDFilter matches rows of table where the artist participates in any of the given roles
|
|
// (any role when empty). Semi-joins <table>_artists; json_tree over the JSON is far slower at scale.
|
|
func ParticipantIDFilter(table string, artistID any, roles ...model.Role) Sqlizer {
|
|
return participantIDFilter(table, artistID, false, roles)
|
|
}
|
|
|
|
// NotParticipantIDFilter is the negation of ParticipantIDFilter.
|
|
func NotParticipantIDFilter(table string, artistID any, roles ...model.Role) Sqlizer {
|
|
return participantIDFilter(table, artistID, true, roles)
|
|
}
|
|
|
|
func participantIDFilter(table string, artistID any, negate bool, roles []model.Role) Sqlizer {
|
|
sel := Select(table + "_id").From(table + "_artists").Where(Eq{"artist_id": artistID})
|
|
if len(roles) > 0 {
|
|
sel = sel.Where(Eq{"role": slice.Map(roles, func(r model.Role) string { return r.String() })})
|
|
}
|
|
sql, args, _ := sel.ToSql()
|
|
op := " IN ("
|
|
if negate {
|
|
op = " NOT IN ("
|
|
}
|
|
return Expr(table+".id"+op+sql+")", args...)
|
|
}
|
|
|
|
func marshalParticipants(participants model.Participants) (string, error) {
|
|
dbParticipants := make(map[model.Role][]participant)
|
|
for role, artists := range participants {
|
|
for _, artist := range artists {
|
|
dbParticipants[role] = append(dbParticipants[role], participant{ID: artist.ID, SubRole: artist.SubRole, Name: artist.Name})
|
|
}
|
|
}
|
|
res, err := json.Marshal(dbParticipants)
|
|
if err != nil {
|
|
return "", fmt.Errorf("marshalling participants: %w", err)
|
|
}
|
|
return string(res), nil
|
|
}
|
|
|
|
func unmarshalParticipants(data string) (model.Participants, error) {
|
|
var dbParticipants map[model.Role][]participant
|
|
err := json.Unmarshal([]byte(data), &dbParticipants)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parsing participants: %w", err)
|
|
}
|
|
|
|
participants := make(model.Participants, len(dbParticipants))
|
|
for role, participantList := range dbParticipants {
|
|
artists := slice.Map(participantList, func(p participant) model.Participant {
|
|
return model.Participant{ID: p.ID, Name: p.Name, SubRole: p.SubRole}
|
|
})
|
|
participants[role] = artists
|
|
}
|
|
return participants, nil
|
|
}
|
|
|
|
func (r sqlRepository) updateParticipants(ctx context.Context, itemID string, participants model.Participants) error {
|
|
// Delete all existing participant entries for this item.
|
|
// This ensures stale role associations are removed when an artist's role changes
|
|
// (e.g., an artist was both albumartist and composer, but is now only composer).
|
|
sqd := Delete(r.tableName + "_artists").Where(Eq{r.tableName + "_id": itemID})
|
|
_, err := r.executeSQL(ctx, sqd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(participants) == 0 {
|
|
return nil
|
|
}
|
|
|
|
var flatParticipants []flatParticipant
|
|
for role, artists := range participants {
|
|
for _, artist := range artists {
|
|
flatParticipants = append(flatParticipants, flatParticipant{
|
|
ArtistID: artist.ID,
|
|
Role: role.String(),
|
|
SubRole: artist.SubRole,
|
|
})
|
|
}
|
|
}
|
|
|
|
participantsJSON, err := json.Marshal(flatParticipants)
|
|
if err != nil {
|
|
return fmt.Errorf("marshaling participants: %w", err)
|
|
}
|
|
|
|
// Build the INSERT query using json_each and INNER JOIN to artist table
|
|
// to automatically filter out non-existent artist IDs
|
|
query := fmt.Sprintf(`
|
|
INSERT INTO %[1]s_artists (%[1]s_id, artist_id, role, sub_role)
|
|
SELECT ?,
|
|
json_extract(value, '$.artist_id') as artist_id,
|
|
json_extract(value, '$.role') as role,
|
|
COALESCE(json_extract(value, '$.sub_role'), '') as sub_role
|
|
-- Parse the flat JSON array: [{"artist_id": "id", "role": "role", "sub_role": "subRole"}]
|
|
FROM json_each(?) -- Iterate through each array element
|
|
-- CRITICAL: Only insert records for artists that actually exist in the database
|
|
JOIN artist ON artist.id = json_extract(value, '$.artist_id') -- Filter out non-existent artist IDs via INNER JOIN
|
|
-- Handle duplicate insertions gracefully (e.g., if called multiple times)
|
|
ON CONFLICT (artist_id, %[1]s_id, role, sub_role) DO NOTHING -- Ignore duplicates
|
|
`, r.tableName)
|
|
|
|
_, err = r.executeSQL(ctx, Expr(query, itemID, string(participantsJSON)))
|
|
return err
|
|
}
|
|
|
|
func (r *sqlRepository) getParticipants(ctx context.Context, m *model.MediaFile) (model.Participants, error) {
|
|
ar := NewArtistRepository(r.db)
|
|
ids := m.Participants.AllIDs()
|
|
artists, err := ar.GetAll(ctx, model.QueryOptions{Filters: Eq{"artist.id": ids}})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("getting participants: %w", err)
|
|
}
|
|
artistMap := slice.ToMap(artists, func(a model.Artist) (string, model.Artist) {
|
|
return a.ID, a
|
|
})
|
|
p := m.Participants
|
|
for role, artistList := range p {
|
|
for idx, artist := range artistList {
|
|
if a, ok := artistMap[artist.ID]; ok {
|
|
p[role][idx].Artist = a
|
|
}
|
|
}
|
|
}
|
|
return p, nil
|
|
}
|