CONFERENCE MANAGEMENT SYSTEM

A MINI PROJECT REPORT

Submitted by

Banu Mathavan V (953622205013)

Nandhini S (953622205029)

Suba Lakshmi G (953622205047)

In partial fulfillment for the award of the degree of

BACHELOR OF TECHNOLOGY

RAMCO INSTITUTE OF TECHNOLOGY

DEPARTMENT OF INFORMATION TECHNOLOGY

RAJAPALAYAM-626 117

ANNA UNIVERSITY: CHENNAI 600 025

APRIL 2025

ANNA UNIVERSITY, CHENNAI

1
BONAFIDE CERTIFICATE

Certified that this Report titled “ CONFERENCE MANAGEMENT SYSTEM” is the

bonafide work of Banu Mathavan V (953622205013), Nandhini S (953622205029),
Suba Lakshmi G (953622205047) who carried out the work under my supervision.
Certified further that to the best of my knowledge the work reported herein does not
form part of any other thesis or dissertation on the basis of which a degree or award
was conferred on an earlier occasion on this or any other candidate.

SIGNATURE SIGNATURE
Dr. ANUSUYA. V Mrs. RETHINAKUMARI. M
HEAD OF THE DEPARTMENT SUPERVISOR
Department of Information Technology Assistant Professor
Ramco Institute of Technology Department of Information Technology
Rajapalayam-626117 Ramco Institute of Technology
Rajapalayam-626117.

The project report submitted for the viva voce held on ………….

2
INTERNAL EXAMINER EXTERNAL EXAMINER

3
DECLARATION

We hereby declare that the project work entitled “ CONFERENCE MANAGEMENT

SYSTEM” has been submitted by, Banu Mathavan V (953622205013), Nandhini S
(953622205029), Suba Lakshmi G (953622205047) in the partial fulfillment of the
requirement for the award of the degree of Bachelor of Technology, Information
Technology. We further declare that the contents, statements and other relevant
matters are true to the best of our knowledge.

Place: Rajapalayam.
Date: / /2025.

DEPARTMENT OF INFORMATION TECHNOLOGY

RAMCO INSTITUTE OF TECHNOLOGY
RAJAPALAYM-626 117.

4
ACKNOWLEDGEMENT

First and foremost, I express my utmost gratitude to our Chairman, Shri. P.R.
Venketrama Raja, B.E., MBA., for his remarkable support and encouragement
toward the improvement of the college.

I extend my sincere thanks to our respected Principal In-charge, Dr. L. Ganesan,

M.E., Ph.D., for the support rendered toward my project work.

I am deeply grateful to our Vice Principal, Dr. S. Rajakarunakaran, M.E., Ph.D.,

for his valuable support in the successful completion of my project.

I am also indebted to Dr. V. Anusuya, M.E., Ph.D., Associate Professor and Head,
Department of Information Technology, for providing the necessary lab facilities to
complete my work.

I convey my heartfelt thanks to my project supervisor, Mrs. M. Rethina Kumari

Assistant Professor, Department of Information Technology, for her continuous
guidance and support throughout the project work.

I am very much thankful to all the staff members of the Department of Information
Technology for the various ways in which they supported me during the completion
of my project.

Last but not least, I extend my sincere thanks to my friends and family members for
their unwavering support and encouragement throughout my project journey.

Signature
ABSTRACT
The Conference Management System (CMS) is a comprehensive, open-source platform
designed to streamline the planning, organization, and execution of academic and
professional conferences. In today’s fast-paced world, managing large-scale events with
multiple participants, sessions, and complex schedules can be a daunting task. The CMS
offers an intuitive and efficient solution, automating processes such as abstract
submissions, paper reviews, scheduling, registration, and attendee management.

Users can customize conference workflows, from call-for-paper submissions to final

presentation scheduling, ensuring seamless integration with various conference formats.
The system provides an easy-to-navigate interface that enables conference organizers
to quickly review submissions, assign reviewers, and finalize event logistics.
Additionally, it supports attendee registration, ticketing, and payment processing, along
with real-time updates and notifications for both speakers and participants.

Developed with a focus on flexibility, performance, and user-centric design, the CMS
is fully scalable to accommodate conferences of any size. It supports integration with
popular conference platforms and provides tools for generating reports, managing
conference materials, and fostering networking among attendees. Fully offline and free
of third-party integrations, the system ensures data privacy and security for all involved.

