Добавляет функционал для работы с вопросами

backend/src/game/dependencies.py

@@ -1,11 +1,13 @@
 from repository.level_repository import LevelRepository
 from repository.map_repository import MapRepository
 from repository.module_repository import ModuleRepository
+from repository.question_repository import QuestionRepository
 from repository.task_unit_repository import TaskUnitRepository
 from repository.theory_unit_repository import TheoryUnitRepository
 from services.level_service import LevelService
 from services.map_service import MapService
 from services.module_service import ModuleService
+from services.question_service import QuestionService
 from services.task_unit_service import TaskUnitService
 from services.theory_unit_service import TheoryUnitService
 
@@ -28,5 +30,9 @@ def task_unit_service() -> TaskUnitService:
 
 def theory_unit_service() -> TheoryUnitService:
     return TheoryUnitService(TheoryUnitRepository)
+
+
+def question_service() -> QuestionService:
+    return QuestionService(QuestionRepository)
 # def users_service():
 #     return UsersService(UsersRepository)

backend/src/game/units/tasks/questions/models.py

@@ -22,13 +22,13 @@ class Question(BaseModel):
     type: Mapped[QuestionTypes] = mapped_column(
         postgresql.ENUM(QuestionTypes, name='question_types'), nullable=False, default=QuestionTypes.SingleChoice)
     question: Mapped[str] = mapped_column(String, nullable=False, default="Вопрос!")
-    correct_answer_id: Mapped[uuid.UUID] = mapped_column(UUID, default=uuid.uuid4)
 
     task: Mapped["TaskUnit"] = relationship(back_populates='questions')
     possible_answers: Mapped[list["AnswerOption"]] = relationship(back_populates='question', lazy='selectin')
 
     def to_read_schema(self) -> QuestionRead:
         return QuestionRead(id=self.id,
+                            type=self.type,
                             task_id=self.task_id,
                             question=self.question,
-                            possible_answers=self.possible_answers)
+                            possible_answers=[model.to_read_schema() for model in self.possible_answers])

backend/src/game/units/tasks/questions/router.py

@@ -3,31 +3,34 @@
 from fastapi import APIRouter
 
 from game.units.tasks.questions.schemas import QuestionRead, QuestionCreate, QuestionUpdate
+from utils.types import QuestionServiceType
 
 router = APIRouter(tags=["Questions"])
 
 
 @router.get('/questions/', tags=["Dev"])
-async def root() -> list[QuestionRead]:
-    return []
+async def root(question_service: QuestionServiceType) -> list[QuestionRead]:
+    return await question_service.get_all()
 
 
 @router.post('/maps/{map_id}/modules/{module_id}/levels/{level_id}/tasks/{task_id}/')
 async def post_question_to_task_unit(map_id: UUID,
                                      module_id: UUID,
                                      level_id: UUID,
                                      task_id: UUID,
-                                     question_create: QuestionCreate) -> QuestionRead:
-    return QuestionRead()
+                                     question_create: QuestionCreate,
+                                     question_service: QuestionServiceType) -> QuestionRead:
+    return await question_service.create_one(task_id, question_create)
 
 
 @router.delete("/maps/{map_id}/modules/{module_id}/levels/{level_id}/tasks/{task_id}/questions/{question_id}/")
 async def delete_question_from_task_unit(map_id: UUID,
                                          module_id: UUID,
                                          level_id: UUID,
                                          task_id: UUID,
-                                         question_id: UUID) -> QuestionRead:
-    return QuestionRead()
+                                         question_id: UUID,
+                                         question_service: QuestionServiceType) -> QuestionRead:
+    return await question_service.delete_one(question_id)
 
 
 @router.patch("/maps/{map_id}/modules/{module_id}/levels/{level_id}/tasks/{task_id}/questions/{question_id}/")
@@ -36,5 +39,6 @@ async def update_question_in_task_unit(map_id: UUID,
                                        level_id: UUID,
                                        task_id: UUID,
                                        question_id: UUID,
-                                       question_update: QuestionUpdate) -> QuestionRead:
-    return QuestionRead()
+                                       question_update: QuestionUpdate,
+                                       question_service: QuestionServiceType) -> QuestionRead:
+    return await question_service.update_one(question_id, question_update)

