Project Introduction

The Online Voting System is a web application designed to facilitate secure and efficient voting processes for elections. Built using Node.js, this platform allows voters to register, view candidates, and cast their votes online. The system supports multiple user roles, including voter, admin, and election officer, ensuring a tailored experience for each user type. The underlying MySQL database schema is structured to manage users, voter profiles, elections, candidates, votes, and notifications, providing a robust foundation for effective election management.

Project Objectives

• To develop a user-friendly interface for voters to register and cast their votes securely.
• To allow election officers to create and manage elections, including setting criteria and dates.
• To implement a secure user authentication system for managing user roles and permissions.
• To facilitate the registration of candidates and their campaign details for each election.
• To track and manage votes, ensuring that each voter can only vote once per election.
• To provide notifications to users regarding important updates, such as election dates and candidate information.
• 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. Voter Profile Management Module:

   This module allows voters to create and update their profiles, including personal information and voting preferences.

3. Election Management Module:

   This module enables election officers to create, update, and manage elections, including details such as title, start date, and end date.

4. Candidate Management Module:

   This module allows candidates to register for elections and provide their manifestos and campaign details.

5. Voting Management Module:

   This module facilitates the voting process, allowing voters to cast their votes and ensuring that each voter can only vote once per election.

6. Notification Module:

   This module sends notifications to users regarding important updates, such as election reminders and candidate information.

Steps Overview

Set Up the Project: Initialize a Node.js project and install necessary packages.

Configure Sequelize: Set up Sequelize to connect to your database.

Define Models: Create Sequelize models based on the provided SQL tables.

Create Repositories: Implement repository functions for CRUD operations.

Set Up Controllers: Create controllers to handle requests and responses.

Define Routes: Set up routes to connect URLs to controllers.

Create Views: Use EJS to create views for displaying data.

Implement Bootstrap 5: Style the views using Bootstrap 5.

Step 1: Set Up the Project

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

Step 2: Configure Sequelize

Create a file named config.js for database configuration.

// config.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 folder named models and create model files for each table.

models/User.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class User extends Model {}
User .init({
    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,
    },
    RoleId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Roles',
            key: 'RoleId',
        },
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'User ',
    tableName: 'Users',
    timestamps: false,
});
module.exports = User;

Repeat similar steps for other models: Role, Election, Candidate, Ballot, Vote, Result, Notification, SupportTicket, Feedback.

Step 4: Create Repositories

Create a folder named repositories and create repository files for each model.

repositories/userRepository.js

const User = require('../models/User');
class UserRepository {
    async createUser (data) {
        return await User.create(data);
    }
    async getAllUsers() {
        return await User.findAll();
    }
    async getUser ById(id) {
        return await User.findByPk(id);
    }
    async updateUser (id, data) {
        return await User.update(data, { where: { UserId: id } });
    }
    async deleteUser (id) {
        return await User.destroy({ where: { UserId: id } });
    }
}
module.exports = new UserRepository();

Step 5: Set Up Controllers

Create a folder named controllers and create controller files for each model.

controllers/userController.js

const userRepository = require('../repositories/userRepository');
class UserController {
    async createUser (req, res) {
        const user = await userRepository.createUser (req.body);
        res.redirect('/users');
    }
    async getAllUsers(req, res) {
        const users = await userRepository.getAllUsers();
        res.render('users/index', { users });
    }
    async getUser (req, res) {
        const user = await userRepository.getUser ById(req.params.id);
        res.render('users/edit', { user });
    }
    async updateUser (req, res) {
        await userRepository.updateUser (req.params.id, req.body);
        res.redirect('/users');
    }
    async deleteUser (req, res) {
        await userRepository.deleteUser (req.params.id);
        res.redirect('/users');
    }
}
module.exports = new UserController();

Step 6: Define Routes

Create a folder named routes and create route files for each model.

routes/userRoutes.js

const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');
router.get('/', userController.getAllUsers);
router.get('/create', (req, res) => res.render('users/create'));
router.post('/', userController.createUser );
router.get('/: id', userController.getUser );
router.post('/:id', userController.updateUser );
router.delete('/:id', userController.deleteUser );
module.exports = router;

Step 7: Create Views

Create a folder named views and subfolders for each model. Use EJS to create the necessary views.

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 rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <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 %>" class="btn btn-warning">Edit</a>
                            <form action="/users/<%= user.UserId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

Step 8: Implement Bootstrap 5

Ensure that all views utilize Bootstrap 5 for styling. You can include Bootstrap's CSS and JS files in the head of your EJS templates as shown in the example above.

