Implement course creation

backend/blueprints/course/__init__.py

@@ -1,83 +1,56 @@
-from flask import Blueprint, request, jsonify
-from werkzeug.utils import secure_filename
-from sqlalchemy.sql import func
+from flask import Blueprint, request, jsonify, g
+from werkzeug.datastructures import MultiDict
 import os
 import uuid
-from db.model import db, Course, Category, User
+from config import DEFAULT_COURSE_COVER
+from db.model import db, Course, Category, User, Chat
 from utils.utils import random_string_generator
+from utils.auth import auth_required, requires_role
 from constants import *
 from config import *
+from constants import PublishedStatus
 
 course = Blueprint('course', __name__)
 
-@course.route('/create/course', methods=['POST'])
+@course.route('/create', methods=['POST'])
+@auth_required()
 def create_course():
-    """
-    Endpoint to create a new course.
-    Ensures strict adherence to the Course model, with file handling and default behaviors.
-    """
+    form_data: dict  = request.form
+    course_uploaded_cover_image: MultiDict|None = request.files.get('cover_image', None)
+    course_uploaded_pdf: MultiDict|None = request.files.get('course_pdf', None)
+
+    cover_file_name: str = DEFAULT_COURSE_COVER
+    pdf_file_name: str = ''
+    if course_uploaded_cover_image is not None:
+        cover_file_name: str = random_string_generator(32)+course_uploaded_cover_image.filename.split('.')[-1]
+        course_uploaded_cover_image.save(os.path.join(USER_UPLOADS_DIR, cover_file_name))
+    if course_uploaded_pdf is not None:
+        pdf_file_name: str = random_string_generator(32) + course_uploaded_pdf.filename.split('.')[-1]
+        course_uploaded_pdf.save(os.path.join(USER_UPLOADS_DIR, pdf_file_name))
+    published_status: PublishedStatus = PublishedStatus.DRAFT
     try:
-        # Retrieve form data
-        data = request.form
-        name :str= data.get('name', '').strip()
-        category_id :str = data.get('category_id', '').strip()
-        description :str= data.get('description', '')
-        is_active :bool = bool(int(data.get('is_active', 0)))
-        published_status :int = data.get('published_status', int(PublishedStatus.DRAFT.value)) # Defaults to DRAFT
-        author_id :str = data.get('author_id', '').strip()
-
-        # Validate required fields
-        if not name or not category_id or not author_id:
-            return jsonify({"error": "Missing required fields: 'name', 'category_id', or 'author_id'."}), 400
-
-        # Validate category existence
-        category :str= Category.query.get(category_id)
-        if not category:
-            return jsonify({"error": "Category not found."}), 404
-
-        # Validate author existence
-        author :str = User.query.get(author_id)
-        if not author:
-            return jsonify({"error": "Author not found."}), 404
-
-        # File handling
-        uploaded_cover_image = request.files.get('cover')
-        uploaded_file = request.files.get('pdf')
-
-        cover_filename_image :str= ''
-        pdf_file_filename :str= ''
-        if uploaded_cover_image is not None:
-            cover_filename_image :str = random_string_generator(10) + os.path.splitext(uploaded_cover_image.filename)[-1]
-            uploaded_cover_image.save(os.path.join(USER_UPLOADS_DIR, cover_filename_image))
-
-        if uploaded_file is not None:
-            pdf_file_filename :str= random_string_generator(10) + os.path.splitext(uploaded_file.filename)[-1]
-            uploaded_file.save( os.path.join(USER_UPLOADS_DIR, pdf_file_filename))
-
-        # Default to DRAFT if critical content is missing
-        if not uploaded_cover_image or not uploaded_file:
-            published_status :int= int(PublishedStatus.DRAFT.value)
-
-        # Create new course
-        new_course = Course(
-            name=name,
-            categoryID=uuid.UUID(category_id),
-            description=description,
-            isActive=is_active,
+        course_name: str = form_data['course_name']
+    except KeyError:
+        return jsonify({'message': 'Course name cannot be empty'}), 401
+
+    course_description: str = form_data.get('course_name', '')
+    category_id: uuid.UUID = uuid.UUID(form_data['category_uuid'])
+    pages_required_for_community: int = int(form_data['community_unlock_at_pages'])  # TODO: Add this field to model
+
+    new_course: Course = Course(
+        name=course_name,
+        categoryID=category_id,
+        authorID=g.current_user.id,
+        description=course_description,
+        isActive=True,
         publishedStatus=int(published_status),
-            coverImage=cover_filename_image,
-            serverFilename=pdf_file_filename,
-            authorID=uuid.UUID(author_id),
-            creationDate=func.now(),
+        coverImage=cover_file_name,
+        serverFilename =pdf_file_name,
+        enrollments=[],
+        quizzes=[],
+        chats=[]
     )
-
-        # Save the course to the database
-        db.session.add(new_course)
+    # chat: Chat = Chat(courseID=new_course.id) TODO: Add a welcome chat for this course
+    db.session.add_all(new_course)
     db.session.commit()
-
-        return jsonify({"message": "Course created successfully.", "course_id": str(new_course.id)}), 201
-
-    except Exception as e:
-        # Rollback in case of an error
-        db.session.rollback()
-        return jsonify({"error": f"An error occurred: {str(e)}"}), 500
+    return jsonify({'message': 'Course was created successfully.'}), 200