feat: #35 add book feedback

Api/Controllers/BooksController.cs

@@ -21,18 +21,16 @@ namespace Api.Controllers;
 [Route("api/books")]
 public class BooksController : Controller
 {
-  private readonly CreateBookCommand _createBookCommand;
   private readonly DeleteBookCommand _deleteBookCommand;
   private readonly GetAllBooksQuery _getAllBooksQuery;
   private readonly GetBookByIdQuery _getBookByIdQuery;
-  private readonly GetBookByCopyIdQuery _getBookByCopyIdQuery;
+  private readonly IGetBookByCopyIdQuery _getBookByCopyIdQuery;
   private readonly GetBookCopyReadingHistoryByCopyIdQuery _getBookCopyReadingHistoryByCopyIdQuery;
   private readonly GetBookHistoryByIdQuery _getBookHistoryByIdQuery;
   private readonly IGetKnowledgeAreasQuery _getKnowledgeAreasQuery;
   private readonly BookCopyValidatorQuery _bookCopyValidatorQuery;
   private readonly SoftDeleteBookCommand _softDeleteBookCommand;
   private readonly EditBookCommand _editBookCommand;
-  private readonly ReturnBookCommand _returnBookCommand;
   private readonly TakeBookService _takeBookService;
   private readonly IInnerCircleHttpClient _client;
 
@@ -42,16 +40,14 @@ public class BooksController : Controller
   public BooksController(
     GetAllBooksQuery getAllBooksQuery,
     GetBookByIdQuery getBookByIdQuery,
-    GetBookByCopyIdQuery getBookByCopyIdQuery,
+    IGetBookByCopyIdQuery getBookByCopyIdQuery,
     GetBookCopyReadingHistoryByCopyIdQuery getBookCopyReadingHistoryByCopyIdQuery,
     GetBookHistoryByIdQuery getBookHistoryByIdQuery,
     BookCopyValidatorQuery bookCopyValidatorQuery,
     IGetKnowledgeAreasQuery getKnowledgeAreasQuery,
-    CreateBookCommand createBookCommand,
     EditBookCommand editBookCommand,
     DeleteBookCommand deleteBookCommand,
     SoftDeleteBookCommand softDeleteBookCommand,
-    ReturnBookCommand returnBookCommand,
     TakeBookService takeBookService,
     IInnerCircleHttpClient client
   )
@@ -63,11 +59,9 @@ IInnerCircleHttpClient client
     _getBookHistoryByIdQuery = getBookHistoryByIdQuery;
     _bookCopyValidatorQuery = bookCopyValidatorQuery;
     _getKnowledgeAreasQuery = getKnowledgeAreasQuery;
-    _createBookCommand = createBookCommand;
     _editBookCommand = editBookCommand;
     _deleteBookCommand = deleteBookCommand;
     _softDeleteBookCommand = softDeleteBookCommand;
-    _returnBookCommand = returnBookCommand;
     _takeBookService = takeBookService;
     _client = client;
   }
