✨ Added rating, favourite delete requests ✨

Author: DeNyWho

src/main/kotlin/club/anifox/backend/controller/users/UsersAnimeController.kt

@@ -12,6 +12,7 @@ import jakarta.validation.constraints.Max
 import jakarta.validation.constraints.Min
 import org.springframework.security.access.prepost.PreAuthorize
 import org.springframework.web.bind.annotation.CrossOrigin
+import org.springframework.web.bind.annotation.DeleteMapping
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.PostMapping
@@ -41,7 +42,15 @@ class UsersAnimeController(
         episodesWatched: Int?,
         response: HttpServletResponse,
     ) {
-        userService.addToFavoritesAnime(token, url, status, episodesWatched, response)
+        userService.addToFavorites(token, url, status, episodesWatched, response)
+    }
+
+    @DeleteMapping("{url}/favourite")
+    fun deleteFavoriteAnime(
+        @RequestHeader(value = "Authorization") token: String,
+        @PathVariable url: String,
+    ) {
+        userService.deleteFavorite(token, url)
     }
 
     @GetMapping("favourite/{status}")
@@ -57,7 +66,7 @@ class UsersAnimeController(
         @Max(500)
         Int,
     ): List<AnimeLight> {
-        return userService.getFavoritesAnimeByStatus(token, status, page, limit)
+        return userService.getFavoritesByStatus(token, status, page, limit)
     }
 
     @GetMapping("recommendations")
@@ -96,7 +105,7 @@ class UsersAnimeController(
     }
 
     @GetMapping("recently")
