use folder.ext when poster.ext is not found for movies or shows (#96)

ErsatzTV.Application/Television/Mapper.cs

@@ -17,7 +17,8 @@ namespace ErsatzTV.Application.Television
                 show.ShowMetadata.HeadOrNone().Map(GetFanArt).IfNone(string.Empty),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Genres.Map(g => g.Name).ToList()).IfNone(new List<string>()),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Tags.Map(g => g.Name).ToList()).IfNone(new List<string>()),
-                show.ShowMetadata.HeadOrNone().Map(m => m.Studios.Map(s => s.Name).ToList()).IfNone(new List<string>()));
+                show.ShowMetadata.HeadOrNone().Map(m => m.Studios.Map(s => s.Name).ToList())
+                    .IfNone(new List<string>()));
 
         internal static TelevisionSeasonViewModel ProjectToViewModel(Season season) =>
             new(

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -238,6 +238,50 @@ namespace ErsatzTV.Core.Tests.Metadata
                     Times.Once);
             }
 
+            [Test]
+            public async Task NewMovie_Statistics_And_FallbackMetadata_And_FolderPoster(
+                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+                string videoExtension,
+                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
+                string imageExtension)
+            {
+                string moviePath = Path.Combine(
+                    FakeRoot,
+                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+                string posterPath = Path.Combine(
+                    Path.GetDirectoryName(moviePath) ?? string.Empty,
+                    $"folder.{imageExtension}");
+
+                MovieFolderScanner service = GetService(
+                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                    new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
+                );
+                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+
+                Either<BaseError, Unit> result = await service.ScanFolder(libraryPath, FFprobePath);
+
+                result.IsRight.Should().BeTrue();
+
+                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+                _localStatisticsProvider.Verify(
+                    x => x.RefreshStatistics(
+                        FFprobePath,
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                    Times.Once);
+
+                _localMetadataProvider.Verify(
+                    x => x.RefreshFallbackMetadata(
+                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                    Times.Once);
+
+                _imageCache.Verify(
+                    x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
+                    Times.Once);
+            }
+
             [Test]
             public async Task NewMovie_Statistics_And_FallbackMetadata_And_MovieNamePoster(
                 [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]

ErsatzTV.Core/Metadata/MovieFolderScanner.cs

@@ -210,6 +210,14 @@ namespace ErsatzTV.Core.Metadata
                     ext => new[] { $"{segment}.{ext}", Path.GetFileNameWithoutExtension(path) + $"-{segment}.{ext}" })
                 .Map(f => Path.Combine(folder, f));
             Option<string> result = possibleMoviePosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
+            if (result.IsNone && artworkKind == ArtworkKind.Poster)
+            {
+                IEnumerable<string> possibleFolderPosters = ImageFileExtensions.Collect(
+                        ext => new[] { $"folder.{ext}" })
+                    .Map(f => Path.Combine(folder, f));
+                result = possibleFolderPosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
+            }
+
             return result;
         }
     }

ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs

@@ -319,15 +319,16 @@ namespace ErsatzTV.Core.Metadata
 
         private Option<string> LocateArtworkForShow(string showFolder, ArtworkKind artworkKind)
         {
-            string segment = artworkKind switch
+            string[] segments = artworkKind switch
             {
-                ArtworkKind.Poster => "poster",
-                ArtworkKind.FanArt => "fanart",
+                ArtworkKind.Poster => new[] { "poster", "folder" },
+                ArtworkKind.FanArt => new[] { "fanart" },
                 _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
             };
 
             return ImageFileExtensions
-                .Map(ext => $"{segment}.{ext}")
+                .Map(ext => segments.Map(segment => $"{segment}.{ext}"))
+                .Flatten()
                 .Map(f => Path.Combine(showFolder, f))
                 .Filter(s => _localFileSystem.FileExists(s))
                 .HeadOrNone();

ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs

@@ -131,7 +131,7 @@ namespace ErsatzTV.Core.Plex
                         result.IsUpdated = true;
                     }
                 }
-                
+
                 foreach (Studio studio in existingMetadata.Studios
                     .Filter(s => incomingMetadata.Studios.All(s2 => s2.Name != s.Name))
                     .ToList())

ErsatzTV.Infrastructure/Data/Repositories/TelevisionRepository.cs

@@ -545,7 +545,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 {
                     return BaseError.New("Multi-episode files are not yet supported");
                 }
-                
+
                 var episode = new Episode
                 {
                     LibraryPathId = libraryPathId,

ErsatzTV.Infrastructure/Search/SearchIndex.cs

@@ -49,7 +49,7 @@ namespace ErsatzTV.Infrastructure.Search
         private readonly ILogger<SearchIndex> _logger;
 
         private readonly ISearchRepository _searchRepository;
-        
+
         public SearchIndex(
             ILocalFileSystem localFileSystem,
             ISearchRepository searchRepository,