Code refactoring. Add support genres and actors to routes

database/crud/__init__.py

@@ -1,4 +1,11 @@
-from .games import *
-from .movies import *
-from .audiobooks import *
-from .users import *
+from .games import GamesCRUD as GamesCRUD
+from .game_genres import GameGenresCRUD as GameGenresCRUD
+
+from .movies import MoviesCRUD as MoviesCRUD
+from .movie_actors import MovieActorsCRUD as MovieActorsCRUD
+from .movie_genres import MovieGenresCRUD as MovieGenresCRUD
+
+from .audiobooks import AudiobooksCRUD as AudiobooksCRUD
+from .audiobook_genres import AudiobookGenresCRUD as AudiobookGenresCRUD
+
+from .users import UsersCRUD as UsersCRUD

database/crud/audiobook_genres.py

@@ -0,0 +1,19 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class AudiobookGenresCRUD(EntityCRUD[mdl.AudiobookGenre]):
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.AudiobookGenre)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.AudiobookGenreCreate):
+        audiobook_genre = mdl.AudiobookGenre(**info.model_dump())
+        return await Database.add(db, audiobook_genre)

database/crud/audiobooks.py

@@ -1,45 +1,46 @@
 from time import strftime
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.future import select
+
+from database.crud.audiobook_genres import AudiobookGenresCRUD
+from database.database import Database, EntityCRUD
 
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_audiobooks(db: AsyncSession):
-    return (await db.execute(select(mdl.Audiobook))).scalars().all()
+class AudiobooksCRUD(EntityCRUD[mdl.Audiobook]):
+    @staticmethod
+    async def get(db: AsyncSession, id: int):
+        return await Database.get(db, mdl.Audiobook, id)
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.Audiobook)
 
-async def get_audiobook(db: AsyncSession, audiobook_id: int):
-    return await db.get(mdl.Audiobook, audiobook_id)
+    @staticmethod
+    async def change_genres(db: AsyncSession, audiobook: mdl.Audiobook, info: sch.AudiobookCreate):
+        audiobook_genres = await AudiobookGenresCRUD.get_all(db)
+        if (info.genres):
+            audiobook.genres = [
+                genre for genre in audiobook_genres if genre.id in info.genres]
 
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.AudiobookCreate,
+                  owner_id: int):
+        audiobook = mdl.Audiobook(**info.model_dump(),
+                                  update_date=strftime("%Y-%m-%d %H:%M:%S"),
+                                  owner_id=owner_id)
+        await AudiobooksCRUD.change_genres(db, audiobook, info)
+        return await Database.add(db, audiobook)
 
-async def add_audiobook(db: AsyncSession,
-                        audiobook_info: sch.AudiobookCreate,
-                        user_id: int):
-    audiobook = mdl.Audiobook(**audiobook_info.model_dump(),
-                              update_date=strftime("%Y-%m-%d %H:%M:%S"),
-                              upload_date=strftime("%Y-%m-%d %H:%M:%S"),
-                              owner_id=user_id)
-    return await add_transaction(db, audiobook)
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.AudiobookCreate):
+        return await Database.change(db, mdl.Audiobook, id, info, AudiobooksCRUD.change_genres)
 
-
-async def edit_audiobook(db: AsyncSession,
-                         audiobook_id: int,
-                         audiobook_info: sch.AudiobookCreate):
-    audiobook = await db.get(mdl.Audiobook, audiobook_id)
-    for key, value in vars(audiobook_info).items():
-        if (getattr(audiobook, key) != value):
-            setattr(audiobook, key, value)
-    setattr(audiobook, "update_date", strftime("%Y-%m-%d %H:%M:%S"))
-    await db.commit()
-    return audiobook
-
-
-async def delete_audiobook(db: AsyncSession,
-                           audiobook_id: int):
-    audiobook = await get_audiobook(db, audiobook_id)
-    await db.delete(audiobook)
-    await db.commit()
-    return audiobook
+    @staticmethod
+    async def delete(db: AsyncSession,
+                     id: int):
+        return await Database.delete(db, mdl.Audiobook, id)

database/crud/game_genres.py

