Merge branch 'develop' of https://github.com/Kareadita/Kavita into feature/magazine

API/Controllers/ChapterController.cs

@@ -6,6 +6,7 @@ using API.Constants;
 using API.Data;
 using API.Data.Repositories;
 using API.DTOs;
+using API.DTOs.SeriesDetail;
 using API.Entities;
 using API.Entities.Enums;
 using API.Entities.Person;
@@ -14,8 +15,10 @@ using API.Helpers;
 using API.Services;
 using API.Services.Tasks.Scanner.Parser;
 using API.SignalR;
+using AutoMapper;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Nager.ArticleNumber;
 
@@ -27,13 +30,16 @@ public class ChapterController : BaseApiController
     private readonly ILocalizationService _localizationService;
     private readonly IEventHub _eventHub;
     private readonly ILogger<ChapterController> _logger;
+    private readonly IMapper _mapper;
 
-    public ChapterController(IUnitOfWork unitOfWork, ILocalizationService localizationService, IEventHub eventHub, ILogger<ChapterController> logger)
+    public ChapterController(IUnitOfWork unitOfWork, ILocalizationService localizationService, IEventHub eventHub, ILogger<ChapterController> logger,
+        IMapper mapper)
     {
         _unitOfWork = unitOfWork;
         _localizationService = localizationService;
         _eventHub = eventHub;
         _logger = logger;
+        _mapper = mapper;
     }
 
     /// <summary>
@@ -62,7 +68,8 @@ public class ChapterController : BaseApiController
     {
         if (User.IsInRole(PolicyConstants.ReadOnlyRole)) return BadRequest(await _localizationService.Translate(User.GetUserId(), "permission-denied"));
 
-        var chapter = await _unitOfWork.ChapterRepository.GetChapterAsync(chapterId);
+        var chapter = await _unitOfWork.ChapterRepository.GetChapterAsync(chapterId,
+            ChapterIncludes.Files | ChapterIncludes.ExternalReviews | ChapterIncludes.ExternalRatings);
         if (chapter == null)
             return BadRequest(_localizationService.Translate(User.GetUserId(), "chapter-doesnt-exist"));
 
@@ -80,6 +87,15 @@ public class ChapterController : BaseApiController
             _unitOfWork.ChapterRepository.Remove(chapter);
         }
 
+        // If we removed the volume, do an additional check if we need to delete the actual series as well or not
+        var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(vol.SeriesId, SeriesIncludes.ExternalData | SeriesIncludes.Volumes);
+        var needToRemoveSeries = needToRemoveVolume && series != null && series.Volumes.Count <= 1;
+        if (needToRemoveSeries)
+        {
+            _unitOfWork.SeriesRepository.Remove(series!);
+        }
+
+
 
         if (!await _unitOfWork.CommitAsync()) return Ok(false);
 
@@ -89,6 +105,12 @@ public class ChapterController : BaseApiController
             await _eventHub.SendMessageAsync(MessageFactory.VolumeRemoved, MessageFactory.VolumeRemovedEvent(chapter.VolumeId, vol.SeriesId), false);
         }
 
+        if (needToRemoveSeries)
+        {
+            await _eventHub.SendMessageAsync(MessageFactory.SeriesRemoved,
+                MessageFactory.SeriesRemovedEvent(series!.Id, series.Name, series.LibraryId), false);
+        }
+
         return Ok(true);
     }
 
@@ -391,6 +413,39 @@ public class ChapterController : BaseApiController
         return Ok();
     }
 
