Coaching Management System Project In Node Js

Project Introduction

The Coaching Management System is a comprehensive web application designed to facilitate the management of coaching classes, courses, and student interactions. Built using Node.js, this platform allows administrators, teachers, and students to engage effectively in the educational process. The system supports multiple user roles, including admin, teacher, and student, ensuring a tailored experience for each user type. The underlying MySQL database schema is structured to manage users, courses, enrollments, schedules, attendance, assessments, submissions, payments, notifications, feedback, and resources, providing a robust foundation for a seamless coaching experience.

Project Objectives

To develop a user-friendly interface for students to enroll in courses and track their progress.
To implement a secure user authentication system with role-based access control.
To allow teachers to create and manage courses, schedules, and assessments effectively.
To facilitate the management of student attendance and performance tracking.
To provide a payment processing system for course fees and manage payment statuses.
To enable students to submit assignments and receive feedback from instructors.
To implement a notification system to keep users informed about important updates and events.
To ensure the application is scalable and maintainable for future enhancements.

Project Modules

User Management Module:
This module handles user registration, authentication, and role management, allowing users to manage their accounts based on their designated roles.
Course Management Module:
This module allows teachers to create, update, and manage courses, including course details, objectives, and schedules.
Enrollment Management Module:
This module manages student enrollments in courses, tracking enrollment dates and statuses.
Schedule Management Module:
This module allows for the creation and management of class schedules, including instructor assignments and class timings.
Attendance Management Module:
This module tracks student attendance for scheduled classes, recording attendance statuses such as present, absent, or late.
Assessment Management Module:
This module enables teachers to create and manage assessments, including due dates and descriptions.
Submission Management Module:
This module allows students to submit assignments and assessments, and provides a mechanism for grading and feedback.
Payment Management Module:
This module handles payment processing for course fees, including payment methods and tracking payment statuses.
Notification Module:
This module sends notifications to users regarding important updates, course announcements, and reminders.
Feedback Module:
This module allows students to provide feedback on courses, including ratings and comments.
Resource Management Module:
This module manages educational resources associated with courses, including documents, links, and videos.

Set Up the Project

Initialize a new Node.js project and install the required packages.

Step 1: Set Up the Project

 
mkdir coaching-app
cd coaching-app
npm init -y
npm install express sequelize mysql2 ejs body-parser

Step 2: Configure Sequelize

Create a config folder and a database.js file to configure Sequelize.

 
// config/database.js
const { Sequelize } = require('sequelize');
const sequelize = new Sequelize('database_name', 'username', 'password', {
    host: 'localhost',
    dialect: 'mysql',
});
module.exports = sequelize;

Step 3: Define Models

Create a models folder and define the models based on the provided schema.

 
// models/User.js
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
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(255),
        allowNull: false,
    },
    Email: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    Phone: {
        type: DataTypes.STRING(15),
    },
    RoleId: {
        type: DataTypes.INTEGER,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = User;

Repeat this process for the other tables (Roles, Courses, etc.) by creating corresponding model files.

Step 4: Create Repositories

Create a repositories folder and implement a repository for the User model.

 
// repositories/UserRepository.js
const User = require('../models/User');
class UserRepository {
    async create(userData) {
        return await User.create(userData);
    }
    async findAll() {
        return await User.findAll();
    }
    async findById(id) {
        return await User.findByPk(id);
    }
    async update(id, userData) {
        const user = await this.findById(id);
        if (user) {
            return await user.update(userData);
        }
        return null;
    }
    async delete(id) {
        const user = await this.findById(id);
        if (user) {
            return await user.destroy();
        }
        return null;
    }
}
module.exports = new UserRepository();

Step 5: Create Controllers

Create a controllers folder and implement a controller for the User model.

 
// controllers/UserController.js
const UserRepository = require('../repositories/UserRepository');
class UserController {
    async create(req, res) {
        const user = await UserRepository.create(req.body);
        res.redirect('/users');
    }
    async findAll(req, res) {
        const users = await UserRepository.findAll();
        res.render('users/index', { users });
    }
    async findById(req, res) {
        const user = await UserRepository.findById(req.params.id);
        res.render('users/edit', { user });
    }
    async update(req, res) {
        await UserRepository.update(req.params.id, req.body);
        res.redirect('/users');
    }
    async delete(req, res) {
        await UserRepository.delete(req.params.id);
        res.redirect('/users');
    }
}
module.exports = new UserController();

Step 6: Set Up Routes

Create a routes folder and define routes for the User model.

 
// routes/userRoutes.js
const express = require('express');
const router = express.Router();
const UserController = require('../controllers/UserController');
router.get('/', UserController.findAll);
router.get('/create', (req, res) => res.render('users/create'));
router.post('/', UserController.create);
router.get('/:id/edit', UserController.findById);
router.post('/:id', UserController.update);
router.post('/:id/delete', UserController.delete);
module.exports = router;

Step 7: Create Views

Create a views folder and set up EJS views for the User model.

views/users/index.ejs:

 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>Users</title>
</head>
<body>
    <div class="container">
        <h1>Users</h1>
        <a href="/users/create" class="btn btn-primary">Create User</a>
        <table class="table">
            <thead>
                <tr>
                    <th>UserId</th>
                    <th>Username</th>
                    <th>Email</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% users.forEach(user => { %>
                    <tr>
                        <td><%= user.UserId %></td>
                        <td><%= user.Username %></td>
                        <td><%= user.Email %></td>
                        <td>
                            <a href="/users/<%= user.UserId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/users/<%= user.UserId %>/delete" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/users/create.ejs:

 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>Create User</title>
</head>
<body>
    <div class="container">
        <h1>Create 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>
            <div class="mb-3">
                <label for="Phone" class="form-label">Phone</label>
                <input type="text" class="form-control" id="Phone" name="Phone">
            </div>
            <button type="submit" class="btn btn-primary">Create User</button>
        </form>
    </div>
</body>
</html>

views/users/edit.ejs:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit User</title>
</head>
<body>
    <div class="container">
        <h1>Edit User</h1>
        <form action="/users/<%= user.UserId %>" 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>
            <div class="mb-3">
                <label for="Phone" class="form-label">Phone</label>
                <input type="text" class="form-control" id="Phone" name="Phone" value="<%= user.Phone %>">
            </div>
            <button type="submit" class="btn btn-primary">Update User</button>
        </form>
    </div>
</body>
</html>

Step 8: Initialize Express and Set Up Middleware

In your main application file, set up Express and middleware.


// app.js
const express = require('express');
const bodyParser = require('body-parser');
const sequelize = require('./config/database');
const userRoutes = require('./routes/userRoutes');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static('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}`);
    });
});