@@ -0,0 +1,20 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class GameGenresCRUD(EntityCRUD[mdl.GameGenre]):
+
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.GameGenre)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.GameGenreCreate):
+        game_genre = mdl.GameGenre(**info.model_dump())
+        return await Database.add(db, game_genre)

database/crud/games.py

@@ -1,46 +1,46 @@
 from time import strftime
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.future import select
-from sqlalchemy.orm import selectinload
+
+from database.crud.game_genres import GameGenresCRUD
+from database.database import Database, EntityCRUD
 
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_games(db: AsyncSession):
-    return (await db.execute(select(mdl.Game))).scalars().all()
+class GamesCRUD(EntityCRUD[mdl.Game]):
+    @staticmethod
+    async def get(db: AsyncSession, id: int):
+        return await Database.get(db, mdl.Game, id)
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.Game)
 
-async def get_game(db: AsyncSession, game_id: int):
-    return await db.get(mdl.Game, game_id)
+    @staticmethod
+    async def change_genres(db: AsyncSession, game: mdl.Game, info: sch.GameCreate):
+        game_genres = await GameGenresCRUD.get_all(db)
+        if (info.genres):
+            game.genres = [
+                genre for genre in game_genres if genre.id in info.genres]
 
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.GameCreate,
+                  owner_id: int):
+        game = mdl.Game(**info.model_dump(),
+                        update_date=strftime("%Y-%m-%d %H:%M:%S"),
+                        owner_id=owner_id)
+        await GamesCRUD.change_genres(db, game, info)
+        return await Database.add(db, game)
 
-async def add_game(db: AsyncSession,
-                   game_info: sch.GameCreate,
-                   user_id: int):
-    game = mdl.Game(**game_info.model_dump(),
-                    update_date=strftime("%Y-%m-%d %H:%M:%S"),
-                    upload_date=strftime("%Y-%m-%d %H:%M:%S"),
-                    owner_id=user_id)
-    return await add_transaction(db, game)
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.GameCreate):
+        return await Database.change(db, mdl.Game, id, info, GamesCRUD.change_genres)
 
-
-async def edit_game(db: AsyncSession,
-                    game_id: int,
-                    game_info: sch.GameCreate):
-    game = await db.get(mdl.Game, game_id)
-    for key, value in vars(game_info).items():
-        if (getattr(game, key) != value):
-            setattr(game, key, value)
-    setattr(game, "update_date", strftime("%Y-%m-%d %H:%M:%S"))
-    await db.commit()
-    return game
-
-
-async def delete_game(db: AsyncSession,
-                      game_id: int):
-    game = await get_game(db, game_id)
-    await db.delete(game)
-    await db.commit()
-    return game
+    @staticmethod
+    async def delete(db: AsyncSession,
+                     id: int):
+        return await Database.delete(db, mdl.Game, id)

database/crud/movie_actors.py

@@ -0,0 +1,19 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class MovieActorsCRUD(EntityCRUD[mdl.MovieActor]):
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.MovieActor)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.MovieActorCreate):
+        movie_actor = mdl.MovieActor(**info.model_dump())
+        return await Database.add(db, movie_actor)

database/crud/movie_genres.py

@@ -0,0 +1,19 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class MovieGenresCRUD(EntityCRUD[mdl.MovieGenre]):
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.MovieGenre)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.MovieGenreCreate):
+        movie_genre = mdl.MovieGenre(**info.model_dump())
+        return await Database.add(db, movie_genre)

database/crud/movies.py

@@ -1,45 +1,58 @@
 from time import strftime
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.future import select
+
+from database.crud.movie_actors import MovieActorsCRUD
+from database.crud.movie_genres import MovieGenresCRUD
+from database.database import Database, EntityCRUD
 
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_movies(db: AsyncSession):
-    return (await db.execute(select(mdl.Movie))).scalars().all()
+class MoviesCRUD(EntityCRUD[mdl.Movie]):
+    @staticmethod
+    async def get(db: AsyncSession, id: int):
+        return await Database.get(db, mdl.Movie, id)
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.Movie)
 
-async def get_movie(db: AsyncSession, movie_id: int):
-    return await db.get(mdl.Movie, movie_id)
+    @staticmethod
+    async def change_actors(db: AsyncSession, movie: mdl.Movie, info: sch.MovieCreate):
+        movie_actors = await MovieActorsCRUD.get_all(db)
+        if (info.actors):
+            movie.actors = [
+                actor for actor in movie_actors if actor.id in info.actors]
 
