feat: remake content upload and diffusion

src/services/blocks/block_types/imageBlock/images.py

@@ -6,24 +6,51 @@ from src.services.blocks.utils.upload_files import upload_file_and_return_file_o
 from src.services.users.users import PublicUser
 
 
-async def create_image_block(request: Request, image_file: UploadFile, activity_id: str):
+async def create_image_block(
+    request: Request, image_file: UploadFile, activity_id: str
+):
     blocks = request.app.db["blocks"]
     activity = request.app.db["activities"]
+    courses = request.app.db["courses"]
 
     block_type = "imageBlock"
 
     # get org_id from activity
-    activity = await activity.find_one({"activity_id": activity_id}, {"_id": 0, "org_id": 1})
+    activity = await activity.find_one({"activity_id": activity_id}, {"_id": 0})
     org_id = activity["org_id"]
 
+    coursechapter_id = activity["coursechapter_id"]
+
+    # get course_id from coursechapter
+    course = await courses.find_one(
+        {"chapters": coursechapter_id},
+        {"_id": 0},
+    )
+
+
     # get block id
     block_id = str(f"block_{uuid4()}")
 
-    block_data = await upload_file_and_return_file_object(request, image_file,  activity_id, block_id, ["jpg", "jpeg", "png", "gif"], block_type)
+    block_data = await upload_file_and_return_file_object(
+        request,
+        image_file,
+        activity_id,
+        block_id,
+        ["jpg", "jpeg", "png", "gif"],
+        block_type,
+        org_id,
+        course["course_id"],
+    )
 
     # create block
-    block = Block(block_id=block_id, activity_id=activity_id,
-                  block_type=block_type, block_data=block_data, org_id=org_id)
+    block = Block(
+        block_id=block_id,
+        activity_id=activity_id,
+        block_type=block_type,
+        block_data=block_data,
+        org_id=org_id,
+        course_id=course["course_id"],
+    )
 
     # insert block
     await blocks.insert_one(block.dict())
@@ -41,4 +68,5 @@ async def get_image_block(request: Request, file_id: str, current_user: PublicUs
 
     else:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="Image block does not exist")
+            status_code=status.HTTP_409_CONFLICT, detail="Image block does not exist"
+        )

src/services/blocks/block_types/pdfBlock/pdfBlock.py

@@ -9,21 +9,45 @@ from src.services.users.users import PublicUser
 async def create_pdf_block(request: Request, pdf_file: UploadFile, activity_id: str):
     blocks = request.app.db["blocks"]
     activity = request.app.db["activities"]
+    courses = request.app.db["courses"]
 
     block_type = "pdfBlock"
 
     # get org_id from activity
-    activity = await activity.find_one({"activity_id": activity_id}, {"_id": 0, "org_id": 1})
+    activity = await activity.find_one({"activity_id": activity_id}, {"_id": 0})
     org_id = activity["org_id"]
 
     # get block id
     block_id = str(f"block_{uuid4()}")
 
-    block_data = await upload_file_and_return_file_object(request, pdf_file,  activity_id, block_id, ["pdf"], block_type)
+    coursechapter_id = activity["coursechapter_id"]
+
+    # get course_id from coursechapter
+    course = await courses.find_one(
+        {"chapters": coursechapter_id},
+        {"_id": 0},
+    )
+
+    block_data = await upload_file_and_return_file_object(
+        request,
+        pdf_file,
+        activity_id,
+        block_id,
+        ["pdf"],
+        block_type,
+        org_id,
+        course["course_id"],
+    )
 
     # create block
-    block = Block(block_id=block_id, activity_id=activity_id,
-                  block_type=block_type, block_data=block_data, org_id=org_id)
+    block = Block(
+        block_id=block_id,
+        activity_id=activity_id,
+        block_type=block_type,
+        block_data=block_data,
+        org_id=org_id,
+        course_id=course["course_id"],
+    )
 
     # insert block
     await blocks.insert_one(block.dict())
@@ -41,4 +65,5 @@ async def get_pdf_block(request: Request, file_id: str, current_user: PublicUser
 
     else:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="Video file does not exist")
+            status_code=status.HTTP_409_CONFLICT, detail="Video file does not exist"
+        )

src/services/blocks/block_types/quizBlock/quizBlock.py

