Initial commit

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -0,0 +1,15 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Channels.Commands
+{
+    public record CreateChannel
+    (
+        string Name,
+        int Number,
+        int FFmpegProfileId,
+        string Logo,
+        StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
+}

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels.Commands
+{
+    public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, ChannelViewModel>>
+    {
+        private readonly IChannelRepository _channelRepository;
+        private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
+
+        public CreateChannelHandler(
+            IChannelRepository channelRepository,
+            IFFmpegProfileRepository ffmpegProfileRepository)
+        {
+            _channelRepository = channelRepository;
+            _ffmpegProfileRepository = ffmpegProfileRepository;
+        }
+
+        public Task<Either<BaseError, ChannelViewModel>> Handle(
+            CreateChannel request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(PersistChannel)
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<ChannelViewModel> PersistChannel(Channel c) =>
+            _channelRepository.Add(c).Map(ProjectToViewModel);
+
+        private async Task<Validation<BaseError, Channel>> Validate(CreateChannel request) =>
+            (ValidateName(request), ValidateNumber(request), await FFmpegProfileMustExist(request))
+            .Apply(
+                (name, number, ffmpegProfileId) => new Channel(Guid.NewGuid())
+                {
+                    Name = name, Number = number, FFmpegProfileId = ffmpegProfileId,
+                    StreamingMode = request.StreamingMode
+                });
+
+        private Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
+            createChannel.NotEmpty(c => c.Name)
+                .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
+
+        // TODO: validate number does not exist?
+        private Validation<BaseError, int> ValidateNumber(CreateChannel createChannel) =>
+            createChannel.AtLeast(1)(c => c.Number);
+
+        private async Task<Validation<BaseError, int>> FFmpegProfileMustExist(CreateChannel createChannel) =>
+            (await _ffmpegProfileRepository.Get(createChannel.FFmpegProfileId))
+            .ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist.")
+            .Map(c => c.Id);
+    }
+}

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Channels.Commands
+{
+    public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Task>>;
+}

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -0,0 +1,28 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Channels.Commands
+{
+    public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Task>>
+    {
+        private readonly IChannelRepository _channelRepository;
+
+        public DeleteChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
+        public async Task<Either<BaseError, Task>> Handle(DeleteChannel request, CancellationToken cancellationToken) =>
+            (await ChannelMustExist(request))
+            .Map(DoDeletion)
+            .ToEither<Task>();
+
+        private Task DoDeletion(int channelId) => _channelRepository.Delete(channelId);
+
+        private async Task<Validation<BaseError, int>> ChannelMustExist(DeleteChannel deleteChannel) =>
+            (await _channelRepository.Get(deleteChannel.ChannelId))
+            .ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.")
+            .Map(c => c.Id);
+    }
+}

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -0,0 +1,16 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Channels.Commands
+{
+    public record UpdateChannel
+    (
+        int ChannelId,
+        string Name,
+        int Number,
+        int FFmpegProfileId,
+        string Logo,
+        StreamingMode StreamingMode) : IRequest<Either<BaseError, ChannelViewModel>>;
+}

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -0,0 +1,60 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels.Commands
+{
+    public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
+    {
+        private readonly IChannelRepository _channelRepository;
+
+        public UpdateChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
+        public Task<Either<BaseError, ChannelViewModel>> Handle(
+            UpdateChannel request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(c => ApplyUpdateRequest(c, request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<ChannelViewModel> ApplyUpdateRequest(Channel c, UpdateChannel update)
+        {
+            c.Name = update.Name;
+            c.Number = update.Number;
+            c.FFmpegProfileId = update.FFmpegProfileId;
+            c.Logo = update.Logo;
+            c.StreamingMode = update.StreamingMode;
+            await _channelRepository.Update(c);
+            return ProjectToViewModel(c);
+        }
+
+        private async Task<Validation<BaseError, Channel>> Validate(UpdateChannel request) =>
+            (await ChannelMustExist(request), ValidateName(request), await ValidateNumber(request))
+            .Apply((channelToUpdate, _, _) => channelToUpdate);
+
+        private Task<Validation<BaseError, Channel>> ChannelMustExist(UpdateChannel updateChannel) =>
+            _channelRepository.Get(updateChannel.ChannelId)
+                .Map(v => v.ToValidation<BaseError>("Channel does not exist."));
+
+        private Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
+            updateChannel.NotEmpty(c => c.Name)
+                .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
+
+        private async Task<Validation<BaseError, int>> ValidateNumber(UpdateChannel updateChannel)
+        {
+            Option<Channel> match = await _channelRepository.GetByNumber(updateChannel.Number);
+            int matchId = match.Map(c => c.Id).IfNone(updateChannel.ChannelId);
+            if (matchId == updateChannel.ChannelId)
+            {
+                return updateChannel.AtLeast(1)(c => c.Number);
+            }
+
+            return BaseError.New("Channel number must be unique");
+        }
+    }
+}