Final Step: Initialize the Application

In your main application file (e.g., app.js), set up the Express server and connect everything together.

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

This setup provides a basic structure for a CRUD application using Node.js, Sequelize, and EJS with Bootstrap 5 templates. You can replicate similar steps for other models and their respective routes, controllers, and views to complete the application. To extend the CRUD application for other models, follow similar steps as outlined for the User model.

Step 3: Define Models for Other Tables

models/Role.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Role extends Model {}
Role.init({
    RoleId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    RoleName: {
        type: DataTypes.STRING(50),
        allowNull: false,
        unique: true,
    },
}, {
    sequelize,
    modelName: 'Role',
    tableName: 'Roles',
    timestamps: false,
});
module.exports = Role;

Repeat similar steps for other models: Election, Candidate, Ballot, Vote, Result, Notification, SupportTicket, Feedback.

Step 4: Create Repositories for Other Models

repositories/roleRepository.js

const Role = require('../models/Role');
class RoleRepository {
    async createRole(data) {
        return await Role.create(data);
    }
    async getAllRoles() {
        return await Role.findAll();
    }
    async getRoleById(id) {
        return await Role.findByPk(id);
    }
    async updateRole(id, data) {
        return await Role.update(data, { where: { RoleId: id } });
    }
    async deleteRole(id) {
        return await Role.destroy({ where: { RoleId: id } });
    }
}
module.exports = new RoleRepository();

Step 5: Set Up Controllers for Other Models

controllers/roleController.js

const roleRepository = require('../repositories/roleRepository');
class RoleController {
    async createRole(req, res) {
        await roleRepository.createRole(req.body);
        res.redirect('/roles');
    }
    async getAllRoles(req, res) {
        const roles = await roleRepository.getAllRoles();
        res.render('roles/index', { roles });
    }
    async getRole(req, res) {
        const role = await roleRepository.getRoleById(req.params.id);
        res.render('roles/edit', { role });
    }
    async updateRole(req, res) {
        await roleRepository.updateRole(req.params.id, req.body);
        res.redirect('/roles');
    }
    async deleteRole(req, res) {
        await roleRepository.deleteRole(req.params.id);
        res.redirect('/roles');
    }
}
module.exports = new RoleController();

Step 6: Define Routes for Other Models

routes/roleRoutes.js

const express = require('express');
const router = express.Router();
const roleController = require('../controllers/roleController');
router.get('/', roleController.getAllRoles);
router.get('/create', (req, res) => res.render('roles/create'));
router.post('/', roleController.createRole);
router.get('/:id', roleController.getRole);
router.post('/:id', roleController.updateRole);
router.delete('/:id', roleController.deleteRole);
module.exports = router;

Step 7: Create Views for Other Models

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 rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <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 %>" class="btn btn-warning">Edit</a>
                            <form action="/roles/<%= role.RoleId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

Final Step: Update Main Application File

In your main application file (e.g., app.js), include the routes for the new models.

const roleRoutes = require('./routes/roleRoutes');
app.use('/roles', roleRoutes);

This completes the setup for the Role model. You can follow similar steps for the remaining models: Election, Candidate, Ballot, Vote, Result, Notification, SupportTicket, and Feedback. Each model will have its own repository, controller, routes, and views, ensuring a consistent structure throughout the application.

Additional Considerations

Error Handling: Implement error handling in your controllers to manage exceptions and provide user feedback.

Validation: Use libraries like express-validator to validate incoming data before processing it.

Authentication: Consider adding user authentication and authorization to secure your application.

Styling: Enhance the user interface with more Bootstrap components and custom styles as needed.

By following these guidelines, you can create a robust CRUD application that effectively manages users, roles, elections, and other related entities.

Remaining Parts of the CRUD Application

Following are the remaining parts of the CRUD application for the models: Election, Candidate, Ballot, Vote, Result, Notification, SupportTicket, and Feedback. This will include models, repositories, controllers, routes, and views for each of these entities.

Step 3: Define Models for Remaining Tables

models/Election.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Election extends Model {}
Election.init({
    ElectionId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Title: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Description: {
        type: DataTypes.TEXT,
    },
    StartDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    EndDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Election',
    tableName: 'Elections',
    timestamps: false,
});
module.exports = Election;

models/Candidate.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Candidate extends Model {}
Candidate.init({
    CandidateId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    ElectionId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Elections',
            key: 'ElectionId',
        },
    },
    Name: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Party: {
        type: DataTypes.STRING(100),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Candidate',
    tableName: 'Candidates',
    timestamps: false,
});
module.exports = Candidate;

