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/MediaFiles/MediaFileRepository.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using Marr.Data.QGen;
 using NzbDrone.Core.Datastore;
 using NzbDrone.Core.Messaging.Events;
-
+using NzbDrone.Core.Music;
 
 namespace NzbDrone.Core.MediaFiles
 {
@@ -10,7 +12,6 @@ namespace NzbDrone.Core.MediaFiles
     {
         List<TrackFile> GetFilesByArtist(int artistId);
         List<TrackFile> GetFilesByAlbum(int albumId);
-        List<TrackFile> GetFilesWithoutMediaInfo();
         List<TrackFile> GetFilesWithRelativePath(int artistId, string relativePath);
     }
 
@@ -22,48 +23,39 @@ namespace NzbDrone.Core.MediaFiles
         {
         }
 
-        public List<TrackFile> GetFilesWithoutMediaInfo()
-        {
-            return Query.Where(c => c.MediaInfo == null).ToList();
-        }
+        // always join with all the other good stuff
+        // needed more often than not so better to load it all now
+        protected override QueryBuilder<TrackFile> Query =>
+            DataMapper.Query<TrackFile>()
+            .Join<TrackFile, Track>(JoinType.Inner, t => t.Tracks, (t, x) => t.Id == x.TrackFileId)
+            .Join<TrackFile, Album>(JoinType.Inner, t => t.Album, (t, a) => t.AlbumId == a.Id)
+            .Join<TrackFile, Artist>(JoinType.Inner, t => t.Artist, (t, a) => t.Album.Value.ArtistMetadataId == a.ArtistMetadataId)
+            .Join<Artist, ArtistMetadata>(JoinType.Inner, a => a.Metadata, (a, m) => a.ArtistMetadataId == m.Id);
 
         public List<TrackFile> GetFilesByArtist(int artistId)
         {
-            string query = string.Format("SELECT TrackFiles.* " +
-                                         "FROM Artists " +
-                                         "JOIN Albums ON Albums.ArtistMetadataId = Artists.ArtistMetadataId " +
-                                         "JOIN AlbumReleases ON AlbumReleases.AlbumId == Albums.Id " +
-                                         "JOIN Tracks ON Tracks.AlbumReleaseId == AlbumReleases.Id " +
-                                         "JOIN TrackFiles ON TrackFiles.Id == Tracks.TrackFileId " +
-                                         "WHERE Artists.Id == {0} " +
-                                         "AND AlbumReleases.Monitored = 1",
-                                         artistId);
-
-            return Query.QueryText(query).ToList();
+            return Query
+                .Join<Album, AlbumRelease>(JoinType.Inner, a => a.AlbumReleases, (a, r) => a.Id == r.AlbumId)
+                .Where<AlbumRelease>(r => r.Monitored == true)
+                .AndWhere(t => t.Artist.Value.Id == artistId)
+                .ToList();
         }
 
         public List<TrackFile> GetFilesByAlbum(int albumId)
         {
-            return Query.Where(c => c.AlbumId == albumId).ToList();
+            return Query
+                .Where(f => f.AlbumId == albumId)
+                .ToList();
         }
         
         public List<TrackFile> GetFilesWithRelativePath(int artistId, string relativePath)
         {
-            var mapper = DataMapper;
-            mapper.AddParameter("artistId", artistId);
-            mapper.AddParameter("relativePath", relativePath);
-            string query = "SELECT TrackFiles.* " +
-                "FROM Artists " +
-                "JOIN Albums ON Albums.ArtistMetadataId = Artists.ArtistMetadataId " +
-                "JOIN AlbumReleases ON AlbumReleases.AlbumId == Albums.Id " +
-                "JOIN Tracks ON Tracks.AlbumReleaseId == AlbumReleases.Id " +
-                "JOIN TrackFiles ON TrackFiles.Id == Tracks.TrackFileId " +
-                "WHERE Artists.Id == @artistId " +
-                "AND AlbumReleases.Monitored = 1 " +
-                "AND TrackFiles.RelativePath == @relativePath";
-
-            return mapper.Query<TrackFile>(query);
+            return Query
+                .Join<Album, AlbumRelease>(JoinType.Inner, a => a.AlbumReleases, (a, r) => a.Id == r.AlbumId)
+                .Where<AlbumRelease>(r => r.Monitored == true)
+                .AndWhere(t => t.Artist.Value.Id == artistId)
+                .AndWhere(t => t.RelativePath == relativePath)
+                .ToList();
         }
-
     }
 }