@@ -31,16 +31,20 @@ class quizBlock(BaseModel):
 async def create_quiz_block(request: Request, quizBlock: quizBlock, activity_id: str, user: PublicUser):
     blocks = request.app.db["blocks"]
     activities = request.app.db["activities"]
+    courses = request.app.db["courses"]
 
     # Get org_id from activity
     activity = await activities.find_one({"activity_id": activity_id}, {"_id": 0, "org_id": 1})
     org_id = activity["org_id"]
 
+    # Get course_id from activity
+    course = await activities.find_one({"activity_id": activity_id}, {"_id": 0, "course_id": 1})
+
     block_id = str(f"block_{uuid4()}")
 
     # create block
     block = Block(block_id=block_id, activity_id=activity_id,
-                  block_type="quizBlock", block_data=quizBlock, org_id=org_id)
+                  block_type="quizBlock", block_data=quizBlock, org_id=org_id, course_id=course["course_id"])
 
     # insert block
     await blocks.insert_one(block.dict())

src/services/blocks/block_types/videoBlock/videoBlock.py

@@ -6,24 +6,52 @@ from src.services.blocks.utils.upload_files import upload_file_and_return_file_o
 from src.services.users.users import PublicUser
 
 
-async def create_video_block(request: Request, video_file: UploadFile, activity_id: str):
+async def create_video_block(
+    request: Request, video_file: UploadFile, activity_id: str
+):
     blocks = request.app.db["blocks"]
     activity = request.app.db["activities"]
+    courses = request.app.db["courses"]
 
     block_type = "videoBlock"
-    
+
     # get org_id from activity
-    activity = await activity.find_one({"activity_id": activity_id}, {"_id": 0, "org_id": 1})
+    activity = await activity.find_one(
+        {"activity_id": activity_id}, {"_id": 0}
+    )
     org_id = activity["org_id"]
 
     # get block id
     block_id = str(f"block_{uuid4()}")
 
-    block_data = await upload_file_and_return_file_object(request, video_file,  activity_id, block_id, ["mp4", "webm", "ogg"], block_type)
+    coursechapter_id = activity["coursechapter_id"]
+
+    # get course_id from coursechapter
+    course = await courses.find_one(
+        {"chapters": coursechapter_id},
+        {"_id": 0},
+    )
+
+    block_data = await upload_file_and_return_file_object(
+        request,
+        video_file,
+        activity_id,
+        block_id,
+        ["mp4", "webm", "ogg"],
+        block_type,
+        org_id,
+        course["course_id"],
+    )
 
     # create block
-    block = Block(block_id=block_id, activity_id=activity_id,
-                  block_type=block_type, block_data=block_data, org_id=org_id)
+    block = Block(
+        block_id=block_id,
+        activity_id=activity_id,
+        block_type=block_type,
+        block_data=block_data,
+        org_id=org_id,
+        course_id=course["course_id"],
+    )
 
     # insert block
     await blocks.insert_one(block.dict())
@@ -41,4 +69,5 @@ async def get_video_block(request: Request, file_id: str, current_user: PublicUs
 
     else:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="Video file does not exist")
+            status_code=status.HTTP_409_CONFLICT, detail="Video file does not exist"
+        )

src/services/blocks/schemas/blocks.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 class Block(BaseModel):
     block_id: str
     activity_id: str
+    course_id: str
     org_id: str
     block_type: Literal["quizBlock", "videoBlock", "pdfBlock", "imageBlock"]
     block_data: Any

src/services/blocks/utils/upload_files.py

@@ -2,10 +2,19 @@ import os
 import uuid
 from fastapi import HTTPException, Request, UploadFile, status
 from src.services.blocks.schemas.files import BlockFile
+from src.services.utils.upload_content import upload_content
 
 
-
-async def upload_file_and_return_file_object(request: Request, file: UploadFile, activity_id: str, block_id: str, list_of_allowed_file_formats: list, type_of_block: str):
+async def upload_file_and_return_file_object(
+    request: Request,
+    file: UploadFile,
+    activity_id: str,
+    block_id: str,
+    list_of_allowed_file_formats: list,
+    type_of_block: str,
+    org_id: str,
+    course_id: str,
+):
     # get file id
     file_id = str(uuid.uuid4())
 
@@ -15,8 +24,9 @@ async def upload_file_and_return_file_object(request: Request, file: UploadFile,
     # validate file format
     if file_format not in list_of_allowed_file_formats:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="File format not supported")