models/Ballot.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Ballot extends Model {}
Ballot.init({
    BallotId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    ElectionId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Elections',
            key: 'ElectionId',
        },
    },
    VoterId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Ballot',
    tableName: 'Ballots',
    timestamps: false,
});
module.exports = Ballot;

models/Vote.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Vote extends Model {}
Vote.init({
    VoteId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    BallotId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Ballots',
            key: 'BallotId',
        },
    },
    CandidateId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Candidates',
            key: 'CandidateId',
        },
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Vote',
    tableName: 'Votes',
    timestamps: false,
});
module.exports = Vote;

models/Result.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Result extends Model {}
Result.init({
    ResultId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    ElectionId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Elections',
            key: 'ElectionId',
        },
    },
    CandidateId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Candidates',
            key: 'CandidateId',
        },
    },
    VoteCount: {
        type: DataTypes.INTEGER,
        defaultValue: 0,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Result',
    tableName: 'Results',
 timestamps: false,
});
module.exports = Result;

models/Notification.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Notification extends Model {}
Notification.init({
    NotificationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    Message: {
        type: DataTypes.STRING(256),
        allowNull: false,
    },
    IsRead: {
        type: DataTypes.BOOLEAN,
        defaultValue: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Notification',
    tableName: 'Notifications',
    timestamps: false,
});
module.exports = Notification;

models/SupportTicket.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class SupportTicket extends Model {}
SupportTicket.init({
    SupportTicketId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    Subject: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Message: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
}, {
    sequelize,
    modelName: 'SupportTicket',
    tableName: 'SupportTickets',
    timestamps: false,
});
module.exports = SupportTicket;

models/Feedback.js

const { Model, DataTypes } = require('sequelize');
const sequelize = require('../config');
class Feedback extends Model {}
Feedback.init({
    FeedbackId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        references: {
            model: 'Users',
            key: 'User Id',
        },
    },
    Comments: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
}, {
    sequelize,
    modelName: 'Feedback',
    tableName: 'Feedback',
    timestamps: false,
});
module.exports = Feedback;

Step 4: Create Repositories for Remaining Models

repositories/electionRepository.js

const Election = require('../models/Election');
class ElectionRepository {
    async createElection(data) {
        return await Election.create(data);
    }
    async getAllElections() {
        return await Election.findAll();
    }
    async getElectionById(id) {
        return await Election.findByPk(id);
    }
    async updateElection(id, data) {
        return await Election.update(data, { where: { ElectionId: id } });
    }
    async deleteElection(id) {
        return await Election.destroy({ where: { ElectionId: id } });
    }
}
module.exports = new ElectionRepository();

repositories/candidateRepository.js

const Candidate = require('../models/Candidate');
class CandidateRepository {
    async createCandidate(data) {
        return await Candidate.create(data);
    }
    async getAllCandidates() {
        return await Candidate.findAll();
    }
    async getCandidateById(id) {
        return await Candidate.findByPk(id);
    }
    async updateCandidate(id, data) {
        return await Candidate.update(data, { where: { CandidateId: id } });
    }
    async deleteCandidate(id) {
        return await Candidate.destroy({ where: { CandidateId: id } });
    }
}
module.exports = new CandidateRepository();

repositories/ballotRepository.js

const Ballot = require('../models/Ballot');
class BallotRepository {
    async createBallot(data) {
        return await Ballot.create(data);
    }
    async getAllBallots() {
        return await Ballot.findAll();
    }
    async getBallotById(id) {
        return await Ballot.findByPk(id);
    }
    async updateBallot(id, data) {
        return await Ballot.update(data, { where: { BallotId: id } });
    }
    async deleteBallot(id) {
        return await Ballot.destroy({ where: { BallotId: id } });
    }
}
module.exports = new BallotRepository();

repositories/voteRepository.js

const Vote = require('../models/Vote');
class VoteRepository {
    async createVote(data) {
        return await Vote.create(data);
    }
    async getAllVotes() {
        return await Vote.findAll();
    }
    async getVoteById(id) {
        return await Vote.findByPk(id);
    }
    async updateVote(id, data) {
        return await Vote.update(data, { where: { VoteId: id } });
    }
    async deleteVote(id) {
        return await Vote.destroy({ where: { VoteId: id } });
    }
}
module.exports = new VoteRepository();

repositories/resultRepository.js