-    fun getRecentlyAnime(
+    fun getRecently(
         @RequestParam(defaultValue = "0", name = "page") page:
         @Min(0)
         @Max(500)
@@ -108,20 +117,24 @@ class UsersAnimeController(
         @RequestHeader(value = "Authorization") token: String,
         response: HttpServletResponse,
     ): List<AnimeLight> {
-        return userService.getRecentlyAnimeAll(token, page, limit)
+        return userService.getRecently(token, page, limit)
     }
 
     @PutMapping("{url}/rating")
     fun setAnimeRating(
         @RequestHeader(value = "Authorization") token: String,
         @PathVariable url: String,
-        @RequestParam(required = true)
-        rating:
-        @Min(0)
-        @Max(10)
-        Int,
+        @RequestParam @Min(0) @Max(10) rating: Int,
         response: HttpServletResponse,
     ) {
         userService.addRating(token, url, rating, response)
     }
+
+    @DeleteMapping("{url}/rating")
+    fun deleteAnimeRating(
+        @RequestHeader(value = "Authorization") token: String,
+        @PathVariable url: String,
+    ) {
+        userService.deleteRating(token, url)
+    }
 }

src/main/kotlin/club/anifox/backend/domain/repository/user/UserRepository.kt

@@ -13,21 +13,21 @@ interface UserRepository {
         response: HttpServletResponse,
     )
 
-    fun getRecentlyAnimeAll(
+    fun getRecently(
         token: String,
         page: Int,
         limit: Int,
     ): List<AnimeLight>
 
-    fun addToFavoritesAnime(
+    fun addToFavorites(
         token: String,
         url: String,
         status: StatusFavourite,
         episodesWatched: Int?,
         response: HttpServletResponse,
     )
 
-    fun getFavoritesAnimeByStatus(
+    fun getFavoritesByStatus(
         token: String,
         status: StatusFavourite,
         page: Int,
@@ -52,4 +52,7 @@ interface UserRepository {
         episodeNumber: Int,
         progress: AnimeEpisodeProgressRequest,
     )
+
+    fun deleteFavorite(token: String, url: String)
+    fun deleteRating(token: String, url: String)
 }

src/main/kotlin/club/anifox/backend/service/user/UserService.kt

@@ -22,7 +22,22 @@ class UserService(
         rating: Int,
         response: HttpServletResponse,
     ) {
-        animeRatingComponent.addRating(token = token, url = url, rating = rating, response = response)
+        animeRatingComponent.addRating(
+            token = token,
+            url = url,
+            rating = rating,
+            response = response,
+        )
+    }
+
+    override fun deleteRating(
+        token: String,
+        url: String,
+    ) {
+        animeRatingComponent.deleteRating(
+            token = token,
+            url = url,
+        )
     }
 
     override fun changeEpisodeProgress(
@@ -31,49 +46,87 @@ class UserService(
         episodeNumber: Int,
         progress: AnimeEpisodeProgressRequest,
     ) {
-        userAnimeInteractionsComponent.changeEpisodeProgress(token, url, episodeNumber, progress)
+        userAnimeInteractionsComponent.changeEpisodeProgress(
+            token = token,
+            url = url,
+            episodeNumber = episodeNumber,
+            progress = progress,
+        )
     }
 
-    override fun getRecentlyAnimeAll(
+    override fun getRecently(
         token: String,
         page: Int,
         limit: Int,
     ): List<AnimeLight> {
-        return userAnimeInteractionsComponent.getRecentlyAnimeList(token = token, page = page, limit = limit)
+        return userAnimeInteractionsComponent.getRecentlyAnimeList(
+            token = token,
+            page = page,
+            limit = limit,
+        )
     }
 
     override fun updatePreferredGenres(
         token: String,
         genres: List<String>,
         response: HttpServletResponse,
     ) {
-        return userAnimeInteractionsComponent.updatePreferredGenres(token = token, genres = genres, response = response)
+        return userAnimeInteractionsComponent.updatePreferredGenres(
+            token = token,
+            genres = genres,
+            response = response,
+        )
     }
 
     override fun getRecommendations(
         token: String,
         page: Int,
         limit: Int,
     ): List<AnimeLight> {
-        return userAnimeInteractionsComponent.getRecommendations(token = token, page = page, limit = limit)
+        return userAnimeInteractionsComponent.getRecommendations(
+            token = token,
+            page = page,
+            limit = limit,
+        )
     }
 
-    override fun addToFavoritesAnime(
+    override fun addToFavorites(
         token: String,
         url: String,
         status: StatusFavourite,
         episodesWatched: Int?,
         response: HttpServletResponse,
     ) {
-        animeFavoriteStatusService.addToFavorites(token = token, url = url, status = status, episodesWatched = episodesWatched, response = response)
+        animeFavoriteStatusService.addToFavorites(
+            token = token,
+            url = url,
+            status = status,
+            episodesWatched = episodesWatched,
+            response = response,
+        )
+    }
+
+    override fun deleteFavorite(
+        token: String,
+        url: String,
+    ) {
+        animeFavoriteStatusService.deleteFavorite(
+            token = token,
+            url = url,
+        )
     }
 
-    override fun getFavoritesAnimeByStatus(
+    override fun getFavoritesByStatus(
         token: String,
         status: StatusFavourite,
         page: Int,
         limit: Int,
     ): List<AnimeLight> {
-        return animeFavoriteStatusService.getFavoritesByStatus(token = token, status = status, page = page, limit = limit)
+        return animeFavoriteStatusService.getFavoritesByStatus(
+            token = token,
+            status = status,
+            page = page,
+            limit = limit,
+        )
     }
 }

src/main/kotlin/club/anifox/backend/service/user/component/favourite/AnimeFavoriteStatusComponent.kt

@@ -74,6 +74,26 @@ class AnimeFavoriteStatusComponent(
         }
     }
 
+    @Transactional
+    fun deleteFavorite(
+        token: String,
+        url: String,
+    ) {
+        val user = userUtils.checkUser(token)
+        val anime = animeUtils.checkAnime(url)
+        val existingFavorite = userFavoriteAnimeRepository.findByUserAndAnime(user, anime)
+
+        if (existingFavorite.isPresent) {
+            val existFavorite = existingFavorite.get()
+
+            updateStatusWithRetry(anime, existFavorite.status, null)
+            userFavoriteAnimeRepository.delete(existFavorite)
+            userFavoriteAnimeRepository.flush()
+        } else {
+            throw NotFoundException("favourite not found")
+        }
+    }
+
     fun getFavoritesByStatus(
         token: String,
         status: StatusFavourite,
@@ -89,7 +109,7 @@ class AnimeFavoriteStatusComponent(
 
         return favoriteAnime.takeIf { it.isNotEmpty() }
             ?.map { it.anime.toAnimeLight() }
-            ?: throw NotFoundException("The user has no favourite anime")
+            ?: throw NotFoundException("favourite not found")
     }
 
     @Transactional

src/main/kotlin/club/anifox/backend/service/user/component/rating/AnimeRatingComponent.kt

@@ -1,5 +1,6 @@
 package club.anifox.backend.service.user.component.rating
 
+import club.anifox.backend.domain.exception.common.NotFoundException
 import club.anifox.backend.jpa.entity.anime.AnimeRatingDistributionTable
 import club.anifox.backend.jpa.entity.anime.AnimeRatingTable
 import club.anifox.backend.jpa.entity.anime.AnimeTable
@@ -70,6 +71,25 @@ class AnimeRatingComponent(
         }
     }
 
+    @Transactional
+    fun deleteRating(
+        token: String,
+        url: String,
+    ) {
+        val user = userUtils.checkUser(token)
+        val anime = animeUtils.checkAnime(url)
+        val existingRating = userRatingRepository.findByUserAndAnime(user, anime)
+
+        if (existingRating.isPresent) {
+            val existRating = existingRating.get()
+            updateRatingWithRetry(anime, existRating.rating, null)
+            userRatingRepository.delete(existRating)
+            userRatingRepository.flush()
+        } else {
+            throw NotFoundException("rating not found")
+        }
+    }
+
     @Transactional
     protected fun processAnimeRatingUpdate(
         user: UserTable,