2
TABLE OF CONTENTS

Chapter No. Contents Page No

6
1 Introduction
6
1.1 Problem Definition
7
1.2 Existing System
7
1.3 Proposed System
8
1.4 Literature Review
8
2 System Requirements
9
2.1 Hardware & Software Requirements
10
2.2 Software Requirements Specification(SRS)
11
3 System Design
11
3.1 Proposed System-Modules of System
12
3.2 UML Diagrams/Flow diagram of Proposed system
15
4 Implementation/Methodology
17
4.1 Sample Code
33
4.2 Test Cases
33
5 Experimental Results
34
5.1 Output Screens
45
6 Conclusion
45
References

3
1. INTRODUCTION

Conference management in the academic and professional domains involves organizing

and coordinating various aspects of conferences such as paper submission, peer review,
scheduling, registration, and communication. With the growing scale and complexity of
modern conferences, manual processes can be inefficient and error-prone. A dedicated
Conference Management System (CMS) helps automate and streamline these tasks,
offering features for submission handling, reviewer assignment, schedule generation,
participant registration, and reporting. This enhances productivity, ensures transparency,
and improves the overall experience for organizers, reviewers, and attendees alike.

1.1 PROBLEM DEFINITION

● Managing conferences effectively poses several challenges due to:

● High volume of paper submissions and tight review timelines.

● Manual assignment of reviewers, which can be time-consuming and biased.

● Lack of centralized platforms for submission tracking, communication, and

scheduling.

● Difficulties in managing participant registration, payment, and notifications.

Problem Statement:

Current practices in managing conferences are often manual, fragmented, and

inefficient, resulting in delays, miscommunication, and administrative overload. The
absence of an integrated, automated system hampers the smooth handling of paper
submissions, reviews, scheduling, and participant management. There is a clear need for a
centralized Conference Management System that streamlines the entire process, enhances
collaboration, and ensures timely and organized execution of conference activities.

4
1.2 EXISTING SYSTEM

In many academic and professional settings, the existing systems used for managing
conferences are either:
• Manual methods involving emails, spreadsheets, and documents, which are error-
prone and difficult to coordinate.
• Generic event management tools that lack features specific to academic conferences
such as peer review workflows, paper revision tracking, and automated scheduling.
• Outdated or fragmented systems that do not support scalability, user-friendliness, or
integration with tools like plagiarism checkers, indexing services

Drawbacks of the Existing System:

Time-consuming and error-prone paper submission and review processes.

• Limited visibility into submission status, reviewer assignments, and deadlines.
• Difficulty in managing large volumes of data related to authors, reviewers, and
participants.
• Lack of automation in scheduling sessions, notifying stakeholders, and handling
registration or payments.
• Poor user experience due to non-intuitive interfaces or fragmented tools.

1.3 PROPOSED SYSTEM

The proposed Conference Management System (CMS) is a web-based platform designed
to streamline the organization and management of academic and professional conferences.
It will automate and enhance key tasks involved in the conference lifecycle, including:
Paper submission, review, and acceptance workflows.

● Author and reviewer profile management.

● Session scheduling and speaker coordination.

● Automated conflict detection and reviewer assignment.

5
● Participant registration and payment handling.

6
● Analytics and reporting for submissions, reviews, and attendance.

Key Benefits:

• Centralized platform for managing all conference activities.

• Streamlined paper submission and peer review process.
• Improved coordination among authors, reviewers, and organizers.
• Real-time tracking of submissions, registrations, and schedules.
• Scalable architecture suitable for conferences of any size.

1.4 LITERATURE REVIEW

Numerous studies and existing systems have explored the challenges and advancements in
conference and event management, particularly within academic and technical domains:
● “An Online Conference Management System for Academic Events” by J. Wang et
al. (2021) emphasized the need for automation in submission and review workflows
to reduce administrative burden.
● The EasyChair system, widely adopted in academia, is noted for its comprehensive
features but also criticized for its complex interface, as discussed in the
International Journal of Web Applications (2019).
● “Peer Review Management in the Cloud” by IEEE (2020) proposed the use of
cloud-based platforms for improved scalability and security in handling large-scale
conferences.

● “Improving Reviewer Assignment using Machine Learning” (ACM, 2022) explored

