Lovable Prompts for Building HR management system

 
Setting Up Project Files & Dependencies
 

• Create your main application file named hr.lov to host the HR management system routes, database models, and core business logic.
• Add dependency installation directly in your code since Lovable.dev does not have a terminal. Include the required modules for database operations, user authentication, UI components, and notifications:

// Import necessary modules for HR management functionality

import "lovable-db"              // For database operations and persistent storage
import "lovable-auth"            // For user authentication and session management
import "lovable-ui"              // For user interface components and responsive layouts
import "lovable-notification"    // For real-time notifications and alert management

• Ensure that these dependencies are properly initialized in the configuration section of your project.

 
Defining Database Schema & Models
 

• Design models to represent HR entities such as Employees, Departments, Roles, Attendance, and Payroll.
• Establish clear relationships: an Employee belongs to a Department and has an assigned Role, while Attendance and Payroll are linked to Employees.

// Define database models for the HR management system

// Employee model with fields: id, name, email, department id, role id, hire date, and status.
model Employee {
    id          int      primary key auto-increment
    name        string   not null
    email       string   unique not null
    department  int      not null  // Foreign key: Department
    role        int      not null  // Foreign key: Role
    hireDate    date     not null
    status      string   default "active"
}

// Department model with fields: id, name, and description.
model Department {
    id          int      primary key auto-increment
    name        string   unique not null
    description string
}

// Role model with fields: id, title, and permissions defined as a JSON string.
model Role {
    id           int      primary key auto-increment
    title        string   unique not null
    permissions  string   // JSON formatted permissions
}

// Attendance model to record daily attendance of employees.
model Attendance {
    id         int      primary key auto-increment
    employeeId int      not null   // Reference to Employee.id
    date       date     not null
    status     string   not null   // Values such as "present", "absent", or "leave"
}

// Payroll model for salary and compensation details.
model Payroll {
    id         int      primary key auto-increment
    employeeId int      not null   // Reference to Employee.id
    amount     float    not null
    date       date     not null
}

• Ensure that relational integrity is maintained by using proper foreign key constraints.

 
Implementing Authentication & Session Management
 

• Integrate authentication middleware using the lovable-auth module to secure sensitive HR routes.
• Establish session management for users with different roles (Admin, Manager, Employee) to support role-based access control.

// Set up authentication routes and session management

// Route for handling user login
route "/login" {
    method: "POST"
    handler: async (req, res) => {
        let credentials = req.body
        let user = await auth.verify(credentials)  // Verify user credentials using lovable-auth
        if(user) {
            session.create(user)  // Create user session upon successful login
            res.send({ success: true, message: "Login successful" })
        } else {
            res.send({ success: false, message: "Invalid credentials" })
        }
    }
}

// Middleware to enforce authentication on protected routes
middleware authRequired {
    action: (req, res, next) => {
        if(session.exists(req)) {
            next()
        } else {
            res.send({ success: false, message: "Authentication required" })
        }
    }
}

• Apply this authentication middleware on all routes that manipulate sensitive HR data.

 
Defining HR Management Routes & Business Logic
 

• Create RESTful API routes for Employee CRUD operations, Department management, Role assignments, Attendance tracking, and Payroll processing.
• Implement role-based access control by validating user permissions within each route handler.

// Define route for creating a new employee record
route "/employee/create" {
    method: "POST"
    middleware: [ authRequired ]
    handler: async (req, res) => {
        let employeeData = req.body
        // Validate user has permission to create an employee
        if(!session.userHasPermission("create\_employee")) {
            return res.send({ success: false, message: "Permission denied" })
        }
        let newEmployee = await db.Employee.create(employeeData)
        // Notify HR team on successful employee creation
        notification.send({
            type: "success",
            message: "Employee " + newEmployee.name + " has been created successfully."
        })
        res.send({ success: true, data: newEmployee })
    }
}

// Define route for updating employee details
route "/employee/update" {
    method: "PUT"
    middleware: [ authRequired ]
    handler: async (req, res) => {
        let { id, updateData } = req.body
        if(!session.userHasPermission("edit\_employee")) {
            return res.send({ success: false, message: "Permission denied" })
        }
        let updatedEmployee = await db.Employee.update(id, updateData)
        res.send({ success: true, data: updatedEmployee })
    }
}

// Define route for fetching a list of employees with optional filtering
route "/employee/list" {
    method: "GET"
    middleware: [ authRequired ]
    handler: async (req, res) => {
        let filter = req.query || {}
        let employees = await db.Employee.list(filter)
        res.send({ success: true, data: employees })
    }
}

// Similar routes can be created for departments, roles, attendance, and payroll management

• Ensure that each route includes proper error handling and permission checks.

 
Designing the UI & User Workflow
 

• Develop a dynamic dashboard that loads different views based on user roles (Admin, Manager, Employee).
• The user flow should follow: Login -> Dashboard -> Employee List/Detail Views -> Edit and Update Operations -> Logout.
• Utilize the lovable-ui module to create responsive layouts and intuitive forms.

// Define UI behavior for the HR dashboard

// Function to render the dashboard based on the user role
function renderDashboard(user) {
    if(user.role === "Admin" || user.role === "Manager") {
        ui.render("Dashboard", {
            header: "HR Dashboard",
            menu: ["Employees", "Departments", "Payroll", "Attendance"],
            content: loadEmployeeList()  // Function to dynamically load the employee list view
        })
    } else {
        ui.render("Dashboard", {
            header: "My Profile",
            content: loadEmployeeProfile(user.id)  // Function to load a specific employee profile view
        })
    }
}

// Event listener for menu selections to update UI content
ui.on("menuSelect", (menu) => {
    switch(menu) {
        case "Employees":
            ui.updateContent(loadEmployeeList())
            break
        case "Departments":
            ui.updateContent(loadDepartmentList())
            break
        case "Payroll":
            ui.updateContent(loadPayrollInfo())
            break
        case "Attendance":
            ui.updateContent(loadAttendanceRecords())
            break
        default:
            ui.updateContent("Feature coming soon")
    }
})

• Ensure navigation is smooth and the UI components are modular for future enhancements.

 
Integrating Notifications & Error Handling
 

• Implement real-time notifications to alert users on key events such as employee creation and error occurrences.
• Use a global error handler to capture exceptions and provide consistent error messaging across routes.

// Function to trigger notifications for system events
function notifyEvent(eventType, message) {
    notification.send({ type: eventType, message: message })
}

// Global error handling middleware for all routes
middleware errorHandler {
    action: (req, res, next) => {
        try {
            next()
        } catch (error) {
            console.error("System Error: ", error)
            res.send({ success: false, message: "Internal server error" })
        }
    }
}

• Attach the errorHandler middleware globally to ensure application stability and easier debugging.

 
Finalizing & Testing the HR Management System
 

• Perform unit testing for each route and function using Lovable's built-in testing capabilities.
• Simulate real-user scenarios to validate authentication, CRUD operations, UI navigation, and notifications.

// Sample test case for verifying employee creation functionality
test "Create Employee" {
    let testEmployee = {
        name: "John Doe",
        email: "[email protected]",
        department: 1,
        role: 2,
        hireDate: "2023-01-15"
    }
    let response = await request.post("/employee/create").send(testEmployee)
    assert(response.success === true)
    assert(response.data.name === "John Doe")
}

• Review test outcomes and adjust configurations to ensure that the HR management system operates flawlessly on the first run.