Feature/rework caching

app/api/api_v1/genres/list_views.py

@@ -36,12 +36,12 @@ async def get_genres(
     ],
 )
 async def search_genres_by_name(
-    genre_name: str,
+    search_query: str,
     genre_cache_service: GenreCacheServiceDep,
     size: PaginationSizeDep = 10,
     page: PaginationPageDep = 1,
 ) -> GenreResponseList:
-    return await genre_cache_service.search_genres_by_name(genre_name, size, page)
+    return await genre_cache_service.search_genres_by_name(search_query, size, page)
 
 
 @router.post(

app/api/api_v1/movies/list_views.py

@@ -11,7 +11,6 @@
 from schemas.movie import (
     MovieCreate,
     MovieFilter,
-    MovieResponseList,
     MovieWithGenreResponse,
     MovieWithGenreResponseList,
 )
@@ -49,8 +48,7 @@ async def watch_movie(
     movie_cache_service: MovieCacheServiceDep,
 ) -> RedirectResponse:
     movie = await movie_cache_service.watch_movie(user_id, create_watch_history_data)
-    url = BASE_MINIO_URL + movie.source_url
-    return RedirectResponse(url=url)
+    return RedirectResponse(url=movie.source_url)
 
 
 @router.post(
@@ -74,23 +72,6 @@ async def search_movies_with_filters(
     )
 
 
-@router.get(
-    "/genre/{genre_id}",
-    response_model=MovieResponseList,
-    status_code=status.HTTP_200_OK,
-    dependencies=[
-        Depends(check_rate_limit_not_auth),
-    ],
-)
-async def get_movies_by_genre_id(
-    genre_id: int,
-    movie_cache_service: MovieCacheServiceDep,
-    size: PaginationSizeDep = 10,
-    page: PaginationPageDep = 1,
-) -> MovieResponseList:
-    return await movie_cache_service.get_movies_by_genre_id(genre_id, size, page)
-
-
 @router.post(
     "/",
     response_model=MovieWithGenreResponse,

app/cache_services/favorite_movie.py

@@ -1,8 +1,12 @@
+import asyncio
 from typing import cast
 
+from core.constants import CacheEntity
+from core.redis.cache_key_service import CacheKeyService
 from core.redis.service import RedisService
 from schemas.favorite_movie import (
     FavoriteMovieCreate,
+    FavoriteMovieResponse,
     FavoriteMovieWithMovieResponse,
     FavoriteMovieWithMovieResponseList,
 )
@@ -13,24 +17,28 @@ class FavoriteMovieCacheService:
     def __init__(
         self,
         favorite_movie_service: FavoriteMovieService,
-        cache_service: RedisService,
+        redis_service: RedisService,
+        cache_key_service: CacheKeyService,
     ) -> None:
         self.favorite_movie_service = favorite_movie_service
-        self.cache_service = cache_service
+        self.redis_service = redis_service
+        self.cache_key_service = cache_key_service
 
     async def get_favorite_movies_by_user_id(
         self,
         user_id: int,
         size: int = 10,
         page: int = 1,
     ) -> FavoriteMovieWithMovieResponseList:
-        key = self.cache_service.create_cache_key(
-            "favorite movies",
+        key = await self.cache_key_service.build_list_key(
+            entity=CacheEntity.favorite_movie,
+            action="get",
+            version_params={"user_id": user_id},
             user_id=user_id,
-            size=size,
             page=page,
+            size=size,
         )
-        cached_favorite_movies_response = await self.cache_service.get(
+        cached_favorite_movies_response = await self.redis_service.get(
             key,
             FavoriteMovieWithMovieResponseList,
         )
@@ -48,22 +56,23 @@ async def get_favorite_movies_by_user_id(
             )
         )
 
-        await self.cache_service.set(
+        await self.redis_service.set(
             key,
             favorite_movies_response,
-            ttl=1800,
+            ttl=24 * 60 * 60,
         )
         return favorite_movies_response
 
     async def get_favorite_movie_by_id(
         self,
         favorite_movie_id: int,
     ) -> FavoriteMovieWithMovieResponse:
-        key = self.cache_service.create_cache_key(
-            "favorite movie",
-            favorite_movie_id=favorite_movie_id,
+        key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=favorite_movie_id,
+            action="get",
         )
-        cached_favorite_movie_response = await self.cache_service.get(
+        cached_favorite_movie_response = await self.redis_service.get(
             key,
             FavoriteMovieWithMovieResponse,
         )
@@ -75,41 +84,58 @@ async def get_favorite_movie_by_id(
                 favorite_movie_id,
             )
         )
-        await self.cache_service.set(key, favorite_movie_response, ttl=1800)
+        await self.redis_service.set(
+            key,
+            favorite_movie_response,
+            ttl=5 * 60,
+        )
         return favorite_movie_response
 
     async def count_favorites_by_movie(self, movie_id: int) -> int:
-        key = self.cache_service.create_cache_key(
-            "favorite movie:count",
-            movie_id=movie_id,
+        key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=movie_id,
+            action="get-count",
         )
-        cached_favorite_movie_response = await self.cache_service.get(key)
+        cached_favorite_movie_response = await self.redis_service.get(key)
         if cached_favorite_movie_response is not None:
             return cast(int, cached_favorite_movie_response)
 
         favorite_movie_response = (
             await self.favorite_movie_service.count_favorites_by_movie(movie_id)
         )
-        await self.cache_service.set(key, favorite_movie_response, ttl=1800)
+        await self.redis_service.set(
+            key,
+            favorite_movie_response,
+            ttl=24 * 60 * 60,
+        )
         return favorite_movie_response
 
     async def check_favorite_movie_status(self, user_id: int, movie_id: int) -> bool:
-        # key = self.cache_service.create_cache_key(
-        #     "favorite movie:status",
-        #     user_id=user_id,
-        #     movie_id=movie_id,
-        # )
-        # cached_favorite_movie_response = await self.cache_service.get(key)
-        # if cached_favorite_movie_response is not None:
-        #     return cast(bool, cached_favorite_movie_response)
+        entity_id = (user_id, movie_id)
+        key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=entity_id,
+            action="get-status",
+        )
+        cached_favorite_movie_response = await self.redis_service.get(
+            key,
+            is_boolean=True,
+        )
+        if cached_favorite_movie_response is not None:
+            return cast(bool, cached_favorite_movie_response)
 
         favorite_movie_response = (
             await self.favorite_movie_service.check_favorite_movie_status(
                 user_id,
                 movie_id,
             )
         )
-        # await self.cache_service.set(key, favorite_movie_response, ttl=1800)
+        await self.redis_service.set(
+            key,
+            favorite_movie_response,
+            ttl=24 * 60 * 60,
+        )
         return favorite_movie_response
 
     async def create_user_favorite_movie(
@@ -123,32 +149,97 @@ async def create_user_favorite_movie(
                 create_favorite_movie_data,
             )
         )
-        key = self.cache_service.create_cache_key(
-            "favorite movie",
+
+        movie_id = favorite_movie_response.movie_id
+        entity_id = (user_id, movie_id)
+        favorite_movie_status_key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=entity_id,
+            action="get-status",
+        )
+        count_favorite_movie_key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=movie_id,
+            action="get-count",
+        )
+        await asyncio.gather(
+            self.cache_key_service.invalidate_list_keys(
+                entity=CacheEntity.favorite_movie,
+                user_id=user_id,
+            ),
+            self.redis_service.delete(favorite_movie_status_key),
+            self.redis_service.incr_by(
+                count_favorite_movie_key,
+                amount=1,
+            ),
         )
-        pattern = key + "*"
-        await self.cache_service.delete_by_pattern(pattern)
         return favorite_movie_response
 
     async def delete_favorite_movie_by_id(
         self,
         user_id: int,
         favorite_movie_id: int,
-    ) -> None:
-        await self.favorite_movie_service.delete_favorite_movie_by_id(
+    ) -> FavoriteMovieResponse:
+        favorite_movie = await self.favorite_movie_service.delete_favorite_movie_by_id(
             user_id,
             favorite_movie_id,
         )
-        key = self.cache_service.create_cache_key(
-            "favorite movie",
+
+        movie_id = favorite_movie.movie_id
+        entity_id = (user_id, movie_id)
+        favorite_movie_status_key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=entity_id,
+            action="get-status",
+        )
+        count_favorite_movie_key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=movie_id,
+            action="get-count",
+        )
+        await asyncio.gather(
+            self.cache_key_service.invalidate_list_keys(
+                entity=CacheEntity.favorite_movie,
+                user_id=user_id,
+            ),
+            self.redis_service.delete(favorite_movie_status_key),
+            self.redis_service.incr_by(
+                count_favorite_movie_key,
+                amount=-1,
+            ),
+        )
+        return favorite_movie
+
+    async def delete_user_favorite_movie(
+        self,
+        user_id: int,
+        movie_id: int,
+    ) -> FavoriteMovieResponse:
+        favorite_movie = await self.favorite_movie_service.delete_user_favorite_movie(
+            user_id,
+            movie_id,
         )
-        pattern = key + "*"
-        await self.cache_service.delete_by_pattern(pattern)
 
-    async def delete_user_favorite_movie(self, user_id: int, movie_id: int) -> None:
-        await self.favorite_movie_service.delete_user_favorite_movie(user_id, movie_id)
-        key = self.cache_service.create_cache_key(
-            "favorite movie",
+        entity_id = (user_id, movie_id)
+        favorite_movie_status_key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=entity_id,
+            action="get-status",
+        )
+        count_favorite_movie_key = self.cache_key_service.build_item_key(
+            entity=CacheEntity.favorite_movie,
+            entity_id=movie_id,
+            action="get-count",
+        )
+        await asyncio.gather(
+            self.cache_key_service.invalidate_list_keys(
+                entity=CacheEntity.favorite_movie,
+                user_id=user_id,
+            ),
+            self.redis_service.delete(favorite_movie_status_key),
+            self.redis_service.incr_by(
+                count_favorite_movie_key,
+                amount=-1,
+            ),
         )
-        pattern = key + "*"
-        await self.cache_service.delete_by_pattern(pattern)
+        return favorite_movie