intelligent paper-reviewer matching techniques to enhance fairness and efficiency.
● OpenConf and Ex Ordo platforms have shown success in simplifying workflows for
smaller conferences but often lack customization for specific domain needs.
These studies highlight the demand for a flexible, user-friendly, and intelligent conference
management system that can scale across diverse event types and sizes.
2. SYSTEM REQUIREMENTS

This chapter outlines the hardware and software prerequisites required to develop and
deploy the Conference Management System (CMS), which will be built using HTML,
CSS, React, Node.js (Express).

7
2.1 HARDWARE & SOFTWARE REQUIREMENTS

HARDWARE REQUIREMENTS

Component Minimum Requirement Recommended

Processor Intel Core i3 or equivalent Intel Core i5 or higher

RAM 4 GB 8 GB or more

Hard Disk 250 GB 500 GB SSD

Monitor 15-inch Display Full HD 1080p Display

Input Devices Keyboard, Mouse Keyboard, Mouse

Network LAN or Internet Connectivity Broadband

SOFTWARE REQUIREMENTS

Software Component Description

Operating System Windows 10 / Linux / macOS

Web Server Express

Backend Language Node.js, Express

Frontend Technologies HTML5, CSS3, React

Database Local Storage

Code Editor Visual Studio Code (VS Code)

Browser Google Chrome / Mozilla Firefox

8
2.2 SOFTWARE REQUIREMENTS SPECIFICATION (SRS)
1. Introduction

● Purpose
To build a web-based Conference Management System that facilitates the
management of academic or professional conferences. The system will support
paper submission, peer review, scheduling, registration, and participant
communication in an efficient and centralized manner.

● Scope
The CMS will serve conference organizers, authors, reviewers, and participants. It
will enable paper handling, reviewer assignment, session planning, registration, and
reporting via a browser-accessible interface. The system will automate repetitive
administrative tasks and improve transparency and coordination.
2. Functional Requirements
● User Authentication and Roles
Secure login system for Admin, Authors, Reviewers, and Participants using JWT
and sessions.

● Paper Submission Module

Authors can upload research papers, view submission status, and make updates
before deadlines.

● Reviewer Assignment Module

Admin can assign reviewers based on subject areas and avoid conflicts of interest.

● Review Management
Reviewers can view assigned papers, submit evaluations, and provide
recommendations.

● Schedule Management
Admin can create conference schedules, assign sessions, and link accepted papers
to presentation slots.

● Registration Module
Participants can register, pay fees, and receive confirmation via email.

● Dashboard & Notifications

Role-based dashboards and in-app/email notifications for deadlines, review
results, and announcements.

● Reports and Analytics

9
Generate downloadable reports on submissions, reviewer activity, registration
status, and session details.

10
3. Non-Functional Requirements
● Security
JWT authentication, bcrypt password hashing, role-based access control, and input
validation.
● Usability
Intuitive and responsive interface using React.js, accessible on desktop and mobile
browsers.

● Portability
Can run on any system supporting Node.js and MySQL (e.g., Windows, Linux,
macOS).

● Scalability
Designed to handle large-scale conferences with hundreds of users and submissions.

● Maintainability
Modular code structure using Express middleware and React components for easier
updates and enhancements.
3. SYSTEM DESIGN
System design defines the logical structure of modules and interactions. The CMS consists
of distinct but interconnected modules that collaborate to support the full lifecycle of a
conference—from submission to presentation.
3.1 PROPOSED SYSTEM – MODULES OF THE SYSTEM
1. Login & Authentication Module
o Provides role-based login for Admin, Authors, Reviewers, and Participants.
o Implements session and token-based security.
2. Paper Management Module
o Authors can submit, update, or withdraw papers.
o Papers are stored in MySQL with metadata and file references.
3. Reviewer Management Module
o Admin assigns reviewers; prevents conflict of interest using email and
subject area matching.
o Reviewers access submissions and submit evaluations.
4. Scheduling Module

11
o Admin creates and edits conference schedules.

12
o Maps accepted papers to time slots and rooms.
5. Registration & Payment Module
o Handles participant registration with form validation and payment gateway
integration.
o Issues confirmation emails automatically.
6. Review & Evaluation Module
o Reviewers enter ratings and comments.
o Admin can monitor review progress and generate decisions.
7. Reports Module
o Generates statistics and downloadable reports: submission numbers, review
timelines, accepted papers, and participant lists.
8. Notifications Module
o Sends reminders, announcements, and updates via email and system alerts.

