Feature/issue 65 final: CRUD endpoints for Programs and Program categories

VictoryCenter/VictoryCenter.BLL/Commands/ProgramCategories/Create/CreateProgramCategoryCommand.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+using VictoryCenter.BLL.DTOs.ProgramCategories;
+
+namespace VictoryCenter.BLL.Commands.ProgramCategories.Create;
+
+public record CreateProgramCategoryCommand(CreateProgramCategoryDto programCategoryDto)
+    : IRequest<Result<ProgramCategoryDto>>;

VictoryCenter/VictoryCenter.BLL/Commands/ProgramCategories/Create/CreateProgramCategoryHandler.cs

@@ -0,0 +1,47 @@
+using MediatR;
+using AutoMapper;
+using FluentResults;
+using FluentValidation;
+using VictoryCenter.BLL.Constants;
+using VictoryCenter.BLL.DTOs.ProgramCategories;
+using VictoryCenter.DAL.Repositories.Interfaces.Base;
+
+namespace VictoryCenter.BLL.Commands.ProgramCategories.Create;
+
+public class CreateProgramCategoryHandler : IRequestHandler<CreateProgramCategoryCommand, Result<ProgramCategoryDto>>
+{
+    private readonly IMapper _mapper;
+    private readonly IRepositoryWrapper _repositoryWrapper;
+    private readonly IValidator<CreateProgramCategoryCommand> _validator;
+
+    public CreateProgramCategoryHandler(IMapper mapper, IRepositoryWrapper repositoryWrapper, IValidator<CreateProgramCategoryCommand> validator)
+    {
+        _mapper = mapper;
+        _repositoryWrapper = repositoryWrapper;
+        _validator = validator;
+    }
+
+    public async Task<Result<ProgramCategoryDto>> Handle(CreateProgramCategoryCommand request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await _validator.ValidateAndThrowAsync(request, cancellationToken);
+
+            var entity = _mapper.Map<DAL.Entities.ProgramCategory>(request.programCategoryDto);
+            entity.CreatedAt = DateTime.UtcNow;
+            await _repositoryWrapper.ProgramCategoriesRepository.CreateAsync(entity);
+
+            if (await _repositoryWrapper.SaveChangesAsync() > 0)
+            {
+                var responseDto = _mapper.Map<ProgramCategoryDto>(entity);
+                return Result.Ok(responseDto);
+            }
+
+            return Result.Fail<ProgramCategoryDto>(ProgramCategoryConstants.FailedToCreateCategory);
+        }
+        catch (ValidationException ex)
+        {
+            return Result.Fail<ProgramCategoryDto>(ex.Message);
+        }
+    }
+}

VictoryCenter/VictoryCenter.BLL/Commands/ProgramCategories/Delete/DeleteProgramCategoryCommand.cs

@@ -0,0 +1,6 @@
+using MediatR;
+using FluentResults;
+
+namespace VictoryCenter.BLL.Commands.ProgramCategories.Delete;
+
+public record DeleteProgramCategoryCommand(long id) : IRequest<Result<long>>;

VictoryCenter/VictoryCenter.BLL/Commands/ProgramCategories/Delete/DeleteProgramCategoryHandler.cs

@@ -0,0 +1,51 @@
+using MediatR;
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using VictoryCenter.BLL.Constants;
+using VictoryCenter.DAL.Repositories.Options;
+using VictoryCenter.DAL.Repositories.Interfaces.Base;
+
+namespace VictoryCenter.BLL.Commands.ProgramCategories.Delete;
+
+public class DeleteProgramCategoryHandler : IRequestHandler<DeleteProgramCategoryCommand, Result<long>>
+{
+    private readonly IRepositoryWrapper _repositoryWrapper;
+
+    public DeleteProgramCategoryHandler(IRepositoryWrapper repositoryWrapper)
+    {
+        _repositoryWrapper = repositoryWrapper;
+    }
+
+    public async Task<Result<long>> Handle(DeleteProgramCategoryCommand request, CancellationToken cancellationToken)
+    {
+        var queryOptions = new QueryOptions<DAL.Entities.ProgramCategory>
+        {
+            Filter = programCategory => programCategory.Id == request.id,
+            Include = programCategory => programCategory
+                .Include(p => p.Programs)
+        };
+
+        var entityToDelete = await _repositoryWrapper.ProgramCategoriesRepository
+            .GetFirstOrDefaultAsync(queryOptions);
+
+        if (entityToDelete is null)
+        {
+            return Result.Fail<long>(ErrorMessagesConstants
+                .NotFound(request.id, typeof(DAL.Entities.ProgramCategory)));
+        }
+
+        if (entityToDelete.Programs.Count != 0)
+        {
+            return Result.Fail(ProgramCategoryConstants.CantDeleteProgramCategoryWhileAssociatedWithAnyProgram);
+        }
+
+        _repositoryWrapper.ProgramCategoriesRepository.Delete(entityToDelete);
+
+        if (await _repositoryWrapper.SaveChangesAsync() > 0)
+        {
+            return Result.Ok(entityToDelete.Id);
+        }
+
+        return Result.Fail(ProgramCategoryConstants.FailedToDeleteCategory);
+    }
+}

