Feat/review controller

API/Controllers/ReviewController.cs

@@ -0,0 +1,114 @@
+using Application.Commands.ReviewCommands.AddReview;
+using Application.Commands.ReviewCommands.DeleteReview;
+using Application.Commands.ReviewCommands.UpdateReview;
+using Application.Dtos.ReviewDtos;
+using Application.Queries.ReviewQueries.GetAllReviews;
+using Application.Queries.ReviewQueries.GetReviewById;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace API.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class ReviewController : ControllerBase
+    {
+        private readonly IMediator _mediator;
+
+        public ReviewController(IMediator mediator)
+        {
+            _mediator = mediator;
+        }
+
+        [HttpGet("GetAll")]
+        public async Task<IActionResult> GetAllReviews()
+        {
+            try
+            {
+                var operationResult = await _mediator.Send(new GetAllReviewsQuery());
+                if (operationResult is not null)
+                {
+                    return Ok(operationResult.Data);
+                }
+                return BadRequest(new { message = operationResult.Message, errors = operationResult.ErrorMessage });
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.InnerException);
+            }
+        }
+
+        [HttpGet("GetById/{id}")]
+        public async Task<IActionResult> GetReviewById(int id)
+        {
+            try
+            {
+                var operationResult = await _mediator.Send(new GetReviewByIdQuery(id));
+                if (operationResult is not null)
+                {
+                    return Ok(operationResult.Data);
+                }
+                return BadRequest(new { message = operationResult.Message, errors = operationResult.ErrorMessage });
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.InnerException);
+            }
+        }
+
+        [HttpPost("Create")]
+        public async Task<IActionResult> AddReview(AddReviewDto dto)
+        {
+            try
+            {
+                var operationResult = await _mediator.Send(new AddReviewCommand(dto));
+                if (operationResult is not null)
+                {
+                    return Ok(operationResult.Data);
+                }
+                return BadRequest(new { message = operationResult.Message, errors = operationResult.ErrorMessage });
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.InnerException);
+            }
+        }
+
+        [HttpPut("Update")]
+        public async Task<IActionResult> UpdateReview(UpdateReviewDto dto)
+        {
+            try
+            {
+                var operationResult = await _mediator.Send(new UpdateReviewCommand(dto));
+                if (operationResult is not null)
+                {
+                    return Ok(operationResult.Data);
+                }
+                return BadRequest(new { message = operationResult.Message, errors = operationResult.ErrorMessage });
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.InnerException);
+            }
+        }
+
+        [HttpDelete("Delete/{id}")]
+        public async Task<IActionResult> DeleteReview(int id)
+        {
+            try
+            {
+                var operationResult = await _mediator.Send(new DeleteReviewCommand(id));
+                if (operationResult is not null)
+                {
+                    return Ok(operationResult.Data);
+                }
+                return BadRequest(new { message = operationResult.Message, errors = operationResult.ErrorMessage });
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.InnerException);
+            }
+
+        }
+    }
+}

Application/Commands/ReviewCommands/AddReview/AddReviewCommand.cs

@@ -0,0 +1,11 @@
+using Application.Dtos.ReviewDtos;
+using Application.Models;
+using MediatR;
+
+namespace Application.Commands.ReviewCommands.AddReview
+{
+    public class AddReviewCommand(AddReviewDto dto) : IRequest<OperationResult<GetReviewDto>>
+    {
+        public AddReviewDto dto { get; set; } = dto;
+    }
+}

Application/Commands/ReviewCommands/AddReview/AddReviewCommandHandler.cs

@@ -0,0 +1,42 @@
+using Application.Dtos.ReviewDtos;
+using Application.Interfaces.RepositoryInterfaces;
+using Application.Models;
+using AutoMapper;
+using Domain.Entities.Metadata;
+using MediatR;
+
+namespace Application.Commands.ReviewCommands.AddReview
+{
+    public class AddReviewCommandHandler(IGenericRepository<Review, int> repository, IMapper mapper) : IRequestHandler<AddReviewCommand, OperationResult<GetReviewDto>>
+    {
+        private readonly IGenericRepository<Review, int> _repository = repository;
+        private readonly IMapper _mapper = mapper;
+
+
+        public async Task<OperationResult<GetReviewDto>> Handle(AddReviewCommand request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                Review review = new()
+                {
+                    Rating = request.dto.Rating,
+                    Comment = request.dto.Comment,
+                    ReviewDate = request.dto.ReviewDate,
+                    BookId = request.dto.BookId
+                };
+
+                var createdReview = await _repository.AddAsync(review);
+                if (createdReview != null)
+                {
+                    var mappedReview = _mapper.Map<GetReviewDto>(request.dto);
+                    return OperationResult<GetReviewDto>.Success(mappedReview);
+                }
+                return OperationResult<GetReviewDto>.Failure("Review not added");
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Review not added", ex);
+            }
+        }
+    }
+}

