Project Introduction

The Job Portal System is a web application designed to connect job seekers with employers, facilitating the job application process. Built using Node.js, this platform allows users to create profiles, post job openings, and apply for jobs. The system supports multiple user roles, including admin, job seeker, and employer, ensuring a tailored experience for each user type. The underlying MySQL database schema is structured to manage users, job postings, applications, resumes, notifications, and reports, providing a robust foundation for effective job management.

Project Objectives

  • To develop a user-friendly interface for job seekers to search and apply for jobs.
  • To implement a secure user authentication system for employers and job seekers.
  • To allow employers to post job openings and manage applications.
  • To enable job seekers to upload resumes and cover letters for job applications.
  • To provide notifications for job seekers regarding application statuses and new job postings.
  • To generate reports for administrators on job postings and application statistics.
  • To ensure the application is scalable and maintainable for future enhancements.

Project Modules

  1. User Management Module:

    This module handles user registration, authentication, and role management, allowing users to manage their accounts securely.

  2. Job Posting Management Module:

    This module allows employers to create, update, and manage job postings, including job details and application deadlines.

  3. Application Management Module:

    This module facilitates the application process, allowing job seekers to apply for jobs and track their application statuses.

  4. Resume Management Module:

    This module enables job seekers to upload and manage their resumes, making it easier to apply for jobs.

  5. Notification Module:

    This module sends notifications to users regarding application updates, new job postings, and other important information.

  6. Reporting Module:

    This module generates reports for administrators on job postings, applications, and user activity.

Steps Overview

Set Up the Project

Create Sequelize Models

Create Repositories

Create Controllers

Create Routes

Create EJS Views

Set Up the Main Application File

Run the Application

Create a Dashboard Page

Step 1: Set Up the Project

Initialize a new Node.js project:


mkdir job-portal
cd job-portal
npm init -y

Install required packages:


npm install express sequelize mysql2 ejs body-parser method-override

Create the project structure:

mkdir models repositories controllers routes views public

Step 2: Create Sequelize Models

Create a file for each model in the models directory. Below are the models based on your SQL schema.