const Result = require('../models/Result');
class ResultRepository {
    async createResult(data) {
        return await Result.create(data);
    }
    async getAllResults() {
        return await Result.findAll();
    }
    async getResultById(id) {
        return await Result.findByPk(id);
    }
    async updateResult(id, data) {
        return await Result.update(data, { where: { ResultId: id } });
    }
    async deleteResult(id) {
        return await Result.destroy({ where: { ResultId: id } });
    }
}
module.exports = new ResultRepository();

repositories/notificationRepository.js

const Notification = require('../models/Notification');
class NotificationRepository {
    async createNotification(data) {
        return await Notification.create(data);
    }
    async getAllNotifications() {
        return await Notification.findAll();
    }
    async getNotificationById(id) {
        return await Notification.findByPk(id);
    }
    async updateNotification(id, data) {
        return await Notification.update(data, { where: { NotificationId: id } });
    }
    async deleteNotification(id) {
        return await Notification.destroy({ where: { NotificationId: id } });
    }
}
module.exports = new NotificationRepository();

repositories/supportTicketRepository.js

const SupportTicket = require('../models/SupportTicket');
class SupportTicketRepository {
    async createSupportTicket(data) {
        return await SupportTicket.create(data);
    }
    async getAllSupportTickets() {
        return await SupportTicket.findAll();
    }
    async getSupportTicketById(id) {
        return await SupportTicket.findByPk(id);
    }
    async updateSupportTicket(id, data) {
        return await SupportTicket.update(data, { where: { SupportTicketId: id } });
    }
    async deleteSupportTicket(id) {
        return await SupportTicket.destroy({ where: { SupportTicketId: id } });
    }
}
module.exports = new SupportTicketRepository();

repositories/feedbackRepository.js

const Feedback = require('../models/Feedback');
class FeedbackRepository {
    async createFeedback(data) {
        return await Feedback.create(data);
    }
    async getAllFeedbacks() {
        return await Feedback.findAll();
    }
    async getFeedbackById(id) {
        return await Feedback.findByPk(id);
    }
    async updateFeedback(id, data) {
        return await Feedback.update(data, { where: { FeedbackId: id } });
    }
    async deleteFeedback(id) {
        return await Feedback.destroy({ where: { FeedbackId: id } });
    }
}
module.exports = new FeedbackRepository();

Step 5: Set Up Controllers for Remaining Models

controllers/electionController.js

const electionRepository = require('../repositories/electionRepository');
class ElectionController {
    async createElection(req, res) {
        await electionRepository.createElection(req.body);
        res.redirect('/elections');
    }
    async getAllElections(req, res) {
        const elections = await electionRepository.getAllElections();
        res.render('elections/index', { elections });
    }
    async getElection(req, res) {
        const election = await electionRepository.getElectionById(req.params.id);
        res.render('elections/edit', { election });
    }
    async updateElection(req, res) {
        await electionRepository.updateElection(req.params.id, req.body);
        res.redirect('/elections');
    }
    async deleteElection(req, res) {
        await electionRepository.deleteElection(req.params.id);
        res.redirect('/elections');
    }
}
module.exports = new ElectionController();

controllers/candidateController.js

const candidateRepository = require('../repositories/candidateRepository');
class CandidateController {
    async createCandidate(req, res) {
        await candidateRepository.createCandidate(req.body);
        res.redirect('/candidates');
    }
    async getAllCandidates(req, res) {
        const candidates = await candidateRepository.getAllCandidates();
        res.render('candidates/index', { candidates });
    }
    async getCandidate(req, res) {
        const candidate = await candidateRepository.getCandidateById(req.params.id);
        res.render('candidates/edit', { candidate });
    }
    async updateCandidate(req, res) {
        await candidateRepository.updateCandidate(req.params.id, req.body);
        res.redirect('/candidates');
    }
    async deleteCandidate(req, res) {
        await candidateRepository.deleteCandidate(req.params.id);
        res.redirect('/candidates');
    }
}
module.exports = new CandidateController();

controllers/ballotController.js

const ballotRepository = require('../repositories/ballotRepository');
class BallotController {
    async createBallot(req, res) {
        await ballotRepository.createBallot(req.body);
        res.redirect('/ballots');
    }
    async getAllBallots(req, res) {
        const ballots = await ballotRepository.getAllBallots();
        res.render('ballots/index', { ballots });
    }
    async getBallot(req, res) {
        const ballot = await ballotRepository.getBallotById(req.params.id);
        res.render('ballots/edit', { ballot });
    }
    async updateBallot(req, res) {
        await ballotRepository.updateBallot(req.params.id, req.body);
        res.redirect('/ballots');
    }
    async deleteBallot(req, res) {
        await ballotRepository.deleteBallot(req.params.id);
        res.redirect('/ballots');
    }
}
module.exports = new BallotController();