Application/Commands/ReviewCommands/AddReview/AddReviewCommandValidator.cs

@@ -0,0 +1,19 @@
+
+using FluentValidation;
+
+namespace Application.Commands.ReviewCommands.AddReview
+{
+    public class AddReviewCommandValidator : AbstractValidator<AddReviewCommand>
+    {
+        public AddReviewCommandValidator()
+        {
+            RuleFor(x => x.dto.Comment)
+                .NotEmpty().WithMessage("Comment can not be empty");
+
+            RuleFor(x => x.dto.Rating)
+                .NotEmpty().WithMessage("Rating betwen 1 - 5 is required.");
+
+            // More stuff here. 
+        }
+    }
+}

Application/Commands/ReviewCommands/DeleteReview/DeleteReviewCommand.cs

@@ -0,0 +1,11 @@
+
+using Application.Models;
+using MediatR;
+
+namespace Application.Commands.ReviewCommands.DeleteReview
+{
+    public class DeleteReviewCommand(int id) : IRequest<OperationResult<bool>>
+    {
+        public int Id { get; set; } = id;
+    }
+}

Application/Commands/ReviewCommands/DeleteReview/DeleteReviewCommandHandler.cs

@@ -0,0 +1,32 @@
+using Application.Interfaces.RepositoryInterfaces;
+using Application.Models;
+using AutoMapper;
+using Domain.Entities.Metadata;
+using MediatR;
+
+namespace Application.Commands.ReviewCommands.DeleteReview
+{
+    internal class DeleteReviewCommandHandler(IGenericRepository<Review, int> repository, IMapper mapper) : IRequestHandler<DeleteReviewCommand, OperationResult<bool>>
+    {
+        private readonly IGenericRepository<Review, int> _repository = repository;
+        private readonly IMapper _mapper = mapper;
+
+        public async Task<OperationResult<bool>> Handle(DeleteReviewCommand request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                var deletionSucessful = await _repository.DeleteAsync(request.Id);
+                if (deletionSucessful is false)
+                {
+                    return OperationResult<bool>.Failure("Operation failed");
+                }
+                return OperationResult<bool>.Success(true);
+            }
+            catch (Exception ex)
+            {
+                return OperationResult<bool>.Failure(ex.Message, ex.InnerException.Message);
+            }
+
+        }
+    }
+}

Application/Commands/ReviewCommands/DeleteReview/DeleteReviewCommandValidator.cs

@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace Application.Commands.ReviewCommands.DeleteReview
+{
+    public class DeleteReviewCommandValidator : AbstractValidator<DeleteReviewCommand>
+    {
+        public DeleteReviewCommandValidator()
+        {
+            RuleFor(x => x.Id)
+                .NotEmpty().WithMessage("Id can not be empty");
+        }
+    }
+}

Application/Commands/ReviewCommands/UpdateReview/UpdateReviewCommand.cs

@@ -0,0 +1,11 @@
+using Application.Dtos.ReviewDtos;
+using Application.Models;
+using MediatR;
+
+namespace Application.Commands.ReviewCommands.UpdateReview
+{
+    public class UpdateReviewCommand(UpdateReviewDto dto) : IRequest<OperationResult<GetReviewDto>>
+    {
+        public UpdateReviewDto dto { get; set; } = dto;
+    }
+}

Application/Commands/ReviewCommands/UpdateReview/UpdateReviewCommandHandler.cs