-    
+            status_code=status.HTTP_409_CONFLICT, detail="File format not supported"
+        )
+
     # create file
     file_binary = await file.read()
 
@@ -36,18 +46,14 @@ async def upload_file_and_return_file_object(request: Request, file: UploadFile,
         file_name=file_name,
         file_size=file_size,
         file_type=file_type,
-        activity_id=activity_id
+        activity_id=activity_id,
     )
 
-    # create folder for activity
-    if not os.path.exists(f"content/uploads/files/activities/{activity_id}/blocks/{type_of_block}/{block_id}"):
-        # create folder for activity
-        os.makedirs(f"content/uploads/files/activities/{activity_id}/blocks/{type_of_block}/{block_id}")
-
-    # upload file to server
-    with open(f"content/uploads/files/activities/{activity_id}/blocks/{type_of_block}/{block_id}/{file_id}.{file_format}", 'wb') as f:
-        f.write(file_binary)
-        f.close()
-
+    await upload_content(
+        f"courses/{course_id}/activities/{activity_id}/dynamic/blocks/{type_of_block}/{block_id}",
+        org_id=org_id,
+        file_binary=file_binary,
+        file_and_format=f"{file_id}.{file_format}",
+    )
 
     return uploadable_file

src/services/courses/activities/activities.py

@@ -1,3 +1,4 @@
+from calendar import c
 from pydantic import BaseModel
 from src.security.security import verify_user_rights_with_roles
 from src.services.users.schemas.users import PublicUser
@@ -16,6 +17,7 @@ class Activity(BaseModel):
 
 class ActivityInDB(Activity):
     activity_id: str
+    course_id: str
     coursechapter_id: str
     org_id: str
     creationDate: str
@@ -47,6 +49,9 @@ async def create_activity(
         request, "create", current_user.user_id, activity_id, org_id
     )
 
+    # get course_id from activity
+    course = await courses.find_one({"chapters": coursechapter_id})
+
     if not hasRoleRights:
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT,
@@ -61,6 +66,7 @@ async def create_activity(
         updateDate=str(datetime.now()),
         activity_id=activity_id,
         org_id=org_id,
+        course_id=course["course_id"],
     )
     await activities.insert_one(activity.dict())
 

src/services/courses/activities/pdf.py

@@ -7,7 +7,13 @@ from uuid import uuid4
 from datetime import datetime
 
 
-async def create_documentpdf_activity(request: Request, name: str,  coursechapter_id: str, current_user: PublicUser,  pdf_file: UploadFile | None = None):
+async def create_documentpdf_activity(
+    request: Request,
+    name: str,
+    coursechapter_id: str,
+    current_user: PublicUser,
+    pdf_file: UploadFile | None = None,
+):
     activities = request.app.db["activities"]
     courses = request.app.db["courses"]
 
@@ -16,18 +22,21 @@ async def create_documentpdf_activity(request: Request, name: str,  coursechapte
 
     # get org_id from course
     coursechapter = await courses.find_one(
-        {"chapters_content.coursechapter_id": coursechapter_id})
+        {"chapters_content.coursechapter_id": coursechapter_id}
+    )
 
     org_id = coursechapter["org_id"]
 
     # check if pdf_file is not None
     if not pdf_file:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="Pdf : No pdf file provided")
+            status_code=status.HTTP_409_CONFLICT, detail="Pdf : No pdf file provided"
+        )
 
     if pdf_file.content_type not in ["application/pdf"]:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="Pdf : Wrong pdf format")
+            status_code=status.HTTP_409_CONFLICT, detail="Pdf : Wrong pdf format"
+        )
 
     # get pdf format
     if pdf_file.filename:
@@ -35,7 +44,8 @@ async def create_documentpdf_activity(request: Request, name: str,  coursechapte
 
     else:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="Pdf : No pdf file provided")