+    /// <summary>
+    /// Returns Ratings and Reviews for an individual Chapter
+    /// </summary>
+    /// <param name="chapterId"></param>
+    /// <returns></returns>
+    [HttpGet("chapter-detail-plus")]
+    public async Task<ActionResult<ChapterDetailPlusDto>> ChapterDetailPlus([FromQuery] int chapterId)
+    {
+        var ret = new ChapterDetailPlusDto();
 
+        var userReviews = (await _unitOfWork.UserRepository.GetUserRatingDtosForChapterAsync(chapterId, User.GetUserId()))
+            .Where(r => !string.IsNullOrEmpty(r.Body))
+            .OrderByDescending(review => review.Username.Equals(User.GetUsername()) ? 1 : 0)
+            .ToList();
+
+        var ownRating = await _unitOfWork.UserRepository.GetUserChapterRatingAsync(User.GetUserId(), chapterId);
+        if (ownRating != null)
+        {
+            ret.Rating = ownRating.Rating;
+            ret.HasBeenRated = ownRating.HasBeenRated;
+        }
+
+        var externalReviews = await _unitOfWork.ChapterRepository.GetExternalChapterReviewDtos(chapterId);
+        if (externalReviews.Count > 0)
+        {
+            userReviews.AddRange(ReviewHelper.SelectSpectrumOfReviews(externalReviews));
+        }
+
+        ret.Reviews = userReviews;
+
+        ret.Ratings = await _unitOfWork.ChapterRepository.GetExternalChapterRatingDtos(chapterId);
+
+        return Ok(ret);
+    }
 
 }

API/Controllers/MetadataController.cs

@@ -221,7 +221,7 @@ public class MetadataController(IUnitOfWork unitOfWork, ILocalizationService loc
         return Ok(ret);
     }
 
-    private async Task PrepareSeriesDetail(List<UserReviewDto> userReviews, SeriesDetailPlusDto ret)
+    private async Task PrepareSeriesDetail(List<UserReviewDto> userReviews, SeriesDetailPlusDto? ret)
     {
         var isAdmin = User.IsInRole(PolicyConstants.AdminRole);
         var user = await unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId())!;
@@ -235,12 +235,12 @@ public class MetadataController(IUnitOfWork unitOfWork, ILocalizationService loc
             ret.Recommendations.OwnedSeries =
                 await unitOfWork.SeriesRepository.GetSeriesDtoByIdsAsync(
                     ret.Recommendations.OwnedSeries.Select(s => s.Id), user);
-            ret.Recommendations.ExternalSeries = new List<ExternalSeriesDto>();
+            ret.Recommendations.ExternalSeries = [];
         }
 
         if (ret.Recommendations != null && user != null)
         {
-            ret.Recommendations.OwnedSeries ??= new List<SeriesDto>();
+            ret.Recommendations.OwnedSeries ??= [];
             await unitOfWork.SeriesRepository.AddSeriesModifiers(user.Id, ret.Recommendations.OwnedSeries);
         }
     }

API/Controllers/PluginController.cs