Step 9: Run the Application

Start your application by running:


node app.js

Now you have a complete CRUD application for managing users using Node.js, Sequelize, Express, EJS, and Bootstrap 5. You can extend this structure to implement CRUD operations for other models like Roles, Courses, etc., following the same pattern.

Step 10: Implement CRUD Operations for Other Models

You can replicate the structure used for the User model to create CRUD operations for the other models such as Roles, Courses, and so on. Here’s how you can do it for the Roles model.

Define the Role Model


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

Create Role Repository


// repositories/RoleRepository.js
const Role = require('../models/Role');
class RoleRepository {
    async create(roleData) {
        return await Role.create(roleData);
    }
    async findAll() {
        return await Role.findAll();
    }
    async findById(id) {
        return await Role.findByPk(id);
    }
    async update(id, roleData) {
        const role = await this.findById(id);
        if (role) {
            return await role.update(roleData);
        }
        return null;
    }
    async delete(id) {
        const role = await this.findById(id);
        if (role) {
            return await role.destroy();
        }
        return null;
    }
}
module.exports = new RoleRepository();

Create Role Controller

 
// controllers/RoleController.js
const RoleRepository = require('../repositories/RoleRepository');
class RoleController {
    async create(req, res) {
        const role = await RoleRepository.create(req.body);
        res.redirect('/roles');
    }
    async findAll(req, res) {
        const roles = await RoleRepository.findAll();
        res.render('roles/index', { roles });
    }
    async findById(req, res) {
        const role = await RoleRepository.findById(req.params.id);
        res.render('roles/edit', { role });
    }
    async update(req, res) {
        await RoleRepository.update(req.params.id, req.body);
        res.redirect('/roles');
    }
    async delete(req, res) {
        await RoleRepository.delete(req.params.id);
        res.redirect('/roles');
    }
}
module.exports = new RoleController();

Set Up Role Routes


// routes/roleRoutes.js
const express = require('express');
const router = express.Router();
const RoleController = require('../controllers/RoleController');
router.get('/', RoleController.findAll);
router.get('/create', (req, res) => res.render('roles/create'));
router.post('/', RoleController.create);
router.get('/:id/edit', RoleController.findById);
router.post('/:id', RoleController.update);
router.post('/:id/delete', RoleController.delete);
module.exports = router;

Create Role Views

