Whole album matching and fingerprinting (#592)

* Cache result of GetAllArtists

* Fixed: Manual import not respecting album import notifications

* Fixed: partial album imports stay in queue, prompting manual import

* Fixed: Allow release if tracks are missing

* Fixed: Be tolerant of missing/extra "The" at start of artist name

* Improve manual import UI

* Omit video tracks from DB entirely

* Revert "faster test packaging in build.sh"

This reverts commit 2723e2a7b8.

-u and -T are not supported on macOS

* Fix tests on linux and macOS

* Actually lint on linux

On linux yarn runs scripts with sh not bash so ** doesn't recursively glob

* Match whole albums

* Option to disable fingerprinting

* Rip out MediaInfo

* Don't split up things that have the same album selected in manual import

* Try to speed up IndentificationService

* More speedups

* Some fixes and increase power of recording id

* Fix NRE when no tags

* Fix NRE when some (but not all) files in a directory have missing tags

* Bump taglib, tidy up tag parsing

* Add a health check

* Remove media info setting

* Tags -> audioTags

* Add some tests where tags are null

* Rename history events

* Add missing method to interface

* Reinstate MediaInfo tags and update info with artist scan

Also adds migration to remove old format media info

* This file no longer exists

* Don't penalise year if missing from tags

* Formatting improvements

* Use correct system newline

* Switch to the netstandard2.0 library to support net 461

* TagLib.File is IDisposable so should be in a using

* Improve filename matching and add tests

* Neater logging of parsed tags

* Fix disk scan tests for new media info update

* Fix quality detection source

* Fix Inexact Artist/Album match

* Add button to clear track mapping

* Fix warning

* Pacify eslint

* Use \ not /

* Fix UI updates

* Fix media covers

Prevent localizing URL propaging back to the metadata object

* Reduce database overhead broadcasting UI updates

* Relax timings a bit to make test pass

* Remove irrelevant tests

* Test framework for identification service

* Fix PreferMissingToBadMatch test case

* Make fingerprinting more robust

* More logging

* Penalize unknown media format and country

* Prefer USA to UK

* Allow Data CD

* Fix exception if fingerprinting fails for all files

* Fix tests

* Fix NRE

* Allow apostrophes and remove accents in filename aggregation

* Address codacy issues

* Cope with old versions of fpcalc and suggest upgrade

* fpcalc health check passes if fingerprinting disabled

* Get the Artist meta with the artist

* Fix the mapper so that lazy loaded lists will be populated on Join

And therefore we can join TrackFiles on Tracks by default and avoid an
extra query

* Rename subtitle -> lyric

* Tidy up MediaInfoFormatter

src/NzbDrone.Core/MetadataSource/SkyHook/SkyHookProxy.cs

@@ -19,13 +19,15 @@ namespace NzbDrone.Core.MetadataSource.SkyHook
     {
         private readonly IHttpClient _httpClient;
         private readonly Logger _logger;
-
         private readonly IArtistService _artistService;
         private readonly IAlbumService _albumService;
         private readonly IHttpRequestBuilderFactory _requestBuilder;
         private readonly IConfigService _configService;
         private readonly IMetadataProfileService _metadataProfileService;
 
+        private static readonly List<string> nonAudioMedia = new List<string> { "DVD", "DVD-Video", "Blu-ray", "HD-DVD", "VCD", "SVCD", "UMD", "VHS" };
+        private static readonly List<string> skippedTracks = new List<string> { "[data track]" };
+
         private IHttpRequestBuilderFactory _customerRequestBuilder;
 
         public SkyHookProxy(IHttpClient httpClient,
@@ -327,16 +329,29 @@ namespace NzbDrone.Core.MetadataSource.SkyHook
             release.Disambiguation = resource.Disambiguation;
             release.Country = resource.Country;
             release.ReleaseDate = resource.ReleaseDate;
-            release.TrackCount = resource.TrackCount;
-            release.Tracks = resource.Tracks.Select(x => MapTrack(x, artistDict)).ToList();
-            release.Media = resource.Media.Select(MapMedium).ToList();
-            if (!release.Media.Any())
+
+            // Get the complete set of media/tracks returned by the API, adding missing media if necessary
+            var allMedia = resource.Media.Select(MapMedium).ToList();
+            var allTracks = resource.Tracks.Select(x => MapTrack(x, artistDict));
+            if (!allMedia.Any())
             {
-                foreach(int n in release.Tracks.Value.Select(x => x.MediumNumber).Distinct())
+                foreach(int n in allTracks.Select(x => x.MediumNumber).Distinct())
                 {
-                    release.Media.Add(new Medium { Name = "Unknown", Number = n, Format = "Unknown" });
+                    allMedia.Add(new Medium { Name = "Unknown", Number = n, Format = "Unknown" });
                 }
             }
+
+            // Skip non-audio media
+            var audioMediaNumbers = allMedia.Where(x => !nonAudioMedia.Contains(x.Format)).Select(x => x.Number);
+
+            // Get tracks on the audio media and omit any that are skipped
+            release.Tracks = allTracks.Where(x => audioMediaNumbers.Contains(x.MediumNumber) && !skippedTracks.Contains(x.Title)).ToList();
+            release.TrackCount = release.Tracks.Value.Count;
+
+            // Only include the media that contain the tracks we have selected
+            var usedMediaNumbers = release.Tracks.Value.Select(track => track.MediumNumber);
+            release.Media = allMedia.Where(medium => usedMediaNumbers.Contains(medium.Number)).ToList();
+            
             release.Duration = release.Tracks.Value.Sum(x => x.Duration);
 
             return release;