VictoryCenter/VictoryCenter.BLL/Commands/ProgramCategories/Update/UpdateProgramCategoryCommand.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+using VictoryCenter.BLL.DTOs.ProgramCategories;
+
+namespace VictoryCenter.BLL.Commands.ProgramCategories.Update;
+
+public record UpdateProgramCategoryCommand(UpdateProgramCategoryDto updateProgramCategoryDto)
+    : IRequest<Result<ProgramCategoryDto>>;

VictoryCenter/VictoryCenter.BLL/Commands/ProgramCategories/Update/UpdateProgramCategoryHandler.cs

@@ -0,0 +1,61 @@
+using MediatR;
+using AutoMapper;
+using FluentResults;
+using FluentValidation;
+using VictoryCenter.BLL.Constants;
+using VictoryCenter.BLL.DTOs.ProgramCategories;
+using VictoryCenter.DAL.Repositories.Options;
+using VictoryCenter.DAL.Repositories.Interfaces.Base;
+
+namespace VictoryCenter.BLL.Commands.ProgramCategories.Update;
+
+public class UpdateProgramCategoryHandler : IRequestHandler<UpdateProgramCategoryCommand, Result<ProgramCategoryDto>>
+{
+    private readonly IMapper _mapper;
+    private readonly IRepositoryWrapper _repositoryWrapper;
+    private readonly IValidator<UpdateProgramCategoryCommand> _validator;
+
+    public UpdateProgramCategoryHandler(IMapper mapper, IRepositoryWrapper repositoryWrapper, IValidator<UpdateProgramCategoryCommand> validator)
+    {
+        _mapper = mapper;
+        _repositoryWrapper = repositoryWrapper;
+        _validator = validator;
+    }
+
+    public async Task<Result<ProgramCategoryDto>> Handle(UpdateProgramCategoryCommand request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await _validator.ValidateAndThrowAsync(request, cancellationToken);
+
+            var programCategoryEntity = await _repositoryWrapper.ProgramCategoriesRepository
+                .GetFirstOrDefaultAsync(new QueryOptions<DAL.Entities.ProgramCategory>
+                {
+                    Filter = programCategory => programCategory.Id == request.updateProgramCategoryDto.Id
+                });
+
+            if (programCategoryEntity is null)
+            {
+                return Result.Fail<ProgramCategoryDto>(ErrorMessagesConstants
+                    .NotFound(request.updateProgramCategoryDto.Id, typeof(DAL.Entities.ProgramCategory)));
+            }
+
+            var entityToUpdate = _mapper.Map(request.updateProgramCategoryDto, programCategoryEntity);
+            entityToUpdate.CreatedAt = programCategoryEntity.CreatedAt;
+
+            _repositoryWrapper.ProgramCategoriesRepository.Update(entityToUpdate);
+
+            if (await _repositoryWrapper.SaveChangesAsync() > 0)
+            {
+                var responseDto = _mapper.Map<ProgramCategoryDto>(entityToUpdate);
+                return Result.Ok(responseDto);
+            }
+
+            return Result.Fail<ProgramCategoryDto>(ProgramCategoryConstants.FailedToUpdateCategory);
+        }
+        catch (ValidationException ex)
+        {
+            return Result.Fail<ProgramCategoryDto>(ex.Message);
+        }
+    }
+}

VictoryCenter/VictoryCenter.BLL/Commands/Programs/Create/CreateProgramCommand.cs

@@ -0,0 +1,7 @@
+using MediatR;
+using FluentResults;
+using VictoryCenter.BLL.DTOs.Programs;
+
+namespace VictoryCenter.BLL.Commands.Programs.Create;
+
+public record CreateProgramCommand(CreateProgramDto createProgramDto) : IRequest<Result<ProgramDto>>;

VictoryCenter/VictoryCenter.BLL/Commands/Programs/Create/CreateProgramHandler.cs