+            status_code=status.HTTP_409_CONFLICT, detail="Pdf : No pdf file provided"
+        )
 
     activity_object = ActivityInDB(
         org_id=org_id,
@@ -43,9 +53,10 @@ async def create_documentpdf_activity(request: Request, name: str,  coursechapte
         coursechapter_id=coursechapter_id,
         name=name,
         type="documentpdf",
+        course_id=coursechapter["course_id"],
         content={
             "documentpdf": {
-                "filename": "documentpdf."+pdf_format,
+                "filename": "documentpdf." + pdf_format,
                 "activity_id": activity_id,
             }
         },
@@ -53,11 +64,15 @@ async def create_documentpdf_activity(request: Request, name: str,  coursechapte
         updateDate=str(datetime.now()),
     )
 
-    hasRoleRights = await verify_user_rights_with_roles(request, "create", current_user.user_id, activity_id, element_org_id=org_id)
+    hasRoleRights = await verify_user_rights_with_roles(
+        request, "create", current_user.user_id, activity_id, element_org_id=org_id
+    )
 
     if not hasRoleRights:
         raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT, detail="Roles : Insufficient rights to perform this action")
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Roles : Insufficient rights to perform this action",
+        )
 
     # create activity
     activity = ActivityInDB(**activity_object.dict())