controllers/voteController.js

const voteRepository = require('../repositories/voteRepository');
class VoteController {
    async createVote(req, res) {
        await voteRepository.createVote(req.body);
        res.redirect('/votes');
    }
    async getAllVotes(req, res) {
        const votes = await voteRepository.getAllVotes();
        res.render('votes/index', { votes });
    }
    async getVote(req, res) {
        const vote = await voteRepository.getVoteById(req.params.id);
        res.render('votes/edit', { vote });
    }
    async updateVote(req, res) {
        await voteRepository.updateVote(req.params.id, req.body);
        res.redirect('/votes');
    }
    async deleteVote(req, res) {
        await voteRepository.deleteVote(req.params.id);
        res.redirect('/votes');
    }
}
module.exports = new VoteController();

controllers/resultController.js

const resultRepository = require('../repositories/resultRepository');
class ResultController {
    async createResult(req, res) {
        await resultRepository.createResult(req.body);
        res.redirect('/results');
    }
    async getAllResults(req, res) {
        const results = await resultRepository.getAllResults();
        res.render('results/index', { results });
    }
    async getResult(req, res) {
        const result = await resultRepository.getResultById(req.params.id);
        res.render('results/edit', { result });
    }
    async updateResult(req, res) {
        await resultRepository.updateResult(req.params.id, req.body);
        res.redirect('/results');
    }
    async deleteResult(req, res) {
        await resultRepository.deleteResult(req.params.id);
        res.redirect('/results');
    }
}
module.exports = new ResultController();

controllers/notificationController.js

const notificationRepository = require('../repositories/notificationRepository');
class NotificationController {
    async createNotification(req, res) {
        await notificationRepository.createNotification(req.body);
        res.redirect('/notifications');
    }
    async getAllNotifications(req, res) {
        const notifications = await notificationRepository.getAllNotifications();
        res.render('notifications/index', { notifications });
    }
    async getNotification(req, res) {
        const notification = await notificationRepository.getNotificationById(req.params.id);
        res.render('notifications/edit', { notification });
    }
    async updateNotification(req, res) {
        await notificationRepository.updateNotification(req.params.id, req.body);
        res.redirect('/notifications');
    }
    async deleteNotification(req, res) {
        await notificationRepository.deleteNotification(req.params.id);
        res.redirect('/notifications');
    }
}
module.exports = new NotificationController();

controllers/supportTicketController.js

const supportTicketRepository = require('../repositories/supportTicketRepository');
class SupportTicketController {
    async createSupportTicket(req, res) {
        await supportTicketRepository.createSupportTicket(req.body);
        res.redirect('/support-tickets');
    }
    async getAllSupportTickets(req, res) {
        const supportTickets = await supportTicketRepository.getAllSupportTickets();
        res.render('support-tickets/index', { supportTickets });
    }
    async getSupportTicket(req, res) {
        const supportTicket = await supportTicketRepository.getSupportTicketById(req.params.id);
        res.render('support-tickets/edit', { supportTicket });
    }
    async updateSupportTicket(req, res) {
        await supportTicketRepository.updateSupportTicket(req.params.id, req.body);
        res.redirect('/support-tickets');
    }
    async deleteSupportTicket(req, res) {
        await supportTicketRepository.deleteSupportTicket(req.params.id);
        res.redirect('/support-tickets');
    }
}
module.exports = new SupportTicketController();

controllers/feedbackController.js

const feedbackRepository = require('../repositories/feedbackRepository');
class FeedbackController {
    async createFeedback(req, res) {
        await feedbackRepository.createFeedback(req.body);
        res.redirect('/feedbacks');
    }
    async getAllFeedbacks(req, res) {
        const feedbacks = await feedbackRepository.getAllFeedbacks();
        res.render('feedbacks/index', { feedbacks });
    }
    async getFeedback(req, res) {
        const feedback = await feedbackRepository.getFeedbackById(req.params.id);
        res.render('feedbacks/edit', { feedback });
    }
    async updateFeedback(req, res) {
        await feedbackRepository.updateFeedback(req.params.id, req.body);
        res.redirect('/feedbacks');
    }
    async deleteFeedback(req, res) {
        await feedbackRepository.deleteFeedback(req.params.id);
        res.redirect('/feedbacks');
    }
}
module.exports = new FeedbackController();