@@ -30,7 +30,7 @@ public class PluginController(IUnitOfWork unitOfWork, ITokenService tokenService
     public async Task<ActionResult<UserDto>> Authenticate([Required] string apiKey, [Required] string pluginName)
     {
         // NOTE: In order to log information about plugins, we need some Plugin Description information for each request
-        // Should log into access table so we can tell the user
+        // Should log into the access table so we can tell the user
         var ipAddress = HttpContext.Connection.RemoteIpAddress?.ToString();
         var userAgent = HttpContext.Request.Headers.UserAgent;
         var userId = await unitOfWork.UserRepository.GetUserIdByApiKeyAsync(apiKey);

API/Controllers/RatingController.cs

@@ -1,15 +1,12 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
-using API.Constants;
 using API.Data;
+using API.Data.Repositories;
 using API.DTOs;
 using API.Extensions;
+using API.Services;
 using API.Services.Plus;
-using EasyCaching.Core;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Logging;
 
 namespace API.Controllers;
 
@@ -21,21 +18,85 @@ namespace API.Controllers;
 public class RatingController : BaseApiController
 {
     private readonly IUnitOfWork _unitOfWork;
+    private readonly IRatingService _ratingService;
+    private readonly ILocalizationService _localizationService;
 
-    public RatingController(IUnitOfWork unitOfWork)
+    public RatingController(IUnitOfWork unitOfWork, IRatingService ratingService, ILocalizationService localizationService)
     {
         _unitOfWork = unitOfWork;
-
+        _ratingService = ratingService;
+        _localizationService = localizationService;
     }
 
-    [HttpGet("overall")]
-    public async Task<ActionResult<RatingDto>> GetOverallRating(int seriesId)
+    /// <summary>
+    /// Update the users' rating of the given series
+    /// </summary>
+    /// <param name="updateRating"></param>
+    /// <returns></returns>
+    /// <exception cref="UnauthorizedAccessException"></exception>
+    [HttpPost("series")]
+    public async Task<ActionResult> UpdateSeriesRating(UpdateRatingDto updateRating)
+    {
+        var user = await _unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId(), AppUserIncludes.Ratings | AppUserIncludes.ChapterRatings);
+        if (user == null) throw new UnauthorizedAccessException();
+
+        if (await _ratingService.UpdateSeriesRating(user, updateRating))
+        {
+            return Ok();
+        }
+
+        return BadRequest(await _localizationService.Translate(User.GetUserId(), "generic-error"));
+    }
+
+    /// <summary>
+    /// Update the users' rating of the given chapter
+    /// </summary>
+    /// <param name="updateRating">chapterId must be set</param>
+    /// <returns></returns>
+    /// <exception cref="UnauthorizedAccessException"></exception>
+    [HttpPost("chapter")]
+    public async Task<ActionResult> UpdateChapterRating(UpdateRatingDto updateRating)
+    {
+        var user = await _unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId(), AppUserIncludes.Ratings | AppUserIncludes.ChapterRatings);
+        if (user == null) throw new UnauthorizedAccessException();
+
+        if (await _ratingService.UpdateChapterRating(user, updateRating))
+        {
+            return Ok();
+        }
+
+        return BadRequest(await _localizationService.Translate(User.GetUserId(), "generic-error"));
+    }
+
+    /// <summary>
+    /// Overall rating from all Kavita users for a given Series
+    /// </summary>
+    /// <param name="seriesId"></param>
+    /// <returns></returns>
+    [HttpGet("overall-series")]
+    public async Task<ActionResult<RatingDto>> GetOverallSeriesRating(int seriesId)
     {
         return Ok(new RatingDto()
         {
             Provider = ScrobbleProvider.Kavita,
             AverageScore = await _unitOfWork.SeriesRepository.GetAverageUserRating(seriesId, User.GetUserId()),
-            FavoriteCount = 0
+            FavoriteCount = 0,
+        });
+    }
+
+    /// <summary>
+    /// Overall rating from all Kavita users for a given Chapter
+    /// </summary>
+    /// <param name="chapterId"></param>
+    /// <returns></returns>
+    [HttpGet("overall-chapter")]
+    public async Task<ActionResult<RatingDto>> GetOverallChapterRating(int chapterId)
+    {
+        return Ok(new RatingDto()
+        {
+            Provider = ScrobbleProvider.Kavita,
+            AverageScore = await _unitOfWork.ChapterRepository.GetAverageUserRating(chapterId, User.GetUserId()),
+            FavoriteCount = 0,
         });
     }
 }

API/Controllers/ReviewController.cs

@@ -1,8 +1,11 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using API.Data;
 using API.Data.Repositories;
 using API.DTOs.SeriesDetail;
+using API.Entities;
+using API.Entities.Enums;
 using API.Extensions;
 using API.Helpers.Builders;
 using API.Services.Plus;
@@ -30,17 +33,17 @@ public class ReviewController : BaseApiController
 
 
     /// <summary>
-    /// Updates the review for a given series
+    /// Updates the user's review for a given series
     /// </summary>
     /// <param name="dto"></param>
     /// <returns></returns>
-    [HttpPost]
-    public async Task<ActionResult<UserReviewDto>> UpdateReview(UpdateUserReviewDto dto)
+    [HttpPost("series")]
+    public async Task<ActionResult<UserReviewDto>> UpdateSeriesReview(UpdateUserReviewDto dto)
     {
         var user = await _unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId(), AppUserIncludes.Ratings);
         if (user == null) return Unauthorized();
 
-        var ratingBuilder = new RatingBuilder(user.Ratings.FirstOrDefault(r => r.SeriesId == dto.SeriesId));
+        var ratingBuilder = new RatingBuilder(await _unitOfWork.UserRepository.GetUserRatingAsync(dto.SeriesId, user.Id));
 
         var rating = ratingBuilder
             .WithBody(dto.Body)
