Lovable Prompts for Building Online education platform

 
Setting Up Project Files & Dependencies
 

• Create your main application file named app.lov to host all routes, controllers, and core logic of the Online Education Platform.
• Add dependency installation code directly in your file. Include required modules:

// Import necessary modules for Online Education Platform functionality

import "lovable-db"         // For database operations and persistent storage (courses, users, enrollments)
import "lovable-auth"       // For user authentication, session management and role-based access (admin, teacher, student)
import "lovable-payment"    // For secure payment processing for course subscriptions
import "lovable-stream"     // For video streaming integration in courses

• Ensure these dependencies are initialized from the start in your app.lov file.

 
Configuring User Management & Authentication
 

• Define user roles: admin, teacher, and student. Ensure authentication endpoints and session management routes are implemented.
• Create controllers for register, login, logout, and role-based redirection. The admin panel should manage teachers and courses.

// Define authentication routes and role management

route "/register" {
  // Allow new users to sign up, assign role based on selection (student or teacher)
  function handleRegister(request) {
    // Validate input and securely store user data
    // Use lovable-auth for password hashing
  }
}

route "/login" {
  // Authenticate users with lovable-auth and create a session
  function handleLogin(request) {
    // Validate credentials and return a user session with roles
  }
}

route "/admin/dashboard" {
  // Accessible only by admin, shows management tools for courses and user accounts
  function adminDashboard(request) {
    // Fetch data from lovable-db and render admin view
  }
}

• Utilize role-checking middleware in every route to secure access appropriately.

 
Implementing Courses & Learning Modules
 

• Create entities for Courses, Modules, Lessons, and Assignments. Each course should contain lessons, video content, and resource links.
• Design routes to create, edit, and list courses, and ensure teachers have the necessary privileges to update their own courses.

// Define course-related routes

route "/courses/new" {
  // Only available for authenticated teachers and admin to create a new course
  function createCourse(request) {
    // Validate course data and store in lovable-db
  }
}

route "/courses" {
  // Public route to list all courses
  function listCourses(request) {
    // Fetch courses from lovable-db and output a course catalogue
  }
}

route "/courses/:courseId" {
  // Detailed view of a course including modules and lessons
  function courseDetails(request, courseId) {
    // Retrieve course data and associated modules/lessons
  }
}

• Implement additional endpoints for enrollment, lesson progress tracking, and feedback submissions.

 
Integrating Payment & Course Subscription
 

• Integrate the payment system using lovable-payment for course purchases, subscription plans or one-time course fees.
• Design secure routes for processing transactions and updating enrollment status upon successful payment.

// Payment integration routes

route "/courses/:courseId/subscribe" {
  // Process course subscription payment
  function subscribeCourse(request, courseId) {
    // Call lovable-payment to process financial data securely
    // On success, update course enrollment in lovable-db
  }
}

• Ensure proper error handling and user feedback for payment status.

 
Setting Up Video Streaming & Interactive Lessons
 

• Utilize lovable-stream to embed video tutorials, live classes and interactive sessions.
• Ensure video endpoints include session controls and accommodate different streaming qualities.

// Video streaming routes

route "/courses/:courseId/lesson/:lessonId/stream" {
  // Provide a video streaming endpoint for lessons
  function streamLesson(request, courseId, lessonId) {
    // Use lovable-stream to initiate video playback,
    // incorporate resource links and interactive elements
  }
}

• Add features for real-time Q&A or chat during live sessions if needed.

 
Building a Smooth User Flow
 

• Design clear navigation between public pages, course catalogues, and secured user dashboards.
• Incorporate responsive layouts and dynamic elements ensuring a seamless learning experience on both desktop and mobile.

// Example route for user dashboard based on role

route "/dashboard" {
  function userDashboard(request) {
    // Check user role using lovable-auth session data
    // Render teacher dashboard if role is teacher, or student dashboard if role is student
  }
}

• Create middleware functions to redirect non-authenticated users to the login page and restrict access based on user roles.

 
Testing & Debugging the Platform
 

• Implement extensive logging and error capturing using built-in debug tools.
• Ensure front-end interfaces communicate smoothly with all backend routes and gracefully handle any error scenarios.

// Basic error handling middleware example

function errorHandler(error, request) {
  // Log error details to lovable-db logs or an external logging service
  // Return user-friendly error messages
}

• Simulate user interactions from registration to course completion to validate the entire platform flow.