views/roles/index.ejs:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>Roles</title>
</head>
<body>
    <div class="container">
        <h1>Roles</h1>
        <a href="/roles/create" class="btn btn-primary">Create Role</a>
        <table class="table">
            <thead>
                <tr>
                    <th>RoleId</th>
                    <th>RoleName</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% roles.forEach(role => { %>
                    <tr>
                        <td><%= role.RoleId %></td>
                        <td><%= role.RoleName %></td>
                        <td>
                            <a href="/roles/<%= role.RoleId %>/edit" class="btn btn-warning">Edit</a>
                            <form action="/roles/<%= role.RoleId %>/delete" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/roles/create.ejs:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale =1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>Create Role</title>
</head>
<body>
    <div class="container">
        <h1>Create Role</h1>
        <form action="/roles" method="POST">
            <div class="mb-3">
                <label for="RoleName" class="form-label">Role Name</label>
                <input type="text" class="form-control" id="RoleName" name="RoleName" required>
            </div>
            <button type="submit" class="btn btn-primary">Create Role</button>
        </form>
    </div>
</body>
</html>

views/roles/edit.ejs:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Role</title>
</head>
<body>
    <div class="container">
        <h1>Edit Role</h1>
        <form action="/roles/<%= role.RoleId %>" method="POST">
            <div class="mb-3">
                <label for="RoleName" class="form-label">Role Name</label>
                <input type="text" class="form-control" id="RoleName" name="RoleName" value="<%= role.RoleName %>" required>
            </div>
            <button type="submit" class="btn btn-primary">Update Role</button>
        </form>
    </div>
</body>
</html>

Step 10: Integrate Role Routes

In your main application file, integrate the role routes.

app.js


const express = require('express');
const bodyParser = require('body-parser');
const sequelize = require('./config/database');
const userRoutes = require('./routes/userRoutes');
const roleRoutes = require('./routes/roleRoutes');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static('public'));
app.use('/users', userRoutes);
app.use('/roles', roleRoutes);
const PORT = process.env.PORT || 3000;
sequelize.sync().then(() => {
    app.listen(PORT, () => {
        console.log(`Server is running on http://localhost:${PORT}`);
    });
});

Step 11: Test the Application

After setting up the routes and views for the Roles model, you can start your application and navigate to /roles to manage roles. You can create, edit, and delete roles just like you did for users.

This structure can be replicated for other models such as Courses, Syllabuses, and so on, allowing you to build a comprehensive CRUD application using Node.js, Sequelize, Express, EJS, and Bootstrap 5. Each model will have its own repository, controller, routes, and views, following the same pattern established for Users and Roles.

Complete Implementation for Remaining Models

Below, I will provide the complete implementation for the remaining models based on your SQL schema: Roles, Courses, Syllabuses, Schedules, Enrollments, Attendance, Assessments, Payments, Feedbacks, Reports, Resources, and Notifications. Each model will include the following:

Model Definition

Repository

Controller

Routes

Views

1. Roles

Model: models/Role.js

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

Repository: repositories/RoleRepository.js

 
const Role = require('../models/Role');
class RoleRepository {
    async create(roleData) {
        return await Role.create(roleData);
    }
    async findAll() {
        return await Role.findAll();
    }
    async findById(id) {
        return await Role.findByPk(id);
    }
    async update(id, roleData) {
        const role = await this.findById(id);
        if (role) {
            return await role.update(roleData);
        }
        return null;
    }
    async delete(id) {
        const role = await this.findById(id);
        if (role) {
            return await role.destroy();
        }
        return null;
    }
}
module.exports = new RoleRepository();

Controller: controllers/RoleController.js

 
const RoleRepository = require('../repositories/RoleRepository');
class RoleController {
    async create(req, res) {
        await RoleRepository.create(req.body);
        res.redirect('/roles');
    }
    async findAll(req, res) {
        const roles = await RoleRepository.findAll();
        res.render('roles/index', { roles });
    }
    async findById(req, res) {
        const role = await RoleRepository.findById(req.params.id);
        res.render('roles/edit', { role });
    }
    async update(req, res) {
        await RoleRepository.update(req.params.id, req.body);
        res.redirect('/roles');
    }
    async delete(req, res) {
        await RoleRepository.delete(req.params.id);
        res.redirect('/roles');
    }
}
module.exports = new RoleController();

Routes: routes/roleRoutes.js

 
const express = require('express');
const router = express.Router();
const RoleController = require('../controllers/RoleController');
router.get('/', RoleController.findAll);
router.get('/create', (req, res) => res.render('roles/create'));
router.post('/', RoleController.create);
router.get('/:id/edit', RoleController.findById);
router.post('/:id', RoleController.update);
router.post('/:id/delete', RoleController.delete);
module.exports = router;

Views: views/roles/index.ejs (similar to the User index), views/roles/create.ejs (similar to the User create), views/roles/edit.ejs (similar to the User edit)

2. Courses

Model: models/Course.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Course = sequelize.define('Course', {
    CourseId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    CourseName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Description: {
        type: DataTypes.TEXT,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Course;

Repository: repositories/CourseRepository.js

 
const Course = require('../models/Course');
class CourseRepository {
    async create(courseData) {
        return await Course.create(courseData);
    }
    async findAll() {
        return await Course.findAll();
    }
    async findById(id) {
        return await Course.findByPk(id);
    }
    async update(id, courseData) {
        const course = await this.findById(id);
        if (course) {
            return await course.update(courseData);
        }
        return null;
    }
    async delete(id) {
        const course = await this.findById(id);
        if (course) {
            return await course.destroy();
        }
        return null;
    }
}
module.exports = new CourseRepository();

Controller: controllers/CourseController.js

 
const CourseRepository = require('../repositories/CourseRepository');
class CourseController {
    async create(req, res) {
        await CourseRepository.create(req.body);
        res.redirect('/courses');
    }
    async findAll(req, res) {
        const courses = await CourseRepository.findAll();
        res.render('courses/index', { courses });
    }
    async findById(req, res) {
        const course = await CourseRepository.findById(req.params.id);
        res.render('courses/edit', { course });
    }
    async update(req, res) {
        await CourseRepository.update(req.params.id, req.body);
        res.redirect('/courses');
    }
    async delete(req, res) {
        await CourseRepository.delete(req.params.id);
        res.redirect('/courses');
    }
}
module.exports = new CourseController();

Routes: routes/courseRoutes.js

 
const express = require('express');
const router = express.Router();
const CourseController = require('../controllers/CourseController');
router.get('/', CourseController.findAll);
router.get('/create', (req, res) => res.render('courses/create'));
router.post('/', CourseController.create);
router.get('/:id/edit', CourseController.findById);
router.post('/:id', CourseController.update);
router.post('/:id/delete', CourseController.delete);
module.exports = router;

Views: views/courses/index.ejs, views/courses/create.ejs, views/courses/edit.ejs

3. Syllabuses

Model: models/Syllabus.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Syllabus = sequelize.define('Syllabus', {
    SyllabusId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    Topic: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    Description: {
        type: DataTypes.TEXT,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Syllabus;

Repository: repositories/SyllabusRepository.js

 
const Syllabus = require('../models/Syllabus');
class SyllabusRepository {
    async create(syllabusData) {
        return await Syllabus.create(syllabusData);
    }
    async findAll() {
        return await Syllabus.findAll();
    }
    async findById(id) {
        return await Syllabus.findByPk(id);
    }
    async update(id, syllabusData) {
        const syllabus = await this.findById(id);
        if (syllabus) {
            return await syllabus.update(syllabusData);
        }
        return null;
    }
    async delete(id) {
        const syllabus = await this.findById(id);
        if (syllabus) {
            return await syllabus.destroy();
        }
        return null;
    }
}
module.exports = new SyllabusRepository();

Controller: controllers/SyllabusController.js

 
const SyllabusRepository = require('../repositories/SyllabusRepository');
class SyllabusController {
    async create(req, res) {
        await SyllabusRepository.create(req.body);
        res.redirect('/syllabuses');
    }
    async findAll(req, res) {
        const syllabuses = await SyllabusRepository.findAll();
        res.render('syllabuses/index', { syllabuses });
    }
    async findById(req, res) {
        const syllabus = await SyllabusRepository.findById(req.params.id);
        res.render('syllabuses/edit', { syllabus });
    }
    async update(req, res) {
        await SyllabusRepository.update(req.params.id, req.body);
        res.redirect('/syllabuses');
    }
    async delete(req, res) {
        await SyllabusRepository.delete(req.params.id);
        res.redirect('/syllabuses');
    }
}
module.exports = new SyllabusController();

Routes: routes/syllabusRoutes.js

 
const express = require('express');
const router = express.Router();
const SyllabusController = require('../controllers/SyllabusController');
router.get('/', SyllabusController.findAll);
router.get('/create', (req, res) => res.render('syllabuses/create'));
router.post('/', SyllabusController.create);
router.get('/:id/edit', SyllabusController.findById);
router.post('/:id', SyllabusController.update);
router.post('/:id/delete', SyllabusController.delete);
module.exports = router;

Views: views/syllabuses/index.ejs, views/syllabuses/create.ejs, views/syllabuses/edit.ejs

4. Schedules

Model: models/Schedule.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Schedule = sequelize.define('Schedule', {
    ScheduleId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    StartDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    EndDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    Location: {
        type: DataTypes.STRING(100),
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Schedule;

Repository: repositories/ScheduleRepository.js

 
const Schedule = require('../models/Schedule');
class ScheduleRepository {
    async create(scheduleData) {
        return await Schedule.create(scheduleData);
    }
    async findAll() {
        return await Schedule.findAll();
    }
    async findById(id) {
        return await Schedule.findByPk(id);
    }
    async update(id, scheduleData) {
        const schedule = await this.findById(id);
        if (schedule) {
            return await schedule.update(scheduleData);
        }
        return null;
    }
    async delete(id) {
        const schedule = await this.findById(id);
        if (schedule) {
            return await schedule.destroy();
        }
        return null;
    }
}
module.exports = new ScheduleRepository();

Controller: controllers/ScheduleController.js

 
const ScheduleRepository = require('../repositories/ScheduleRepository');
class ScheduleController {
    async create(req, res) {
        await ScheduleRepository.create(req.body);
        res.redirect('/schedules');
    }
    async findAll(req, res) {
        const schedules = await ScheduleRepository.findAll();
        res.render('schedules/index', { schedules });
    }
    async findById(req, res) {
        const schedule = await ScheduleRepository.findById(req.params.id);
        res.render('schedules/edit', { schedule });
    }
    async update(req, res) {
        await ScheduleRepository.update(req.params.id, req.body);
        res.redirect('/schedules');
    }
    async delete(req, res) {
        await ScheduleRepository.delete(req.params.id);
        res.redirect('/schedules');
    }
}
module.exports = new ScheduleController();

Routes: routes/scheduleRoutes.js

 
const express = require('express');
const router = express.Router();
const ScheduleController = require('../controllers/ScheduleController');
router.get('/', ScheduleController.findAll);
router.get('/create', (req, res) => res.render('schedules/create'));
router.post('/', ScheduleController.create);
router.get('/:id/edit', ScheduleController.findById);
router.post('/:id', ScheduleController.update);
router.post('/:id/delete', ScheduleController.delete);
module.exports = router;

Views: views/schedules/index.ejs, views/schedules/create.ejs, views/schedules/edit.ejs

5. Enrollments

Model: models/Enrollment.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Enrollment = sequelize.define('Enrollment', {
    EnrollmentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    EnrollmentDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    Status: {
        type: DataTypes.STRING(20),
        defaultValue: 'Active',
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Enrollment;

Repository: repositories/EnrollmentRepository.js

 
const Enrollment = require('../models/Enrollment');
class EnrollmentRepository {
    async create(enrollmentData) {
        return await Enrollment.create(enrollmentData);
    }
    async findAll() {
        return await Enrollment.findAll();
    }
    async findById(id) {
        return await Enrollment.findByPk(id);
    }
    async update(id, enrollmentData) {
        const enrollment = await this.findById(id);
        if (enrollment) {
            return await enrollment.update(enrollmentData);
        }
        return null;
    }
    async delete(id) {
        const enrollment = await this.findById(id);
        if (enrollment) {
            return await enrollment.destroy();
        }
        return null;
    }
}
module.exports = new EnrollmentRepository();

Controller: controllers/EnrollmentController.js

 
const EnrollmentRepository = require('../repositories/EnrollmentRepository');
class EnrollmentController {
    async create(req, res) {
        await EnrollmentRepository.create(req.body);
        res.redirect('/enrollments');
    }
    async findAll(req, res) {
        const enrollments = await EnrollmentRepository.findAll();
        res.render('enrollments/index', { enrollments });
    }
    async findById(req, res) {
        const enrollment = await EnrollmentRepository.findById(req.params.id);
        res.render('enrollments/edit', { enrollment });
    }
    async update(req, res) {
        await EnrollmentRepository.update(req.params.id, req.body);
        res.redirect('/enrollments');
    }
    async delete(req, res) {
        await EnrollmentRepository.delete(req.params.id);
        res.redirect('/enrollments');
    }
}
module.exports = new EnrollmentController();

Routes: routes/enrollmentRoutes.js

 
const express = require('express');
const router = express.Router();
const EnrollmentController = require('../controllers/EnrollmentController');
router.get('/', EnrollmentController.findAll);
router.get('/create', (req, res) => res.render('enrollments/create'));
router.post('/', EnrollmentController.create);
router.get('/:id/edit', EnrollmentController.findById);
router.post('/:id', EnrollmentController.update);
router.post('/:id/delete', EnrollmentController.delete);
module.exports = router;

Views: views/enrollments/index.ejs, views/enrollments/create.ejs, views/enrollments/edit.ejs

6. Attendance

Model: models/Attendance.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config /database');
const Attendance = sequelize.define('Attendance', {
    AttendanceId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    EnrollmentId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Enrollments',
            key: 'EnrollmentId',
        },
    },
    ScheduleId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Schedules',
            key: 'ScheduleId',
        },
    },
    Attended: {
        type: DataTypes.BOOLEAN,
        defaultValue: false,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
});
module.exports = Attendance;

Repository: repositories/AttendanceRepository.js

 
const Attendance = require('../models/Attendance');
class AttendanceRepository {
    async create(attendanceData) {
        return await Attendance.create(attendanceData);
    }
    async findAll() {
        return await Attendance.findAll();
    }
    async findById(id) {
        return await Attendance.findByPk(id);
    }
    async update(id, attendanceData) {
        const attendance = await this.findById(id);
        if (attendance) {
            return await attendance.update(attendanceData);
        }
        return null;
    }
    async delete(id) {
        const attendance = await this.findById(id);
        if (attendance) {
            return await attendance.destroy();
        }
        return null;
    }
}
module.exports = new AttendanceRepository();

Controller: controllers/AttendanceController.js

 
const AttendanceRepository = require('../repositories/AttendanceRepository');
class AttendanceController {
    async create(req, res) {
        await AttendanceRepository.create(req.body);
        res.redirect('/attendances');
    }
    async findAll(req, res) {
        const attendances = await AttendanceRepository.findAll();
        res.render('attendances/index', { attendances });
    }
    async findById(req, res) {
        const attendance = await AttendanceRepository.findById(req.params.id);
        res.render('attendances/edit', { attendance });
    }
    async update(req, res) {
        await AttendanceRepository.update(req.params.id, req.body);
        res.redirect('/attendances');
    }
    async delete(req, res) {
        await AttendanceRepository.delete(req.params.id);
        res.redirect('/attendances');
    }
}
module.exports = new AttendanceController();

Routes: routes/attendanceRoutes.js

 
const express = require('express');
const router = express.Router();
const AttendanceController = require('../controllers/AttendanceController');
router.get('/', AttendanceController.findAll);
router.get('/create', (req, res) => res.render('attendances/create'));
router.post('/', AttendanceController.create);
router.get('/:id/edit', AttendanceController.findById);
router.post('/:id', AttendanceController.update);
router.post('/:id/delete', AttendanceController.delete);
module.exports = router;

Views: views/attendances/index.ejs, views/attendances/create.ejs, views/attendances/edit.ejs

7. Assessments

Model: models/Assessment.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Assessment = sequelize.define('Assessment', {
    AssessmentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    AssessmentType: {
        type: DataTypes.STRING(50),
    },
    TotalMarks: {
        type: DataTypes.INTEGER,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Assessment;

Repository: repositories/AssessmentRepository.js

 
const Assessment = require('../models/Assessment');
class AssessmentRepository {
    async create(assessmentData) {
        return await Assessment.create(assessmentData);
    }
    async findAll() {
        return await Assessment.findAll();
    }
    async findById(id) {
        return await Assessment.findByPk(id);
    }
    async update(id, assessmentData) {
        const assessment = await this.findById(id);
        if (assessment) {
            return await assessment.update(assessmentData);
        }
        return null;
    }
    async delete(id) {
        const assessment = await this.findById(id);
        if (assessment) {
            return await assessment.destroy();
        }
        return null;
    }
}
module.exports = new AssessmentRepository();

Controller: controllers/AssessmentController.js

 
const AssessmentRepository = require('../repositories/AssessmentRepository');
class AssessmentController {
    async create(req, res) {
        await AssessmentRepository.create(req.body);
        res.redirect('/assessments');
    }
    async findAll(req, res) {
        const assessments = await AssessmentRepository.findAll();
        res.render('assessments/index', { assessments });
    }
    async findById(req, res) {
        const assessment = await AssessmentRepository.findById(req.params.id);
        res.render('assessments/edit', { assessment });
    }
    async update(req, res) {
        await AssessmentRepository.update(req.params.id, req.body);
        res.redirect('/assessments');
    }
    async delete(req, res) {
        await AssessmentRepository.delete(req.params.id);
        res.redirect('/assessments');
    }
}
module.exports = new AssessmentController();

Routes: routes/assessmentRoutes.js

 
const express = require('express');
const router = express.Router();
const AssessmentController = require('../controllers/AssessmentController');
router.get('/', AssessmentController.findAll);
router.get('/create', (req, res) => res.render('assessments/create'));
router.post('/', AssessmentController.create);
router.get('/:id/edit', AssessmentController.findById);
router.post('/:id', AssessmentController.update);
router.post('/:id/delete', AssessmentController.delete);
module.exports = router;

Views: views/assessments/index.ejs, views/assessments/create.ejs, views/assessments/edit.ejs

8. Payments

Model: models/Payment.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Payment = sequelize.define('Payment', {
    PaymentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    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: 'Pending',
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Payment;

Repository: repositories/PaymentRepository.js

 
const Payment = require('../models/Payment');
class PaymentRepository {
    async create(paymentData) {
        return await Payment.create(paymentData);
    }
    async findAll() {
        return await Payment.findAll();
    }
    async findById(id) {
        return await Payment.findByPk(id);
    }
    async update(id, paymentData) {
        const payment = await this.findById(id);
        if (payment) {
            return await payment.update(paymentData);
        }
        return null;
    }
    async delete(id) {
        const payment = await this.findById(id);
        if (payment) {
            return await payment.destroy();
        }
        return null;
    }
}
module.exports = new PaymentRepository();

Controller: controllers/PaymentController.js

 
const PaymentRepository = require('../repositories/PaymentRepository');
class PaymentController {
    async create(req, res) {
        await PaymentRepository.create(req.body);
        res.redirect('/payments');
    }
    async findAll(req, res) {
        const payments = await PaymentRepository.findAll();
        res.render('payments/index', { payments });
    }
    async findById(req, res) {
        const payment = await PaymentRepository.findById(req.params.id);
        res.render('payments/edit', { payment });
    }
    async update(req, res) {
        await PaymentRepository.update(req.params.id, req.body);
        res.redirect('/payments');
    }
    async delete(req, res) {
        await PaymentRepository.delete(req.params.id);
        res.redirect('/payments');
    }
}
module.exports = new PaymentController();

Routes: routes/paymentRoutes.js

 
const express = require('express');
const router = express.Router();
const PaymentController = require('../controllers/PaymentController');
router.get('/', PaymentController.findAll);
router.get('/create', (req, res) => res.render('payments/create'));
router.post('/', PaymentController.create);
router.get('/:id/edit', PaymentController.findById);
router.post('/:id', PaymentController.update);
router.post('/:id/delete', PaymentController.delete);
module.exports = router;

Views: views/payments/index.ejs, views/pay

payments/create.ejs, views/payments/edit.ejs

9. Feedbacks

Model: models/Feedback.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Feedback = sequelize.define('Feedback', {
    FeedbackId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    Comments: {
        type: DataTypes.TEXT,
    },
    Rating: {
        type: DataTypes.INTEGER,
        validate: {
            min: 1,
            max: 5,
        },
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Feedback;

Repository: repositories/FeedbackRepository.js

 
const Feedback = require('../models/Feedback');
class FeedbackRepository {
    async create(feedbackData) {
        return await Feedback.create(feedbackData);
    }
    async findAll() {
        return await Feedback.findAll();
    }
    async findById(id) {
        return await Feedback.findByPk(id);
    }
    async update(id, feedbackData) {
        const feedback = await this.findById(id);
        if (feedback) {
            return await feedback.update(feedbackData);
        }
        return null;
    }
    async delete(id) {
        const feedback = await this.findById(id);
        if (feedback) {
            return await feedback.destroy();
        }
        return null;
    }
}
module.exports = new FeedbackRepository();

Controller: controllers/FeedbackController.js

 
const FeedbackRepository = require('../repositories/FeedbackRepository');
class FeedbackController {
    async create(req, res) {
        await FeedbackRepository.create(req.body);
        res.redirect('/feedbacks');
    }
    async findAll(req, res) {
        const feedbacks = await FeedbackRepository.findAll();
        res.render('feedbacks/index', { feedbacks });
    }
    async findById(req, res) {
        const feedback = await FeedbackRepository.findById(req.params.id);
        res.render('feedbacks/edit', { feedback });
    }
    async update(req, res) {
        await FeedbackRepository.update(req.params.id, req.body);
        res.redirect('/feedbacks');
    }
    async delete(req, res) {
        await FeedbackRepository.delete(req.params.id);
        res.redirect('/feedbacks');
    }
}
module.exports = new FeedbackController();

Routes: routes/feedbackRoutes.js

 
const express = require('express');
const router = express.Router();
const FeedbackController = require('../controllers/FeedbackController');
router.get('/', FeedbackController.findAll);
router.get('/create', (req, res) => res.render('feedbacks/create'));
router.post('/', FeedbackController.create);
router.get('/:id/edit', FeedbackController.findById);
router.post('/:id', FeedbackController.update);
router.post('/:id/delete', FeedbackController.delete);
module.exports = router;

Views: views/feedbacks/index.ejs, views/feedbacks/create.ejs, views/feedbacks/edit.ejs

10. Reports

Model: models/Report.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Report = sequelize.define('Report', {
    ReportId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    ReportDate: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    Description: {
        type: DataTypes.TEXT,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
});
module.exports = Report;

Repository: repositories/ReportRepository.js

 
const Report = require('../models/Report');
class ReportRepository {
    async create(reportData) {
        return await Report.create(reportData);
    }
    async findAll() {
        return await Report.findAll();
    }
    async findById(id) {
        return await Report.findByPk(id);
    }
    async update(id, reportData) {
        const report = await this.findById(id);
        if (report) {
            return await report.update(reportData);
        }
        return null;
    }
    async delete(id) {
        const report = await this.findById(id);
        if (report) {
            return await report.destroy();
        }
        return null;
    }
}
module.exports = new ReportRepository();

Controller: controllers/ReportController.js

 
const ReportRepository = require('../repositories/ReportRepository');
class ReportController {
    async create(req, res) {
        await ReportRepository.create(req.body);
        res.redirect('/reports');
    }
    async findAll(req, res) {
        const reports = await ReportRepository.findAll();
        res.render('reports/index', { reports });
    }
    async findById(req, res) {
        const report = await ReportRepository.findById(req.params.id);
        res.render('reports/edit', { report });
    }
    async update(req, res) {
        await ReportRepository.update(req.params.id, req.body);
        res.redirect('/reports');
    }
    async delete(req, res) {
        await ReportRepository.delete(req.params.id);
        res.redirect('/reports');
    }
}
module.exports = new ReportController();

Routes: routes/reportRoutes.js

 
const express = require('express');
const router = express.Router();
const ReportController = require('../controllers/ReportController');
router.get('/', ReportController.findAll);
router.get('/create', (req, res) => res.render('reports/create'));
router.post('/', ReportController.create);
router.get('/:id/edit', ReportController.findById);
router.post('/:id', ReportController.update);
router.post('/:id/delete', ReportController.delete);
module.exports = router;

Views: views/reports/index.ejs, views/reports/create.ejs, views/reports/edit.ejs

11. Resources

Model: models/Resource.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Resource = sequelize.define('Resource', {
    ResourceId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    CourseId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Courses',
            key: 'CourseId',
        },
    },
    ResourceType: {
        type: DataTypes.STRING(50),
    },
    ResourceUrl: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
    updatedAt: 'UpdatedAt',
});
module.exports = Resource;

Repository: repositories/ResourceRepository.js

 
const Resource = require('../models/Resource');
class ResourceRepository {
    async create(resourceData) {
        return await Resource.create(resourceData);
    }
    async findAll() {
        return await Resource.findAll();
    }
    async findById(id) {
        return await Resource.findByPk(id);
    }
    async update(id, resourceData) {
        const resource = await this.findById(id);
        if (resource) {
            return await resource.update(resourceData);
        }
        return null;
    }
    async delete(id) {
        const resource = await this.findById(id);
        if (resource) {
            return await resource.destroy();
        }
        return null;
    }
}
module.exports = new ResourceRepository();

Controller: controllers/ResourceController.js

 
const ResourceRepository = require('../repositories/ResourceRepository');
class ResourceController {
    async create(req, res) {
        await ResourceRepository.create(req.body);
        res.redirect('/resources');
    }
    async findAll(req, res) {
        const resources = await ResourceRepository.findAll();
        res.render('resources/index', { resources });
    }
    async findById(req, res) {
        const resource = await ResourceRepository.findById(req.params.id);
        res.render('resources/edit', { resource });
    }
    async update(req, res) {
        await ResourceRepository.update(req.params.id, req.body);
        res.redirect('/resources');
    }
    async delete(req, res) {
        await ResourceRepository.delete(req.params.id);
        res.redirect('/resources');
    }
}
module.exports = new ResourceController();

Routes: routes/resourceRoutes.js

 
const express = require('express');
const router = express.Router();
const ResourceController = require('../controllers/ResourceController');
router.get('/', ResourceController.findAll);
router.get('/create', (req, res) => res.render('resources/create'));
router.post('/', ResourceController.create);
router.get('/:id/edit', ResourceController.findById);
router.post('/:id', ResourceController.update);
router.post('/:id/delete', ResourceController.delete);
module.exports = router;

Views: views/resources/index.ejs, views/resources/create.ejs, views/resources/edit.ejs

12. Notifications

Model: models/Notification.js

 
const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Notification = sequelize.define('Notification', {
    NotificationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User  Id',
        },
    },
    Message: {
        type: DataTypes.TEXT,
    },
    IsRead: {
        type: DataTypes.BOOLEAN,
        defaultValue: false,
    },
}, {
    timestamps: true,
    createdAt: 'CreatedAt',
});
module.exports = Notification;

Repository: repositories/NotificationRepository.js

 
const Notification = require('../models/Notification');
class NotificationRepository {
    async create(notificationData) {
        return await Notification.create(notificationData);
    }
    async findAll() {
        return await Notification.findAll();
    }
    async findById(id) {
        return await Notification.findByPk(id);
    }
    async update(id, notificationData) {
        const notification = await this.findById(id);
        if (notification) {
            return await notification.update(notificationData);
        }
        return null;
    }
    async delete(id) {
        const notification = await this.findById(id);
        if (notification) {
            return await notification.destroy();
        }
        return null;
    }
}
module.exports = new NotificationRepository();

Controller: controllers/NotificationController.js

 
const NotificationRepository = require('../repositories/NotificationRepository');
class NotificationController {
    async create(req, res) {
        await NotificationRepository.create(req.body);
        res.redirect('/notifications');
    }
    async findAll(req, res) {
        const notifications = await NotificationRepository.findAll();
        res.render('notifications/index', { notifications });
    }
    async findById(req, res) {
        const notification = await NotificationRepository.findById(req.params.id);
        res.render('notifications/edit', { notification });
    }
    async update(req, res) {
        await NotificationRepository.update(req.params.id, req.body);
        res.redirect('/notifications');
    }
    async delete(req, res) {
        await NotificationRepository.delete(req.params.id);
        res.redirect('/notifications');
    }
}
module.exports = new NotificationController();

Routes: routes/notificationRoutes.js

 
const express = require('express');
const router = express.Router();
const NotificationController = require('../controllers/NotificationController');
router.get('/', NotificationController.findAll);
router.get('/create', (req, res) => res.render('notifications/create'));
router.post('/', NotificationController.create);
router.get('/:id/edit', NotificationController.findById);
router.post('/:id', NotificationController.update);
router.post('/:id/delete', NotificationController.delete);
module.exports = router;

Views: views/notifications/index.ejs, views/notifications/create.ejs, views/notifications/edit.ejs

Final Integration

In your main application file, integrate all the routes:

 
// app.js
const express = require('express');
const bodyParser = require('body-parser');
const sequelize = require('./config/database');
const userRoutes = require('./routes/userRoutes');
const roleRoutes = require('./routes/roleRoutes');
const courseRoutes = require('./routes/courseRoutes');
const syllabusRoutes = require('./routes/syllabusRoutes');
const scheduleRoutes = require('./routes/scheduleRoutes');
const enrollmentRoutes = require('./routes/enrollmentRoutes');
const attendanceRoutes = require('./routes/attendanceRoutes');
const assessmentRoutes = require('./routes/assessmentRoutes');
const paymentRoutes = require('./routes/paymentRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const reportRoutes = require('./routes/reportRoutes');
const resourceRoutes = require('./routes/resourceRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static('public'));
app.use('/users', userRoutes);
app.use('/roles', roleRoutes);
app.use('/courses', courseRoutes);
app.use('/syllabuses', syllabusRoutes);
app.use('/schedules', scheduleRoutes);
app.use('/enrollments', enrollmentRoutes);
app.use('/attendances', attendanceRoutes);
app.use('/assessments', assessmentRoutes);
app.use('/payments', paymentRoutes);
app.use('/feedbacks', feedbackRoutes);
app.use('/reports', reportRoutes);
app.use('/resources', resourceRoutes);
app.use('/notifications', notificationRoutes);
const PORT = process.env.PORT || 3000;
sequelize.sync().then(() => {
    app.listen(PORT, () => {
        console.log(`Server is running on http://localhost:${PORT}`);
    });
});

With this setup, you now have a complete CRUD application for all the models defined in your SQL schema. Each model has its own routes, controllers, repositories, and views, allowing for easy management of users, roles, courses, syllabuses, schedules, enrollments, attendance, assessments, payments, feedbacks, reports, resources, and notifications. You can further enhance the application by adding features such as authentication, validation, and error handling as needed.

Folder Structure for NodeJS & ExpressJS project

To create a dashboard page in your NodeJS project using Sequelize and EJS, you'll need to set up a controller, routes, and a view to display consolidated data. Here's a high-level overview of the steps involved:

Model Setup

Ensure you have the necessary models defined in Sequelize that represent the data you want to consolidate.

Controller

Create a controller that fetches the consolidated data from your models. This controller will aggregate data from different models as needed.

Routes

Define a route that maps to the dashboard controller method.

View

Create an EJS view that will render the dashboard and display the consolidated data.

Structure

Controller: controllers/DashboardController.js

Routes: routes/dashboardRoutes.js

View: views/dashboard.ejs

Steps

Dashboard Controller:

Fetch data from various models and consolidate it.

Dashboard Routes:

Set up a route to access the dashboard.

Dashboard View:

Create an EJS file to display the data in a user-friendly format.

1. Dashboard Controller

Create a file named DashboardController.js in the controllers directory. This controller will fetch and consolidate data from various models.

 
// controllers/DashboardController.js
const User = require('../models/User');
const Course = require('../models/Course');
const Enrollment = require('../models/Enrollment');
const Feedback = require('../models/Feedback');
class DashboardController {
    async getDashboardData(req, res) {
        try {
            const userCount = await User.count();
            const courseCount = await Course.count();
            const enrollmentCount = await Enrollment.count();
            const feedbackCount = await Feedback.count();
            const dashboardData = {
                userCount,
                courseCount,
                enrollmentCount,
                feedbackCount,
            };
            res.render('dashboard', { dashboardData });
        } catch (error) {
            console.error("Error fetching dashboard data:", error);
            res.status(500).send("Internal Server Error");
        }
    }
}
module.exports = new DashboardController();

2. Dashboard Routes

Create a file named dashboardRoutes.js in the routes directory. This file will define the route for accessing the dashboard.

routes/dashboardRoutes.js


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

3. Dashboard View

Create a file named dashboard.ejs in the views directory. This file will render the dashboard and display the consolidated data.

views/dashboard.ejs


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dashboard</title>
    <link rel="stylesheet" href="/styles.css"> <!-- Link to your CSS file -->
</head>
<body>
    <h1>Dashboard</h1>
    <div class="dashboard">
        <div class="card">
            <h2>Total Users</h2>
            <p><%= dashboardData.userCount %></p>
        </div>
        <div class="card">
            <h2>Total Courses</h2>
            <p><%= dashboardData.courseCount %></p>
        </div>
        <div class="card">
            <h2>Total Enrollments</h2>
            <p><%= dashboardData.enrollmentCount %></p>
        </div>
        <div class="card">
            <h2>Total Feedbacks</h2>
            <p><%= dashboardData.feedbackCount %></p>
        </div>
    </div>
</body>
</html>

4. Integrate Dashboard Routes

In your main application file (e.g., app.js), integrate the dashboard routes.

app.js


const express = require('express');
const bodyParser = require('body-parser');
const sequelize = require('./config/database');
const userRoutes = require('./routes/userRoutes');
const dashboardRoutes = require('./routes/dashboardRoutes'); // Import dashboard routes
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static('public'));
app.use('/users', userRoutes);
app.use('/dashboard', dashboardRoutes); // Use dashboard routes
const PORT = process.env.PORT || 3000;
sequelize.sync().then(() => {
    app.listen(PORT, () => {
        console.log(`Server is running on http://localhost:${PORT}`);
    });
});

With this setup, you now have a functional dashboard page that consolidates data from various models in your NodeJS application. The dashboard displays the total number of users, courses, enrollments, and feedbacks, providing a quick overview of the project's status. You can further enhance the dashboard by adding charts, graphs, or additional metrics as needed.