Broken Duck Media Logo Broken Duck

About Services Products Resources

Course Builder

Core → Gold
💰 $2000

Drag-and-drop tools to assemble learning materials.

Technology iconTechnology iconTechnology iconTechnology icon

Overview of Course Builder Module

The Course Builder module is a cutting-edge tool designed to streamline the creation and management of learning materials through an intuitive drag-and-drop interface. This module empowers developers to integrate robust course-building capabilities into their applications, whether they are Learning Management Systems (LMS), custom educational platforms, or enterprise training solutions.

Purpose

The primary purpose of the Course Builder module is to simplify the process of assembling and managing educational content. It abstracts the complexities of course creation, enabling developers to focus on integration and customization while providing users with a user-friendly interface for building courses.

Benefits

Usage Scenarios

The Course Builder module is ideal for:

  1. LMS Integration: Adding course creation features directly within an LMS.
  2. Custom Platforms: Enhancing educational applications with tailored course-building tools.
  3. Enterprise Training Solutions: Implementing internal training programs with flexible content management.
  4. Open-Source Contributions: Extending functionality in open-source projects to meet community needs.

This module is a powerful addition for developers seeking to enhance their platforms with intuitive and efficient course-building capabilities.

Key Features of Course Builder Module

1. Drag-and-Drop Interface

2. Course Structure Validation

3. Content Management Integration

4. Preset Templates and Wizards

5. API and Custom Integration Support

6. Version Control and Publishing

7. Multi-User Collaboration

8. Customizable Media Embedding

9. Analytics and Reporting Hooks

10. Export/Import Functionality

These features make Course Builder a robust toolset for developers building educational software, offering flexibility and scalability to meet diverse course assembly needs.

# Course Builder Module Documentation

## Overview
The Course Builder module provides tools for creating and managing learning materials using drag-and-drop functionality. This documentation includes code examples for API endpoints, UI components, and data models.

---

## Code Samples

### 1. FastAPI Endpoint (Python)
This example shows a FastAPI endpoint to fetch course details:

```python
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import Optional
import models
from datetime import datetime

router = APIRouter()

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@router.get("/courses/{course_id}", response_model=CourseResponse)
def get_course(course_id: str, db: Session = Depends(get_db)):
    """Get course details by ID."""
    course = db.query(models.Course).filter(models.Course.id == course_id).first()
    if not course:
        raise HTTPException(status_code=404, detail="Course not found")
    return course

2. React UI Snippet (JavaScript)

This example demonstrates a drag-and-drop course builder interface:

import { useState } from 'react';
import { DragDropContext, Droppable, Draggable } from 'react-beautiful-dnd';

interface CourseItem {
  id: string;
  title: string;
  difficulty: string;
}

export const CourseBuilder = () => {
  const [courses, setCourses] = useState<CourseItem[]>([
    { id: '1', title: 'Introduction to Python', difficulty: 'Beginner' },
    { id: '2', title: 'Advanced Data Structures', difficulty: 'Advanced' }
  ]);

  const reorder = (list: CourseItem[], source: number, destination: number) => {
    if (!destination) return;
    const item = list[source];
    const newCourses = [...list];
    newCourses.splice(source, 1);
    newCourses.splice(destination, 0, item);
    setCourses(newCourses);
  };

  return (
    <DragDropContext onDragEnd={reorder}>
      <Droppable droppableId="courses">
        {(provided) => (
          <div {...provided.droppableProps} className="course-container">
            {courses.map((course, index) => (
              <Draggable key={course.id} draggableId={course.id} index={index}>
                {(provided) => (
                  <div
                    ref={provided.innerRef}
                    {...provided.draggableProps}
                    {...provided.dragHandleProps}
                    className="course-item"
                  >
                    {course.title} ({course.difficulty})
                  </div>
                )}
              </Draggable>
            ))}
            {provided.placeholder}
          </div>
        )}
      </Droppable>
    </DragDropContext>
  );
};

3. Data Schema (Pydantic)

This example defines the course data model using Pydantic:

from pydantic import BaseModel, UUID4, Field
from typing import Optional
from enum import Enum

class DifficultyLevel(str, Enum):
    BEGINNER = "Beginner"
    INTERMEDIATE = "Intermediate"
    ADVANCED = "Advanced"

class Course(BaseModel):
    id: UUID4
    title: str = Field(..., max_length=100)
    description: Optional[str] = Field(None, max_length=500)
    difficulty: DifficultyLevel
    duration: int  # in minutes
    created_at: datetime

class CourseResponse(Course):
    pass

Explanation

This documentation provides a comprehensive overview of the Course Builder module’s core components.

Technical Documentation for Course Builder Module

Overview

The following modules integrate with Course Builder to enhance functionality:

Use Cases

  1. Drag-and-Drop Course Creation: Quickly assemble content using an intuitive interface.
  2. Export/Import Courses: Transfer courses between systems in SCORM or xAPI formats.
  3. Customization: Tailor course appearance with themes and templates.
  4. Real-Time Collaboration: Allow multiple users to edit courses simultaneously.

Integration Tips

Configuration Options

OptionDescriptionData TypeDefault ValueNotes
api_endpointURL of the Course Builder APIString/course-builder/apiRequired
enable_drag_dropToggle drag-and-drop functionalityBooleantrueOptional, default to enabled
auth_tokenAuthentication token for secure API accessStringRequired if enabled
allowed_file_typesMIME types allowed for content uploadsArray of Stringsimage/, video/, etc.Comma-separated values
cache_timeoutCache expiration time in secondsInteger3600Optional
error_handling_modeError handling strategy (strict or lenient)StringstrictOptional

This documentation provides a comprehensive guide for developers integrating and configuring the Course Builder module, ensuring seamless operation within existing systems.