Step 6: Define Routes for Remaining Models

routes/electionRoutes.js

const express = require('express');
const router = express.Router();
const electionController = require('../controllers/electionController');
router.get('/', electionController.getAllElections);
router.get('/create', (req, res) => res.render('elections/create'));
router.post('/', electionController.createElection);
router.get('/:id', electionController.getElection);
router.post('/:id', electionController.updateElection);
router.delete('/:id', electionController.deleteElection);
module.exports = router;

routes/candidateRoutes.js

const express = require('express');
const router = express.Router();
const candidateController = require('../controllers/candidateController');
router.get('/', candidateController.getAllCandidates);
router.get('/create', (req, res) => res.render('candidates/create'));
router.post('/', candidateController.createCandidate);
router.get('/:id', candidateController.getCandidate);
router.post('/:id', candidateController.updateCandidate);
router.delete('/:id', candidateController.deleteCandidate);
module.exports = router;

routes/ballotRoutes.js

const express = require('express');
const router = express.Router();
const ballotController = require('../controllers/ballotController');
router.get('/', ballotController.getAllBallots);
router.get('/create', (req, res) => res.render('ballots/create'));
router.post('/', ballotController.createBallot);
router.get('/:id', ballotController.getBallot);
router.post('/:id', ballotController.updateBallot);
router.delete('/:id', ballotController.deleteBallot);
module.exports = router;

routes/voteRoutes.js

const express = require('express');
const router = express.Router();
const voteController = require('../controllers/voteController');
router.get('/', voteController.getAllVotes);
router.get('/create', (req, res) => res.render('votes/create'));
router.post('/', voteController.createVote);
router.get('/:id', voteController.getVote);
router.post('/:id', voteController.updateVote);
router.delete('/:id', voteController.deleteVote);
module.exports = router;

routes/resultRoutes.js

const express = require('express');
const router = express.Router();
const resultController = require('../controllers/resultController');
router.get('/', resultController.getAllResults);
router.get('/create', (req, res) => res.render('results/create'));
router.post('/', resultController.createResult);
router.get('/:id', resultController.getResult);
router.post('/:id', resultController.updateResult);
router.delete('/:id', resultController.deleteResult);
module.exports = router;

routes/notificationRoutes.js

const express = require('express');
const router = express.Router();
const notificationController = require('../controllers/notificationController');
router.get('/', notificationController.getAllNotifications);
router.get('/create', (req, res) => res.render('notifications/create'));
router.post('/', notificationController.createNotification);
router.get('/:id', notificationController.getNotification);
router.post('/:id', notificationController.updateNotification);
router.delete('/:id', notificationController.deleteNotification);
module.exports = router;

routes/supportTicketRoutes.js

const express = require('express');
const router = express.Router();
const supportTicketController = require('../controllers/supportTicketController');
router.get('/', supportTicketController.getAllSupportTickets);
router.get('/create', (req, res) => res.render('support-tickets/create'));
router.post('/', supportTicketController.createSupportTicket);
router.get('/:id', supportTicketController.getSupportTicket);
router.post('/:id', supportTicketController.updateSupportTicket);
router.delete('/:id', supportTicketController.deleteSupportTicket);
module.exports = router;

routes/feedbackRoutes.js

const express = require('express');
const router = express.Router();
const feedbackController = require('../controllers/feedbackController');
router.get('/', feedbackController.getAllFeedbacks);
router.get('/create', (req, res) => res.render('feedbacks/create'));
router.post('/', feedbackController.createFeedback);
router.get('/:id', feedbackController.getFeedback);
router.post('/:id', feedbackController.updateFeedback);
router.delete('/:id', feedbackController.deleteFeedback);
module.exports = router;

Step 7: Create Views for Remaining Models