@@ -0,0 +1,85 @@
+using MediatR;
+using AutoMapper;
+using FluentResults;
+using FluentValidation;
+using VictoryCenter.BLL.Constants;
+using VictoryCenter.BLL.DTOs.Programs;
+using VictoryCenter.BLL.Interfaces.BlobStorage;
+using VictoryCenter.DAL.Entities;
+using VictoryCenter.DAL.Repositories.Interfaces.Base;
+using VictoryCenter.DAL.Repositories.Options;
+
+namespace VictoryCenter.BLL.Commands.Programs.Create;
+
+public class CreateProgramHandler : IRequestHandler<CreateProgramCommand, Result<ProgramDto>>
+{
+    private readonly IMapper _mapper;
+    private readonly IRepositoryWrapper _repositoryWrapper;
+    private readonly IValidator<CreateProgramCommand> _validator;
+    private readonly IBlobService _blobService;
+
+    public CreateProgramHandler(IMapper mapper, IRepositoryWrapper repositoryWrapper, IValidator<CreateProgramCommand> validator, IBlobService blobService)
+    {
+        _mapper = mapper;
+        _repositoryWrapper = repositoryWrapper;
+        _validator = validator;
+        _blobService = blobService;
+    }
+
+    public async Task<Result<ProgramDto>> Handle(CreateProgramCommand request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await _validator.ValidateAndThrowAsync(request, cancellationToken);
+
+            var categoryOptions = new QueryOptions<ProgramCategory>
+            {
+                Filter = category => request.createProgramDto.CategoriesId.Contains(category.Id),
+                AsNoTracking = false
+            };
+
+            var categories = await _repositoryWrapper
+                .ProgramCategoriesRepository.GetAllAsync(categoryOptions);
+
+            var entity = _mapper.Map<Program>(request.createProgramDto);
+
+            if (entity.ImageId != null)
+            {
+                var newImage = await _repositoryWrapper.ImageRepository.GetFirstOrDefaultAsync(new QueryOptions<Image>
+                {
+                    Filter = image => image.Id == request.createProgramDto.ImageId,
+                    AsNoTracking = false
+                });
+                if (newImage is not null)
+                {
+                    try
+                    {
+                        newImage.Base64 = await _blobService.FindFileInStorageAsBase64Async(newImage.BlobName, newImage.MimeType);
+                    }
+                    catch(Exception)
+                    {
+                        return Result.Fail<ProgramDto>(ProgramConstants.FailedRetrievingProgramPhoto);
+                    }
+                }
+
+                entity.Image = newImage;
+            }
+
+            entity.Categories = categories.ToList();
+            entity.CreatedAt = DateTime.UtcNow;
+
+            await _repositoryWrapper.ProgramsRepository.CreateAsync(entity);
+
+            if (await _repositoryWrapper.SaveChangesAsync() > 0)
+            {
+                return Result.Ok(_mapper.Map<ProgramDto>(entity));
+            }
+
+            return Result.Fail<ProgramDto>(ProgramConstants.FailedToCreateProgram);
+        }
+        catch (ValidationException ex)
+        {
+            return Result.Fail<ProgramDto>(ex.Message);
+        }
+    }
+}

VictoryCenter/VictoryCenter.BLL/Commands/Programs/Delete/DeleteProgramCommand.cs

@@ -0,0 +1,5 @@
+using MediatR;
+using FluentResults;
+namespace VictoryCenter.BLL.Commands.Programs.Delete;
+
+public record DeleteProgramCommand(long Id) : IRequest<Result<long>>;

VictoryCenter/VictoryCenter.BLL/Commands/Programs/Delete/DeleteProgramHandler.cs

@@ -0,0 +1,44 @@
+using MediatR;
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using VictoryCenter.BLL.Constants;
+using VictoryCenter.DAL.Entities;
+using VictoryCenter.DAL.Repositories.Options;
+using VictoryCenter.DAL.Repositories.Interfaces.Base;
+
+namespace VictoryCenter.BLL.Commands.Programs.Delete;
+
+public class DeleteProgramHandler : IRequestHandler<DeleteProgramCommand, Result<long>>
+{
+    private readonly IRepositoryWrapper _repositoryWrapper;
+
+    public DeleteProgramHandler(IRepositoryWrapper repositoryWrapper)
+    {
+        _repositoryWrapper = repositoryWrapper;
+    }
+
+    public async Task<Result<long>> Handle(DeleteProgramCommand request, CancellationToken cancellationToken)
+    {
+        var entityToDelete = await _repositoryWrapper.ProgramsRepository.GetFirstOrDefaultAsync(new QueryOptions<Program>
+        {
+            Filter = program => program.Id == request.Id,
+            Include = program => program.Include(p => p.Categories)
+        });
+
+        if (entityToDelete is null)
+        {
+            return Result.Fail<long>(ErrorMessagesConstants
+                .NotFound(request.Id, typeof(Program)));
+        }
+
+        entityToDelete.Categories.Clear();
+        _repositoryWrapper.ProgramsRepository.Delete(entityToDelete);
+
+        if (await _repositoryWrapper.SaveChangesAsync() > 0)
+        {
+            return Result.Ok(entityToDelete.Id);
+        }
+
+        return Result.Fail(ProgramConstants.FailedToDeleteProgram);
+    }
+}

VictoryCenter/VictoryCenter.BLL/Commands/Programs/Update/UpdateProgramCommand.cs

@@ -0,0 +1,7 @@
+using MediatR;
+using FluentResults;
+using VictoryCenter.BLL.DTOs.Programs;
+
+namespace VictoryCenter.BLL.Commands.Programs.Update;
+
+public record UpdateProgramCommand(UpdateProgramDto updateProgramDto) : IRequest<Result<ProgramDto>>;