backend/src/game/units/tasks/questions/schemas.py

@@ -7,14 +7,14 @@
 
 
 class __QuestionBase(BaseModel):
-    task_id: UUID
     type: QuestionTypes
     question: str
 
     model_config = ConfigDict(from_attributes=True)
 
 
 class QuestionRead(__QuestionBase):
+    task_id: UUID
     id: UUID
     possible_answers: list[AnswerOptionRead]
 

backend/src/repository/question_repository.py

@@ -0,0 +1,27 @@
+import typing
+import uuid
+
+from sqlalchemy import insert
+
+from database import async_session_maker
+from game.units.tasks.questions import Question
+from game.units.tasks.questions.answers import AnswerOption
+from repository.sqlalchemy_repository import SQLAlchemyRepository
+
+
+class QuestionRepository(SQLAlchemyRepository):
+    model = Question
+
+    async def add_one(self, model: dict[str, typing.Any]) -> Question:
+        async with async_session_maker() as session:
+            question_to_add = Question(type=model['type'],
+                                       question=model['question'],
+                                       task_id=model['task_id'])
+            possible_answers = [AnswerOption(**answer_option_schema, question_id=question_to_add.id) for
+                                answer_option_schema in model['possible_answers']]
+            for ap in possible_answers:
+                question_to_add.possible_answers.append(ap)
+            session.add(question_to_add)
+            await session.commit()
+            await session.refresh(question_to_add)
+            return question_to_add

backend/src/services/question_service.py

@@ -0,0 +1,33 @@
+import uuid
+
+from game.units.tasks.questions.schemas import QuestionRead, QuestionCreate, QuestionUpdate
+from repository.abstract import AbstractRepository
+
+
+class QuestionService:
+    __question_repo: AbstractRepository
+
+    def __init__(self, map_repo: type[AbstractRepository]):
+        self.__question_repo = map_repo()
+
+    async def create_one(self, task_id: uuid.UUID, schema_create: QuestionCreate) -> QuestionRead:
+        schema_dict = schema_create.model_dump()
+        schema_dict['task_id'] = task_id
+        return await self.__question_repo.add_one(schema_dict)
+
+    async def get_all(self) -> list[QuestionRead]:
+        models = await self.__question_repo.find_all()
+        return [model.to_read_schema() for model in models]
+
+    async def get_one(self, id: uuid.UUID) -> QuestionRead:
+        res = await self.__question_repo.get_one(id)
+        return res.to_read_schema()
+
+    async def delete_one(self, id: uuid.UUID) -> QuestionRead:
+        res = await self.__question_repo.delete_one(id)
+        return res.to_read_schema()
+
+    async def update_one(self, id: uuid.UUID, schema_update: QuestionUpdate) -> QuestionRead:
+        schema_dict = schema_update.model_dump()
+        res = await self.__question_repo.update_one(id, schema_dict)
+        return res.to_read_schema()

backend/src/utils/types.py

@@ -5,10 +5,12 @@
 
 from auth.base_config import current_user, current_superuser
 from database import get_async_session
-from game.dependencies import map_service, module_service, level_service, task_unit_service, theory_unit_service
+from game.dependencies import map_service, module_service, level_service, task_unit_service, theory_unit_service, \
+    question_service
 from services.level_service import LevelService
 from services.map_service import MapService
 from services.module_service import ModuleService
+from services.question_service import QuestionService
 from services.task_unit_service import TaskUnitService
 from services.theory_unit_service import TheoryUnitService
 from users.models import User
@@ -21,6 +23,7 @@
 LevelServiceType = Annotated[LevelService, Depends(level_service)]
 TaskUnitServiceType = Annotated[TaskUnitService, Depends(task_unit_service)]
 TheoryUnitServiceType = Annotated[TheoryUnitService, Depends(theory_unit_service)]
+QuestionServiceType = Annotated[QuestionService, Depends(question_service)]
 
 # AsyncDBSession = Annotated[AsyncSession, Depends(get_async_session)]
 # QueryDBLimit = Annotated[int, Query(ge=0, le=10 ** 3)]