rework television media (#26)

* rework television media

* refactor poster saving

* television and movie views are working again

* remove dead code

* use paper styling for all cards

* add show poster, plot to seasons page

* remove missing shows; cleanup interfaces

* fix split show display (same show in different folders/sources)

* add placeholder "add to schedule" button

* no more duplicate television shows, even with the same show split across sources

* stop releasing CLI for now

* use season number as season placeholder

* add television shows to collections

* add television seasons to collections

* add television episodes to collections

* add movies to collections

* remove movies, shows, seasons, episodes from collections

* fix page width and menus

* fix buffer size defaults

* fix chronological episode ordering

* allow deleting media collections

* don't get stuck building a playout with an empty collection

* schedule editing and playouts work again

* minor cleanup

* remove dead code

* fix bugs with viewing movies as they are loading

* add scanner tests; support nested movie folders

* update collections docs

* rearrange order of schedule items

* add show and season to schedule

* delete schedules that use legacy collections, reset all posters

* move cleanup to new migration

* load fallback metadata when nfo fails; don't require metadata in ui

* update readme and screenshots

ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace ErsatzTV.Core.Tests.Fakes
+{
+    public record FakeFileEntry(string Path)
+    {
+        public DateTime LastWriteTime { get; set; } = DateTime.MinValue;
+    }
+}

ErsatzTV.Core.Tests/Fakes/FakeFolderEntry.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Core.Tests.Fakes
+{
+    public record FakeFolderEntry(string Path);
+}

ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.Tests.Fakes
+{
+    public class FakeLocalFileSystem : ILocalFileSystem
+    {
+        public static readonly byte[] TestBytes = { 1, 2, 3, 4, 5 };
+
+        private readonly List<FakeFileEntry> _files;
+        private readonly List<FakeFolderEntry> _folders;
+
+        public FakeLocalFileSystem(List<FakeFileEntry> files) : this(files, new List<FakeFolderEntry>())
+        {
+        }
+
+        public FakeLocalFileSystem(List<FakeFileEntry> files, List<FakeFolderEntry> folders)
+        {
+            _files = files;
+
+            var allFolders = new List<string>(folders.Map(f => f.Path));
+            foreach (FakeFileEntry file in _files)
+            {
+                List<DirectoryInfo> moreFolders =
+                    Split(new DirectoryInfo(Path.GetDirectoryName(file.Path) ?? string.Empty));
+                allFolders.AddRange(moreFolders.Map(i => i.FullName));
+            }
+
+            _folders = allFolders.Distinct().Map(f => new FakeFolderEntry(f)).ToList();
+        }
+
+        public DateTime GetLastWriteTime(string path) =>
+            Optional(_files.SingleOrDefault(f => f.Path == path))
+                .Map(f => f.LastWriteTime)
+                .IfNone(DateTime.MinValue);
+
+        public bool IsMediaSourceAccessible(LocalMediaSource localMediaSource) =>
+            _files.Any(f => f.Path.StartsWith(localMediaSource.Folder));
+
+        public IEnumerable<string> ListSubdirectories(string folder) =>
+            _folders.Map(f => f.Path).Filter(f => f.StartsWith(folder) && Directory.GetParent(f)?.FullName == folder);
+
+        public IEnumerable<string> ListFiles(string folder) =>
+            _files.Map(f => f.Path).Filter(f => Path.GetDirectoryName(f) == folder);
+
+        public bool FileExists(string path) => _files.Any(f => f.Path == path);
+
+        public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
+
+        private static List<DirectoryInfo> Split(DirectoryInfo path)
+        {
+            var result = new List<DirectoryInfo>();
+            if (path == null || string.IsNullOrWhiteSpace(path.FullName))
+            {
+                return result;
+            }
+
+            if (path.Parent != null)
+            {
+                result.AddRange(Split(path.Parent));
+            }
+
+            result.Add(path);
+
+            return result;
+        }
+    }
+}

ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
-using ErsatzTV.Core.AggregateModels;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
@@ -11,9 +11,9 @@ namespace ErsatzTV.Core.Tests.Fakes
 {
     public class FakeMediaCollectionRepository : IMediaCollectionRepository
     {
-        private readonly Map<int, List<MediaItem>> _data;
+        private readonly Map<int, List<MovieMediaItem>> _data;
 
-        public FakeMediaCollectionRepository(Map<int, List<MediaItem>> data) => _data = data;
+        public FakeMediaCollectionRepository(Map<int, List<MovieMediaItem>> data) => _data = data;
 
         public Task<SimpleMediaCollection> Add(SimpleMediaCollection collection) => throw new NotSupportedException();
 
@@ -25,32 +25,20 @@ namespace ErsatzTV.Core.Tests.Fakes
         public Task<Option<SimpleMediaCollection>> GetSimpleMediaCollectionWithItems(int id) =>
             throw new NotSupportedException();
 
-        public Task<Option<TelevisionMediaCollection>> GetTelevisionMediaCollection(int id) =>
+        public Task<Option<SimpleMediaCollection>> GetSimpleMediaCollectionWithItemsUntracked(int id) =>
             throw new NotSupportedException();
 
         public Task<List<SimpleMediaCollection>> GetSimpleMediaCollections() => throw new NotSupportedException();
 
         public Task<List<MediaCollection>> GetAll() => throw new NotSupportedException();
 
-        public Task<List<MediaCollectionSummary>> GetSummaries(string searchString) =>
-            throw new NotSupportedException();
-
-        public Task<Option<List<MediaItem>>> GetItems(int id) => Some(_data[id]).AsTask();
+        public Task<Option<List<MediaItem>>> GetItems(int id) => Some(_data[id].OfType<MediaItem>().ToList()).AsTask();
 
         public Task<Option<List<MediaItem>>> GetSimpleMediaCollectionItems(int id) =>
             throw new NotSupportedException();
 
-        public Task<Option<List<MediaItem>>> GetTelevisionMediaCollectionItems(int id) =>
-            throw new NotSupportedException();
-
         public Task Update(SimpleMediaCollection collection) => throw new NotSupportedException();
 
-        public Task<bool> InsertOrIgnore(TelevisionMediaCollection collection) => throw new NotSupportedException();
-
-        public Task<Unit> ReplaceItems(int collectionId, List<MediaItem> mediaItems) =>
-            throw new NotSupportedException();
-
         public Task Delete(int mediaCollectionId) => throw new NotSupportedException();
-        public Task DeleteEmptyTelevisionCollections() => throw new NotSupportedException();
     }
 }

ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Tests.Fakes
+{
+    public class FakeTelevisionRepository : ITelevisionRepository
+    {
+        public Task<bool> Update(TelevisionShow show) => throw new NotSupportedException();
+
+        public Task<bool> Update(TelevisionSeason season) => throw new NotSupportedException();
+
+        public Task<bool> Update(TelevisionEpisodeMediaItem episode) => throw new NotSupportedException();
+
+        public Task<List<TelevisionShow>> GetAllShows() => throw new NotSupportedException();
+
+        public Task<Option<TelevisionShow>> GetShow(int televisionShowId) => throw new NotSupportedException();
+
+        public Task<int> GetShowCount() => throw new NotSupportedException();
+
+        public Task<List<TelevisionShow>> GetPagedShows(int pageNumber, int pageSize) =>
+            throw new NotSupportedException();
+
+        public Task<List<TelevisionEpisodeMediaItem>> GetShowItems(int televisionShowId) =>
+            throw new NotSupportedException();
+
+        public Task<List<TelevisionSeason>> GetAllSeasons() => throw new NotSupportedException();
+
+        public Task<Option<TelevisionSeason>> GetSeason(int televisionSeasonId) => throw new NotSupportedException();
+
+        public Task<int> GetSeasonCount(int televisionShowId) => throw new NotSupportedException();
+
+        public Task<List<TelevisionSeason>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize) =>
+            throw new NotSupportedException();
+
+        public Task<List<TelevisionEpisodeMediaItem>> GetSeasonItems(int televisionSeasonId) =>
+            throw new NotSupportedException();
+
+        public Task<Option<TelevisionEpisodeMediaItem>> GetEpisode(int televisionEpisodeId) =>
+            throw new NotSupportedException();
+
+        public Task<int> GetEpisodeCount(int televisionSeasonId) => throw new NotSupportedException();
+
+        public Task<List<TelevisionEpisodeMediaItem>> GetPagedEpisodes(
+            int televisionSeasonId,
+            int pageNumber,
+            int pageSize) => throw new NotSupportedException();
+
+        public Task<Option<TelevisionShow>> GetShowByPath(int mediaSourceId, string path) =>
+            throw new NotSupportedException();
+
+        public Task<Option<TelevisionShow>> GetShowByMetadata(TelevisionShowMetadata metadata) =>
+            throw new NotSupportedException();
+
+        public Task<Either<BaseError, TelevisionShow>> AddShow(
+            int localMediaSourceId,
+            string showFolder,
+            TelevisionShowMetadata metadata) => throw new NotSupportedException();
+
+        public Task<Either<BaseError, TelevisionSeason>> GetOrAddSeason(
+            TelevisionShow show,
+            string path,
+            int seasonNumber) => throw new NotSupportedException();
+
+        public Task<Either<BaseError, TelevisionEpisodeMediaItem>> GetOrAddEpisode(
+            TelevisionSeason season,
+            int mediaSourceId,
+            string path) => throw new NotSupportedException();
+
+        public Task<Unit> DeleteMissingSources(int localMediaSourceId, List<string> allFolders) =>
+            throw new NotSupportedException();
+
+        public Task<Unit> DeleteEmptyShows() => throw new NotSupportedException();
+    }
+}