fix adding to collections from ui

ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollectionHandler.cs

@@ -1,16 +1,13 @@
-using System.Linq;
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
     public class
-        AddEpisodeToCollectionHandler : MediatR.IRequestHandler<AddEpisodeToCollection,
-            Either<BaseError, Unit>>
+        AddEpisodeToCollectionHandler : MediatR.IRequestHandler<AddEpisodeToCollection, Either<BaseError, Unit>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
         private readonly ITelevisionRepository _televisionRepository;
@@ -27,41 +24,27 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             AddEpisodeToCollection request,
             CancellationToken cancellationToken) =>
             Validate(request)
-                .MapT(ApplyAddTelevisionEpisodeRequest)
+                .MapT(_ => ApplyAddTelevisionEpisodeRequest(request))
                 .Bind(v => v.ToEitherAsync());
 
-        private async Task<Unit> ApplyAddTelevisionEpisodeRequest(RequestParameters parameters)
-        {
-            if (parameters.Collection.MediaItems.All(s => s.Id != parameters.EpisodeToAdd.Id))
-            {
-                parameters.Collection.MediaItems.Add(parameters.EpisodeToAdd);
-                await _mediaCollectionRepository.Update(parameters.Collection);
-            }
-
-            return Unit.Default;
-        }
+        private Task<Unit> ApplyAddTelevisionEpisodeRequest(AddEpisodeToCollection request) =>
+            _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.EpisodeId);
 
-        private async Task<Validation<BaseError, RequestParameters>>
-            Validate(AddEpisodeToCollection request) =>
-            (await SimpleMediaCollectionMustExist(request), await ValidateEpisode(request))
-            .Apply(
-                (collectionToUpdate, episode) =>
-                    new RequestParameters(collectionToUpdate, episode));
+        private async Task<Validation<BaseError, Unit>> Validate(AddEpisodeToCollection request) =>
+            (await CollectionMustExist(request), await ValidateEpisode(request))
+            .Apply((_, _) => Unit.Default);
 
-        private Task<Validation<BaseError, Collection>> SimpleMediaCollectionMustExist(
-            AddEpisodeToCollection updateCollection) =>
-            _mediaCollectionRepository.GetCollectionWithItems(updateCollection.CollectionId)
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddEpisodeToCollection request) =>
+            _mediaCollectionRepository.Get(request.CollectionId)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
 
-        private Task<Validation<BaseError, Episode>> ValidateEpisode(
-            AddEpisodeToCollection request) =>
+        private Task<Validation<BaseError, Unit>> ValidateEpisode(AddEpisodeToCollection request) =>
             LoadTelevisionEpisode(request)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Episode does not exist"));
 
-        private Task<Option<Episode>> LoadTelevisionEpisode(
-            AddEpisodeToCollection request) =>
-            _televisionRepository.GetEpisode(request.EpisodeId);
-
-        private record RequestParameters(Collection Collection, Episode EpisodeToAdd);
+        private Task<Option<int>> LoadTelevisionEpisode(AddEpisodeToCollection request) =>
+            _televisionRepository.GetEpisode(request.EpisodeId).MapT(e => e.Id);
     }
 }

ErsatzTV.Application/MediaCollections/Commands/AddMovieToCollectionHandler.cs

@@ -7,9 +7,7 @@ using LanguageExt;
 
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
-    public class
-        AddMovieToCollectionHandler : MediatR.IRequestHandler<AddMovieToCollection,
-            Either<BaseError, Unit>>
+    public class AddMovieToCollectionHandler : MediatR.IRequestHandler<AddMovieToCollection, Either<BaseError, Unit>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
         private readonly IMovieRepository _movieRepository;
@@ -26,37 +24,27 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             AddMovieToCollection request,
             CancellationToken cancellationToken) =>
             Validate(request)
-                .MapT(ApplyAddMoviesRequest)
+                .MapT(_ => ApplyAddMoviesRequest(request))
                 .Bind(v => v.ToEitherAsync());
 
-        private async Task<Unit> ApplyAddMoviesRequest(RequestParameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.MovieToAdd);
-            await _mediaCollectionRepository.Update(parameters.Collection);
-
-            return Unit.Default;
-        }
+        private Task<Unit> ApplyAddMoviesRequest(AddMovieToCollection request) =>
+            _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.MovieId);
 