@@ -52,22 +55,58 @@ public class ReviewController : BaseApiController
         {
             user.Ratings.Add(rating);
         }
+
         _unitOfWork.UserRepository.Update(user);
 
         await _unitOfWork.CommitAsync();
 
-
         BackgroundJob.Enqueue(() =>
             _scrobblingService.ScrobbleReviewUpdate(user.Id, dto.SeriesId, string.Empty, dto.Body));
         return Ok(_mapper.Map<UserReviewDto>(rating));
     }
 
+    /// <summary>
+    /// Update the user's review for a given chapter
+    /// </summary>
+    /// <param name="dto">chapterId must be set</param>
+    /// <returns></returns>
+    [HttpPost("chapter")]
+    public async Task<ActionResult<UserReviewDto>> UpdateChapterReview(UpdateUserReviewDto dto)
+    {
+        var user = await _unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId(), AppUserIncludes.ChapterRatings);
+        if (user == null) return Unauthorized();
+
+        if (dto.ChapterId == null) return BadRequest();
+
+        int chapterId = dto.ChapterId.Value;
+
+        var ratingBuilder = new ChapterRatingBuilder(await _unitOfWork.UserRepository.GetUserChapterRatingAsync(user.Id, chapterId));
+
+        var rating = ratingBuilder
+            .WithBody(dto.Body)
+            .WithSeriesId(dto.SeriesId)
+            .WithChapterId(chapterId)
+            .Build();
+
+        if (rating.Id == 0)
+        {
+            user.ChapterRatings.Add(rating);
+        }
+
+        _unitOfWork.UserRepository.Update(user);
+
+        await _unitOfWork.CommitAsync();
+
+        return Ok(_mapper.Map<UserReviewDto>(rating));
+    }
+
+
     /// <summary>
     /// Deletes the user's review for the given series
     /// </summary>
     /// <returns></returns>
-    [HttpDelete]
-    public async Task<ActionResult> DeleteReview(int seriesId)
+    [HttpDelete("series")]
+    public async Task<ActionResult> DeleteSeriesReview([FromQuery] int seriesId)
     {
         var user = await _unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId(), AppUserIncludes.Ratings);
         if (user == null) return Unauthorized();
@@ -80,4 +119,23 @@ public class ReviewController : BaseApiController
 
         return Ok();
     }
+
+    /// <summary>
+    /// Deletes the user's review for the given chapter
+    /// </summary>
+    /// <returns></returns>
+    [HttpDelete("chapter")]
+    public async Task<ActionResult> DeleteChapterReview([FromQuery] int chapterId)
+    {
+        var user = await _unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId(), AppUserIncludes.ChapterRatings);
+        if (user == null) return Unauthorized();
+
+        user.ChapterRatings = user.ChapterRatings.Where(r => r.ChapterId != chapterId).ToList();
+
+        _unitOfWork.UserRepository.Update(user);
+
+        await _unitOfWork.CommitAsync();
+
+        return Ok();
+    }
 }

API/Controllers/SeriesController.cs

@@ -191,21 +191,6 @@ public class SeriesController : BaseApiController
         return Ok(await _unitOfWork.ChapterRepository.GetChapterMetadataDtoAsync(chapterId));
     }
 
-
-    /// <summary>
-    /// Update the user rating for the given series
-    /// </summary>
-    /// <param name="updateSeriesRatingDto"></param>
-    /// <returns></returns>
-    [HttpPost("update-rating")]
-    public async Task<ActionResult> UpdateSeriesRating(UpdateSeriesRatingDto updateSeriesRatingDto)
-    {
-        var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername(), AppUserIncludes.Ratings);
-        if (!await _seriesService.UpdateRating(user!, updateSeriesRatingDto))
-            return BadRequest(await _localizationService.Translate(User.GetUserId(), "generic-error"));
-        return Ok();
-    }
-
     /// <summary>
     /// Updates the Series
     /// </summary>