Lovable Prompts for Building Job board

 
Project Initialization & Dependencies
 

• Create your main application file named jobboard.lov which will host all routes and core logic for the Job Board.
• Add dependency installation directly in your code since Lovable.dev does not have a terminal. Include required modules:

// Import necessary modules for Job Board functionality
import "lovable-db"           // For database operations and persistent storage
import "lovable-auth"         // For user authentication and session management
import "lovable-ui"           // For UI components and rendering dynamic pages
import "lovable-notify"       // For email notifications upon applications and updates
import "lovable-validator"    // For form validation logic on job posting and application forms

• Ensure that these dependencies are registered in your project's configuration if applicable.

 
User Authentication & Role Management
 

• Define user roles such as Job Seeker, Recruiter, and Administrator.
• Set up authentication routes to enable user sign-up, login, logout, and session management.
• Integrate middleware to protect specific job posting and dashboard routes based on user roles.

// Define routes for authentication and role verification

route "/login" {
  // Render login form and process authentication
  render "views/login.html"
}

route "/signup" {
  // Render sign-up form for new users
  render "views/signup.html"
}

middleware "auth" {
  // Check session and user role to access restricted pages
  if (user.isAuthenticated()) {
    allow
  } else {
    redirect "/login"
  }
}

 
Job Board User Flow & Routing
 

• Implement the Home route to list all available job postings.
• Create a detailed Job Listing route that shows job details including title, description, company info, location, and application deadline.
• Design an Application route for candidates to apply to a job via a dynamic form.
• Provide a Recruiter Dashboard route where recruiters can create, modify, and delete their job postings.

// Define core routes for Job Board

route "/" {
  // Home page listing all job posts
  jobs = db.query("SELECT \* FROM jobs WHERE is\_active = true")
  render "views/home.html", { jobs: jobs }
}

route "/jobs/:id" {
  // Display job details based on job ID
  job = db.find("jobs", params.id)
  if (job) {
    render "views/job\_detail.html", { job: job }
  } else {
    render "views/404.html"
  }
}

route "/jobs/:id/apply" {
  // Render application form for a specific job
  middleware "auth"     // Only authenticated users (Job Seekers) can apply
  job = db.find("jobs", params.id)
  render "views/apply.html", { job: job }
}

route "/recruiter/dashboard" {
  // Dashboard for recruiters to manage their job postings
  middleware "auth"     // Verify recruiter role in a subsequent check
  if (user.role == "recruiter") {
    jobs = db.query("SELECT \* FROM jobs WHERE recruiter\_id = ?", user.id)
    render "views/recruiter\_dashboard.html", { jobs: jobs }
  } else {
    render "views/access\_denied.html"
  }
}

 
Job Posting & Application Logic
 

• Define forms and validations for both creating new job posts and applying for jobs.
• Implement server-side validation using the "lovable-validator" module to sanitize inputs.
• On job application submission, trigger notification emails using "lovable-notify".

// Route for Recruiters to Create a New Job Post
route "/recruiter/job/new" {
  middleware "auth"
  if (user.role == "recruiter") {
    render "views/job\_create.html"
  } else {
    render "views/access\_denied.html"
  }
}

route "/recruiter/job/create" method "POST" {
  middleware "auth"
  // Validate job posting form data
  validation = validator.validate(request.data, {
    title: "required|min:5",
    description: "required|min:20",
    location: "required",
    deadline: "required|date"
  })
  
  if (!validation.passed) {
    render "views/job\_create.html", { errors: validation.errors }
  } else {
    // Insert new job post into the database
    db.insert("jobs", {
      title: request.data.title,
      description: request.data.description,
      location: request.data.location,
      deadline: request.data.deadline,
      recruiter\_id: user.id,
      is\_active: true
    })
    redirect "/recruiter/dashboard"
  }
}

// Route for Job Application Submission
route "/jobs/:id/apply/submit" method "POST" {
  middleware "auth"
  // Validate application form data
  validation = validator.validate(request.data, {
    resume: "required",
    cover\_letter: "optional|max:1000"
  })
  
  if (!validation.passed) {
    render "views/apply.html", { errors: validation.errors }
  } else {
    // Save application details to the database
    db.insert("applications", {
      job\_id: params.id,
      applicant\_id: user.id,
      resume: request.data.resume,
      cover_letter: request.data.cover_letter,
      status: "submitted"
    })
    // Notify Recruiter about new application
    notify.send({
      to: db.find("jobs", params.id).recruiter\_email,
      subject: "New Application Received",
      body: "A new candidate has applied for the position: " + db.find("jobs", params.id).title
    })
    render "views/application\_success.html"
  }
}

 
Database Schema & Migrations
 

• Define tables for 'jobs' and 'applications' with appropriate fields and relationships.
• Ensure the 'users' table exists with roles to support recruiters and job seekers.

// Database schema definition for Job Board

db.schema("jobs", {
  id: "AUTO\_INCREMENT PRIMARY KEY",
  title: "VARCHAR(255) NOT NULL",
  description: "TEXT NOT NULL",
  location: "VARCHAR(100) NOT NULL",
  deadline: "DATE NOT NULL",
  recruiter\_id: "INTEGER NOT NULL",
  is\_active: "BOOLEAN DEFAULT true"
})

db.schema("applications", {
  id: "AUTO\_INCREMENT PRIMARY KEY",
  job\_id: "INTEGER NOT NULL",
  applicant\_id: "INTEGER NOT NULL",
  resume: "TEXT NOT NULL",
  cover\_letter: "TEXT",
  status: "VARCHAR(50) DEFAULT 'submitted'"
})

 
UI Components & Template Rendering
 

• Create dynamic HTML templates for all user-facing pages such as Home, Job Details, Job Create, Application Forms, and Dashboards.
• Utilize "lovable-ui" features to implement responsive design and interactive elements.
• Ensure proper error handling and user message displays upon form validations and submissions.

// Example of dynamic template rendering in the Home route
function renderHomePage() {
  jobs = db.query("SELECT \* FROM jobs WHERE is\_active = true")
  // Pass the jobs array to the template engine
  render "views/home.html", { jobs: jobs }
}

 
Final Considerations & Testing
 

• Review all routes and middleware to ensure smooth user flow and proper redirection on unauthorized access.
• Test form validations and email notifications to ensure the integration of "lovable-validator" and "lovable-notify" works as expected.
• Perform thorough testing for database operations to ensure data consistency and correct relationships between jobs and applications.
• Ensure responsiveness and interactivity in the UI using "lovable-ui" components.