Feature/fixes pr

.gitignore

@@ -12,4 +12,5 @@ node_modules/
 survey.json
 .coverage
 export_deta.py
+.DS_Store
 target/

classquiz/db/models.py

@@ -140,6 +140,8 @@ class QuizQuestion(BaseModel):
     answers: list[ABCDQuizAnswer] | RangeQuizAnswer | list[TextQuizAnswer] | list[VotingQuizAnswer] | str
     image: str | None = None
     hide_results: bool | None = False
+    youtube_url: str | None = None
+    music: str | None = None
 
     @field_validator("answers")
     def answers_not_none_if_abcd_type(cls, v, info: ValidationInfo):
@@ -277,6 +279,7 @@ class AnswerData(BaseModel):
     right: bool
     time_taken: float  # In milliseconds
     score: int
+    total_score: int | None
 
 
 class AnswerDataList(RootModel):

classquiz/helpers/__init__.py

@@ -297,3 +297,12 @@ def extract_image_ids_from_quiz(quiz: Quiz) -> list[str | uuid.UUID]:
             continue
         quiz_images.append(question["image"])
     return quiz_images
+
+
+def extract_music_ids_from_quiz(quiz: Quiz) -> list[str | uuid.UUID]:
+    quiz_musics = []
+    for question in quiz.questions:
+        if question.get("music") is None:
+            continue
+        quiz_musics.append(question.get("music"))
+    return quiz_musics

classquiz/routers/box_controller/embedded/socket.py