@@ -0,0 +1,37 @@
+using Application.Dtos.ReviewDtos;
+using Application.Interfaces.RepositoryInterfaces;
+using Application.Models;
+using AutoMapper;
+using Domain.Entities.Metadata;
+using MediatR;
+
+namespace Application.Commands.ReviewCommands.UpdateReview
+{
+    public class UpdateReviewCommandHandler(IGenericRepository<Review, int> repository, IMapper mapper) : IRequestHandler<UpdateReviewCommand, OperationResult<GetReviewDto>>
+    {
+        private readonly IGenericRepository<Review, int> _repository = repository;
+        private readonly IMapper _mapper = mapper;
+
+        public async Task<OperationResult<GetReviewDto>> Handle(UpdateReviewCommand request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                Review review = new()
+                {
+                    Id = request.dto.ReviewId,
+                    Rating = request.dto.Rating,
+                    Comment = request.dto.Comment,
+                    ReviewDate = request.dto.ReviewDate,
+                    BookId = request.dto.BookId
+                };
+                var updatedReview = await _repository.UpdateAsync(review);
+                var mappedReview = _mapper.Map<GetReviewDto>(updatedReview);
+                return OperationResult<GetReviewDto>.Success(mappedReview);
+            }
+            catch (Exception ex)
+            {
+                return OperationResult<GetReviewDto>.Failure(ex.Message, ex.InnerException.Message);
+            }
+        }
+    }
+}

Application/Commands/ReviewCommands/UpdateReview/UpdateReviewCommandValidator.cs

@@ -0,0 +1,22 @@
+
+using FluentValidation;
+
+namespace Application.Commands.ReviewCommands.UpdateReview
+{
+    public class UpdateReviewCommandValidator : AbstractValidator<UpdateReviewCommand>
+    {
+        public UpdateReviewCommandValidator()
+        {
+            RuleFor(x => x.dto.ReviewId)
+                .NotEmpty().WithMessage("ReviewId can not be empty");
+
+            RuleFor(x => x.dto.Comment)
+                .NotEmpty().WithMessage("Comment can not be empty");
+
+            RuleFor(x => x.dto.Rating)
+                .NotEmpty().WithMessage("Rating betwen 1 - 5 is required.");
+
+            // More stuff here. 
+        }
+    }
+}

Application/DependencyInjection.cs

@@ -29,6 +29,7 @@ public static IServiceCollection AddApplication(this IServiceCollection services
             services.AddAutoMapper(typeof(BookCopyMappingProfiles).Assembly);
             services.AddAutoMapper(typeof(LibraryBranchMappingProfiles).Assembly);
             services.AddAutoMapper(typeof(GenreMappingProfiles).Assembly);
+            services.AddAutoMapper(typeof(ReviewMappingProfiles).Assembly);
 
             // Register validators
             services.AddValidatorsFromAssemblyContaining<AddAuthorCommandValidator>();

Application/Dtos/ReviewDtos/AddReviewDto.cs

@@ -0,0 +1,11 @@
+
+namespace Application.Dtos.ReviewDtos
+{
+    public class AddReviewDto
+    {
+        public int Rating { get; set; }
+        public string Comment { get; set; }
+        public DateTime ReviewDate { get; set; }
+        public Guid BookId { get; set; }
+    }
+}

Application/Dtos/ReviewDtos/GetReviewDto.cs

@@ -0,0 +1,12 @@
+
+namespace Application.Dtos.ReviewDtos
+{
+    public class GetReviewDto
+    {
+        public int ReviewId { get; set; }
+        public int Rating { get; set; }
+        public string Comment { get; set; }
+        public DateTime ReviewDate { get; set; }
+        public Guid BookId { get; set; }
+    }
+}

Application/Dtos/ReviewDtos/UpdateReviewDto.cs

@@ -0,0 +1,12 @@
+
+namespace Application.Dtos.ReviewDtos
+{
+    public class UpdateReviewDto
+    {
+        public int ReviewId { get; set; }
+        public int Rating { get; set; }
+        public string Comment { get; set; }
+        public DateTime ReviewDate { get; set; }
+        public Guid BookId { get; set; }
+    }
+}

Application/Mappings/ReviewMappingProfiles.cs

@@ -0,0 +1,17 @@
+
+using Application.Dtos.ReviewDtos;
+using AutoMapper;
+using Domain.Entities.Metadata;
+
+namespace Application.Mappings
+{
+    public class ReviewMappingProfiles : Profile
+    {
+        public ReviewMappingProfiles()
+        {
+            CreateMap<Review, AddReviewDto>();
+            CreateMap<Review, GetReviewDto>();
+
+        }
+    }
+}

Application/Queries/ReviewQueries/GetAllReviews/GetAllReviewsQuery.cs

@@ -0,0 +1,11 @@
+using Application.Dtos.ReviewDtos;
+using Application.Models;
+using MediatR;
+
+namespace Application.Queries.ReviewQueries.GetAllReviews
+{
+    public class GetAllReviewsQuery() : IRequest<OperationResult<List<GetReviewDto>>>
+    {
+
+    }
+}