-        private async Task<Validation<BaseError, RequestParameters>>
-            Validate(AddMovieToCollection request) =>
-            (await SimpleMediaCollectionMustExist(request), await ValidateMovies(request))
-            .Apply(
-                (collectionToUpdate, movieToAdd) =>
-                    new RequestParameters(collectionToUpdate, movieToAdd));
+        private async Task<Validation<BaseError, Unit>> Validate(AddMovieToCollection request) =>
+            (await CollectionMustExist(request), await ValidateMovies(request))
+            .Apply((_, _) => Unit.Default);
 
-        private Task<Validation<BaseError, Collection>> SimpleMediaCollectionMustExist(
-            AddMovieToCollection updateCollection) =>
-            _mediaCollectionRepository.GetCollectionWithItems(updateCollection.CollectionId)
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddMovieToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
 
-        private Task<Validation<BaseError, Movie>> ValidateMovies(
-            AddMovieToCollection request) =>
+        private Task<Validation<BaseError, Unit>> ValidateMovies(AddMovieToCollection request) =>
             LoadMovie(request)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Movie does not exist"));
 
         private Task<Option<Movie>> LoadMovie(AddMovieToCollection request) =>
             _movieRepository.GetMovie(request.MovieId);
-
-        private record RequestParameters(Collection Collection, Movie MovieToAdd);
     }
 }

ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollectionHandler.cs

@@ -1,5 +1,4 @@
-using System.Linq;
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -8,9 +7,7 @@ using LanguageExt;
 
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
-    public class
-        AddSeasonToCollectionHandler : MediatR.IRequestHandler<AddSeasonToCollection,
-            Either<BaseError, Unit>>
+    public class AddSeasonToCollectionHandler : MediatR.IRequestHandler<AddSeasonToCollection, Either<BaseError, Unit>>
     {
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
         private readonly ITelevisionRepository _televisionRepository;
@@ -27,41 +24,28 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             AddSeasonToCollection request,
             CancellationToken cancellationToken) =>
             Validate(request)
-                .MapT(ApplyAddTelevisionSeasonRequest)
+                .MapT(_ => ApplyAddTelevisionSeasonRequest(request))
                 .Bind(v => v.ToEitherAsync());
 
-        private async Task<Unit> ApplyAddTelevisionSeasonRequest(RequestParameters parameters)
-        {
-            if (parameters.Collection.MediaItems.All(s => s.Id != parameters.SeasonToAdd.Id))
-            {
-                parameters.Collection.MediaItems.Add(parameters.SeasonToAdd);
-                await _mediaCollectionRepository.Update(parameters.Collection);
-            }
-
-            return Unit.Default;
-        }
+        private async Task<Unit> ApplyAddTelevisionSeasonRequest(AddSeasonToCollection request) =>
+            await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.SeasonId);
 
-        private async Task<Validation<BaseError, RequestParameters>>
-            Validate(AddSeasonToCollection request) =>
-            (await SimpleMediaCollectionMustExist(request), await ValidateSeason(request))
-            .Apply(
-                (collectionToUpdate, season) =>
-                    new RequestParameters(collectionToUpdate, season));
+        private async Task<Validation<BaseError, Unit>> Validate(AddSeasonToCollection request) =>
+            (await CollectionMustExist(request), await ValidateSeason(request))
+            .Apply((_, _) => Unit.Default);
 
-        private Task<Validation<BaseError, Collection>> SimpleMediaCollectionMustExist(
-            AddSeasonToCollection updateCollection) =>
-            _mediaCollectionRepository.GetCollectionWithItems(updateCollection.CollectionId)
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddSeasonToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
 
-        private Task<Validation<BaseError, Season>> ValidateSeason(
-            AddSeasonToCollection request) =>
+        private Task<Validation<BaseError, Unit>> ValidateSeason(AddSeasonToCollection request) =>
             LoadTelevisionSeason(request)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Season does not exist"));
 
         private Task<Option<Season>> LoadTelevisionSeason(
             AddSeasonToCollection request) =>
             _televisionRepository.GetSeason(request.SeasonId);
-
-        private record RequestParameters(Collection Collection, Season SeasonToAdd);
     }
 }

ErsatzTV.Application/MediaCollections/Commands/AddShowToCollectionHandler.cs

@@ -1,5 +1,4 @@
-using System.Linq;
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -25,40 +24,27 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             AddShowToCollection request,
             CancellationToken cancellationToken) =>
             Validate(request)