views/elections/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Elections</title>
</head>
<body>
    <div class="container">
        <h1>Elections</h1>
        <a href="/elections/create" class="btn btn-primary">Create Election</a>
        <table class="table">
            <thead>
                <tr>
                    <th>ElectionId</th>
                    <th>Title</th>
                    <th>Description</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% elections.forEach(election => { %>
                    <tr>
                        <td><%= election.ElectionId %></td>
                        <td><%= election.Title %></td>
                        <td><%= election.Description %></td>
                        <td>
                            <a href="/elections/<%= election.ElectionId %>" class="btn btn-warning">Edit</a>
                            <form action="/elections/<%= election.ElectionId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/candidates/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Candidates</title>
</head>
<body>
    <div class="container">
        <h1>Candidates</h1>
        <a href="/candidates/create" class="btn btn-primary">Create Candidate</a>
        <table class="table">
            <thead>
                <tr>
                    <th>CandidateId</th>
                    <th>Name</th>
                    <th>Party</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% candidates.forEach(candidate => { %>
                    <tr>
                        <td><%= candidate.CandidateId %></td>
                        <td><%= candidate.Name %></td>
                        <td><%= candidate.Party %></td>
                        <td>
                            <a href="/candidates/<%= candidate.CandidateId %>" class="btn btn-warning">Edit</a>
                            <form action="/candidates/<%= candidate.CandidateId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/ballots/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Ballots</title>
</head>
<body>
    <div class="container">
        <h1>Ballots</h1>
        <a href="/ballots/create" class="btn btn-primary">Create Ballot</a>
        <table class="table">
            <thead>
                <tr>
                    <th>BallotId</th>
                    <th>ElectionId</th>
                    <th>VoterId</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% ballots.forEach(ballot => { %>
                    <tr>
                        <td><%= ballot.BallotId %></td>
                        <td><%= ballot.Election Id %></td>
                        <td><%= ballot.VoterId %></td>
                        <td>
                            <a href="/ballots/<%= ballot.BallotId %>" class="btn btn-warning">Edit</a>
                            <form action="/ballots/<%= ballot.BallotId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/votes/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Votes</title>
</head>
<body>
    <div class="container">
        <h1>Votes</h1>
        <a href="/votes/create" class="btn btn-primary">Create Vote</a>
        <table class="table">
            <thead>
                <tr>
                    <th>VoteId</th>
                    <th>BallotId</th>
                    <th>CandidateId</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% votes.forEach(vote => { %>
                    <tr>
                        <td><%= vote.VoteId %></td>
                        <td><%= vote.BallotId %></td>
                        <td><%= vote.CandidateId %></td>
                        <td>
                            <a href="/votes/<%= vote.VoteId %>" class="btn btn-warning">Edit</a>
                            <form action="/votes/<%= vote.VoteId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/results/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Results</title>
</head>
<body>
    <div class="container">
        <h1>Results</h1>
        <a href="/results/create" class="btn btn-primary">Create Result</a>
        <table class="table">
            <thead>
                <tr>
                    <th>ResultId</th>
                    <th>ElectionId</th>
                    <th>CandidateId</th>
                    <th>VoteCount</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% results.forEach(result => { %>
                    <tr>
                        <td><%= result.ResultId %></td>
                        <td><%= result.ElectionId %></td>
                        <td><%= result.CandidateId %></td>
                        <td><%= result.VoteCount %></td>
                        <td>
                            <a href="/results/<%= result.ResultId %>" class="btn btn-warning">Edit</a>
                            <form action="/results/<%= result.ResultId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/notifications/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Notifications</title>
</head>
<body>
    <div class="container">
        <h1>Notifications</h1>
        <a href="/notifications/create" class="btn btn-primary">Create Notification</a>
        <table class="table">
            <thead>
                <tr>
                    <th>NotificationId</th>
                    <th>UserId</th>
                    <th>Message</th>
                    <th>IsRead</th>
                    <th >Actions</th>
                </tr>
            </thead>
            <tbody>
                <% notifications.forEach(notification => { %>
                    <tr>
                        <td><%= notification.NotificationId %></td>
                        <td><%= notification.UserId %></td>
                        <td><%= notification.Message %></td>
                        <td><%= notification.IsRead ? 'Yes' : 'No' %></td>
                        <td>
                            <a href="/notifications/<%= notification.NotificationId %>" class="btn btn-warning">Edit</a>
                            <form action="/notifications/<%= notification.NotificationId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/support-tickets/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Support Tickets</title>
</head>
<body>
    <div class="container">
        <h1>Support Tickets</h1>
        <a href="/support-tickets/create" class="btn btn-primary">Create Support Ticket</a>
        <table class="table">
            <thead>
                <tr>
                    <th>SupportTicketId</th>
                    <th>UserId</th>
                    <th>Subject</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% supportTickets.forEach(ticket => { %>
                    <tr>
                        <td><%= ticket.SupportTicketId %></td>
                        <td><%= ticket.UserId %></td>
                        <td><%= ticket.Subject %></td>
                        <td><%= ticket.Status %></td>
                        <td>
                            <a href="/support-tickets/<%= ticket.SupportTicketId %>" class="btn btn-warning">Edit</a>
                            <form action="/support-tickets/<%= ticket.SupportTicketId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/feedbacks/index.ejs

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Feedbacks</title>
</head>
<body>
    <div class="container">
        <h1>Feedbacks</h1>
        <a href="/feedbacks/create" class="btn btn-primary">Create Feedback</a>
        <table class="table">
            <thead>
                <tr>
                    <th>FeedbackId</th>
                    <th>UserId</th>
                    <th>Comments</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% feedbacks.forEach(feedback => { %>
                    <tr>
                        <td><%= feedback.FeedbackId %></td>
                        <td><%= feedback.UserId %></td>
                        <td><%= feedback.Comments %></td>
                        <td>
                            <a href="/feedbacks/<%= feedback.FeedbackId %>" class="btn btn-warning">Edit</a>
                            <form action="/feedbacks/<%= feedback.FeedbackId %>" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

Final Step: Update Main Application File

In your main application file (e.g., app.js), include the routes for the new models.

const electionRoutes = require('./routes/electionRoutes');
const candidateRoutes = require('./routes/candidateRoutes');
const ballotRoutes = require('./routes/ballotRoutes');
const voteRoutes = require('./routes/voteRoutes');
const resultRoutes = require('./routes/resultRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const supportTicketRoutes = require('./routes/supportTicket Routes');
const feedbackRoutes = require('./routes/feedbackRoutes');
app.use('/elections', electionRoutes);
app.use('/candidates', candidateRoutes);
app.use('/ballots', ballotRoutes);
app.use('/votes', voteRoutes);
app.use('/results', resultRoutes);
app.use('/notifications', notificationRoutes);
app.use('/support-tickets', supportTicketRoutes);
app.use('/feedbacks', feedbackRoutes);

Additional Considerations

Middleware: Consider adding middleware for authentication and authorization to protect certain routes.

Error Handling: Implement centralized error handling to manage errors gracefully across the application.

Testing: Write unit tests and integration tests to ensure the application behaves as expected.

Deployment: Prepare the application for deployment by configuring environment variables and optimizing performance.

This completes the setup for the remaining models in your CRUD application using Node.js, Sequelize, and EJS with Bootstrap 5 templates. You now have a fully functional application that can manage users, roles, elections, candidates, ballots, votes, results, notifications, support tickets, and feedback.

Folder Structure for NodeJS & ExpressJS project

To create a dashboard page in your Node.js project using Sequelize, 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:

Define the Dashboard Route

Create a route that will handle requests to the dashboard.

Create the Dashboard Controller

Implement a controller that fetches the necessary consolidated data from your models using Sequelize.

Create the Dashboard View

Design a view that will display the consolidated data in a user-friendly format.

Step 1: Define the Dashboard Route

Create a new file for your dashboard routes, e.g., routes/dashboardRoutes.js:

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

Step 2: Create the Dashboard Controller

Create a new file for your dashboard controller, e.g., controllers/dashboardController.js:

const Election = require('../models/Election');
const Candidate = require('../models/Candidate');
const Vote = require('../models/Vote');
class DashboardController {
    async getDashboardData(req, res) {
        try {
            const totalElections = await Election.count();
            const totalCandidates = await Candidate.count();
            const totalVotes = await Vote.count();
            res.render('dashboard', {
                totalElections,
                totalCandidates,
                totalVotes,
            });
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new DashboardController();

Step 3: Create the Dashboard View

Create a new view file for the dashboard, e.g., views/dashboard.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-beta1/css/bootstrap.min.css">
    <title>Dashboard</title>
</head>
<body>
    <div class="container">
        <h1>Dashboard</h1>
        <div class="row">
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Elections</h5>
                        <p class="card-text"><%= totalElections %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Candidates</h5>
                        <p class="card-text"><%= totalCandidates %></p>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card">
                    <div class="card-body">
                        <h5 class="card-title">Total Votes</h5>
                        <p class="card-text"><%= totalVotes %></p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</body>
</html>

Step 4: Update Main Application File

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

const dashboardRoutes = require('./routes/dashboardRoutes');
app.use('/dashboard', dashboardRoutes);

Final Considerations

Ensure that your models (Election, Candidate, Vote) are correctly defined and that the database is populated with data for the dashboard to display meaningful information.

You can expand the dashboard to include more metrics or visualizations as needed.

Consider adding authentication to restrict access to the dashboard.

This setup will give you a basic dashboard page that displays consolidated data from your Node.js application using Sequelize.