mirror of
https://github.com/navidrome/navidrome.git
synced 2025-04-04 04:57:37 +03:00
feat(bfr): Big Refactor: new scanner, lots of new fields and tags, improvements and DB schema changes (#2709)
* fix(server): more race conditions when updating artist/album from external sources
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(scanner): add .gitignore syntax to .ndignore. Resolves #1394
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(ui): null
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(scanner): pass configfile option to child process
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(scanner): resume interrupted fullScans
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(scanner): remove old scanner code
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(scanner): rename old metadata package
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(scanner): move old metadata package
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: tests
Signed-off-by: Deluan <deluan@navidrome.org>
* chore(deps): update Go to 1.23.4
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: logs
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(test):
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: log level
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: remove log message
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: add config for scanner watcher
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: children playlists
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: replace `interface{}` with `any`
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: smart playlists with genres
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: allow any tags in smart playlists
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: artist names in playlists
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: smart playlist's sort by tags
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add moods to child
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add moods to AlbumID3
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor(subsonic): use generic JSONArray for OS arrays
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor(subsonic): use https in test
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add releaseTypes to AlbumID3
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add recordLabels to AlbumID3
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor(subsonic): rename JSONArray to Array
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add artists to AlbumID3
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add artists to Child
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(scanner): do not pre-populate smart playlists
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): implement a simplified version of ArtistID3.
See https://github.com/opensubsonic/open-subsonic-api/discussions/120
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add artists to album child
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add contributors to mediafile Child
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add albumArtists to mediafile Child
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add displayArtist and displayAlbumArtist
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add displayComposer to Child
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add roles to ArtistID3
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(subsonic): use " • " separator for displayComposer
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor:
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(subsonic):
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(subsonic): respect `PreferSortTags` config option
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor(subsonic):
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: optimize purging non-unused tags
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: don't run 'refresh artist stats' concurrently with other transactions
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor:
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: log message
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: add Scanner.ScanOnStartup config option, default true
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: better json parsing error msg when importing NSPs
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: don't update album's imported_time when updating external_metadata
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: handle interrupted scans and full scans after migrations
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: run `analyze` when migration requires a full rescan
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: run `PRAGMA optimize` at the end of the scan
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: don't update artist's updated_at when updating external_metadata
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: handle multiple artists and roles in smart playlists
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(ui): dim missing tracks
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: album missing logic
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: error encoding in gob
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: separate warnings from errors
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: mark albums as missing if they were contained in a deleted folder
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: add participant names to media_file and album tables
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: use participations in criteria, instead of m2m relationship
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: rename participations to participants
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add moods to album child
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: albumartist role case
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(scanner): run scanner as an external process by default
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(ui): show albumArtist names
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(ui): dim out missing albums
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: flaky test
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(server): scrobble buffer mapping. fix #3583
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: more participations renaming
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: listenbrainz scrobbling
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: send release_group_mbid to listenbrainz
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): implement OpenSubsonic explicitStatus field (#3597)
* feat: implement OpenSubsonic explicitStatus field
* fix(subsonic): fix failing snapshot tests
* refactor: create helper for setting explicitStatus
* fix: store smaller values for explicit-status on database
* test: ToAlbum explicitStatus
* refactor: rename explicitStatus helper function
---------
Co-authored-by: Deluan Quintão <deluan@navidrome.org>
* fix: handle album and track tags in the DB based on the mappings.yaml file
Signed-off-by: Deluan <deluan@navidrome.org>
* save similar artists as JSONB
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: getAlbumList byGenre
Signed-off-by: Deluan <deluan@navidrome.org>
* detect changes in PID configuration
Signed-off-by: Deluan <deluan@navidrome.org>
* set default album PID to legacy_pid
Signed-off-by: Deluan <deluan@navidrome.org>
* fix tests
Signed-off-by: Deluan <deluan@navidrome.org>
* fix SIGSEGV
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: don't lose album stars/ratings when migrating
Signed-off-by: Deluan <deluan@navidrome.org>
* store full PID conf in properties
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: keep album annotations when changing PID.Album config
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: reassign album annotations
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: use (display) albumArtist and add links to each artist
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: not showing albums by albumartist
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: error msgs
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: hide PID from Native API
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: album cover art resolution
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: trim participant names
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: reduce watcher log spam
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: panic when initializing the watcher
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: various artists
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: don't store empty lyrics in the DB
Signed-off-by: Deluan <deluan@navidrome.org>
* remove unused methods
Signed-off-by: Deluan <deluan@navidrome.org>
* drop full_text indexes, as they are not being used by SQLite
Signed-off-by: Deluan <deluan@navidrome.org>
* keep album created_at when upgrading
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(ui): null pointer
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: album artwork cache
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: don't expose missing files in Subsonic API
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: searchable interface
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: filter out missing items from subsonic search
* fix: filter out missing items from playlists
* fix: filter out missing items from shares
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(ui): add filter by artist role
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): only return albumartists in getIndexes and getArtists endpoints
Signed-off-by: Deluan <deluan@navidrome.org>
* sort roles alphabetically
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: artist playcounts
Signed-off-by: Deluan <deluan@navidrome.org>
* change default Album PID conf
Signed-off-by: Deluan <deluan@navidrome.org>
* fix albumartist link when it does not match any albumartists values
Signed-off-by: Deluan <deluan@navidrome.org>
* fix `Ignoring filter not whitelisted` (role) message
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: trim any names/titles being imported
Signed-off-by: Deluan <deluan@navidrome.org>
* remove unused genre code
Signed-off-by: Deluan <deluan@navidrome.org>
* serialize calls to Last.fm's getArtist
Signed-off-by: Deluan <deluan@navidrome.org>
xxx
Signed-off-by: Deluan <deluan@navidrome.org>
* add counters to genres
Signed-off-by: Deluan <deluan@navidrome.org>
* nit: fix migration `notice` message
Signed-off-by: Deluan <deluan@navidrome.org>
* optimize similar artists query
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: last.fm.getInfo when mbid does not exist
Signed-off-by: Deluan <deluan@navidrome.org>
* ui only show missing items for admins
Signed-off-by: Deluan <deluan@navidrome.org>
* don't allow interaction with missing items
Signed-off-by: Deluan <deluan@navidrome.org>
* Add Missing Files view (WIP)
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: merged tag_counts into tag table
Signed-off-by: Deluan <deluan@navidrome.org>
* add option to completely disable automatic scanner
Signed-off-by: Deluan <deluan@navidrome.org>
* add delete missing files functionality
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: playlists not showing for regular users
Signed-off-by: Deluan <deluan@navidrome.org>
* reduce updateLastAccess frequency to once every minute
Signed-off-by: Deluan <deluan@navidrome.org>
* reduce update player frequency to once every minute
Signed-off-by: Deluan <deluan@navidrome.org>
* add timeout when updating player
Signed-off-by: Deluan <deluan@navidrome.org>
* remove dead code
Signed-off-by: Deluan <deluan@navidrome.org>
* fix duplicated roles in stats
Signed-off-by: Deluan <deluan@navidrome.org>
* add `; ` to artist splitters
Signed-off-by: Deluan <deluan@navidrome.org>
* fix stats query
Signed-off-by: Deluan <deluan@navidrome.org>
* more logs
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: support legacy clients (DSub) by removing OpenSubsonic extra fields - WIP
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: support legacy clients (DSub) by removing OpenSubsonic extra fields - WIP
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: support legacy clients (DSub) by removing OpenSubsonic extra fields - WIP
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: support legacy clients (DSub) by removing OpenSubsonic extra fields - WIP
Signed-off-by: Deluan <deluan@navidrome.org>
* add record label filter
Signed-off-by: Deluan <deluan@navidrome.org>
* add release type filter
Signed-off-by: Deluan <deluan@navidrome.org>
* fix purgeUnused tags
Signed-off-by: Deluan <deluan@navidrome.org>
* add grouping filter to albums
Signed-off-by: Deluan <deluan@navidrome.org>
* allow any album tags to be used in as filters in the API
Signed-off-by: Deluan <deluan@navidrome.org>
* remove empty tags from album info
Signed-off-by: Deluan <deluan@navidrome.org>
* comments in the migration
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: Cannot read properties of undefined
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: listenbrainz scrobbling (#3640)
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: remove duplicated tag values
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: don't ignore the taglib folder!
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: show track subtitle tag
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: show artists stats based on selected role
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: inspect
Signed-off-by: Deluan <deluan@navidrome.org>
* add media type to album info/filters
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: change format of subtitle in the UI
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: subtitle in Subsonic API and search
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: subtitle in UI's player
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: split strings should be case-insensitive
Signed-off-by: Deluan <deluan@navidrome.org>
* disable ScanSchedule
Signed-off-by: Deluan <deluan@navidrome.org>
* increase default sessiontimeout
Signed-off-by: Deluan <deluan@navidrome.org>
* add sqlite command line tool to docker image
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: resources override
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: album PID conf
Signed-off-by: Deluan <deluan@navidrome.org>
* change migration to mark current artists as albumArtists
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(ui): Allow filtering on multiple genres (#3679)
* feat(ui): Allow filtering on multiple genres
Signed-off-by: Henrik Nordvik <henrikno@gmail.com>
Signed-off-by: Deluan <deluan@navidrome.org>
* add multi-genre filter in Album list
Signed-off-by: Deluan <deluan@navidrome.org>
---------
Signed-off-by: Henrik Nordvik <henrikno@gmail.com>
Signed-off-by: Deluan <deluan@navidrome.org>
Co-authored-by: Henrik Nordvik <henrikno@gmail.com>
* add more multi-valued tag filters to Album and Song views
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(ui): unselect missing files after removing
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(ui): song filter
Signed-off-by: Deluan <deluan@navidrome.org>
* fix sharing tracks. fix #3687
Signed-off-by: Deluan <deluan@navidrome.org>
* use rowids when using search for sync (ex: Symfonium)
Signed-off-by: Deluan <deluan@navidrome.org>
* fix "Report Real Paths" option for subsonic clients
Signed-off-by: Deluan <deluan@navidrome.org>
* fix "Report Real Paths" option for subsonic clients for search
Signed-off-by: Deluan <deluan@navidrome.org>
* add libraryPath to Native API /songs endpoint
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(subsonic): add album version
Signed-off-by: Deluan <deluan@navidrome.org>
* made all tags lowercase as they are case-insensitive anyways.
Signed-off-by: Deluan <deluan@navidrome.org>
* feat(ui): Show full paths, extended properties for album/song (#3691)
* feat(ui): Show full paths, extended properties for album/song
- uses library path + os separator + path
- show participants (album/song) and tags (song)
- make album/participant clickable in show info
* add source to path
* fix pathSeparator in UI
Signed-off-by: Deluan <deluan@navidrome.org>
* fix local artist artwork (#3695)
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: parse vorbis performers
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: clean function into smaller functions
Signed-off-by: Deluan <deluan@navidrome.org>
* fix translations for en and pt
Signed-off-by: Deluan <deluan@navidrome.org>
* add trace log to show annotations reassignment
Signed-off-by: Deluan <deluan@navidrome.org>
* add trace log to show annotations reassignment
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: allow performers without instrument/subrole
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: metadata clean function again
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: optimize split function
Signed-off-by: Deluan <deluan@navidrome.org>
* refactor: split function is now a method of TagConf
Signed-off-by: Deluan <deluan@navidrome.org>
* fix: humanize Artist total size
Signed-off-by: Deluan <deluan@navidrome.org>
* add album version to album details
Signed-off-by: Deluan <deluan@navidrome.org>
* don't display album-level tags in SongInfo
Signed-off-by: Deluan <deluan@navidrome.org>
* fix genre clicking in Album Page
Signed-off-by: Deluan <deluan@navidrome.org>
* don't use mbids in Last.fm api calls.
From 1337574018:
With MBID:
```
GET https://ws.audioscrobbler.com/2.0/?api_key=XXXX&artist=Van+Morrison&format=json&lang=en&mbid=a41ac10f-0a56-4672-9161-b83f9b223559&method=artist.getInfo
{
artist: {
name: "Bee Gees",
mbid: "bf0f7e29-dfe1-416c-b5c6-f9ebc19ea810",
url: "https://www.last.fm/music/Bee+Gees",
}
```
Without MBID:
```
GET https://ws.audioscrobbler.com/2.0/?api_key=XXXX&artist=Van+Morrison&format=json&lang=en&method=artist.getInfo
{
artist: {
name: "Van Morrison",
mbid: "a41ac10f-0a56-4672-9161-b83f9b223559",
url: "https://www.last.fm/music/Van+Morrison",
}
```
Signed-off-by: Deluan <deluan@navidrome.org>
* better logging for when the artist folder is not found
Signed-off-by: Deluan <deluan@navidrome.org>
* fix various issues with artist image resolution
Signed-off-by: Deluan <deluan@navidrome.org>
* hide "Additional Tags" header if there are none.
Signed-off-by: Deluan <deluan@navidrome.org>
* simplify tag rendering
Signed-off-by: Deluan <deluan@navidrome.org>
* enhance logging for artist folder detection
Signed-off-by: Deluan <deluan@navidrome.org>
* make folderID consistent for relative and absolute folderPaths
Signed-off-by: Deluan <deluan@navidrome.org>
* handle more folder paths scenarios
Signed-off-by: Deluan <deluan@navidrome.org>
* filter out other roles when SubsonicArtistParticipations = true
Signed-off-by: Deluan <deluan@navidrome.org>
* fix "Cannot read properties of undefined"
Signed-off-by: Deluan <deluan@navidrome.org>
* fix lyrics and comments being truncated (#3701)
* fix lyrics and comments being truncated
* specifically test for lyrics and comment length
* reorder assertions
Signed-off-by: Deluan <deluan@navidrome.org>
---------
Signed-off-by: Deluan <deluan@navidrome.org>
Co-authored-by: Deluan <deluan@navidrome.org>
* fix(server): Expose library_path for playlist (#3705)
Allows showing absolute path for UI, and makes "report real path" work for playlists (Subsonic)
* fix BFR on Windows (#3704)
* fix potential reflected cross-site scripting vulnerability
Signed-off-by: Deluan <deluan@navidrome.org>
* hack to make it work on Windows
* ignore windows executables
* try fixing the pipeline
Signed-off-by: Deluan <deluan@navidrome.org>
* allow MusicFolder in other drives
* move windows local drive logic to local storage implementation
---------
Signed-off-by: Deluan <deluan@navidrome.org>
* increase pagination sizes for missing files
Signed-off-by: Deluan <deluan@navidrome.org>
* reduce level of "already scanning" watcher log message
Signed-off-by: Deluan <deluan@navidrome.org>
* only count folders with audio files in it
See https://github.com/navidrome/navidrome/discussions/3676#discussioncomment-11990930
Signed-off-by: Deluan <deluan@navidrome.org>
* add album version and catalog number to search
Signed-off-by: Deluan <deluan@navidrome.org>
* add `organization` alias for `recordlabel`
Signed-off-by: Deluan <deluan@navidrome.org>
* remove mbid from Last.fm agent
Signed-off-by: Deluan <deluan@navidrome.org>
* feat: support inspect in ui (#3726)
* inspect in ui
* address round 1
* add catalogNum to AlbumInfo
Signed-off-by: Deluan <deluan@navidrome.org>
* remove dependency on metadata_old (deprecated) package
Signed-off-by: Deluan <deluan@navidrome.org>
* add `RawTags` to model
Signed-off-by: Deluan <deluan@navidrome.org>
* support parsing MBIDs for roles (from the https://github.com/kgarner7/picard-all-mbids plugin) (#3698)
* parse standard roles, vorbis/m4a work for now
* fix djmixer
* working roles, use DJ-mix
* add performers to file
* map mbids
* add a few more tests
* add test
Signed-off-by: Deluan <deluan@navidrome.org>
* try to simplify the performers logic
Signed-off-by: Deluan <deluan@navidrome.org>
* stylistic changes
---------
Signed-off-by: Deluan <deluan@navidrome.org>
Co-authored-by: Deluan <deluan@navidrome.org>
* remove param mutation
Signed-off-by: Deluan <deluan@navidrome.org>
* run automated SQLite optimizations
Signed-off-by: Deluan <deluan@navidrome.org>
* fix playlists import/export on Windows
* fix import playlists
* fix export playlists
* better handling of Windows volumes
Signed-off-by: Deluan <deluan@navidrome.org>
* handle more album ID reassignments
Signed-off-by: Deluan <deluan@navidrome.org>
* allow adding/overriding tags in the config file
Signed-off-by: Deluan <deluan@navidrome.org>
* fix(ui): Fix playlist track id, handle missing tracks better (#3734)
- Use `mediaFileId` instead of `id` for playlist tracks
- Only fetch if the file is not missing
- If extractor fails to get the file, also error (rather than panic)
* optimize DB after each scan.
Signed-off-by: Deluan <deluan@navidrome.org>
* remove sortable from AlbumSongs columns
Signed-off-by: Deluan <deluan@navidrome.org>
* simplify query to get missing tracks
Signed-off-by: Deluan <deluan@navidrome.org>
* mark Scanner.Extractor as deprecated
Signed-off-by: Deluan <deluan@navidrome.org>
---------
Signed-off-by: Deluan <deluan@navidrome.org>
Signed-off-by: Henrik Nordvik <henrikno@gmail.com>
Co-authored-by: Caio Cotts <caio@cotts.com.br>
Co-authored-by: Henrik Nordvik <henrikno@gmail.com>
Co-authored-by: Kendall Garner <17521368+kgarner7@users.noreply.github.com>
This commit is contained in:
Deluan Quintão
GitHub
parent
46a963a02a
commit
c795bcfcf7
329 changed files with 16586 additions and 5852 deletions
185
model/album.go
185
model/album.go
|
|
@ -1,75 +1,115 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
"slices"
|
||||
"iter"
|
||||
"math"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/navidrome/navidrome/utils/slice"
|
||||
"github.com/gohugoio/hashstructure"
|
||||
)
|
||||
|
||||
type Album struct {
|
||||
Annotations `structs:"-"`
|
||||
Annotations `structs:"-" hash:"ignore"`
|
||||
|
||||
ID string `structs:"id" json:"id"`
|
||||
LibraryID int `structs:"library_id" json:"libraryId"`
|
||||
Name string `structs:"name" json:"name"`
|
||||
EmbedArtPath string `structs:"embed_art_path" json:"embedArtPath"`
|
||||
ArtistID string `structs:"artist_id" json:"artistId"`
|
||||
Artist string `structs:"artist" json:"artist"`
|
||||
AlbumArtistID string `structs:"album_artist_id" json:"albumArtistId"`
|
||||
AlbumArtist string `structs:"album_artist" json:"albumArtist"`
|
||||
AllArtistIDs string `structs:"all_artist_ids" json:"allArtistIds"`
|
||||
MaxYear int `structs:"max_year" json:"maxYear"`
|
||||
MinYear int `structs:"min_year" json:"minYear"`
|
||||
Date string `structs:"date" json:"date,omitempty"`
|
||||
MaxOriginalYear int `structs:"max_original_year" json:"maxOriginalYear"`
|
||||
MinOriginalYear int `structs:"min_original_year" json:"minOriginalYear"`
|
||||
OriginalDate string `structs:"original_date" json:"originalDate,omitempty"`
|
||||
ReleaseDate string `structs:"release_date" json:"releaseDate,omitempty"`
|
||||
Releases int `structs:"releases" json:"releases"`
|
||||
Compilation bool `structs:"compilation" json:"compilation"`
|
||||
Comment string `structs:"comment" json:"comment,omitempty"`
|
||||
SongCount int `structs:"song_count" json:"songCount"`
|
||||
Duration float32 `structs:"duration" json:"duration"`
|
||||
Size int64 `structs:"size" json:"size"`
|
||||
Genre string `structs:"genre" json:"genre"`
|
||||
Genres Genres `structs:"-" json:"genres"`
|
||||
Discs Discs `structs:"discs" json:"discs,omitempty"`
|
||||
FullText string `structs:"full_text" json:"-"`
|
||||
SortAlbumName string `structs:"sort_album_name" json:"sortAlbumName,omitempty"`
|
||||
SortAlbumArtistName string `structs:"sort_album_artist_name" json:"sortAlbumArtistName,omitempty"`
|
||||
OrderAlbumName string `structs:"order_album_name" json:"orderAlbumName"`
|
||||
OrderAlbumArtistName string `structs:"order_album_artist_name" json:"orderAlbumArtistName"`
|
||||
CatalogNum string `structs:"catalog_num" json:"catalogNum,omitempty"`
|
||||
MbzAlbumID string `structs:"mbz_album_id" json:"mbzAlbumId,omitempty"`
|
||||
MbzAlbumArtistID string `structs:"mbz_album_artist_id" json:"mbzAlbumArtistId,omitempty"`
|
||||
MbzAlbumType string `structs:"mbz_album_type" json:"mbzAlbumType,omitempty"`
|
||||
MbzAlbumComment string `structs:"mbz_album_comment" json:"mbzAlbumComment,omitempty"`
|
||||
ImageFiles string `structs:"image_files" json:"imageFiles,omitempty"`
|
||||
Paths string `structs:"paths" json:"paths,omitempty"`
|
||||
Description string `structs:"description" json:"description,omitempty"`
|
||||
SmallImageUrl string `structs:"small_image_url" json:"smallImageUrl,omitempty"`
|
||||
MediumImageUrl string `structs:"medium_image_url" json:"mediumImageUrl,omitempty"`
|
||||
LargeImageUrl string `structs:"large_image_url" json:"largeImageUrl,omitempty"`
|
||||
ExternalUrl string `structs:"external_url" json:"externalUrl,omitempty"`
|
||||
ExternalInfoUpdatedAt *time.Time `structs:"external_info_updated_at" json:"externalInfoUpdatedAt"`
|
||||
CreatedAt time.Time `structs:"created_at" json:"createdAt"`
|
||||
UpdatedAt time.Time `structs:"updated_at" json:"updatedAt"`
|
||||
ID string `structs:"id" json:"id"`
|
||||
LibraryID int `structs:"library_id" json:"libraryId"`
|
||||
Name string `structs:"name" json:"name"`
|
||||
EmbedArtPath string `structs:"embed_art_path" json:"-"`
|
||||
AlbumArtistID string `structs:"album_artist_id" json:"albumArtistId"` // Deprecated, use Participants
|
||||
// BFR Rename to AlbumArtistDisplayName
|
||||
AlbumArtist string `structs:"album_artist" json:"albumArtist"`
|
||||
MaxYear int `structs:"max_year" json:"maxYear"`
|
||||
MinYear int `structs:"min_year" json:"minYear"`
|
||||
Date string `structs:"date" json:"date,omitempty"`
|
||||
MaxOriginalYear int `structs:"max_original_year" json:"maxOriginalYear"`
|
||||
MinOriginalYear int `structs:"min_original_year" json:"minOriginalYear"`
|
||||
OriginalDate string `structs:"original_date" json:"originalDate,omitempty"`
|
||||
ReleaseDate string `structs:"release_date" json:"releaseDate,omitempty"`
|
||||
Compilation bool `structs:"compilation" json:"compilation"`
|
||||
Comment string `structs:"comment" json:"comment,omitempty"`
|
||||
SongCount int `structs:"song_count" json:"songCount"`
|
||||
Duration float32 `structs:"duration" json:"duration"`
|
||||
Size int64 `structs:"size" json:"size"`
|
||||
Discs Discs `structs:"discs" json:"discs,omitempty"`
|
||||
SortAlbumName string `structs:"sort_album_name" json:"sortAlbumName,omitempty"`
|
||||
SortAlbumArtistName string `structs:"sort_album_artist_name" json:"sortAlbumArtistName,omitempty"`
|
||||
OrderAlbumName string `structs:"order_album_name" json:"orderAlbumName"`
|
||||
OrderAlbumArtistName string `structs:"order_album_artist_name" json:"orderAlbumArtistName"`
|
||||
CatalogNum string `structs:"catalog_num" json:"catalogNum,omitempty"`
|
||||
MbzAlbumID string `structs:"mbz_album_id" json:"mbzAlbumId,omitempty"`
|
||||
MbzAlbumArtistID string `structs:"mbz_album_artist_id" json:"mbzAlbumArtistId,omitempty"`
|
||||
MbzAlbumType string `structs:"mbz_album_type" json:"mbzAlbumType,omitempty"`
|
||||
MbzAlbumComment string `structs:"mbz_album_comment" json:"mbzAlbumComment,omitempty"`
|
||||
MbzReleaseGroupID string `structs:"mbz_release_group_id" json:"mbzReleaseGroupId,omitempty"`
|
||||
FolderIDs []string `structs:"folder_ids" json:"-" hash:"set"` // All folders that contain media_files for this album
|
||||
ExplicitStatus string `structs:"explicit_status" json:"explicitStatus"`
|
||||
|
||||
// External metadata fields
|
||||
Description string `structs:"description" json:"description,omitempty" hash:"ignore"`
|
||||
SmallImageUrl string `structs:"small_image_url" json:"smallImageUrl,omitempty" hash:"ignore"`
|
||||
MediumImageUrl string `structs:"medium_image_url" json:"mediumImageUrl,omitempty" hash:"ignore"`
|
||||
LargeImageUrl string `structs:"large_image_url" json:"largeImageUrl,omitempty" hash:"ignore"`
|
||||
ExternalUrl string `structs:"external_url" json:"externalUrl,omitempty" hash:"ignore"`
|
||||
ExternalInfoUpdatedAt *time.Time `structs:"external_info_updated_at" json:"externalInfoUpdatedAt" hash:"ignore"`
|
||||
|
||||
Genre string `structs:"genre" json:"genre" hash:"ignore"` // Easy access to the most common genre
|
||||
Genres Genres `structs:"-" json:"genres" hash:"ignore"` // Easy access to all genres for this album
|
||||
Tags Tags `structs:"tags" json:"tags,omitempty" hash:"ignore"` // All imported tags for this album
|
||||
Participants Participants `structs:"participants" json:"participants" hash:"ignore"` // All artists that participated in this album
|
||||
|
||||
Missing bool `structs:"missing" json:"missing"` // If all file of the album ar missing
|
||||
ImportedAt time.Time `structs:"imported_at" json:"importedAt" hash:"ignore"` // When this album was imported/updated
|
||||
CreatedAt time.Time `structs:"created_at" json:"createdAt"` // Oldest CreatedAt for all songs in this album
|
||||
UpdatedAt time.Time `structs:"updated_at" json:"updatedAt"` // Newest UpdatedAt for all songs in this album
|
||||
}
|
||||
|
||||
func (a Album) CoverArtID() ArtworkID {
|
||||
return artworkIDFromAlbum(a)
|
||||
}
|
||||
|
||||
// Equals compares two Album structs, ignoring calculated fields
|
||||
func (a Album) Equals(other Album) bool {
|
||||
// Normalize float32 values to avoid false negatives
|
||||
a.Duration = float32(math.Floor(float64(a.Duration)))
|
||||
other.Duration = float32(math.Floor(float64(other.Duration)))
|
||||
|
||||
opts := &hashstructure.HashOptions{
|
||||
IgnoreZeroValue: true,
|
||||
ZeroNil: true,
|
||||
}
|
||||
hash1, _ := hashstructure.Hash(a, opts)
|
||||
hash2, _ := hashstructure.Hash(other, opts)
|
||||
|
||||
return hash1 == hash2
|
||||
}
|
||||
|
||||
// AlbumLevelTags contains all Tags marked as `album: true` in the mappings.yml file. They are not
|
||||
// "first-class citizens" in the Album struct, but are still stored in the album table, in the `tags` column.
|
||||
var AlbumLevelTags = sync.OnceValue(func() map[TagName]struct{} {
|
||||
tags := make(map[TagName]struct{})
|
||||
m := TagMappings()
|
||||
for t, conf := range m {
|
||||
if conf.Album {
|
||||
tags[t] = struct{}{}
|
||||
}
|
||||
}
|
||||
return tags
|
||||
})
|
||||
|
||||
func (a *Album) SetTags(tags TagList) {
|
||||
a.Tags = tags.GroupByFrequency()
|
||||
for k := range a.Tags {
|
||||
if _, ok := AlbumLevelTags()[k]; !ok {
|
||||
delete(a.Tags, k)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Discs map[int]string
|
||||
|
||||
// Add adds a disc to the Discs map. If the map is nil, it is initialized.
|
||||
func (d *Discs) Add(discNumber int, discSubtitle string) {
|
||||
if *d == nil {
|
||||
*d = Discs{}
|
||||
}
|
||||
(*d)[discNumber] = discSubtitle
|
||||
func (d Discs) Add(discNumber int, discSubtitle string) {
|
||||
d[discNumber] = discSubtitle
|
||||
}
|
||||
|
||||
type DiscID struct {
|
||||
|
|
@ -80,36 +120,23 @@ type DiscID struct {
|
|||
|
||||
type Albums []Album
|
||||
|
||||
// ToAlbumArtist creates an Artist object based on the attributes of this Albums collection.
|
||||
// It assumes all albums have the same AlbumArtist, or else results are unpredictable.
|
||||
func (als Albums) ToAlbumArtist() Artist {
|
||||
a := Artist{AlbumCount: len(als)}
|
||||
mbzArtistIds := make([]string, 0, len(als))
|
||||
for _, al := range als {
|
||||
a.ID = al.AlbumArtistID
|
||||
a.Name = al.AlbumArtist
|
||||
a.SortArtistName = al.SortAlbumArtistName
|
||||
a.OrderArtistName = al.OrderAlbumArtistName
|
||||
|
||||
a.SongCount += al.SongCount
|
||||
a.Size += al.Size
|
||||
a.Genres = append(a.Genres, al.Genres...)
|
||||
mbzArtistIds = append(mbzArtistIds, al.MbzAlbumArtistID)
|
||||
}
|
||||
slices.SortFunc(a.Genres, func(a, b Genre) int { return cmp.Compare(a.ID, b.ID) })
|
||||
a.Genres = slices.Compact(a.Genres)
|
||||
a.MbzArtistID = slice.MostFrequent(mbzArtistIds)
|
||||
|
||||
return a
|
||||
}
|
||||
type AlbumCursor iter.Seq2[Album, error]
|
||||
|
||||
type AlbumRepository interface {
|
||||
CountAll(...QueryOptions) (int64, error)
|
||||
Exists(id string) (bool, error)
|
||||
Put(*Album) error
|
||||
UpdateExternalInfo(*Album) error
|
||||
Get(id string) (*Album, error)
|
||||
GetAll(...QueryOptions) (Albums, error)
|
||||
GetAllWithoutGenres(...QueryOptions) (Albums, error)
|
||||
Search(q string, offset int, size int) (Albums, error)
|
||||
|
||||
// The following methods are used exclusively by the scanner:
|
||||
Touch(ids ...string) error
|
||||
TouchByMissingFolder() (int64, error)
|
||||
GetTouchedAlbums(libID int) (AlbumCursor, error)
|
||||
RefreshPlayCounts() (int64, error)
|
||||
CopyAttributes(fromID, toID string, columns ...string) error
|
||||
|
||||
AnnotatedRepository
|
||||
SearchableRepository[Albums]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
package model_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
|
||||
. "github.com/navidrome/navidrome/model"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
|
|
@ -9,79 +11,22 @@ import (
|
|||
var _ = Describe("Albums", func() {
|
||||
var albums Albums
|
||||
|
||||
Context("Simple attributes", func() {
|
||||
BeforeEach(func() {
|
||||
albums = Albums{
|
||||
{ID: "1", AlbumArtist: "Artist", AlbumArtistID: "11", SortAlbumArtistName: "SortAlbumArtistName", OrderAlbumArtistName: "OrderAlbumArtistName"},
|
||||
{ID: "2", AlbumArtist: "Artist", AlbumArtistID: "11", SortAlbumArtistName: "SortAlbumArtistName", OrderAlbumArtistName: "OrderAlbumArtistName"},
|
||||
}
|
||||
})
|
||||
|
||||
It("sets the single values correctly", func() {
|
||||
artist := albums.ToAlbumArtist()
|
||||
Expect(artist.ID).To(Equal("11"))
|
||||
Expect(artist.Name).To(Equal("Artist"))
|
||||
Expect(artist.SortArtistName).To(Equal("SortAlbumArtistName"))
|
||||
Expect(artist.OrderArtistName).To(Equal("OrderAlbumArtistName"))
|
||||
})
|
||||
})
|
||||
|
||||
Context("Aggregated attributes", func() {
|
||||
When("we have multiple songs", func() {
|
||||
Context("JSON Marshalling", func() {
|
||||
When("we have a valid Albums object", func() {
|
||||
BeforeEach(func() {
|
||||
albums = Albums{
|
||||
{ID: "1", SongCount: 4, Size: 1024},
|
||||
{ID: "2", SongCount: 6, Size: 2048},
|
||||
{ID: "1", AlbumArtist: "Artist", AlbumArtistID: "11", SortAlbumArtistName: "SortAlbumArtistName", OrderAlbumArtistName: "OrderAlbumArtistName"},
|
||||
{ID: "2", AlbumArtist: "Artist", AlbumArtistID: "11", SortAlbumArtistName: "SortAlbumArtistName", OrderAlbumArtistName: "OrderAlbumArtistName"},
|
||||
}
|
||||
})
|
||||
It("calculates the aggregates correctly", func() {
|
||||
artist := albums.ToAlbumArtist()
|
||||
Expect(artist.AlbumCount).To(Equal(2))
|
||||
Expect(artist.SongCount).To(Equal(10))
|
||||
Expect(artist.Size).To(Equal(int64(3072)))
|
||||
})
|
||||
})
|
||||
})
|
||||
It("marshals correctly", func() {
|
||||
data, err := json.Marshal(albums)
|
||||
Expect(err).To(BeNil())
|
||||
|
||||
Context("Calculated attributes", func() {
|
||||
Context("Genres", func() {
|
||||
When("we have only one Genre", func() {
|
||||
BeforeEach(func() {
|
||||
albums = Albums{{Genres: Genres{{ID: "g1", Name: "Rock"}}}}
|
||||
})
|
||||
It("sets the correct Genre", func() {
|
||||
artist := albums.ToAlbumArtist()
|
||||
Expect(artist.Genres).To(ConsistOf(Genre{ID: "g1", Name: "Rock"}))
|
||||
})
|
||||
})
|
||||
When("we have multiple Genres", func() {
|
||||
BeforeEach(func() {
|
||||
albums = Albums{{Genres: Genres{{ID: "g1", Name: "Rock"}, {ID: "g2", Name: "Punk"}, {ID: "g3", Name: "Alternative"}, {ID: "g2", Name: "Punk"}}}}
|
||||
})
|
||||
It("sets the correct Genres", func() {
|
||||
artist := albums.ToAlbumArtist()
|
||||
Expect(artist.Genres).To(Equal(Genres{{ID: "g1", Name: "Rock"}, {ID: "g2", Name: "Punk"}, {ID: "g3", Name: "Alternative"}}))
|
||||
})
|
||||
})
|
||||
})
|
||||
Context("MbzArtistID", func() {
|
||||
When("we have only one MbzArtistID", func() {
|
||||
BeforeEach(func() {
|
||||
albums = Albums{{MbzAlbumArtistID: "id1"}}
|
||||
})
|
||||
It("sets the correct MbzArtistID", func() {
|
||||
artist := albums.ToAlbumArtist()
|
||||
Expect(artist.MbzArtistID).To(Equal("id1"))
|
||||
})
|
||||
})
|
||||
When("we have multiple MbzArtistID", func() {
|
||||
BeforeEach(func() {
|
||||
albums = Albums{{MbzAlbumArtistID: "id1"}, {MbzAlbumArtistID: "id2"}, {MbzAlbumArtistID: "id1"}}
|
||||
})
|
||||
It("sets the correct MbzArtistID", func() {
|
||||
artist := albums.ToAlbumArtist()
|
||||
Expect(artist.MbzArtistID).To(Equal("id1"))
|
||||
})
|
||||
var albums2 Albums
|
||||
err = json.Unmarshal(data, &albums2)
|
||||
Expect(err).To(BeNil())
|
||||
Expect(albums2).To(Equal(albums))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
|
|||
|
|
@ -3,15 +3,16 @@ package model
|
|||
import "time"
|
||||
|
||||
type Annotations struct {
|
||||
PlayCount int64 `structs:"play_count" json:"playCount"`
|
||||
PlayDate *time.Time `structs:"play_date" json:"playDate" `
|
||||
Rating int `structs:"rating" json:"rating" `
|
||||
Starred bool `structs:"starred" json:"starred" `
|
||||
StarredAt *time.Time `structs:"starred_at" json:"starredAt"`
|
||||
PlayCount int64 `structs:"play_count" json:"playCount,omitempty"`
|
||||
PlayDate *time.Time `structs:"play_date" json:"playDate,omitempty" `
|
||||
Rating int `structs:"rating" json:"rating,omitempty" `
|
||||
Starred bool `structs:"starred" json:"starred,omitempty" `
|
||||
StarredAt *time.Time `structs:"starred_at" json:"starredAt,omitempty"`
|
||||
}
|
||||
|
||||
type AnnotatedRepository interface {
|
||||
IncPlayCount(itemID string, ts time.Time) error
|
||||
SetStar(starred bool, itemIDs ...string) error
|
||||
SetRating(rating int, itemID string) error
|
||||
ReassignAnnotation(prevID string, newID string) error
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,27 +1,45 @@
|
|||
package model
|
||||
|
||||
import "time"
|
||||
import (
|
||||
"maps"
|
||||
"slices"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Artist struct {
|
||||
Annotations `structs:"-"`
|
||||
|
||||
ID string `structs:"id" json:"id"`
|
||||
Name string `structs:"name" json:"name"`
|
||||
AlbumCount int `structs:"album_count" json:"albumCount"`
|
||||
SongCount int `structs:"song_count" json:"songCount"`
|
||||
Genres Genres `structs:"-" json:"genres"`
|
||||
FullText string `structs:"full_text" json:"-"`
|
||||
SortArtistName string `structs:"sort_artist_name" json:"sortArtistName,omitempty"`
|
||||
OrderArtistName string `structs:"order_artist_name" json:"orderArtistName"`
|
||||
Size int64 `structs:"size" json:"size"`
|
||||
MbzArtistID string `structs:"mbz_artist_id" json:"mbzArtistId,omitempty"`
|
||||
ID string `structs:"id" json:"id"`
|
||||
|
||||
// Data based on tags
|
||||
Name string `structs:"name" json:"name"`
|
||||
SortArtistName string `structs:"sort_artist_name" json:"sortArtistName,omitempty"`
|
||||
OrderArtistName string `structs:"order_artist_name" json:"orderArtistName,omitempty"`
|
||||
MbzArtistID string `structs:"mbz_artist_id" json:"mbzArtistId,omitempty"`
|
||||
|
||||
// Data calculated from files
|
||||
Stats map[Role]ArtistStats `structs:"-" json:"stats,omitempty"`
|
||||
Size int64 `structs:"-" json:"size,omitempty"`
|
||||
AlbumCount int `structs:"-" json:"albumCount,omitempty"`
|
||||
SongCount int `structs:"-" json:"songCount,omitempty"`
|
||||
|
||||
// Data imported from external sources
|
||||
Biography string `structs:"biography" json:"biography,omitempty"`
|
||||
SmallImageUrl string `structs:"small_image_url" json:"smallImageUrl,omitempty"`
|
||||
MediumImageUrl string `structs:"medium_image_url" json:"mediumImageUrl,omitempty"`
|
||||
LargeImageUrl string `structs:"large_image_url" json:"largeImageUrl,omitempty"`
|
||||
ExternalUrl string `structs:"external_url" json:"externalUrl,omitempty"`
|
||||
SimilarArtists Artists `structs:"similar_artists" json:"-"`
|
||||
ExternalInfoUpdatedAt *time.Time `structs:"external_info_updated_at" json:"externalInfoUpdatedAt"`
|
||||
ExternalInfoUpdatedAt *time.Time `structs:"external_info_updated_at" json:"externalInfoUpdatedAt,omitempty"`
|
||||
|
||||
CreatedAt *time.Time `structs:"created_at" json:"createdAt,omitempty"`
|
||||
UpdatedAt *time.Time `structs:"updated_at" json:"updatedAt,omitempty"`
|
||||
}
|
||||
|
||||
type ArtistStats struct {
|
||||
SongCount int `json:"songCount"`
|
||||
AlbumCount int `json:"albumCount"`
|
||||
Size int64 `json:"size"`
|
||||
}
|
||||
|
||||
func (a Artist) ArtistImageUrl() string {
|
||||
|
|
@ -38,6 +56,11 @@ func (a Artist) CoverArtID() ArtworkID {
|
|||
return artworkIDFromArtist(a)
|
||||
}
|
||||
|
||||
// Roles returns the roles this artist has participated in., based on the Stats field
|
||||
func (a Artist) Roles() []Role {
|
||||
return slices.Collect(maps.Keys(a.Stats))
|
||||
}
|
||||
|
||||
type Artists []Artist
|
||||
|
||||
type ArtistIndex struct {
|
||||
|
|
@ -50,9 +73,15 @@ type ArtistRepository interface {
|
|||
CountAll(options ...QueryOptions) (int64, error)
|
||||
Exists(id string) (bool, error)
|
||||
Put(m *Artist, colsToUpdate ...string) error
|
||||
UpdateExternalInfo(a *Artist) error
|
||||
Get(id string) (*Artist, error)
|
||||
GetAll(options ...QueryOptions) (Artists, error)
|
||||
Search(q string, offset int, size int) (Artists, error)
|
||||
GetIndex() (ArtistIndexes, error)
|
||||
GetIndex(roles ...Role) (ArtistIndexes, error)
|
||||
|
||||
// The following methods are used exclusively by the scanner:
|
||||
RefreshPlayCounts() (int64, error)
|
||||
RefreshStats() (int64, error)
|
||||
|
||||
AnnotatedRepository
|
||||
SearchableRepository[Artists]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,16 +24,21 @@ func (c Criteria) OrderBy() string {
|
|||
if c.Sort == "" {
|
||||
c.Sort = "title"
|
||||
}
|
||||
f := fieldMap[strings.ToLower(c.Sort)]
|
||||
sortField := strings.ToLower(c.Sort)
|
||||
f := fieldMap[sortField]
|
||||
var mapped string
|
||||
if f == nil {
|
||||
log.Error("Invalid field in 'sort' field. Using 'title'", "sort", c.Sort)
|
||||
mapped = fieldMap["title"].field
|
||||
} else {
|
||||
if f.order == "" {
|
||||
mapped = f.field
|
||||
} else {
|
||||
if f.order != "" {
|
||||
mapped = f.order
|
||||
} else if f.isTag {
|
||||
mapped = "COALESCE(json_extract(media_file.tags, '$." + sortField + "[0].value'), '')"
|
||||
} else if f.isRole {
|
||||
mapped = "COALESCE(json_extract(media_file.participants, '$." + sortField + "[0].name'), '')"
|
||||
} else {
|
||||
mapped = f.field
|
||||
}
|
||||
}
|
||||
if c.Order != "" {
|
||||
|
|
@ -46,23 +51,20 @@ func (c Criteria) OrderBy() string {
|
|||
return mapped
|
||||
}
|
||||
|
||||
func (c Criteria) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (c Criteria) ToSql() (sql string, args []any, err error) {
|
||||
return c.Expression.ToSql()
|
||||
}
|
||||
|
||||
func (c Criteria) ChildPlaylistIds() (ids []string) {
|
||||
func (c Criteria) ChildPlaylistIds() []string {
|
||||
if c.Expression == nil {
|
||||
return ids
|
||||
return nil
|
||||
}
|
||||
|
||||
switch rules := c.Expression.(type) {
|
||||
case Any:
|
||||
ids = rules.ChildPlaylistIds()
|
||||
case All:
|
||||
ids = rules.ChildPlaylistIds()
|
||||
if parent := c.Expression.(interface{ ChildPlaylistIds() (ids []string) }); parent != nil {
|
||||
return parent.ChildPlaylistIds()
|
||||
}
|
||||
|
||||
return ids
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c Criteria) MarshalJSON() ([]byte, error) {
|
||||
|
|
|
|||
|
|
@ -12,5 +12,6 @@ import (
|
|||
func TestCriteria(t *testing.T) {
|
||||
log.SetLevel(log.LevelFatal)
|
||||
gomega.RegisterFailHandler(Fail)
|
||||
// Register `genre` as a tag name, so we can use it in tests
|
||||
RunSpecs(t, "Criteria Suite")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,28 +12,30 @@ import (
|
|||
var _ = Describe("Criteria", func() {
|
||||
var goObj Criteria
|
||||
var jsonObj string
|
||||
BeforeEach(func() {
|
||||
goObj = Criteria{
|
||||
Expression: All{
|
||||
Contains{"title": "love"},
|
||||
NotContains{"title": "hate"},
|
||||
Any{
|
||||
IsNot{"artist": "u2"},
|
||||
Is{"album": "best of"},
|
||||
|
||||
Context("with a complex criteria", func() {
|
||||
BeforeEach(func() {
|
||||
goObj = Criteria{
|
||||
Expression: All{
|
||||
Contains{"title": "love"},
|
||||
NotContains{"title": "hate"},
|
||||
Any{
|
||||
IsNot{"artist": "u2"},
|
||||
Is{"album": "best of"},
|
||||
},
|
||||
All{
|
||||
StartsWith{"comment": "this"},
|
||||
InTheRange{"year": []int{1980, 1990}},
|
||||
IsNot{"genre": "Rock"},
|
||||
},
|
||||
},
|
||||
All{
|
||||
StartsWith{"comment": "this"},
|
||||
InTheRange{"year": []int{1980, 1990}},
|
||||
IsNot{"genre": "test"},
|
||||
},
|
||||
},
|
||||
Sort: "title",
|
||||
Order: "asc",
|
||||
Limit: 20,
|
||||
Offset: 10,
|
||||
}
|
||||
var b bytes.Buffer
|
||||
err := json.Compact(&b, []byte(`
|
||||
Sort: "title",
|
||||
Order: "asc",
|
||||
Limit: 20,
|
||||
Offset: 10,
|
||||
}
|
||||
var b bytes.Buffer
|
||||
err := json.Compact(&b, []byte(`
|
||||
{
|
||||
"all": [
|
||||
{ "contains": {"title": "love"} },
|
||||
|
|
@ -46,7 +48,7 @@ var _ = Describe("Criteria", func() {
|
|||
{ "all": [
|
||||
{ "startsWith": {"comment": "this"} },
|
||||
{ "inTheRange": {"year":[1980,1990]} },
|
||||
{ "isNot": { "genre": "test" }}
|
||||
{ "isNot": { "genre": "Rock" }}
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
@ -56,128 +58,150 @@ var _ = Describe("Criteria", func() {
|
|||
"offset": 10
|
||||
}
|
||||
`))
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
jsonObj = b.String()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
jsonObj = b.String()
|
||||
})
|
||||
It("generates valid SQL", func() {
|
||||
sql, args, err := goObj.ToSql()
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(sql).To(gomega.Equal(
|
||||
`(media_file.title LIKE ? AND media_file.title NOT LIKE ? ` +
|
||||
`AND (not exists (select 1 from json_tree(participants, '$.artist') where key='name' and value = ?) ` +
|
||||
`OR media_file.album = ?) AND (media_file.comment LIKE ? AND (media_file.year >= ? AND media_file.year <= ?) ` +
|
||||
`AND not exists (select 1 from json_tree(tags, '$.genre') where key='value' and value = ?)))`))
|
||||
gomega.Expect(args).To(gomega.HaveExactElements("%love%", "%hate%", "u2", "best of", "this%", 1980, 1990, "Rock"))
|
||||
})
|
||||
It("marshals to JSON", func() {
|
||||
j, err := json.Marshal(goObj)
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(string(j)).To(gomega.Equal(jsonObj))
|
||||
})
|
||||
It("is reversible to/from JSON", func() {
|
||||
var newObj Criteria
|
||||
err := json.Unmarshal([]byte(jsonObj), &newObj)
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
j, err := json.Marshal(newObj)
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(string(j)).To(gomega.Equal(jsonObj))
|
||||
})
|
||||
Describe("OrderBy", func() {
|
||||
It("sorts by regular fields", func() {
|
||||
gomega.Expect(goObj.OrderBy()).To(gomega.Equal("media_file.title asc"))
|
||||
})
|
||||
|
||||
It("sorts by tag fields", func() {
|
||||
goObj.Sort = "genre"
|
||||
gomega.Expect(goObj.OrderBy()).To(
|
||||
gomega.Equal(
|
||||
"COALESCE(json_extract(media_file.tags, '$.genre[0].value'), '') asc",
|
||||
),
|
||||
)
|
||||
})
|
||||
|
||||
It("sorts by role fields", func() {
|
||||
goObj.Sort = "artist"
|
||||
gomega.Expect(goObj.OrderBy()).To(
|
||||
gomega.Equal(
|
||||
"COALESCE(json_extract(media_file.participants, '$.artist[0].name'), '') asc",
|
||||
),
|
||||
)
|
||||
})
|
||||
|
||||
It("sorts by random", func() {
|
||||
newObj := goObj
|
||||
newObj.Sort = "random"
|
||||
gomega.Expect(newObj.OrderBy()).To(gomega.Equal("random() asc"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
It("generates valid SQL", func() {
|
||||
sql, args, err := goObj.ToSql()
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(sql).To(gomega.Equal("(media_file.title LIKE ? AND media_file.title NOT LIKE ? AND (media_file.artist <> ? OR media_file.album = ?) AND (media_file.comment LIKE ? AND (media_file.year >= ? AND media_file.year <= ?) AND COALESCE(genre.name, '') <> ?))"))
|
||||
gomega.Expect(args).To(gomega.HaveExactElements("%love%", "%hate%", "u2", "best of", "this%", 1980, 1990, "test"))
|
||||
})
|
||||
|
||||
It("marshals to JSON", func() {
|
||||
j, err := json.Marshal(goObj)
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(string(j)).To(gomega.Equal(jsonObj))
|
||||
})
|
||||
|
||||
It("is reversible to/from JSON", func() {
|
||||
var newObj Criteria
|
||||
err := json.Unmarshal([]byte(jsonObj), &newObj)
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
j, err := json.Marshal(newObj)
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(string(j)).To(gomega.Equal(jsonObj))
|
||||
})
|
||||
|
||||
It("allows sort by random", func() {
|
||||
newObj := goObj
|
||||
newObj.Sort = "random"
|
||||
gomega.Expect(newObj.OrderBy()).To(gomega.Equal("random() asc"))
|
||||
})
|
||||
|
||||
It("extracts all child smart playlist IDs from All expression criteria", func() {
|
||||
topLevelInPlaylistID := uuid.NewString()
|
||||
topLevelNotInPlaylistID := uuid.NewString()
|
||||
|
||||
nestedAnyInPlaylistID := uuid.NewString()
|
||||
nestedAnyNotInPlaylistID := uuid.NewString()
|
||||
|
||||
nestedAllInPlaylistID := uuid.NewString()
|
||||
nestedAllNotInPlaylistID := uuid.NewString()
|
||||
|
||||
goObj := Criteria{
|
||||
Expression: All{
|
||||
InPlaylist{"id": topLevelInPlaylistID},
|
||||
NotInPlaylist{"id": topLevelNotInPlaylistID},
|
||||
Any{
|
||||
InPlaylist{"id": nestedAnyInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAnyNotInPlaylistID},
|
||||
Context("with artist roles", func() {
|
||||
BeforeEach(func() {
|
||||
goObj = Criteria{
|
||||
Expression: All{
|
||||
Is{"artist": "The Beatles"},
|
||||
Contains{"composer": "Lennon"},
|
||||
},
|
||||
All{
|
||||
InPlaylist{"id": nestedAllInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAllNotInPlaylistID},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
ids := goObj.ChildPlaylistIds()
|
||||
|
||||
gomega.Expect(ids).To(gomega.ConsistOf(topLevelInPlaylistID, topLevelNotInPlaylistID, nestedAnyInPlaylistID, nestedAnyNotInPlaylistID, nestedAllInPlaylistID, nestedAllNotInPlaylistID))
|
||||
It("generates valid SQL", func() {
|
||||
sql, args, err := goObj.ToSql()
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(sql).To(gomega.Equal(
|
||||
`(exists (select 1 from json_tree(participants, '$.artist') where key='name' and value = ?) AND ` +
|
||||
`exists (select 1 from json_tree(participants, '$.composer') where key='name' and value LIKE ?))`,
|
||||
))
|
||||
gomega.Expect(args).To(gomega.HaveExactElements("The Beatles", "%Lennon%"))
|
||||
})
|
||||
})
|
||||
|
||||
It("extracts all child smart playlist IDs from Any expression criteria", func() {
|
||||
topLevelInPlaylistID := uuid.NewString()
|
||||
topLevelNotInPlaylistID := uuid.NewString()
|
||||
Context("with child playlists", func() {
|
||||
var (
|
||||
topLevelInPlaylistID string
|
||||
topLevelNotInPlaylistID string
|
||||
nestedAnyInPlaylistID string
|
||||
nestedAnyNotInPlaylistID string
|
||||
nestedAllInPlaylistID string
|
||||
nestedAllNotInPlaylistID string
|
||||
)
|
||||
BeforeEach(func() {
|
||||
topLevelInPlaylistID = uuid.NewString()
|
||||
topLevelNotInPlaylistID = uuid.NewString()
|
||||
|
||||
nestedAnyInPlaylistID := uuid.NewString()
|
||||
nestedAnyNotInPlaylistID := uuid.NewString()
|
||||
nestedAnyInPlaylistID = uuid.NewString()
|
||||
nestedAnyNotInPlaylistID = uuid.NewString()
|
||||
|
||||
nestedAllInPlaylistID := uuid.NewString()
|
||||
nestedAllNotInPlaylistID := uuid.NewString()
|
||||
nestedAllInPlaylistID = uuid.NewString()
|
||||
nestedAllNotInPlaylistID = uuid.NewString()
|
||||
|
||||
goObj := Criteria{
|
||||
Expression: Any{
|
||||
InPlaylist{"id": topLevelInPlaylistID},
|
||||
NotInPlaylist{"id": topLevelNotInPlaylistID},
|
||||
Any{
|
||||
InPlaylist{"id": nestedAnyInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAnyNotInPlaylistID},
|
||||
},
|
||||
All{
|
||||
InPlaylist{"id": nestedAllInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAllNotInPlaylistID},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
ids := goObj.ChildPlaylistIds()
|
||||
|
||||
gomega.Expect(ids).To(gomega.ConsistOf(topLevelInPlaylistID, topLevelNotInPlaylistID, nestedAnyInPlaylistID, nestedAnyNotInPlaylistID, nestedAllInPlaylistID, nestedAllNotInPlaylistID))
|
||||
})
|
||||
|
||||
It("extracts child smart playlist IDs from deeply nested expression", func() {
|
||||
nestedAnyInPlaylistID := uuid.NewString()
|
||||
nestedAnyNotInPlaylistID := uuid.NewString()
|
||||
|
||||
nestedAllInPlaylistID := uuid.NewString()
|
||||
nestedAllNotInPlaylistID := uuid.NewString()
|
||||
|
||||
goObj := Criteria{
|
||||
Expression: Any{
|
||||
Any{
|
||||
goObj = Criteria{
|
||||
Expression: All{
|
||||
InPlaylist{"id": topLevelInPlaylistID},
|
||||
NotInPlaylist{"id": topLevelNotInPlaylistID},
|
||||
Any{
|
||||
InPlaylist{"id": nestedAnyInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAnyNotInPlaylistID},
|
||||
},
|
||||
All{
|
||||
Any{
|
||||
InPlaylist{"id": nestedAnyInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAnyNotInPlaylistID},
|
||||
InPlaylist{"id": nestedAllInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAllNotInPlaylistID},
|
||||
},
|
||||
},
|
||||
}
|
||||
})
|
||||
It("extracts all child smart playlist IDs from expression criteria", func() {
|
||||
ids := goObj.ChildPlaylistIds()
|
||||
gomega.Expect(ids).To(gomega.ConsistOf(topLevelInPlaylistID, topLevelNotInPlaylistID, nestedAnyInPlaylistID, nestedAnyNotInPlaylistID, nestedAllInPlaylistID, nestedAllNotInPlaylistID))
|
||||
})
|
||||
It("extracts child smart playlist IDs from deeply nested expression", func() {
|
||||
goObj = Criteria{
|
||||
Expression: Any{
|
||||
Any{
|
||||
All{
|
||||
Any{
|
||||
All{
|
||||
InPlaylist{"id": nestedAllInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAllNotInPlaylistID},
|
||||
InPlaylist{"id": nestedAnyInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAnyNotInPlaylistID},
|
||||
Any{
|
||||
All{
|
||||
InPlaylist{"id": nestedAllInPlaylistID},
|
||||
NotInPlaylist{"id": nestedAllNotInPlaylistID},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
ids := goObj.ChildPlaylistIds()
|
||||
|
||||
gomega.Expect(ids).To(gomega.ConsistOf(nestedAnyInPlaylistID, nestedAnyNotInPlaylistID, nestedAllInPlaylistID, nestedAllNotInPlaylistID))
|
||||
ids := goObj.ChildPlaylistIds()
|
||||
gomega.Expect(ids).To(gomega.ConsistOf(nestedAnyInPlaylistID, nestedAnyNotInPlaylistID, nestedAllInPlaylistID, nestedAllNotInPlaylistID))
|
||||
})
|
||||
It("returns empty list when no child playlist IDs are present", func() {
|
||||
ids := Criteria{}.ChildPlaylistIds()
|
||||
gomega.Expect(ids).To(gomega.BeEmpty())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
|
|||
5
model/criteria/export_test.go
Normal file
5
model/criteria/export_test.go
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
package criteria
|
||||
|
||||
var StartOfPeriod = startOfPeriod
|
||||
|
||||
type UnmarshalConjunctionType = unmarshalConjunctionType
|
||||
|
|
@ -1,21 +1,22 @@
|
|||
package criteria
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
|
||||
"github.com/Masterminds/squirrel"
|
||||
"github.com/navidrome/navidrome/log"
|
||||
)
|
||||
|
||||
var fieldMap = map[string]*mappedField{
|
||||
"title": {field: "media_file.title"},
|
||||
"album": {field: "media_file.album"},
|
||||
"artist": {field: "media_file.artist"},
|
||||
"albumartist": {field: "media_file.album_artist"},
|
||||
"hascoverart": {field: "media_file.has_cover_art"},
|
||||
"tracknumber": {field: "media_file.track_number"},
|
||||
"discnumber": {field: "media_file.disc_number"},
|
||||
"year": {field: "media_file.year"},
|
||||
"date": {field: "media_file.date"},
|
||||
"date": {field: "media_file.date", alias: "recordingdate"},
|
||||
"originalyear": {field: "media_file.original_year"},
|
||||
"originaldate": {field: "media_file.original_date"},
|
||||
"releaseyear": {field: "media_file.release_year"},
|
||||
|
|
@ -31,31 +32,37 @@ var fieldMap = map[string]*mappedField{
|
|||
"sortalbum": {field: "media_file.sort_album_name"},
|
||||
"sortartist": {field: "media_file.sort_artist_name"},
|
||||
"sortalbumartist": {field: "media_file.sort_album_artist_name"},
|
||||
"albumtype": {field: "media_file.mbz_album_type"},
|
||||
"albumtype": {field: "media_file.mbz_album_type", alias: "releasetype"},
|
||||
"albumcomment": {field: "media_file.mbz_album_comment"},
|
||||
"catalognumber": {field: "media_file.catalog_num"},
|
||||
"filepath": {field: "media_file.path"},
|
||||
"filetype": {field: "media_file.suffix"},
|
||||
"duration": {field: "media_file.duration"},
|
||||
"bitrate": {field: "media_file.bit_rate"},
|
||||
"bitdepth": {field: "media_file.bit_depth"},
|
||||
"bpm": {field: "media_file.bpm"},
|
||||
"channels": {field: "media_file.channels"},
|
||||
"genre": {field: "COALESCE(genre.name, '')"},
|
||||
"loved": {field: "COALESCE(annotation.starred, false)"},
|
||||
"dateloved": {field: "annotation.starred_at"},
|
||||
"lastplayed": {field: "annotation.play_date"},
|
||||
"playcount": {field: "COALESCE(annotation.play_count, 0)"},
|
||||
"rating": {field: "COALESCE(annotation.rating, 0)"},
|
||||
"random": {field: "", order: "random()"},
|
||||
|
||||
// special fields
|
||||
"random": {field: "", order: "random()"}, // pseudo-field for random sorting
|
||||
"value": {field: "value"}, // pseudo-field for tag and roles values
|
||||
}
|
||||
|
||||
type mappedField struct {
|
||||
field string
|
||||
order string
|
||||
field string
|
||||
order string
|
||||
isRole bool // true if the field is a role (e.g. "artist", "composer", "conductor", etc.)
|
||||
isTag bool // true if the field is a tag imported from the file metadata
|
||||
alias string // name from `mappings.yml` that may differ from the name used in the smart playlist
|
||||
}
|
||||
|
||||
func mapFields(expr map[string]interface{}) map[string]interface{} {
|
||||
m := make(map[string]interface{})
|
||||
func mapFields(expr map[string]any) map[string]any {
|
||||
m := make(map[string]any)
|
||||
for f, v := range expr {
|
||||
if dbf := fieldMap[strings.ToLower(f)]; dbf != nil && dbf.field != "" {
|
||||
m[dbf.field] = v
|
||||
|
|
@ -65,3 +72,136 @@ func mapFields(expr map[string]interface{}) map[string]interface{} {
|
|||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// mapExpr maps a normal field expression to a specific type of expression (tag or role).
|
||||
// This is required because tags are handled differently than other fields,
|
||||
// as they are stored as a JSON column in the database.
|
||||
func mapExpr(expr squirrel.Sqlizer, negate bool, exprFunc func(string, squirrel.Sqlizer, bool) squirrel.Sqlizer) squirrel.Sqlizer {
|
||||
rv := reflect.ValueOf(expr)
|
||||
if rv.Kind() != reflect.Map || rv.Type().Key().Kind() != reflect.String {
|
||||
log.Fatal(fmt.Sprintf("expr is not a map-based operator: %T", expr))
|
||||
}
|
||||
|
||||
// Extract into a generic map
|
||||
var k string
|
||||
m := make(map[string]any, rv.Len())
|
||||
for _, key := range rv.MapKeys() {
|
||||
// Save the key to build the expression, and use the provided keyName as the key
|
||||
k = key.String()
|
||||
m["value"] = rv.MapIndex(key).Interface()
|
||||
break // only one key is expected (and supported)
|
||||
}
|
||||
|
||||
// Clear the original map
|
||||
for _, key := range rv.MapKeys() {
|
||||
rv.SetMapIndex(key, reflect.Value{})
|
||||
}
|
||||
|
||||
// Write the updated map back into the original variable
|
||||
for key, val := range m {
|
||||
rv.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(val))
|
||||
}
|
||||
|
||||
return exprFunc(k, expr, negate)
|
||||
}
|
||||
|
||||
// mapTagExpr maps a normal field expression to a tag expression.
|
||||
func mapTagExpr(expr squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
|
||||
return mapExpr(expr, negate, tagExpr)
|
||||
}
|
||||
|
||||
// mapRoleExpr maps a normal field expression to an artist role expression.
|
||||
func mapRoleExpr(expr squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
|
||||
return mapExpr(expr, negate, roleExpr)
|
||||
}
|
||||
|
||||
func isTagExpr(expr map[string]any) bool {
|
||||
for f := range expr {
|
||||
if f2, ok := fieldMap[strings.ToLower(f)]; ok && f2.isTag {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func isRoleExpr(expr map[string]any) bool {
|
||||
for f := range expr {
|
||||
if f2, ok := fieldMap[strings.ToLower(f)]; ok && f2.isRole {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func tagExpr(tag string, cond squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
|
||||
return tagCond{tag: tag, cond: cond, not: negate}
|
||||
}
|
||||
|
||||
type tagCond struct {
|
||||
tag string
|
||||
cond squirrel.Sqlizer
|
||||
not bool
|
||||
}
|
||||
|
||||
func (e tagCond) ToSql() (string, []any, error) {
|
||||
cond, args, err := e.cond.ToSql()
|
||||
cond = fmt.Sprintf("exists (select 1 from json_tree(tags, '$.%s') where key='value' and %s)",
|
||||
e.tag, cond)
|
||||
if e.not {
|
||||
cond = "not " + cond
|
||||
}
|
||||
return cond, args, err
|
||||
}
|
||||
|
||||
func roleExpr(role string, cond squirrel.Sqlizer, negate bool) squirrel.Sqlizer {
|
||||
return roleCond{role: role, cond: cond, not: negate}
|
||||
}
|
||||
|
||||
type roleCond struct {
|
||||
role string
|
||||
cond squirrel.Sqlizer
|
||||
not bool
|
||||
}
|
||||
|
||||
func (e roleCond) ToSql() (string, []any, error) {
|
||||
cond, args, err := e.cond.ToSql()
|
||||
cond = fmt.Sprintf(`exists (select 1 from json_tree(participants, '$.%s') where key='name' and %s)`,
|
||||
e.role, cond)
|
||||
if e.not {
|
||||
cond = "not " + cond
|
||||
}
|
||||
return cond, args, err
|
||||
}
|
||||
|
||||
// AddRoles adds roles to the field map. This is used to add all artist roles to the field map, so they can be used in
|
||||
// smart playlists. If a role already exists in the field map, it is ignored, so calls to this function are idempotent.
|
||||
func AddRoles(roles []string) {
|
||||
for _, role := range roles {
|
||||
name := strings.ToLower(role)
|
||||
if _, ok := fieldMap[name]; ok {
|
||||
continue
|
||||
}
|
||||
fieldMap[name] = &mappedField{field: name, isRole: true}
|
||||
}
|
||||
}
|
||||
|
||||
// AddTagNames adds tag names to the field map. This is used to add all tags mapped in the `mappings.yml`
|
||||
// file to the field map, so they can be used in smart playlists.
|
||||
// If a tag name already exists in the field map, it is ignored, so calls to this function are idempotent.
|
||||
func AddTagNames(tagNames []string) {
|
||||
for _, name := range tagNames {
|
||||
name := strings.ToLower(name)
|
||||
if _, ok := fieldMap[name]; ok {
|
||||
continue
|
||||
}
|
||||
for _, fm := range fieldMap {
|
||||
if fm.alias == name {
|
||||
fieldMap[name] = fm
|
||||
break
|
||||
}
|
||||
}
|
||||
if _, ok := fieldMap[name]; !ok {
|
||||
fieldMap[name] = &mappedField{field: name, isTag: true}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ import (
|
|||
var _ = Describe("fields", func() {
|
||||
Describe("mapFields", func() {
|
||||
It("ignores random fields", func() {
|
||||
m := map[string]interface{}{"random": "123"}
|
||||
m := map[string]any{"random": "123"}
|
||||
m = mapFields(m)
|
||||
gomega.Expect(m).To(gomega.BeEmpty())
|
||||
})
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ import (
|
|||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type unmarshalConjunctionType []Expression
|
||||
|
|
@ -24,7 +23,7 @@ func (uc *unmarshalConjunctionType) UnmarshalJSON(data []byte) error {
|
|||
expr = unmarshalConjunction(k, v)
|
||||
}
|
||||
if expr == nil {
|
||||
return fmt.Errorf(`invalid expression key %s`, k)
|
||||
return fmt.Errorf(`invalid expression key '%s'`, k)
|
||||
}
|
||||
es = append(es, expr)
|
||||
}
|
||||
|
|
@ -34,7 +33,7 @@ func (uc *unmarshalConjunctionType) UnmarshalJSON(data []byte) error {
|
|||
}
|
||||
|
||||
func unmarshalExpression(opName string, rawValue json.RawMessage) Expression {
|
||||
m := make(map[string]interface{})
|
||||
m := make(map[string]any)
|
||||
err := json.Unmarshal(rawValue, &m)
|
||||
if err != nil {
|
||||
return nil
|
||||
|
|
@ -89,7 +88,7 @@ func unmarshalConjunction(conjName string, rawValue json.RawMessage) Expression
|
|||
return nil
|
||||
}
|
||||
|
||||
func marshalExpression(name string, value map[string]interface{}) ([]byte, error) {
|
||||
func marshalExpression(name string, value map[string]any) ([]byte, error) {
|
||||
if len(value) != 1 {
|
||||
return nil, fmt.Errorf(`invalid %s expression length %d for values %v`, name, len(value), value)
|
||||
}
|
||||
|
|
@ -120,10 +119,3 @@ func marshalConjunction(name string, conj []Expression) ([]byte, error) {
|
|||
}
|
||||
return json.Marshal(aux)
|
||||
}
|
||||
|
||||
type date time.Time
|
||||
|
||||
func (t date) MarshalJSON() ([]byte, error) {
|
||||
stamp := fmt.Sprintf(`"%s"`, time.Time(t).Format("2006-01-02"))
|
||||
return []byte(stamp), nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ type (
|
|||
And = All
|
||||
)
|
||||
|
||||
func (all All) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (all All) ToSql() (sql string, args []any, err error) {
|
||||
return squirrel.And(all).ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -32,7 +32,7 @@ type (
|
|||
Or = Any
|
||||
)
|
||||
|
||||
func (any Any) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (any Any) ToSql() (sql string, args []any, err error) {
|
||||
return squirrel.Or(any).ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -47,7 +47,13 @@ func (any Any) ChildPlaylistIds() (ids []string) {
|
|||
type Is squirrel.Eq
|
||||
type Eq = Is
|
||||
|
||||
func (is Is) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (is Is) ToSql() (sql string, args []any, err error) {
|
||||
if isRoleExpr(is) {
|
||||
return mapRoleExpr(is, false).ToSql()
|
||||
}
|
||||
if isTagExpr(is) {
|
||||
return mapTagExpr(is, false).ToSql()
|
||||
}
|
||||
return squirrel.Eq(mapFields(is)).ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -57,7 +63,13 @@ func (is Is) MarshalJSON() ([]byte, error) {
|
|||
|
||||
type IsNot squirrel.NotEq
|
||||
|
||||
func (in IsNot) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (in IsNot) ToSql() (sql string, args []any, err error) {
|
||||
if isRoleExpr(in) {
|
||||
return mapRoleExpr(squirrel.Eq(in), true).ToSql()
|
||||
}
|
||||
if isTagExpr(in) {
|
||||
return mapTagExpr(squirrel.Eq(in), true).ToSql()
|
||||
}
|
||||
return squirrel.NotEq(mapFields(in)).ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -67,7 +79,10 @@ func (in IsNot) MarshalJSON() ([]byte, error) {
|
|||
|
||||
type Gt squirrel.Gt
|
||||
|
||||
func (gt Gt) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (gt Gt) ToSql() (sql string, args []any, err error) {
|
||||
if isTagExpr(gt) {
|
||||
return mapTagExpr(gt, false).ToSql()
|
||||
}
|
||||
return squirrel.Gt(mapFields(gt)).ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -77,7 +92,10 @@ func (gt Gt) MarshalJSON() ([]byte, error) {
|
|||
|
||||
type Lt squirrel.Lt
|
||||
|
||||
func (lt Lt) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (lt Lt) ToSql() (sql string, args []any, err error) {
|
||||
if isTagExpr(lt) {
|
||||
return mapTagExpr(squirrel.Lt(lt), false).ToSql()
|
||||
}
|
||||
return squirrel.Lt(mapFields(lt)).ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -87,31 +105,37 @@ func (lt Lt) MarshalJSON() ([]byte, error) {
|
|||
|
||||
type Before squirrel.Lt
|
||||
|
||||
func (bf Before) ToSql() (sql string, args []interface{}, err error) {
|
||||
return squirrel.Lt(mapFields(bf)).ToSql()
|
||||
func (bf Before) ToSql() (sql string, args []any, err error) {
|
||||
return Lt(bf).ToSql()
|
||||
}
|
||||
|
||||
func (bf Before) MarshalJSON() ([]byte, error) {
|
||||
return marshalExpression("before", bf)
|
||||
}
|
||||
|
||||
type After squirrel.Gt
|
||||
type After Gt
|
||||
|
||||
func (af After) ToSql() (sql string, args []interface{}, err error) {
|
||||
return squirrel.Gt(mapFields(af)).ToSql()
|
||||
func (af After) ToSql() (sql string, args []any, err error) {
|
||||
return Gt(af).ToSql()
|
||||
}
|
||||
|
||||
func (af After) MarshalJSON() ([]byte, error) {
|
||||
return marshalExpression("after", af)
|
||||
}
|
||||
|
||||
type Contains map[string]interface{}
|
||||
type Contains map[string]any
|
||||
|
||||
func (ct Contains) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (ct Contains) ToSql() (sql string, args []any, err error) {
|
||||
lk := squirrel.Like{}
|
||||
for f, v := range mapFields(ct) {
|
||||
lk[f] = fmt.Sprintf("%%%s%%", v)
|
||||
}
|
||||
if isRoleExpr(ct) {
|
||||
return mapRoleExpr(lk, false).ToSql()
|
||||
}
|
||||
if isTagExpr(ct) {
|
||||
return mapTagExpr(lk, false).ToSql()
|
||||
}
|
||||
return lk.ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -119,13 +143,19 @@ func (ct Contains) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("contains", ct)
|
||||
}
|
||||
|
||||
type NotContains map[string]interface{}
|
||||
type NotContains map[string]any
|
||||
|
||||
func (nct NotContains) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (nct NotContains) ToSql() (sql string, args []any, err error) {
|
||||
lk := squirrel.NotLike{}
|
||||
for f, v := range mapFields(nct) {
|
||||
lk[f] = fmt.Sprintf("%%%s%%", v)
|
||||
}
|
||||
if isRoleExpr(nct) {
|
||||
return mapRoleExpr(squirrel.Like(lk), true).ToSql()
|
||||
}
|
||||
if isTagExpr(nct) {
|
||||
return mapTagExpr(squirrel.Like(lk), true).ToSql()
|
||||
}
|
||||
return lk.ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -133,13 +163,19 @@ func (nct NotContains) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("notContains", nct)
|
||||
}
|
||||
|
||||
type StartsWith map[string]interface{}
|
||||
type StartsWith map[string]any
|
||||
|
||||
func (sw StartsWith) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (sw StartsWith) ToSql() (sql string, args []any, err error) {
|
||||
lk := squirrel.Like{}
|
||||
for f, v := range mapFields(sw) {
|
||||
lk[f] = fmt.Sprintf("%s%%", v)
|
||||
}
|
||||
if isRoleExpr(sw) {
|
||||
return mapRoleExpr(lk, false).ToSql()
|
||||
}
|
||||
if isTagExpr(sw) {
|
||||
return mapTagExpr(lk, false).ToSql()
|
||||
}
|
||||
return lk.ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -147,13 +183,19 @@ func (sw StartsWith) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("startsWith", sw)
|
||||
}
|
||||
|
||||
type EndsWith map[string]interface{}
|
||||
type EndsWith map[string]any
|
||||
|
||||
func (sw EndsWith) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (sw EndsWith) ToSql() (sql string, args []any, err error) {
|
||||
lk := squirrel.Like{}
|
||||
for f, v := range mapFields(sw) {
|
||||
lk[f] = fmt.Sprintf("%%%s", v)
|
||||
}
|
||||
if isRoleExpr(sw) {
|
||||
return mapRoleExpr(lk, false).ToSql()
|
||||
}
|
||||
if isTagExpr(sw) {
|
||||
return mapTagExpr(lk, false).ToSql()
|
||||
}
|
||||
return lk.ToSql()
|
||||
}
|
||||
|
||||
|
|
@ -161,10 +203,10 @@ func (sw EndsWith) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("endsWith", sw)
|
||||
}
|
||||
|
||||
type InTheRange map[string]interface{}
|
||||
type InTheRange map[string]any
|
||||
|
||||
func (itr InTheRange) ToSql() (sql string, args []interface{}, err error) {
|
||||
var and squirrel.And
|
||||
func (itr InTheRange) ToSql() (sql string, args []any, err error) {
|
||||
and := squirrel.And{}
|
||||
for f, v := range mapFields(itr) {
|
||||
s := reflect.ValueOf(v)
|
||||
if s.Kind() != reflect.Slice || s.Len() != 2 {
|
||||
|
|
@ -182,9 +224,9 @@ func (itr InTheRange) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("inTheRange", itr)
|
||||
}
|
||||
|
||||
type InTheLast map[string]interface{}
|
||||
type InTheLast map[string]any
|
||||
|
||||
func (itl InTheLast) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (itl InTheLast) ToSql() (sql string, args []any, err error) {
|
||||
exp, err := inPeriod(itl, false)
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
|
|
@ -196,9 +238,9 @@ func (itl InTheLast) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("inTheLast", itl)
|
||||
}
|
||||
|
||||
type NotInTheLast map[string]interface{}
|
||||
type NotInTheLast map[string]any
|
||||
|
||||
func (nitl NotInTheLast) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (nitl NotInTheLast) ToSql() (sql string, args []any, err error) {
|
||||
exp, err := inPeriod(nitl, true)
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
|
|
@ -210,9 +252,9 @@ func (nitl NotInTheLast) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("notInTheLast", nitl)
|
||||
}
|
||||
|
||||
func inPeriod(m map[string]interface{}, negate bool) (Expression, error) {
|
||||
func inPeriod(m map[string]any, negate bool) (Expression, error) {
|
||||
var field string
|
||||
var value interface{}
|
||||
var value any
|
||||
for f, v := range mapFields(m) {
|
||||
field, value = f, v
|
||||
break
|
||||
|
|
@ -237,9 +279,9 @@ func startOfPeriod(numDays int64, from time.Time) string {
|
|||
return from.Add(time.Duration(-24*numDays) * time.Hour).Format("2006-01-02")
|
||||
}
|
||||
|
||||
type InPlaylist map[string]interface{}
|
||||
type InPlaylist map[string]any
|
||||
|
||||
func (ipl InPlaylist) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (ipl InPlaylist) ToSql() (sql string, args []any, err error) {
|
||||
return inList(ipl, false)
|
||||
}
|
||||
|
||||
|
|
@ -247,9 +289,9 @@ func (ipl InPlaylist) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("inPlaylist", ipl)
|
||||
}
|
||||
|
||||
type NotInPlaylist map[string]interface{}
|
||||
type NotInPlaylist map[string]any
|
||||
|
||||
func (ipl NotInPlaylist) ToSql() (sql string, args []interface{}, err error) {
|
||||
func (ipl NotInPlaylist) ToSql() (sql string, args []any, err error) {
|
||||
return inList(ipl, true)
|
||||
}
|
||||
|
||||
|
|
@ -257,7 +299,7 @@ func (ipl NotInPlaylist) MarshalJSON() ([]byte, error) {
|
|||
return marshalExpression("notInPlaylist", ipl)
|
||||
}
|
||||
|
||||
func inList(m map[string]interface{}, negate bool) (sql string, args []interface{}, err error) {
|
||||
func inList(m map[string]any, negate bool) (sql string, args []any, err error) {
|
||||
var playlistid string
|
||||
var ok bool
|
||||
if playlistid, ok = m["id"].(string); !ok {
|
||||
|
|
@ -284,7 +326,7 @@ func inList(m map[string]interface{}, negate bool) (sql string, args []interface
|
|||
}
|
||||
}
|
||||
|
||||
func extractPlaylistIds(inputRule interface{}) (ids []string) {
|
||||
func extractPlaylistIds(inputRule any) (ids []string) {
|
||||
var id string
|
||||
var ok bool
|
||||
|
||||
|
|
|
|||
|
|
@ -1,17 +1,23 @@
|
|||
package criteria
|
||||
package criteria_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
. "github.com/navidrome/navidrome/model/criteria"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
"github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = BeforeSuite(func() {
|
||||
AddRoles([]string{"artist", "composer"})
|
||||
AddTagNames([]string{"genre"})
|
||||
})
|
||||
|
||||
var _ = Describe("Operators", func() {
|
||||
rangeStart := date(time.Date(2021, 10, 01, 0, 0, 0, 0, time.Local))
|
||||
rangeEnd := date(time.Date(2021, 11, 01, 0, 0, 0, 0, time.Local))
|
||||
rangeStart := time.Date(2021, 10, 01, 0, 0, 0, 0, time.Local)
|
||||
rangeEnd := time.Date(2021, 11, 01, 0, 0, 0, 0, time.Local)
|
||||
|
||||
DescribeTable("ToSQL",
|
||||
func(op Expression, expectedSql string, expectedArgs ...any) {
|
||||
|
|
@ -30,18 +36,73 @@ var _ = Describe("Operators", func() {
|
|||
Entry("startsWith", StartsWith{"title": "Low Rider"}, "media_file.title LIKE ?", "Low Rider%"),
|
||||
Entry("endsWith", EndsWith{"title": "Low Rider"}, "media_file.title LIKE ?", "%Low Rider"),
|
||||
Entry("inTheRange [number]", InTheRange{"year": []int{1980, 1990}}, "(media_file.year >= ? AND media_file.year <= ?)", 1980, 1990),
|
||||
Entry("inTheRange [date]", InTheRange{"lastPlayed": []date{rangeStart, rangeEnd}}, "(annotation.play_date >= ? AND annotation.play_date <= ?)", rangeStart, rangeEnd),
|
||||
Entry("inTheRange [date]", InTheRange{"lastPlayed": []time.Time{rangeStart, rangeEnd}}, "(annotation.play_date >= ? AND annotation.play_date <= ?)", rangeStart, rangeEnd),
|
||||
Entry("before", Before{"lastPlayed": rangeStart}, "annotation.play_date < ?", rangeStart),
|
||||
Entry("after", After{"lastPlayed": rangeStart}, "annotation.play_date > ?", rangeStart),
|
||||
// TODO These may be flaky
|
||||
Entry("inTheLast", InTheLast{"lastPlayed": 30}, "annotation.play_date > ?", startOfPeriod(30, time.Now())),
|
||||
Entry("notInTheLast", NotInTheLast{"lastPlayed": 30}, "(annotation.play_date < ? OR annotation.play_date IS NULL)", startOfPeriod(30, time.Now())),
|
||||
|
||||
// InPlaylist and NotInPlaylist are special cases
|
||||
Entry("inPlaylist", InPlaylist{"id": "deadbeef-dead-beef"}, "media_file.id IN "+
|
||||
"(SELECT media_file_id FROM playlist_tracks pl LEFT JOIN playlist on pl.playlist_id = playlist.id WHERE (pl.playlist_id = ? AND playlist.public = ?))", "deadbeef-dead-beef", 1),
|
||||
Entry("notInPlaylist", NotInPlaylist{"id": "deadbeef-dead-beef"}, "media_file.id NOT IN "+
|
||||
"(SELECT media_file_id FROM playlist_tracks pl LEFT JOIN playlist on pl.playlist_id = playlist.id WHERE (pl.playlist_id = ? AND playlist.public = ?))", "deadbeef-dead-beef", 1),
|
||||
|
||||
// TODO These may be flaky
|
||||
Entry("inTheLast", InTheLast{"lastPlayed": 30}, "annotation.play_date > ?", StartOfPeriod(30, time.Now())),
|
||||
Entry("notInTheLast", NotInTheLast{"lastPlayed": 30}, "(annotation.play_date < ? OR annotation.play_date IS NULL)", StartOfPeriod(30, time.Now())),
|
||||
|
||||
// Tag tests
|
||||
Entry("tag is [string]", Is{"genre": "Rock"}, "exists (select 1 from json_tree(tags, '$.genre') where key='value' and value = ?)", "Rock"),
|
||||
Entry("tag isNot [string]", IsNot{"genre": "Rock"}, "not exists (select 1 from json_tree(tags, '$.genre') where key='value' and value = ?)", "Rock"),
|
||||
Entry("tag gt", Gt{"genre": "A"}, "exists (select 1 from json_tree(tags, '$.genre') where key='value' and value > ?)", "A"),
|
||||
Entry("tag lt", Lt{"genre": "Z"}, "exists (select 1 from json_tree(tags, '$.genre') where key='value' and value < ?)", "Z"),
|
||||
Entry("tag contains", Contains{"genre": "Rock"}, "exists (select 1 from json_tree(tags, '$.genre') where key='value' and value LIKE ?)", "%Rock%"),
|
||||
Entry("tag not contains", NotContains{"genre": "Rock"}, "not exists (select 1 from json_tree(tags, '$.genre') where key='value' and value LIKE ?)", "%Rock%"),
|
||||
Entry("tag startsWith", StartsWith{"genre": "Soft"}, "exists (select 1 from json_tree(tags, '$.genre') where key='value' and value LIKE ?)", "Soft%"),
|
||||
Entry("tag endsWith", EndsWith{"genre": "Rock"}, "exists (select 1 from json_tree(tags, '$.genre') where key='value' and value LIKE ?)", "%Rock"),
|
||||
|
||||
// Artist roles tests
|
||||
Entry("role is [string]", Is{"artist": "u2"}, "exists (select 1 from json_tree(participants, '$.artist') where key='name' and value = ?)", "u2"),
|
||||
Entry("role isNot [string]", IsNot{"artist": "u2"}, "not exists (select 1 from json_tree(participants, '$.artist') where key='name' and value = ?)", "u2"),
|
||||
Entry("role contains [string]", Contains{"artist": "u2"}, "exists (select 1 from json_tree(participants, '$.artist') where key='name' and value LIKE ?)", "%u2%"),
|
||||
Entry("role not contains [string]", NotContains{"artist": "u2"}, "not exists (select 1 from json_tree(participants, '$.artist') where key='name' and value LIKE ?)", "%u2%"),
|
||||
Entry("role startsWith [string]", StartsWith{"composer": "John"}, "exists (select 1 from json_tree(participants, '$.composer') where key='name' and value LIKE ?)", "John%"),
|
||||
Entry("role endsWith [string]", EndsWith{"composer": "Lennon"}, "exists (select 1 from json_tree(participants, '$.composer') where key='name' and value LIKE ?)", "%Lennon"),
|
||||
)
|
||||
|
||||
Describe("Custom Tags", func() {
|
||||
It("generates valid SQL", func() {
|
||||
AddTagNames([]string{"mood"})
|
||||
op := EndsWith{"mood": "Soft"}
|
||||
sql, args, err := op.ToSql()
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(tags, '$.mood') where key='value' and value LIKE ?)"))
|
||||
gomega.Expect(args).To(gomega.HaveExactElements("%Soft"))
|
||||
})
|
||||
It("skips unknown tag names", func() {
|
||||
op := EndsWith{"unknown": "value"}
|
||||
sql, args, _ := op.ToSql()
|
||||
gomega.Expect(sql).To(gomega.BeEmpty())
|
||||
gomega.Expect(args).To(gomega.BeEmpty())
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Custom Roles", func() {
|
||||
It("generates valid SQL", func() {
|
||||
AddRoles([]string{"producer"})
|
||||
op := EndsWith{"producer": "Eno"}
|
||||
sql, args, err := op.ToSql()
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(sql).To(gomega.Equal("exists (select 1 from json_tree(participants, '$.producer') where key='name' and value LIKE ?)"))
|
||||
gomega.Expect(args).To(gomega.HaveExactElements("%Eno"))
|
||||
})
|
||||
It("skips unknown roles", func() {
|
||||
op := Contains{"groupie": "Penny Lane"}
|
||||
sql, args, _ := op.ToSql()
|
||||
gomega.Expect(sql).To(gomega.BeEmpty())
|
||||
gomega.Expect(args).To(gomega.BeEmpty())
|
||||
})
|
||||
})
|
||||
|
||||
DescribeTable("JSON Marshaling",
|
||||
func(op Expression, jsonString string) {
|
||||
obj := And{op}
|
||||
|
|
@ -49,7 +110,7 @@ var _ = Describe("Operators", func() {
|
|||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
gomega.Expect(string(newJs)).To(gomega.Equal(fmt.Sprintf(`{"all":[%s]}`, jsonString)))
|
||||
|
||||
var unmarshalObj unmarshalConjunctionType
|
||||
var unmarshalObj UnmarshalConjunctionType
|
||||
js := "[" + jsonString + "]"
|
||||
err = json.Unmarshal([]byte(js), &unmarshalObj)
|
||||
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
||||
|
|
@ -64,8 +125,8 @@ var _ = Describe("Operators", func() {
|
|||
Entry("notContains", NotContains{"title": "Low Rider"}, `{"notContains":{"title":"Low Rider"}}`),
|
||||
Entry("startsWith", StartsWith{"title": "Low Rider"}, `{"startsWith":{"title":"Low Rider"}}`),
|
||||
Entry("endsWith", EndsWith{"title": "Low Rider"}, `{"endsWith":{"title":"Low Rider"}}`),
|
||||
Entry("inTheRange [number]", InTheRange{"year": []interface{}{1980.0, 1990.0}}, `{"inTheRange":{"year":[1980,1990]}}`),
|
||||
Entry("inTheRange [date]", InTheRange{"lastPlayed": []interface{}{"2021-10-01", "2021-11-01"}}, `{"inTheRange":{"lastPlayed":["2021-10-01","2021-11-01"]}}`),
|
||||
Entry("inTheRange [number]", InTheRange{"year": []any{1980.0, 1990.0}}, `{"inTheRange":{"year":[1980,1990]}}`),
|
||||
Entry("inTheRange [date]", InTheRange{"lastPlayed": []any{"2021-10-01", "2021-11-01"}}, `{"inTheRange":{"lastPlayed":["2021-10-01","2021-11-01"]}}`),
|
||||
Entry("before", Before{"lastPlayed": "2021-10-01"}, `{"before":{"lastPlayed":"2021-10-01"}}`),
|
||||
Entry("after", After{"lastPlayed": "2021-10-01"}, `{"after":{"lastPlayed":"2021-10-01"}}`),
|
||||
Entry("inTheLast", InTheLast{"lastPlayed": 30.0}, `{"inTheLast":{"lastPlayed":30}}`),
|
||||
|
|
|
|||
|
|
@ -22,10 +22,12 @@ type ResourceRepository interface {
|
|||
|
||||
type DataStore interface {
|
||||
Library(ctx context.Context) LibraryRepository
|
||||
Folder(ctx context.Context) FolderRepository
|
||||
Album(ctx context.Context) AlbumRepository
|
||||
Artist(ctx context.Context) ArtistRepository
|
||||
MediaFile(ctx context.Context) MediaFileRepository
|
||||
Genre(ctx context.Context) GenreRepository
|
||||
Tag(ctx context.Context) TagRepository
|
||||
Playlist(ctx context.Context) PlaylistRepository
|
||||
PlayQueue(ctx context.Context) PlayQueueRepository
|
||||
Transcoding(ctx context.Context) TranscodingRepository
|
||||
|
|
@ -40,5 +42,5 @@ type DataStore interface {
|
|||
Resource(ctx context.Context, model interface{}) ResourceRepository
|
||||
|
||||
WithTx(func(tx DataStore) error) error
|
||||
GC(ctx context.Context, rootFolder string) error
|
||||
GC(ctx context.Context) error
|
||||
}
|
||||
|
|
|
|||
86
model/folder.go
Normal file
86
model/folder.go
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"iter"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/navidrome/navidrome/model/id"
|
||||
)
|
||||
|
||||
// Folder represents a folder in the library. Its path is relative to the library root.
|
||||
// ALWAYS use NewFolder to create a new instance.
|
||||
type Folder struct {
|
||||
ID string `structs:"id"`
|
||||
LibraryID int `structs:"library_id"`
|
||||
LibraryPath string `structs:"-" json:"-" hash:"-"`
|
||||
Path string `structs:"path"`
|
||||
Name string `structs:"name"`
|
||||
ParentID string `structs:"parent_id"`
|
||||
NumAudioFiles int `structs:"num_audio_files"`
|
||||
NumPlaylists int `structs:"num_playlists"`
|
||||
ImageFiles []string `structs:"image_files"`
|
||||
ImagesUpdatedAt time.Time `structs:"images_updated_at"`
|
||||
Missing bool `structs:"missing"`
|
||||
UpdateAt time.Time `structs:"updated_at"`
|
||||
CreatedAt time.Time `structs:"created_at"`
|
||||
}
|
||||
|
||||
func (f Folder) AbsolutePath() string {
|
||||
return filepath.Join(f.LibraryPath, f.Path, f.Name)
|
||||
}
|
||||
|
||||
func (f Folder) String() string {
|
||||
return f.AbsolutePath()
|
||||
}
|
||||
|
||||
// FolderID generates a unique ID for a folder in a library.
|
||||
// The ID is generated based on the library ID and the folder path relative to the library root.
|
||||
// Any leading or trailing slashes are removed from the folder path.
|
||||
func FolderID(lib Library, path string) string {
|
||||
path = strings.TrimPrefix(path, lib.Path)
|
||||
path = strings.TrimPrefix(path, string(os.PathSeparator))
|
||||
path = filepath.Clean(path)
|
||||
key := fmt.Sprintf("%d:%s", lib.ID, path)
|
||||
return id.NewHash(key)
|
||||
}
|
||||
|
||||
func NewFolder(lib Library, folderPath string) *Folder {
|
||||
newID := FolderID(lib, folderPath)
|
||||
dir, name := path.Split(folderPath)
|
||||
dir = path.Clean(dir)
|
||||
var parentID string
|
||||
if dir == "." && name == "." {
|
||||
dir = ""
|
||||
parentID = ""
|
||||
} else {
|
||||
parentID = FolderID(lib, dir)
|
||||
}
|
||||
return &Folder{
|
||||
LibraryID: lib.ID,
|
||||
ID: newID,
|
||||
Path: dir,
|
||||
Name: name,
|
||||
ParentID: parentID,
|
||||
ImageFiles: []string{},
|
||||
UpdateAt: time.Now(),
|
||||
CreatedAt: time.Now(),
|
||||
}
|
||||
}
|
||||
|
||||
type FolderCursor iter.Seq2[Folder, error]
|
||||
|
||||
type FolderRepository interface {
|
||||
Get(id string) (*Folder, error)
|
||||
GetByPath(lib Library, path string) (*Folder, error)
|
||||
GetAll(...QueryOptions) ([]Folder, error)
|
||||
CountAll(...QueryOptions) (int64, error)
|
||||
GetLastUpdates(lib Library) (map[string]time.Time, error)
|
||||
Put(*Folder) error
|
||||
MarkMissing(missing bool, ids ...string) error
|
||||
GetTouchedWithPlaylists() (FolderCursor, error)
|
||||
}
|
||||
119
model/folder_test.go
Normal file
119
model/folder_test.go
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
package model_test
|
||||
|
||||
import (
|
||||
"path"
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/model/id"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("Folder", func() {
|
||||
var (
|
||||
lib model.Library
|
||||
)
|
||||
|
||||
BeforeEach(func() {
|
||||
lib = model.Library{
|
||||
ID: 1,
|
||||
Path: filepath.FromSlash("/music"),
|
||||
}
|
||||
})
|
||||
|
||||
Describe("FolderID", func() {
|
||||
When("the folder path is the library root", func() {
|
||||
It("should return the correct folder ID", func() {
|
||||
folderPath := lib.Path
|
||||
expectedID := id.NewHash("1:.")
|
||||
Expect(model.FolderID(lib, folderPath)).To(Equal(expectedID))
|
||||
})
|
||||
})
|
||||
|
||||
When("the folder path is '.' (library root)", func() {
|
||||
It("should return the correct folder ID", func() {
|
||||
folderPath := "."
|
||||
expectedID := id.NewHash("1:.")
|
||||
Expect(model.FolderID(lib, folderPath)).To(Equal(expectedID))
|
||||
})
|
||||
})
|
||||
|
||||
When("the folder path is relative", func() {
|
||||
It("should return the correct folder ID", func() {
|
||||
folderPath := "rock"
|
||||
expectedID := id.NewHash("1:rock")
|
||||
Expect(model.FolderID(lib, folderPath)).To(Equal(expectedID))
|
||||
})
|
||||
})
|
||||
|
||||
When("the folder path starts with '.'", func() {
|
||||
It("should return the correct folder ID", func() {
|
||||
folderPath := "./rock"
|
||||
expectedID := id.NewHash("1:rock")
|
||||
Expect(model.FolderID(lib, folderPath)).To(Equal(expectedID))
|
||||
})
|
||||
})
|
||||
|
||||
When("the folder path is absolute", func() {
|
||||
It("should return the correct folder ID", func() {
|
||||
folderPath := filepath.FromSlash("/music/rock")
|
||||
expectedID := id.NewHash("1:rock")
|
||||
Expect(model.FolderID(lib, folderPath)).To(Equal(expectedID))
|
||||
})
|
||||
})
|
||||
|
||||
When("the folder has multiple subdirs", func() {
|
||||
It("should return the correct folder ID", func() {
|
||||
folderPath := filepath.FromSlash("/music/rock/metal")
|
||||
expectedID := id.NewHash("1:rock/metal")
|
||||
Expect(model.FolderID(lib, folderPath)).To(Equal(expectedID))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("NewFolder", func() {
|
||||
It("should create a new SubFolder with the correct attributes", func() {
|
||||
folderPath := filepath.FromSlash("rock/metal")
|
||||
folder := model.NewFolder(lib, folderPath)
|
||||
|
||||
Expect(folder.LibraryID).To(Equal(lib.ID))
|
||||
Expect(folder.ID).To(Equal(model.FolderID(lib, folderPath)))
|
||||
Expect(folder.Path).To(Equal(path.Clean("rock")))
|
||||
Expect(folder.Name).To(Equal("metal"))
|
||||
Expect(folder.ParentID).To(Equal(model.FolderID(lib, "rock")))
|
||||
Expect(folder.ImageFiles).To(BeEmpty())
|
||||
Expect(folder.UpdateAt).To(BeTemporally("~", time.Now(), time.Second))
|
||||
Expect(folder.CreatedAt).To(BeTemporally("~", time.Now(), time.Second))
|
||||
})
|
||||
|
||||
It("should create a new Folder with the correct attributes", func() {
|
||||
folderPath := "rock"
|
||||
folder := model.NewFolder(lib, folderPath)
|
||||
|
||||
Expect(folder.LibraryID).To(Equal(lib.ID))
|
||||
Expect(folder.ID).To(Equal(model.FolderID(lib, folderPath)))
|
||||
Expect(folder.Path).To(Equal(path.Clean(".")))
|
||||
Expect(folder.Name).To(Equal("rock"))
|
||||
Expect(folder.ParentID).To(Equal(model.FolderID(lib, ".")))
|
||||
Expect(folder.ImageFiles).To(BeEmpty())
|
||||
Expect(folder.UpdateAt).To(BeTemporally("~", time.Now(), time.Second))
|
||||
Expect(folder.CreatedAt).To(BeTemporally("~", time.Now(), time.Second))
|
||||
})
|
||||
|
||||
It("should handle the root folder correctly", func() {
|
||||
folderPath := "."
|
||||
folder := model.NewFolder(lib, folderPath)
|
||||
|
||||
Expect(folder.LibraryID).To(Equal(lib.ID))
|
||||
Expect(folder.ID).To(Equal(model.FolderID(lib, folderPath)))
|
||||
Expect(folder.Path).To(Equal(""))
|
||||
Expect(folder.Name).To(Equal("."))
|
||||
Expect(folder.ParentID).To(Equal(""))
|
||||
Expect(folder.ImageFiles).To(BeEmpty())
|
||||
Expect(folder.UpdateAt).To(BeTemporally("~", time.Now(), time.Second))
|
||||
Expect(folder.CreatedAt).To(BeTemporally("~", time.Now(), time.Second))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
@ -11,5 +11,4 @@ type Genres []Genre
|
|||
|
||||
type GenreRepository interface {
|
||||
GetAll(...QueryOptions) (Genres, error)
|
||||
Put(*Genre) error
|
||||
}
|
||||
|
|
|
|||
36
model/id/id.go
Normal file
36
model/id/id.go
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
package id
|
||||
|
||||
import (
|
||||
"crypto/md5"
|
||||
"fmt"
|
||||
"math/big"
|
||||
"strings"
|
||||
|
||||
gonanoid "github.com/matoous/go-nanoid/v2"
|
||||
"github.com/navidrome/navidrome/log"
|
||||
)
|
||||
|
||||
func NewRandom() string {
|
||||
id, err := gonanoid.Generate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 22)
|
||||
if err != nil {
|
||||
log.Error("Could not generate new ID", err)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
func NewHash(data ...string) string {
|
||||
hash := md5.New()
|
||||
for _, d := range data {
|
||||
hash.Write([]byte(d))
|
||||
hash.Write([]byte(string('\u200b')))
|
||||
}
|
||||
h := hash.Sum(nil)
|
||||
bi := big.NewInt(0)
|
||||
bi.SetBytes(h)
|
||||
s := bi.Text(62)
|
||||
return fmt.Sprintf("%022s", s)
|
||||
}
|
||||
|
||||
func NewTagID(name, value string) string {
|
||||
return NewHash(strings.ToLower(name), strings.ToLower(value))
|
||||
}
|
||||
|
|
@ -1,32 +1,35 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
"io/fs"
|
||||
"os"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Library struct {
|
||||
ID int
|
||||
Name string
|
||||
Path string
|
||||
RemotePath string
|
||||
LastScanAt time.Time
|
||||
UpdatedAt time.Time
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
func (f Library) FS() fs.FS {
|
||||
return os.DirFS(f.Path)
|
||||
ID int
|
||||
Name string
|
||||
Path string
|
||||
RemotePath string
|
||||
LastScanAt time.Time
|
||||
LastScanStartedAt time.Time
|
||||
FullScanInProgress bool
|
||||
UpdatedAt time.Time
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
type Libraries []Library
|
||||
|
||||
type LibraryRepository interface {
|
||||
Get(id int) (*Library, error)
|
||||
// GetPath returns the path of the library with the given ID.
|
||||
// Its implementation must be optimized to avoid unnecessary queries.
|
||||
GetPath(id int) (string, error)
|
||||
GetAll(...QueryOptions) (Libraries, error)
|
||||
Put(*Library) error
|
||||
StoreMusicFolder() error
|
||||
AddArtist(id int, artistID string) error
|
||||
UpdateLastScan(id int, t time.Time) error
|
||||
GetAll(...QueryOptions) (Libraries, error)
|
||||
|
||||
// TODO These methods should be moved to a core service
|
||||
ScanBegin(id int, fullScan bool) error
|
||||
ScanEnd(id int) error
|
||||
ScanInProgress() (bool, error)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,6 +35,10 @@ var (
|
|||
lrcIdRegex = regexp.MustCompile(`\[(ar|ti|offset):([^]]+)]`)
|
||||
)
|
||||
|
||||
func (l Lyrics) IsEmpty() bool {
|
||||
return len(l.Line) == 0
|
||||
}
|
||||
|
||||
func ToLyrics(language, text string) (*Lyrics, error) {
|
||||
text = str.SanitizeText(text)
|
||||
|
||||
|
|
@ -171,7 +175,6 @@ func ToLyrics(language, text string) (*Lyrics, error) {
|
|||
Offset: offset,
|
||||
Synced: synced,
|
||||
}
|
||||
|
||||
return &lyrics, nil
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,32 +2,39 @@ package model
|
|||
|
||||
import (
|
||||
"cmp"
|
||||
"crypto/md5"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"iter"
|
||||
"mime"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/gohugoio/hashstructure"
|
||||
"github.com/navidrome/navidrome/conf"
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
"github.com/navidrome/navidrome/utils"
|
||||
"github.com/navidrome/navidrome/utils/slice"
|
||||
"github.com/navidrome/navidrome/utils/str"
|
||||
)
|
||||
|
||||
type MediaFile struct {
|
||||
Annotations `structs:"-"`
|
||||
Bookmarkable `structs:"-"`
|
||||
Annotations `structs:"-" hash:"ignore"`
|
||||
Bookmarkable `structs:"-" hash:"ignore"`
|
||||
|
||||
ID string `structs:"id" json:"id"`
|
||||
LibraryID int `structs:"library_id" json:"libraryId"`
|
||||
Path string `structs:"path" json:"path"`
|
||||
Title string `structs:"title" json:"title"`
|
||||
Album string `structs:"album" json:"album"`
|
||||
ArtistID string `structs:"artist_id" json:"artistId"`
|
||||
Artist string `structs:"artist" json:"artist"`
|
||||
AlbumArtistID string `structs:"album_artist_id" json:"albumArtistId"`
|
||||
ID string `structs:"id" json:"id" hash:"ignore"`
|
||||
PID string `structs:"pid" json:"-" hash:"ignore"`
|
||||
LibraryID int `structs:"library_id" json:"libraryId" hash:"ignore"`
|
||||
LibraryPath string `structs:"-" json:"libraryPath" hash:"-"`
|
||||
FolderID string `structs:"folder_id" json:"folderId" hash:"ignore"`
|
||||
Path string `structs:"path" json:"path" hash:"ignore"`
|
||||
Title string `structs:"title" json:"title"`
|
||||
Album string `structs:"album" json:"album"`
|
||||
ArtistID string `structs:"artist_id" json:"artistId"` // Deprecated: Use Participants instead
|
||||
// BFR Rename to ArtistDisplayName
|
||||
Artist string `structs:"artist" json:"artist"`
|
||||
AlbumArtistID string `structs:"album_artist_id" json:"albumArtistId"` // Deprecated: Use Participants instead
|
||||
// BFR Rename to AlbumArtistDisplayName
|
||||
AlbumArtist string `structs:"album_artist" json:"albumArtist"`
|
||||
AlbumID string `structs:"album_id" json:"albumId"`
|
||||
HasCoverArt bool `structs:"has_cover_art" json:"hasCoverArt"`
|
||||
|
|
@ -45,37 +52,51 @@ type MediaFile struct {
|
|||
Duration float32 `structs:"duration" json:"duration"`
|
||||
BitRate int `structs:"bit_rate" json:"bitRate"`
|
||||
SampleRate int `structs:"sample_rate" json:"sampleRate"`
|
||||
BitDepth int `structs:"bit_depth" json:"bitDepth"`
|
||||
Channels int `structs:"channels" json:"channels"`
|
||||
Genre string `structs:"genre" json:"genre"`
|
||||
Genres Genres `structs:"-" json:"genres"`
|
||||
FullText string `structs:"full_text" json:"-"`
|
||||
Genres Genres `structs:"-" json:"genres,omitempty"`
|
||||
SortTitle string `structs:"sort_title" json:"sortTitle,omitempty"`
|
||||
SortAlbumName string `structs:"sort_album_name" json:"sortAlbumName,omitempty"`
|
||||
SortArtistName string `structs:"sort_artist_name" json:"sortArtistName,omitempty"`
|
||||
SortAlbumArtistName string `structs:"sort_album_artist_name" json:"sortAlbumArtistName,omitempty"`
|
||||
SortArtistName string `structs:"sort_artist_name" json:"sortArtistName,omitempty"` // Deprecated: Use Participants instead
|
||||
SortAlbumArtistName string `structs:"sort_album_artist_name" json:"sortAlbumArtistName,omitempty"` // Deprecated: Use Participants instead
|
||||
OrderTitle string `structs:"order_title" json:"orderTitle,omitempty"`
|
||||
OrderAlbumName string `structs:"order_album_name" json:"orderAlbumName"`
|
||||
OrderArtistName string `structs:"order_artist_name" json:"orderArtistName"`
|
||||
OrderAlbumArtistName string `structs:"order_album_artist_name" json:"orderAlbumArtistName"`
|
||||
OrderArtistName string `structs:"order_artist_name" json:"orderArtistName"` // Deprecated: Use Participants instead
|
||||
OrderAlbumArtistName string `structs:"order_album_artist_name" json:"orderAlbumArtistName"` // Deprecated: Use Participants instead
|
||||
Compilation bool `structs:"compilation" json:"compilation"`
|
||||
Comment string `structs:"comment" json:"comment,omitempty"`
|
||||
Lyrics string `structs:"lyrics" json:"lyrics"`
|
||||
Bpm int `structs:"bpm" json:"bpm,omitempty"`
|
||||
BPM int `structs:"bpm" json:"bpm,omitempty"`
|
||||
ExplicitStatus string `structs:"explicit_status" json:"explicitStatus"`
|
||||
CatalogNum string `structs:"catalog_num" json:"catalogNum,omitempty"`
|
||||
MbzRecordingID string `structs:"mbz_recording_id" json:"mbzRecordingID,omitempty"`
|
||||
MbzReleaseTrackID string `structs:"mbz_release_track_id" json:"mbzReleaseTrackId,omitempty"`
|
||||
MbzAlbumID string `structs:"mbz_album_id" json:"mbzAlbumId,omitempty"`
|
||||
MbzArtistID string `structs:"mbz_artist_id" json:"mbzArtistId,omitempty"`
|
||||
MbzAlbumArtistID string `structs:"mbz_album_artist_id" json:"mbzAlbumArtistId,omitempty"`
|
||||
MbzReleaseGroupID string `structs:"mbz_release_group_id" json:"mbzReleaseGroupId,omitempty"`
|
||||
MbzArtistID string `structs:"mbz_artist_id" json:"mbzArtistId,omitempty"` // Deprecated: Use Participants instead
|
||||
MbzAlbumArtistID string `structs:"mbz_album_artist_id" json:"mbzAlbumArtistId,omitempty"` // Deprecated: Use Participants instead
|
||||
MbzAlbumType string `structs:"mbz_album_type" json:"mbzAlbumType,omitempty"`
|
||||
MbzAlbumComment string `structs:"mbz_album_comment" json:"mbzAlbumComment,omitempty"`
|
||||
RgAlbumGain float64 `structs:"rg_album_gain" json:"rgAlbumGain"`
|
||||
RgAlbumPeak float64 `structs:"rg_album_peak" json:"rgAlbumPeak"`
|
||||
RgTrackGain float64 `structs:"rg_track_gain" json:"rgTrackGain"`
|
||||
RgTrackPeak float64 `structs:"rg_track_peak" json:"rgTrackPeak"`
|
||||
RGAlbumGain float64 `structs:"rg_album_gain" json:"rgAlbumGain"`
|
||||
RGAlbumPeak float64 `structs:"rg_album_peak" json:"rgAlbumPeak"`
|
||||
RGTrackGain float64 `structs:"rg_track_gain" json:"rgTrackGain"`
|
||||
RGTrackPeak float64 `structs:"rg_track_peak" json:"rgTrackPeak"`
|
||||
|
||||
CreatedAt time.Time `structs:"created_at" json:"createdAt"` // Time this entry was created in the DB
|
||||
UpdatedAt time.Time `structs:"updated_at" json:"updatedAt"` // Time of file last update (mtime)
|
||||
Tags Tags `structs:"tags" json:"tags,omitempty" hash:"ignore"` // All imported tags from the original file
|
||||
Participants Participants `structs:"participants" json:"participants" hash:"ignore"` // All artists that participated in this track
|
||||
|
||||
Missing bool `structs:"missing" json:"missing" hash:"ignore"` // If the file is not found in the library's FS
|
||||
BirthTime time.Time `structs:"birth_time" json:"birthTime" hash:"ignore"` // Time of file creation (ctime)
|
||||
CreatedAt time.Time `structs:"created_at" json:"createdAt" hash:"ignore"` // Time this entry was created in the DB
|
||||
UpdatedAt time.Time `structs:"updated_at" json:"updatedAt" hash:"ignore"` // Time of file last update (mtime)
|
||||
}
|
||||
|
||||
func (mf MediaFile) FullTitle() string {
|
||||
if mf.Tags[TagSubtitle] == nil {
|
||||
return mf.Title
|
||||
}
|
||||
return fmt.Sprintf("%s (%s)", mf.Title, mf.Tags[TagSubtitle][0])
|
||||
}
|
||||
|
||||
func (mf MediaFile) ContentType() string {
|
||||
|
|
@ -104,37 +125,69 @@ func (mf MediaFile) StructuredLyrics() (LyricList, error) {
|
|||
return lyrics, nil
|
||||
}
|
||||
|
||||
type MediaFiles []MediaFile
|
||||
|
||||
// Dirs returns a deduped list of all directories from the MediaFiles' paths
|
||||
func (mfs MediaFiles) Dirs() []string {
|
||||
dirs := slice.Map(mfs, func(m MediaFile) string {
|
||||
return filepath.Dir(m.Path)
|
||||
})
|
||||
slices.Sort(dirs)
|
||||
return slices.Compact(dirs)
|
||||
// String is mainly used for debugging
|
||||
func (mf MediaFile) String() string {
|
||||
return mf.Path
|
||||
}
|
||||
|
||||
// Hash returns a hash of the MediaFile based on its tags and audio properties
|
||||
func (mf MediaFile) Hash() string {
|
||||
opts := &hashstructure.HashOptions{
|
||||
IgnoreZeroValue: true,
|
||||
ZeroNil: true,
|
||||
}
|
||||
hash, _ := hashstructure.Hash(mf, opts)
|
||||
sum := md5.New()
|
||||
sum.Write([]byte(fmt.Sprintf("%d", hash)))
|
||||
sum.Write(mf.Tags.Hash())
|
||||
sum.Write(mf.Participants.Hash())
|
||||
return fmt.Sprintf("%x", sum.Sum(nil))
|
||||
}
|
||||
|
||||
// Equals compares two MediaFiles by their hash. It does not consider the ID, PID, Path and other identifier fields.
|
||||
// Check the structure for the fields that are marked with `hash:"ignore"`.
|
||||
func (mf MediaFile) Equals(other MediaFile) bool {
|
||||
return mf.Hash() == other.Hash()
|
||||
}
|
||||
|
||||
// IsEquivalent compares two MediaFiles by path only. Used for matching missing tracks.
|
||||
func (mf MediaFile) IsEquivalent(other MediaFile) bool {
|
||||
return utils.BaseName(mf.Path) == utils.BaseName(other.Path)
|
||||
}
|
||||
|
||||
func (mf MediaFile) AbsolutePath() string {
|
||||
return filepath.Join(mf.LibraryPath, mf.Path)
|
||||
}
|
||||
|
||||
type MediaFiles []MediaFile
|
||||
|
||||
// ToAlbum creates an Album object based on the attributes of this MediaFiles collection.
|
||||
// It assumes all mediafiles have the same Album, or else results are unpredictable.
|
||||
// It assumes all mediafiles have the same Album (same ID), or else results are unpredictable.
|
||||
func (mfs MediaFiles) ToAlbum() Album {
|
||||
a := Album{SongCount: len(mfs)}
|
||||
fullText := make([]string, 0, len(mfs))
|
||||
albumArtistIds := make([]string, 0, len(mfs))
|
||||
songArtistIds := make([]string, 0, len(mfs))
|
||||
if len(mfs) == 0 {
|
||||
return Album{}
|
||||
}
|
||||
a := Album{SongCount: len(mfs), Tags: make(Tags), Participants: make(Participants), Discs: Discs{1: ""}}
|
||||
|
||||
// Sorting the mediafiles ensure the results will be consistent
|
||||
slices.SortFunc(mfs, func(a, b MediaFile) int { return cmp.Compare(a.Path, b.Path) })
|
||||
|
||||
mbzAlbumIds := make([]string, 0, len(mfs))
|
||||
mbzReleaseGroupIds := make([]string, 0, len(mfs))
|
||||
comments := make([]string, 0, len(mfs))
|
||||
years := make([]int, 0, len(mfs))
|
||||
dates := make([]string, 0, len(mfs))
|
||||
originalYears := make([]int, 0, len(mfs))
|
||||
originalDates := make([]string, 0, len(mfs))
|
||||
releaseDates := make([]string, 0, len(mfs))
|
||||
tags := make(TagList, 0, len(mfs[0].Tags)*len(mfs))
|
||||
|
||||
a.Missing = true
|
||||
for _, m := range mfs {
|
||||
// We assume these attributes are all the same for all songs on an album
|
||||
// We assume these attributes are all the same for all songs in an album
|
||||
a.ID = m.AlbumID
|
||||
a.LibraryID = m.LibraryID
|
||||
a.Name = m.Album
|
||||
a.Artist = m.Artist
|
||||
a.ArtistID = m.ArtistID
|
||||
a.AlbumArtist = m.AlbumArtist
|
||||
a.AlbumArtistID = m.AlbumArtistID
|
||||
a.SortAlbumName = m.SortAlbumName
|
||||
|
|
@ -145,7 +198,7 @@ func (mfs MediaFiles) ToAlbum() Album {
|
|||
a.MbzAlbumType = m.MbzAlbumType
|
||||
a.MbzAlbumComment = m.MbzAlbumComment
|
||||
a.CatalogNum = m.CatalogNum
|
||||
a.Compilation = m.Compilation
|
||||
a.Compilation = a.Compilation || m.Compilation
|
||||
|
||||
// Calculated attributes based on aggregations
|
||||
a.Duration += m.Duration
|
||||
|
|
@ -155,50 +208,51 @@ func (mfs MediaFiles) ToAlbum() Album {
|
|||
originalYears = append(originalYears, m.OriginalYear)
|
||||
originalDates = append(originalDates, m.OriginalDate)
|
||||
releaseDates = append(releaseDates, m.ReleaseDate)
|
||||
a.UpdatedAt = newer(a.UpdatedAt, m.UpdatedAt)
|
||||
a.CreatedAt = older(a.CreatedAt, m.CreatedAt)
|
||||
a.Genres = append(a.Genres, m.Genres...)
|
||||
comments = append(comments, m.Comment)
|
||||
albumArtistIds = append(albumArtistIds, m.AlbumArtistID)
|
||||
songArtistIds = append(songArtistIds, m.ArtistID)
|
||||
mbzAlbumIds = append(mbzAlbumIds, m.MbzAlbumID)
|
||||
fullText = append(fullText,
|
||||
m.Album, m.AlbumArtist, m.Artist,
|
||||
m.SortAlbumName, m.SortAlbumArtistName, m.SortArtistName,
|
||||
m.DiscSubtitle)
|
||||
mbzReleaseGroupIds = append(mbzReleaseGroupIds, m.MbzReleaseGroupID)
|
||||
if m.HasCoverArt && a.EmbedArtPath == "" {
|
||||
a.EmbedArtPath = m.Path
|
||||
}
|
||||
if m.DiscNumber > 0 {
|
||||
a.Discs.Add(m.DiscNumber, m.DiscSubtitle)
|
||||
}
|
||||
tags = append(tags, m.Tags.FlattenAll()...)
|
||||
a.Participants.Merge(m.Participants)
|
||||
|
||||
if m.ExplicitStatus == "c" && a.ExplicitStatus != "e" {
|
||||
a.ExplicitStatus = "c"
|
||||
} else if m.ExplicitStatus == "e" {
|
||||
a.ExplicitStatus = "e"
|
||||
}
|
||||
|
||||
a.UpdatedAt = newer(a.UpdatedAt, m.UpdatedAt)
|
||||
a.CreatedAt = older(a.CreatedAt, m.BirthTime)
|
||||
a.Missing = a.Missing && m.Missing
|
||||
}
|
||||
|
||||
a.Paths = strings.Join(mfs.Dirs(), consts.Zwsp)
|
||||
a.SetTags(tags)
|
||||
a.FolderIDs = slice.Unique(slice.Map(mfs, func(m MediaFile) string { return m.FolderID }))
|
||||
a.Date, _ = allOrNothing(dates)
|
||||
a.OriginalDate, _ = allOrNothing(originalDates)
|
||||
a.ReleaseDate, a.Releases = allOrNothing(releaseDates)
|
||||
a.ReleaseDate, _ = allOrNothing(releaseDates)
|
||||
a.MinYear, a.MaxYear = minMax(years)
|
||||
a.MinOriginalYear, a.MaxOriginalYear = minMax(originalYears)
|
||||
a.Comment, _ = allOrNothing(comments)
|
||||
a.Genre = slice.MostFrequent(a.Genres).Name
|
||||
slices.SortFunc(a.Genres, func(a, b Genre) int { return cmp.Compare(a.ID, b.ID) })
|
||||
a.Genres = slices.Compact(a.Genres)
|
||||
a.FullText = " " + str.SanitizeStrings(fullText...)
|
||||
a = fixAlbumArtist(a, albumArtistIds)
|
||||
songArtistIds = append(songArtistIds, a.AlbumArtistID, a.ArtistID)
|
||||
slices.Sort(songArtistIds)
|
||||
a.AllArtistIDs = strings.Join(slices.Compact(songArtistIds), " ")
|
||||
a.MbzAlbumID = slice.MostFrequent(mbzAlbumIds)
|
||||
a.MbzReleaseGroupID = slice.MostFrequent(mbzReleaseGroupIds)
|
||||
fixAlbumArtist(&a)
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
func allOrNothing(items []string) (string, int) {
|
||||
sort.Strings(items)
|
||||
items = slices.Compact(items)
|
||||
if len(items) == 0 {
|
||||
return "", 0
|
||||
}
|
||||
items = slice.Unique(items)
|
||||
if len(items) != 1 {
|
||||
return "", len(slices.Compact(items))
|
||||
return "", len(items)
|
||||
}
|
||||
return items[0], 1
|
||||
}
|
||||
|
|
@ -233,38 +287,44 @@ func older(t1, t2 time.Time) time.Time {
|
|||
return t1
|
||||
}
|
||||
|
||||
func fixAlbumArtist(a Album, albumArtistIds []string) Album {
|
||||
// fixAlbumArtist sets the AlbumArtist to "Various Artists" if the album has more than one artist
|
||||
// or if it is a compilation
|
||||
func fixAlbumArtist(a *Album) {
|
||||
if !a.Compilation {
|
||||
if a.AlbumArtistID == "" {
|
||||
a.AlbumArtistID = a.ArtistID
|
||||
a.AlbumArtist = a.Artist
|
||||
artist := a.Participants.First(RoleArtist)
|
||||
a.AlbumArtistID = artist.ID
|
||||
a.AlbumArtist = artist.Name
|
||||
}
|
||||
return a
|
||||
return
|
||||
}
|
||||
|
||||
albumArtistIds = slices.Compact(albumArtistIds)
|
||||
if len(albumArtistIds) > 1 {
|
||||
albumArtistIds := slice.Map(a.Participants[RoleAlbumArtist], func(p Participant) string { return p.ID })
|
||||
if len(slice.Unique(albumArtistIds)) > 1 {
|
||||
a.AlbumArtist = consts.VariousArtists
|
||||
a.AlbumArtistID = consts.VariousArtistsID
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
type MediaFileCursor iter.Seq2[MediaFile, error]
|
||||
|
||||
type MediaFileRepository interface {
|
||||
CountAll(options ...QueryOptions) (int64, error)
|
||||
Exists(id string) (bool, error)
|
||||
Put(m *MediaFile) error
|
||||
Get(id string) (*MediaFile, error)
|
||||
GetWithParticipants(id string) (*MediaFile, error)
|
||||
GetAll(options ...QueryOptions) (MediaFiles, error)
|
||||
Search(q string, offset int, size int) (MediaFiles, error)
|
||||
GetCursor(options ...QueryOptions) (MediaFileCursor, error)
|
||||
Delete(id string) error
|
||||
DeleteMissing(ids []string) error
|
||||
FindByPaths(paths []string) (MediaFiles, error)
|
||||
|
||||
// Queries by path to support the scanner, no Annotations or Bookmarks required in the response
|
||||
FindAllByPath(path string) (MediaFiles, error)
|
||||
FindPathsRecursively(basePath string) ([]string, error)
|
||||
DeleteByPath(path string) (int64, error)
|
||||
// The following methods are used exclusively by the scanner:
|
||||
MarkMissing(bool, ...*MediaFile) error
|
||||
MarkMissingByFolder(missing bool, folderIDs ...string) error
|
||||
GetMissingAndMatching(libId int) (MediaFileCursor, error)
|
||||
|
||||
AnnotatedRepository
|
||||
BookmarkableRepository
|
||||
SearchableRepository[MediaFiles]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,25 +9,24 @@ import (
|
|||
var _ = Describe("fixAlbumArtist", func() {
|
||||
var album Album
|
||||
BeforeEach(func() {
|
||||
album = Album{}
|
||||
album = Album{Participants: Participants{}}
|
||||
})
|
||||
Context("Non-Compilations", func() {
|
||||
BeforeEach(func() {
|
||||
album.Compilation = false
|
||||
album.Artist = "Sparks"
|
||||
album.ArtistID = "ar-123"
|
||||
album.Participants.Add(RoleArtist, Artist{ID: "ar-123", Name: "Sparks"})
|
||||
})
|
||||
It("returns the track artist if no album artist is specified", func() {
|
||||
al := fixAlbumArtist(album, nil)
|
||||
Expect(al.AlbumArtistID).To(Equal("ar-123"))
|
||||
Expect(al.AlbumArtist).To(Equal("Sparks"))
|
||||
fixAlbumArtist(&album)
|
||||
Expect(album.AlbumArtistID).To(Equal("ar-123"))
|
||||
Expect(album.AlbumArtist).To(Equal("Sparks"))
|
||||
})
|
||||
It("returns the album artist if it is specified", func() {
|
||||
album.AlbumArtist = "Sparks Brothers"
|
||||
album.AlbumArtistID = "ar-345"
|
||||
al := fixAlbumArtist(album, nil)
|
||||
Expect(al.AlbumArtistID).To(Equal("ar-345"))
|
||||
Expect(al.AlbumArtist).To(Equal("Sparks Brothers"))
|
||||
fixAlbumArtist(&album)
|
||||
Expect(album.AlbumArtistID).To(Equal("ar-345"))
|
||||
Expect(album.AlbumArtist).To(Equal("Sparks Brothers"))
|
||||
})
|
||||
})
|
||||
Context("Compilations", func() {
|
||||
|
|
@ -39,15 +38,18 @@ var _ = Describe("fixAlbumArtist", func() {
|
|||
})
|
||||
|
||||
It("returns VariousArtists if there's more than one album artist", func() {
|
||||
al := fixAlbumArtist(album, []string{"ar-123", "ar-345"})
|
||||
Expect(al.AlbumArtistID).To(Equal(consts.VariousArtistsID))
|
||||
Expect(al.AlbumArtist).To(Equal(consts.VariousArtists))
|
||||
album.Participants.Add(RoleAlbumArtist, Artist{ID: "ar-123", Name: "Sparks"})
|
||||
album.Participants.Add(RoleAlbumArtist, Artist{ID: "ar-345", Name: "The Beach"})
|
||||
fixAlbumArtist(&album)
|
||||
Expect(album.AlbumArtistID).To(Equal(consts.VariousArtistsID))
|
||||
Expect(album.AlbumArtist).To(Equal(consts.VariousArtists))
|
||||
})
|
||||
|
||||
It("returns the sole album artist if they are the same", func() {
|
||||
al := fixAlbumArtist(album, []string{"ar-000", "ar-000"})
|
||||
Expect(al.AlbumArtistID).To(Equal("ar-000"))
|
||||
Expect(al.AlbumArtist).To(Equal("The Beatles"))
|
||||
album.Participants.Add(RoleAlbumArtist, Artist{ID: "ar-000", Name: "The Beatles"})
|
||||
fixAlbumArtist(&album)
|
||||
Expect(album.AlbumArtistID).To(Equal("ar-000"))
|
||||
Expect(album.AlbumArtist).To(Equal("The Beatles"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
|
|||
|
|
@ -1,12 +1,10 @@
|
|||
package model_test
|
||||
|
||||
import (
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
||||
"github.com/navidrome/navidrome/conf"
|
||||
"github.com/navidrome/navidrome/conf/configtest"
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
. "github.com/navidrome/navidrome/model"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
|
|
@ -14,6 +12,7 @@ import (
|
|||
|
||||
var _ = Describe("MediaFiles", func() {
|
||||
var mfs MediaFiles
|
||||
|
||||
Describe("ToAlbum", func() {
|
||||
Context("Simple attributes", func() {
|
||||
BeforeEach(func() {
|
||||
|
|
@ -23,14 +22,15 @@ var _ = Describe("MediaFiles", func() {
|
|||
SortAlbumName: "SortAlbumName", SortArtistName: "SortArtistName", SortAlbumArtistName: "SortAlbumArtistName",
|
||||
OrderAlbumName: "OrderAlbumName", OrderAlbumArtistName: "OrderAlbumArtistName",
|
||||
MbzAlbumArtistID: "MbzAlbumArtistID", MbzAlbumType: "MbzAlbumType", MbzAlbumComment: "MbzAlbumComment",
|
||||
Compilation: false, CatalogNum: "", Path: "/music1/file1.mp3",
|
||||
MbzReleaseGroupID: "MbzReleaseGroupID", Compilation: false, CatalogNum: "", Path: "/music1/file1.mp3", FolderID: "Folder1",
|
||||
},
|
||||
{
|
||||
ID: "2", Album: "Album", ArtistID: "ArtistID", Artist: "Artist", AlbumArtistID: "AlbumArtistID", AlbumArtist: "AlbumArtist", AlbumID: "AlbumID",
|
||||
SortAlbumName: "SortAlbumName", SortArtistName: "SortArtistName", SortAlbumArtistName: "SortAlbumArtistName",
|
||||
OrderAlbumName: "OrderAlbumName", OrderArtistName: "OrderArtistName", OrderAlbumArtistName: "OrderAlbumArtistName",
|
||||
MbzAlbumArtistID: "MbzAlbumArtistID", MbzAlbumType: "MbzAlbumType", MbzAlbumComment: "MbzAlbumComment",
|
||||
Compilation: true, CatalogNum: "CatalogNum", HasCoverArt: true, Path: "/music2/file2.mp3",
|
||||
MbzReleaseGroupID: "MbzReleaseGroupID",
|
||||
Compilation: true, CatalogNum: "CatalogNum", HasCoverArt: true, Path: "/music2/file2.mp3", FolderID: "Folder2",
|
||||
},
|
||||
}
|
||||
})
|
||||
|
|
@ -39,8 +39,6 @@ var _ = Describe("MediaFiles", func() {
|
|||
album := mfs.ToAlbum()
|
||||
Expect(album.ID).To(Equal("AlbumID"))
|
||||
Expect(album.Name).To(Equal("Album"))
|
||||
Expect(album.Artist).To(Equal("Artist"))
|
||||
Expect(album.ArtistID).To(Equal("ArtistID"))
|
||||
Expect(album.AlbumArtist).To(Equal("AlbumArtist"))
|
||||
Expect(album.AlbumArtistID).To(Equal("AlbumArtistID"))
|
||||
Expect(album.SortAlbumName).To(Equal("SortAlbumName"))
|
||||
|
|
@ -50,17 +48,33 @@ var _ = Describe("MediaFiles", func() {
|
|||
Expect(album.MbzAlbumArtistID).To(Equal("MbzAlbumArtistID"))
|
||||
Expect(album.MbzAlbumType).To(Equal("MbzAlbumType"))
|
||||
Expect(album.MbzAlbumComment).To(Equal("MbzAlbumComment"))
|
||||
Expect(album.MbzReleaseGroupID).To(Equal("MbzReleaseGroupID"))
|
||||
Expect(album.CatalogNum).To(Equal("CatalogNum"))
|
||||
Expect(album.Compilation).To(BeTrue())
|
||||
Expect(album.EmbedArtPath).To(Equal("/music2/file2.mp3"))
|
||||
Expect(album.Paths).To(Equal("/music1" + consts.Zwsp + "/music2"))
|
||||
Expect(album.FolderIDs).To(ConsistOf("Folder1", "Folder2"))
|
||||
})
|
||||
})
|
||||
Context("Aggregated attributes", func() {
|
||||
When("we don't have any songs", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{}
|
||||
})
|
||||
It("returns an empty album", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.Duration).To(Equal(float32(0)))
|
||||
Expect(album.Size).To(Equal(int64(0)))
|
||||
Expect(album.MinYear).To(Equal(0))
|
||||
Expect(album.MaxYear).To(Equal(0))
|
||||
Expect(album.Date).To(BeEmpty())
|
||||
Expect(album.UpdatedAt).To(BeZero())
|
||||
Expect(album.CreatedAt).To(BeZero())
|
||||
})
|
||||
})
|
||||
When("we have only one song", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{Duration: 100.2, Size: 1024, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:30"), CreatedAt: t("2022-12-19 08:30")},
|
||||
{Duration: 100.2, Size: 1024, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:30"), BirthTime: t("2022-12-19 08:30")},
|
||||
}
|
||||
})
|
||||
It("calculates the aggregates correctly", func() {
|
||||
|
|
@ -78,9 +92,9 @@ var _ = Describe("MediaFiles", func() {
|
|||
When("we have multiple songs with different dates", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{Duration: 100.2, Size: 1024, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:30"), CreatedAt: t("2022-12-19 08:30")},
|
||||
{Duration: 200.2, Size: 2048, Year: 0, Date: "", UpdatedAt: t("2022-12-19 09:45"), CreatedAt: t("2022-12-19 08:30")},
|
||||
{Duration: 150.6, Size: 1000, Year: 1986, Date: "1986-01-02", UpdatedAt: t("2022-12-19 09:45"), CreatedAt: t("2022-12-19 07:30")},
|
||||
{Duration: 100.2, Size: 1024, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:30"), BirthTime: t("2022-12-19 08:30")},
|
||||
{Duration: 200.2, Size: 2048, Year: 0, Date: "", UpdatedAt: t("2022-12-19 09:45"), BirthTime: t("2022-12-19 08:30")},
|
||||
{Duration: 150.6, Size: 1000, Year: 1986, Date: "1986-01-02", UpdatedAt: t("2022-12-19 09:45"), BirthTime: t("2022-12-19 07:30")},
|
||||
}
|
||||
})
|
||||
It("calculates the aggregates correctly", func() {
|
||||
|
|
@ -109,9 +123,9 @@ var _ = Describe("MediaFiles", func() {
|
|||
When("we have multiple songs with same dates", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{Duration: 100.2, Size: 1024, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:30"), CreatedAt: t("2022-12-19 08:30")},
|
||||
{Duration: 200.2, Size: 2048, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:45"), CreatedAt: t("2022-12-19 08:30")},
|
||||
{Duration: 150.6, Size: 1000, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:45"), CreatedAt: t("2022-12-19 07:30")},
|
||||
{Duration: 100.2, Size: 1024, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:30"), BirthTime: t("2022-12-19 08:30")},
|
||||
{Duration: 200.2, Size: 2048, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:45"), BirthTime: t("2022-12-19 08:30")},
|
||||
{Duration: 150.6, Size: 1000, Year: 1985, Date: "1985-01-02", UpdatedAt: t("2022-12-19 09:45"), BirthTime: t("2022-12-19 07:30")},
|
||||
}
|
||||
})
|
||||
It("sets the date field correctly", func() {
|
||||
|
|
@ -121,16 +135,24 @@ var _ = Describe("MediaFiles", func() {
|
|||
Expect(album.MaxYear).To(Equal(1985))
|
||||
})
|
||||
})
|
||||
DescribeTable("explicitStatus",
|
||||
func(mfs MediaFiles, status string) {
|
||||
Expect(mfs.ToAlbum().ExplicitStatus).To(Equal(status))
|
||||
},
|
||||
Entry("sets the album to clean when a clean song is present", MediaFiles{{ExplicitStatus: ""}, {ExplicitStatus: "c"}, {ExplicitStatus: ""}}, "c"),
|
||||
Entry("sets the album to explicit when an explicit song is present", MediaFiles{{ExplicitStatus: ""}, {ExplicitStatus: "e"}, {ExplicitStatus: ""}}, "e"),
|
||||
Entry("takes precedence of explicit songs over clean ones", MediaFiles{{ExplicitStatus: "e"}, {ExplicitStatus: "c"}, {ExplicitStatus: ""}}, "e"),
|
||||
)
|
||||
})
|
||||
Context("Calculated attributes", func() {
|
||||
Context("Discs", func() {
|
||||
When("we have no discs", func() {
|
||||
When("we have no discs info", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{{Album: "Album1"}, {Album: "Album1"}, {Album: "Album1"}}
|
||||
})
|
||||
It("sets the correct Discs", func() {
|
||||
It("adds 1 disc without subtitle", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.Discs).To(BeEmpty())
|
||||
Expect(album.Discs).To(Equal(Discs{1: ""}))
|
||||
})
|
||||
})
|
||||
When("we have only one disc", func() {
|
||||
|
|
@ -153,38 +175,52 @@ var _ = Describe("MediaFiles", func() {
|
|||
})
|
||||
})
|
||||
|
||||
Context("Genres", func() {
|
||||
When("we have only one Genre", func() {
|
||||
Context("Genres/tags", func() {
|
||||
When("we don't have any tags", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{{Genres: Genres{{ID: "g1", Name: "Rock"}}}}
|
||||
mfs = MediaFiles{{}}
|
||||
})
|
||||
It("sets the correct Genre", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.Genre).To(Equal("Rock"))
|
||||
Expect(album.Genres).To(ConsistOf(Genre{ID: "g1", Name: "Rock"}))
|
||||
Expect(album.Tags).To(BeEmpty())
|
||||
})
|
||||
})
|
||||
When("we have only one Genre", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{{Tags: Tags{"genre": []string{"Rock"}}}}
|
||||
})
|
||||
It("sets the correct Genre", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.Tags).To(HaveLen(1))
|
||||
Expect(album.Tags).To(HaveKeyWithValue(TagGenre, []string{"Rock"}))
|
||||
})
|
||||
})
|
||||
When("we have multiple Genres", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{{Genres: Genres{{ID: "g1", Name: "Rock"}, {ID: "g2", Name: "Punk"}, {ID: "g3", Name: "Alternative"}}}}
|
||||
mfs = MediaFiles{
|
||||
{Tags: Tags{"genre": []string{"Punk"}, "mood": []string{"Happy", "Chill"}}},
|
||||
{Tags: Tags{"genre": []string{"Rock"}}},
|
||||
{Tags: Tags{"genre": []string{"Alternative", "Rock"}}},
|
||||
}
|
||||
})
|
||||
It("sets the correct Genre", func() {
|
||||
It("sets the correct Genre, sorted by frequency, then alphabetically", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.Genre).To(Equal("Rock"))
|
||||
Expect(album.Genres).To(Equal(Genres{{ID: "g1", Name: "Rock"}, {ID: "g2", Name: "Punk"}, {ID: "g3", Name: "Alternative"}}))
|
||||
Expect(album.Tags).To(HaveLen(2))
|
||||
Expect(album.Tags).To(HaveKeyWithValue(TagGenre, []string{"Rock", "Alternative", "Punk"}))
|
||||
Expect(album.Tags).To(HaveKeyWithValue(TagMood, []string{"Chill", "Happy"}))
|
||||
})
|
||||
})
|
||||
When("we have one predominant Genre", func() {
|
||||
var album Album
|
||||
When("we have tags with mismatching case", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{{Genres: Genres{{ID: "g2", Name: "Punk"}, {ID: "g1", Name: "Rock"}, {ID: "g2", Name: "Punk"}}}}
|
||||
album = mfs.ToAlbum()
|
||||
mfs = MediaFiles{
|
||||
{Tags: Tags{"genre": []string{"synthwave"}}},
|
||||
{Tags: Tags{"genre": []string{"Synthwave"}}},
|
||||
}
|
||||
})
|
||||
It("sets the correct Genre", func() {
|
||||
Expect(album.Genre).To(Equal("Punk"))
|
||||
})
|
||||
It("removes duplications from Genres", func() {
|
||||
Expect(album.Genres).To(Equal(Genres{{ID: "g1", Name: "Rock"}, {ID: "g2", Name: "Punk"}}))
|
||||
It("normalizes the tags in just one", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.Tags).To(HaveLen(1))
|
||||
Expect(album.Tags).To(HaveKeyWithValue(TagGenre, []string{"Synthwave"}))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
@ -211,41 +247,42 @@ var _ = Describe("MediaFiles", func() {
|
|||
BeforeEach(func() {
|
||||
mfs = MediaFiles{{Comment: "comment1"}, {Comment: "not the same"}, {Comment: "comment1"}}
|
||||
})
|
||||
It("sets the correct Genre", func() {
|
||||
It("sets the correct comment", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.Comment).To(BeEmpty())
|
||||
})
|
||||
})
|
||||
})
|
||||
Context("AllArtistIds", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{AlbumArtistID: "22", ArtistID: "11"},
|
||||
{AlbumArtistID: "22", ArtistID: "33"},
|
||||
{AlbumArtistID: "22", ArtistID: "11"},
|
||||
}
|
||||
})
|
||||
It("removes duplications", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.AllArtistIDs).To(Equal("11 22 33"))
|
||||
})
|
||||
})
|
||||
Context("FullText", func() {
|
||||
Context("Participants", func() {
|
||||
var album Album
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{
|
||||
Album: "Album1", AlbumArtist: "AlbumArtist1", Artist: "Artist1", DiscSubtitle: "DiscSubtitle1",
|
||||
SortAlbumName: "SortAlbumName1", SortAlbumArtistName: "SortAlbumArtistName1", SortArtistName: "SortArtistName1",
|
||||
Album: "Album1", AlbumArtistID: "AA1", AlbumArtist: "Display AlbumArtist1", Artist: "Artist1",
|
||||
DiscSubtitle: "DiscSubtitle1", SortAlbumName: "SortAlbumName1",
|
||||
Participants: Participants{
|
||||
RoleAlbumArtist: ParticipantList{_p("AA1", "AlbumArtist1", "SortAlbumArtistName1")},
|
||||
RoleArtist: ParticipantList{_p("A1", "Artist1", "SortArtistName1")},
|
||||
},
|
||||
},
|
||||
{
|
||||
Album: "Album1", AlbumArtist: "AlbumArtist1", Artist: "Artist2", DiscSubtitle: "DiscSubtitle2",
|
||||
SortAlbumName: "SortAlbumName1", SortAlbumArtistName: "SortAlbumArtistName1", SortArtistName: "SortArtistName2",
|
||||
Album: "Album1", AlbumArtistID: "AA1", AlbumArtist: "Display AlbumArtist1", Artist: "Artist2",
|
||||
DiscSubtitle: "DiscSubtitle2", SortAlbumName: "SortAlbumName1",
|
||||
Participants: Participants{
|
||||
RoleAlbumArtist: ParticipantList{_p("AA1", "AlbumArtist1", "SortAlbumArtistName1")},
|
||||
RoleArtist: ParticipantList{_p("A2", "Artist2", "SortArtistName2")},
|
||||
RoleComposer: ParticipantList{_p("C1", "Composer1")},
|
||||
},
|
||||
},
|
||||
}
|
||||
album = mfs.ToAlbum()
|
||||
})
|
||||
It("fills the fullText attribute correctly", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.FullText).To(Equal(" album1 albumartist1 artist1 artist2 discsubtitle1 discsubtitle2 sortalbumartistname1 sortalbumname1 sortartistname1 sortartistname2"))
|
||||
It("gets all participants from all tracks", func() {
|
||||
Expect(album.Participants).To(HaveKeyWithValue(RoleAlbumArtist, ParticipantList{_p("AA1", "AlbumArtist1", "SortAlbumArtistName1")}))
|
||||
Expect(album.Participants).To(HaveKeyWithValue(RoleComposer, ParticipantList{_p("C1", "Composer1")}))
|
||||
Expect(album.Participants).To(HaveKeyWithValue(RoleArtist, ParticipantList{
|
||||
_p("A1", "Artist1", "SortArtistName1"), _p("A2", "Artist2", "SortArtistName2"),
|
||||
}))
|
||||
})
|
||||
})
|
||||
Context("MbzAlbumID", func() {
|
||||
|
|
@ -262,7 +299,7 @@ var _ = Describe("MediaFiles", func() {
|
|||
BeforeEach(func() {
|
||||
mfs = MediaFiles{{MbzAlbumID: "id1"}, {MbzAlbumID: "id2"}, {MbzAlbumID: "id1"}}
|
||||
})
|
||||
It("sets the correct MbzAlbumID", func() {
|
||||
It("uses the most frequent MbzAlbumID", func() {
|
||||
album := mfs.ToAlbum()
|
||||
Expect(album.MbzAlbumID).To(Equal("id1"))
|
||||
})
|
||||
|
|
@ -270,66 +307,6 @@ var _ = Describe("MediaFiles", func() {
|
|||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Dirs", func() {
|
||||
var mfs MediaFiles
|
||||
|
||||
When("there are no media files", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{}
|
||||
})
|
||||
It("returns an empty list", func() {
|
||||
Expect(mfs.Dirs()).To(BeEmpty())
|
||||
})
|
||||
})
|
||||
|
||||
When("there is one media file", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{Path: "/music/artist/album/song.mp3"},
|
||||
}
|
||||
})
|
||||
It("returns the directory of the media file", func() {
|
||||
Expect(mfs.Dirs()).To(Equal([]string{filepath.Clean("/music/artist/album")}))
|
||||
})
|
||||
})
|
||||
|
||||
When("there are multiple media files in the same directory", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{Path: "/music/artist/album/song1.mp3"},
|
||||
{Path: "/music/artist/album/song2.mp3"},
|
||||
}
|
||||
})
|
||||
It("returns a single directory", func() {
|
||||
Expect(mfs.Dirs()).To(Equal([]string{filepath.Clean("/music/artist/album")}))
|
||||
})
|
||||
})
|
||||
|
||||
When("there are multiple media files in different directories", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{Path: "/music/artist2/album/song2.mp3"},
|
||||
{Path: "/music/artist1/album/song1.mp3"},
|
||||
}
|
||||
})
|
||||
It("returns all directories", func() {
|
||||
Expect(mfs.Dirs()).To(Equal([]string{filepath.Clean("/music/artist1/album"), filepath.Clean("/music/artist2/album")}))
|
||||
})
|
||||
})
|
||||
|
||||
When("there are media files with empty paths", func() {
|
||||
BeforeEach(func() {
|
||||
mfs = MediaFiles{
|
||||
{Path: ""},
|
||||
{Path: "/music/artist/album/song.mp3"},
|
||||
}
|
||||
})
|
||||
It("ignores the empty paths", func() {
|
||||
Expect(mfs.Dirs()).To(Equal([]string{".", filepath.Clean("/music/artist/album")}))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
var _ = Describe("MediaFile", func() {
|
||||
|
|
|
|||
70
model/metadata/legacy_ids.go
Normal file
70
model/metadata/legacy_ids.go
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
package metadata
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
"crypto/md5"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/navidrome/navidrome/conf"
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
"github.com/navidrome/navidrome/model"
|
||||
)
|
||||
|
||||
// These are the legacy ID functions that were used in the original Navidrome ID generation.
|
||||
// They are kept here for backwards compatibility with existing databases.
|
||||
|
||||
func legacyTrackID(mf model.MediaFile) string {
|
||||
return fmt.Sprintf("%x", md5.Sum([]byte(mf.Path)))
|
||||
}
|
||||
|
||||
func legacyAlbumID(md Metadata) string {
|
||||
releaseDate := legacyReleaseDate(md)
|
||||
albumPath := strings.ToLower(fmt.Sprintf("%s\\%s", legacyMapAlbumArtistName(md), legacyMapAlbumName(md)))
|
||||
if !conf.Server.Scanner.GroupAlbumReleases {
|
||||
if len(releaseDate) != 0 {
|
||||
albumPath = fmt.Sprintf("%s\\%s", albumPath, releaseDate)
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf("%x", md5.Sum([]byte(albumPath)))
|
||||
}
|
||||
|
||||
func legacyMapAlbumArtistName(md Metadata) string {
|
||||
values := []string{
|
||||
md.String(model.TagAlbumArtist),
|
||||
"",
|
||||
md.String(model.TagTrackArtist),
|
||||
consts.UnknownArtist,
|
||||
}
|
||||
if md.Bool(model.TagCompilation) {
|
||||
values[1] = consts.VariousArtists
|
||||
}
|
||||
return cmp.Or(values...)
|
||||
}
|
||||
|
||||
func legacyMapAlbumName(md Metadata) string {
|
||||
return cmp.Or(
|
||||
md.String(model.TagAlbum),
|
||||
consts.UnknownAlbum,
|
||||
)
|
||||
}
|
||||
|
||||
// Keep the TaggedLikePicard logic for backwards compatibility
|
||||
func legacyReleaseDate(md Metadata) string {
|
||||
// Start with defaults
|
||||
date := md.Date(model.TagRecordingDate)
|
||||
year := date.Year()
|
||||
originalDate := md.Date(model.TagOriginalDate)
|
||||
originalYear := originalDate.Year()
|
||||
releaseDate := md.Date(model.TagReleaseDate)
|
||||
releaseYear := releaseDate.Year()
|
||||
|
||||
// MusicBrainz Picard writes the Release Date of an album to the Date tag, and leaves the Release Date tag empty
|
||||
taggedLikePicard := (originalYear != 0) &&
|
||||
(releaseYear == 0) &&
|
||||
(year >= originalYear)
|
||||
if taggedLikePicard {
|
||||
return string(date)
|
||||
}
|
||||
return string(releaseDate)
|
||||
}
|
||||
166
model/metadata/map_mediafile.go
Normal file
166
model/metadata/map_mediafile.go
Normal file
|
|
@ -0,0 +1,166 @@
|
|||
package metadata
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"maps"
|
||||
"math"
|
||||
"strconv"
|
||||
|
||||
"github.com/navidrome/navidrome/log"
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/model/id"
|
||||
"github.com/navidrome/navidrome/utils/str"
|
||||
)
|
||||
|
||||
func (md Metadata) ToMediaFile(libID int, folderID string) model.MediaFile {
|
||||
mf := model.MediaFile{
|
||||
LibraryID: libID,
|
||||
FolderID: folderID,
|
||||
Tags: maps.Clone(md.tags),
|
||||
}
|
||||
|
||||
// Title and Album
|
||||
mf.Title = md.mapTrackTitle()
|
||||
mf.Album = md.mapAlbumName()
|
||||
mf.SortTitle = md.String(model.TagTitleSort)
|
||||
mf.SortAlbumName = md.String(model.TagAlbumSort)
|
||||
mf.OrderTitle = str.SanitizeFieldForSorting(mf.Title)
|
||||
mf.OrderAlbumName = str.SanitizeFieldForSortingNoArticle(mf.Album)
|
||||
mf.Compilation = md.Bool(model.TagCompilation)
|
||||
|
||||
// Disc and Track info
|
||||
mf.TrackNumber, _ = md.NumAndTotal(model.TagTrackNumber)
|
||||
mf.DiscNumber, _ = md.NumAndTotal(model.TagDiscNumber)
|
||||
mf.DiscSubtitle = md.String(model.TagDiscSubtitle)
|
||||
mf.CatalogNum = md.String(model.TagCatalogNumber)
|
||||
mf.Comment = md.String(model.TagComment)
|
||||
mf.BPM = int(math.Round(md.Float(model.TagBPM)))
|
||||
mf.Lyrics = md.mapLyrics()
|
||||
mf.ExplicitStatus = md.mapExplicitStatusTag()
|
||||
|
||||
// Dates
|
||||
origDate := md.Date(model.TagOriginalDate)
|
||||
mf.OriginalYear, mf.OriginalDate = origDate.Year(), string(origDate)
|
||||
relDate := md.Date(model.TagReleaseDate)
|
||||
mf.ReleaseYear, mf.ReleaseDate = relDate.Year(), string(relDate)
|
||||
date := md.Date(model.TagRecordingDate)
|
||||
mf.Year, mf.Date = date.Year(), string(date)
|
||||
|
||||
// MBIDs
|
||||
mf.MbzRecordingID = md.String(model.TagMusicBrainzRecordingID)
|
||||
mf.MbzReleaseTrackID = md.String(model.TagMusicBrainzTrackID)
|
||||
mf.MbzAlbumID = md.String(model.TagMusicBrainzAlbumID)
|
||||
mf.MbzReleaseGroupID = md.String(model.TagMusicBrainzReleaseGroupID)
|
||||
|
||||
// ReplayGain
|
||||
mf.RGAlbumPeak = md.Float(model.TagReplayGainAlbumPeak, 1)
|
||||
mf.RGAlbumGain = md.mapGain(model.TagReplayGainAlbumGain, model.TagR128AlbumGain)
|
||||
mf.RGTrackPeak = md.Float(model.TagReplayGainTrackPeak, 1)
|
||||
mf.RGTrackGain = md.mapGain(model.TagReplayGainTrackGain, model.TagR128TrackGain)
|
||||
|
||||
// General properties
|
||||
mf.HasCoverArt = md.HasPicture()
|
||||
mf.Duration = md.Length()
|
||||
mf.BitRate = md.AudioProperties().BitRate
|
||||
mf.SampleRate = md.AudioProperties().SampleRate
|
||||
mf.BitDepth = md.AudioProperties().BitDepth
|
||||
mf.Channels = md.AudioProperties().Channels
|
||||
mf.Path = md.FilePath()
|
||||
mf.Suffix = md.Suffix()
|
||||
mf.Size = md.Size()
|
||||
mf.BirthTime = md.BirthTime()
|
||||
mf.UpdatedAt = md.ModTime()
|
||||
|
||||
mf.Participants = md.mapParticipants()
|
||||
mf.Artist = md.mapDisplayArtist(mf)
|
||||
mf.AlbumArtist = md.mapDisplayAlbumArtist(mf)
|
||||
|
||||
// Persistent IDs
|
||||
mf.PID = md.trackPID(mf)
|
||||
mf.AlbumID = md.albumID(mf)
|
||||
|
||||
// BFR These IDs will go away once the UI handle multiple participants.
|
||||
// BFR For Legacy Subsonic compatibility, we will set them in the API handlers
|
||||
mf.ArtistID = mf.Participants.First(model.RoleArtist).ID
|
||||
mf.AlbumArtistID = mf.Participants.First(model.RoleAlbumArtist).ID
|
||||
|
||||
// BFR What to do with sort/order artist names?
|
||||
mf.OrderArtistName = mf.Participants.First(model.RoleArtist).OrderArtistName
|
||||
mf.OrderAlbumArtistName = mf.Participants.First(model.RoleAlbumArtist).OrderArtistName
|
||||
mf.SortArtistName = mf.Participants.First(model.RoleArtist).SortArtistName
|
||||
mf.SortAlbumArtistName = mf.Participants.First(model.RoleAlbumArtist).SortArtistName
|
||||
|
||||
// Don't store tags that are first-class fields (and are not album-level tags) in the
|
||||
// MediaFile struct. This is to avoid redundancy in the DB
|
||||
//
|
||||
// Remove all tags from the main section that are not flagged as album tags
|
||||
for tag, conf := range model.TagMainMappings() {
|
||||
if !conf.Album {
|
||||
delete(mf.Tags, tag)
|
||||
}
|
||||
}
|
||||
|
||||
return mf
|
||||
}
|
||||
|
||||
func (md Metadata) AlbumID(mf model.MediaFile, pidConf string) string {
|
||||
getPID := createGetPID(id.NewHash)
|
||||
return getPID(mf, md, pidConf)
|
||||
}
|
||||
|
||||
func (md Metadata) mapGain(rg, r128 model.TagName) float64 {
|
||||
v := md.Gain(rg)
|
||||
if v != 0 {
|
||||
return v
|
||||
}
|
||||
r128value := md.String(r128)
|
||||
if r128value != "" {
|
||||
var v, err = strconv.Atoi(r128value)
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
// Convert Q7.8 to float
|
||||
var value = float64(v) / 256.0
|
||||
// Adding 5 dB to normalize with ReplayGain level
|
||||
return value + 5
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (md Metadata) mapLyrics() string {
|
||||
rawLyrics := md.Pairs(model.TagLyrics)
|
||||
|
||||
lyricList := make(model.LyricList, 0, len(rawLyrics))
|
||||
|
||||
for _, raw := range rawLyrics {
|
||||
lang := raw.Key()
|
||||
text := raw.Value()
|
||||
|
||||
lyrics, err := model.ToLyrics(lang, text)
|
||||
if err != nil {
|
||||
log.Warn("Unexpected failure occurred when parsing lyrics", "file", md.filePath, err)
|
||||
continue
|
||||
}
|
||||
if !lyrics.IsEmpty() {
|
||||
lyricList = append(lyricList, *lyrics)
|
||||
}
|
||||
}
|
||||
|
||||
res, err := json.Marshal(lyricList)
|
||||
if err != nil {
|
||||
log.Warn("Unexpected error occurred when serializing lyrics", "file", md.filePath, err)
|
||||
return ""
|
||||
}
|
||||
return string(res)
|
||||
}
|
||||
|
||||
func (md Metadata) mapExplicitStatusTag() string {
|
||||
switch md.first(model.TagExplicitStatus) {
|
||||
case "1", "4":
|
||||
return "e"
|
||||
case "2":
|
||||
return "c"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
78
model/metadata/map_mediafile_test.go
Normal file
78
model/metadata/map_mediafile_test.go
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
package metadata_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
"sort"
|
||||
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/model/metadata"
|
||||
"github.com/navidrome/navidrome/tests"
|
||||
. "github.com/navidrome/navidrome/utils/gg"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("ToMediaFile", func() {
|
||||
var (
|
||||
props metadata.Info
|
||||
md metadata.Metadata
|
||||
mf model.MediaFile
|
||||
)
|
||||
|
||||
BeforeEach(func() {
|
||||
_, filePath, _ := tests.TempFile(GinkgoT(), "test", ".mp3")
|
||||
fileInfo, _ := os.Stat(filePath)
|
||||
props = metadata.Info{
|
||||
FileInfo: testFileInfo{fileInfo},
|
||||
}
|
||||
})
|
||||
|
||||
var toMediaFile = func(tags model.RawTags) model.MediaFile {
|
||||
props.Tags = tags
|
||||
md = metadata.New("filepath", props)
|
||||
return md.ToMediaFile(1, "folderID")
|
||||
}
|
||||
|
||||
Describe("Dates", func() {
|
||||
It("should parse the dates like Picard", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ORIGINALDATE": {"1978-09-10"},
|
||||
"DATE": {"1977-03-04"},
|
||||
"RELEASEDATE": {"2002-01-02"},
|
||||
})
|
||||
|
||||
Expect(mf.Year).To(Equal(1977))
|
||||
Expect(mf.Date).To(Equal("1977-03-04"))
|
||||
Expect(mf.OriginalYear).To(Equal(1978))
|
||||
Expect(mf.OriginalDate).To(Equal("1978-09-10"))
|
||||
Expect(mf.ReleaseYear).To(Equal(2002))
|
||||
Expect(mf.ReleaseDate).To(Equal("2002-01-02"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Lyrics", func() {
|
||||
It("should parse the lyrics", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"LYRICS:XXX": {"Lyrics"},
|
||||
"LYRICS:ENG": {
|
||||
"[00:00.00]This is\n[00:02.50]English SYLT\n",
|
||||
},
|
||||
})
|
||||
var actual model.LyricList
|
||||
err := json.Unmarshal([]byte(mf.Lyrics), &actual)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
expected := model.LyricList{
|
||||
{Lang: "eng", Line: []model.Line{
|
||||
{Value: "This is", Start: P(int64(0))},
|
||||
{Value: "English SYLT", Start: P(int64(2500))},
|
||||
}, Synced: true},
|
||||
{Lang: "xxx", Line: []model.Line{{Value: "Lyrics"}}, Synced: false},
|
||||
}
|
||||
sort.Slice(actual, func(i, j int) bool { return actual[i].Lang < actual[j].Lang })
|
||||
sort.Slice(expected, func(i, j int) bool { return expected[i].Lang < expected[j].Lang })
|
||||
Expect(actual).To(Equal(expected))
|
||||
})
|
||||
})
|
||||
})
|
||||
230
model/metadata/map_participants.go
Normal file
230
model/metadata/map_participants.go
Normal file
|
|
@ -0,0 +1,230 @@
|
|||
package metadata
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/utils/str"
|
||||
"golang.org/x/text/cases"
|
||||
"golang.org/x/text/language"
|
||||
)
|
||||
|
||||
type roleTags struct {
|
||||
name model.TagName
|
||||
sort model.TagName
|
||||
mbid model.TagName
|
||||
}
|
||||
|
||||
var roleMappings = map[model.Role]roleTags{
|
||||
model.RoleComposer: {name: model.TagComposer, sort: model.TagComposerSort, mbid: model.TagMusicBrainzComposerID},
|
||||
model.RoleLyricist: {name: model.TagLyricist, sort: model.TagLyricistSort, mbid: model.TagMusicBrainzLyricistID},
|
||||
model.RoleConductor: {name: model.TagConductor, mbid: model.TagMusicBrainzConductorID},
|
||||
model.RoleArranger: {name: model.TagArranger, mbid: model.TagMusicBrainzArrangerID},
|
||||
model.RoleDirector: {name: model.TagDirector, mbid: model.TagMusicBrainzDirectorID},
|
||||
model.RoleProducer: {name: model.TagProducer, mbid: model.TagMusicBrainzProducerID},
|
||||
model.RoleEngineer: {name: model.TagEngineer, mbid: model.TagMusicBrainzEngineerID},
|
||||
model.RoleMixer: {name: model.TagMixer, mbid: model.TagMusicBrainzMixerID},
|
||||
model.RoleRemixer: {name: model.TagRemixer, mbid: model.TagMusicBrainzRemixerID},
|
||||
model.RoleDJMixer: {name: model.TagDJMixer, mbid: model.TagMusicBrainzDJMixerID},
|
||||
}
|
||||
|
||||
func (md Metadata) mapParticipants() model.Participants {
|
||||
participants := make(model.Participants)
|
||||
|
||||
// Parse track artists
|
||||
artists := md.parseArtists(
|
||||
model.TagTrackArtist, model.TagTrackArtists,
|
||||
model.TagTrackArtistSort, model.TagTrackArtistsSort,
|
||||
model.TagMusicBrainzArtistID,
|
||||
)
|
||||
participants.Add(model.RoleArtist, artists...)
|
||||
|
||||
// Parse album artists
|
||||
albumArtists := md.parseArtists(
|
||||
model.TagAlbumArtist, model.TagAlbumArtists,
|
||||
model.TagAlbumArtistSort, model.TagAlbumArtistsSort,
|
||||
model.TagMusicBrainzAlbumArtistID,
|
||||
)
|
||||
if len(albumArtists) == 1 && albumArtists[0].Name == consts.UnknownArtist {
|
||||
if md.Bool(model.TagCompilation) {
|
||||
albumArtists = md.buildArtists([]string{consts.VariousArtists}, nil, []string{consts.VariousArtistsMbzId})
|
||||
} else {
|
||||
albumArtists = artists
|
||||
}
|
||||
}
|
||||
participants.Add(model.RoleAlbumArtist, albumArtists...)
|
||||
|
||||
// Parse all other roles
|
||||
for role, info := range roleMappings {
|
||||
names := md.getRoleValues(info.name)
|
||||
if len(names) > 0 {
|
||||
sorts := md.Strings(info.sort)
|
||||
mbids := md.Strings(info.mbid)
|
||||
artists := md.buildArtists(names, sorts, mbids)
|
||||
participants.Add(role, artists...)
|
||||
}
|
||||
}
|
||||
|
||||
rolesMbzIdMap := md.buildRoleMbidMaps()
|
||||
md.processPerformers(participants, rolesMbzIdMap)
|
||||
md.syncMissingMbzIDs(participants)
|
||||
|
||||
return participants
|
||||
}
|
||||
|
||||
// buildRoleMbidMaps creates a map of roles to MBZ IDs
|
||||
func (md Metadata) buildRoleMbidMaps() map[string][]string {
|
||||
titleCaser := cases.Title(language.Und)
|
||||
rolesMbzIdMap := make(map[string][]string)
|
||||
for _, mbid := range md.Pairs(model.TagMusicBrainzPerformerID) {
|
||||
role := titleCaser.String(mbid.Key())
|
||||
rolesMbzIdMap[role] = append(rolesMbzIdMap[role], mbid.Value())
|
||||
}
|
||||
|
||||
return rolesMbzIdMap
|
||||
}
|
||||
|
||||
func (md Metadata) processPerformers(participants model.Participants, rolesMbzIdMap map[string][]string) {
|
||||
// roleIdx keeps track of the index of the MBZ ID for each role
|
||||
roleIdx := make(map[string]int)
|
||||
for role := range rolesMbzIdMap {
|
||||
roleIdx[role] = 0
|
||||
}
|
||||
|
||||
titleCaser := cases.Title(language.Und)
|
||||
for _, performer := range md.Pairs(model.TagPerformer) {
|
||||
name := performer.Value()
|
||||
subRole := titleCaser.String(performer.Key())
|
||||
|
||||
artist := model.Artist{
|
||||
ID: md.artistID(name),
|
||||
Name: name,
|
||||
OrderArtistName: str.SanitizeFieldForSortingNoArticle(name),
|
||||
MbzArtistID: md.getPerformerMbid(subRole, rolesMbzIdMap, roleIdx),
|
||||
}
|
||||
participants.AddWithSubRole(model.RolePerformer, subRole, artist)
|
||||
}
|
||||
}
|
||||
|
||||
// getPerformerMbid returns the MBZ ID for a performer, based on the subrole
|
||||
func (md Metadata) getPerformerMbid(subRole string, rolesMbzIdMap map[string][]string, roleIdx map[string]int) string {
|
||||
if mbids, exists := rolesMbzIdMap[subRole]; exists && roleIdx[subRole] < len(mbids) {
|
||||
defer func() { roleIdx[subRole]++ }()
|
||||
return mbids[roleIdx[subRole]]
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// syncMissingMbzIDs fills in missing MBZ IDs for artists that have been previously parsed
|
||||
func (md Metadata) syncMissingMbzIDs(participants model.Participants) {
|
||||
artistMbzIDMap := make(map[string]string)
|
||||
for _, artist := range append(participants[model.RoleArtist], participants[model.RoleAlbumArtist]...) {
|
||||
if artist.MbzArtistID != "" {
|
||||
artistMbzIDMap[artist.Name] = artist.MbzArtistID
|
||||
}
|
||||
}
|
||||
|
||||
for role, list := range participants {
|
||||
for i, artist := range list {
|
||||
if artist.MbzArtistID == "" {
|
||||
if mbzID, exists := artistMbzIDMap[artist.Name]; exists {
|
||||
participants[role][i].MbzArtistID = mbzID
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (md Metadata) parseArtists(
|
||||
name model.TagName, names model.TagName, sort model.TagName,
|
||||
sorts model.TagName, mbid model.TagName,
|
||||
) []model.Artist {
|
||||
nameValues := md.getArtistValues(name, names)
|
||||
sortValues := md.getArtistValues(sort, sorts)
|
||||
mbids := md.Strings(mbid)
|
||||
if len(nameValues) == 0 {
|
||||
nameValues = []string{consts.UnknownArtist}
|
||||
}
|
||||
return md.buildArtists(nameValues, sortValues, mbids)
|
||||
}
|
||||
|
||||
func (md Metadata) buildArtists(names, sorts, mbids []string) []model.Artist {
|
||||
var artists []model.Artist
|
||||
for i, name := range names {
|
||||
id := md.artistID(name)
|
||||
artist := model.Artist{
|
||||
ID: id,
|
||||
Name: name,
|
||||
OrderArtistName: str.SanitizeFieldForSortingNoArticle(name),
|
||||
}
|
||||
if i < len(sorts) {
|
||||
artist.SortArtistName = sorts[i]
|
||||
}
|
||||
if i < len(mbids) {
|
||||
artist.MbzArtistID = mbids[i]
|
||||
}
|
||||
artists = append(artists, artist)
|
||||
}
|
||||
return artists
|
||||
}
|
||||
|
||||
// getRoleValues returns the values of a role tag, splitting them if necessary
|
||||
func (md Metadata) getRoleValues(role model.TagName) []string {
|
||||
values := md.Strings(role)
|
||||
if len(values) == 0 {
|
||||
return nil
|
||||
}
|
||||
if conf := model.TagRolesConf(); len(conf.Split) > 0 {
|
||||
values = conf.SplitTagValue(values)
|
||||
return filterDuplicatedOrEmptyValues(values)
|
||||
}
|
||||
return values
|
||||
}
|
||||
|
||||
// getArtistValues returns the values of a single or multi artist tag, splitting them if necessary
|
||||
func (md Metadata) getArtistValues(single, multi model.TagName) []string {
|
||||
vMulti := md.Strings(multi)
|
||||
if len(vMulti) > 0 {
|
||||
return vMulti
|
||||
}
|
||||
vSingle := md.Strings(single)
|
||||
if len(vSingle) != 1 {
|
||||
return vSingle
|
||||
}
|
||||
if conf := model.TagArtistsConf(); len(conf.Split) > 0 {
|
||||
vSingle = conf.SplitTagValue(vSingle)
|
||||
return filterDuplicatedOrEmptyValues(vSingle)
|
||||
}
|
||||
return vSingle
|
||||
}
|
||||
|
||||
func (md Metadata) getTags(tagNames ...model.TagName) []string {
|
||||
for _, tagName := range tagNames {
|
||||
values := md.Strings(tagName)
|
||||
if len(values) > 0 {
|
||||
return values
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (md Metadata) mapDisplayRole(mf model.MediaFile, role model.Role, tagNames ...model.TagName) string {
|
||||
artistNames := md.getTags(tagNames...)
|
||||
values := []string{
|
||||
"",
|
||||
mf.Participants.First(role).Name,
|
||||
consts.UnknownArtist,
|
||||
}
|
||||
if len(artistNames) == 1 {
|
||||
values[0] = artistNames[0]
|
||||
}
|
||||
return cmp.Or(values...)
|
||||
}
|
||||
|
||||
func (md Metadata) mapDisplayArtist(mf model.MediaFile) string {
|
||||
return md.mapDisplayRole(mf, model.RoleArtist, model.TagTrackArtist, model.TagTrackArtists)
|
||||
}
|
||||
|
||||
func (md Metadata) mapDisplayAlbumArtist(mf model.MediaFile) string {
|
||||
return md.mapDisplayRole(mf, model.RoleAlbumArtist, model.TagAlbumArtist, model.TagAlbumArtists)
|
||||
}
|
||||
593
model/metadata/map_participants_test.go
Normal file
593
model/metadata/map_participants_test.go
Normal file
|
|
@ -0,0 +1,593 @@
|
|||
package metadata_test
|
||||
|
||||
import (
|
||||
"os"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/model/metadata"
|
||||
"github.com/navidrome/navidrome/tests"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
. "github.com/onsi/gomega/gstruct"
|
||||
"github.com/onsi/gomega/types"
|
||||
)
|
||||
|
||||
var _ = Describe("Participants", func() {
|
||||
var (
|
||||
props metadata.Info
|
||||
md metadata.Metadata
|
||||
mf model.MediaFile
|
||||
mbid1, mbid2, mbid3 string
|
||||
)
|
||||
|
||||
BeforeEach(func() {
|
||||
_, filePath, _ := tests.TempFile(GinkgoT(), "test", ".mp3")
|
||||
fileInfo, _ := os.Stat(filePath)
|
||||
mbid1 = uuid.NewString()
|
||||
mbid2 = uuid.NewString()
|
||||
mbid3 = uuid.NewString()
|
||||
props = metadata.Info{
|
||||
FileInfo: testFileInfo{fileInfo},
|
||||
}
|
||||
})
|
||||
|
||||
var toMediaFile = func(tags model.RawTags) model.MediaFile {
|
||||
props.Tags = tags
|
||||
md = metadata.New("filepath", props)
|
||||
return md.ToMediaFile(1, "folderID")
|
||||
}
|
||||
|
||||
Describe("ARTIST(S) tags", func() {
|
||||
Context("No ARTIST/ARTISTS tags", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{})
|
||||
})
|
||||
|
||||
It("should set artist to Unknown Artist", func() {
|
||||
Expect(mf.Artist).To(Equal("[Unknown Artist]"))
|
||||
})
|
||||
|
||||
It("should add an Unknown Artist to participants", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2)) // ARTIST and ALBUMARTIST
|
||||
|
||||
artist := participants[model.RoleArtist][0]
|
||||
Expect(artist.ID).ToNot(BeEmpty())
|
||||
Expect(artist.Name).To(Equal("[Unknown Artist]"))
|
||||
Expect(artist.OrderArtistName).To(Equal("[unknown artist]"))
|
||||
Expect(artist.SortArtistName).To(BeEmpty())
|
||||
Expect(artist.MbzArtistID).To(BeEmpty())
|
||||
})
|
||||
})
|
||||
|
||||
Context("Single-valued ARTIST tags, no ARTISTS tags", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"Artist Name"},
|
||||
"ARTISTSORT": {"Name, Artist"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1},
|
||||
})
|
||||
})
|
||||
|
||||
It("should use the artist tag as display name", func() {
|
||||
Expect(mf.Artist).To(Equal("Artist Name"))
|
||||
})
|
||||
|
||||
It("should populate the participants", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2)) // ARTIST and ALBUMARTIST
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleArtist, HaveLen(1)),
|
||||
))
|
||||
Expect(mf.Artist).To(Equal("Artist Name"))
|
||||
|
||||
artist := participants[model.RoleArtist][0]
|
||||
|
||||
Expect(artist.ID).ToNot(BeEmpty())
|
||||
Expect(artist.Name).To(Equal("Artist Name"))
|
||||
Expect(artist.OrderArtistName).To(Equal("artist name"))
|
||||
Expect(artist.SortArtistName).To(Equal("Name, Artist"))
|
||||
Expect(artist.MbzArtistID).To(Equal(mbid1))
|
||||
})
|
||||
})
|
||||
Context("Multiple values in a Single-valued ARTIST tags, no ARTISTS tags", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"Artist Name feat. Someone Else"},
|
||||
"ARTISTSORT": {"Name, Artist feat. Else, Someone"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1},
|
||||
})
|
||||
})
|
||||
|
||||
It("should split the tag", func() {
|
||||
By("keeping the first artist as the display name")
|
||||
Expect(mf.Artist).To(Equal("Artist Name feat. Someone Else"))
|
||||
Expect(mf.SortArtistName).To(Equal("Name, Artist"))
|
||||
Expect(mf.OrderArtistName).To(Equal("artist name"))
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleArtist, HaveLen(2)),
|
||||
))
|
||||
|
||||
By("adding the first artist to the participants")
|
||||
artist0 := participants[model.RoleArtist][0]
|
||||
Expect(artist0.ID).ToNot(BeEmpty())
|
||||
Expect(artist0.Name).To(Equal("Artist Name"))
|
||||
Expect(artist0.OrderArtistName).To(Equal("artist name"))
|
||||
Expect(artist0.SortArtistName).To(Equal("Name, Artist"))
|
||||
|
||||
By("assuming the MBID is for the first artist")
|
||||
Expect(artist0.MbzArtistID).To(Equal(mbid1))
|
||||
|
||||
By("adding the second artist to the participants")
|
||||
artist1 := participants[model.RoleArtist][1]
|
||||
Expect(artist1.ID).ToNot(BeEmpty())
|
||||
Expect(artist1.Name).To(Equal("Someone Else"))
|
||||
Expect(artist1.OrderArtistName).To(Equal("someone else"))
|
||||
Expect(artist1.SortArtistName).To(Equal("Else, Someone"))
|
||||
Expect(artist1.MbzArtistID).To(BeEmpty())
|
||||
})
|
||||
It("should split the tag using case-insensitive separators", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"A1 FEAT. A2"},
|
||||
})
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleArtist, HaveLen(2)),
|
||||
))
|
||||
|
||||
artist1 := participants[model.RoleArtist][0]
|
||||
Expect(artist1.Name).To(Equal("A1"))
|
||||
artist2 := participants[model.RoleArtist][1]
|
||||
Expect(artist2.Name).To(Equal("A2"))
|
||||
})
|
||||
|
||||
It("should not add an empty artist after split", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"John Doe / / Jane Doe"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(model.RoleArtist, HaveLen(2)))
|
||||
artists := participants[model.RoleArtist]
|
||||
Expect(artists[0].Name).To(Equal("John Doe"))
|
||||
Expect(artists[1].Name).To(Equal("Jane Doe"))
|
||||
})
|
||||
})
|
||||
|
||||
Context("Multi-valued ARTIST tags, no ARTISTS tags", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"First Artist", "Second Artist"},
|
||||
"ARTISTSORT": {"Name, First Artist", "Name, Second Artist"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1, mbid2},
|
||||
})
|
||||
})
|
||||
|
||||
It("should use the first artist name as display name", func() {
|
||||
Expect(mf.Artist).To(Equal("First Artist"))
|
||||
})
|
||||
|
||||
It("should populate the participants with all artists", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2)) // ARTIST and ALBUMARTIST
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleArtist, HaveLen(2)),
|
||||
))
|
||||
|
||||
artist0 := participants[model.RoleArtist][0]
|
||||
Expect(artist0.ID).ToNot(BeEmpty())
|
||||
Expect(artist0.Name).To(Equal("First Artist"))
|
||||
Expect(artist0.OrderArtistName).To(Equal("first artist"))
|
||||
Expect(artist0.SortArtistName).To(Equal("Name, First Artist"))
|
||||
Expect(artist0.MbzArtistID).To(Equal(mbid1))
|
||||
|
||||
artist1 := participants[model.RoleArtist][1]
|
||||
Expect(artist1.ID).ToNot(BeEmpty())
|
||||
Expect(artist1.Name).To(Equal("Second Artist"))
|
||||
Expect(artist1.OrderArtistName).To(Equal("second artist"))
|
||||
Expect(artist1.SortArtistName).To(Equal("Name, Second Artist"))
|
||||
Expect(artist1.MbzArtistID).To(Equal(mbid2))
|
||||
})
|
||||
})
|
||||
|
||||
Context("Single-valued ARTIST tags, multi-valued ARTISTS tags", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"First Artist & Second Artist"},
|
||||
"ARTISTSORT": {"Name, First Artist & Name, Second Artist"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1, mbid2},
|
||||
"ARTISTS": {"First Artist", "Second Artist"},
|
||||
"ARTISTSSORT": {"Name, First Artist", "Name, Second Artist"},
|
||||
})
|
||||
})
|
||||
|
||||
It("should use the single-valued tag as display name", func() {
|
||||
Expect(mf.Artist).To(Equal("First Artist & Second Artist"))
|
||||
})
|
||||
|
||||
It("should prioritize multi-valued tags over single-valued tags", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2)) // ARTIST and ALBUMARTIST
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleArtist, HaveLen(2)),
|
||||
))
|
||||
artist0 := participants[model.RoleArtist][0]
|
||||
Expect(artist0.ID).ToNot(BeEmpty())
|
||||
Expect(artist0.Name).To(Equal("First Artist"))
|
||||
Expect(artist0.OrderArtistName).To(Equal("first artist"))
|
||||
Expect(artist0.SortArtistName).To(Equal("Name, First Artist"))
|
||||
Expect(artist0.MbzArtistID).To(Equal(mbid1))
|
||||
|
||||
artist1 := participants[model.RoleArtist][1]
|
||||
Expect(artist1.ID).ToNot(BeEmpty())
|
||||
Expect(artist1.Name).To(Equal("Second Artist"))
|
||||
Expect(artist1.OrderArtistName).To(Equal("second artist"))
|
||||
Expect(artist1.SortArtistName).To(Equal("Name, Second Artist"))
|
||||
Expect(artist1.MbzArtistID).To(Equal(mbid2))
|
||||
})
|
||||
})
|
||||
|
||||
Context("Multi-valued ARTIST tags, multi-valued ARTISTS tags", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"First Artist", "Second Artist"},
|
||||
"ARTISTSORT": {"Name, First Artist", "Name, Second Artist"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1, mbid2},
|
||||
"ARTISTS": {"First Artist 2", "Second Artist 2"},
|
||||
"ARTISTSSORT": {"2, First Artist Name", "2, Second Artist Name"},
|
||||
})
|
||||
})
|
||||
|
||||
XIt("should use the values concatenated as a display name ", func() {
|
||||
Expect(mf.Artist).To(Equal("First Artist + Second Artist"))
|
||||
})
|
||||
|
||||
// TODO: remove when the above is implemented
|
||||
It("should use the first artist name as display name", func() {
|
||||
Expect(mf.Artist).To(Equal("First Artist 2"))
|
||||
})
|
||||
|
||||
It("should prioritize ARTISTS tags", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2)) // ARTIST and ALBUMARTIST
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleArtist, HaveLen(2)),
|
||||
))
|
||||
artist0 := participants[model.RoleArtist][0]
|
||||
Expect(artist0.ID).ToNot(BeEmpty())
|
||||
Expect(artist0.Name).To(Equal("First Artist 2"))
|
||||
Expect(artist0.OrderArtistName).To(Equal("first artist 2"))
|
||||
Expect(artist0.SortArtistName).To(Equal("2, First Artist Name"))
|
||||
Expect(artist0.MbzArtistID).To(Equal(mbid1))
|
||||
|
||||
artist1 := participants[model.RoleArtist][1]
|
||||
Expect(artist1.ID).ToNot(BeEmpty())
|
||||
Expect(artist1.Name).To(Equal("Second Artist 2"))
|
||||
Expect(artist1.OrderArtistName).To(Equal("second artist 2"))
|
||||
Expect(artist1.SortArtistName).To(Equal("2, Second Artist Name"))
|
||||
Expect(artist1.MbzArtistID).To(Equal(mbid2))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("ALBUMARTIST(S) tags", func() {
|
||||
Context("No ALBUMARTIST/ALBUMARTISTS tags", func() {
|
||||
When("the COMPILATION tag is not set", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"Artist Name"},
|
||||
"ARTISTSORT": {"Name, Artist"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1},
|
||||
})
|
||||
})
|
||||
|
||||
It("should use the ARTIST as ALBUMARTIST", func() {
|
||||
Expect(mf.AlbumArtist).To(Equal("Artist Name"))
|
||||
})
|
||||
|
||||
It("should add the ARTIST to participants as ALBUMARTIST", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2))
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleAlbumArtist, HaveLen(1)),
|
||||
))
|
||||
|
||||
albumArtist := participants[model.RoleAlbumArtist][0]
|
||||
Expect(albumArtist.ID).ToNot(BeEmpty())
|
||||
Expect(albumArtist.Name).To(Equal("Artist Name"))
|
||||
Expect(albumArtist.OrderArtistName).To(Equal("artist name"))
|
||||
Expect(albumArtist.SortArtistName).To(Equal("Name, Artist"))
|
||||
Expect(albumArtist.MbzArtistID).To(Equal(mbid1))
|
||||
})
|
||||
})
|
||||
|
||||
When("the COMPILATION tag is true", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"COMPILATION": {"1"},
|
||||
})
|
||||
})
|
||||
|
||||
It("should use the Various Artists as display name", func() {
|
||||
Expect(mf.AlbumArtist).To(Equal("Various Artists"))
|
||||
})
|
||||
|
||||
It("should add the Various Artists to participants as ALBUMARTIST", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2))
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleAlbumArtist, HaveLen(1)),
|
||||
))
|
||||
|
||||
albumArtist := participants[model.RoleAlbumArtist][0]
|
||||
Expect(albumArtist.ID).ToNot(BeEmpty())
|
||||
Expect(albumArtist.Name).To(Equal("Various Artists"))
|
||||
Expect(albumArtist.OrderArtistName).To(Equal("various artists"))
|
||||
Expect(albumArtist.SortArtistName).To(BeEmpty())
|
||||
Expect(albumArtist.MbzArtistID).To(Equal(consts.VariousArtistsMbzId))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Context("ALBUMARTIST tag is set", func() {
|
||||
BeforeEach(func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"Track Artist Name"},
|
||||
"ARTISTSORT": {"Name, Track Artist"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1},
|
||||
"ALBUMARTIST": {"Album Artist Name"},
|
||||
"ALBUMARTISTSORT": {"Album Artist Sort Name"},
|
||||
"MUSICBRAINZ_ALBUMARTISTID": {mbid2},
|
||||
})
|
||||
})
|
||||
|
||||
It("should use the ALBUMARTIST as display name", func() {
|
||||
Expect(mf.AlbumArtist).To(Equal("Album Artist Name"))
|
||||
})
|
||||
|
||||
It("should populate the participants with the ALBUMARTIST", func() {
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveLen(2))
|
||||
Expect(participants).To(SatisfyAll(
|
||||
HaveKeyWithValue(model.RoleAlbumArtist, HaveLen(1)),
|
||||
))
|
||||
|
||||
albumArtist := participants[model.RoleAlbumArtist][0]
|
||||
Expect(albumArtist.ID).ToNot(BeEmpty())
|
||||
Expect(albumArtist.Name).To(Equal("Album Artist Name"))
|
||||
Expect(albumArtist.OrderArtistName).To(Equal("album artist name"))
|
||||
Expect(albumArtist.SortArtistName).To(Equal("Album Artist Sort Name"))
|
||||
Expect(albumArtist.MbzArtistID).To(Equal(mbid2))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("COMPOSER and LYRICIST tags (with sort names)", func() {
|
||||
DescribeTable("should return the correct participation",
|
||||
func(role model.Role, nameTag, sortTag string) {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
nameTag: {"First Name", "Second Name"},
|
||||
sortTag: {"Name, First", "Name, Second"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(role, HaveLen(2)))
|
||||
|
||||
p := participants[role]
|
||||
Expect(p[0].ID).ToNot(BeEmpty())
|
||||
Expect(p[0].Name).To(Equal("First Name"))
|
||||
Expect(p[0].SortArtistName).To(Equal("Name, First"))
|
||||
Expect(p[0].OrderArtistName).To(Equal("first name"))
|
||||
Expect(p[1].ID).ToNot(BeEmpty())
|
||||
Expect(p[1].Name).To(Equal("Second Name"))
|
||||
Expect(p[1].SortArtistName).To(Equal("Name, Second"))
|
||||
Expect(p[1].OrderArtistName).To(Equal("second name"))
|
||||
},
|
||||
Entry("COMPOSER", model.RoleComposer, "COMPOSER", "COMPOSERSORT"),
|
||||
Entry("LYRICIST", model.RoleLyricist, "LYRICIST", "LYRICISTSORT"),
|
||||
)
|
||||
})
|
||||
|
||||
Describe("PERFORMER tags", func() {
|
||||
When("PERFORMER tag is set", func() {
|
||||
matchPerformer := func(name, orderName, subRole string) types.GomegaMatcher {
|
||||
return MatchFields(IgnoreExtras, Fields{
|
||||
"Artist": MatchFields(IgnoreExtras, Fields{
|
||||
"Name": Equal(name),
|
||||
"OrderArtistName": Equal(orderName),
|
||||
}),
|
||||
"SubRole": Equal(subRole),
|
||||
})
|
||||
}
|
||||
|
||||
It("should return the correct participation", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"PERFORMER:GUITAR": {"Eric Clapton", "B.B. King"},
|
||||
"PERFORMER:BASS": {"Nathan East"},
|
||||
"PERFORMER:HAMMOND ORGAN": {"Tim Carmon"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(model.RolePerformer, HaveLen(4)))
|
||||
|
||||
p := participants[model.RolePerformer]
|
||||
Expect(p).To(ContainElements(
|
||||
matchPerformer("Eric Clapton", "eric clapton", "Guitar"),
|
||||
matchPerformer("B.B. King", "b.b. king", "Guitar"),
|
||||
matchPerformer("Nathan East", "nathan east", "Bass"),
|
||||
matchPerformer("Tim Carmon", "tim carmon", "Hammond Organ"),
|
||||
))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Other tags", func() {
|
||||
DescribeTable("should return the correct participation",
|
||||
func(role model.Role, tag string) {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
tag: {"John Doe", "Jane Doe"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(role, HaveLen(2)))
|
||||
|
||||
p := participants[role]
|
||||
Expect(p[0].ID).ToNot(BeEmpty())
|
||||
Expect(p[0].Name).To(Equal("John Doe"))
|
||||
Expect(p[0].OrderArtistName).To(Equal("john doe"))
|
||||
Expect(p[1].ID).ToNot(BeEmpty())
|
||||
Expect(p[1].Name).To(Equal("Jane Doe"))
|
||||
Expect(p[1].OrderArtistName).To(Equal("jane doe"))
|
||||
},
|
||||
Entry("CONDUCTOR", model.RoleConductor, "CONDUCTOR"),
|
||||
Entry("ARRANGER", model.RoleArranger, "ARRANGER"),
|
||||
Entry("PRODUCER", model.RoleProducer, "PRODUCER"),
|
||||
Entry("ENGINEER", model.RoleEngineer, "ENGINEER"),
|
||||
Entry("MIXER", model.RoleMixer, "MIXER"),
|
||||
Entry("REMIXER", model.RoleRemixer, "REMIXER"),
|
||||
Entry("DJMIXER", model.RoleDJMixer, "DJMIXER"),
|
||||
Entry("DIRECTOR", model.RoleDirector, "DIRECTOR"),
|
||||
// TODO PERFORMER
|
||||
)
|
||||
})
|
||||
|
||||
Describe("Role value splitting", func() {
|
||||
When("the tag is single valued", func() {
|
||||
It("should split the values by the configured separator", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"COMPOSER": {"John Doe/Someone Else/The Album Artist"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(model.RoleComposer, HaveLen(3)))
|
||||
composers := participants[model.RoleComposer]
|
||||
Expect(composers[0].Name).To(Equal("John Doe"))
|
||||
Expect(composers[1].Name).To(Equal("Someone Else"))
|
||||
Expect(composers[2].Name).To(Equal("The Album Artist"))
|
||||
})
|
||||
It("should not add an empty participant after split", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"COMPOSER": {"John Doe/"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(model.RoleComposer, HaveLen(1)))
|
||||
composers := participants[model.RoleComposer]
|
||||
Expect(composers[0].Name).To(Equal("John Doe"))
|
||||
})
|
||||
It("should trim the values", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"COMPOSER": {"John Doe / Someone Else / The Album Artist"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(model.RoleComposer, HaveLen(3)))
|
||||
composers := participants[model.RoleComposer]
|
||||
Expect(composers[0].Name).To(Equal("John Doe"))
|
||||
Expect(composers[1].Name).To(Equal("Someone Else"))
|
||||
Expect(composers[2].Name).To(Equal("The Album Artist"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("MBID tags", func() {
|
||||
It("should set the MBID for the artist based on the track/album artist", func() {
|
||||
mf = toMediaFile(model.RawTags{
|
||||
"ARTIST": {"John Doe", "Jane Doe"},
|
||||
"MUSICBRAINZ_ARTISTID": {mbid1, mbid2},
|
||||
"ALBUMARTIST": {"The Album Artist"},
|
||||
"MUSICBRAINZ_ALBUMARTISTID": {mbid3},
|
||||
"COMPOSER": {"John Doe", "Someone Else", "The Album Artist"},
|
||||
"PRODUCER": {"Jane Doe", "John Doe"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(model.RoleComposer, HaveLen(3)))
|
||||
composers := participants[model.RoleComposer]
|
||||
Expect(composers[0].MbzArtistID).To(Equal(mbid1))
|
||||
Expect(composers[1].MbzArtistID).To(BeEmpty())
|
||||
Expect(composers[2].MbzArtistID).To(Equal(mbid3))
|
||||
|
||||
Expect(participants).To(HaveKeyWithValue(model.RoleProducer, HaveLen(2)))
|
||||
producers := participants[model.RoleProducer]
|
||||
Expect(producers[0].MbzArtistID).To(Equal(mbid2))
|
||||
Expect(producers[1].MbzArtistID).To(Equal(mbid1))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Non-standard MBID tags", func() {
|
||||
var allMappings = map[model.Role]model.TagName{
|
||||
model.RoleComposer: model.TagMusicBrainzComposerID,
|
||||
model.RoleLyricist: model.TagMusicBrainzLyricistID,
|
||||
model.RoleConductor: model.TagMusicBrainzConductorID,
|
||||
model.RoleArranger: model.TagMusicBrainzArrangerID,
|
||||
model.RoleDirector: model.TagMusicBrainzDirectorID,
|
||||
model.RoleProducer: model.TagMusicBrainzProducerID,
|
||||
model.RoleEngineer: model.TagMusicBrainzEngineerID,
|
||||
model.RoleMixer: model.TagMusicBrainzMixerID,
|
||||
model.RoleRemixer: model.TagMusicBrainzRemixerID,
|
||||
model.RoleDJMixer: model.TagMusicBrainzDJMixerID,
|
||||
}
|
||||
|
||||
It("should handle more artists than mbids", func() {
|
||||
for key := range allMappings {
|
||||
mf = toMediaFile(map[string][]string{
|
||||
key.String(): {"a", "b", "c"},
|
||||
allMappings[key].String(): {"f634bf6d-d66a-425d-888a-28ad39392759", "3dfa3c70-d7d3-4b97-b953-c298dd305e12"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(key, HaveLen(3)))
|
||||
roles := participants[key]
|
||||
|
||||
Expect(roles[0].Name).To(Equal("a"))
|
||||
Expect(roles[1].Name).To(Equal("b"))
|
||||
Expect(roles[2].Name).To(Equal("c"))
|
||||
|
||||
Expect(roles[0].MbzArtistID).To(Equal("f634bf6d-d66a-425d-888a-28ad39392759"))
|
||||
Expect(roles[1].MbzArtistID).To(Equal("3dfa3c70-d7d3-4b97-b953-c298dd305e12"))
|
||||
Expect(roles[2].MbzArtistID).To(Equal(""))
|
||||
}
|
||||
})
|
||||
|
||||
It("should handle more mbids than artists", func() {
|
||||
for key := range allMappings {
|
||||
mf = toMediaFile(map[string][]string{
|
||||
key.String(): {"a", "b"},
|
||||
allMappings[key].String(): {"f634bf6d-d66a-425d-888a-28ad39392759", "3dfa3c70-d7d3-4b97-b953-c298dd305e12"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(key, HaveLen(2)))
|
||||
roles := participants[key]
|
||||
|
||||
Expect(roles[0].Name).To(Equal("a"))
|
||||
Expect(roles[1].Name).To(Equal("b"))
|
||||
|
||||
Expect(roles[0].MbzArtistID).To(Equal("f634bf6d-d66a-425d-888a-28ad39392759"))
|
||||
Expect(roles[1].MbzArtistID).To(Equal("3dfa3c70-d7d3-4b97-b953-c298dd305e12"))
|
||||
}
|
||||
})
|
||||
|
||||
It("should refuse duplicate names if no mbid specified", func() {
|
||||
for key := range allMappings {
|
||||
mf = toMediaFile(map[string][]string{
|
||||
key.String(): {"a", "b", "a", "a"},
|
||||
})
|
||||
|
||||
participants := mf.Participants
|
||||
Expect(participants).To(HaveKeyWithValue(key, HaveLen(2)))
|
||||
roles := participants[key]
|
||||
|
||||
Expect(roles[0].Name).To(Equal("a"))
|
||||
Expect(roles[0].MbzArtistID).To(Equal(""))
|
||||
Expect(roles[1].Name).To(Equal("b"))
|
||||
Expect(roles[1].MbzArtistID).To(Equal(""))
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
373
model/metadata/metadata.go
Normal file
373
model/metadata/metadata.go
Normal file
|
|
@ -0,0 +1,373 @@
|
|||
package metadata
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
"io/fs"
|
||||
"math"
|
||||
"path"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
"github.com/navidrome/navidrome/log"
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/utils/slice"
|
||||
)
|
||||
|
||||
type Info struct {
|
||||
FileInfo FileInfo
|
||||
Tags model.RawTags
|
||||
AudioProperties AudioProperties
|
||||
HasPicture bool
|
||||
}
|
||||
|
||||
type FileInfo interface {
|
||||
fs.FileInfo
|
||||
BirthTime() time.Time
|
||||
}
|
||||
|
||||
type AudioProperties struct {
|
||||
Duration time.Duration
|
||||
BitRate int
|
||||
BitDepth int
|
||||
SampleRate int
|
||||
Channels int
|
||||
}
|
||||
|
||||
type Date string
|
||||
|
||||
func (d Date) Year() int {
|
||||
if d == "" {
|
||||
return 0
|
||||
}
|
||||
y, _ := strconv.Atoi(string(d[:4]))
|
||||
return y
|
||||
}
|
||||
|
||||
type Pair string
|
||||
|
||||
func (p Pair) Key() string { return p.parse(0) }
|
||||
func (p Pair) Value() string { return p.parse(1) }
|
||||
func (p Pair) parse(i int) string {
|
||||
parts := strings.SplitN(string(p), consts.Zwsp, 2)
|
||||
if len(parts) > i {
|
||||
return parts[i]
|
||||
}
|
||||
return ""
|
||||
}
|
||||
func (p Pair) String() string {
|
||||
return string(p)
|
||||
}
|
||||
func NewPair(key, value string) string {
|
||||
return key + consts.Zwsp + value
|
||||
}
|
||||
|
||||
func New(filePath string, info Info) Metadata {
|
||||
return Metadata{
|
||||
filePath: filePath,
|
||||
fileInfo: info.FileInfo,
|
||||
tags: clean(filePath, info.Tags),
|
||||
audioProps: info.AudioProperties,
|
||||
hasPicture: info.HasPicture,
|
||||
}
|
||||
}
|
||||
|
||||
type Metadata struct {
|
||||
filePath string
|
||||
fileInfo FileInfo
|
||||
tags model.Tags
|
||||
audioProps AudioProperties
|
||||
hasPicture bool
|
||||
}
|
||||
|
||||
func (md Metadata) FilePath() string { return md.filePath }
|
||||
func (md Metadata) ModTime() time.Time { return md.fileInfo.ModTime() }
|
||||
func (md Metadata) BirthTime() time.Time { return md.fileInfo.BirthTime() }
|
||||
func (md Metadata) Size() int64 { return md.fileInfo.Size() }
|
||||
func (md Metadata) Suffix() string {
|
||||
return strings.ToLower(strings.TrimPrefix(path.Ext(md.filePath), "."))
|
||||
}
|
||||
func (md Metadata) AudioProperties() AudioProperties { return md.audioProps }
|
||||
func (md Metadata) Length() float32 { return float32(md.audioProps.Duration.Milliseconds()) / 1000 }
|
||||
func (md Metadata) HasPicture() bool { return md.hasPicture }
|
||||
func (md Metadata) All() model.Tags { return md.tags }
|
||||
func (md Metadata) Strings(key model.TagName) []string { return md.tags[key] }
|
||||
func (md Metadata) String(key model.TagName) string { return md.first(key) }
|
||||
func (md Metadata) Int(key model.TagName) int64 { v, _ := strconv.Atoi(md.first(key)); return int64(v) }
|
||||
func (md Metadata) Bool(key model.TagName) bool { v, _ := strconv.ParseBool(md.first(key)); return v }
|
||||
func (md Metadata) Date(key model.TagName) Date { return md.date(key) }
|
||||
func (md Metadata) NumAndTotal(key model.TagName) (int, int) { return md.tuple(key) }
|
||||
func (md Metadata) Float(key model.TagName, def ...float64) float64 {
|
||||
return float(md.first(key), def...)
|
||||
}
|
||||
func (md Metadata) Gain(key model.TagName) float64 {
|
||||
v := strings.TrimSpace(strings.Replace(md.first(key), "dB", "", 1))
|
||||
return float(v)
|
||||
}
|
||||
func (md Metadata) Pairs(key model.TagName) []Pair {
|
||||
values := md.tags[key]
|
||||
return slice.Map(values, func(v string) Pair { return Pair(v) })
|
||||
}
|
||||
func (md Metadata) first(key model.TagName) string {
|
||||
if v, ok := md.tags[key]; ok && len(v) > 0 {
|
||||
return v[0]
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func float(value string, def ...float64) float64 {
|
||||
v, err := strconv.ParseFloat(value, 64)
|
||||
if err != nil || v == math.Inf(-1) || v == math.Inf(1) {
|
||||
if len(def) > 0 {
|
||||
return def[0]
|
||||
}
|
||||
return 0
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// Used for tracks and discs
|
||||
func (md Metadata) tuple(key model.TagName) (int, int) {
|
||||
tag := md.first(key)
|
||||
if tag == "" {
|
||||
return 0, 0
|
||||
}
|
||||
tuple := strings.Split(tag, "/")
|
||||
t1, t2 := 0, 0
|
||||
t1, _ = strconv.Atoi(tuple[0])
|
||||
if len(tuple) > 1 {
|
||||
t2, _ = strconv.Atoi(tuple[1])
|
||||
} else {
|
||||
t2tag := md.first(key + "total")
|
||||
t2, _ = strconv.Atoi(t2tag)
|
||||
}
|
||||
return t1, t2
|
||||
}
|
||||
|
||||
var dateRegex = regexp.MustCompile(`([12]\d\d\d)`)
|
||||
|
||||
func (md Metadata) date(tagName model.TagName) Date {
|
||||
return Date(md.first(tagName))
|
||||
}
|
||||
|
||||
// date tries to parse a date from a tag, it tries to get at least the year. See the tests for examples.
|
||||
func parseDate(filePath string, tagName model.TagName, tagValue string) string {
|
||||
if len(tagValue) < 4 {
|
||||
return ""
|
||||
}
|
||||
|
||||
// first get just the year
|
||||
match := dateRegex.FindStringSubmatch(tagValue)
|
||||
if len(match) == 0 {
|
||||
log.Debug("Error parsing date", "file", filePath, "tag", tagName, "date", tagValue)
|
||||
return ""
|
||||
}
|
||||
|
||||
// if the tag is just the year, return it
|
||||
if len(tagValue) < 5 {
|
||||
return match[1]
|
||||
}
|
||||
|
||||
// if the tag is too long, truncate it
|
||||
tagValue = tagValue[:min(10, len(tagValue))]
|
||||
|
||||
// then try to parse the full date
|
||||
for _, mask := range []string{"2006-01-02", "2006-01"} {
|
||||
_, err := time.Parse(mask, tagValue)
|
||||
if err == nil {
|
||||
return tagValue
|
||||
}
|
||||
}
|
||||
log.Debug("Error parsing month and day from date", "file", filePath, "tag", tagName, "date", tagValue)
|
||||
return match[1]
|
||||
}
|
||||
|
||||
// clean filters out tags that are not in the mappings or are empty,
|
||||
// combine equivalent tags and remove duplicated values.
|
||||
// It keeps the order of the tags names as they are defined in the mappings.
|
||||
func clean(filePath string, tags model.RawTags) model.Tags {
|
||||
lowered := lowerTags(tags)
|
||||
mappings := model.TagMappings()
|
||||
cleaned := make(model.Tags, len(mappings))
|
||||
|
||||
for name, mapping := range mappings {
|
||||
var values []string
|
||||
switch mapping.Type {
|
||||
case model.TagTypePair:
|
||||
values = processPairMapping(name, mapping, lowered)
|
||||
default:
|
||||
values = processRegularMapping(mapping, lowered)
|
||||
}
|
||||
cleaned[name] = values
|
||||
}
|
||||
|
||||
cleaned = filterEmptyTags(cleaned)
|
||||
return sanitizeAll(filePath, cleaned)
|
||||
}
|
||||
|
||||
func processRegularMapping(mapping model.TagConf, lowered model.Tags) []string {
|
||||
var values []string
|
||||
for _, alias := range mapping.Aliases {
|
||||
if vs, ok := lowered[model.TagName(alias)]; ok {
|
||||
splitValues := mapping.SplitTagValue(vs)
|
||||
values = append(values, splitValues...)
|
||||
}
|
||||
}
|
||||
return values
|
||||
}
|
||||
|
||||
func lowerTags(tags model.RawTags) model.Tags {
|
||||
lowered := make(model.Tags, len(tags))
|
||||
for k, v := range tags {
|
||||
lowered[model.TagName(strings.ToLower(k))] = v
|
||||
}
|
||||
return lowered
|
||||
}
|
||||
|
||||
func processPairMapping(name model.TagName, mapping model.TagConf, lowered model.Tags) []string {
|
||||
var aliasValues []string
|
||||
for _, alias := range mapping.Aliases {
|
||||
if vs, ok := lowered[model.TagName(alias)]; ok {
|
||||
aliasValues = append(aliasValues, vs...)
|
||||
}
|
||||
}
|
||||
|
||||
if len(aliasValues) > 0 {
|
||||
return parseVorbisPairs(aliasValues)
|
||||
}
|
||||
return parseID3Pairs(name, lowered)
|
||||
}
|
||||
|
||||
func parseID3Pairs(name model.TagName, lowered model.Tags) []string {
|
||||
var pairs []string
|
||||
prefix := string(name) + ":"
|
||||
for tagKey, tagValues := range lowered {
|
||||
keyStr := string(tagKey)
|
||||
if strings.HasPrefix(keyStr, prefix) {
|
||||
keyPart := strings.TrimPrefix(keyStr, prefix)
|
||||
if keyPart == string(name) {
|
||||
keyPart = ""
|
||||
}
|
||||
for _, v := range tagValues {
|
||||
pairs = append(pairs, NewPair(keyPart, v))
|
||||
}
|
||||
}
|
||||
}
|
||||
return pairs
|
||||
}
|
||||
|
||||
var vorbisPairRegex = regexp.MustCompile(`\(([^()]+(?:\([^()]*\)[^()]*)*)\)`)
|
||||
|
||||
// parseVorbisPairs, from
|
||||
//
|
||||
// "Salaam Remi (drums (drum set) and organ)",
|
||||
//
|
||||
// to
|
||||
//
|
||||
// "drums (drum set) and organ" -> "Salaam Remi",
|
||||
func parseVorbisPairs(values []string) []string {
|
||||
pairs := make([]string, 0, len(values))
|
||||
for _, value := range values {
|
||||
matches := vorbisPairRegex.FindAllStringSubmatch(value, -1)
|
||||
if len(matches) == 0 {
|
||||
pairs = append(pairs, NewPair("", value))
|
||||
continue
|
||||
}
|
||||
key := strings.TrimSpace(matches[0][1])
|
||||
key = strings.ToLower(key)
|
||||
valueWithoutKey := strings.TrimSpace(strings.Replace(value, "("+matches[0][1]+")", "", 1))
|
||||
pairs = append(pairs, NewPair(key, valueWithoutKey))
|
||||
}
|
||||
return pairs
|
||||
}
|
||||
|
||||
func filterEmptyTags(tags model.Tags) model.Tags {
|
||||
for k, v := range tags {
|
||||
clean := filterDuplicatedOrEmptyValues(v)
|
||||
if len(clean) == 0 {
|
||||
delete(tags, k)
|
||||
} else {
|
||||
tags[k] = clean
|
||||
}
|
||||
}
|
||||
return tags
|
||||
}
|
||||
|
||||
func filterDuplicatedOrEmptyValues(values []string) []string {
|
||||
seen := make(map[string]struct{}, len(values))
|
||||
var result []string
|
||||
for _, v := range values {
|
||||
if v == "" {
|
||||
continue
|
||||
}
|
||||
if _, ok := seen[v]; ok {
|
||||
continue
|
||||
}
|
||||
seen[v] = struct{}{}
|
||||
result = append(result, v)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func sanitizeAll(filePath string, tags model.Tags) model.Tags {
|
||||
cleaned := model.Tags{}
|
||||
for k, v := range tags {
|
||||
tag, found := model.TagMappings()[k]
|
||||
if !found {
|
||||
continue
|
||||
}
|
||||
|
||||
var values []string
|
||||
for _, value := range v {
|
||||
cleanedValue := sanitize(filePath, k, tag, value)
|
||||
if cleanedValue != "" {
|
||||
values = append(values, cleanedValue)
|
||||
}
|
||||
}
|
||||
if len(values) > 0 {
|
||||
cleaned[k] = values
|
||||
}
|
||||
}
|
||||
return cleaned
|
||||
}
|
||||
|
||||
const defaultMaxTagLength = 1024
|
||||
|
||||
func sanitize(filePath string, tagName model.TagName, tag model.TagConf, value string) string {
|
||||
// First truncate the value to the maximum length
|
||||
maxLength := cmp.Or(tag.MaxLength, defaultMaxTagLength)
|
||||
if len(value) > maxLength {
|
||||
log.Trace("Truncated tag value", "tag", tagName, "value", value, "length", len(value), "maxLength", maxLength)
|
||||
value = value[:maxLength]
|
||||
}
|
||||
|
||||
switch tag.Type {
|
||||
case model.TagTypeDate:
|
||||
value = parseDate(filePath, tagName, value)
|
||||
if value == "" {
|
||||
log.Trace("Invalid date tag value", "tag", tagName, "value", value)
|
||||
}
|
||||
case model.TagTypeInteger:
|
||||
_, err := strconv.Atoi(value)
|
||||
if err != nil {
|
||||
log.Trace("Invalid integer tag value", "tag", tagName, "value", value)
|
||||
return ""
|
||||
}
|
||||
case model.TagTypeFloat:
|
||||
_, err := strconv.ParseFloat(value, 64)
|
||||
if err != nil {
|
||||
log.Trace("Invalid float tag value", "tag", tagName, "value", value)
|
||||
return ""
|
||||
}
|
||||
case model.TagTypeUUID:
|
||||
_, err := uuid.Parse(value)
|
||||
if err != nil {
|
||||
log.Trace("Invalid UUID tag value", "tag", tagName, "value", value)
|
||||
return ""
|
||||
}
|
||||
}
|
||||
return value
|
||||
}
|
||||
32
model/metadata/metadata_suite_test.go
Normal file
32
model/metadata/metadata_suite_test.go
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
package metadata_test
|
||||
|
||||
import (
|
||||
"io/fs"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/djherbis/times"
|
||||
_ "github.com/mattn/go-sqlite3"
|
||||
"github.com/navidrome/navidrome/log"
|
||||
"github.com/navidrome/navidrome/tests"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
func TestMetadata(t *testing.T) {
|
||||
tests.Init(t, true)
|
||||
log.SetLevel(log.LevelFatal)
|
||||
RegisterFailHandler(Fail)
|
||||
RunSpecs(t, "Metadata Suite")
|
||||
}
|
||||
|
||||
type testFileInfo struct {
|
||||
fs.FileInfo
|
||||
}
|
||||
|
||||
func (t testFileInfo) BirthTime() time.Time {
|
||||
if ts := times.Get(t.FileInfo); ts.HasBirthTime() {
|
||||
return ts.BirthTime()
|
||||
}
|
||||
return t.FileInfo.ModTime()
|
||||
}
|
||||
293
model/metadata/metadata_test.go
Normal file
293
model/metadata/metadata_test.go
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
package metadata_test
|
||||
|
||||
import (
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/model/metadata"
|
||||
"github.com/navidrome/navidrome/utils"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("Metadata", func() {
|
||||
var (
|
||||
filePath string
|
||||
fileInfo os.FileInfo
|
||||
props metadata.Info
|
||||
md metadata.Metadata
|
||||
)
|
||||
|
||||
BeforeEach(func() {
|
||||
// It is easier to have a real file to test the mod and birth times
|
||||
filePath = utils.TempFileName("test", ".mp3")
|
||||
f, _ := os.Create(filePath)
|
||||
DeferCleanup(func() {
|
||||
_ = f.Close()
|
||||
_ = os.Remove(filePath)
|
||||
})
|
||||
|
||||
fileInfo, _ = os.Stat(filePath)
|
||||
props = metadata.Info{
|
||||
AudioProperties: metadata.AudioProperties{
|
||||
Duration: time.Minute * 3,
|
||||
BitRate: 320,
|
||||
},
|
||||
HasPicture: true,
|
||||
FileInfo: testFileInfo{fileInfo},
|
||||
}
|
||||
})
|
||||
|
||||
Describe("Metadata", func() {
|
||||
Describe("New", func() {
|
||||
It("should create a new Metadata object with the correct properties", func() {
|
||||
props.Tags = model.RawTags{
|
||||
"©ART": {"First Artist", "Second Artist"},
|
||||
"----:com.apple.iTunes:CATALOGNUMBER": {"1234"},
|
||||
"tbpm": {"120.6"},
|
||||
"WM/IsCompilation": {"1"},
|
||||
}
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
Expect(md.FilePath()).To(Equal(filePath))
|
||||
Expect(md.ModTime()).To(Equal(fileInfo.ModTime()))
|
||||
Expect(md.BirthTime()).To(BeTemporally("~", md.ModTime(), time.Second))
|
||||
Expect(md.Size()).To(Equal(fileInfo.Size()))
|
||||
Expect(md.Suffix()).To(Equal("mp3"))
|
||||
Expect(md.AudioProperties()).To(Equal(props.AudioProperties))
|
||||
Expect(md.Length()).To(Equal(float32(3 * 60)))
|
||||
Expect(md.HasPicture()).To(Equal(props.HasPicture))
|
||||
Expect(md.Strings(model.TagTrackArtist)).To(Equal([]string{"First Artist", "Second Artist"}))
|
||||
Expect(md.String(model.TagTrackArtist)).To(Equal("First Artist"))
|
||||
Expect(md.Int(model.TagCatalogNumber)).To(Equal(int64(1234)))
|
||||
Expect(md.Float(model.TagBPM)).To(Equal(120.6))
|
||||
Expect(md.Bool(model.TagCompilation)).To(BeTrue())
|
||||
Expect(md.All()).To(SatisfyAll(
|
||||
HaveLen(4),
|
||||
HaveKeyWithValue(model.TagTrackArtist, []string{"First Artist", "Second Artist"}),
|
||||
HaveKeyWithValue(model.TagBPM, []string{"120.6"}),
|
||||
HaveKeyWithValue(model.TagCompilation, []string{"1"}),
|
||||
HaveKeyWithValue(model.TagCatalogNumber, []string{"1234"}),
|
||||
))
|
||||
|
||||
})
|
||||
|
||||
It("should clean the tags map correctly", func() {
|
||||
const unknownTag = "UNKNOWN_TAG"
|
||||
props.Tags = model.RawTags{
|
||||
"TPE1": {"Artist Name", "Artist Name", ""},
|
||||
"©ART": {"Second Artist"},
|
||||
"CatalogNumber": {""},
|
||||
"Album": {"Album Name", "", "Album Name"},
|
||||
"Date": {"2022-10-02 12:15:01"},
|
||||
"Year": {"2022", "2022", ""},
|
||||
"Genre": {"Pop", "", "Pop", "Rock"},
|
||||
"Track": {"1/10", "1/10", ""},
|
||||
unknownTag: {"value"},
|
||||
}
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
Expect(md.All()).To(SatisfyAll(
|
||||
HaveLen(5),
|
||||
Not(HaveKey(unknownTag)),
|
||||
HaveKeyWithValue(model.TagTrackArtist, []string{"Artist Name", "Second Artist"}),
|
||||
HaveKeyWithValue(model.TagAlbum, []string{"Album Name"}),
|
||||
HaveKeyWithValue(model.TagRecordingDate, []string{"2022-10-02", "2022"}),
|
||||
HaveKeyWithValue(model.TagGenre, []string{"Pop", "Rock"}),
|
||||
HaveKeyWithValue(model.TagTrackNumber, []string{"1/10"}),
|
||||
))
|
||||
})
|
||||
|
||||
It("should truncate long strings", func() {
|
||||
props.Tags = model.RawTags{
|
||||
"Title": {strings.Repeat("a", 2048)},
|
||||
"Comment": {strings.Repeat("a", 8192)},
|
||||
"lyrics:xxx": {strings.Repeat("a", 60000)},
|
||||
}
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
Expect(md.String(model.TagTitle)).To(HaveLen(1024))
|
||||
Expect(md.String(model.TagComment)).To(HaveLen(4096))
|
||||
pair := md.Pairs(model.TagLyrics)
|
||||
|
||||
Expect(pair).To(HaveLen(1))
|
||||
Expect(pair[0].Key()).To(Equal("xxx"))
|
||||
|
||||
// Note: a total of 6 characters are lost from maxLength from
|
||||
// the key portion and separator
|
||||
Expect(pair[0].Value()).To(HaveLen(32762))
|
||||
})
|
||||
|
||||
It("should split multiple values", func() {
|
||||
props.Tags = model.RawTags{
|
||||
"Genre": {"Rock/Pop;;Punk"},
|
||||
}
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
Expect(md.Strings(model.TagGenre)).To(Equal([]string{"Rock", "Pop", "Punk"}))
|
||||
})
|
||||
})
|
||||
|
||||
DescribeTable("Date",
|
||||
func(value string, expectedYear int, expectedDate string) {
|
||||
props.Tags = model.RawTags{
|
||||
"date": {value},
|
||||
}
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
testDate := md.Date(model.TagRecordingDate)
|
||||
Expect(string(testDate)).To(Equal(expectedDate))
|
||||
Expect(testDate.Year()).To(Equal(expectedYear))
|
||||
},
|
||||
Entry(nil, "1985", 1985, "1985"),
|
||||
Entry(nil, "2002-01", 2002, "2002-01"),
|
||||
Entry(nil, "1969.06", 1969, "1969"),
|
||||
Entry(nil, "1980.07.25", 1980, "1980"),
|
||||
Entry(nil, "2004-00-00", 2004, "2004"),
|
||||
Entry(nil, "2016-12-31", 2016, "2016-12-31"),
|
||||
Entry(nil, "2016-12-31 12:15", 2016, "2016-12-31"),
|
||||
Entry(nil, "2013-May-12", 2013, "2013"),
|
||||
Entry(nil, "May 12, 2016", 2016, "2016"),
|
||||
Entry(nil, "01/10/1990", 1990, "1990"),
|
||||
Entry(nil, "invalid", 0, ""),
|
||||
)
|
||||
|
||||
DescribeTable("NumAndTotal",
|
||||
func(num, total string, expectedNum int, expectedTotal int) {
|
||||
props.Tags = model.RawTags{
|
||||
"Track": {num},
|
||||
"TrackTotal": {total},
|
||||
}
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
testNum, testTotal := md.NumAndTotal(model.TagTrackNumber)
|
||||
Expect(testNum).To(Equal(expectedNum))
|
||||
Expect(testTotal).To(Equal(expectedTotal))
|
||||
},
|
||||
Entry(nil, "2", "", 2, 0),
|
||||
Entry(nil, "2", "10", 2, 10),
|
||||
Entry(nil, "2/10", "", 2, 10),
|
||||
Entry(nil, "", "", 0, 0),
|
||||
Entry(nil, "A", "", 0, 0),
|
||||
)
|
||||
|
||||
Describe("Performers", func() {
|
||||
Describe("ID3", func() {
|
||||
BeforeEach(func() {
|
||||
props.Tags = model.RawTags{
|
||||
"PERFORMER:GUITAR": {"Guitarist 1", "Guitarist 2"},
|
||||
"PERFORMER:BACKGROUND VOCALS": {"Backing Singer"},
|
||||
"PERFORMER:PERFORMER": {"Wonderlove", "Lovewonder"},
|
||||
}
|
||||
})
|
||||
|
||||
It("should return the performers", func() {
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
Expect(md.All()).To(HaveKey(model.TagPerformer))
|
||||
Expect(md.Strings(model.TagPerformer)).To(ConsistOf(
|
||||
metadata.NewPair("guitar", "Guitarist 1"),
|
||||
metadata.NewPair("guitar", "Guitarist 2"),
|
||||
metadata.NewPair("background vocals", "Backing Singer"),
|
||||
metadata.NewPair("", "Wonderlove"),
|
||||
metadata.NewPair("", "Lovewonder"),
|
||||
))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Vorbis", func() {
|
||||
BeforeEach(func() {
|
||||
props.Tags = model.RawTags{
|
||||
"PERFORMER": {
|
||||
"John Adams (Rhodes piano)",
|
||||
"Vincent Henry (alto saxophone, baritone saxophone and tenor saxophone)",
|
||||
"Salaam Remi (drums (drum set) and organ)",
|
||||
"Amy Winehouse (guitar)",
|
||||
"Amy Winehouse (vocals)",
|
||||
"Wonderlove",
|
||||
},
|
||||
}
|
||||
})
|
||||
|
||||
It("should return the performers", func() {
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
Expect(md.All()).To(HaveKey(model.TagPerformer))
|
||||
Expect(md.Strings(model.TagPerformer)).To(ConsistOf(
|
||||
metadata.NewPair("rhodes piano", "John Adams"),
|
||||
metadata.NewPair("alto saxophone, baritone saxophone and tenor saxophone", "Vincent Henry"),
|
||||
metadata.NewPair("drums (drum set) and organ", "Salaam Remi"),
|
||||
metadata.NewPair("guitar", "Amy Winehouse"),
|
||||
metadata.NewPair("vocals", "Amy Winehouse"),
|
||||
metadata.NewPair("", "Wonderlove"),
|
||||
))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Lyrics", func() {
|
||||
BeforeEach(func() {
|
||||
props.Tags = model.RawTags{
|
||||
"LYRICS:POR": {"Letras"},
|
||||
"LYRICS:ENG": {"Lyrics"},
|
||||
}
|
||||
})
|
||||
|
||||
It("should return the lyrics", func() {
|
||||
md = metadata.New(filePath, props)
|
||||
|
||||
Expect(md.All()).To(HaveKey(model.TagLyrics))
|
||||
Expect(md.Strings(model.TagLyrics)).To(ContainElements(
|
||||
metadata.NewPair("por", "Letras"),
|
||||
metadata.NewPair("eng", "Lyrics"),
|
||||
))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("ReplayGain", func() {
|
||||
createMF := func(tag, tagValue string) model.MediaFile {
|
||||
props.Tags = model.RawTags{
|
||||
tag: {tagValue},
|
||||
}
|
||||
md = metadata.New(filePath, props)
|
||||
return md.ToMediaFile(0, "0")
|
||||
}
|
||||
|
||||
DescribeTable("Gain",
|
||||
func(tagValue string, expected float64) {
|
||||
mf := createMF("replaygain_track_gain", tagValue)
|
||||
Expect(mf.RGTrackGain).To(Equal(expected))
|
||||
},
|
||||
Entry("0", "0", 0.0),
|
||||
Entry("1.2dB", "1.2dB", 1.2),
|
||||
Entry("Infinity", "Infinity", 0.0),
|
||||
Entry("Invalid value", "INVALID VALUE", 0.0),
|
||||
)
|
||||
DescribeTable("Peak",
|
||||
func(tagValue string, expected float64) {
|
||||
mf := createMF("replaygain_track_peak", tagValue)
|
||||
Expect(mf.RGTrackPeak).To(Equal(expected))
|
||||
},
|
||||
Entry("0", "0", 0.0),
|
||||
Entry("0.5", "0.5", 0.5),
|
||||
Entry("Invalid dB suffix", "0.7dB", 1.0),
|
||||
Entry("Infinity", "Infinity", 1.0),
|
||||
Entry("Invalid value", "INVALID VALUE", 1.0),
|
||||
)
|
||||
DescribeTable("getR128GainValue",
|
||||
func(tagValue string, expected float64) {
|
||||
mf := createMF("r128_track_gain", tagValue)
|
||||
Expect(mf.RGTrackGain).To(Equal(expected))
|
||||
|
||||
},
|
||||
Entry("0", "0", 5.0),
|
||||
Entry("-3776", "-3776", -9.75),
|
||||
Entry("Infinity", "Infinity", 0.0),
|
||||
Entry("Invalid value", "INVALID VALUE", 0.0),
|
||||
)
|
||||
})
|
||||
|
||||
})
|
||||
})
|
||||
99
model/metadata/persistent_ids.go
Normal file
99
model/metadata/persistent_ids.go
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
package metadata
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/navidrome/navidrome/conf"
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
"github.com/navidrome/navidrome/model"
|
||||
"github.com/navidrome/navidrome/model/id"
|
||||
"github.com/navidrome/navidrome/utils"
|
||||
"github.com/navidrome/navidrome/utils/slice"
|
||||
"github.com/navidrome/navidrome/utils/str"
|
||||
)
|
||||
|
||||
type hashFunc = func(...string) string
|
||||
|
||||
// getPID returns the persistent ID for a given spec, getting the referenced values from the metadata
|
||||
// The spec is a pipe-separated list of fields, where each field is a comma-separated list of attributes
|
||||
// Attributes can be either tags or some processed values like folder, albumid, albumartistid, etc.
|
||||
// For each field, it gets all its attributes values and concatenates them, then hashes the result.
|
||||
// If a field is empty, it is skipped and the function looks for the next field.
|
||||
func createGetPID(hash hashFunc) func(mf model.MediaFile, md Metadata, spec string) string {
|
||||
var getPID func(mf model.MediaFile, md Metadata, spec string) string
|
||||
getAttr := func(mf model.MediaFile, md Metadata, attr string) string {
|
||||
switch attr {
|
||||
case "albumid":
|
||||
return getPID(mf, md, conf.Server.PID.Album)
|
||||
case "folder":
|
||||
return filepath.Dir(mf.Path)
|
||||
case "albumartistid":
|
||||
return hash(str.Clear(strings.ToLower(mf.AlbumArtist)))
|
||||
case "title":
|
||||
return mf.Title
|
||||
case "album":
|
||||
return str.Clear(strings.ToLower(md.String(model.TagAlbum)))
|
||||
}
|
||||
return md.String(model.TagName(attr))
|
||||
}
|
||||
getPID = func(mf model.MediaFile, md Metadata, spec string) string {
|
||||
pid := ""
|
||||
fields := strings.Split(spec, "|")
|
||||
for _, field := range fields {
|
||||
attributes := strings.Split(field, ",")
|
||||
hasValue := false
|
||||
values := slice.Map(attributes, func(attr string) string {
|
||||
v := getAttr(mf, md, attr)
|
||||
if v != "" {
|
||||
hasValue = true
|
||||
}
|
||||
return v
|
||||
})
|
||||
if hasValue {
|
||||
pid += strings.Join(values, "\\")
|
||||
break
|
||||
}
|
||||
}
|
||||
return hash(pid)
|
||||
}
|
||||
|
||||
return func(mf model.MediaFile, md Metadata, spec string) string {
|
||||
switch spec {
|
||||
case "track_legacy":
|
||||
return legacyTrackID(mf)
|
||||
case "album_legacy":
|
||||
return legacyAlbumID(md)
|
||||
}
|
||||
return getPID(mf, md, spec)
|
||||
}
|
||||
}
|
||||
|
||||
func (md Metadata) trackPID(mf model.MediaFile) string {
|
||||
return createGetPID(id.NewHash)(mf, md, conf.Server.PID.Track)
|
||||
}
|
||||
|
||||
func (md Metadata) albumID(mf model.MediaFile) string {
|
||||
return createGetPID(id.NewHash)(mf, md, conf.Server.PID.Album)
|
||||
}
|
||||
|
||||
// BFR Must be configurable?
|
||||
func (md Metadata) artistID(name string) string {
|
||||
mf := model.MediaFile{AlbumArtist: name}
|
||||
return createGetPID(id.NewHash)(mf, md, "albumartistid")
|
||||
}
|
||||
|
||||
func (md Metadata) mapTrackTitle() string {
|
||||
if title := md.String(model.TagTitle); title != "" {
|
||||
return title
|
||||
}
|
||||
return utils.BaseName(md.FilePath())
|
||||
}
|
||||
|
||||
func (md Metadata) mapAlbumName() string {
|
||||
return cmp.Or(
|
||||
md.String(model.TagAlbum),
|
||||
consts.UnknownAlbum,
|
||||
)
|
||||
}
|
||||
117
model/metadata/persistent_ids_test.go
Normal file
117
model/metadata/persistent_ids_test.go
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
package metadata
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/navidrome/navidrome/conf"
|
||||
"github.com/navidrome/navidrome/conf/configtest"
|
||||
"github.com/navidrome/navidrome/model"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("getPID", func() {
|
||||
var (
|
||||
md Metadata
|
||||
mf model.MediaFile
|
||||
sum hashFunc
|
||||
getPID func(mf model.MediaFile, md Metadata, spec string) string
|
||||
)
|
||||
|
||||
BeforeEach(func() {
|
||||
sum = func(s ...string) string { return "(" + strings.Join(s, ",") + ")" }
|
||||
getPID = createGetPID(sum)
|
||||
})
|
||||
|
||||
Context("attributes are tags", func() {
|
||||
spec := "musicbrainz_trackid|album,discnumber,tracknumber"
|
||||
When("no attributes were present", func() {
|
||||
It("should return empty pid", func() {
|
||||
md.tags = map[model.TagName][]string{}
|
||||
pid := getPID(mf, md, spec)
|
||||
Expect(pid).To(Equal("()"))
|
||||
})
|
||||
})
|
||||
When("all fields are present", func() {
|
||||
It("should return the pid", func() {
|
||||
md.tags = map[model.TagName][]string{
|
||||
"musicbrainz_trackid": {"mbtrackid"},
|
||||
"album": {"album name"},
|
||||
"discnumber": {"1"},
|
||||
"tracknumber": {"1"},
|
||||
}
|
||||
Expect(getPID(mf, md, spec)).To(Equal("(mbtrackid)"))
|
||||
})
|
||||
})
|
||||
When("only first field is present", func() {
|
||||
It("should return the pid", func() {
|
||||
md.tags = map[model.TagName][]string{
|
||||
"musicbrainz_trackid": {"mbtrackid"},
|
||||
}
|
||||
Expect(getPID(mf, md, spec)).To(Equal("(mbtrackid)"))
|
||||
})
|
||||
})
|
||||
When("first is empty, but second field is present", func() {
|
||||
It("should return the pid", func() {
|
||||
md.tags = map[model.TagName][]string{
|
||||
"album": {"album name"},
|
||||
"discnumber": {"1"},
|
||||
}
|
||||
Expect(getPID(mf, md, spec)).To(Equal("(album name\\1\\)"))
|
||||
})
|
||||
})
|
||||
})
|
||||
Context("calculated attributes", func() {
|
||||
BeforeEach(func() {
|
||||
DeferCleanup(configtest.SetupConfig())
|
||||
conf.Server.PID.Album = "musicbrainz_albumid|albumartistid,album,version,releasedate"
|
||||
})
|
||||
When("field is title", func() {
|
||||
It("should return the pid", func() {
|
||||
spec := "title|folder"
|
||||
md.tags = map[model.TagName][]string{"title": {"title"}}
|
||||
md.filePath = "/path/to/file.mp3"
|
||||
mf.Title = "Title"
|
||||
Expect(getPID(mf, md, spec)).To(Equal("(Title)"))
|
||||
})
|
||||
})
|
||||
When("field is folder", func() {
|
||||
It("should return the pid", func() {
|
||||
spec := "folder|title"
|
||||
md.tags = map[model.TagName][]string{"title": {"title"}}
|
||||
mf.Path = "/path/to/file.mp3"
|
||||
Expect(getPID(mf, md, spec)).To(Equal("(/path/to)"))
|
||||
})
|
||||
})
|
||||
When("field is albumid", func() {
|
||||
It("should return the pid", func() {
|
||||
spec := "albumid|title"
|
||||
md.tags = map[model.TagName][]string{
|
||||
"title": {"title"},
|
||||
"album": {"album name"},
|
||||
"version": {"version"},
|
||||
"releasedate": {"2021-01-01"},
|
||||
}
|
||||
mf.AlbumArtist = "Album Artist"
|
||||
Expect(getPID(mf, md, spec)).To(Equal("(((album artist)\\album name\\version\\2021-01-01))"))
|
||||
})
|
||||
})
|
||||
When("field is albumartistid", func() {
|
||||
It("should return the pid", func() {
|
||||
spec := "musicbrainz_albumartistid|albumartistid"
|
||||
md.tags = map[model.TagName][]string{
|
||||
"albumartist": {"Album Artist"},
|
||||
}
|
||||
mf.AlbumArtist = "Album Artist"
|
||||
Expect(getPID(mf, md, spec)).To(Equal("((album artist))"))
|
||||
})
|
||||
})
|
||||
When("field is album", func() {
|
||||
It("should return the pid", func() {
|
||||
spec := "album|title"
|
||||
md.tags = map[model.TagName][]string{"album": {"Album Name"}}
|
||||
Expect(getPID(mf, md, spec)).To(Equal("(album name)"))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
196
model/participants.go
Normal file
196
model/participants.go
Normal file
|
|
@ -0,0 +1,196 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
"crypto/md5"
|
||||
"fmt"
|
||||
"slices"
|
||||
"strings"
|
||||
|
||||
"github.com/navidrome/navidrome/utils/slice"
|
||||
)
|
||||
|
||||
var (
|
||||
RoleInvalid = Role{"invalid"}
|
||||
RoleArtist = Role{"artist"}
|
||||
RoleAlbumArtist = Role{"albumartist"}
|
||||
RoleComposer = Role{"composer"}
|
||||
RoleConductor = Role{"conductor"}
|
||||
RoleLyricist = Role{"lyricist"}
|
||||
RoleArranger = Role{"arranger"}
|
||||
RoleProducer = Role{"producer"}
|
||||
RoleDirector = Role{"director"}
|
||||
RoleEngineer = Role{"engineer"}
|
||||
RoleMixer = Role{"mixer"}
|
||||
RoleRemixer = Role{"remixer"}
|
||||
RoleDJMixer = Role{"djmixer"}
|
||||
RolePerformer = Role{"performer"}
|
||||
)
|
||||
|
||||
var AllRoles = map[string]Role{
|
||||
RoleArtist.role: RoleArtist,
|
||||
RoleAlbumArtist.role: RoleAlbumArtist,
|
||||
RoleComposer.role: RoleComposer,
|
||||
RoleConductor.role: RoleConductor,
|
||||
RoleLyricist.role: RoleLyricist,
|
||||
RoleArranger.role: RoleArranger,
|
||||
RoleProducer.role: RoleProducer,
|
||||
RoleDirector.role: RoleDirector,
|
||||
RoleEngineer.role: RoleEngineer,
|
||||
RoleMixer.role: RoleMixer,
|
||||
RoleRemixer.role: RoleRemixer,
|
||||
RoleDJMixer.role: RoleDJMixer,
|
||||
RolePerformer.role: RolePerformer,
|
||||
}
|
||||
|
||||
// Role represents the role of an artist in a track or album.
|
||||
type Role struct {
|
||||
role string
|
||||
}
|
||||
|
||||
func (r Role) String() string {
|
||||
return r.role
|
||||
}
|
||||
|
||||
func (r Role) MarshalText() (text []byte, err error) {
|
||||
return []byte(r.role), nil
|
||||
}
|
||||
|
||||
func (r *Role) UnmarshalText(text []byte) error {
|
||||
role := RoleFromString(string(text))
|
||||
if role == RoleInvalid {
|
||||
return fmt.Errorf("invalid role: %s", text)
|
||||
}
|
||||
*r = role
|
||||
return nil
|
||||
}
|
||||
|
||||
func RoleFromString(role string) Role {
|
||||
if r, ok := AllRoles[role]; ok {
|
||||
return r
|
||||
}
|
||||
return RoleInvalid
|
||||
}
|
||||
|
||||
type Participant struct {
|
||||
Artist
|
||||
SubRole string `json:"subRole,omitempty"`
|
||||
}
|
||||
|
||||
type ParticipantList []Participant
|
||||
|
||||
func (p ParticipantList) Join(sep string) string {
|
||||
return strings.Join(slice.Map(p, func(p Participant) string {
|
||||
if p.SubRole != "" {
|
||||
return p.Name + " (" + p.SubRole + ")"
|
||||
}
|
||||
return p.Name
|
||||
}), sep)
|
||||
}
|
||||
|
||||
type Participants map[Role]ParticipantList
|
||||
|
||||
// Add adds the artists to the role, ignoring duplicates.
|
||||
func (p Participants) Add(role Role, artists ...Artist) {
|
||||
participants := slice.Map(artists, func(artist Artist) Participant {
|
||||
return Participant{Artist: artist}
|
||||
})
|
||||
p.add(role, participants...)
|
||||
}
|
||||
|
||||
// AddWithSubRole adds the artists to the role, ignoring duplicates.
|
||||
func (p Participants) AddWithSubRole(role Role, subRole string, artists ...Artist) {
|
||||
participants := slice.Map(artists, func(artist Artist) Participant {
|
||||
return Participant{Artist: artist, SubRole: subRole}
|
||||
})
|
||||
p.add(role, participants...)
|
||||
}
|
||||
|
||||
func (p Participants) Sort() {
|
||||
for _, artists := range p {
|
||||
slices.SortFunc(artists, func(a1, a2 Participant) int {
|
||||
return cmp.Compare(a1.Name, a2.Name)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// First returns the first artist for the role, or an empty artist if the role is not present.
|
||||
func (p Participants) First(role Role) Artist {
|
||||
if artists, ok := p[role]; ok && len(artists) > 0 {
|
||||
return artists[0].Artist
|
||||
}
|
||||
return Artist{}
|
||||
}
|
||||
|
||||
// Merge merges the other Participants into this one.
|
||||
func (p Participants) Merge(other Participants) {
|
||||
for role, artists := range other {
|
||||
p.add(role, artists...)
|
||||
}
|
||||
}
|
||||
|
||||
func (p Participants) add(role Role, participants ...Participant) {
|
||||
seen := make(map[string]struct{}, len(p[role]))
|
||||
for _, artist := range p[role] {
|
||||
seen[artist.ID+artist.SubRole] = struct{}{}
|
||||
}
|
||||
for _, participant := range participants {
|
||||
key := participant.ID + participant.SubRole
|
||||
if _, ok := seen[key]; !ok {
|
||||
seen[key] = struct{}{}
|
||||
p[role] = append(p[role], participant)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// AllArtists returns all artists found in the Participants.
|
||||
func (p Participants) AllArtists() []Artist {
|
||||
// First count the total number of artists to avoid reallocations.
|
||||
totalArtists := 0
|
||||
for _, roleArtists := range p {
|
||||
totalArtists += len(roleArtists)
|
||||
}
|
||||
artists := make(Artists, 0, totalArtists)
|
||||
for _, roleArtists := range p {
|
||||
artists = append(artists, slice.Map(roleArtists, func(p Participant) Artist { return p.Artist })...)
|
||||
}
|
||||
slices.SortStableFunc(artists, func(a1, a2 Artist) int {
|
||||
return cmp.Compare(a1.ID, a2.ID)
|
||||
})
|
||||
return slices.CompactFunc(artists, func(a1, a2 Artist) bool {
|
||||
return a1.ID == a2.ID
|
||||
})
|
||||
}
|
||||
|
||||
// AllIDs returns all artist IDs found in the Participants.
|
||||
func (p Participants) AllIDs() []string {
|
||||
artists := p.AllArtists()
|
||||
return slice.Map(artists, func(a Artist) string { return a.ID })
|
||||
}
|
||||
|
||||
// AllNames returns all artist names found in the Participants, including SortArtistNames.
|
||||
func (p Participants) AllNames() []string {
|
||||
names := make([]string, 0, len(p))
|
||||
for _, artists := range p {
|
||||
for _, artist := range artists {
|
||||
names = append(names, artist.Name)
|
||||
if artist.SortArtistName != "" {
|
||||
names = append(names, artist.SortArtistName)
|
||||
}
|
||||
}
|
||||
}
|
||||
return slice.Unique(names)
|
||||
}
|
||||
|
||||
func (p Participants) Hash() []byte {
|
||||
flattened := make([]string, 0, len(p))
|
||||
for role, artists := range p {
|
||||
ids := slice.Map(artists, func(participant Participant) string { return participant.SubRole + ":" + participant.ID })
|
||||
slices.Sort(ids)
|
||||
flattened = append(flattened, role.String()+":"+strings.Join(ids, "/"))
|
||||
}
|
||||
slices.Sort(flattened)
|
||||
sum := md5.New()
|
||||
sum.Write([]byte(strings.Join(flattened, "|")))
|
||||
return sum.Sum(nil)
|
||||
}
|
||||
214
model/participants_test.go
Normal file
214
model/participants_test.go
Normal file
|
|
@ -0,0 +1,214 @@
|
|||
package model_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
|
||||
. "github.com/navidrome/navidrome/model"
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("Participants", func() {
|
||||
Describe("JSON Marshalling", func() {
|
||||
When("we have a valid Albums object", func() {
|
||||
var participants Participants
|
||||
BeforeEach(func() {
|
||||
participants = Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
RoleAlbumArtist: []Participant{_p("3", "AlbumArtist1"), _p("4", "AlbumArtist2")},
|
||||
}
|
||||
})
|
||||
|
||||
It("marshals correctly", func() {
|
||||
data, err := json.Marshal(participants)
|
||||
Expect(err).To(BeNil())
|
||||
|
||||
var afterConversion Participants
|
||||
err = json.Unmarshal(data, &afterConversion)
|
||||
Expect(err).To(BeNil())
|
||||
Expect(afterConversion).To(Equal(participants))
|
||||
})
|
||||
|
||||
It("returns unmarshal error when the role is invalid", func() {
|
||||
err := json.Unmarshal([]byte(`{"unknown": []}`), &participants)
|
||||
Expect(err).To(MatchError("invalid role: unknown"))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("First", func() {
|
||||
var participants Participants
|
||||
BeforeEach(func() {
|
||||
participants = Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
RoleAlbumArtist: []Participant{_p("3", "AlbumArtist1"), _p("4", "AlbumArtist2")},
|
||||
}
|
||||
})
|
||||
It("returns the first artist of the role", func() {
|
||||
Expect(participants.First(RoleArtist)).To(Equal(Artist{ID: "1", Name: "Artist1"}))
|
||||
})
|
||||
It("returns an empty artist when the role is not present", func() {
|
||||
Expect(participants.First(RoleComposer)).To(Equal(Artist{}))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Add", func() {
|
||||
var participants Participants
|
||||
BeforeEach(func() {
|
||||
participants = Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
}
|
||||
})
|
||||
It("adds the artist to the role", func() {
|
||||
participants.Add(RoleArtist, Artist{ID: "5", Name: "Artist5"})
|
||||
Expect(participants).To(Equal(Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2"), _p("5", "Artist5")},
|
||||
}))
|
||||
})
|
||||
It("creates a new role if it doesn't exist", func() {
|
||||
participants.Add(RoleComposer, Artist{ID: "5", Name: "Artist5"})
|
||||
Expect(participants).To(Equal(Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
RoleComposer: []Participant{_p("5", "Artist5")},
|
||||
}))
|
||||
})
|
||||
It("should not add duplicate artists", func() {
|
||||
participants.Add(RoleArtist, Artist{ID: "1", Name: "Artist1"})
|
||||
Expect(participants).To(Equal(Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
}))
|
||||
})
|
||||
It("adds the artist with and without subrole", func() {
|
||||
participants = Participants{}
|
||||
participants.Add(RolePerformer, Artist{ID: "3", Name: "Artist3"})
|
||||
participants.AddWithSubRole(RolePerformer, "SubRole", Artist{ID: "3", Name: "Artist3"})
|
||||
|
||||
artist3 := _p("3", "Artist3")
|
||||
artist3WithSubRole := artist3
|
||||
artist3WithSubRole.SubRole = "SubRole"
|
||||
|
||||
Expect(participants[RolePerformer]).To(HaveLen(2))
|
||||
Expect(participants).To(Equal(Participants{
|
||||
RolePerformer: []Participant{
|
||||
artist3,
|
||||
artist3WithSubRole,
|
||||
},
|
||||
}))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Merge", func() {
|
||||
var participations1, participations2 Participants
|
||||
BeforeEach(func() {
|
||||
participations1 = Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Duplicated Artist")},
|
||||
RoleAlbumArtist: []Participant{_p("3", "AlbumArtist1"), _p("4", "AlbumArtist2")},
|
||||
}
|
||||
participations2 = Participants{
|
||||
RoleArtist: []Participant{_p("5", "Artist3"), _p("6", "Artist4"), _p("2", "Duplicated Artist")},
|
||||
RoleAlbumArtist: []Participant{_p("7", "AlbumArtist3"), _p("8", "AlbumArtist4")},
|
||||
}
|
||||
})
|
||||
It("merges correctly, skipping duplicated artists", func() {
|
||||
participations1.Merge(participations2)
|
||||
Expect(participations1).To(Equal(Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Duplicated Artist"), _p("5", "Artist3"), _p("6", "Artist4")},
|
||||
RoleAlbumArtist: []Participant{_p("3", "AlbumArtist1"), _p("4", "AlbumArtist2"), _p("7", "AlbumArtist3"), _p("8", "AlbumArtist4")},
|
||||
}))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Hash", func() {
|
||||
It("should return the same hash for the same participants", func() {
|
||||
p1 := Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
RoleAlbumArtist: []Participant{_p("3", "AlbumArtist1"), _p("4", "AlbumArtist2")},
|
||||
}
|
||||
p2 := Participants{
|
||||
RoleArtist: []Participant{_p("2", "Artist2"), _p("1", "Artist1")},
|
||||
RoleAlbumArtist: []Participant{_p("4", "AlbumArtist2"), _p("3", "AlbumArtist1")},
|
||||
}
|
||||
Expect(p1.Hash()).To(Equal(p2.Hash()))
|
||||
})
|
||||
It("should return different hashes for different participants", func() {
|
||||
p1 := Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1")},
|
||||
}
|
||||
p2 := Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
}
|
||||
Expect(p1.Hash()).ToNot(Equal(p2.Hash()))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("All", func() {
|
||||
var participants Participants
|
||||
BeforeEach(func() {
|
||||
participants = Participants{
|
||||
RoleArtist: []Participant{_p("1", "Artist1"), _p("2", "Artist2")},
|
||||
RoleAlbumArtist: []Participant{_p("3", "AlbumArtist1"), _p("4", "AlbumArtist2")},
|
||||
RoleProducer: []Participant{_p("5", "Producer", "SortProducerName")},
|
||||
RoleComposer: []Participant{_p("1", "Artist1")},
|
||||
}
|
||||
})
|
||||
|
||||
Describe("All", func() {
|
||||
It("returns all artists found in the Participants", func() {
|
||||
artists := participants.AllArtists()
|
||||
Expect(artists).To(ConsistOf(
|
||||
Artist{ID: "1", Name: "Artist1"},
|
||||
Artist{ID: "2", Name: "Artist2"},
|
||||
Artist{ID: "3", Name: "AlbumArtist1"},
|
||||
Artist{ID: "4", Name: "AlbumArtist2"},
|
||||
Artist{ID: "5", Name: "Producer", SortArtistName: "SortProducerName"},
|
||||
))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("AllIDs", func() {
|
||||
It("returns all artist IDs found in the Participants", func() {
|
||||
ids := participants.AllIDs()
|
||||
Expect(ids).To(ConsistOf("1", "2", "3", "4", "5"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("AllNames", func() {
|
||||
It("returns all artist names found in the Participants", func() {
|
||||
names := participants.AllNames()
|
||||
Expect(names).To(ConsistOf("Artist1", "Artist2", "AlbumArtist1", "AlbumArtist2",
|
||||
"Producer", "SortProducerName"))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
var _ = Describe("ParticipantList", func() {
|
||||
Describe("Join", func() {
|
||||
It("joins the participants with the given separator", func() {
|
||||
list := ParticipantList{
|
||||
_p("1", "Artist 1"),
|
||||
_p("3", "Artist 2"),
|
||||
}
|
||||
list[0].SubRole = "SubRole"
|
||||
Expect(list.Join(", ")).To(Equal("Artist 1 (SubRole), Artist 2"))
|
||||
})
|
||||
|
||||
It("returns the sole participant if there is only one", func() {
|
||||
list := ParticipantList{_p("1", "Artist 1")}
|
||||
Expect(list.Join(", ")).To(Equal("Artist 1"))
|
||||
})
|
||||
|
||||
It("returns empty string if there are no participants", func() {
|
||||
var list ParticipantList
|
||||
Expect(list.Join(", ")).To(Equal(""))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
func _p(id, name string, sortName ...string) Participant {
|
||||
p := Participant{Artist: Artist{ID: id, Name: name}}
|
||||
if len(sortName) > 0 {
|
||||
p.Artist.SortArtistName = sortName[0]
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
|
@ -61,7 +61,7 @@ func (pls *Playlist) ToM3U8() string {
|
|||
buf.WriteString(fmt.Sprintf("#PLAYLIST:%s\n", pls.Name))
|
||||
for _, t := range pls.Tracks {
|
||||
buf.WriteString(fmt.Sprintf("#EXTINF:%.f,%s - %s\n", t.Duration, t.Artist, t.Title))
|
||||
buf.WriteString(t.Path + "\n")
|
||||
buf.WriteString(t.AbsolutePath() + "\n")
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
|
@ -106,7 +106,7 @@ type PlaylistRepository interface {
|
|||
Exists(id string) (bool, error)
|
||||
Put(pls *Playlist) error
|
||||
Get(id string) (*Playlist, error)
|
||||
GetWithTracks(id string, refreshSmartPlaylist bool) (*Playlist, error)
|
||||
GetWithTracks(id string, refreshSmartPlaylist, includeMissing bool) (*Playlist, error)
|
||||
GetAll(options ...QueryOptions) (Playlists, error)
|
||||
FindByPath(path string) (*Playlist, error)
|
||||
Delete(id string) error
|
||||
|
|
|
|||
|
|
@ -19,6 +19,17 @@ const (
|
|||
ReverseProxyIp = contextKey("reverseProxyIp")
|
||||
)
|
||||
|
||||
var allKeys = []contextKey{
|
||||
User,
|
||||
Username,
|
||||
Client,
|
||||
Version,
|
||||
Player,
|
||||
Transcoding,
|
||||
ClientUniqueId,
|
||||
ReverseProxyIp,
|
||||
}
|
||||
|
||||
func WithUser(ctx context.Context, u model.User) context.Context {
|
||||
return context.WithValue(ctx, User, u)
|
||||
}
|
||||
|
|
@ -90,3 +101,12 @@ func ReverseProxyIpFrom(ctx context.Context) (string, bool) {
|
|||
v, ok := ctx.Value(ReverseProxyIp).(string)
|
||||
return v, ok
|
||||
}
|
||||
|
||||
func AddValues(ctx, requestCtx context.Context) context.Context {
|
||||
for _, key := range allKeys {
|
||||
if v := requestCtx.Value(key); v != nil {
|
||||
ctx = context.WithValue(ctx, key, v)
|
||||
}
|
||||
}
|
||||
return ctx
|
||||
}
|
||||
|
|
|
|||
5
model/searchable.go
Normal file
5
model/searchable.go
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
package model
|
||||
|
||||
type SearchableRepository[T any] interface {
|
||||
Search(q string, offset, size int, includeMissing bool) (T, error)
|
||||
}
|
||||
256
model/tag.go
Normal file
256
model/tag.go
Normal file
|
|
@ -0,0 +1,256 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
"crypto/md5"
|
||||
"fmt"
|
||||
"slices"
|
||||
"strings"
|
||||
|
||||
"github.com/navidrome/navidrome/model/id"
|
||||
"github.com/navidrome/navidrome/utils/slice"
|
||||
)
|
||||
|
||||
type Tag struct {
|
||||
ID string `json:"id,omitempty"`
|
||||
TagName TagName `json:"tagName,omitempty"`
|
||||
TagValue string `json:"tagValue,omitempty"`
|
||||
AlbumCount int `json:"albumCount,omitempty"`
|
||||
MediaFileCount int `json:"songCount,omitempty"`
|
||||
}
|
||||
|
||||
type TagList []Tag
|
||||
|
||||
func (l TagList) GroupByFrequency() Tags {
|
||||
grouped := map[string]map[string]int{}
|
||||
values := map[string]string{}
|
||||
for _, t := range l {
|
||||
if m, ok := grouped[string(t.TagName)]; !ok {
|
||||
grouped[string(t.TagName)] = map[string]int{t.ID: 1}
|
||||
} else {
|
||||
m[t.ID]++
|
||||
}
|
||||
values[t.ID] = t.TagValue
|
||||
}
|
||||
|
||||
tags := Tags{}
|
||||
for name, counts := range grouped {
|
||||
idList := make([]string, 0, len(counts))
|
||||
for tid := range counts {
|
||||
idList = append(idList, tid)
|
||||
}
|
||||
slices.SortFunc(idList, func(a, b string) int {
|
||||
return cmp.Or(
|
||||
cmp.Compare(counts[b], counts[a]),
|
||||
cmp.Compare(values[a], values[b]),
|
||||
)
|
||||
})
|
||||
tags[TagName(name)] = slice.Map(idList, func(id string) string { return values[id] })
|
||||
}
|
||||
return tags
|
||||
}
|
||||
|
||||
func (t Tag) String() string {
|
||||
return fmt.Sprintf("%s=%s", t.TagName, t.TagValue)
|
||||
}
|
||||
|
||||
func NewTag(name TagName, value string) Tag {
|
||||
name = name.ToLower()
|
||||
hashID := tagID(name, value)
|
||||
return Tag{
|
||||
ID: hashID,
|
||||
TagName: name,
|
||||
TagValue: value,
|
||||
}
|
||||
}
|
||||
|
||||
func tagID(name TagName, value string) string {
|
||||
return id.NewTagID(string(name), value)
|
||||
}
|
||||
|
||||
type RawTags map[string][]string
|
||||
|
||||
type Tags map[TagName][]string
|
||||
|
||||
func (t Tags) Values(name TagName) []string {
|
||||
return t[name]
|
||||
}
|
||||
|
||||
func (t Tags) IDs() []string {
|
||||
var ids []string
|
||||
for name, tag := range t {
|
||||
name = name.ToLower()
|
||||
for _, v := range tag {
|
||||
ids = append(ids, tagID(name, v))
|
||||
}
|
||||
}
|
||||
return ids
|
||||
}
|
||||
|
||||
func (t Tags) Flatten(name TagName) TagList {
|
||||
var tags TagList
|
||||
for _, v := range t[name] {
|
||||
tags = append(tags, NewTag(name, v))
|
||||
}
|
||||
return tags
|
||||
}
|
||||
|
||||
func (t Tags) FlattenAll() TagList {
|
||||
var tags TagList
|
||||
for name, values := range t {
|
||||
for _, v := range values {
|
||||
tags = append(tags, NewTag(name, v))
|
||||
}
|
||||
}
|
||||
return tags
|
||||
}
|
||||
|
||||
func (t Tags) Sort() {
|
||||
for _, values := range t {
|
||||
slices.Sort(values)
|
||||
}
|
||||
}
|
||||
|
||||
func (t Tags) Hash() []byte {
|
||||
if len(t) == 0 {
|
||||
return nil
|
||||
}
|
||||
ids := t.IDs()
|
||||
slices.Sort(ids)
|
||||
sum := md5.New()
|
||||
sum.Write([]byte(strings.Join(ids, "|")))
|
||||
return sum.Sum(nil)
|
||||
}
|
||||
|
||||
func (t Tags) ToGenres() (string, Genres) {
|
||||
values := t.Values("genre")
|
||||
if len(values) == 0 {
|
||||
return "", nil
|
||||
}
|
||||
genres := slice.Map(values, func(g string) Genre {
|
||||
t := NewTag("genre", g)
|
||||
return Genre{ID: t.ID, Name: g}
|
||||
})
|
||||
return genres[0].Name, genres
|
||||
}
|
||||
|
||||
// Merge merges the tags from another Tags object into this one, removing any duplicates
|
||||
func (t Tags) Merge(tags Tags) {
|
||||
for name, values := range tags {
|
||||
for _, v := range values {
|
||||
t.Add(name, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (t Tags) Add(name TagName, v string) {
|
||||
for _, existing := range t[name] {
|
||||
if existing == v {
|
||||
return
|
||||
}
|
||||
}
|
||||
t[name] = append(t[name], v)
|
||||
}
|
||||
|
||||
type TagRepository interface {
|
||||
Add(...Tag) error
|
||||
UpdateCounts() error
|
||||
}
|
||||
|
||||
type TagName string
|
||||
|
||||
func (t TagName) ToLower() TagName {
|
||||
return TagName(strings.ToLower(string(t)))
|
||||
}
|
||||
|
||||
func (t TagName) String() string {
|
||||
return string(t)
|
||||
}
|
||||
|
||||
// Tag names, as defined in the mappings.yaml file
|
||||
const (
|
||||
TagAlbum TagName = "album"
|
||||
TagTitle TagName = "title"
|
||||
TagTrackNumber TagName = "track"
|
||||
TagDiscNumber TagName = "disc"
|
||||
TagTotalTracks TagName = "tracktotal"
|
||||
TagTotalDiscs TagName = "disctotal"
|
||||
TagDiscSubtitle TagName = "discsubtitle"
|
||||
TagSubtitle TagName = "subtitle"
|
||||
TagGenre TagName = "genre"
|
||||
TagMood TagName = "mood"
|
||||
TagComment TagName = "comment"
|
||||
TagAlbumSort TagName = "albumsort"
|
||||
TagAlbumVersion TagName = "albumversion"
|
||||
TagTitleSort TagName = "titlesort"
|
||||
TagCompilation TagName = "compilation"
|
||||
TagGrouping TagName = "grouping"
|
||||
TagLyrics TagName = "lyrics"
|
||||
TagRecordLabel TagName = "recordlabel"
|
||||
TagReleaseType TagName = "releasetype"
|
||||
TagReleaseCountry TagName = "releasecountry"
|
||||
TagMedia TagName = "media"
|
||||
TagCatalogNumber TagName = "catalognumber"
|
||||
TagBPM TagName = "bpm"
|
||||
TagExplicitStatus TagName = "explicitstatus"
|
||||
|
||||
// Dates and years
|
||||
|
||||
TagOriginalDate TagName = "originaldate"
|
||||
TagReleaseDate TagName = "releasedate"
|
||||
TagRecordingDate TagName = "recordingdate"
|
||||
|
||||
// Artists and roles
|
||||
|
||||
TagAlbumArtist TagName = "albumartist"
|
||||
TagAlbumArtists TagName = "albumartists"
|
||||
TagAlbumArtistSort TagName = "albumartistsort"
|
||||
TagAlbumArtistsSort TagName = "albumartistssort"
|
||||
TagTrackArtist TagName = "artist"
|
||||
TagTrackArtists TagName = "artists"
|
||||
TagTrackArtistSort TagName = "artistsort"
|
||||
TagTrackArtistsSort TagName = "artistssort"
|
||||
TagComposer TagName = "composer"
|
||||
TagComposerSort TagName = "composersort"
|
||||
TagLyricist TagName = "lyricist"
|
||||
TagLyricistSort TagName = "lyricistsort"
|
||||
TagDirector TagName = "director"
|
||||
TagProducer TagName = "producer"
|
||||
TagEngineer TagName = "engineer"
|
||||
TagMixer TagName = "mixer"
|
||||
TagRemixer TagName = "remixer"
|
||||
TagDJMixer TagName = "djmixer"
|
||||
TagConductor TagName = "conductor"
|
||||
TagArranger TagName = "arranger"
|
||||
TagPerformer TagName = "performer"
|
||||
|
||||
// ReplayGain
|
||||
|
||||
TagReplayGainAlbumGain TagName = "replaygain_album_gain"
|
||||
TagReplayGainAlbumPeak TagName = "replaygain_album_peak"
|
||||
TagReplayGainTrackGain TagName = "replaygain_track_gain"
|
||||
TagReplayGainTrackPeak TagName = "replaygain_track_peak"
|
||||
TagR128AlbumGain TagName = "r128_album_gain"
|
||||
TagR128TrackGain TagName = "r128_track_gain"
|
||||
|
||||
// MusicBrainz
|
||||
|
||||
TagMusicBrainzArtistID TagName = "musicbrainz_artistid"
|
||||
TagMusicBrainzRecordingID TagName = "musicbrainz_recordingid"
|
||||
TagMusicBrainzTrackID TagName = "musicbrainz_trackid"
|
||||
TagMusicBrainzAlbumArtistID TagName = "musicbrainz_albumartistid"
|
||||
TagMusicBrainzAlbumID TagName = "musicbrainz_albumid"
|
||||
TagMusicBrainzReleaseGroupID TagName = "musicbrainz_releasegroupid"
|
||||
|
||||
TagMusicBrainzComposerID TagName = "musicbrainz_composerid"
|
||||
TagMusicBrainzLyricistID TagName = "musicbrainz_lyricistid"
|
||||
TagMusicBrainzDirectorID TagName = "musicbrainz_directorid"
|
||||
TagMusicBrainzProducerID TagName = "musicbrainz_producerid"
|
||||
TagMusicBrainzEngineerID TagName = "musicbrainz_engineerid"
|
||||
TagMusicBrainzMixerID TagName = "musicbrainz_mixerid"
|
||||
TagMusicBrainzRemixerID TagName = "musicbrainz_remixerid"
|
||||
TagMusicBrainzDJMixerID TagName = "musicbrainz_djmixerid"
|
||||
TagMusicBrainzConductorID TagName = "musicbrainz_conductorid"
|
||||
TagMusicBrainzArrangerID TagName = "musicbrainz_arrangerid"
|
||||
TagMusicBrainzPerformerID TagName = "musicbrainz_performerid"
|
||||
)
|
||||
208
model/tag_mappings.go
Normal file
208
model/tag_mappings.go
Normal file
|
|
@ -0,0 +1,208 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
"maps"
|
||||
"regexp"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/navidrome/navidrome/conf"
|
||||
"github.com/navidrome/navidrome/consts"
|
||||
"github.com/navidrome/navidrome/log"
|
||||
"github.com/navidrome/navidrome/model/criteria"
|
||||
"github.com/navidrome/navidrome/resources"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
type mappingsConf struct {
|
||||
Main tagMappings `yaml:"main"`
|
||||
Additional tagMappings `yaml:"additional"`
|
||||
Roles TagConf `yaml:"roles"`
|
||||
Artists TagConf `yaml:"artists"`
|
||||
}
|
||||
|
||||
type tagMappings map[TagName]TagConf
|
||||
|
||||
type TagConf struct {
|
||||
Aliases []string `yaml:"aliases"`
|
||||
Type TagType `yaml:"type"`
|
||||
MaxLength int `yaml:"maxLength"`
|
||||
Split []string `yaml:"split"`
|
||||
Album bool `yaml:"album"`
|
||||
SplitRx *regexp.Regexp `yaml:"-"`
|
||||
}
|
||||
|
||||
// SplitTagValue splits a tag value by the split separators, but only if it has a single value.
|
||||
func (c TagConf) SplitTagValue(values []string) []string {
|
||||
// If there's not exactly one value or no separators, return early.
|
||||
if len(values) != 1 || c.SplitRx == nil {
|
||||
return values
|
||||
}
|
||||
tag := values[0]
|
||||
|
||||
// Replace all occurrences of any separator with the zero-width space.
|
||||
tag = c.SplitRx.ReplaceAllString(tag, consts.Zwsp)
|
||||
|
||||
// Split by the zero-width space and trim each substring.
|
||||
parts := strings.Split(tag, consts.Zwsp)
|
||||
for i, part := range parts {
|
||||
parts[i] = strings.TrimSpace(part)
|
||||
}
|
||||
return parts
|
||||
}
|
||||
|
||||
type TagType string
|
||||
|
||||
const (
|
||||
TagTypeInteger TagType = "integer"
|
||||
TagTypeFloat TagType = "float"
|
||||
TagTypeDate TagType = "date"
|
||||
TagTypeUUID TagType = "uuid"
|
||||
TagTypePair TagType = "pair"
|
||||
)
|
||||
|
||||
func TagMappings() map[TagName]TagConf {
|
||||
mappings, _ := parseMappings()
|
||||
return mappings
|
||||
}
|
||||
|
||||
func TagRolesConf() TagConf {
|
||||
_, cfg := parseMappings()
|
||||
return cfg.Roles
|
||||
}
|
||||
|
||||
func TagArtistsConf() TagConf {
|
||||
_, cfg := parseMappings()
|
||||
return cfg.Artists
|
||||
}
|
||||
|
||||
func TagMainMappings() map[TagName]TagConf {
|
||||
_, mappings := parseMappings()
|
||||
return mappings.Main
|
||||
}
|
||||
|
||||
var _mappings mappingsConf
|
||||
|
||||
var parseMappings = sync.OnceValues(func() (map[TagName]TagConf, mappingsConf) {
|
||||
_mappings.Artists.SplitRx = compileSplitRegex("artists", _mappings.Artists.Split)
|
||||
_mappings.Roles.SplitRx = compileSplitRegex("roles", _mappings.Roles.Split)
|
||||
|
||||
normalized := tagMappings{}
|
||||
collectTags(_mappings.Main, normalized)
|
||||
_mappings.Main = normalized
|
||||
|
||||
normalized = tagMappings{}
|
||||
collectTags(_mappings.Additional, normalized)
|
||||
_mappings.Additional = normalized
|
||||
|
||||
// Merge main and additional mappings, log an error if a tag is found in both
|
||||
for k, v := range _mappings.Main {
|
||||
if _, ok := _mappings.Additional[k]; ok {
|
||||
log.Error("Tag found in both main and additional mappings", "tag", k)
|
||||
}
|
||||
normalized[k] = v
|
||||
}
|
||||
return normalized, _mappings
|
||||
})
|
||||
|
||||
func collectTags(tagMappings, normalized map[TagName]TagConf) {
|
||||
for k, v := range tagMappings {
|
||||
var aliases []string
|
||||
for _, val := range v.Aliases {
|
||||
aliases = append(aliases, strings.ToLower(val))
|
||||
}
|
||||
if v.Split != nil {
|
||||
if v.Type != "" {
|
||||
log.Error("Tag splitting only available for string types", "tag", k, "split", v.Split, "type", v.Type)
|
||||
v.Split = nil
|
||||
} else {
|
||||
v.SplitRx = compileSplitRegex(k, v.Split)
|
||||
}
|
||||
}
|
||||
v.Aliases = aliases
|
||||
normalized[k.ToLower()] = v
|
||||
}
|
||||
}
|
||||
|
||||
func compileSplitRegex(tagName TagName, split []string) *regexp.Regexp {
|
||||
// Build a list of escaped, non-empty separators.
|
||||
var escaped []string
|
||||
for _, s := range split {
|
||||
if s == "" {
|
||||
continue
|
||||
}
|
||||
escaped = append(escaped, regexp.QuoteMeta(s))
|
||||
}
|
||||
// If no valid separators remain, return the original value.
|
||||
if len(escaped) == 0 {
|
||||
log.Warn("No valid separators found in split list", "split", split, "tag", tagName)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Create one regex that matches any of the separators (case-insensitive).
|
||||
pattern := "(?i)(" + strings.Join(escaped, "|") + ")"
|
||||
re, err := regexp.Compile(pattern)
|
||||
if err != nil {
|
||||
log.Error("Error compiling regexp", "pattern", pattern, "tag", tagName, "err", err)
|
||||
return nil
|
||||
}
|
||||
return re
|
||||
}
|
||||
|
||||
func tagNames() []string {
|
||||
mappings := TagMappings()
|
||||
names := make([]string, 0, len(mappings))
|
||||
for k := range mappings {
|
||||
names = append(names, string(k))
|
||||
}
|
||||
return names
|
||||
}
|
||||
|
||||
func loadTagMappings() {
|
||||
mappingsFile, err := resources.FS().Open("mappings.yaml")
|
||||
if err != nil {
|
||||
log.Error("Error opening mappings.yaml", err)
|
||||
}
|
||||
decoder := yaml.NewDecoder(mappingsFile)
|
||||
err = decoder.Decode(&_mappings)
|
||||
if err != nil {
|
||||
log.Error("Error decoding mappings.yaml", err)
|
||||
}
|
||||
if len(_mappings.Main) == 0 {
|
||||
log.Error("No tag mappings found in mappings.yaml, check the format")
|
||||
}
|
||||
|
||||
// Overwrite the default mappings with the ones from the config
|
||||
for tag, cfg := range conf.Server.Tags {
|
||||
if len(cfg.Aliases) == 0 {
|
||||
delete(_mappings.Main, TagName(tag))
|
||||
delete(_mappings.Additional, TagName(tag))
|
||||
continue
|
||||
}
|
||||
c := TagConf{
|
||||
Aliases: cfg.Aliases,
|
||||
Type: TagType(cfg.Type),
|
||||
MaxLength: cfg.MaxLength,
|
||||
Split: cfg.Split,
|
||||
Album: cfg.Album,
|
||||
SplitRx: compileSplitRegex(TagName(tag), cfg.Split),
|
||||
}
|
||||
if _, ok := _mappings.Main[TagName(tag)]; ok {
|
||||
_mappings.Main[TagName(tag)] = c
|
||||
} else {
|
||||
_mappings.Additional[TagName(tag)] = c
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func init() {
|
||||
conf.AddHook(func() {
|
||||
loadTagMappings()
|
||||
|
||||
// This is here to avoid cyclic imports. The criteria package needs to know all tag names, so they can be used in
|
||||
// smart playlists
|
||||
criteria.AddTagNames(tagNames())
|
||||
criteria.AddRoles(slices.Collect(maps.Keys(AllRoles)))
|
||||
})
|
||||
}
|
||||
120
model/tag_test.go
Normal file
120
model/tag_test.go
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
package model
|
||||
|
||||
import (
|
||||
. "github.com/onsi/ginkgo/v2"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("Tag", func() {
|
||||
Describe("NewTag", func() {
|
||||
It("should create a new tag", func() {
|
||||
tag := NewTag("genre", "Rock")
|
||||
tag2 := NewTag("Genre", "Rock")
|
||||
tag3 := NewTag("Genre", "rock")
|
||||
Expect(tag2.ID).To(Equal(tag.ID))
|
||||
Expect(tag3.ID).To(Equal(tag.ID))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Tags", func() {
|
||||
var tags Tags
|
||||
BeforeEach(func() {
|
||||
tags = Tags{
|
||||
"genre": {"Rock", "Pop"},
|
||||
"artist": {"The Beatles"},
|
||||
}
|
||||
})
|
||||
It("should flatten tags by name", func() {
|
||||
flat := tags.Flatten("genre")
|
||||
Expect(flat).To(ConsistOf(
|
||||
NewTag("genre", "Rock"),
|
||||
NewTag("genre", "Pop"),
|
||||
))
|
||||
})
|
||||
It("should flatten tags", func() {
|
||||
flat := tags.FlattenAll()
|
||||
Expect(flat).To(ConsistOf(
|
||||
NewTag("genre", "Rock"),
|
||||
NewTag("genre", "Pop"),
|
||||
NewTag("artist", "The Beatles"),
|
||||
))
|
||||
})
|
||||
It("should get values by name", func() {
|
||||
Expect(tags.Values("genre")).To(ConsistOf("Rock", "Pop"))
|
||||
Expect(tags.Values("artist")).To(ConsistOf("The Beatles"))
|
||||
})
|
||||
|
||||
Describe("Hash", func() {
|
||||
It("should always return the same value for the same tags ", func() {
|
||||
tags1 := Tags{
|
||||
"genre": {"Rock", "Pop"},
|
||||
}
|
||||
tags2 := Tags{
|
||||
"Genre": {"pop", "rock"},
|
||||
}
|
||||
Expect(tags1.Hash()).To(Equal(tags2.Hash()))
|
||||
})
|
||||
It("should return different values for different tags", func() {
|
||||
tags1 := Tags{
|
||||
"genre": {"Rock", "Pop"},
|
||||
}
|
||||
tags2 := Tags{
|
||||
"artist": {"The Beatles"},
|
||||
}
|
||||
Expect(tags1.Hash()).ToNot(Equal(tags2.Hash()))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("TagList", func() {
|
||||
Describe("GroupByFrequency", func() {
|
||||
It("should return an empty Tags map for an empty TagList", func() {
|
||||
tagList := TagList{}
|
||||
|
||||
groupedTags := tagList.GroupByFrequency()
|
||||
|
||||
Expect(groupedTags).To(BeEmpty())
|
||||
})
|
||||
|
||||
It("should handle tags with different frequencies correctly", func() {
|
||||
tagList := TagList{
|
||||
NewTag("genre", "Jazz"),
|
||||
NewTag("genre", "Rock"),
|
||||
NewTag("genre", "Pop"),
|
||||
NewTag("genre", "Rock"),
|
||||
NewTag("artist", "The Rolling Stones"),
|
||||
NewTag("artist", "The Beatles"),
|
||||
NewTag("artist", "The Beatles"),
|
||||
}
|
||||
|
||||
groupedTags := tagList.GroupByFrequency()
|
||||
|
||||
Expect(groupedTags).To(HaveKeyWithValue(TagName("genre"), []string{"Rock", "Jazz", "Pop"}))
|
||||
Expect(groupedTags).To(HaveKeyWithValue(TagName("artist"), []string{"The Beatles", "The Rolling Stones"}))
|
||||
})
|
||||
|
||||
It("should sort tags by name when frequency is the same", func() {
|
||||
tagList := TagList{
|
||||
NewTag("genre", "Jazz"),
|
||||
NewTag("genre", "Rock"),
|
||||
NewTag("genre", "Alternative"),
|
||||
NewTag("genre", "Pop"),
|
||||
}
|
||||
|
||||
groupedTags := tagList.GroupByFrequency()
|
||||
|
||||
Expect(groupedTags).To(HaveKeyWithValue(TagName("genre"), []string{"Alternative", "Jazz", "Pop", "Rock"}))
|
||||
})
|
||||
It("should normalize casing", func() {
|
||||
tagList := TagList{
|
||||
NewTag("genre", "Synthwave"),
|
||||
NewTag("genre", "synthwave"),
|
||||
}
|
||||
|
||||
groupedTags := tagList.GroupByFrequency()
|
||||
|
||||
Expect(groupedTags).To(HaveKeyWithValue(TagName("genre"), []string{"synthwave"}))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
Loading…
Add table
Add a link
Reference in a new issue