User Model (models/User.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const User = sequelize.define('User ', {
    UserId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Username: {
        type: DataTypes.STRING(50),
        allowNull: false,
        unique: true,
    },
    PasswordHash: {
        type: DataTypes.STRING(256),
        allowNull: false,
    },
    Email: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    Phone: {
        type: DataTypes.STRING(15),
    },
    RoleId: {
        type: DataTypes.INTEGER,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = User;

Role Model (models/Role.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Role = sequelize.define('Role', {
    RoleId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    RoleName: {
        type: DataTypes.STRING(50),
        allowNull: false,
        unique: true,
    },
});
module.exports = Role;

Reservation Model (models/Reservation.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Reservation = sequelize.define('Reservation', {
    ReservationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    GuestId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    RoomId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    CheckInDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CheckOutDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    NumberOfGuests: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Reservation;

Room Model (models/Room.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Room = sequelize.define('Room', {
    RoomId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    RoomNumber: {
        type: DataTypes.STRING(10),
        allowNull: false,
        unique: true,
    },
    RoomType: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    Price: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Room;

Invoice Model (models/Invoice.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Invoice = sequelize.define('Invoice', {
    InvoiceId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    ReservationId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    PaymentStatus: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Invoice;

HousekeepingTask Model (models/HousekeepingTask.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const HousekeepingTask = sequelize.define('HousekeepingTask', {
    TaskId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    RoomId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    TaskDescription: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = HousekeepingTask;

Guest Model (models/Guest.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Guest = sequelize.define('Guest', {
    GuestId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Name: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Email: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Phone: {
        type: DataTypes.STRING(15),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Guest;

Feedback Model (models/Feedback.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Feedback = sequelize.define('Feedback', {
    FeedbackId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Comments: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    Rating: {
        type: DataTypes.INTEGER,
        allowNull: false,
        validate: {
            min: 1,
            max: 5,
        },
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Feedback;

SubscriptionPlan Model (models/SubscriptionPlan.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const SubscriptionPlan = sequelize.define('SubscriptionPlan', {
    PlanId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    PlanName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Price: {
        type: DataTypes.DECIMAL(10, 2),
        allowNull: false,
    },
    DurationInDays: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = SubscriptionPlan;

Payment Model (models/Payment.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Payment = sequelize.define('Payment', {
    PaymentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    PlanId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Amount: {
        type: DataTypes.DECIMAL(10, 2),
        allowNull: false,
    },
    PaymentDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    PaymentMethod: {
        type: DataTypes.STRING(50),
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Completed',
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Payment;

Step 3: Create Repositories

Create a repository for each model in the repositories directory. Below is an example for the User repository.

User Repository (repositories/UserRepository.js):


const User = require('../models/User');
class UserRepository {
    async getAllUsers() {
        return await User.findAll();
    }
    async getUser ById(id) {
        return await User.findByPk(id);
    }
    async createUser (userData) {
        return await User.create(userData);
    }
    async updateUser (id, userData) {
        const user = await this.getUser ById(id);
        if (user) {
            return await user.update(userData);
        }
        throw new Error('User  not found');
    }
    async deleteUser (id) {
        const user = await this.getUser ById(id);
        if (user) {
            return await user.destroy();
        }
        throw new Error('User  not found');
    }
}
module.exports = new UserRepository();

Step 4: Create Controllers

Create a controller for each model in the controllers directory. Below is an example for the User controller.

User Controller (controllers/UserController.js):


const UserRepository = require('../repositories/UserRepository');
class UserController {
    async listUsers(req, res) {
        try {
            const users = await UserRepository.getAllUsers();
            res.render('users/list', { users });
        } catch (error) {
            console.error('Error fetching users:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async showUser (req, res) {
        try {
            const user = await UserRepository.getUser ById(req.params.id);
            if (user) {
                res.render('users/show', { user });
            } else {
                res.status(404).send('User  not found');
            }
        } catch (error) {
            console.error('Error fetching user:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async createUser (req, res) {
        try {
            await UserRepository.createUser (req.body);
            res.redirect('/users');
        } catch (error) {
            console.error('Error creating user:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async updateUser (req, res) {
        try {
            await UserRepository.updateUser (req.params.id, req.body);
            res.redirect('/users');
        } catch (error) {
            console.error('Error updating user:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async deleteUser (req, res) {
        try {
            await UserRepository.deleteUser (req.params.id);
            res.redirect('/users');
        } catch (error) {
            console.error('Error deleting user:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new UserController();

Step 5: Create Routes

Create a route for each model in the routes directory. Below is an example for the User routes.

User Routes (routes/userRoutes.js):


const express = require('express');
const router = express.Router();
const UserController = require('../controllers/UserController');
router.get('/', UserController.listUsers);
router.get('/:id', UserController.showUser );
router.post('/', UserController.createUser );
router.put('/:id', UserController.updateUser );
router.delete('/:id', UserController.deleteUser );
module.exports = router;

Step 6: Create EJS Views

Create EJS views for listing, showing, creating, and editing users in the views/users directory.

List Users View (views/users/list.ejs):


<%- include('../partials/header') %>
<h1>Users</h1>
<a href="/users/new" class="btn btn-primary">Add User</a>
<table class="table">
    <thead>
        <tr>
            <th>Username</th>
            <th>Email</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% users.forEach(user => { %>
            <tr>
                <td><%= user.Username %></td>
                <td><%= user.Email %></td>
                <td>
                    <a href="/users/<%= user.UserId %>" class="btn btn-info">View</a>
                    <form action="/users/<%= user.UserId %>?_method=DELETE" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>
<%- include('../partials/footer') %>

Show User View (views/users/show.ejs):


<%- include('../partials/header') %>
<h1>User Details</h1>
<p>Username: <%= user.Username %></p>
<p>Email: < <%= user.Email %></p>
<a href="/users" class="btn btn-secondary">Back to Users</a>
<%- include('../partials/footer') %>

Create User View (views/users/new.ejs):


<%- include('../partials/header') %>
<h1>Add User</h1>
<form action="/users" method="POST">
    <div class="mb-3">
        <label for="Username" class="form-label">Username</label>
        <input type="text" class="form-control" id="Username" name="Username" required>
    </div>
    <div class="mb-3">
        <label for="Email" class="form-label">Email</label>
        <input type="email" class="form-control" id="Email" name="Email" required>
    </div>
    <div class="mb-3">
        <label for="PasswordHash" class="form-label">Password</label>
        <input type="password" class="form-control" id="PasswordHash" name="PasswordHash" required>
    </div>
    <button type="submit" class="btn btn-primary">Create User</button>
</form>
<%- include('../partials/footer') %>

Edit User View (views/users/edit.ejs):


<%- include('../partials/header') %>
<h1>Edit User</h1>
<form action="/users/<%= user.UserId %>?_method=PUT" method="POST">
    <div class="mb-3">
        <label for="Username" class="form-label">Username</label>
        <input type="text" class="form-control" id="Username" name="Username" value="<%= user.Username %>" required>
    </div>
    <div class="mb-3">
        <label for="Email" class="form-label">Email</label>
        <input type="email" class="form-control" id="Email" name="Email" value="<%= user.Email %>" required>
    </div>
    <button type="submit" class="btn btn-primary">Update User</button>
</form>
<%- include('../partials/footer') %>

Step 7: Set Up the Main Application File

Update your main application file (app.js) to include the user routes and set up the view engine.


const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const path = require('path');
const userRoutes = require('./routes/userRoutes');
const sequelize = require('./config');
const app = express();
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/users', userRoutes);
const PORT = process.env.PORT || 3000;
sequelize.sync().then(() => {
    app.listen(PORT, () => console.log(`Server is running on http://localhost:${PORT}`));
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

Step 8: Run the Application

Start the application:


node app.js

Access the application in your browser: Navigate to http://localhost:3000/users to see the user management interface.

Step 9: Create a Dashboard Page

You can create a dashboard page similar to the previous example, consolidating data from the various models. This will involve creating a new controller, route, and view for the dashboard, allowing you to display relevant statistics and information about users, jobs, applications, and more.

This setup provides a complete CRUD application for managing users, and you can replicate similar steps for other models like Roles, Jobs, Resumes, Applications, CompanyProfiles, Notifications, Feedbacks, SubscriptionPlans, and Payments by creating their respective models, repositories, controllers, routes, and views.

Step 1: Create Remaining Models

Job Model (models/Job.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Job = sequelize.define('Job', {
    JobId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    EmployerId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    JobTitle: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    JobDescription: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    JobType: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    Location: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Salary: {
        type: DataTypes.DECIMAL(10, 2),
    },
    PostedDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    ExpirationDate: {
        type: DataTypes.DATE,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Job;

Resume Model (models/Resume.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Resume = sequelize.define('Resume', {
    ResumeId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    JobSeekerId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ResumeFile: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Resume;

Application Model (models/Application.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Application = sequelize.define('Application', {
    ApplicationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    JobId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    JobSeekerId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ApplicationDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Pending',
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Application;

CompanyProfile Model (models/CompanyProfile.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const CompanyProfile = sequelize.define('CompanyProfile', {
    CompanyId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    EmployerId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    CompanyName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    Website: {
        type: DataTypes.STRING(255),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = CompanyProfile;

Notification Model (models/Notification.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Notification = sequelize.define('Notification', {
    NotificationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Message: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    IsRead: {
        type: DataTypes.BOOLEAN,
        defaultValue: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Notification;

Feedback Model (models/Feedback.js):


const { DataTypes } = require('sequelize');
const sequelize = require('../config');
const Feedback = sequelize.define('Feedback', {
    FeedbackId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    GuestId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Comments: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    Rating: {
        type: DataTypes.INTEGER,
        allowNull: false,
        validate: {
            min: 1,
            max: 5,
        },
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Feedback;

Step 2: Create Repositories for Remaining Models

Job Repository (repositories/JobRepository.js):


const Job = require('../models/Job');
class JobRepository {
    async getAllJobs() {
        return await Job.findAll();
    }
    async getJobById(id) {
        return await Job.findByPk(id);
    }
    async createJob(jobData) {
        return await Job.create(jobData);
    }
    async updateJob(id, jobData) {
        const job = await this.getJobById(id);
        if (job) {
            return await job.update(jobData);
        }
        throw new Error('Job not found');
    }
    async deleteJob(id) {
        const job = await this.getJobById(id);
        if (job) {
            return await job.destroy();
        }
        throw new Error('Job not found');
    }
}
module.exports = new JobRepository();

Resume Repository (repositories/ResumeRepository.js):


const Resume = require('../models/Resume');
class ResumeRepository {
    async getAllResumes() {
        return await Resume.findAll();
    }
    async getResumeById(id) {
        return await Resume.findByPk(id);
    }
    async createResume(resumeData) {
        return await Resume.create(resumeData);
    }
    async updateResume(id, resumeData) {
        const resume = await this.getResumeById(id);
        if (resume) {
            return await resume.update(resumeData);
        }
        throw new Error('Resume not found');
    }
    async deleteResume(id) {
        const resume = await this.getResumeById(id);
        if (resume) {
            return await resume.destroy();
        }
        throw new Error('Resume not found');
    }
}
module.exports = new ResumeRepository();

Application Repository (repositories/ApplicationRepository.js):


const Application = require('../models/Application');
class ApplicationRepository {
    async getAllApplications() {
        return await Application.findAll();
    }
    async getApplicationById(id) {
        return await Application.findByPk(id);
    }
    async createApplication(applicationData) {
        return await Application.create(applicationData);
    }
    async updateApplication(id, applicationData) {
        const application = await this.getApplicationById(id);
        if (application) {
            return await application.update(applicationData);
        }
        throw new Error('Application not found');
    }
    async deleteApplication(id) {
        const application = await this.getApplicationById(id);
        if (application) {
            return await application.destroy();
        }
        throw new Error('Application not found');
    }
}
module.exports = new ApplicationRepository();

CompanyProfile Repository (repositories/CompanyProfileRepository.js):


const CompanyProfile = require('../models/CompanyProfile');
class CompanyProfileRepository {
    async getAllCompanyProfiles() {
        return await CompanyProfile.findAll();
    }
    async getCompanyProfileById(id) {
        return await CompanyProfile.findByPk(id);
    }
    async createCompanyProfile(companyProfileData) {
        return await CompanyProfile.create(companyProfileData);
    }
    async updateCompanyProfile(id, companyProfileData) {
        const companyProfile = await this.getCompanyProfileById(id);
        if (companyProfile) {
            return await companyProfile.update(companyProfileData);
        }
        throw new Error('Company Profile not found');
    }
    async deleteCompanyProfile(id) {
        const companyProfile = await this.getCompanyProfileById(id);
        if (companyProfile) {
            return await companyProfile.destroy();
        }
        throw new Error('Company Profile not found');
    }
}
module.exports = new CompanyProfileRepository();

Notification Repository (repositories/NotificationRepository.js):


const Notification = require('../models/Notification');
class NotificationRepository {
    async getAllNotifications() {
        return await Notification.findAll();
    }
    async getNotificationById(id) {
        return await Notification.findByPk(id);
    }
    async createNotification(notificationData) {
        return await Notification.create(notificationData);
    }
    async updateNotification(id, notificationData) {
        const notification = await this.getNotificationById(id );
        if (notification) {
            return await notification.update(notificationData);
        }
        throw new Error('Notification not found');
    }
    async deleteNotification(id) {
        const notification = await this.getNotificationById(id);
        if (notification) {
            return await notification.destroy();
        }
        throw new Error('Notification not found');
    }
}
module.exports = new NotificationRepository();

Feedback Repository (repositories/FeedbackRepository.js):


const Feedback = require('../models/Feedback');
class FeedbackRepository {
    async getAllFeedbacks() {
        return await Feedback.findAll();
    }
    async getFeedbackById(id) {
        return await Feedback.findByPk(id);
    }
    async createFeedback(feedbackData) {
        return await Feedback.create(feedbackData);
    }
    async updateFeedback(id, feedbackData) {
        const feedback = await this.getFeedbackById(id);
        if (feedback) {
            return await feedback.update(feedbackData);
        }
        throw new Error('Feedback not found');
    }
    async deleteFeedback(id) {
        const feedback = await this.getFeedbackById(id);
        if (feedback) {
            return await feedback.destroy();
        }
        throw new Error('Feedback not found');
    }
}
module.exports = new FeedbackRepository();

Step 3: Create Controllers for Remaining Models

Job Controller (controllers/JobController.js):


const JobRepository = require('../repositories/JobRepository');
class JobController {
    async listJobs(req, res) {
        try {
            const jobs = await JobRepository.getAllJobs();
            res.render('jobs/list', { jobs });
        } catch (error) {
            console.error('Error fetching jobs:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async showJob(req, res) {
        try {
            const job = await JobRepository.getJobById(req.params.id);
            if (job) {
                res.render('jobs/show', { job });
            } else {
                res.status(404).send('Job not found');
            }
        } catch (error) {
            console.error('Error fetching job:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async createJob(req, res) {
        try {
            await JobRepository.createJob(req.body);
            res.redirect('/jobs');
        } catch (error) {
            console.error('Error creating job:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async updateJob(req, res) {
        try {
            await JobRepository.updateJob(req.params.id, req.body);
            res.redirect('/jobs');
        } catch (error) {
            console.error('Error updating job:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async deleteJob(req, res) {
        try {
            await JobRepository.deleteJob(req.params.id);
            res.redirect('/jobs');
        } catch (error) {
            console.error('Error deleting job:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new JobController();

Resume Controller (controllers/ResumeController.js):


const ResumeRepository = require('../repositories/ResumeRepository');
class ResumeController {
    async listResumes(req, res) {
        try {
            const resumes = await ResumeRepository.getAllResumes();
            res.render('resumes/list', { resumes });
        } catch (error) {
            console.error('Error fetching resumes:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async showResume(req, res) {
        try {
            const resume = await ResumeRepository.getResumeById(req.params.id);
            if (resume) {
                res.render('resumes/show', { resume });
            } else {
                res.status(404).send('Resume not found');
            }
        } catch (error) {
            console.error('Error fetching resume:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async createResume(req, res) {
        try {
            await ResumeRepository.createResume(req.body);
            res.redirect('/resumes');
        } catch (error) {
            console.error('Error creating resume:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async updateResume(req, res) {
        try {
            await ResumeRepository.updateResume(req.params.id, req.body);
            res.redirect('/resumes');
        } catch (error) {
            console.error('Error updating resume:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async deleteResume(req, res) {
        try {
await ResumeRepository.deleteResume(req.params.id); res.redirect('/resumes'); } catch (error) { console.error('Error deleting resume:', error); res.status(500).send('Internal Server Error'); } } }
module.exports = new ResumeController();

Application Controller (controllers/ApplicationController.js):


const ApplicationRepository = require('../repositories/ApplicationRepository');
class ApplicationController {
    async listApplications(req, res) {
        try {
            const applications = await ApplicationRepository.getAllApplications();
            res.render('applications/list', { applications });
        } catch (error) {
            console.error('Error fetching applications:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async showApplication(req, res) {
        try {
            const application = await ApplicationRepository.getApplicationById(req.params.id);
            if (application) {
                res.render('applications/show', { application });
            } else {
                res.status(404).send('Application not found');
            }
        } catch (error) {
            console.error('Error fetching application:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async createApplication(req, res) {
        try {
            await ApplicationRepository.createApplication(req.body);
            res.redirect('/applications');
        } catch (error) {
            console.error('Error creating application:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async updateApplication(req, res) {
        try {
            await ApplicationRepository.updateApplication(req.params.id, req.body);
            res.redirect('/applications');
        } catch (error) {
            console.error('Error updating application:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async deleteApplication(req, res) {
        try {
            await ApplicationRepository.deleteApplication(req.params.id);
            res.redirect('/applications');
        } catch (error) {
            console.error('Error deleting application:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new ApplicationController();

CompanyProfile Controller (controllers/CompanyProfileController.js):


const CompanyProfileRepository = require('../repositories/CompanyProfileRepository');
class CompanyProfileController {
    async listCompanyProfiles(req, res) {
        try {
            const companyProfiles = await CompanyProfileRepository.getAllCompanyProfiles();
            res.render('companyProfiles/list', { companyProfiles });
        } catch (error) {
            console.error('Error fetching company profiles:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async showCompanyProfile(req, res) {
        try {
            const companyProfile = await CompanyProfileRepository.getCompanyProfileById(req.params.id);
            if (companyProfile) {
                res.render('companyProfiles/show', { companyProfile });
            } else {
                res.status(404).send('Company Profile not found');
            }
        } catch (error) {
            console.error('Error fetching company profile:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async createCompanyProfile(req, res) {
        try {
            await CompanyProfileRepository.createCompanyProfile(req.body);
            res.redirect('/companyProfiles');
        } catch (error) {
            console.error('Error creating company profile:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async updateCompanyProfile(req, res) {
        try {
            await CompanyProfileRepository.updateCompanyProfile(req.params.id, req.body);
            res.redirect('/companyProfiles');
        } catch (error) {
            console.error('Error updating company profile:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async deleteCompanyProfile(req, res) {
        try {
            await CompanyProfileRepository.deleteCompanyProfile(req.params.id);
            res.redirect('/companyProfiles');
        } catch (error) {
            console.error('Error deleting company profile:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new CompanyProfileController();

Notification Controller (controllers/NotificationController.js):


const NotificationRepository = require('../repositories/NotificationRepository');
class NotificationController {
    async listNotifications(req, res) {
        try {
            const notifications = await NotificationRepository.getAllNotifications();
            res.render('notifications/list', { notifications });
        } catch (error) {
            console.error('Error fetching notifications:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async showNotification(req, res) {
        try {
            const notification = await NotificationRepository.getNotificationById(req.params.id);
            if (notification) {
                res.render('notifications/show ', { notification });
            } else {
                res.status(404).send('Notification not found');
            }
        } catch (error) {
            console.error('Error fetching notification:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async createNotification(req, res) {
        try {
            await NotificationRepository.createNotification(req.body);
            res.redirect('/notifications');
        } catch (error) {
            console.error('Error creating notification:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async updateNotification(req, res) {
        try {
            await NotificationRepository.updateNotification(req.params.id, req.body);
            res.redirect('/notifications');
        } catch (error) {
            console.error('Error updating notification:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async deleteNotification(req, res) {
        try {
            await NotificationRepository.deleteNotification(req.params.id);
            res.redirect('/notifications');
        } catch (error) {
            console.error('Error deleting notification:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new NotificationController();

Feedback Controller (controllers/FeedbackController.js):


const FeedbackRepository = require('../repositories/FeedbackRepository');
class FeedbackController {
    async listFeedbacks(req, res) {
        try {
            const feedbacks = await FeedbackRepository.getAllFeedbacks();
            res.render('feedbacks/list', { feedbacks });
        } catch (error) {
            console.error('Error fetching feedbacks:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async showFeedback(req, res) {
        try {
            const feedback = await FeedbackRepository.getFeedbackById(req.params.id);
            if (feedback) {
                res.render('feedbacks/show', { feedback });
            } else {
                res.status(404).send('Feedback not found');
            }
        } catch (error) {
            console.error('Error fetching feedback:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async createFeedback(req, res) {
        try {
            await FeedbackRepository.createFeedback(req.body);
            res.redirect('/feedbacks');
        } catch (error) {
            console.error('Error creating feedback:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async updateFeedback(req, res) {
        try {
            await FeedbackRepository.updateFeedback(req.params.id, req.body);
            res.redirect('/feedbacks');
        } catch (error) {
            console.error('Error updating feedback:', error);
            res.status(500).send('Internal Server Error');
        }
    }
    async deleteFeedback(req, res) {
        try {
            await FeedbackRepository.deleteFeedback(req.params.id);
            res.redirect('/feedbacks');
        } catch (error) {
            console.error('Error deleting feedback:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new FeedbackController();

Step 4: Create Routes for Remaining Models

Job Routes (routes/jobRoutes.js):


const express = require('express');
const router = express.Router();
const JobController = require('../controllers/JobController');
router.get('/', JobController.listJobs);
router.get('/:id', JobController.showJob);
router.post('/', JobController.createJob);
router.put('/:id', JobController.updateJob);
router.delete('/:id', JobController.deleteJob);
module.exports = router;

Resume Routes (routes/resumeRoutes.js):


const express = require('express');
const router = express.Router();
const ResumeController = require('../controllers/ResumeController');
router.get('/', ResumeController.listResumes);
router.get('/:id', ResumeController.showResume);
router.post('/', ResumeController.createResume);
router.put('/:id', ResumeController.updateResume);
router.delete('/:id', ResumeController.deleteResume);
module.exports = router;

Application Routes (routes/applicationRoutes.js):


const express = require('express');
const router = express.Router();
const ApplicationController = require('../controllers/ApplicationController');
router.get('/', ApplicationController.listApplications);
router.get('/:id', ApplicationController.showApplication);
router.post('/', ApplicationController.createApplication);
router.put('/:id', ApplicationController.updateApplication);
router.delete('/:id', ApplicationController.deleteApplication);
module.exports = router;

CompanyProfile Routes (routes/companyProfileRoutes.js):


const express = require('express');
const router = express.Router();
const CompanyProfileController = require('../controllers/ CompanyProfileController');
router.get('/', CompanyProfileController.listCompanyProfiles);
router.get('/:id', CompanyProfileController.showCompanyProfile);
router.post('/', CompanyProfileController.createCompanyProfile);
router.put('/:id', CompanyProfileController.updateCompanyProfile);
router.delete('/:id', CompanyProfileController.deleteCompanyProfile);
module.exports = router;

Notification Routes (routes/notificationRoutes.js):


const express = require('express');
const router = express.Router();
const NotificationController = require('../controllers/NotificationController');
router.get('/', NotificationController.listNotifications);
router.get('/:id', NotificationController.showNotification);
router.post('/', NotificationController.createNotification);
router.put('/:id', NotificationController.updateNotification);
router.delete('/:id', NotificationController.deleteNotification);
module.exports = router;

Feedback Routes (routes/feedbackRoutes.js):


const express = require('express');
const router = express.Router();
const FeedbackController = require('../controllers/FeedbackController');
router.get('/', FeedbackController.listFeedbacks);
router.get('/:id', FeedbackController.showFeedback);
router.post('/', FeedbackController.createFeedback);
router.put('/:id', FeedbackController.updateFeedback);
router.delete('/:id', FeedbackController.deleteFeedback);
module.exports = router;

Step 5: Create EJS Views for Remaining Models

Job Views:

List Jobs View (views/jobs/list.ejs):


<%- include('../partials/header') %>
<h1>Jobs</h1>
<a href="/jobs/new" class="btn btn-primary">Add Job</a>
<table class="table">
    <thead>
        <tr>
            <th>Job Title</th>
            <th>Employer ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% jobs.forEach(job => { %>
            <tr>
                <td><%= job.JobTitle %></td>
                <td><%= job.EmployerId %></td>
                <td>
                    <a href="/jobs/<%= job.JobId %>" class="btn btn-info">View</a>
                    <form action="/jobs/<%= job.JobId %>?_method=DELETE" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>
<%- include('../partials/footer') %>

Show Job View (views/jobs/show.ejs):


<%- include('../partials/header') %>
<h1>Job Details</h1>
<p>Job Title: <%= job.JobTitle %></p>
<p>Job Description: <%= job.JobDescription %></p>
<a href="/jobs" class="btn btn-secondary">Back to Jobs</a>
<%- include('../partials/footer') %>

Create Job View (views/jobs/new.ejs):


<%- include('../partials/header') %>
<h1>Add Job</h1>
<form action="/jobs" method="POST">
    <div class="mb-3">
        <label for="JobTitle" class="form-label">Job Title</label>
        <input type="text" class="form-control" id="JobTitle" name="JobTitle" required>
    </div>
    <div class="mb-3">
        <label for="JobDescription" class="form-label">Job Description</label>
        <textarea class="form-control" id="JobDescription" name="JobDescription" required></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Job</button>
</form>
<%- include('../partials/footer') %>

Resume Views:

List Resumes View (views/resumes/list.ejs):


<%- include('../partials/header') %>
<h1>Resumes</h1>
<a href="/resumes/new" class="btn btn-primary">Add Resume</a>
<table class="table">
    <thead>
        <tr>
            <th>Resume ID</th>
            <th>Job Seeker ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% resumes.forEach(resume => { %>
            <tr>
                <td><%= resume.ResumeId %></td>
                <td><%= resume.JobSeekerId %></ <td>
                    <a href="/resumes/<%= resume.ResumeId %>" class="btn btn-info">View</a>
                    <form action="/resumes/<%= resume.ResumeId %>?_method=DELETE" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>
<%- include('../partials/footer') %>

Show Resume View (views/resumes/show.ejs):


<%- include('../partials/header') %>
<h1>Resume Details</h1>
<p>Resume ID: <%= resume.ResumeId %></p>
<p>Job Seeker ID: <%= resume.JobSeekerId %></p>
<p>Resume File: <%= resume.ResumeFile %></p>
<a href="/resumes" class="btn btn-secondary">Back to Resumes</a>
<%- include('../partials/footer') %>

Create Resume View (views/resumes/new.ejs):


<%- include('../partials/header') %>
<h1>Add Resume</h1>
<form action="/resumes" method="POST">
    <div class="mb-3">
        <label for="JobSeekerId" class="form-label">Job Seeker ID</label>
        <input type="number" class="form-control" id="JobSeekerId" name="JobSeekerId" required>
    </div>
    <div class="mb-3">
        <label for="ResumeFile" class="form-label">Resume File</label>
        <input type="text" class="form-control" id="ResumeFile" name="ResumeFile" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Resume</button>
</form>
<%- include('../partials/footer') %>

Application Views:

List Applications View (views/applications/list.ejs):


<%- include('../partials/header') %>
<h1>Applications</h1>
<a href="/applications/new" class="btn btn-primary">Add Application</a>
<table class="table">
    <thead>
        <tr>
            <th>Application ID</th>
            <th>Job ID</th>
            <th>Job Seeker ID</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% applications.forEach(application => { %>
            <tr>
                <td><%= application.ApplicationId %></td>
                <td><%= application.JobId %></td>
                <td><%= application.JobSeekerId %></td>
                <td>
                    <a href="/applications/<%= application.ApplicationId %>" class="btn btn-info">View</a>
                    <form action="/applications/<%= application.ApplicationId %>?_method=DELETE" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>
<%- include('../partials/footer') %>

Show Application View (views/applications/show.ejs):


<%- include('../partials/header') %>
<h1>Application Details</h1>
<p>Application ID: <%= application.ApplicationId %></p>
<p>Job ID: <%= application.JobId %></p>
<p>Job Seeker ID: <%= application.JobSeekerId %></p>
<p>Status: <%= application.Status %></p>
<a href="/applications" class="btn btn-secondary">Back to Applications</a>
<%- include('../partials/footer') %>

Create Application View (views/applications/new.ejs):


<%- include('../partials/header') %>
<h1>Add Application</h1>
<form action="/applications" method="POST">
    <div class="mb-3">
        <label for="JobId" class="form-label">Job ID</label>
        <input type="number" class="form-control" id="JobId" name="JobId" required>
    </div>
    <div class="mb-3">
        <label for="JobSeekerId" class="form-label">Job Seeker ID</label>
        <input type="number" class="form-control" id="Job SeekerId" name="JobSeekerId" required>
    </div>
    <button type="submit" class="btn btn-primary">Create Application</button>
</form>
<%- include('../partials/footer') %>

CompanyProfile Views:

List CompanyProfiles View (views/companyProfiles/list.ejs):


<%- include('../partials/header') %>
<h1>Company Profiles</h1>
<a href="/companyProfiles/new" class="btn btn-primary">Add Company Profile</a>
<table class="table">
    <thead>
        <tr>
            <th>Company ID</th>
            <th>Employer ID</th>
            <th>Company Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% companyProfiles.forEach(companyProfile => { %>
            <tr>
                <td><%= companyProfile.CompanyId %></td>
                <td><%= companyProfile.EmployerId %></td>
                <td><%= companyProfile.CompanyName %></td>
                <td>
                    <a href="/companyProfiles/<%= companyProfile.CompanyId %>" class="btn btn-info">View</a>
                    <form action="/companyProfiles/<%= companyProfile.CompanyId %>?_method=DELETE" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>
<%- include('../partials/footer') %>

Show CompanyProfile View (views/companyProfiles/show.ejs):


<%- include('../partials/header') %>
<h1>Company Profile Details</h1>
<p>Company ID: <%= companyProfile.CompanyId %></p>
<p>Employer ID: <%= companyProfile.EmployerId %></p>
<p>Company Name: <%= companyProfile.CompanyName %></p>
<p>Description: <%= companyProfile.Description %></p>
<a href="/companyProfiles" class="btn btn-secondary">Back to Company Profiles</a>
<%- include('../partials/footer') %>

Create CompanyProfile View (views/companyProfiles/new.ejs):


<%- include('../partials/header') %>
<h1>Add Company Profile</h1>
<form action="/companyProfiles" method="POST">
    <div class="mb-3">
        <label for="EmployerId" class="form-label">Employer ID</label>
        <input type="number" class="form-control" id="EmployerId" name="EmployerId" required>
    </div>
    <div class="mb-3">
        <label for="CompanyName" class="form-label">Company Name</label>
        <input type="text" class="form-control" id="CompanyName" name="CompanyName" required>
    </div>
    <div class="mb-3">
        <label for="Description" class="form-label">Description</label>
        <textarea class="form-control" id="Description" name="Description"></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Company Profile</button>
</form>
<%- include('../partials/footer') %>

Notification Views:

List Notifications View (views/notifications/list.ejs):


<%- include('../partials/header') %>
<h1>Notifications</h1>
<a href="/notifications/new" class="btn btn-primary">Add Notification</a>
<table class="table">
    <thead>
        <tr>
            <th>Notification ID</th>
            <th>User ID</th>
            <th>Message</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% notifications.forEach(notification => { %>
            <tr>
                <td><%= notification.NotificationId %></td>
                <td><%= notification.UserId %></td>
                <td><%= notification.Message %></td>
                <td>
                    <a href="/notifications/<%= notification.NotificationId %>" class="btn btn-info">View</a>
                    <form action="/notifications/<%= notification.NotificationId %>?_method=DELETE" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>
</%- include('../partials/footer') %>

Show Notification View (views/notifications/show.ejs):

<%- include('../partials/header') %>
<h1>Notification Details</h1>
<p>Notification ID: <%= notification.NotificationId %></p>
<p>User ID: <%= notification.UserId %></p>
<p>Message: <%= notification.Message %></p>
<p>Is Read: <%= notification.IsRead ? 'Yes' : 'No' %></p>
<a href="/notifications" class="btn btn-secondary">Back to Notifications</a>
<%- include('../partials/footer') %>

Create Notification View (views/notifications/new.ejs):


<%- include('../partials/header') %>
<h1>Add Notification</h1>
<form action="/notifications" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type="number" class="form-control" id="User Id" name="User Id" required>
    </div>
    <div class="mb-3">
        <label for="Message" class="form-label">Message</label>
        <textarea class="form-control" id="Message" name="Message" required></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Create Notification</button>
</form>
<%- include('../partials/footer') %>

Feedback Views:

List Feedbacks View (views/feedbacks/list.ejs):


<%- include('../partials/header') %>
<h1>Feedbacks</h1>
<a href="/feedbacks/new" class="btn btn-primary">Add Feedback</a>
<table class="table">
    <thead>
        <tr>
            <th>Feedback ID</th>
            <th>User ID</th>
            <th>Comments</th>
            <th>Rating</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        <% feedbacks.forEach(feedback => { %>
            <tr>
                <td><%= feedback.FeedbackId %></td>
                <td><%= feedback.UserId %></td>
                <td><%= feedback.Comments %></td>
                <td><%= feedback.Rating %></td>
                <td>
                    <a href="/feedbacks/<%= feedback.FeedbackId %>" class="btn btn-info">View</a>
                    <form action="/feedbacks/<%= feedback.FeedbackId %>?_method=DELETE" method="POST" style="display:inline;">
                        <button type="submit" class="btn btn-danger">Delete</button>
                    </form>
                </td>
            </tr>
        <% }) %>
    </tbody>
</table>
<%- include('../partials/footer') %>

Show Feedback View (views/feedbacks/show.ejs):


<%- include('../partials/header') %>
<h1>Feedback Details</h1>
<p>Feedback ID: <%= feedback.FeedbackId %></p>
<p>User ID: <%= feedback.UserId %></p>
<p>Comments: <%= feedback.Comments %></p>
<p>Rating: <%= feedback.Rating %></p>
<a href="/feedbacks" class="btn btn-secondary">Back to Feedbacks</a>
<%- include('../partials/footer') %>

Create Feedback View (views/feedbacks/new.ejs):


<%- include('../partials/header') %>
<h1>Add Feedback</h1>
<form action="/feedbacks" method="POST">
    <div class="mb-3">
        <label for="User Id" class="form-label">User  ID</label>
        <input type="number" class="form-control" id="User Id" name="User Id" required>
    </div>
    <div class="mb-3">
        <label for="Comments" class="form-label">Comments</label>
        <textarea class="form-control" id="Comments" name="Comments" required></textarea>
    </div>
    <div class="mb-3">
        <label for="Rating" class="form-label">Rating</label>
        <input type="number" class="form-control" id="Rating" name="Rating" min="1" max="5" required>
    </div>
    <button type=" submit" class="btn btn-primary">Create Feedback</button>
</form>
<%- include('../partials/footer') %>

Step 6: Update Main Application File

In your main application file (app.js), include the routes for the remaining models:


const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const path = require('path');
const userRoutes = require('./routes/userRoutes');
const jobRoutes = require('./routes/jobRoutes');
const resumeRoutes = require('./routes/resumeRoutes');
const applicationRoutes = require('./routes/applicationRoutes');
const companyProfileRoutes = require('./routes/companyProfileRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const sequelize = require('./config');
const app = express();
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/users', userRoutes);
app.use('/jobs', jobRoutes);
app.use('/resumes', resumeRoutes);
app.use('/applications', applicationRoutes);
app.use('/companyProfiles', companyProfileRoutes);
app.use('/notifications', notificationRoutes);
app.use('/feedbacks', feedbackRoutes);
const PORT = process.env.PORT || 3000;
sequelize.sync().then(() => {
    app.listen(PORT, () => console.log(`Server is running on http://localhost:${PORT}`));
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

Step 7: Run the Application

Start the application:


node app.js

Access the application in your browser: Navigate to the respective routes (e.g., http://localhost:3000/users, http://localhost:3000/jobs, etc.) to see the management interfaces for each model.

Creating a Dashboard Page

To create a dashboard page that consolidates data related to the job portal project, we will follow these steps:

Create a Dashboard Route

Create a Dashboard Controller

Create a Dashboard View

Update the Main Application File to Include the Dashboard Route

Step 1: Create a Dashboard Route

Create a new file for the dashboard routes (routes/dashboardRoutes.js):


const express = require('express');
const router = express.Router();
const DashboardController = require('../controllers/DashboardController');
router.get('/', DashboardController.showDashboard);
module.exports = router;

Step 2: Create a Dashboard Controller

Create a new file for the dashboard controller (controllers/DashboardController.js):


const UserRepository = require('../repositories/UserRepository');
const JobRepository = require('../repositories/JobRepository');
const ReservationRepository = require('../repositories/ReservationRepository');
const ApplicationRepository = require('../repositories/ApplicationRepository');
const GuestRepository = require('../repositories/GuestRepository');
class DashboardController {
    async showDashboard(req, res) {
        try {
            const totalUsers = await UserRepository.getAllUsers();
            const totalJobs = await JobRepository.getAllJobs();
            const totalReservations = await ReservationRepository.getAllReservations();
            const totalApplications = await ApplicationRepository.getAllApplications();
            const totalGuests = await GuestRepository.getAllGuests();
            res.render('dashboard', {
                totalUsers: totalUsers.length,
                totalJobs: totalJobs.length,
                totalReservations: totalReservations.length,
                totalApplications: totalApplications.length,
                totalGuests: totalGuests.length,
            });
        } catch (error) {
            console.error('Error fetching dashboard data:', error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new DashboardController();

Step 3: Create a Dashboard View

Create a new view file for the dashboard (views/dashboard.ejs):


<%- include('partials/header') %>
<h1>Dashboard</h1>
<div class="row">
    <div class="col-md-3">
        <div class="card text-white bg-primary mb-3">
            <div class="card-header">Total Users</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalUsers %></h5>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="card text-white bg-success mb-3">
            <div class="card-header">Total Jobs</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalJobs %></h5>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="card text-white bg-warning mb-3">
            <div class="card-header">Total Reservations</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalReservations %></h5>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="card text-white bg-danger mb-3">
            <div class="card-header">Total Applications</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalApplications %></h5>
            </div>
        </div>
    </div>
    <div class="col-md-3">
        <div class="card text-white bg-info mb-3">
            <div class="card-header">Total Guests</div>
            <div class="card-body">
                <h5 class="card-title"><%= totalGuests %></h5>
            </div>
        </div>
    </div>
</div>
<%- include('partials/footer') %>

Step 4: Update the Main Application File

Update your main application file (app.js) to include the dashboard route:


const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const path = require('path');
const userRoutes = require('./routes/userRoutes');
const jobRoutes = require('./routes/jobRoutes');
const reservationRoutes = require('./routes/reservationRoutes');
const applicationRoutes = require('./routes/applicationRoutes');
const companyProfileRoutes = require('./routes/companyProfileRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const menuItemRoutes = require('./routes/menuItemRoutes');
const eventBookingRoutes = require('./routes/eventBookingRoutes');
const promotionRoutes = require('./routes/promotionRoutes');
const dashboardRoutes = require('./routes/dashboardRoutes');
const sequelize = require('./config');
const app = express();
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/users', userRoutes);
app.use('/jobs', jobRoutes);
app.use('/reservations', reservationRoutes);
app.use('/applications', applicationRoutes);
app.use('/companyProfiles', companyProfileRoutes);
app.use('/notifications', notificationRoutes);
app.use('/feedbacks', feedbackRoutes);
app.use('/menu-items', menuItemRoutes);
app.use('/event-bookings', eventBookingRoutes);
app.use('/promotions', promotionRoutes);
app.use('/dashboard', dashboardRoutes);
const PORT = process.env.PORT || 3000;
sequelize.sync().then(() => {
    app.listen(PORT, () => console.log(`Server is running on http://localhost :3000`));
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

With these steps, you have created a dashboard page that consolidates data related to the project. The dashboard displays the total number of users, jobs, reservations, applications, and guests. You can access the dashboard by navigating to http://localhost:3000/dashboard in your browser. This setup provides a quick overview of the key metrics for your job portal application.