-                .MapT(ApplyAddTelevisionShowRequest)
+                .MapT(_ => ApplyAddTelevisionShowRequest(request))
                 .Bind(v => v.ToEitherAsync());
 
-        private async Task<Unit> ApplyAddTelevisionShowRequest(RequestParameters parameters)
-        {
-            if (parameters.Collection.MediaItems.All(s => s.Id != parameters.ShowToAdd.Id))
-            {
-                parameters.Collection.MediaItems.Add(parameters.ShowToAdd);
-                await _mediaCollectionRepository.Update(parameters.Collection);
-            }
-
-            return Unit.Default;
-        }
+        private Task<Unit> ApplyAddTelevisionShowRequest(AddShowToCollection request)
+            => _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.ShowId);
 
-        private async Task<Validation<BaseError, RequestParameters>>
-            Validate(AddShowToCollection request) =>
-            (await SimpleMediaCollectionMustExist(request), await ValidateShow(request))
-            .Apply(
-                (collectionToUpdate, show) =>
-                    new RequestParameters(collectionToUpdate, show));
+        private async Task<Validation<BaseError, Unit>> Validate(AddShowToCollection request) =>
+            (await CollectionMustExist(request), await ValidateShow(request))
+            .Apply((_, _) => Unit.Default);
 
-        private Task<Validation<BaseError, Collection>> SimpleMediaCollectionMustExist(
-            AddShowToCollection updateCollection) =>
-            _mediaCollectionRepository.GetCollectionWithItems(updateCollection.CollectionId)
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddShowToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
 
-        private Task<Validation<BaseError, Show>> ValidateShow(
-            AddShowToCollection request) =>
+        private Task<Validation<BaseError, Unit>> ValidateShow(AddShowToCollection request) =>
             LoadTelevisionShow(request)
+                .MapT(_ => Unit.Default)
                 .Map(v => v.ToValidation<BaseError>("Show does not exist"));
 
         private Task<Option<Show>> LoadTelevisionShow(AddShowToCollection request) =>
             _televisionRepository.GetShow(request.ShowId);
-
-        private record RequestParameters(Collection Collection, Show ShowToAdd);
     }
 }

ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs

@@ -16,6 +16,7 @@ namespace ErsatzTV.Core.Tests.Fakes
         public FakeMediaCollectionRepository(Map<int, List<MediaItem>> data) => _data = data;
 
         public Task<Collection> Add(Collection collection) => throw new NotSupportedException();
+        public Task<Unit> AddMediaItem(int collectionId, int mediaItemId) => throw new NotSupportedException();
 
         public Task<Option<Collection>> Get(int id) => throw new NotSupportedException();
 

ErsatzTV.Core/Interfaces/Repositories/IMediaCollectionRepository.cs

@@ -8,6 +8,7 @@ namespace ErsatzTV.Core.Interfaces.Repositories
     public interface IMediaCollectionRepository
     {
         Task<Collection> Add(Collection collection);
+        Task<Unit> AddMediaItem(int collectionId, int mediaItemId);
         Task<Option<Collection>> Get(int id);
         Task<Option<Collection>> GetCollectionWithItems(int id);
         Task<Option<Collection>> GetCollectionWithItemsUntracked(int id);

ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs

@@ -29,6 +29,37 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             return collection;
         }
 
+
+        public async Task<Unit> AddMediaItem(int collectionId, int mediaItemId)
+        {
+            Option<Collection> maybeCollection = await _dbContext.Collections
+                .Include(c => c.MediaItems)
+                .OrderBy(c => c.Id)
+                .SingleOrDefaultAsync(c => c.Id == collectionId)
+                .Map(Optional);
+
+            await maybeCollection.IfSomeAsync(
+                async collection =>
+                {
+                    if (collection.MediaItems.All(i => i.Id != mediaItemId))
+                    {
+                        Option<MediaItem> maybeMediaItem = await _dbContext.MediaItems
+                            .OrderBy(i => i.Id)
+                            .SingleOrDefaultAsync(i => i.Id == mediaItemId)
+                            .Map(Optional);
+
+                        await maybeMediaItem.IfSomeAsync(
+                            async mediaItem =>
+                            {
+                                collection.MediaItems.Add(mediaItem);
+                                await _dbContext.SaveChangesAsync();
+                            });
+                    }
+                });
+
+            return Unit.Default;
+        }
+
         public Task<Option<Collection>> Get(int id) =>
             _dbContext.Collections
                 .OrderBy(c => c.Id)