@@ -52,13 +52,14 @@ async def submit_answer_fn(data_answer: int, game_pin: str, player_id: str, now:
     if answer_right:
         score = calculate_score(abs(diff), int(float(question.time)))
     await redis.set(f"answer_given:{player_id}:{game.current_question}", "True", ex=600)
-    await redis.hincrby(f"game_session:{game_pin}:player_scores", username, score)
+    total_score = await redis.hincrby(f"game_session:{game_pin}:player_scores", username, score)
     answer_data = AnswerData(
         username=username,
         answer=selected_answer,
         right=answer_right,
         time_taken=abs(diff),
         score=score,
+        total_score=total_score,
     )
     answers = await redis.get(f"game_session:{game_pin}:{game.current_question}")
     answers = await set_answer(answers, game_pin=game_pin, data=answer_data, q_index=game.current_question)

classquiz/routers/editor.py

@@ -19,7 +19,12 @@
 from datetime import datetime
 from uuid import UUID
 
-from classquiz.helpers import get_meili_data, check_image_string, extract_image_ids_from_quiz
+from classquiz.helpers import (
+    get_meili_data,
+    check_image_string,
+    extract_image_ids_from_quiz,
+    extract_music_ids_from_quiz,
+)
 from classquiz.storage.errors import DeletionFailedError
 
 settings = settings()
@@ -67,17 +72,82 @@ async def init_editor(edit: bool, quiz_id: Optional[UUID] = None, user: User = D
     return InitEditorResponse(token=edit_id)
 
 
-@router.post("/finish")
-async def finish_edit(edit_id: str, quiz_input: QuizInput):
-    session_data = await redis.get(f"edit_session:{edit_id}")
-    if session_data is None:
-        raise HTTPException(status_code=401, detail="Edit ID not found!")
-    session_data = EditSessionData.model_validate_json(session_data)
-    quiz_input.title = bleach.clean(quiz_input.title, tags=ALLOWED_TAGS_FOR_QUIZ, strip=True)
-    quiz_input.description = bleach.clean(quiz_input.description, tags=ALLOWED_TAGS_FOR_QUIZ, strip=True)
-    if quiz_input.background_color is not None:
-        quiz_input.background_color = bleach.clean(quiz_input.background_color, tags=[], strip=True)
+async def finish_edit_function(
+    old_quiz_data: Quiz,
+    edit_id: str,
+    quiz_input: QuizInput,
+    images_to_delete: list[str | uuid.UUID],
+    musics_to_delete: list[str | uuid.UUID],
+):
+    await arq.enqueue_job("quiz_update", old_quiz_data, old_quiz_data.id, _defer_by=2)
+    quiz = old_quiz_data
+    meilisearch.index(settings.meilisearch_index).update_documents([await get_meili_data(quiz)])
+    if not quiz_input.public:
+        meilisearch.index(settings.meilisearch_index).delete_document(str(quiz.id))
+    else:
+        meilisearch.index(settings.meilisearch_index).add_documents([await get_meili_data(quiz)])
+    quiz.title = quiz_input.title
+    quiz.public = quiz_input.public
+    quiz.description = quiz_input.description
+    quiz.updated_at = datetime.now()
+    quiz.questions = quiz_input.model_dump()["questions"]
+    quiz.cover_image = quiz_input.cover_image
+    quiz.background_color = quiz_input.background_color
+    quiz.background_image = quiz_input.background_image
+    quiz.mod_rating = None
+    for image in images_to_delete:
+        if image is not None:
+            try:
+                await storage.delete([image])
+            except DeletionFailedError:
+                pass
+    for music in musics_to_delete:
+        if music is not None:
+            try:
+                await storage.delete([music])
+            except DeletionFailedError:
+                pass
+    await redis.srem("edit_sessions", edit_id)
+    await redis.delete(f"edit_session:{edit_id}")
+    await redis.delete(f"edit_session:{edit_id}:images")
+    await quiz.update()
+    return quiz
+
+
+async def finish_create_function(session_data: EditSessionData, edit_id: str, quiz_input: QuizInput):
+    quiz = Quiz(
+        **quiz_input.model_dump(),
+        user_id=session_data.user_id,
+        id=session_data.quiz_id,
+        created_at=datetime.now(),
+        updated_at=datetime.now(),
+    )
 
+    await redis.delete("global_quiz_count")
+    if quiz_input.public:
+        meilisearch.index(settings.meilisearch_index).add_documents([await get_meili_data(quiz)])
+    try:
+        await redis.srem("edit_sessions", edit_id)
+        await redis.delete(f"edit_session:{edit_id}")
+        await redis.delete(f"edit_session:{edit_id}:images")
+        await quiz.save()
+    except asyncpg.exceptions.UniqueViolationError:
+        raise HTTPException(status_code=400, detail="The quiz already exists")
+    new_images = extract_image_ids_from_quiz(quiz)
+    new_musics = extract_music_ids_from_quiz(quiz)
+    for image in new_images:
+        item = await StorageItem.objects.get_or_none(id=uuid.UUID(image))
+        if item is None:
+            continue
+        await quiz.storageitems.add(item)
+    for music in new_musics:
+        item = await StorageItem.objects.get_or_none(id=uuid.UUID(music))
+        if item is None:
+            continue
+        await quiz.storageitems.add(item)
+
+
+def cleanup_questions(quiz_input: QuizInput):
     for i, question in enumerate(quiz_input.questions):
         if question.type == QuizQuestionType.ABCD:
             for i2, answer in enumerate(question.answers):
@@ -90,7 +160,22 @@ async def finish_edit(edit_id: str, quiz_input: QuizInput):
                         answer.answer, tags=ALLOWED_TAGS_FOR_QUIZ, strip=True
                     )
 
+
+@router.post("/finish")
+async def finish_edit(edit_id: str, quiz_input: QuizInput):
+    session_data = await redis.get(f"edit_session:{edit_id}")
+    if session_data is None:
+        raise HTTPException(status_code=401, detail="Edit ID not found!")
+    session_data = EditSessionData.model_validate_json(session_data)
+    quiz_input.title = bleach.clean(quiz_input.title, tags=ALLOWED_TAGS_FOR_QUIZ, strip=True)
+    quiz_input.description = bleach.clean(quiz_input.description, tags=ALLOWED_TAGS_FOR_QUIZ, strip=True)
+    if quiz_input.background_color is not None:
+        quiz_input.background_color = bleach.clean(quiz_input.background_color, tags=[], strip=True)
+
+    cleanup_questions(quiz_input)
+
     images_to_delete = []
+    musics_to_delete = []
     old_quiz_data: Quiz = await Quiz.objects.get_or_none(id=session_data.quiz_id, user_id=session_data.user_id)
 
     for i, question in enumerate(quiz_input.questions):
@@ -113,55 +198,6 @@ async def finish_edit(edit_id: str, quiz_input: QuizInput):
         raise HTTPException(status_code=400, detail="image url is not valid")
 
     if session_data.edit:
-        await arq.enqueue_job("quiz_update", old_quiz_data, old_quiz_data.id, _defer_by=2)
-        quiz = old_quiz_data
-        meilisearch.index(settings.meilisearch_index).update_documents([await get_meili_data(quiz)])
-        if not quiz_input.public:
-            meilisearch.index(settings.meilisearch_index).delete_document(str(quiz.id))
-        else:
-            meilisearch.index(settings.meilisearch_index).add_documents([await get_meili_data(quiz)])
-        quiz.title = quiz_input.title
-        quiz.public = quiz_input.public
-        quiz.description = quiz_input.description
-        quiz.updated_at = datetime.now()
-        quiz.questions = quiz_input.model_dump()["questions"]
-        quiz.cover_image = quiz_input.cover_image
-        quiz.background_color = quiz_input.background_color
-        quiz.background_image = quiz_input.background_image
-        quiz.mod_rating = None
-        for image in images_to_delete:
-            if image is not None:
-                try:
-                    await storage.delete([image])
-                except DeletionFailedError:
-                    pass
-        await redis.srem("edit_sessions", edit_id)
-        await redis.delete(f"edit_session:{edit_id}")
-        await redis.delete(f"edit_session:{edit_id}:images")
-        await quiz.update()
-        return quiz
+        return await finish_edit_function(old_quiz_data, edit_id, quiz_input, images_to_delete, musics_to_delete)
     else:
-        quiz = Quiz(
-            **quiz_input.model_dump(),
-            user_id=session_data.user_id,
-            id=session_data.quiz_id,
-            created_at=datetime.now(),
-            updated_at=datetime.now(),
-        )
-
-        await redis.delete("global_quiz_count")
-        if quiz_input.public:
-            meilisearch.index(settings.meilisearch_index).add_documents([await get_meili_data(quiz)])
-        try:
-            await redis.srem("edit_sessions", edit_id)
-            await redis.delete(f"edit_session:{edit_id}")
-            await redis.delete(f"edit_session:{edit_id}:images")
-            await quiz.save()
-        except asyncpg.exceptions.UniqueViolationError:
-            raise HTTPException(status_code=400, detail="The quiz already exists")
-        new_images = extract_image_ids_from_quiz(quiz)
-        for image in new_images:
-            item = await StorageItem.objects.get_or_none(id=uuid.UUID(image))
-            if item is None:
-                continue
-            await quiz.storageitems.add(item)
+        await finish_create_function(session_data, edit_id, quiz_input)

classquiz/routers/storage.py

@@ -84,7 +84,6 @@ async def get_basic_file_info(file_name: str) -> Response:
         item = await StorageItem.objects.get_or_none(id=checked_image_string[1])
         if item is None:
             raise HTTPException(status_code=404, detail="File not found")
-        # return PublicStorageItem.from_db_model(item)
         storage_file_name = item.storage_path
         if storage_file_name is None:
             storage_file_name = item.id.hex
@@ -103,7 +102,6 @@ async def download_file_head(file_name: str) -> Response:
         item = await StorageItem.objects.get_or_none(id=checked_image_string[1])
         if item is None:
             raise HTTPException(status_code=404, detail="File not found")
-        # return PublicStorageItem.from_db_model(item)
         storage_file_name = item.storage_path
         if storage_file_name is None:
             storage_file_name = item.id.hex
@@ -151,8 +149,10 @@ async def upload_raw_file(request: Request, user: User = Depends(get_current_use
     if user.storage_used > settings.free_storage_limit:
         raise HTTPException(status_code=409, detail="Storage limit reached")
     file_id = uuid4()
+    body_len = 0
     data_file = SpooledTemporaryFile(max_size=1000)
     async for chunk in request.stream():
+        body_len += len(chunk)
         data_file.write(chunk)
     data_file.seek(0)
     file_obj = StorageItem(
@@ -161,7 +161,43 @@ async def upload_raw_file(request: Request, user: User = Depends(get_current_use
         mime_type=request.headers.get("Content-Type"),
         hash=None,
         user=user,
-        size=0,
+        size=body_len,
+        deleted_at=None,
+        alt_text=None,
+    )
+    # https://github.com/VirusTotal/vt-py/issues/119#issuecomment-1261246867
+    await storage.upload(
+        file_name=file_id.hex,
+        # skipcq: PYL-W0212
+        file_data=data_file._file,
+        mime_type=request.headers.get("Content-Type"),
+    )
+    await file_obj.save()
+    await arq.enqueue_job("calculate_hash", file_id.hex)
+    return PublicStorageItem.from_db_model(file_obj)
+
+
+@router.post("/raw/{filename}")
+async def upload_raw_file_with_filename(
+    filename: str, request: Request, user: User = Depends(get_current_user)
+) -> PublicStorageItem:
+    if user.storage_used > settings.free_storage_limit:
+        raise HTTPException(status_code=409, detail="Storage limit reached")
+    file_id = uuid4()
+    body_len = 0
+    data_file = SpooledTemporaryFile(max_size=1000)
+    async for chunk in request.stream():
+        body_len += len(chunk)
+        data_file.write(chunk)
+    data_file.seek(0)
+    file_obj = StorageItem(
+        id=file_id,
+        uploaded_at=datetime.now(),
+        mime_type=request.headers.get("Content-Type"),
+        hash=None,
+        user=user,
+        size=body_len,
+        filename=filename,
         deleted_at=None,
         alt_text=None,
     )
@@ -243,6 +279,7 @@ async def get_latest_images(count: int = 50, user: User = Depends(get_current_us
     count = min(count, 50)
     items = (
         await StorageItem.objects.filter(user=user)
+        .filter(StorageItem.deleted_at == None)  # noqa: E711
         .limit(count)
         .select_related([StorageItem.quizzes, StorageItem.quiztivities])
         .order_by(StorageItem.uploaded_at.desc())