3.2 UML DIAGRAMS / FLOW DIAGRAM OF PROPOSED SYSTEM

A. Use Case Diagram

13
B. Activity Diagram

C. Class Diagram

14
D. Communication Diagram

E. Sequence Diagram

15
F. State Chart

4. IMPLEMENTATION / METHODOLOGY
The development of the Conference Management System follows a modular and
component-based architecture, enabling scalability, maintainability, and team
collaboration. The system is structured using React.js for the frontend, and Node.js with
Express.js for the backend. It follows the principle of separation of concerns, keeping
frontend components, backend services, and business logic decoupled for improved
flexibility and reusability.
Development Methodology Used
Frontend
● Technology: React.js
● Approach: Responsive, component-based user interface
Key Features:
● Utilizes functional components and React Hooks (useState, useEffect, etc.) for
efficient state management.
● Implements React Router for seamless navigation between pages and routes.
● Form validation and interactivity are handled using:

16
o Formik – for managing form state.
o Yup – for schema-based validation.
o Custom validation logic where necessary
for additional flexibility.
Backend

● Technology: Node.js with Express.js

● Architecture: RESTful API-based design
Key Features:
● APIs are created for handling:
o User authentication
o Paper submission and update
o Reviewer assignment and evaluation
o Conference schedule management
o Registration and payment processing
● Express Middleware is used for:
o Centralized error handling
o JWT-based user authentication
o Input validation using express-validator
Security
● Authentication:
o Utilizes JWT (JSON Web Tokens) to implement secure and stateless user
sessions.
● Password Protection:
o Passwords are hashed using bcrypt.js before storing in the database.
● Input Handling:
o User inputs are sanitized to protect against:
▪ XSS (Cross-site scripting)
▪ SQL/NoSQL Injection Attacks

17
● Data Transmission:

