fix plex movie scanning performance (#74)

ErsatzTV.Core/Interfaces/Repositories/IMovieRepository.cs

@@ -16,5 +16,6 @@ namespace ErsatzTV.Core.Interfaces.Repositories
         Task<List<MovieMetadata>> GetPagedMovies(int pageNumber, int pageSize);
         Task<IEnumerable<string>> FindMoviePaths(LibraryPath libraryPath);
         Task<Unit> DeleteByPath(LibraryPath libraryPath, string path);
+        Task<Unit> AddGenre(MovieMetadata metadata, Genre genre);
     }
 }

ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs

@@ -13,6 +13,7 @@ namespace ErsatzTV.Core.Plex
     public class PlexMovieLibraryScanner : PlexLibraryScanner, IPlexMovieLibraryScanner
     {
         private readonly ILogger<PlexMovieLibraryScanner> _logger;
+        private readonly IMetadataRepository _metadataRepository;
         private readonly IMovieRepository _movieRepository;
         private readonly IPlexServerApiClient _plexServerApiClient;
 
@@ -25,6 +26,7 @@ namespace ErsatzTV.Core.Plex
         {
             _plexServerApiClient = plexServerApiClient;
             _movieRepository = movieRepository;
+            _metadataRepository = metadataRepository;
             _logger = logger;
         }
 
@@ -51,16 +53,11 @@ namespace ErsatzTV.Core.Plex
                             .BindT(existing => UpdateMetadata(existing, incoming))
                             .BindT(existing => UpdateArtwork(existing, incoming));
 
-                        await maybeMovie.Match(
-                            async movie => await _movieRepository.Update(movie),
-                            error =>
-                            {
-                                _logger.LogWarning(
-                                    "Error processing plex movie at {Key}: {Error}",
-                                    incoming.Key,
-                                    error.Value);
-                                return Task.CompletedTask;
-                            });
+                        maybeMovie.IfLeft(
+                            error => _logger.LogWarning(
+                                "Error processing plex movie at {Key}: {Error}",
+                                incoming.Key,
+                                error.Value));
                     }
                 },
                 error =>
@@ -91,13 +88,16 @@ namespace ErsatzTV.Core.Plex
                 Either<BaseError, MediaVersion> maybeStatistics =
                     await _plexServerApiClient.GetStatistics(incoming.Key.Split("/").Last(), connection, token);
 
-                maybeStatistics.IfRight(
-                    mediaVersion =>
+                await maybeStatistics.Match(
+                    async mediaVersion =>
                     {
                         existingVersion.SampleAspectRatio = mediaVersion.SampleAspectRatio ?? "1:1";
                         existingVersion.VideoScanKind = mediaVersion.VideoScanKind;
                         existingVersion.DateUpdated = incomingVersion.DateUpdated;
-                    });
+
+                        await _metadataRepository.UpdateStatistics(existingVersion);
+                    },
+                    _ => Task.CompletedTask);
             }
 
             return Right<BaseError, PlexMovie>(existing);
@@ -115,6 +115,7 @@ namespace ErsatzTV.Core.Plex
                     .ToList())
                 {
                     existingMetadata.Genres.Remove(genre);
+                    _metadataRepository.RemoveGenre(genre);
                 }
 
                 foreach (Genre genre in incomingMetadata.Genres
@@ -122,6 +123,7 @@ namespace ErsatzTV.Core.Plex
                     .ToList())
                 {
                     existingMetadata.Genres.Add(genre);
+                    _movieRepository.AddGenre(existingMetadata, genre);
                 }
             }
 

ErsatzTV.Infrastructure/Data/Repositories/MovieRepository.cs

@@ -72,7 +72,9 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
 
         public async Task<Either<BaseError, PlexMovie>> GetOrAdd(PlexLibrary library, PlexMovie item)
         {
-            Option<PlexMovie> maybeExisting = await _dbContext.PlexMovies
+            await using TvContext context = _dbContextFactory.CreateDbContext();
+            Option<PlexMovie> maybeExisting = await context.PlexMovies
+                .AsNoTracking()
                 .Include(i => i.MovieMetadata)
                 .ThenInclude(mm => mm.Genres)
                 .Include(i => i.MovieMetadata)
@@ -84,7 +86,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
 
             return await maybeExisting.Match(
                 plexMovie => Right<BaseError, PlexMovie>(plexMovie).AsTask(),
-                async () => await AddPlexMovie(_dbContext, library, item));
+                async () => await AddPlexMovie(context, library, item));
         }
 
         public async Task<bool> Update(Movie movie)
@@ -140,6 +142,11 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             return Unit.Default;
         }
 
+        public Task<Unit> AddGenre(MovieMetadata metadata, Genre genre) =>
+            _dbConnection.ExecuteAsync(
+                "INSERT INTO Genre (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
+                new { genre.Name, MetadataId = metadata.Id }).ToUnit();
+
         private async Task<Either<BaseError, Movie>> AddMovie(int libraryPathId, string path)
         {
             try