@@ -146,9 +140,9 @@ public async Task<ActionResult<SingleBookResponse>> GetBookByIdAsync([Required][
   [HttpGet("copy/{id}")]
   public async Task<ActionResult<SingleBookResponse>> GetBookByCopyIdAsync([Required][FromRoute] long id, [Required][FromQuery] string secretKey)
   {
-    var bookId = await _getBookByCopyIdQuery.GetBookIdByCopyIdAsync(id, User.GetTenantId());
+    var book = await _getBookByCopyIdQuery.GetByCopyIdAsync(id, User.GetTenantId());
 
-    if (bookId == 0)
+    if (book == null)
     {
       return NotFound(new
       {
@@ -166,7 +160,7 @@ public async Task<ActionResult<SingleBookResponse>> GetBookByCopyIdAsync([Requir
       });
     }
 
-    return await GetBookResponseAsync(bookId);
+    return await GetBookResponseAsync(book.Id);
   }
 
   /// <summary>
@@ -202,6 +196,19 @@ public async Task<ActionResult<BookWithCopiesResponse>> GetBookCopiesByIdAsync([
     };
   }
 
+  /// <summary>
+  ///     Get book feedback by book id
+  /// </summary>
+  [RequiresPermission(UserClaimsProvider.CanViewBooks)]
+  [HttpGet("feedback/{bookId}")]
+  public Task<GetBookFeedbackResponse> GetBookFeedbackAsync(
+    [Required][FromRoute] long bookId,
+    [FromServices] GetBookFeedbackHandler getBookFeedbackHandler
+  )
+  {
+    return getBookFeedbackHandler.HandleAsync(bookId, User.GetTenantId());
+  }
+
   /// <summary>
   ///     Adds book
   /// </summary>
@@ -262,18 +269,14 @@ public async Task<IActionResult> TakeBookAsync([Required][FromBody] TakeBookRequ
   /// <param name="returnBookRequest"></param>
   [RequiresPermission(UserClaimsProvider.CanViewBooks)]
   [HttpPost("return")]
-  public async Task ReturnBookAsync([Required][FromBody] ReturnBookRequest returnBookRequest)
+  public async Task ReturnBookAsync(
+    [Required][FromBody] ReturnBookRequest returnBookRequest,
+    [FromServices] ReturnBookHandler returnBookHandler
+  )
   {
     var employee = await _client.GetEmployeeAsync(User.GetCorporateEmail());
 
-    var returnBookCommandParams = new ReturnBookCommandParams
-    {
-      BookCopyId = returnBookRequest.BookCopyId,
-      ProgressOfReading = (ProgressOfReading)Enum.Parse(typeof(ProgressOfReading), returnBookRequest.ProgressOfReading),
-      ActualReturnedAtUtc = DateTime.UtcNow
-    };
-
-    await _returnBookCommand.ReturnAsync(returnBookCommandParams, employee, User.GetTenantId());
+    await returnBookHandler.HandleAsync(returnBookRequest, employee, User.GetTenantId());
   }
 
   /// <summary>

Api/Controllers/Handlers/GetBookFeedbackHandler.cs

@@ -0,0 +1,51 @@
+using Api.Responses;
+using Application;
+using Application.Queries;
+
+namespace Api.Controllers.Handlers;
+
+public class GetBookFeedbackHandler
+{
+    private readonly IInnerCircleHttpClient _client;
+
+    private readonly GetBookFeedbackQuery _getBookFeedbackQuery;
+
+    public GetBookFeedbackHandler(
+        IInnerCircleHttpClient client,
+        GetBookFeedbackQuery getBookFeedbackQuery
+    )
+    {
+        _client = client;
+        _getBookFeedbackQuery = getBookFeedbackQuery;
+    }
+
+    public async Task<GetBookFeedbackResponse> HandleAsync(long bookId, long tenantId)
+    {
+        var bookFeedback = await _getBookFeedbackQuery.GetAsync(bookId, tenantId);
+
+        var employeesIds = bookFeedback
+            .Select(x => x.EmployeeId)
+            .ToList();
+
+        var employeesByIds = await _client.GetEmployeesByIdsAsync(employeesIds);
+
+        return new GetBookFeedbackResponse
+        {
+            BookFeedback = bookFeedback
+                .Select(x =>
+                {
+                    return new BookFeedbackDto
+                    {
+                        Id = x.Id,
+                        EmployeeFullName = employeesByIds.FirstOrDefault(employee => employee.EmployeeId == x.EmployeeId).FullName,
+                        LeftFeedbackAtUtc = x.LeftFeedbackAtUtc,
+                        ProgressOfReading = x.ProgressOfReading.ToString(),
+                        Rating = x.Rating,
+                        Advantages = x.Advantages,
+                        Disadvantages = x.Disadvantages
+                    };
+                })
+                .ToList(),
+        };
+    }
+}

Api/Controllers/Handlers/ReturnBookHandler.cs

@@ -0,0 +1,45 @@
+using Api.Requests;
+using Application.Commands;
+using Application.Queries;
+using Core;
+using Core.Entities;
+
+namespace Api.Controllers.Handlers;
+
+public class ReturnBookHandler
+{
+  private readonly IGetBookByCopyIdQuery _getBookByCopyIdQuery;
+  private readonly ReturnBookCommand _returnBookCommand;
+
+  public ReturnBookHandler(
+    IGetBookByCopyIdQuery getBookByCopyIdQuery,
+    ReturnBookCommand returnBookCommand
+  )
+  {
+    _getBookByCopyIdQuery = getBookByCopyIdQuery;
+    _returnBookCommand = returnBookCommand;
+  }
+
+  public async Task HandleAsync(ReturnBookRequest returnBookRequest, Employee employee, long tenantId)
+  {
+    var book = await _getBookByCopyIdQuery.GetByCopyIdAsync(returnBookRequest.BookCopyId, tenantId);
+
+    if (book == null)
+    {
+      throw new ArgumentException($"Book copy with id {returnBookRequest.BookCopyId} not found");
+    }
+
+    var returnBookCommandParams = new ReturnBookCommandParams
+    {
+      BookCopyId = returnBookRequest.BookCopyId,
+      BookId = book.Id,
+      ProgressOfReading = (ProgressOfReading)Enum.Parse(typeof(ProgressOfReading), returnBookRequest.ProgressOfReading),
+      ActualReturnedAtUtc = DateTime.UtcNow,
+      Rating = returnBookRequest.Rating,
+      Advantages = returnBookRequest.Advantages,
+      Disadvantages = returnBookRequest.Disadvantages,
+    };
+
+     await _returnBookCommand.ReturnAsync(returnBookCommandParams, employee, tenantId);
+  }
+}

Api/Controllers/Handlers/ReturnBookHandlerTests.cs

@@ -0,0 +1,45 @@
+using Api.Controllers.Handlers;
+using Api.Requests;
+using Application.Queries;
+using Core.Entities;
+using Moq;
+using Xunit;
+
+namespace Application.Commands;
+
+public class ReturnBookHandlerTests
+{
+  private const long TENANT_ID = 1;
+
+  private readonly ReturnBookHandler _handler;
+
+  public ReturnBookHandlerTests()
+  {
+    var getBookByCopyIdQueryMock = new Mock<IGetBookByCopyIdQuery>();
+
+    getBookByCopyIdQueryMock
+      .Setup(x => x.GetByCopyIdAsync(1, TENANT_ID))
+      .ReturnsAsync(new Book
+      {
+        Id = 1,
+        TenantId = TENANT_ID
+      });
+
+    _handler = new ReturnBookHandler(getBookByCopyIdQueryMock.Object, null);
+  }
+
+  [Fact]
+  public async Task HandleAsyncWithNonExistedBookCopyId_ShouldThrowException()
+  {
+    var createBookRequest = new ReturnBookRequest
+    {
+      BookCopyId = 999
+    };
+
+    var exception = await Assert.ThrowsAsync<ArgumentException>(
+      async () => await _handler.HandleAsync(createBookRequest, null, TENANT_ID)
+    );
+
+    Assert.Equal($"Book copy with id {createBookRequest.BookCopyId} not found", exception.Message);
+  }
+}

Api/DependencyInjection.cs

@@ -23,15 +23,18 @@ public static void AddApplication(this IServiceCollection services, IConfigurati
     services.AddTransient<DeleteBookCommand>();
     services.AddTransient<SoftDeleteBookCommand>();
     services.AddTransient<GetBookByIdQuery>();
-    services.AddTransient<GetBookByCopyIdQuery>();
+    services.AddTransient<IGetBookByCopyIdQuery, GetBookByCopyIdQuery>();
     services.AddTransient<GetBookHistoryByIdQuery>();
+    services.AddTransient<GetBookFeedbackHandler>();
+    services.AddTransient<GetBookFeedbackQuery>();
     services.AddTransient<IGetKnowledgeAreasQuery, GetKnowledgeAreasQuery>();
     services.AddTransient<GetAllBooksQuery>();
     services.AddTransient<CreateBookHandler>();
     services.AddTransient<GetBookCopyReadingHistoryByCopyIdQuery>();
     services.AddTransient<BookCopyValidatorQuery>();
     services.AddTransient<TakeBookCommand>();
     services.AddTransient<ReturnBookCommand>();
+    services.AddTransient<ReturnBookHandler>();
     services.AddTransient<IInnerCircleHttpClient, InnerCircleHttpClient>();
     services.AddTransient<TakeBookService>();
   }

Api/Requests/ReturnBookRequest.cs

@@ -9,4 +9,11 @@ public class ReturnBookRequest
 
   [Required]
   public string ProgressOfReading { get; set; }
+
+  [Range(1, 5)]
+  public int? Rating { get; set; }
+
+  public string? Advantages { get; set; }
+
+  public string? Disadvantages { get; set; }
 }

Api/Responses/GetBookFeedbackResponse.cs

@@ -0,0 +1,23 @@
+namespace Api.Responses;
+
+public class GetBookFeedbackResponse
+{
+  public List<BookFeedbackDto> BookFeedback { get; set; }
+}
+
+public class BookFeedbackDto
+{
+    public long Id { get; set; }
+
+    public string EmployeeFullName { get; set; }
+
+    public DateTime LeftFeedbackAtUtc { get; set; }
+
+    public string ProgressOfReading { get; set; }
+
+    public int? Rating { get; set; }
+
+    public string? Advantages { get; set; }
+
+    public string? Disadvantages { get; set; }
+}

Application/AppDbContext.cs

@@ -21,6 +21,8 @@ public AppDbContext()
 
   public virtual DbSet<KnowledgeArea> KnowledgeAreas { get; set; }
 
+   public virtual DbSet<BookFeedback> BookFeedback { get; set; }
+
   protected override void OnModelCreating(ModelBuilder modelBuilder)
   {
     modelBuilder.ApplyConfigurationsFromAssembly(GetType().Assembly);

Application/Commands/ReturnBookCommand.cs

@@ -8,9 +8,17 @@ public class ReturnBookCommandParams
 {
   public long BookCopyId { get; set; }
 
+  public long BookId { get; set; }
+
   public ProgressOfReading ProgressOfReading { get; set; }
 
   public DateTime ActualReturnedAtUtc { get; set; }
+
+  public int? Rating { get; set; }
+
+  public string? Advantages { get; set; }
+
+  public string? Disadvantages { get; set; }
 }
 
 public class ReturnBookCommand
@@ -38,7 +46,25 @@ long tenantId
     bookCopyReadingHistory.ActualReturnedAtUtc = returnBookCommandParams.ActualReturnedAtUtc;
     bookCopyReadingHistory.ProgressOfReading = returnBookCommandParams.ProgressOfReading;
 
-    _context.BooksCopiesReadingHistory.Update(bookCopyReadingHistory);
+    if (returnBookCommandParams.ProgressOfReading == ProgressOfReading.ReadPartially ||
+        returnBookCommandParams.ProgressOfReading == ProgressOfReading.ReadEntirely
+      )
+    {
+      var bookFeedback = new BookFeedback
+      {
+        TenantId = tenantId,
+        BookId = returnBookCommandParams.BookId,
+        EmployeeId = employee.Id,
+        LeftFeedbackAtUtc = DateTime.UtcNow,
+        ProgressOfReading = returnBookCommandParams.ProgressOfReading,
+        Rating = returnBookCommandParams.Rating,
+        Advantages = returnBookCommandParams.Advantages,
+        Disadvantages = returnBookCommandParams.Disadvantages
+      };
+
+      await _context.BookFeedback.AddAsync(bookFeedback);
+    }
+
     await _context.SaveChangesAsync();
   }
 }