+    @staticmethod
+    async def change_genres(db: AsyncSession, movie: mdl.Movie, info: sch.MovieCreate):
+        movie_genres = await MovieGenresCRUD.get_all(db)
+        if (info.genres):
+            movie.genres = [
+                genre for genre in movie_genres if genre.id in info.genres]
 
-async def add_movie(db: AsyncSession,
-                    movie_info: sch.MovieCreate,
-                    user_id: int):
-    movie = mdl.Movie(**movie_info.model_dump(),
-                      update_date=strftime("%Y-%m-%d %H:%M:%S"),
-                      upload_date=strftime("%Y-%m-%d %H:%M:%S"),
-                      owner_id=user_id)
-    return await add_transaction(db, movie)
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.MovieCreate,
+                  owner_id: int):
+        movie = mdl.Movie(**info.model_dump(),
+                          update_date=strftime("%Y-%m-%d %H:%M:%S"),
+                          owner_id=owner_id)
+        await MoviesCRUD.change_genres(db, movie, info)
+        await MoviesCRUD.change_actors(db, movie, info)
+        return await Database.add(db, movie)
 
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.MovieCreate):
+        async def additional_change(db: AsyncSession, movie: mdl.Movie, info: sch.MovieCreate):
+            await MoviesCRUD.change_genres(db, movie, info)
+            await MoviesCRUD.change_actors(db, movie, info)
+        return await Database.change(db, mdl.Movie, id, info, additional_change)
 
-async def edit_movie(db: AsyncSession,
-                     movie_id: int,
-                     movie_info: sch.MovieCreate):
-    movie = await db.get(mdl.Movie, movie_id)
-    for key, value in vars(movie_info).items():
-        if (getattr(movie, key) != value):
-            setattr(movie, key, value)
-    setattr(movie, "update_date", strftime("%Y-%m-%d %H:%M:%S"))
-    await db.commit()
-    return movie
-
-
-async def delete_movie(db: AsyncSession,
-                       movie_id: int):
-    movie = await get_movie(db, movie_id)
-    await db.delete(movie)
-    await db.commit()
-    return movie
+    @staticmethod
+    async def delete(db: AsyncSession,
+                     id: int):
+        return await Database.delete(db, mdl.Movie, id)

database/crud/users.py

@@ -1,26 +1,45 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 
+from database.database import Database, EntityCRUD
+
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_user(db: AsyncSession, username: str):
-    return (await db.execute(select(mdl.User).where(mdl.User.name == username))).scalar()
+class UsersCRUD(EntityCRUD[mdl.User]):
+    @staticmethod
+    async def get(db: AsyncSession, username: str):
+        return (await db.execute(select(mdl.User).where(mdl.User.name == username))).scalar()
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.User)
 
-async def add_user(db: AsyncSession,
-                   user_data: sch.UserCreate, hash_of_password: str):
-    user_data_db = \
-        {k: v for k, v in user_data.model_dump().items()
-         if k != "password"}
-    user = mdl.User(**user_data_db,
-                    hash_of_password=hash_of_password)
-    return await add_transaction(db, user)
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.UserCreate,
+                  hash_of_password: str):
+        user_data_db = \
+            {k: v for k, v in info.model_dump().items()
+             if k != "password"}
+        user = mdl.User(**user_data_db,
+                        hash_of_password=hash_of_password)
+        return await Database.add(db, user)
 
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.UserCreate):
+        return await Database.change(db, mdl.User, id, info)
 
-async def check_email(db: AsyncSession, email: str):
-    users = (await db.execute(select(mdl.User)
-                              .where(mdl.User.email == email))).scalars().all()
-    return True if len(users) == 0 else False
+    @staticmethod
+    async def delete_user(db: AsyncSession,
+                          id: int):
+        return await Database.delete(db, mdl.User, id)
+
+    @staticmethod
+    async def check_email(db: AsyncSession, email: str):
+        users = (await db.execute(select(mdl.User)
+                                  .where(mdl.User.email == email))).scalars().all()
+        return True if len(users) == 0 else False