Merge branch 'backend' into frontend

backend/src/game/units/theory/models.py

@@ -23,7 +23,7 @@ class TheoryUnit(BaseModel):
     # videos: Mapped[list["TheoryVideo"]] = relationship(back_populates="theory_block")
     level: Mapped[list["Level"]] = relationship(back_populates='theory_units')
 
-    def to_read_model(self) -> TheoryUnitRead:
+    def to_read_schema(self) -> TheoryUnitRead:
         return TheoryUnitRead(id=self.id,
                               title=self.title,
                               content=self.content)

backend/src/repository/sqlalchemy_repository.py

@@ -10,7 +10,7 @@
 class SQLAlchemyRepository(AbstractRepository):
     model = None
 
-    async def add_one(self, model: dict[str, typing.Any]) -> uuid.UUID:
+    async def add_one(self, model: dict[str, typing.Any]) -> model:
         async with async_session_maker() as session:
             stmt = insert(self.model).values(**model).returning(self.model)
             res = await session.execute(stmt)

backend/src/services/level_service.py

@@ -7,8 +7,8 @@
 class LevelService:
     __level_repo: AbstractRepository
 
-    def __init__(self, level_repo: type[AbstractRepository]):
-        self.__level_repo = level_repo()
+    def __init__(self, repository: type[AbstractRepository]):
+        self.__level_repo = repository()
 
     async def create_one(self, level_create: LevelCreate) -> LevelRead:
         level_dict = level_create.model_dump()

backend/src/services/map_service.py

@@ -7,16 +7,16 @@
 class MapService:
     __map_repo: AbstractRepository
 
-    def __init__(self, map_repo: type[AbstractRepository]):
-        self.__map_repo = map_repo()
+    def __init__(self, repository: type[AbstractRepository]):
+        self.__map_repo = repository()
 
-    async def create_one(self, map_create: MapCreate) -> MapRead:
-        map_dict = map_create.model_dump()
-        return await self.__map_repo.add_one(map_dict)
+    async def create_one(self, schema_create: MapCreate) -> MapRead:
+        schema_dict = schema_create.model_dump()
+        return await self.__map_repo.add_one(schema_dict)
 
     async def get_all(self) -> list[MapRead]:
-        maps = await self.__map_repo.find_all()
-        return [map_model.to_read_schema() for map_model in maps]
+        models = await self.__map_repo.find_all()
+        return [model.to_read_schema() for model in models]
 
     async def get_one(self, id: uuid.UUID) -> MapRead:
         res = await self.__map_repo.get_one(id)
@@ -26,7 +26,7 @@ async def delete_one(self, id: uuid.UUID) -> MapRead:
         res = await self.__map_repo.delete_one(id)
         return res.to_read_schema()
 
-    async def update_one(self, id: uuid.UUID, map_update: MapUpdate) -> MapRead:
-        map_dict = map_update.model_dump()
-        res = await self.__map_repo.update_one(id, map_dict)
+    async def update_one(self, id: uuid.UUID, schema_update: MapUpdate) -> MapRead:
+        schema_dict = schema_update.model_dump()
+        res = await self.__map_repo.update_one(id, schema_dict)
         return res.to_read_schema()

backend/src/services/module_service.py

@@ -7,12 +7,12 @@
 class ModuleService:
     __module_repo: AbstractRepository
 
-    def __init__(self, map_repo: type[AbstractRepository]):
-        self.__module_repo = map_repo()
+    def __init__(self, repository: type[AbstractRepository]):
+        self.__module_repo = repository()
 
-    async def create_one(self, module_create: ModuleCreate) -> ModuleRead:
-        module_dict = module_create.model_dump()
-        return await self.__module_repo.add_one(module_dict)
+    async def create_one(self, schema_create: ModuleCreate) -> ModuleRead:
+        schema_dict = schema_create.model_dump()
+        return await self.__module_repo.add_one(schema_dict)
 
     async def get_all(self) -> list[ModuleRead]:
         models = await self.__module_repo.find_all()
@@ -26,7 +26,7 @@ async def delete_one(self, id: uuid.UUID) -> ModuleRead:
         res = await self.__module_repo.delete_one(id)
         return res.to_read_schema()
 
-    async def update_one(self, id: uuid.UUID, module_update: ModuleUpdate) -> ModuleRead:
-        module_dict = module_update.model_dump()
-        res = await self.__module_repo.update_one(id, module_dict)
+    async def update_one(self, id: uuid.UUID, schema_update: ModuleUpdate) -> ModuleRead:
+        schema_dict = schema_update.model_dump()
+        res = await self.__module_repo.update_one(id, schema_dict)
         return res.to_read_schema()

backend/src/services/question_service.py

@@ -7,8 +7,8 @@
 class QuestionService:
     __question_repo: AbstractRepository
 
-    def __init__(self, map_repo: type[AbstractRepository]):
-        self.__question_repo = map_repo()
+    def __init__(self, repository: type[AbstractRepository]):
+        self.__question_repo = repository()
 
     async def create_one(self, task_id: uuid.UUID, schema_create: QuestionCreate) -> QuestionRead:
         schema_dict = schema_create.model_dump(include={'type', 'possible_answers', 'question'})

backend/src/services/task_unit_service.py

@@ -7,8 +7,8 @@
 class TaskUnitService:
     __task_unit_repo: AbstractRepository
 
-    def __init__(self, map_repo: type[AbstractRepository]):
-        self.__task_unit_repo = map_repo()
+    def __init__(self, repository: type[AbstractRepository]):
+        self.__task_unit_repo = repository()
 
     async def create_one(self, level_id: uuid.UUID, schema_create: TaskUnitCreate) -> TaskUnitRead:
         schema_dict = schema_create.model_dump()

backend/src/services/theory_unit_service.py

@@ -7,8 +7,8 @@
 class TheoryUnitService:
     __theory_unit_repo: AbstractRepository
 
-    def __init__(self, map_repo: type[AbstractRepository]):
-        self.__theory_unit_repo = map_repo()
+    def __init__(self, repository: type[AbstractRepository]):
+        self.__theory_unit_repo = repository()
 
     async def create_one(self, level_id: uuid.UUID, schema_create: TheoryUnitCreate) -> TheoryUnitRead:
         schema_dict = schema_create.model_dump()