@@ -66,11 +81,13 @@ async def create_documentpdf_activity(request: Request, name: str,  coursechapte
     # upload pdf
     if pdf_file:
         # get pdffile format
-        await upload_pdf(pdf_file,  activity_id)
+        await upload_pdf(pdf_file, activity_id, org_id, coursechapter["course_id"])
 
     # todo : choose whether to update the chapter or not
     # update chapter
-    await courses.update_one({"chapters_content.coursechapter_id": coursechapter_id}, {
-        "$addToSet": {"chapters_content.$.activities": activity_id}})
+    await courses.update_one(
+        {"chapters_content.coursechapter_id": coursechapter_id},
+        {"$addToSet": {"chapters_content.$.activities": activity_id}},
+    )
 
     return activity

src/services/courses/activities/uploads/pdfs.py

@@ -1,23 +1,19 @@
 import os
 
+from src.services.utils.upload_content import upload_content
 
-async def upload_pdf(pdf_file,  activity_id):
+
+async def upload_pdf(pdf_file, activity_id, org_id, course_id):
     contents = pdf_file.file.read()
     pdf_format = pdf_file.filename.split(".")[-1]
 
-    if not os.path.exists("content/uploads/documents/documentpdf"):
-        # create folder
-        os.makedirs("content/uploads/documents/documentpdf")
-
-    # create folder
-    os.mkdir(f"content/uploads/documents/documentpdf/{activity_id}")
-
     try:
-        with open(f"content/uploads/documents/documentpdf/{activity_id}/documentpdf.{pdf_format}", 'wb') as f:
-            f.write(contents)
-            f.close()
+        await upload_content(
+            f"courses/{course_id}/activities/{activity_id}/documentpdf",
+            org_id,
+            contents,
+            f"documentpdf.{pdf_format}",
+        )
 
     except Exception:
         return {"message": "There was an error uploading the file"}
-    finally:
-        pdf_file.file.close()

src/services/courses/activities/uploads/videos.py

@@ -1,23 +1,19 @@
 import os
 
+from src.services.utils.upload_content import upload_content
 
-async def upload_video(video_file,  activity_id):
+
+async def upload_video(video_file, activity_id, org_id, course_id):
     contents = video_file.file.read()
     video_format = video_file.filename.split(".")[-1]
 
-    if not os.path.exists("content/uploads/video"):
-        # create folder
-        os.makedirs("content/uploads/video")
-
-    # create folder
-    os.mkdir(f"content/uploads/video/{activity_id}")
-
     try:
-        with open(f"content/uploads/video/{activity_id}/video.{video_format}", 'wb') as f:
-            f.write(contents)
-            f.close()
+        await upload_content(
+            f"courses/{course_id}/activities/{activity_id}/video",
+            org_id,
+            contents,
+            f"video.{video_format}",
+        )
 
     except Exception:
         return {"message": "There was an error uploading the file"}
-    finally:
-        video_file.file.close()

src/services/courses/activities/video.py

@@ -62,6 +62,7 @@ async def create_video_activity(
         org_id=org_id,
         activity_id=activity_id,
         coursechapter_id=coursechapter_id,
+        course_id=coursechapter["course_id"],
         name=name,
         type="video",
         content={
@@ -91,7 +92,7 @@ async def create_video_activity(
     # upload video
     if video_file:
         # get videofile format
-        await upload_video(video_file, activity_id)
+        await upload_video(video_file, activity_id, org_id, coursechapter["course_id"])
 
     # todo : choose whether to update the chapter or not
     # update chapter
@@ -109,6 +110,7 @@ class ExternalVideo(BaseModel):
     type: Literal["youtube", "vimeo"]
     coursechapter_id: str
 
+
 class ExternalVideoInDB(BaseModel):
     activity_id: str
 
@@ -150,6 +152,7 @@ async def create_external_video_activity(
                 "type": data.type,
             }
         },
+        course_id=coursechapter["course_id"],
         creationDate=str(datetime.now()),
         updateDate=str(datetime.now()),
     )

src/services/courses/courses.py

@@ -1,3 +1,4 @@
+from calendar import c
 import json
 from typing import List, Optional
 from uuid import uuid4
@@ -184,7 +185,9 @@ async def create_course(
         name_in_disk = (
             f"{course_id}_thumbnail_{uuid4()}.{thumbnail_file.filename.split('.')[-1]}"
         )
-        await upload_thumbnail(thumbnail_file, name_in_disk)
+        await upload_thumbnail(
+            thumbnail_file, name_in_disk, course_object.org_id, course_id
+        )
         course_object.thumbnail = name_in_disk
 
     course = CourseInDB(
@@ -225,7 +228,9 @@ async def update_course_thumbnail(
         if thumbnail_file and thumbnail_file.filename:
             name_in_disk = f"{course_id}_thumbnail_{uuid4()}.{thumbnail_file.filename.split('.')[-1]}"
             course = Course(**course).copy(update={"thumbnail": name_in_disk})
-            await upload_thumbnail(thumbnail_file, name_in_disk)
+            await upload_thumbnail(
+                thumbnail_file, name_in_disk, course.org_id, course_id
+            )
 
             updated_course = CourseInDB(
                 course_id=course_id,

src/services/courses/thumbnails.py

@@ -1,17 +1,17 @@
 import os
 
+from src.services.utils.upload_content import upload_content
 
-async def upload_thumbnail(thumbnail_file, name_in_disk):
+
+async def upload_thumbnail(thumbnail_file, name_in_disk, org_id, course_id):
     contents = thumbnail_file.file.read()
     try:
-        if not os.path.exists("content/uploads/img"):
-            os.makedirs("content/uploads/img")
-        
-        with open(f"content/uploads/img/{name_in_disk}", 'wb') as f:
-            f.write(contents)
-            f.close()
+        await upload_content(
+            f"courses/{course_id}/thumbnails",
+            org_id,
+            contents,
+            f"{name_in_disk}",
+        )
 
     except Exception:
         return {"message": "There was an error uploading the file"}
-    finally:
-        thumbnail_file.file.close()

src/services/orgs/logos.py

@@ -2,25 +2,18 @@ import os
 from uuid import uuid4
 from fastapi import HTTPException, status
 
+from src.services.utils.upload_content import upload_content
 
-async def upload_org_logo(logo_file):
+
+async def upload_org_logo(logo_file, org_id):
     contents = logo_file.file.read()
     name_in_disk = f"{uuid4()}.{logo_file.filename.split('.')[-1]}"
 
-    try:
-        if not os.path.exists("content/uploads/logos"):
-            os.makedirs("content/uploads/logos")
-
-        with open(f"content/uploads/logos/{name_in_disk}", "wb") as f:
-            f.write(contents)
-            f.close()
-
-    except Exception:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="There was an error uploading the file",
-        )
-    finally:
-        logo_file.file.close()
+    await upload_content(
+        "logos",
+        org_id,
+        contents,
+        name_in_disk,
+    )
 
     return name_in_disk

src/services/orgs/orgs.py

@@ -115,7 +115,7 @@ async def update_org_logo(
 
     await orgs.find_one({"org_id": org_id})
 
-    name_in_disk = await upload_org_logo(logo_file)
+    name_in_disk = await upload_org_logo(logo_file, org_id)
 
     # update org
     await orgs.update_one({"org_id": org_id}, {"$set": {"logo": name_in_disk}})

src/services/utils/upload_content.py

@@ -0,0 +1,17 @@
+import os
+
+
+async def upload_content(
+    directory: str, org_id: str, file_binary: bytes, file_and_format: str
+):
+    # create folder for activity
+    if not os.path.exists(f"content/{org_id}/{directory}"):
+        # create folder for activity
+        os.makedirs(f"content/{org_id}/{directory}")
+    # upload file to server
+    with open(
+        f"content/{org_id}/{directory}/{file_and_format}",
+        "wb",
+    ) as f:
+        f.write(file_binary)
+        f.close()