18
o Deployment over HTTPS is strongly recommended to ensure encrypted and
secure data transfer.
4.1 CODING
conferenceController.js:
const Conference = require("../models/conference");
const createConference = async (req, res) => {
console.log(req.params);
Conference.createConference(req)
.then((conference) => {
res.status(201).json({
conference,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const getAllConferences = async (req, res) => {
Conference.getAllConferences(req)
.then((conferences) => {
res.status(200).json({
conferences,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
//conference registration
const conferenceRegistration = async (req, res) => {
Conference.conferenceRegistration(req)
.then((conference) => {
res.status(200).json({
conference,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
//cancel registration
const cancelRegistration = async (req, res) => {
Conference.cancelConferenceRegistration(req)
.then((conference) => {
res.status(200).json({
conference,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const getConferenceById = async (req, res) => {

19
const id = req.params.id;
Conference.getConferenceById(id)
.then((conference) => {
res.status(200).json({
conference,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const editConference = async (req, res) => {
Conference.editConference(req)
.then((conference) => {
res.status(200).json({
conference,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const deleteConference = async (req, res) => {
Conference.deleteConference(req)
.then((conference) => {
res.status(200).json({
conference,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const viewConference = async (req, res) => {
console.log("in view conference contoller");
Conference.viewConference(req)
.then((conference) => {
res.status(201).json({
conference,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const removeUserFromConferences = async (req, res) => {
Conference.removeUserFromConferences(req)
.then((ack) => {
res.status(200).json({
ack,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};

20
const removeConferencesOfOrg = async (req, res) => {
Conference.removeConferencesOfOrg(req)
.then((ack) => {
res.status(200).json({
ack,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
module.exports = {
createConference,
getAllConferences,
getConferenceById,
editConference,
deleteConference,
conferenceRegistration,
cancelRegistration,
viewConference,
removeUserFromConferences, // call when user is deleted
removeConferencesOfOrg, // call when org is deleted
};

orgController.js:
const Org = require("../models/org");
const jwt = require("jsonwebtoken");
const createToken = (id) => {
return jwt.sign({ id }, process.env.JWT_SECRET, {
expiresIn: process.env.JWT_EXPIRES_IN,
});
};
const allOrgs = async (req, res) => {
Org.find()
.then((orgs) => {
res.status(200).json({
orgs,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const getOrgById = async (req, res) => {
const emailId = req.params.emailid;
Org.getOrgById(emailId)
.then((org) => {
res.status(200).json({
org,
});

21
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const myConferences = async (req, res) => {
const id = req.params.id;
Org.myConferences(id)
.then((conferences) => {
res.status(200).json({
conferences,
});
})
.catch((error) => res.status(400).json({ error: error.message }));

};
const signupOrg = async (req, res) => {
const { orgname, email, password } = req.body;
Org.signup(orgname, email, password)
.then((org) => {
const token = createToken(org._id);
res.status(201).json({
email,
token,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const loginOrg = async (req, res) => {
const { email, password } = req.body;
Org.login(email, password)
.then((org) => {
const token = createToken(org._id);
res.status(200).json({
email,
token,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
const updateOrg = async (req, res) => {
const { email, password } = req.body;
Org.update(email, password)
.then((org) => {
res.status(200).json({
org,
});
})

22
.catch((error) => res.status(400).json({ error: error.message }));
};
const deleteOrg = async (req, res) => {
const { email } = req.body;
Org.findOneAndDelete({ email })
.then((org) => {
res.status(200).json({
org,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
// update org accepted status
const updateOrgAcceptedStatus = async (req, res) => {
const { email } = req.body;
Org.findOne({ email })
.then((org) => {
org.accepted = !org.accepted;
org.save();
res.status(200).json({
org,
});
})
.catch((error) => res.status(400).json({ error: error.message }));
};
module.exports = {
signupOrg,
loginOrg,
updateOrg,
deleteOrg,
allOrgs,
getOrgById,
updateOrgAcceptedStatus,
myConferences,
};

uploadController.js:
const fs = require("fs");
const { google } = require("googleapis");
const { JWT } = require("google-auth-library");
const User = require("../models/user");
// authenticate with google
const authenticateGoogle = () => {
const auth = new google.auth.GoogleAuth({
keyFile: "../key-file.json",
scopes: "https://www.googleapis.com/auth/drive",

23
});
return auth;
};
const keyFile = require("../key-file.json");
const client = new JWT({
email: keyFile.client_email,
key: keyFile.private_key,
scopes: ["https://www.googleapis.com/auth/drive"],
});
const drive = google.drive({
version: "v3",
auth: authenticateGoogle(),
});
// upload to google drive
const uploadToGoogleDrive = async (file, auth) => {
const fileMetadata = {
name: file.originalname,
parents: ["1ADFpHcBEnWz632M913g xy8nuDO4fkz"], // Change it according to your
desired parent folder id
};
const media = {
mimeType: file.mimetype,
body: fs.createReadStream(file.path),
};
const response = await drive.files.create({
requestBody: fileMetadata,
media: media,
fields: "id",
});
return response;
};
const deleteFile = (filePath) => {
fs.unlink(filePath, () => {
console.log("file deleted");
});
};
const uploadPaper = async (req, res) => {
const { email, confid } = req.query;
console.log(email, confid);
const auth = authenticateGoogle();
const response = await uploadToGoogleDrive(req.file, auth);
deleteFile(req.file.path);
const user = await User.findOne({ email });
user.papers.push({
title: req.body.originalname,
fileUrl: response.data.id,

24
conference: confid,
});
console.log(response.data.id);
await user.save();

res.status(200).json({ response });

};
const getPaper = async (req, res) => {
console.log("get paper");
let downloadUrl = "";
drive.files.get(
{
fileId: "1590nRXUmOoerl4hdy2aGCfGekni9BWbo",
fields: "id,name,webContentLink",
},
(err, resp) => {
if (err) throw new Error("Error retrieving file metadata");
const { id, name, webContentLink } = resp.data;
console.log(`Retrieved file metadata for ${name} with ID ${id}`);
// Send a GET request to the file's download URL to download the file
downloadUrl = webContentLink.replace(/\/view\?usp=sharing$/, "");
console.log(downloadUrl);
const options = {
method: "GET",
headers: {
Authorization: `Bearer ${client.credentials.access_token}`,
"Access-Control-Allow-Origin": "*", // Required for CORS support to work
},
};
res.json({ downloadUrl, options });
}
);
};
module.exports = { uploadPaper, getPaper };

requireAuth.js:
const jwt = require("jsonwebtoken");
const User = require("../models/user");
const requireAuth = (req, res, next) => {
const { authorization } = req.headers;
if (!authorization) {
return res.status(401).send({ error: "You must be logged in." });
}
const token = authorization.replace("Bearer ", "");
jwt.verify(token, process.env.SECRET_KEY, async (err, payload) => {
if (err) {

25
return res.status(401).send({ error: "You must be logged in." });
}
const { _id } = payload;
req.user = await User.findOne({ _id }).select("_id"); // adding req.user to the request object
await next();
});
};
module.exports = requireAuth;

conferenceRoutes.js:
const express = require("express");
const conferenceController = require("../controllers/conferenceController.js");
const router = express.Router();
const {
createConference,
getAllConferences,
getConferenceById,
editConference,
deleteConference,
conferenceRegistration
, cancelRegistration,
viewConference,
removeUserFromConferences, // call when user is deleted
removeConferencesOfOrg, // call when org is deleted
} = require("../controllers/conferenceController");
const requireAuth = require("../middlewares/requireAuth");
router.post("/create", createConference);
router.get("/all", getAllConferences);
router.get("/:id", getConferenceById);
router.patch("/register/:id", conferenceRegistration);
router.patch("/cancelRegistration/:id", cancelRegistration);
router.get("/get", viewConference);
router.patch("/edit", editConference);
router.delete("/delete/:id", deleteConference);
router.patch("/removeUser", removeUserFromConferences);
router.delete("/remove-conferences-of-Org",removeConferencesOfOrg);
module.exports = router;

orgRoutes.js:
const express = require("express");
const router = express.Router();
const {
loginOrg,
signupOrg,
updateOrg,
deleteOrg,

26
allOrgs,
getOrgById,
updateOrgAcceptedStatus,
myConferences,
} = require("../controllers/orgController");
router.get("/", allOrgs);
router.get("/:emailid", getOrgById);
router.get("/:id/myConferences", myConferences);
router.post("/signup", signupOrg);
router.post("/login", loginOrg);
router.patch("/update", updateOrg);
router.delete("/delete", deleteOrg);
router.patch("/update/accepted", updateOrgAcceptedStatus);
module.exports = router;

uploadRoutes.js:
const express = require("express");
const router = express.Router();
const Multer = require("multer");
const { uploadPaper, getPaper } = require("../controllers/uploadController");
const multer = Multer({
storage: Multer.diskStorage({
destination: function (req, file, callback) {
callback(null, `${ dirname}/../papers`);
},
filename: function (req, file, callback) {
callback(
null,
file.fieldname + "_" + Date.now() + "_" + file.originalname
);
},
}),
limits: {
fileSize: 5 * 1024 * 1024,
},
});
roter.get("/paper", getPaper);
// router.use(multer.single("file"));
router.post("/paper", multer.single("file"), uploadPaper);
module.exports = router;

userRoutes.js:
const express = require("express");
const router = express.Router();
const {
loginUser,

27
signupUser,
updateUser,
updateUserProfile,
deleteUser,
getAllUsers,
getUserById,
uploadProfilePicture,
getProfilePic,
removeProfilePic,
uploadPaper,
} = require("../controllers/userController");
router.get("/", getAllUsers);
router.get("/:id", getUserById);
router.post("/signup", signupUser);
router.post("/login", loginUser);
router.patch("/update", updateUser);
router.patch("/updateProfile/:id", updateUserProfile);
router.patch("/upload-pic", uploadProfilePicture);
router.delete("/delete", deleteUser);
router.get("/show-pic/:id", getProfilePic);
router.patch("/remove-pic/:id", removeProfilePic);
router.post("/uploads/:id", uploadPaper);
module.exports = router;

index.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Vite + React</title>
<link
rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"
/>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.jsx"></script>
</body>
</html>

AdminNavbar.jsx:
import React, { useState } from "react";

28
import "../assets/CSS/style.css";
// Bootstrap CSS
import "bootstrap/dist/css/bootstrap.min.css";
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import { faSearch, faSignOut } from "@fortawesome/free-solid-svg-icons";
import $ from "jquery";
import { Link } from "react-router-dom";
import { useAuthContext } from "../hooks/useAuthContext";
import { useLogout } from "../hooks/useLogout";
const AdminNavbar = () => {
const { logout } = useLogout();
const { user } = useAuthContext();
const handleClick = () => {
logout();
};
return (
<>
<nav className="global-nav-bar admin-nav">
<Link onClick={handleClick} className="admin-nav-right-logout-span">
<div
className="admin-nav-right-logout-span"
style={{ cursor: "pointer" }}
onClick={handleClick}
>
<FontAwesomeIcon icon={faSignOut} style={{}} />
<p className="admin-nav-right-logout-span-txt" style={{ padding: "0", margin: "0",
marginLeft: "5px" }}>
LOGOUT
</p>
</div>
</Link>
</nav>
</>
);
};
export default AdminNavbar;

Footer.jsx:
import React from "react";
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import {
faHouse,
faEnvelope,
faPhone,
} from "@fortawesome/free-solid-svg-icons";
import { Link } from "react-router-dom";

29
const Footer = () => {
const handleGoToTop = () => {
window.scrollTo({ top: 0, behavior: "smooth" });
};
return (
<>
<footer className="text-center text-lg-start text-black">
<div className="container p-4 pb-0">
<section className="">
<div className="row">
<div className="col-md-3 col-lg-3 col-xl-3 mx-auto mt-3">
<h4 className="text-uppercase mb-4">
Conference Management Site
</h4>
<p>
Lorem ipsum dolor sit amet consectetur, adipisicing elit.
Corrupti, harum. A illo hic cumque. Animi, exercitationem est.
Ipsum, similique officia.
</p>
</div>
<hr className="w-100 clearfix d-md-none" />
<div className="col-md-2 col-lg-2 col-xl-2 mx-auto mt-3">
<h5 className="text-uppercase mb-4">
<b>Sections</b>
</h5>
<p>
<Link className="text-black" onClick={handleGoToTop}>
Back To Top
</Link>
</p>
<p>
<Link className="text-black" to="/privacy-policy">
Privacy Policy
</Link>
</p>
{/* <p>
<a className="text-black" href="#organizations">Organizations</a>
</p> */}
</div>
<hr className="w-100 clearfix d-md-none" />
<div className="col-md-4 col-lg-3 col-xl-3 mx-auto mt-3">
<h5 className="text-uppercase mb-4 mx-3">
<b>Contact</b>
</h5>
<p>
<FontAwesomeIcon

30
icon={faHouse}
className="mx-3 text-secondary"
/>
Gandhinagar, Gujarat, India
</p>
<p>
<FontAwesomeIcon
icon={faEnvelope}
className="mx-3 text-secondary"
/>{" "}
[email protected]
</p>
<p>
<FontAwesomeIcon
icon={faPhone}
className="mx-3 text-secondary"
/>{" "}
+ 279 234 567 88
</p>
</div>
</div>
</section>
</div>
</footer>
</>
);
};
export default Footer;

App.jsx:
import { BrowserRouter, Routes, Route, Navigate } from "react-router-dom";
import { useAuthContext } from "./hooks/useAuthContext";
import Home from "./pages/Home";
import HomeConf from "./pages/HomeConf";
import Login from "./pages/Login";
import Signup from "./pages/Signup";
import PasswordReset from "./pages/PasswordReset";
import AdminLogin from "./pages/AdminLogin";
import AdminDashboard from "./pages/AdminDashboard";
import OrgLogin from "./pages/OrgLogin";
import OrgSignup from "./pages/OrgSignup";
import OrgDashboard from "./pages/OrgDashboard";
import UserDashboard from "./pages/UserDashboard";
import Choice from "./pages/choice";
import UserProfile from "./pages/UserProfile";
import OrgProfile from "./pages/OrgProfile";

31
import TestUpload from "./pages/TestUpload";
import CallForPaper from "./pages/CallForPaper";
import Error from "./pages/Error";
import Privacy from "./pages/privacy";
import Papers from "./pages/Papers";
function App() {
const { user, org } = useAuthContext(); // will be used to provide functionality of private routes
return (
<>
<BrowserRouter>
<Routes>
{/* admin routes */}
<Route
element={
!user || user.user.role !== "admin" ? (
<AdminLogin />
):(
<Navigate to="/admin/dashboard" />
)
}
path="/admin/login"
/>
<Route
element={
user && user.user.role === "admin" ? (
<AdminDashboard />
):(
<Navigate to="/admin/login" />
)
}
path="/admin/dashboard"
/>
{/* general routes */}
{/* public routes */}
<Route element={<Home />} path="/" />
<Route
element={!user && !org ? <Choice /> : <Navigate to="/" />}
path="/choice"
/>
<Route
element={!user ? <Login /> : <Navigate to="/" />}
path="/login"
/>
<Route
element={!user ? <Signup /> : <Navigate to="/" />}
path="/signup"

32
/>
<Route
element={org ? <OrgDashboard /> : <Navigate to="/choise" />}
path="org-dashboard"
/>
<Route
element={!org ? <OrgLogin /> : <Navigate to="/" />}
path="/org-login"
/>
<Route
element={!org ? <OrgSignup /> : <Navigate to="/" />}
path="/org-signup"
/>
<Route
element={org ? <OrgDashboard /> : <Navigate to="/choice" />}
path="/dashboard"
/>
<Route
element={
user ? (
<UserProfile />
) : org ? (
<OrgProfile />
):(
<Navigate to="/choice" />
)
}
path="/profile"
/>
<Route element={<PasswordReset />} path="/password-reset" />
<Route element={<Privacy />} path="/privacy-policy" />
<Route element={<TestUpload />} path="test-upload" />
<Route element={<HomeConf />} path="/conferences" />
<Route
element={
user && user.user.role === "publisher" ? (
<CallForPaper />
):(
<Navigate to="/choice" />
)
}
path="/call-for-paper"
/>
<Route element={<Papers />} path="/conference/papers" />
<Route element={<Error />} path="*" />
</Routes>

33
</BrowserRouter>
</>
);
}
export default App;

index.css:
*{
margin: 0;
padding: 0;
box-sizing: border-box;
font-family: "Open Sans", sans-serif !important;
}
body {
min-height: 100vh;
}
a{
text-decoration: none;
}
.container-fluid {
margin: 0 !important;
overflow: hidden !important;
}

Main.jsx:
import React from "react";
import ReactDOM from "react-dom/client";
import App from "./App";
import { AuthContextProvider } from "./context/AuthContext";
import './index.css'
ReactDOM.createRoot(document.getElementById("root")).render(
<React.StrictMode>
<AuthContextProvider>
<App />
</AuthContextProvider>
</React.StrictMode>
);

34
4.2 TEST CASES

5. EXPERIMENTAL RESULTS

The developed Conference Management System was deployed and tested in a local
server environment using XAMPP. It effectively supported key functionalities such as
user registration, session scheduling, speaker management, and attendee interactions.
● User Registration: Users were able to register securely and create
personalized profiles.
● Session Scheduling: Admins could create, manage, and schedule
conference sessions and track attendee participation.
● Speaker Management: Speakers were able to submit their abstracts, update session
details, and interact with the admin.
● Attendee Interaction: Attendees could browse sessions, register for specific
talks, and receive notifications about their upcoming sessions.
● Data Consistency: All user, session, and speaker data was stored consistently
across the system, ensuring seamless functionality.
● Usability and Responsiveness: The system was tested across various devices
and browsers (Chrome, Firefox), confirming that it was fully responsive and
user- friendly.
35
The system was validated in terms of functionality, usability, and performance, and it met
the expected objectives for conference management.

5.1 OUTPUT SCREENS

36
37
38
39
40
41
42
43
44
45
46
6. CONCLUSION

The Conference Management System provides a robust platform to streamline the

organization and management of academic and professional conferences. It automates
processes such as paper submission, reviewer assignment, participant registration,
schedule generation, and communication handling.
The system offers:
• A user-friendly and responsive interface for all user roles.
• Role-based access for Admin, Reviewer, and Participant.
• Secure and centralized management of papers, users, and reviews.
• Scalability to support multiple events and future feature enhancements.
This project improves the efficiency of conference logistics, enhances transparency in
review processes, and fosters better communication among stakeholders.

REFERENCES

1. S. Sharma & R. Patel, "Design and Implementation of an Online Conference

Management System", International Journal of Advanced Research in Computer
and Communication Engineering, Vol. 7, Issue 4, April 2018 – Discusses the
implementation of key modules such as user registration, paper upload, and review
tracking.
2. K. Laudon & J. Laudon, Management Information Systems, Pearson Education –
Offers foundational knowledge on building systems that support decision-making
and administrative processes.
3. A. Mehta, "Conference Management System using PHP and MySQL",
International Journal of Scientific & Engineering Research, Vol. 10, Issue 6, June
2019 – Provides a case study of a web-based system built using LAMP stack.
4. Springer, "EasyChair Conference Management System" – Industry-standard
47
platform used as a reference model for automated academic conference workflows.

48